void innerFH(double *uH, unsigned lenH, double *uO, unsigned lenO, double *u,
             unsigned len, double th, unsigned repCount, unsigned sam_sizH,
             unsigned sam_sizO, double *F, unsigned char *inl) {
  unsigned i, rep, max_i, max_s, no_i;
  double aF[3 * 3];
  unsigned char *v = (unsigned char *)malloc(len * sizeof(unsigned char));
  double *usam = (double *)malloc(6 * (sam_sizH + sam_sizO) * sizeof(double));
  double *Ds = (double *)malloc(len * sizeof(double));
  int *allInl = (int *)malloc((sam_sizH + sam_sizO) * sizeof(int));
  double *buffer = (double *)malloc(9 * (sam_sizH + sam_sizO) * sizeof(double));
  for (i = 0; i < sam_sizH + sam_sizO; ++i) {
    allInl[i] = i;
  }
  for (i = 0; i < 3 * 3; ++i) {
    F[i] = 1;
  }
  for (i = 0; i < len; ++i) {
    inl[i] = 0;
  }
  max_i = 0;
  max_s = 0;
  for (rep = 0; rep < repCount; ++rep) {
    dual_sample(uH, lenH, sam_sizH, uO, lenO, sam_sizO, usam);
    u2f(usam, allInl, sam_sizH + sam_sizO, aF, buffer);
    FDs(u, aF, Ds, len);
    no_i = 0;
    for (i = 0; i < len; ++i) {
      if (Ds[i] < th) {
        v[i] = 1;
        ++no_i;
      } else {
        v[i] = 0;
      }
    }
    if (max_i < no_i) {
      memcpy(inl, v, len * sizeof(unsigned char));
      memcpy(F, aF, 3 * 3 * sizeof(double));
      max_i = no_i;
    }
    if (no_i > max_s) {
      max_s = no_i;
      no_i = u2Fit(u, len, aF, v, th, th * 3, 4);
      if (max_i < no_i) {
        memcpy(inl, v, len * sizeof(unsigned char));
        memcpy(F, aF, 3 * 3 * sizeof(double));
        max_i = no_i;
      }
    }
  }
  free(usam);
  free(Ds);
  free(allInl);
  free(buffer);
  free(v);
}


