// File: manikandan5[P]Image-Matching-Stitching-Warping/siftpp/sift.cpp
// Function: VL::Sift::detectKeypoints(float, float)
void
Sift::detectKeypoints(VL::float_t threshold, VL::float_t edgeThreshold)
{
  keypoints.clear() ;

  int nValidatedKeypoints = 0 ;

  // Process one octave per time
  for(int o = omin ; o < omin + O ; ++o) {
        
    int const xo = 1 ;
    int const yo = getOctaveWidth(o) ;
    int const so = getOctaveWidth(o) * getOctaveHeight(o) ;
    int const ow = getOctaveWidth(o) ;
    int const oh = getOctaveHeight(o) ;

    VL::float_t xperiod = getOctaveSamplingPeriod(o) ;

    // -----------------------------------------------------------------
    //                                           Difference of Gaussians
    // -----------------------------------------------------------------
    pixel_t* dog = temp ;
    tempIsGrad = false ;
    {
      pixel_t* pt = dog ;
      for(int s = smin ; s <= smax-1 ; ++s) {
        pixel_t* srca = getLevel(o, s  ) ;
        pixel_t* srcb = getLevel(o, s+1) ;
        pixel_t* enda = srcb ;
        while( srca != enda ) {
          *pt++ = *srcb++ - *srca++ ;
        }
      }
    }
    
    // -----------------------------------------------------------------
    //                                           Find points of extremum
    // -----------------------------------------------------------------
    {
      pixel_t* pt  = dog + xo + yo + so ;
      for(int s = smin+1 ; s <= smax-2 ; ++s) {
        for(int y = 1 ; y < oh - 1 ; ++y) {
          for(int x = 1 ; x < ow - 1 ; ++x) {          
            pixel_t v = *pt ;
            
            // assert( (pt - x*xo - y*yo - (s-smin)*so) - dog == 0 ) ;
            
#define CHECK_NEIGHBORS(CMP,SGN)                    \
            ( v CMP ## = SGN 0.8 * threshold &&     \
              v CMP *(pt + xo) &&                   \
              v CMP *(pt - xo) &&                   \
              v CMP *(pt + so) &&                   \
              v CMP *(pt - so) &&                   \
              v CMP *(pt + yo) &&                   \
              v CMP *(pt - yo) &&                   \
                                                    \
              v CMP *(pt + yo + xo) &&              \
              v CMP *(pt + yo - xo) &&              \
              v CMP *(pt - yo + xo) &&              \
              v CMP *(pt - yo - xo) &&              \
                                                    \
              v CMP *(pt + xo      + so) &&         \
              v CMP *(pt - xo      + so) &&         \
              v CMP *(pt + yo      + so) &&         \
              v CMP *(pt - yo      + so) &&         \
              v CMP *(pt + yo + xo + so) &&         \
              v CMP *(pt + yo - xo + so) &&         \
              v CMP *(pt - yo + xo + so) &&         \
              v CMP *(pt - yo - xo + so) &&         \
                                                    \
              v CMP *(pt + xo      - so) &&         \
              v CMP *(pt - xo      - so) &&         \
              v CMP *(pt + yo      - so) &&         \
              v CMP *(pt - yo      - so) &&         \
              v CMP *(pt + yo + xo - so) &&         \
              v CMP *(pt + yo - xo - so) &&         \
              v CMP *(pt - yo + xo - so) &&         \
              v CMP *(pt - yo - xo - so) )
            
            if( CHECK_NEIGHBORS(>,+) || CHECK_NEIGHBORS(<,-) ) {
              
              Keypoint k ;
              k.ix = x ;
              k.iy = y ;
              k.is = s ;
              keypoints.push_back(k) ;
            }
            pt += 1 ;
          }
          pt += 2 ;
        }
        pt += 2*yo ;
      }
    }

    // -----------------------------------------------------------------
    //                                               Refine local maxima
    // -----------------------------------------------------------------
    { // refine
      KeypointsIter siter ;
      KeypointsIter diter ;
      
      for(diter = siter = keypointsBegin() + nValidatedKeypoints ; 
          siter != keypointsEnd() ; 
          ++siter) {
       
        int x = int( siter->ix ) ;
        int y = int( siter->iy ) ;
        int s = int( siter->is ) ;
                
        VL::float_t Dx=0,Dy=0,Ds=0,Dxx=0,Dyy=0,Dss=0,Dxy=0,Dxs=0,Dys=0 ;
        VL::float_t  b [3] ;
        pixel_t* pt ;
        int dx = 0 ;
        int dy = 0 ;

        // must be exec. at least once
        for(int iter = 0 ; iter < 5 ; ++iter) {

          VL::float_t A[3*3] ;          

          x += dx ;
          y += dy ;

          pt = dog 
            + xo * x
            + yo * y
            + so * (s - smin) ;

#define at(dx,dy,ds) (*( pt + (dx)*xo + (dy)*yo + (ds)*so))
#define Aat(i,j)     (A[(i)+(j)*3])    
          
          /* Compute the gradient. */
          Dx = 0.5 * (at(+1,0,0) - at(-1,0,0)) ;
          Dy = 0.5 * (at(0,+1,0) - at(0,-1,0));
          Ds = 0.5 * (at(0,0,+1) - at(0,0,-1)) ;
          
          /* Compute the Hessian. */
          Dxx = (at(+1,0,0) + at(-1,0,0) - 2.0 * at(0,0,0)) ;
          Dyy = (at(0,+1,0) + at(0,-1,0) - 2.0 * at(0,0,0)) ;
          Dss = (at(0,0,+1) + at(0,0,-1) - 2.0 * at(0,0,0)) ;
          
          Dxy = 0.25 * ( at(+1,+1,0) + at(-1,-1,0) - at(-1,+1,0) - at(+1,-1,0) ) ;
          Dxs = 0.25 * ( at(+1,0,+1) + at(-1,0,-1) - at(-1,0,+1) - at(+1,0,-1) ) ;
          Dys = 0.25 * ( at(0,+1,+1) + at(0,-1,-1) - at(0,-1,+1) - at(0,+1,-1) ) ;
          
          /* Solve linear system. */
          Aat(0,0) = Dxx ;
          Aat(1,1) = Dyy ;
          Aat(2,2) = Dss ;
          Aat(0,1) = Aat(1,0) = Dxy ;
          Aat(0,2) = Aat(2,0) = Dxs ;
          Aat(1,2) = Aat(2,1) = Dys ;
          
          b[0] = - Dx ;
          b[1] = - Dy ;
          b[2] = - Ds ;
          
          // Gauss elimination
          for(int j = 0 ; j < 3 ; ++j) {

            // look for leading pivot
            VL::float_t maxa = 0 ;
            VL::float_t maxabsa = 0 ;
            int   maxi = -1 ;
            int i ;
            for(i = j ; i < 3 ; ++i) {
              VL::float_t a    = Aat(i,j) ;
              VL::float_t absa = fabsf( a ) ;
              if ( absa > maxabsa ) {
                maxa    = a ;
                maxabsa = absa ;
                maxi    = i ;
              }
            }

            // singular?
            if( maxabsa < 1e-10f ) {
              b[0] = 0 ;
              b[1] = 0 ;
              b[2] = 0 ;
              break ;
            }

            i = maxi ;

            // swap j-th row with i-th row and
            // normalize j-th row
            for(int jj = j ; jj < 3 ; ++jj) {
              std::swap( Aat(j,jj) , Aat(i,jj) ) ;
              Aat(j,jj) /= maxa ;
            }
            std::swap( b[j], b[i] ) ;
            b[j] /= maxa ;

            // elimination
            for(int ii = j+1 ; ii < 3 ; ++ii) {
              VL::float_t x = Aat(ii,j) ;
              for(int jj = j ; jj < 3 ; ++jj) {
                Aat(ii,jj) -= x * Aat(j,jj) ;                
              }
              b[ii] -= x * b[j] ;
            }
          }

          // backward substitution
          for(int i = 2 ; i > 0 ; --i) {
            VL::float_t x = b[i] ;
            for(int ii = i-1 ; ii >= 0 ; --ii) {
              b[ii] -= x * Aat(ii,i) ;
            }
          }

          /* If the translation of the keypoint is big, move the keypoint
           * and re-iterate the computation. Otherwise we are all set.
           */
          dx= ((b[0] >  0.6 && x < ow-2) ?  1 : 0 )
            + ((b[0] < -0.6 && x > 1   ) ? -1 : 0 ) ;
          
          dy= ((b[1] >  0.6 && y < oh-2) ?  1 : 0 )
            + ((b[1] < -0.6 && y > 1   ) ? -1 : 0 ) ;

          /*          
          std::cout<<x<<","<<y<<"="<<at(0,0,0)
                   <<"("
                   <<at(0,0,0)+0.5 * (Dx * b[0] + Dy * b[1] + Ds * b[2])<<")"
                   <<" "<<std::flush ; 
          */

          if( dx == 0 && dy == 0 ) break ;
        }
        
        /* std::cout<<std::endl ; */
        
        // Accept-reject keypoint
        {
          VL::float_t val = at(0,0,0) + 0.5 * (Dx * b[0] + Dy * b[1] + Ds * b[2]) ; 
          VL::float_t score = (Dxx+Dyy)*(Dxx+Dyy) / (Dxx*Dyy - Dxy*Dxy) ; 
          VL::float_t xn = x + b[0] ;
          VL::float_t yn = y + b[1] ;
          VL::float_t sn = s + b[2] ;
          
          if(fast_abs(val) > threshold &&
             score < (edgeThreshold+1)*(edgeThreshold+1)/edgeThreshold && 
             score >= 0 &&
             fast_abs(b[0]) < 1.5 &&
             fast_abs(b[1]) < 1.5 &&
             fast_abs(b[2]) < 1.5 &&
             xn >= 0    &&
             xn <= ow-1 &&
             yn >= 0    &&
             yn <= oh-1 &&
             sn >= smin &&
             sn <= smax ) {
            
            diter->o  = o ;
       
            diter->ix = x ;
            diter->iy = y ;
            diter->is = s ;

            diter->x = xn * xperiod ; 
            diter->y = yn * xperiod ; 
            diter->s = sn ;

            diter->sigma = getScaleFromIndex(o,sn) ;

            ++diter ;
          }
        }
      } // next candidate keypoint

      // prepare for next octave
      keypoints.resize( diter - keypoints.begin() ) ;
      nValidatedKeypoints = keypoints.size() ;
    } // refine block

  } // next octave
}

