// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/stb_truetype.h
// Function: stbtt_GetGlyphShape(stbtt_fontinfo const*, int, stbtt_vertex**)
STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)
{
   stbtt_int16 numberOfContours;
   stbtt_uint8 *endPtsOfContours;
   stbtt_uint8 *data = info->data;
   stbtt_vertex *vertices=0;
   int num_vertices=0;
   int g = stbtt__GetGlyfOffset(info, glyph_index);

   *pvertices = NULL;

   if (g < 0) return 0;

   numberOfContours = ttSHORT(data + g);

   if (numberOfContours > 0) {
      stbtt_uint8 flags=0,flagcount;
      stbtt_int32 ins, i,j=0,m,n, next_move, was_off=0, off, start_off=0;
      stbtt_int32 x,y,cx,cy,sx,sy, scx,scy;
      stbtt_uint8 *points;
      endPtsOfContours = (data + g + 10);
      ins = ttUSHORT(data + g + 10 + numberOfContours * 2);
      points = data + g + 10 + numberOfContours * 2 + 2 + ins;

      n = 1+ttUSHORT(endPtsOfContours + numberOfContours*2-2);

      m = n + 2*numberOfContours;  // a loose bound on how many vertices we might need
      vertices = (stbtt_vertex *) STBTT_malloc(m * sizeof(vertices[0]), info->userdata);
      if (vertices == 0)
         return 0;

      next_move = 0;
      flagcount=0;

      // in first pass, we load uninterpreted data into the allocated array
      // above, shifted to the end of the array so we won't overwrite it when
      // we create our final data starting from the front

      off = m - n; // starting offset for uninterpreted data, regardless of how m ends up being calculated

      // first load flags

      for (i=0; i < n; ++i) {
         if (flagcount == 0) {
            flags = *points++;
            if (flags & 8)
               flagcount = *points++;
         } else
            --flagcount;
         vertices[off+i].type = flags;
      }

      // now load x coordinates
      x=0;
      for (i=0; i < n; ++i) {
         flags = vertices[off+i].type;
         if (flags & 2) {
            stbtt_int16 dx = *points++;
            x += (flags & 16) ? dx : -dx; // ???
         } else {
            if (!(flags & 16)) {
               x = x + (stbtt_int16) (points[0]*256 + points[1]);
               points += 2;
            }
         }
         vertices[off+i].x = (stbtt_int16) x;
      }

      // now load y coordinates
      y=0;
      for (i=0; i < n; ++i) {
         flags = vertices[off+i].type;
         if (flags & 4) {
            stbtt_int16 dy = *points++;
            y += (flags & 32) ? dy : -dy; // ???
         } else {
            if (!(flags & 32)) {
               y = y + (stbtt_int16) (points[0]*256 + points[1]);
               points += 2;
            }
         }
         vertices[off+i].y = (stbtt_int16) y;
      }

      // now convert them to our format
      num_vertices=0;
      sx = sy = cx = cy = scx = scy = 0;
      for (i=0; i < n; ++i) {
         flags = vertices[off+i].type;
         x     = (stbtt_int16) vertices[off+i].x;
         y     = (stbtt_int16) vertices[off+i].y;

         if (next_move == i) {
            if (i != 0)
               num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy);

            // now start the new one               
            start_off = !(flags & 1);
            if (start_off) {
               // if we start off with an off-curve point, then when we need to find a point on the curve
               // where we can start, and we need to save some state for when we wraparound.
               scx = x;
               scy = y;
               if (!(vertices[off+i+1].type & 1)) {
                  // next point is also a curve point, so interpolate an on-point curve
                  sx = (x + (stbtt_int32) vertices[off+i+1].x) >> 1;
                  sy = (y + (stbtt_int32) vertices[off+i+1].y) >> 1;
               } else {
                  // otherwise just use the next point as our start point
                  sx = (stbtt_int32) vertices[off+i+1].x;
                  sy = (stbtt_int32) vertices[off+i+1].y;
                  ++i; // we're using point i+1 as the starting point, so skip it
               }
            } else {
               sx = x;
               sy = y;
            }
            stbtt_setvertex(&vertices[num_vertices++], STBTT_vmove,sx,sy,0,0);
            was_off = 0;
            next_move = 1 + ttUSHORT(endPtsOfContours+j*2);
            ++j;
         } else {
            if (!(flags & 1)) { // if it's a curve
               if (was_off) // two off-curve control points in a row means interpolate an on-curve midpoint
                  stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+x)>>1, (cy+y)>>1, cx, cy);
               cx = x;
               cy = y;
               was_off = 1;
            } else {
               if (was_off)
                  stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, x,y, cx, cy);
               else
                  stbtt_setvertex(&vertices[num_vertices++], STBTT_vline, x,y,0,0);
               was_off = 0;
            }
         }
      }
      num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy);
   } else if (numberOfContours == -1) {
      // Compound shapes.
      int more = 1;
      stbtt_uint8 *comp = data + g + 10;
      num_vertices = 0;
      vertices = 0;
      while (more) {
         stbtt_uint16 flags, gidx;
         int comp_num_verts = 0, i;
         stbtt_vertex *comp_verts = 0, *tmp = 0;
         float mtx[6] = {1,0,0,1,0,0}, m, n;
         
         flags = ttSHORT(comp); comp+=2;
         gidx = ttSHORT(comp); comp+=2;

         if (flags & 2) { // XY values
            if (flags & 1) { // shorts
               mtx[4] = ttSHORT(comp); comp+=2;
               mtx[5] = ttSHORT(comp); comp+=2;
            } else {
               mtx[4] = ttCHAR(comp); comp+=1;
               mtx[5] = ttCHAR(comp); comp+=1;
            }
         }
         else {
            // @TODO handle matching point
            STBTT_assert(0);
         }
         if (flags & (1<<3)) { // WE_HAVE_A_SCALE
            mtx[0] = mtx[3] = ttSHORT(comp)/16384.0f; comp+=2;
            mtx[1] = mtx[2] = 0;
         } else if (flags & (1<<6)) { // WE_HAVE_AN_X_AND_YSCALE
            mtx[0] = ttSHORT(comp)/16384.0f; comp+=2;
            mtx[1] = mtx[2] = 0;
            mtx[3] = ttSHORT(comp)/16384.0f; comp+=2;
         } else if (flags & (1<<7)) { // WE_HAVE_A_TWO_BY_TWO
            mtx[0] = ttSHORT(comp)/16384.0f; comp+=2;
            mtx[1] = ttSHORT(comp)/16384.0f; comp+=2;
            mtx[2] = ttSHORT(comp)/16384.0f; comp+=2;
            mtx[3] = ttSHORT(comp)/16384.0f; comp+=2;
         }
         
         // Find transformation scales.
         m = (float) STBTT_sqrt(mtx[0]*mtx[0] + mtx[1]*mtx[1]);
         n = (float) STBTT_sqrt(mtx[2]*mtx[2] + mtx[3]*mtx[3]);

         // Get indexed glyph.
         comp_num_verts = stbtt_GetGlyphShape(info, gidx, &comp_verts);
         if (comp_num_verts > 0) {
            // Transform vertices.
            for (i = 0; i < comp_num_verts; ++i) {
               stbtt_vertex* v = &comp_verts[i];
               stbtt_vertex_type x,y;
               x=v->x; y=v->y;
               v->x = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4]));
               v->y = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5]));
               x=v->cx; y=v->cy;
               v->cx = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4]));
               v->cy = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5]));
            }
            // Append vertices.
            tmp = (stbtt_vertex*)STBTT_malloc((num_vertices+comp_num_verts)*sizeof(stbtt_vertex), info->userdata);
            if (!tmp) {
               if (vertices) STBTT_free(vertices, info->userdata);
               if (comp_verts) STBTT_free(comp_verts, info->userdata);
               return 0;
            }
            if (num_vertices > 0) STBTT_memcpy(tmp, vertices, num_vertices*sizeof(stbtt_vertex));
            STBTT_memcpy(tmp+num_vertices, comp_verts, comp_num_verts*sizeof(stbtt_vertex));
            if (vertices) STBTT_free(vertices, info->userdata);
            vertices = tmp;
            STBTT_free(comp_verts, info->userdata);
            num_vertices += comp_num_verts;
         }
         // More components ?
         more = flags & (1<<5);
      }
   } else if (numberOfContours < 0) {
      // @TODO other compound variations?
      STBTT_assert(0);
   } else {
      // numberOfCounters == 0, do nothing
   }

   *pvertices = vertices;
   return num_vertices;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rdi, %r12
