// File: pitzl[P]bobyqa/bobyqa.cc
// Function: altmov(long, long, double*, double*, double*, double*, long, double*, double*, long, long, double, double*, double*, double*, double*, double*, double*, double*)
static void
altmov(const INTEGER n, const INTEGER npt, REAL xpt[],
       REAL* xopt, REAL* bmat, REAL* zmat, const INTEGER ndim,
       REAL* sl, REAL* su, const INTEGER kopt, const INTEGER knew,
       const REAL adelt, REAL* xnew, REAL* xalt, REAL* alpha,
       REAL* cauchy, REAL* glag, REAL* hcol, REAL* w)
{
  /* The arguments N, NPT, XPT, XOPT, BMAT, ZMAT, NDIM, SL and SU all have the
     same meanings as the corresponding arguments of BOBYQB.

     KOPT is the index of the optimal interpolation point.

     KNEW is the index of the interpolation point that is going to be moved.

     ADELT is the current trust region bound.

     XNEW will be set to a suitable new position for the interpolation point
     XPT(KNEW,.).  Specifically, it satisfies the SL, SU and trust region
     bounds and it should provide a large denominator in the next call of
     UPDATE.  The step XNEW-XOPT from XOPT is restricted to moves along the
     straight lines through XOPT and another interpolation point.

     XALT also provides a large value of the modulus of the KNEW-th Lagrange
     function subject to the constraints that have been mentioned, its main
     difference from XNEW being that XALT-XOPT is a constrained version of the
     Cauchy step within the trust region.  An exception is that XALT is not
     calculated if all components of GLAG (see below) are zero.

     ALPHA will be set to the KNEW-th diagonal element of the H matrix.

     CAUCHY will be set to the square of the KNEW-th Lagrange function at the
     step XALT-XOPT from XOPT for the vector XALT that is returned, except that
     CAUCHY is set to zero if XALT is not calculated.

     GLAG is a working space vector of length N for the gradient of the KNEW-th
     Lagrange function at XOPT.

     HCOL is a working space vector of length NPT for the second derivative
     coefficients of the KNEW-th Lagrange function.

     W is a working space vector of length 2N that is going to hold the
     constrained Cauchy step from XOPT of the Lagrange function, followed by
     the downhill version of XALT when the uphill step is calculated. */

  /* Constants. */
  const REAL half = 0.5;
  const REAL one = 1.0;
  const REAL zero = 0.0;
  const REAL one_plus_sqrt2 = one + M_SQRT2;

  /* Local variables. */
  REAL bigstp, csave, curv, dderiv, diff, distsq, ggfree, gw, ha,
    predsq, presav, scale, slbd, step, stpsav, subd, sumin,
    temp, tempa, tempb, tempd, vlag, wfixsq, wsqsav;
  INTEGER i, i1, ibdsav, iflag, ilbd, isbd, iubd, j, k, ksav;

  /* Parameter adjustments to comply with FORTRAN indexing. */
  xpt  -= 1 + npt;
  xopt -= 1;
  bmat -= 1 + ndim;
  zmat -= 1 + npt;
  sl   -= 1;
  su   -= 1;
  xnew -= 1;
  xalt -= 1;
  glag -= 1;
  hcol -= 1;
  w    -= 1;
#define XPT(a1,a2) xpt[(a2)*npt + a1]
#define BMAT(a1,a2) bmat[(a2)*ndim + a1]
#define ZMAT(a1,a2) zmat[(a2)*npt + a1]

  /* FIXME: Set uninitialized variables. */
  csave = zero;
  stpsav = zero;
  step = zero;
  ksav = 0;
  ibdsav = 0;

  /* Set the first NPT components of W to the leading elements of the KNEW-th
     column of the H matrix. */
  LOOP(k,npt ) {
    hcol[k] = zero;
  }
  i1 = npt - n - 1;
  LOOP(j,i1 ) {
    temp = ZMAT(knew, j);
    LOOP(k,npt ) {
      hcol[k] += temp*ZMAT(k,j);
    }
  }
  *alpha = hcol[knew];
  ha = half*(*alpha);

  /* Calculate the gradient of the KNEW-th Lagrange function at XOPT. */
  LOOP(i,n ) {
    glag[i] = BMAT(knew, i);
  }
  LOOP(k,npt ) {
    temp = zero;
    LOOP(j,n ) {
      temp += XPT(k,j)*xopt[j];
    }
    temp = hcol[k]*temp;
    LOOP(i,n ) {
      glag[i] += temp*XPT(k,i);
    }
  }

  /* Search for a large denominator along the straight lines through XOPT and
     another interpolation point.  SLBD and SUBD will be lower and upper bounds
     on the step along each of these lines in turn.  PREDSQ will be set to the
     square of the predicted denominator for each line.  PRESAV will be set to
     the largest admissible value of PREDSQ that occurs. */
  presav = zero;
  LOOP(k,npt ) {
    if( k == kopt ) {
      continue;
    }
    dderiv = zero;
    distsq = zero;
    LOOP(i,n ) {
      temp = XPT(k,i) - xopt[i];
      dderiv += glag[i]*temp;
      distsq += temp*temp;
    }
    subd = adelt/SQRT(distsq);
    slbd = -subd;
    ilbd = 0;
    iubd = 0;
    sumin = MIN(one,subd);

    /* Revise SLBD and SUBD if necessary because of the bounds in SL and SU. */
    LOOP(i,n ) {
      temp = XPT(k,i) - xopt[i];
      if( temp > zero ) {
        if( slbd*temp < sl[i] - xopt[i] ) {
          slbd = (sl[i] - xopt[i])/temp;
          ilbd = -i;
        }
        if( subd*temp > su[i] - xopt[i] ) {
          subd = (su[i] - xopt[i])/temp;
          subd = MAX(subd,sumin);
          iubd = i;
        }
      }
      else if( temp < zero ) {
        if( slbd*temp > su[i] - xopt[i] ) {
          slbd = (su[i] - xopt[i])/temp;
          ilbd = i;
        }
        if( subd*temp < sl[i] - xopt[i] ) {
          subd = (sl[i] - xopt[i])/temp;
          subd = MAX(subd,sumin);
          iubd = -i;
        }
      }
    }

    /* Seek a large modulus of the KNEW-th Lagrange function when the index of
       the other interpolation point on the line through XOPT is KNEW. */
    if( k == knew ) {
      diff = dderiv - one;
      step = slbd;
      vlag = slbd*(dderiv - slbd*diff);
      isbd = ilbd;
      temp = subd*(dderiv - subd*diff);
      if( ABS(temp) > ABS(vlag) ) {
        step = subd;
        vlag = temp;
        isbd = iubd;
      }
      tempd = half*dderiv;
      tempa = tempd - diff*slbd;
      tempb = tempd - diff*subd;
      if( tempa*tempb < zero ) {
        temp = tempd*tempd/diff;
        if( ABS(temp) > ABS(vlag) ) {
          step = tempd/diff;
          vlag = temp;
          isbd = 0;
        }
      }

      /* Search along each of the other lines through XOPT and another
         point. */
    }
    else {
      step = slbd;
      vlag = slbd*(one - slbd);
      isbd = ilbd;
      temp = subd*(one - subd);
      if( ABS(temp) > ABS(vlag) ) {
        step = subd;
        vlag = temp;
        isbd = iubd;
      }
      if( subd > half ) {
        if( ABS(vlag) < 0.25 ) {
          step = half;
          vlag = 0.25;
          isbd = 0;
        }
      }
      vlag *= dderiv;
    }

    /* Calculate PREDSQ for the current line search and maintain PRESAV. */
    temp = step*(one - step)*distsq;
    predsq = vlag*vlag*(vlag*vlag + ha*temp*temp);
    if( predsq > presav ) {
      presav = predsq;
      ksav = k;
      stpsav = step;
      ibdsav = isbd;
    }
  }

  /* Construct XNEW in a way that satisfies the bound constraints exactly. */
  LOOP(i,n ) {
    temp = xopt[i] + stpsav*(XPT(ksav,i) - xopt[i]);
    temp = MIN(temp,su[i]);
    xnew[i] = MAX(temp,sl[i]);
  }
  if( ibdsav < 0 ) {
    xnew[-ibdsav] = sl[-ibdsav];
  }
  if( ibdsav > 0 ) {
    xnew[ibdsav] = su[ibdsav];
  }

  /* Prepare for the iterative method that assembles the constrained Cauchy
     step in W.  The sum of squares of the fixed components of W is formed in
     WFIXSQ, and the free components of W are set to BIGSTP. */
  bigstp = adelt + adelt;
  iflag = 0;
  for( ;; ) {
    wfixsq = zero;
    ggfree = zero;
    LOOP(i,n ) {
      w[i] = zero;
      tempa = xopt[i] - sl[i];
      tempa = MIN(tempa,glag[i]);
      tempb = xopt[i] - su[i];
      tempb = MAX(tempb,glag[i]);
      if( tempa > zero || tempb < zero ) {
        w[i] = bigstp;
        ggfree += glag[i]*glag[i];
      }
    }
    if( ggfree == zero ) {
      *cauchy = zero;
      return;
    }

    /* Investigate whether more components of W can be fixed. */
    do {
      temp = adelt*adelt - wfixsq;
      if( temp <= zero) break;
      wsqsav = wfixsq;
      step = SQRT(temp/ggfree);
      ggfree = zero;
      LOOP(i,n ) {
        if( w[i] == bigstp ) {
          temp = xopt[i] - step*glag[i];
          if( temp <= sl[i] ) {
            w[i] = sl[i] - xopt[i];
            wfixsq += w[i]*w[i];
          }
	  else if( temp >= su[i] ) {
            w[i] = su[i] - xopt[i];
            wfixsq += w[i]*w[i];
          }
	  else {
            ggfree += glag[i]*glag[i];
          }
        }
      }
    } while (wfixsq > wsqsav && ggfree > zero);

    /* Set the remaining free components of W and all components of XALT,
       except that W may be scaled later. */
    gw = zero;
    LOOP(i,n ) {
      if( w[i] == bigstp ) {
        w[i] = -step*glag[i];
        temp = xopt[i] + w[i];
        temp = MIN(temp,su[i]);
        xalt[i] = MAX(temp,sl[i]);
      }
      else if( w[i] == zero ) {
        xalt[i] = xopt[i];
      }
      else if( glag[i] > zero ) {
        xalt[i] = sl[i];
      }
      else {
        xalt[i] = su[i];
      }
      gw += glag[i]*w[i];
    }

    /* Set CURV to the curvature of the KNEW-th Lagrange function along W.
       Scale W by a factor less than one if that can reduce the modulus of the
       Lagrange function at XOPT+W.  Set CAUCHY to the final value of the
       square of this function. */
    curv = zero;
    LOOP(k,npt ) {
      temp = zero;
      LOOP(j,n ) {
        temp += XPT(k,j)*w[j];
      }
      curv += hcol[k]*temp*temp;
    }
    if( iflag == 1 ) {
      curv = -curv;
    }
    if( curv > -gw && curv < -one_plus_sqrt2*gw ) {
      scale = -gw/curv;
      LOOP(i,n ) {
        temp = xopt[i] + scale*w[i];
        temp = MIN(temp,su[i]);
        xalt[i] = MAX(temp,sl[i]);
      }
      temp = half*gw*scale;
      *cauchy = temp*temp;
    }
    else {
      temp = gw + half*curv;
      *cauchy = temp*temp;
    }

    /* If IFLAG is zero, then XALT is calculated as before after reversing the
       sign of GLAG.  Thus two XALT vectors become available.  The one that is
       chosen is the one that gives the larger value of CAUCHY. */
    if( iflag != 0 ) {
      break;
    }
    LOOP(i,n ) {
      glag[i] = -glag[i];
      w[n + i] = xalt[i];
    }
    csave = *cauchy;
    iflag = 1;
  }
  if( csave > *cauchy ) {
    LOOP(i,n ) {
      xalt[i] = w[n + i];
    }
    *cauchy = csave;
  }

}

