// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: stbtt__fill_active_edges_new
static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, int len, stbtt__active_edge *e, float y_top)
{
   float y_bottom = y_top+1;

   while (e) {
      /*  brute force every pixel */

      /*  compute intersection points with top & bottom */
      STBTT_assert(e->ey >= y_top);

      if (e->fdx == 0) {
         float x0 = e->fx;
         if (x0 < len) {
            if (x0 >= 0) {
               stbtt__handle_clipped_edge(scanline,(int) x0,e, x0,y_top, x0,y_bottom);
               stbtt__handle_clipped_edge(scanline_fill-1,(int) x0+1,e, x0,y_top, x0,y_bottom);
            } else {
               stbtt__handle_clipped_edge(scanline_fill-1,0,e, x0,y_top, x0,y_bottom);
            }
         }
      } else {
         float x0 = e->fx;
         float dx = e->fdx;
         float xb = x0 + dx;
         float x_top, x_bottom;
         float sy0,sy1;
         float dy = e->fdy;
         STBTT_assert(e->sy <= y_bottom && e->ey >= y_top);

         /*  compute endpoints of line segment clipped to this scanline (if the */
         /*  line segment starts on this scanline. x0 is the intersection of the */
         /*  line with y_top, but that may be off the line segment. */
         if (e->sy > y_top) {
            x_top = x0 + dx * (e->sy - y_top);
            sy0 = e->sy;
         } else {
            x_top = x0;
            sy0 = y_top;
         }
         if (e->ey < y_bottom) {
            x_bottom = x0 + dx * (e->ey - y_top);
            sy1 = e->ey;
         } else {
            x_bottom = xb;
            sy1 = y_bottom;
         }

         if (x_top >= 0 && x_bottom >= 0 && x_top < len && x_bottom < len) {
            /*  from here on, we don't have to range check x values */

            if ((int) x_top == (int) x_bottom) {
               float height;
               /*  simple case, only spans one pixel */
               int x = (int) x_top;
               height = (sy1 - sy0) * e->direction;
               STBTT_assert(x >= 0 && x < len);
               scanline[x]      += stbtt__position_trapezoid_area(height, x_top, x+1.0f, x_bottom, x+1.0f);
               scanline_fill[x] += height; /*  everything right of this pixel is filled */
            } else {
               int x,x1,x2;
               float y_crossing, y_final, step, sign, area;
               /*  covers 2+ pixels */
               if (x_top > x_bottom) {
                  /*  flip scanline vertically; signed area is the same */
                  float t;
                  sy0 = y_bottom - (sy0 - y_top);
                  sy1 = y_bottom - (sy1 - y_top);
                  t = sy0, sy0 = sy1, sy1 = t;
                  t = x_bottom, x_bottom = x_top, x_top = t;
                  dx = -dx;
                  dy = -dy;
                  t = x0, x0 = xb, xb = t;
               }
               STBTT_assert(dy >= 0);
               STBTT_assert(dx >= 0);

               x1 = (int) x_top;
               x2 = (int) x_bottom;
               /*  compute intersection with y axis at x1+1 */
               y_crossing = y_top + dy * (x1+1 - x0);

               /*  compute intersection with y axis at x2 */
               y_final = y_top + dy * (x2 - x0);

               /*            x1    x_top                            x2    x_bottom */
               /*      y_top  +------|-----+------------+------------+--------|---+------------+ */
               /*             |            |            |            |            |            | */
               /*             |            |            |            |            |            | */
               /*        sy0  |      Txxxxx|............|............|............|............| */
               /*  y_crossing |            *xxxxx.......|............|............|............| */
               /*             |            |     xxxxx..|............|............|............| */
               /*             |            |     /-   xx*xxxx........|............|............| */
               /*             |            | dy <       |    xxxxxx..|............|............| */
               /*    y_final  |            |     \-     |          xx*xxx.........|............| */
               /*        sy1  |            |            |            |   xxxxxB...|............| */
               /*             |            |            |            |            |            | */
               /*             |            |            |            |            |            | */
               /*   y_bottom  +------------+------------+------------+------------+------------+ */
               /*  */
               /*  goal is to measure the area covered by '.' in each pixel */

               /*  if x2 is right at the right edge of x1, y_crossing can blow up, github #1057 */
               /*  @TODO: maybe test against sy1 rather than y_bottom? */
               if (y_crossing > y_bottom)
                  y_crossing = y_bottom;

               sign = e->direction;

               /*  area of the rectangle covered from sy0..y_crossing */
               area = sign * (y_crossing-sy0);

               /*  area of the triangle (x_top,sy0), (x1+1,sy0), (x1+1,y_crossing) */
               scanline[x1] += stbtt__sized_triangle_area(area, x1+1 - x_top);

               /*  check if final y_crossing is blown up; no test case for this */
               if (y_final > y_bottom) {
                  y_final = y_bottom;
                  dy = (y_final - y_crossing ) / (x2 - (x1+1)); /*  if denom=0, y_final = y_crossing, so y_final <= y_bottom */
               }

               /*  in second pixel, area covered by line segment found in first pixel */
               /*  is always a rectangle 1 wide * the height of that line segment; this */
               /*  is exactly what the variable 'area' stores. it also gets a contribution */
               /*  from the line segment within it. the THIRD pixel will get the first */
               /*  pixel's rectangle contribution, the second pixel's rectangle contribution, */
               /*  and its own contribution. the 'own contribution' is the same in every pixel except */
               /*  the leftmost and rightmost, a trapezoid that slides down in each pixel. */
               /*  the second pixel's contribution to the third pixel will be the */
               /*  rectangle 1 wide times the height change in the second pixel, which is dy. */

               step = sign * dy * 1; /*  dy is dy/dx, change in y for every 1 change in x, */
               /*  which multiplied by 1-pixel-width is how much pixel area changes for each step in x */
               /*  so the area advances by 'step' every time */

               for (x = x1+1; x < x2; ++x) {
                  scanline[x] += area + step/2; /*  area of trapezoid is 1*step/2 */
                  area += step;
               }
               STBTT_assert(STBTT_fabs(area) <= 1.01f); /*  accumulated error from area += step unless we round step down */
               STBTT_assert(sy1 > y_final-0.01f);

               /*  area covered in the last pixel is the rectangle from all the pixels to the left, */
               /*  plus the trapezoid filled by the line segment in this pixel all the way to the right edge */
               scanline[x2] += area + sign * stbtt__position_trapezoid_area(sy1-y_final, (float) x2, x2+1.0f, x_bottom, x2+1.0f);

               /*  the rest of the line is filled based on the total height of the line segment in this pixel */
               scanline_fill[x2] += sign * (sy1-sy0);
            }
         } else {
            /*  if edge goes outside of box we're drawing, we require */
            /*  clipping logic. since this does not match the intended use */
            /*  of this library, we use a different, very slow brute */
            /*  force implementation */
            /*  note though that this does happen some of the time because */
            /*  x_top and x_bottom can be extrapolated at the top & bottom of */
            /*  the shape and actually lie outside the bounding box */
            int x;
            for (x=0; x < len; ++x) {
               /*  cases: */
               /*  */
               /*  there can be up to two intersections with the pixel. any intersection */
               /*  with left or right edges can be handled by splitting into two (or three) */
               /*  regions. intersections with top & bottom do not necessitate case-wise logic. */
               /*  */
               /*  the old way of doing this found the intersections with the left & right edges, */
               /*  then used some simple logic to produce up to three segments in sorted order */
               /*  from top-to-bottom. however, this had a problem: if an x edge was epsilon */
               /*  across the x border, then the corresponding y position might not be distinct */
               /*  from the other y segment, and it might ignored as an empty segment. to avoid */
               /*  that, we need to explicitly produce segments based on x positions. */

               /*  rename variables to clearly-defined pairs */
               float y0 = y_top;
               float x1 = (float) (x);
               float x2 = (float) (x+1);
               float x3 = xb;
               float y3 = y_bottom;

               /*  x = e->x + e->dx * (y-y_top) */
               /*  (y-y_top) = (x - e->x) / e->dx */
               /*  y = (x - e->x) / e->dx + y_top */
               float y1 = (x - x0) / dx + y_top;
               float y2 = (x+1 - x0) / dx + y_top;

               if (x0 < x1 && x3 > x2) {         /*  three segments descending down-right */
                  stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1);
                  stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x2,y2);
                  stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3);
               } else if (x3 < x1 && x0 > x2) {  /*  three segments descending down-left */
                  stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2);
                  stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x1,y1);
                  stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3);
               } else if (x0 < x1 && x3 > x1) {  /*  two segments across x, down-right */
                  stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1);
                  stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3);
               } else if (x3 < x1 && x0 > x1) {  /*  two segments across x, down-left */
                  stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1);
                  stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3);
               } else if (x0 < x2 && x3 > x2) {  /*  two segments across x+1, down-right */
                  stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2);
                  stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3);
               } else if (x3 < x2 && x0 > x2) {  /*  two segments across x+1, down-left */
                  stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2);
                  stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3);
               } else {  /*  one segment */
                  stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x3,y3);
               }
            }
         }
      }
      e = e->next;
   }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movl %edx, 0x94(%rsp)