x86 assembly (clang, -O0):
<innerFH>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movsd  %xmm0,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,%edi
shl    $0x0,%rdi
call   1060 <malloc@plt>
mov    %rax,-0xa8(%rbp)
mov    0x18(%rbp),%eax
add    0x20(%rbp),%eax
imul   $0x6,%eax,%eax
mov    %eax,%eax
mov    %eax,%edi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0xb0(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,%edi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0xb8(%rbp)
mov    0x18(%rbp),%eax
add    0x20(%rbp),%eax
mov    %eax,%eax
mov    %eax,%edi
shl    $0x2,%rdi
call   1060 <malloc@plt>
mov    %rax,-0xc0(%rbp)
mov    0x18(%rbp),%eax
add    0x20(%rbp),%eax
imul   $0x9,%eax,%eax
mov    %eax,%eax
mov    %eax,%edi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0xc8(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
cmp    %ecx,%eax
jae    125b <innerFH+0xeb>
mov    -0x3c(%rbp),%edx
mov    -0xc0(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    122c <innerFH+0xbc>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x9,-0x3c(%rbp)
jae    128e <innerFH+0x11e>
mov    0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movsd  0xd8d(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1262 <innerFH+0xf2>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    12ba <innerFH+0x14a>
mov    0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movb   $0x0,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1295 <innerFH+0x125>
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x10(%rbp),%eax
jae    149e <innerFH+0x32e>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    0x18(%rbp),%edx
mov    -0x18(%rbp),%rcx
mov    -0x1c(%rbp),%r8d
mov    0x20(%rbp),%r9d
mov    -0xb0(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1090 <dual_sample@plt>
mov    -0xb0(%rbp),%rdi
mov    -0xc0(%rbp),%rsi
mov    0x18(%rbp),%edx
add    0x20(%rbp),%edx
lea    -0xa0(%rbp),%rcx
mov    -0xc8(%rbp),%r8
mov    $0x0,%al
call   1040 <u2f@plt>
mov    -0x28(%rbp),%rdi
lea    -0xa0(%rbp),%rsi
mov    -0xb8(%rbp),%rdx
mov    -0x2c(%rbp),%ecx
mov    $0x0,%al
call   1070 <FDs@plt>
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    13bd <innerFH+0x24d>
mov    -0xb8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    139c <innerFH+0x22c>
mov    -0xa8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movb   $0x1,(%rax,%rcx,1)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    13aa <innerFH+0x23a>
mov    -0xa8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movb   $0x0,(%rax,%rcx,1)
jmp    13af <innerFH+0x23f>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1356 <innerFH+0x1e6>
mov    -0x44(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jae    13fd <innerFH+0x28d>
mov    0x30(%rbp),%rdi
mov    -0xa8(%rbp),%rsi
mov    -0x2c(%rbp),%eax
mov    %eax,%edx
shl    $0x0,%rdx
call   1050 <memcpy@plt>
mov    0x28(%rbp),%rdi
lea    -0xa0(%rbp),%rsi
mov    $0x48,%edx
call   1050 <memcpy@plt>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jbe    148b <innerFH+0x31b>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x28(%rbp),%rdi
mov    -0x2c(%rbp),%esi
lea    -0xa0(%rbp),%rdx
mov    -0xa8(%rbp),%rcx
movsd  -0x38(%rbp),%xmm0
movsd  0xbcf(%rip),%xmm1
mulsd  -0x38(%rbp),%xmm1
mov    $0x4,%r8d
mov    $0x2,%al
call   1080 <u2Fit@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jae    1486 <innerFH+0x316>
mov    0x30(%rbp),%rdi
mov    -0xa8(%rbp),%rsi
mov    -0x2c(%rbp),%eax
mov    %eax,%edx
shl    $0x0,%rdx
call   1050 <memcpy@plt>
mov    0x28(%rbp),%rdi
lea    -0xa0(%rbp),%rsi
mov    $0x48,%edx
call   1050 <memcpy@plt>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    148b <innerFH+0x31b>
jmp    1490 <innerFH+0x320>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    12cf <innerFH+0x15f>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<innerFH>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
movdqa %xmm0,0x40(%rsp)
mov    %r8,0x38(%rsp)
mov    %ecx,0x18(%rsp)
mov    %rdx,0x88(%rsp)
mov    %esi,0x14(%rsp)
mov    %rdi,0x80(%rsp)
mov    0x130(%rsp),%r14d
mov    0x128(%rsp),%r15d
mov    %r9d,0xc(%rsp)
mov    %r9d,%r12d
mov    %r12,%rdi
call   1070 <malloc@plt>
mov    %rax,%rbx
add    %r14d,%r15d
lea    (%r15,%r15,1),%eax
lea    (%rax,%rax,2),%edi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,0x30(%rsp)
lea    0x0(,%r12,8),%rdi
call   1070 <malloc@plt>
mov    %rax,%r14
lea    0x0(,%r15,4),%rdi
call   1070 <malloc@plt>
mov    %rax,%rbp
lea    (%r15,%r15,8),%edi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,0x20(%rsp)
test   %r15d,%r15d
je     139d <innerFH+0x21d>
cmp    $0x8,%r15d
jae    1237 <innerFH+0xb7>
xor    %eax,%eax
jmp    1390 <innerFH+0x210>
mov    %r15d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    1266 <innerFH+0xe6>
movdqa 0xda1(%rip),%xmm0
xor    %esi,%esi
jmp    1339 <innerFH+0x1b9>
and    $0xfffffffffffffffc,%rdx
movdqa 0xd8e(%rip),%xmm0
xor    %esi,%esi
movdqa 0xd93(%rip),%xmm8
movdqa 0xd9a(%rip),%xmm9
movdqa 0xda1(%rip),%xmm10
movdqa 0xda9(%rip),%xmm4
movdqa 0xdb1(%rip),%xmm5
movdqa 0xdb9(%rip),%xmm6
movdqa 0xdc1(%rip),%xmm7
movdqa 0xdc9(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,0x0(%rbp,%rsi,4)
movdqu %xmm2,0x10(%rbp,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rbp,%rsi,4)
movdqu %xmm3,0x30(%rbp,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rbp,%rsi,4)
movdqu %xmm3,0x50(%rbp,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rbp,%rsi,4)
movdqu %xmm3,0x70(%rbp,%rsi,4)
add    $0x20,%rsi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rdx
jne    12c0 <innerFH+0x140>
test   %rcx,%rcx
je     1380 <innerFH+0x200>
lea    0x10(,%rsi,4),%rdx
add    %rbp,%rdx
shl    $0x5,%rcx
xor    %esi,%esi
movdqa 0xcb9(%rip),%xmm1
movdqa 0xcc1(%rip),%xmm2
nop
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,%rcx
jne    1360 <innerFH+0x1e0>
cmp    %r15,%rax
je     139d <innerFH+0x21d>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %eax,0x0(%rbp,%rax,4)
add    $0x1,%rax
cmp    %rax,%r15
jne    1390 <innerFH+0x210>
mov    %rbp,0x28(%rsp)
mov    0x140(%rsp),%rdi
movaps 0xcdf(%rip),%xmm0
mov    0x138(%rsp),%rcx
movups %xmm0,(%rcx)
movups %xmm0,0x10(%rcx)
movups %xmm0,0x20(%rcx)
movups %xmm0,0x30(%rcx)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x40(%rcx)
cmpl   $0x0,0xc(%rsp)
je     13e7 <innerFH+0x267>
xor    %esi,%esi
mov    %r12,%rdx
call   1040 <memset@plt>
cmpl   $0x0,0x120(%rsp)
movapd 0x40(%rsp),%xmm0
je     185a <innerFH+0x6da>
movsd  0xcad(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x70(%rsp)
mov    %r12d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x68(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x60(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
unpcklpd %xmm0,%xmm0
mov    %rcx,%rax
mov    %rcx,0x58(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x50(%rsp)
xor    %eax,%eax
xor    %ecx,%ecx
xor    %r13d,%r13d
mov    %r15,0x78(%rsp)
movapd %xmm0,0x90(%rsp)
jmp    147f <innerFH+0x2ff>
nopl   0x0(%rax,%rax,1)
mov    %r13d,%r15d
mov    0x10(%rsp),%eax
add    $0x1,%eax
mov    %r15d,%r13d
cmp    0x120(%rsp),%eax
mov    0x78(%rsp),%r15
je     185a <innerFH+0x6da>
mov    %ecx,0x1c(%rsp)
mov    %eax,0x10(%rsp)
mov    0x30(%rsp),%rbp
mov    %rbp,(%rsp)
mov    0x80(%rsp),%rdi
mov    0x14(%rsp),%esi
mov    0x128(%rsp),%edx
mov    0x88(%rsp),%rcx
mov    0x18(%rsp),%r8d
mov    0x130(%rsp),%r9d
xor    %eax,%eax
call   10a0 <dual_sample@plt>
mov    %rbp,%rdi
mov    0x28(%rsp),%rsi
mov    %r15d,%edx
lea    0xa0(%rsp),%rbp
mov    %rbp,%rcx
mov    0x20(%rsp),%r8
xor    %eax,%eax
call   1050 <u2f@plt>
mov    0x38(%rsp),%rdi
mov    %rbp,%rsi
mov    %r14,%rdx
mov    0xc(%rsp),%ebp
mov    %ebp,%ecx
xor    %eax,%eax
call   1080 <FDs@plt>
movapd 0x40(%rsp),%xmm0
mov    $0x0,%r15d
test   %ebp,%ebp
je     171b <innerFH+0x59b>
cmpl   $0x4,0xc(%rsp)
jae    1520 <innerFH+0x3a0>
xor    %eax,%eax
xor    %r15d,%r15d
jmp    1700 <innerFH+0x580>
xchg   %ax,%ax
cmpq   $0x0,0x60(%rsp)
je     182e <innerFH+0x6ae>
pxor   %xmm6,%xmm6
mov    0x50(%rsp),%rcx
xor    %eax,%eax
xorpd  %xmm1,%xmm1
movapd 0x90(%rsp),%xmm7
movdqa 0xb53(%rip),%xmm8
nopl   (%rax)
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   %xmm8,%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   %xmm8,%xmm5
shufps $0xe8,%xmm3,%xmm3
psubd  %xmm3,%xmm6
shufps $0xe8,%xmm2,%xmm2
psubd  %xmm2,%xmm1
movd   %xmm4,%edx
mov    %dx,(%rbx,%rax,1)
movd   %xmm5,%edx
mov    %dx,0x2(%rbx,%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   %xmm8,%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   %xmm8,%xmm5
shufps $0xe8,%xmm3,%xmm3
psubd  %xmm3,%xmm6
shufps $0xe8,%xmm2,%xmm2
psubd  %xmm2,%xmm1
movd   %xmm4,%edx
mov    %dx,0x4(%rbx,%rax,1)
movd   %xmm5,%edx
mov    %dx,0x6(%rbx,%rax,1)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1550 <innerFH+0x3d0>
testb  $0x1,0x58(%rsp)
je     16e1 <innerFH+0x561>
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   %xmm8,%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   %xmm8,%xmm5
shufps $0xe8,%xmm3,%xmm3
psubd  %xmm3,%xmm6
shufps $0xe8,%xmm2,%xmm2
psubd  %xmm2,%xmm1
movd   %xmm4,%ecx
mov    %cx,(%rbx,%rax,1)
movd   %xmm5,%ecx
mov    %cx,0x2(%rbx,%rax,1)
paddd  %xmm1,%xmm6
pshufd $0x55,%xmm6,%xmm1
paddd  %xmm6,%xmm1
movd   %xmm1,%r15d
mov    0x68(%rsp),%rcx
mov    %rcx,%rax
cmp    %r12,%rcx
je     171b <innerFH+0x59b>
xor    %ecx,%ecx
ucomisd (%r14,%rax,8),%xmm0
seta   %cl
seta   (%rbx,%rax,1)
add    %ecx,%r15d
add    $0x1,%rax
cmp    %rax,%r12
jne    1700 <innerFH+0x580>
mov    0x1c(%rsp),%ecx
cmp    %r15d,%ecx
jae    178b <innerFH+0x60b>
mov    0x140(%rsp),%rdi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1060 <memcpy@plt>
movapd 0x40(%rsp),%xmm0
movdqa 0xa0(%rsp),%xmm4
movapd 0xb0(%rsp),%xmm1
movdqa 0xc0(%rsp),%xmm2
movdqa 0xd0(%rsp),%xmm3
mov    0x138(%rsp),%rcx
movdqu %xmm4,(%rcx)
movupd %xmm1,0x10(%rcx)
movdqu %xmm2,0x20(%rcx)
movdqu %xmm3,0x30(%rcx)
mov    0xe0(%rsp),%rax
mov    %rax,0x40(%rcx)
mov    %r15d,%ecx
cmp    %r13d,%r15d
jbe    1460 <innerFH+0x2e0>
mov    0x38(%rsp),%rdi
mov    0xc(%rsp),%esi
lea    0xa0(%rsp),%rdx
mov    %ecx,%ebp
mov    %rbx,%rcx
movsd  0x70(%rsp),%xmm1
mov    $0x4,%r8d
mov    $0x2,%al
call   1090 <u2Fit@plt>
mov    %ebp,%ecx
cmp    %eax,%ebp
jae    1463 <innerFH+0x2e3>
mov    %eax,%ebp
mov    0x140(%rsp),%rdi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1060 <memcpy@plt>
movapd 0xa0(%rsp),%xmm0
movapd 0xb0(%rsp),%xmm1
movdqa 0xc0(%rsp),%xmm2
movdqa 0xd0(%rsp),%xmm3
mov    0x138(%rsp),%rcx
movupd %xmm0,(%rcx)
movupd %xmm1,0x10(%rcx)
movdqu %xmm2,0x20(%rcx)
movdqu %xmm3,0x30(%rcx)
mov    0xe0(%rsp),%rax
mov    %rax,0x40(%rcx)
mov    %ebp,%ecx
jmp    1463 <innerFH+0x2e3>
pxor   %xmm6,%xmm6
xor    %eax,%eax
xorpd  %xmm1,%xmm1
movapd 0x90(%rsp),%xmm7
movdqa 0x856(%rip),%xmm8
testb  $0x1,0x58(%rsp)
jne    1663 <innerFH+0x4e3>
jmp    16e1 <innerFH+0x561>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @innerFH(double* %0, i32 %1, double* %2, i32 %3, double* %4, i32 %5, double %6, i32 %7, i32 %8, i32 %9, double* %10, i8* %11) {
%13 = alloca double*
%14 = alloca i32
%15 = alloca double*
%16 = alloca i32
%17 = alloca double*
%18 = alloca i32
%19 = alloca double
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca double*
%24 = alloca i8*
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca [9 x double]
%31 = alloca i8*
%32 = alloca double*
%33 = alloca double*
%34 = alloca i32*
%35 = alloca double*
store double* %0, double** %13
store i32 %1, i32* %14
store double* %2, double** %15
store i32 %3, i32* %16
store double* %4, double** %17
store i32 %5, i32* %18
store double %6, double* %19
store i32 %7, i32* %20
store i32 %8, i32* %21
store i32 %9, i32* %22
store double* %10, double** %23
store i8* %11, i8** %24
%36 = load i32, i32* %18
%37 = zext i32 %36 to i64
%38 = mul i64 %37, 1
%39 = call i8* @malloc(i64 %38)
store i8* %39, i8** %31
%40 = load i32, i32* %21
%41 = load i32, i32* %22
%42 = add i32 %40, %41
%43 = mul i32 6, %42
%44 = zext i32 %43 to i64
%45 = mul i64 %44, 8
%46 = call i8* @malloc(i64 %45)
%47 = bitcast i8* %46 to double*
store double* %47, double** %32
%48 = load i32, i32* %18
%49 = zext i32 %48 to i64
%50 = mul i64 %49, 8
%51 = call i8* @malloc(i64 %50)
%52 = bitcast i8* %51 to double*
store double* %52, double** %33
%53 = load i32, i32* %21
%54 = load i32, i32* %22
%55 = add i32 %53, %54
%56 = zext i32 %55 to i64
%57 = mul i64 %56, 4
%58 = call i8* @malloc(i64 %57)
%59 = bitcast i8* %58 to i32*
store i32* %59, i32** %34
%60 = load i32, i32* %21
%61 = load i32, i32* %22
%62 = add i32 %60, %61
%63 = mul i32 9, %62
%64 = zext i32 %63 to i64
%65 = mul i64 %64, 8
%66 = call i8* @malloc(i64 %65)
%67 = bitcast i8* %66 to double*
store double* %67, double** %35
store i32 0, i32* %25
br label %68
68: ; preds = %80, %12
%69 = load i32, i32* %25
%70 = load i32, i32* %21
%71 = load i32, i32* %22
%72 = add i32 %70, %71
%73 = icmp ult i32 %69, %72
br i1 %73, label %74, label %83
74: ; preds = %68
%75 = load i32, i32* %25
%76 = load i32*, i32** %34
%77 = load i32, i32* %25
%78 = zext i32 %77 to i64
%79 = getelementptr inbounds i32, i32* %76, i64 %78
store i32 %75, i32* %79
br label %80
80: ; preds = %74
%81 = load i32, i32* %25
%82 = add i32 %81, 1
store i32 %82, i32* %25
br label %68
83: ; preds = %68
store i32 0, i32* %25
br label %84
84: ; preds = %92, %83
%85 = load i32, i32* %25
%86 = icmp ult i32 %85, 9
br i1 %86, label %87, label %95
87: ; preds = %84
%88 = load double*, double** %23
%89 = load i32, i32* %25
%90 = zext i32 %89 to i64
%91 = getelementptr inbounds double, double* %88, i64 %90
store double 1.000000e+00, double* %91
br label %92
92: ; preds = %87
%93 = load i32, i32* %25
%94 = add i32 %93, 1
store i32 %94, i32* %25
br label %84
95: ; preds = %84
store i32 0, i32* %25
br label %96
96: ; preds = %105, %95
%97 = load i32, i32* %25
%98 = load i32, i32* %18
%99 = icmp ult i32 %97, %98
br i1 %99, label %100, label %108
100: ; preds = %96
%101 = load i8*, i8** %24
%102 = load i32, i32* %25
%103 = zext i32 %102 to i64
%104 = getelementptr inbounds i8, i8* %101, i64 %103
store i8 0, i8* %104
br label %105
105: ; preds = %100
%106 = load i32, i32* %25
%107 = add i32 %106, 1
store i32 %107, i32* %25
br label %96
108: ; preds = %96
store i32 0, i32* %27
store i32 0, i32* %28
store i32 0, i32* %26
br label %109
109: ; preds = %208, %108
%110 = load i32, i32* %26
%111 = load i32, i32* %20
%112 = icmp ult i32 %110, %111
br i1 %112, label %113, label %211
113: ; preds = %109
%114 = load double*, double** %13
%115 = load i32, i32* %14
%116 = load i32, i32* %21
%117 = load double*, double** %15
%118 = load i32, i32* %16
%119 = load i32, i32* %22
%120 = load double*, double** %32
%121 = call i32 (double*, i32, i32, double*, i32, i32, double*, ...) bitcast (i32 (...)* @dual_sample to i32 (double*, i32, i32, double*, i32, i32, double*, ...)*)(double* %114, i32 %115, i32 %116, double* %117, i32 %118, i32 %119, double* %120)
%122 = load double*, double** %32
%123 = load i32*, i32** %34
%124 = load i32, i32* %21
%125 = load i32, i32* %22
%126 = add i32 %124, %125
%127 = getelementptr inbounds [9 x double], [9 x double]* %30, i64 0, i64 0
%128 = load double*, double** %35
%129 = call i32 (double*, i32*, i32, double*, double*, ...) bitcast (i32 (...)* @u2f to i32 (double*, i32*, i32, double*, double*, ...)*)(double* %122, i32* %123, i32 %126, double* %127, double* %128)
%130 = load double*, double** %17
%131 = getelementptr inbounds [9 x double], [9 x double]* %30, i64 0, i64 0
%132 = load double*, double** %33
%133 = load i32, i32* %18
%134 = call i32 (double*, double*, double*, i32, ...) bitcast (i32 (...)* @FDs to i32 (double*, double*, double*, i32, ...)*)(double* %130, double* %131, double* %132, i32 %133)
store i32 0, i32* %29
store i32 0, i32* %25
br label %135
135: ; preds = %160, %113
%136 = load i32, i32* %25
%137 = load i32, i32* %18
%138 = icmp ult i32 %136, %137
br i1 %138, label %139, label %163
139: ; preds = %135
%140 = load double*, double** %33
%141 = load i32, i32* %25
%142 = zext i32 %141 to i64
%143 = getelementptr inbounds double, double* %140, i64 %142
%144 = load double, double* %143
%145 = load double, double* %19
%146 = fcmp olt double %144, %145
br i1 %146, label %147, label %154
147: ; preds = %139
%148 = load i8*, i8** %31
%149 = load i32, i32* %25
%150 = zext i32 %149 to i64
%151 = getelementptr inbounds i8, i8* %148, i64 %150
store i8 1, i8* %151
%152 = load i32, i32* %29
%153 = add i32 %152, 1
store i32 %153, i32* %29
br label %159
154: ; preds = %139
%155 = load i8*, i8** %31
%156 = load i32, i32* %25
%157 = zext i32 %156 to i64
%158 = getelementptr inbounds i8, i8* %155, i64 %157
store i8 0, i8* %158
br label %159
159: ; preds = %154, %147
br label %160
160: ; preds = %159
%161 = load i32, i32* %25
%162 = add i32 %161, 1
store i32 %162, i32* %25
br label %135
163: ; preds = %135
%164 = load i32, i32* %27
%165 = load i32, i32* %29
%166 = icmp ult i32 %164, %165
br i1 %166, label %167, label %178
167: ; preds = %163
%168 = load i8*, i8** %24
%169 = load i8*, i8** %31
%170 = load i32, i32* %18
%171 = zext i32 %170 to i64
%172 = mul i64 %171, 1
%173 = load double*, double** %23
%174 = bitcast double* %173 to i8*
%175 = getelementptr inbounds [9 x double], [9 x double]* %30, i64 0, i64 0
%176 = bitcast double* %175 to i8*
%177 = load i32, i32* %29
store i32 %177, i32* %27
br label %178
178: ; preds = %167, %163
%179 = load i32, i32* %29
%180 = load i32, i32* %28
%181 = icmp ugt i32 %179, %180
br i1 %181, label %182, label %207
182: ; preds = %178
%183 = load i32, i32* %29
store i32 %183, i32* %28
%184 = load double*, double** %17
%185 = load i32, i32* %18
%186 = getelementptr inbounds [9 x double], [9 x double]* %30, i64 0, i64 0
%187 = load i8*, i8** %31
%188 = load double, double* %19
%189 = load double, double* %19
%190 = fmul double %189, 3.000000e+00
%191 = call i32 (double*, i32, double*, i8*, double, double, i32, ...) bitcast (i32 (...)* @u2Fit to i32 (double*, i32, double*, i8*, double, double, i32, ...)*)(double* %184, i32 %185, double* %186, i8* %187, double %188, double %190, i32 4)
store i32 %191, i32* %29
%192 = load i32, i32* %27
%193 = load i32, i32* %29
%194 = icmp ult i32 %192, %193
br i1 %194, label %195, label %206
195: ; preds = %182
%196 = load i8*, i8** %24
%197 = load i8*, i8** %31
%198 = load i32, i32* %18
%199 = zext i32 %198 to i64
%200 = mul i64 %199, 1
%201 = load double*, double** %23
%202 = bitcast double* %201 to i8*
%203 = getelementptr inbounds [9 x double], [9 x double]* %30, i64 0, i64 0
%204 = bitcast double* %203 to i8*
%205 = load i32, i32* %29
store i32 %205, i32* %27
br label %206
206: ; preds = %195, %182
br label %207
207: ; preds = %206, %178
br label %208
208: ; preds = %207
%209 = load i32, i32* %26
%210 = add i32 %209, 1
store i32 %210, i32* %26
br label %109
211: ; preds = %109
%212 = load double*, double** %32
%213 = bitcast double* %212 to i8*
%214 = load double*, double** %33
%215 = bitcast double* %214 to i8*
%216 = load i32*, i32** %34
%217 = bitcast i32* %216 to i8*
%218 = load double*, double** %35
%219 = bitcast double* %218 to i8*
%220 = load i8*, i8** %31
ret void
}

LLVM IR (-O2):
define void @innerFH(double* %0, i32 %1, double* %2, i32 %3, double* %4, i32 %5, double %6, i32 %7, i32 %8, i32 %9, double* nocapture writeonly %10, i8* nocapture writeonly %11) {
%13 = alloca [9 x double]
%14 = bitcast [9 x double]* %13 to i8*
%15 = zext i32 %5 to i64
%16 = tail call i8* @malloc(i64 %15)
%17 = add i32 %9, %8
%18 = mul i32 %17, 6
%19 = zext i32 %18 to i64
%20 = shl nuw nsw i64 %19, 3
%21 = tail call i8* @malloc(i64 %20)
%22 = bitcast i8* %21 to double*
%23 = shl nuw nsw i64 %15, 3
%24 = tail call i8* @malloc(i64 %23)
%25 = bitcast i8* %24 to double*
%26 = zext i32 %17 to i64
%27 = shl nuw nsw i64 %26, 2
%28 = tail call i8* @malloc(i64 %27)
%29 = bitcast i8* %28 to i32*
%30 = mul i32 %17, 9
%31 = zext i32 %30 to i64
%32 = shl nuw nsw i64 %31, 3
%33 = tail call i8* @malloc(i64 %32)
%34 = bitcast i8* %33 to double*
%35 = icmp eq i32 %17, 0
br i1 %35, label %102, label %36
36: ; preds = %12
%37 = icmp ult i32 %17, 8
br i1 %37, label %100, label %38
38: ; preds = %36
%39 = and i64 %26, 4294967288
%40 = add nsw i64 %39, -8
%41 = lshr exact i64 %40, 3
%42 = add nuw nsw i64 %41, 1
%43 = and i64 %42, 3
%44 = icmp ult i64 %40, 24
br i1 %44, label %81, label %45
45: ; preds = %38
%46 = and i64 %42, 4611686018427387900
br label %47
47: ; preds = %47, %45
%48 = phi i64 [ 0, %45 ], [ %77, %47 ]
%49 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %45 ], [ %78, %47 ]
%50 = phi i64 [ 0, %45 ], [ %79, %47 ]
%51 = add <4 x i32> %49, <i32 4, i32 4, i32 4, i32 4>
%52 = getelementptr inbounds i32, i32* %29, i64 %48
%53 = bitcast i32* %52 to <4 x i32>*
store <4 x i32> %49, <4 x i32>* %53
%54 = getelementptr inbounds i32, i32* %52, i64 4
%55 = bitcast i32* %54 to <4 x i32>*
store <4 x i32> %51, <4 x i32>* %55
%56 = or i64 %48, 8
%57 = add <4 x i32> %49, <i32 8, i32 8, i32 8, i32 8>
%58 = add <4 x i32> %49, <i32 12, i32 12, i32 12, i32 12>
%59 = getelementptr inbounds i32, i32* %29, i64 %56
%60 = bitcast i32* %59 to <4 x i32>*
store <4 x i32> %57, <4 x i32>* %60
%61 = getelementptr inbounds i32, i32* %59, i64 4
%62 = bitcast i32* %61 to <4 x i32>*
store <4 x i32> %58, <4 x i32>* %62
%63 = or i64 %48, 16
%64 = add <4 x i32> %49, <i32 16, i32 16, i32 16, i32 16>
%65 = add <4 x i32> %49, <i32 20, i32 20, i32 20, i32 20>
%66 = getelementptr inbounds i32, i32* %29, i64 %63
%67 = bitcast i32* %66 to <4 x i32>*
store <4 x i32> %64, <4 x i32>* %67
%68 = getelementptr inbounds i32, i32* %66, i64 4
%69 = bitcast i32* %68 to <4 x i32>*
store <4 x i32> %65, <4 x i32>* %69
%70 = or i64 %48, 24
%71 = add <4 x i32> %49, <i32 24, i32 24, i32 24, i32 24>
%72 = add <4 x i32> %49, <i32 28, i32 28, i32 28, i32 28>
%73 = getelementptr inbounds i32, i32* %29, i64 %70
%74 = bitcast i32* %73 to <4 x i32>*
store <4 x i32> %71, <4 x i32>* %74
%75 = getelementptr inbounds i32, i32* %73, i64 4
%76 = bitcast i32* %75 to <4 x i32>*
store <4 x i32> %72, <4 x i32>* %76
%77 = add nuw i64 %48, 32
%78 = add <4 x i32> %49, <i32 32, i32 32, i32 32, i32 32>
%79 = add i64 %50, 4
%80 = icmp eq i64 %79, %46
br i1 %80, label %81, label %47
81: ; preds = %47, %38
%82 = phi i64 [ 0, %38 ], [ %77, %47 ]
%83 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %38 ], [ %78, %47 ]
%84 = icmp eq i64 %43, 0
br i1 %84, label %98, label %85
85: ; preds = %81, %85
%86 = phi i64 [ %94, %85 ], [ %82, %81 ]
%87 = phi <4 x i32> [ %95, %85 ], [ %83, %81 ]
%88 = phi i64 [ %96, %85 ], [ 0, %81 ]
%89 = add <4 x i32> %87, <i32 4, i32 4, i32 4, i32 4>
%90 = getelementptr inbounds i32, i32* %29, i64 %86
%91 = bitcast i32* %90 to <4 x i32>*
store <4 x i32> %87, <4 x i32>* %91
%92 = getelementptr inbounds i32, i32* %90, i64 4
%93 = bitcast i32* %92 to <4 x i32>*
store <4 x i32> %89, <4 x i32>* %93
%94 = add nuw i64 %86, 8
%95 = add <4 x i32> %87, <i32 8, i32 8, i32 8, i32 8>
%96 = add i64 %88, 1
%97 = icmp eq i64 %96, %43
br i1 %97, label %98, label %85
98: ; preds = %85, %81
%99 = icmp eq i64 %39, %26
br i1 %99, label %102, label %100
100: ; preds = %36, %98
%101 = phi i64 [ 0, %36 ], [ %39, %98 ]
br label %112
102: ; preds = %112, %98, %12
%103 = bitcast double* %10 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %103
%104 = getelementptr inbounds double, double* %10, i64 2
%105 = bitcast double* %104 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %105
%106 = getelementptr inbounds double, double* %10, i64 4
%107 = bitcast double* %106 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %107
%108 = getelementptr inbounds double, double* %10, i64 6
%109 = bitcast double* %108 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %109
%110 = getelementptr inbounds double, double* %10, i64 8
store double 1.000000e+00, double* %110
%111 = icmp eq i32 %5, 0
br i1 %111, label %119, label %118
112: ; preds = %100, %112
%113 = phi i64 [ %116, %112 ], [ %101, %100 ]
%114 = getelementptr inbounds i32, i32* %29, i64 %113
%115 = trunc i64 %113 to i32
store i32 %115, i32* %114
%116 = add nuw nsw i64 %113, 1
%117 = icmp eq i64 %116, %26
br i1 %117, label %102, label %112
118: ; preds = %102
br label %119
119: ; preds = %118, %102
%120 = icmp eq i32 %7, 0
br i1 %120, label %255, label %121
121: ; preds = %119
%122 = getelementptr inbounds [9 x double], [9 x double]* %13, i64 0, i64 0
%123 = bitcast double* %10 to i8*
%124 = fmul double %6, 3.000000e+00
%125 = and i64 %15, 4294967292
%126 = add nsw i64 %125, -4
%127 = lshr exact i64 %126, 2
%128 = add nuw nsw i64 %127, 1
%129 = icmp ult i32 %5, 4
%130 = and i64 %15, 4294967292
%131 = insertelement <2 x double> poison, double %6, i64 0
%132 = shufflevector <2 x double> %131, <2 x double> poison, <2 x i32> zeroinitializer
%133 = insertelement <2 x double> poison, double %6, i64 0
%134 = shufflevector <2 x double> %133, <2 x double> poison, <2 x i32> zeroinitializer
%135 = and i64 %128, 1
%136 = icmp eq i64 %126, 0
%137 = and i64 %128, 9223372036854775806
%138 = icmp eq i64 %135, 0
%139 = icmp eq i64 %130, %15
br label %140
140: ; preds = %121, %250
%141 = phi i32 [ 0, %121 ], [ %253, %250 ]
%142 = phi i32 [ 0, %121 ], [ %252, %250 ]
%143 = phi i32 [ 0, %121 ], [ %251, %250 ]
%144 = call i32 (double*, i32, i32, double*, i32, i32, double*, ...) bitcast (i32 (...)* @dual_sample to i32 (double*, i32, i32, double*, i32, i32, double*, ...)*)(double* %0, i32 %1, i32 %8, double* %2, i32 %3, i32 %9, double* %22)
%145 = call i32 (double*, i32*, i32, double*, double*, ...) bitcast (i32 (...)* @u2f to i32 (double*, i32*, i32, double*, double*, ...)*)(double* %22, i32* %29, i32 %17, double* %122, double* %34)
%146 = call i32 (double*, double*, double*, i32, ...) bitcast (i32 (...)* @FDs to i32 (double*, double*, double*, i32, ...)*)(double* %4, double* %122, double* %25, i32 %5)
br i1 %111, label %239, label %147
147: ; preds = %140
br i1 %129, label %224, label %148
148: ; preds = %147
br i1 %136, label %194, label %149
149: ; preds = %148, %149
%150 = phi i64 [ %191, %149 ], [ 0, %148 ]
%151 = phi <2 x i32> [ %185, %149 ], [ zeroinitializer, %148 ]
%152 = phi <2 x i32> [ %186, %149 ], [ zeroinitializer, %148 ]
%153 = phi i64 [ %192, %149 ], [ 0, %148 ]
%154 = getelementptr inbounds double, double* %25, i64 %150
%155 = bitcast double* %154 to <2 x double>*
%156 = load <2 x double>, <2 x double>* %155
%157 = getelementptr inbounds double, double* %154, i64 2
%158 = bitcast double* %157 to <2 x double>*
%159 = load <2 x double>, <2 x double>* %158
%160 = fcmp olt <2 x double> %156, %132
%161 = fcmp olt <2 x double> %159, %134
%162 = zext <2 x i1> %160 to <2 x i8>
%163 = zext <2 x i1> %161 to <2 x i8>
%164 = zext <2 x i1> %160 to <2 x i32>
%165 = zext <2 x i1> %161 to <2 x i32>
%166 = add <2 x i32> %151, %164
%167 = add <2 x i32> %152, %165
%168 = getelementptr inbounds i8, i8* %16, i64 %150
%169 = bitcast i8* %168 to <2 x i8>*
store <2 x i8> %162, <2 x i8>* %169
%170 = getelementptr inbounds i8, i8* %168, i64 2
%171 = bitcast i8* %170 to <2 x i8>*
store <2 x i8> %163, <2 x i8>* %171
%172 = or i64 %150, 4
%173 = getelementptr inbounds double, double* %25, i64 %172
%174 = bitcast double* %173 to <2 x double>*
%175 = load <2 x double>, <2 x double>* %174
%176 = getelementptr inbounds double, double* %173, i64 2
%177 = bitcast double* %176 to <2 x double>*
%178 = load <2 x double>, <2 x double>* %177
%179 = fcmp olt <2 x double> %175, %132
%180 = fcmp olt <2 x double> %178, %134
%181 = zext <2 x i1> %179 to <2 x i8>
%182 = zext <2 x i1> %180 to <2 x i8>
%183 = zext <2 x i1> %179 to <2 x i32>
%184 = zext <2 x i1> %180 to <2 x i32>
%185 = add <2 x i32> %166, %183
%186 = add <2 x i32> %167, %184
%187 = getelementptr inbounds i8, i8* %16, i64 %172
%188 = bitcast i8* %187 to <2 x i8>*
store <2 x i8> %181, <2 x i8>* %188
%189 = getelementptr inbounds i8, i8* %187, i64 2
%190 = bitcast i8* %189 to <2 x i8>*
store <2 x i8> %182, <2 x i8>* %190
%191 = add nuw i64 %150, 8
%192 = add i64 %153, 2
%193 = icmp eq i64 %192, %137
br i1 %193, label %194, label %149
194: ; preds = %149, %148
%195 = phi <2 x i32> [ undef, %148 ], [ %185, %149 ]
%196 = phi <2 x i32> [ undef, %148 ], [ %186, %149 ]
%197 = phi i64 [ 0, %148 ], [ %191, %149 ]
%198 = phi <2 x i32> [ zeroinitializer, %148 ], [ %185, %149 ]
%199 = phi <2 x i32> [ zeroinitializer, %148 ], [ %186, %149 ]
br i1 %138, label %219, label %200
200: ; preds = %194
%201 = getelementptr inbounds double, double* %25, i64 %197
%202 = bitcast double* %201 to <2 x double>*
%203 = load <2 x double>, <2 x double>* %202
%204 = getelementptr inbounds double, double* %201, i64 2
%205 = bitcast double* %204 to <2 x double>*
%206 = load <2 x double>, <2 x double>* %205
%207 = fcmp olt <2 x double> %203, %132
%208 = fcmp olt <2 x double> %206, %134
%209 = zext <2 x i1> %207 to <2 x i8>
%210 = zext <2 x i1> %208 to <2 x i8>
%211 = zext <2 x i1> %207 to <2 x i32>
%212 = zext <2 x i1> %208 to <2 x i32>
%213 = add <2 x i32> %198, %211
%214 = add <2 x i32> %199, %212
%215 = getelementptr inbounds i8, i8* %16, i64 %197
%216 = bitcast i8* %215 to <2 x i8>*
store <2 x i8> %209, <2 x i8>* %216
%217 = getelementptr inbounds i8, i8* %215, i64 2
%218 = bitcast i8* %217 to <2 x i8>*
store <2 x i8> %210, <2 x i8>* %218
br label %219
219: ; preds = %194, %200
%220 = phi <2 x i32> [ %195, %194 ], [ %213, %200 ]
%221 = phi <2 x i32> [ %196, %194 ], [ %214, %200 ]
%222 = add <2 x i32> %221, %220
%223 = call i32 @llvm.vector.reduce.add.v2i32(<2 x i32> %222)
br i1 %139, label %239, label %224
224: ; preds = %147, %219
%225 = phi i64 [ 0, %147 ], [ %130, %219 ]
%226 = phi i32 [ 0, %147 ], [ %223, %219 ]
br label %227
227: ; preds = %224, %227
%228 = phi i64 [ %237, %227 ], [ %225, %224 ]
%229 = phi i32 [ %235, %227 ], [ %226, %224 ]
%230 = getelementptr inbounds double, double* %25, i64 %228
%231 = load double, double* %230
%232 = fcmp olt double %231, %6
%233 = zext i1 %232 to i8
%234 = zext i1 %232 to i32
%235 = add i32 %229, %234
%236 = getelementptr inbounds i8, i8* %16, i64 %228
store i8 %233, i8* %236
%237 = add nuw nsw i64 %228, 1
%238 = icmp eq i64 %237, %15
br i1 %238, label %239, label %227
239: ; preds = %227, %219, %140
%240 = phi i32 [ 0, %140 ], [ %223, %219 ], [ %235, %227 ]
%241 = icmp ult i32 %142, %240
br i1 %241, label %242, label %243
242: ; preds = %239
br label %243
243: ; preds = %242, %239
%244 = phi i32 [ %240, %242 ], [ %142, %239 ]
%245 = icmp ugt i32 %240, %143
br i1 %245, label %246, label %250
246: ; preds = %243
%247 = call i32 (double*, i32, double*, i8*, double, double, i32, ...) bitcast (i32 (...)* @u2Fit to i32 (double*, i32, double*, i8*, double, double, i32, ...)*)(double* %4, i32 %5, double* %122, i8* %16, double %6, double %124, i32 4)
%248 = icmp ult i32 %244, %247
br i1 %248, label %249, label %250
249: ; preds = %246
br label %250
250: ; preds = %243, %249, %246
%251 = phi i32 [ %240, %249 ], [ %240, %246 ], [ %143, %243 ]
%252 = phi i32 [ %247, %249 ], [ %244, %246 ], [ %244, %243 ]
%253 = add nuw i32 %141, 1
%254 = icmp eq i32 %253, %7
br i1 %254, label %255, label %140
255: ; preds = %250, %119
ret void
}