void cftmdl1(int n, float *a, float *w) {
  int j, j0, j1, j2, j3, k, m, mh;
  float wn4r, wk1r, wk1i, wk3r, wk3i;
  float x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
  mh = n >> 3;
  m = 2 * mh;
  j1 = m;
  j2 = j1 + m;
  j3 = j2 + m;
  x0r = a[0] + a[j2];
  x0i = a[1] + a[j2 + 1];
  x1r = a[0] - a[j2];
  x1i = a[1] - a[j2 + 1];
  x2r = a[j1] + a[j3];
  x2i = a[j1 + 1] + a[j3 + 1];
  x3r = a[j1] - a[j3];
  x3i = a[j1 + 1] - a[j3 + 1];
  a[0] = x0r + x2r;
  a[1] = x0i + x2i;
  a[j1] = x0r - x2r;
  a[j1 + 1] = x0i - x2i;
  a[j2] = x1r - x3i;
  a[j2 + 1] = x1i + x3r;
  a[j3] = x1r + x3i;
  a[j3 + 1] = x1i - x3r;
  wn4r = w[1];
  k = 0;
  for (j = 2; j < mh; j += 2) {
    k += 4;
    wk1r = w[k];
    wk1i = w[k + 1];
    wk3r = w[k + 2];
    wk3i = w[k + 3];
    j1 = j + m;
    j2 = j1 + m;
    j3 = j2 + m;
    x0r = a[j] + a[j2];
    x0i = a[j + 1] + a[j2 + 1];
    x1r = a[j] - a[j2];
    x1i = a[j + 1] - a[j2 + 1];
    x2r = a[j1] + a[j3];
    x2i = a[j1 + 1] + a[j3 + 1];
    x3r = a[j1] - a[j3];
    x3i = a[j1 + 1] - a[j3 + 1];
    a[j] = x0r + x2r;
    a[j + 1] = x0i + x2i;
    a[j1] = x0r - x2r;
    a[j1 + 1] = x0i - x2i;
    x0r = x1r - x3i;
    x0i = x1i + x3r;
    a[j2] = wk1r * x0r - wk1i * x0i;
    a[j2 + 1] = wk1r * x0i + wk1i * x0r;
    x0r = x1r + x3i;
    x0i = x1i - x3r;
    a[j3] = wk3r * x0r + wk3i * x0i;
    a[j3 + 1] = wk3r * x0i - wk3i * x0r;
    j0 = m - j;
    j1 = j0 + m;
    j2 = j1 + m;
    j3 = j2 + m;
    x0r = a[j0] + a[j2];
    x0i = a[j0 + 1] + a[j2 + 1];
    x1r = a[j0] - a[j2];
    x1i = a[j0 + 1] - a[j2 + 1];
    x2r = a[j1] + a[j3];
    x2i = a[j1 + 1] + a[j3 + 1];
    x3r = a[j1] - a[j3];
    x3i = a[j1 + 1] - a[j3 + 1];
    a[j0] = x0r + x2r;
    a[j0 + 1] = x0i + x2i;
    a[j1] = x0r - x2r;
    a[j1 + 1] = x0i - x2i;
    x0r = x1r - x3i;
    x0i = x1i + x3r;
    a[j2] = wk1i * x0r - wk1r * x0i;
    a[j2 + 1] = wk1i * x0i + wk1r * x0r;
    x0r = x1r + x3i;
    x0i = x1i - x3r;
    a[j3] = wk3i * x0r + wk3r * x0i;
    a[j3 + 1] = wk3i * x0i - wk3r * x0r;
  }
  j0 = mh;
  j1 = j0 + m;
  j2 = j1 + m;
  j3 = j2 + m;
  x0r = a[j0] + a[j2];
  x0i = a[j0 + 1] + a[j2 + 1];
  x1r = a[j0] - a[j2];
  x1i = a[j0 + 1] - a[j2 + 1];
  x2r = a[j1] + a[j3];
  x2i = a[j1 + 1] + a[j3 + 1];
  x3r = a[j1] - a[j3];
  x3i = a[j1 + 1] - a[j3 + 1];
  a[j0] = x0r + x2r;
  a[j0 + 1] = x0i + x2i;
  a[j1] = x0r - x2r;
  a[j1 + 1] = x0i - x2i;
  x0r = x1r - x3i;
  x0i = x1i + x3r;
  a[j2] = wn4r * (x0r - x0i);
  a[j2 + 1] = wn4r * (x0i + x0r);
  x0r = x1r + x3i;
  x0i = x1i - x3r;
  a[j3] = -wn4r * (x0r + x0i);
  a[j3 + 1] = -wn4r * (x0i - x0r);
}


