// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/quickshift.c
// Function: vl_quickshift_process
VL_EXPORT
void vl_quickshift_process(VlQS * q)
{
  vl_qs_type const *I = q->image;
  int        *parents = q->parents;
  vl_qs_type *E = q->density;
  vl_qs_type *dists = q->dists;
  vl_qs_type *M = 0, *n = 0 ;
  vl_qs_type sigma = q->sigma ;
  vl_qs_type tau = q->tau;
  vl_qs_type tau2 = tau*tau;

  int K = q->channels, d;
  int N1 = q->height, N2 = q->width;
  int i1,i2, j1,j2, R, tR;

  d = 2 + K ; /* Total dimensions include spatial component (x,y) */

  if (q->medoid) { /* n and M are only used in mediod shift */
    M = (vl_qs_type *) vl_calloc(N1*N2*d, sizeof(vl_qs_type)) ;
    n = (vl_qs_type *) vl_calloc(N1*N2,   sizeof(vl_qs_type)) ;
  }

  R = (int) ceil (3 * sigma) ;
  tR = (int) ceil (tau) ;

  /* -----------------------------------------------------------------
   *                                                                 n
   * -------------------------------------------------------------- */

  /* If we are doing medoid shift, initialize n to the inner product of the
   * image with itself
   */
  if (n) {
    for (i2 = 0 ; i2 < N2 ; ++ i2) {
      for (i1 = 0 ; i1 < N1 ; ++ i1) {
        n [i1 + N1 * i2] = vl_quickshift_inner(I,N1,N2,K,
                                               i1,i2,
                                               i1,i2) ;
      }
    }
  }

  /* -----------------------------------------------------------------
   *                                                 E = - [oN'*F]', M
   * -------------------------------------------------------------- */

  /*
     D_ij = d(x_i,x_j)
     E_ij = exp(- .5 * D_ij / sigma^2) ;
     F_ij = - E_ij
     E_i  = sum_j E_ij
     M_di = sum_j X_j F_ij

     E is the parzen window estimate of the density
     0 = dissimilar to everything, windowsize = identical
  */

  for (i2 = 0 ; i2 < N2 ; ++ i2) {
    for (i1 = 0 ; i1 < N1 ; ++ i1) {

      int j1min = VL_MAX(i1 - R, 0   ) ;
      int j1max = VL_MIN(i1 + R, N1-1) ;
      int j2min = VL_MAX(i2 - R, 0   ) ;
      int j2max = VL_MIN(i2 + R, N2-1) ;

      /* For each pixel in the window compute the distance between it and the
       * source pixel */
      for (j2 = j2min ; j2 <= j2max ; ++ j2) {
        for (j1 = j1min ; j1 <= j1max ; ++ j1) {
          vl_qs_type Dij = vl_quickshift_distance(I,N1,N2,K, i1,i2, j1,j2) ;
          /* Make distance a similarity */
          vl_qs_type Fij = - exp(- Dij / (2*sigma*sigma)) ;

          /* E is E_i above */
          E [i1 + N1 * i2] -= Fij ;

          if (M) {
            /* Accumulate votes for the median */
            int k ;
            M [i1 + N1*i2 + (N1*N2) * 0] += j1 * Fij ;
            M [i1 + N1*i2 + (N1*N2) * 1] += j2 * Fij ;
            for (k = 0 ; k < K ; ++k) {
              M [i1 + N1*i2 + (N1*N2) * (k+2)] +=
                I [j1 + N1*j2 + (N1*N2) * k] * Fij ;
            }
          }

        } /* j1 */
      } /* j2 */

    }  /* i1 */
  } /* i2 */

  /* -----------------------------------------------------------------
   *                                               Find best neighbors
   * -------------------------------------------------------------- */

  if (q->medoid) {

    /*
       Qij = - nj Ei - 2 sum_k Gjk Mik
       n is I.^2
    */

    /* medoid shift */
    for (i2 = 0 ; i2 < N2 ; ++i2) {
      for (i1 = 0 ; i1 < N1 ; ++i1) {

        vl_qs_type sc_best = 0  ;
        /* j1/j2 best are the best indicies for each i */
        vl_qs_type j1_best = i1 ;
        vl_qs_type j2_best = i2 ;

        int j1min = VL_MAX(i1 - R, 0   ) ;
        int j1max = VL_MIN(i1 + R, N1-1) ;
        int j2min = VL_MAX(i2 - R, 0   ) ;
        int j2max = VL_MIN(i2 + R, N2-1) ;

        for (j2 = j2min ; j2 <= j2max ; ++ j2) {
          for (j1 = j1min ; j1 <= j1max ; ++ j1) {

            vl_qs_type Qij = - n [j1 + j2 * N1] * E [i1 + i2 * N1] ;
            int k ;

            Qij -= 2 * j1 * M [i1 + i2 * N1 + (N1*N2) * 0] ;
            Qij -= 2 * j2 * M [i1 + i2 * N1 + (N1*N2) * 1] ;
            for (k = 0 ; k < K ; ++k) {
              Qij -= 2 *
                I [j1 + j2 * N1 + (N1*N2) * k] *
                M [i1 + i2 * N1 + (N1*N2) * (k + 2)] ;
            }

            if (Qij > sc_best) {
              sc_best = Qij ;
              j1_best = j1 ;
              j2_best = j2 ;
            }
          }
        }

        /* parents_i is the linear index of j which is the best pair
         * dists_i is the score of the best match
         */
        parents [i1 + N1 * i2] = j1_best + N1 * j2_best ;
        dists[i1 + N1 * i2] = sc_best ;
      }
    }

  } else {

    /* Quickshift assigns each i to the closest j which has an increase in the
     * density (E). If there is no j s.t. Ej > Ei, then dists_i == inf (a root
     * node in one of the trees of merges).
     */
    for (i2 = 0 ; i2 < N2 ; ++i2) {
      for (i1 = 0 ; i1 < N1 ; ++i1) {

        vl_qs_type E0 = E [i1 + N1 * i2] ;
        vl_qs_type d_best = VL_QS_INF ;
        vl_qs_type j1_best = i1   ;
        vl_qs_type j2_best = i2   ;

        int j1min = VL_MAX(i1 - tR, 0   ) ;
        int j1max = VL_MIN(i1 + tR, N1-1) ;
        int j2min = VL_MAX(i2 - tR, 0   ) ;
        int j2max = VL_MIN(i2 + tR, N2-1) ;

        for (j2 = j2min ; j2 <= j2max ; ++ j2) {
          for (j1 = j1min ; j1 <= j1max ; ++ j1) {
            if (E [j1 + N1 * j2] > E0) {
              vl_qs_type Dij = vl_quickshift_distance(I,N1,N2,K, i1,i2, j1,j2) ;
              if (Dij <= tau2 && Dij < d_best) {
                d_best = Dij ;
                j1_best = j1 ;
                j2_best = j2 ;
              }
            }
          }
        }

        /* parents is the index of the best pair */
        /* dists_i is the minimal distance, inf implies no Ej > Ei within
         * distance tau from the point */
        parents [i1 + N1 * i2] = j1_best + N1 * j2_best ;
        dists[i1 + N1 * i2] = sqrt(d_best) ;
      }
    }
  }

  if (M) vl_free(M) ;
  if (n) vl_free(n) ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq (%rdi), %rax
movq %rax, 0x78(%rsp)
movq 0x28(%rdi), %rax
movq %rax, 0x100(%rsp)
movq 0x38(%rdi), %rax
movq %rax, 0xa8(%rsp)
movq 0x30(%rdi), %rax
movq %rax, 0xf8(%rsp)
movsd 0x18(%rdi), %xmm0
movsd %xmm0, 0xb0(%rsp)
movsd 0x20(%rdi), %xmm0
movaps %xmm0, 0x110(%rsp)
movl 0x10(%rdi), %eax
movslq 0x8(%rdi), %r12
movl 0xc(%rdi), %ebp
xorl %r14d, %r14d
movq %rdi, 0x120(%rsp)
cmpl $0x0, 0x14(%rdi)
movq %r12, 0x8(%rsp)
movq %rax, 0x48(%rsp)
movq %rbp, 0x50(%rsp)
je 0x24256
addl $0x2, %eax
movq 0x50(%rsp), %rcx
movl %ecx, %ebp
imull 0x8(%rsp), %ebp
imull %ebp, %eax
movslq %eax, %rdi
pushq $0x8
popq %rbx
movq %rbx, %rsi
callq 0x9960
movq %rax, 0x20(%rsp)
movslq %ebp, %rdi
movq 0x50(%rsp), %rbp
movq 0x8(%rsp), %r12
movq %rbx, %rsi
callq 0x9960
movq %rax, %r13
jmp 0x24262
xorl %r13d, %r13d
movq $0x0, 0x20(%rsp)
movsd 0x8f7e(%rip), %xmm0     # 0x2d1e8
mulsd 0xb0(%rsp), %xmm0
callq 0x9a40
cvttsd2si %xmm0, %eax
movq %rax, 0x18(%rsp)
movapd 0x110(%rsp), %xmm0
callq 0x9a40
movl %ebp, %eax
imull %r12d, %eax
testl %r12d, %r12d
cmovgl %r12d, %r14d
movslq %eax, %rsi
movl %r14d, %eax
movq %rax, 0x90(%rsp)
testq %r13, %r13
movq %rsi, 0x60(%rsp)
movq %r13, 0x108(%rsp)
je 0x24366
xorl %ecx, %ecx
movq 0x48(%rsp), %rdx
testl %edx, %edx
movl $0x0, %eax
cmovgl %edx, %eax
testl %ebp, %ebp
movl $0x0, %edx
cmovgl %ebp, %edx
movq %rdx, 0x58(%rsp)
leaq (,%r12,8), %rdx
leaq (,%rsi,8), %rsi
movq 0x78(%rsp), %rdi
cmpq 0x58(%rsp), %rcx
je 0x24381
movq %rcx, %r8
imulq %rcx, %r8
movq %rcx, %r9
imulq %r12, %r9
movq %rdi, %r10
xorl %r11d, %r11d
cmpq 0x90(%rsp), %r11
je 0x2435e
movl %r11d, %ebx
imull %r11d, %ebx
addl %r8d, %ebx
cvtsi2sd %ebx, %xmm1
leaq (%r11,%r9), %rbx
movq %rax, %r14
movq %r10, %r15
subq $0x1, %r14
jb 0x2434e
movsd (%r15), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm1
addq %rsi, %r15
jmp 0x24336
movsd %xmm1, (%r13,%rbx,8)
incq %r11
addq $0x8, %r10
jmp 0x24314
incq %rcx
addq %rdx, %rdi
jmp 0x242f5
xorl %ecx, %ecx
movq 0x48(%rsp), %rdx
testl %edx, %edx
movl $0x0, %eax
cmovgl %edx, %eax
testl %ebp, %ebp
cmovgl %ebp, %ecx
movq %rcx, 0x58(%rsp)
movapd 0x110(%rsp), %xmm1
mulsd %xmm1, %xmm1
movapd %xmm1, 0x110(%rsp)
cvttsd2si %xmm0, %ecx
movq %rcx, 0xc0(%rsp)
leal -0x1(%r12), %ecx
movl %ecx, 0x34(%rsp)
leal -0x1(%rbp), %ecx
movl %ecx, 0x30(%rsp)
movsd 0xb0(%rsp), %xmm1
movapd %xmm1, %xmm0
addsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x18(%rsp), %rcx
negl %ecx
movl %eax, %eax
movq %rax, 0xb0(%rsp)
leaq (,%r12,8), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rax
leaq (,%rax,8), %rbp
shlq $0x4, %rax
movq 0x20(%rsp), %rdi
movq %rax, 0x80(%rsp)
leaq (%rdi,%rax), %r13
xorl %r9d, %r9d
movl %ecx, 0x2c(%rsp)
movl %ecx, %edx
testl %edx, %edx
movl $0x0, %esi
cmovgl %edx, %esi
cmpq 0x58(%rsp), %r9
je 0x2465e
movq 0x10(%rsp), %r8
imulq %rsi, %r8
movq 0x18(%rsp), %rax
addl %r9d, %eax
movl 0x30(%rsp), %ecx
cmpl %ecx, %eax
cmovgel %ecx, %eax
movq %r9, %rcx
imulq 0x8(%rsp), %rcx
movq %rcx, 0x130(%rsp)
cltq
movq %rax, 0x98(%rsp)
addq 0x78(%rsp), %r8
movq %r8, 0xc8(%rsp)
movq %r13, 0x128(%rsp)
xorl %r8d, %r8d
movl 0x2c(%rsp), %eax
movl %edx, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq %r9, 0x40(%rsp)
testl %eax, %eax
movl $0x0, %ebx
cmovgl %eax, %ebx
cmpq 0x90(%rsp), %r8
je 0x24647
movl %eax, 0x88(%rsp)
movq 0xc8(%rsp), %rax
leaq (%rax,%rbx,8), %r12
movq 0x18(%rsp), %rax
addl %r8d, %eax
movl 0x34(%rsp), %ecx
cmpl %ecx, %eax
cmovgel %ecx, %eax
movq 0x130(%rsp), %rcx
leaq (%r8,%rcx), %r14
movq 0x60(%rsp), %rcx
addq %r14, %rcx
movq %rcx, 0xe8(%rsp)
cltq
movq %rax, 0x70(%rsp)
movq %rsi, %rax
movq %r8, 0x68(%rsp)
movq %rbx, 0xe0(%rsp)
cmpq 0x98(%rsp), %rax
jg 0x24623
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0xf0(%rsp)
movq %r12, 0xa0(%rsp)
cmpq 0x70(%rsp), %rbx
jg 0x24606
movq 0x78(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq %rax, %r15
pushq %rax
pushq %rbx
callq 0x24b6b
addq $0x10, %rsp
xorpd 0x8b48(%rip), %xmm0     # 0x2d0a0
divsd 0x38(%rsp), %xmm0
callq 0x9ae0
movq 0x20(%rsp), %rdi
movq 0xa8(%rsp), %rax
movsd (%rax,%r14,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rax,%r14,8)
testq %rdi, %rdi
je 0x245ed
xorpd 0x8b13(%rip), %xmm0     # 0x2d0a0
cvtsi2sd %ebx, %xmm1
mulsd %xmm0, %xmm1
addsd (%rdi,%r14,8), %xmm1
movsd %xmm1, (%rdi,%r14,8)
movapd %xmm0, %xmm1
mulsd 0xf0(%rsp), %xmm1
movq 0xe8(%rsp), %rax
addsd (%rdi,%rax,8), %xmm1
movsd %xmm1, (%rdi,%rax,8)
xorl %eax, %eax
movq 0xb0(%rsp), %rcx
subq $0x1, %rcx
jb 0x245ed
movsd (%r12,%rax), %xmm1
mulsd %xmm0, %xmm1
addsd (%r13,%rax), %xmm1
movsd %xmm1, (%r13,%rax)
addq %rbp, %rax
jmp 0x245ca
incq %rbx
addq $0x8, %r12
movq 0x40(%rsp), %r9
movq 0x68(%rsp), %r8
movq %r15, %rax
jmp 0x24523
incq %rax
movq 0xa0(%rsp), %r12
addq 0x10(%rsp), %r12
movq 0xe0(%rsp), %rbx
jmp 0x24500
incq %r8
movl 0x88(%rsp), %eax
incl %eax
addq $0x8, %r13
movl 0xd8(%rsp), %edx
movq 0xd0(%rsp), %rsi
jmp 0x24491
incq %r9
incl %edx
movq 0x128(%rsp), %r13
addq 0x10(%rsp), %r13
jmp 0x24417
movq 0x120(%rsp), %rax
cmpl $0x0, 0x14(%rax)
cvtsi2sdl 0x8(%rsp), %xmm0
movsd %xmm0, 0xa0(%rsp)
je 0x248c3
addq %rdi, 0x80(%rsp)
xorl %edx, %edx
movapd 0x8a0f(%rip), %xmm0     # 0x2d0a0
movsd 0x9bff(%rip), %xmm1     # 0x2e298
movl 0x2c(%rsp), %ecx
testl %ecx, %ecx
movl $0x0, %eax
cmovgl %ecx, %eax
cmpq 0x58(%rsp), %rdx
je 0x24b33
movl %ecx, 0x38(%rsp)
movq 0x10(%rsp), %rsi
movq %rax, 0x48(%rsp)
imulq %rax, %rsi
cvtsi2sd %edx, %xmm2
movq 0x18(%rsp), %rax
addl %edx, %eax
movl 0x30(%rsp), %ecx
cmpl %ecx, %eax
cmovgel %ecx, %eax
movq %rdx, 0x40(%rsp)
imulq 0x8(%rsp), %rdx
movq %rdx, 0x68(%rsp)
movslq %eax, %r8
addq 0x78(%rsp), %rsi
movq %rsi, 0x70(%rsp)
movq 0x80(%rsp), %r9
xorl %r10d, %r10d
movl 0x2c(%rsp), %eax
testl %eax, %eax
movl $0x0, %esi
cmovgl %eax, %esi
cmpq 0x90(%rsp), %r10
je 0x24896
movl %eax, 0x50(%rsp)
movq 0x70(%rsp), %rax
leaq (%rax,%rsi,8), %r15
cvtsi2sd %r10d, %xmm3
movq 0x18(%rsp), %rax
addl %r10d, %eax
movl 0x34(%rsp), %ecx
cmpl %ecx, %eax
cmovgel %ecx, %eax
movq 0x68(%rsp), %rcx
leaq (%r10,%rcx), %r13
movq 0x60(%rsp), %rcx
addq %r13, %rcx
cltq
xorpd %xmm4, %xmm4
movq 0x48(%rsp), %rdx
movapd %xmm2, %xmm5
cmpq %r8, %rdx
jg 0x24859
movq %rdx, %r14
imulq 0x8(%rsp), %r14
leal (%rdx,%rdx), %edi
cvtsi2sd %edi, %xmm6
xorpd %xmm0, %xmm6
cvtsi2sd %edx, %xmm7
movq %r15, %r12
movq %rsi, %rbx
cmpq %rax, %rbx
jg 0x2484c
leaq (%rbx,%r14), %rdi
movq 0xa8(%rsp), %r11
movsd (%r11,%r13,8), %xmm8
movq 0x108(%rsp), %r11
mulsd (%r11,%rdi,8), %xmm8
leal (%rbx,%rbx), %edi
cvtsi2sd %edi, %xmm9
xorpd %xmm0, %xmm9
movq 0x20(%rsp), %rdi
mulsd (%rdi,%r13,8), %xmm9
subsd %xmm8, %xmm9
movsd (%rdi,%rcx,8), %xmm8
mulsd %xmm6, %xmm8
addsd %xmm9, %xmm8
xorl %edi, %edi
movq 0xb0(%rsp), %r11
subq $0x1, %r11
jb 0x24807
movsd (%r12,%rdi), %xmm9
mulsd %xmm1, %xmm9
mulsd (%r9,%rdi), %xmm9
addsd %xmm9, %xmm8
addq %rbp, %rdi
jmp 0x247e6
ucomisd %xmm4, %xmm8
jbe 0x24812
cvtsi2sd %ebx, %xmm3
movapd %xmm4, %xmm9
cmpltsd %xmm8, %xmm9
movapd %xmm9, %xmm10
andpd %xmm7, %xmm10
andnpd %xmm5, %xmm9
orpd %xmm10, %xmm9
maxsd %xmm4, %xmm8
incq %rbx
addq $0x8, %r12
movapd %xmm9, %xmm5
movapd %xmm8, %xmm4
jmp 0x24786
incq %rdx
addq 0x10(%rsp), %r15
jmp 0x2475f
mulsd 0xa0(%rsp), %xmm5
addsd %xmm3, %xmm5
cvttsd2si %xmm5, %eax
movq 0x100(%rsp), %rcx
movl %eax, (%rcx,%r13,4)
movq 0xf8(%rsp), %rax
movsd %xmm4, (%rax,%r13,8)
incq %r10
movl 0x50(%rsp), %eax
incl %eax
addq $0x8, %r9
jmp 0x24704
movq 0x40(%rsp), %rdx
incq %rdx
movl 0x38(%rsp), %ecx
incl %ecx
movq 0x80(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x20(%rsp), %rdi
jmp 0x2469d
movq 0xc0(%rsp), %rax
negl %eax
xorl %ecx, %ecx
movl %eax, 0xc8(%rsp)
testl %eax, %eax
movl $0x0, %r13d
cmovgl %eax, %r13d
cmpq 0x58(%rsp), %rcx
je 0x24b33
movl %eax, 0xd0(%rsp)
movq 0x10(%rsp), %rax
imulq %r13, %rax
addq 0xa8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rcx, %rax
imulq 0x8(%rsp), %rax
movq %rax, 0x60(%rsp)
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0xd8(%rsp)
movq 0xc0(%rsp), %rax
movq %rcx, %rbp
addl %ecx, %eax
movl 0x30(%rsp), %ecx
cmpl %ecx, %eax
cmovgel %ecx, %eax
cltq
movq %rax, 0xf0(%rsp)
xorl %r15d, %r15d
movl 0xc8(%rsp), %ecx
movq %r13, 0x88(%rsp)
testl %ecx, %ecx
movl $0x0, %eax
cmovgl %ecx, %eax
movq %rax, 0xe8(%rsp)
cmpq 0x90(%rsp), %r15
je 0x24b1f
movl %ecx, 0x98(%rsp)
movq 0x60(%rsp), %rax
leaq (%r15,%rax), %rcx
movq 0xa8(%rsp), %rax
movq %rcx, 0xe0(%rsp)
movsd (%rax,%rcx,8), %xmm1
cvtsi2sd %r15d, %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0xc0(%rsp), %rax
addl %r15d, %eax
movl 0x34(%rsp), %ecx
cmpl %ecx, %eax
cmovgel %ecx, %eax
movslq %eax, %r14
movq 0x18(%rsp), %r12
movsd 0x91f5(%rip), %xmm3     # 0x2dbc0
movsd 0xd8(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd %xmm1, 0x70(%rsp)
cmpq 0xf0(%rsp), %r13
jg 0x24aaf
cvtsi2sd %r13d, %xmm0
movsd %xmm0, 0x68(%rsp)
movq 0xe8(%rsp), %rbx
cmpq %r14, %rbx
jg 0x24aa2
movsd (%r12,%rbx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x24a9a
movq 0x78(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movl %r15d, %r8d
movl %ebp, %r9d
pushq %r13
pushq %rbx
movapd %xmm3, 0xc0(%rsp)
callq 0x24b6b
movapd 0xc0(%rsp), %xmm3
addq $0x10, %rsp
movapd %xmm0, %xmm1
cmpltpd %xmm3, %xmm1
movapd %xmm0, %xmm2
cmplepd 0x110(%rsp), %xmm2
andpd %xmm1, %xmm2
movd %xmm2, %eax
testb $0x1, %al
je 0x24a8f
cvtsi2sd %ebx, %xmm1
movsd %xmm1, 0x40(%rsp)
movsd 0x68(%rsp), %xmm1
movsd %xmm1, 0x38(%rsp)
movapd %xmm0, %xmm3
movq 0x20(%rsp), %rdi
movsd 0x70(%rsp), %xmm1
incq %rbx
jmp 0x24a01
incq %r13
addq 0x10(%rsp), %r12
jmp 0x249e0
movsd 0x38(%rsp), %xmm0
mulsd 0xa0(%rsp), %xmm0
addsd 0x40(%rsp), %xmm0
cvttsd2si %xmm0, %eax
movq 0x100(%rsp), %rcx
movq 0xe0(%rsp), %rbx
movl %eax, (%rcx,%rbx,4)
ucomisd 0x851d(%rip), %xmm3     # 0x2d000
jb 0x24aeb
sqrtsd %xmm3, %xmm0
jmp 0x24af9
movapd %xmm3, %xmm0
callq 0x9a00
movq 0x20(%rsp), %rdi
movq 0x88(%rsp), %r13
movl 0x98(%rsp), %ecx
movq 0xf8(%rsp), %rax
movsd %xmm0, (%rax,%rbx,8)
incq %r15
incl %ecx
jmp 0x24957
movq %rbp, %rcx
incq %rcx
movl 0xd0(%rsp), %eax
incl %eax
jmp 0x248d6
testq %rdi, %rdi
je 0x24b3d
callq 0x95b0
movq 0x108(%rsp), %rdi
addq $0x138, %rsp            # imm = 0x138
testq %rdi, %rdi
je 0x24b60
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x95b0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq