// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__fill_active_edges_new(float*, float*, int, stbtt__active_edge*, float)
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;
               STBTT_assert(x >= 0 && x < len);
               scanline[x] += e->direction * (1-((x_top - x) + (x_bottom-x))/2)  * height;
               scanline_fill[x] += e->direction * height; // everything right of this pixel is filled
            } else {
               int x,x1,x2;
               float y_crossing, 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;
                  // [DEAR IMGUI] Fix static analyzer warning
                  (void)dx; // [ImGui: fix static analyzer warning]
               }

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

               sign = e->direction;
               // area of the rectangle covered from y0..y_crossing
               area = sign * (y_crossing-sy0);
               // area of the triangle (x_top,y0), (x+1,y0), (x+1,y_crossing)
               scanline[x1] += area * (1-((x_top - x1)+(x1+1-x1))/2);

               step = sign * dy;
               for (x = x1+1; x < x2; ++x) {
                  scanline[x] += area + step/2;
                  area += step;
               }
               y_crossing += dy * (x2 - (x1+1));

               STBTT_assert(STBTT_fabs(area) <= 1.01f);

               scanline[x2] += area + sign * (1-((x2-x2)+(x_bottom-x2))/2) * (sy1-y_crossing);

               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
            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:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movss %xmm0, -0x24(%rbp)