// Assembly:
subq $0x1d8, %rsp            # imm = 0x1D8
movq 0x238(%rsp), %rax
movq 0x230(%rsp), %rax
movq 0x228(%rsp), %rax
movq 0x220(%rsp), %rax
movq 0x218(%rsp), %rax
movq 0x210(%rsp), %rax
movq 0x208(%rsp), %rax
movq 0x200(%rsp), %rax
movq 0x1f8(%rsp), %rax
movq 0x1f0(%rsp), %rax
movq 0x1e8(%rsp), %rax
movq 0x1e0(%rsp), %rax
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
movq %rdx, 0x1c0(%rsp)
movq %rcx, 0x1b8(%rsp)
movq %r8, 0x1b0(%rsp)
movq %r9, 0x1a8(%rsp)
movsd %xmm0, 0x1a0(%rsp)
movsd 0x3408(%rip), %xmm0     # 0x11020
movsd %xmm0, 0x198(%rsp)
movsd 0x33ef(%rip), %xmm0     # 0x11018
movsd %xmm0, 0x190(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x188(%rsp)
movsd 0x3452(%rip), %xmm0     # 0x11098
movsd %xmm0, 0x180(%rsp)
movq 0x1c8(%rsp), %rdx
addq $0x1, %rdx
movq 0x1c0(%rsp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x1c0(%rsp)
movq 0x1b8(%rsp), %rax
addq $-0x8, %rax
movq %rax, 0x1b8(%rsp)
movq 0x1e0(%rsp), %rdx
addq $0x1, %rdx
movq 0x1b0(%rsp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x1b0(%rsp)
movq 0x1c8(%rsp), %rdx
addq $0x1, %rdx
movq 0x1a8(%rsp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x1a8(%rsp)
movq 0x1e8(%rsp), %rax
addq $-0x8, %rax
movq %rax, 0x1e8(%rsp)
movq 0x1f0(%rsp), %rax
addq $-0x8, %rax
movq %rax, 0x1f0(%rsp)
movq 0x208(%rsp), %rax
addq $-0x8, %rax
movq %rax, 0x208(%rsp)
movq 0x210(%rsp), %rax
addq $-0x8, %rax
movq %rax, 0x210(%rsp)
movq 0x228(%rsp), %rax
addq $-0x8, %rax
movq %rax, 0x228(%rsp)
movq 0x230(%rsp), %rax
addq $-0x8, %rax
movq %rax, 0x230(%rsp)
movq 0x238(%rsp), %rax
addq $-0x8, %rax
movq %rax, 0x238(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x170(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x108(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x110(%rsp)
movq $0x0, 0x70(%rsp)
movq $0x0, 0xa8(%rsp)
movq $0x1, 0x78(%rsp)
movq 0x78(%rsp), %rax
cmpq 0x1c8(%rsp), %rax
jg 0xdddd
movq 0x230(%rsp), %rax
movq 0x78(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq 0x78(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x78(%rsp)
jmp 0xdda9
movq 0x1c8(%rsp), %rax
subq 0x1d0(%rsp), %rax
subq $0x1, %rax
movq %rax, 0xb0(%rsp)
movq $0x1, 0x80(%rsp)
movq 0x80(%rsp), %rax
cmpq 0xb0(%rsp), %rax
jg 0xded8
movq 0x1a8(%rsp), %rax
movq 0x80(%rsp), %rcx
imulq 0x1c8(%rsp), %rcx
addq 0x200(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0xf0(%rsp)
movq $0x1, 0x78(%rsp)
movq 0x78(%rsp), %rax
cmpq 0x1c8(%rsp), %rax
jg 0xdebd
movsd 0xf0(%rsp), %xmm0
movq 0x1a8(%rsp), %rax
movq 0x80(%rsp), %rcx
imulq 0x1c8(%rsp), %rcx
addq 0x78(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq 0x230(%rsp), %rax
movq 0x78(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq 0x78(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x78(%rsp)
jmp 0xde53
jmp 0xdebf
movq 0x80(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x80(%rsp)
jmp 0xde05
movq 0x230(%rsp), %rax
movq 0x200(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x218(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x218(%rsp), %rax
movsd 0x3117(%rip), %xmm0     # 0x11020
mulsd (%rax), %xmm0
movsd %xmm0, 0x138(%rsp)
movq $0x1, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
cmpq 0x1d0(%rsp), %rax
jg 0xdf85
movq 0x1b0(%rsp), %rax
movq 0xb8(%rsp), %rcx
imulq 0x1e0(%rsp), %rcx
addq 0x200(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x228(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0xb8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xb8(%rsp)
jmp 0xdf22
movq $0x1, 0x78(%rsp)
movq 0x78(%rsp), %rax
cmpq 0x1c8(%rsp), %rax
jg 0xe0ee
xorps %xmm0, %xmm0
movsd %xmm0, 0xf0(%rsp)
movq $0x1, 0x80(%rsp)
movq 0x80(%rsp), %rax
cmpq 0x1d0(%rsp), %rax
jg 0xe033
movq 0x1c0(%rsp), %rax
movq 0x80(%rsp), %rcx
imulq 0x1c8(%rsp), %rcx
addq 0x78(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x1b8(%rsp), %rax
movq 0x80(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd 0xf0(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0xf0(%rsp)
movq 0x80(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x80(%rsp)
jmp 0xdfb9
movq 0x230(%rsp), %rax
movq 0x78(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
mulsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0xf0(%rsp)
movq $0x1, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
cmpq 0x1d0(%rsp), %rax
jg 0xe0d9
movsd 0xf0(%rsp), %xmm0
movq 0x1c0(%rsp), %rax
movq 0xb8(%rsp), %rcx
imulq 0x1c8(%rsp), %rcx
addq 0x78(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq 0x228(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq 0xb8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xb8(%rsp)
jmp 0xe063
jmp 0xe0db
movq 0x78(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x78(%rsp)
jmp 0xdf8e
xorps %xmm0, %xmm0
movsd %xmm0, 0x128(%rsp)
movq $0x1, 0x78(%rsp)
movq 0x78(%rsp), %rax
cmpq 0x1c8(%rsp), %rax
jg 0xeb3b
movq 0x78(%rsp), %rax
cmpq 0x1f8(%rsp), %rax
jne 0xe12a
jmp 0xeb28
xorps %xmm0, %xmm0
movsd %xmm0, 0x160(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x150(%rsp)
movq $0x1, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
cmpq 0x1d0(%rsp), %rax
jg 0xe222
movq 0x1c0(%rsp), %rax
movq 0xb8(%rsp), %rcx
imulq 0x1c8(%rsp), %rcx
addq 0x78(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x1b8(%rsp), %rax
movq 0xb8(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0xf0(%rsp)
movq 0x228(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0xf0(%rsp), %xmm2
movsd 0x160(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x160(%rsp)
movsd 0xf0(%rsp), %xmm0
movsd 0xf0(%rsp), %xmm2
movsd 0x150(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x150(%rsp)
movq 0xb8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xb8(%rsp)
jmp 0xe14e
movsd 0x1a0(%rsp), %xmm0
movsd %xmm0, 0x68(%rsp)
movsd 0x150(%rsp), %xmm0
callq 0x1030
movaps %xmm0, %xmm1
movsd 0x68(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x100(%rsp)
movsd 0x100(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x118(%rsp)
movq $0x0, 0x98(%rsp)
movq $0x0, 0x88(%rsp)
movsd 0x100(%rsp), %xmm0
movsd 0x2d71(%rip), %xmm1     # 0x11018
ucomisd %xmm1, %xmm0
jb 0xe2bd
movsd 0x2d63(%rip), %xmm0     # 0x11018
movsd %xmm0, 0x60(%rsp)
jmp 0xe2cc
movsd 0x100(%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0xf8(%rsp)
movq $0x1, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
cmpq 0x1d0(%rsp), %rax
jg 0xe654
movq 0x1c0(%rsp), %rax
movq 0xb8(%rsp), %rcx
imulq 0x1c8(%rsp), %rcx
addq 0x78(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x1b8(%rsp), %rax
movq 0xb8(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0xf0(%rsp)
movsd 0xf0(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xe4be
movsd 0x118(%rsp), %xmm1
mulsd 0xf0(%rsp), %xmm1
movq 0x1e8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x1b8(%rsp), %rax
movq 0xb8(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xe3e4
movq 0x1e8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x1b8(%rsp), %rax
movq 0xb8(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
divsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0x118(%rsp)
xorl %eax, %eax
subq 0xb8(%rsp), %rax
movq %rax, 0x98(%rsp)
movsd 0x100(%rsp), %xmm0
mulsd 0xf0(%rsp), %xmm0
movq 0x1f0(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x1b8(%rsp), %rax
movq 0xb8(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm1
ucomisd %xmm1, %xmm0
jbe 0xe4b9
movq 0x1f0(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x1b8(%rsp), %rax
movq 0xb8(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
divsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0x100(%rsp)
movsd 0x100(%rsp), %xmm0
ucomisd 0xf8(%rsp), %xmm0
jb 0xe48b
movsd 0x100(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
jmp 0xe49a
movsd 0xf8(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x100(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x88(%rsp)
jmp 0xe639
xorps %xmm0, %xmm0
ucomisd 0xf0(%rsp), %xmm0
jbe 0xe637
movsd 0x118(%rsp), %xmm0
mulsd 0xf0(%rsp), %xmm0
movq 0x1f0(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x1b8(%rsp), %rax
movq 0xb8(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm1
ucomisd %xmm1, %xmm0
jbe 0xe55e
movq 0x1f0(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x1b8(%rsp), %rax
movq 0xb8(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
divsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0x118(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x98(%rsp)
movsd 0x100(%rsp), %xmm1
mulsd 0xf0(%rsp), %xmm1
movq 0x1e8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x1b8(%rsp), %rax
movq 0xb8(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xe635
movq 0x1e8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x1b8(%rsp), %rax
movq 0xb8(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
divsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0x100(%rsp)
movsd 0x100(%rsp), %xmm0
ucomisd 0xf8(%rsp), %xmm0
jb 0xe605
movsd 0x100(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0xe614
movsd 0xf8(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x100(%rsp)
xorl %eax, %eax
subq 0xb8(%rsp), %rax
movq %rax, 0x88(%rsp)
jmp 0xe637
jmp 0xe639
jmp 0xe63b
movq 0xb8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xb8(%rsp)
jmp 0xe2e7
movq 0x78(%rsp), %rax
cmpq 0x200(%rsp), %rax
jne 0xe8fa
movsd 0x160(%rsp), %xmm0
movsd 0x29a0(%rip), %xmm1     # 0x11018
subsd %xmm1, %xmm0
movsd %xmm0, 0x158(%rsp)
movsd 0x118(%rsp), %xmm0
movsd %xmm0, 0x110(%rsp)
movsd 0x118(%rsp), %xmm0
movsd 0x160(%rsp), %xmm2
movsd 0x118(%rsp), %xmm1
movsd 0x158(%rsp), %xmm3
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0xd0(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x90(%rsp)
movsd 0x100(%rsp), %xmm0
movsd 0x160(%rsp), %xmm2
movsd 0x100(%rsp), %xmm1
movsd 0x158(%rsp), %xmm3
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0xf0(%rsp)
movsd 0xf0(%rsp), %xmm0
movaps 0x2959(%rip), %xmm1     # 0x110b0
pand %xmm1, %xmm0
movsd 0xd0(%rsp), %xmm1
movaps 0x2945(%rip), %xmm2     # 0x110b0
pand %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xe7a9
movsd 0x100(%rsp), %xmm0
movsd %xmm0, 0x110(%rsp)
movsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0xd0(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x90(%rsp)
movsd 0x286f(%rip), %xmm0     # 0x11020
mulsd 0x160(%rsp), %xmm0
movsd %xmm0, 0xd8(%rsp)
movsd 0xd8(%rsp), %xmm1
movsd 0x158(%rsp), %xmm0
movsd 0x118(%rsp), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0xe8(%rsp)
movsd 0xd8(%rsp), %xmm1
movsd 0x158(%rsp), %xmm0
movsd 0x100(%rsp), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0xe0(%rsp)
movsd 0xe8(%rsp), %xmm1
mulsd 0xe0(%rsp), %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0xe8f5
movsd 0xd8(%rsp), %xmm0
mulsd 0xd8(%rsp), %xmm0
divsd 0x158(%rsp), %xmm0
movsd %xmm0, 0xf0(%rsp)
movsd 0xf0(%rsp), %xmm0
movaps 0x2814(%rip), %xmm1     # 0x110b0
pand %xmm1, %xmm0
movsd 0xd0(%rsp), %xmm1
movaps 0x2800(%rip), %xmm2     # 0x110b0
pand %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xe8f3
movsd 0xd8(%rsp), %xmm0
divsd 0x158(%rsp), %xmm0
movsd %xmm0, 0x110(%rsp)
movsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0xd0(%rsp)
movq $0x0, 0x90(%rsp)
jmp 0xe8f5
jmp 0xea50
movsd 0x118(%rsp), %xmm0
movsd %xmm0, 0x110(%rsp)
movsd 0x118(%rsp), %xmm0
movsd 0x26fb(%rip), %xmm1     # 0x11018
subsd 0x118(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0xd0(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x90(%rsp)
movsd 0x100(%rsp), %xmm0
movsd 0x26c4(%rip), %xmm1     # 0x11018
subsd 0x100(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0xf0(%rsp)
movsd 0xf0(%rsp), %xmm0
movaps 0x2736(%rip), %xmm1     # 0x110b0
pand %xmm1, %xmm0
movsd 0xd0(%rsp), %xmm1
movaps 0x2722(%rip), %xmm2     # 0x110b0
pand %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xe9cc
movsd 0x100(%rsp), %xmm0
movsd %xmm0, 0x110(%rsp)
movsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0xd0(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x90(%rsp)
movsd 0x100(%rsp), %xmm0
movsd 0x2643(%rip), %xmm1     # 0x11020
ucomisd %xmm1, %xmm0
jbe 0xea35
movsd 0xd0(%rsp), %xmm1
movaps 0x26bd(%rip), %xmm0     # 0x110b0
pand %xmm0, %xmm1
movsd 0x2651(%rip), %xmm0     # 0x11050
ucomisd %xmm1, %xmm0
jbe 0xea33
movsd 0x2613(%rip), %xmm0     # 0x11020
movsd %xmm0, 0x110(%rsp)
movsd 0x2632(%rip), %xmm0     # 0x11050
movsd %xmm0, 0xd0(%rsp)
movq $0x0, 0x90(%rsp)
jmp 0xea35
movsd 0x160(%rsp), %xmm0
mulsd 0xd0(%rsp), %xmm0
movsd %xmm0, 0xd0(%rsp)
movsd 0x110(%rsp), %xmm0
movsd 0x25b7(%rip), %xmm1     # 0x11018
subsd 0x110(%rsp), %xmm1
mulsd %xmm1, %xmm0
mulsd 0x150(%rsp), %xmm0
movsd %xmm0, 0xf0(%rsp)
movsd 0xd0(%rsp), %xmm0
mulsd 0xd0(%rsp), %xmm0
movsd 0xd0(%rsp), %xmm1
movsd 0xd0(%rsp), %xmm3
movsd 0x138(%rsp), %xmm2
mulsd 0xf0(%rsp), %xmm2
mulsd 0xf0(%rsp), %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x130(%rsp)
movsd 0x130(%rsp), %xmm0
ucomisd 0x128(%rsp), %xmm0
jbe 0xeb26
movsd 0x130(%rsp), %xmm0
movsd %xmm0, 0x128(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x70(%rsp)
movsd 0x110(%rsp), %xmm0
movsd %xmm0, 0x108(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0xa8(%rsp)
jmp 0xeb28
movq 0x78(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x78(%rsp)
jmp 0xe103
movq $0x1, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
cmpq 0x1d0(%rsp), %rax
jg 0xeca3
movq 0x1b8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd 0x108(%rsp), %xmm0
movq 0x1c0(%rsp), %rax
movq 0xb8(%rsp), %rcx
imulq 0x1c8(%rsp), %rcx
addq 0x70(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq 0x1b8(%rsp), %rax
movq 0xb8(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0xf0(%rsp)
movsd 0xf0(%rsp), %xmm1
movq 0x1f0(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0xebf9
movsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
jmp 0xec14
movq 0x1f0(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0xf0(%rsp)
movsd 0xf0(%rsp), %xmm0
movq 0x1e8(%rsp), %rax
movq 0xb8(%rsp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jb 0xec54
movsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0xec6f
movq 0x1e8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
movq 0x208(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0xb8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xb8(%rsp)
jmp 0xeb47
cmpq $0x0, 0xa8(%rsp)
jge 0xecdc
movq 0x1e8(%rsp), %rax
xorl %ecx, %ecx
subq 0xa8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x208(%rsp), %rax
xorl %ecx, %ecx
subq 0xa8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
cmpq $0x0, 0xa8(%rsp)
jle 0xed11
movq 0x1f0(%rsp), %rax
movq 0xa8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x208(%rsp), %rax
movq 0xa8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movsd 0x1a0(%rsp), %xmm0
addsd 0x1a0(%rsp), %xmm0
movsd %xmm0, 0x178(%rsp)
movq $0x0, 0xa0(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0xc8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x148(%rsp)
movq $0x1, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
cmpq 0x1d0(%rsp), %rax
jg 0xef47
movq 0x238(%rsp), %rax
movq 0xb8(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq 0x1b8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x1e8(%rsp), %rax
movq 0xb8(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0xe8(%rsp)
movsd 0xe8(%rsp), %xmm1
movq 0x228(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0xedf2
movsd 0xe8(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
jmp 0xee0d
movq 0x228(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0xe8(%rsp)
movq 0x1b8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x1f0(%rsp), %rax
movq 0xb8(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0xe0(%rsp)
movsd 0xe0(%rsp), %xmm0
movq 0x228(%rsp), %rax
movq 0xb8(%rsp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jb 0xee80
movsd 0xe0(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0xee9b
movq 0x228(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0xe0(%rsp)
movsd 0xe8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
ja 0xeeca
xorps %xmm0, %xmm0
ucomisd 0xe0(%rsp), %xmm0
jbe 0xef2c
movsd 0x178(%rsp), %xmm0
movq 0x238(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x228(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x228(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd 0x148(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x148(%rsp)
jmp 0xef2e
movq 0xb8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xb8(%rsp)
jmp 0xed5c
movsd 0x148(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xef6f
jp 0xef6f
movq 0x220(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0xfa77
jmp 0xef71
movsd 0x1a0(%rsp), %xmm0
movsd 0x1a0(%rsp), %xmm2
movsd 0xc8(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0xf0(%rsp)
xorps %xmm0, %xmm0
ucomisd 0xf0(%rsp), %xmm0
jb 0xefc7
jmp 0xf2a7
movsd 0xc8(%rsp), %xmm0
movsd %xmm0, 0xc0(%rsp)
movsd 0xf0(%rsp), %xmm0
divsd 0x148(%rsp), %xmm0
callq 0x1030
movsd %xmm0, 0x110(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x148(%rsp)
movq $0x1, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
cmpq 0x1d0(%rsp), %rax
jg 0xf268
movq 0x238(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd 0x178(%rsp), %xmm0
jne 0xf24d
jp 0xf24d
movq 0x1b8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd 0x110(%rsp), %xmm0
movq 0x228(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0xf0(%rsp)
movsd 0xf0(%rsp), %xmm1
movq 0x1e8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0xf15c
movq 0x1e8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x1b8(%rsp), %rax
movq 0xb8(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq 0x238(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x238(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x238(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd 0xc8(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0xc8(%rsp)
jmp 0xf24b
movsd 0xf0(%rsp), %xmm0
movq 0x1f0(%rsp), %rax
movq 0xb8(%rsp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jb 0xf205
movq 0x1f0(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x1b8(%rsp), %rax
movq 0xb8(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq 0x238(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x238(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x238(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd 0xc8(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0xc8(%rsp)
jmp 0xf249
movq 0x228(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x228(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd 0x148(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x148(%rsp)
jmp 0xf24b
jmp 0xf24d
jmp 0xf24f
movq 0xb8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xb8(%rsp)
jmp 0xf011
jmp 0xf26a
movsd 0xc8(%rsp), %xmm0
xorl %eax, %eax
ucomisd 0xc0(%rsp), %xmm0
movb %al, 0x2f(%rsp)
jbe 0xf29b
movsd 0x148(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
seta %al
movb %al, 0x2f(%rsp)
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0xef71
xorps %xmm0, %xmm0
movsd %xmm0, 0x140(%rsp)
movq $0x1, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
cmpq 0x1d0(%rsp), %rax
jg 0xf568
movq 0x238(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd 0x178(%rsp), %xmm0
jne 0xf447
jp 0xf447
movsd 0x110(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq 0x228(%rsp), %rax
movq 0xb8(%rsp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq 0x238(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x1b8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x238(%rsp), %rax
movq 0xb8(%rsp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0xf0(%rsp)
movsd 0xf0(%rsp), %xmm1
movq 0x1f0(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0xf3b1
movsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0xf3cc
movq 0x1f0(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0xf0(%rsp)
movsd 0xf0(%rsp), %xmm0
movq 0x1e8(%rsp), %rax
movq 0xb8(%rsp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jb 0xf40c
movsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0xf427
movq 0x1e8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movq 0x210(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0xf50b
movq 0x238(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xf493
jp 0xf493
movq 0x1b8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x210(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0xf509
movq 0x228(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xf4dd
movq 0x1e8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x210(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0xf507
movq 0x1f0(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x210(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0xf509
jmp 0xf50b
movq 0x228(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x238(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd 0x140(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x140(%rsp)
movq 0xb8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xb8(%rsp)
jmp 0xf2bf
xorps %xmm0, %xmm0
movsd %xmm0, 0x168(%rsp)
movq $0x1, 0x78(%rsp)
movq 0x78(%rsp), %rax
cmpq 0x1c8(%rsp), %rax
jg 0xf673
xorps %xmm0, %xmm0
movsd %xmm0, 0xf0(%rsp)
movq $0x1, 0x80(%rsp)
movq 0x80(%rsp), %rax
cmpq 0x1d0(%rsp), %rax
jg 0xf622
movq 0x1c0(%rsp), %rax
movq 0x80(%rsp), %rcx
imulq 0x1c8(%rsp), %rcx
addq 0x78(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x238(%rsp), %rax
movq 0x80(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd 0xf0(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0xf0(%rsp)
movq 0x80(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x80(%rsp)
jmp 0xf5a8
movq 0x230(%rsp), %rax
movq 0x78(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
mulsd 0xf0(%rsp), %xmm0
movsd 0xf0(%rsp), %xmm2
movsd 0x168(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x168(%rsp)
movq 0x78(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x78(%rsp)
jmp 0xf57d
cmpq $0x1, 0xa0(%rsp)
jne 0xf6a7
movsd 0x168(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x168(%rsp)
movsd 0x168(%rsp), %xmm0
movsd 0x140(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xf8b8
movsd 0x168(%rsp), %xmm1
movsd 0x19b5(%rip), %xmm0     # 0x110a0
mulsd 0x140(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xf8b8
movsd 0x140(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
divsd 0x168(%rsp), %xmm0
movsd %xmm0, 0x120(%rsp)
movq $0x1, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
cmpq 0x1d0(%rsp), %rax
jg 0xf875
movq 0x1b8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd 0x120(%rsp), %xmm0
movq 0x238(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0xf0(%rsp)
movsd 0xf0(%rsp), %xmm1
movq 0x1f0(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0xf7cb
movsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0xf7e6
movq 0x1f0(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0xf0(%rsp)
movsd 0xf0(%rsp), %xmm0
movq 0x1e8(%rsp), %rax
movq 0xb8(%rsp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jb 0xf826
movsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0xf841
movq 0x1e8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movq 0x210(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0xb8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xb8(%rsp)
jmp 0xf73c
movsd 0x17a3(%rip), %xmm0     # 0x11020
mulsd 0x140(%rsp), %xmm0
mulsd 0x120(%rsp), %xmm0
movsd %xmm0, 0xf0(%rsp)
movsd 0xf0(%rsp), %xmm0
mulsd 0xf0(%rsp), %xmm0
movq 0x220(%rsp), %rax
movsd %xmm0, (%rax)
jmp 0xf901
movsd 0x140(%rsp), %xmm1
movsd 0x168(%rsp), %xmm0
movsd 0x174e(%rip), %xmm2     # 0x11020
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0xf0(%rsp)
movsd 0xf0(%rsp), %xmm0
mulsd 0xf0(%rsp), %xmm0
movq 0x220(%rsp), %rax
movsd %xmm0, (%rax)
cmpq $0x0, 0xa0(%rsp)
je 0xf911
jmp 0xf9e5
movq $0x1, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
cmpq 0x1d0(%rsp), %rax
jg 0xf9bf
movq 0x228(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq 0x228(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x210(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x238(%rsp), %rax
movq 0x1d0(%rsp), %rcx
addq 0xb8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0xb8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xb8(%rsp)
jmp 0xf91d
movq 0x220(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x170(%rsp)
movq $0x1, 0xa0(%rsp)
jmp 0xed38
movsd 0x170(%rsp), %xmm0
movq 0x220(%rsp), %rax
ucomisd (%rax), %xmm0
jbe 0xfa77
movq $0x1, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
cmpq 0x1d0(%rsp), %rax
jg 0xfa62
movq 0x238(%rsp), %rax
movq 0x1d0(%rsp), %rcx
addq 0xb8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x210(%rsp), %rax
movq 0xb8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0xb8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xb8(%rsp)
jmp 0xfa08
movsd 0x170(%rsp), %xmm0
movq 0x220(%rsp), %rax
movsd %xmm0, (%rax)
addq $0x1d8, %rsp            # imm = 0x1D8
retq
nop