void open_loop_nbest_pitch(float *sw, int start, int end, int len, int *pitch,
                           float *gain, int N, char *stack) {
  int i, j, k;
  float *best_score;
  float e0;
  float *corr, *energy, *score;
  best_score = ((((stack)) +=
                 ((sizeof(float)) - (int)((stack))) & ((sizeof(float)) - 1)),
                (stack) += ((N) * sizeof(float)),
                (float *)((stack) - ((N) * sizeof(float))));
  corr = ((((stack)) +=
           ((sizeof(float)) - (int)((stack))) & ((sizeof(float)) - 1)),
          (stack) += ((end - start + 1) * sizeof(float)),
          (float *)((stack) - ((end - start + 1) * sizeof(float))));
  energy = ((((stack)) +=
             ((sizeof(float)) - (int)((stack))) & ((sizeof(float)) - 1)),
            (stack) += ((end - start + 2) * sizeof(float)),
            (float *)((stack) - ((end - start + 2) * sizeof(float))));
  score = ((((stack)) +=
            ((sizeof(float)) - (int)((stack))) & ((sizeof(float)) - 1)),
           (stack) += ((end - start + 1) * sizeof(float)),
           (float *)((stack) - ((end - start + 1) * sizeof(float))));
  for (i = 0; i < N; i++) {
    best_score[i] = -1;
    gain[i] = 0;
  }
  energy[0] = inner_prod(sw - start, sw - start, len);
  e0 = inner_prod(sw, sw, len);
  for (i = start; i <= end; i++) {
    energy[i - start + 1] = energy[i - start] + sw[-i - 1] * sw[-i - 1] -
                            sw[-i + len - 1] * sw[-i + len - 1];
  }
  for (i = start; i <= end; i++) {
    corr[i - start] = 0;
    score[i - start] = 0;
  }
  for (i = start; i <= end; i++) {
    corr[i - start] = inner_prod(sw, sw - i, len);
    score[i - start] =
        corr[i - start] * corr[i - start] / (energy[i - start] + 1);
  }
  for (i = start; i <= end; i++) {
    if (score[i - start] > best_score[N - 1]) {
      float g1, g;
      g1 = corr[i - start] / (energy[i - start] + 10);
      g = sqrt(g1 * corr[i - start] / (e0 + 10));
      if (g > g1)
        g = g1;
      if (g < 0)
        g = 0;
      for (j = 0; j < N; j++) {
        if (score[i - start] > best_score[j]) {
          for (k = N - 1; k > j; k--) {
            best_score[k] = best_score[k - 1];
            pitch[k] = pitch[k - 1];
            gain[k] = gain[k - 1];
          }
          best_score[j] = score[i - start];
          pitch[j] = i;
          gain[j] = g;
          break;
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<open_loop_nbest_pitch>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    0x18(%rbp),%rax
movslq %eax,%rcx
mov    $0x4,%eax
sub    %rcx,%rax
and    $0x3,%rax
add    0x18(%rbp),%rax
mov    %rax,0x18(%rbp)
movslq 0x10(%rbp),%rax
shl    $0x2,%rax
add    0x18(%rbp),%rax
mov    %rax,0x18(%rbp)
mov    0x18(%rbp),%rax
movslq 0x10(%rbp),%rdx
shl    $0x2,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    0x18(%rbp),%rax
movslq %eax,%rcx
mov    $0x4,%eax
sub    %rcx,%rax
and    $0x3,%rax
add    0x18(%rbp),%rax
mov    %rax,0x18(%rbp)
mov    -0x10(%rbp),%eax
sub    -0xc(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    0x18(%rbp),%rax
mov    %rax,0x18(%rbp)
mov    0x18(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rdx
shl    $0x2,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    0x18(%rbp),%rax
movslq %eax,%rcx
mov    $0x4,%eax
sub    %rcx,%rax
and    $0x3,%rax
add    0x18(%rbp),%rax
mov    %rax,0x18(%rbp)
mov    -0x10(%rbp),%eax
sub    -0xc(%rbp),%eax
add    $0x2,%eax
cltq
shl    $0x2,%rax
add    0x18(%rbp),%rax
mov    %rax,0x18(%rbp)
mov    0x18(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    -0xc(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rdx
shl    $0x2,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    0x18(%rbp),%rax
movslq %eax,%rcx
mov    $0x4,%eax
sub    %rcx,%rax
and    $0x3,%rax
add    0x18(%rbp),%rax
mov    %rax,0x18(%rbp)
mov    -0x10(%rbp),%eax
sub    -0xc(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    0x18(%rbp),%rax
mov    %rax,0x18(%rbp)
mov    0x18(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rdx
shl    $0x2,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    12c3 <open_loop_nbest_pitch+0x1a3>
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  0xd68(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1284 <open_loop_nbest_pitch+0x164>
mov    -0x8(%rbp),%rdi
movslq -0xc(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
movslq -0xc(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x14(%rbp),%edx
mov    $0x0,%al
call   1030 <inner_prod@plt>
cvtsi2ss %eax,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    $0x0,%al
call   1030 <inner_prod@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     13d6 <open_loop_nbest_pitch+0x2b6>
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
xor    %ecx,%ecx
sub    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
xor    %ecx,%ecx
sub    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
xor    %ecx,%ecx
sub    -0x2c(%rbp),%ecx
add    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
xor    %ecx,%ecx
sub    -0x2c(%rbp),%ecx
add    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1322 <open_loop_nbest_pitch+0x202>
mov    -0xc(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1420 <open_loop_nbest_pitch+0x300>
mov    -0x50(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13dc <open_loop_nbest_pitch+0x2bc>
mov    -0xc(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     14cc <open_loop_nbest_pitch+0x3ac>
mov    -0x8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
movslq -0x2c(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x14(%rbp),%edx
mov    $0x0,%al
call   1030 <inner_prod@plt>
cvtsi2ss %eax,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movss  0xb61(%rip),%xmm1
addss  (%rax,%rcx,4),%xmm1
divss  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1426 <open_loop_nbest_pitch+0x306>
mov    -0xc(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     16c6 <open_loop_nbest_pitch+0x5a6>
mov    -0x60(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    16b3 <open_loop_nbest_pitch+0x593>
mov    -0x50(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movss  0xad2(%rip),%xmm1
addss  (%rax,%rcx,4),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x64(%rbp),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  0xaa5(%rip),%xmm1
addss  -0x44(%rbp),%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1040 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x68(%rbp),%xmm0
ucomiss -0x64(%rbp),%xmm0
jbe    158f <open_loop_nbest_pitch+0x46f>
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
ucomiss -0x68(%rbp),%xmm0
jbe    15a4 <open_loop_nbest_pitch+0x484>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    16ae <open_loop_nbest_pitch+0x58e>
mov    -0x60(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    169b <open_loop_nbest_pitch+0x57b>
mov    0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jle    1657 <open_loop_nbest_pitch+0x537>
mov    -0x40(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    15e4 <open_loop_nbest_pitch+0x4c4>
mov    -0x60(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    16ae <open_loop_nbest_pitch+0x58e>
jmp    16a0 <open_loop_nbest_pitch+0x580>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15ab <open_loop_nbest_pitch+0x48b>
jmp    16b3 <open_loop_nbest_pitch+0x593>
jmp    16b8 <open_loop_nbest_pitch+0x598>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14d2 <open_loop_nbest_pitch+0x3b2>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<open_loop_nbest_pitch>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r9,%rbx
mov    %r8,0x78(%rsp)
mov    %edx,%r13d
mov    %esi,%r11d
mov    %rdi,%r12
movslq 0xc0(%rsp),%r8
mov    0xc8(%rsp),%rax
mov    %eax,%edx
neg    %edx
and    $0x3,%edx
mov    %rdx,(%rsp)
lea    (%rax,%rdx,1),%r9
lea    (%r9,%r8,4),%r14
mov    %r14d,%eax
neg    %eax
and    $0x3,%eax
add    %r14,%rax
mov    %r13d,%edx
sub    %esi,%edx
mov    %rdx,0x28(%rsp)
add    $0x1,%edx
mov    %edx,0x54(%rsp)
movslq %edx,%rdx
mov    %rax,0x80(%rsp)
mov    %rdx,0x8(%rsp)
lea    (%rax,%rdx,4),%r15
mov    %r15d,%eax
neg    %eax
and    $0x3,%eax
add    %r15,%rax
mov    %rax,0x48(%rsp)
test   %r8,%r8
jle    13a4 <open_loop_nbest_pitch+0x284>
mov    %r8d,%eax
cmp    $0x8,%r8d
jb     11dd <open_loop_nbest_pitch+0xbd>
lea    (%rbx,%rax,4),%rdx
cmp    %rdx,%r9
jae    128c <open_loop_nbest_pitch+0x16c>
mov    (%rsp),%rdx
lea    (%rdx,%rax,4),%rdx
add    0xc8(%rsp),%rdx
cmp    %rbx,%rdx
jbe    128c <open_loop_nbest_pitch+0x16c>
xor    %edx,%edx
mov    %rdx,%rdi
not    %rdi
add    %rax,%rdi
mov    %rax,%rsi
and    $0x3,%rsi
je     1219 <open_loop_nbest_pitch+0xf9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movl   $0xbf800000,(%r9,%rdx,4)
bf
movl   $0x0,(%rbx,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    1200 <open_loop_nbest_pitch+0xe0>
cmp    $0x3,%rdi
jb     13a4 <open_loop_nbest_pitch+0x284>
mov    0xc8(%rsp),%rsi
mov    (%rsp),%rdi
add    %rdi,%rsi
add    $0xc,%rsi
cs nopw 0x0(%rax,%rax,1)
movl   $0xbf800000,-0xc(%rsi,%rdx,4)
bf
movl   $0x0,(%rbx,%rdx,4)
movl   $0xbf800000,-0x8(%rsi,%rdx,4)
bf
movl   $0x0,0x4(%rbx,%rdx,4)
movl   $0xbf800000,-0x4(%rsi,%rdx,4)
bf
movl   $0x0,0x8(%rbx,%rdx,4)
movl   $0xbf800000,(%rsi,%rdx,4)
movl   $0x0,0xc(%rbx,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rax
jne    1240 <open_loop_nbest_pitch+0x120>
jmp    13a4 <open_loop_nbest_pitch+0x284>
mov    %eax,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%r10d
and    $0x3,%r10d
cmp    $0x18,%rdi
jae    12b4 <open_loop_nbest_pitch+0x194>
xor    %edi,%edi
jmp    1339 <open_loop_nbest_pitch+0x219>
and    $0xfffffffffffffffc,%rsi
mov    0xc8(%rsp),%rdi
mov    (%rsp),%rbp
add    %rdi,%rbp
add    $0x70,%rbp
xor    %edi,%edi
movaps 0xd2c(%rip),%xmm0
xorps  %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movups %xmm0,-0x70(%rbp,%rdi,4)
movups %xmm0,-0x60(%rbp,%rdi,4)
movups %xmm1,(%rbx,%rdi,4)
movups %xmm1,0x10(%rbx,%rdi,4)
movups %xmm0,-0x50(%rbp,%rdi,4)
movups %xmm0,-0x40(%rbp,%rdi,4)
movups %xmm1,0x20(%rbx,%rdi,4)
movups %xmm1,0x30(%rbx,%rdi,4)
movups %xmm0,-0x30(%rbp,%rdi,4)
movups %xmm0,-0x20(%rbp,%rdi,4)
movups %xmm1,0x40(%rbx,%rdi,4)
movups %xmm1,0x50(%rbx,%rdi,4)
movups %xmm0,-0x10(%rbp,%rdi,4)
movups %xmm0,0x0(%rbp,%rdi,4)
movups %xmm1,0x60(%rbx,%rdi,4)
movups %xmm1,0x70(%rbx,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    12e0 <open_loop_nbest_pitch+0x1c0>
test   %r10,%r10
je     139b <open_loop_nbest_pitch+0x27b>
lea    (%rbx,%rdi,4),%rsi
add    $0x10,%rsi
mov    (%rsp),%rbp
lea    0x0(,%rdi,4),%rdi
add    %rbp,%rdi
mov    0xc8(%rsp),%rbp
add    %rbp,%rdi
add    $0x10,%rdi
shl    $0x5,%r10
xor    %ebp,%ebp
movaps 0xc8f(%rip),%xmm0
xorps  %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm0,(%rdi,%rbp,1)
movups %xmm1,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r10
jne    1380 <open_loop_nbest_pitch+0x260>
cmp    %rax,%rdx
jne    11df <open_loop_nbest_pitch+0xbf>
mov    %r15,0x70(%rsp)
mov    %r14,0x60(%rsp)
movslq %r11d,%rax
mov    %rax,0x20(%rsp)
lea    0x0(,%rax,4),%rax
mov    %r12,%r15
mov    %rax,0x10(%rsp)
sub    %rax,%r15
mov    %r15,%rdi
mov    %r15,%rsi
mov    %ecx,%edx
xor    %eax,%eax
mov    %r8,0x40(%rsp)
mov    %r9,0x68(%rsp)
mov    %rcx,%rbp
mov    %r11d,0x18(%rsp)
call   1030 <inner_prod@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    0x48(%rsp),%rax
movss  %xmm0,(%rax)
mov    %r12,%rdi
mov    %r12,%rsi
mov    %rbp,%r14
mov    %ebp,%edx
xor    %eax,%eax
call   1030 <inner_prod@plt>
mov    0x18(%rsp),%r8d
mov    0x40(%rsp),%r9
mov    %eax,%r10d
mov    %r13d,%eax
sub    %r8d,%eax
jl     18df <open_loop_nbest_pitch+0x7bf>
lea    0x1(%r13),%edi
mov    %r8d,%ecx
not    %ecx
mov    %ecx,%edx
sub    %eax,%edx
cmp    %ecx,%edx
mov    %r14,%rbp
jg     14b0 <open_loop_nbest_pitch+0x390>
lea    (%rcx,%rbp,1),%edx
mov    %edx,%esi
sub    %eax,%esi
cmp    %edx,%esi
jg     14b0 <open_loop_nbest_pitch+0x390>
mov    0x48(%rsp),%rax
movss  (%rax),%xmm0
mov    0x8(%rsp),%rax
add    %r9,%rax
mov    (%rsp),%rdx
lea    (%rdx,%rax,4),%rax
mov    0xc8(%rsp),%rdx
add    %rdx,%rax
add    $0x4,%rax
nopl   0x0(%rax)
movslq %ecx,%rcx
movss  (%r12,%rcx,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
lea    (%rcx,%rbp,1),%edx
movslq %edx,%rdx
movss  (%r12,%rdx,4),%xmm0
mulss  %xmm0,%xmm0
subss  %xmm0,%xmm1
movss  %xmm1,(%rax)
add    $0x4,%rax
lea    (%rdi,%rcx,1),%edx
add    $0xffffffff,%edx
add    $0xffffffff,%ecx
movaps %xmm1,%xmm0
cmp    $0xffffffff,%edx
jne    1470 <open_loop_nbest_pitch+0x350>
jmp    151c <open_loop_nbest_pitch+0x3fc>
mov    %r8d,%ecx
not    %ecx
mov    0x8(%rsp),%rax
add    %r9,%rax
mov    (%rsp),%rdx
lea    (%rdx,%rax,4),%rax
mov    0xc8(%rsp),%rdx
add    %rdx,%rax
add    $0x4,%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq %ecx,%rcx
movss  (%r12,%rcx,4),%xmm0
mulss  %xmm0,%xmm0
addss  -0x4(%rax),%xmm0
lea    (%rcx,%rbp,1),%edx
movslq %edx,%rdx
movss  (%r12,%rdx,4),%xmm1
mulss  %xmm1,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%rax)
lea    (%rdi,%rcx,1),%edx
add    $0xffffffff,%edx
add    $0xffffffff,%ecx
add    $0x4,%rax
cmp    $0xffffffff,%edx
jne    14e0 <open_loop_nbest_pitch+0x3c0>
mov    %r13d,%esi
sub    %r8d,%esi
jl     18df <open_loop_nbest_pitch+0x7bf>
mov    %r10d,0x50(%rsp)
mov    %rdi,0x58(%rsp)
mov    %r13,0x38(%rsp)
movslq 0x28(%rsp),%rbp
mov    0x48(%rsp),%rax
lea    (%rax,%rbp,4),%rax
add    $0x8,%rax
mov    %eax,%ecx
neg    %ecx
and    $0x3,%ecx
lea    0x0(,%r9,4),%rdx
mov    %rdx,0x30(%rsp)
lea    0x2(%rbp),%r11
add    %rax,%rcx
mov    %rcx,0x28(%rsp)
mov    0x20(%rsp),%r13
cmp    $0x7,%esi
jb     16fe <open_loop_nbest_pitch+0x5de>
lea    (%r9,%r11,1),%r10
add    0x8(%rsp),%r10
lea    (%r10,%rsi,1),%rax
mov    (%rsp),%rcx
lea    (%rcx,%rax,4),%rax
mov    0xc8(%rsp),%rcx
add    %rcx,%rax
add    $0x4,%rax
cmp    %rax,0x60(%rsp)
jae    15cd <open_loop_nbest_pitch+0x4ad>
lea    (%r9,%rsi,1),%rax
mov    (%rsp),%rcx
lea    (%rcx,%rax,4),%rax
mov    0xc8(%rsp),%rcx
add    %rcx,%rax
add    $0x4,%rax
mov    0x20(%rsp),%r13
cmp    %rax,0x28(%rsp)
jb     16fe <open_loop_nbest_pitch+0x5de>
add    $0x1,%rsi
mov    %rsi,%r13
and    $0xfffffffffffffff8,%r13
lea    -0x8(%r13),%rax
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%edi
and    $0x3,%edi
cmp    $0x18,%rax
jae    15fa <open_loop_nbest_pitch+0x4da>
xor    %r8d,%r8d
jmp    168c <open_loop_nbest_pitch+0x56c>
and    $0xfffffffffffffffc,%rcx
mov    (%rsp),%r9
mov    0x30(%rsp),%rax
add    %r9,%rax
mov    0xc8(%rsp),%r8
lea    (%r8,%rax,1),%rdx
add    $0x70,%rdx
lea    (%r9,%r10,4),%rax
lea    (%r8,%rax,1),%r9
add    $0x70,%r9
xor    %r8d,%r8d
xorps  %xmm0,%xmm0
nopl   0x0(%rax)
movups %xmm0,-0x70(%rdx)
movups %xmm0,-0x60(%rdx)
movups %xmm0,-0x70(%r9,%r8,4)
movups %xmm0,-0x60(%r9,%r8,4)
movups %xmm0,-0x50(%rdx)
movups %xmm0,-0x40(%rdx)
movups %xmm0,-0x50(%r9,%r8,4)
movups %xmm0,-0x40(%r9,%r8,4)
movups %xmm0,-0x30(%rdx)
movups %xmm0,-0x20(%rdx)
movups %xmm0,-0x30(%r9,%r8,4)
movups %xmm0,-0x20(%r9,%r8,4)
movups %xmm0,-0x10(%rdx)
movups %xmm0,(%rdx)
movups %xmm0,-0x10(%r9,%r8,4)
movups %xmm0,(%r9,%r8,4)
add    $0x20,%r8
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rcx
jne    1630 <open_loop_nbest_pitch+0x510>
test   %rdi,%rdi
je     16eb <open_loop_nbest_pitch+0x5cb>
shl    $0x2,%r10
lea    (%r10,%r8,4),%rax
mov    (%rsp),%rdx
or     %rdx,%rax
mov    0xc8(%rsp),%r9
lea    (%r9,%rax,1),%rcx
add    $0x10,%rcx
mov    0x30(%rsp),%rax
lea    (%rax,%r8,4),%rax
add    %rdx,%rax
lea    (%r9,%rax,1),%rdx
add    $0x10,%rdx
shl    $0x5,%rdi
xor    %eax,%eax
xorps  %xmm0,%xmm0
nopl   (%rax)
movups %xmm0,-0x10(%rdx,%rax,1)
movups %xmm0,(%rdx,%rax,1)
movups %xmm0,-0x10(%rcx,%rax,1)
movups %xmm0,(%rcx,%rax,1)
add    $0x20,%rax
cmp    %rax,%rdi
jne    16d0 <open_loop_nbest_pitch+0x5b0>
cmp    %r13,%rsi
mov    0x40(%rsp),%r9
je     1826 <open_loop_nbest_pitch+0x706>
add    0x20(%rsp),%r13
mov    0x38(%rsp),%r8
mov    %r8d,%ecx
sub    %r13d,%ecx
lea    0x1(%rcx),%eax
test   $0x3,%al
je     177c <open_loop_nbest_pitch+0x65c>
mov    %rbp,%r10
add    %r9,%r11
add    0x8(%rsp),%r11
shl    $0x2,%r11
lea    (%r11,%r13,4),%rsi
mov    (%rsp),%rdi
or     %rdi,%rsi
mov    0x10(%rsp),%rbp
sub    %rbp,%rsi
mov    0xc8(%rsp),%rax
add    %rax,%rsi
mov    0x30(%rsp),%rdx
lea    (%rdx,%r13,4),%rdx
add    %rdi,%rdx
sub    %rbp,%rdx
add    %rax,%rdx
mov    %r8d,%eax
sub    %r13b,%al
add    $0x1,%al
movzbl %al,%edi
and    $0x3,%edi
xor    %eax,%eax
nop
movl   $0x0,(%rdx,%rax,4)
movl   $0x0,(%rsi,%rax,4)
add    $0x1,%rax
cmp    %eax,%edi
jne    1760 <open_loop_nbest_pitch+0x640>
add    %rax,%r13
mov    %r10,%rbp
cmp    $0x3,%ecx
jb     1826 <open_loop_nbest_pitch+0x706>
mov    0x8(%rsp),%rdx
shl    $0x2,%rdx
lea    0x8(,%rbp,4),%rcx
mov    0x38(%rsp),%rsi
sub    %r13d,%esi
add    $0x1,%esi
mov    0x30(%rsp),%rax
lea    (%rax,%r13,4),%rax
add    %rax,%rcx
add    %rdx,%rcx
mov    (%rsp),%rdi
add    %rdi,%rcx
mov    0x10(%rsp),%rbp
sub    %rbp,%rcx
mov    0xc8(%rsp),%rdx
add    %rdx,%rcx
add    %rdi,%rax
sub    %rbp,%rax
add    %rdx,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movl   $0x0,(%rax,%rdx,4)
movl   $0x0,(%rcx,%rdx,4)
movl   $0x0,0x4(%rax,%rdx,4)
movl   $0x0,0x4(%rcx,%rdx,4)
movl   $0x0,0x8(%rax,%rdx,4)
movl   $0x0,0x8(%rcx,%rdx,4)
movl   $0x0,0xc(%rax,%rdx,4)
movl   $0x0,0xc(%rcx,%rdx,4)
add    $0x4,%rdx
cmp    %edx,%esi
jne    17e0 <open_loop_nbest_pitch+0x6c0>
mov    0x18(%rsp),%eax
cmp    %eax,0x38(%rsp)
mov    0x50(%rsp),%eax
jl     18df <open_loop_nbest_pitch+0x7bf>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x10(%rsp)
mov    0x54(%rsp),%eax
mov    %rax,(%rsp)
xor    %r13d,%r13d
mov    %r14,0x8(%rsp)
mov    0x60(%rsp),%rbp
mov    %r12,%r14
mov    0x70(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r14,%rdi
mov    %r15,%rsi
mov    0x8(%rsp),%rdx
xor    %eax,%eax
call   1030 <inner_prod@plt>
mov    0x28(%rsp),%rsi
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x0(%rbp)
mulss  %xmm0,%xmm0
movss  (%r12,%r13,4),%xmm1
addss  0x76b(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,(%rsi,%r13,4)
add    $0x4,%rbp
add    $0x1,%r13
add    $0xfffffffffffffffc,%r15
cmp    %r13d,(%rsp)
jne    1870 <open_loop_nbest_pitch+0x750>
mov    0x18(%rsp),%eax
cmp    %eax,0x38(%rsp)
mov    0x78(%rsp),%r13
mov    0x40(%rsp),%r8
mov    0x68(%rsp),%rdi
mov    0x58(%rsp),%r9
jge    18f1 <open_loop_nbest_pitch+0x7d1>
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%r8),%eax
mov    %eax,0x8(%rsp)
movslq %eax,%r12
movss  0x10(%rsp),%xmm0
addss  0x70a(%rip),%xmm0
movss  %xmm0,0x10(%rsp)
mov    %r8,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,0x18(%rsp)
mov    %r8d,%ebp
movss  0x6ed(%rip),%xmm2
xorps  %xmm3,%xmm3
mov    0x20(%rsp),%r15
jmp    1949 <open_loop_nbest_pitch+0x829>
movss  %xmm1,(%rdi,%rax,4)
mov    %r15d,0x0(%r13,%rax,4)
movss  %xmm0,(%rbx,%rax,4)
add    $0x1,%r15
cmp    %r15d,%r9d
je     18df <open_loop_nbest_pitch+0x7bf>
mov    %r15,%r14
sub    0x20(%rsp),%r14
movss  (%rsi,%r14,4),%xmm0
ucomiss (%rdi,%r12,4),%xmm0
jbe    1940 <open_loop_nbest_pitch+0x820>
mov    0x80(%rsp),%rax
movss  (%rax,%r14,4),%xmm0
mov    0x48(%rsp),%rax
movss  (%rax,%r14,4),%xmm1
addss  %xmm2,%xmm1
movaps %xmm0,%xmm4
divss  %xmm1,%xmm4
mulss  %xmm4,%xmm0
divss  0x10(%rsp),%xmm0
ucomiss %xmm3,%xmm0
jb     19a0 <open_loop_nbest_pitch+0x880>
sqrtss %xmm0,%xmm0
test   %r8d,%r8d
jg     19d7 <open_loop_nbest_pitch+0x8b7>
jmp    1940 <open_loop_nbest_pitch+0x820>
nopl   0x0(%rax)
movss  %xmm4,(%rsp)
call   1040 <sqrtf@plt>
movss  (%rsp),%xmm4
xorps  %xmm3,%xmm3
movss  0x65a(%rip),%xmm2
mov    0x28(%rsp),%rsi
mov    0x58(%rsp),%r9
mov    0x68(%rsp),%rdi
mov    0x40(%rsp),%r8
test   %r8d,%r8d
jle    1940 <open_loop_nbest_pitch+0x820>
minss  %xmm0,%xmm4
xorps  %xmm0,%xmm0
maxss  %xmm4,%xmm0
movss  (%rsi,%r14,4),%xmm1
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
ucomiss (%rdi,%rax,4),%xmm1
ja     1a04 <open_loop_nbest_pitch+0x8e4>
add    $0x1,%rax
cmp    %rax,%rbp
jne    19f0 <open_loop_nbest_pitch+0x8d0>
jmp    1940 <open_loop_nbest_pitch+0x820>
cmp    %eax,0x8(%rsp)
jle    1931 <open_loop_nbest_pitch+0x811>
mov    0x18(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  -0x4(%rdi,%rcx,4),%xmm1
movss  %xmm1,(%rdi,%rcx,4)
mov    -0x4(%r13,%rcx,4),%edx
mov    %edx,0x0(%r13,%rcx,4)
movss  -0x4(%rbx,%rcx,4),%xmm1
movss  %xmm1,(%rbx,%rcx,4)
lea    -0x1(%rcx),%rdx
mov    %rdx,%rcx
cmp    %rax,%rdx
jg     1a20 <open_loop_nbest_pitch+0x900>
movss  (%rsi,%r14,4),%xmm1
jmp    1931 <open_loop_nbest_pitch+0x811>

LLVM IR (-O0):
define void @open_loop_nbest_pitch(float* %0, i32 %1, i32 %2, i32 %3, i32* %4, float* %5, i32 %6, i8* %7) {
%9 = alloca float*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32*
%14 = alloca float*
%15 = alloca i32
%16 = alloca i8*
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca float*
%21 = alloca float
%22 = alloca float*
%23 = alloca float*
%24 = alloca float*
%25 = alloca float
%26 = alloca float
store float* %0, float** %9
store i32 %1, i32* %10
store i32 %2, i32* %11
store i32 %3, i32* %12
store i32* %4, i32** %13
store float* %5, float** %14
store i32 %6, i32* %15
store i8* %7, i8** %16
%27 = load i8*, i8** %16
%28 = ptrtoint i8* %27 to i32
%29 = sext i32 %28 to i64
%30 = sub i64 4, %29
%31 = and i64 %30, 3
%32 = load i8*, i8** %16
%33 = getelementptr inbounds i8, i8* %32, i64 %31
store i8* %33, i8** %16
%34 = load i32, i32* %15
%35 = sext i32 %34 to i64
%36 = mul i64 %35, 4
%37 = load i8*, i8** %16
%38 = getelementptr inbounds i8, i8* %37, i64 %36
store i8* %38, i8** %16
%39 = load i8*, i8** %16
%40 = load i32, i32* %15
%41 = sext i32 %40 to i64
%42 = mul i64 %41, 4
%43 = sub i64 0, %42
%44 = getelementptr inbounds i8, i8* %39, i64 %43
%45 = bitcast i8* %44 to float*
store float* %45, float** %20
%46 = load i8*, i8** %16
%47 = ptrtoint i8* %46 to i32
%48 = sext i32 %47 to i64
%49 = sub i64 4, %48
%50 = and i64 %49, 3
%51 = load i8*, i8** %16
%52 = getelementptr inbounds i8, i8* %51, i64 %50
store i8* %52, i8** %16
%53 = load i32, i32* %11
%54 = load i32, i32* %10
%55 = sub nsw i32 %53, %54
%56 = add nsw i32 %55, 1
%57 = sext i32 %56 to i64
%58 = mul i64 %57, 4
%59 = load i8*, i8** %16
%60 = getelementptr inbounds i8, i8* %59, i64 %58
store i8* %60, i8** %16
%61 = load i8*, i8** %16
%62 = load i32, i32* %11
%63 = load i32, i32* %10
%64 = sub nsw i32 %62, %63
%65 = add nsw i32 %64, 1
%66 = sext i32 %65 to i64
%67 = mul i64 %66, 4
%68 = sub i64 0, %67
%69 = getelementptr inbounds i8, i8* %61, i64 %68
%70 = bitcast i8* %69 to float*
store float* %70, float** %22
%71 = load i8*, i8** %16
%72 = ptrtoint i8* %71 to i32
%73 = sext i32 %72 to i64
%74 = sub i64 4, %73
%75 = and i64 %74, 3
%76 = load i8*, i8** %16
%77 = getelementptr inbounds i8, i8* %76, i64 %75
store i8* %77, i8** %16
%78 = load i32, i32* %11
%79 = load i32, i32* %10
%80 = sub nsw i32 %78, %79
%81 = add nsw i32 %80, 2
%82 = sext i32 %81 to i64
%83 = mul i64 %82, 4
%84 = load i8*, i8** %16
%85 = getelementptr inbounds i8, i8* %84, i64 %83
store i8* %85, i8** %16
%86 = load i8*, i8** %16
%87 = load i32, i32* %11
%88 = load i32, i32* %10
%89 = sub nsw i32 %87, %88
%90 = add nsw i32 %89, 2
%91 = sext i32 %90 to i64
%92 = mul i64 %91, 4
%93 = sub i64 0, %92
%94 = getelementptr inbounds i8, i8* %86, i64 %93
%95 = bitcast i8* %94 to float*
store float* %95, float** %23
%96 = load i8*, i8** %16
%97 = ptrtoint i8* %96 to i32
%98 = sext i32 %97 to i64
%99 = sub i64 4, %98
%100 = and i64 %99, 3
%101 = load i8*, i8** %16
%102 = getelementptr inbounds i8, i8* %101, i64 %100
store i8* %102, i8** %16
%103 = load i32, i32* %11
%104 = load i32, i32* %10
%105 = sub nsw i32 %103, %104
%106 = add nsw i32 %105, 1
%107 = sext i32 %106 to i64
%108 = mul i64 %107, 4
%109 = load i8*, i8** %16
%110 = getelementptr inbounds i8, i8* %109, i64 %108
store i8* %110, i8** %16
%111 = load i8*, i8** %16
%112 = load i32, i32* %11
%113 = load i32, i32* %10
%114 = sub nsw i32 %112, %113
%115 = add nsw i32 %114, 1
%116 = sext i32 %115 to i64
%117 = mul i64 %116, 4
%118 = sub i64 0, %117
%119 = getelementptr inbounds i8, i8* %111, i64 %118
%120 = bitcast i8* %119 to float*
store float* %120, float** %24
store i32 0, i32* %17
br label %121
121: ; preds = %134, %8
%122 = load i32, i32* %17
%123 = load i32, i32* %15
%124 = icmp slt i32 %122, %123
br i1 %124, label %125, label %137
125: ; preds = %121
%126 = load float*, float** %20
%127 = load i32, i32* %17
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds float, float* %126, i64 %128
store float -1.000000e+00, float* %129
%130 = load float*, float** %14
%131 = load i32, i32* %17
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds float, float* %130, i64 %132
store float 0.000000e+00, float* %133
br label %134
134: ; preds = %125
%135 = load i32, i32* %17
%136 = add nsw i32 %135, 1
store i32 %136, i32* %17
br label %121
137: ; preds = %121
%138 = load float*, float** %9
%139 = load i32, i32* %10
%140 = sext i32 %139 to i64
%141 = sub i64 0, %140
%142 = getelementptr inbounds float, float* %138, i64 %141
%143 = load float*, float** %9
%144 = load i32, i32* %10
%145 = sext i32 %144 to i64
%146 = sub i64 0, %145
%147 = getelementptr inbounds float, float* %143, i64 %146
%148 = load i32, i32* %12
%149 = call i32 (float*, float*, i32, ...) bitcast (i32 (...)* @inner_prod to i32 (float*, float*, i32, ...)*)(float* %142, float* %147, i32 %148)
%150 = sitofp i32 %149 to float
%151 = load float*, float** %23
%152 = getelementptr inbounds float, float* %151, i64 0
store float %150, float* %152
%153 = load float*, float** %9
%154 = load float*, float** %9
%155 = load i32, i32* %12
%156 = call i32 (float*, float*, i32, ...) bitcast (i32 (...)* @inner_prod to i32 (float*, float*, i32, ...)*)(float* %153, float* %154, i32 %155)
%157 = sitofp i32 %156 to float
store float %157, float* %21
%158 = load i32, i32* %10
store i32 %158, i32* %17
br label %159
159: ; preds = %213, %137
%160 = load i32, i32* %17
%161 = load i32, i32* %11
%162 = icmp sle i32 %160, %161
br i1 %162, label %163, label %216
163: ; preds = %159
%164 = load float*, float** %23
%165 = load i32, i32* %17
%166 = load i32, i32* %10
%167 = sub nsw i32 %165, %166
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds float, float* %164, i64 %168
%170 = load float, float* %169
%171 = load float*, float** %9
%172 = load i32, i32* %17
%173 = sub nsw i32 0, %172
%174 = sub nsw i32 %173, 1
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds float, float* %171, i64 %175
%177 = load float, float* %176
%178 = load float*, float** %9
%179 = load i32, i32* %17
%180 = sub nsw i32 0, %179
%181 = sub nsw i32 %180, 1
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds float, float* %178, i64 %182
%184 = load float, float* %183
%185 = call float @llvm.fmuladd.f32(float %177, float %184, float %170)
%186 = load float*, float** %9
%187 = load i32, i32* %17
%188 = sub nsw i32 0, %187
%189 = load i32, i32* %12
%190 = add nsw i32 %188, %189
%191 = sub nsw i32 %190, 1
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds float, float* %186, i64 %192
%194 = load float, float* %193
%195 = load float*, float** %9
%196 = load i32, i32* %17
%197 = sub nsw i32 0, %196
%198 = load i32, i32* %12
%199 = add nsw i32 %197, %198
%200 = sub nsw i32 %199, 1
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds float, float* %195, i64 %201
%203 = load float, float* %202
%204 = fneg float %194
%205 = call float @llvm.fmuladd.f32(float %204, float %203, float %185)
%206 = load float*, float** %23
%207 = load i32, i32* %17
%208 = load i32, i32* %10
%209 = sub nsw i32 %207, %208
%210 = add nsw i32 %209, 1
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds float, float* %206, i64 %211
store float %205, float* %212
br label %213
213: ; preds = %163
%214 = load i32, i32* %17
%215 = add nsw i32 %214, 1
store i32 %215, i32* %17
br label %159
216: ; preds = %159
%217 = load i32, i32* %10
store i32 %217, i32* %17
br label %218
218: ; preds = %235, %216
%219 = load i32, i32* %17
%220 = load i32, i32* %11
%221 = icmp sle i32 %219, %220
br i1 %221, label %222, label %238
222: ; preds = %218
%223 = load float*, float** %22
%224 = load i32, i32* %17
%225 = load i32, i32* %10
%226 = sub nsw i32 %224, %225
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds float, float* %223, i64 %227
store float 0.000000e+00, float* %228
%229 = load float*, float** %24
%230 = load i32, i32* %17
%231 = load i32, i32* %10
%232 = sub nsw i32 %230, %231
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds float, float* %229, i64 %233
store float 0.000000e+00, float* %234
br label %235
235: ; preds = %222
%236 = load i32, i32* %17
%237 = add nsw i32 %236, 1
store i32 %237, i32* %17
br label %218
238: ; preds = %218
%239 = load i32, i32* %10
store i32 %239, i32* %17
br label %240
240: ; preds = %290, %238
%241 = load i32, i32* %17
%242 = load i32, i32* %11
%243 = icmp sle i32 %241, %242
br i1 %243, label %244, label %293
244: ; preds = %240
%245 = load float*, float** %9
%246 = load float*, float** %9
%247 = load i32, i32* %17
%248 = sext i32 %247 to i64
%249 = sub i64 0, %248
%250 = getelementptr inbounds float, float* %246, i64 %249
%251 = load i32, i32* %12
%252 = call i32 (float*, float*, i32, ...) bitcast (i32 (...)* @inner_prod to i32 (float*, float*, i32, ...)*)(float* %245, float* %250, i32 %251)
%253 = sitofp i32 %252 to float
%254 = load float*, float** %22
%255 = load i32, i32* %17
%256 = load i32, i32* %10
%257 = sub nsw i32 %255, %256
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds float, float* %254, i64 %258
store float %253, float* %259
%260 = load float*, float** %22
%261 = load i32, i32* %17
%262 = load i32, i32* %10
%263 = sub nsw i32 %261, %262
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds float, float* %260, i64 %264
%266 = load float, float* %265
%267 = load float*, float** %22
%268 = load i32, i32* %17
%269 = load i32, i32* %10
%270 = sub nsw i32 %268, %269
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds float, float* %267, i64 %271
%273 = load float, float* %272
%274 = fmul float %266, %273
%275 = load float*, float** %23
%276 = load i32, i32* %17
%277 = load i32, i32* %10
%278 = sub nsw i32 %276, %277
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds float, float* %275, i64 %279
%281 = load float, float* %280
%282 = fadd float %281, 1.000000e+00
%283 = fdiv float %274, %282
%284 = load float*, float** %24
%285 = load i32, i32* %17
%286 = load i32, i32* %10
%287 = sub nsw i32 %285, %286
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds float, float* %284, i64 %288
store float %283, float* %289
br label %290
290: ; preds = %244
%291 = load i32, i32* %17
%292 = add nsw i32 %291, 1
store i32 %292, i32* %17
br label %240
293: ; preds = %240
%294 = load i32, i32* %10
store i32 %294, i32* %17
br label %295
295: ; preds = %443, %293
%296 = load i32, i32* %17
%297 = load i32, i32* %11
%298 = icmp sle i32 %296, %297
br i1 %298, label %299, label %446
299: ; preds = %295
%300 = load float*, float** %24
%301 = load i32, i32* %17
%302 = load i32, i32* %10
%303 = sub nsw i32 %301, %302
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds float, float* %300, i64 %304
%306 = load float, float* %305
%307 = load float*, float** %20
%308 = load i32, i32* %15
%309 = sub nsw i32 %308, 1
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds float, float* %307, i64 %310
%312 = load float, float* %311
%313 = fcmp ogt float %306, %312
br i1 %313, label %314, label %442
314: ; preds = %299
%315 = load float*, float** %22
%316 = load i32, i32* %17
%317 = load i32, i32* %10
%318 = sub nsw i32 %316, %317
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds float, float* %315, i64 %319
%321 = load float, float* %320
%322 = load float*, float** %23
%323 = load i32, i32* %17
%324 = load i32, i32* %10
%325 = sub nsw i32 %323, %324
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds float, float* %322, i64 %326
%328 = load float, float* %327
%329 = fadd float %328, 1.000000e+01
%330 = fdiv float %321, %329
store float %330, float* %25
%331 = load float, float* %25
%332 = load float*, float** %22
%333 = load i32, i32* %17
%334 = load i32, i32* %10
%335 = sub nsw i32 %333, %334
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds float, float* %332, i64 %336
%338 = load float, float* %337
%339 = fmul float %331, %338
%340 = load float, float* %21
%341 = fadd float %340, 1.000000e+01
%342 = fdiv float %339, %341
%343 = fpext float %342 to double
%344 = call double @sqrt(double %343)
%345 = fptrunc double %344 to float
store float %345, float* %26
%346 = load float, float* %26
%347 = load float, float* %25
%348 = fcmp ogt float %346, %347
br i1 %348, label %349, label %351
349: ; preds = %314
%350 = load float, float* %25
store float %350, float* %26
br label %351
351: ; preds = %349, %314
%352 = load float, float* %26
%353 = fcmp olt float %352, 0.000000e+00
br i1 %353, label %354, label %355
354: ; preds = %351
store float 0.000000e+00, float* %26
br label %355
355: ; preds = %354, %351
store i32 0, i32* %18
br label %356
356: ; preds = %438, %355
%357 = load i32, i32* %18
%358 = load i32, i32* %15
%359 = icmp slt i32 %357, %358
br i1 %359, label %360, label %441
360: ; preds = %356
%361 = load float*, float** %24
%362 = load i32, i32* %17
%363 = load i32, i32* %10
%364 = sub nsw i32 %362, %363
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds float, float* %361, i64 %365
%367 = load float, float* %366
%368 = load float*, float** %20
%369 = load i32, i32* %18
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds float, float* %368, i64 %370
%372 = load float, float* %371
%373 = fcmp ogt float %367, %372
br i1 %373, label %374, label %437
374: ; preds = %360
%375 = load i32, i32* %15
%376 = sub nsw i32 %375, 1
store i32 %376, i32* %19
br label %377
377: ; preds = %412, %374
%378 = load i32, i32* %19
%379 = load i32, i32* %18
%380 = icmp sgt i32 %378, %379
br i1 %380, label %381, label %415
381: ; preds = %377
%382 = load float*, float** %20
%383 = load i32, i32* %19
%384 = sub nsw i32 %383, 1
%385 = sext i32 %384 to i64
%386 = getelementptr inbounds float, float* %382, i64 %385
%387 = load float, float* %386
%388 = load float*, float** %20
%389 = load i32, i32* %19
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds float, float* %388, i64 %390
store float %387, float* %391
%392 = load i32*, i32** %13
%393 = load i32, i32* %19
%394 = sub nsw i32 %393, 1
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds i32, i32* %392, i64 %395
%397 = load i32, i32* %396
%398 = load i32*, i32** %13
%399 = load i32, i32* %19
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds i32, i32* %398, i64 %400
store i32 %397, i32* %401
%402 = load float*, float** %14
%403 = load i32, i32* %19
%404 = sub nsw i32 %403, 1
%405 = sext i32 %404 to i64
%406 = getelementptr inbounds float, float* %402, i64 %405
%407 = load float, float* %406
%408 = load float*, float** %14
%409 = load i32, i32* %19
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds float, float* %408, i64 %410
store float %407, float* %411
br label %412
412: ; preds = %381
%413 = load i32, i32* %19
%414 = add nsw i32 %413, -1
store i32 %414, i32* %19
br label %377
415: ; preds = %377
%416 = load float*, float** %24
%417 = load i32, i32* %17
%418 = load i32, i32* %10
%419 = sub nsw i32 %417, %418
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds float, float* %416, i64 %420
%422 = load float, float* %421
%423 = load float*, float** %20
%424 = load i32, i32* %18
%425 = sext i32 %424 to i64
%426 = getelementptr inbounds float, float* %423, i64 %425
store float %422, float* %426
%427 = load i32, i32* %17
%428 = load i32*, i32** %13
%429 = load i32, i32* %18
%430 = sext i32 %429 to i64
%431 = getelementptr inbounds i32, i32* %428, i64 %430
store i32 %427, i32* %431
%432 = load float, float* %26
%433 = load float*, float** %14
%434 = load i32, i32* %18
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds float, float* %433, i64 %435
store float %432, float* %436
br label %441
437: ; preds = %360
br label %438
438: ; preds = %437
%439 = load i32, i32* %18
%440 = add nsw i32 %439, 1
store i32 %440, i32* %18
br label %356
441: ; preds = %415, %356
br label %442
442: ; preds = %441, %299
br label %443
443: ; preds = %442
%444 = load i32, i32* %17
%445 = add nsw i32 %444, 1
store i32 %445, i32* %17
br label %295
446: ; preds = %295
ret void
}

LLVM IR (-O2):
define void @open_loop_nbest_pitch(float* %0, i32 %1, i32 %2, i32 %3, i32* nocapture %4, float* nocapture %5, i32 %6, i8* %7) {
%9 = bitcast float* %5 to i8*
%10 = ptrtoint i8* %7 to i64
%11 = sub i64 0, %10
%12 = and i64 %11, 3
%13 = getelementptr i8, i8* %7, i64 %12
%14 = sext i32 %6 to i64
%15 = shl nsw i64 %14, 2
%16 = getelementptr i8, i8* %13, i64 %15
%17 = sub nsw i64 0, %15
%18 = getelementptr inbounds i8, i8* %16, i64 %17
%19 = bitcast i8* %18 to float*
%20 = ptrtoint i8* %16 to i64
%21 = sub i64 0, %20
%22 = and i64 %21, 3
%23 = getelementptr inbounds i8, i8* %16, i64 %22
%24 = sub nsw i32 %2, %1
%25 = add nsw i32 %24, 1
%26 = sext i32 %25 to i64
%27 = shl nsw i64 %26, 2
%28 = getelementptr inbounds i8, i8* %23, i64 %27
%29 = sub nsw i64 0, %27
%30 = getelementptr inbounds i8, i8* %28, i64 %29
%31 = bitcast i8* %30 to float*
%32 = ptrtoint i8* %28 to i64
%33 = sub i64 0, %32
%34 = and i64 %33, 3
%35 = getelementptr inbounds i8, i8* %28, i64 %34
%36 = add nsw i32 %24, 2
%37 = sext i32 %36 to i64
%38 = shl nsw i64 %37, 2
%39 = getelementptr inbounds i8, i8* %35, i64 %38
%40 = sub nsw i64 0, %38
%41 = getelementptr i8, i8* %39, i64 %40
%42 = bitcast i8* %41 to float*
%43 = ptrtoint i8* %39 to i64
%44 = sub i64 0, %43
%45 = and i64 %44, 3
%46 = getelementptr inbounds i8, i8* %39, i64 %45
%47 = getelementptr inbounds i8, i8* %46, i64 %27
%48 = getelementptr i8, i8* %47, i64 %29
%49 = bitcast i8* %48 to float*
%50 = icmp sgt i32 %6, 0
br i1 %50, label %51, label %164
51: ; preds = %8
%52 = zext i32 %6 to i64
%53 = icmp ult i32 %6, 8
br i1 %53, label %132, label %54
54: ; preds = %51
%55 = shl nuw nsw i64 %52, 2
%56 = or i64 %55, %12
%57 = getelementptr i8, i8* %7, i64 %56
%58 = getelementptr float, float* %5, i64 %52
%59 = bitcast float* %58 to i8*
%60 = icmp ult i8* %13, %59
%61 = icmp ugt i8* %57, %9
%62 = and i1 %60, %61
br i1 %62, label %132, label %63
63: ; preds = %54
%64 = and i64 %52, 4294967288
%65 = add nsw i64 %64, -8
%66 = lshr exact i64 %65, 3
%67 = add nuw nsw i64 %66, 1
%68 = and i64 %67, 3
%69 = icmp ult i64 %65, 24
br i1 %69, label %113, label %70
70: ; preds = %63
%71 = and i64 %67, 4611686018427387900
br label %72
72: ; preds = %72, %70
%73 = phi i64 [ 0, %70 ], [ %110, %72 ]
%74 = phi i64 [ 0, %70 ], [ %111, %72 ]
%75 = getelementptr inbounds float, float* %19, i64 %73
%76 = bitcast float* %75 to <4 x float>*
store <4 x float> <float -1.000000e+00, float -1.000000e+00, float -1.000000e+00, float -1.000000e+00>, <4 x float>* %76
%77 = getelementptr inbounds float, float* %75, i64 4
%78 = bitcast float* %77 to <4 x float>*
store <4 x float> <float -1.000000e+00, float -1.000000e+00, float -1.000000e+00, float -1.000000e+00>, <4 x float>* %78
%79 = getelementptr inbounds float, float* %5, i64 %73
%80 = bitcast float* %79 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %80
%81 = getelementptr inbounds float, float* %79, i64 4
%82 = bitcast float* %81 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %82
%83 = or i64 %73, 8
%84 = getelementptr inbounds float, float* %19, i64 %83
%85 = bitcast float* %84 to <4 x float>*
store <4 x float> <float -1.000000e+00, float -1.000000e+00, float -1.000000e+00, float -1.000000e+00>, <4 x float>* %85
%86 = getelementptr inbounds float, float* %84, i64 4
%87 = bitcast float* %86 to <4 x float>*
store <4 x float> <float -1.000000e+00, float -1.000000e+00, float -1.000000e+00, float -1.000000e+00>, <4 x float>* %87
%88 = getelementptr inbounds float, float* %5, i64 %83
%89 = bitcast float* %88 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %89
%90 = getelementptr inbounds float, float* %88, i64 4
%91 = bitcast float* %90 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %91
%92 = or i64 %73, 16
%93 = getelementptr inbounds float, float* %19, i64 %92
%94 = bitcast float* %93 to <4 x float>*
store <4 x float> <float -1.000000e+00, float -1.000000e+00, float -1.000000e+00, float -1.000000e+00>, <4 x float>* %94
%95 = getelementptr inbounds float, float* %93, i64 4
%96 = bitcast float* %95 to <4 x float>*
store <4 x float> <float -1.000000e+00, float -1.000000e+00, float -1.000000e+00, float -1.000000e+00>, <4 x float>* %96
%97 = getelementptr inbounds float, float* %5, i64 %92
%98 = bitcast float* %97 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %98
%99 = getelementptr inbounds float, float* %97, i64 4
%100 = bitcast float* %99 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %100
%101 = or i64 %73, 24
%102 = getelementptr inbounds float, float* %19, i64 %101
%103 = bitcast float* %102 to <4 x float>*
store <4 x float> <float -1.000000e+00, float -1.000000e+00, float -1.000000e+00, float -1.000000e+00>, <4 x float>* %103
%104 = getelementptr inbounds float, float* %102, i64 4
%105 = bitcast float* %104 to <4 x float>*
store <4 x float> <float -1.000000e+00, float -1.000000e+00, float -1.000000e+00, float -1.000000e+00>, <4 x float>* %105
%106 = getelementptr inbounds float, float* %5, i64 %101
%107 = bitcast float* %106 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %107
%108 = getelementptr inbounds float, float* %106, i64 4
%109 = bitcast float* %108 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %109
%110 = add nuw i64 %73, 32
%111 = add i64 %74, 4
%112 = icmp eq i64 %111, %71
br i1 %112, label %113, label %72
113: ; preds = %72, %63
%114 = phi i64 [ 0, %63 ], [ %110, %72 ]
%115 = icmp eq i64 %68, 0
br i1 %115, label %130, label %116
116: ; preds = %113, %116
%117 = phi i64 [ %127, %116 ], [ %114, %113 ]
%118 = phi i64 [ %128, %116 ], [ 0, %113 ]
%119 = getelementptr inbounds float, float* %19, i64 %117
%120 = bitcast float* %119 to <4 x float>*
store <4 x float> <float -1.000000e+00, float -1.000000e+00, float -1.000000e+00, float -1.000000e+00>, <4 x float>* %120
%121 = getelementptr inbounds float, float* %119, i64 4
%122 = bitcast float* %121 to <4 x float>*
store <4 x float> <float -1.000000e+00, float -1.000000e+00, float -1.000000e+00, float -1.000000e+00>, <4 x float>* %122
%123 = getelementptr inbounds float, float* %5, i64 %117
%124 = bitcast float* %123 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %124
%125 = getelementptr inbounds float, float* %123, i64 4
%126 = bitcast float* %125 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %126
%127 = add nuw i64 %117, 8
%128 = add i64 %118, 1
%129 = icmp eq i64 %128, %68
br i1 %129, label %130, label %116
130: ; preds = %116, %113
%131 = icmp eq i64 %64, %52
br i1 %131, label %164, label %132
132: ; preds = %54, %51, %130
%133 = phi i64 [ 0, %54 ], [ 0, %51 ], [ %64, %130 ]
%134 = xor i64 %133, -1
%135 = add nsw i64 %134, %52
%136 = and i64 %52, 3
%137 = icmp eq i64 %136, 0
br i1 %137, label %146, label %138
138: ; preds = %132, %138
%139 = phi i64 [ %143, %138 ], [ %133, %132 ]
%140 = phi i64 [ %144, %138 ], [ 0, %132 ]
%141 = getelementptr inbounds float, float* %19, i64 %139
store float -1.000000e+00, float* %141
%142 = getelementptr inbounds float, float* %5, i64 %139
store float 0.000000e+00, float* %142
%143 = add nuw nsw i64 %139, 1
%144 = add i64 %140, 1
%145 = icmp eq i64 %144, %136
br i1 %145, label %146, label %138
146: ; preds = %138, %132
%147 = phi i64 [ %133, %132 ], [ %143, %138 ]
%148 = icmp ult i64 %135, 3
br i1 %148, label %164, label %149
149: ; preds = %146, %149
%150 = phi i64 [ %162, %149 ], [ %147, %146 ]
%151 = getelementptr inbounds float, float* %19, i64 %150
store float -1.000000e+00, float* %151
%152 = getelementptr inbounds float, float* %5, i64 %150
store float 0.000000e+00, float* %152
%153 = add nuw nsw i64 %150, 1
%154 = getelementptr inbounds float, float* %19, i64 %153
store float -1.000000e+00, float* %154
%155 = getelementptr inbounds float, float* %5, i64 %153
store float 0.000000e+00, float* %155
%156 = add nuw nsw i64 %150, 2
%157 = getelementptr inbounds float, float* %19, i64 %156
store float -1.000000e+00, float* %157
%158 = getelementptr inbounds float, float* %5, i64 %156
store float 0.000000e+00, float* %158
%159 = add nuw nsw i64 %150, 3
%160 = getelementptr inbounds float, float* %19, i64 %159
store float -1.000000e+00, float* %160
%161 = getelementptr inbounds float, float* %5, i64 %159
store float 0.000000e+00, float* %161
%162 = add nuw nsw i64 %150, 4
%163 = icmp eq i64 %162, %52
br i1 %163, label %164, label %149
164: ; preds = %146, %149, %130, %8
%165 = sext i32 %1 to i64
%166 = sub nsw i64 0, %165
%167 = getelementptr inbounds float, float* %0, i64 %166
%168 = tail call i32 (float*, float*, i32, ...) bitcast (i32 (...)* @inner_prod to i32 (float*, float*, i32, ...)*)(float* %167, float* %167, i32 %3)
%169 = sitofp i32 %168 to float
store float %169, float* %42
%170 = tail call i32 (float*, float*, i32, ...) bitcast (i32 (...)* @inner_prod to i32 (float*, float*, i32, ...)*)(float* %0, float* %0, i32 %3)
%171 = sitofp i32 %170 to float
%172 = icmp slt i32 %2, %1
br i1 %172, label %456, label %173
173: ; preds = %164
%174 = add i32 %2, 1
%175 = sub i32 %2, %1
%176 = xor i32 %1, -1
%177 = sub i32 %176, %175
%178 = icmp sgt i32 %177, %176
%179 = xor i32 %1, -1
%180 = add i32 %179, %3
%181 = sub i32 %180, %175
%182 = icmp sgt i32 %181, %180
%183 = or i1 %178, %182
br i1 %183, label %184, label %206
184: ; preds = %173, %184
%185 = phi i64 [ %203, %184 ], [ %165, %173 ]
%186 = sub nsw i64 %185, %165
%187 = getelementptr inbounds float, float* %42, i64 %186
%188 = load float, float* %187
%189 = trunc i64 %185 to i32
%190 = xor i32 %189, -1
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds float, float* %0, i64 %191
%193 = load float, float* %192
%194 = tail call float @llvm.fmuladd.f32(float %193, float %193, float %188)
%195 = add i32 %190, %3
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds float, float* %0, i64 %196
%198 = load float, float* %197
%199 = fneg float %198
%200 = tail call float @llvm.fmuladd.f32(float %199, float %198, float %194)
%201 = add nuw nsw i64 %186, 1
%202 = getelementptr inbounds float, float* %42, i64 %201
store float %200, float* %202
%203 = add nsw i64 %185, 1
%204 = trunc i64 %203 to i32
%205 = icmp eq i32 %174, %204
br i1 %205, label %208, label %184
206: ; preds = %173
%207 = load float, float* %42
br label %323
208: ; preds = %323, %184
br i1 %172, label %456, label %209
209: ; preds = %208
%210 = add i32 %2, 1
%211 = sub i32 %2, %1
%212 = zext i32 %211 to i64
%213 = add nuw nsw i64 %212, 1
%214 = icmp ult i32 %211, 7
br i1 %214, label %303, label %215
215: ; preds = %209
%216 = sub i32 %2, %1
%217 = zext i32 %216 to i64
%218 = add nsw i64 %14, %217
%219 = shl nsw i64 %218, 2
%220 = or i64 %219, %12
%221 = add nsw i64 %220, 4
%222 = getelementptr i8, i8* %7, i64 %221
%223 = add nsw i64 %14, %37
%224 = add nsw i64 %223, %26
%225 = add nsw i64 %224, %217
%226 = shl nsw i64 %225, 2
%227 = or i64 %226, %12
%228 = add nsw i64 %227, 4
%229 = getelementptr i8, i8* %7, i64 %228
%230 = icmp ult i8* %16, %229
%231 = icmp ult i8* %48, %222
%232 = and i1 %230, %231
br i1 %232, label %303, label %233
233: ; preds = %215
%234 = and i64 %213, 8589934584
%235 = add nsw i64 %234, %165
%236 = add nsw i64 %234, -8
%237 = lshr exact i64 %236, 3
%238 = add nuw nsw i64 %237, 1
%239 = and i64 %238, 3
%240 = icmp ult i64 %236, 24
br i1 %240, label %284, label %241
241: ; preds = %233
%242 = and i64 %238, 4611686018427387900
br label %243
243: ; preds = %243, %241
%244 = phi i64 [ 0, %241 ], [ %281, %243 ]
%245 = phi i64 [ 0, %241 ], [ %282, %243 ]
%246 = getelementptr inbounds float, float* %31, i64 %244
%247 = bitcast float* %246 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %247
%248 = getelementptr inbounds float, float* %246, i64 4
%249 = bitcast float* %248 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %249
%250 = getelementptr inbounds float, float* %49, i64 %244
%251 = bitcast float* %250 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %251
%252 = getelementptr inbounds float, float* %250, i64 4
%253 = bitcast float* %252 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %253
%254 = or i64 %244, 8
%255 = getelementptr inbounds float, float* %31, i64 %254
%256 = bitcast float* %255 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %256
%257 = getelementptr inbounds float, float* %255, i64 4
%258 = bitcast float* %257 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %258
%259 = getelementptr inbounds float, float* %49, i64 %254
%260 = bitcast float* %259 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %260
%261 = getelementptr inbounds float, float* %259, i64 4
%262 = bitcast float* %261 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %262
%263 = or i64 %244, 16
%264 = getelementptr inbounds float, float* %31, i64 %263
%265 = bitcast float* %264 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %265
%266 = getelementptr inbounds float, float* %264, i64 4
%267 = bitcast float* %266 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %267
%268 = getelementptr inbounds float, float* %49, i64 %263
%269 = bitcast float* %268 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %269
%270 = getelementptr inbounds float, float* %268, i64 4
%271 = bitcast float* %270 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %271
%272 = or i64 %244, 24
%273 = getelementptr inbounds float, float* %31, i64 %272
%274 = bitcast float* %273 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %274
%275 = getelementptr inbounds float, float* %273, i64 4
%276 = bitcast float* %275 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %276
%277 = getelementptr inbounds float, float* %49, i64 %272
%278 = bitcast float* %277 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %278
%279 = getelementptr inbounds float, float* %277, i64 4
%280 = bitcast float* %279 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %280
%281 = add nuw i64 %244, 32
%282 = add i64 %245, 4
%283 = icmp eq i64 %282, %242
br i1 %283, label %284, label %243
284: ; preds = %243, %233
%285 = phi i64 [ 0, %233 ], [ %281, %243 ]
%286 = icmp eq i64 %239, 0
br i1 %286, label %301, label %287
287: ; preds = %284, %287
%288 = phi i64 [ %298, %287 ], [ %285, %284 ]
%289 = phi i64 [ %299, %287 ], [ 0, %284 ]
%290 = getelementptr inbounds float, float* %31, i64 %288
%291 = bitcast float* %290 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %291
%292 = getelementptr inbounds float, float* %290, i64 4
%293 = bitcast float* %292 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %293
%294 = getelementptr inbounds float, float* %49, i64 %288
%295 = bitcast float* %294 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %295
%296 = getelementptr inbounds float, float* %294, i64 4
%297 = bitcast float* %296 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %297
%298 = add nuw i64 %288, 8
%299 = add i64 %289, 1
%300 = icmp eq i64 %299, %239
br i1 %300, label %301, label %287
301: ; preds = %287, %284
%302 = icmp eq i64 %213, %234
br i1 %302, label %344, label %303
303: ; preds = %215, %209, %301
%304 = phi i64 [ %165, %215 ], [ %165, %209 ], [ %235, %301 ]
%305 = add i32 %2, 1
%306 = trunc i64 %304 to i32
%307 = sub i32 %305, %306
%308 = sub i32 %2, %306
%309 = and i32 %307, 3
%310 = icmp eq i32 %309, 0
br i1 %310, label %320, label %311
311: ; preds = %303, %311
%312 = phi i64 [ %317, %311 ], [ %304, %303 ]
%313 = phi i32 [ %318, %311 ], [ 0, %303 ]
%314 = sub nsw i64 %312, %165
%315 = getelementptr inbounds float, float* %31, i64 %314
store float 0.000000e+00, float* %315
%316 = getelementptr inbounds float, float* %49, i64 %314
store float 0.000000e+00, float* %316
%317 = add nsw i64 %312, 1
%318 = add i32 %313, 1
%319 = icmp eq i32 %318, %309
br i1 %319, label %320, label %311
320: ; preds = %311, %303
%321 = phi i64 [ %304, %303 ], [ %317, %311 ]
%322 = icmp ult i32 %308, 3
br i1 %322, label %344, label %347
323: ; preds = %206, %323
%324 = phi float [ %207, %206 ], [ %338, %323 ]
%325 = phi i64 [ %165, %206 ], [ %341, %323 ]
%326 = sub nsw i64 %325, %165
%327 = trunc i64 %325 to i32
%328 = xor i32 %327, -1
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds float, float* %0, i64 %329
%331 = load float, float* %330
%332 = tail call float @llvm.fmuladd.f32(float %331, float %331, float %324)
%333 = add i32 %328, %3
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds float, float* %0, i64 %334
%336 = load float, float* %335
%337 = fneg float %336
%338 = tail call float @llvm.fmuladd.f32(float %337, float %336, float %332)
%339 = add nuw nsw i64 %326, 1
%340 = getelementptr inbounds float, float* %42, i64 %339
store float %338, float* %340
%341 = add nsw i64 %325, 1
%342 = trunc i64 %341 to i32
%343 = icmp eq i32 %174, %342
br i1 %343, label %208, label %323
344: ; preds = %320, %347, %301
br i1 %172, label %456, label %345
345: ; preds = %344
%346 = add i32 %2, 1
br label %376
347: ; preds = %320, %347
%348 = phi i64 [ %364, %347 ], [ %321, %320 ]
%349 = sub nsw i64 %348, %165
%350 = getelementptr inbounds float, float* %31, i64 %349
store float 0.000000e+00, float* %350
%351 = getelementptr inbounds float, float* %49, i64 %349
store float 0.000000e+00, float* %351
%352 = add nsw i64 %348, 1
%353 = sub nsw i64 %352, %165
%354 = getelementptr inbounds float, float* %31, i64 %353
store float 0.000000e+00, float* %354
%355 = getelementptr inbounds float, float* %49, i64 %353
store float 0.000000e+00, float* %355
%356 = add nsw i64 %348, 2
%357 = sub nsw i64 %356, %165
%358 = getelementptr inbounds float, float* %31, i64 %357
store float 0.000000e+00, float* %358
%359 = getelementptr inbounds float, float* %49, i64 %357
store float 0.000000e+00, float* %359
%360 = add nsw i64 %348, 3
%361 = sub nsw i64 %360, %165
%362 = getelementptr inbounds float, float* %31, i64 %361
store float 0.000000e+00, float* %362
%363 = getelementptr inbounds float, float* %49, i64 %361
store float 0.000000e+00, float* %363
%364 = add nsw i64 %348, 4
%365 = trunc i64 %364 to i32
%366 = icmp eq i32 %210, %365
br i1 %366, label %344, label %347
367: ; preds = %376
br i1 %172, label %456, label %368
368: ; preds = %367
%369 = add nsw i32 %6, -1
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds float, float* %19, i64 %370
%372 = fadd float %171, 1.000000e+01
%373 = add nsw i64 %14, -1
%374 = add i32 %2, 1
%375 = zext i32 %6 to i64
br label %393
376: ; preds = %345, %376
%377 = phi i64 [ %165, %345 ], [ %390, %376 ]
%378 = sub nsw i64 0, %377
%379 = getelementptr inbounds float, float* %0, i64 %378
%380 = tail call i32 (float*, float*, i32, ...) bitcast (i32 (...)* @inner_prod to i32 (float*, float*, i32, ...)*)(float* %0, float* %379, i32 %3)
%381 = sitofp i32 %380 to float
%382 = sub nsw i64 %377, %165
%383 = getelementptr inbounds float, float* %31, i64 %382
store float %381, float* %383
%384 = fmul float %381, %381
%385 = getelementptr inbounds float, float* %42, i64 %382
%386 = load float, float* %385
%387 = fadd float %386, 1.000000e+00
%388 = fdiv float %384, %387
%389 = getelementptr inbounds float, float* %49, i64 %382
store float %388, float* %389
%390 = add nsw i64 %377, 1
%391 = trunc i64 %390 to i32
%392 = icmp eq i32 %346, %391
br i1 %392, label %367, label %376
393: ; preds = %368, %452
%394 = phi i64 [ %165, %368 ], [ %453, %452 ]
%395 = sub nsw i64 %394, %165
%396 = getelementptr inbounds float, float* %49, i64 %395
%397 = load float, float* %396
%398 = load float, float* %371
%399 = fcmp ogt float %397, %398
br i1 %399, label %400, label %452
400: ; preds = %393
%401 = getelementptr inbounds float, float* %31, i64 %395
%402 = load float, float* %401
%403 = getelementptr inbounds float, float* %42, i64 %395
%404 = load float, float* %403
%405 = fadd float %404, 1.000000e+01
%406 = fdiv float %402, %405
%407 = fmul float %402, %406
%408 = fdiv float %407, %372
%409 = tail call float @sqrtf(float %408)
%410 = fcmp ogt float %409, %406
%411 = select i1 %410, float %406, float %409
%412 = fcmp olt float %411, 0.000000e+00
%413 = select i1 %412, float 0.000000e+00, float %411
br i1 %50, label %414, label %452
414: ; preds = %400
%415 = load float, float* %396
br label %416
416: ; preds = %414, %449
%417 = phi i64 [ 0, %414 ], [ %450, %449 ]
%418 = getelementptr inbounds float, float* %19, i64 %417
%419 = load float, float* %418
%420 = fcmp ogt float %415, %419
br i1 %420, label %421, label %449
421: ; preds = %416
%422 = trunc i64 %417 to i32
%423 = and i64 %417, 4294967295
%424 = getelementptr inbounds float, float* %19, i64 %423
%425 = icmp sgt i32 %369, %422
br i1 %425, label %426, label %444
426: ; preds = %421
%427 = shl i64 %417, 32
%428 = ashr exact i64 %427, 32
br label %429
429: ; preds = %426, %429
%430 = phi i64 [ %373, %426 ], [ %431, %429 ]
%431 = add nsw i64 %430, -1
%432 = getelementptr inbounds float, float* %19, i64 %431
%433 = load float, float* %432
%434 = getelementptr inbounds float, float* %19, i64 %430
store float %433, float* %434
%435 = getelementptr inbounds i32, i32* %4, i64 %431
%436 = load i32, i32* %435
%437 = getelementptr inbounds i32, i32* %4, i64 %430
store i32 %436, i32* %437
%438 = getelementptr inbounds float, float* %5, i64 %431
%439 = load float, float* %438
%440 = getelementptr inbounds float, float* %5, i64 %430
store float %439, float* %440
%441 = icmp sgt i64 %431, %428
br i1 %441, label %429, label %442
442: ; preds = %429
%443 = load float, float* %396
br label %444
444: ; preds = %442, %421
%445 = phi float [ %443, %442 ], [ %415, %421 ]
store float %445, float* %424
%446 = getelementptr inbounds i32, i32* %4, i64 %423
%447 = trunc i64 %394 to i32
store i32 %447, i32* %446
%448 = getelementptr inbounds float, float* %5, i64 %423
store float %413, float* %448
br label %452
449: ; preds = %416
%450 = add nuw nsw i64 %417, 1
%451 = icmp eq i64 %450, %375
br i1 %451, label %452, label %416
452: ; preds = %449, %400, %444, %393
%453 = add nsw i64 %394, 1
%454 = trunc i64 %453 to i32
%455 = icmp eq i32 %374, %454
br i1 %455, label %456, label %393
456: ; preds = %452, %164, %208, %344, %367
ret void
}