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


x86 assembly (clang, -O0):
<cftmdl2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x4(%rbp),%eax
sar    $0x3,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%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
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%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,-0x74(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%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,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x74(%rbp),%xmm1
subss  -0x78(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x40(%rbp),%xmm0
movss  -0x78(%rbp),%xmm1
addss  -0x74(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x64(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x68(%rbp),%xmm0
addss  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x64(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
subss  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
movss  -0x7c(%rbp),%xmm1
subss  -0x80(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x40(%rbp),%xmm0
movss  -0x80(%rbp),%xmm1
addss  -0x7c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
subss  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
addss  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x30(%rbp)
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x2,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1ba1 <cftmdl2+0xaa1>
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,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%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,-0x64(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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
movslq -0x1c(%rbp),%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
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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
movslq -0x24(%rbp),%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,-0x74(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%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,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x44(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0x74(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x78(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0x78(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x74(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
addss  -0x8c(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
addss  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
subss  -0x8c(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
subss  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x4c(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x5c(%rbp),%xmm0
movss  -0x7c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x80(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x5c(%rbp),%xmm0
movss  -0x80(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x7c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
addss  -0x8c(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
addss  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
subss  -0x8c(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
subss  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
sub    -0x1c(%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    -0x28(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%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,-0x64(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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
movslq -0x20(%rbp),%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
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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
movslq -0x24(%rbp),%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,-0x74(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%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,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x58(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x58(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x48(%rbp),%xmm0
movss  -0x74(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x78(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x48(%rbp),%xmm0
movss  -0x78(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x74(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
addss  -0x8c(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
addss  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
subss  -0x8c(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
subss  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x60(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x50(%rbp),%xmm0
movss  -0x7c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x80(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x50(%rbp),%xmm0
movss  -0x80(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x7c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
addss  -0x8c(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
addss  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
subss  -0x8c(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
subss  -0x90(%rbp),%xmm0
ff
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    13a8 <cftmdl2+0x2a8>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x3c(%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    -0x28(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%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,-0x64(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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
movslq -0x20(%rbp),%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
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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
movslq -0x24(%rbp),%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,-0x74(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%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,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x44(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x48(%rbp),%xmm0
movss  -0x74(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x78(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x48(%rbp),%xmm0
movss  -0x78(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x74(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
addss  -0x8c(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
addss  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
subss  -0x8c(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
subss  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x48(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x44(%rbp),%xmm0
movss  -0x7c(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  -0x80(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x44(%rbp),%xmm0
movss  -0x80(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  -0x7c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
subss  -0x8c(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
subss  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
addss  -0x8c(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
addss  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cftmdl2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %edi,%eax
sar    $0x3,%eax
lea    (%rax,%rax,1),%ebp
mov    %rdx,-0x60(%rsp)
movss  0x4(%rdx),%xmm8
lea    0x0(,%rax,4),%edx
lea    0x0(%rbp,%rbp,2),%ebx
lea    0x1(,%rax,4),%ecx
movslq %ecx,%r8
movss  (%rsi,%r8,4),%xmm5
movss  (%rsi),%xmm9
movss  0x4(%rsi),%xmm0
movaps %xmm9,%xmm3
subss  %xmm5,%xmm3
movslq %edx,%rcx
movss  (%rsi,%rcx,4),%xmm6
movaps %xmm0,%xmm4
addss  %xmm6,%xmm4
addss  %xmm5,%xmm9
subss  %xmm6,%xmm0
movslq %ebp,%rdx
movss  (%rsi,%rdx,4),%xmm1
movslq %ebx,%rbp
or     $0x1,%ebx
movslq %ebx,%r9
movss  (%rsi,%r9,4),%xmm10
movaps %xmm1,%xmm6
subss  %xmm10,%xmm6
lea    0x1(%rax,%rax,1),%ebx
movslq %ebx,%rbx
movss  (%rsi,%rbx,4),%xmm7
movss  (%rsi,%rbp,4),%xmm2
movaps %xmm7,%xmm5
addss  %xmm2,%xmm5
addss  %xmm10,%xmm1
subss  %xmm2,%xmm7
movaps %xmm6,%xmm2
subss  %xmm5,%xmm2
mulss  %xmm8,%xmm2
addss  %xmm6,%xmm5
mulss  %xmm8,%xmm5
movaps %xmm3,%xmm6
addss  %xmm2,%xmm6
movss  %xmm6,(%rsi)
movaps %xmm4,%xmm6
addss  %xmm5,%xmm6
movss  %xmm6,0x4(%rsi)
subss  %xmm2,%xmm3
mov    %rdx,-0x50(%rsp)
movss  %xmm3,(%rsi,%rdx,4)
subss  %xmm5,%xmm4
mov    %rbx,-0x20(%rsp)
movss  %xmm4,(%rsi,%rbx,4)
movaps %xmm1,%xmm2
subss  %xmm7,%xmm2
mulss  %xmm8,%xmm2
addss  %xmm1,%xmm7
mulss  %xmm8,%xmm7
movaps %xmm9,%xmm1
subss  %xmm7,%xmm1
movss  %xmm1,(%rsi,%rcx,4)
movaps %xmm0,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,(%rsi,%r8,4)
addss  %xmm9,%xmm7
movss  %xmm7,(%rsi,%rbp,4)
subss  %xmm2,%xmm0
movss  %xmm0,(%rsi,%r9,4)
movslq %eax,%rbp
cmp    $0x18,%edi
jl     164b <cftmdl2+0x54b>
mov    %rcx,%r13
movabs $0xfffffffe00000000,%r8
ff ff ff
lea    -0x1(%rcx),%rax
mov    %rax,-0x28(%rsp)
mov    -0x60(%rsp),%rax
lea    -0x4(%rax,%rcx,4),%r15
mov    -0x50(%rsp),%rdx
lea    (%rdx,%rdx,2),%ecx
movslq %ecx,%rcx
lea    0x3(%rcx),%rbx
add    $0x3,%r13
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x30(%rsp)
lea    -0x1(%rdx),%r14
lea    0x0(,%rdx,4),%rdi
lea    (%rdi,%rdi,2),%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x38(%rsp)
mov    %rdx,%rcx
shl    $0x22,%rcx
add    %r8,%rcx
mov    %rcx,-0x48(%rsp)
mov    %rdx,%r12
shl    $0x4,%r12
add    $0xfffffffffffffff8,%r12
lea    0x3(%rdx),%r9
lea    0x1(%rdx),%rcx
lea    (%rdi,%rdi,2),%rax
add    $0x8,%rax
mov    $0x2,%r11d
mov    %r14,-0x40(%rsp)
mov    %r14,%rdi
mov    %rbp,-0x18(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %rcx,-0x8(%rsp)
mov    -0x60(%rsp),%rdx
movss  (%rdx,%r11,8),%xmm9
movss  0x4(%rdx,%r11,8),%xmm11
movss  0x8(%rdx,%r11,8),%xmm0
movss  %xmm0,-0x54(%rsp)
movss  0xc(%rdx,%r11,8),%xmm0
movss  %xmm0,-0x64(%rsp)
movss  -0xc(%r15),%xmm13
movss  -0x8(%r15),%xmm8
movss  (%rsi,%r13,4),%xmm1
mov    %r13,-0x10(%rsp)
movss  (%rsi,%r11,4),%xmm2
movss  0x4(%rsi,%r11,4),%xmm0
movaps %xmm2,%xmm4
subss  %xmm1,%xmm4
movss  (%rsi,%rcx,8),%xmm3
movaps %xmm0,%xmm6
addss  %xmm3,%xmm6
addss  %xmm1,%xmm2
subss  %xmm3,%xmm0
movss  (%rsi,%rbx,4),%xmm14
movss  -0x4(%rsi,%r9,4),%xmm5
movss  (%rsi,%r9,4),%xmm1
movaps %xmm5,%xmm3
subss  %xmm14,%xmm3
movss  (%rsi,%rax,1),%xmm15
movaps %xmm1,%xmm7
addss  %xmm15,%xmm7
addss  %xmm14,%xmm5
subss  %xmm15,%xmm1
movaps %xmm9,%xmm14
mulss  %xmm6,%xmm14
mulss  %xmm11,%xmm6
movaps %xmm9,%xmm10
mulss  %xmm4,%xmm10
subss  %xmm6,%xmm10
mulss  %xmm11,%xmm4
addss  %xmm14,%xmm4
movaps %xmm8,%xmm6
mulss  %xmm7,%xmm6
mulss  %xmm13,%xmm7
movaps %xmm8,%xmm12
mulss  %xmm3,%xmm12
subss  %xmm7,%xmm12
movss  -0x4(%r15),%xmm14
mulss  %xmm13,%xmm3
addss  %xmm6,%xmm3
movaps %xmm10,%xmm6
addss  %xmm12,%xmm6
movss  (%r15),%xmm15
movss  %xmm6,(%rsi,%r11,4)
movaps %xmm4,%xmm6
addss  %xmm3,%xmm6
movss  %xmm6,0x4(%rsi,%r11,4)
subss  %xmm12,%xmm10
movss  %xmm10,-0x4(%rsi,%r9,4)
subss  %xmm3,%xmm4
movss  %xmm4,(%rsi,%r9,4)
movss  -0x64(%rsp),%xmm7
movaps %xmm7,%xmm3
mulss  %xmm0,%xmm3
movss  -0x54(%rsp),%xmm12
movaps %xmm12,%xmm4
mulss  %xmm2,%xmm4
addss  %xmm3,%xmm4
mulss  %xmm7,%xmm2
mulss  %xmm12,%xmm0
subss  %xmm2,%xmm0
movaps %xmm14,%xmm2
mulss  %xmm1,%xmm2
movaps %xmm15,%xmm3
mulss  %xmm5,%xmm3
addss  %xmm2,%xmm3
mulss  %xmm14,%xmm5
mulss  %xmm15,%xmm1
subss  %xmm5,%xmm1
movaps %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,(%rsi,%rcx,8)
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rsi,%r13,4)
subss  %xmm3,%xmm4
movss  %xmm4,(%rsi,%rax,1)
subss  %xmm1,%xmm0
movss  %xmm0,(%rsi,%rbx,4)
mov    -0x30(%rsp),%rcx
movss  (%rsi,%rcx,4),%xmm1
movss  -0x4(%rsi,%rdi,4),%xmm3
movss  (%rsi,%rdi,4),%xmm4
movaps %xmm3,%xmm5
subss  %xmm1,%xmm5
mov    -0x38(%rsp),%r14
movss  (%rsi,%r14,1),%xmm2
movaps %xmm4,%xmm0
addss  %xmm2,%xmm0
addss  %xmm1,%xmm3
subss  %xmm2,%xmm4
mov    -0x40(%rsp),%r8
movss  (%rsi,%r8,8),%xmm10
mov    -0x48(%rsp),%r10
mov    %r10,%r13
sar    $0x1e,%r13
or     $0x4,%r13
movss  (%rsi,%r13,1),%xmm1
movaps %xmm10,%xmm2
subss  %xmm1,%xmm2
mov    -0x28(%rsp),%rbp
movss  (%rsi,%rbp,4),%xmm6
addss  %xmm1,%xmm10
movss  (%rsi,%r12,1),%xmm7
movaps %xmm6,%xmm1
addss  %xmm7,%xmm1
subss  %xmm7,%xmm6
movaps %xmm0,%xmm7
mulss  %xmm8,%xmm7
mulss  %xmm13,%xmm0
mulss  %xmm5,%xmm13
subss  %xmm7,%xmm13
mulss  %xmm8,%xmm5
addss  %xmm5,%xmm0
movaps %xmm1,%xmm5
mulss  %xmm9,%xmm5
mulss  %xmm11,%xmm1
mulss  %xmm2,%xmm11
subss  %xmm5,%xmm11
mulss  %xmm9,%xmm2
addss  %xmm2,%xmm1
movaps %xmm13,%xmm2
addss  %xmm11,%xmm2
movss  %xmm2,-0x4(%rsi,%rdi,4)
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rsi,%rdi,4)
subss  %xmm11,%xmm13
movss  %xmm13,(%rsi,%r8,8)
subss  %xmm1,%xmm0
movss  %xmm0,(%rsi,%rbp,4)
movaps %xmm14,%xmm0
mulss  %xmm3,%xmm0
mulss  %xmm15,%xmm3
mulss  %xmm4,%xmm15
addss  %xmm15,%xmm0
mulss  %xmm14,%xmm4
subss  %xmm3,%xmm4
movss  -0x64(%rsp),%xmm3
movaps %xmm3,%xmm1
mulss  %xmm10,%xmm1
mulss  %xmm12,%xmm10
mulss  %xmm6,%xmm12
addss  %xmm12,%xmm1
mulss  %xmm3,%xmm6
subss  %xmm10,%xmm6
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rsi,%r14,1)
movaps %xmm4,%xmm2
addss  %xmm6,%xmm2
movss  %xmm2,(%rsi,%rcx,4)
subss  %xmm1,%xmm0
movss  %xmm0,(%rsi,%r12,1)
subss  %xmm6,%xmm4
movss  %xmm4,(%rsi,%r13,1)
mov    -0x18(%rsp),%rdx
add    $0x2,%r11
add    $0xfffffffffffffff0,%r15
add    $0x2,%rbx
mov    -0x10(%rsp),%r13
add    $0x2,%r13
add    $0xfffffffffffffffe,%rbp
mov    %rbp,-0x28(%rsp)
add    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x30(%rsp)
mov    -0x8(%rsp),%rcx
add    $0xfffffffffffffffe,%rdi
add    $0xffffffffffffffff,%r8
mov    %r8,-0x40(%rsp)
add    $0xfffffffffffffff8,%r14
mov    %r14,-0x38(%rsp)
movabs $0xfffffffe00000000,%rbp
ff ff ff
add    %rbp,%r10
mov    %r10,-0x48(%rsp)
add    $0xfffffffffffffff8,%r12
add    $0x2,%r9
add    $0x1,%rcx
add    $0x8,%rax
mov    %rdx,%rbp
cmp    %rdx,%r11
jl     12d0 <cftmdl2+0x1d0>
mov    -0x60(%rsp),%rax
mov    -0x50(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm10
mov    -0x20(%rsp),%rcx
movss  (%rax,%rcx,4),%xmm8
lea    0x0(%rbp,%rbp,2),%ecx
lea    0x0(%rbp,%rbp,4),%eax
lea    0x0(,%rbp,8),%edi
sub    %ebp,%edi
cltq
movss  (%rsi,%rax,4),%xmm0
movss  0x4(%rsi,%rax,4),%xmm2
movss  (%rsi,%rbp,4),%xmm1
movss  0x4(%rsi,%rbp,4),%xmm9
movaps %xmm1,%xmm4
subss  %xmm2,%xmm4
movaps %xmm9,%xmm12
addss  %xmm0,%xmm12
addss  %xmm2,%xmm1
subss  %xmm0,%xmm9
movslq %ecx,%rdx
movslq %edi,%rcx
movss  (%rsi,%rcx,4),%xmm2
movss  0x4(%rsi,%rcx,4),%xmm3
movss  (%rsi,%rdx,4),%xmm14
movss  0x4(%rsi,%rdx,4),%xmm5
movaps %xmm14,%xmm7
subss  %xmm3,%xmm7
movaps %xmm5,%xmm15
addss  %xmm2,%xmm15
addss  %xmm3,%xmm14
subss  %xmm2,%xmm5
movaps %xmm10,%xmm2
movaps %xmm8,%xmm11
mulss  %xmm15,%xmm11
mulss  %xmm10,%xmm15
movaps %xmm8,%xmm3
mulss  %xmm7,%xmm3
mulss  %xmm10,%xmm7
movaps %xmm8,%xmm13
mulss  %xmm9,%xmm13
mulss  %xmm10,%xmm9
movaps %xmm8,%xmm6
mulss  %xmm1,%xmm6
mulss  %xmm10,%xmm1
movaps %xmm10,%xmm0
mulss  %xmm12,%xmm0
mulss  %xmm8,%xmm12
mulss  %xmm4,%xmm2
subss  %xmm12,%xmm2
movaps %xmm5,%xmm12
mulss  %xmm10,%xmm5
mulss  %xmm8,%xmm4
addss  %xmm0,%xmm4
subss  %xmm15,%xmm3
addss  %xmm11,%xmm7
movaps %xmm2,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,(%rsi,%rbp,4)
movaps %xmm4,%xmm0
addss  %xmm7,%xmm0
movss  %xmm0,0x4(%rsi,%rbp,4)
subss  %xmm3,%xmm2
movss  %xmm2,(%rsi,%rdx,4)
subss  %xmm7,%xmm4
movss  %xmm4,0x4(%rsi,%rdx,4)
subss  %xmm9,%xmm6
addss  %xmm13,%xmm1
mulss  %xmm8,%xmm12
mulss  %xmm14,%xmm10
subss  %xmm12,%xmm10
mulss  %xmm8,%xmm14
addss  %xmm14,%xmm5
movaps %xmm6,%xmm0
subss  %xmm10,%xmm0
movss  %xmm0,(%rsi,%rax,4)
movaps %xmm1,%xmm0
subss  %xmm5,%xmm0
movss  %xmm0,0x4(%rsi,%rax,4)
addss  %xmm6,%xmm10
movss  %xmm10,(%rsi,%rcx,4)
addss  %xmm1,%xmm5
movss  %xmm5,0x4(%rsi,%rcx,4)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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