// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/hog.c
// Function: vl_hog_extract
void
vl_hog_extract (VlHog * self, float * features)
{
  vl_index x, y ;
  vl_uindex k ;
  vl_size hogStride = self->hogWidth * self->hogHeight ;

  assert(features) ;

#define at(x,y,k) (self->hog[(x) + (y) * self->hogWidth + (k) * hogStride])
#define atNorm(x,y) (self->hogNorm[(x) + (y) * self->hogWidth])

  /*
   Compute the squared L2 norm of the unoriented version of each HOG
   cell histogram. The unoriented version is obtained by folding
   the 2*numOrientations compotnent into numOrientations only.
   */
  {
    float const * iter = self->hog ;
    for (k = 0 ; k < self->numOrientations ; ++k) {
      float * niter = self->hogNorm ;
      float * niterEnd = self->hogNorm + self->hogWidth * self->hogHeight ;
      vl_size stride = self->hogWidth*self->hogHeight*self->numOrientations ;
      while (niter != niterEnd) {
        float h1 = *iter ;
        float h2 = *(iter + stride) ;
        float h = h1 + h2 ;
        *niter += h * h ;
        niter++ ;
        iter++ ;
      }
    }
  }

  /*
   HOG block-normalisation.

   The Dalal-Triggs implementation computes a normalized descriptor for
   each block of 2x2 cells, by stacking the histograms of each cell
   into a vector and L2-normalizing and truncating the result.
   
   Each block-level descriptor is then decomposed back into cells
   and corresponding parts are stacked into cell-level descritpors.
   Each HOG cell is contained in exactly
   four 2x2 cell blocks. For example, the cell number 5 in the following
   figure is contained in blocks 1245, 2356, 4578, 5689:

   +---+---+---+
   | 1 | 2 | 3 |
   +---+---+---+
   | 4 | 5 | 6 |
   +---+---+---+
   | 7 | 8 | 9 |
   +---+---+---+

   Hence, when block-level descriptors are decomposed back
   into cells, each cell receives contributions from four blocks. So,
   if each cell started with a D-dimensional histogram, it
   ends up with a 4D dimesional descriptor vector.

   Note however that this is just a convenient way of rewriting the 
   blocks as per-cell contributions, but the block information
   is unchanged. In particular, barring boundary effects,
   in an array of H x W cells there are approximately HW blocks;
   hence the L2 norm of all the blocks stacked is approximately HW
   (because individual blocks are L2-normalized). Since this does
   not change in the final HOG descriptor,
   the L2 norm of the HOG descriptor of an image should be approximately
   the same as the area of the image divided by the
   area of a HOG cell. This can be used as a sanity check.

   The UoCTTI variant differs in some non-negligible ways. First, 
   it includes both oriented and unoriented histograms, as well
   as four components capturing texture. Second, and most importantly, 
   it merges the four chunks of block-level descirptors landing in
   each cell into one by taking their average. This makes sense
   because, ultimately, these four sub-descriptors are identical
   to the original cell histogram, just with four different normalisations
   applied.
   */
  {
    float const * iter = self->hog ;
    for (y = 0 ; y < (signed)self->hogHeight ; ++y) {
      for (x = 0 ; x < (signed)self->hogWidth ; ++x) {

        /* norm of upper-left, upper-right, ... cells */
        vl_index xm = VL_MAX(x - 1, 0) ;
        vl_index xp = VL_MIN(x + 1, (signed)self->hogWidth - 1) ;
        vl_index ym = VL_MAX(y - 1, 0) ;
        vl_index yp = VL_MIN(y + 1, (signed)self->hogHeight - 1) ;

        double norm1 = atNorm(xm,ym) ;
        double norm2 = atNorm(x,ym) ;
        double norm3 = atNorm(xp,ym) ;
        double norm4 = atNorm(xm,y) ;
        double norm5 = atNorm(x,y) ;
        double norm6 = atNorm(xp,y) ;
        double norm7 = atNorm(xm,yp) ;
        double norm8 = atNorm(x,yp) ;
        double norm9 = atNorm(xp,yp) ;

        double factor1, factor2, factor3, factor4 ;

        double t1 = 0 ;
        double t2 = 0 ;
        double t3 = 0 ;
        double t4 = 0 ;

        float * oiter = features + x + self->hogWidth * y ;

        /* each factor is the inverse of the l2 norm of one of the 2x2 blocks surrounding
           cell x,y */
#if 0
        if (self->transposed) {
          /* if the image is transposed, y and x are swapped */
          factor1 = 1.0 / VL_MAX(sqrt(norm1 + norm2 + norm4 + norm5), 1e-10) ;
          factor3 = 1.0 / VL_MAX(sqrt(norm2 + norm3 + norm5 + norm6), 1e-10) ;
          factor2 = 1.0 / VL_MAX(sqrt(norm4 + norm5 + norm7 + norm8), 1e-10) ;
          factor4 = 1.0 / VL_MAX(sqrt(norm5 + norm6 + norm8 + norm9), 1e-10) ;
        } else {
          factor1 = 1.0 / VL_MAX(sqrt(norm1 + norm2 + norm4 + norm5), 1e-10) ;
          factor2 = 1.0 / VL_MAX(sqrt(norm2 + norm3 + norm5 + norm6), 1e-10) ;
          factor3 = 1.0 / VL_MAX(sqrt(norm4 + norm5 + norm7 + norm8), 1e-10) ;
          factor4 = 1.0 / VL_MAX(sqrt(norm5 + norm6 + norm8 + norm9), 1e-10) ;
        }
#else
        /* as implemented in UOCTTI code */
        if (self->transposed) {
          /* if the image is transposed, y and x are swapped */
          factor1 = 1.0 / sqrt(norm1 + norm2 + norm4 + norm5 + 1e-4) ;
          factor3 = 1.0 / sqrt(norm2 + norm3 + norm5 + norm6 + 1e-4) ;
          factor2 = 1.0 / sqrt(norm4 + norm5 + norm7 + norm8 + 1e-4) ;
          factor4 = 1.0 / sqrt(norm5 + norm6 + norm8 + norm9 + 1e-4) ;
        } else {
          factor1 = 1.0 / sqrt(norm1 + norm2 + norm4 + norm5 + 1e-4) ;
          factor2 = 1.0 / sqrt(norm2 + norm3 + norm5 + norm6 + 1e-4) ;
          factor3 = 1.0 / sqrt(norm4 + norm5 + norm7 + norm8 + 1e-4) ;
          factor4 = 1.0 / sqrt(norm5 + norm6 + norm8 + norm9 + 1e-4) ;
        }
#endif

        for (k = 0 ; k < self->numOrientations ; ++k) {
          double ha = iter[hogStride * k] ;
          double hb = iter[hogStride * (k + self->numOrientations)] ;
          double hc ;

          double ha1 = factor1 * ha ;
          double ha2 = factor2 * ha ;
          double ha3 = factor3 * ha ;
          double ha4 = factor4 * ha ;

          double hb1 = factor1 * hb ;
          double hb2 = factor2 * hb ;
          double hb3 = factor3 * hb ;
          double hb4 = factor4 * hb ;

          double hc1 = ha1 + hb1 ;
          double hc2 = ha2 + hb2 ;
          double hc3 = ha3 + hb3 ;
          double hc4 = ha4 + hb4 ;

          ha1 = VL_MIN(0.2, ha1) ;
          ha2 = VL_MIN(0.2, ha2) ;
          ha3 = VL_MIN(0.2, ha3) ;
          ha4 = VL_MIN(0.2, ha4) ;

          hb1 = VL_MIN(0.2, hb1) ;
          hb2 = VL_MIN(0.2, hb2) ;
          hb3 = VL_MIN(0.2, hb3) ;
          hb4 = VL_MIN(0.2, hb4) ;

          hc1 = VL_MIN(0.2, hc1) ;
          hc2 = VL_MIN(0.2, hc2) ;
          hc3 = VL_MIN(0.2, hc3) ;
          hc4 = VL_MIN(0.2, hc4) ;

          t1 += hc1 ;
          t2 += hc2 ;
          t3 += hc3 ;
          t4 += hc4 ;

          switch (self->variant) {
            case VlHogVariantUoctti :
              ha = 0.5 * (ha1 + ha2 + ha3 + ha4) ;
              hb = 0.5 * (hb1 + hb2 + hb3 + hb4) ;
              hc = 0.5 * (hc1 + hc2 + hc3 + hc4) ;
              *oiter = ha ;
              *(oiter + hogStride * self->numOrientations) = hb ;
              *(oiter + 2 * hogStride * self->numOrientations) = hc ;
              break ;

            case VlHogVariantDalalTriggs :
              *oiter = hc1 ;
              *(oiter + hogStride * self->numOrientations) = hc2 ;
              *(oiter + 2 * hogStride * self->numOrientations) = hc3 ;
              *(oiter + 3 * hogStride * self->numOrientations) = hc4 ;
              break ;
          }
          oiter += hogStride ;

        } /* next orientation */

        switch (self->variant) {
          case VlHogVariantUoctti :
            oiter += 2 * hogStride * self->numOrientations ;
            *oiter = (1.0f/sqrtf(18.0f)) * t1 ; oiter += hogStride ;
            *oiter = (1.0f/sqrtf(18.0f)) * t2 ; oiter += hogStride ;
            *oiter = (1.0f/sqrtf(18.0f)) * t3 ; oiter += hogStride ;
            *oiter = (1.0f/sqrtf(18.0f)) * t4 ; oiter += hogStride ;
            break ;

          case VlHogVariantDalalTriggs :
            break ;
        }
        ++iter ;
      } /* next x */
    } /* next y */
  } /* block normalization */
}

