// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/gmm.c
// Function: vl_gmm_restart_empty_modes_f
static vl_size
VL_XCAT(_vl_gmm_restart_empty_modes_, SFX) (VlGMM * self, TYPE const * data)
{
  vl_size dimension = self->dimension;
  vl_size numClusters = self->numClusters;
  vl_index i_cl, j_cl, i_d, d;
  vl_size zeroWNum = 0;
  TYPE * priors = (TYPE*)self->priors ;
  TYPE * means = (TYPE*)self->means ;
  TYPE * covariances = (TYPE*)self->covariances ;
  TYPE * posteriors = (TYPE*)self->posteriors ;

  //VlRand * rand = vl_get_rand() ;

  TYPE * mass = vl_calloc(sizeof(TYPE), self->numClusters) ;

  if (numClusters <= 1) { return 0 ; }

  /* compute statistics */
  {
    vl_uindex i, k ;
    vl_size numNullAssignments = 0 ;
    for (i = 0 ; i < self->numData ; ++i) {
      for (k = 0 ; k < self->numClusters ; ++k) {
        TYPE p = ((TYPE*)self->posteriors)[k + i * self->numClusters] ;
        mass[k] += p ;
        if (p < VL_GMM_MIN_POSTERIOR) {
          numNullAssignments ++ ;
        }
      }
    }
    if (self->verbosity) {
      VL_PRINTF("gmm: sparsity of data posterior: %.1f%%\n", (double)numNullAssignments / (self->numData * self->numClusters) * 100) ;
    }
  }

#if 0
  /* search for cluster with negligible weight and reassign them to fat clusters */
  for (i_cl = 0 ; i_cl < numClusters ; ++i_cl) {
    if (priors[i_cl] < 0.00001/numClusters) {
      double mass = priors[0]  ;
      vl_index best = 0 ;

      for (j_cl = 1 ; j_cl < numClusters ; ++j_cl) {
        if (priors[j_cl] > mass) { mass = priors[j_cl] ; best = j_cl ; }
      }

      if (j_cl == i_cl) {
        /* this should never happen */
        continue ;
      }

      j_cl = best ;
      zeroWNum ++ ;

      VL_PRINTF("gmm: restarting mode %d by splitting mode %d (with prior %f)\n", i_cl,j_cl,mass) ;

      priors[i_cl] = mass/2 ;
      priors[j_cl] = mass/2 ;
      for (d = 0 ; d < dimension ; ++d) {
        TYPE sigma2 =  covariances[j_cl*dimension + d] ;
        TYPE sigma = VL_XCAT(vl_sqrt_,SFX)(sigma2) ;
        means[i_cl*dimension + d] = means[j_cl*dimension + d] + 0.001 * (vl_rand_real1(rand) - 0.5) * sigma ;
        covariances[i_cl*dimension + d] = sigma2 ;
      }
    }
  }
#endif

  /* search for cluster with negligible weight and reassign them to fat clusters */
  for (i_cl = 0 ; i_cl < (signed)numClusters ; ++i_cl) {
    double size = - VL_INFINITY_D ;
    vl_index best = -1 ;

    if (mass[i_cl] >= VL_GMM_MIN_POSTERIOR *
        VL_MAX(1.0, (double) self->numData / self->numClusters))
    {
      continue ;
    }

    if (self->verbosity) {
      VL_PRINTF("gmm: mode %d is nearly empty (mass %f)\n", i_cl, mass[i_cl]) ;
    }

    /*
     Search for the Gaussian components that (approximately)
     maximally contribute to make the negative log-likelihood of the data
     large. Then split the worst offender.
     
     To do so, we approximate the exptected log-likelihood of the GMM:
     
     E[-log(f(x))] = H(f) = - log \int f(x) log f(x)
    
     where the density f(x) = sum_k pk gk(x) is a GMM. This is intractable
     but it is easy to approximate if we suppose that supp gk is disjoint with
     supp gq for all components k ~= q. In this canse
     
     H(f) ~= sum_k [ - pk log(pk) + pk H(gk) ]
     
     where H(gk) is the entropy of component k taken alone. The entropy of
     the latter is given by:
     
     H(gk) = D/2 (1 + log(2pi) + 1/2 sum_{i=0}^D log sigma_i^2

     */

    for (j_cl = 0 ; j_cl < (signed)numClusters ; ++j_cl) {
      double size_ ;
      if (priors[j_cl] < VL_GMM_MIN_PRIOR) { continue ; }
      size_ = + 0.5 * dimension * (1.0 + log(2*VL_PI)) ;
      for(d = 0 ; d < (signed)dimension ; d++) {
        double sigma2 = covariances[j_cl * dimension + d] ;
        size_ += 0.5 * log(sigma2) ;
      }
      size_ = priors[j_cl] * (size_ - log(priors[j_cl])) ;

      if (self->verbosity > 1) {
        VL_PRINTF("gmm: mode %d: prior %f, mass %f, entropy contribution %f\n",
                  j_cl, priors[j_cl], mass[j_cl], size_) ;
      }

      if (size_ > size) {
        size = size_ ;
        best = j_cl ;
      }
    }

    j_cl = best ;

    if (j_cl == i_cl || j_cl < 0) {
      if (self->verbosity) {
        VL_PRINTF("gmm: mode %d is empty, "
                  "but no other mode to split could be found\n", i_cl) ;
      }
      continue ;
    }

    if (self->verbosity) {
      VL_PRINTF("gmm: reinitializing empty mode %d with mode %d (prior %f, mass %f, score %f)\n",
                i_cl, j_cl, priors[j_cl], mass[j_cl], size) ;
    }

    /*
     Search for the dimension with maximum variance.
     */

    size = - VL_INFINITY_D ;
    best = - 1 ;

    for(d = 0; d < (signed)dimension; d++) {
      double sigma2 = covariances[j_cl * dimension + d] ;
      if (sigma2 > size) {
        size = sigma2 ;
        best = d ;
      }
    }

    /*
     Reassign points j_cl (mode to split) to i_cl (empty mode).
     */
    {
      TYPE mu = means[best + j_cl * self->dimension] ;
      for(i_d = 0 ; i_d < (signed)self->numData ; ++ i_d) {
        TYPE p = posteriors[j_cl + self->numClusters * i_d] ;
        TYPE q = posteriors[i_cl + self->numClusters * i_d] ; /* ~= 0 */
        if (data[best + i_d * self->dimension] < mu) {
          /* assign this point to i_cl */
          posteriors[i_cl + self->numClusters * i_d] = p + q ;
          posteriors[j_cl + self->numClusters * i_d] = 0 ;
        } else {
          /* assign this point to j_cl */
          posteriors[i_cl + self->numClusters * i_d] = 0 ;
          posteriors[j_cl + self->numClusters * i_d] = p + q ;
        }
      }
    }

    /*
     Re-estimate.
     */
    VL_XCAT(_vl_gmm_maximization_, SFX)
    (self,posteriors,priors,covariances,means,data,self->numData) ;
  }

  return zeroWNum;
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0xf8(%rsp)
movq %rsi, 0xf0(%rsp)
movq 0xf8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xe8(%rsp)
movq 0xf8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0xe0(%rsp)
movq $0x0, 0xb8(%rsp)
movq 0xf8(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0xb0(%rsp)
movq 0xf8(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0xa8(%rsp)
movq 0xf8(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0xa0(%rsp)
movq 0xf8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x98(%rsp)
movq 0xf8(%rsp), %rax
movq 0x10(%rax), %rsi
movl $0x4, %edi
callq 0x9a70
movq %rax, 0x90(%rsp)
cmpq $0x1, 0xe0(%rsp)
ja 0x1c765
movq $0x0, 0x100(%rsp)
jmp 0x1d0ad
movq $0x0, 0x78(%rsp)
movq $0x0, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq 0xf8(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x1c86d
movq $0x0, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq 0xf8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x1c852
movq 0xf8(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x80(%rsp), %rcx
movq 0x88(%rsp), %rdx
movq 0xf8(%rsp), %rsi
imulq 0x10(%rsi), %rdx
addq %rdx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, 0x74(%rsp)
movss 0x74(%rsp), %xmm0
movq 0x90(%rsp), %rax
movq 0x80(%rsp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movss 0x74(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x3c885(%rip), %xmm0    # 0x590a8
ucomisd %xmm1, %xmm0
jbe 0x1c837
movq 0x78(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x78(%rsp)
jmp 0x1c839
movq 0x80(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x80(%rsp)
jmp 0x1c7a0
jmp 0x1c854
movq 0x88(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x88(%rsp)
jmp 0x1c77a
movq 0xf8(%rsp), %rax
cmpl $0x0, 0x30(%rax)
je 0x1c8f2
callq 0x91a0
movq %rax, %rcx
movq 0x78(%rsp), %xmm0
movaps 0x3c8d0(%rip), %xmm3    # 0x59160
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x3c8d4(%rip), %xmm2    # 0x59170
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0xf8(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rax
imulq %rdx, %rax
movq %rax, %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd 0x3ca6d(%rip), %xmm1    # 0x59350
mulsd %xmm1, %xmm0
leaq 0x3cdab(%rip), %rdi     # 0x59699
movb $0x1, %al
callq *%rcx
movq $0x0, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
movq 0xe0(%rsp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x1d09d
movaps 0x3c85f(%rip), %xmm1    # 0x59180
movsd 0x3ca57(%rip), %xmm0    # 0x59380
pxor %xmm1, %xmm0
movlpd %xmm0, 0x68(%rsp)
movq $-0x1, 0x60(%rsp)
movq 0x90(%rsp), %rax
movq 0xd8(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0xf8(%rsp), %rax
movq 0x18(%rax), %xmm1
movaps 0x3c7f1(%rip), %xmm3    # 0x59160
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
movapd 0x3c7f5(%rip), %xmm2    # 0x59170
subpd %xmm2, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movq 0x10(%rax), %xmm0
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
subpd %xmm2, %xmm0
movaps %xmm0, %xmm2
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movsd 0x3c72a(%rip), %xmm0    # 0x590d8
ucomisd %xmm1, %xmm0
jbe 0x1c9c4
movsd 0x3c71c(%rip), %xmm0    # 0x590d8
movsd %xmm0, 0x28(%rsp)
jmp 0x1ca15
movq 0xf8(%rsp), %rax
movq 0x18(%rax), %xmm0
movaps 0x3c788(%rip), %xmm3    # 0x59160
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x3c78c(%rip), %xmm2    # 0x59170
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x10(%rax), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x28(%rsp), %xmm2
movsd 0x3c67f(%rip), %xmm1    # 0x590a8
mulsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1ca38
jmp 0x1d084
movq 0xf8(%rsp), %rax
cmpl $0x0, 0x30(%rax)
je 0x1ca7a
callq 0x91a0
movq %rax, %rcx
movq 0xd8(%rsp), %rsi
movq 0x90(%rsp), %rax
movq 0xd8(%rsp), %rdx
movss (%rax,%rdx,4), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x3cc4c(%rip), %rdi     # 0x596c2
movb $0x1, %al
callq *%rcx
movq $0x0, 0xd0(%rsp)
movq 0xd0(%rsp), %rax
movq 0xe0(%rsp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x1ccd4
movq 0xb0(%rsp), %rax
movq 0xd0(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x3c785(%rip), %xmm0    # 0x59248
ucomisd %xmm1, %xmm0
jbe 0x1cace
jmp 0x1ccbb
movaps 0x3c68b(%rip), %xmm0    # 0x59160
movq 0xe8(%rsp), %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0x3c686(%rip), %xmm0    # 0x59170
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd 0x3c57f(%rip), %xmm0    # 0x59080
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x3c71d(%rip), %xmm0    # 0x59230
callq 0x94c0
movaps %xmm0, %xmm2
movsd 0x20(%rsp), %xmm0
movsd 0x3c5af(%rip), %xmm1    # 0x590d8
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x58(%rsp)
movq $0x0, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
movq 0xe8(%rsp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x1cbcb
movq 0xa0(%rsp), %rax
movq 0xd0(%rsp), %rcx
imulq 0xe8(%rsp), %rcx
addq 0xc0(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
callq 0x94c0
movsd 0x58(%rsp), %xmm1
movsd 0x3c4dc(%rip), %xmm2    # 0x59080
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x58(%rsp)
movq 0xc0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xc0(%rsp)
jmp 0x1cb43
movq 0xb0(%rsp), %rax
movq 0xd0(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0xb0(%rsp), %rax
movq 0xd0(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x94c0
movsd 0x10(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x18(%rsp), %xmm0
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x58(%rsp)
movq 0xf8(%rsp), %rax
cmpl $0x1, 0x30(%rax)
jle 0x1cc92
callq 0x91a0
movq %rax, %rcx
movq 0xd0(%rsp), %rsi
movq 0xb0(%rsp), %rax
movq 0xd0(%rsp), %rdx
movss (%rax,%rdx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0x90(%rsp), %rax
movq 0xd0(%rsp), %rdx
movss (%rax,%rdx,4), %xmm1
cvtss2sd %xmm1, %xmm1
movsd 0x58(%rsp), %xmm2
leaq 0x3ca5c(%rip), %rdi     # 0x596ea
movb $0x3, %al
callq *%rcx
movsd 0x58(%rsp), %xmm0
ucomisd 0x68(%rsp), %xmm0
jbe 0x1ccb9
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x68(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x1ccbb
movq 0xd0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xd0(%rsp)
jmp 0x1ca86
movq 0x60(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq 0xd0(%rsp), %rax
cmpq 0xd8(%rsp), %rax
je 0x1ccfe
cmpq $0x0, 0xd0(%rsp)
jge 0x1cd2c
movq 0xf8(%rsp), %rax
cmpl $0x0, 0x30(%rax)
je 0x1cd27
callq 0x91a0
movq %rax, %rcx
movq 0xd8(%rsp), %rsi
leaq 0x3ca01(%rip), %rdi     # 0x59724
movb $0x0, %al
callq *%rcx
jmp 0x1d084
movq 0xf8(%rsp), %rax
cmpl $0x0, 0x30(%rax)
je 0x1cd95
callq 0x91a0
movq %rax, %rcx
movq 0xd8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
movq 0xb0(%rsp), %rax
movq 0xd0(%rsp), %rdi
movss (%rax,%rdi,4), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0x90(%rsp), %rax
movq 0xd0(%rsp), %rdi
movss (%rax,%rdi,4), %xmm1
cvtss2sd %xmm1, %xmm1
movsd 0x68(%rsp), %xmm2
leaq 0x3c9d5(%rip), %rdi     # 0x59766
movb $0x3, %al
callq *%rcx
movsd 0x3c5e3(%rip), %xmm0    # 0x59380
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x68(%rsp)
movq $-0x1, 0x60(%rsp)
movq $0x0, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
movq 0xe8(%rsp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x1ce59
movq 0xa0(%rsp), %rax
movq 0xd0(%rsp), %rcx
imulq 0xe8(%rsp), %rcx
addq 0xc0(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x48(%rsp), %xmm0
ucomisd 0x68(%rsp), %xmm0
jbe 0x1ce3e
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x68(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x1ce40
movq 0xc0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xc0(%rsp)
jmp 0x1cdcf
movq 0xa8(%rsp), %rax
movq 0x60(%rsp), %rcx
movq 0xd0(%rsp), %rdx
movq 0xf8(%rsp), %rsi
imulq 0x8(%rsi), %rdx
addq %rdx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, 0x44(%rsp)
movq $0x0, 0xc8(%rsp)
movq 0xc8(%rsp), %rax
movq 0xf8(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x1d03f
movq 0x98(%rsp), %rax
movq 0xd0(%rsp), %rcx
movq 0xf8(%rsp), %rdx
movq 0x10(%rdx), %rdx
imulq 0xc8(%rsp), %rdx
addq %rdx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, 0x40(%rsp)
movq 0x98(%rsp), %rax
movq 0xd8(%rsp), %rcx
movq 0xf8(%rsp), %rdx
movq 0x10(%rdx), %rdx
imulq 0xc8(%rsp), %rdx
addq %rdx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, 0x3c(%rsp)
movq 0xf0(%rsp), %rax
movq 0x60(%rsp), %rcx
movq 0xc8(%rsp), %rdx
movq 0xf8(%rsp), %rsi
imulq 0x8(%rsi), %rdx
addq %rdx, %rcx
movss (%rax,%rcx,4), %xmm1
movss 0x44(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x1cfbb
movss 0x40(%rsp), %xmm0
addss 0x3c(%rsp), %xmm0
movq 0x98(%rsp), %rax
movq 0xd8(%rsp), %rcx
movq 0xf8(%rsp), %rdx
movq 0x10(%rdx), %rdx
imulq 0xc8(%rsp), %rdx
addq %rdx, %rcx
movss %xmm0, (%rax,%rcx,4)
movq 0x98(%rsp), %rax
movq 0xd0(%rsp), %rcx
movq 0xf8(%rsp), %rdx
movq 0x10(%rdx), %rdx
imulq 0xc8(%rsp), %rdx
addq %rdx, %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x1d024
movq 0x98(%rsp), %rax
movq 0xd8(%rsp), %rcx
movq 0xf8(%rsp), %rdx
movq 0x10(%rdx), %rdx
imulq 0xc8(%rsp), %rdx
addq %rdx, %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movss 0x40(%rsp), %xmm0
addss 0x3c(%rsp), %xmm0
movq 0x98(%rsp), %rax
movq 0xd0(%rsp), %rcx
movq 0xf8(%rsp), %rdx
movq 0x10(%rdx), %rdx
imulq 0xc8(%rsp), %rdx
addq %rdx, %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0x1d026
movq 0xc8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xc8(%rsp)
jmp 0x1ce95
movq 0xf8(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq 0xb0(%rsp), %rdx
movq 0xa0(%rsp), %rcx
movq 0xa8(%rsp), %r8
movq 0xf0(%rsp), %r9
movq 0xf8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
callq 0x1acd0
movq 0xd8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xd8(%rsp)
jmp 0x1c8fe
movq 0xb8(%rsp), %rax
movq %rax, 0x100(%rsp)
movq 0x100(%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
retq
nopl (%rax)