LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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:
movl %esi, %eax
movzwl 0x4(%rdi,%rax), %ecx
rolw $0x8, %cx
xorl %eax, %eax
testw %cx, %cx
je 0x4e37
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movzwl %cx, %r8d
movsbl (%rdx), %ecx
movl %r8d, %r8d
addl $0xc, %esi
movl %esi, %esi
movzbl (%rdi,%rsi), %r11d
movb $0x1, %r10b
cmpl %ecx, %r11d
jne 0x4e23
movzbl 0x1(%rdi,%rsi), %r11d
movsbl 0x1(%rdx), %ebx
cmpl %ebx, %r11d
jne 0x4e23
movzbl 0x2(%rdi,%rsi), %r11d
movsbl 0x2(%rdx), %ebx
cmpl %ebx, %r11d
jne 0x4e23
movzbl 0x3(%rdi,%rsi), %r11d
movsbl 0x3(%rdx), %ebx
cmpl %ebx, %r11d
jne 0x4e23
movl 0x8(%rdi,%rsi), %r9d
bswapl %r9d
xorl %r10d, %r10d
testb %r10b, %r10b
je 0x4e32
addl $0x10, %esi
decq %r8
jne 0x4ddc
jmp 0x4e35
movl %r9d, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq 0x8(%rdi), %rax
movslq 0x1c(%rdi), %r9
movzbl 0x24(%rax,%r9), %r10d
shll $0x8, %r10d
movzbl 0x25(%rax,%r9), %r9d
movswl %r10w, %r10d
orl %r9d, %r10d
movl %r10d, (%rsi)
movslq 0x1c(%rdi), %rsi
movzbl 0x26(%rax,%rsi), %r9d
shll $0x8, %r9d
movzbl 0x27(%rax,%rsi), %esi
movswl %r9w, %r9d
orl %esi, %r9d
movl %r9d, (%rdx)
movslq 0x1c(%rdi), %rdx
movzbl 0x28(%rax,%rdx), %esi
shll $0x8, %esi
movzbl 0x29(%rax,%rdx), %edx
movswl %si, %esi
orl %edx, %esi
movl %esi, (%rcx)
movslq 0x1c(%rdi), %rcx
movzbl 0x2a(%rax,%rcx), %edx
shll $0x8, %edx
movzbl 0x2b(%rax,%rcx), %eax
movswl %dx, %ecx
orl %eax, %ecx
movl %ecx, (%r8)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movss %xmm3, -0x30(%rbp)
movss %xmm2, -0x28(%rbp)
movss %xmm1, -0x2c(%rbp)
movss %xmm0, -0x24(%rbp)
xorl %eax, %eax
leaq -0x40(%rbp), %rdx
movl %eax, (%rdx)
leaq -0x3c(%rbp), %rcx
movl %eax, (%rcx)
leaq -0x38(%rbp), %r8
leaq -0x34(%rbp), %r9
callq 0x42d4
testl %eax, %eax
je 0x4fff
testq %r12, %r12
je 0x4f8f
xorps %xmm0, %xmm0
cvtsi2ssl -0x40(%rbp), %xmm0
mulss -0x24(%rbp), %xmm0
addss -0x28(%rbp), %xmm0
callq 0x11d0
cvttss2si %xmm0, %eax
movl %eax, (%r12)
testq %r15, %r15
je 0x4fb6
xorl %eax, %eax
subl -0x34(%rbp), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss -0x2c(%rbp), %xmm0
addss -0x30(%rbp), %xmm0
callq 0x11d0
cvttss2si %xmm0, %eax
movl %eax, (%r15)
testq %r14, %r14
je 0x4fd9
xorps %xmm0, %xmm0
cvtsi2ssl -0x38(%rbp), %xmm0
mulss -0x24(%rbp), %xmm0
addss -0x28(%rbp), %xmm0
callq 0x1110
cvttss2si %xmm0, %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0x502d
xorl %eax, %eax
subl -0x3c(%rbp), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss -0x2c(%rbp), %xmm0
addss -0x30(%rbp), %xmm0
callq 0x1110
cvttss2si %xmm0, %eax
jmp 0x502b
testq %r12, %r12
je 0x500c
movl $0x0, (%r12)
testq %r15, %r15
je 0x5018
movl $0x0, (%r15)
testq %r14, %r14
je 0x5024
movl $0x0, (%r14)
xorl %eax, %eax
testq %rbx, %rbx
je 0x502d
movl %eax, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %r13d
movss %xmm3, -0x38(%rbp)
movss %xmm2, -0x34(%rbp)
movss %xmm1, -0x30(%rbp)
movss %xmm0, -0x2c(%rbp)
movl %r8d, -0x40(%rbp)
movl %ecx, %r14d
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x50(%rbp), %rdx
movl %r9d, %esi
callq 0x38d3
movl %eax, -0x3c(%rbp)
leaq -0x48(%rbp), %rdx
leaq -0x44(%rbp), %rcx
movq %r15, %rdi
movl %r13d, %esi
movss -0x2c(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
movss -0x34(%rbp), %xmm2
movss -0x38(%rbp), %xmm3
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x4f19
movq %rbx, -0x58(%rbp)
movl %r12d, -0x68(%rbp)
movl %r14d, -0x64(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x60(%rbp)
testl %r12d, %r12d
sete %al
testl %r14d, %r14d
sete %cl
orb %al, %cl
jne 0x647c
movq -0x50(%rbp), %rsi
movl -0x48(%rbp), %ecx
movl -0x44(%rbp), %r8d
leaq -0x68(%rbp), %rdi
movss 0x866e(%rip), %xmm0     # 0xeac8
movl -0x3c(%rbp), %edx
movss -0x2c(%rbp), %xmm1
movss -0x30(%rbp), %xmm2
movss -0x34(%rbp), %xmm3
movss -0x38(%rbp), %xmm4
movl $0x1, %r9d
callq 0x511b
movq -0x50(%rbp), %rdi
callq 0x1030
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r14d
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r13d
movq %rsi, %rbx
movl 0x28(%rbp), %r9d
subl %r14d, %edx
incl %edx
subl 0x10(%rbp), %ecx
incl %ecx
callq 0x63ad
cmpl $0x2, %r14d
jl 0x65ed
movq %rbx, %rdi
movl %r13d, %esi
movl %r12d, %edx
movl %r15d, %ecx
movl %r14d, %r8d
callq 0x6c8b
movl 0x10(%rbp), %edx
cmpl $0x2, %edx
jl 0x660d
movq %rbx, %rdi
movl %r13d, %esi
movl %r12d, %edx
movl %r15d, %ecx
movl 0x10(%rbp), %r8d
callq 0x6ee0
movl 0x10(%rbp), %edx
movq 0x18(%rbp), %rax
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
testl %r14d, %r14d
je 0x663b
movl $0x1, %ecx
subl %r14d, %ecx
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
xorps %xmm2, %xmm2
cvtsi2ss %r14d, %xmm2
addss %xmm2, %xmm2
divss %xmm2, %xmm1
movq 0x20(%rbp), %rcx
movss %xmm1, (%rax)
testl %edx, %edx
je 0x6664
movl $0x1, %eax
subl %edx, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
xorps %xmm1, %xmm1
cvtsi2ss %edx, %xmm1
addss %xmm1, %xmm1
divss %xmm1, %xmm0
movss %xmm0, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x67da
xorps %xmm0, %xmm0
jmp 0x67e2
movss 0x82da(%rip), %xmm0     # 0xeabc
movss %xmm0, -0x2c(%rbp)
xorps %xmm0, %xmm0
cvtsi2ss %esi, %xmm0
movss 0x8296(%rip), %xmm1     # 0xea8c
movaps %xmm1, %xmm2
divss %xmm0, %xmm2
movss %xmm2, -0x30(%rbp)
xorps %xmm0, %xmm0
cvtsi2ss %edx, %xmm0
divss %xmm0, %xmm1
movss %xmm1, -0x34(%rbp)
movslq %ecx, %rax
leaq (%rax,%rax,4), %r13
movss (%rbx), %xmm0
addss 0x8(%r14,%r13,4), %xmm0
addss 0x827c(%rip), %xmm0     # 0xeaa8
callq 0x11d0
movaps %xmm0, -0x50(%rbp)
cvttss2si %xmm0, %r15d
movq -0x40(%rbp), %rax
movss (%rax), %xmm0
addss 0xc(%r14,%r13,4), %xmm0
addss 0x8257(%rip), %xmm0     # 0xeaa8
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,4), %ecx
addl %ecx, %r15d
movzwl (%r14,%r13,4), %edx
subl %edx, %r15d
xorps %xmm0, %xmm0
cvtsi2ss %r15d, %xmm0
addss %xmm2, %xmm0
movss %xmm0, 0x10(%r12)
movzwl 0x6(%r14,%r13,4), %esi
addl %esi, %eax
movzwl 0x2(%r14,%r13,4), %edi
subl %edi, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
addss %xmm2, %xmm0
movss %xmm0, 0x14(%r12)
xorps %xmm0, %xmm0
cvtsi2ss %edx, %xmm0
movss -0x30(%rbp), %xmm3
mulss %xmm3, %xmm0
movss %xmm0, 0x8(%r12)
xorps %xmm0, %xmm0
cvtsi2ss %edi, %xmm0
movss -0x34(%rbp), %xmm2
mulss %xmm2, %xmm0
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
movss %xmm0, 0xc(%r12)
xorps %xmm0, %xmm0
cvtsi2ss %esi, %xmm0
mulss %xmm3, %xmm1
movss %xmm1, 0x18(%r12)
mulss %xmm2, %xmm0
movss %xmm0, 0x1c(%r12)
movss 0x10(%r14,%r13,4), %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_O1/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, %r13d
movl %r8d, %ebx
movl %ecx, -0x34(%rbp)
movl %edx, %r15d
movq %rsi, -0x40(%rbp)
movq %rdi, %r14
movl $0x14, %edi
callq 0x1170
movq %rax, %r12
movl %r15d, -0x30(%rbp)
movl %r13d, -0x2c(%rbp)
subl %r13d, %r15d
movslq %r15d, %rdi
callq 0x1170
movq %rax, %r13
testq %r12, %r12
setne %al
testq %r13, %r13
setne %cl
testb %cl, %al
jne 0x69b5
testq %r12, %r12
je 0x699d
movq %r12, %rdi
callq 0x1030
xorl %ebx, %ebx
testq %r13, %r13
je 0x6a36
movq %r13, %rdi
callq 0x1030
jmp 0x6a36
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 %r12, 0x8(%r14)
movq %r13, 0x38(%r14)
movl -0x2c(%rbp), %esi
movl %esi, 0x1c(%r14)
testl %ebx, %ebx
cmovel %edx, %ebx
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, (%r12)
movl %eax, 0x4(%r12)
movq $0x0, 0x8(%r12)
movl $0x0, 0x10(%r12)
movl $0x1, %ebx
testq %rdi, %rdi
je 0x6a36
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_O1/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 0x6a7e
cmpl $0x9, %edx
jae 0x6a9d
movl %esi, 0x24(%rdi)
movl %edx, 0x28(%rdi)
popq %rbp
retq
leaq 0x8267(%rip), %rdi      # 0xecec
leaq 0x81dc(%rip), %rsi      # 0xec68
leaq 0x826b(%rip), %rcx      # 0xecfe
movl $0xee8, %edx            # imm = 0xEE8
callq 0x10c0
leaq 0x82ab(%rip), %rdi      # 0xed4f
leaq 0x81bd(%rip), %rsi      # 0xec68
leaq 0x824c(%rip), %rcx      # 0xecfe
movl $0xee9, %edx            # imm = 0xEE9
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O1/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 $0xb8, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movl %edx, -0x2c(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdi, %r15
movl %r8d, %eax
testl %r8d, %r8d
jle 0x76cc
xorl %ecx, %ecx
leaq (%rcx,%rcx,4), %rdx
movslq 0x10(%r14,%rdx,8), %rdi
testq %rdi, %rdi
jle 0x76c4
leaq (%r14,%rdx,8), %rdx
movq 0x18(%rdx), %rdx
leaq (%rdi,%rdi,8), %rsi
leaq (%rsi,%rsi,2), %rsi
addq %rdi, %rsi
xorl %edi, %edi
movq $0x0, (%rdx,%rdi)
addq $0x1c, %rdi
cmpq %rdi, %rsi
jne 0x76b3
incq %rcx
cmpq %rax, %rcx
jne 0x7690
xorl %r13d, %r13d
testl %ebx, %ebx
jle 0x76fd
shlq $0x3, %rax
leaq (%rax,%rax,4), %rax
xorl %edx, %edx
xorl %ecx, %ecx
movslq 0x10(%r14,%rdx), %rsi
movslq %ecx, %rcx
addq %rsi, %rcx
addq $0x28, %rdx
cmpq %rdx, %rax
jne 0x76df
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rdi
jmp 0x76ff
xorl %edi, %edi
callq 0x1170
testq %rax, %rax
je 0x7781
movq %rax, %r12
movq (%r15), %rax
leaq -0xd8(%rbp), %rcx
movq %rax, (%rcx)
movq %r15, %r13
movq -0x38(%rbp), %r15
movq %r15, %rdi
movl -0x2c(%rbp), %esi
callq 0x7bb8
leaq -0xd8(%rbp), %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x7796
movq %r13, %rdi
leaq -0xd8(%rbp), %r15
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
movq %r12, %r8
callq 0x6ac5
movq %r13, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x75b3
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
movq %r12, %r8
callq 0x717b
movl %eax, %r13d
movq %r12, %rdi
callq 0x1030
movl %r13d, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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)
movq $0x0, 0x8(%rax)
movl %r8d, 0x10(%rax)
movq %r9, 0x18(%rax)
movss %xmm0, (%rax)
movq %rax, %rcx
movl $0x1, %r8d
callq 0x7662
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0xb0, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movaps %xmm0, -0x30(%rbp)
movq %rdi, %r12
callq 0x7bb8
leaq -0xd0(%rbp), %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x7796
movaps -0x30(%rbp), %xmm2
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm2
jbe 0x7cdc
movq -0xc8(%rbp), %rax
movslq -0xac(%rbp), %rcx
movzbl 0x4(%rax,%rcx), %edx
shll $0x8, %edx
movzbl 0x5(%rax,%rcx), %esi
movswl %dx, %edx
orl %esi, %edx
movzbl 0x6(%rax,%rcx), %esi
shll $0x8, %esi
movzbl 0x7(%rax,%rcx), %eax
movswl %si, %ecx
orl %eax, %ecx
subl %ecx, %edx
xorps %xmm0, %xmm0
cvtsi2ss %edx, %xmm0
jmp 0x7d04
xorps 0x6e4d(%rip), %xmm2     # 0xeb30
movq -0xc8(%rbp), %rax
movslq -0xb4(%rbp), %rcx
movzwl 0x12(%rax,%rcx), %eax
rolw $0x8, %ax
movzwl %ax, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss %xmm0, %xmm2
movq -0xc8(%rbp), %rax
movslq -0xac(%rbp), %rcx
movzwl 0x4(%rax,%rcx), %edx
rolw $0x8, %dx
movzwl 0x6(%rax,%rcx), %esi
rolw $0x8, %si
movzwl 0x8(%rax,%rcx), %eax
movswl %dx, %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
rolw $0x8, %ax
mulss %xmm2, %xmm0
movss %xmm0, (%r15)
movswl %si, %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
cwtl
cvtsi2ss %eax, %xmm1
mulss %xmm2, %xmm0
movss %xmm0, (%r14)
mulss %xmm2, %xmm1
movss %xmm1, (%rbx)
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq (%rax,%rax,8), %rcx
leaq (%rcx,%rcx,2), %rcx
addq %rax, %rcx
cmpl $0x0, 0x18(%rbp)
leaq (%rdi,%rcx), %r14
movss 0x8(%rdi,%rcx), %xmm1
movss (%r8), %xmm0
addss %xmm1, %xmm0
je 0x7e33
addss 0x6ce7(%rip), %xmm0     # 0xeaa8
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 0x6cb2(%rip), %xmm0     # 0xeaa8
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 0x7e67
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)
xorps %xmm0, %xmm0
cvtsi2ss %r15d, %xmm0
movss 0x6c0f(%rip), %xmm1     # 0xea8c
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
xorps %xmm2, %xmm2
cvtsi2ss %eax, %xmm2
divss %xmm0, %xmm4
mulss %xmm4, %xmm2
movss %xmm2, 0xc(%r13)
movzwl 0x4(%r14), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss %xmm1, %xmm0
movss %xmm0, 0x18(%r13)
movzwl 0x6(%r14), %eax
xorps %xmm0, %xmm0
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_O1/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, -0x2c(%rbp)
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %rbx
movq 0x8(%rdi), %r13
movl 0x10(%rdi), %esi
leaq 0x5820(%rip), %rdx      # 0xede4
movq %r13, %rdi
callq 0x4db8
testl %eax, %eax
je 0x9690
movl %eax, %ecx
movzwl 0x2(%r13,%rcx), %edx
rolw $0x8, %dx
testw %dx, %dx
je 0x9690
movzwl %dx, %esi
movzwl 0x4(%r13,%rcx), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
addl %eax, %ecx
addl $0x6, %eax
movslq %ecx, %rdx
addq %r13, %rdx
movl %esi, %esi
movl -0x2c(%rbp), %r9d
movl %eax, %eax
movzwl (%r13,%rax), %edi
rolw $0x8, %di
movzwl %di, %r8d
movb $0x1, %dil
cmpl %r12d, %r8d
jne 0x967f
movzwl 0x2(%r13,%rax), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r8d
cmpl %r15d, %r8d
jne 0x967f
movzwl 0x4(%r13,%rax), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r8d
cmpl %r14d, %r8d
jne 0x967f
movzwl 0x6(%r13,%rax), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r8d
cmpl %r9d, %r8d
jne 0x967f
movzwl 0x8(%r13,%rax), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
movl %ecx, (%rbx)
movzwl 0xa(%r13,%rax), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
addq %rdx, %rcx
xorl %edi, %edi
testb %dil, %dil
je 0x9692
addl $0xc, %eax
decq %rsi
jne 0x960a
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa0bd
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
movl %ecx, -0x2c(%rbp)
orl %ecx, %eax
js 0xa1e5
movl %r9d, %r14d
movl %r8d, %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 0xa1f9
movl $0x0, -0x40(%rbp)
testl %r15d, %r15d
jle 0xa1de
movl 0x8019(%rip), %eax      # 0x12130
leal -0x1(%r15), %ecx
xorl %esi, %esi
xorl %edx, %edx
testl %eax, %eax
setne %dl
cmovnel %esi, %ecx
leaq -0x1(,%rdx,2), %rdx
cmpl $0x1, %eax
sbbl %esi, %esi
orl %r15d, %esi
movl %esi, -0x3c(%rbp)
movslq %r14d, %r15
movslq %ecx, %rax
movslq -0x2c(%rbp), %rcx
movl %ecx, %esi
movq %rsi, -0x48(%rbp)
imulq %r15, %rcx
movq %rax, %rsi
imulq %rcx, %rsi
addq 0x18(%rbp), %rsi
movq %rsi, -0x38(%rbp)
movq %rdx, -0x58(%rbp)
imulq %rdx, %rcx
movq %rcx, -0x50(%rbp)
movq %r15, -0x68(%rbp)
movq %rax, -0x60(%rbp)
cmpl $0x0, -0x2c(%rbp)
movl 0x20(%rbp), %eax
movl 0x10(%rbp), %r13d
movq %rbx, %r14
jle 0xa1b4
movq -0x38(%rbp), %rbx
movq -0x48(%rbp), %r12
movq %r14, %rdi
movl %r15d, %esi
movq %r14, %r15
movl %eax, %r14d
movl %eax, %edx
movl %r13d, %ecx
movq %rbx, %r8
callq 0xa32c
movl %r14d, %eax
movq %r15, %r14
movq -0x68(%rbp), %r15
addq %r15, %rbx
decq %r12
jne 0xa189
movq 0x8(%r14), %rdi
leaq -0x40(%rbp), %rsi
movl 0x28(%rbp), %edx
callq *(%r14)
movq -0x60(%rbp), %rax
addq -0x58(%rbp), %rax
movq -0x38(%rbp), %rcx
addq -0x50(%rbp), %rcx
movq %rcx, -0x38(%rbp)
cmpl %eax, -0x3c(%rbp)
movq %r14, %rbx
jne 0xa16d
movl $0x1, %eax
jmp 0xa1e7
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_O1/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
movb (%rsi), %al
testb %al, %al
je 0xa2fe
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
incq %r14
leaq -0x2b(%rbp), %r13
leaq -0x2f(%rbp), %r12
movzbl %al, %eax
cmpl $0x31, %eax
jg 0xa255
cmpl $0x20, %eax
je 0xa2f0
cmpl $0x31, %eax
jne 0xa30d
movl (%rbx), %ecx
cmpq $0x28, %rcx
ja 0xa2b0
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0xa2bc
cmpl $0x32, %eax
je 0xa279
cmpl $0x34, %eax
jne 0xa30d
movl (%rbx), %ecx
cmpq $0x28, %rcx
ja 0xa2d0
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0xa2dc
movl (%rbx), %ecx
cmpq $0x28, %rcx
ja 0xa28f
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0xa29b
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movzwl (%rax), %eax
movw %ax, -0x2b(%rbp)
movq 0x8(%r15), %rdi
movq %r13, %rsi
movl $0x2, %edx
jmp 0xa2ed
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movb (%rax), %al
movb %al, -0x29(%rbp)
movq 0x8(%r15), %rdi
leaq -0x29(%rbp), %rsi
movl $0x1, %edx
jmp 0xa2ed
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movl (%rax), %eax
movl %eax, -0x2f(%rbp)
movq 0x8(%r15), %rdi
movq %r12, %rsi
movl $0x4, %edx
callq *(%r15)
movb (%r14), %al
incq %r14
testb %al, %al
jne 0xa225
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4a52(%rip), %rdi      # 0xed66
leaq 0x4887(%rip), %rsi      # 0xeba2
leaq 0x4bd6(%rip), %rcx      # 0xeef8
movl $0x171, %edx            # imm = 0x171
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O1/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 0xa37a
cmpl $0x3, %r15d
je 0xa361
cmpl $0x4, %r15d
jne 0xa398
testl %r12d, %r12d
je 0xa3cd
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 0xa38d
testl %ecx, %ecx
je 0xa3bf
movb (%r14), %al
leaq -0x26(%rbp), %rsi
movb %al, (%rsi)
movb %al, 0x1(%rsi)
movb %al, 0x2(%rsi)
movq 0x8(%rbx), %rdi
movl $0x3, %edx
callq *(%rbx)
testl %r12d, %r12d
jle 0xa3b2
movq 0x8(%rbx), %rdi
movslq %r15d, %rax
leaq (%r14,%rax), %rsi
decq %rsi
movl $0x1, %edx
callq *(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x1, %edx
jmp 0xa396
movzbl 0x3(%r14), %eax
xorl %ecx, %ecx
leaq 0x2e19(%rip), %rdx      # 0xd1f4
movzbl (%rcx,%rdx), %esi
movzbl (%r14,%rcx), %edi
subl %esi, %edi
imull %eax, %edi
movslq %edi, %rdi
imulq $-0x7f7f7f7f, %rdi, %r8 # imm = 0x80808081
shrq $0x20, %r8
addl %r8d, %edi
movl %edi, %r8d
shrl $0x1f, %r8d
shrl $0x7, %edi
addl %r8d, %edi
addb %sil, %dil
movb %dil, -0x23(%rbp,%rcx)
incq %rcx
cmpq $0x3, %rcx
jne 0xa3db
movb -0x21(%rbp), %al
movb -0x23(%rbp), %cl
movb -0x22(%rbp), %dl
leaq -0x29(%rbp), %rsi
jmp 0xa370
// File: /workspace/github_c_makefile_star2_O1/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 0x4618(%rip), %xmm0     # 0xeb08
ucomiss %xmm2, %xmm0
jbe 0xa4fd
movl $0x0, (%rbx)
jmp 0xa563
movq %rsi, %r14
xorps %xmm0, %xmm0
cvtss2sd %xmm2, %xmm0
leaq -0x24(%rbp), %r15
movq %r15, %rdi
movss %xmm1, -0x20(%rbp)
movss %xmm2, -0x1c(%rbp)
callq 0x1120
cvtsd2ss %xmm0, %xmm0
mulss 0x45e3(%rip), %xmm0     # 0xeb0c
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, %eax
movb %al, 0x2(%rbx)
movb (%r15), %al
addb $-0x80, %al
movb %al, 0x3(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x8, %r14d
jl 0xa92c
movq %rdi, %r15
leaq -0x29(%rbp), %r12
leaq -0x2a(%rbp), %r13
movl %ebx, %eax
shrl $0x10, %eax
movb %al, -0x29(%rbp)
movq 0x8(%r15), %rdi
movq %r12, %rsi
movl $0x1, %edx
callq *(%r15)
movl %ebx, %eax
notl %eax
testl $0xff0000, %eax         # imm = 0xFF0000
jne 0xa91a
movb $0x0, -0x2a(%rbp)
movq 0x8(%r15), %rdi
movq %r13, %rsi
movl $0x1, %edx
callq *(%r15)
shll $0x8, %ebx
leal -0x8(%r14), %eax
cmpl $0xf, %r14d
movl %eax, %r14d
jg 0xa8e5
jmp 0xa92f
movl %r14d, %eax
movq -0x38(%rbp), %rcx
movl %ebx, (%rcx)
movq -0x40(%rbp), %rcx
movl %eax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4133(%rip), %xmm9     # 0xeb10
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 0x4107(%rip), %xmm8     # 0xeb14
mulss 0x4103(%rip), %xmm3     # 0xeb18
mulss 0x40ff(%rip), %xmm0     # 0xeb1c
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_O1/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 %rbx
pushq %rax
testq %rsi, %rsi
js 0xb92a
shrq $0x20, %rsi
xorl %ecx, %ecx
movl $0x2, %r8d
xorl %eax, %eax
cmpl %esi, %ecx
jge 0xb843
movslq %ecx, %r9
incl %ecx
movzbl (%rdi,%r9), %r9d
jmp 0xb846
xorl %r9d, %r9d
shll $0x8, %eax
orl %r9d, %eax
decl %r8d
jne 0xb833
cmpl %esi, %ecx
jge 0xb860
movslq %ecx, %r8
incl %ecx
movb (%rdi,%r8), %r10b
jmp 0xb863
xorl %r10d, %r10d
testl %edx, %edx
js 0xb949
cmpl %edx, %eax
jle 0xb949
leal -0x1(%r10), %r8d
cmpb $0x4, %r8b
jae 0xb968
movzbl %r10b, %r8d
imull %r8d, %edx
addl %ecx, %edx
cmpl %esi, %edx
ja 0xb92a
xorl %ecx, %ecx
xorl %r9d, %r9d
testb %r10b, %r10b
je 0xb8bd
movl %r8d, %r11d
cmpl %esi, %edx
jge 0xb8af
movslq %edx, %rbx
incl %edx
movzbl (%rdi,%rbx), %ebx
jmp 0xb8b1
xorl %ebx, %ebx
shll $0x8, %r9d
orl %ebx, %r9d
decl %r11d
jne 0xb8a0
testb %r10b, %r10b
je 0xb8e5
xorl %ecx, %ecx
movl %r8d, %r10d
cmpl %esi, %edx
jge 0xb8d7
movslq %edx, %r11
incl %edx
movzbl (%rdi,%r11), %r11d
jmp 0xb8da
xorl %r11d, %r11d
shll $0x8, %ecx
orl %r11d, %ecx
decl %r10d
jne 0xb8c7
incl %eax
imull %r8d, %eax
leal (%rax,%r9), %r8d
addl $0x2, %r8d
subl %r9d, %ecx
movl %ecx, %eax
orl %r8d, %eax
js 0xb91f
xorl %eax, %eax
subl %r8d, %esi
jl 0xb921
movl $0x0, %edx
cmpl %ecx, %esi
jl 0xb923
movl %r8d, %eax
addq %rax, %rdi
shlq $0x20, %rcx
movq %rdi, %rax
movq %rcx, %rdx
jmp 0xb923
xorl %eax, %eax
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3729(%rip), %rdi      # 0xf05a
leaq 0x3330(%rip), %rsi      # 0xec68
leaq 0x3733(%rip), %rcx      # 0xf072
movl $0x45b, %edx            # imm = 0x45B
callq 0x10c0
leaq 0x36a8(%rip), %rdi      # 0xeff8
leaq 0x3311(%rip), %rsi      # 0xec68
leaq 0x36ae(%rip), %rcx      # 0xf00c
movl $0x4d0, %edx            # imm = 0x4D0
callq 0x10c0
leaq 0x36ce(%rip), %rdi      # 0xf03d
leaq 0x32f2(%rip), %rsi      # 0xec68
leaq 0x368f(%rip), %rcx      # 0xf00c
movl $0x4d1, %edx            # imm = 0x4D1
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movss %xmm1, -0x10(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rdi, %rbx
callq 0xba77
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
xorl %eax, %eax
movq %rbx, %rdi
movl $0x1, %esi
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
callq 0xbbd2
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x4, %esi
pushq %r10
pushq %rax
callq 0xbbd2
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movslq 0x8(%rdi), %rax
movl 0xc(%rdi), %ecx
cmpl %ecx, %eax
jge 0xbad5
movq (%rdi), %rdx
leal 0x1(%rax), %esi
movl %esi, 0x8(%rdi)
movb (%rdx,%rax), %al
jmp 0xbad7
xorl %eax, %eax
movzbl %al, %edx
leal -0x20(%rdx), %esi
cmpb $-0x2a, %sil
ja 0xbaf0
addl $0xffffff75, %edx       # imm = 0xFFFFFF75
movl %edx, %eax
jmp 0xbbb1
leal 0x9(%rax), %esi
cmpb $0x3, %sil
ja 0xbb20
shll $0x8, %edx
movslq 0x8(%rdi), %rax
xorl %esi, %esi
cmpl %ecx, %eax
jge 0xbb13
movq (%rdi), %rcx
leal 0x1(%rax), %esi
movl %esi, 0x8(%rdi)
movzbl (%rcx,%rax), %esi
leal (%rdx,%rsi), %eax
addl $0xffff096c, %eax       # imm = 0xFFFF096C
jmp 0xbbb1
addb $0x5, %al
cmpb $0x3, %al
ja 0xbb4b
movslq 0x8(%rdi), %rax
xorl %esi, %esi
cmpl %ecx, %eax
jge 0xbb3d
movq (%rdi), %rcx
leal 0x1(%rax), %esi
movl %esi, 0x8(%rdi)
movzbl (%rcx,%rax), %esi
shll $0x8, %edx
orl %esi, %edx
movl $0xfa94, %eax           # imm = 0xFA94
subl %edx, %eax
jmp 0xbbb1
cmpl $0x1d, %edx
je 0xbb84
cmpl $0x1c, %edx
jne 0xbbb3
movl 0x8(%rdi), %esi
xorl %eax, %eax
movl $0x2, %edx
cmpl %ecx, %esi
jge 0xbb75
movq (%rdi), %r8
movslq %esi, %r9
incl %esi
movl %esi, 0x8(%rdi)
movzbl (%r8,%r9), %r8d
jmp 0xbb78
xorl %r8d, %r8d
shll $0x8, %eax
orl %r8d, %eax
decl %edx
jne 0xbb5f
jmp 0xbbb1
movl 0x8(%rdi), %esi
xorl %eax, %eax
movl $0x4, %edx
cmpl %ecx, %esi
jge 0xbba4
movq (%rdi), %r8
movslq %esi, %r9
incl %esi
movl %esi, 0x8(%rdi)
movzbl (%r8,%r9), %r8d
jmp 0xbba7
xorl %r8d, %r8d
shll $0x8, %eax
orl %r8d, %eax
decl %edx
jne 0xbb8e
popq %rbp
retq
leaq 0x31ac(%rip), %rdi      # 0xed66
leaq 0x30a7(%rip), %rsi      # 0xec68
leaq 0x3534(%rip), %rcx      # 0xf0fc
movl $0x49a, %edx            # imm = 0x49A
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O1/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), %r8d
movl 0x10(%rbp), %r12d
cmpl $0x0, (%rdi)
je 0xbc29
movq %rbx, %rdi
movl %edx, %esi
movl %ecx, %edx
callq 0xbc74
cmpb $0x4, %r14b
jne 0xbc62
movq %rbx, %rdi
movl %r13d, %esi
movl %r15d, %edx
callq 0xbc74
movq %rbx, %rdi
movl %r12d, %esi
movl 0x18(%rbp), %edx
callq 0xbc74
jmp 0xbc62
movq 0x28(%rbx), %rax
movslq 0x30(%rbx), %rsi
leaq (%rsi,%rsi), %rdi
shlq $0x4, %rsi
subq %rdi, %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 %r8w, 0xa(%rax,%rsi)
incl 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq