LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbiw__write_pixels
static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad, int expand_mono)
{
   stbiw_uint32 zero = 0;
   int i,j, j_end;

   if (y <= 0)
      return;

   if (stbi__flip_vertically_on_write)
      vdir *= -1;

   if (vdir < 0) {
      j_end = -1; j = y-1;
   } else {
      j_end =  y; j = 0;
   }

   for (; j != j_end; j += vdir) {
      for (i=0; i < x; ++i) {
         unsigned char *d = (unsigned char *) data + (j*x+i)*comp;
         stbiw__write_pixel(s, rgb_dir, comp, write_alpha, expand_mono, d);
      }
      s->func(s->context, &zero, scanline_pad);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x0, -0x18(%rbp)
jg 0xd85c
jmp 0xd90e
cmpl $0x0, 0xddc1(%rip)      # 0x1b624
je 0xd86c
imull $-0x1, -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0xd884
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xd891
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
jmp 0xd893
movl -0x28(%rbp), %eax
cmpl -0x2c(%rbp), %eax
je 0xd90e
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xd8eb
movq 0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
imull -0x14(%rbp), %ecx
addl -0x24(%rbp), %ecx
imull -0x1c(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %edx
movl 0x18(%rbp), %ecx
movl 0x28(%rbp), %r8d
movq -0x38(%rbp), %r9
callq 0xd920
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd8a2
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl 0x20(%rbp), %edx
leaq -0x20(%rbp), %rsi
callq *%rax
movl -0x10(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0xd893
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x10(%rbp), %rax
ucomiss 0x8(%rax), %xmm0
jbe 0xe050
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x24(%rbp)
jmp 0xe05e
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x20(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0xe07c
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x28(%rbp)
jmp 0xe0b7
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x10(%rbp), %rax
ucomiss 0x8(%rax), %xmm0
jbe 0xe09f
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
jmp 0xe0ad
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movss 0x858f(%rip), %xmm0     # 0x16658
ucomiss -0x18(%rbp), %xmm0
jbe 0xe0f3
movq -0x8(%rbp), %rax
movb $0x0, 0x3(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x2(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
jmp 0xe18f
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq -0x14(%rbp), %rdi
callq 0x1100
cvtsd2ss %xmm0, %xmm0
movss 0x854b(%rip), %xmm1     # 0x1665c
mulss %xmm1, %xmm0
movss -0x18(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movss -0x1c(%rbp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movss -0x1c(%rbp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movss -0x1c(%rbp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x14(%rbp), %eax
addl $0x80, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbiw__write_dump_data
static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data)
{
   unsigned char lengthbyte = STBIW_UCHAR(length);
   STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code
   s->func(s->context, &lengthbyte, 1);
   s->func(s->context, data, length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, -0x19(%rbp)
cmpl $0x80, -0xc(%rbp)
jg 0xe1c9
jmp 0xe1e8
leaq 0x8a4b(%rip), %rdi      # 0x16c1b
leaq 0x850b(%rip), %rsi      # 0x166e2
movl $0x275, %edx            # imm = 0x275
leaq 0x8a46(%rip), %rcx      # 0x16c29
callq 0x10a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
callq *%rax
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbiw__write_run_data
static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte)
{
   unsigned char lengthbyte = STBIW_UCHAR(length+128);
   STBIW_ASSERT(length+128 <= 255);
   s->func(s->context, &lengthbyte, 1);
   s->func(s->context, &databyte, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %eax
addl $0x80, %eax
andl $0xff, %eax
movb %al, -0xe(%rbp)
movl -0xc(%rbp), %eax
addl $0x80, %eax
cmpl $0xff, %eax
jg 0xe255
jmp 0xe274
leaq 0x8a16(%rip), %rdi      # 0x16c72
leaq 0x847f(%rip), %rsi      # 0x166e2
movl $0x26d, %edx            # imm = 0x26D
leaq 0x8a15(%rip), %rcx      # 0x16c84
callq 0x10a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
leaq -0xe(%rbp), %rsi
movl $0x1, %edx
callq *%rax
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
leaq -0xd(%rbp), %rsi
movl $0x1, %edx
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbiw__paeth
static unsigned char stbiw__paeth(int a, int b, int c)
{
   int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c);
   if (pa <= pb && pa <= pc) return STBIW_UCHAR(a);
   if (pb <= pc) return STBIW_UCHAR(b);
   return STBIW_UCHAR(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl -0x8(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0xe316
movl -0x18(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0xe316
movl -0x8(%rbp), %eax
andl $0xff, %eax
movb %al, -0x1(%rbp)
jmp 0xe336
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0xe32b
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, -0x1(%rbp)
jmp 0xe336
movl -0x10(%rbp), %eax
andl $0xff, %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movzwl 0x2(%rax), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movzwl (%rax), %eax
movl $0x18, %ecx
subl -0x28(%rbp), %ecx
shll %cl, %eax
orl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x8, -0x28(%rbp)
jl 0xe96a
movl -0x24(%rbp), %eax
sarl $0x10, %eax
andl $0xff, %eax
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x29(%rbp), %esi
callq 0xe3b0
movzbl -0x29(%rbp), %eax
cmpl $0xff, %eax
jne 0xe956
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xe3b0
movl -0x24(%rbp), %eax
shll $0x8, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x28(%rbp)
jmp 0xe91f
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_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, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0xecdb
xorl %eax, %eax
subl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0xece1
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0xecf8
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xecfe
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movw $0x1, 0x2(%rax)
movl -0x14(%rbp), %eax
sarl %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0xed2d
movq -0x10(%rbp), %rax
movw 0x2(%rax), %cx
addw $0x1, %cx
movw %cx, 0x2(%rax)
jmp 0xed0e
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
andl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x10610
leaq -0x20(%rbp), %rdi
movl $0x2, %esi
callq 0x10460
movl %eax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xff50
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0xfe8e
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0xfe8e
jmp 0xfead
leaq 0x6ea3(%rip), %rdi      # 0x16d38
leaq 0x691b(%rip), %rsi      # 0x167b7
movl $0x4d0, %edx            # imm = 0x4D0
leaq 0x6ea4(%rip), %rcx      # 0x16d4c
callq 0x10a0
cmpl $0x1, -0x2c(%rbp)
jl 0xfebb
cmpl $0x4, -0x2c(%rbp)
jg 0xfebb
jmp 0xfeda
leaq 0x6ebb(%rip), %rdi      # 0x16d7d
leaq 0x68ee(%rip), %rsi      # 0x167b7
movl $0x4d1, %edx            # imm = 0x4D1
leaq 0x6e77(%rip), %rcx      # 0x16d4c
callq 0x10a0
movl -0x24(%rbp), %esi
movl -0x2c(%rbp), %eax
imull %eax, %esi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xffa0
movq -0x40(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x10460
movq -0x40(%rbp), %rdi
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %esi
callq 0x10460
movq -0x40(%rbp), %rdi
movl %eax, -0x34(%rbp)
movl -0x28(%rbp), %esi
incl %esi
movl -0x2c(%rbp), %eax
imull %eax, %esi
movl -0x30(%rbp), %eax
movl %eax, %edx
movl %esi, %ecx
leal 0x2(%rcx,%rdx), %esi
movl -0x34(%rbp), %edx
subl %eax, %edx
callq 0x10690
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x103e0
movq -0x8(%rbp), %rax
movss 0x10(%rax), %xmm0
addss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
movss %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movss 0x14(%rax), %xmm0
addss -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x14(%rax)
movq -0x8(%rbp), %rax
movss %xmm0, 0xc(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
cvttss2si 0x10(%rax), %edx
movq -0x8(%rbp), %rax
cvttss2si 0x14(%rax), %ecx
movl $0x1, %esi
xorl %r9d, %r9d
movl %r9d, %r8d
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x10770
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movss %xmm3, -0x18(%rbp)
movss %xmm4, -0x1c(%rbp)
movss %xmm5, -0x20(%rbp)
movq -0x8(%rbp), %rax
movss 0x10(%rax), %xmm0
addss -0xc(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movss 0x14(%rax), %xmm0
addss -0x10(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x24(%rbp), %xmm0
addss -0x14(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x28(%rbp), %xmm0
addss -0x18(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x2c(%rbp), %xmm0
addss -0x1c(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x10(%rax)
movss -0x30(%rbp), %xmm0
addss -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x14(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
cvttss2si 0x10(%rax), %edx
movq -0x8(%rbp), %rax
cvttss2si 0x14(%rax), %ecx
cvttss2si -0x24(%rbp), %r8d
cvttss2si -0x28(%rbp), %r9d
cvttss2si -0x2c(%rbp), %r10d
cvttss2si -0x30(%rbp), %eax
movl $0x4, %esi
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x10770
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__cid_get_glyph_subrs
static stbtt__buf stbtt__cid_get_glyph_subrs(const stbtt_fontinfo *info, int glyph_index)
{
   stbtt__buf fdselect = info->fdselect;
   int nranges, start, end, v, fmt, fdselector = -1, i;

   stbtt__buf_seek(&fdselect, 0);
   fmt = stbtt__buf_get8(&fdselect);
   if (fmt == 0) {
      // untested
      stbtt__buf_skip(&fdselect, glyph_index);
      fdselector = stbtt__buf_get8(&fdselect);
   } else if (fmt == 3) {
      nranges = stbtt__buf_get16(&fdselect);
      start = stbtt__buf_get16(&fdselect);
      for (i = 0; i < nranges; i++) {
         v = stbtt__buf_get8(&fdselect);
         end = stbtt__buf_get16(&fdselect);
         if (glyph_index >= start && glyph_index < end) {
            fdselector = v;
            break;
         }
         start = end;
      }
   }
   if (fdselector == -1) stbtt__new_buf(NULL, 0);
   return stbtt__get_subrs(info->cff, stbtt__cff_index_get(info->fontdicts, fdselector));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x98(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0xffffffff, -0x48(%rbp) # imm = 0xFFFFFFFF
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x10610
leaq -0x30(%rbp), %rdi
callq 0xff50
movzbl %al, %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jne 0x10243
movl -0x1c(%rbp), %esi
leaq -0x30(%rbp), %rdi
callq 0xffa0
leaq -0x30(%rbp), %rdi
callq 0xff50
movzbl %al, %eax
movl %eax, -0x48(%rbp)
jmp 0x102c7
cmpl $0x3, -0x44(%rbp)
jne 0x102c5
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x10460
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x10460
movl %eax, -0x38(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x102c3
leaq -0x30(%rbp), %rdi
callq 0xff50
movzbl %al, %eax
movl %eax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x10460
movl %eax, -0x3c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x38(%rbp), %eax
jl 0x102b2
movl -0x1c(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x102b2
movl -0x40(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0x102c3
movl -0x3c(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x10272
jmp 0x102c5
jmp 0x102c7
cmpl $-0x1, -0x48(%rbp)
jne 0x102e1
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x10710
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x48(%rbp), %edx
movq 0x80(%rax), %rdi
movq 0x88(%rax), %rsi
callq 0xfe40
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq %rcx, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq 0x40(%rax), %rdi
movq 0x48(%rax), %rsi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
callq 0x10960
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__get_subr
static stbtt__buf stbtt__get_subr(stbtt__buf idx, int n)
{
   int count = stbtt__cff_index_count(&idx);
   int bias = 107;
   if (count >= 33900)
      bias = 32768;
   else if (count >= 1240)
      bias = 1131;
   n += bias;
   if (n < 0 || n >= count)
      return stbtt__new_buf(NULL, 0);
   return stbtt__cff_index_get(idx, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x10d60
movl %eax, -0x28(%rbp)
movl $0x6b, -0x2c(%rbp)
cmpl $0x846c, -0x28(%rbp)    # imm = 0x846C
jl 0x10378
movl $0x8000, -0x2c(%rbp)    # imm = 0x8000
jmp 0x1038a
cmpl $0x4d8, -0x28(%rbp)     # imm = 0x4D8
jl 0x10388
movl $0x46b, -0x2c(%rbp)     # imm = 0x46B
jmp 0x1038a
movl -0x2c(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x103a1
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jl 0x103b7
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x10710
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x103cf
movl -0x24(%rbp), %edx
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xfe40
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x1, -0xc(%rbp)
jl 0x10484
cmpl $0x4, -0xc(%rbp)
jg 0x10484
jmp 0x104a3
leaq 0x69f3(%rip), %rdi      # 0x16e7e
leaq 0x6325(%rip), %rsi      # 0x167b7
movl $0x468, %edx            # imm = 0x468
leaq 0x69f1(%rip), %rcx      # 0x16e8f
callq 0x10a0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x104dc
movl -0x10(%rbp), %eax
shll $0x8, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xff50
movb %al, %cl
movl -0x18(%rbp), %eax
movzbl %cl, %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x104aa
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xff50
movzbl %al, %eax
movl %eax, -0x14(%rbp)
cmpl $0x20, -0x14(%rbp)
jl 0x1052a
cmpl $0xf6, -0x14(%rbp)
jg 0x1052a
movl -0x14(%rbp), %eax
subl $0x8b, %eax
movl %eax, -0x4(%rbp)
jmp 0x10601
cmpl $0xf7, -0x14(%rbp)
jl 0x10568
cmpl $0xfa, -0x14(%rbp)
jg 0x10568
movl -0x14(%rbp), %eax
subl $0xf7, %eax
shll $0x8, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xff50
movb %al, %cl
movl -0x18(%rbp), %eax
movzbl %cl, %ecx
addl %ecx, %eax
addl $0x6c, %eax
movl %eax, -0x4(%rbp)
jmp 0x10601
cmpl $0xfb, -0x14(%rbp)
jl 0x105a8
cmpl $0xfe, -0x14(%rbp)
jg 0x105a8
movl -0x14(%rbp), %ecx
subl $0xfb, %ecx
xorl %eax, %eax
subl %ecx, %eax
shll $0x8, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xff50
movb %al, %cl
movl -0x1c(%rbp), %eax
movzbl %cl, %ecx
subl %ecx, %eax
subl $0x6c, %eax
movl %eax, -0x4(%rbp)
jmp 0x10601
cmpl $0x1c, -0x14(%rbp)
jne 0x105c1
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x10460
movl %eax, -0x4(%rbp)
jmp 0x10601
cmpl $0x1d, -0x14(%rbp)
jne 0x105da
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x10460
movl %eax, -0x4(%rbp)
jmp 0x10601
jmp 0x105dc
jmp 0x105de
jmp 0x105e0
jmp 0x105e2
leaq 0x62cc(%rip), %rdi      # 0x168b5
leaq 0x61c7(%rip), %rsi      # 0x167b7
movl $0x49a, %edx            # imm = 0x49A
leaq 0x68c2(%rip), %rcx      # 0x16ebe
callq 0x10a0
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__buf_range
static stbtt__buf stbtt__buf_range(const stbtt__buf *b, int o, int s)
{
   stbtt__buf r = stbtt__new_buf(NULL, 0);
   if (o < 0 || s < 0 || o > b->size || s > b->size - o) return r;
   r.data = b->data + o;
   r.size = s;
   return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x10710
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x106df
cmpl $0x0, -0x20(%rbp)
jl 0x106df
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jg 0x106df
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %ecx
subl -0x1c(%rbp), %ecx
cmpl %ecx, %eax
jle 0x106e1
jmp 0x106f9
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__new_buf
static stbtt__buf stbtt__new_buf(const void *p, size_t size)
{
   stbtt__buf r;
   STBTT_assert(size < 0x40000000);
   r.data = (stbtt_uint8*) p;
   r.size = (int) size;
   r.cursor = 0;
   return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
cmpq $0x40000000, -0x20(%rbp) # imm = 0x40000000
jae 0x1072c
jmp 0x1074b
leaq 0x66a7(%rip), %rdi      # 0x16dda
leaq 0x607d(%rip), %rsi      # 0x167b7
movl $0x471, %edx            # imm = 0x471
leaq 0x66a6(%rip), %rcx      # 0x16dec
callq 0x10a0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movb %sil, %al
movl 0x18(%rbp), %esi
movl 0x10(%rbp), %esi
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x107d7
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x10860
movzbl -0x9(%rbp), %eax
cmpl $0x4, %eax
jne 0x107d5
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x10860
movq -0x8(%rbp), %rdi
movl 0x10(%rbp), %esi
movl 0x18(%rbp), %edx
callq 0x10860
jmp 0x10849
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rax
imulq $0xe, %rax, %rax
addq %rax, %rdi
movb -0x9(%rbp), %al
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movzbl %al, %esi
callq 0x10900
movl 0x10(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rdx
movslq 0x30(%rdx), %rdx
imulq $0xe, %rdx, %rdx
addq %rdx, %rax
movw %cx, 0x8(%rax)
movl 0x18(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rdx
movslq 0x30(%rdx), %rdx
imulq $0xe, %rdx, %rdx
addq %rdx, %rax
movw %cx, 0xa(%rax)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jg 0x10884
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x1088e
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jg 0x108a4
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x108ae
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jl 0x108c4
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x108ce
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jl 0x108e4
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x108ee
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x4(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_setvertex
static void stbtt_setvertex(stbtt_vertex *v, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy)
{
   v->type = type;
   v->x = (stbtt_int16) x;
   v->y = (stbtt_int16) y;
   v->cx = (stbtt_int16) cx;
   v->cy = (stbtt_int16) cy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0xc(%rax)
movl -0x10(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, (%rax)
movl -0x14(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2(%rax)
movl -0x18(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x4(%rax)
movl -0x1c(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x6(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x60, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
leaq -0x3c(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x10b0
leaq -0x3c(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movl $0x12, %esi
movl $0x2, %edx
callq 0x10a50
cmpl $0x0, -0x38(%rbp)
je 0x109b2
cmpl $0x0, -0x3c(%rbp)
jne 0x109c8
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x10710
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x10a42
movl -0x38(%rbp), %esi
movl -0x3c(%rbp), %edx
leaq -0x20(%rbp), %rdi
callq 0x10690
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x50(%rbp), %rdi
movl $0x13, %esi
movl $0x1, %edx
leaq -0x34(%rbp), %rcx
callq 0x10a50
cmpl $0x0, -0x34(%rbp)
jne 0x10a22
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x10710
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x10a42
movl -0x38(%rbp), %esi
addl -0x34(%rbp), %esi
leaq -0x20(%rbp), %rdi
callq 0x10610
leaq -0x20(%rbp), %rdi
callq 0x10ad0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x10ba0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x10(%rbp), %ecx
movb %al, -0x31(%rbp)
jge 0x10a9a
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
setl %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x10aa3
jmp 0x10ac4
leaq -0x30(%rbp), %rdi
callq 0x104f0
movl %eax, %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x10a81
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x10460
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x10b6b
movq -0x18(%rbp), %rdi
callq 0xff50
movzbl %al, %eax
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jl 0x10b1a
cmpl $0x4, -0x24(%rbp)
jg 0x10b1a
jmp 0x10b39
leaq 0x625c(%rip), %rdi      # 0x16d7d
leaq 0x5c8f(%rip), %rsi      # 0x167b7
movl $0x48b, %edx            # imm = 0x48B
leaq 0x631c(%rip), %rcx      # 0x16e50
callq 0x10a0
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
imull -0x1c(%rbp), %esi
callq 0xffa0
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x10460
movq -0x30(%rbp), %rdi
movl %eax, %esi
subl $0x1, %esi
callq 0xffa0
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
movl 0x8(%rdi), %edx
subl %esi, %edx
callq 0x10690
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__dict_get
static stbtt__buf stbtt__dict_get(stbtt__buf *b, int key)
{
   stbtt__buf_seek(b, 0);
   while (b->cursor < b->size) {
      int start = b->cursor, end, op;
      while (stbtt__buf_peek8(b) >= 28)
         stbtt__cff_skip_operand(b);
      end = b->cursor;
      op = stbtt__buf_get8(b);
      if (op == 12)  op = stbtt__buf_get8(b) | 0x100;
      if (op == key) return stbtt__buf_range(b, start, end-start);
   }
   return stbtt__buf_range(b, 0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x10610
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x10c50
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10c80
movzbl %al, %eax
cmpl $0x1c, %eax
jl 0x10bf4
movq -0x18(%rbp), %rdi
callq 0x10cc0
jmp 0x10bd8
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0xff50
movzbl %al, %eax
movl %eax, -0x28(%rbp)
cmpl $0xc, -0x28(%rbp)
jne 0x10c27
movq -0x18(%rbp), %rdi
callq 0xff50
movzbl %al, %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x10c4b
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
subl -0x20(%rbp), %edx
callq 0x10690
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x10c65
jmp 0x10bba
movq -0x18(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x10690
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__cff_skip_operand
static void stbtt__cff_skip_operand(stbtt__buf *b) {
   int v, b0 = stbtt__buf_peek8(b);
   STBTT_assert(b0 >= 28);
   if (b0 == 30) {
      stbtt__buf_skip(b, 1);
      while (b->cursor < b->size) {
         v = stbtt__buf_get8(b);
         if ((v & 0xF) == 0xF || (v >> 4) == 0xF)
            break;
      }
   } else {
      stbtt__cff_int(b);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10c80
movzbl %al, %eax
movl %eax, -0x10(%rbp)
cmpl $0x1c, -0x10(%rbp)
jl 0x10ce3
jmp 0x10d02
leaq 0x6132(%rip), %rdi      # 0x16e1c
leaq 0x5ac6(%rip), %rsi      # 0x167b7
movl $0x4a0, %edx            # imm = 0x4A0
leaq 0x6128(%rip), %rcx      # 0x16e25
callq 0x10a0
cmpl $0x1e, -0x10(%rbp)
jne 0x10d51
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xffa0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x10d4f
movq -0x8(%rbp), %rdi
callq 0xff50
movzbl %al, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0xf, %eax
cmpl $0xf, %eax
je 0x10d4b
movl -0xc(%rbp), %eax
sarl $0x4, %eax
cmpl $0xf, %eax
jne 0x10d4d
jmp 0x10d4f
jmp 0x10d16
jmp 0x10d5a
movq -0x8(%rbp), %rdi
callq 0x104f0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x10e31
cmpl $0x0, -0x10(%rbp)
je 0x10dff
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
cltq
imulq $0xe, %rax, %rax
addq %rax, %rdi
movl 0x20(%rbp), %edx
addl 0x10(%rbp), %edx
sarl %edx
movl 0x28(%rbp), %ecx
addl 0x18(%rbp), %ecx
sarl %ecx
movl 0x20(%rbp), %r8d
movl 0x28(%rbp), %r9d
movl $0x3, %esi
callq 0x10900
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
cltq
imulq $0xe, %rax, %rax
addq %rax, %rdi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl 0x10(%rbp), %r8d
movl 0x18(%rbp), %r9d
movl $0x3, %esi
callq 0x10900
jmp 0x10e99
cmpl $0x0, -0x10(%rbp)
je 0x10e69
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
cltq
imulq $0xe, %rax, %rax
addq %rax, %rdi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl 0x20(%rbp), %r8d
movl 0x28(%rbp), %r9d
movl $0x3, %esi
callq 0x10900
jmp 0x10e97
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
cltq
imulq $0xe, %rax, %rax
addq %rax, %rdi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl $0x2, %esi
xorl %r9d, %r9d
movl %r9d, %r8d
callq 0x10900
jmp 0x10e99
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__sort_edges_ins_sort
static void stbtt__sort_edges_ins_sort(stbtt__edge *p, int n)
{
   int i,j;
   for (i=1; i < n; ++i) {
      stbtt__edge t = p[i], *a = &t;
      j = i;
      while (j > 0) {
         stbtt__edge *b = &p[j-1];
         int c = STBTT__COMPARE(a,b);
         if (!c) break;
         p[j] = p[j-1];
         --j;
      }
      if (i != j)
         p[j] = t;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1221b
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movl 0x10(%rax), %eax
movl %eax, -0x18(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x121df
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movss 0x4(%rax), %xmm1
movq -0x38(%rbp), %rax
movss 0x4(%rax), %xmm0
ucomiss %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0x1219a
jmp 0x121df
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movl -0x14(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
imulq $0x14, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12150
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x1220b
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x10(%rax)
jmp 0x1220d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x12112
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__new_active
static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata)
{
   stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh, sizeof(*z), userdata);
   float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0);
   STBTT_assert(z != NULL);
   //STBTT_assert(e->y0 <= start_point);
   if (!z) return z;
   z->fdx = dxdy;
   z->fdy = dxdy != 0.0f ? (1.0f/dxdy) : 0.0f;
   z->fx = e->x0 + dxdy * (start_point - e->y0);
   z->fx -= off_x;
   z->direction = e->invert ? 1.0f : -1.0f;
   z->sy = e->y0;
   z->ey = e->y1;
   z->next = 0;
   return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movss %xmm0, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x20, %esi
callq 0x12f10
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
subss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm1
movq -0x18(%rbp), %rax
subss 0x4(%rax), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x34(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x122b7
jmp 0x122d6
leaq 0x4e79(%rip), %rdi      # 0x17137
leaq 0x44f2(%rip), %rsi      # 0x167b7
movl $0xabe, %edx            # imm = 0xABE
leaq 0x4e76(%rip), %rcx      # 0x17147
callq 0x10a0
cmpq $0x0, -0x30(%rbp)
jne 0x122ea
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x123ed
movss -0x34(%rbp), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0xc(%rax)
movss -0x34(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x12309
jp 0x12309
jmp 0x1231d
movss 0x430b(%rip), %xmm0     # 0x1661c
divss -0x34(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
jmp 0x12327
xorps %xmm0, %xmm0
movss %xmm0, -0x38(%rbp)
jmp 0x12327
movss -0x38(%rbp), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x10(%rax)
movq -0x18(%rbp), %rax
movss (%rax), %xmm1
movss -0x34(%rbp), %xmm0
movss -0x20(%rbp), %xmm2
movq -0x18(%rbp), %rax
subss 0x4(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x8(%rax)
cvtsi2ssl -0x1c(%rbp), %xmm1
movq -0x30(%rbp), %rax
movss 0x8(%rax), %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movss 0x4295(%rip), %xmm0     # 0x1661c
movss 0x42e5(%rip), %xmm1     # 0x16674
movss %xmm1, -0x40(%rbp)
cmpl $0x0, %eax
movss %xmm0, -0x3c(%rbp)
jne 0x123a8
movss -0x40(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0x3c(%rbp), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x14(%rax)
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x18(%rax)
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x1c(%rax)
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__hheap_cleanup
static void stbtt__hheap_cleanup(stbtt__hheap *hh, void *userdata)
{
   stbtt__hheap_chunk *c = hh->head;
   while (c) {
      stbtt__hheap_chunk *n = c->next;
      STBTT_free(c, userdata);
      c = n;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x12f00
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x12edb
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__hheap_alloc
static void *stbtt__hheap_alloc(stbtt__hheap *hh, size_t size, void *userdata)
{
   if (hh->first_free) {
      void *p = hh->first_free;
      hh->first_free = * (void **) p;
      return p;
   } else {
      if (hh->num_remaining_in_head_chunk == 0) {
         int count = (size < 32 ? 2000 : size < 128 ? 800 : 100);
         stbtt__hheap_chunk *c = (stbtt__hheap_chunk *) STBTT_malloc(sizeof(stbtt__hheap_chunk) + size * count, userdata);
         if (c == NULL)
            return NULL;
         c->next = hh->head;
         hh->head = c;
         hh->num_remaining_in_head_chunk = count;
      }
      --hh->num_remaining_in_head_chunk;
      return (char *) (hh->head) + sizeof(stbtt__hheap_chunk) + size * hh->num_remaining_in_head_chunk;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x12f57
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1300f
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x12fe0
cmpq $0x20, -0x18(%rbp)
jae 0x12f72
movl $0x7d0, %eax            # imm = 0x7D0
movl %eax, -0x3c(%rbp)
jmp 0x12f8d
movq -0x18(%rbp), %rdx
movl $0x64, %eax
movl $0x320, %ecx            # imm = 0x320
cmpq $0x80, %rdx
cmovbl %ecx, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rax
imulq %rax, %rdi
addq $0x8, %rdi
callq 0x1140
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x12fbd
movq $0x0, -0x8(%rbp)
jmp 0x1300f
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdx
movslq 0x10(%rdx), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)