movq 0x8(%rdi), %rbx
callq 0x35c4d
movq %r14, -0x88(%rbp)
movq $0x0, (%r14)
xorl %r13d, %r13d
testl %eax, %eax
js 0x3645e
movl %eax, %eax
leaq (%rbx,%rax), %rdx
movzbl (%rbx,%rax), %ecx
movzbl 0x1(%rbx,%rax), %eax
shll $0x8, %ecx
orl %ecx, %eax
testw %ax, %ax
jle 0x3609c
leal (%rax,%rax), %ebx
movzbl 0xa(%rdx,%rbx), %r15d
movzbl 0xb(%rdx,%rbx), %ecx
movq %rcx, -0x60(%rbp)
movzbl 0x8(%rdx,%rbx), %r14d
movzbl 0x9(%rdx,%rbx), %ecx
shll $0x8, %r14d
movq %rcx, -0x40(%rbp)
addl %r14d, %ecx
movq %rcx, -0x70(%rbp)
leal (%rcx,%rax,2), %eax
leal (%rax,%rax,4), %eax
leal 0xa(,%rax,2), %edi
movq %rdx, %r12
callq 0x8589
testq %rax, %rax
je 0x3645e
movq %rax, %rdi
leaq (%r12,%rbx), %rax
addq $0xa, %rax
addq $0xa, %r12
movq %r12, -0x78(%rbp)
shll $0x8, %r15d
addq -0x60(%rbp), %r15
addq %r15, %rax
addq $0x2, %rax
movzwl %bx, %ecx
leaq (%rcx,%rcx,4), %rcx
leaq (%rdi,%rcx,2), %rcx
addq $0x8, %rcx
addl -0x40(%rbp), %r14d
leal 0x2(,%r14,2), %edx
leaq (%rdx,%rdx,4), %rdx
xorl %esi, %esi
xorl %r9d, %r9d
xorl %r8d, %r8d
testb %r8b, %r8b
je 0x35da5
decb %r8b
jmp 0x35dbe
movb (%rax), %r9b
testb $0x8, %r9b
jne 0x35db6
incq %rax
xorl %r8d, %r8d
jmp 0x35dbe
movb 0x1(%rax), %r8b
addq $0x2, %rax
movb %r9b, (%rcx,%rsi)
addq $0xa, %rsi
cmpq %rsi, %rdx
jne 0x35d9b
movq %rbx, -0x68(%rbp)
leal 0x2(,%r14,2), %edx
leaq (%rdx,%rdx,4), %rdx
xorl %esi, %esi
xorl %r11d, %r11d
movzbl (%rcx,%rsi), %r8d
testb $0x2, %r8b
jne 0x35e03
testb $0x10, %r8b
jne 0x35e1b
movzwl (%rax), %r8d
rolw $0x8, %r8w
addl %r8d, %r11d
addq $0x2, %rax
jmp 0x35e1b
movzbl (%rax), %r9d
incq %rax
movl %r9d, %r10d
negl %r10d
testb $0x10, %r8b
cmovnel %r9d, %r10d
addl %r10d, %r11d
movw %r11w, -0x8(%rcx,%rsi)
addq $0xa, %rsi
cmpq %rsi, %rdx
jne 0x35de0
leal 0x2(,%r14,2), %edx
leaq (%rdx,%rdx,4), %rdx
xorl %esi, %esi
xorl %r11d, %r11d
movzbl (%rcx,%rsi), %r8d
testb $0x4, %r8b
jne 0x35e5e
testb $0x20, %r8b
jne 0x35e76
movzwl (%rax), %r8d
rolw $0x8, %r8w
addl %r8d, %r11d
addq $0x2, %rax
jmp 0x35e76
movzbl (%rax), %r9d
incq %rax
movl %r9d, %r10d
negl %r10d
testb $0x20, %r8b
cmovnel %r9d, %r10d
addl %r10d, %r11d
movw %r11w, -0x6(%rcx,%rsi)
addq $0xa, %rsi
cmpq %rsi, %rdx
jne 0x35e3b
xorl %esi, %esi
xorl %r12d, %r12d
movq $0x0, -0x58(%rbp)
xorl %ecx, %ecx
movq $0x0, -0x60(%rbp)
movq $0x0, -0x40(%rbp)
xorl %r9d, %r9d
xorl %r8d, %r8d
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x0, -0x44(%rbp)
xorl %edx, %edx
movq %rdi, -0x50(%rbp)
movq -0x68(%rbp), %r11
leal (%r12,%r11), %eax
cltq
leaq (%rax,%rax,4), %r14
movzbl 0x8(%rdi,%r14,2), %r13d
movzwl (%rdi,%r14,2), %r10d
movzwl 0x2(%rdi,%r14,2), %eax
movswl %r10w, %r15d
movswl %ax, %ebx
cmpl %r12d, %ecx
jne 0x35f3e
testl %r12d, %r12d
je 0x35f11
movl -0x44(%rbp), %ecx
pushq -0x30(%rbp)
pushq -0x38(%rbp)
pushq -0x60(%rbp)
pushq -0x40(%rbp)
callq 0x364c8
addq $0x20, %rsp
movl %eax, %esi
movq -0x78(%rbp), %rcx
movq -0x58(%rbp), %rdx
andl $0x1, %r13d
je 0x35fc1
movl %r15d, %r8d
movl %ebx, %r9d
movq -0x40(%rbp), %r15
movq -0x60(%rbp), %rbx
movq -0x50(%rbp), %rdi
movq -0x68(%rbp), %r11
jmp 0x3601d
testb $0x1, %r13b
jne 0x35f93
testl %edx, %edx
je 0x35f81
movslq %esi, %rdx
incl %esi
leaq (%rdx,%rdx,4), %rdx
movq -0x38(%rbp), %r14
leal (%r14,%r15), %eax
shrl %eax
movq -0x30(%rbp), %r13
leal (%rbx,%r13), %r10d
shrl %r10d
movb $0x3, 0x8(%rdi,%rdx,2)
movw %ax, (%rdi,%rdx,2)
movw %r10w, 0x2(%rdi,%rdx,2)
movw %r14w, 0x4(%rdi,%rdx,2)
movw %r13w, 0x6(%rdi,%rdx,2)
movl $0x1, %edx
movq %r15, -0x38(%rbp)
movq %rbx, -0x30(%rbp)
jmp 0x36066
movslq %esi, %r11
leaq (%r11,%r11,4), %r11
leaq (%rdi,%r11,2), %r11
testl %edx, %edx
je 0x35feb
movb $0x3, 0x8(%r11)
movw %r10w, (%r11)
movw %ax, 0x2(%r11)
movq -0x38(%rbp), %rax
movw %ax, 0x4(%r11)
movq -0x30(%rbp), %rax
movl %eax, %edx
jmp 0x36002
movq -0x50(%rbp), %rdi
leaq (%rdi,%r14,2), %rax
movswl 0xa(%rax), %r8d
testb $0x1, 0x12(%rax)
movq -0x68(%rbp), %r11
jne 0x36015
addl %r15d, %r8d
sarl %r8d
movswl 0xc(%rax), %r9d
addl %ebx, %r9d
sarl %r9d
jmp 0x3601d
movb $0x2, 0x8(%r11)
movw %r10w, (%r11)
movw %ax, 0x2(%r11)
movw $0x0, 0x4(%r11)
xorl %edx, %edx
movw %dx, 0x6(%r11)
incl %esi
xorl %edx, %edx
movq -0x50(%rbp), %rdi
movq -0x68(%rbp), %r11
jmp 0x36066
movswl 0xc(%rax), %r9d
incl %r12d
xorl $0x1, %r13d
movslq %esi, %rax
leaq (%rax,%rax,4), %rax
movb $0x1, 0x8(%rdi,%rax,2)
movw %r8w, (%rdi,%rax,2)
movw %r9w, 0x2(%rdi,%rax,2)
movl $0x0, 0x4(%rdi,%rax,2)
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %eax
rolw $0x8, %ax
incl %esi
movzwl %ax, %ecx
incl %ecx
incl %edx
movq %rdx, -0x58(%rbp)
xorl %edx, %edx
movl %r13d, -0x44(%rbp)
movq %r15, -0x40(%rbp)
movq %rbx, -0x60(%rbp)
leal 0x1(%r12), %eax
cmpl -0x70(%rbp), %r12d
movl %eax, %r12d
jl 0x35ecb
movl -0x44(%rbp), %ecx
pushq -0x30(%rbp)
pushq -0x38(%rbp)
pushq -0x60(%rbp)
pushq -0x40(%rbp)
callq 0x364c8
movq -0x50(%rbp), %r15
addq $0x20, %rsp
movl %eax, %r13d
jmp 0x36454
cmpw $-0x1, %ax
je 0x360b6
testw %cx, %cx
js 0x364a9
xorl %r13d, %r13d
xorl %r15d, %r15d
jmp 0x36454
addq $0xa, %rdx
xorl %r14d, %r14d
xorl %ecx, %ecx
movq %r12, -0x68(%rbp)
movq $0x0, -0x80(%rbp)
movzbl 0x1(%rdx), %ebx
testb $0x2, %bl
je 0x3648a
movzbl 0x4(%rdx), %eax
testb $0x1, %bl
movl %ecx, %r15d
jne 0x36100
movsbl %al, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movsbl 0x5(%rdx), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
movl $0x6, %ecx
jmp 0x36129
movzbl 0x5(%rdx), %ecx
movzwl %ax, %eax
shll $0x8, %eax
orl %ecx, %eax
cwtl
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movzwl 0x6(%rdx), %eax
rolw $0x8, %ax
cwtl
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
movl $0x8, %ecx
addq %rdx, %rcx
testb $0x8, %bl
movss %xmm0, -0x60(%rbp)
movss %xmm1, -0x50(%rbp)
jne 0x36173
testb $0x40, %bl
jne 0x361ae
testb %bl, %bl
js 0x361fe
xorps %xmm2, %xmm2
movss %xmm2, -0x58(%rbp)
movq %rcx, -0x40(%rbp)
movss 0x7234(%rip), %xmm0     # 0x3d390
movss %xmm0, -0x38(%rbp)
xorps %xmm1, %xmm1
movss %xmm1, -0x30(%rbp)
movss %xmm0, -0x70(%rbp)
jmp 0x36271
movzwl (%rcx), %eax
rolw $0x8, %ax
cwtl
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
mulss 0xc652(%rip), %xmm1     # 0x427dc
addq $0x2, %rcx
movq %rcx, -0x40(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x58(%rbp)
movss %xmm0, -0x30(%rbp)
movss %xmm1, -0x38(%rbp)
movss %xmm1, -0x70(%rbp)
jmp 0x36271
movzwl (%rcx), %eax
rolw $0x8, %ax
cwtl
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
movzwl 0x2(%rcx), %eax
movss 0xc613(%rip), %xmm0     # 0x427dc
mulss %xmm0, %xmm1
movss %xmm1, -0x70(%rbp)
rolw $0x8, %ax
cwtl
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, -0x38(%rbp)
addq $0x4, %rcx
movq %rcx, -0x40(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x58(%rbp)
movss %xmm0, -0x30(%rbp)
jmp 0x36271
movzwl (%rcx), %eax
rolw $0x8, %ax
cwtl
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
movzwl 0x2(%rcx), %eax
rolw $0x8, %ax
cwtl
xorps %xmm3, %xmm3
cvtsi2ss %eax, %xmm3
movzwl 0x4(%rcx), %eax
rolw $0x8, %ax
cwtl
xorps %xmm2, %xmm2
cvtsi2ss %eax, %xmm2
movss 0xc5a7(%rip), %xmm0     # 0x427dc
mulss %xmm0, %xmm1
movss %xmm1, -0x70(%rbp)
movzwl 0x6(%rcx), %eax
rolw $0x8, %ax
cwtl
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
mulss %xmm0, %xmm3
movss %xmm3, -0x30(%rbp)
mulss %xmm0, %xmm2
movss %xmm2, -0x58(%rbp)
mulss %xmm0, %xmm1
movss %xmm1, -0x38(%rbp)
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movzwl 0x2(%rdx), %eax
rolw $0x8, %ax
movzwl %ax, %esi
movq %r12, %rdi
leaq -0x80(%rbp), %rdx
callq 0x35cb2
testl %eax, %eax
jle 0x3643e
movl %eax, %r13d
movl %ebx, -0x44(%rbp)
movss -0x30(%rbp), %xmm11
movaps %xmm11, %xmm0
mulss %xmm11, %xmm0
movss -0x70(%rbp), %xmm8
movaps %xmm8, %xmm1
mulss %xmm8, %xmm1
addss %xmm0, %xmm1
xorps %xmm0, %xmm0
sqrtss %xmm1, %xmm0
movss -0x38(%rbp), %xmm10
movaps %xmm10, %xmm1
mulss %xmm10, %xmm1
movss -0x58(%rbp), %xmm9
movaps %xmm9, %xmm2
mulss %xmm9, %xmm2
addss %xmm1, %xmm2
xorps %xmm1, %xmm1
sqrtss %xmm2, %xmm1
movq -0x80(%rbp), %rbx
movl %eax, %eax
addq %rax, %rax
leaq (%rax,%rax,4), %r12
xorl %eax, %eax
movss -0x60(%rbp), %xmm6
movss -0x50(%rbp), %xmm7
movswl (%rbx,%rax), %ecx
xorps %xmm2, %xmm2
cvtsi2ss %ecx, %xmm2
movswl 0x2(%rbx,%rax), %ecx
xorps %xmm3, %xmm3
cvtsi2ss %ecx, %xmm3
movaps %xmm9, %xmm4
mulss %xmm3, %xmm4
movaps %xmm8, %xmm5
mulss %xmm2, %xmm5
addss %xmm4, %xmm5
addss %xmm6, %xmm5
mulss %xmm0, %xmm5
cvttss2si %xmm5, %ecx
movw %cx, (%rbx,%rax)
mulss %xmm10, %xmm3
mulss %xmm11, %xmm2
addss %xmm3, %xmm2
addss %xmm7, %xmm2
mulss %xmm1, %xmm2
cvttss2si %xmm2, %ecx
movw %cx, 0x2(%rbx,%rax)
movswl 0x4(%rbx,%rax), %ecx
movswl 0x6(%rbx,%rax), %edx
xorps %xmm2, %xmm2
cvtsi2ss %ecx, %xmm2
xorps %xmm3, %xmm3
cvtsi2ss %edx, %xmm3
movaps %xmm9, %xmm4
mulss %xmm3, %xmm4
movaps %xmm8, %xmm5
mulss %xmm2, %xmm5
addss %xmm4, %xmm5
addss %xmm6, %xmm5
mulss %xmm0, %xmm5
cvttss2si %xmm5, %ecx
mulss %xmm10, %xmm3
mulss %xmm11, %xmm2
addss %xmm3, %xmm2
addss %xmm7, %xmm2
mulss %xmm1, %xmm2
cvttss2si %xmm2, %edx
movw %cx, 0x4(%rbx,%rax)
movw %dx, 0x6(%rbx,%rax)
addq $0xa, %rax
cmpq %rax, %r12
jne 0x36301
addl %r15d, %r13d
leaq (,%r13,2), %rax
leaq (%rax,%rax,4), %rdi
callq 0x8589
testq %rax, %rax
je 0x36470
movq %rax, %rdi
movl %r15d, %eax
movl %r15d, %r15d
testl %eax, %eax
movq %rdi, -0x50(%rbp)
jle 0x36406
leaq (%r15,%r15), %rax
leaq (%rax,%rax,4), %rdx
movq %r14, %rsi
callq 0x7080
movq -0x50(%rbp), %rdi
leaq (%r15,%r15,4), %rax
leaq (%rdi,%rax,2), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x7080
testq %r14, %r14
je 0x36426
movq %r14, %rdi
callq 0x9019
movq %rbx, %rdi
callq 0x9019
movq -0x50(%rbp), %r15
movq %r15, %r14
movq -0x68(%rbp), %r12
movl -0x44(%rbp), %ebx
jmp 0x36444
movl %r15d, %r13d
movq %r14, %r15
movl %r13d, %ecx
movq -0x40(%rbp), %rdx
testb $0x20, %bl
jne 0x360c3
movq -0x88(%rbp), %rax
movq %r15, (%rax)
movl %r13d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %r14, %r14
je 0x3647d
movq %r14, %rdi
callq 0x9019
movq %rbx, %rdi
callq 0x9019
xorl %r13d, %r13d
jmp 0x3645e
leaq 0x87b1(%rip), %rdi      # 0x3ec42
leaq 0x1084d(%rip), %rsi     # 0x46ce5
leaq 0x10a30(%rip), %rcx     # 0x46ecf
movl $0x570, %edx            # imm = 0x570
callq 0x7140
leaq 0x8792(%rip), %rdi      # 0x3ec42
leaq 0x1082e(%rip), %rsi     # 0x46ce5
leaq 0x10a11(%rip), %rcx     # 0x46ecf
movl $0x5a5, %edx            # imm = 0x5A5
callq 0x7140