LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x79a5
leaq -0xd0(%rbp), %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x755f
movaps -0x30(%rbp), %xmm2
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm2
jbe 0x7acf
movq -0xc8(%rbp), %rax
movslq -0xac(%rbp), %rcx
movzbl 0x5(%rax,%rcx), %esi
movzbl 0x4(%rax,%rcx), %edx
shll $0x8, %edx
movswl %dx, %edx
orl %esi, %edx
movzbl 0x7(%rax,%rcx), %edi
movzbl 0x6(%rax,%rcx), %esi
shll $0x8, %esi
movswl %si, %esi
orl %edi, %esi
movl %edx, %edi
subl %esi, %edi
xorps %xmm0, %xmm0
cvtsi2ss %edi, %xmm0
divss %xmm0, %xmm2
jmp 0x7b14
xorps 0x705a(%rip), %xmm2     # 0xeb30
movq -0xc8(%rbp), %rax
movslq -0xb4(%rbp), %rcx
movzwl 0x12(%rax,%rcx), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
divss %xmm0, %xmm2
movslq -0xac(%rbp), %rcx
movzwl 0x4(%rax,%rcx), %edx
movzwl 0x6(%rax,%rcx), %esi
rolw $0x8, %dx
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_O3/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 0x7c1f
addss 0x6ef7(%rip), %xmm0     # 0xeaa4
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 0x6ec2(%rip), %xmm0     # 0xeaa4
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 0x7c53
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 0x6e1f(%rip), %xmm1     # 0xea88
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_O3/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_GetFontNameString
STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID)
{
   stbtt_int32 i,count,stringOffset;
   stbtt_uint8 *fc = font->data;
   stbtt_uint32 offset = font->fontstart;
   stbtt_uint32 nm = stbtt__find_table(fc, offset, "name");
   if (!nm) return NULL;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r15d
movl %r8d, %r12d
movl %ecx, %r13d
movl %edx, %r14d
movq %rsi, -0x30(%rbp)
movq 0x8(%rdi), %rbx
movl 0x10(%rdi), %esi
leaq 0x5b69(%rip), %rdx      # 0xede4
movq %rbx, %rdi
callq 0x4c2a
testl %eax, %eax
je 0x92fe
movl %eax, %ecx
movzwl 0x2(%rbx,%rcx), %edx
rolw $0x8, %dx
testw %dx, %dx
je 0x92fe
movzwl 0x4(%rbx,%rcx), %ecx
movzwl %dx, %esi
rolw $0x8, %cx
movzwl %cx, %edx
addl %eax, %edx
addl $0x6, %eax
movl %esi, %esi
xorl %ecx, %ecx
movl %eax, %eax
movzwl (%rbx,%rax), %edi
rolw $0x8, %di
movzwl %di, %edi
cmpl %r14d, %edi
jne 0x92f4
movzwl 0x2(%rbx,%rax), %edi
rolw $0x8, %di
movzwl %di, %edi
cmpl %r13d, %edi
jne 0x92f4
movzwl 0x4(%rbx,%rax), %edi
rolw $0x8, %di
movzwl %di, %edi
cmpl %r12d, %edi
jne 0x92f4
movzwl 0x6(%rbx,%rax), %edi
rolw $0x8, %di
movzwl %di, %edi
cmpl %r15d, %edi
je 0x9312
addl $0xc, %eax
decq %rsi
jne 0x92af
jmp 0x9300
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzwl 0x8(%rbx,%rax), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
movq -0x30(%rbp), %rsi
movl %ecx, (%rsi)
movslq %edx, %rdx
addq %rbx, %rdx
movzwl 0xa(%rbx,%rax), %eax
rolw $0x8, %ax
movzwl %ax, %ecx
addq %rdx, %rcx
jmp 0x9300
// File: /workspace/github_c_makefile_star2_O3/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 0x9cfb
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 0x9e20
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 0x9e34
movl $0x0, -0x40(%rbp)
testl %r15d, %r15d
jle 0x9e19
movl 0x83db(%rip), %eax      # 0x12130
leal -0x1(%r15), %edx
xorl %esi, %esi
xorl %ecx, %ecx
testl %eax, %eax
cmovnel %esi, %edx
setne %cl
cmpl $0x1, %eax
sbbl %esi, %esi
leaq -0x1(,%rcx,2), %rax
orl %r15d, %esi
movl %esi, -0x3c(%rbp)
movslq %r14d, %r15
movslq -0x2c(%rbp), %rcx
movl %ecx, %esi
movq %rsi, -0x48(%rbp)
imulq %r15, %rcx
movq %rcx, %rsi
imulq %rdx, %rsi
addq 0x18(%rbp), %rsi
movq %rsi, -0x38(%rbp)
movq %rax, -0x58(%rbp)
imulq %rax, %rcx
movq %rcx, -0x50(%rbp)
movq %r15, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
cmpl $0x0, -0x2c(%rbp)
movl 0x20(%rbp), %eax
movl 0x10(%rbp), %r13d
movq %rbx, %r14
jle 0x9def
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 0x9f67
movl %r14d, %eax
movq %r15, %r14
movq -0x68(%rbp), %r15
addq %r15, %rbx
decq %r12
jne 0x9dc4
movq 0x8(%r14), %rdi
leaq -0x40(%rbp), %rsi
movl 0x28(%rbp), %edx
callq *(%r14)
movq -0x60(%rbp), %rdx
addq -0x58(%rbp), %rdx
movq -0x38(%rbp), %rax
addq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl %edx, -0x3c(%rbp)
movq %r14, %rbx
jne 0x9da8
movl $0x1, %eax
jmp 0x9e22
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_O3/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 0x9f39
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 0x9e90
cmpl $0x20, %eax
je 0x9f2b
cmpl $0x31, %eax
jne 0x9f48
movl (%rbx), %ecx
cmpq $0x28, %rcx
ja 0x9eeb
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x9ef7
cmpl $0x32, %eax
je 0x9eb4
cmpl $0x34, %eax
jne 0x9f48
movl (%rbx), %ecx
cmpq $0x28, %rcx
ja 0x9f0b
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x9f17
movl (%rbx), %ecx
cmpq $0x28, %rcx
ja 0x9eca
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x9ed6
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 0x9f28
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 0x9f28
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 0x9e60
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4e17(%rip), %rdi      # 0xed66
leaq 0x4c4c(%rip), %rsi      # 0xeba2
leaq 0x4f9b(%rip), %rcx      # 0xeef8
movl $0x171, %edx            # imm = 0x171
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O3/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 0x9fc8
cmpl $0x3, %r15d
je 0x9fa0
cmpl $0x4, %r15d
jne 0x9ff9
testl %r12d, %r12d
je 0xa020
movb 0x2(%r14), %al
movb (%r14), %cl
movb 0x1(%r14), %dl
movq (%rbx), %r8
movq 0x8(%rbx), %rdi
leaq -0x2c(%rbp), %rsi
movb %al, (%rsi)
movb %dl, 0x1(%rsi)
movb %cl, 0x2(%rsi)
movl $0x3, %edx
callq *%r8
jmp 0x9ff9
testl %ecx, %ecx
je 0x9feb
movb (%r14), %al
movq (%rbx), %rcx
movq 0x8(%rbx), %rdi
leaq -0x26(%rbp), %rsi
movb %al, (%rsi)
movb %al, 0x1(%rsi)
movb %al, 0x2(%rsi)
movl $0x3, %edx
callq *%rcx
jmp 0x9ff9
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x1, %edx
callq *(%rbx)
testl %r12d, %r12d
jle 0xa013
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
movzbl 0x3(%r14), %eax
xorl %ecx, %ecx
leaq 0x31c6(%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 0xa02e
movb -0x21(%rbp), %al
movb -0x23(%rbp), %cl
movb -0x22(%rbp), %dl
movq (%rbx), %r8
movq 0x8(%rbx), %rdi
leaq -0x29(%rbp), %rsi
jmp 0x9fb6
// File: /workspace/github_c_makefile_star2_O3/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 0x49be(%rip), %xmm0     # 0xeb08
ucomiss %xmm2, %xmm0
jbe 0xa15a
movw $0x0, (%rbx)
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0xa1ba
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 0x4986(%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, %ecx
movb (%r15), %al
addb $-0x80, %al
movb %al, 0x3(%rbx)
movb %cl, 0x2(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl %r8d, %r15d
movl %ecx, %r14d
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %r15d
movq %rdx, -0x40(%rbp)
addl (%rdx), %r15d
andl %eax, %r14d
movb $0x18, %cl
subb %r15b, %cl
shll %cl, %r14d
movq %rsi, -0x38(%rbp)
orl (%rsi), %r14d
cmpl $0x8, %r15d
jl 0xa5c6
movq %rdi, %r13
leaq -0x29(%rbp), %rbx
leaq -0x2a(%rbp), %r12
movl %r14d, %eax
shrl $0x10, %eax
movq (%r13), %rcx
movq 0x8(%r13), %rdi
movb %al, -0x29(%rbp)
movq %rbx, %rsi
movl $0x1, %edx
callq *%rcx
movl %r14d, %eax
notl %eax
testl $0xff0000, %eax         # imm = 0xFF0000
jne 0xa5b3
movq (%r13), %rax
movq 0x8(%r13), %rdi
movb $0x0, -0x2a(%rbp)
movq %r12, %rsi
movl $0x1, %edx
callq *%rax
shll $0x8, %r14d
leal -0x8(%r15), %eax
cmpl $0xf, %r15d
movl %eax, %r15d
jg 0xa576
jmp 0xa5c9
movl %r15d, %eax
movq -0x38(%rbp), %rcx
movl %r14d, (%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_O3/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 0x4498(%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 0x446c(%rip), %xmm8     # 0xeb14
mulss 0x4468(%rip), %xmm3     # 0xeb18
mulss 0x4464(%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_O3/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
testq %rsi, %rsi
js 0xb5c4
shrq $0x20, %rsi
xorl %r8d, %r8d
movl $0x2, %ecx
xorl %eax, %eax
cmpl %esi, %r8d
jge 0xb4ef
movslq %r8d, %r9
incl %r8d
movzbl (%rdi,%r9), %r9d
jmp 0xb4f2
xorl %r9d, %r9d
shll $0x8, %eax
orl %r9d, %eax
decl %ecx
jne 0xb4dd
cmpl %esi, %r8d
jge 0xb50c
movslq %r8d, %rcx
incl %r8d
movb (%rdi,%rcx), %cl
jmp 0xb50e
xorl %ecx, %ecx
testl %edx, %edx
js 0xb5e3
cmpl %edx, %eax
jle 0xb5e3
leal -0x1(%rcx), %r9d
cmpb $0x4, %r9b
jae 0xb602
movzbl %cl, %ecx
imull %ecx, %edx
addl %r8d, %edx
cmpl %esi, %edx
ja 0xb5c4
xorl %r8d, %r8d
movl %ecx, %r9d
cmpl %esi, %edx
jge 0xb553
movslq %edx, %r10
incl %edx
movzbl (%rdi,%r10), %r10d
jmp 0xb556
xorl %r10d, %r10d
shll $0x8, %r8d
orl %r10d, %r8d
decl %r9d
jne 0xb543
xorl %r9d, %r9d
movl %ecx, %r10d
cmpl %esi, %edx
jge 0xb578
movslq %edx, %r11
incl %edx
movzbl (%rdi,%r11), %r11d
jmp 0xb57b
xorl %r11d, %r11d
shll $0x8, %r9d
orl %r11d, %r9d
decl %r10d
jne 0xb568
incl %eax
imull %ecx, %eax
leal (%rax,%r8), %ecx
addl $0x2, %ecx
subl %r8d, %r9d
movl %r9d, %eax
orl %ecx, %eax
js 0xb5be
xorl %eax, %eax
subl %ecx, %esi
jl 0xb5c0
movl $0x0, %edx
cmpl %r9d, %esi
jl 0xb5c2
movl %ecx, %eax
addq %rax, %rdi
shlq $0x20, %r9
movq %rdi, %rax
movq %r9, %rdx
jmp 0xb5c2
xorl %eax, %eax
xorl %edx, %edx
popq %rbp
retq
leaq 0x3a8f(%rip), %rdi      # 0xf05a
leaq 0x3696(%rip), %rsi      # 0xec68
leaq 0x3a99(%rip), %rcx      # 0xf072
movl $0x45b, %edx            # imm = 0x45B
callq 0x10c0
leaq 0x3a0e(%rip), %rdi      # 0xeff8
leaq 0x3677(%rip), %rsi      # 0xec68
leaq 0x3a14(%rip), %rcx      # 0xf00c
movl $0x4d0, %edx            # imm = 0x4D0
callq 0x10c0
leaq 0x3a34(%rip), %rdi      # 0xf03d
leaq 0x3658(%rip), %rsi      # 0xec68
leaq 0x39f5(%rip), %rcx      # 0xf00c
movl $0x4d1, %edx            # imm = 0x4D1
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O3/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 0xb869
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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), %edx
cmpl %edx, %eax
jge 0xb84a
movq (%rdi), %rcx
leaq 0x1(%rax), %rsi
movl %esi, 0x8(%rdi)
movzbl (%rcx,%rax), %r8d
leal -0x20(%r8), %r9d
cmpb $-0x2a, %r9b
ja 0xb78c
addl $0xffffff75, %r8d       # imm = 0xFFFFFF75
movl %r8d, %eax
jmp 0xb848
leal 0x9(%r8), %r9d
cmpb $0x3, %r9b
ja 0xb7ba
shll $0x8, %r8d
xorl %r9d, %r9d
cmpl %edx, %esi
jge 0xb7ac
addl $0x2, %eax
movl %eax, 0x8(%rdi)
movzbl (%rcx,%rsi), %r9d
leal (%r8,%r9), %eax
addl $0xffff096c, %eax       # imm = 0xFFFF096C
jmp 0xb848
leal 0x5(%r8), %r9d
cmpb $0x3, %r9b
ja 0xb7e8
xorl %r9d, %r9d
cmpl %edx, %esi
jge 0xb7d7
leal 0x2(%rax), %edx
movl %edx, 0x8(%rdi)
movzbl 0x1(%rcx,%rax), %r9d
shll $0x8, %r8d
orl %r9d, %r8d
movl $0xfa94, %eax           # imm = 0xFA94
subl %r8d, %eax
jmp 0xb848
cmpl $0x1c, %r8d
je 0xb81f
cmpl $0x1d, %r8d
jne 0xb84a
xorl %eax, %eax
movl $0x4, %r8d
cmpl %edx, %esi
jge 0xb80f
movslq %esi, %r9
incl %esi
movl %esi, 0x8(%rdi)
movzbl (%rcx,%r9), %r9d
jmp 0xb812
xorl %r9d, %r9d
shll $0x8, %eax
orl %r9d, %eax
decl %r8d
jne 0xb7fc
jmp 0xb848
xorl %eax, %eax
movl $0x2, %r8d
cmpl %edx, %esi
jge 0xb83a
movslq %esi, %r9
incl %esi
movl %esi, 0x8(%rdi)
movzbl (%rcx,%r9), %r9d
jmp 0xb83d
xorl %r9d, %r9d
shll $0x8, %eax
orl %r9d, %eax
decl %r8d
jne 0xb827
popq %rbp
retq
leaq 0x3515(%rip), %rdi      # 0xed66
leaq 0x3410(%rip), %rsi      # 0xec68
leaq 0x3869(%rip), %rcx      # 0xf0c8
movl $0x49a, %edx            # imm = 0x49A
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O3/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 0xb8c0
movq %rbx, %rdi
movl %edx, %esi
movl %ecx, %edx
callq 0xb90b
cmpb $0x4, %r14b
jne 0xb8f9
movq %rbx, %rdi
movl %r13d, %esi
movl %r15d, %edx
callq 0xb90b
movq %rbx, %rdi
movl %r12d, %esi
movl 0x18(%rbp), %edx
callq 0xb90b
jmp 0xb8f9
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
// File: /workspace/github_c_makefile_star2_O3/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__track_vertex
static void stbtt__track_vertex(stbtt__csctx *c, stbtt_int32 x, stbtt_int32 y)
{
   if (x > c->max_x || !c->started) c->max_x = x;
   if (y > c->max_y || !c->started) c->max_y = y;
   if (x < c->min_x || !c->started) c->min_x = x;
   if (y < c->min_y || !c->started) c->min_y = y;
   c->started = 1;
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, -0x30(%rbp)
movq %rsi, -0x28(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdx, (%rdi)
movq %rcx, 0x8(%rdi)
movl $0x0, -0x1c(%rbp)
leaq -0x38(%rbp), %r15
movq $0x0, (%r15)
movl $0x12, %esi
movl $0x2, %edx
movq %r15, %rcx
callq 0xba64
movl (%r15), %ecx
movl 0x4(%r15), %r15d
testq %r15, %r15
setne %al
testl %ecx, %ecx
setne %sil
andb %al, %sil
xorl %eax, %eax
movl $0x0, %edx
cmpb $0x1, %sil
jne 0xba3a
movl %ecx, %eax
shrq $0x20, %rbx
movl %eax, %ecx
orl %r15d, %ecx
js 0xb9f3
movl %ebx, %ecx
subl %r15d, %ecx
setl %dl
cmpl %eax, %ecx
setl %sil
xorl %ecx, %ecx
orb %dl, %sil
movl $0x0, %edx
jne 0xb9f7
addq %r15, %r14
shlq $0x20, %rax
movq %r14, %rcx
movq %rax, %rdx
jmp 0xb9f7
xorl %ecx, %ecx
xorl %edx, %edx
leaq -0x48(%rbp), %rdi
movq %rcx, (%rdi)
movq %rdx, 0x8(%rdi)
leaq -0x1c(%rbp), %r14
movl $0x13, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0xba64
movl (%r14), %eax
testl %eax, %eax
je 0xba36
addl %r15d, %eax
js 0xba45
cmpl %ebx, %eax
jg 0xba45
leaq -0x30(%rbp), %rdi
movl %eax, 0x8(%rdi)
callq 0xbc16
jmp 0xba3a
xorl %eax, %eax
xorl %edx, %edx
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x360e(%rip), %rdi      # 0xf05a
leaq 0x3215(%rip), %rsi      # 0xec68
leaq 0x3618(%rip), %rcx      # 0xf072
movl $0x45b, %edx            # imm = 0x45B
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O3/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__dict_get_ints
static void stbtt__dict_get_ints(stbtt__buf *b, int key, int outcount, stbtt_uint32 *out)
{
   int i;
   stbtt__buf operands = stbtt__dict_get(b, key);
   for (i = 0; i < outcount && operands.cursor < operands.size; i++)
      out[i] = stbtt__cff_int(&operands);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0xc(%rdi), %eax
testl %eax, %eax
js 0xbbf7
movq %rdi, %r15
movl $0x0, 0x8(%rdi)
je 0xbbe8
movq %rcx, %rbx
movl %edx, %r14d
movl %esi, %r12d
xorl %r13d, %r13d
cmpl %eax, %r13d
jge 0xbb3c
movq (%r15), %rsi
movslq %r13d, %rdi
movb (%rsi,%rdi), %dl
movl %r13d, %ecx
cmpb $0x1c, %dl
jb 0xbb44
movq %r15, %rdi
cmpb $0x1e, %dl
jne 0xbb1d
movl $0x1, %esi
callq 0xb621
movl 0x8(%r15), %ecx
movl 0xc(%r15), %eax
movl %eax, %edx
cmpl %eax, %ecx
cmovgl %ecx, %edx
jge 0xbb2a
movslq %ecx, %rsi
movslq %edx, %rdx
movq (%r15), %rdi
decq %rdx
leaq 0x1(%rsi), %rcx
leal 0x1(%rsi), %r8d
movl %r8d, 0x8(%r15)
movzbl (%rdi,%rsi), %r8d
movl %r8d, %r9d
notl %r9d
testb $0xf, %r9b
je 0xbb2a
andl $-0x10, %r8d
cmpl $0xf0, %r8d
je 0xbb2a
cmpq %rsi, %rdx
movq %rcx, %rsi
jne 0xbae9
jmp 0xbb2a
callq 0xb751
movl 0x8(%r15), %ecx
movl 0xc(%r15), %eax
cmpl %eax, %ecx
jge 0xbb77
movq (%r15), %rsi
movslq %ecx, %rdi
movb (%rsi,%rdi), %dl
jmp 0xbab1
movl %r13d, %edx
movl %r13d, %ecx
jmp 0xbb79
movslq %ecx, %rdx
incq %rdx
movl %edx, 0x8(%r15)
movzbl (%rsi,%rdi), %edi
cmpl $0xc, %edi
jne 0xbb7b
movl $0x100, %edi            # imm = 0x100
cmpl %eax, %edx
jge 0xbb7b
leal 0x2(%rcx), %r8d
movl %r8d, 0x8(%r15)
movzbl (%rsi,%rdx), %edi
orl $0x100, %edi            # imm = 0x100
movl %r8d, %edx
jmp 0xbb7b
movl %ecx, %edx
xorl %edi, %edi
cmpl %r12d, %edi
je 0xbb8d
movl %edx, %r13d
cmpl %eax, %edx
jl 0xba9c
jmp 0xbbe8
movl %ecx, %edx
subl %r13d, %edx
movl %edx, %esi
orl %r13d, %esi
js 0xbbe8
cmpl %r13d, %eax
jl 0xbbe8
cmpl %ecx, %eax
jl 0xbbe8
movl %r13d, %eax
addq (%r15), %rax
shlq $0x20, %rdx
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
testl %r14d, %r14d
jle 0xbbe8
cmpl %r13d, %ecx
je 0xbbe8
movl %r14d, %r15d
movl $0x1, %r12d
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0xb751
movl %eax, -0x4(%rbx,%r12,4)
cmpq %r15, %r12
jae 0xbbe8
incq %r12
movl -0x2c(%rbp), %eax
cmpl %eax, -0x30(%rbp)
jl 0xbbcb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x345c(%rip), %rdi      # 0xf05a
leaq 0x3063(%rip), %rsi      # 0xec68
leaq 0x3466(%rip), %rcx      # 0xf072
movl $0x45b, %edx            # imm = 0x45B
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O3/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__cff_get_index
static stbtt__buf stbtt__cff_get_index(stbtt__buf *b)
{
   int count, start, offsize;
   start = b->cursor;
   count = stbtt__buf_get16(b);
   if (count) {
      offsize = stbtt__buf_get8(b);
      STBTT_assert(offsize >= 1 && offsize <= 4);
      stbtt__buf_skip(b, offsize * count);
      stbtt__buf_skip(b, stbtt__buf_get(b, offsize) - 1);
   }
   return stbtt__buf_range(b, start, b->cursor - start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %r14d
movl 0xc(%rdi), %ecx
xorl %esi, %esi
movl $0x2, %edx
movl %r14d, %eax
cmpl %ecx, %eax
jge 0xbc4a
movq (%rbx), %rdi
movslq %eax, %r8
incl %eax
movl %eax, 0x8(%rbx)
movzbl (%rdi,%r8), %edi
jmp 0xbc4c
xorl %edi, %edi
shll $0x8, %esi
orl %edi, %esi
decl %edx
jne 0xbc34
testl %esi, %esi
je 0xbcbf
cmpl %ecx, %eax
jge 0xbd04
movq (%rbx), %rcx
leal 0x1(%rax), %edx
movl %edx, 0x8(%rbx)
cltq
movzbl (%rcx,%rax), %r15d
leal -0x1(%r15), %eax
cmpb $0x4, %al
jae 0xbd04
imull %r15d, %esi
movq %rbx, %rdi
callq 0xb621
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %eax
xorl %esi, %esi
cmpl %eax, %ecx
jge 0xbca6
movq (%rbx), %rdx
movslq %ecx, %rdi
incl %ecx
movl %ecx, 0x8(%rbx)
movzbl (%rdx,%rdi), %edx
jmp 0xbca8
xorl %edx, %edx
shll $0x8, %esi
orl %edx, %esi
decl %r15d
jne 0xbc91
decl %esi
movq %rbx, %rdi
callq 0xb621
movl 0x8(%rbx), %eax
movl %eax, %ecx
subl %r14d, %ecx
movl %ecx, %edx
orl %r14d, %edx
js 0xbcf5
movl 0xc(%rbx), %edx
cmpl %r14d, %edx
setl %sil
cmpl %eax, %edx
setl %dl
xorl %eax, %eax
orb %sil, %dl
movl $0x0, %edx
jne 0xbcf9
movq (%rbx), %rax
addq %r14, %rax
shlq $0x20, %rcx
movq %rcx, %rdx
jmp 0xbcf9
xorl %eax, %eax
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3332(%rip), %rdi      # 0xf03d
leaq 0x2f56(%rip), %rsi      # 0xec68
leaq 0x3381(%rip), %rcx      # 0xf09a
movl $0x48b, %edx            # imm = 0x48B
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O3/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__close_shape
static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off,
    stbtt_int32 sx, stbtt_int32 sy, stbtt_int32 scx, stbtt_int32 scy, stbtt_int32 cx, stbtt_int32 cy)
{
   if (start_off) {
      if (was_off)
         stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+scx)>>1, (cy+scy)>>1, cx,cy);
      stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, sx,sy,scx,scy);
   } else {
      if (was_off)
         stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve,sx,sy,cx,cy);
      else
         stbtt_setvertex(&vertices[num_vertices++], STBTT_vline,sx,sy,0,0);
   }
   return num_vertices;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %eax
movl 0x28(%rbp), %r10d
movl 0x20(%rbp), %r11d
testl %ecx, %ecx
je 0xbda3
movl 0x18(%rbp), %ecx
movl 0x10(%rbp), %ebx
testl %edx, %edx
je 0xbd7a
movslq %eax, %rdx
incl %eax
leaq (%rdx,%rdx), %rsi
shlq $0x4, %rdx
subq %rsi, %rdx
leal (%r11,%rbx), %esi
shrl %esi
leal (%r10,%rcx), %r14d
shrl %r14d
movb $0x3, 0xc(%rdi,%rdx)
movw %si, (%rdi,%rdx)
movw %r14w, 0x2(%rdi,%rdx)
movw %r11w, 0x4(%rdi,%rdx)
movw %r10w, 0x6(%rdi,%rdx)
movslq %eax, %rsi
movq %rsi, %r10
shlq $0x4, %r10
subq %rsi, %r10
subq %rsi, %r10
movb $0x3, 0xc(%rdi,%r10)
movw %r8w, (%rdi,%r10)
movw %r9w, 0x2(%rdi,%r10)
movw %bx, 0x4(%rdi,%r10)
jmp 0xbde6
movslq %eax, %rsi
movq %rsi, %rcx
shlq $0x4, %rcx
subq %rsi, %rcx
subq %rsi, %rcx
addq %rdi, %rcx
testl %edx, %edx
je 0xbdd1
movb $0x3, 0xc(%rcx)
movw %r8w, (%rcx)
movw %r9w, 0x2(%rcx)
movw %r11w, 0x4(%rcx)
movl %r10d, %ecx
jmp 0xbde6
movb $0x2, 0xc(%rcx)
movw %r8w, (%rcx)
movw %r9w, 0x2(%rcx)
movw $0x0, 0x4(%rcx)
xorl %ecx, %ecx
leaq (%rsi,%rsi), %rdx
shlq $0x4, %rsi
subq %rdx, %rsi
movw %cx, 0x6(%rdi,%rsi)
incl %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__GetGlyphClass
static stbtt_int32  stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph)
{
    stbtt_uint16 classDefFormat = ttUSHORT(classDefTable);
    switch(classDefFormat)
    {
        case 1: {
            stbtt_uint16 startGlyphID = ttUSHORT(classDefTable + 2);
            stbtt_uint16 glyphCount = ttUSHORT(classDefTable + 4);
            stbtt_uint8 *classDef1ValueArray = classDefTable + 6;

            if (glyph >= startGlyphID && glyph < startGlyphID + glyphCount)
                return (stbtt_int32)ttUSHORT(classDef1ValueArray + 2 * (glyph - startGlyphID));

            classDefTable = classDef1ValueArray + 2 * glyphCount;
        } break;

        case 2: {
            stbtt_uint16 classRangeCount = ttUSHORT(classDefTable + 2);
            stbtt_uint8 *classRangeRecords = classDefTable + 4;

            // Binary search.
            stbtt_int32 l=0, r=classRangeCount-1, m;
            int strawStart, strawEnd, needle=glyph;
            while (l <= r) {
                stbtt_uint8 *classRangeRecord;
                m = (l + r) >> 1;
                classRangeRecord = classRangeRecords + 6 * m;
                strawStart = ttUSHORT(classRangeRecord);
                strawEnd = ttUSHORT(classRangeRecord + 2);
                if (needle < strawStart)
                    r = m - 1;
                else if (needle > strawEnd)
                    l = m + 1;
                else
                    return (stbtt_int32)ttUSHORT(classRangeRecord + 4);
            }

            classDefTable = classRangeRecords + 6 * classRangeCount;
        } break;

        default: {
            // There are no other cases.
            STBTT_assert(0);
        } break;
    }

    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzwl (%rdi), %eax
rolw $0x8, %ax
cmpw $0x2, %ax
je 0xbe64
movzwl %ax, %eax
cmpl $0x1, %eax
jne 0xbee6
movzwl 0x2(%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %esi, %ecx
subl %edx, %ecx
jl 0xbee4
movzwl 0x4(%rdi), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r8d
addl %edx, %r8d
cmpl %esi, %r8d
jbe 0xbee4
addq $0x6, %rdi
addl %ecx, %ecx
movslq %ecx, %rcx
leaq (%rdi,%rcx), %rax
leaq (%rdi,%rcx), %r8
incq %r8
jmp 0xbed8
movzwl 0x2(%rdi), %ecx
rolw $0x8, %cx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testw %cx, %cx
je 0xbee4
movzwl %cx, %ecx
addq $0x4, %rdi
decl %ecx
xorl %edx, %edx
leal (%rdx,%rcx), %r8d
movl %r8d, %r9d
sarl %r9d
andl $-0x2, %r8d
leal (%r8,%r8,2), %r8d
movslq %r8d, %r8
movzwl (%rdi,%r8), %r10d
rolw $0x8, %r10w
movzwl %r10w, %r10d
cmpl %esi, %r10d
jle 0xbeb1
decl %r9d
movl %r9d, %ecx
jmp 0xbeca
addq %rdi, %r8
movzwl 0x2(%r8), %edx
rolw $0x8, %dx
movzwl %dx, %edx
cmpl %esi, %edx
jae 0xbed0
incl %r9d
movl %r9d, %edx
cmpl %ecx, %edx
jle 0xbe81
jmp 0xbee4
leaq 0x4(%r8), %rax
addq $0x5, %r8
movzbl (%rax), %eax
movzbl (%r8), %ecx
shll $0x8, %eax
orl %ecx, %eax
popq %rbp
retq
leaq 0x2e79(%rip), %rdi      # 0xed66
leaq 0x2d74(%rip), %rsi      # 0xec68
leaq 0x3391(%rip), %rcx      # 0xf28c
movl $0x95f, %edx            # imm = 0x95F
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O3/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__tesselate_curve
static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float objspace_flatness_squared, int n)
{
   // midpoint
   float mx = (x0 + 2*x1 + x2)/4;
   float my = (y0 + 2*y1 + y2)/4;
   // versus directly drawn line
   float dx = (x0+x2)/2 - mx;
   float dy = (y0+y2)/2 - my;
   if (n > 16) // 65536 segments on one curve better be enough!
      return 1;
   if (dx*dx+dy*dy > objspace_flatness_squared) { // half-pixel error allowed... need to be smaller if AA
      stbtt__tesselate_curve(points, num_points, x0,y0, (x0+x1)/2.0f,(y0+y1)/2.0f, mx,my, objspace_flatness_squared,n+1);
      stbtt__tesselate_curve(points, num_points, mx,my, (x1+x2)/2.0f,(y1+y2)/2.0f, x2,y2, objspace_flatness_squared,n+1);
   } else {
      stbtt__add_point(points, *num_points,x2,y2);
      *num_points = *num_points+1;
   }
   return 1;
}

// Assembly:
cmpl $0x10, %edx
jg 0xc08e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %r14d
movaps %xmm3, %xmm7
movaps %xmm2, %xmm8
movq %rsi, %rbx
movq %rdi, %r15
movaps %xmm3, %xmm11
addss %xmm7, %xmm11
addss %xmm1, %xmm11
movaps %xmm2, %xmm10
addss %xmm8, %xmm10
addss %xmm0, %xmm10
incl %r14d
movss 0x2b51(%rip), %xmm9     # 0xeaa4
movss %xmm5, -0x24(%rbp)
movss %xmm4, -0x20(%rbp)
movss %xmm6, -0x1c(%rbp)
addss %xmm5, %xmm11
addss %xmm4, %xmm10
movss 0x2bb0(%rip), %xmm3     # 0xeb24
mulss %xmm3, %xmm10
mulss %xmm3, %xmm11
movaps %xmm1, %xmm2
addss %xmm5, %xmm2
mulss %xmm9, %xmm2
subss %xmm11, %xmm2
movaps %xmm0, %xmm3
addss %xmm4, %xmm3
mulss %xmm9, %xmm3
subss %xmm10, %xmm3
mulss %xmm2, %xmm2
mulss %xmm3, %xmm3
addss %xmm2, %xmm3
ucomiss %xmm6, %xmm3
jbe 0xc06b
movaps %xmm0, %xmm2
addss %xmm8, %xmm2
mulss %xmm9, %xmm2
movaps %xmm1, %xmm3
addss %xmm7, %xmm3
mulss %xmm9, %xmm3
movq %r15, %rdi
movq %rbx, %rsi
movaps %xmm10, %xmm4
movaps %xmm11, %xmm5
movss -0x1c(%rbp), %xmm6
movl %r14d, %edx
movss %xmm7, -0x34(%rbp)
movss %xmm8, -0x30(%rbp)
movss %xmm10, -0x28(%rbp)
movss %xmm11, -0x2c(%rbp)
callq 0xbf05
movss 0x2a9b(%rip), %xmm9     # 0xeaa4
movss -0x30(%rbp), %xmm8
movss -0x34(%rbp), %xmm7
movss -0x1c(%rbp), %xmm6
movss -0x20(%rbp), %xmm4
movss -0x24(%rbp), %xmm5
addss %xmm4, %xmm8
mulss %xmm9, %xmm8
addss %xmm5, %xmm7
mulss %xmm9, %xmm7
movaps %xmm8, %xmm10
addss %xmm8, %xmm10
movss -0x28(%rbp), %xmm0
addss %xmm0, %xmm10
movaps %xmm7, %xmm11
addss %xmm7, %xmm11
movss -0x2c(%rbp), %xmm1
addss %xmm1, %xmm11
incl %r14d
cmpl $0x12, %r14d
jne 0xbf62
jmp 0xc084
movslq (%rbx), %rax
testq %r15, %r15
je 0xc080
movss %xmm4, (%r15,%rax,8)
movss %xmm5, 0x4(%r15,%rax,8)
incl %eax
movl %eax, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__isfont
static int stbtt__isfont(stbtt_uint8 *font)
{
   // check the version number
   if (stbtt_tag4(font, '1',0,0,0))  return 1; // TrueType 1
   if (stbtt_tag(font, "typ1"))   return 1; // TrueType with type 1 font -- we don't support this!
   if (stbtt_tag(font, "OTTO"))   return 1; // OpenType with CFF
   if (stbtt_tag4(font, 0,1,0,0)) return 1; // OpenType 1.0
   if (stbtt_tag(font, "true"))   return 1; // Apple specification for TrueType fonts
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzbl (%rdi), %eax
cmpl $0x4e, %eax
jg 0xc6ef
testl %eax, %eax
je 0xc71a
cmpl $0x31, %eax
jne 0xc75d
cmpb $0x0, 0x1(%rdi)
jne 0xc75d
jmp 0xc720
cmpl $0x4f, %eax
je 0xc733
cmpl $0x74, %eax
jne 0xc75d
movzbl 0x1(%rdi), %eax
cmpl $0x72, %eax
je 0xc74c
cmpl $0x79, %eax
jne 0xc75d
cmpb $0x70, 0x2(%rdi)
jne 0xc75d
movl $0x1, %eax
cmpb $0x31, 0x3(%rdi)
jne 0xc75d
jmp 0xc75f
cmpb $0x1, 0x1(%rdi)
jne 0xc75d
cmpb $0x0, 0x2(%rdi)
jne 0xc75d
cmpb $0x0, 0x3(%rdi)
jne 0xc75d
movl $0x1, %eax
jmp 0xc75f
cmpb $0x54, 0x1(%rdi)
jne 0xc75d
cmpb $0x54, 0x2(%rdi)
jne 0xc75d
movl $0x1, %eax
cmpb $0x4f, 0x3(%rdi)
jne 0xc75d
jmp 0xc75f
cmpb $0x75, 0x2(%rdi)
jne 0xc75d
movl $0x1, %eax
cmpb $0x65, 0x3(%rdi)
je 0xc75f
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/comparaisons.c
// Function: generationAleatoire
Chaines* generationAleatoire(int nbChaines, int nbPointsChaine, int xmax, int ymax){
    //La CellChaine qu'on va mettre dans la structure Chaines
    CellChaine *cellChaineMain = NULL;

    //La premiere boucle pour creer nbChaines de chaines
    for (int i = 0; i < nbChaines; i++)
    {
        CellChaine *newCellChaine = calloc(1, sizeof(CellChaine));
        newCellChaine->numero = i;

        //Le CellPoint qu'on va mettre dans CellChaine
        CellPoint *cellPointMain = NULL;

        //La deuxieme boucle pour creer nbPointsChaine pour chaque CellChaine
        for (int j = 0; j < nbPointsChaine; j++)
        {
            CellPoint *newCellPoint = calloc(1,sizeof(CellPoint));

            //attribution des points entre 0 et xmax,ymax (noncompris)
            newCellPoint->x = generateRandomDouble(xmax);
            newCellPoint->y = generateRandomDouble(ymax);

            //En tete de cellPointMain
            newCellPoint->suiv = cellPointMain;
            cellPointMain = newCellPoint;
        }

        //insertions des points dans la CellChaine, puis de la CellChaine dans la tete de cellChaineMain
        newCellChaine->points = cellPointMain;
        newCellChaine->suiv = cellChaineMain;
        cellChaineMain = newCellChaine;
    }

    //Creation de la chaine
    Chaines *C = calloc(1, sizeof(Chaines));
    C->gamma = 1;
    C->nbChaines = nbChaines;
    C->chaines = cellChaineMain;

    return C;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %r12d, %r12d
movl %edi, (%rsp)
testl %edi, %edi
jle 0x16ee
movl %esi, %ebp
imull $0x64, %edx, %r13d
imull $0x64, %ecx, %ebx
xorl %eax, %eax
movl %esi, 0x4(%rsp)
movq %rax, 0x8(%rsp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x10c0
movq %rax, 0x10(%rsp)
movl %r12d, (%rax)
testl %ebp, %ebp
jle 0x16c3
xorl %r14d, %r14d
movl $0x1, %edi
movl $0x18, %esi
callq 0x10c0
movq %rax, %r15
callq 0x1120
cltd
idivl %r13d
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
movsd 0x2a40(%rip), %xmm1     # 0x40d0
divsd %xmm1, %xmm0
movsd %xmm0, (%r15)
callq 0x1120
cltd
idivl %ebx
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
divsd 0x2a20(%rip), %xmm0     # 0x40d0
movsd %xmm0, 0x8(%r15)
movq %r14, 0x10(%r15)
movq %r15, %r14
decl %ebp
jne 0x1666
jmp 0x16c6
xorl %r15d, %r15d
movq 0x10(%rsp), %r14
movq %r15, 0x8(%r14)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%r14)
incl %r12d
movq %r14, %rax
cmpl (%rsp), %r12d
movl 0x4(%rsp), %ebp
jne 0x1643
jmp 0x16f1
xorl %r14d, %r14d
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movl $0x1, (%rax)
movl (%rsp), %ecx
movl %ecx, 0x4(%rax)
movq %r14, 0x8(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop