unsigned rFtH(double *u, unsigned char *hinl, double th, double *H,
              unsigned len, double *F, int *bufferP, double *bufferZ) {
  unsigned char *nhinl, *v, *inl;
  double *Ds, *uN, *us, *uH, *uV;
  unsigned i, nhinlCount = 0, hinlCount = 0, ninl, maxni;
  unsigned *ptr, max_i, m_i, max_sam, s_size, pos, idx, auxI, no_i;
  double ec[3], ecNorm, c1[3], c2[3], aFt[3 * 3], aFtH[3 * 3], aF[3 * 3],
      Ht[3 * 3];
  unsigned MAX_SAM = 10000, no_sam;
  double conf = .999;
  unsigned char sam_sizH = 6;
  unsigned char sam_sizO = 4;
  inl = (unsigned char *)malloc(len * sizeof(unsigned char));
  Ds = (double *)malloc(len * sizeof(double));
  dHDs(H, u, len, Ds, bufferP, bufferZ);
  nhinl = (unsigned char *)malloc(len * sizeof(unsigned char));
  for (i = 0; i < len; ++i) {
    if (Ds[i] > 100 * th) {
      nhinl[i] = 1;
      ++nhinlCount;
    } else {
      nhinl[i] = 0;
    }
    if (hinl[i]) {
      ++hinlCount;
    }
  }
  free(Ds);
  Ds = (double *)malloc(nhinlCount * sizeof(double));
  v = (unsigned char *)malloc(nhinlCount * sizeof(unsigned char));
  uN = (double *)malloc(6 * nhinlCount * sizeof(double));
  us = (double *)malloc(6 * nhinlCount * sizeof(double));
  uV = (double *)malloc(6 * nhinlCount * sizeof(double));
  uH = (double *)malloc(6 * hinlCount * sizeof(double));
  nhinlCount = 0, hinlCount = 0;
  for (i = 0; i < len; ++i) {
    if (nhinl[i]) {
      memcpy(uN + 6 * nhinlCount, u + 6 * i, 6 * sizeof(double));
      memcpy(us + 6 * nhinlCount, u + 6 * i, 3 * sizeof(double));
      us[6 * nhinlCount + 3] =
          H[0] * u[6 * i + 3] + H[3] * u[6 * i + 4] + H[6] * u[6 * i + 5];
      us[6 * nhinlCount + 4] =
          H[1] * u[6 * i + 3] + H[4] * u[6 * i + 4] + H[7] * u[6 * i + 5];
      us[6 * nhinlCount + 5] =
          H[2] * u[6 * i + 3] + H[5] * u[6 * i + 4] + H[8] * u[6 * i + 5];
      ++nhinlCount;
    }
    if (hinl[i]) {
      memcpy(uH + 6 * hinlCount, u + 6 * i, 6 * sizeof(double));
      ++hinlCount;
    }
  }
  ptr = (unsigned *)malloc(nhinlCount * sizeof(unsigned));
  for (i = 0; i < nhinlCount; ++i) {
    ptr[i] = i;
  }
  max_i = 3;
  m_i = sam_sizO;
  max_sam = MAX_SAM;
  s_size = 2;
  if (nhinlCount < 4 || hinlCount < 6) {
    max_i = 0;
  } else {
    for (no_sam = 1; no_sam < 2 * max_sam; ++no_sam) {
      for (pos = 0; pos < s_size; ++pos) {
        idx = pos + 1 + rand() % (nhinlCount - pos - 1);
        auxI = ptr[pos];
        ptr[pos] = ptr[idx];
        ptr[idx] = auxI;
      }
      crossp(c1, us + 6 * ptr[0], us + 6 * ptr[0] + 3);
      crossp(c2, us + 6 * ptr[1], us + 6 * ptr[1] + 3);
      crossp(ec, c1, c2);
      ecNorm = sqrt(ec[0] * ec[0] + ec[1] * ec[1] + ec[2] * ec[2]);
      ec[0] = ec[0] / ecNorm;
      ec[1] = ec[1] / ecNorm;
      ec[2] = ec[2] / ecNorm;
      skew_sym(ec, aFt);
      mattr(Ht, H, 3, 3);
      mmul(aFtH, aFt, Ht, 3);
      mattr(aFt, aFtH, 3, 3);
      FDs(uN, aFt, Ds, nhinlCount);
      no_i = 0;
      for (i = 0; i < nhinlCount; ++i) {
        if (Ds[i] < th * 2) {
          ++no_i;
          v[i] = 1;
        } else {
          v[i] = 0;
        }
      }
      if (no_i > m_i) {
        no_i = 0;
        for (i = 0; i < nhinlCount; ++i) {
          if (v[i]) {
            memcpy(uV + 6 * no_i, uN + 6 * i, 6 * sizeof(double));
            ++no_i;
          }
        }
        m_i = no_i;
        innerFH(uH, hinlCount, uV, no_i, u, len, th, 15, sam_sizH, sam_sizO, aF,
                inl);
        ninl = 0;
        for (i = 0; i < len; ++i) {
          if (inl[i]) {
            ++ninl;
          }
        }
        if (ninl > max_i) {
          max_i = ninl;
          memcpy(F, aF, 3 * 3 * sizeof(double));
          maxni = 0;
          for (i = 0; i < len; ++i) {
            if (inl[i] && nhinl[i]) {
              ++maxni;
            }
          }
          max_sam = dmin(max_sam, nsamples(maxni, nhinlCount, 2, conf));
        }
      }
    }
  }
  free(inl);
  free(Ds);
  free(nhinl);
  free(uN);
  free(us);
  free(uV);
  free(uH);
  free(ptr);
  free(v);
  return max_i;
}


