LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__GetGlyphInfoT2
static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)
{
   stbtt__csctx c = STBTT__CSCTX_INIT(1);
   int r = stbtt__run_charstring(info, glyph_index, &c);
   if (x0)  *x0 = r ? c.min_x : 0;
   if (y0)  *y0 = r ? c.min_y : 0;
   if (x1)  *x1 = r ? c.max_x : 0;
   if (y1)  *y1 = r ? c.max_y : 0;
   return r ? c.num_vertices : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10b0
movl $0x1, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x68(%rbp), %rdx
callq 0xed60
movl %eax, -0x6c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4c31
cmpl $0x0, -0x6c(%rbp)
je 0x4c21
movl -0x50(%rbp), %eax
movl %eax, -0x70(%rbp)
jmp 0x4c28
xorl %eax, %eax
movl %eax, -0x70(%rbp)
jmp 0x4c28
movl -0x70(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x4c56
cmpl $0x0, -0x6c(%rbp)
je 0x4c46
movl -0x48(%rbp), %eax
movl %eax, -0x74(%rbp)
jmp 0x4c4d
xorl %eax, %eax
movl %eax, -0x74(%rbp)
jmp 0x4c4d
movl -0x74(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x4c7b
cmpl $0x0, -0x6c(%rbp)
je 0x4c6b
movl -0x4c(%rbp), %eax
movl %eax, -0x78(%rbp)
jmp 0x4c72
xorl %eax, %eax
movl %eax, -0x78(%rbp)
jmp 0x4c72
movl -0x78(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x4ca0
cmpl $0x0, -0x6c(%rbp)
je 0x4c90
movl -0x44(%rbp), %eax
movl %eax, -0x7c(%rbp)
jmp 0x4c97
xorl %eax, %eax
movl %eax, -0x7c(%rbp)
jmp 0x4c97
movl -0x7c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x6c(%rbp)
je 0x4cae
movl -0x38(%rbp), %eax
movl %eax, -0x80(%rbp)
jmp 0x4cb5
xorl %eax, %eax
movl %eax, -0x80(%rbp)
jmp 0x4cb5
movl -0x80(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__GetGlyfOffset
static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_index)
{
   int g1,g2;

   STBTT_assert(!info->cff.size);

   if (glyph_index >= info->numGlyphs) return -1; // glyph index out of range
   if (info->indexToLocFormat >= 2)    return -1; // unknown index->glyph map format

   if (info->indexToLocFormat == 0) {
      g1 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2) * 2;
      g2 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2 + 2) * 2;
   } else {
      g1 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4);
      g2 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4 + 4);
   }

   return g1==g2 ? -1 : g1; // if length is 0, return -1
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
jne 0x4ceb
jmp 0x4d0a
leaq 0x12000(%rip), %rdi     # 0x16cf2
leaq 0x11abe(%rip), %rsi     # 0x167b7
movl $0x613, %edx            # imm = 0x613
leaq 0x11ffd(%rip), %rcx     # 0x16d02
callq 0x10a0
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jl 0x4d22
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4e50
movq -0x10(%rbp), %rax
cmpl $0x2, 0x38(%rax)
jl 0x4d38
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4e50
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x4dc0
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x18(%rax), %rax
addq %rax, %rdi
movl -0x14(%rbp), %eax
shll %eax
cltq
addq %rax, %rdi
callq 0x4990
movw %ax, %cx
movl -0x24(%rbp), %eax
movzwl %cx, %ecx
shll %ecx
addl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x18(%rax), %rax
addq %rax, %rdi
movl -0x14(%rbp), %eax
shll %eax
cltq
addq %rax, %rdi
addq $0x2, %rdi
callq 0x4990
movw %ax, %cx
movl -0x20(%rbp), %eax
movzwl %cx, %ecx
shll %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4e32
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x18(%rax), %rax
addq %rax, %rdi
movl -0x14(%rbp), %eax
shll $0x2, %eax
cltq
addq %rax, %rdi
callq 0x49d0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x18(%rax), %rax
addq %rax, %rdi
movl -0x14(%rbp), %eax
shll $0x2, %eax
cltq
addq %rax, %rdi
addq $0x4, %rdi
callq 0x49d0
movl %eax, %ecx
movl -0x28(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x4e44
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x30(%rbp)
jmp 0x4e4a
movl -0x18(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_IsGlyphEmpty
STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index)
{
   stbtt_int16 numberOfContours;
   int g;
   if (info->cff.size)
      return stbtt__GetGlyphInfoT2(info, glyph_index, NULL, NULL, NULL, NULL) == 0;
   g = stbtt__GetGlyfOffset(info, glyph_index);
   if (g < 0) return 1;
   numberOfContours = ttSHORT(info->data + g);
   return numberOfContours == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
je 0x4f03
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %rdx
movq %r9, %rcx
movq %r9, %r8
callq 0x4bc0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x4f4b
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4cd0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x4f21
movl $0x1, -0x4(%rbp)
jmp 0x4f4b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
callq 0x49b0
movw %ax, -0x16(%rbp)
movswl -0x16(%rbp), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__GetGlyphShapeT2
static int stbtt__GetGlyphShapeT2(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)
{
   // runs the charstring twice, once to count and once to output (to avoid realloc)
   stbtt__csctx count_ctx = STBTT__CSCTX_INIT(1);
   stbtt__csctx output_ctx = STBTT__CSCTX_INIT(0);
   if (stbtt__run_charstring(info, glyph_index, &count_ctx)) {
      *pvertices = (stbtt_vertex*)STBTT_malloc(count_ctx.num_vertices*sizeof(stbtt_vertex), info->userdata);
      output_ctx.pvertices = *pvertices;
      if (stbtt__run_charstring(info, glyph_index, &output_ctx)) {
         STBTT_assert(output_ctx.num_vertices == count_ctx.num_vertices);
         return output_ctx.num_vertices;
      }
   }
   *pvertices = NULL;
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10b0
movl $0x1, -0x58(%rbp)
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10b0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x58(%rbp), %rdx
callq 0xed60
cmpl $0x0, %eax
je 0x5f82
movslq -0x28(%rbp), %rax
imulq $0xe, %rax, %rdi
callq 0x1140
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x90(%rbp), %rdx
callq 0xed60
cmpl $0x0, %eax
je 0x5f80
movl -0x60(%rbp), %eax
cmpl -0x28(%rbp), %eax
jne 0x5f59
jmp 0x5f78
leaq 0x10fd1(%rip), %rdi     # 0x16f31
leaq 0x10850(%rip), %rsi     # 0x167b7
movl $0x8b5, %edx            # imm = 0x8B5
leaq 0x10ff0(%rip), %rcx     # 0x16f63
callq 0x10a0
movl -0x60(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5f94
jmp 0x5f82
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_GetGlyphHMetrics
STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing)
{
   stbtt_uint16 numOfLongHorMetrics = ttUSHORT(info->data+info->hhea + 34);
   if (glyph_index < numOfLongHorMetrics) {
      if (advanceWidth)     *advanceWidth    = ttSHORT(info->data + info->hmtx + 4*glyph_index);
      if (leftSideBearing)  *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*glyph_index + 2);
   } else {
      if (advanceWidth)     *advanceWidth    = ttSHORT(info->data + info->hmtx + 4*(numOfLongHorMetrics-1));
      if (leftSideBearing)  *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*numOfLongHorMetrics + 2*(glyph_index - numOfLongHorMetrics));
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x24(%rax), %rax
addq %rax, %rdi
addq $0x22, %rdi
callq 0x4990
movw %ax, -0x22(%rbp)
movl -0xc(%rbp), %eax
movzwl -0x22(%rbp), %ecx
cmpl %ecx, %eax
jge 0x604e
cmpq $0x0, -0x18(%rbp)
je 0x6015
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x28(%rax), %rax
addq %rax, %rdi
movl -0xc(%rbp), %eax
shll $0x2, %eax
cltq
addq %rax, %rdi
callq 0x49b0
movswl %ax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x604c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x28(%rax), %rax
addq %rax, %rdi
movl -0xc(%rbp), %eax
shll $0x2, %eax
cltq
addq %rax, %rdi
addq $0x2, %rdi
callq 0x49b0
movswl %ax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x60cb
cmpq $0x0, -0x18(%rbp)
je 0x6085
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x28(%rax), %rax
addq %rax, %rdi
movzwl -0x22(%rbp), %eax
subl $0x1, %eax
shll $0x2, %eax
cltq
addq %rax, %rdi
callq 0x49b0
movswl %ax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x60c9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x28(%rax), %rax
addq %rax, %rdi
movzwl -0x22(%rbp), %eax
shll $0x2, %eax
cltq
addq %rax, %rdi
movl -0xc(%rbp), %eax
movzwl -0x22(%rbp), %ecx
subl %ecx, %eax
shll %eax
cltq
addq %rax, %rdi
callq 0x49b0
movswl %ax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x60cb
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_GetGlyphKernAdvance
STBTT_DEF int  stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int g1, int g2)
{
   int xAdvance = 0;

   if (info->gpos)
      xAdvance += stbtt__GetGlyphGPOSInfoAdvance(info, g1, g2);

   if (info->kern)
      xAdvance += stbtt__GetGlyphKernInfoAdvance(info, g1, g2);

   return xAdvance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x6118
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x6140
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x6137
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x6720
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__GetGlyphKernInfoAdvance
static int  stbtt__GetGlyphKernInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)
{
   stbtt_uint8 *data = info->data + info->kern;
   stbtt_uint32 needle, straw;
   int l, r, m;

   // 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;

   l = 0;
   r = ttUSHORT(data+10) - 1;
   needle = glyph1 << 16 | glyph2;
   while (l <= r) {
      m = (l + r) >> 1;
      straw = ttULONG(data+18+(m*6)); // note: unaligned read
      if (needle < straw)
         r = m - 1;
      else if (needle > straw)
         l = m + 1;
      else
         return ttSHORT(data+22+(m*6));
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x2c(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x675f
movl $0x0, -0x4(%rbp)
jmp 0x6843
movq -0x20(%rbp), %rdi
addq $0x2, %rdi
callq 0x4990
movzwl %ax, %eax
cmpl $0x1, %eax
jge 0x6780
movl $0x0, -0x4(%rbp)
jmp 0x6843
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x4990
movzwl %ax, %eax
cmpl $0x1, %eax
je 0x67a1
movl $0x0, -0x4(%rbp)
jmp 0x6843
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
addq $0xa, %rdi
callq 0x4990
movzwl %ax, %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x14(%rbp), %eax
shll $0x10, %eax
orl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jg 0x683c
movl -0x2c(%rbp), %eax
addl -0x30(%rbp), %eax
sarl %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rdi
addq $0x12, %rdi
imull $0x6, -0x34(%rbp), %eax
cltq
addq %rax, %rdi
callq 0x49d0
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x6809
movl -0x34(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x683a
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jbe 0x681c
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6838
movq -0x20(%rbp), %rdi
addq $0x16, %rdi
imull $0x6, -0x34(%rbp), %eax
cltq
addq %rax, %rdi
callq 0x49b0
cwtl
movl %eax, -0x4(%rbp)
jmp 0x6843
jmp 0x683a
jmp 0x67ca
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_GetFontVMetricsOS2
STBTT_DEF int  stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap)
{
   int tab = stbtt__find_table(info->data, info->fontstart, "OS/2");
   if (!tab)
      return 0;
   if (typoAscent ) *typoAscent  = ttSHORT(info->data+tab + 68);
   if (typoDescent) *typoDescent = ttSHORT(info->data+tab + 70);
   if (typoLineGap) *typoLineGap = ttSHORT(info->data+tab + 72);
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
leaq 0xfe48(%rip), %rdx      # 0x16836
callq 0x6a90
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x6a05
movl $0x0, -0x4(%rbp)
jmp 0x6a84
cmpq $0x0, -0x18(%rbp)
je 0x6a2d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x2c(%rbp), %rax
addq %rax, %rdi
addq $0x44, %rdi
callq 0x49b0
movswl %ax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x6a55
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x2c(%rbp), %rax
addq %rax, %rdi
addq $0x46, %rdi
callq 0x49b0
movswl %ax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x6a7d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x2c(%rbp), %rax
addq %rax, %rdi
addq $0x48, %rdi
callq 0x49b0
movswl %ax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__find_table
static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag)
{
   stbtt_int32 num_tables = ttUSHORT(data+fontstart+4);
   stbtt_uint32 tabledir = fontstart + 12;
   stbtt_int32 i;
   for (i=0; i < num_tables; ++i) {
      stbtt_uint32 loc = tabledir + 16*i;
      if (stbtt_tag(data+loc+0, tag))
         return ttULONG(data+loc+8);
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
addq $0x4, %rdi
callq 0x4990
movzwl %ax, %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
addl $0xc, %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x6b6c
movl -0x28(%rbp), %eax
movl -0x2c(%rbp), %ecx
shll $0x4, %ecx
addl %ecx, %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl -0x30(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x6b5c
movq -0x10(%rbp), %rax
movl -0x30(%rbp), %ecx
movzbl 0x1(%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movsbl 0x1(%rcx), %ecx
cmpl %ecx, %eax
jne 0x6b5c
movq -0x10(%rbp), %rax
movl -0x30(%rbp), %ecx
movzbl 0x2(%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movsbl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jne 0x6b5c
movq -0x10(%rbp), %rax
movl -0x30(%rbp), %ecx
movzbl 0x3(%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movsbl 0x3(%rcx), %ecx
cmpl %ecx, %eax
jne 0x6b5c
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %eax
addq %rax, %rdi
addq $0x8, %rdi
callq 0x49d0
movl %eax, -0x4(%rbp)
jmp 0x6b73
jmp 0x6b5e
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6acc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_GetFontBoundingBox
STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1)
{
   *x0 = ttSHORT(info->data + info->head + 36);
   *y0 = ttSHORT(info->data + info->head + 38);
   *x1 = ttSHORT(info->data + info->head + 40);
   *y1 = ttSHORT(info->data + info->head + 42);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x1c(%rax), %rax
addq %rax, %rdi
addq $0x24, %rdi
callq 0x49b0
movswl %ax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x1c(%rax), %rax
addq %rax, %rdi
addq $0x26, %rdi
callq 0x49b0
movswl %ax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x1c(%rax), %rax
addq %rax, %rdi
addq $0x28, %rdi
callq 0x49b0
movswl %ax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x1c(%rax), %rax
addq %rax, %rdi
addq $0x2a, %rdi
callq 0x49b0
movswl %ax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_GetGlyphBitmapBoxSubpixel
STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1)
{
   int x0=0,y0=0,x1,y1; // =0 suppresses compiler warning
   if (!stbtt_GetGlyphBox(font, glyph, &x0,&y0,&x1,&y1)) {
      // e.g. space character
      if (ix0) *ix0 = 0;
      if (iy0) *iy0 = 0;
      if (ix1) *ix1 = 0;
      if (iy1) *iy1 = 0;
   } else {
      // move to integral bboxes (treating pixels as little squares, what pixels get touched)?
      if (ix0) *ix0 = STBTT_ifloor( x0 * scale_x + shift_x);
      if (iy0) *iy0 = STBTT_ifloor(-y1 * scale_y + shift_y);
      if (ix1) *ix1 = STBTT_iceil ( x1 * scale_x + shift_x);
      if (iy1) *iy1 = STBTT_iceil (-y0 * scale_y + shift_y);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movss %xmm1, -0x14(%rbp)
movss %xmm2, -0x18(%rbp)
movss %xmm3, -0x1c(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x44(%rbp), %rdx
leaq -0x48(%rbp), %rcx
leaq -0x4c(%rbp), %r8
leaq -0x50(%rbp), %r9
callq 0x4aa0
cmpl $0x0, %eax
jne 0x6dcb
cmpq $0x0, -0x28(%rbp)
je 0x6d93
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x6da4
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x38(%rbp)
je 0x6db5
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x40(%rbp)
je 0x6dc6
movq -0x40(%rbp), %rax
movl $0x0, (%rax)
jmp 0x6e99
cmpq $0x0, -0x28(%rbp)
je 0x6dfc
cvtsi2ssl -0x44(%rbp), %xmm0
movss -0x10(%rbp), %xmm2
movss -0x18(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1190
cvttsd2si %xmm0, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x6e31
xorl %eax, %eax
subl -0x50(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss -0x14(%rbp), %xmm2
movss -0x1c(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1190
cvttsd2si %xmm0, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x38(%rbp)
je 0x6e62
cvtsi2ssl -0x4c(%rbp), %xmm0
movss -0x10(%rbp), %xmm2
movss -0x18(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11e0
cvttsd2si %xmm0, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x40(%rbp)
je 0x6e97
xorl %eax, %eax
subl -0x48(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss -0x14(%rbp), %xmm2
movss -0x1c(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11e0
cvttsd2si %xmm0, %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
jmp 0x6e99
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_Rasterize
STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata)
{
   float scale            = scale_x > scale_y ? scale_y : scale_x;
   int winding_count      = 0;
   int *winding_lengths   = NULL;
   stbtt__point *windings = stbtt_FlattenCurves(vertices, num_verts, flatness_in_pixels / scale, &winding_lengths, &winding_count, userdata);
   if (windings) {
      stbtt__rasterize(result, windings, winding_lengths, winding_count, scale_x, scale_y, shift_x, shift_y, x_off, y_off, invert, userdata);
      STBTT_free(winding_lengths, userdata);
      STBTT_free(windings, userdata);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movss %xmm1, -0x20(%rbp)
movss %xmm2, -0x24(%rbp)
movss %xmm3, -0x28(%rbp)
movss %xmm4, -0x2c(%rbp)
movl %ecx, -0x30(%rbp)
movl %r8d, -0x34(%rbp)
movl %r9d, -0x38(%rbp)
movss -0x20(%rbp), %xmm0
ucomiss -0x24(%rbp), %xmm0
jbe 0x7032
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x54(%rbp)
jmp 0x703c
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x54(%rbp)
movss -0x54(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movss -0xc(%rbp), %xmm0
divss -0x3c(%rbp), %xmm0
movq 0x10(%rbp), %r8
leaq -0x48(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x70e0
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x70d5
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movl -0x40(%rbp), %ecx
movss -0x20(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
movss -0x28(%rbp), %xmm2
movss -0x2c(%rbp), %xmm3
movl -0x30(%rbp), %r8d
movl -0x34(%rbp), %r9d
movl -0x38(%rbp), %r10d
movq 0x10(%rbp), %rax
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x7530
movq -0x48(%rbp), %rdi
callq 0x1030
movq -0x50(%rbp), %rdi
callq 0x1030
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_MakeGlyphBitmapSubpixel
STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph)
{
   int ix0,iy0;
   stbtt_vertex *vertices;
   int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices);
   stbtt__bitmap gbm;   

   stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,0,0);
   gbm.pixels = output;
   gbm.w = out_w;
   gbm.h = out_h;
   gbm.stride = out_stride;

   if (gbm.w && gbm.h)
      stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0,iy0, 1, info->userdata);

   STBTT_free(vertices, info->userdata);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movss %xmm0, -0x20(%rbp)
movss %xmm1, -0x24(%rbp)
movss %xmm2, -0x28(%rbp)
movss %xmm3, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0x30(%rbp), %esi
leaq -0x40(%rbp), %rdx
callq 0x4a50
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rdi
movl -0x30(%rbp), %esi
movss -0x20(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
movss -0x28(%rbp), %xmm2
movss -0x2c(%rbp), %xmm3
leaq -0x34(%rbp), %rdx
leaq -0x38(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %r8
callq 0x6d20
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x60(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x58(%rbp)
cmpl $0x0, -0x60(%rbp)
je 0x7b8f
cmpl $0x0, -0x5c(%rbp)
je 0x7b8f
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %edx
movss -0x20(%rbp), %xmm1
movss -0x24(%rbp), %xmm2
movss -0x28(%rbp), %xmm3
movss -0x2c(%rbp), %xmm4
movl -0x34(%rbp), %ecx
movl -0x38(%rbp), %r8d
movq -0x8(%rbp), %rax
movq (%rax), %rax
leaq -0x60(%rbp), %rdi
movss 0xeaa4(%rip), %xmm0     # 0x16624
movl $0x1, %r9d
movq %rax, (%rsp)
callq 0x6fe0
movq -0x40(%rbp), %rdi
callq 0x1030
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_MakeGlyphBitmapSubpixelPrefilter
STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int prefilter_x, int prefilter_y, float *sub_x, float *sub_y, int glyph)
{
   stbtt_MakeGlyphBitmapSubpixel(info,
                                 output,
                                 out_w - (prefilter_x - 1),
                                 out_h - (prefilter_y - 1),
                                 out_stride,
                                 scale_x,
                                 scale_y,
                                 shift_x,
                                 shift_y,
                                 glyph);

   if (prefilter_x > 1)
      stbtt__h_prefilter(output, out_w, out_h, out_stride, prefilter_x);

   if (prefilter_y > 1)
      stbtt__v_prefilter(output, out_w, out_h, out_stride, prefilter_y);

   *sub_x = stbtt__oversample_shift(prefilter_x);
   *sub_y = stbtt__oversample_shift(prefilter_y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x28(%rbp), %eax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movss %xmm0, -0x20(%rbp)
movss %xmm1, -0x24(%rbp)
movss %xmm2, -0x28(%rbp)
movss %xmm3, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x30(%rbp), %eax
subl $0x1, %eax
subl %eax, %edx
movl -0x18(%rbp), %ecx
movl 0x10(%rbp), %eax
subl $0x1, %eax
subl %eax, %ecx
movl -0x1c(%rbp), %r8d
movss -0x20(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
movss -0x28(%rbp), %xmm2
movss -0x2c(%rbp), %xmm3
movl 0x28(%rbp), %r9d
callq 0x7ab0
cmpl $0x1, -0x30(%rbp)
jle 0x7e5b
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x30(%rbp), %r8d
callq 0x8700
cmpl $0x1, 0x10(%rbp)
jle 0x7e77
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl 0x10(%rbp), %r8d
callq 0x8a50
movl -0x30(%rbp), %edi
callq 0x8e00
movq 0x18(%rbp), %rax
movss %xmm0, (%rax)
movl 0x10(%rbp), %edi
callq 0x8e00
movq 0x20(%rbp), %rax
movss %xmm0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_PackBegin
STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int pw, int ph, int stride_in_bytes, int padding, void *alloc_context)
{
   stbrp_context *context = (stbrp_context *) STBTT_malloc(sizeof(*context)            ,alloc_context);
   int            num_nodes = pw - padding;
   stbrp_node    *nodes   = (stbrp_node    *) STBTT_malloc(sizeof(*nodes  ) * num_nodes,alloc_context);

   if (context == NULL || nodes == NULL) {
      if (context != NULL) STBTT_free(context, alloc_context);
      if (nodes   != NULL) STBTT_free(nodes  , alloc_context);
      return 0;
   }

   spc->user_allocator_context = alloc_context;
   spc->width = pw;
   spc->height = ph;
   spc->pixels = pixels;
   spc->pack_info = context;
   spc->nodes = nodes;
   spc->padding = padding;
   spc->stride_in_bytes = stride_in_bytes != 0 ? stride_in_bytes : pw;
   spc->h_oversample = 1;
   spc->v_oversample = 1;
   spc->skip_missing = 0;

   stbrp_init_target(context, pw-padding, ph-padding, nodes, num_nodes);

   if (pixels)
      STBTT_memset(pixels, 0, pw*ph); // background of 0 around pixels

   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl $0x14, %edi
callq 0x1140
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
subl -0x28(%rbp), %eax
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rdi
shlq $0x0, %rdi
callq 0x1140
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x8268
cmpq $0x0, -0x40(%rbp)
jne 0x8294
cmpq $0x0, -0x30(%rbp)
je 0x8278
movq -0x30(%rbp), %rdi
callq 0x1030
cmpq $0x0, -0x40(%rbp)
je 0x8288
movq -0x40(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
jmp 0x8360
movq 0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
cmpl $0x0, -0x24(%rbp)
je 0x82ef
movl -0x24(%rbp), %eax
movl %eax, -0x44(%rbp)
jmp 0x82f5
movl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x24(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %esi
subl -0x28(%rbp), %esi
movl -0x20(%rbp), %edx
subl -0x28(%rbp), %edx
movq -0x40(%rbp), %rcx
movl -0x34(%rbp), %r8d
callq 0x8370
cmpq $0x0, -0x18(%rbp)
je 0x8359
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
imull -0x20(%rbp), %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x10b0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbrp_init_target
static void stbrp_init_target(stbrp_context *con, int pw, int ph, stbrp_node *nodes, int num_nodes)
{
   con->width  = pw;
   con->height = ph;
   con->x = 0;
   con->y = 0;
   con->bottom_y = 0;
   STBTT__NOTUSED(nodes);
   STBTT__NOTUSED(num_nodes);   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_PackSetOversampling
STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample)
{
   STBTT_assert(h_oversample <= STBTT_MAX_OVERSAMPLE);
   STBTT_assert(v_oversample <= STBTT_MAX_OVERSAMPLE);
   if (h_oversample <= STBTT_MAX_OVERSAMPLE)
      spc->h_oversample = h_oversample;
   if (v_oversample <= STBTT_MAX_OVERSAMPLE)
      spc->v_oversample = v_oversample;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x8, -0xc(%rbp)
ja 0x840a
jmp 0x8429
leaq 0xe42a(%rip), %rdi      # 0x1683b
leaq 0xe39f(%rip), %rsi      # 0x167b7
movl $0xee8, %edx            # imm = 0xEE8
leaq 0xe429(%rip), %rcx      # 0x1684d
callq 0x10a0
cmpl $0x8, -0x10(%rbp)
ja 0x8431
jmp 0x8450
leaq 0xe466(%rip), %rdi      # 0x1689e
leaq 0xe378(%rip), %rsi      # 0x167b7
movl $0xee9, %edx            # imm = 0xEE9
leaq 0xe402(%rip), %rcx      # 0x1684d
callq 0x10a0
cmpl $0x8, -0xc(%rbp)
ja 0x8460
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
cmpl $0x8, -0x10(%rbp)
ja 0x8470
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbrp_pack_rects
static void stbrp_pack_rects(stbrp_context *con, stbrp_rect *rects, int num_rects)
{
   int i;
   for (i=0; i < num_rects; ++i) {
      if (con->x + rects[i].w > con->width) {
         con->x = 0;
         con->y = con->bottom_y;
      }
      if (con->y + rects[i].h > con->height)
         break;
      rects[i].x = con->x;
      rects[i].y = con->y;
      rects[i].was_packed = 1;
      con->x += rects[i].w;
      if (con->y + rects[i].h > con->bottom_y)
         con->bottom_y = con->y + rects[i].h;
   }
   for (   ; i < num_rects; ++i)
      rects[i].was_packed = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x9508
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
addl 0xc(%rcx), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x942c
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
addl 0x10(%rcx), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jle 0x9453
jmp 0x9508
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x1, 0x14(%rax)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
addl 0x10(%rcx), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jle 0x94f8
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
addl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x94fa
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x93e6
jmp 0x950a
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x9533
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x14(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x950a
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_PackFontRange
STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size,
            int first_unicode_codepoint_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range)
{
   stbtt_pack_range range;
   range.first_unicode_codepoint_in_range = first_unicode_codepoint_in_range;
   range.array_of_unicode_codepoints = NULL;
   range.num_chars                   = num_chars_in_range;
   range.chardata_for_range          = chardata_for_range;
   range.font_size                   = font_size;
   return stbtt_PackFontRanges(spc, fontdata, font_index, &range, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movss %xmm0, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq $0x0, -0x48(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x50(%rbp), %rcx
movl $0x1, %r8d
callq 0x9540
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_GetScaledFontVMetrics
STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, float size, float *ascent, float *descent, float *lineGap)
{
   int i_ascent, i_descent, i_lineGap;
   float scale;
   stbtt_fontinfo info;
   stbtt_InitFont(&info, fontdata, stbtt_GetFontOffsetForIndex(fontdata, index));
   scale = size > 0 ? stbtt_ScaleForPixelHeight(&info, size) : stbtt_ScaleForMappingEmToPixels(&info, -size);
   stbtt_GetFontVMetrics(&info, &i_ascent, &i_descent, &i_lineGap);
   *ascent  = (float) i_ascent  * scale;
   *descent = (float) i_descent * scale;
   *lineGap = (float) i_lineGap * scale;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x97f0
movq -0xe0(%rbp), %rsi
movl %eax, %edx
leaq -0xd8(%rbp), %rdi
callq 0x97c0
movss -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x9907
movss -0x10(%rbp), %xmm0
leaq -0xd8(%rbp), %rdi
callq 0x6c40
movss %xmm0, -0xe4(%rbp)
jmp 0x992d
movss -0x10(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
leaq -0xd8(%rbp), %rdi
callq 0x6cb0
movss %xmm0, -0xe4(%rbp)
movss -0xe4(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
leaq -0xd8(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x34(%rbp), %rcx
callq 0x6910
cvtsi2ssl -0x2c(%rbp), %xmm0
mulss -0x38(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
cvtsi2ssl -0x30(%rbp), %xmm0
mulss -0x38(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
cvtsi2ssl -0x34(%rbp), %xmm0
mulss -0x38(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_GetFontOffsetForIndex_internal
static int stbtt_GetFontOffsetForIndex_internal(unsigned char *font_collection, int index)
{
   // if it's just a font, there's only one valid index
   if (stbtt__isfont(font_collection))
      return index == 0 ? 0 : -1;

   // check if it's a TTC
   if (stbtt_tag(font_collection, "ttcf")) {
      // version 1?
      if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) {
         stbtt_int32 n = ttLONG(font_collection+8);
         if (index >= n)
            return -1;
         return ttULONG(font_collection+12+index*4);
      }
   }
   return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13a90
cmpl $0x0, %eax
je 0xc465
movl -0x14(%rbp), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xc527
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movsbl 0xafd0(%rip), %ecx      # 0x17443
cmpl %ecx, %eax
jne 0xc520
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movsbl 0xafba(%rip), %ecx      # 0x17444
cmpl %ecx, %eax
jne 0xc520
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movsbl 0xafa4(%rip), %ecx      # 0x17445
cmpl %ecx, %eax
jne 0xc520
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
movsbl 0xaf92(%rip), %ecx      # 0x17446
cmpl %ecx, %eax
jne 0xc520
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
callq 0x49d0
cmpl $0x10000, %eax          # imm = 0x10000
je 0xc4e0
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
callq 0x49d0
cmpl $0x20000, %eax          # imm = 0x20000
jne 0xc51e
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x13c30
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0xc501
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc527
movq -0x10(%rbp), %rdi
addq $0xc, %rdi
movl -0x14(%rbp), %eax
shll $0x2, %eax
cltq
addq %rax, %rdi
callq 0x49d0
movl %eax, -0x4(%rbp)
jmp 0xc527
jmp 0xc520
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_GetNumberOfFonts_internal
static int stbtt_GetNumberOfFonts_internal(unsigned char *font_collection)
{
   // if it's just a font, there's only one valid font
   if (stbtt__isfont(font_collection))
      return 1;

   // check if it's a TTC
   if (stbtt_tag(font_collection, "ttcf")) {
      // version 1?
      if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) {
         return ttLONG(font_collection+8);
      }
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13a90
cmpl $0x0, %eax
je 0xc576
movl $0x1, -0x4(%rbp)
jmp 0xc604
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movsbl 0xaebf(%rip), %ecx      # 0x17443
cmpl %ecx, %eax
jne 0xc5fd
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movsbl 0xaead(%rip), %ecx      # 0x17444
cmpl %ecx, %eax
jne 0xc5fd
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movsbl 0xae9b(%rip), %ecx      # 0x17445
cmpl %ecx, %eax
jne 0xc5fd
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
movsbl 0xae89(%rip), %ecx      # 0x17446
cmpl %ecx, %eax
jne 0xc5fd
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
callq 0x49d0
cmpl $0x10000, %eax          # imm = 0x10000
je 0xc5e9
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
callq 0x49d0
cmpl $0x20000, %eax          # imm = 0x20000
jne 0xc5fb
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x13c30
movl %eax, -0x4(%rbp)
jmp 0xc604
jmp 0xc5fd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_FindMatchingFont_internal
static int stbtt_FindMatchingFont_internal(unsigned char *font_collection, char *name_utf8, stbtt_int32 flags)
{
   stbtt_int32 i;
   for (i=0;;++i) {
      stbtt_int32 off = stbtt_GetFontOffsetForIndex(font_collection, i);
      if (off < 0) return off;
      if (stbtt__matches((stbtt_uint8 *) font_collection, off, (stbtt_uint8*) name_utf8, flags))
         return off;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x97f0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0xcdd7
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xce04
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x13c70
cmpl $0x0, %eax
je 0xcdf7
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xce04
jmp 0xcdf9
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xcdba
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbiw__outfile
static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...)
{
   if (y < 0 || x < 0) {
      return 0;
   } else {
      va_list v;
      va_start(v, fmt);
      stbiw__writefv(s, fmt, v);
      va_end(v);
      stbiw__write_pixels(s,rgb_dir,vdir,x,y,comp,data,alpha,pad, expand_mono);
      return 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
testb %al, %al
je 0xd52f
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq 0x30(%rbp), %rax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0xd561
cmpl $0x0, -0x24(%rbp)
jge 0xd56a
movl $0x0, -0xc(%rbp)
jmp 0xd5e5
leaq -0x50(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x30, (%rax)
movq -0x18(%rbp), %rdi
movq 0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0xd600
leaq -0x50(%rbp), %rax
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
movl -0x2c(%rbp), %r9d
movq 0x18(%rbp), %rbx
movl 0x20(%rbp), %r11d
movl 0x28(%rbp), %r10d
movl 0x10(%rbp), %eax
movq %rbx, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movl %eax, 0x18(%rsp)
callq 0xd820
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)