movq %rcx, 0x88(%rsp)
movss %xmm0, 0x84(%rsp)
movss 0x2b2a1(%rip), %xmm0    # 0xad4e8
addss 0x84(%rsp), %xmm0
movss %xmm0, 0x80(%rsp)
cmpq $0x0, 0x88(%rsp)
je 0x82f61
movq 0x88(%rsp), %rax
movss 0x1c(%rax), %xmm0
ucomiss 0x84(%rsp), %xmm0
jb 0x82281
jmp 0x822a0
leaq 0x2fa1b(%rip), %rdi     # 0xb1ca3
leaq 0x2f12f(%rip), %rsi     # 0xb13be
movl $0x38d3, %edx           # imm = 0x38D3
leaq 0x2f99d(%rip), %rcx     # 0xb1c38
callq 0x13b40
movq 0x88(%rsp), %rax
movss 0xc(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x823b3
jp 0x823b3
movq 0x88(%rsp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, 0x7c(%rsp)
movss 0x7c(%rsp), %xmm1
cvtsi2ssl 0x94(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x823ae
movss 0x7c(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x82373
movq 0xa0(%rsp), %rdi
cvttss2si 0x7c(%rsp), %esi
movq 0x88(%rsp), %rdx
movss 0x7c(%rsp), %xmm0
movss 0x84(%rsp), %xmm1
movss 0x7c(%rsp), %xmm2
movss 0x80(%rsp), %xmm3
callq 0x830f0
movq 0x98(%rsp), %rdi
addq $-0x4, %rdi
cvttss2si 0x7c(%rsp), %esi
addl $0x1, %esi
movq 0x88(%rsp), %rdx
movss 0x7c(%rsp), %xmm0
movss 0x84(%rsp), %xmm1
movss 0x7c(%rsp), %xmm2
movss 0x80(%rsp), %xmm3
callq 0x830f0
jmp 0x823ac
movq 0x98(%rsp), %rdi
addq $-0x4, %rdi
movq 0x88(%rsp), %rdx
movss 0x7c(%rsp), %xmm0
movss 0x84(%rsp), %xmm1
movss 0x7c(%rsp), %xmm2
movss 0x80(%rsp), %xmm3
xorl %esi, %esi
callq 0x830f0
jmp 0x823ae
jmp 0x82f49
movq 0x88(%rsp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, 0x78(%rsp)
movq 0x88(%rsp), %rax
movss 0xc(%rax), %xmm0
movss %xmm0, 0x74(%rsp)
movss 0x78(%rsp), %xmm0
addss 0x74(%rsp), %xmm0
movss %xmm0, 0x70(%rsp)
movq 0x88(%rsp), %rax
movss 0x10(%rax), %xmm0
movss %xmm0, 0x5c(%rsp)
movq 0x88(%rsp), %rax
movss 0x18(%rax), %xmm1
movss 0x80(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jb 0x82432
movq 0x88(%rsp), %rax
movss 0x1c(%rax), %xmm0
ucomiss 0x84(%rsp), %xmm0
jb 0x82432
jmp 0x82451
leaq 0x2f855(%rip), %rdi     # 0xb1c8e
leaq 0x2ef7e(%rip), %rsi     # 0xb13be
movl $0x38e6, %edx           # imm = 0x38E6
leaq 0x2f7ec(%rip), %rcx     # 0xb1c38
callq 0x13b40
movq 0x88(%rsp), %rax
movss 0x18(%rax), %xmm0
ucomiss 0x84(%rsp), %xmm0
jbe 0x824ad
movss 0x78(%rsp), %xmm1
movss 0x74(%rsp), %xmm0
movq 0x88(%rsp), %rax
movss 0x18(%rax), %xmm2
subss 0x84(%rsp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x6c(%rsp)
movq 0x88(%rsp), %rax
movss 0x18(%rax), %xmm0
movss %xmm0, 0x64(%rsp)
jmp 0x824c8
movss 0x78(%rsp), %xmm0
movss %xmm0, 0x6c(%rsp)
movss 0x84(%rsp), %xmm0
movss %xmm0, 0x64(%rsp)
movq 0x88(%rsp), %rax
movss 0x1c(%rax), %xmm1
movss 0x80(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x82528
movss 0x78(%rsp), %xmm1
movss 0x74(%rsp), %xmm0
movq 0x88(%rsp), %rax
movss 0x1c(%rax), %xmm2
subss 0x84(%rsp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x68(%rsp)
movq 0x88(%rsp), %rax
movss 0x1c(%rax), %xmm0
movss %xmm0, 0x60(%rsp)
jmp 0x82543
movss 0x70(%rsp), %xmm0
movss %xmm0, 0x68(%rsp)
movss 0x80(%rsp), %xmm0
movss %xmm0, 0x60(%rsp)
movss 0x6c(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x82ac4
movss 0x68(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x82ac4
movss 0x6c(%rsp), %xmm1
cvtsi2ssl 0x94(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x82ac4
movss 0x68(%rsp), %xmm1
cvtsi2ssl 0x94(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x82ac4
cvttss2si 0x6c(%rsp), %eax
cvttss2si 0x68(%rsp), %ecx
cmpl %ecx, %eax
jne 0x8267d
cvttss2si 0x6c(%rsp), %eax
movl %eax, 0x54(%rsp)
movss 0x60(%rsp), %xmm0
subss 0x64(%rsp), %xmm0
movq 0x88(%rsp), %rax
mulss 0x14(%rax), %xmm0
movss %xmm0, 0x58(%rsp)
cmpl $0x0, 0x54(%rsp)
jl 0x825ea
movl 0x54(%rsp), %eax
cmpl 0x94(%rsp), %eax
jge 0x825ea
jmp 0x82609
leaq 0x2f6c1(%rip), %rdi     # 0xb1cb2
leaq 0x2edc6(%rip), %rsi     # 0xb13be
movl $0x3902, %edx           # imm = 0x3902
leaq 0x2f634(%rip), %rcx     # 0xb1c38
callq 0x13b40
movss 0x58(%rsp), %xmm0
movss 0x6c(%rsp), %xmm1
cvtsi2ssl 0x54(%rsp), %xmm2
movss 0x2aec5(%rip), %xmm3    # 0xad4e8
addss %xmm3, %xmm2
movss 0x68(%rsp), %xmm3
cvtsi2ssl 0x54(%rsp), %xmm4
movss 0x2aead(%rip), %xmm5    # 0xad4e8
addss %xmm5, %xmm4
callq 0x83580
movq 0xa0(%rsp), %rax
movslq 0x54(%rsp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movss 0x58(%rsp), %xmm0
movq 0x98(%rsp), %rax
movslq 0x54(%rsp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x82abf
movss 0x6c(%rsp), %xmm0
ucomiss 0x68(%rsp), %xmm0
jbe 0x82770
movss 0x80(%rsp), %xmm0
movss 0x64(%rsp), %xmm1
subss 0x84(%rsp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, 0x64(%rsp)
movss 0x80(%rsp), %xmm0
movss 0x60(%rsp), %xmm1
subss 0x84(%rsp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, 0x60(%rsp)
movss 0x64(%rsp), %xmm0
movss %xmm0, 0x30(%rsp)
movss 0x60(%rsp), %xmm0
movss %xmm0, 0x64(%rsp)
movss 0x30(%rsp), %xmm0
movss %xmm0, 0x60(%rsp)
movss 0x68(%rsp), %xmm0
movss %xmm0, 0x30(%rsp)
movss 0x6c(%rsp), %xmm0
movss %xmm0, 0x68(%rsp)
movss 0x30(%rsp), %xmm0
movss %xmm0, 0x6c(%rsp)
movss 0x74(%rsp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, 0x74(%rsp)
movss 0x5c(%rsp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, 0x5c(%rsp)
movss 0x78(%rsp), %xmm0
movss %xmm0, 0x30(%rsp)
movss 0x70(%rsp), %xmm0
movss %xmm0, 0x78(%rsp)
movss 0x30(%rsp), %xmm0
movss %xmm0, 0x70(%rsp)
movss 0x5c(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x82780
jmp 0x8279f
leaq 0x2f53d(%rip), %rdi     # 0xb1cc4
leaq 0x2ec30(%rip), %rsi     # 0xb13be
movl $0x3914, %edx           # imm = 0x3914
leaq 0x2f49e(%rip), %rcx     # 0xb1c38
callq 0x13b40
movss 0x74(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x827af
jmp 0x827ce
leaq 0x2f516(%rip), %rdi     # 0xb1ccc
leaq 0x2ec01(%rip), %rsi     # 0xb13be
movl $0x3915, %edx           # imm = 0x3915
leaq 0x2f46f(%rip), %rcx     # 0xb1c38
callq 0x13b40
cvttss2si 0x6c(%rsp), %eax
movl %eax, 0x4c(%rsp)
cvttss2si 0x68(%rsp), %eax
movl %eax, 0x48(%rsp)
movss 0x84(%rsp), %xmm1
movss 0x5c(%rsp), %xmm0
movl 0x4c(%rsp), %eax
addl $0x1, %eax
cvtsi2ss %eax, %xmm2
subss 0x78(%rsp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x44(%rsp)
movss 0x84(%rsp), %xmm1
movss 0x5c(%rsp), %xmm0
cvtsi2ssl 0x48(%rsp), %xmm2
subss 0x78(%rsp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x40(%rsp)
movss 0x44(%rsp), %xmm0
ucomiss 0x80(%rsp), %xmm0
jbe 0x82858
movss 0x80(%rsp), %xmm0
movss %xmm0, 0x44(%rsp)
movq 0x88(%rsp), %rax
movss 0x14(%rax), %xmm0
movss %xmm0, 0x38(%rsp)
movss 0x38(%rsp), %xmm0
movss 0x44(%rsp), %xmm1
subss 0x64(%rsp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0x34(%rsp)
movss 0x34(%rsp), %xmm0
movl 0x4c(%rsp), %eax
addl $0x1, %eax
cvtsi2ss %eax, %xmm1
subss 0x6c(%rsp), %xmm1
callq 0x835d0
movq 0xa0(%rsp), %rax
movslq 0x4c(%rsp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movss 0x40(%rsp), %xmm0
ucomiss 0x80(%rsp), %xmm0
jbe 0x82900
movss 0x80(%rsp), %xmm0
movss %xmm0, 0x40(%rsp)
movss 0x40(%rsp), %xmm0
subss 0x44(%rsp), %xmm0
movl 0x48(%rsp), %eax
movl 0x4c(%rsp), %ecx
addl $0x1, %ecx
subl %ecx, %eax
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x5c(%rsp)
movss 0x38(%rsp), %xmm0
mulss 0x5c(%rsp), %xmm0
movss 0x2abd4(%rip), %xmm1    # 0xad4e8
mulss %xmm1, %xmm0
movss %xmm0, 0x3c(%rsp)
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
movl 0x50(%rsp), %eax
cmpl 0x48(%rsp), %eax
jge 0x82985
movss 0x34(%rsp), %xmm0
movss 0x3c(%rsp), %xmm1
movss 0x2ab9d(%rip), %xmm2    # 0xad4e4
divss %xmm2, %xmm1
addss %xmm1, %xmm0
movq 0xa0(%rsp), %rax
movslq 0x50(%rsp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movss 0x3c(%rsp), %xmm0
addss 0x34(%rsp), %xmm0
movss %xmm0, 0x34(%rsp)
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x82929
movss 0x34(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
movaps 0x2e9fa(%rip), %xmm0    # 0xb1390
pand %xmm0, %xmm1
movsd 0x2ac4e(%rip), %xmm0    # 0xad5f0
ucomisd %xmm1, %xmm0
jb 0x829aa
jmp 0x829c9
leaq 0x2f323(%rip), %rdi     # 0xb1cd4
leaq 0x2ea06(%rip), %rsi     # 0xb13be
movl $0x3955, %edx           # imm = 0x3955
leaq 0x2f274(%rip), %rcx     # 0xb1c38
callq 0x13b40
movss 0x60(%rsp), %xmm0
movss 0x40(%rsp), %xmm1
movss 0x2ab63(%rip), %xmm2    # 0xad540
subss %xmm2, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x829e8
jmp 0x82a07
leaq 0x2f2f9(%rip), %rdi     # 0xb1ce8
leaq 0x2e9c8(%rip), %rsi     # 0xb13be
movl $0x3956, %edx           # imm = 0x3956
leaq 0x2f236(%rip), %rcx     # 0xb1c38
callq 0x13b40
movss 0x34(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
movss 0x38(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x60(%rsp), %xmm0
subss 0x40(%rsp), %xmm0
cvtsi2ssl 0x48(%rsp), %xmm1
cvtsi2ssl 0x48(%rsp), %xmm2
movss 0x2aaa9(%rip), %xmm3    # 0xad4e8
addss %xmm3, %xmm2
movss 0x68(%rsp), %xmm3
cvtsi2ssl 0x48(%rsp), %xmm4
movss 0x2aa91(%rip), %xmm5    # 0xad4e8
addss %xmm5, %xmm4
callq 0x83580
movss 0x8(%rsp), %xmm1
movaps %xmm0, %xmm2
movss 0xc(%rsp), %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq 0xa0(%rsp), %rax
movslq 0x48(%rsp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movss 0x38(%rsp), %xmm0
movss 0x60(%rsp), %xmm2
subss 0x64(%rsp), %xmm2
movq 0x98(%rsp), %rax
movslq 0x48(%rsp), %rcx
movss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x82f47
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x94(%rsp), %eax
jge 0x82f45
movss 0x84(%rsp), %xmm0
movss %xmm0, 0x28(%rsp)
cvtsi2ssl 0x2c(%rsp), %xmm0
movss %xmm0, 0x24(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x20(%rsp)
movss 0x70(%rsp), %xmm0
movss %xmm0, 0x1c(%rsp)
movss 0x80(%rsp), %xmm0
movss %xmm0, 0x18(%rsp)
cvtsi2ssl 0x2c(%rsp), %xmm0
subss 0x78(%rsp), %xmm0
divss 0x74(%rsp), %xmm0
addss 0x84(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
cvtsi2ss %eax, %xmm0
subss 0x78(%rsp), %xmm0
divss 0x74(%rsp), %xmm0
addss 0x84(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
movss 0x78(%rsp), %xmm1
movss 0x24(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x82c29
movss 0x1c(%rsp), %xmm0
ucomiss 0x20(%rsp), %xmm0
jbe 0x82c29
movq 0xa0(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x88(%rsp), %rdx
movss 0x78(%rsp), %xmm0
movss 0x28(%rsp), %xmm1
movss 0x24(%rsp), %xmm2
movss 0x14(%rsp), %xmm3
callq 0x830f0
movq 0xa0(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x88(%rsp), %rdx
movss 0x24(%rsp), %xmm0
movss 0x14(%rsp), %xmm1
movss 0x20(%rsp), %xmm2
movss 0x10(%rsp), %xmm3
callq 0x830f0
movq 0xa0(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x88(%rsp), %rdx
movss 0x20(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
movss 0x1c(%rsp), %xmm2
movss 0x18(%rsp), %xmm3
callq 0x830f0
jmp 0x82f33
movss 0x1c(%rsp), %xmm1
movss 0x24(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x82ce7
movss 0x78(%rsp), %xmm0
ucomiss 0x20(%rsp), %xmm0
jbe 0x82ce7
movq 0xa0(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x88(%rsp), %rdx
movss 0x78(%rsp), %xmm0
movss 0x28(%rsp), %xmm1
movss 0x20(%rsp), %xmm2
movss 0x10(%rsp), %xmm3
callq 0x830f0
movq 0xa0(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x88(%rsp), %rdx
movss 0x20(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
movss 0x24(%rsp), %xmm2
movss 0x14(%rsp), %xmm3
callq 0x830f0
movq 0xa0(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x88(%rsp), %rdx
movss 0x24(%rsp), %xmm0
movss 0x14(%rsp), %xmm1
movss 0x1c(%rsp), %xmm2
movss 0x18(%rsp), %xmm3
callq 0x830f0
jmp 0x82f31
movss 0x78(%rsp), %xmm1
movss 0x24(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x82d6c
movss 0x1c(%rsp), %xmm0
ucomiss 0x24(%rsp), %xmm0
jbe 0x82d6c
movq 0xa0(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x88(%rsp), %rdx
movss 0x78(%rsp), %xmm0
movss 0x28(%rsp), %xmm1
movss 0x24(%rsp), %xmm2
movss 0x14(%rsp), %xmm3
callq 0x830f0
movq 0xa0(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x88(%rsp), %rdx
movss 0x24(%rsp), %xmm0
movss 0x14(%rsp), %xmm1
movss 0x1c(%rsp), %xmm2
movss 0x18(%rsp), %xmm3
callq 0x830f0
jmp 0x82f2f
movss 0x1c(%rsp), %xmm1
movss 0x24(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x82df1
movss 0x78(%rsp), %xmm0
ucomiss 0x24(%rsp), %xmm0
jbe 0x82df1
movq 0xa0(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x88(%rsp), %rdx
movss 0x78(%rsp), %xmm0
movss 0x28(%rsp), %xmm1
movss 0x24(%rsp), %xmm2
movss 0x14(%rsp), %xmm3
callq 0x830f0
movq 0xa0(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x88(%rsp), %rdx
movss 0x24(%rsp), %xmm0
movss 0x14(%rsp), %xmm1
movss 0x1c(%rsp), %xmm2
movss 0x18(%rsp), %xmm3
callq 0x830f0
jmp 0x82f2d
movss 0x78(%rsp), %xmm1
movss 0x20(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x82e76
movss 0x1c(%rsp), %xmm0
ucomiss 0x20(%rsp), %xmm0
jbe 0x82e76
movq 0xa0(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x88(%rsp), %rdx
movss 0x78(%rsp), %xmm0
movss 0x28(%rsp), %xmm1
movss 0x20(%rsp), %xmm2
movss 0x10(%rsp), %xmm3
callq 0x830f0
movq 0xa0(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x88(%rsp), %rdx
movss 0x20(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
movss 0x1c(%rsp), %xmm2
movss 0x18(%rsp), %xmm3
callq 0x830f0
jmp 0x82f2b
movss 0x1c(%rsp), %xmm1
movss 0x20(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x82ef8
movss 0x78(%rsp), %xmm0
ucomiss 0x20(%rsp), %xmm0
jbe 0x82ef8
movq 0xa0(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x88(%rsp), %rdx
movss 0x78(%rsp), %xmm0
movss 0x28(%rsp), %xmm1
movss 0x20(%rsp), %xmm2
movss 0x10(%rsp), %xmm3
callq 0x830f0
movq 0xa0(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x88(%rsp), %rdx
movss 0x20(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
movss 0x1c(%rsp), %xmm2
movss 0x18(%rsp), %xmm3
callq 0x830f0
jmp 0x82f29
movq 0xa0(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x88(%rsp), %rdx
movss 0x78(%rsp), %xmm0
movss 0x28(%rsp), %xmm1
movss 0x1c(%rsp), %xmm2
movss 0x18(%rsp), %xmm3
callq 0x830f0
jmp 0x82f2b
jmp 0x82f2d
jmp 0x82f2f
jmp 0x82f31
jmp 0x82f33
jmp 0x82f35
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x82acc
jmp 0x82f47
jmp 0x82f49
movq 0x88(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x88(%rsp)
jmp 0x82259
addq $0xa8, %rsp
retq
nopl (%rax)