movss 0x4b7c5(%rip), %xmm0    # 0x170c3c
addss -0x24(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x125f37
jmp 0x12548e
movq -0x20(%rbp), %rax
movss 0x1c(%rax), %xmm0
ucomiss -0x24(%rbp), %xmm0
jb 0x12549f
jmp 0x1254be
leaq 0x661c8(%rip), %rdi     # 0x18b66e
leaq 0x65b3d(%rip), %rsi     # 0x18afea
movl $0xba5, %edx            # imm = 0xBA5
leaq 0x6614a(%rip), %rcx     # 0x18b603
callq 0xd180
jmp 0x1254c0
movq -0x20(%rbp), %rax
movss 0xc(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x12558c
jp 0x12558c
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm1
cvtsi2ssl -0x14(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x125587
movss -0x2c(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x12555e
movq -0x8(%rbp), %rdi
cvttss2si -0x2c(%rbp), %esi
movq -0x20(%rbp), %rdx
movss -0x2c(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
movss -0x2c(%rbp), %xmm2
movss -0x28(%rbp), %xmm3
callq 0x1260a0
movq -0x10(%rbp), %rdi
addq $-0x4, %rdi
cvttss2si -0x2c(%rbp), %esi
addl $0x1, %esi
movq -0x20(%rbp), %rdx
movss -0x2c(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
movss -0x2c(%rbp), %xmm2
movss -0x28(%rbp), %xmm3
callq 0x1260a0
jmp 0x125585
movq -0x10(%rbp), %rdi
addq $-0x4, %rdi
movq -0x20(%rbp), %rdx
movss -0x2c(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
movss -0x2c(%rbp), %xmm2
movss -0x28(%rbp), %xmm3
xorl %esi, %esi
callq 0x1260a0
jmp 0x125587
jmp 0x125f27
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movss 0xc(%rax), %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x30(%rbp), %xmm0
addss -0x34(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
movq -0x20(%rbp), %rax
movss 0x10(%rax), %xmm0
movss %xmm0, -0x4c(%rbp)
movq -0x20(%rbp), %rax
movss 0x18(%rax), %xmm1
movss -0x28(%rbp), %xmm0
xorl %eax, %eax
ucomiss %xmm1, %xmm0
movb %al, -0x95(%rbp)
jb 0x1255f6
movq -0x20(%rbp), %rax
movss 0x1c(%rax), %xmm0
ucomiss -0x24(%rbp), %xmm0
setae %al
movb %al, -0x95(%rbp)
movb -0x95(%rbp), %al
testb $0x1, %al
jne 0x125602
jmp 0x125604
jmp 0x125623
leaq 0x6604e(%rip), %rdi     # 0x18b659
leaq 0x659d8(%rip), %rsi     # 0x18afea
movl $0xbb8, %edx            # imm = 0xBB8
leaq 0x65fe5(%rip), %rcx     # 0x18b603
callq 0xd180
jmp 0x125625
movq -0x20(%rbp), %rax
movss 0x18(%rax), %xmm0
ucomiss -0x24(%rbp), %xmm0
jbe 0x125669
movss -0x30(%rbp), %xmm1
movss -0x34(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss 0x18(%rax), %xmm2
subss -0x24(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movss 0x18(%rax), %xmm0
movss %xmm0, -0x44(%rbp)
jmp 0x12567d
movss -0x30(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
movq -0x20(%rbp), %rax
movss 0x1c(%rax), %xmm1
movss -0x28(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x1256c5
movss -0x30(%rbp), %xmm1
movss -0x34(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss 0x1c(%rax), %xmm2
subss -0x24(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rax
movss 0x1c(%rax), %xmm0
movss %xmm0, -0x48(%rbp)
jmp 0x1256d9
movss -0x38(%rbp), %xmm0
movss %xmm0, -0x40(%rbp)
movss -0x28(%rbp), %xmm0
movss %xmm0, -0x48(%rbp)
movss -0x3c(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x125b00
movss -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x125b00
movss -0x3c(%rbp), %xmm1
cvtsi2ssl -0x14(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x125b00
movss -0x40(%rbp), %xmm1
cvtsi2ssl -0x14(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x125b00
cvttss2si -0x3c(%rbp), %eax
cvttss2si -0x40(%rbp), %ecx
cmpl %ecx, %eax
jne 0x125827
cvttss2si -0x3c(%rbp), %eax
movl %eax, -0x54(%rbp)
movss -0x48(%rbp), %xmm0
subss -0x44(%rbp), %xmm0
movss %xmm0, -0x50(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x54(%rbp)
movb %al, -0x96(%rbp)
jl 0x125767
movl -0x54(%rbp), %eax
cmpl -0x14(%rbp), %eax
setl %al
movb %al, -0x96(%rbp)
movb -0x96(%rbp), %al
testb $0x1, %al
jne 0x125773
jmp 0x125775
jmp 0x125794
leaq 0x65f01(%rip), %rdi     # 0x18b67d
leaq 0x65867(%rip), %rsi     # 0x18afea
movl $0xbd4, %edx            # imm = 0xBD4
leaq 0x65e74(%rip), %rcx     # 0x18b603
callq 0xd180
jmp 0x125796
movq -0x20(%rbp), %rax
movss 0x14(%rax), %xmm0
movss -0x3c(%rbp), %xmm2
cvtsi2ssl -0x54(%rbp), %xmm1
subss %xmm1, %xmm2
movss -0x40(%rbp), %xmm1
cvtsi2ssl -0x54(%rbp), %xmm3
subss %xmm3, %xmm1
addss %xmm1, %xmm2
movss 0x4c805(%rip), %xmm1    # 0x171fcc
divss %xmm1, %xmm2
movss 0x4b469(%rip), %xmm1    # 0x170c3c
subss %xmm2, %xmm1
mulss %xmm1, %xmm0
movss -0x50(%rbp), %xmm2
movq -0x8(%rbp), %rax
movslq -0x54(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
movss 0x14(%rax), %xmm0
movss -0x50(%rbp), %xmm2
movq -0x10(%rbp), %rax
movslq -0x54(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x125afb
movss -0x3c(%rbp), %xmm0
ucomiss -0x40(%rbp), %xmm0
jbe 0x1258ee
movss -0x28(%rbp), %xmm0
movss -0x44(%rbp), %xmm1
subss -0x24(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x44(%rbp)
movss -0x28(%rbp), %xmm0
movss -0x48(%rbp), %xmm1
subss -0x24(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x48(%rbp)
movss -0x44(%rbp), %xmm0
movss %xmm0, -0x74(%rbp)
movss -0x48(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
movss -0x74(%rbp), %xmm0
movss %xmm0, -0x48(%rbp)
movss -0x40(%rbp), %xmm0
movss %xmm0, -0x74(%rbp)
movss -0x3c(%rbp), %xmm0
movss %xmm0, -0x40(%rbp)
movss -0x74(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0x34(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x4c(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x4c(%rbp)
movss -0x30(%rbp), %xmm0
movss %xmm0, -0x74(%rbp)
movss -0x38(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x74(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
cvttss2si -0x3c(%rbp), %eax
movl %eax, -0x5c(%rbp)
cvttss2si -0x40(%rbp), %eax
movl %eax, -0x60(%rbp)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
cvtsi2ss %eax, %xmm0
subss -0x30(%rbp), %xmm0
movss -0x4c(%rbp), %xmm2
movss -0x24(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x64(%rbp)
movq -0x20(%rbp), %rax
movss 0x14(%rax), %xmm0
movss %xmm0, -0x6c(%rbp)
movss -0x6c(%rbp), %xmm0
movss -0x64(%rbp), %xmm1
subss -0x44(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x70(%rbp)
movss -0x70(%rbp), %xmm0
movss -0x3c(%rbp), %xmm1
cvtsi2ssl -0x5c(%rbp), %xmm2
subss %xmm2, %xmm1
movl -0x5c(%rbp), %eax
addl $0x1, %eax
subl -0x5c(%rbp), %eax
cvtsi2ss %eax, %xmm2
addss %xmm2, %xmm1
movss 0x4c656(%rip), %xmm2    # 0x171fcc
divss %xmm2, %xmm1
movss 0x4b2ba(%rip), %xmm2    # 0x170c3c
subss %xmm1, %xmm2
movq -0x8(%rbp), %rax
movslq -0x5c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movss -0x6c(%rbp), %xmm0
mulss -0x4c(%rbp), %xmm0
movss %xmm0, -0x68(%rbp)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
movl -0x58(%rbp), %eax
cmpl -0x60(%rbp), %eax
jge 0x125a06
movss -0x70(%rbp), %xmm0
movss -0x68(%rbp), %xmm1
movss 0x4c5fa(%rip), %xmm2    # 0x171fcc
divss %xmm2, %xmm1
addss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movslq -0x58(%rbp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movss -0x68(%rbp), %xmm0
addss -0x70(%rbp), %xmm0
movss %xmm0, -0x70(%rbp)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x1259b8
movss -0x4c(%rbp), %xmm0
movl -0x60(%rbp), %eax
movl -0x5c(%rbp), %ecx
addl $0x1, %ecx
subl %ecx, %eax
cvtsi2ss %eax, %xmm2
movss -0x64(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x64(%rbp)
movss -0x70(%rbp), %xmm1
movaps 0x4cdc8(%rip), %xmm0    # 0x172800
pand %xmm0, %xmm1
movss 0x5e00c(%rip), %xmm0    # 0x183a50
ucomiss %xmm1, %xmm0
jb 0x125a4b
jmp 0x125a6a
leaq 0x65c3d(%rip), %rdi     # 0x18b68f
leaq 0x65591(%rip), %rsi     # 0x18afea
movl $0xbfb, %edx            # imm = 0xBFB
leaq 0x65b9e(%rip), %rcx     # 0x18b603
callq 0xd180
jmp 0x125a6c
movss -0x70(%rbp), %xmm1
movss -0x6c(%rbp), %xmm0
movl -0x60(%rbp), %eax
subl -0x60(%rbp), %eax
cvtsi2ss %eax, %xmm3
movss -0x40(%rbp), %xmm2
cvtsi2ssl -0x60(%rbp), %xmm4
subss %xmm4, %xmm2
addss %xmm2, %xmm3
movss 0x4c532(%rip), %xmm2    # 0x171fcc
divss %xmm2, %xmm3
movss 0x4b196(%rip), %xmm2    # 0x170c3c
subss %xmm3, %xmm2
mulss %xmm2, %xmm0
movss -0x48(%rbp), %xmm2
subss -0x64(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movslq -0x60(%rbp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movss -0x6c(%rbp), %xmm0
movss -0x48(%rbp), %xmm2
subss -0x44(%rbp), %xmm2
movq -0x10(%rbp), %rax
movslq -0x60(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x125f25
movl $0x0, -0x78(%rbp)
movl -0x78(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x125f23
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x7c(%rbp)
cvtsi2ssl -0x78(%rbp), %xmm0
movss %xmm0, -0x80(%rbp)
movl -0x78(%rbp), %eax
addl $0x1, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x84(%rbp)
movss -0x38(%rbp), %xmm0
movss %xmm0, -0x88(%rbp)
movss -0x28(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
cvtsi2ssl -0x78(%rbp), %xmm0
subss -0x30(%rbp), %xmm0
divss -0x34(%rbp), %xmm0
addss -0x24(%rbp), %xmm0
movss %xmm0, -0x90(%rbp)
movl -0x78(%rbp), %eax
addl $0x1, %eax
cvtsi2ss %eax, %xmm0
subss -0x30(%rbp), %xmm0
divss -0x34(%rbp), %xmm0
addss -0x24(%rbp), %xmm0
movss %xmm0, -0x94(%rbp)
movss -0x30(%rbp), %xmm1
movss -0x80(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x125c41
movss -0x88(%rbp), %xmm0
ucomiss -0x84(%rbp), %xmm0
jbe 0x125c41
movq -0x8(%rbp), %rdi
movl -0x78(%rbp), %esi
movq -0x20(%rbp), %rdx
movss -0x30(%rbp), %xmm0
movss -0x7c(%rbp), %xmm1
movss -0x80(%rbp), %xmm2
movss -0x90(%rbp), %xmm3
callq 0x1260a0
movq -0x8(%rbp), %rdi
movl -0x78(%rbp), %esi
movq -0x20(%rbp), %rdx
movss -0x80(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
movss -0x84(%rbp), %xmm2
movss -0x94(%rbp), %xmm3
callq 0x1260a0
movq -0x8(%rbp), %rdi
movl -0x78(%rbp), %esi
movq -0x20(%rbp), %rdx
movss -0x84(%rbp), %xmm0
movss -0x94(%rbp), %xmm1
movss -0x88(%rbp), %xmm2
movss -0x8c(%rbp), %xmm3
callq 0x1260a0
jmp 0x125f13
movss -0x88(%rbp), %xmm1
movss -0x80(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x125cf2
movss -0x30(%rbp), %xmm0
ucomiss -0x84(%rbp), %xmm0
jbe 0x125cf2
movq -0x8(%rbp), %rdi
movl -0x78(%rbp), %esi
movq -0x20(%rbp), %rdx
movss -0x30(%rbp), %xmm0
movss -0x7c(%rbp), %xmm1
movss -0x84(%rbp), %xmm2
movss -0x94(%rbp), %xmm3
callq 0x1260a0
movq -0x8(%rbp), %rdi
movl -0x78(%rbp), %esi
movq -0x20(%rbp), %rdx
movss -0x84(%rbp), %xmm0
movss -0x94(%rbp), %xmm1
movss -0x80(%rbp), %xmm2
movss -0x90(%rbp), %xmm3
callq 0x1260a0
movq -0x8(%rbp), %rdi
movl -0x78(%rbp), %esi
movq -0x20(%rbp), %rdx
movss -0x80(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
movss -0x88(%rbp), %xmm2
movss -0x8c(%rbp), %xmm3
callq 0x1260a0
jmp 0x125f11
movss -0x30(%rbp), %xmm1
movss -0x80(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x125d68
movss -0x88(%rbp), %xmm0
ucomiss -0x80(%rbp), %xmm0
jbe 0x125d68
movq -0x8(%rbp), %rdi
movl -0x78(%rbp), %esi
movq -0x20(%rbp), %rdx
movss -0x30(%rbp), %xmm0
movss -0x7c(%rbp), %xmm1
movss -0x80(%rbp), %xmm2
movss -0x90(%rbp), %xmm3
callq 0x1260a0
movq -0x8(%rbp), %rdi
movl -0x78(%rbp), %esi
movq -0x20(%rbp), %rdx
movss -0x80(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
movss -0x88(%rbp), %xmm2
movss -0x8c(%rbp), %xmm3
callq 0x1260a0
jmp 0x125f0f
movss -0x88(%rbp), %xmm1
movss -0x80(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x125dde
movss -0x30(%rbp), %xmm0
ucomiss -0x80(%rbp), %xmm0
jbe 0x125dde
movq -0x8(%rbp), %rdi
movl -0x78(%rbp), %esi
movq -0x20(%rbp), %rdx
movss -0x30(%rbp), %xmm0
movss -0x7c(%rbp), %xmm1
movss -0x80(%rbp), %xmm2
movss -0x90(%rbp), %xmm3
callq 0x1260a0
movq -0x8(%rbp), %rdi
movl -0x78(%rbp), %esi
movq -0x20(%rbp), %rdx
movss -0x80(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
movss -0x88(%rbp), %xmm2
movss -0x8c(%rbp), %xmm3
callq 0x1260a0
jmp 0x125f0d
movss -0x30(%rbp), %xmm1
movss -0x84(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x125e60
movss -0x88(%rbp), %xmm0
ucomiss -0x84(%rbp), %xmm0
jbe 0x125e60
movq -0x8(%rbp), %rdi
movl -0x78(%rbp), %esi
movq -0x20(%rbp), %rdx
movss -0x30(%rbp), %xmm0
movss -0x7c(%rbp), %xmm1
movss -0x84(%rbp), %xmm2
movss -0x94(%rbp), %xmm3
callq 0x1260a0
movq -0x8(%rbp), %rdi
movl -0x78(%rbp), %esi
movq -0x20(%rbp), %rdx
movss -0x84(%rbp), %xmm0
movss -0x94(%rbp), %xmm1
movss -0x88(%rbp), %xmm2
movss -0x8c(%rbp), %xmm3
callq 0x1260a0
jmp 0x125f0b
movss -0x88(%rbp), %xmm1
movss -0x84(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x125edf
movss -0x30(%rbp), %xmm0
ucomiss -0x84(%rbp), %xmm0
jbe 0x125edf
movq -0x8(%rbp), %rdi
movl -0x78(%rbp), %esi
movq -0x20(%rbp), %rdx
movss -0x30(%rbp), %xmm0
movss -0x7c(%rbp), %xmm1
movss -0x84(%rbp), %xmm2
movss -0x94(%rbp), %xmm3
callq 0x1260a0
movq -0x8(%rbp), %rdi
movl -0x78(%rbp), %esi
movq -0x20(%rbp), %rdx
movss -0x84(%rbp), %xmm0
movss -0x94(%rbp), %xmm1
movss -0x88(%rbp), %xmm2
movss -0x8c(%rbp), %xmm3
callq 0x1260a0
jmp 0x125f09
movq -0x8(%rbp), %rdi
movl -0x78(%rbp), %esi
movq -0x20(%rbp), %rdx
movss -0x30(%rbp), %xmm0
movss -0x7c(%rbp), %xmm1
movss -0x88(%rbp), %xmm2
movss -0x8c(%rbp), %xmm3
callq 0x1260a0
jmp 0x125f0b
jmp 0x125f0d
jmp 0x125f0f
jmp 0x125f11
jmp 0x125f13
jmp 0x125f15
movl -0x78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x78(%rbp)
jmp 0x125b07
jmp 0x125f25
jmp 0x125f27
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x125481
addq $0xa0, %rsp
popq %rbp
retq