x86 assembly (clang, -O0):
<cftmdl1>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x4(%rbp),%eax
sar    $0x3,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%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    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%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 -0x2c(%rbp),%rcx
subss  (%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    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x50(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x54(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x50(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x2,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    18e4 <cftmdl1+0x7e4>
mov    -0x30(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%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    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%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    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%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    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%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 -0x2c(%rbp),%rcx
subss  (%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    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x50(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x5c(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x54(%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  -0x40(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x50(%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)
movss  -0x58(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x5c(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x48(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%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,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%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,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%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    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%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 -0x2c(%rbp),%rcx
subss  (%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    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x50(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x5c(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x54(%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  -0x44(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x50(%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)
movss  -0x58(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x5c(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%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    1317 <cftmdl1+0x217>
mov    -0x38(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%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,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%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,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%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    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%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 -0x2c(%rbp),%rcx
subss  (%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    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x50(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x5c(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm1
subss  -0x54(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
addss  -0x50(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x5c(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x3c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x50(%rbp),%xmm1
addss  -0x54(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x54(%rbp),%xmm1
subss  -0x50(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
pop    %rbp
ret

x86 assembly (clang, -O2):
<cftmdl1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdx,%r14
mov    %edi,%eax
sar    $0x3,%eax
lea    (%rax,%rax,1),%ebx
lea    0x0(,%rax,4),%ecx
lea    (%rbx,%rbx,2),%r9d
movslq %ecx,%rbp
movss  (%rsi,%rbp,4),%xmm2
movss  (%rsi),%xmm9
movss  0x4(%rsi),%xmm0
movaps %xmm9,%xmm3
addss  %xmm2,%xmm3
lea    0x1(,%rax,4),%ecx
movslq %ecx,%r8
movss  (%rsi,%r8,4),%xmm5
movaps %xmm0,%xmm4
addss  %xmm5,%xmm4
subss  %xmm2,%xmm9
subss  %xmm5,%xmm0
movslq %ebx,%rdx
movss  (%rsi,%rdx,4),%xmm2
movslq %r9d,%r10
movss  (%rsi,%r10,4),%xmm8
movaps %xmm2,%xmm6
addss  %xmm8,%xmm6
lea    0x1(%rax,%rax,1),%ebx
movslq %ebx,%r9
movss  (%rsi,%r9,4),%xmm7
mov    %r10d,%ebx
or     $0x1,%ebx
movslq %ebx,%rbx
movss  (%rsi,%rbx,4),%xmm5
movaps %xmm7,%xmm1
addss  %xmm5,%xmm1
subss  %xmm8,%xmm2
subss  %xmm5,%xmm7
movaps %xmm3,%xmm5
addss  %xmm6,%xmm5
movss  %xmm5,(%rsi)
movaps %xmm4,%xmm5
addss  %xmm1,%xmm5
movss  %xmm5,0x4(%rsi)
subss  %xmm6,%xmm3
movss  %xmm3,(%rsi,%rdx,4)
subss  %xmm1,%xmm4
movss  %xmm4,(%rsi,%r9,4)
movaps %xmm9,%xmm1
subss  %xmm7,%xmm1
movss  %xmm1,(%rsi,%rbp,4)
movaps %xmm0,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,(%rsi,%r8,4)
addss  %xmm9,%xmm7
movss  %xmm7,(%rsi,%r10,4)
subss  %xmm2,%xmm0
movss  %xmm0,(%rsi,%rbx,4)
movss  0x4(%r14),%xmm8
cltq
mov    %rax,-0x38(%rsp)
cmp    $0x18,%edi
jl     153d <cftmdl1+0x43d>
mov    %r14,%r11
movabs $0xfffffffe00000000,%r8
ff ff ff
lea    (%rdx,%rdx,2),%eax
cltq
lea    0x3(%rax),%rcx
mov    %rcx,-0x30(%rsp)
lea    0x3(%rbp),%r12
add    $0xffffffffffffffff,%rbp
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rsp)
lea    -0x1(%rdx),%r10
lea    0x0(,%rdx,4),%rbx
lea    (%rbx,%rbx,2),%rax
add    $0xfffffffffffffff8,%rax
mov    %rdx,%r15
shl    $0x22,%r15
add    %r8,%r15
mov    %r15,%r8
mov    %rdx,%rdi
shl    $0x4,%rdi
add    $0xfffffffffffffff8,%rdi
lea    0x3(%rdx),%r13
add    $0x1,%rdx
lea    (%rbx,%rbx,2),%rbx
add    $0x8,%rbx
mov    $0x2,%r9d
mov    %r10,-0x28(%rsp)
mov    %r14,-0x10(%rsp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rax,-0x18(%rsp)
movss  (%r11,%r9,8),%xmm11
movss  0x4(%r11,%r9,8),%xmm12
movss  0x8(%r11,%r9,8),%xmm10
movss  0xc(%r11,%r9,8),%xmm9
movss  (%rsi,%rdx,8),%xmm0
movss  (%rsi,%r9,4),%xmm13
movss  0x4(%rsi,%r9,4),%xmm5
movaps %xmm13,%xmm1
addss  %xmm0,%xmm1
movss  (%rsi,%r12,4),%xmm2
mov    %r12,%rcx
mov    %r12,-0x8(%rsp)
movaps %xmm5,%xmm3
addss  %xmm2,%xmm3
subss  %xmm0,%xmm13
subss  %xmm2,%xmm5
movss  (%rsi,%rbx,1),%xmm2
movss  -0x4(%rsi,%r13,4),%xmm14
movss  (%rsi,%r13,4),%xmm6
movaps %xmm14,%xmm0
addss  %xmm2,%xmm0
mov    -0x30(%rsp),%r12
movss  (%rsi,%r12,4),%xmm7
movaps %xmm6,%xmm4
addss  %xmm7,%xmm4
subss  %xmm2,%xmm14
subss  %xmm7,%xmm6
movaps %xmm1,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,(%rsi,%r9,4)
movaps %xmm3,%xmm2
addss  %xmm4,%xmm2
movss  %xmm2,0x4(%rsi,%r9,4)
subss  %xmm0,%xmm1
movss  %xmm1,-0x4(%rsi,%r13,4)
subss  %xmm4,%xmm3
movss  %xmm3,(%rsi,%r13,4)
movaps %xmm13,%xmm0
subss  %xmm6,%xmm0
movaps %xmm5,%xmm1
addss  %xmm14,%xmm1
movaps %xmm11,%xmm2
mulss  %xmm1,%xmm2
mulss  %xmm12,%xmm1
movaps %xmm11,%xmm3
mulss  %xmm0,%xmm3
subss  %xmm1,%xmm3
movss  %xmm3,(%rsi,%rdx,8)
mulss  %xmm12,%xmm0
addss  %xmm2,%xmm0
movss  %xmm0,(%rsi,%rcx,4)
addss  %xmm13,%xmm6
subss  %xmm14,%xmm5
movaps %xmm9,%xmm0
mulss  %xmm5,%xmm0
movaps %xmm10,%xmm1
mulss  %xmm6,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rbx,1)
mulss  %xmm9,%xmm6
mulss  %xmm10,%xmm5
subss  %xmm6,%xmm5
movss  %xmm5,(%rsi,%r12,4)
movss  (%rsi,%rax,1),%xmm0
movss  -0x4(%rsi,%r10,4),%xmm13
movss  (%rsi,%r10,4),%xmm5
movaps %xmm13,%xmm6
addss  %xmm0,%xmm6
mov    -0x20(%rsp),%rax
movss  (%rsi,%rax,4),%xmm3
movaps %xmm5,%xmm2
addss  %xmm3,%xmm2
subss  %xmm0,%xmm13
subss  %xmm3,%xmm5
mov    -0x28(%rsp),%r14
movss  (%rsi,%r14,8),%xmm0
movss  (%rsi,%rdi,1),%xmm14
movaps %xmm0,%xmm4
addss  %xmm14,%xmm4
movss  (%rsi,%rbp,4),%xmm7
mov    %r8,%r15
sar    $0x1e,%r15
or     $0x4,%r15
movss  (%rsi,%r15,1),%xmm1
movaps %xmm7,%xmm3
addss  %xmm1,%xmm3
subss  %xmm14,%xmm0
subss  %xmm1,%xmm7
movaps %xmm6,%xmm1
addss  %xmm4,%xmm1
movss  %xmm1,-0x4(%rsi,%r10,4)
movaps %xmm2,%xmm1
addss  %xmm3,%xmm1
movss  %xmm1,(%rsi,%r10,4)
subss  %xmm4,%xmm6
movss  %xmm6,(%rsi,%r14,8)
subss  %xmm3,%xmm2
movss  %xmm2,(%rsi,%rbp,4)
movaps %xmm13,%xmm1
subss  %xmm7,%xmm1
movaps %xmm5,%xmm2
addss  %xmm0,%xmm2
movaps %xmm2,%xmm3
mulss  %xmm11,%xmm3
mulss  %xmm12,%xmm2
mulss  %xmm1,%xmm12
subss  %xmm3,%xmm12
mov    -0x18(%rsp),%rcx
movss  %xmm12,(%rsi,%rcx,1)
mulss  %xmm11,%xmm1
addss  %xmm1,%xmm2
movss  %xmm2,(%rsi,%rax,4)
addss  %xmm13,%xmm7
subss  %xmm0,%xmm5
movaps %xmm9,%xmm0
mulss  %xmm7,%xmm0
mulss  %xmm10,%xmm7
mulss  %xmm5,%xmm10
addss  %xmm10,%xmm0
movss  %xmm0,(%rsi,%rdi,1)
mulss  %xmm9,%xmm5
subss  %xmm7,%xmm5
movss  %xmm5,(%rsi,%r15,1)
mov    -0x38(%rsp),%rcx
mov    -0x10(%rsp),%r11
add    $0x2,%r9
add    $0x2,%r12
mov    %r12,-0x30(%rsp)
mov    -0x8(%rsp),%r12
add    $0x2,%r12
add    $0xfffffffffffffffe,%rbp
add    $0xfffffffffffffffe,%rax
mov    %rax,-0x20(%rsp)
mov    -0x18(%rsp),%rax
add    $0xfffffffffffffffe,%r10
add    $0xffffffffffffffff,%r14
mov    %r14,-0x28(%rsp)
add    $0xfffffffffffffff8,%rax
movabs $0xfffffffe00000000,%r15
ff ff ff
add    %r15,%r8
add    $0xfffffffffffffff8,%rdi
add    $0x2,%r13
add    $0x1,%rdx
add    $0x8,%rbx
cmp    %rcx,%r9
jl     1290 <cftmdl1+0x190>
mov    -0x38(%rsp),%r15
lea    (%r15,%r15,2),%eax
lea    (%r15,%r15,4),%ecx
lea    0x0(,%r15,8),%edx
sub    %r15d,%edx
movslq %ecx,%rcx
movss  (%rsi,%r15,4),%xmm9
movss  0x4(%rsi,%r15,4),%xmm1
movss  (%rsi,%rcx,4),%xmm0
movss  0x4(%rsi,%rcx,4),%xmm3
movaps %xmm9,%xmm4
addss  %xmm0,%xmm4
movaps %xmm1,%xmm5
addss  %xmm3,%xmm5
subss  %xmm0,%xmm9
subss  %xmm3,%xmm1
movslq %eax,%rdi
movslq %edx,%rax
movss  (%rsi,%rdi,4),%xmm2
movss  0x4(%rsi,%rdi,4),%xmm7
movss  (%rsi,%rax,4),%xmm6
movss  0x4(%rsi,%rax,4),%xmm10
movaps %xmm2,%xmm3
addss  %xmm6,%xmm3
movaps %xmm7,%xmm0
addss  %xmm10,%xmm0
subss  %xmm6,%xmm2
subss  %xmm10,%xmm7
movaps %xmm4,%xmm6
addss  %xmm3,%xmm6
movss  %xmm6,(%rsi,%r15,4)
movaps %xmm5,%xmm6
addss  %xmm0,%xmm6
movss  %xmm6,0x4(%rsi,%r15,4)
subss  %xmm3,%xmm4
movss  %xmm4,(%rsi,%rdi,4)
subss  %xmm0,%xmm5
movss  %xmm5,0x4(%rsi,%rdi,4)
movaps %xmm9,%xmm0
subss  %xmm7,%xmm0
movaps %xmm1,%xmm3
addss  %xmm2,%xmm3
movaps %xmm0,%xmm4
subss  %xmm3,%xmm4
mulss  %xmm8,%xmm4
movss  %xmm4,(%rsi,%rcx,4)
addss  %xmm0,%xmm3
mulss  %xmm8,%xmm3
movss  %xmm3,0x4(%rsi,%rcx,4)
addss  %xmm9,%xmm7
subss  %xmm2,%xmm1
xorps  0x9d5(%rip),%xmm8
movaps %xmm1,%xmm0
addss  %xmm7,%xmm0
mulss  %xmm8,%xmm0
movss  %xmm0,(%rsi,%rax,4)
subss  %xmm7,%xmm1
mulss  %xmm8,%xmm1
movss  %xmm1,0x4(%rsi,%rax,4)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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