void cftsub(int n, float *a, float *w) {
  int j, j1, j2, j3, k, k1, ks, l, m;
  float wk1r, wk1i, wk2r, wk2i, wk3r, wk3i;
  float x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
  l = 2;
  while ((l << 1) < n) {
    m = l << 2;
    for (j = 0; j <= l - 2; j += 2) {
      j1 = j + l;
      j2 = j1 + l;
      j3 = j2 + l;
      x0r = a[j] + a[j1];
      x0i = a[j + 1] + a[j1 + 1];
      x1r = a[j] - a[j1];
      x1i = a[j + 1] - a[j1 + 1];
      x2r = a[j2] + a[j3];
      x2i = a[j2 + 1] + a[j3 + 1];
      x3r = a[j2] - a[j3];
      x3i = a[j2 + 1] - a[j3 + 1];
      a[j] = x0r + x2r;
      a[j + 1] = x0i + x2i;
      a[j2] = x0r - x2r;
      a[j2 + 1] = x0i - x2i;
      a[j1] = x1r - x3i;
      a[j1 + 1] = x1i + x3r;
      a[j3] = x1r + x3i;
      a[j3 + 1] = x1i - x3r;
    }
    if (m < n) {
      wk1r = w[2];
      for (j = m; j <= l + m - 2; j += 2) {
        j1 = j + l;
        j2 = j1 + l;
        j3 = j2 + l;
        x0r = a[j] + a[j1];
        x0i = a[j + 1] + a[j1 + 1];
        x1r = a[j] - a[j1];
        x1i = a[j + 1] - a[j1 + 1];
        x2r = a[j2] + a[j3];
        x2i = a[j2 + 1] + a[j3 + 1];
        x3r = a[j2] - a[j3];
        x3i = a[j2 + 1] - a[j3 + 1];
        a[j] = x0r + x2r;
        a[j + 1] = x0i + x2i;
        a[j2] = x2i - x0i;
        a[j2 + 1] = x0r - x2r;
        x0r = x1r - x3i;
        x0i = x1i + x3r;
        a[j1] = wk1r * (x0r - x0i);
        a[j1 + 1] = wk1r * (x0r + x0i);
        x0r = x3i + x1r;
        x0i = x3r - x1i;
        a[j3] = wk1r * (x0i - x0r);
        a[j3 + 1] = wk1r * (x0i + x0r);
      }
      k1 = 1;
      ks = -1;
      for (k = (m << 1); k <= n - m; k += m) {
        k1++;
        ks = -ks;
        wk1r = w[k1 << 1];
        wk1i = w[(k1 << 1) + 1];
        wk2r = ks * w[k1];
        wk2i = w[k1 + ks];
        wk3r = wk1r - 2 * wk2i * wk1i;
        wk3i = 2 * wk2i * wk1r - wk1i;
        for (j = k; j <= l + k - 2; j += 2) {
          j1 = j + l;
          j2 = j1 + l;
          j3 = j2 + l;
          x0r = a[j] + a[j1];
          x0i = a[j + 1] + a[j1 + 1];
          x1r = a[j] - a[j1];
          x1i = a[j + 1] - a[j1 + 1];
          x2r = a[j2] + a[j3];
          x2i = a[j2 + 1] + a[j3 + 1];
          x3r = a[j2] - a[j3];
          x3i = a[j2 + 1] - a[j3 + 1];
          a[j] = x0r + x2r;
          a[j + 1] = x0i + x2i;
          x0r -= x2r;
          x0i -= x2i;
          a[j2] = wk2r * x0r - wk2i * x0i;
          a[j2 + 1] = wk2r * x0i + wk2i * x0r;
          x0r = x1r - x3i;
          x0i = x1i + x3r;
          a[j1] = wk1r * x0r - wk1i * x0i;
          a[j1 + 1] = wk1r * x0i + wk1i * x0r;
          x0r = x1r + x3i;
          x0i = x1i - x3r;
          a[j3] = wk3r * x0r - wk3i * x0i;
          a[j3 + 1] = wk3r * x0i + wk3i * x0r;
        }
      }
    }
    l = m;
  }
  if (l < n) {
    for (j = 0; j <= l - 2; j += 2) {
      j1 = j + l;
      x0r = a[j] - a[j1];
      x0i = a[j + 1] - a[j1 + 1];
      a[j] += a[j1];
      a[j + 1] += a[j1 + 1];
      a[j1] = x0r;
      a[j1 + 1] = x0i;
    }
  }
}