// Assembly:
subq $0x218, %rsp            # imm = 0x218
movq %rdi, 0x210(%rsp)
movq %rsi, 0x208(%rsp)
movq 0x210(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x210(%rsp), %rcx
imulq 0x60(%rcx), %rax
movq %rax, 0x1e8(%rsp)
movq 0x210(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x1e0(%rsp)
movq $0x0, 0x1f0(%rsp)
movq 0x1f0(%rsp), %rax
movq 0x210(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x20a7e
movq 0x210(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x1d8(%rsp)
movq 0x210(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x210(%rsp), %rcx
movq 0x58(%rcx), %rcx
movq 0x210(%rsp), %rdx
imulq 0x60(%rdx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x1d0(%rsp)
movq 0x210(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x210(%rsp), %rcx
imulq 0x60(%rcx), %rax
movq 0x210(%rsp), %rcx
imulq 0x10(%rcx), %rax
movq %rax, 0x1c8(%rsp)
movq 0x1d8(%rsp), %rax
cmpq 0x1d0(%rsp), %rax
je 0x20a63
movq 0x1e0(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0x1c4(%rsp)
movq 0x1e0(%rsp), %rax
movq 0x1c8(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, 0x1c0(%rsp)
movss 0x1c4(%rsp), %xmm0
addss 0x1c0(%rsp), %xmm0
movss %xmm0, 0x1bc(%rsp)
movss 0x1bc(%rsp), %xmm0
movss 0x1bc(%rsp), %xmm2
movq 0x1d8(%rsp), %rax
movss (%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax)
movq 0x1d8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x1d8(%rsp)
movq 0x1e0(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x1e0(%rsp)
jmp 0x209a8
jmp 0x20a65
movq 0x1f0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x1f0(%rsp)
jmp 0x20918
movq 0x210(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x1b0(%rsp)
movq $0x0, 0x1f8(%rsp)
movq 0x1f8(%rsp), %rax
movq 0x210(%rsp), %rcx
movq 0x60(%rcx), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x21adb
movq $0x0, 0x200(%rsp)
movq 0x200(%rsp), %rax
movq 0x210(%rsp), %rcx
movq 0x58(%rcx), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x21ac0
movq 0x200(%rsp), %rax
subq $0x1, %rax
cmpq $0x0, %rax
jle 0x20b12
movq 0x200(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x80(%rsp)
jmp 0x20b1e
xorl %eax, %eax
movq %rax, 0x80(%rsp)
jmp 0x20b1e
movq 0x80(%rsp), %rax
movq %rax, 0x1a8(%rsp)
movq 0x200(%rsp), %rax
addq $0x1, %rax
movq 0x210(%rsp), %rcx
movq 0x58(%rcx), %rcx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x20b64
movq 0x200(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x78(%rsp)
jmp 0x20b7a
movq 0x210(%rsp), %rax
movq 0x58(%rax), %rax
subl $0x1, %eax
cltq
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x1a0(%rsp)
movq 0x1f8(%rsp), %rax
subq $0x1, %rax
cmpq $0x0, %rax
jle 0x20bac
movq 0x1f8(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x70(%rsp)
jmp 0x20bb5
xorl %eax, %eax
movq %rax, 0x70(%rsp)
jmp 0x20bb5
movq 0x70(%rsp), %rax
movq %rax, 0x198(%rsp)
movq 0x1f8(%rsp), %rax
addq $0x1, %rax
movq 0x210(%rsp), %rcx
movq 0x60(%rcx), %rcx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x20bf8
movq 0x1f8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
jmp 0x20c0e
movq 0x210(%rsp), %rax
movq 0x60(%rax), %rax
subl $0x1, %eax
cltq
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x190(%rsp)
movq 0x210(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x1a8(%rsp), %rcx
movq 0x198(%rsp), %rdx
movq 0x210(%rsp), %rsi
imulq 0x58(%rsi), %rdx
addq %rdx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x188(%rsp)
movq 0x210(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x200(%rsp), %rcx
movq 0x198(%rsp), %rdx
movq 0x210(%rsp), %rsi
imulq 0x58(%rsi), %rdx
addq %rdx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x180(%rsp)
movq 0x210(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x1a0(%rsp), %rcx
movq 0x198(%rsp), %rdx
movq 0x210(%rsp), %rsi
imulq 0x58(%rsi), %rdx
addq %rdx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x178(%rsp)
movq 0x210(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x1a8(%rsp), %rcx
movq 0x1f8(%rsp), %rdx
movq 0x210(%rsp), %rsi
imulq 0x58(%rsi), %rdx
addq %rdx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x170(%rsp)
movq 0x210(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x200(%rsp), %rcx
movq 0x1f8(%rsp), %rdx
movq 0x210(%rsp), %rsi
imulq 0x58(%rsi), %rdx
addq %rdx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x168(%rsp)
movq 0x210(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x1a0(%rsp), %rcx
movq 0x1f8(%rsp), %rdx
movq 0x210(%rsp), %rsi
imulq 0x58(%rsi), %rdx
addq %rdx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x160(%rsp)
movq 0x210(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x1a8(%rsp), %rcx
movq 0x190(%rsp), %rdx
movq 0x210(%rsp), %rsi
imulq 0x58(%rsi), %rdx
addq %rdx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x158(%rsp)
movq 0x210(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x200(%rsp), %rcx
movq 0x190(%rsp), %rdx
movq 0x210(%rsp), %rsi
imulq 0x58(%rsi), %rdx
addq %rdx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x150(%rsp)
movq 0x210(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x1a0(%rsp), %rcx
movq 0x190(%rsp), %rdx
movq 0x210(%rsp), %rsi
imulq 0x58(%rsi), %rdx
addq %rdx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x148(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x120(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x118(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x110(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x108(%rsp)
movq 0x208(%rsp), %rax
movq 0x200(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq 0x210(%rsp), %rcx
movq 0x58(%rcx), %rcx
imulq 0x1f8(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x100(%rsp)
movq 0x210(%rsp), %rax
cmpl $0x0, 0x18(%rax)
je 0x20fff
movsd 0x188(%rsp), %xmm0
addsd 0x180(%rsp), %xmm0
addsd 0x170(%rsp), %xmm0
addsd 0x168(%rsp), %xmm0
movsd 0x3844e(%rip), %xmm1    # 0x59340
addsd %xmm1, %xmm0
callq 0x9b20
movaps %xmm0, %xmm1
movsd 0x381d2(%rip), %xmm0    # 0x590d8
divsd %xmm1, %xmm0
movsd %xmm0, 0x140(%rsp)
movsd 0x180(%rsp), %xmm0
addsd 0x178(%rsp), %xmm0
addsd 0x168(%rsp), %xmm0
addsd 0x160(%rsp), %xmm0
movsd 0x38401(%rip), %xmm1    # 0x59340
addsd %xmm1, %xmm0
callq 0x9b20
movaps %xmm0, %xmm1
movsd 0x38185(%rip), %xmm0    # 0x590d8
divsd %xmm1, %xmm0
movsd %xmm0, 0x130(%rsp)
movsd 0x170(%rsp), %xmm0
addsd 0x168(%rsp), %xmm0
addsd 0x158(%rsp), %xmm0
addsd 0x150(%rsp), %xmm0
movsd 0x383b4(%rip), %xmm1    # 0x59340
addsd %xmm1, %xmm0
callq 0x9b20
movaps %xmm0, %xmm1
movsd 0x38138(%rip), %xmm0    # 0x590d8
divsd %xmm1, %xmm0
movsd %xmm0, 0x138(%rsp)
movsd 0x168(%rsp), %xmm0
addsd 0x160(%rsp), %xmm0
addsd 0x150(%rsp), %xmm0
addsd 0x148(%rsp), %xmm0
movsd 0x38367(%rip), %xmm1    # 0x59340
addsd %xmm1, %xmm0
callq 0x9b20
movaps %xmm0, %xmm1
movsd 0x380eb(%rip), %xmm0    # 0x590d8
divsd %xmm1, %xmm0
movsd %xmm0, 0x128(%rsp)
jmp 0x21133
movsd 0x188(%rsp), %xmm0
addsd 0x180(%rsp), %xmm0
addsd 0x170(%rsp), %xmm0
addsd 0x168(%rsp), %xmm0
movsd 0x38315(%rip), %xmm1    # 0x59340
addsd %xmm1, %xmm0
callq 0x9b20
movaps %xmm0, %xmm1
movsd 0x38099(%rip), %xmm0    # 0x590d8
divsd %xmm1, %xmm0
movsd %xmm0, 0x140(%rsp)
movsd 0x180(%rsp), %xmm0
addsd 0x178(%rsp), %xmm0
addsd 0x168(%rsp), %xmm0
addsd 0x160(%rsp), %xmm0
movsd 0x382c8(%rip), %xmm1    # 0x59340
addsd %xmm1, %xmm0
callq 0x9b20
movaps %xmm0, %xmm1
movsd 0x3804c(%rip), %xmm0    # 0x590d8
divsd %xmm1, %xmm0
movsd %xmm0, 0x138(%rsp)
movsd 0x170(%rsp), %xmm0
addsd 0x168(%rsp), %xmm0
addsd 0x158(%rsp), %xmm0
addsd 0x150(%rsp), %xmm0
movsd 0x3827b(%rip), %xmm1    # 0x59340
addsd %xmm1, %xmm0
callq 0x9b20
movaps %xmm0, %xmm1
movsd 0x37fff(%rip), %xmm0    # 0x590d8
divsd %xmm1, %xmm0
movsd %xmm0, 0x130(%rsp)
movsd 0x168(%rsp), %xmm0
addsd 0x160(%rsp), %xmm0
addsd 0x150(%rsp), %xmm0
addsd 0x148(%rsp), %xmm0
movsd 0x3822e(%rip), %xmm1    # 0x59340
addsd %xmm1, %xmm0
callq 0x9b20
movaps %xmm0, %xmm1
movsd 0x37fb2(%rip), %xmm0    # 0x590d8
divsd %xmm1, %xmm0
movsd %xmm0, 0x128(%rsp)
movq $0x0, 0x1f0(%rsp)
movq 0x1f0(%rsp), %rax
movq 0x210(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x218ea
movq 0x1b0(%rsp), %rax
movq 0x1e8(%rsp), %rcx
imulq 0x1f0(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0xf8(%rsp)
movq 0x1b0(%rsp), %rax
movq 0x1e8(%rsp), %rcx
movq 0x1f0(%rsp), %rdx
movq 0x210(%rsp), %rsi
addq 0x10(%rsi), %rdx
imulq %rdx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0xf0(%rsp)
movsd 0x140(%rsp), %xmm0
mulsd 0xf8(%rsp), %xmm0
movsd %xmm0, 0xe0(%rsp)
movsd 0x138(%rsp), %xmm0
mulsd 0xf8(%rsp), %xmm0
movsd %xmm0, 0xd8(%rsp)
movsd 0x130(%rsp), %xmm0
mulsd 0xf8(%rsp), %xmm0
movsd %xmm0, 0xd0(%rsp)
movsd 0x128(%rsp), %xmm0
mulsd 0xf8(%rsp), %xmm0
movsd %xmm0, 0xc8(%rsp)
movsd 0x140(%rsp), %xmm0
mulsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0xc0(%rsp)
movsd 0x138(%rsp), %xmm0
mulsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0xb8(%rsp)
movsd 0x130(%rsp), %xmm0
mulsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0xb0(%rsp)
movsd 0x128(%rsp), %xmm0
mulsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0xa8(%rsp)
movsd 0xe0(%rsp), %xmm0
addsd 0xc0(%rsp), %xmm0
movsd %xmm0, 0xa0(%rsp)
movsd 0xd8(%rsp), %xmm0
addsd 0xb8(%rsp), %xmm0
movsd %xmm0, 0x98(%rsp)
movsd 0xd0(%rsp), %xmm0
addsd 0xb0(%rsp), %xmm0
movsd %xmm0, 0x90(%rsp)
movsd 0xc8(%rsp), %xmm0
addsd 0xa8(%rsp), %xmm0
movsd %xmm0, 0x88(%rsp)
movsd 0xe0(%rsp), %xmm0
movsd 0x384f5(%rip), %xmm1    # 0x59808
ucomisd %xmm1, %xmm0
jbe 0x21329
movsd 0x384e7(%rip), %xmm0    # 0x59808
movsd %xmm0, 0x60(%rsp)
jmp 0x21338
movsd 0xe0(%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0xe0(%rsp)
movsd 0xd8(%rsp), %xmm0
movsd 0x384b0(%rip), %xmm1    # 0x59808
ucomisd %xmm1, %xmm0
jbe 0x2136e
movsd 0x384a2(%rip), %xmm0    # 0x59808
movsd %xmm0, 0x58(%rsp)
jmp 0x2137d
movsd 0xd8(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0xd8(%rsp)
movsd 0xd0(%rsp), %xmm0
movsd 0x3846b(%rip), %xmm1    # 0x59808
ucomisd %xmm1, %xmm0
jbe 0x213b3
movsd 0x3845d(%rip), %xmm0    # 0x59808
movsd %xmm0, 0x50(%rsp)
jmp 0x213c2
movsd 0xd0(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0xd0(%rsp)
movsd 0xc8(%rsp), %xmm0
movsd 0x38426(%rip), %xmm1    # 0x59808
ucomisd %xmm1, %xmm0
jbe 0x213f8
movsd 0x38418(%rip), %xmm0    # 0x59808
movsd %xmm0, 0x48(%rsp)
jmp 0x21407
movsd 0xc8(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0xc8(%rsp)
movsd 0xc0(%rsp), %xmm0
movsd 0x383e1(%rip), %xmm1    # 0x59808
ucomisd %xmm1, %xmm0
jbe 0x2143d
movsd 0x383d3(%rip), %xmm0    # 0x59808
movsd %xmm0, 0x40(%rsp)
jmp 0x2144c
movsd 0xc0(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0xc0(%rsp)
movsd 0xb8(%rsp), %xmm0
movsd 0x3839c(%rip), %xmm1    # 0x59808
ucomisd %xmm1, %xmm0
jbe 0x21482
movsd 0x3838e(%rip), %xmm0    # 0x59808
movsd %xmm0, 0x38(%rsp)
jmp 0x21491
movsd 0xb8(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0xb8(%rsp)
movsd 0xb0(%rsp), %xmm0
movsd 0x38357(%rip), %xmm1    # 0x59808
ucomisd %xmm1, %xmm0
jbe 0x214c7
movsd 0x38349(%rip), %xmm0    # 0x59808
movsd %xmm0, 0x30(%rsp)
jmp 0x214d6
movsd 0xb0(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0xb0(%rsp)
movsd 0xa8(%rsp), %xmm0
movsd 0x38312(%rip), %xmm1    # 0x59808
ucomisd %xmm1, %xmm0
jbe 0x2150c
movsd 0x38304(%rip), %xmm0    # 0x59808
movsd %xmm0, 0x28(%rsp)
jmp 0x2151b
movsd 0xa8(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0xa8(%rsp)
movsd 0xa0(%rsp), %xmm0
movsd 0x382cd(%rip), %xmm1    # 0x59808
ucomisd %xmm1, %xmm0
jbe 0x21551
movsd 0x382bf(%rip), %xmm0    # 0x59808
movsd %xmm0, 0x20(%rsp)
jmp 0x21560
movsd 0xa0(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0xa0(%rsp)
movsd 0x98(%rsp), %xmm0
movsd 0x38288(%rip), %xmm1    # 0x59808
ucomisd %xmm1, %xmm0
jbe 0x21596
movsd 0x3827a(%rip), %xmm0    # 0x59808
movsd %xmm0, 0x18(%rsp)
jmp 0x215a5
movsd 0x98(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x98(%rsp)
movsd 0x90(%rsp), %xmm0
movsd 0x38243(%rip), %xmm1    # 0x59808
ucomisd %xmm1, %xmm0
jbe 0x215db
movsd 0x38235(%rip), %xmm0    # 0x59808
movsd %xmm0, 0x10(%rsp)
jmp 0x215ea
movsd 0x90(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x90(%rsp)
movsd 0x88(%rsp), %xmm0
movsd 0x381fe(%rip), %xmm1    # 0x59808
ucomisd %xmm1, %xmm0
jbe 0x21620
movsd 0x381f0(%rip), %xmm0    # 0x59808
movsd %xmm0, 0x8(%rsp)
jmp 0x2162f
movsd 0x88(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x88(%rsp)
movsd 0xa0(%rsp), %xmm1
movsd 0x120(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x120(%rsp)
movsd 0x98(%rsp), %xmm1
movsd 0x118(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x118(%rsp)
movsd 0x90(%rsp), %xmm1
movsd 0x110(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x110(%rsp)
movsd 0x88(%rsp), %xmm1
movsd 0x108(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x108(%rsp)
movq 0x210(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x2180b
jmp 0x216d2
movl 0x4(%rsp), %eax
subl $0x1, %eax
jne 0x218b5
jmp 0x216e1
movsd 0xe0(%rsp), %xmm1
addsd 0xd8(%rsp), %xmm1
addsd 0xd0(%rsp), %xmm1
addsd 0xc8(%rsp), %xmm1
movsd 0x37973(%rip), %xmm0    # 0x59080
mulsd %xmm1, %xmm0
movsd %xmm0, 0xf8(%rsp)
movsd 0xc0(%rsp), %xmm1
addsd 0xb8(%rsp), %xmm1
addsd 0xb0(%rsp), %xmm1
addsd 0xa8(%rsp), %xmm1
movsd 0x3793a(%rip), %xmm0    # 0x59080
mulsd %xmm1, %xmm0
movsd %xmm0, 0xf0(%rsp)
movsd 0xa0(%rsp), %xmm1
addsd 0x98(%rsp), %xmm1
addsd 0x90(%rsp), %xmm1
addsd 0x88(%rsp), %xmm1
movsd 0x37901(%rip), %xmm0    # 0x59080
mulsd %xmm1, %xmm0
movsd %xmm0, 0xe8(%rsp)
movsd 0xf8(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x100(%rsp), %rax
movss %xmm0, (%rax)
movsd 0xf0(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x100(%rsp), %rax
movq 0x1e8(%rsp), %rcx
movq 0x210(%rsp), %rdx
imulq 0x10(%rdx), %rcx
movss %xmm0, (%rax,%rcx,4)
movsd 0xe8(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x100(%rsp), %rax
movq 0x1e8(%rsp), %rcx
shlq %rcx
movq 0x210(%rsp), %rdx
imulq 0x10(%rdx), %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0x218b5
movsd 0xa0(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x100(%rsp), %rax
movss %xmm0, (%rax)
movsd 0x98(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x100(%rsp), %rax
movq 0x1e8(%rsp), %rcx
movq 0x210(%rsp), %rdx
imulq 0x10(%rdx), %rcx
movss %xmm0, (%rax,%rcx,4)
movsd 0x90(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x100(%rsp), %rax
movq 0x1e8(%rsp), %rcx
shlq %rcx
movq 0x210(%rsp), %rdx
imulq 0x10(%rdx), %rcx
movss %xmm0, (%rax,%rcx,4)
movsd 0x88(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x100(%rsp), %rax
imulq $0x3, 0x1e8(%rsp), %rcx
movq 0x210(%rsp), %rdx
imulq 0x10(%rdx), %rcx
movss %xmm0, (%rax,%rcx,4)
movq 0x1e8(%rsp), %rax
shlq $0x2, %rax
addq 0x100(%rsp), %rax
movq %rax, 0x100(%rsp)
movq 0x1f0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x1f0(%rsp)
jmp 0x2113f
movq 0x210(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rsp)
testl %eax, %eax
je 0x21a91
jmp 0x21901
movl (%rsp), %eax
subl $0x1, %eax
jne 0x21a93
jmp 0x2190f
movq 0x1e8(%rsp), %rax
shlq %rax
movq 0x210(%rsp), %rcx
imulq 0x10(%rcx), %rax
shlq $0x2, %rax
addq 0x100(%rsp), %rax
movq %rax, 0x100(%rsp)
movss 0x37eed(%rip), %xmm0    # 0x59830
callq 0x96a0
movaps %xmm0, %xmm1
movss 0x3783d(%rip), %xmm0    # 0x59190
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0x120(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x100(%rsp), %rax
movss %xmm0, (%rax)
movq 0x1e8(%rsp), %rax
shlq $0x2, %rax
addq 0x100(%rsp), %rax
movq %rax, 0x100(%rsp)
movss 0x37e98(%rip), %xmm0    # 0x59830
callq 0x96a0
movaps %xmm0, %xmm1
movss 0x377e8(%rip), %xmm0    # 0x59190
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0x118(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x100(%rsp), %rax
movss %xmm0, (%rax)
movq 0x1e8(%rsp), %rax
shlq $0x2, %rax
addq 0x100(%rsp), %rax
movq %rax, 0x100(%rsp)
movss 0x37e43(%rip), %xmm0    # 0x59830
callq 0x96a0
movaps %xmm0, %xmm1
movss 0x37793(%rip), %xmm0    # 0x59190
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0x110(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x100(%rsp), %rax
movss %xmm0, (%rax)
movq 0x1e8(%rsp), %rax
shlq $0x2, %rax
addq 0x100(%rsp), %rax
movq %rax, 0x100(%rsp)
movss 0x37dee(%rip), %xmm0    # 0x59830
callq 0x96a0
movaps %xmm0, %xmm1
movss 0x3773e(%rip), %xmm0    # 0x59190
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0x108(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x100(%rsp), %rax
movss %xmm0, (%rax)
movq 0x1e8(%rsp), %rax
shlq $0x2, %rax
addq 0x100(%rsp), %rax
movq %rax, 0x100(%rsp)
jmp 0x21a93
jmp 0x21a93
movq 0x1b0(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x1b0(%rsp)
movq 0x200(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x200(%rsp)
jmp 0x20aca
jmp 0x21ac2
movq 0x1f8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x1f8(%rsp)
jmp 0x20a9e
addq $0x218, %rsp            # imm = 0x218
retq
nopw %cs:(%rax,%rax)
nopl (%rax)