// Assembly:
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, 0x1d0(%rsp)
movss %xmm0, 0x1cc(%rsp)
movss %xmm1, 0x1c8(%rsp)
movq 0x1d0(%rsp), %rdi
movq %rdi, 0x40(%rsp)
addq $0x60, %rdi
callq 0xc5fd0
movq 0x40(%rsp), %rax
movl $0x0, 0x1c4(%rsp)
movl 0x14(%rax), %eax
movl %eax, 0x1c0(%rsp)
movq 0x40(%rsp), %rdx
movl 0x1c0(%rsp), %eax
movl 0x14(%rdx), %ecx
addl 0xc(%rdx), %ecx
cmpl %ecx, %eax
jge 0xc4144
movq 0x40(%rsp), %rdi
movl $0x1, 0x1bc(%rsp)
movl 0x1c0(%rsp), %esi
callq 0xc5d40
movq 0x40(%rsp), %rdi
movl %eax, 0x1b8(%rsp)
movl 0x1c0(%rsp), %esi
callq 0xc5d40
movq 0x40(%rsp), %rdi
movl %eax, 0x3c(%rsp)
movl 0x1c0(%rsp), %esi
callq 0xc5df0
movq 0x40(%rsp), %rdi
movl %eax, %ecx
movl 0x3c(%rsp), %eax
imull %ecx, %eax
movl %eax, 0x1b4(%rsp)
movl 0x1c0(%rsp), %esi
callq 0xc5d40
movq 0x40(%rsp), %rdi
movl %eax, 0x1b0(%rsp)
movl 0x1c0(%rsp), %esi
callq 0xc5df0
movq 0x40(%rsp), %rdi
movl %eax, 0x1ac(%rsp)
movl 0x1c0(%rsp), %esi
callq 0xc5ce0
movq 0x40(%rsp), %rax
movss %xmm0, 0x1a8(%rsp)
movq 0x30(%rax), %rcx
movq %rcx, 0x1a0(%rsp)
movb $0x0, 0x3c(%rax)
movq 0x1a0(%rsp), %rcx
movq %rcx, 0x198(%rsp)
movl 0x18(%rax), %eax
movl %eax, 0x194(%rsp)
movq 0x40(%rsp), %rcx
movl 0x194(%rsp), %eax
movl 0x1c(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0xc2337
movq 0x40(%rsp), %rdi
movl 0x1c0(%rsp), %esi
movl 0x194(%rsp), %edx
callq 0xc5ea0
movq 0x40(%rsp), %rdi
movq %rax, 0x188(%rsp)
movl 0x1c0(%rsp), %esi
movl 0x194(%rsp), %edx
addl $0x1, %edx
callq 0xc5ea0
movq %rax, 0x180(%rsp)
movq 0x180(%rsp), %rax
movq %rax, 0x178(%rsp)
movq 0x188(%rsp), %rax
cmpq 0x178(%rsp), %rax
je 0xc231f
movq 0x180(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x180(%rsp)
movss (%rax), %xmm0
movq 0x188(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x188(%rsp)
subss (%rax), %xmm0
movq 0x198(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x198(%rsp)
movss %xmm0, (%rax)
jmp 0xc22ba
jmp 0xc2321
movl 0x194(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x194(%rsp)
jmp 0xc224d
movq 0x40(%rsp), %rax
movq 0x1a0(%rsp), %rcx
addq $0x4, %rcx
movslq 0x1b8(%rsp), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movslq 0x1b4(%rsp), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movq %rcx, 0x170(%rsp)
movl 0x18(%rax), %eax
addl $0x1, %eax
movl %eax, 0x16c(%rsp)
movq 0x40(%rsp), %rcx
movl 0x16c(%rsp), %eax
movl 0x1c(%rcx), %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jg 0xc2eaf
movl $0x1, 0x168(%rsp)
movl 0x168(%rsp), %eax
movl 0x1ac(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xc2e76
movl $0x1, 0x164(%rsp)
movl 0x164(%rsp), %eax
movl 0x1b0(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xc2e4c
movq 0x170(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0x160(%rsp)
movss 0x160(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movss 0x1cc(%rsp), %xmm1
cvtss2sd %xmm1, %xmm2
movsd 0x2b084(%rip), %xmm1    # 0xed498
mulsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jb 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
ucomiss 0x4(%rax), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
ucomiss -0x4(%rax), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b4(%rsp), %rcx
ucomiss (%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b4(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
ucomiss (%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rcx
ucomiss (%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
ucomiss (%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rcx
ucomiss 0x4(%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rcx
ucomiss -0x4(%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
ucomiss 0x4(%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
ucomiss -0x4(%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b4(%rsp), %rcx
ucomiss 0x4(%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b4(%rsp), %rcx
ucomiss -0x4(%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rcx
ucomiss (%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rcx
ucomiss (%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rcx
ucomiss 0x4(%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rcx
ucomiss -0x4(%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rcx
ucomiss 0x4(%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rcx
ucomiss -0x4(%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b4(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
ucomiss 0x4(%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b4(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
ucomiss -0x4(%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
ucomiss (%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
ucomiss (%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
ucomiss 0x4(%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
ucomiss -0x4(%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
ucomiss 0x4(%rax,%rcx,4), %xmm0
jbe 0xc28b6
movss 0x160(%rsp), %xmm0
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
ucomiss -0x4(%rax,%rcx,4), %xmm0
ja 0xc2de2
movss 0x160(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
movss 0x1cc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm2
movsd 0x2abc8(%rip), %xmm0    # 0xed4a0
mulsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movss 0x4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movss -0x4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b4(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b4(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rcx
movss 0x4(%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rcx
movss -0x4(%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
movss 0x4(%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
movss -0x4(%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b4(%rsp), %rcx
movss 0x4(%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b4(%rsp), %rcx
movss -0x4(%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rcx
movss 0x4(%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rcx
movss -0x4(%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rcx
movss 0x4(%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rcx
movss -0x4(%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b4(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
movss 0x4(%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b4(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
movss -0x4(%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
movss 0x4(%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
movss -0x4(%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
movss 0x4(%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movss 0x160(%rsp), %xmm1
movq 0x170(%rsp), %rax
movslq 0x1b8(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b4(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
movss -0x4(%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc2e22
movq 0x40(%rsp), %rdi
movl 0x164(%rsp), %eax
movl %eax, 0x144(%rsp)
movl 0x168(%rsp), %eax
movl %eax, 0x148(%rsp)
movl 0x16c(%rsp), %eax
movl %eax, 0x14c(%rsp)
addq $0x60, %rdi
leaq 0x140(%rsp), %rsi
callq 0xc5ff0
movq 0x170(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x170(%rsp)
movl 0x164(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x164(%rsp)
jmp 0xc23c4
movq 0x170(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x170(%rsp)
movl 0x168(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x168(%rsp)
jmp 0xc23a0
movl 0x1b8(%rsp), %ecx
shll %ecx
movq 0x170(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x170(%rsp)
movl 0x16c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x16c(%rsp)
jmp 0xc237b
leaq 0x138(%rsp), %rdi
callq 0xc6060
leaq 0x130(%rsp), %rdi
callq 0xc6060
movq 0x40(%rsp), %rdi
callq 0x93d10
movq %rax, 0x120(%rsp)
movslq 0x1c4(%rsp), %rsi
leaq 0x120(%rsp), %rdi
callq 0xc6080
movq %rax, 0x128(%rsp)
movq 0x128(%rsp), %rax
movq %rax, 0x138(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x130(%rsp)
movq 0x40(%rsp), %rdi
callq 0x93dc0
movq %rax, 0x118(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0x118(%rsp), %rsi
callq 0xc60c0
testb $0x1, %al
jne 0xc2f48
jmp 0xc40dd
leaq 0x138(%rsp), %rdi
callq 0xc6100
movl 0x4(%rax), %eax
movl %eax, 0x114(%rsp)
leaq 0x138(%rsp), %rdi
callq 0xc6100
movl 0x8(%rax), %eax
movl %eax, 0x110(%rsp)
leaq 0x138(%rsp), %rdi
callq 0xc6100
movl 0xc(%rax), %eax
movl %eax, 0x10c(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x108(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x104(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x100(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0xfc(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0xf8(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0xf4(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0xf0(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0xec(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0xe8(%rsp)
movl $0x0, 0xcc(%rsp)
movl $0x0, 0xc8(%rsp)
movl $0x0, 0xc4(%rsp)
cmpl $0x5, 0xc4(%rsp)
jge 0xc3ce2
movq 0x40(%rsp), %rsi
movl 0xcc(%rsp), %eax
addl 0x114(%rsp), %eax
movl %eax, 0x114(%rsp)
movl 0xc8(%rsp), %eax
addl 0x110(%rsp), %eax
movl %eax, 0x110(%rsp)
movq 0x1a0(%rsp), %rax
movl 0x114(%rsp), %ecx
shll $0x0, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl 0x1b8(%rsp), %ecx
imull 0x110(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl 0x1b4(%rsp), %ecx
movl 0x10c(%rsp), %edx
subl 0x18(%rsi), %edx
imull %edx, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0xd0(%rsp)
movq 0xd0(%rsp), %rax
addq $0x4, %rax
imull $0x0, 0x1b8(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0x0, 0x1b4(%rsp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq 0xd0(%rsp), %rax
addq $-0x4, %rax
imull $0x0, 0x1b8(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0x0, 0x1b4(%rsp), %ecx
movslq %ecx, %rcx
subss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x4f2e(%rip), %xmm0     # 0xc8048
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x108(%rsp)
movq 0xd0(%rsp), %rax
movl 0x1b8(%rsp), %ecx
shll $0x0, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0x0, 0x1b4(%rsp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq 0xd0(%rsp), %rax
imull $0xffffffff, 0x1b8(%rsp), %ecx # imm = 0xFFFFFFFF
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0x0, 0x1b4(%rsp), %ecx
movslq %ecx, %rcx
subss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x4eb8(%rip), %xmm0     # 0xc8048
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x104(%rsp)
movq 0xd0(%rsp), %rax
imull $0x0, 0x1b8(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl 0x1b4(%rsp), %ecx
shll $0x0, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq 0xd0(%rsp), %rax
imull $0x0, 0x1b8(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0xffffffff, 0x1b4(%rsp), %ecx # imm = 0xFFFFFFFF
movslq %ecx, %rcx
subss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x4e42(%rip), %xmm0     # 0xc8048
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x100(%rsp)
movq 0xd0(%rsp), %rax
addq $0x4, %rax
imull $0x0, 0x1b8(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0x0, 0x1b4(%rsp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq 0xd0(%rsp), %rax
addq $-0x4, %rax
imull $0x0, 0x1b8(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0x0, 0x1b4(%rsp), %ecx
movslq %ecx, %rcx
addss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0xd0(%rsp), %rax
imull $0x0, 0x1b8(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0x0, 0x1b4(%rsp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm1
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xfc(%rsp)
movq 0xd0(%rsp), %rax
movl 0x1b8(%rsp), %ecx
shll $0x0, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0x0, 0x1b4(%rsp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq 0xd0(%rsp), %rax
imull $0xffffffff, 0x1b8(%rsp), %ecx # imm = 0xFFFFFFFF
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0x0, 0x1b4(%rsp), %ecx
movslq %ecx, %rcx
addss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0xd0(%rsp), %rax
imull $0x0, 0x1b8(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0x0, 0x1b4(%rsp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm1
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xf8(%rsp)
movq 0xd0(%rsp), %rax
imull $0x0, 0x1b8(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl 0x1b4(%rsp), %ecx
shll $0x0, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq 0xd0(%rsp), %rax
imull $0x0, 0x1b8(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0xffffffff, 0x1b4(%rsp), %ecx # imm = 0xFFFFFFFF
movslq %ecx, %rcx
addss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0xd0(%rsp), %rax
imull $0x0, 0x1b8(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0x0, 0x1b4(%rsp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm1
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xf4(%rsp)
movq 0xd0(%rsp), %rax
addq $0x4, %rax
movl 0x1b8(%rsp), %ecx
shll $0x0, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0x0, 0x1b4(%rsp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq 0xd0(%rsp), %rax
addq $-0x4, %rax
imull $0xffffffff, 0x1b8(%rsp), %ecx # imm = 0xFFFFFFFF
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0x0, 0x1b4(%rsp), %ecx
movslq %ecx, %rcx
addss (%rax,%rcx,4), %xmm0
movq 0xd0(%rsp), %rax
addq $-0x4, %rax
movl 0x1b8(%rsp), %ecx
shll $0x0, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0x0, 0x1b4(%rsp), %ecx
movslq %ecx, %rcx
subss (%rax,%rcx,4), %xmm0
movq 0xd0(%rsp), %rax
addq $0x4, %rax
imull $0xffffffff, 0x1b8(%rsp), %ecx # imm = 0xFFFFFFFF
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0x0, 0x1b4(%rsp), %ecx
movslq %ecx, %rcx
subss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x29fb0(%rip), %xmm0    # 0xed478
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xf0(%rsp)
movq 0xd0(%rsp), %rax
addq $0x4, %rax
imull $0x0, 0x1b8(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl 0x1b4(%rsp), %ecx
shll $0x0, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq 0xd0(%rsp), %rax
addq $-0x4, %rax
imull $0x0, 0x1b8(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0xffffffff, 0x1b4(%rsp), %ecx # imm = 0xFFFFFFFF
movslq %ecx, %rcx
addss (%rax,%rcx,4), %xmm0
movq 0xd0(%rsp), %rax
addq $-0x4, %rax
imull $0x0, 0x1b8(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl 0x1b4(%rsp), %ecx
shll $0x0, %ecx
movslq %ecx, %rcx
subss (%rax,%rcx,4), %xmm0
movq 0xd0(%rsp), %rax
addq $0x4, %rax
imull $0x0, 0x1b8(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0xffffffff, 0x1b4(%rsp), %ecx # imm = 0xFFFFFFFF
movslq %ecx, %rcx
subss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x29ed1(%rip), %xmm0    # 0xed478
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xec(%rsp)
movq 0xd0(%rsp), %rax
movl 0x1b8(%rsp), %ecx
shll $0x0, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl 0x1b4(%rsp), %ecx
shll $0x0, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq 0xd0(%rsp), %rax
imull $0xffffffff, 0x1b8(%rsp), %ecx # imm = 0xFFFFFFFF
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0xffffffff, 0x1b4(%rsp), %ecx # imm = 0xFFFFFFFF
movslq %ecx, %rcx
addss (%rax,%rcx,4), %xmm0
movq 0xd0(%rsp), %rax
imull $0xffffffff, 0x1b8(%rsp), %ecx # imm = 0xFFFFFFFF
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl 0x1b4(%rsp), %ecx
shll $0x0, %ecx
movslq %ecx, %rcx
subss (%rax,%rcx,4), %xmm0
movq 0xd0(%rsp), %rax
movl 0x1b8(%rsp), %ecx
shll $0x0, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0xffffffff, 0x1b4(%rsp), %ecx # imm = 0xFFFFFFFF
movslq %ecx, %rcx
subss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x29df8(%rip), %xmm0    # 0xed478
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xe8(%rsp)
movss 0xfc(%rsp), %xmm0
movss %xmm0, 0xa0(%rsp)
movss 0xf8(%rsp), %xmm0
movss %xmm0, 0xb0(%rsp)
movss 0xf4(%rsp), %xmm0
movss %xmm0, 0xc0(%rsp)
movss 0xf0(%rsp), %xmm0
movss %xmm0, 0xa4(%rsp)
movss %xmm0, 0xac(%rsp)
movss 0xec(%rsp), %xmm0
movss %xmm0, 0xa8(%rsp)
movss %xmm0, 0xb8(%rsp)
movss 0xe8(%rsp), %xmm0
movss %xmm0, 0xb4(%rsp)
movss %xmm0, 0xbc(%rsp)
movss 0x108(%rsp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, 0xdc(%rsp)
movss 0x104(%rsp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, 0xe0(%rsp)
movss 0x100(%rsp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, 0xe4(%rsp)
movl $0x0, 0x9c(%rsp)
cmpl $0x3, 0x9c(%rsp)
jge 0xc3ad3
xorps %xmm0, %xmm0
movss %xmm0, 0x98(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x94(%rsp)
movl $0xffffffff, 0x90(%rsp) # imm = 0xFFFFFFFF
movl 0x9c(%rsp), %eax
movl %eax, 0x8c(%rsp)
cmpl $0x3, 0x8c(%rsp)
jge 0xc386c
movl 0x8c(%rsp), %eax
imull $0x3, 0x9c(%rsp), %ecx
addl %ecx, %eax
cltq
movss 0xa0(%rsp,%rax,4), %xmm0
movss %xmm0, 0x88(%rsp)
movss 0x88(%rsp), %xmm0
movaps 0x29cce(%rip), %xmm1    # 0xed4d0
pand %xmm1, %xmm0
movss %xmm0, 0x84(%rsp)
movss 0x84(%rsp), %xmm0
ucomiss 0x94(%rsp), %xmm0
jbe 0xc3854
movss 0x88(%rsp), %xmm0
movss %xmm0, 0x98(%rsp)
movss 0x84(%rsp), %xmm0
movss %xmm0, 0x94(%rsp)
movl 0x8c(%rsp), %eax
movl %eax, 0x90(%rsp)
jmp 0xc3856
movl 0x8c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8c(%rsp)
jmp 0xc37bf
movss 0x29bdc(%rip), %xmm0    # 0xed450
ucomiss 0x94(%rsp), %xmm0
jbe 0xc38a7
xorps %xmm0, %xmm0
movss %xmm0, 0xdc(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0xe0(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0xe4(%rsp)
jmp 0xc3ad3
movl 0x90(%rsp), %eax
movl %eax, 0x8c(%rsp)
movl 0x9c(%rsp), %eax
movl %eax, 0x80(%rsp)
cmpl $0x3, 0x80(%rsp)
jge 0xc3962
movl 0x9c(%rsp), %eax
imull $0x3, 0x80(%rsp), %ecx
addl %ecx, %eax
cltq
leaq 0xa0(%rsp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
movl 0x8c(%rsp), %eax
imull $0x3, 0x80(%rsp), %ecx
addl %ecx, %eax
cltq
leaq 0xa0(%rsp), %rsi
shlq $0x2, %rax
addq %rax, %rsi
callq 0xc6110
movss 0x98(%rsp), %xmm1
movl 0x9c(%rsp), %eax
imull $0x3, 0x80(%rsp), %ecx
addl %ecx, %eax
cltq
movss 0xa0(%rsp,%rax,4), %xmm0
divss %xmm1, %xmm0
movss %xmm0, 0xa0(%rsp,%rax,4)
movl 0x80(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x80(%rsp)
jmp 0xc38c3
movslq 0x9c(%rsp), %rax
leaq 0xdc(%rsp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
movslq 0x8c(%rsp), %rax
leaq 0xdc(%rsp), %rsi
shlq $0x2, %rax
addq %rax, %rsi
callq 0xc6110
movss 0x98(%rsp), %xmm1
movslq 0x9c(%rsp), %rax
movss 0xdc(%rsp,%rax,4), %xmm0
divss %xmm1, %xmm0
movss %xmm0, 0xdc(%rsp,%rax,4)
movl 0x9c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
cmpl $0x3, 0x7c(%rsp)
jge 0xc3abb
movl 0x7c(%rsp), %eax
imull $0x3, 0x9c(%rsp), %ecx
addl %ecx, %eax
cltq
movss 0xa0(%rsp,%rax,4), %xmm0
movss %xmm0, 0x78(%rsp)
movl 0x9c(%rsp), %eax
movl %eax, 0x74(%rsp)
cmpl $0x3, 0x74(%rsp)
jge 0xc3a67
movss 0x78(%rsp), %xmm0
movl 0x9c(%rsp), %eax
imull $0x3, 0x74(%rsp), %ecx
addl %ecx, %eax
cltq
movss 0xa0(%rsp,%rax,4), %xmm2
movl 0x7c(%rsp), %eax
imull $0x3, 0x74(%rsp), %ecx
addl %ecx, %eax
cltq
movss 0xa0(%rsp,%rax,4), %xmm1
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0xa0(%rsp,%rax,4)
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0xc39ff
movss 0x78(%rsp), %xmm0
movslq 0x9c(%rsp), %rax
movss 0xdc(%rsp,%rax,4), %xmm2
movslq 0x7c(%rsp), %rax
movss 0xdc(%rsp,%rax,4), %xmm1
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0xdc(%rsp,%rax,4)
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0xc39ca
jmp 0xc3abd
movl 0x9c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x9c(%rsp)
jmp 0xc3780
movl $0x2, 0x70(%rsp)
cmpl $0x0, 0x70(%rsp)
jle 0xc3b74
movslq 0x70(%rsp), %rax
movss 0xdc(%rsp,%rax,4), %xmm0
movss %xmm0, 0x6c(%rsp)
movl 0x70(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x68(%rsp)
cmpl $0x0, 0x68(%rsp)
jl 0xc3b62
movss 0x6c(%rsp), %xmm0
movl 0x68(%rsp), %eax
imull $0x3, 0x70(%rsp), %ecx
addl %ecx, %eax
cltq
movss 0xa0(%rsp,%rax,4), %xmm2
movslq 0x68(%rsp), %rax
movss 0xdc(%rsp,%rax,4), %xmm1
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0xdc(%rsp,%rax,4)
movl 0x68(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x68(%rsp)
jmp 0xc3b05
jmp 0xc3b64
movl 0x70(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x70(%rsp)
jmp 0xc3adb
movss 0xdc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
xorl %eax, %eax
movsd 0x298f5(%rip), %xmm1    # 0xed480
ucomisd %xmm1, %xmm0
movb %al, 0x3b(%rsp)
jbe 0xc3baf
movl 0x114(%rsp), %eax
movl 0x1b0(%rsp), %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
setl %al
movb %al, 0x3b(%rsp)
movb 0x3b(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x34(%rsp)
movss 0xdc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
xorl %eax, %eax
movsd 0x298ad(%rip), %xmm0    # 0xed488
ucomisd %xmm1, %xmm0
movb %al, 0x3a(%rsp)
jbe 0xc3bf4
cmpl $0x1, 0x114(%rsp)
setg %al
movb %al, 0x3a(%rsp)
movl 0x34(%rsp), %eax
movb 0x3a(%rsp), %sil
xorl %ecx, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
testb $0x1, %sil
cmovnel %edx, %ecx
addl %ecx, %eax
movl %eax, 0xcc(%rsp)
movss 0xe0(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
xorl %eax, %eax
movsd 0x29855(%rip), %xmm1    # 0xed480
ucomisd %xmm1, %xmm0
movb %al, 0x33(%rsp)
jbe 0xc3c4f
movl 0x110(%rsp), %eax
movl 0x1ac(%rsp), %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
setl %al
movb %al, 0x33(%rsp)
movb 0x33(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x2c(%rsp)
movss 0xe0(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
xorl %eax, %eax
movsd 0x2980d(%rip), %xmm0    # 0xed488
ucomisd %xmm1, %xmm0
movb %al, 0x32(%rsp)
jbe 0xc3c94
cmpl $0x1, 0x110(%rsp)
setg %al
movb %al, 0x32(%rsp)
movl 0x2c(%rsp), %eax
movb 0x32(%rsp), %sil
xorl %ecx, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
testb $0x1, %sil
cmovnel %edx, %ecx
addl %ecx, %eax
movl %eax, 0xc8(%rsp)
cmpl $0x0, 0xcc(%rsp)
jne 0xc3cca
cmpl $0x0, 0xc8(%rsp)
jne 0xc3cca
jmp 0xc3ce2
jmp 0xc3ccc
movl 0xc4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc4(%rsp)
jmp 0xc301a
movq 0xd0(%rsp), %rax
imull $0x0, 0x1b8(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
imull $0x0, 0x1b4(%rsp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm1
movss 0x108(%rsp), %xmm2
movss 0xdc(%rsp), %xmm3
movss 0x104(%rsp), %xmm0
mulss 0xe0(%rsp), %xmm0
mulss %xmm3, %xmm2
addss %xmm0, %xmm2
movss 0x100(%rsp), %xmm0
movss 0xe4(%rsp), %xmm3
mulss %xmm3, %xmm0
addss %xmm2, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x42e6(%rip), %xmm2     # 0xc8048
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x64(%rsp)
movss 0xfc(%rsp), %xmm0
addss 0xf8(%rsp), %xmm0
movss 0xfc(%rsp), %xmm1
addss 0xf8(%rsp), %xmm1
mulss %xmm1, %xmm0
movss 0xfc(%rsp), %xmm1
movss 0xf8(%rsp), %xmm3
movss 0xf0(%rsp), %xmm2
mulss 0xf0(%rsp), %xmm2
movd %xmm2, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm2
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x60(%rsp)
cvtsi2ssl 0x114(%rsp), %xmm0
addss 0xdc(%rsp), %xmm0
movss %xmm0, 0x5c(%rsp)
cvtsi2ssl 0x110(%rsp), %xmm0
addss 0xe0(%rsp), %xmm0
movss %xmm0, 0x58(%rsp)
cvtsi2ssl 0x10c(%rsp), %xmm0
addss 0xe4(%rsp), %xmm0
movss %xmm0, 0x54(%rsp)
movss 0x64(%rsp), %xmm0
callq 0xc6150
ucomiss 0x1cc(%rsp), %xmm0
jbe 0xc40c9
movss 0x60(%rsp), %xmm1
movss 0x42d2(%rip), %xmm0     # 0xc8120
addss 0x1c8(%rsp), %xmm0
movss 0x42c1(%rip), %xmm2     # 0xc8120
addss 0x1c8(%rsp), %xmm2
mulss %xmm2, %xmm0
divss 0x1c8(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc40c9
movss 0x60(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0xc40c9
movss 0xdc(%rsp), %xmm0
callq 0xc6150
cvtss2sd %xmm0, %xmm1
movsd 0x295e6(%rip), %xmm0    # 0xed490
ucomisd %xmm1, %xmm0
jbe 0xc40c9
movss 0xe0(%rsp), %xmm0
callq 0xc6150
cvtss2sd %xmm0, %xmm1
movsd 0x295c2(%rip), %xmm0    # 0xed490
ucomisd %xmm1, %xmm0
jbe 0xc40c9
movss 0xe4(%rsp), %xmm0
callq 0xc6150
cvtss2sd %xmm0, %xmm1
movsd 0x2959e(%rip), %xmm0    # 0xed490
ucomisd %xmm1, %xmm0
jbe 0xc40c9
movss 0x5c(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0xc40c9
movss 0x5c(%rsp), %xmm1
movl 0x1b0(%rsp), %eax
subl $0x1, %eax
cvtsi2ss %eax, %xmm0
ucomiss %xmm1, %xmm0
jb 0xc40c9
movss 0x58(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0xc40c9
movss 0x58(%rsp), %xmm1
movl 0x1ac(%rsp), %eax
subl $0x1, %eax
cvtsi2ss %eax, %xmm0
ucomiss %xmm1, %xmm0
jb 0xc40c9
movq 0x40(%rsp), %rax
movss 0x54(%rsp), %xmm0
cvtsi2ssl 0x18(%rax), %xmm1
ucomiss %xmm1, %xmm0
jb 0xc40c9
movq 0x40(%rsp), %rax
movss 0x54(%rsp), %xmm1
cvtsi2ssl 0x1c(%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0xc40c9
movl 0x1c0(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0x130(%rsp), %rdi
callq 0xc6100
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
movl 0x114(%rsp), %eax
movl %eax, 0x10(%rsp)
leaq 0x130(%rsp), %rdi
callq 0xc6100
movl 0x10(%rsp), %ecx
movl %ecx, 0x4(%rax)
movl 0x110(%rsp), %eax
movl %eax, 0x14(%rsp)
leaq 0x130(%rsp), %rdi
callq 0xc6100
movl 0x14(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x10c(%rsp), %eax
movl %eax, 0x18(%rsp)
leaq 0x130(%rsp), %rdi
callq 0xc6100
movl 0x18(%rsp), %ecx
movl %ecx, 0xc(%rax)
movss 0x5c(%rsp), %xmm0
mulss 0x1a8(%rsp), %xmm0
movss %xmm0, 0x1c(%rsp)
leaq 0x130(%rsp), %rdi
callq 0xc6100
movss 0x1c(%rsp), %xmm0
movss %xmm0, 0x10(%rax)
movss 0x58(%rsp), %xmm0
mulss 0x1a8(%rsp), %xmm0
movss %xmm0, 0x20(%rsp)
leaq 0x130(%rsp), %rdi
callq 0xc6100
movss 0x20(%rsp), %xmm0
movss %xmm0, 0x14(%rax)
movss 0x54(%rsp), %xmm0
movss %xmm0, 0x24(%rsp)
leaq 0x130(%rsp), %rdi
callq 0xc6100
movss 0x24(%rsp), %xmm0
movq 0x40(%rsp), %rdi
movss %xmm0, 0x18(%rax)
cvtsi2ssl 0x1c0(%rsp), %xmm0
movss 0x54(%rsp), %xmm1
callq 0xc6170
movss %xmm0, 0x28(%rsp)
leaq 0x130(%rsp), %rdi
callq 0xc6100
movss 0x28(%rsp), %xmm0
movss %xmm0, 0x1c(%rax)
leaq 0x130(%rsp), %rdi
callq 0xc61d0
jmp 0xc40cb
leaq 0x138(%rsp), %rdi
callq 0xc61d0
jmp 0xc2f18
movq 0x40(%rsp), %rdi
movq %rdi, %rax
addq $0x60, %rax
movq %rax, (%rsp)
addq $0x60, %rdi
callq 0x93f30
movq %rax, 0x48(%rsp)
leaq 0x130(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xc6290
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xc61f0
movq 0x40(%rsp), %rdi
addq $0x60, %rdi
callq 0xc62d0
movl %eax, 0x1c4(%rsp)
movl 0x1c0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c0(%rsp)
jmp 0xc2161
addq $0x1d8, %rsp            # imm = 0x1D8
retq
nopl (%rax)