x86 assembly (clang, -O0):
<cftsub>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x2,-0x38(%rbp)
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
cmp    -0x4(%rbp),%eax
jge    1a45 <cftsub+0x945>
mov    -0x38(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     135b <cftsub+0x25b>
mov    -0x1c(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x58(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
subss  -0x74(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x64(%rbp),%xmm0
addss  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
addss  -0x74(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x64(%rbp),%xmm0
subss  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    1135 <cftsub+0x35>
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1a3a <cftsub+0x93a>
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x38(%rbp),%ecx
add    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     1604 <cftsub+0x504>
mov    -0x1c(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x58(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
subss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x64(%rbp),%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
subss  -0x5c(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
addss  -0x5c(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x70(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm1
subss  -0x58(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm1
addss  -0x58(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    137b <cftsub+0x27b>
movl   $0x1,-0x30(%rbp)
movl   $0xffffffff,-0x34(%rbp)
mov    -0x3c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
cmp    %ecx,%eax
jg     1a35 <cftsub+0x935>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
xor    %eax,%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
cvtsi2ssl -0x34(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x40(%rbp),%xmm1
movss  0x957(%rip),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  0x92b(%rip),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x38(%rbp),%ecx
add    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     1a22 <cftsub+0x922>
mov    -0x1c(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x58(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x6c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x48(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x5c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
subss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x64(%rbp),%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x5c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
addss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x64(%rbp),%xmm0
subss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x50(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  -0x5c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    1704 <cftsub+0x604>
jmp    1a27 <cftsub+0x927>
mov    -0x3c(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    161b <cftsub+0x51b>
jmp    1a3a <cftsub+0x93a>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    1116 <cftsub+0x16>
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1b3e <cftsub+0xa3e>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     1b39 <cftsub+0xa39>
mov    -0x1c(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    1a58 <cftsub+0x958>
jmp    1b3e <cftsub+0xa3e>
pop    %rbp
ret

x86 assembly (clang, -O2):
<cftsub>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
cmp    $0x5,%edi
jl     1712 <cftsub+0x612>
mov    %rdx,-0x68(%rsp)
lea    0x4(%rsi),%rax
mov    %rax,-0x38(%rsp)
mov    $0x2,%r11d
mov    %edi,-0x7c(%rsp)
jmp    114f <cftsub+0x4f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
shl    $0x3,%r15d
mov    %r15d,%ecx
cmp    %edi,%ecx
jge    1722 <cftsub+0x622>
mov    %r11d,%r15d
lea    0x0(,%r15,4),%r11d
lea    -0x2(%r15),%eax
mov    %rax,-0x60(%rsp)
cmp    $0x2,%r15d
jl     1273 <cftsub+0x173>
mov    %r15d,%eax
mov    -0x60(%rsp),%r8d
lea    (%r15,%r15,1),%r9d
lea    (%r15,%r15,2),%r10d
add    $0x1,%r10
or     $0x1,%r9
mov    -0x38(%rsp),%rcx
lea    (%rcx,%rax,4),%rbp
lea    (%rsi,%rax,8),%r14
lea    (%rax,%rax,2),%rax
lea    (%rsi,%rax,4),%rbx
xor    %eax,%eax
nopl   0x0(%rax)
movss  (%rsi,%rax,4),%xmm10
movss  0x4(%rsi,%rax,4),%xmm0
movss  -0x4(%rbp,%rax,4),%xmm2
movss  0x0(%rbp,%rax,4),%xmm5
movaps %xmm10,%xmm4
addss  %xmm2,%xmm4
movaps %xmm0,%xmm3
addss  %xmm5,%xmm3
subss  %xmm2,%xmm10
subss  %xmm5,%xmm0
movss  (%r14,%rax,4),%xmm2
movss  (%rbx,%rax,4),%xmm9
movaps %xmm2,%xmm7
addss  %xmm9,%xmm7
lea    (%r9,%rax,1),%ecx
movslq %ecx,%rdx
movss  (%rsi,%rdx,4),%xmm5
lea    (%r10,%rax,1),%ecx
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm6
movaps %xmm5,%xmm1
addss  %xmm6,%xmm1
subss  %xmm9,%xmm2
subss  %xmm6,%xmm5
movaps %xmm4,%xmm6
addss  %xmm7,%xmm6
movss  %xmm6,(%rsi,%rax,4)
movaps %xmm3,%xmm6
addss  %xmm1,%xmm6
movss  %xmm6,0x4(%rsi,%rax,4)
subss  %xmm7,%xmm4
movss  %xmm4,(%r14,%rax,4)
subss  %xmm1,%xmm3
movss  %xmm3,(%rsi,%rdx,4)
movaps %xmm10,%xmm1
subss  %xmm5,%xmm1
movss  %xmm1,-0x4(%rbp,%rax,4)
movaps %xmm0,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0x0(%rbp,%rax,4)
addss  %xmm10,%xmm5
movss  %xmm5,(%rbx,%rax,4)
subss  %xmm2,%xmm0
movss  %xmm0,(%rsi,%rcx,4)
add    $0x2,%rax
cmp    %r8,%rax
jbe    11a0 <cftsub+0xa0>
cmp    %edi,%r11d
jge    1140 <cftsub+0x40>
lea    (%r15,%r15,4),%eax
add    $0xfffffffe,%eax
movslq %r11d,%r9
movslq %r15d,%rcx
mov    %rcx,-0x50(%rsp)
mov    %r11,-0x70(%rsp)
cmp    %eax,%r11d
jg     140e <cftsub+0x30e>
mov    -0x68(%rsp),%rcx
movss  0x8(%rcx),%xmm9
lea    (%r15,%r15,4),%ecx
movslq %eax,%r8
mov    %ecx,%r10d
add    $0x1,%r10
lea    (%r15,%r15,1),%eax
lea    (%rax,%rax,2),%r11d
or     $0x1,%r11
lea    0x0(,%r15,8),%r14d
sub    %r15d,%r14d
add    $0x1,%r14
lea    (%rsi,%r9,4),%rbx
mov    -0x50(%rsp),%rcx
lea    (%rcx,%r9,1),%rax
lea    (%rsi,%rax,4),%r12
lea    (%r9,%rcx,2),%rax
lea    (%rsi,%rax,4),%r13
lea    (%rcx,%rcx,2),%rcx
add    %r9,%rcx
lea    (%rsi,%rcx,4),%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movss  (%r12,%rdi,4),%xmm3
movss  (%rbx,%rdi,4),%xmm11
movss  0x4(%rbx,%rdi,4),%xmm10
movaps %xmm11,%xmm5
addss  %xmm3,%xmm5
lea    (%r10,%rdi,1),%edx
movslq %edx,%rbp
movss  (%rsi,%rbp,4),%xmm4
movaps %xmm10,%xmm6
addss  %xmm4,%xmm6
subss  %xmm3,%xmm11
subss  %xmm4,%xmm10
movss  0x0(%r13,%rdi,4),%xmm3
movss  (%rcx,%rdi,4),%xmm7
movaps %xmm3,%xmm1
addss  %xmm7,%xmm1
lea    (%r11,%rdi,1),%edx
movslq %edx,%rax
movss  (%rsi,%rax,4),%xmm2
lea    (%r14,%rdi,1),%edx
movslq %edx,%rdx
movss  (%rsi,%rdx,4),%xmm0
movaps %xmm2,%xmm4
addss  %xmm0,%xmm4
subss  %xmm7,%xmm3
subss  %xmm0,%xmm2
movaps %xmm5,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rbx,%rdi,4)
movaps %xmm6,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,0x4(%rbx,%rdi,4)
subss  %xmm6,%xmm4
movss  %xmm4,0x0(%r13,%rdi,4)
subss  %xmm1,%xmm5
movss  %xmm5,(%rsi,%rax,4)
movaps %xmm11,%xmm0
subss  %xmm2,%xmm0
movaps %xmm10,%xmm1
addss  %xmm3,%xmm1
movaps %xmm0,%xmm4
subss  %xmm1,%xmm4
mulss  %xmm9,%xmm4
movss  %xmm4,(%r12,%rdi,4)
addss  %xmm0,%xmm1
mulss  %xmm9,%xmm1
movss  %xmm1,(%rsi,%rbp,4)
addss  %xmm11,%xmm2
subss  %xmm10,%xmm3
movaps %xmm3,%xmm0
subss  %xmm2,%xmm0
mulss  %xmm9,%xmm0
movss  %xmm0,(%rcx,%rdi,4)
addss  %xmm2,%xmm3
mulss  %xmm9,%xmm3
movss  %xmm3,(%rsi,%rdx,4)
lea    (%r9,%rdi,1),%rax
add    $0x2,%rax
add    $0x2,%rdi
cmp    %r8,%rax
jle    1300 <cftsub+0x200>
lea    0x0(,%r15,8),%ecx
mov    -0x7c(%rsp),%edi
mov    %edi,%eax
mov    -0x70(%rsp),%r11
sub    %r11d,%eax
cmp    %eax,%ecx
jg     1147 <cftsub+0x47>
mov    %ecx,-0x78(%rsp)
movslq %ecx,%rbx
cltq
mov    %rax,-0x20(%rsp)
lea    (%r15,%r15,8),%r8d
add    $0x1,%r8
mov    %r11d,%eax
mov    %rax,-0x28(%rsp)
mov    %r15d,%eax
add    %eax,%eax
lea    (%rax,%rax,4),%eax
or     $0x1,%rax
lea    (%r15,%r15,4),%ecx
lea    (%r15,%rcx,2),%ecx
add    $0x1,%rcx
lea    (%rsi,%rbx,4),%rbp
mov    %r9,-0x18(%rsp)
lea    0x0(,%r9,4),%rdx
mov    %rdx,-0x30(%rsp)
mov    -0x50(%rsp),%r9
lea    (%r9,%rbx,1),%rdx
lea    (%rsi,%rdx,4),%r11
lea    (%rbx,%r9,2),%rdx
lea    (%rsi,%rdx,4),%rdi
lea    (%r9,%r9,2),%rdx
add    %rbx,%rdx
lea    (%rsi,%rdx,4),%r9
mov    $0x1,%r10d
mov    $0xffffffff,%edx
mov    $0x1,%r14d
jmp    14ec <cftsub+0x3ec>
nopl   0x0(%rax,%rax,1)
add    -0x18(%rsp),%rbx
mov    -0x28(%rsp),%rdx
add    %rdx,%r8
add    %rdx,%rax
add    %rdx,%rcx
mov    -0x30(%rsp),%rdx
add    %rdx,%rbp
add    %rdx,%r11
add    %rdx,%rdi
add    %rdx,%r9
mov    -0x58(%rsp),%r14
mov    %r10d,%edx
mov    -0x74(%rsp),%r10d
cmp    -0x20(%rsp),%rbx
jg     1700 <cftsub+0x600>
mov    %edx,-0x74(%rsp)
lea    0x1(%r14),%rdx
mov    %rdx,-0x58(%rsp)
mov    -0x60(%rsp),%rdx
add    %ebx,%edx
movslq %edx,%r12
cmp    %r12,%rbx
jg     14b0 <cftsub+0x3b0>
mov    -0x58(%rsp),%r13
mov    %r13,%rdx
shl    $0x21,%rdx
sar    $0x1e,%rdx
mov    -0x68(%rsp),%r15
movss  (%r15,%rdx,1),%xmm15
lea    0x1(%r13,%r13,1),%edx
cvtsi2ss %r10d,%xmm11
movslq %edx,%rdx
movss  (%r15,%rdx,4),%xmm1
mulss  0x4(%r15,%r14,4),%xmm11
movslq %r10d,%rdx
lea    0x1(%r14,%rdx,1),%rdx
movss  (%r15,%rdx,4),%xmm2
movaps %xmm2,%xmm14
addss  %xmm2,%xmm14
movaps %xmm14,%xmm0
mulss  %xmm1,%xmm0
movaps %xmm15,%xmm6
subss  %xmm0,%xmm6
movaps %xmm1,%xmm3
movaps 0xa92(%rip),%xmm0
xorps  %xmm0,%xmm3
movaps %xmm3,(%rsp)
mulss  %xmm15,%xmm14
movaps %xmm1,-0x50(%rsp)
subss  %xmm1,%xmm14
movaps %xmm2,0x10(%rsp)
xorps  %xmm0,%xmm2
movaps %xmm2,-0x10(%rsp)
movaps %xmm14,%xmm13
xorps  %xmm0,%xmm13
xor    %r14d,%r14d
nopl   0x0(%rax)
movss  (%r11,%r14,4),%xmm3
movss  0x0(%rbp,%r14,4),%xmm12
movss  0x4(%rbp,%r14,4),%xmm1
movaps %xmm12,%xmm5
addss  %xmm3,%xmm5
lea    (%r8,%r14,1),%edx
movslq %edx,%r13
movss  (%rsi,%r13,4),%xmm4
movaps %xmm1,%xmm0
addss  %xmm4,%xmm0
subss  %xmm3,%xmm12
subss  %xmm4,%xmm1
movss  (%rdi,%r14,4),%xmm9
movss  (%r9,%r14,4),%xmm8
movaps %xmm9,%xmm3
addss  %xmm8,%xmm3
lea    (%rax,%r14,1),%edx
movslq %edx,%r15
movss  (%rsi,%r15,4),%xmm4
lea    (%rcx,%r14,1),%edx
movslq %edx,%rdx
movss  (%rsi,%rdx,4),%xmm10
subss  %xmm8,%xmm9
movaps %xmm4,%xmm2
addss  %xmm10,%xmm2
subss  %xmm10,%xmm4
movaps %xmm5,%xmm7
addss  %xmm3,%xmm7
movss  %xmm7,0x0(%rbp,%r14,4)
movaps %xmm0,%xmm7
addss  %xmm2,%xmm7
movss  %xmm7,0x4(%rbp,%r14,4)
subss  %xmm3,%xmm5
subss  %xmm2,%xmm0
movaps %xmm11,%xmm2
mulss  %xmm0,%xmm2
mulss  -0x10(%rsp),%xmm0
movaps %xmm11,%xmm3
mulss  %xmm5,%xmm3
addss  %xmm0,%xmm3
movss  %xmm3,(%rdi,%r14,4)
mulss  0x10(%rsp),%xmm5
addss  %xmm2,%xmm5
movss  %xmm5,(%rsi,%r15,4)
movaps %xmm12,%xmm0
subss  %xmm4,%xmm0
movaps %xmm1,%xmm2
addss  %xmm9,%xmm2
movaps %xmm15,%xmm3
mulss  %xmm2,%xmm3
mulss  (%rsp),%xmm2
movaps %xmm15,%xmm5
mulss  %xmm0,%xmm5
addss  %xmm2,%xmm5
movss  %xmm5,(%r11,%r14,4)
mulss  -0x50(%rsp),%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,(%rsi,%r13,4)
addss  %xmm12,%xmm4
subss  %xmm9,%xmm1
movaps %xmm6,%xmm0
mulss  %xmm1,%xmm0
mulss  %xmm13,%xmm1
movaps %xmm6,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%r9,%r14,4)
mulss  %xmm14,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,(%rsi,%rdx,4)
lea    (%rbx,%r14,1),%rdx
add    $0x2,%rdx
add    $0x2,%r14
cmp    %r12,%rdx
jle    15a0 <cftsub+0x4a0>
jmp    14b0 <cftsub+0x3b0>
nopl   0x0(%rax)
mov    -0x70(%rsp),%r11
mov    -0x7c(%rsp),%edi
mov    -0x78(%rsp),%ecx
jmp    1147 <cftsub+0x47>
mov    $0x2,%r11d
cmp    $0x3,%edi
jge    1735 <cftsub+0x635>
jmp    17a7 <cftsub+0x6a7>
cmp    %edi,%r11d
jge    17a7 <cftsub+0x6a7>
cmp    $0x2,%r11d
jl     17a7 <cftsub+0x6a7>
mov    %r11d,%ebp
add    $0xfffffffe,%r11d
lea    (%rsi,%rbp,4),%rcx
shl    $0x20,%rbp
xor    %edx,%edx
movabs $0x200000000,%rdi
movss  (%rcx,%rdx,4),%xmm0
movss  (%rsi,%rdx,4),%xmm1
movss  0x4(%rsi,%rdx,4),%xmm2
movaps %xmm1,%xmm3
subss  %xmm0,%xmm3
mov    %rbp,%rax
sar    $0x1e,%rax
or     $0x4,%rax
movss  (%rsi,%rax,1),%xmm4
movaps %xmm2,%xmm5
subss  %xmm4,%xmm5
addss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rdx,4)
addss  %xmm4,%xmm2
movss  %xmm2,0x4(%rsi,%rdx,4)
movss  %xmm3,(%rcx,%rdx,4)
movss  %xmm5,(%rsi,%rax,1)
add    $0x2,%rdx
add    %rdi,%rbp
cmp    %r11,%rdx
jbe    1750 <cftsub+0x650>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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