x86 assembly (clang, -O0):
<rFtH>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0x2a8,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    %ecx,-0x2c(%rbp)
mov    %r8,-0x38(%rbp)
mov    %r9,-0x40(%rbp)
movl   $0x0,-0x88(%rbp)
movl   $0x0,-0x8c(%rbp)
movl   $0x2710,-0x264(%rbp)
movsd  0xdce(%rip),%xmm0
movsd  %xmm0,-0x270(%rbp)
ff
movb   $0x6,-0x271(%rbp)
movb   $0x4,-0x272(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,%edi
shl    $0x0,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,%edi
shl    $0x3,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x28(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x2c(%rbp),%edx
mov    -0x60(%rbp),%rcx
mov    -0x40(%rbp),%r8
mov    0x10(%rbp),%r9
mov    $0x0,%al
call   10f0 <dHDs@plt>
mov    -0x2c(%rbp),%eax
mov    %eax,%edi
shl    $0x0,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    1347 <rFtH+0x167>
mov    -0x60(%rbp),%rax
mov    -0x84(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xd44(%rip),%xmm1
mulsd  -0x20(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jbe    12fd <rFtH+0x11d>
mov    -0x48(%rbp),%rax
mov    -0x84(%rbp),%ecx
movb   $0x1,(%rax,%rcx,1)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    130b <rFtH+0x12b>
mov    -0x48(%rbp),%rax
mov    -0x84(%rbp),%ecx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x84(%rbp),%ecx
cmpb   $0x0,(%rax,%rcx,1)
je     132e <rFtH+0x14e>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1333 <rFtH+0x153>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    12a6 <rFtH+0xc6>
mov    -0x60(%rbp),%rdi
call   1040 <free@plt>
mov    -0x88(%rbp),%eax
mov    %eax,%edi
shl    $0x3,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x88(%rbp),%eax
mov    %eax,%edi
shl    $0x0,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x50(%rbp)
imul   $0x6,-0x88(%rbp),%eax
mov    %eax,%eax
mov    %eax,%edi
shl    $0x3,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x68(%rbp)
imul   $0x6,-0x88(%rbp),%eax
mov    %eax,%eax
mov    %eax,%edi
shl    $0x3,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x70(%rbp)
imul   $0x6,-0x88(%rbp),%eax
mov    %eax,%eax
mov    %eax,%edi
shl    $0x3,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x80(%rbp)
imul   $0x6,-0x8c(%rbp),%eax
mov    %eax,%eax
mov    %eax,%edi
shl    $0x3,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x88(%rbp)
movl   $0x0,-0x8c(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    167c <rFtH+0x49c>
mov    -0x48(%rbp),%rax
mov    -0x84(%rbp),%ecx
cmpb   $0x0,(%rax,%rcx,1)
je     160e <rFtH+0x42e>
mov    -0x68(%rbp),%rdi
imul   $0x6,-0x88(%rbp),%eax
mov    %eax,%eax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
imul   $0x6,-0x84(%rbp),%eax
mov    %eax,%eax
shl    $0x3,%rax
add    %rax,%rsi
mov    $0x30,%edx
call   1060 <memcpy@plt>
mov    -0x70(%rbp),%rax
imul   $0x6,-0x88(%rbp),%ecx
mov    %ecx,%ecx
mov    -0x10(%rbp),%rdx
imul   $0x6,-0x84(%rbp),%esi
mov    %esi,%esi
mov    (%rdx,%rsi,8),%rdi
mov    %rdi,(%rax,%rcx,8)
mov    0x8(%rdx,%rsi,8),%rdi
mov    %rdi,0x8(%rax,%rcx,8)
mov    0x10(%rdx,%rsi,8),%rdx
mov    %rdx,0x10(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
imul   $0x6,-0x84(%rbp),%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
imul   $0x6,-0x84(%rbp),%ecx
add    $0x4,%ecx
mov    %ecx,%ecx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x28(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
imul   $0x6,-0x84(%rbp),%ecx
add    $0x5,%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
imul   $0x6,-0x88(%rbp),%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
imul   $0x6,-0x84(%rbp),%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
imul   $0x6,-0x84(%rbp),%ecx
add    $0x4,%ecx
mov    %ecx,%ecx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x28(%rbp),%rax
movsd  0x38(%rax),%xmm0
mov    -0x10(%rbp),%rax
imul   $0x6,-0x84(%rbp),%ecx
add    $0x5,%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
imul   $0x6,-0x88(%rbp),%ecx
add    $0x4,%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
imul   $0x6,-0x84(%rbp),%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
imul   $0x6,-0x84(%rbp),%ecx
add    $0x4,%ecx
mov    %ecx,%ecx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x28(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x10(%rbp),%rax
imul   $0x6,-0x84(%rbp),%ecx
add    $0x5,%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
imul   $0x6,-0x88(%rbp),%ecx
add    $0x5,%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x84(%rbp),%ecx
cmpb   $0x0,(%rax,%rcx,1)
je     1663 <rFtH+0x483>
mov    -0x78(%rbp),%rdi
imul   $0x6,-0x8c(%rbp),%eax
mov    %eax,%eax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
imul   $0x6,-0x84(%rbp),%eax
mov    %eax,%eax
shl    $0x3,%rax
add    %rax,%rsi
mov    $0x30,%edx
call   1060 <memcpy@plt>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1668 <rFtH+0x488>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    13f8 <rFtH+0x218>
mov    -0x88(%rbp),%eax
mov    %eax,%edi
shl    $0x2,%rdi
call   1080 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x88(%rbp),%eax
jae    16da <rFtH+0x4fa>
mov    -0x84(%rbp),%edx
mov    -0xa0(%rbp),%rax
mov    -0x84(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    169e <rFtH+0x4be>
movl   $0x3,-0xa4(%rbp)
movzbl -0x272(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x264(%rbp),%eax
mov    %eax,-0xac(%rbp)
movl   $0x2,-0xb0(%rbp)
cmpl   $0x4,-0x88(%rbp)
jb     1721 <rFtH+0x541>
cmpl   $0x6,-0x8c(%rbp)
jae    1730 <rFtH+0x550>
movl   $0x0,-0xa4(%rbp)
jmp    1cd0 <rFtH+0xaf0>
movl   $0x1,-0x268(%rbp)
mov    -0x268(%rbp),%eax
mov    -0xac(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jae    1ccb <rFtH+0xaeb>
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jae    1804 <rFtH+0x624>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x278(%rbp)
mov    $0x0,%al
call   1100 <rand@plt>
mov    -0x88(%rbp),%ecx
sub    -0xb4(%rbp),%ecx
sub    $0x1,%ecx
xor    %edx,%edx
div    %ecx
mov    -0x278(%rbp),%eax
add    %edx,%eax
mov    %eax,-0xb8(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xbc(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0xb8(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
mov    -0xa0(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0xbc(%rbp),%edx
mov    -0xa0(%rbp),%rax
mov    -0xb8(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    175b <rFtH+0x57b>
lea    -0x100(%rbp),%rdi
mov    -0x70(%rbp),%rsi
mov    -0xa0(%rbp),%rax
imul   $0x6,(%rax),%eax
mov    %eax,%eax
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x70(%rbp),%rdx
mov    -0xa0(%rbp),%rax
imul   $0x6,(%rax),%eax
mov    %eax,%eax
shl    $0x3,%rax
add    %rax,%rdx
add    $0x18,%rdx
mov    $0x0,%al
call   10c0 <crossp@plt>
lea    -0x120(%rbp),%rdi
mov    -0x70(%rbp),%rsi
mov    -0xa0(%rbp),%rax
imul   $0x6,0x4(%rax),%eax
mov    %eax,%eax
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x70(%rbp),%rdx
mov    -0xa0(%rbp),%rax
imul   $0x6,0x4(%rax),%eax
mov    %eax,%eax
shl    $0x3,%rax
add    %rax,%rdx
add    $0x18,%rdx
mov    $0x0,%al
call   10c0 <crossp@plt>
lea    -0xe0(%rbp),%rdi
lea    -0x100(%rbp),%rsi
lea    -0x120(%rbp),%rdx
mov    $0x0,%al
call   10c0 <crossp@plt>
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0xd8(%rbp),%xmm0
ff
mulsd  -0xd8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   10e0 <sqrt@plt>
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
divsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
divsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
divsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
lea    -0xe0(%rbp),%rdi
lea    -0x170(%rbp),%rsi
mov    $0x0,%al
call   10d0 <skew_sym@plt>
lea    -0x260(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    $0x3,%ecx
mov    %ecx,%edx
mov    $0x0,%al
call   10a0 <mattr@plt>
lea    -0x1c0(%rbp),%rdi
lea    -0x170(%rbp),%rsi
lea    -0x260(%rbp),%rdx
mov    $0x3,%ecx
mov    $0x0,%al
call   1070 <mmul@plt>
lea    -0x170(%rbp),%rdi
lea    -0x1c0(%rbp),%rsi
mov    $0x3,%ecx
mov    %ecx,%edx
mov    $0x0,%al
call   10a0 <mattr@plt>
mov    -0x68(%rbp),%rdi
lea    -0x170(%rbp),%rsi
mov    -0x60(%rbp),%rdx
mov    -0x88(%rbp),%ecx
mov    $0x0,%al
call   1090 <FDs@plt>
movl   $0x0,-0xc0(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x88(%rbp),%eax
jae    1a53 <rFtH+0x873>
mov    -0x60(%rbp),%rax
mov    -0x84(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x60d(%rip),%xmm0
mulsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1a2c <rFtH+0x84c>
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x84(%rbp),%ecx
movb   $0x1,(%rax,%rcx,1)
jmp    1a3a <rFtH+0x85a>
mov    -0x50(%rbp),%rax
mov    -0x84(%rbp),%ecx
movb   $0x0,(%rax,%rcx,1)
jmp    1a3f <rFtH+0x85f>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    19d2 <rFtH+0x7f2>
mov    -0xc0(%rbp),%eax
cmp    -0xa8(%rbp),%eax
jbe    1cb2 <rFtH+0xad2>
movl   $0x0,-0xc0(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x88(%rbp),%eax
jae    1af9 <rFtH+0x919>
mov    -0x50(%rbp),%rax
mov    -0x84(%rbp),%ecx
cmpb   $0x0,(%rax,%rcx,1)
je     1ae0 <rFtH+0x900>
mov    -0x80(%rbp),%rdi
imul   $0x6,-0xc0(%rbp),%eax
mov    %eax,%eax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x68(%rbp),%rsi
imul   $0x6,-0x84(%rbp),%eax
mov    %eax,%eax
shl    $0x3,%rax
add    %rax,%rsi
mov    $0x30,%edx
call   1060 <memcpy@plt>
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    1ae5 <rFtH+0x905>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1a79 <rFtH+0x899>
mov    -0xc0(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x78(%rbp),%rdi
mov    -0x8c(%rbp),%esi
mov    -0x80(%rbp),%rdx
mov    -0xc0(%rbp),%ecx
mov    -0x10(%rbp),%r8
mov    -0x2c(%rbp),%r9d
movsd  -0x20(%rbp),%xmm0
movzbl -0x271(%rbp),%ebx
movzbl -0x272(%rbp),%r11d
ff
lea    -0x210(%rbp),%r10
mov    -0x58(%rbp),%rax
movl   $0xf,(%rsp)
mov    %ebx,0x8(%rsp)
mov    %r11d,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x1,%al
call   1030 <innerFH@plt>
movl   $0x0,-0x90(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    1bc0 <rFtH+0x9e0>
mov    -0x58(%rbp),%rax
mov    -0x84(%rbp),%ecx
cmpb   $0x0,(%rax,%rcx,1)
je     1ba7 <rFtH+0x9c7>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1bac <rFtH+0x9cc>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1b75 <rFtH+0x995>
mov    -0x90(%rbp),%eax
cmp    -0xa4(%rbp),%eax
jbe    1cad <rFtH+0xacd>
mov    -0x90(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x38(%rbp),%rdi
lea    -0x210(%rbp),%rsi
mov    $0x48,%edx
call   1060 <memcpy@plt>
movl   $0x0,-0x94(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    1c6c <rFtH+0xa8c>
mov    -0x58(%rbp),%rax
mov    -0x84(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1c53 <rFtH+0xa73>
mov    -0x48(%rbp),%rax
mov    -0x84(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1c53 <rFtH+0xa73>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1c58 <rFtH+0xa78>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1c07 <rFtH+0xa27>
mov    -0xac(%rbp),%eax
mov    %eax,-0x27c(%rbp)
mov    -0x94(%rbp),%edi
mov    -0x88(%rbp),%esi
movsd  -0x270(%rbp),%xmm0
ff
mov    $0x2,%edx
mov    $0x1,%al
call   1050 <nsamples@plt>
mov    -0x27c(%rbp),%edi
mov    %eax,%esi
mov    $0x0,%al
call   10b0 <dmin@plt>
mov    %eax,-0xac(%rbp)
jmp    1cb2 <rFtH+0xad2>
jmp    1cb7 <rFtH+0xad7>
mov    -0x268(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x268(%rbp)
jmp    173a <rFtH+0x55a>
jmp    1cd0 <rFtH+0xaf0>
mov    -0x58(%rbp),%rdi
call   1040 <free@plt>
mov    -0x60(%rbp),%rdi
call   1040 <free@plt>
mov    -0x48(%rbp),%rdi
call   1040 <free@plt>
mov    -0x68(%rbp),%rdi
call   1040 <free@plt>
mov    -0x70(%rbp),%rdi
call   1040 <free@plt>
mov    -0x80(%rbp),%rdi
call   1040 <free@plt>
mov    -0x78(%rbp),%rdi
call   1040 <free@plt>
mov    -0xa0(%rbp),%rdi
call   1040 <free@plt>
mov    -0x50(%rbp),%rdi
call   1040 <free@plt>
mov    -0xa4(%rbp),%eax
add    $0x2a8,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<rFtH>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2b8,%rsp
mov    %r9,0x18(%rsp)
mov    %r8,0x100(%rsp)
mov    %ecx,0x2c(%rsp)
mov    %rdx,%rbp
movsd  %xmm0,0x40(%rsp)
mov    %rsi,%r13
mov    %rdi,%r15
mov    %ecx,%r14d
mov    %r14,%rdi
call   1070 <malloc@plt>
mov    %rax,0x10(%rsp)
lea    0x0(,%r14,8),%rdi
call   1070 <malloc@plt>
mov    %rax,%r12
xor    %ebx,%ebx
mov    %rbp,0xb8(%rsp)
mov    %rbp,%rdi
mov    0x2c(%rsp),%ebp
mov    %r15,0x50(%rsp)
mov    %r15,%rsi
mov    %ebp,%edx
mov    %rax,%rcx
mov    0x18(%rsp),%r8
mov    0x2f0(%rsp),%r9
xor    %eax,%eax
call   10e0 <dHDs@plt>
mov    %r14,0x20(%rsp)
mov    %r14,%rdi
call   1070 <malloc@plt>
movsd  0x40(%rsp),%xmm0
test   %ebp,%ebp
mov    %rax,0x30(%rsp)
je     1295 <rFtH+0xc5>
movsd  0x1d88(%rip),%xmm12
mulsd  %xmm0,%xmm12
mov    %ebp,%r8d
cmp    $0x4,%ebp
jae    12a1 <rFtH+0xd1>
xor    %edi,%edi
xor    %ebx,%ebx
xor    %ecx,%ecx
mov    0x20(%rsp),%rbp
jmp    1400 <rFtH+0x230>
xor    %eax,%eax
mov    %rax,0x18(%rsp)
jmp    1439 <rFtH+0x269>
mov    0x20(%rsp),%rbp
mov    %ebp,%edi
and    $0xfffffffc,%edi
movapd %xmm12,%xmm13
unpcklpd %xmm12,%xmm13
pxor   %xmm8,%xmm8
xor    %ecx,%ecx
movdqa 0x1d5b(%rip),%xmm9
pcmpeqd %xmm10,%xmm10
movdqa 0x1d5d(%rip),%xmm11
pxor   %xmm3,%xmm3
pxor   %xmm1,%xmm1
pxor   %xmm5,%xmm5
pxor   %xmm7,%xmm7
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%r12,%rcx,8),%xmm4
movupd 0x10(%r12,%rcx,8),%xmm6
movapd %xmm13,%xmm2
cmpltpd %xmm4,%xmm2
movq   %xmm2,%rdx
movzbl %dl,%edx
movdqa %xmm2,%xmm4
punpckhqdq %xmm2,%xmm4
movq   %xmm4,%rsi
shl    $0x8,%esi
or     %edx,%esi
movd   %esi,%xmm4
pand   %xmm9,%xmm4
movapd %xmm13,%xmm0
cmpltpd %xmm6,%xmm0
movq   %xmm0,%rdx
movzbl %dl,%edx
movdqa %xmm0,%xmm6
punpckhqdq %xmm0,%xmm6
movq   %xmm6,%rsi
shl    $0x8,%esi
or     %edx,%esi
movd   %esi,%xmm6
pand   %xmm9,%xmm6
shufps $0xe8,%xmm2,%xmm2
psubd  %xmm2,%xmm3
shufps $0xe8,%xmm0,%xmm0
psubd  %xmm0,%xmm1
movd   %xmm4,%edx
mov    %dx,(%rax,%rcx,1)
movd   %xmm6,%edx
mov    %dx,0x2(%rax,%rcx,1)
movzwl 0x0(%r13,%rcx,1),%edx
movd   %edx,%xmm0
movzwl 0x2(%r13,%rcx,1),%edx
movd   %edx,%xmm2
pcmpeqb %xmm8,%xmm0
pxor   %xmm10,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0xd4,%xmm0,%xmm0
pand   %xmm11,%xmm0
paddd  %xmm0,%xmm5
pcmpeqb %xmm8,%xmm2
pxor   %xmm10,%xmm2
punpcklbw %xmm2,%xmm2
pshuflw $0xd4,%xmm2,%xmm0
pand   %xmm11,%xmm0
paddd  %xmm0,%xmm7
add    $0x4,%rcx
cmp    %rcx,%rdi
jne    12f0 <rFtH+0x120>
paddd  %xmm5,%xmm7
pshufd $0x55,%xmm7,%xmm0
paddd  %xmm7,%xmm0
movd   %xmm0,%ecx
paddd  %xmm3,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebx
cmp    %rbp,%rdi
je     1428 <rFtH+0x258>
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rdi,8),%xmm0
xor    %edx,%edx
ucomisd %xmm12,%xmm0
seta   %dl
seta   (%rax,%rdi,1)
add    %edx,%ebx
cmpb   $0x1,0x0(%r13,%rdi,1)
sbb    $0xffffffff,%ecx
add    $0x1,%rdi
cmp    %rdi,%rbp
jne    1400 <rFtH+0x230>
add    %ecx,%ecx
lea    (%rcx,%rcx,2),%eax
shl    $0x3,%rax
mov    %rax,0x18(%rsp)
mov    %r8d,%ebp
mov    %r12,%rdi
call   1040 <free@plt>
mov    %ebx,%r15d
lea    0x0(,%r15,8),%rdi
call   1070 <malloc@plt>
mov    %rax,%r14
mov    %r15,%rdi
call   1070 <malloc@plt>
mov    %rax,%r12
add    %ebx,%ebx
lea    (%rbx,%rbx,2),%ebx
shl    $0x3,%rbx
mov    %rbx,%rdi
call   1070 <malloc@plt>
mov    %rax,%r15
mov    %rbx,%rdi
call   1070 <malloc@plt>
mov    %rax,0x70(%rsp)
mov    %rbx,%rdi
call   1070 <malloc@plt>
mov    %rax,0x58(%rsp)
mov    0x18(%rsp),%rdi
call   1070 <malloc@plt>
mov    %rax,0x80(%rsp)
test   %ebp,%ebp
je     1661 <rFtH+0x491>
mov    0x20(%rsp),%rax
add    %rax,%rax
lea    (%rax,%rax,2),%r8
xor    %ecx,%ecx
mov    0x30(%rsp),%rdx
xor    %r11d,%r11d
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    0xb8(%rsp),%r9
mov    0x50(%rsp),%rbp
mov    0x70(%rsp),%r10
jmp    14f5 <rFtH+0x325>
nopl   0x0(%rax,%rax,1)
add    $0x6,%rcx
add    $0x1,%rdx
add    $0x1,%r13
cmp    %rcx,%r8
je     1618 <rFtH+0x448>
cmpb   $0x0,(%rdx)
je     15c5 <rFtH+0x3f5>
lea    (%r11,%r11,1),%esi
lea    (%rsi,%rsi,2),%edi
mov    %ecx,%ebx
movups 0x0(%rbp,%rbx,8),%xmm0
movups 0x10(%rbp,%rbx,8),%xmm1
movups 0x20(%rbp,%rbx,8),%xmm2
movups %xmm2,0x20(%r15,%rdi,8)
movups %xmm1,0x10(%r15,%rdi,8)
movups %xmm0,(%r15,%rdi,8)
mov    0x10(%rbp,%rbx,8),%rax
mov    %rax,0x10(%r10,%rdi,8)
movups 0x0(%rbp,%rbx,8),%xmm0
movups %xmm0,(%r10,%rdi,8)
lea    0x3(%rcx),%eax
movsd  0x0(%rbp,%rax,8),%xmm0
lea    0x4(%rcx),%eax
movsd  0x0(%rbp,%rax,8),%xmm1
movsd  0x18(%r9),%xmm2
mulsd  %xmm1,%xmm2
movsd  (%r9),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
lea    0x5(%rcx),%eax
movsd  0x0(%rbp,%rax,8),%xmm2
movsd  0x30(%r9),%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm3,%xmm4
lea    0x3(%rsi,%rsi,2),%eax
movsd  %xmm4,(%r10,%rax,8)
lea    0x4(%rsi,%rsi,2),%eax
unpcklpd %xmm1,%xmm1
movupd 0x8(%r9),%xmm3
movupd 0x20(%r9),%xmm4
mulpd  %xmm1,%xmm4
movupd 0x38(%r9),%xmm1
unpcklpd %xmm0,%xmm0
mulpd  %xmm3,%xmm0
addpd  %xmm4,%xmm0
unpcklpd %xmm2,%xmm2
mulpd  %xmm1,%xmm2
addpd  %xmm0,%xmm2
movupd %xmm2,(%r10,%rax,8)
add    $0x1,%r11d
cmpb   $0x0,0x0(%r13)
je     14e0 <rFtH+0x310>
mov    0x18(%rsp),%rdi
lea    (%rdi,%rdi,1),%eax
lea    (%rax,%rax,2),%eax
mov    %ecx,%esi
and    $0xfffffffe,%esi
movupd 0x0(%rbp,%rsi,8),%xmm0
movupd 0x10(%rbp,%rsi,8),%xmm1
movupd 0x20(%rbp,%rsi,8),%xmm2
mov    0x80(%rsp),%rsi
movupd %xmm2,0x20(%rsi,%rax,8)
movupd %xmm1,0x10(%rsi,%rax,8)
movupd %xmm0,(%rsi,%rax,8)
add    $0x1,%edi
mov    %rdi,0x18(%rsp)
jmp    14e0 <rFtH+0x310>
mov    %r11d,%eax
mov    %rax,0x38(%rsp)
lea    0x0(,%rax,4),%rdi
mov    %r11,0x48(%rsp)
call   1070 <malloc@plt>
mov    0x48(%rsp),%r8
mov    %rax,%r13
test   %r8d,%r8d
je     1677 <rFtH+0x4a7>
cmp    $0x8,%r8d
jae    1683 <rFtH+0x4b3>
xor    %eax,%eax
mov    0x10(%rsp),%rdi
movsd  0x40(%rsp),%xmm0
mov    0x20(%rsp),%rbp
mov    0x38(%rsp),%rcx
jmp    17f0 <rFtH+0x620>
xor    %ebx,%ebx
xor    %edi,%edi
call   1070 <malloc@plt>
mov    %rax,%r13
mov    0x10(%rsp),%rdi
jmp    21e4 <rFtH+0x1014>
xor    %ebx,%ebx
mov    0x10(%rsp),%rdi
jmp    21e4 <rFtH+0x1014>
mov    0x38(%rsp),%rcx
mov    %ecx,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%edi
and    $0x3,%edi
cmp    $0x18,%rsi
mov    0x20(%rsp),%rbp
jae    16bb <rFtH+0x4eb>
movdqa 0x198c(%rip),%xmm0
xor    %esi,%esi
jmp    1795 <rFtH+0x5c5>
and    $0xfffffffffffffffc,%rdx
movdqa 0x1979(%rip),%xmm0
xor    %esi,%esi
movdqa 0x197e(%rip),%xmm8
movdqa 0x1985(%rip),%xmm9
movdqa 0x198c(%rip),%xmm10
movdqa 0x1994(%rip),%xmm4
movdqa 0x199c(%rip),%xmm5
movdqa 0x19a4(%rip),%xmm6
movdqa 0x19ac(%rip),%xmm7
movdqa 0x19b4(%rip),%xmm1
nopl   0x0(%rax)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,0x0(%r13,%rsi,4)
movdqu %xmm2,0x10(%r13,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%r13,%rsi,4)
movdqu %xmm3,0x30(%r13,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%r13,%rsi,4)
movdqu %xmm3,0x50(%r13,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%r13,%rsi,4)
movdqu %xmm3,0x70(%r13,%rsi,4)
add    $0x20,%rsi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rdx
jne    1710 <rFtH+0x540>
test   %rdi,%rdi
je     17e0 <rFtH+0x610>
lea    0x10(,%rsi,4),%rdx
add    %r13,%rdx
shl    $0x5,%rdi
xor    %esi,%esi
movdqa 0x189d(%rip),%xmm1
movdqa 0x18a5(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rdx,%rsi,1)
movdqu %xmm3,(%rdx,%rsi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rsi
cmp    %rsi,%rdi
jne    17c0 <rFtH+0x5f0>
cmp    %rcx,%rax
mov    0x10(%rsp),%rdi
movsd  0x40(%rsp),%xmm0
je     17fe <rFtH+0x62e>
mov    %eax,0x0(%r13,%rax,4)
add    $0x1,%rax
cmp    %rax,%rcx
jne    17f0 <rFtH+0x620>
xor    %ebx,%ebx
cmp    $0x4,%r8d
jb     21e4 <rFtH+0x1014>
cmpl   $0x6,0x18(%rsp)
jb     21e4 <rFtH+0x1014>
mov    %r15,0x60(%rsp)
mov    %r13,0xb0(%rsp)
movapd %xmm0,%xmm8
addsd  %xmm0,%xmm8
lea    -0x1(%r8),%eax
mov    %eax,0x8c(%rsp)
lea    -0x2(%r8),%eax
mov    %eax,0x88(%rsp)
mov    %ecx,%eax
and    $0xfffffffc,%eax
mov    %rax,0x120(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x118(%rsp)
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %ebp,%eax
and    $0xfffffff8,%eax
mov    %rax,0xf0(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0xe8(%rsp)
mov    %rax,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
movapd %xmm8,%xmm7
unpcklpd %xmm8,%xmm7
mov    %rdx,%rax
mov    %rdx,0x110(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x108(%rsp)
and    $0xfffffffe,%ecx
mov    %rcx,0xf8(%rsp)
movabs $0x3ffffffffffffffc,%rcx
ff ff 3f
or     $0x2,%rcx
mov    %rsi,%rax
mov    %rsi,0xe0(%rsp)
and    %rsi,%rcx
mov    %rcx,0xd8(%rsp)
and    $0xfffffffe,%ebp
mov    %rbp,0x128(%rsp)
mov    $0x2710,%eax
mov    %rax,0x68(%rsp)
mov    $0x4,%r13d
mov    $0x3,%ebx
mov    $0x1,%ebp
movapd %xmm8,0xc0(%rsp)
movapd %xmm7,0x130(%rsp)
jmp    193c <rFtH+0x76c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x8(%rsp),%eax
mov    %eax,%ebx
mov    0xc(%rsp),%ebp
add    $0x1,%ebp
mov    0x68(%rsp),%rax
add    %eax,%eax
cmp    %eax,%ebp
jae    21d2 <rFtH+0x1002>
mov    %ebp,0xc(%rsp)
mov    %ebx,0x8(%rsp)
xor    %eax,%eax
call   10f0 <rand@plt>
xor    %edx,%edx
divl   0x8c(%rsp)
mov    0xb0(%rsp),%rbp
mov    0x0(%rbp),%eax
mov    0x4(%rbp,%rdx,4),%ecx
mov    %ecx,0x0(%rbp)
mov    %eax,0x4(%rbp,%rdx,4)
xor    %eax,%eax
call   10f0 <rand@plt>
xor    %edx,%edx
divl   0x88(%rsp)
add    $0x2,%edx
mov    0x4(%rbp),%eax
mov    0x0(%rbp,%rdx,4),%ecx
mov    %ecx,0x4(%rbp)
mov    %eax,0x0(%rbp,%rdx,4)
mov    0x0(%rbp),%eax
add    %eax,%eax
lea    (%rax,%rax,2),%eax
mov    0x70(%rsp),%rbx
lea    (%rbx,%rax,8),%rsi
lea    (%rbx,%rax,8),%rdx
add    $0x18,%rdx
lea    0x1b0(%rsp),%r15
mov    %r15,%rdi
xor    %eax,%eax
call   10b0 <crossp@plt>
mov    0x4(%rbp),%eax
add    %eax,%eax
lea    (%rax,%rax,2),%eax
lea    (%rbx,%rax,8),%rsi
lea    (%rbx,%rax,8),%rdx
add    $0x18,%rdx
lea    0x190(%rsp),%rbx
mov    %rbx,%rdi
xor    %eax,%eax
call   10b0 <crossp@plt>
lea    0x90(%rsp),%rdi
mov    %r15,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   10b0 <crossp@plt>
movsd  0x90(%rsp),%xmm1
movsd  0x98(%rsp),%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0xa0(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd 0x15e8(%rip),%xmm0
mov    %r13,0x78(%rsp)
jb     1a40 <rFtH+0x870>
sqrtsd %xmm0,%xmm0
jmp    1a45 <rFtH+0x875>
cs nopw 0x0(%rax,%rax,1)
nop
call   10d0 <sqrt@plt>
mov    0x60(%rsp),%r15
movapd 0x90(%rsp),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
divpd  %xmm2,%xmm1
movapd %xmm1,0x90(%rsp)
movsd  0xa0(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0xa0(%rsp)
xor    %ebx,%ebx
lea    0x90(%rsp),%rdi
lea    0x270(%rsp),%rbp
mov    %rbp,%rsi
xor    %eax,%eax
call   10c0 <skew_sym@plt>
lea    0x1d0(%rsp),%rdi
mov    0xb8(%rsp),%rsi
mov    $0x3,%edx
mov    $0x3,%ecx
xor    %eax,%eax
call   1090 <mattr@plt>
lea    0x220(%rsp),%r13
mov    %r13,%rdi
mov    %rbp,%rsi
lea    0x1d0(%rsp),%rdx
mov    $0x3,%ecx
xor    %eax,%eax
call   1060 <mmul@plt>
mov    %rbp,%rdi
mov    %r13,%rsi
mov    $0x3,%edx
mov    $0x3,%ecx
xor    %eax,%eax
call   1090 <mattr@plt>
mov    %r15,%rdi
mov    %rbp,%rsi
mov    %r14,%rdx
mov    0x48(%rsp),%rbp
mov    %ebp,%ecx
xor    %eax,%eax
call   1080 <FDs@plt>
mov    %rbp,%r9
cmp    $0x4,%r9d
jae    1b40 <rFtH+0x970>
xor    %eax,%eax
movq   0x40(%rsp),%xmm0
mov    0x50(%rsp),%r8
mov    0x58(%rsp),%rbp
mov    0x38(%rsp),%rdi
movapd 0xc0(%rsp),%xmm8
mov    0x78(%rsp),%r13
jmp    1d50 <rFtH+0xb80>
nop
cmpq   $0x0,0x118(%rsp)
je     1eec <rFtH+0xd1c>
xorpd  %xmm0,%xmm0
mov    0x108(%rsp),%rcx
xor    %eax,%eax
xorpd  %xmm1,%xmm1
mov    0x50(%rsp),%r8
mov    0x58(%rsp),%rbp
mov    0x38(%rsp),%rdi
movapd 0xc0(%rsp),%xmm8
movapd 0x130(%rsp),%xmm7
movdqa 0x1495(%rip),%xmm6
mov    0x78(%rsp),%r13
movupd (%r14,%rax,8),%xmm3
movupd 0x10(%r14,%rax,8),%xmm2
cmpltpd %xmm7,%xmm3
movq   %xmm3,%rdx
movzbl %dl,%edx
movdqa %xmm3,%xmm4
punpckhqdq %xmm3,%xmm4
movq   %xmm4,%rsi
shl    $0x8,%esi
or     %edx,%esi
movd   %esi,%xmm4
pand   %xmm6,%xmm4
cmpltpd %xmm7,%xmm2
movq   %xmm2,%rdx
movzbl %dl,%edx
movdqa %xmm2,%xmm5
punpckhqdq %xmm2,%xmm5
movq   %xmm5,%rsi
shl    $0x8,%esi
or     %edx,%esi
movd   %esi,%xmm5
pand   %xmm6,%xmm5
shufps $0xe8,%xmm3,%xmm3
psubd  %xmm3,%xmm0
shufps $0xe8,%xmm2,%xmm2
psubd  %xmm2,%xmm1
movd   %xmm4,%edx
mov    %dx,(%r12,%rax,1)
movd   %xmm5,%edx
mov    %dx,0x2(%r12,%rax,1)
movupd 0x20(%r14,%rax,8),%xmm3
movupd 0x30(%r14,%rax,8),%xmm2
cmpltpd %xmm7,%xmm3
movq   %xmm3,%rdx
movzbl %dl,%edx
movdqa %xmm3,%xmm4
punpckhqdq %xmm3,%xmm4
movq   %xmm4,%rsi
shl    $0x8,%esi
or     %edx,%esi
movd   %esi,%xmm4
pand   %xmm6,%xmm4
cmpltpd %xmm7,%xmm2
movq   %xmm2,%rdx
movzbl %dl,%edx
movdqa %xmm2,%xmm5
punpckhqdq %xmm2,%xmm5
movq   %xmm5,%rsi
shl    $0x8,%esi
or     %edx,%esi
movd   %esi,%xmm5
pand   %xmm6,%xmm5
shufps $0xe8,%xmm3,%xmm3
psubd  %xmm3,%xmm0
shufps $0xe8,%xmm2,%xmm2
psubd  %xmm2,%xmm1
movd   %xmm4,%edx
mov    %dx,0x4(%r12,%rax,1)
movd   %xmm5,%edx
mov    %dx,0x6(%r12,%rax,1)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1b90 <rFtH+0x9c0>
testb  $0x1,0x110(%rsp)
01
je     1d24 <rFtH+0xb54>
movupd (%r14,%rax,8),%xmm3
movupd 0x10(%r14,%rax,8),%xmm2
cmpltpd %xmm7,%xmm3
movq   %xmm3,%rcx
movzbl %cl,%ecx
movdqa %xmm3,%xmm4
punpckhqdq %xmm3,%xmm4
movq   %xmm4,%rdx
shl    $0x8,%edx
or     %ecx,%edx
movd   %edx,%xmm4
pand   %xmm6,%xmm4
cmpltpd %xmm7,%xmm2
movq   %xmm2,%rcx
movzbl %cl,%ecx
movdqa %xmm2,%xmm5
punpckhqdq %xmm2,%xmm5
movq   %xmm5,%rdx
shl    $0x8,%edx
or     %ecx,%edx
movd   %edx,%xmm5
pand   %xmm6,%xmm5
shufps $0xe8,%xmm3,%xmm3
psubd  %xmm3,%xmm0
shufps $0xe8,%xmm2,%xmm2
psubd  %xmm2,%xmm1
movd   %xmm4,%ecx
mov    %cx,(%r12,%rax,1)
movd   %xmm5,%ecx
mov    %cx,0x2(%r12,%rax,1)
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%ebx
mov    0x120(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdi,%rcx
movq   0x40(%rsp),%xmm0
je     1d6b <rFtH+0xb9b>
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
ucomisd (%r14,%rax,8),%xmm8
seta   %cl
seta   (%r12,%rax,1)
add    %ecx,%ebx
add    $0x1,%rax
cmp    %rax,%rdi
jne    1d50 <rFtH+0xb80>
cmp    %r13d,%ebx
jbe    1920 <rFtH+0x750>
xor    %eax,%eax
cmp    $0x1,%r9d
jne    1e40 <rFtH+0xc70>
xor    %r13d,%r13d
test   $0x1,%dil
je     1dc3 <rFtH+0xbf3>
cmpb   $0x0,(%r12,%rax,1)
je     1dc3 <rFtH+0xbf3>
lea    0x0(%r13,%r13,1),%ecx
lea    (%rcx,%rcx,2),%ecx
add    %eax,%eax
lea    (%rax,%rax,2),%eax
movups (%r15,%rax,8),%xmm3
movdqu 0x10(%r15,%rax,8),%xmm1
movups 0x20(%r15,%rax,8),%xmm2
movups %xmm2,0x20(%rbp,%rcx,8)
movdqu %xmm1,0x10(%rbp,%rcx,8)
movups %xmm3,0x0(%rbp,%rcx,8)
add    $0x1,%r13d
sub    $0x8,%rsp
mov    0x88(%rsp),%rdi
mov    0x20(%rsp),%rsi
mov    %rbp,%rdx
mov    %r13d,%ecx
mov    0x34(%rsp),%ebx
mov    %ebx,%r9d
mov    $0x1,%al
push   0x18(%rsp)
lea    0x150(%rsp),%rbp
push   %rbp
push   $0x4
push   $0x6
push   $0xf
call   1030 <innerFH@plt>
add    $0x30,%rsp
test   %ebx,%ebx
je     1920 <rFtH+0x750>
cmp    $0x8,%ebx
jae    1f38 <rFtH+0xd68>
xor    %eax,%eax
xor    %ebx,%ebx
mov    0x10(%rsp),%rdx
mov    0x30(%rsp),%r8
mov    0x20(%rsp),%rbp
mov    0x48(%rsp),%rsi
mov    0x8(%rsp),%edi
jmp    2090 <rFtH+0xec0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0x6,%ecx
xor    %r13d,%r13d
mov    0xf8(%rsp),%rbx
jmp    1e71 <rFtH+0xca1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x2,%rax
add    $0xc,%rcx
cmp    %rax,%rbx
je     1d83 <rFtH+0xbb3>
cmpb   $0x0,(%r12,%rax,1)
je     1eac <rFtH+0xcdc>
lea    0x0(%r13,%r13,1),%edx
lea    (%rdx,%rdx,2),%edx
lea    -0x6(%rcx),%esi
and    $0xfffffffc,%esi
movups (%r15,%rsi,8),%xmm3
movdqu 0x10(%r15,%rsi,8),%xmm1
movups 0x20(%r15,%rsi,8),%xmm2
movups %xmm2,0x20(%rbp,%rdx,8)
movdqu %xmm1,0x10(%rbp,%rdx,8)
movups %xmm3,0x0(%rbp,%rdx,8)
add    $0x1,%r13d
cmpb   $0x0,0x1(%r12,%rax,1)
je     1e60 <rFtH+0xc90>
lea    0x0(%r13,%r13,1),%edx
lea    (%rdx,%rdx,2),%edx
mov    %ecx,%esi
and    $0xfffffffe,%esi
movups (%r15,%rsi,8),%xmm3
movdqu 0x10(%r15,%rsi,8),%xmm1
movups 0x20(%r15,%rsi,8),%xmm2
movups %xmm2,0x20(%rbp,%rdx,8)
movdqu %xmm1,0x10(%rbp,%rdx,8)
movups %xmm3,0x0(%rbp,%rdx,8)
add    $0x1,%r13d
jmp    1e60 <rFtH+0xc90>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
xorpd  %xmm1,%xmm1
mov    0x50(%rsp),%r8
mov    0x58(%rsp),%rbp
mov    0x38(%rsp),%rdi
movapd 0xc0(%rsp),%xmm8
movapd 0x130(%rsp),%xmm7
movdqa 0x1100(%rip),%xmm6
mov    0x78(%rsp),%r13
testb  $0x1,0x110(%rsp)
01
jne    1ca6 <rFtH+0xad6>
jmp    1d24 <rFtH+0xb54>
cmpq   $0x0,0xe8(%rsp)
je     2121 <rFtH+0xf51>
pxor   %xmm0,%xmm0
mov    0xd8(%rsp),%rcx
xor    %eax,%eax
pxor   %xmm1,%xmm1
mov    0x10(%rsp),%rdx
mov    0x30(%rsp),%r8
mov    0x20(%rsp),%rbp
mov    0x48(%rsp),%rsi
pxor   %xmm4,%xmm4
pcmpeqd %xmm5,%xmm5
movdqa 0x1153(%rip),%xmm6
mov    0x8(%rsp),%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movd   (%rdx,%rax,1),%xmm3
movd   0x4(%rdx,%rax,1),%xmm2
pcmpeqb %xmm4,%xmm3
pxor   %xmm5,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
pand   %xmm6,%xmm3
paddd  %xmm0,%xmm3
pcmpeqb %xmm4,%xmm2
pxor   %xmm5,%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
pand   %xmm6,%xmm2
paddd  %xmm1,%xmm2
movd   0x8(%rdx,%rax,1),%xmm0
movd   0xc(%rdx,%rax,1),%xmm1
pcmpeqb %xmm4,%xmm0
pxor   %xmm5,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
pand   %xmm6,%xmm0
paddd  %xmm3,%xmm0
pcmpeqb %xmm4,%xmm1
pxor   %xmm5,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
pand   %xmm6,%xmm1
paddd  %xmm2,%xmm1
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    1f90 <rFtH+0xdc0>
testb  $0x1,0xe0(%rsp)
01
je     205a <rFtH+0xe8a>
movd   (%rdx,%rax,1),%xmm2
movd   0x4(%rdx,%rax,1),%xmm3
pcmpeqb %xmm4,%xmm2
pxor   %xmm5,%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
pand   %xmm6,%xmm2
paddd  %xmm2,%xmm0
pcmpeqb %xmm4,%xmm3
pxor   %xmm5,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
pand   %xmm6,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebx
mov    0xf0(%rsp),%rcx
mov    %rcx,%rax
cmp    %rbp,%rcx
je     20a0 <rFtH+0xed0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmpb   $0x1,(%rdx,%rax,1)
sbb    $0xffffffff,%ebx
add    $0x1,%rax
cmp    %rax,%rbp
jne    2090 <rFtH+0xec0>
cmp    %edi,%ebx
jbe    211a <rFtH+0xf4a>
mov    0x180(%rsp),%rax
mov    0x100(%rsp),%rcx
mov    %rax,0x40(%rcx)
movapd 0x140(%rsp),%xmm0
movdqa 0x150(%rsp),%xmm1
movaps 0x160(%rsp),%xmm2
movaps 0x170(%rsp),%xmm3
movups %xmm3,0x30(%rcx)
movups %xmm2,0x20(%rcx)
movdqu %xmm1,0x10(%rcx)
movupd %xmm0,(%rcx)
mov    0x2c(%rsp),%eax
test   %eax,%eax
je     2166 <rFtH+0xf96>
cmp    $0x1,%eax
jne    2198 <rFtH+0xfc8>
xor    %eax,%eax
xor    %edi,%edi
test   $0x1,%bpl
mov    0xc(%rsp),%ebp
je     216c <rFtH+0xf9c>
cmpb   $0x0,(%rdx,%rax,1)
je     216c <rFtH+0xf9c>
cmpb   $0x1,(%r8,%rax,1)
sbb    $0xffffffff,%edi
jmp    216c <rFtH+0xf9c>
mov    %edi,%ebx
jmp    1926 <rFtH+0x756>
pxor   %xmm0,%xmm0
xor    %eax,%eax
pxor   %xmm1,%xmm1
mov    0x10(%rsp),%rdx
mov    0x30(%rsp),%r8
mov    0x20(%rsp),%rbp
mov    0x48(%rsp),%rsi
pxor   %xmm4,%xmm4
pcmpeqd %xmm5,%xmm5
movdqa 0xf81(%rip),%xmm6
mov    0x8(%rsp),%edi
testb  $0x1,0xe0(%rsp)
01
jne    201f <rFtH+0xe4f>
jmp    205a <rFtH+0xe8a>
xor    %edi,%edi
mov    0xc(%rsp),%ebp
mov    $0x2,%edx
movq   0xe8f(%rip),%xmm0
mov    $0x1,%al
call   1050 <nsamples@plt>
mov    0x68(%rsp),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   10a0 <dmin@plt>
mov    %rax,0x68(%rsp)
jmp    192a <rFtH+0x75a>
xor    %eax,%eax
xor    %edi,%edi
jmp    21b2 <rFtH+0xfe2>
xchg   %ax,%ax
add    $0x2,%rax
cmp    %rax,0x128(%rsp)
je     2100 <rFtH+0xf30>
cmpb   $0x0,(%rdx,%rax,1)
je     21c0 <rFtH+0xff0>
cmpb   $0x1,(%r8,%rax,1)
sbb    $0xffffffff,%edi
cmpb   $0x0,0x1(%rdx,%rax,1)
je     21a0 <rFtH+0xfd0>
cmpb   $0x1,0x1(%r8,%rax,1)
sbb    $0xffffffff,%edi
jmp    21a0 <rFtH+0xfd0>
mov    0x10(%rsp),%rdi
mov    0xb0(%rsp),%r13
mov    0x60(%rsp),%r15
call   1040 <free@plt>
mov    %r14,%rdi
call   1040 <free@plt>
mov    0x30(%rsp),%rdi
call   1040 <free@plt>
mov    %r15,%rdi
call   1040 <free@plt>
mov    0x70(%rsp),%rdi
call   1040 <free@plt>
mov    0x58(%rsp),%rdi
call   1040 <free@plt>
mov    0x80(%rsp),%rdi
call   1040 <free@plt>
mov    %r13,%rdi
call   1040 <free@plt>
mov    %r12,%rdi
call   1040 <free@plt>
mov    %ebx,%eax
add    $0x2b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @rFtH(double* %0, i8* %1, double %2, double* %3, i32 %4, double* %5, i32* %6, double* %7) {
%9 = alloca double*
%10 = alloca i8*
%11 = alloca double
%12 = alloca double*
%13 = alloca i32
%14 = alloca double*
%15 = alloca i32*
%16 = alloca double*
%17 = alloca i8*
%18 = alloca i8*
%19 = alloca i8*
%20 = alloca double*
%21 = alloca double*
%22 = alloca double*
%23 = alloca double*
%24 = alloca double*
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32*
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca [3 x double]
%40 = alloca double
%41 = alloca [3 x double]
%42 = alloca [3 x double]
%43 = alloca [9 x double]
%44 = alloca [9 x double]
%45 = alloca [9 x double]
%46 = alloca [9 x double]
%47 = alloca i32
%48 = alloca i32
%49 = alloca double
%50 = alloca i8
%51 = alloca i8
store double* %0, double** %9
store i8* %1, i8** %10
store double %2, double* %11
store double* %3, double** %12
store i32 %4, i32* %13
store double* %5, double** %14
store i32* %6, i32** %15
store double* %7, double** %16
store i32 0, i32* %26
store i32 0, i32* %27
store i32 10000, i32* %47
store double 0x3FEFF7CED916872B, double* %49
store i8 6, i8* %50
store i8 4, i8* %51
%52 = load i32, i32* %13
%53 = zext i32 %52 to i64
%54 = mul i64 %53, 1
%55 = call i8* @malloc(i64 %54)
store i8* %55, i8** %19
%56 = load i32, i32* %13
%57 = zext i32 %56 to i64
%58 = mul i64 %57, 8
%59 = call i8* @malloc(i64 %58)
%60 = bitcast i8* %59 to double*
store double* %60, double** %20
%61 = load double*, double** %12
%62 = load double*, double** %9
%63 = load i32, i32* %13
%64 = load double*, double** %20
%65 = load i32*, i32** %15
%66 = load double*, double** %16
%67 = call i32 (double*, double*, i32, double*, i32*, double*, ...) bitcast (i32 (...)* @dHDs to i32 (double*, double*, i32, double*, i32*, double*, ...)*)(double* %61, double* %62, i32 %63, double* %64, i32* %65, double* %66)
%68 = load i32, i32* %13
%69 = zext i32 %68 to i64
%70 = mul i64 %69, 1
%71 = call i8* @malloc(i64 %70)
store i8* %71, i8** %17
store i32 0, i32* %25
br label %72
72: ; preds = %108, %8
%73 = load i32, i32* %25
%74 = load i32, i32* %13
%75 = icmp ult i32 %73, %74
br i1 %75, label %76, label %111
76: ; preds = %72
%77 = load double*, double** %20
%78 = load i32, i32* %25
%79 = zext i32 %78 to i64
%80 = getelementptr inbounds double, double* %77, i64 %79
%81 = load double, double* %80
%82 = load double, double* %11
%83 = fmul double 1.000000e+02, %82
%84 = fcmp ogt double %81, %83
br i1 %84, label %85, label %92
85: ; preds = %76
%86 = load i8*, i8** %17
%87 = load i32, i32* %25
%88 = zext i32 %87 to i64
%89 = getelementptr inbounds i8, i8* %86, i64 %88
store i8 1, i8* %89
%90 = load i32, i32* %26
%91 = add i32 %90, 1
store i32 %91, i32* %26
br label %97
92: ; preds = %76
%93 = load i8*, i8** %17
%94 = load i32, i32* %25
%95 = zext i32 %94 to i64
%96 = getelementptr inbounds i8, i8* %93, i64 %95
store i8 0, i8* %96
br label %97
97: ; preds = %92, %85
%98 = load i8*, i8** %10
%99 = load i32, i32* %25
%100 = zext i32 %99 to i64
%101 = getelementptr inbounds i8, i8* %98, i64 %100
%102 = load i8, i8* %101
%103 = icmp ne i8 %102, 0
br i1 %103, label %104, label %107
104: ; preds = %97
%105 = load i32, i32* %27
%106 = add i32 %105, 1
store i32 %106, i32* %27
br label %107
107: ; preds = %104, %97
br label %108
108: ; preds = %107
%109 = load i32, i32* %25
%110 = add i32 %109, 1
store i32 %110, i32* %25
br label %72
111: ; preds = %72
%112 = load double*, double** %20
%113 = bitcast double* %112 to i8*
%114 = load i32, i32* %26
%115 = zext i32 %114 to i64
%116 = mul i64 %115, 8
%117 = call i8* @malloc(i64 %116)
%118 = bitcast i8* %117 to double*
store double* %118, double** %20
%119 = load i32, i32* %26
%120 = zext i32 %119 to i64
%121 = mul i64 %120, 1
%122 = call i8* @malloc(i64 %121)
store i8* %122, i8** %18
%123 = load i32, i32* %26
%124 = mul i32 6, %123
%125 = zext i32 %124 to i64
%126 = mul i64 %125, 8
%127 = call i8* @malloc(i64 %126)
%128 = bitcast i8* %127 to double*
store double* %128, double** %21
%129 = load i32, i32* %26
%130 = mul i32 6, %129
%131 = zext i32 %130 to i64
%132 = mul i64 %131, 8
%133 = call i8* @malloc(i64 %132)
%134 = bitcast i8* %133 to double*
store double* %134, double** %22
%135 = load i32, i32* %26
%136 = mul i32 6, %135
%137 = zext i32 %136 to i64
%138 = mul i64 %137, 8
%139 = call i8* @malloc(i64 %138)
%140 = bitcast i8* %139 to double*
store double* %140, double** %24
%141 = load i32, i32* %27
%142 = mul i32 6, %141
%143 = zext i32 %142 to i64
%144 = mul i64 %143, 8
%145 = call i8* @malloc(i64 %144)
%146 = bitcast i8* %145 to double*
store double* %146, double** %23
store i32 0, i32* %26
store i32 0, i32* %27
store i32 0, i32* %25
br label %147
147: ; preds = %325, %111
%148 = load i32, i32* %25
%149 = load i32, i32* %13
%150 = icmp ult i32 %148, %149
br i1 %150, label %151, label %328
151: ; preds = %147
%152 = load i8*, i8** %17
%153 = load i32, i32* %25
%154 = zext i32 %153 to i64
%155 = getelementptr inbounds i8, i8* %152, i64 %154
%156 = load i8, i8* %155
%157 = icmp ne i8 %156, 0
br i1 %157, label %158, label %302
158: ; preds = %151
%159 = load double*, double** %21
%160 = load i32, i32* %26
%161 = mul i32 6, %160
%162 = zext i32 %161 to i64
%163 = getelementptr inbounds double, double* %159, i64 %162
%164 = bitcast double* %163 to i8*
%165 = load double*, double** %9
%166 = load i32, i32* %25
%167 = mul i32 6, %166
%168 = zext i32 %167 to i64
%169 = getelementptr inbounds double, double* %165, i64 %168
%170 = bitcast double* %169 to i8*
%171 = load double*, double** %22
%172 = load i32, i32* %26
%173 = mul i32 6, %172
%174 = zext i32 %173 to i64
%175 = getelementptr inbounds double, double* %171, i64 %174
%176 = bitcast double* %175 to i8*
%177 = load double*, double** %9
%178 = load i32, i32* %25
%179 = mul i32 6, %178
%180 = zext i32 %179 to i64
%181 = getelementptr inbounds double, double* %177, i64 %180
%182 = bitcast double* %181 to i8*
%183 = load double*, double** %12
%184 = getelementptr inbounds double, double* %183, i64 0
%185 = load double, double* %184
%186 = load double*, double** %9
%187 = load i32, i32* %25
%188 = mul i32 6, %187
%189 = add i32 %188, 3
%190 = zext i32 %189 to i64
%191 = getelementptr inbounds double, double* %186, i64 %190
%192 = load double, double* %191
%193 = load double*, double** %12
%194 = getelementptr inbounds double, double* %193, i64 3
%195 = load double, double* %194
%196 = load double*, double** %9
%197 = load i32, i32* %25
%198 = mul i32 6, %197
%199 = add i32 %198, 4
%200 = zext i32 %199 to i64
%201 = getelementptr inbounds double, double* %196, i64 %200
%202 = load double, double* %201
%203 = fmul double %195, %202
%204 = call double @llvm.fmuladd.f64(double %185, double %192, double %203)
%205 = load double*, double** %12
%206 = getelementptr inbounds double, double* %205, i64 6
%207 = load double, double* %206
%208 = load double*, double** %9
%209 = load i32, i32* %25
%210 = mul i32 6, %209
%211 = add i32 %210, 5
%212 = zext i32 %211 to i64
%213 = getelementptr inbounds double, double* %208, i64 %212
%214 = load double, double* %213
%215 = call double @llvm.fmuladd.f64(double %207, double %214, double %204)
%216 = load double*, double** %22
%217 = load i32, i32* %26
%218 = mul i32 6, %217
%219 = add i32 %218, 3
%220 = zext i32 %219 to i64
%221 = getelementptr inbounds double, double* %216, i64 %220
store double %215, double* %221
%222 = load double*, double** %12
%223 = getelementptr inbounds double, double* %222, i64 1
%224 = load double, double* %223
%225 = load double*, double** %9
%226 = load i32, i32* %25
%227 = mul i32 6, %226
%228 = add i32 %227, 3
%229 = zext i32 %228 to i64
%230 = getelementptr inbounds double, double* %225, i64 %229
%231 = load double, double* %230
%232 = load double*, double** %12
%233 = getelementptr inbounds double, double* %232, i64 4
%234 = load double, double* %233
%235 = load double*, double** %9
%236 = load i32, i32* %25
%237 = mul i32 6, %236
%238 = add i32 %237, 4
%239 = zext i32 %238 to i64
%240 = getelementptr inbounds double, double* %235, i64 %239
%241 = load double, double* %240
%242 = fmul double %234, %241
%243 = call double @llvm.fmuladd.f64(double %224, double %231, double %242)
%244 = load double*, double** %12
%245 = getelementptr inbounds double, double* %244, i64 7
%246 = load double, double* %245
%247 = load double*, double** %9
%248 = load i32, i32* %25
%249 = mul i32 6, %248
%250 = add i32 %249, 5
%251 = zext i32 %250 to i64
%252 = getelementptr inbounds double, double* %247, i64 %251
%253 = load double, double* %252
%254 = call double @llvm.fmuladd.f64(double %246, double %253, double %243)
%255 = load double*, double** %22
%256 = load i32, i32* %26
%257 = mul i32 6, %256
%258 = add i32 %257, 4
%259 = zext i32 %258 to i64
%260 = getelementptr inbounds double, double* %255, i64 %259
store double %254, double* %260
%261 = load double*, double** %12
%262 = getelementptr inbounds double, double* %261, i64 2
%263 = load double, double* %262
%264 = load double*, double** %9
%265 = load i32, i32* %25
%266 = mul i32 6, %265
%267 = add i32 %266, 3
%268 = zext i32 %267 to i64
%269 = getelementptr inbounds double, double* %264, i64 %268
%270 = load double, double* %269
%271 = load double*, double** %12
%272 = getelementptr inbounds double, double* %271, i64 5
%273 = load double, double* %272
%274 = load double*, double** %9
%275 = load i32, i32* %25
%276 = mul i32 6, %275
%277 = add i32 %276, 4
%278 = zext i32 %277 to i64
%279 = getelementptr inbounds double, double* %274, i64 %278
%280 = load double, double* %279
%281 = fmul double %273, %280
%282 = call double @llvm.fmuladd.f64(double %263, double %270, double %281)
%283 = load double*, double** %12
%284 = getelementptr inbounds double, double* %283, i64 8
%285 = load double, double* %284
%286 = load double*, double** %9
%287 = load i32, i32* %25
%288 = mul i32 6, %287
%289 = add i32 %288, 5
%290 = zext i32 %289 to i64
%291 = getelementptr inbounds double, double* %286, i64 %290
%292 = load double, double* %291
%293 = call double @llvm.fmuladd.f64(double %285, double %292, double %282)
%294 = load double*, double** %22
%295 = load i32, i32* %26
%296 = mul i32 6, %295
%297 = add i32 %296, 5
%298 = zext i32 %297 to i64
%299 = getelementptr inbounds double, double* %294, i64 %298
store double %293, double* %299
%300 = load i32, i32* %26
%301 = add i32 %300, 1
store i32 %301, i32* %26
br label %302
302: ; preds = %158, %151
%303 = load i8*, i8** %10
%304 = load i32, i32* %25
%305 = zext i32 %304 to i64
%306 = getelementptr inbounds i8, i8* %303, i64 %305
%307 = load i8, i8* %306
%308 = icmp ne i8 %307, 0
br i1 %308, label %309, label %324
309: ; preds = %302
%310 = load double*, double** %23
%311 = load i32, i32* %27
%312 = mul i32 6, %311
%313 = zext i32 %312 to i64
%314 = getelementptr inbounds double, double* %310, i64 %313
%315 = bitcast double* %314 to i8*
%316 = load double*, double** %9
%317 = load i32, i32* %25
%318 = mul i32 6, %317
%319 = zext i32 %318 to i64
%320 = getelementptr inbounds double, double* %316, i64 %319
%321 = bitcast double* %320 to i8*
%322 = load i32, i32* %27
%323 = add i32 %322, 1
store i32 %323, i32* %27
br label %324
324: ; preds = %309, %302
br label %325
325: ; preds = %324
%326 = load i32, i32* %25
%327 = add i32 %326, 1
store i32 %327, i32* %25
br label %147
328: ; preds = %147
%329 = load i32, i32* %26
%330 = zext i32 %329 to i64
%331 = mul i64 %330, 4
%332 = call i8* @malloc(i64 %331)
%333 = bitcast i8* %332 to i32*
store i32* %333, i32** %30
store i32 0, i32* %25
br label %334
334: ; preds = %344, %328
%335 = load i32, i32* %25
%336 = load i32, i32* %26
%337 = icmp ult i32 %335, %336
br i1 %337, label %338, label %347
338: ; preds = %334
%339 = load i32, i32* %25
%340 = load i32*, i32** %30
%341 = load i32, i32* %25
%342 = zext i32 %341 to i64
%343 = getelementptr inbounds i32, i32* %340, i64 %342
store i32 %339, i32* %343
br label %344
344: ; preds = %338
%345 = load i32, i32* %25
%346 = add i32 %345, 1
store i32 %346, i32* %25
br label %334
347: ; preds = %334
store i32 3, i32* %31
%348 = load i8, i8* %51
%349 = zext i8 %348 to i32
store i32 %349, i32* %32
%350 = load i32, i32* %47
store i32 %350, i32* %33
store i32 2, i32* %34
%351 = load i32, i32* %26
%352 = icmp ult i32 %351, 4
br i1 %352, label %356, label %353
353: ; preds = %347
%354 = load i32, i32* %27
%355 = icmp ult i32 %354, 6
br i1 %355, label %356, label %357
356: ; preds = %353, %347
store i32 0, i32* %31
br label %636
357: ; preds = %353
store i32 1, i32* %48
br label %358
358: ; preds = %632, %357
%359 = load i32, i32* %48
%360 = load i32, i32* %33
%361 = mul i32 2, %360
%362 = icmp ult i32 %359, %361
br i1 %362, label %363, label %635
363: ; preds = %358
store i32 0, i32* %35
br label %364
364: ; preds = %397, %363
%365 = load i32, i32* %35
%366 = load i32, i32* %34
%367 = icmp ult i32 %365, %366
br i1 %367, label %368, label %400
368: ; preds = %364
%369 = load i32, i32* %35
%370 = add i32 %369, 1
%371 = call i32 (...) @rand()
%372 = load i32, i32* %26
%373 = load i32, i32* %35
%374 = sub i32 %372, %373
%375 = sub i32 %374, 1
%376 = urem i32 %371, %375
%377 = add i32 %370, %376
store i32 %377, i32* %36
%378 = load i32*, i32** %30
%379 = load i32, i32* %35
%380 = zext i32 %379 to i64
%381 = getelementptr inbounds i32, i32* %378, i64 %380
%382 = load i32, i32* %381
store i32 %382, i32* %37
%383 = load i32*, i32** %30
%384 = load i32, i32* %36
%385 = zext i32 %384 to i64
%386 = getelementptr inbounds i32, i32* %383, i64 %385
%387 = load i32, i32* %386
%388 = load i32*, i32** %30
%389 = load i32, i32* %35
%390 = zext i32 %389 to i64
%391 = getelementptr inbounds i32, i32* %388, i64 %390
store i32 %387, i32* %391
%392 = load i32, i32* %37
%393 = load i32*, i32** %30
%394 = load i32, i32* %36
%395 = zext i32 %394 to i64
%396 = getelementptr inbounds i32, i32* %393, i64 %395
store i32 %392, i32* %396
br label %397
397: ; preds = %368
%398 = load i32, i32* %35
%399 = add i32 %398, 1
store i32 %399, i32* %35
br label %364
400: ; preds = %364
%401 = getelementptr inbounds [3 x double], [3 x double]* %41, i64 0, i64 0
%402 = load double*, double** %22
%403 = load i32*, i32** %30
%404 = getelementptr inbounds i32, i32* %403, i64 0
%405 = load i32, i32* %404
%406 = mul i32 6, %405
%407 = zext i32 %406 to i64
%408 = getelementptr inbounds double, double* %402, i64 %407
%409 = load double*, double** %22
%410 = load i32*, i32** %30
%411 = getelementptr inbounds i32, i32* %410, i64 0
%412 = load i32, i32* %411
%413 = mul i32 6, %412
%414 = zext i32 %413 to i64
%415 = getelementptr inbounds double, double* %409, i64 %414
%416 = getelementptr inbounds double, double* %415, i64 3
%417 = call i32 (double*, double*, double*, ...) bitcast (i32 (...)* @crossp to i32 (double*, double*, double*, ...)*)(double* %401, double* %408, double* %416)
%418 = getelementptr inbounds [3 x double], [3 x double]* %42, i64 0, i64 0
%419 = load double*, double** %22
%420 = load i32*, i32** %30
%421 = getelementptr inbounds i32, i32* %420, i64 1
%422 = load i32, i32* %421
%423 = mul i32 6, %422
%424 = zext i32 %423 to i64
%425 = getelementptr inbounds double, double* %419, i64 %424
%426 = load double*, double** %22
%427 = load i32*, i32** %30
%428 = getelementptr inbounds i32, i32* %427, i64 1
%429 = load i32, i32* %428
%430 = mul i32 6, %429
%431 = zext i32 %430 to i64
%432 = getelementptr inbounds double, double* %426, i64 %431
%433 = getelementptr inbounds double, double* %432, i64 3
%434 = call i32 (double*, double*, double*, ...) bitcast (i32 (...)* @crossp to i32 (double*, double*, double*, ...)*)(double* %418, double* %425, double* %433)
%435 = getelementptr inbounds [3 x double], [3 x double]* %39, i64 0, i64 0
%436 = getelementptr inbounds [3 x double], [3 x double]* %41, i64 0, i64 0
%437 = getelementptr inbounds [3 x double], [3 x double]* %42, i64 0, i64 0
%438 = call i32 (double*, double*, double*, ...) bitcast (i32 (...)* @crossp to i32 (double*, double*, double*, ...)*)(double* %435, double* %436, double* %437)
%439 = getelementptr inbounds [3 x double], [3 x double]* %39, i64 0, i64 0
%440 = load double, double* %439
%441 = getelementptr inbounds [3 x double], [3 x double]* %39, i64 0, i64 0
%442 = load double, double* %441
%443 = getelementptr inbounds [3 x double], [3 x double]* %39, i64 0, i64 1
%444 = load double, double* %443
%445 = getelementptr inbounds [3 x double], [3 x double]* %39, i64 0, i64 1
%446 = load double, double* %445
%447 = fmul double %444, %446
%448 = call double @llvm.fmuladd.f64(double %440, double %442, double %447)
%449 = getelementptr inbounds [3 x double], [3 x double]* %39, i64 0, i64 2
%450 = load double, double* %449
%451 = getelementptr inbounds [3 x double], [3 x double]* %39, i64 0, i64 2
%452 = load double, double* %451
%453 = call double @llvm.fmuladd.f64(double %450, double %452, double %448)
%454 = call double @sqrt(double %453)
store double %454, double* %40
%455 = getelementptr inbounds [3 x double], [3 x double]* %39, i64 0, i64 0
%456 = load double, double* %455
%457 = load double, double* %40
%458 = fdiv double %456, %457
%459 = getelementptr inbounds [3 x double], [3 x double]* %39, i64 0, i64 0
store double %458, double* %459
%460 = getelementptr inbounds [3 x double], [3 x double]* %39, i64 0, i64 1
%461 = load double, double* %460
%462 = load double, double* %40
%463 = fdiv double %461, %462
%464 = getelementptr inbounds [3 x double], [3 x double]* %39, i64 0, i64 1
store double %463, double* %464
%465 = getelementptr inbounds [3 x double], [3 x double]* %39, i64 0, i64 2
%466 = load double, double* %465
%467 = load double, double* %40
%468 = fdiv double %466, %467
%469 = getelementptr inbounds [3 x double], [3 x double]* %39, i64 0, i64 2
store double %468, double* %469
%470 = getelementptr inbounds [3 x double], [3 x double]* %39, i64 0, i64 0
%471 = getelementptr inbounds [9 x double], [9 x double]* %43, i64 0, i64 0
%472 = call i32 (double*, double*, ...) bitcast (i32 (...)* @skew_sym to i32 (double*, double*, ...)*)(double* %470, double* %471)
%473 = getelementptr inbounds [9 x double], [9 x double]* %46, i64 0, i64 0
%474 = load double*, double** %12
%475 = call i32 (double*, double*, i32, i32, ...) bitcast (i32 (...)* @mattr to i32 (double*, double*, i32, i32, ...)*)(double* %473, double* %474, i32 3, i32 3)
%476 = getelementptr inbounds [9 x double], [9 x double]* %44, i64 0, i64 0
%477 = getelementptr inbounds [9 x double], [9 x double]* %43, i64 0, i64 0
%478 = getelementptr inbounds [9 x double], [9 x double]* %46, i64 0, i64 0
%479 = call i32 (double*, double*, double*, i32, ...) bitcast (i32 (...)* @mmul to i32 (double*, double*, double*, i32, ...)*)(double* %476, double* %477, double* %478, i32 3)
%480 = getelementptr inbounds [9 x double], [9 x double]* %43, i64 0, i64 0
%481 = getelementptr inbounds [9 x double], [9 x double]* %44, i64 0, i64 0
%482 = call i32 (double*, double*, i32, i32, ...) bitcast (i32 (...)* @mattr to i32 (double*, double*, i32, i32, ...)*)(double* %480, double* %481, i32 3, i32 3)
%483 = load double*, double** %21
%484 = getelementptr inbounds [9 x double], [9 x double]* %43, i64 0, i64 0
%485 = load double*, double** %20
%486 = load i32, i32* %26
%487 = call i32 (double*, double*, double*, i32, ...) bitcast (i32 (...)* @FDs to i32 (double*, double*, double*, i32, ...)*)(double* %483, double* %484, double* %485, i32 %486)
store i32 0, i32* %38
store i32 0, i32* %25
br label %488
488: ; preds = %514, %400
%489 = load i32, i32* %25
%490 = load i32, i32* %26
%491 = icmp ult i32 %489, %490
br i1 %491, label %492, label %517
492: ; preds = %488
%493 = load double*, double** %20
%494 = load i32, i32* %25
%495 = zext i32 %494 to i64
%496 = getelementptr inbounds double, double* %493, i64 %495
%497 = load double, double* %496
%498 = load double, double* %11
%499 = fmul double %498, 2.000000e+00
%500 = fcmp olt double %497, %499
br i1 %500, label %501, label %508
501: ; preds = %492
%502 = load i32, i32* %38
%503 = add i32 %502, 1
store i32 %503, i32* %38
%504 = load i8*, i8** %18
%505 = load i32, i32* %25
%506 = zext i32 %505 to i64
%507 = getelementptr inbounds i8, i8* %504, i64 %506
store i8 1, i8* %507
br label %513
508: ; preds = %492
%509 = load i8*, i8** %18
%510 = load i32, i32* %25
%511 = zext i32 %510 to i64
%512 = getelementptr inbounds i8, i8* %509, i64 %511
store i8 0, i8* %512
br label %513
513: ; preds = %508, %501
br label %514
514: ; preds = %513
%515 = load i32, i32* %25
%516 = add i32 %515, 1
store i32 %516, i32* %25
br label %488
517: ; preds = %488
%518 = load i32, i32* %38
%519 = load i32, i32* %32
%520 = icmp ugt i32 %518, %519
br i1 %520, label %521, label %631
521: ; preds = %517
store i32 0, i32* %38
store i32 0, i32* %25
br label %522
522: ; preds = %549, %521
%523 = load i32, i32* %25
%524 = load i32, i32* %26
%525 = icmp ult i32 %523, %524
br i1 %525, label %526, label %552
526: ; preds = %522
%527 = load i8*, i8** %18
%528 = load i32, i32* %25
%529 = zext i32 %528 to i64
%530 = getelementptr inbounds i8, i8* %527, i64 %529
%531 = load i8, i8* %530
%532 = icmp ne i8 %531, 0
br i1 %532, label %533, label %548
533: ; preds = %526
%534 = load double*, double** %24
%535 = load i32, i32* %38
%536 = mul i32 6, %535
%537 = zext i32 %536 to i64
%538 = getelementptr inbounds double, double* %534, i64 %537
%539 = bitcast double* %538 to i8*
%540 = load double*, double** %21
%541 = load i32, i32* %25
%542 = mul i32 6, %541
%543 = zext i32 %542 to i64
%544 = getelementptr inbounds double, double* %540, i64 %543
%545 = bitcast double* %544 to i8*
%546 = load i32, i32* %38
%547 = add i32 %546, 1
store i32 %547, i32* %38
br label %548
548: ; preds = %533, %526
br label %549
549: ; preds = %548
%550 = load i32, i32* %25
%551 = add i32 %550, 1
store i32 %551, i32* %25
br label %522
552: ; preds = %522
%553 = load i32, i32* %38
store i32 %553, i32* %32
%554 = load double*, double** %23
%555 = load i32, i32* %27
%556 = load double*, double** %24
%557 = load i32, i32* %38
%558 = load double*, double** %9
%559 = load i32, i32* %13
%560 = load double, double* %11
%561 = load i8, i8* %50
%562 = zext i8 %561 to i32
%563 = load i8, i8* %51
%564 = zext i8 %563 to i32
%565 = getelementptr inbounds [9 x double], [9 x double]* %45, i64 0, i64 0
%566 = load i8*, i8** %19
%567 = call i32 (double*, i32, double*, i32, double*, i32, double, i32, i32, i32, double*, i8*, ...) bitcast (i32 (...)* @innerFH to i32 (double*, i32, double*, i32, double*, i32, double, i32, i32, i32, double*, i8*, ...)*)(double* %554, i32 %555, double* %556, i32 %557, double* %558, i32 %559, double %560, i32 15, i32 %562, i32 %564, double* %565, i8* %566)
store i32 0, i32* %28
store i32 0, i32* %25
br label %568
568: ; preds = %583, %552
%569 = load i32, i32* %25
%570 = load i32, i32* %13
%571 = icmp ult i32 %569, %570
br i1 %571, label %572, label %586
572: ; preds = %568
%573 = load i8*, i8** %19
%574 = load i32, i32* %25
%575 = zext i32 %574 to i64
%576 = getelementptr inbounds i8, i8* %573, i64 %575
%577 = load i8, i8* %576
%578 = icmp ne i8 %577, 0
br i1 %578, label %579, label %582
579: ; preds = %572
%580 = load i32, i32* %28
%581 = add i32 %580, 1
store i32 %581, i32* %28
br label %582
582: ; preds = %579, %572
br label %583
583: ; preds = %582
%584 = load i32, i32* %25
%585 = add i32 %584, 1
store i32 %585, i32* %25
br label %568
586: ; preds = %568
%587 = load i32, i32* %28
%588 = load i32, i32* %31
%589 = icmp ugt i32 %587, %588
br i1 %589, label %590, label %630
590: ; preds = %586
%591 = load i32, i32* %28
store i32 %591, i32* %31
%592 = load double*, double** %14
%593 = bitcast double* %592 to i8*
%594 = getelementptr inbounds [9 x double], [9 x double]* %45, i64 0, i64 0
%595 = bitcast double* %594 to i8*
store i32 0, i32* %29
store i32 0, i32* %25
br label %596
596: ; preds = %620, %590
%597 = load i32, i32* %25
%598 = load i32, i32* %13
%599 = icmp ult i32 %597, %598
br i1 %599, label %600, label %623
600: ; preds = %596
%601 = load i8*, i8** %19
%602 = load i32, i32* %25
%603 = zext i32 %602 to i64
%604 = getelementptr inbounds i8, i8* %601, i64 %603
%605 = load i8, i8* %604
%606 = zext i8 %605 to i32
%607 = icmp ne i32 %606, 0
br i1 %607, label %608, label %619
608: ; preds = %600
%609 = load i8*, i8** %17
%610 = load i32, i32* %25
%611 = zext i32 %610 to i64
%612 = getelementptr inbounds i8, i8* %609, i64 %611
%613 = load i8, i8* %612
%614 = zext i8 %613 to i32
%615 = icmp ne i32 %614, 0
br i1 %615, label %616, label %619
616: ; preds = %608
%617 = load i32, i32* %29
%618 = add i32 %617, 1
store i32 %618, i32* %29
br label %619
619: ; preds = %616, %608, %600
br label %620
620: ; preds = %619
%621 = load i32, i32* %25
%622 = add i32 %621, 1
store i32 %622, i32* %25
br label %596
623: ; preds = %596
%624 = load i32, i32* %33
%625 = load i32, i32* %29
%626 = load i32, i32* %26
%627 = load double, double* %49
%628 = call i32 (i32, i32, i32, double, ...) bitcast (i32 (...)* @nsamples to i32 (i32, i32, i32, double, ...)*)(i32 %625, i32 %626, i32 2, double %627)
%629 = call i32 (i32, i32, ...) bitcast (i32 (...)* @dmin to i32 (i32, i32, ...)*)(i32 %624, i32 %628)
store i32 %629, i32* %33
br label %630
630: ; preds = %623, %586
br label %631
631: ; preds = %630, %517
br label %632
632: ; preds = %631
%633 = load i32, i32* %48
%634 = add i32 %633, 1
store i32 %634, i32* %48
br label %358
635: ; preds = %358
br label %636
636: ; preds = %635, %356
%637 = load i8*, i8** %19
%638 = load double*, double** %20
%639 = bitcast double* %638 to i8*
%640 = load i8*, i8** %17
%641 = load double*, double** %21
%642 = bitcast double* %641 to i8*
%643 = load double*, double** %22
%644 = bitcast double* %643 to i8*
%645 = load double*, double** %24
%646 = bitcast double* %645 to i8*
%647 = load double*, double** %23
%648 = bitcast double* %647 to i8*
%649 = load i32*, i32** %30
%650 = bitcast i32* %649 to i8*
%651 = load i8*, i8** %18
%652 = load i32, i32* %31
ret i32 %652
}

LLVM IR (-O2):
define i32 @rFtH(double* %0, i8* nocapture %1, double %2, double* %3, i32 %4, double* nocapture writeonly %5, i32* %6, double* %7) {
%9 = alloca [3 x double]
%10 = alloca [3 x double]
%11 = alloca [3 x double]
%12 = alloca [9 x double]
%13 = alloca [9 x double]
%14 = alloca [9 x double]
%15 = alloca [9 x double]
%16 = bitcast [3 x double]* %9 to i8*
%17 = bitcast [3 x double]* %10 to i8*
%18 = bitcast [3 x double]* %11 to i8*
%19 = bitcast [9 x double]* %12 to i8*
%20 = bitcast [9 x double]* %13 to i8*
%21 = bitcast [9 x double]* %14 to i8*
%22 = bitcast [9 x double]* %15 to i8*
%23 = zext i32 %4 to i64
%24 = tail call i8* @malloc(i64 %23)
%25 = shl nuw nsw i64 %23, 3
%26 = tail call i8* @malloc(i64 %25)
%27 = bitcast i8* %26 to double*
%28 = tail call i32 (double*, double*, i32, double*, i32*, double*, ...) bitcast (i32 (...)* @dHDs to i32 (double*, double*, i32, double*, i32*, double*, ...)*)(double* %3, double* %0, i32 %4, double* %27, i32* %6, double* %7)
%29 = tail call i8* @malloc(i64 %23)
%30 = icmp eq i32 %4, 0
br i1 %30, label %112, label %31
31: ; preds = %8
%32 = fmul double %2, 1.000000e+02
%33 = icmp ult i32 %4, 4
br i1 %33, label %84, label %34
34: ; preds = %31
%35 = and i64 %23, 4294967292
%36 = insertelement <2 x double> poison, double %32, i64 0
%37 = shufflevector <2 x double> %36, <2 x double> poison, <2 x i32> zeroinitializer
%38 = insertelement <2 x double> poison, double %32, i64 0
%39 = shufflevector <2 x double> %38, <2 x double> poison, <2 x i32> zeroinitializer
br label %40
40: ; preds = %40, %34
%41 = phi i64 [ 0, %34 ], [ %76, %40 ]
%42 = phi <2 x i32> [ zeroinitializer, %34 ], [ %58, %40 ]
%43 = phi <2 x i32> [ zeroinitializer, %34 ], [ %59, %40 ]
%44 = phi <2 x i32> [ zeroinitializer, %34 ], [ %74, %40 ]
%45 = phi <2 x i32> [ zeroinitializer, %34 ], [ %75, %40 ]
%46 = getelementptr inbounds double, double* %27, i64 %41
%47 = bitcast double* %46 to <2 x double>*
%48 = load <2 x double>, <2 x double>* %47
%49 = getelementptr inbounds double, double* %46, i64 2
%50 = bitcast double* %49 to <2 x double>*
%51 = load <2 x double>, <2 x double>* %50
%52 = fcmp ogt <2 x double> %48, %37
%53 = fcmp ogt <2 x double> %51, %39
%54 = zext <2 x i1> %52 to <2 x i8>
%55 = zext <2 x i1> %53 to <2 x i8>
%56 = zext <2 x i1> %52 to <2 x i32>
%57 = zext <2 x i1> %53 to <2 x i32>
%58 = add <2 x i32> %42, %56
%59 = add <2 x i32> %43, %57
%60 = getelementptr inbounds i8, i8* %29, i64 %41
%61 = bitcast i8* %60 to <2 x i8>*
store <2 x i8> %54, <2 x i8>* %61
%62 = getelementptr inbounds i8, i8* %60, i64 2
%63 = bitcast i8* %62 to <2 x i8>*
store <2 x i8> %55, <2 x i8>* %63
%64 = getelementptr inbounds i8, i8* %1, i64 %41
%65 = bitcast i8* %64 to <2 x i8>*
%66 = load <2 x i8>, <2 x i8>* %65
%67 = getelementptr inbounds i8, i8* %64, i64 2
%68 = bitcast i8* %67 to <2 x i8>*
%69 = load <2 x i8>, <2 x i8>* %68
%70 = icmp ne <2 x i8> %66, zeroinitializer
%71 = icmp ne <2 x i8> %69, zeroinitializer
%72 = zext <2 x i1> %70 to <2 x i32>
%73 = zext <2 x i1> %71 to <2 x i32>
%74 = add <2 x i32> %44, %72
%75 = add <2 x i32> %45, %73
%76 = add nuw i64 %41, 4
%77 = icmp eq i64 %76, %35
br i1 %77, label %78, label %40
78: ; preds = %40
%79 = add <2 x i32> %75, %74
%80 = call i32 @llvm.vector.reduce.add.v2i32(<2 x i32> %79)
%81 = add <2 x i32> %59, %58
%82 = call i32 @llvm.vector.reduce.add.v2i32(<2 x i32> %81)
%83 = icmp eq i64 %35, %23
br i1 %83, label %106, label %84
84: ; preds = %31, %78
%85 = phi i64 [ 0, %31 ], [ %35, %78 ]
%86 = phi i32 [ 0, %31 ], [ %82, %78 ]
%87 = phi i32 [ 0, %31 ], [ %80, %78 ]
br label %88
88: ; preds = %84, %88
%89 = phi i64 [ %104, %88 ], [ %85, %84 ]
%90 = phi i32 [ %97, %88 ], [ %86, %84 ]
%91 = phi i32 [ %103, %88 ], [ %87, %84 ]
%92 = getelementptr inbounds double, double* %27, i64 %89
%93 = load double, double* %92
%94 = fcmp ogt double %93, %32
%95 = zext i1 %94 to i8
%96 = zext i1 %94 to i32
%97 = add i32 %90, %96
%98 = getelementptr inbounds i8, i8* %29, i64 %89
store i8 %95, i8* %98
%99 = getelementptr inbounds i8, i8* %1, i64 %89
%100 = load i8, i8* %99
%101 = icmp ne i8 %100, 0
%102 = zext i1 %101 to i32
%103 = add i32 %91, %102
%104 = add nuw nsw i64 %89, 1
%105 = icmp eq i64 %104, %23
br i1 %105, label %106, label %88
106: ; preds = %88, %78
%107 = phi i32 [ %82, %78 ], [ %97, %88 ]
%108 = phi i32 [ %80, %78 ], [ %103, %88 ]
%109 = mul i32 %108, 6
%110 = zext i32 %109 to i64
%111 = shl nuw nsw i64 %110, 3
br label %112
112: ; preds = %106, %8
%113 = phi i64 [ 0, %8 ], [ %111, %106 ]
%114 = phi i32 [ 0, %8 ], [ %107, %106 ]
tail call void @free(i8* %26)
%115 = zext i32 %114 to i64
%116 = shl nuw nsw i64 %115, 3
%117 = tail call i8* @malloc(i64 %116)
%118 = bitcast i8* %117 to double*
%119 = tail call i8* @malloc(i64 %115)
%120 = mul i32 %114, 6
%121 = zext i32 %120 to i64
%122 = shl nuw nsw i64 %121, 3
%123 = tail call i8* @malloc(i64 %122)
%124 = bitcast i8* %123 to double*
%125 = tail call i8* @malloc(i64 %122)
%126 = bitcast i8* %125 to double*
%127 = tail call i8* @malloc(i64 %122)
%128 = bitcast i8* %127 to double*
%129 = tail call i8* @malloc(i64 %113)
%130 = bitcast i8* %129 to double*
br i1 %30, label %131, label %133
131: ; preds = %112
%132 = tail call i8* @malloc(i64 0)
br label %687
133: ; preds = %112
%134 = getelementptr inbounds double, double* %3, i64 3
%135 = getelementptr inbounds double, double* %3, i64 6
%136 = getelementptr inbounds double, double* %3, i64 1
%137 = getelementptr inbounds double, double* %3, i64 4
%138 = getelementptr inbounds double, double* %3, i64 7
%139 = bitcast double* %136 to <2 x double>*
%140 = bitcast double* %137 to <2 x double>*
%141 = bitcast double* %138 to <2 x double>*
br label %142
142: ; preds = %133, %214
%143 = phi i64 [ 0, %133 ], [ %216, %214 ]
%144 = phi i32 [ 0, %133 ], [ %200, %214 ]
%145 = phi i32 [ 0, %133 ], [ %215, %214 ]
%146 = getelementptr inbounds i8, i8* %29, i64 %143
%147 = load i8, i8* %146
%148 = icmp eq i8 %147, 0
br i1 %148, label %199, label %149
149: ; preds = %142
%150 = mul i32 %144, 6
%151 = zext i32 %150 to i64
%152 = getelementptr inbounds double, double* %124, i64 %151
%153 = bitcast double* %152 to i8*
%154 = trunc i64 %143 to i32
%155 = mul i32 %154, 6
%156 = zext i32 %155 to i64
%157 = getelementptr inbounds double, double* %0, i64 %156
%158 = bitcast double* %157 to i8*
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 dereferenceable(48) %153, i8* align 8 dereferenceable(48) %158, i64 48, i1 false)
%159 = getelementptr inbounds double, double* %126, i64 %151
%160 = bitcast double* %159 to i8*
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 dereferenceable(24) %160, i8* align 8 dereferenceable(24) %158, i64 24, i1 false)
%161 = load double, double* %3
%162 = add i32 %155, 3
%163 = zext i32 %162 to i64
%164 = getelementptr inbounds double, double* %0, i64 %163
%165 = load double, double* %164
%166 = load double, double* %134
%167 = add i32 %155, 4
%168 = zext i32 %167 to i64
%169 = getelementptr inbounds double, double* %0, i64 %168
%170 = load double, double* %169
%171 = fmul double %166, %170
%172 = tail call double @llvm.fmuladd.f64(double %161, double %165, double %171)
%173 = load double, double* %135
%174 = add i32 %155, 5
%175 = zext i32 %174 to i64
%176 = getelementptr inbounds double, double* %0, i64 %175
%177 = load double, double* %176
%178 = tail call double @llvm.fmuladd.f64(double %173, double %177, double %172)
%179 = add i32 %150, 3
%180 = zext i32 %179 to i64
%181 = getelementptr inbounds double, double* %126, i64 %180
store double %178, double* %181
%182 = add i32 %150, 4
%183 = zext i32 %182 to i64
%184 = getelementptr inbounds double, double* %126, i64 %183
%185 = load <2 x double>, <2 x double>* %139
%186 = load <2 x double>, <2 x double>* %140
%187 = insertelement <2 x double> poison, double %170, i64 0
%188 = shufflevector <2 x double> %187, <2 x double> poison, <2 x i32> zeroinitializer
%189 = fmul <2 x double> %188, %186
%190 = insertelement <2 x double> poison, double %165, i64 0
%191 = shufflevector <2 x double> %190, <2 x double> poison, <2 x i32> zeroinitializer
%192 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %185, <2 x double> %191, <2 x double> %189)
%193 = load <2 x double>, <2 x double>* %141
%194 = insertelement <2 x double> poison, double %177, i64 0
%195 = shufflevector <2 x double> %194, <2 x double> poison, <2 x i32> zeroinitializer
%196 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %193, <2 x double> %195, <2 x double> %192)
%197 = bitcast double* %184 to <2 x double>*
store <2 x double> %196, <2 x double>* %197
%198 = add i32 %144, 1
br label %199
199: ; preds = %149, %142
%200 = phi i32 [ %198, %149 ], [ %144, %142 ]
%201 = getelementptr inbounds i8, i8* %1, i64 %143
%202 = load i8, i8* %201
%203 = icmp eq i8 %202, 0
br i1 %203, label %214, label %204
204: ; preds = %199
%205 = mul i32 %145, 6
%206 = zext i32 %205 to i64
%207 = getelementptr inbounds double, double* %130, i64 %206
%208 = bitcast double* %207 to i8*
%209 = mul i64 %143, 6
%210 = and i64 %209, 4294967294
%211 = getelementptr inbounds double, double* %0, i64 %210
%212 = bitcast double* %211 to i8*
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 dereferenceable(48) %208, i8* align 8 dereferenceable(48) %212, i64 48, i1 false)
%213 = add i32 %145, 1
br label %214
214: ; preds = %199, %204
%215 = phi i32 [ %213, %204 ], [ %145, %199 ]
%216 = add nuw nsw i64 %143, 1
%217 = icmp eq i64 %216, %23
br i1 %217, label %218, label %142
218: ; preds = %214
%219 = zext i32 %200 to i64
%220 = shl nuw nsw i64 %219, 2
%221 = tail call i8* @malloc(i64 %220)
%222 = bitcast i8* %221 to i32*
%223 = icmp eq i32 %200, 0
br i1 %223, label %687, label %224
224: ; preds = %218
%225 = icmp ult i32 %200, 8
br i1 %225, label %288, label %226
226: ; preds = %224
%227 = and i64 %219, 4294967288
%228 = add nsw i64 %227, -8
%229 = lshr exact i64 %228, 3
%230 = add nuw nsw i64 %229, 1
%231 = and i64 %230, 3
%232 = icmp ult i64 %228, 24
br i1 %232, label %269, label %233
233: ; preds = %226
%234 = and i64 %230, 4611686018427387900
br label %235
235: ; preds = %235, %233
%236 = phi i64 [ 0, %233 ], [ %265, %235 ]
%237 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %233 ], [ %266, %235 ]
%238 = phi i64 [ 0, %233 ], [ %267, %235 ]
%239 = add <4 x i32> %237, <i32 4, i32 4, i32 4, i32 4>
%240 = getelementptr inbounds i32, i32* %222, i64 %236
%241 = bitcast i32* %240 to <4 x i32>*
store <4 x i32> %237, <4 x i32>* %241
%242 = getelementptr inbounds i32, i32* %240, i64 4
%243 = bitcast i32* %242 to <4 x i32>*
store <4 x i32> %239, <4 x i32>* %243
%244 = or i64 %236, 8
%245 = add <4 x i32> %237, <i32 8, i32 8, i32 8, i32 8>
%246 = add <4 x i32> %237, <i32 12, i32 12, i32 12, i32 12>
%247 = getelementptr inbounds i32, i32* %222, i64 %244
%248 = bitcast i32* %247 to <4 x i32>*
store <4 x i32> %245, <4 x i32>* %248
%249 = getelementptr inbounds i32, i32* %247, i64 4
%250 = bitcast i32* %249 to <4 x i32>*
store <4 x i32> %246, <4 x i32>* %250
%251 = or i64 %236, 16
%252 = add <4 x i32> %237, <i32 16, i32 16, i32 16, i32 16>
%253 = add <4 x i32> %237, <i32 20, i32 20, i32 20, i32 20>
%254 = getelementptr inbounds i32, i32* %222, i64 %251
%255 = bitcast i32* %254 to <4 x i32>*
store <4 x i32> %252, <4 x i32>* %255
%256 = getelementptr inbounds i32, i32* %254, i64 4
%257 = bitcast i32* %256 to <4 x i32>*
store <4 x i32> %253, <4 x i32>* %257
%258 = or i64 %236, 24
%259 = add <4 x i32> %237, <i32 24, i32 24, i32 24, i32 24>
%260 = add <4 x i32> %237, <i32 28, i32 28, i32 28, i32 28>
%261 = getelementptr inbounds i32, i32* %222, i64 %258
%262 = bitcast i32* %261 to <4 x i32>*
store <4 x i32> %259, <4 x i32>* %262
%263 = getelementptr inbounds i32, i32* %261, i64 4
%264 = bitcast i32* %263 to <4 x i32>*
store <4 x i32> %260, <4 x i32>* %264
%265 = add nuw i64 %236, 32
%266 = add <4 x i32> %237, <i32 32, i32 32, i32 32, i32 32>
%267 = add i64 %238, 4
%268 = icmp eq i64 %267, %234
br i1 %268, label %269, label %235
269: ; preds = %235, %226
%270 = phi i64 [ 0, %226 ], [ %265, %235 ]
%271 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %226 ], [ %266, %235 ]
%272 = icmp eq i64 %231, 0
br i1 %272, label %286, label %273
273: ; preds = %269, %273
%274 = phi i64 [ %282, %273 ], [ %270, %269 ]
%275 = phi <4 x i32> [ %283, %273 ], [ %271, %269 ]
%276 = phi i64 [ %284, %273 ], [ 0, %269 ]
%277 = add <4 x i32> %275, <i32 4, i32 4, i32 4, i32 4>
%278 = getelementptr inbounds i32, i32* %222, i64 %274
%279 = bitcast i32* %278 to <4 x i32>*
store <4 x i32> %275, <4 x i32>* %279
%280 = getelementptr inbounds i32, i32* %278, i64 4
%281 = bitcast i32* %280 to <4 x i32>*
store <4 x i32> %277, <4 x i32>* %281
%282 = add nuw i64 %274, 8
%283 = add <4 x i32> %275, <i32 8, i32 8, i32 8, i32 8>
%284 = add i64 %276, 1
%285 = icmp eq i64 %284, %231
br i1 %285, label %286, label %273
286: ; preds = %273, %269
%287 = icmp eq i64 %227, %219
br i1 %287, label %296, label %288
288: ; preds = %224, %286
%289 = phi i64 [ 0, %224 ], [ %227, %286 ]
br label %290
290: ; preds = %288, %290
%291 = phi i64 [ %294, %290 ], [ %289, %288 ]
%292 = getelementptr inbounds i32, i32* %222, i64 %291
%293 = trunc i64 %291 to i32
store i32 %293, i32* %292
%294 = add nuw nsw i64 %291, 1
%295 = icmp eq i64 %294, %219
br i1 %295, label %296, label %290
296: ; preds = %290, %286
%297 = icmp ult i32 %200, 4
%298 = icmp ult i32 %215, 6
%299 = select i1 %297, i1 true, i1 %298
br i1 %299, label %687, label %300
300: ; preds = %296
%301 = getelementptr inbounds [3 x double], [3 x double]* %10, i64 0, i64 0
%302 = getelementptr inbounds [3 x double], [3 x double]* %11, i64 0, i64 0
%303 = getelementptr inbounds i32, i32* %222, i64 1
%304 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 0
%305 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 1
%306 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 2
%307 = getelementptr inbounds [9 x double], [9 x double]* %12, i64 0, i64 0
%308 = getelementptr inbounds [9 x double], [9 x double]* %15, i64 0, i64 0
%309 = getelementptr inbounds [9 x double], [9 x double]* %13, i64 0, i64 0
%310 = fmul double %2, 2.000000e+00
%311 = getelementptr inbounds [9 x double], [9 x double]* %14, i64 0, i64 0
%312 = bitcast double* %5 to i8*
%313 = add i32 %200, -1
%314 = add i32 %200, -2
%315 = and i64 %219, 4294967292
%316 = add nsw i64 %315, -4
%317 = lshr exact i64 %316, 2
%318 = add nuw nsw i64 %317, 1
%319 = and i64 %23, 4294967288
%320 = add nsw i64 %319, -8
%321 = lshr exact i64 %320, 3
%322 = add nuw nsw i64 %321, 1
%323 = bitcast [3 x double]* %9 to <2 x double>*
%324 = bitcast [3 x double]* %9 to <2 x double>*
%325 = icmp ult i32 %200, 4
%326 = and i64 %219, 4294967292
%327 = insertelement <2 x double> poison, double %310, i64 0
%328 = shufflevector <2 x double> %327, <2 x double> poison, <2 x i32> zeroinitializer
%329 = insertelement <2 x double> poison, double %310, i64 0
%330 = shufflevector <2 x double> %329, <2 x double> poison, <2 x i32> zeroinitializer
%331 = and i64 %318, 1
%332 = icmp eq i64 %316, 0
%333 = and i64 %318, 9223372036854775806
%334 = icmp eq i64 %331, 0
%335 = icmp eq i64 %326, %219
%336 = and i64 %219, 1
%337 = icmp eq i32 %200, 1
%338 = and i64 %219, 4294967294
%339 = icmp eq i64 %336, 0
%340 = icmp ult i32 %4, 8
%341 = and i64 %23, 4294967288
%342 = and i64 %322, 1
%343 = icmp eq i64 %320, 0
%344 = and i64 %322, 4611686018427387902
%345 = icmp eq i64 %342, 0
%346 = icmp eq i64 %341, %23
%347 = and i64 %23, 1
%348 = icmp eq i32 %4, 1
%349 = and i64 %23, 4294967294
%350 = icmp eq i64 %347, 0
br label %351
351: ; preds = %680, %300
%352 = phi i32 [ 1, %300 ], [ %684, %680 ]
%353 = phi i32 [ 3, %300 ], [ %683, %680 ]
%354 = phi i32 [ 4, %300 ], [ %682, %680 ]
%355 = phi i32 [ 10000, %300 ], [ %681, %680 ]
%356 = call i32 (...) @rand()
%357 = urem i32 %356, %313
%358 = add nuw i32 %357, 1
%359 = load i32, i32* %222
%360 = zext i32 %358 to i64
%361 = getelementptr inbounds i32, i32* %222, i64 %360
%362 = load i32, i32* %361
store i32 %362, i32* %222
store i32 %359, i32* %361
%363 = call i32 (...) @rand()
%364 = urem i32 %363, %314
%365 = add i32 %364, 2
%366 = load i32, i32* %303
%367 = zext i32 %365 to i64
%368 = getelementptr inbounds i32, i32* %222, i64 %367
%369 = load i32, i32* %368
store i32 %369, i32* %303
store i32 %366, i32* %368
%370 = load i32, i32* %222
%371 = mul i32 %370, 6
%372 = zext i32 %371 to i64
%373 = getelementptr inbounds double, double* %126, i64 %372
%374 = getelementptr inbounds double, double* %373, i64 3
%375 = call i32 (double*, double*, double*, ...) bitcast (i32 (...)* @crossp to i32 (double*, double*, double*, ...)*)(double* %301, double* %373, double* %374)
%376 = load i32, i32* %303
%377 = mul i32 %376, 6
%378 = zext i32 %377 to i64
%379 = getelementptr inbounds double, double* %126, i64 %378
%380 = getelementptr inbounds double, double* %379, i64 3
%381 = call i32 (double*, double*, double*, ...) bitcast (i32 (...)* @crossp to i32 (double*, double*, double*, ...)*)(double* %302, double* %379, double* %380)
%382 = call i32 (double*, double*, double*, ...) bitcast (i32 (...)* @crossp to i32 (double*, double*, double*, ...)*)(double* %304, double* %301, double* %302)
%383 = load double, double* %304
%384 = load double, double* %305
%385 = fmul double %384, %384
%386 = call double @llvm.fmuladd.f64(double %383, double %383, double %385)
%387 = load double, double* %306
%388 = call double @llvm.fmuladd.f64(double %387, double %387, double %386)
%389 = call double @sqrt(double %388)
%390 = load <2 x double>, <2 x double>* %323
%391 = insertelement <2 x double> poison, double %389, i64 0
%392 = shufflevector <2 x double> %391, <2 x double> poison, <2 x i32> zeroinitializer
%393 = fdiv <2 x double> %390, %392
store <2 x double> %393, <2 x double>* %324
%394 = load double, double* %306
%395 = fdiv double %394, %389
store double %395, double* %306
%396 = call i32 (double*, double*, ...) bitcast (i32 (...)* @skew_sym to i32 (double*, double*, ...)*)(double* %304, double* %307)
%397 = call i32 (double*, double*, i32, i32, ...) bitcast (i32 (...)* @mattr to i32 (double*, double*, i32, i32, ...)*)(double* %308, double* %3, i32 3, i32 3)
%398 = call i32 (double*, double*, double*, i32, ...) bitcast (i32 (...)* @mmul to i32 (double*, double*, double*, i32, ...)*)(double* %309, double* %307, double* %308, i32 3)
%399 = call i32 (double*, double*, i32, i32, ...) bitcast (i32 (...)* @mattr to i32 (double*, double*, i32, i32, ...)*)(double* %307, double* %309, i32 3, i32 3)
%400 = call i32 (double*, double*, double*, i32, ...) bitcast (i32 (...)* @FDs to i32 (double*, double*, double*, i32, ...)*)(double* %124, double* %307, double* %118, i32 %200)
br i1 %325, label %477, label %401
401: ; preds = %351
br i1 %332, label %447, label %402
402: ; preds = %401, %402
%403 = phi i64 [ %444, %402 ], [ 0, %401 ]
%404 = phi <2 x i32> [ %438, %402 ], [ zeroinitializer, %401 ]
%405 = phi <2 x i32> [ %439, %402 ], [ zeroinitializer, %401 ]
%406 = phi i64 [ %445, %402 ], [ 0, %401 ]
%407 = getelementptr inbounds double, double* %118, i64 %403
%408 = bitcast double* %407 to <2 x double>*
%409 = load <2 x double>, <2 x double>* %408
%410 = getelementptr inbounds double, double* %407, i64 2
%411 = bitcast double* %410 to <2 x double>*
%412 = load <2 x double>, <2 x double>* %411
%413 = fcmp olt <2 x double> %409, %328
%414 = fcmp olt <2 x double> %412, %330
%415 = zext <2 x i1> %413 to <2 x i8>
%416 = zext <2 x i1> %414 to <2 x i8>
%417 = zext <2 x i1> %413 to <2 x i32>
%418 = zext <2 x i1> %414 to <2 x i32>
%419 = add <2 x i32> %404, %417
%420 = add <2 x i32> %405, %418
%421 = getelementptr inbounds i8, i8* %119, i64 %403
%422 = bitcast i8* %421 to <2 x i8>*
store <2 x i8> %415, <2 x i8>* %422
%423 = getelementptr inbounds i8, i8* %421, i64 2
%424 = bitcast i8* %423 to <2 x i8>*
store <2 x i8> %416, <2 x i8>* %424
%425 = or i64 %403, 4
%426 = getelementptr inbounds double, double* %118, i64 %425
%427 = bitcast double* %426 to <2 x double>*
%428 = load <2 x double>, <2 x double>* %427
%429 = getelementptr inbounds double, double* %426, i64 2
%430 = bitcast double* %429 to <2 x double>*
%431 = load <2 x double>, <2 x double>* %430
%432 = fcmp olt <2 x double> %428, %328
%433 = fcmp olt <2 x double> %431, %330
%434 = zext <2 x i1> %432 to <2 x i8>
%435 = zext <2 x i1> %433 to <2 x i8>
%436 = zext <2 x i1> %432 to <2 x i32>
%437 = zext <2 x i1> %433 to <2 x i32>
%438 = add <2 x i32> %419, %436
%439 = add <2 x i32> %420, %437
%440 = getelementptr inbounds i8, i8* %119, i64 %425
%441 = bitcast i8* %440 to <2 x i8>*
store <2 x i8> %434, <2 x i8>* %441
%442 = getelementptr inbounds i8, i8* %440, i64 2
%443 = bitcast i8* %442 to <2 x i8>*
store <2 x i8> %435, <2 x i8>* %443
%444 = add nuw i64 %403, 8
%445 = add i64 %406, 2
%446 = icmp eq i64 %445, %333
br i1 %446, label %447, label %402
447: ; preds = %402, %401
%448 = phi <2 x i32> [ undef, %401 ], [ %438, %402 ]
%449 = phi <2 x i32> [ undef, %401 ], [ %439, %402 ]
%450 = phi i64 [ 0, %401 ], [ %444, %402 ]
%451 = phi <2 x i32> [ zeroinitializer, %401 ], [ %438, %402 ]
%452 = phi <2 x i32> [ zeroinitializer, %401 ], [ %439, %402 ]
br i1 %334, label %472, label %453
453: ; preds = %447
%454 = getelementptr inbounds double, double* %118, i64 %450
%455 = bitcast double* %454 to <2 x double>*
%456 = load <2 x double>, <2 x double>* %455
%457 = getelementptr inbounds double, double* %454, i64 2
%458 = bitcast double* %457 to <2 x double>*
%459 = load <2 x double>, <2 x double>* %458
%460 = fcmp olt <2 x double> %456, %328
%461 = fcmp olt <2 x double> %459, %330
%462 = zext <2 x i1> %460 to <2 x i8>
%463 = zext <2 x i1> %461 to <2 x i8>
%464 = zext <2 x i1> %460 to <2 x i32>
%465 = zext <2 x i1> %461 to <2 x i32>
%466 = add <2 x i32> %451, %464
%467 = add <2 x i32> %452, %465
%468 = getelementptr inbounds i8, i8* %119, i64 %450
%469 = bitcast i8* %468 to <2 x i8>*
store <2 x i8> %462, <2 x i8>* %469
%470 = getelementptr inbounds i8, i8* %468, i64 2
%471 = bitcast i8* %470 to <2 x i8>*
store <2 x i8> %463, <2 x i8>* %471
br label %472
472: ; preds = %447, %453
%473 = phi <2 x i32> [ %448, %447 ], [ %466, %453 ]
%474 = phi <2 x i32> [ %449, %447 ], [ %467, %453 ]
%475 = add <2 x i32> %474, %473
%476 = call i32 @llvm.vector.reduce.add.v2i32(<2 x i32> %475)
br i1 %335, label %492, label %477
477: ; preds = %351, %472
%478 = phi i64 [ 0, %351 ], [ %326, %472 ]
%479 = phi i32 [ 0, %351 ], [ %476, %472 ]
br label %480
480: ; preds = %477, %480
%481 = phi i64 [ %490, %480 ], [ %478, %477 ]
%482 = phi i32 [ %488, %480 ], [ %479, %477 ]
%483 = getelementptr inbounds double, double* %118, i64 %481
%484 = load double, double* %483
%485 = fcmp olt double %484, %310
%486 = zext i1 %485 to i8
%487 = zext i1 %485 to i32
%488 = add i32 %482, %487
%489 = getelementptr inbounds i8, i8* %119, i64 %481
store i8 %486, i8* %489
%490 = add nuw nsw i64 %481, 1
%491 = icmp eq i64 %490, %219
br i1 %491, label %492, label %480
492: ; preds = %480, %472
%493 = phi i32 [ %476, %472 ], [ %488, %480 ]
%494 = icmp ugt i32 %493, %354
br i1 %494, label %495, label %680
495: ; preds = %492
br i1 %337, label %534, label %496
496: ; preds = %495, %529
%497 = phi i64 [ %531, %529 ], [ 0, %495 ]
%498 = phi i32 [ %530, %529 ], [ 0, %495 ]
%499 = phi i64 [ %532, %529 ], [ 0, %495 ]
%500 = getelementptr inbounds i8, i8* %119, i64 %497
%501 = load i8, i8* %500
%502 = icmp eq i8 %501, 0
br i1 %502, label %513, label %503
503: ; preds = %496
%504 = mul i32 %498, 6
%505 = zext i32 %504 to i64
%506 = getelementptr inbounds double, double* %128, i64 %505
%507 = bitcast double* %506 to i8*
%508 = mul i64 %497, 6
%509 = and i64 %508, 4294967292
%510 = getelementptr inbounds double, double* %124, i64 %509
%511 = bitcast double* %510 to i8*
%512 = add i32 %498, 1
br label %513
513: ; preds = %496, %503
%514 = phi i32 [ %512, %503 ], [ %498, %496 ]
%515 = or i64 %497, 1
%516 = getelementptr inbounds i8, i8* %119, i64 %515
%517 = load i8, i8* %516
%518 = icmp eq i8 %517, 0
br i1 %518, label %529, label %519
519: ; preds = %513
%520 = mul i32 %514, 6
%521 = zext i32 %520 to i64
%522 = getelementptr inbounds double, double* %128, i64 %521
%523 = bitcast double* %522 to i8*
%524 = mul i64 %515, 6
%525 = and i64 %524, 4294967294
%526 = getelementptr inbounds double, double* %124, i64 %525
%527 = bitcast double* %526 to i8*
%528 = add i32 %514, 1
br label %529
529: ; preds = %519, %513
%530 = phi i32 [ %528, %519 ], [ %514, %513 ]
%531 = add nuw nsw i64 %497, 2
%532 = add i64 %499, 2
%533 = icmp eq i64 %532, %338
br i1 %533, label %534, label %496
534: ; preds = %529, %495
%535 = phi i32 [ undef, %495 ], [ %530, %529 ]
%536 = phi i64 [ 0, %495 ], [ %531, %529 ]
%537 = phi i32 [ 0, %495 ], [ %530, %529 ]
br i1 %339, label %552, label %538
538: ; preds = %534
%539 = getelementptr inbounds i8, i8* %119, i64 %536
%540 = load i8, i8* %539
%541 = icmp eq i8 %540, 0
br i1 %541, label %552, label %542
542: ; preds = %538
%543 = mul i32 %537, 6
%544 = zext i32 %543 to i64
%545 = getelementptr inbounds double, double* %128, i64 %544
%546 = bitcast double* %545 to i8*
%547 = mul i64 %536, 6
%548 = and i64 %547, 4294967294
%549 = getelementptr inbounds double, double* %124, i64 %548
%550 = bitcast double* %549 to i8*
%551 = add i32 %537, 1
br label %552
552: ; preds = %538, %542, %534
%553 = phi i32 [ %535, %534 ], [ %551, %542 ], [ %537, %538 ]
%554 = call i32 (double*, i32, double*, i32, double*, i32, double, i32, i32, i32, double*, i8*, ...) bitcast (i32 (...)* @innerFH to i32 (double*, i32, double*, i32, double*, i32, double, i32, i32, i32, double*, i8*, ...)*)(double* %130, i32 %215, double* %128, i32 %553, double* %0, i32 %4, double %2, i32 15, i32 6, i32 4, double* %311, i8* %24)
br i1 %30, label %680, label %555
555: ; preds = %552
br i1 %340, label %614, label %556
556: ; preds = %555
br i1 %343, label %590, label %557
557: ; preds = %556, %557
%558 = phi i64 [ %587, %557 ], [ 0, %556 ]
%559 = phi <4 x i32> [ %585, %557 ], [ zeroinitializer, %556 ]
%560 = phi <4 x i32> [ %586, %557 ], [ zeroinitializer, %556 ]
%561 = phi i64 [ %588, %557 ], [ 0, %556 ]
%562 = getelementptr inbounds i8, i8* %24, i64 %558
%563 = bitcast i8* %562 to <4 x i8>*
%564 = load <4 x i8>, <4 x i8>* %563
%565 = getelementptr inbounds i8, i8* %562, i64 4
%566 = bitcast i8* %565 to <4 x i8>*
%567 = load <4 x i8>, <4 x i8>* %566
%568 = icmp ne <4 x i8> %564, zeroinitializer
%569 = icmp ne <4 x i8> %567, zeroinitializer
%570 = zext <4 x i1> %568 to <4 x i32>
%571 = zext <4 x i1> %569 to <4 x i32>
%572 = add <4 x i32> %559, %570
%573 = add <4 x i32> %560, %571
%574 = or i64 %558, 8
%575 = getelementptr inbounds i8, i8* %24, i64 %574
%576 = bitcast i8* %575 to <4 x i8>*
%577 = load <4 x i8>, <4 x i8>* %576
%578 = getelementptr inbounds i8, i8* %575, i64 4
%579 = bitcast i8* %578 to <4 x i8>*
%580 = load <4 x i8>, <4 x i8>* %579
%581 = icmp ne <4 x i8> %577, zeroinitializer
%582 = icmp ne <4 x i8> %580, zeroinitializer
%583 = zext <4 x i1> %581 to <4 x i32>
%584 = zext <4 x i1> %582 to <4 x i32>
%585 = add <4 x i32> %572, %583
%586 = add <4 x i32> %573, %584
%587 = add nuw i64 %558, 16
%588 = add i64 %561, 2
%589 = icmp eq i64 %588, %344
br i1 %589, label %590, label %557
590: ; preds = %557, %556
%591 = phi <4 x i32> [ undef, %556 ], [ %585, %557 ]
%592 = phi <4 x i32> [ undef, %556 ], [ %586, %557 ]
%593 = phi i64 [ 0, %556 ], [ %587, %557 ]
%594 = phi <4 x i32> [ zeroinitializer, %556 ], [ %585, %557 ]
%595 = phi <4 x i32> [ zeroinitializer, %556 ], [ %586, %557 ]
br i1 %345, label %609, label %596
596: ; preds = %590
%597 = getelementptr inbounds i8, i8* %24, i64 %593
%598 = bitcast i8* %597 to <4 x i8>*
%599 = load <4 x i8>, <4 x i8>* %598
%600 = getelementptr inbounds i8, i8* %597, i64 4
%601 = bitcast i8* %600 to <4 x i8>*
%602 = load <4 x i8>, <4 x i8>* %601
%603 = icmp ne <4 x i8> %599, zeroinitializer
%604 = icmp ne <4 x i8> %602, zeroinitializer
%605 = zext <4 x i1> %603 to <4 x i32>
%606 = zext <4 x i1> %604 to <4 x i32>
%607 = add <4 x i32> %594, %605
%608 = add <4 x i32> %595, %606
br label %609
609: ; preds = %590, %596
%610 = phi <4 x i32> [ %591, %590 ], [ %607, %596 ]
%611 = phi <4 x i32> [ %592, %590 ], [ %608, %596 ]
%612 = add <4 x i32> %611, %610
%613 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %612)
br i1 %346, label %627, label %614
614: ; preds = %555, %609
%615 = phi i64 [ 0, %555 ], [ %341, %609 ]
%616 = phi i32 [ 0, %555 ], [ %613, %609 ]
br label %617
617: ; preds = %614, %617
%618 = phi i64 [ %625, %617 ], [ %615, %614 ]
%619 = phi i32 [ %624, %617 ], [ %616, %614 ]
%620 = getelementptr inbounds i8, i8* %24, i64 %618
%621 = load i8, i8* %620
%622 = icmp ne i8 %621, 0
%623 = zext i1 %622 to i32
%624 = add i32 %619, %623
%625 = add nuw nsw i64 %618, 1
%626 = icmp eq i64 %625, %23
br i1 %626, label %627, label %617
627: ; preds = %617, %609
%628 = phi i32 [ %613, %609 ], [ %624, %617 ]
%629 = icmp ugt i32 %628, %353
br i1 %629, label %630, label %680
630: ; preds = %627
br i1 %30, label %676, label %631
631: ; preds = %630
br i1 %348, label %662, label %632
632: ; preds = %631, %657
%633 = phi i64 [ %659, %657 ], [ 0, %631 ]
%634 = phi i32 [ %658, %657 ], [ 0, %631 ]
%635 = phi i64 [ %660, %657 ], [ 0, %631 ]
%636 = getelementptr inbounds i8, i8* %24, i64 %633
%637 = load i8, i8* %636
%638 = icmp eq i8 %637, 0
br i1 %638, label %645, label %639
639: ; preds = %632
%640 = getelementptr inbounds i8, i8* %29, i64 %633
%641 = load i8, i8* %640
%642 = icmp ne i8 %641, 0
%643 = zext i1 %642 to i32
%644 = add i32 %634, %643
br label %645
645: ; preds = %639, %632
%646 = phi i32 [ %634, %632 ], [ %644, %639 ]
%647 = or i64 %633, 1
%648 = getelementptr inbounds i8, i8* %24, i64 %647
%649 = load i8, i8* %648
%650 = icmp eq i8 %649, 0
br i1 %650, label %657, label %651
651: ; preds = %645
%652 = getelementptr inbounds i8, i8* %29, i64 %647
%653 = load i8, i8* %652
%654 = icmp ne i8 %653, 0
%655 = zext i1 %654 to i32
%656 = add i32 %646, %655
br label %657
657: ; preds = %651, %645
%658 = phi i32 [ %646, %645 ], [ %656, %651 ]
%659 = add nuw nsw i64 %633, 2
%660 = add i64 %635, 2
%661 = icmp eq i64 %660, %349
br i1 %661, label %662, label %632
662: ; preds = %657, %631
%663 = phi i32 [ undef, %631 ], [ %658, %657 ]
%664 = phi i64 [ 0, %631 ], [ %659, %657 ]
%665 = phi i32 [ 0, %631 ], [ %658, %657 ]
br i1 %350, label %676, label %666
666: ; preds = %662
%667 = getelementptr inbounds i8, i8* %24, i64 %664
%668 = load i8, i8* %667
%669 = icmp eq i8 %668, 0
br i1 %669, label %676, label %670
670: ; preds = %666
%671 = getelementptr inbounds i8, i8* %29, i64 %664
%672 = load i8, i8* %671
%673 = icmp ne i8 %672, 0
%674 = zext i1 %673 to i32
%675 = add i32 %665, %674
br label %676
676: ; preds = %662, %670, %666, %630
%677 = phi i32 [ 0, %630 ], [ %663, %662 ], [ %665, %666 ], [ %675, %670 ]
%678 = call i32 (i32, i32, i32, double, ...) bitcast (i32 (...)* @nsamples to i32 (i32, i32, i32, double, ...)*)(i32 %677, i32 %200, i32 2, double 0x3FEFF7CED916872B)
%679 = call i32 (i32, i32, ...) bitcast (i32 (...)* @dmin to i32 (i32, i32, ...)*)(i32 %355, i32 %678)
br label %680
680: ; preds = %552, %492, %676, %627
%681 = phi i32 [ %679, %676 ], [ %355, %627 ], [ %355, %492 ], [ %355, %552 ]
%682 = phi i32 [ %553, %676 ], [ %553, %627 ], [ %354, %492 ], [ %553, %552 ]
%683 = phi i32 [ %628, %676 ], [ %353, %627 ], [ %353, %492 ], [ %353, %552 ]
%684 = add nuw i32 %352, 1
%685 = shl i32 %681, 1
%686 = icmp ult i32 %684, %685
br i1 %686, label %351, label %687
687: ; preds = %680, %218, %131, %296
%688 = phi i8* [ %221, %296 ], [ %221, %218 ], [ %132, %131 ], [ %221, %680 ]
%689 = phi i32 [ 0, %296 ], [ 0, %218 ], [ 0, %131 ], [ %683, %680 ]
ret i32 %689
}