LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_GetBakedQuad
STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int opengl_fillrule)
{
   float d3d_bias = opengl_fillrule ? 0 : -0.5f;
   float ipw = 1.0f / pw, iph = 1.0f / ph;
   const stbtt_bakedchar *b = chardata + char_index;
   int round_x = STBTT_ifloor((*xpos + b->xoff) + 0.5f);
   int round_y = STBTT_ifloor((*ypos + b->yoff) + 0.5f);

   q->x0 = round_x + d3d_bias;
   q->y0 = round_y + d3d_bias;
   q->x1 = round_x + b->x1 - b->x0 + d3d_bias;
   q->y1 = round_y + b->y1 - b->y0 + d3d_bias;

   q->s0 = b->x0 * ipw;
   q->t0 = b->y0 * iph;
   q->s1 = b->x1 * ipw;
   q->t1 = b->y1 * iph;

   *xpos += b->xadvance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, -0x40(%rbp)
movq %r8, %rbx
movq %rdi, %r14
movq 0x10(%rbp), %r12
cmpl $0x0, 0x18(%rbp)
je 0x61e3
xorps %xmm0, %xmm0
jmp 0x61eb
movss 0x78d1(%rip), %xmm0     # 0xdabc
movss %xmm0, -0x2c(%rbp)
cvtsi2ss %esi, %xmm0
movss 0x7890(%rip), %xmm1     # 0xda8c
movaps %xmm1, %xmm2
divss %xmm0, %xmm2
movss %xmm2, -0x30(%rbp)
cvtsi2ss %edx, %xmm0
divss %xmm0, %xmm1
movss %xmm1, -0x34(%rbp)
movslq %ecx, %rax
imulq $0x14, %rax, %r13
movss (%rbx), %xmm0
addss 0x8(%r14,%r13), %xmm0
addss 0x7879(%rip), %xmm0     # 0xdaa8
callq 0x11d0
movaps %xmm0, -0x50(%rbp)
cvttss2si %xmm0, %r15d
movq -0x40(%rbp), %rax
movss (%rax), %xmm0
addss 0xc(%r14,%r13), %xmm0
addss 0x7854(%rip), %xmm0     # 0xdaa8
callq 0x11d0
cvttss2si %xmm0, %eax
cvttps2dq -0x50(%rbp), %xmm1
cvtdq2ps %xmm1, %xmm1
movss -0x2c(%rbp), %xmm2
addss %xmm2, %xmm1
movss %xmm1, (%r12)
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
addss %xmm2, %xmm0
movss %xmm0, 0x4(%r12)
movzwl 0x4(%r14,%r13), %ecx
addl %ecx, %r15d
movzwl (%r14,%r13), %edx
subl %edx, %r15d
cvtsi2ss %r15d, %xmm0
addss %xmm2, %xmm0
movss %xmm0, 0x10(%r12)
movzwl 0x6(%r14,%r13), %esi
addl %esi, %eax
movzwl 0x2(%r14,%r13), %edi
subl %edi, %eax
cvtsi2ss %eax, %xmm0
addss %xmm2, %xmm0
movss %xmm0, 0x14(%r12)
cvtsi2ss %edx, %xmm0
movss -0x30(%rbp), %xmm3
mulss %xmm3, %xmm0
movss %xmm0, 0x8(%r12)
cvtsi2ss %edi, %xmm0
movss -0x34(%rbp), %xmm2
mulss %xmm2, %xmm0
cvtsi2ss %ecx, %xmm1
movss %xmm0, 0xc(%r12)
cvtsi2ss %esi, %xmm0
mulss %xmm3, %xmm1
movss %xmm1, 0x18(%r12)
mulss %xmm2, %xmm0
movss %xmm0, 0x1c(%r12)
movss 0x10(%r14,%r13), %xmm0
addss (%rbx), %xmm0
movss %xmm0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r12d
movl %r8d, %ebx
movl %ecx, -0x34(%rbp)
movl %edx, %r15d
movq %rsi, -0x40(%rbp)
movq %rdi, %r14
pushq $0x14
popq %rdi
callq 0x1170
movq %rax, %r13
movl %r15d, -0x30(%rbp)
movl %r12d, -0x2c(%rbp)
subl %r12d, %r15d
movslq %r15d, %rdi
callq 0x1170
movq %rax, %r12
testq %r13, %r13
setne %al
testq %r12, %r12
setne %cl
testb %cl, %al
jne 0x6393
movq %r13, %rdi
callq 0x1030
movq %r12, %rdi
callq 0x1030
xorl %ebx, %ebx
jmp 0x6409
movq 0x10(%rbp), %rax
movq %rax, (%r14)
movl -0x30(%rbp), %edx
movl %edx, 0x10(%r14)
movl -0x34(%rbp), %ecx
movl %ecx, 0x14(%r14)
movq -0x40(%rbp), %rdi
movq %rdi, 0x30(%r14)
movq %r13, 0x8(%r14)
movq %r12, 0x38(%r14)
testl %ebx, %ebx
cmovel %edx, %ebx
movl -0x2c(%rbp), %esi
movl %esi, 0x1c(%r14)
movl %ebx, 0x18(%r14)
movl $0x1, 0x28(%r14)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x20(%r14)
movl %ecx, %eax
subl %esi, %eax
movl %r15d, (%r13)
movl %eax, 0x4(%r13)
andq $0x0, 0x8(%r13)
andl $0x0, 0x10(%r13)
pushq $0x1
popq %rbx
testq %rdi, %rdi
je 0x6409
imull %edx, %ecx
movslq %ecx, %rdx
xorl %esi, %esi
callq 0x10d0
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpl $0x9, %esi
jae 0x6451
cmpl $0x9, %edx
jae 0x6470
movl %esi, 0x24(%rdi)
movl %edx, 0x28(%rdi)
popq %rbp
retq
leaq 0x7894(%rip), %rdi      # 0xdcec
leaq 0x7809(%rip), %rsi      # 0xdc68
leaq 0x7898(%rip), %rcx      # 0xdcfe
movl $0xee8, %edx            # imm = 0xEE8
callq 0x10c0
leaq 0x78d8(%rip), %rdi      # 0xdd4f
leaq 0x77ea(%rip), %rsi      # 0xdc68
leaq 0x7879(%rip), %rcx      # 0xdcfe
movl $0xee9, %edx            # imm = 0xEE9
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_PackFontRanges
STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges)
{
   stbtt_fontinfo info;
   int i,j,n, return_value = 1;
   //stbrp_context *context = (stbrp_context *) spc->pack_info;
   stbrp_rect    *rects;

   // flag all characters as NOT packed
   for (i=0; i < num_ranges; ++i)
      for (j=0; j < ranges[i].num_chars; ++j)
         ranges[i].chardata_for_range[j].x0 =
         ranges[i].chardata_for_range[j].y0 =
         ranges[i].chardata_for_range[j].x1 =
         ranges[i].chardata_for_range[j].y1 = 0;

   n = 0;
   for (i=0; i < num_ranges; ++i)
      n += ranges[i].num_chars;
         
   rects = (stbrp_rect *) STBTT_malloc(sizeof(*rects) * n, spc->user_allocator_context);
   if (rects == NULL)
      return 0;

   info.userdata = spc->user_allocator_context;
   stbtt_InitFont(&info, fontdata, stbtt_GetFontOffsetForIndex(fontdata,font_index));

   n = stbtt_PackFontRangesGatherRects(spc, &info, ranges, num_ranges, rects);

   stbtt_PackFontRangesPackRects(spc, rects, n);
  
   return_value = stbtt_PackFontRangesRenderIntoRects(spc, &info, ranges, num_ranges, rects);

   STBTT_free(rects, spc->user_allocator_context);
   return return_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movl %edx, -0x2c(%rbp)
movq %rsi, %r12
movq %rdi, %r15
xorl %eax, %eax
testl %r8d, %r8d
movl $0x0, %ecx
cmovgl %r8d, %ecx
xorl %edx, %edx
cmpq %rcx, %rdx
je 0x6f42
imulq $0x28, %rdx, %rdi
leaq (%r14,%rdi), %rsi
movl 0x10(%r14,%rdi), %edi
testl %edi, %edi
cmovlel %eax, %edi
imulq $0x1c, %rdi, %rdi
xorl %r8d, %r8d
cmpq %r8, %rdi
je 0x6f3d
movq 0x18(%rsi), %r9
andq $0x0, (%r9,%r8)
addq $0x1c, %r8
jmp 0x6f29
incq %rdx
jmp 0x6f0b
imulq $0x28, %rcx, %rax
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rcx, %rax
je 0x6f5a
addl 0x10(%r14,%rcx), %edx
addq $0x28, %rcx
jmp 0x6f4a
movslq %edx, %rax
imulq $0x18, %rax, %rdi
callq 0x1170
testq %rax, %rax
je 0x6fdd
movq %rax, %r13
movq (%r15), %rax
leaq -0xd0(%rbp), %rcx
movq %rax, (%rcx)
movq %r12, %rdi
movl -0x2c(%rbp), %esi
callq 0x73c8
leaq -0xd0(%rbp), %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x6ff3
movq %r15, %rdi
leaq -0xd0(%rbp), %rsi
movq %rsi, %r12
movq %r14, %rdx
movl %ebx, %ecx
movq %r13, %r8
callq 0x6498
movq %r15, %rdi
movq %r13, %rsi
movl %eax, %edx
callq 0x6e3c
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl %ebx, %ecx
movq %r13, %r8
callq 0x6a63
movl %eax, %ebx
movq %r13, %rdi
callq 0x1030
jmp 0x6fdf
xorl %ebx, %ebx
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x30, %rsp
leaq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
andq $0x0, 0x8(%rax)
movl %r8d, 0x10(%rax)
movq %r9, 0x18(%rax)
movss %xmm0, (%rax)
pushq $0x1
popq %r8
movq %rax, %rcx
callq 0x6ed8
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r8, -0x48(%rbp)
movq %rcx, %r14
movq %rdx, %r15
movaps %xmm0, -0x40(%rbp)
movq %rdi, %r12
callq 0x73c8
leaq -0xf8(%rbp), %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x6ff3
movaps -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x74df
leaq -0xf8(%rbp), %rdi
callq 0x4b6c
jmp 0x7508
xorps 0x664a(%rip), %xmm0     # 0xdb30
movq -0xf0(%rbp), %rax
movslq -0xdc(%rbp), %rcx
movzwl 0x12(%rax,%rcx), %eax
rolw $0x8, %ax
movzwl %ax, %eax
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
movaps %xmm0, -0x40(%rbp)
leaq -0xf8(%rbp), %rdi
leaq -0x54(%rbp), %r12
leaq -0x50(%rbp), %r13
leaq -0x4c(%rbp), %rbx
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x4982
cvtsi2ssl (%r12), %xmm0
movaps -0x40(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, (%r15)
cvtsi2ssl (%r13), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, (%r14)
cvtsi2ssl (%rbx), %xmm0
mulss %xmm1, %xmm0
movq -0x48(%rbp), %rax
movss %xmm0, (%rax)
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_GetPackedQuad
STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int align_to_integer)
{
   float ipw = 1.0f / pw, iph = 1.0f / ph;
   const stbtt_packedchar *b = chardata + char_index;

   if (align_to_integer) {
      float x = (float) STBTT_ifloor((*xpos + b->xoff) + 0.5f);
      float y = (float) STBTT_ifloor((*ypos + b->yoff) + 0.5f);
      q->x0 = x;
      q->y0 = y;
      q->x1 = x + b->xoff2 - b->xoff;
      q->y1 = y + b->yoff2 - b->yoff;
   } else {
      q->x0 = *xpos + b->xoff;
      q->y0 = *ypos + b->yoff;
      q->x1 = *xpos + b->xoff2;
      q->y1 = *ypos + b->yoff2;
   }

   q->s0 = b->x0 * ipw;
   q->t0 = b->y0 * iph;
   q->s1 = b->x1 * ipw;
   q->t1 = b->y1 * iph;

   *xpos += b->xadvance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r12
movq %r8, %rbx
movl %edx, %r15d
movq 0x10(%rbp), %r13
movslq %ecx, %rax
imulq $0x1c, %rax, %rax
cmpl $0x0, 0x18(%rbp)
leaq (%rdi,%rax), %r14
movss 0x8(%rdi,%rax), %xmm1
movss (%r8), %xmm0
addss %xmm1, %xmm0
je 0x7629
addss 0x64f1(%rip), %xmm0     # 0xdaa8
movl %esi, -0x34(%rbp)
movss %xmm1, -0x30(%rbp)
callq 0x11d0
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movss 0xc(%r14), %xmm1
movss %xmm1, -0x2c(%rbp)
movss (%r12), %xmm0
addss %xmm1, %xmm0
addss 0x64bc(%rip), %xmm0     # 0xdaa8
callq 0x11d0
movl -0x34(%rbp), %esi
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movaps -0x50(%rbp), %xmm1
movss %xmm1, (%r13)
movss %xmm0, 0x4(%r13)
addss 0x14(%r14), %xmm1
subss -0x30(%rbp), %xmm1
movss %xmm1, 0x10(%r13)
addss 0x18(%r14), %xmm0
subss -0x2c(%rbp), %xmm0
jmp 0x765d
movss %xmm0, (%r13)
movss (%r12), %xmm0
addss 0xc(%r14), %xmm0
movss %xmm0, 0x4(%r13)
movss (%rbx), %xmm0
addss 0x14(%r14), %xmm0
movss %xmm0, 0x10(%r13)
movss (%r12), %xmm0
addss 0x18(%r14), %xmm0
movss %xmm0, 0x14(%r13)
cvtsi2ss %r15d, %xmm0
movss 0x641c(%rip), %xmm1     # 0xda8c
cvtsi2ss %esi, %xmm2
movzwl (%r14), %eax
cvtsi2ss %eax, %xmm3
movaps %xmm1, %xmm4
divss %xmm2, %xmm1
mulss %xmm1, %xmm3
movss %xmm3, 0x8(%r13)
movzwl 0x2(%r14), %eax
cvtsi2ss %eax, %xmm2
divss %xmm0, %xmm4
mulss %xmm4, %xmm2
movss %xmm2, 0xc(%r13)
movzwl 0x4(%r14), %eax
cvtsi2ss %eax, %xmm0
mulss %xmm1, %xmm0
movss %xmm0, 0x18(%r13)
movzwl 0x6(%r14), %eax
cvtsi2ss %eax, %xmm0
mulss %xmm4, %xmm0
movss %xmm0, 0x1c(%r13)
movss 0x10(%r14), %xmm0
addss (%rbx), %xmm0
movss %xmm0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_GetFontNameString
STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID)
{
   stbtt_int32 i,count,stringOffset;
   stbtt_uint8 *fc = font->data;
   stbtt_uint32 offset = font->fontstart;
   stbtt_uint32 nm = stbtt__find_table(fc, offset, "name");
   if (!nm) return NULL;

   count = ttUSHORT(fc+nm+2);
   stringOffset = nm + ttUSHORT(fc+nm+4);
   for (i=0; i < count; ++i) {
      stbtt_uint32 loc = nm + 6 + 12 * i;
      if (platformID == ttUSHORT(fc+loc+0) && encodingID == ttUSHORT(fc+loc+2)
          && languageID == ttUSHORT(fc+loc+4) && nameID == ttUSHORT(fc+loc+6)) {
         *length = ttUSHORT(fc+loc+8);
         return (const char *) (fc+stringOffset+ttUSHORT(fc+loc+10));
      }
   }
   return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r15d
movl %r8d, %r12d
movl %ecx, %r13d
movl %edx, %r14d
movq %rsi, -0x30(%rbp)
movq 0x8(%rdi), %rbx
movl 0x10(%rdi), %esi
leaq 0x5368(%rip), %rdx      # 0xdde4
movq %rbx, %rdi
callq 0x4a85
testl %eax, %eax
je 0x8b05
movl %eax, %ecx
movzwl 0x2(%rbx,%rcx), %edx
rolw $0x8, %dx
movzwl 0x4(%rbx,%rcx), %ecx
movzwl %dx, %esi
rolw $0x8, %cx
movzwl %cx, %edx
addl %eax, %edx
addl $0x6, %eax
xorl %ecx, %ecx
subq $0x1, %rsi
jb 0x8b07
movl %eax, %edi
movzwl (%rbx,%rdi), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r8d
cmpl %r14d, %r8d
jne 0x8b00
movzwl 0x2(%rbx,%rdi), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r8d
cmpl %r13d, %r8d
jne 0x8b00
movzwl 0x4(%rbx,%rdi), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r8d
cmpl %r12d, %r8d
jne 0x8b00
movzwl 0x6(%rbx,%rdi), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r8d
cmpl %r15d, %r8d
je 0x8b19
addl $0xc, %eax
jmp 0x8aa9
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzwl 0x8(%rbx,%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movq -0x30(%rbp), %rcx
movl %eax, (%rcx)
movslq %edx, %rax
addq %rbx, %rax
movzwl 0xa(%rbx,%rdi), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
addq %rax, %rcx
jmp 0x8b07
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
testb %al, %al
je 0x93d4
movaps %xmm0, -0x100(%rbp)
movaps %xmm1, -0xf0(%rbp)
movaps %xmm2, -0xe0(%rbp)
movaps %xmm3, -0xd0(%rbp)
movaps %xmm4, -0xc0(%rbp)
movaps %xmm5, -0xb0(%rbp)
movaps %xmm6, -0xa0(%rbp)
movaps %xmm7, -0x90(%rbp)
movl %r8d, %eax
orl %ecx, %eax
js 0x94d8
movl %r9d, %r13d
movl %r8d, %r14d
movl %ecx, %r15d
movq %rdi, %rbx
movq 0x30(%rbp), %rsi
leaq -0x130(%rbp), %rax
leaq -0x80(%rbp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x38(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000030, %rax     # imm = 0x3000000030
movq %rax, (%rdx)
callq 0x94ec
andl $0x0, -0x2c(%rbp)
testl %r14d, %r14d
jle 0x94d3
movl 0x10(%rbp), %r12d
movl 0x8d01(%rip), %eax      # 0x12130
leal -0x1(%r14), %edx
xorl %esi, %esi
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leaq -0x1(%rcx,%rcx), %rcx
cmovnel %esi, %edx
cmpl $0x1, %eax
movl $0x0, %eax
sbbl %eax, %eax
orl %r14d, %eax
movslq %r13d, %r13
testl %r15d, %r15d
cmovgl %r15d, %esi
movq %rsi, -0x48(%rbp)
movslq %r15d, %rsi
cltq
movq %rax, -0x50(%rbp)
imulq %r13, %rsi
movq %rsi, %r14
imulq %rdx, %r14
addq 0x18(%rbp), %r14
movq %rcx, -0x40(%rbp)
imulq %rcx, %rsi
movq %rsi, -0x38(%rbp)
cmpq -0x50(%rbp), %rdx
je 0x94d3
movq %rdx, -0x60(%rbp)
movq -0x48(%rbp), %r15
movq %r14, -0x58(%rbp)
subq $0x1, %r15
jb 0x94b4
movq %rbx, %rdi
movl %r13d, %esi
movl 0x20(%rbp), %edx
movl %r12d, %ecx
movq %r14, %r8
callq 0x960f
addq %r13, %r14
jmp 0x9495
movq 0x8(%rbx), %rdi
leaq -0x2c(%rbp), %rsi
movl 0x28(%rbp), %edx
callq *(%rbx)
movq -0x60(%rbp), %rdx
addq -0x40(%rbp), %rdx
movq -0x58(%rbp), %r14
addq -0x38(%rbp), %r14
jmp 0x9483
pushq $0x1
popq %rax
jmp 0x94da
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbiw__writefv
static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v)
{
   while (*fmt) {
      switch (*fmt++) {
         case ' ': break;
         case '1': { unsigned char x = STBIW_UCHAR(va_arg(v, int));
                     s->func(s->context,&x,1);
                     break; }
         case '2': { int x = va_arg(v,int);
                     unsigned char b[2];
                     b[0] = STBIW_UCHAR(x);
                     b[1] = STBIW_UCHAR(x>>8);
                     s->func(s->context,b,2);
                     break; }
         case '4': { stbiw_uint32 x = va_arg(v,int);
                     unsigned char b[4];
                     b[0]=STBIW_UCHAR(x);
                     b[1]=STBIW_UCHAR(x>>8);
                     b[2]=STBIW_UCHAR(x>>16);
                     b[3]=STBIW_UCHAR(x>>24);
                     s->func(s->context,b,4);
                     break; }
         default:
            STBIW_ASSERT(0);
            return;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x29(%rbp), %r12
pushq $0x1
popq %r13
movzbl (%r14), %eax
testl %eax, %eax
je 0x95e1
incq %r14
cmpl $0x20, %eax
je 0x950b
cmpl $0x34, %eax
je 0x955e
cmpl $0x32, %eax
je 0x9548
cmpl $0x31, %eax
jne 0x95f0
movl (%rbx), %ecx
cmpq $0x28, %rcx
ja 0x959a
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x95a6
movl (%rbx), %ecx
cmpq $0x28, %rcx
ja 0x9574
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x9580
movl (%rbx), %ecx
cmpq $0x28, %rcx
ja 0x95bd
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x95c9
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movzwl (%rax), %eax
movw %ax, -0x2b(%rbp)
movq 0x8(%r15), %rdi
leaq -0x2b(%rbp), %rsi
pushq $0x2
popq %rdx
callq *(%r15)
jmp 0x950b
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movb (%rax), %al
movb %al, -0x29(%rbp)
movq 0x8(%r15), %rdi
movq %r12, %rsi
movl %r13d, %edx
callq *(%r15)
jmp 0x950b
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movl (%rax), %eax
movl %eax, -0x2f(%rbp)
movq 0x8(%r15), %rdi
leaq -0x2f(%rbp), %rsi
pushq $0x4
popq %rdx
callq *(%r15)
jmp 0x950b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x476f(%rip), %rdi      # 0xdd66
leaq 0x45a4(%rip), %rsi      # 0xdba2
leaq 0x48f3(%rip), %rcx      # 0xdef8
movl $0x171, %edx            # imm = 0x171
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbiw__write_pixel
static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d)
{
   unsigned char bg[3] = { 255, 0, 255}, px[3];
   int k;

   if (write_alpha < 0)
      s->func(s->context, &d[comp - 1], 1);

   switch (comp) {
      case 2: // 2 pixels = mono + alpha, alpha is written separately, so same as 1-channel case
      case 1:
         if (expand_mono)
            stbiw__write3(s, d[0], d[0], d[0]); // monochrome bmp
         else
            s->func(s->context, d, 1);  // monochrome TGA
         break;
      case 4:
         if (!write_alpha) {
            // composite against pink background
            for (k = 0; k < 3; ++k)
               px[k] = bg[k] + ((d[k] - bg[k]) * d[3]) / 255;
            stbiw__write3(s, px[1 - rgb_dir], px[1], px[1 + rgb_dir]);
            break;
         }
         /* FALLTHROUGH */
      case 3:
         stbiw__write3(s, d[1 - rgb_dir], d[1], d[1 + rgb_dir]);
         break;
   }
   if (write_alpha > 0)
      s->func(s->context, &d[comp - 1], 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movl %edx, %r12d
movl %esi, %r15d
movq %rdi, %rbx
leal -0x1(%r15), %eax
cmpl $0x2, %eax
jb 0x965d
cmpl $0x3, %r15d
je 0x9644
cmpl $0x4, %r15d
jne 0x9679
testl %r12d, %r12d
je 0x96aa
movb 0x2(%r14), %al
movb (%r14), %cl
movb 0x1(%r14), %dl
leaq -0x2c(%rbp), %rsi
movb %al, (%rsi)
movb %dl, 0x1(%rsi)
movb %cl, 0x2(%rsi)
jmp 0x9670
testl %ecx, %ecx
je 0x969e
movb (%r14), %al
leaq -0x26(%rbp), %rsi
movb %al, (%rsi)
movb %al, 0x1(%rsi)
movb %al, 0x2(%rsi)
movq 0x8(%rbx), %rdi
pushq $0x3
popq %rdx
callq *(%rbx)
testl %r12d, %r12d
jle 0x9691
movq 0x8(%rbx), %rdi
movslq %r15d, %rax
leaq (%r14,%rax), %rsi
decq %rsi
pushq $0x1
popq %rdx
callq *(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rdi
pushq $0x1
popq %rdx
movq %r14, %rsi
jmp 0x9677
movzbl 0x3(%r14), %ecx
xorl %esi, %esi
leaq 0x2b3c(%rip), %rdi      # 0xc1f4
movl $0xff, %r8d
cmpq $0x3, %rsi
je 0x96e4
movzbl (%rsi,%rdi), %r9d
movzbl (%r14,%rsi), %eax
subl %r9d, %eax
imull %ecx, %eax
cltd
idivl %r8d
addb %r9b, %al
movb %al, -0x23(%rbp,%rsi)
incq %rsi
jmp 0x96be
movb -0x21(%rbp), %al
movb -0x23(%rbp), %cl
movb -0x22(%rbp), %dl
leaq -0x29(%rbp), %rsi
jmp 0x9653
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbiw__linear_to_rgbe
static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear)
{
   int exponent;
   float maxcomp = stbiw__max(linear[0], stbiw__max(linear[1], linear[2]));

   if (maxcomp < 1e-32f) {
      rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0;
   } else {
      float normalize = (float) frexp(maxcomp, &exponent) * 256.0f/maxcomp;

      rgbe[0] = (unsigned char)(linear[0] * normalize);
      rgbe[1] = (unsigned char)(linear[1] * normalize);
      rgbe[2] = (unsigned char)(linear[2] * normalize);
      rgbe[3] = (unsigned char)(exponent + 128);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movss (%rsi), %xmm1
movss 0x4(%rsi), %xmm0
maxss 0x8(%rsi), %xmm0
movaps %xmm1, %xmm2
maxss %xmm0, %xmm2
movss 0x4347(%rip), %xmm0     # 0xdb08
ucomiss %xmm2, %xmm0
jbe 0x97d0
andw $0x0, (%rbx)
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x982d
movq %rsi, %r14
cvtss2sd %xmm2, %xmm0
leaq -0x24(%rbp), %r15
movq %r15, %rdi
movss %xmm1, -0x20(%rbp)
movss %xmm2, -0x1c(%rbp)
callq 0x1120
cvtsd2ss %xmm0, %xmm0
mulss 0x4313(%rip), %xmm0     # 0xdb0c
divss -0x1c(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %eax
movb %al, (%rbx)
movss 0x4(%r14), %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %eax
movb %al, 0x1(%rbx)
mulss 0x8(%r14), %xmm0
cvttss2si %xmm0, %ecx
movb (%r15), %al
addb $-0x80, %al
movb %al, 0x3(%rbx)
movb %cl, 0x2(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbiw__jpg_writeBits
static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) {
   int bitBuf = *bitBufP, bitCnt = *bitCntP;
   bitCnt += bs[1];
   bitBuf |= bs[0] << (24 - bitCnt);
   while(bitCnt >= 8) {
      unsigned char c = (bitBuf >> 16) & 255;
      stbiw__putc(s, c);
      if(c == 255) {
         stbiw__putc(s, 0);
      }
      bitBuf <<= 8;
      bitCnt -= 8;
   }
   *bitBufP = bitBuf;
   *bitCntP = bitCnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movzwl 0x2(%rcx), %r14d
movq %rdx, -0x40(%rbp)
addl (%rdx), %r14d
movzwl (%rcx), %ebx
movb $0x18, %cl
subb %r14b, %cl
shll %cl, %ebx
movq %rsi, -0x38(%rbp)
orl (%rsi), %ebx
movq %rdi, %r15
leaq -0x29(%rbp), %r12
pushq $0x1
popq %r13
cmpl $0x8, %r14d
jl 0x9ba7
movl %ebx, %eax
shrl $0x10, %eax
movb %al, -0x29(%rbp)
movq 0x8(%r15), %rdi
movq %r12, %rsi
movl %r13d, %edx
callq *(%r15)
movl %ebx, %eax
notl %eax
testl $0xff0000, %eax         # imm = 0xFF0000
jne 0x9b9e
movb $0x0, -0x2a(%rbp)
movq 0x8(%r15), %rdi
leaq -0x2a(%rbp), %rsi
movl %r13d, %edx
callq *(%r15)
shll $0x8, %ebx
addl $-0x8, %r14d
jmp 0x9b66
movq -0x38(%rbp), %rax
movl %ebx, (%rax)
movq -0x40(%rbp), %rax
movl %r14d, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbiw__jpg_DCT
static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) {
   float d0 = *d0p, d1 = *d1p, d2 = *d2p, d3 = *d3p, d4 = *d4p, d5 = *d5p, d6 = *d6p, d7 = *d7p;
   float z1, z2, z3, z4, z5, z11, z13;

   float tmp0 = d0 + d7;
   float tmp7 = d0 - d7;
   float tmp1 = d1 + d6;
   float tmp6 = d1 - d6;
   float tmp2 = d2 + d5;
   float tmp5 = d2 - d5;
   float tmp3 = d3 + d4;
   float tmp4 = d3 - d4;

   // Even part
   float tmp10 = tmp0 + tmp3;   // phase 2
   float tmp13 = tmp0 - tmp3;
   float tmp11 = tmp1 + tmp2;
   float tmp12 = tmp1 - tmp2;

   d0 = tmp10 + tmp11;       // phase 3
   d4 = tmp10 - tmp11;

   z1 = (tmp12 + tmp13) * 0.707106781f; // c4
   d2 = tmp13 + z1;       // phase 5
   d6 = tmp13 - z1;

   // Odd part
   tmp10 = tmp4 + tmp5;       // phase 2
   tmp11 = tmp5 + tmp6;
   tmp12 = tmp6 + tmp7;

   // The rotator is modified from fig 4-8 to avoid extra negations.
   z5 = (tmp10 - tmp12) * 0.382683433f; // c6
   z2 = tmp10 * 0.541196100f + z5; // c2-c6
   z4 = tmp12 * 1.306562965f + z5; // c2+c6
   z3 = tmp11 * 0.707106781f; // c4

   z11 = tmp7 + z3;      // phase 5
   z13 = tmp7 - z3;

   *d5p = z13 + z2;         // phase 6
   *d3p = z13 - z2;
   *d1p = z11 + z4;
   *d7p = z11 - z4;

   *d0p = d0;  *d2p = d2;  *d4p = d4;  *d6p = d6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rbp), %r10
movq 0x10(%rbp), %rax
movss (%rdi), %xmm2
movss (%rsi), %xmm0
movss (%rdx), %xmm4
movss (%rcx), %xmm3
movss (%r8), %xmm5
movss (%r9), %xmm6
movss (%rax), %xmm7
movss (%r10), %xmm8
movaps %xmm2, %xmm1
addss %xmm8, %xmm1
subss %xmm8, %xmm2
movaps %xmm0, %xmm8
addss %xmm7, %xmm8
subss %xmm7, %xmm0
movaps %xmm4, %xmm7
addss %xmm6, %xmm7
subss %xmm6, %xmm4
movaps %xmm3, %xmm6
addss %xmm5, %xmm6
subss %xmm5, %xmm3
movaps %xmm6, %xmm5
addss %xmm1, %xmm5
subss %xmm6, %xmm1
movaps %xmm7, %xmm9
addss %xmm8, %xmm9
subss %xmm7, %xmm8
movaps %xmm9, %xmm6
addss %xmm5, %xmm6
subss %xmm9, %xmm5
addss %xmm1, %xmm8
movss 0x3eba(%rip), %xmm9     # 0xdb10
mulss %xmm9, %xmm8
movaps %xmm1, %xmm7
addss %xmm8, %xmm7
subss %xmm8, %xmm1
addss %xmm4, %xmm3
addss %xmm0, %xmm4
addss %xmm2, %xmm0
movaps %xmm3, %xmm8
subss %xmm0, %xmm8
mulss 0x3e8e(%rip), %xmm8     # 0xdb14
mulss 0x3e8a(%rip), %xmm3     # 0xdb18
mulss 0x3e86(%rip), %xmm0     # 0xdb1c
addss %xmm8, %xmm3
addss %xmm8, %xmm0
mulss %xmm9, %xmm4
movaps %xmm2, %xmm8
addss %xmm4, %xmm8
subss %xmm4, %xmm2
movaps %xmm2, %xmm4
addss %xmm3, %xmm4
movss %xmm4, (%r9)
subss %xmm3, %xmm2
movss %xmm2, (%rcx)
movaps %xmm8, %xmm2
addss %xmm0, %xmm2
movss %xmm2, (%rsi)
subss %xmm0, %xmm8
movss %xmm8, (%r10)
movss %xmm6, (%rdi)
movss %xmm7, (%rdx)
movss %xmm5, (%r8)
movss %xmm1, (%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbiw__jpg_calcBits
static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) {
   int tmp1 = val < 0 ? -val : val;
   val = val < 0 ? val-1 : val;
   bits[1] = 1;
   while(tmp1 >>= 1) {
      ++bits[1];
   }
   bits[0] = val & ((1<<bits[1])-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
negl %eax
cmovsl %edi, %eax
movl $0x1, %ecx
cmpl $0x2, %eax
jb 0x9d0a
shrl %eax
incl %ecx
jmp 0x9cff
movw %cx, 0x2(%rsi)
movl %edi, %eax
sarl $0x1f, %eax
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
addl %edi, %eax
notl %edx
andl %eax, %edx
movw %dx, (%rsi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__cff_index_get
static stbtt__buf stbtt__cff_index_get(stbtt__buf b, int i)
{
   int count, offsize, start, end;
   stbtt__buf_seek(&b, 0);
   count = stbtt__buf_get16(&b);
   offsize = stbtt__buf_get8(&b);
   STBTT_assert(i >= 0 && i < count);
   STBTT_assert(offsize >= 1 && offsize <= 4);
   stbtt__buf_skip(&b, i*offsize);
   start = stbtt__buf_get(&b, offsize);
   end = stbtt__buf_get(&b, offsize);
   return stbtt__buf_range(&b, 2+(count+1)*offsize+start, end - start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
leaq -0x30(%rbp), %r15
movq %rdi, (%r15)
movq %rsi, 0x8(%r15)
xorl %r12d, %r12d
movq %r15, %rdi
xorl %esi, %esi
callq 0xac33
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0xab50
movl %eax, %ebx
movslq 0x8(%r15), %rax
cmpl 0xc(%r15), %eax
jge 0xa934
movq -0x30(%rbp), %rcx
leal 0x1(%rax), %edx
movl %edx, -0x28(%rbp)
movb (%rcx,%rax), %r12b
testl %r14d, %r14d
js 0xa99e
cmpl %r14d, %ebx
jle 0xa99e
leal -0x1(%r12), %eax
cmpb $0x4, %al
jae 0xa9bd
movzbl %r12b, %r15d
imull %r15d, %r14d
leaq -0x30(%rbp), %r12
movq %r12, %rdi
movl %r14d, %esi
callq 0xa9fa
movq %r12, %rdi
movl %r15d, %esi
callq 0xab50
movl %eax, %r14d
movq %r12, %rdi
movl %r15d, %esi
callq 0xab50
incl %ebx
imull %r15d, %ebx
leal (%rbx,%r14), %esi
addl $0x2, %esi
subl %r14d, %eax
movq %r12, %rdi
movl %eax, %edx
callq 0xac63
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3653(%rip), %rdi      # 0xdff8
leaq 0x32bc(%rip), %rsi      # 0xdc68
leaq 0x3659(%rip), %rcx      # 0xe00c
movl $0x4d0, %edx            # imm = 0x4D0
callq 0x10c0
leaq 0x3679(%rip), %rdi      # 0xe03d
leaq 0x329d(%rip), %rsi      # 0xdc68
leaq 0x363a(%rip), %rcx      # 0xe00c
movl $0x4d1, %edx            # imm = 0x4D1
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__csctx_rmove_to
static void stbtt__csctx_rmove_to(stbtt__csctx *ctx, float dx, float dy)
{
   stbtt__csctx_close_shape(ctx);
   ctx->first_x = ctx->x = ctx->x + dx;
   ctx->first_y = ctx->y = ctx->y + dy;
   stbtt__csctx_v(ctx, STBTT_vmove, (int)ctx->x, (int)ctx->y, 0, 0, 0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movss %xmm1, -0x10(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rdi, %rbx
callq 0xab09
movss -0xc(%rbp), %xmm0
addss 0x10(%rbx), %xmm0
movss %xmm0, 0x10(%rbx)
movss %xmm0, 0x8(%rbx)
movaps %xmm0, %xmm1
movss -0x10(%rbp), %xmm0
addss 0x14(%rbx), %xmm0
movss %xmm0, 0x14(%rbx)
movss %xmm0, 0xc(%rbx)
cvttss2si %xmm1, %edx
cvttss2si %xmm0, %ecx
andl $0x0, 0x8(%rsp)
andl $0x0, (%rsp)
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xac9e
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__csctx_rccurve_to
static void stbtt__csctx_rccurve_to(stbtt__csctx *ctx, float dx1, float dy1, float dx2, float dy2, float dx3, float dy3)
{
   float cx1 = ctx->x + dx1;
   float cy1 = ctx->y + dy1;
   float cx2 = cx1 + dx2;
   float cy2 = cy1 + dy2;
   ctx->x = cx2 + dx3;
   ctx->y = cy2 + dy3;
   stbtt__csctx_v(ctx, STBTT_vcubic, (int)ctx->x, (int)ctx->y, (int)cx1, (int)cy1, (int)cx2, (int)cy2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
addss 0x10(%rdi), %xmm0
addss 0x14(%rdi), %xmm1
addss %xmm0, %xmm2
addss %xmm1, %xmm3
addss %xmm2, %xmm4
movss %xmm4, 0x10(%rdi)
addss %xmm3, %xmm5
movss %xmm5, 0x14(%rdi)
cvttss2si %xmm4, %edx
cvttss2si %xmm5, %ecx
cvttss2si %xmm0, %r8d
cvttss2si %xmm1, %r9d
cvttss2si %xmm2, %eax
cvttss2si %xmm3, %r10d
pushq $0x4
popq %rsi
pushq %r10
pushq %rax
callq 0xac9e
popq %rax
popq %rcx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__buf_get
static stbtt_uint32 stbtt__buf_get(stbtt__buf *b, int n)
{
   stbtt_uint32 v = 0;
   int i;
   STBTT_assert(n >= 1 && n <= 4);
   for (i = 0; i < n; i++)
      v = (v << 8) | stbtt__buf_get8(b);
   return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
xorl %r14d, %r14d
testl %esi, %esi
cmovlel %r14d, %ebx
subl $0x1, %ebx
jb 0xab81
shll $0x8, %r14d
movq %r15, %rdi
callq 0xa9dc
movzbl %al, %eax
orl %eax, %r14d
jmp 0xab68
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__cff_int
static stbtt_uint32 stbtt__cff_int(stbtt__buf *b)
{
   int b0 = stbtt__buf_get8(b);
   if (b0 >= 32 && b0 <= 246)       return b0 - 139;
   else if (b0 >= 247 && b0 <= 250) return (b0 - 247)*256 + stbtt__buf_get8(b) + 108;
   else if (b0 >= 251 && b0 <= 254) return -(b0 - 251)*256 - stbtt__buf_get8(b) - 108;
   else if (b0 == 28)               return stbtt__buf_get16(b);
   else if (b0 == 29)               return stbtt__buf_get32(b);
   STBTT_assert(0);
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0xa9dc
movzbl %al, %ebx
leal -0x20(%rbx), %ecx
cmpb $-0x2a, %cl
ja 0xabb1
addl $0xffffff75, %ebx       # imm = 0xFFFFFF75
jmp 0xabf0
leal 0x9(%rax), %ecx
cmpb $0x3, %cl
ja 0xabd1
shll $0x8, %ebx
movq %r14, %rdi
callq 0xa9dc
movzbl %al, %eax
addl %eax, %ebx
addl $0xffff096c, %ebx       # imm = 0xFFFF096C
jmp 0xabf0
addb $0x5, %al
cmpb $0x3, %al
ja 0xabf7
movq %r14, %rdi
callq 0xa9dc
movzbl %al, %eax
shll $0x8, %ebx
orl %eax, %ebx
movl $0xfa94, %eax           # imm = 0xFA94
subl %ebx, %eax
movl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x1d, %ebx
je 0xac05
cmpl $0x1c, %ebx
jne 0xac14
pushq $0x2
jmp 0xac07
pushq $0x4
popq %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xab50
leaq 0x314b(%rip), %rdi      # 0xdd66
leaq 0x3046(%rip), %rsi      # 0xdc68
leaq 0x349f(%rip), %rcx      # 0xe0c8
movl $0x49a, %edx            # imm = 0x49A
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__csctx_v
static void stbtt__csctx_v(stbtt__csctx *c, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy, stbtt_int32 cx1, stbtt_int32 cy1)
{
   if (c->bounds) {
      stbtt__track_vertex(c, x, y);
      if (type == STBTT_vcubic) {
         stbtt__track_vertex(c, cx, cy);
         stbtt__track_vertex(c, cx1, cy1);
      }
   } else {
      stbtt_setvertex(&c->pvertices[c->num_vertices], type, x, y, cx, cy);
      c->pvertices[c->num_vertices].cx1 = (stbtt_int16) cx1;
      c->pvertices[c->num_vertices].cy1 = (stbtt_int16) cy1;
   }
   c->num_vertices++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r15d
movl %r8d, %r13d
movl %esi, %r14d
movq %rdi, %rbx
movl 0x18(%rbp), %edi
movl 0x10(%rbp), %r12d
cmpl $0x0, (%rbx)
je 0xacf4
movq %rbx, %rdi
movl %edx, %esi
movl %ecx, %edx
callq 0xad37
cmpb $0x4, %r14b
jne 0xad25
movq %rbx, %rdi
movl %r13d, %esi
movl %r15d, %edx
callq 0xad37
movq %rbx, %rdi
movl %r12d, %esi
movl 0x18(%rbp), %edx
callq 0xad37
jmp 0xad25
movq 0x28(%rbx), %rax
movslq 0x30(%rbx), %rsi
imulq $0xe, %rsi, %rsi
movb %r14b, 0xc(%rax,%rsi)
movw %dx, (%rax,%rsi)
movw %cx, 0x2(%rax,%rsi)
movw %r13w, 0x4(%rax,%rsi)
movw %r15w, 0x6(%rax,%rsi)
movw %r12w, 0x8(%rax,%rsi)
movw %di, 0xa(%rax,%rsi)
incl 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__track_vertex
static void stbtt__track_vertex(stbtt__csctx *c, stbtt_int32 x, stbtt_int32 y)
{
   if (x > c->max_x || !c->started) c->max_x = x;
   if (y > c->max_y || !c->started) c->max_y = y;
   if (x < c->min_x || !c->started) c->min_x = x;
   if (y < c->min_y || !c->started) c->min_y = y;
   c->started = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl %esi, 0x1c(%rdi)
jl 0xad46
cmpl $0x0, 0x4(%rdi)
jne 0xad49
movl %esi, 0x1c(%rdi)
cmpl %edx, 0x24(%rdi)
jl 0xad54
cmpl $0x0, 0x4(%rdi)
jne 0xad57
movl %edx, 0x24(%rdi)
cmpl %esi, 0x18(%rdi)
jg 0xad62
cmpl $0x0, 0x4(%rdi)
jne 0xad65
movl %esi, 0x18(%rdi)
cmpl %edx, 0x20(%rdi)
jg 0xad70
cmpl $0x0, 0x4(%rdi)
jne 0xad73
movl %edx, 0x20(%rdi)
movl $0x1, 0x4(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__get_subrs
static stbtt__buf stbtt__get_subrs(stbtt__buf cff, stbtt__buf fontdict)
{
   stbtt_uint32 subrsoff = 0, private_loc[2] = { 0, 0 };
   stbtt__buf pdict;
   stbtt__dict_get_ints(&fontdict, 18, 2, private_loc);
   if (!private_loc[1] || !private_loc[0]) return stbtt__new_buf(NULL, 0);
   pdict = stbtt__buf_range(&cff, private_loc[1], private_loc[0]);
   stbtt__dict_get_ints(&pdict, 19, 1, &subrsoff);
   if (!subrsoff) return stbtt__new_buf(NULL, 0);
   stbtt__buf_seek(&cff, private_loc[1]+subrsoff);
   return stbtt__cff_get_index(&cff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdx, (%rdi)
movq %rcx, 0x8(%rdi)
andl $0x0, -0x14(%rbp)
leaq -0x30(%rbp), %rbx
andq $0x0, (%rbx)
pushq $0x12
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rcx
callq 0xae2e
movl (%rbx), %edx
movl 0x4(%rbx), %ebx
testl %ebx, %ebx
setne %al
testl %edx, %edx
setne %sil
andb %al, %sil
xorl %eax, %eax
movl $0x0, %ecx
cmpb $0x1, %sil
jne 0xae22
leaq -0x28(%rbp), %rdi
movl %ebx, %esi
callq 0xac63
leaq -0x40(%rbp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
pushq $0x13
popq %rsi
pushq $0x1
popq %rdx
leaq -0x14(%rbp), %r14
movq %r14, %rcx
callq 0xae2e
movl (%r14), %esi
testl %esi, %esi
je 0xae1e
addl %ebx, %esi
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
callq 0xac33
movq %rbx, %rdi
callq 0xaf58
movq %rdx, %rcx
jmp 0xae22
xorl %eax, %eax
xorl %ecx, %ecx
movq %rcx, %rdx
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__dict_get_ints
static void stbtt__dict_get_ints(stbtt__buf *b, int key, int outcount, stbtt_uint32 *out)
{
   int i;
   stbtt__buf operands = stbtt__dict_get(b, key);
   for (i = 0; i < outcount && operands.cursor < operands.size; i++)
      out[i] = stbtt__cff_int(&operands);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, -0x2c(%rbp)
movl %esi, -0x30(%rbp)
movq %rdi, %r15
xorl %esi, %esi
callq 0xac33
pushq $0x1
popq %r14
movl 0x8(%r15), %r12d
movl 0xc(%r15), %eax
cmpl %eax, %r12d
jge 0xaf01
movl %r12d, %r13d
cmpl %eax, %r13d
jge 0xaec4
movq (%r15), %rax
movslq %r13d, %rcx
movb (%rax,%rcx), %al
cmpb $0x1c, %al
jb 0xaec4
movq %r15, %rdi
cmpb $0x1e, %al
jne 0xaeb5
movl %r14d, %esi
callq 0xa9fa
movl 0x8(%r15), %eax
cmpl 0xc(%r15), %eax
jge 0xaeba
movq %r15, %rdi
callq 0xa9dc
movzbl %al, %eax
movl %eax, %ecx
notl %ecx
testb $0xf, %cl
je 0xaeba
andl $-0x10, %eax
cmpl $0xf0, %eax
jne 0xae8b
jmp 0xaeba
callq 0xab8f
movl 0x8(%r15), %r13d
movl 0xc(%r15), %eax
jmp 0xae6a
movq %r15, %rdi
callq 0xa9dc
cmpb $0xc, %al
jne 0xaee2
movq %r15, %rdi
callq 0xa9dc
movzbl %al, %eax
orl $0x100, %eax            # imm = 0x100
jmp 0xaee5
movzbl %al, %eax
cmpl -0x30(%rbp), %eax
jne 0xae56
subl %r12d, %r13d
movq %r15, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0xac63
jmp 0xaf0e
testl %eax, %eax
js 0xaf0a
movq (%r15), %rax
jmp 0xaf0c
xorl %eax, %eax
xorl %edx, %edx
movl -0x2c(%rbp), %ecx
leaq -0x40(%rbp), %r14
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
movslq %ecx, %r15
movq %rdx, %rax
shrq $0x20, %rax
xorl %r12d, %r12d
cmpq %r15, %r12
jge 0xaf49
cmpl %eax, %edx
jge 0xaf49
movq %r14, %rdi
callq 0xab8f
movl %eax, (%rbx,%r12,4)
incq %r12
movl -0x38(%rbp), %edx
movl -0x34(%rbp), %eax
jmp 0xaf29
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__cff_get_index
static stbtt__buf stbtt__cff_get_index(stbtt__buf *b)
{
   int count, start, offsize;
   start = b->cursor;
   count = stbtt__buf_get16(b);
   if (count) {
      offsize = stbtt__buf_get8(b);
      STBTT_assert(offsize >= 1 && offsize <= 4);
      stbtt__buf_skip(b, offsize * count);
      stbtt__buf_skip(b, stbtt__buf_get(b, offsize) - 1);
   }
   return stbtt__buf_range(b, start, b->cursor - start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl 0x8(%rdi), %ebx
pushq $0x2
popq %rsi
callq 0xab50
testl %eax, %eax
je 0xafb1
movl %eax, %r15d
movq %r14, %rdi
callq 0xa9dc
leal -0x1(%rax), %ecx
cmpb $0x4, %cl
jae 0xafc9
movzbl %al, %r12d
imull %r12d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0xa9fa
movq %r14, %rdi
movl %r12d, %esi
callq 0xab50
leal -0x1(%rax), %esi
movq %r14, %rdi
callq 0xa9fa
movl 0x8(%r14), %edx
subl %ebx, %edx
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xac63
leaq 0x306d(%rip), %rdi      # 0xe03d
leaq 0x2c91(%rip), %rsi      # 0xdc68
leaq 0x30bc(%rip), %rcx      # 0xe09a
movl $0x48b, %edx            # imm = 0x48B
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__close_shape
static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off,
    stbtt_int32 sx, stbtt_int32 sy, stbtt_int32 scx, stbtt_int32 scy, stbtt_int32 cx, stbtt_int32 cy)
{
   if (start_off) {
      if (was_off)
         stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+scx)>>1, (cy+scy)>>1, cx,cy);
      stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, sx,sy,scx,scy);
   } else {
      if (was_off)
         stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve,sx,sy,cx,cy);
      else
         stbtt_setvertex(&vertices[num_vertices++], STBTT_vline,sx,sy,0,0);
   }
   return num_vertices;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %eax
movl 0x28(%rbp), %esi
movl 0x20(%rbp), %r11d
testl %ecx, %ecx
je 0xb056
movl 0x18(%rbp), %ecx
movl 0x10(%rbp), %ebx
testl %edx, %edx
je 0xb038
movslq %eax, %rdx
incl %eax
imulq $0xe, %rdx, %rdx
leal (%r11,%rbx), %r10d
shrl %r10d
leal (%rsi,%rcx), %r14d
shrl %r14d
movb $0x3, 0xc(%rdi,%rdx)
movw %r10w, (%rdi,%rdx)
movw %r14w, 0x2(%rdi,%rdx)
movw %r11w, 0x4(%rdi,%rdx)
movw %si, 0x6(%rdi,%rdx)
movslq %eax, %r10
imulq $0xe, %r10, %rdx
movb $0x3, 0xc(%rdi,%rdx)
movw %r8w, (%rdi,%rdx)
movw %r9w, 0x2(%rdi,%rdx)
movw %bx, 0x4(%rdi,%rdx)
jmp 0xb08e
movslq %eax, %r10
imulq $0xe, %r10, %rcx
addq %rdi, %rcx
testl %edx, %edx
je 0xb07a
movb $0x3, 0xc(%rcx)
movw %r8w, (%rcx)
movw %r9w, 0x2(%rcx)
movw %r11w, 0x4(%rcx)
movl %esi, %ecx
jmp 0xb08e
movb $0x2, 0xc(%rcx)
movw %r8w, (%rcx)
movw %r9w, 0x2(%rcx)
andw $0x0, 0x4(%rcx)
xorl %ecx, %ecx
imulq $0xe, %r10, %rdx
movw %cx, 0x6(%rdi,%rdx)
incl %eax
popq %rbx
popq %r14
popq %rbp
retq