void cftf1st(int n, float *a, float *w) {
  int j, j0, j1, j2, j3, k, m, mh;
  float wn4r, csc1, csc3, wk1r, wk1i, wk3r, wk3i, wd1r, wd1i, wd3r, wd3i;
  float x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, y0r, y0i, y1r, y1i, y2r, y2i,
      y3r, y3i;
  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];
  csc1 = w[2];
  csc3 = w[3];
  wd1r = 1;
  wd1i = 0;
  wd3r = 1;
  wd3i = 0;
  k = 0;
  for (j = 2; j < mh - 2; j += 4) {
    k += 4;
    wk1r = csc1 * (wd1r + w[k]);
    wk1i = csc1 * (wd1i + w[k + 1]);
    wk3r = csc3 * (wd3r + w[k + 2]);
    wk3i = csc3 * (wd3i + w[k + 3]);
    wd1r = w[k];
    wd1i = w[k + 1];
    wd3r = w[k + 2];
    wd3i = 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];
    y0r = a[j + 2] + a[j2 + 2];
    y0i = a[j + 3] + a[j2 + 3];
    y1r = a[j + 2] - a[j2 + 2];
    y1i = a[j + 3] - a[j2 + 3];
    x2r = a[j1] + a[j3];
    x2i = a[j1 + 1] + a[j3 + 1];
    x3r = a[j1] - a[j3];
    x3i = a[j1 + 1] - a[j3 + 1];
    y2r = a[j1 + 2] + a[j3 + 2];
    y2i = a[j1 + 3] + a[j3 + 3];
    y3r = a[j1 + 2] - a[j3 + 2];
    y3i = a[j1 + 3] - a[j3 + 3];
    a[j] = x0r + x2r;
    a[j + 1] = x0i + x2i;
    a[j + 2] = y0r + y2r;
    a[j + 3] = y0i + y2i;
    a[j1] = x0r - x2r;
    a[j1 + 1] = x0i - x2i;
    a[j1 + 2] = y0r - y2r;
    a[j1 + 3] = y0i - y2i;
    x0r = x1r - x3i;
    x0i = x1i + x3r;
    a[j2] = wk1r * x0r - wk1i * x0i;
    a[j2 + 1] = wk1r * x0i + wk1i * x0r;
    x0r = y1r - y3i;
    x0i = y1i + y3r;
    a[j2 + 2] = wd1r * x0r - wd1i * x0i;
    a[j2 + 3] = wd1r * x0i + wd1i * x0r;
    x0r = x1r + x3i;
    x0i = x1i - x3r;
    a[j3] = wk3r * x0r + wk3i * x0i;
    a[j3 + 1] = wk3r * x0i - wk3i * x0r;
    x0r = y1r + y3i;
    x0i = y1i - y3r;
    a[j3 + 2] = wd3r * x0r + wd3i * x0i;
    a[j3 + 3] = wd3r * x0i - wd3i * 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];
    y0r = a[j0 - 2] + a[j2 - 2];
    y0i = a[j0 - 1] + a[j2 - 1];
    y1r = a[j0 - 2] - a[j2 - 2];
    y1i = 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];
    y2r = a[j1 - 2] + a[j3 - 2];
    y2i = a[j1 - 1] + a[j3 - 1];
    y3r = a[j1 - 2] - a[j3 - 2];
    y3i = a[j1 - 1] - a[j3 - 1];
    a[j0] = x0r + x2r;
    a[j0 + 1] = x0i + x2i;
    a[j0 - 2] = y0r + y2r;
    a[j0 - 1] = y0i + y2i;
    a[j1] = x0r - x2r;
    a[j1 + 1] = x0i - x2i;
    a[j1 - 2] = y0r - y2r;
    a[j1 - 1] = y0i - y2i;
    x0r = x1r - x3i;
    x0i = x1i + x3r;
    a[j2] = wk1i * x0r - wk1r * x0i;
    a[j2 + 1] = wk1i * x0i + wk1r * x0r;
    x0r = y1r - y3i;
    x0i = y1i + y3r;
    a[j2 - 2] = wd1i * x0r - wd1r * x0i;
    a[j2 - 1] = wd1i * x0i + wd1r * x0r;
    x0r = x1r + x3i;
    x0i = x1i - x3r;
    a[j3] = wk3i * x0r + wk3r * x0i;
    a[j3 + 1] = wk3i * x0i - wk3r * x0r;
    x0r = y1r + y3i;
    x0i = y1i - y3r;
    a[j3 - 2] = wd3i * x0r + wd3r * x0i;
    a[j3 - 1] = wd3i * x0i - wd3r * x0r;
  }
  wk1r = csc1 * (wd1r + wn4r);
  wk1i = csc1 * (wd1i + wn4r);
  wk3r = csc3 * (wd3r - wn4r);
  wk3i = csc3 * (wd3i - wn4r);
  j0 = mh;
  j1 = j0 + m;
  j2 = j1 + m;
  j3 = j2 + m;
  x0r = a[j0 - 2] + a[j2 - 2];
  x0i = a[j0 - 1] + a[j2 - 1];
  x1r = a[j0 - 2] - a[j2 - 2];
  x1i = a[j0 - 1] - a[j2 - 1];
  x2r = a[j1 - 2] + a[j3 - 2];
  x2i = a[j1 - 1] + a[j3 - 1];
  x3r = a[j1 - 2] - a[j3 - 2];
  x3i = a[j1 - 1] - a[j3 - 1];
  a[j0 - 2] = x0r + x2r;
  a[j0 - 1] = x0i + x2i;
  a[j1 - 2] = x0r - x2r;
  a[j1 - 1] = x0i - x2i;
  x0r = x1r - x3i;
  x0i = x1i + x3r;
  a[j2 - 2] = wk1r * x0r - wk1i * x0i;
  a[j2 - 1] = wk1r * x0i + wk1i * x0r;
  x0r = x1r + x3i;
  x0i = x1i - x3r;
  a[j3 - 2] = wk3r * x0r + wk3i * x0i;
  a[j3 - 1] = wk3r * x0i - wk3i * x0r;
  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);
  x0r = a[j0 + 2] + a[j2 + 2];
  x0i = a[j0 + 3] + a[j2 + 3];
  x1r = a[j0 + 2] - a[j2 + 2];
  x1i = a[j0 + 3] - a[j2 + 3];
  x2r = a[j1 + 2] + a[j3 + 2];
  x2i = a[j1 + 3] + a[j3 + 3];
  x3r = a[j1 + 2] - a[j3 + 2];
  x3i = a[j1 + 3] - a[j3 + 3];
  a[j0 + 2] = x0r + x2r;
  a[j0 + 3] = x0i + x2i;
  a[j1 + 2] = x0r - x2r;
  a[j1 + 3] = x0i - x2i;
  x0r = x1r - x3i;
  x0i = x1i + x3r;
  a[j2 + 2] = wk1i * x0r - wk1r * x0i;
  a[j2 + 3] = wk1i * x0i + wk1r * x0r;
  x0r = x1r + x3i;
  x0i = x1i - x3r;
  a[j3 + 2] = wk3i * x0r + wk3r * x0i;
  a[j3 + 3] = wk3i * x0i - wk3r * x0r;
}


x86 assembly (clang, -O0):
<cftf1st>:
push   %rbp
mov    %rsp,%rbp
sub    $0x28,%rsp
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,-0x68(%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,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%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,-0x74(%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,-0x78(%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,-0x7c(%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,-0x80(%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,-0x84(%rbp)
ff
movss  -0x68(%rbp),%xmm0
addss  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x6c(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x68(%rbp),%xmm0
subss  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
subss  -0x80(%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)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  0x1cc6(%rip),%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  0x1cb1(%rip),%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x2,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    1ff9 <cftf1st+0xef9>
mov    -0x30(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x30(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x60(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x64(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%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,-0x68(%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,-0x6c(%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,-0x70(%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,-0x74(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
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,-0x78(%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,-0x7c(%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,-0x80(%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,-0x84(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x68(%rbp),%xmm0
addss  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
addss  -0x98(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
addss  -0x9c(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
subss  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
subss  -0x98(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
subss  -0x9c(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x68(%rbp)
movss  -0x74(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x48(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x6c(%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  -0x48(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x68(%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  -0x90(%rbp),%xmm0
ff
subss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0x68(%rbp)
movss  -0x94(%rbp),%xmm0
ff
addss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0x6c(%rbp)
movss  -0x58(%rbp),%xmm0
movss  -0x68(%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
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x68(%rbp)
movss  -0x74(%rbp),%xmm0
subss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x50(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
movss  -0x6c(%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
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x90(%rbp),%xmm0
ff
addss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0x68(%rbp)
movss  -0x94(%rbp),%xmm0
ff
subss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0x6c(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  -0x68(%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    $0x3,%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,-0x68(%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,-0x6c(%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,-0x70(%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,-0x74(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
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,-0x78(%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,-0x7c(%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,-0x80(%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,-0x84(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x68(%rbp),%xmm0
addss  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
addss  -0x98(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
addss  -0x9c(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
subss  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
subss  -0x98(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
subss  -0x9c(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x68(%rbp)
movss  -0x74(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  -0x6c(%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  -0x4c(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  -0x68(%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  -0x90(%rbp),%xmm0
ff
subss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0x68(%rbp)
movss  -0x94(%rbp),%xmm0
ff
addss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0x6c(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x68(%rbp)
movss  -0x74(%rbp),%xmm0
subss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  -0x68(%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)
movss  -0x90(%rbp),%xmm0
ff
addss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0x68(%rbp)
movss  -0x94(%rbp),%xmm0
ff
subss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0x6c(%rbp)
movss  -0x64(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x64(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x68(%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
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x1c(%rbp)
jmp    136a <cftf1st+0x26a>
movss  -0x40(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
addss  -0x3c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm1
addss  -0x3c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x60(%rbp),%xmm1
subss  -0x3c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x64(%rbp),%xmm1
subss  -0x3c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
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
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x68(%rbp),%xmm0
addss  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
subss  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x68(%rbp)
movss  -0x74(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x48(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x68(%rbp)
movss  -0x74(%rbp),%xmm0
subss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x50(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
movss  -0x6c(%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
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
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,-0x68(%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,-0x6c(%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,-0x70(%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,-0x74(%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,-0x78(%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,-0x7c(%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,-0x80(%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,-0x84(%rbp)
ff
movss  -0x68(%rbp),%xmm0
addss  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
subss  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x68(%rbp)
movss  -0x74(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x68(%rbp),%xmm1
subss  -0x6c(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm1
addss  -0x68(%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  -0x70(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x68(%rbp)
movss  -0x74(%rbp),%xmm0
subss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x3c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x68(%rbp),%xmm1
addss  -0x6c(%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  -0x6c(%rbp),%xmm1
subss  -0x68(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x68(%rbp),%xmm0
addss  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
subss  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x68(%rbp)
movss  -0x74(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x68(%rbp)
movss  -0x74(%rbp),%xmm0
subss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  -0x68(%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    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
add    $0x28,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cftf1st>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %edi,%ebx
sar    $0x3,%ebx
lea    (%rbx,%rbx,1),%ecx
lea    0x0(,%rbx,4),%eax
lea    (%rcx,%rcx,2),%ebp
movslq %eax,%r9
movss  (%rsi,%r9,4),%xmm2
movss  (%rsi),%xmm9
movss  0x4(%rsi),%xmm0
movaps %xmm9,%xmm3
addss  %xmm2,%xmm3
lea    0x1(,%rbx,4),%eax
movslq %eax,%r8
movss  (%rsi,%r8,4),%xmm5
movaps %xmm0,%xmm4
addss  %xmm5,%xmm4
subss  %xmm2,%xmm9
subss  %xmm5,%xmm0
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm2
movslq %ebp,%rbp
movss  (%rsi,%rbp,4),%xmm8
movaps %xmm2,%xmm6
addss  %xmm8,%xmm6
lea    0x1(%rbx,%rbx,1),%eax
movslq %eax,%r10
movss  (%rsi,%r10,4),%xmm7
mov    %ebp,%eax
or     $0x1,%eax
cltq
movss  (%rsi,%rax,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,%rcx,4)
subss  %xmm1,%xmm4
movss  %xmm4,(%rsi,%r10,4)
movaps %xmm9,%xmm1
subss  %xmm7,%xmm1
movss  %xmm1,(%rsi,%r9,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,%rax,4)
movss  0x4(%rdx),%xmm0
movaps %xmm0,-0x10(%rsp)
movss  0x8(%rdx),%xmm2
mov    %rdx,-0x30(%rsp)
movss  0xc(%rdx),%xmm0
mov    %rbx,-0x38(%rsp)
lea    -0x2(%rbx),%eax
cltq
mov    %rax,-0x58(%rsp)
cmp    $0x28,%edi
movss  %xmm0,-0x70(%rsp)
movss  %xmm2,-0x74(%rsp)
jl     178f <cftf1st+0x68f>
lea    (%rcx,%rcx,2),%eax
cltq
lea    0x3(%rax),%rdx
mov    %rdx,-0x48(%rsp)
lea    0x3(%r9),%r13
add    $0xffffffffffffffff,%r9
mov    %r9,-0x40(%rsp)
add    $0xffffffffffffffff,%rax
lea    -0x4(%rcx),%rbp
lea    -0x10(,%rcx,8),%rbx
ff
lea    0x0(,%rcx,4),%r8
lea    (%r8,%r8,2),%r11
add    $0xfffffffffffffff0,%r11
mov    %rcx,%rdi
shl    $0x22,%rdi
movabs $0xfffffffe00000000,%rdx
ff ff ff
add    %rdi,%rdx
mov    %rdx,-0x50(%rsp)
mov    %rcx,%r15
shl    $0x4,%r15
add    $0xfffffffffffffff0,%r15
lea    0x8(,%rcx,8),%r10
add    $0x2,%rcx
lea    (%r8,%r8,2),%r8
add    $0x8,%r8
movss  0xd55(%rip),%xmm11
xorps  %xmm3,%xmm3
mov    $0x3,%r9d
xorps  %xmm14,%xmm14
movaps %xmm11,%xmm13
mov    -0x58(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  %xmm3,-0x5c(%rsp)
mov    -0x30(%rsp),%rdx
movss  0x4(%rdx,%r9,4),%xmm0
movss  %xmm0,-0x60(%rsp)
movss  (%rsi,%r10,1),%xmm5
movss  (%rsi,%r13,4),%xmm2
mov    %r13,%rdi
mov    %r13,-0x28(%rsp)
movups -0x4(%rsi,%r9,4),%xmm6
movaps %xmm6,%xmm0
subss  %xmm5,%xmm0
movaps %xmm0,-0x20(%rsp)
movaps %xmm6,%xmm1
shufps $0x55,%xmm6,%xmm1
subss  %xmm2,%xmm1
movsd  0x8(%rsi,%r10,1),%xmm3
unpcklps %xmm2,%xmm5
movlhps %xmm3,%xmm5
addps  %xmm6,%xmm5
movaps %xmm6,%xmm15
unpckhpd %xmm6,%xmm15
subss  %xmm3,%xmm15
shufps $0xff,%xmm6,%xmm6
shufps $0x55,%xmm3,%xmm3
subss  %xmm3,%xmm6
movss  (%rsi,%r8,1),%xmm10
mov    -0x48(%rsp),%r13
movss  (%rsi,%r13,4),%xmm3
movups (%rsi,%rcx,4),%xmm2
movaps %xmm2,%xmm9
subss  %xmm10,%xmm9
movaps %xmm2,%xmm7
shufps $0x55,%xmm2,%xmm7
subss  %xmm3,%xmm7
movsd  0x8(%rsi,%r8,1),%xmm0
unpcklps %xmm3,%xmm10
movlhps %xmm0,%xmm10
addps  %xmm2,%xmm10
movaps %xmm2,%xmm8
unpckhpd %xmm2,%xmm8
subss  %xmm0,%xmm8
shufps $0xff,%xmm2,%xmm2
shufps $0x55,%xmm0,%xmm0
subss  %xmm0,%xmm2
movaps %xmm5,%xmm0
addps  %xmm10,%xmm0
movss  0x8(%rdx,%r9,4),%xmm3
movss  %xmm3,-0x68(%rsp)
movss  0xc(%rdx,%r9,4),%xmm4
movss  %xmm4,-0x6c(%rsp)
movss  0x10(%rdx,%r9,4),%xmm12
movss  %xmm12,-0x64(%rsp)
movups %xmm0,-0x4(%rsi,%r9,4)
subps  %xmm10,%xmm5
movups %xmm5,(%rsi,%rcx,4)
movss  -0x60(%rsp),%xmm10
addss  %xmm10,%xmm13
movss  -0x74(%rsp),%xmm0
mulss  %xmm0,%xmm13
addss  %xmm3,%xmm14
mulss  %xmm0,%xmm14
movaps -0x20(%rsp),%xmm0
subss  %xmm7,%xmm0
movaps %xmm1,%xmm5
addss  %xmm9,%xmm5
movaps %xmm13,%xmm4
mulss  %xmm5,%xmm4
mulss  %xmm14,%xmm5
movaps %xmm13,%xmm3
mulss  %xmm0,%xmm3
subss  %xmm5,%xmm3
movss  %xmm3,(%rsi,%r10,1)
mulss  %xmm14,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,(%rsi,%rdi,4)
movaps %xmm15,%xmm0
subss  %xmm2,%xmm0
movaps %xmm6,%xmm3
addss  %xmm8,%xmm3
movaps %xmm10,%xmm12
mulss  %xmm3,%xmm12
movss  -0x68(%rsp),%xmm4
mulss  %xmm4,%xmm3
movaps %xmm10,%xmm5
mulss  %xmm0,%xmm5
subss  %xmm3,%xmm5
movss  %xmm5,0x8(%rsi,%r10,1)
mulss  %xmm4,%xmm0
addss  %xmm12,%xmm0
movss  %xmm0,0xc(%rsi,%r10,1)
movss  -0x6c(%rsp),%xmm5
addss  %xmm5,%xmm11
movss  -0x70(%rsp),%xmm0
mulss  %xmm0,%xmm11
movss  -0x5c(%rsp),%xmm12
movss  -0x64(%rsp),%xmm4
addss  %xmm4,%xmm12
mulss  %xmm0,%xmm12
addss  -0x20(%rsp),%xmm7
subss  %xmm9,%xmm1
movaps %xmm12,%xmm0
mulss  %xmm1,%xmm0
movaps %xmm11,%xmm3
mulss  %xmm7,%xmm3
addss  %xmm0,%xmm3
movss  %xmm3,(%rsi,%r8,1)
mulss  %xmm12,%xmm7
mulss  %xmm11,%xmm1
subss  %xmm7,%xmm1
movss  %xmm1,(%rsi,%r13,4)
addss  %xmm15,%xmm2
subss  %xmm8,%xmm6
movaps %xmm4,%xmm0
mulss  %xmm6,%xmm0
movaps %xmm5,%xmm3
movaps %xmm5,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x8(%rsi,%r8,1)
mulss  %xmm4,%xmm2
mulss  %xmm5,%xmm6
subss  %xmm2,%xmm6
movss  %xmm6,0xc(%rsi,%r8,1)
movss  (%rsi,%rax,4),%xmm0
movups (%rsi,%rbp,4),%xmm6
movaps %xmm6,%xmm10
unpckhpd %xmm6,%xmm10
movsd  0x4(%rsi,%r11,1),%xmm4
movaps %xmm6,%xmm2
shufps $0xff,%xmm6,%xmm2
subss  %xmm0,%xmm2
movss  (%rsi,%r11,1),%xmm3
movaps %xmm6,%xmm15
subss  %xmm3,%xmm15
unpcklps %xmm4,%xmm3
shufps $0xd4,%xmm4,%xmm0
shufps $0x24,%xmm0,%xmm3
addps  %xmm6,%xmm3
shufps $0x55,%xmm6,%xmm6
subss  %xmm4,%xmm6
shufps $0x55,%xmm4,%xmm4
subss  %xmm4,%xmm10
movsd  0x4(%rsi,%rbx,1),%xmm5
movss  (%rsi,%rbx,1),%xmm8
movaps %xmm8,%xmm0
unpcklps %xmm5,%xmm0
mov    %r11,%rdi
mov    -0x40(%rsp),%r11
movss  (%rsi,%r11,4),%xmm4
movaps %xmm4,%xmm9
shufps $0xd4,%xmm5,%xmm4
shufps $0x24,%xmm4,%xmm0
mov    -0x50(%rsp),%rdx
mov    %rdx,%r12
sar    $0x1e,%r12
or     $0x4,%r12
movsd  0x4(%rsi,%r15,1),%xmm4
subps  %xmm4,%xmm5
movss  (%rsi,%r12,1),%xmm7
subss  %xmm7,%xmm9
movss  (%rsi,%r15,1),%xmm1
subss  %xmm1,%xmm8
unpcklps %xmm4,%xmm1
shufps $0xd4,%xmm4,%xmm7
shufps $0x24,%xmm7,%xmm1
addps  %xmm0,%xmm1
movaps %xmm3,%xmm0
addps  %xmm1,%xmm0
movups %xmm0,(%rsi,%rbp,4)
subps  %xmm1,%xmm3
movaps %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
movss  %xmm0,0x8(%rsi,%rbx,1)
movaps %xmm3,%xmm0
shufps $0xff,%xmm3,%xmm0
movss  %xmm0,(%rsi,%r11,4)
movss  %xmm3,(%rsi,%rbx,1)
shufps $0x55,%xmm3,%xmm3
movss  %xmm3,0x4(%rsi,%rbx,1)
movaps %xmm5,%xmm3
shufps $0x55,%xmm5,%xmm3
movaps %xmm10,%xmm0
subss  %xmm9,%xmm0
movaps %xmm2,%xmm1
addss  %xmm3,%xmm1
movaps %xmm1,%xmm4
mulss  %xmm13,%xmm4
mulss  %xmm14,%xmm1
mulss  %xmm0,%xmm14
subss  %xmm4,%xmm14
movss  %xmm14,0x8(%rsi,%rdi,1)
mulss  %xmm13,%xmm0
addss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rax,4)
movaps %xmm15,%xmm0
subss  %xmm5,%xmm0
movaps %xmm6,%xmm1
addss  %xmm8,%xmm1
movss  -0x68(%rsp),%xmm14
movaps %xmm14,%xmm13
mulss  %xmm1,%xmm13
movss  -0x60(%rsp),%xmm4
mulss  %xmm4,%xmm1
movaps %xmm14,%xmm7
mulss  %xmm0,%xmm7
subss  %xmm1,%xmm7
movss  %xmm7,(%rsi,%rdi,1)
mulss  %xmm4,%xmm0
movaps %xmm4,%xmm1
addss  %xmm13,%xmm0
movss  %xmm0,0x4(%rsi,%rdi,1)
addss  %xmm10,%xmm9
subss  %xmm3,%xmm2
movaps %xmm12,%xmm0
mulss  %xmm9,%xmm0
mulss  %xmm11,%xmm9
mulss  %xmm2,%xmm11
addss  %xmm11,%xmm0
movss  %xmm0,0x8(%rsi,%r15,1)
mulss  %xmm12,%xmm2
subss  %xmm9,%xmm2
movss  %xmm2,(%rsi,%r12,1)
addss  %xmm15,%xmm5
movss  -0x6c(%rsp),%xmm7
movss  -0x64(%rsp),%xmm4
movaps %xmm1,%xmm15
subss  %xmm8,%xmm6
movaps %xmm7,%xmm0
mulss  %xmm6,%xmm0
movaps %xmm4,%xmm1
mulss  %xmm5,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%r15,1)
mulss  %xmm7,%xmm5
mulss  %xmm4,%xmm6
subss  %xmm5,%xmm6
movaps %xmm14,%xmm1
movss  %xmm6,0x4(%rsi,%r15,1)
lea    0x4(%r9),%r12
add    $0x4,%r13
mov    %r13,-0x48(%rsp)
mov    -0x28(%rsp),%r13
add    $0x4,%r13
add    $0xfffffffffffffffc,%r11
mov    %r11,-0x40(%rsp)
mov    %rdi,%r11
add    $0xfffffffffffffffc,%rax
add    $0xfffffffffffffffc,%rbp
add    $0xfffffffffffffff0,%rbx
add    $0xfffffffffffffff0,%r11
movabs $0xfffffffc00000000,%rdi
ff ff ff
add    %rdi,%rdx
mov    %rdx,-0x50(%rsp)
add    $0xfffffffffffffff0,%r15
add    $0x4,%rcx
add    $0x10,%r10
add    $0x10,%r8
add    $0x3,%r9
movaps %xmm4,%xmm3
movaps %xmm7,%xmm11
movaps %xmm15,%xmm13
cmp    %r14,%r9
mov    %r12,%r9
jl     12d0 <cftf1st+0x1d0>
jmp    17a2 <cftf1st+0x6a2>
xorps  %xmm1,%xmm1
movss  0x865(%rip),%xmm15
movaps %xmm15,%xmm7
xorps  %xmm4,%xmm4
movaps -0x10(%rsp),%xmm10
addss  %xmm10,%xmm15
movss  -0x74(%rsp),%xmm0
mulss  %xmm0,%xmm15
addss  %xmm10,%xmm1
mulss  %xmm0,%xmm1
subss  %xmm10,%xmm7
movss  -0x70(%rsp),%xmm0
mulss  %xmm0,%xmm7
subss  %xmm10,%xmm4
mulss  %xmm0,%xmm4
mov    -0x38(%rsp),%rdx
lea    (%rdx,%rdx,2),%eax
lea    (%rdx,%rdx,4),%ecx
lea    0x0(,%rdx,8),%ebp
sub    %edx,%ebp
mov    -0x58(%rsp),%rbx
movss  (%rsi,%rbx,4),%xmm8
movslq %ecx,%rcx
movss  -0x8(%rsi,%rcx,4),%xmm0
movss  -0x4(%rsi,%rcx,4),%xmm2
movaps %xmm1,%xmm13
movaps %xmm8,%xmm5
addss  %xmm0,%xmm5
movslq %edx,%rdx
movss  -0x4(%rsi,%rdx,4),%xmm6
movaps %xmm6,%xmm1
addss  %xmm2,%xmm1
subss  %xmm0,%xmm8
subss  %xmm2,%xmm6
movslq %eax,%rdi
movss  -0x8(%rsi,%rdi,4),%xmm9
movss  -0x4(%rsi,%rdi,4),%xmm2
movslq %ebp,%rax
movss  -0x8(%rsi,%rax,4),%xmm0
movss  -0x4(%rsi,%rax,4),%xmm11
movaps %xmm9,%xmm3
addss  %xmm0,%xmm3
movaps %xmm2,%xmm12
addss  %xmm11,%xmm12
subss  %xmm0,%xmm9
subss  %xmm11,%xmm2
movaps %xmm5,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,(%rsi,%rbx,4)
movaps %xmm1,%xmm0
addss  %xmm12,%xmm0
movss  %xmm0,-0x4(%rsi,%rdx,4)
subss  %xmm3,%xmm5
movss  %xmm5,-0x8(%rsi,%rdi,4)
subss  %xmm12,%xmm1
movss  %xmm1,-0x4(%rsi,%rdi,4)
movaps %xmm8,%xmm0
subss  %xmm2,%xmm0
movaps %xmm6,%xmm1
addss  %xmm9,%xmm1
movaps %xmm15,%xmm3
mulss  %xmm1,%xmm3
mulss  %xmm13,%xmm1
movaps %xmm15,%xmm5
mulss  %xmm0,%xmm5
subss  %xmm1,%xmm5
movss  %xmm5,-0x8(%rsi,%rcx,4)
mulss  %xmm13,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,-0x4(%rsi,%rcx,4)
addss  %xmm8,%xmm2
subss  %xmm9,%xmm6
movaps %xmm4,%xmm0
mulss  %xmm6,%xmm0
movaps %xmm7,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,-0x8(%rsi,%rax,4)
mulss  %xmm4,%xmm2
mulss  %xmm7,%xmm6
subss  %xmm2,%xmm6
movss  %xmm6,-0x4(%rsi,%rax,4)
movss  (%rsi,%rdx,4),%xmm8
movss  0x4(%rsi,%rdx,4),%xmm6
movss  (%rsi,%rcx,4),%xmm0
movss  0x4(%rsi,%rcx,4),%xmm2
movaps %xmm8,%xmm5
addss  %xmm0,%xmm5
movaps %xmm6,%xmm1
addss  %xmm2,%xmm1
subss  %xmm0,%xmm8
subss  %xmm2,%xmm6
movss  (%rsi,%rdi,4),%xmm11
movss  0x4(%rsi,%rdi,4),%xmm12
movss  (%rsi,%rax,4),%xmm0
movss  0x4(%rsi,%rax,4),%xmm9
movaps %xmm11,%xmm3
addss  %xmm0,%xmm3
movaps %xmm12,%xmm2
addss  %xmm9,%xmm2
subss  %xmm0,%xmm11
subss  %xmm9,%xmm12
movaps %xmm5,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,(%rsi,%rdx,4)
movaps %xmm1,%xmm0
addss  %xmm2,%xmm0
movss  %xmm0,0x4(%rsi,%rdx,4)
subss  %xmm3,%xmm5
movss  %xmm5,(%rsi,%rdi,4)
subss  %xmm2,%xmm1
movss  %xmm1,0x4(%rsi,%rdi,4)
movaps %xmm8,%xmm0
subss  %xmm12,%xmm0
movaps %xmm6,%xmm2
addss  %xmm11,%xmm2
movaps %xmm0,%xmm3
subss  %xmm2,%xmm3
mulss  %xmm10,%xmm3
movss  %xmm3,(%rsi,%rcx,4)
addss  %xmm0,%xmm2
mulss  %xmm10,%xmm2
movss  %xmm2,0x4(%rsi,%rcx,4)
addss  %xmm8,%xmm12
subss  %xmm11,%xmm6
xorps  0x636(%rip),%xmm10
movaps %xmm6,%xmm0
addss  %xmm12,%xmm0
mulss  %xmm10,%xmm0
movss  %xmm0,(%rsi,%rax,4)
subss  %xmm12,%xmm6
mulss  %xmm10,%xmm6
movss  %xmm6,0x4(%rsi,%rax,4)
movss  0x8(%rsi,%rdx,4),%xmm8
movss  0xc(%rsi,%rdx,4),%xmm6
movss  0x8(%rsi,%rcx,4),%xmm0
movss  0xc(%rsi,%rcx,4),%xmm1
movaps %xmm8,%xmm5
addss  %xmm0,%xmm5
movaps %xmm6,%xmm2
addss  %xmm1,%xmm2
subss  %xmm0,%xmm8
subss  %xmm1,%xmm6
movss  0x8(%rsi,%rdi,4),%xmm9
movss  0xc(%rsi,%rdi,4),%xmm1
movss  0x8(%rsi,%rax,4),%xmm0
movss  0xc(%rsi,%rax,4),%xmm10
movaps %xmm9,%xmm3
addss  %xmm0,%xmm3
movaps %xmm1,%xmm11
addss  %xmm10,%xmm11
subss  %xmm0,%xmm9
subss  %xmm10,%xmm1
movaps %xmm5,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,0x8(%rsi,%rdx,4)
movaps %xmm2,%xmm0
addss  %xmm11,%xmm0
movss  %xmm0,0xc(%rsi,%rdx,4)
subss  %xmm3,%xmm5
movss  %xmm5,0x8(%rsi,%rdi,4)
subss  %xmm11,%xmm2
movss  %xmm2,0xc(%rsi,%rdi,4)
movaps %xmm8,%xmm0
subss  %xmm1,%xmm0
movaps %xmm6,%xmm2
addss  %xmm9,%xmm2
movaps %xmm2,%xmm3
mulss  %xmm15,%xmm3
movaps %xmm13,%xmm5
mulss  %xmm0,%xmm5
subss  %xmm3,%xmm5
movss  %xmm5,0x8(%rsi,%rcx,4)
mulss  %xmm15,%xmm0
mulss  %xmm13,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0xc(%rsi,%rcx,4)
addss  %xmm8,%xmm1
subss  %xmm9,%xmm6
movaps %xmm7,%xmm0
mulss  %xmm6,%xmm0
movaps %xmm4,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0x8(%rsi,%rax,4)
mulss  %xmm7,%xmm1
mulss  %xmm4,%xmm6
subss  %xmm1,%xmm6
movss  %xmm6,0xc(%rsi,%rax,4)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @cftf1st(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
%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
%37 = alloca float
%38 = alloca float
%39 = alloca float
%40 = alloca float
%41 = alloca float
store i32 %0, i32* %4
store float* %1, float** %5
store float* %2, float** %6
%42 = load i32, i32* %4
%43 = ashr i32 %42, 3
store i32 %43, i32* %14
%44 = load i32, i32* %14
%45 = mul nsw i32 2, %44
store i32 %45, i32* %13
%46 = load i32, i32* %13
store i32 %46, i32* %9
%47 = load i32, i32* %9
%48 = load i32, i32* %13
%49 = add nsw i32 %47, %48
store i32 %49, i32* %10
%50 = load i32, i32* %10
%51 = load i32, i32* %13
%52 = add nsw i32 %50, %51
store i32 %52, i32* %11
%53 = load float*, float** %5
%54 = getelementptr inbounds float, float* %53, i64 0
%55 = load float, float* %54
%56 = load float*, float** %5
%57 = load i32, i32* %10
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds float, float* %56, i64 %58
%60 = load float, float* %59
%61 = fadd float %55, %60
store float %61, float* %26
%62 = load float*, float** %5
%63 = getelementptr inbounds float, float* %62, i64 1
%64 = load float, float* %63
%65 = load float*, float** %5
%66 = load i32, i32* %10
%67 = add nsw i32 %66, 1
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds float, float* %65, i64 %68
%70 = load float, float* %69
%71 = fadd float %64, %70
store float %71, float* %27
%72 = load float*, float** %5
%73 = getelementptr inbounds float, float* %72, i64 0
%74 = load float, float* %73
%75 = load float*, float** %5
%76 = load i32, i32* %10
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds float, float* %75, i64 %77
%79 = load float, float* %78
%80 = fsub float %74, %79
store float %80, float* %28
%81 = load float*, float** %5
%82 = getelementptr inbounds float, float* %81, i64 1
%83 = load float, float* %82
%84 = load float*, float** %5
%85 = load i32, i32* %10
%86 = add nsw i32 %85, 1
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds float, float* %84, i64 %87
%89 = load float, float* %88
%90 = fsub float %83, %89
store float %90, float* %29
%91 = load float*, float** %5
%92 = load i32, i32* %9
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds float, float* %91, i64 %93
%95 = load float, float* %94
%96 = load float*, float** %5
%97 = load i32, i32* %11
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds float, float* %96, i64 %98
%100 = load float, float* %99
%101 = fadd float %95, %100
store float %101, float* %30
%102 = load float*, float** %5
%103 = load i32, i32* %9
%104 = add nsw i32 %103, 1
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds float, float* %102, i64 %105
%107 = load float, float* %106
%108 = load float*, float** %5
%109 = load i32, i32* %11
%110 = add nsw i32 %109, 1
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds float, float* %108, i64 %111
%113 = load float, float* %112
%114 = fadd float %107, %113
store float %114, float* %31
%115 = load float*, float** %5
%116 = load i32, i32* %9
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds float, float* %115, i64 %117
%119 = load float, float* %118
%120 = load float*, float** %5
%121 = load i32, i32* %11
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds float, float* %120, i64 %122
%124 = load float, float* %123
%125 = fsub float %119, %124
store float %125, float* %32
%126 = load float*, float** %5
%127 = load i32, i32* %9
%128 = add nsw i32 %127, 1
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds float, float* %126, i64 %129
%131 = load float, float* %130
%132 = load float*, float** %5
%133 = load i32, i32* %11
%134 = add nsw i32 %133, 1
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds float, float* %132, i64 %135
%137 = load float, float* %136
%138 = fsub float %131, %137
store float %138, float* %33
%139 = load float, float* %26
%140 = load float, float* %30
%141 = fadd float %139, %140
%142 = load float*, float** %5
%143 = getelementptr inbounds float, float* %142, i64 0
store float %141, float* %143
%144 = load float, float* %27
%145 = load float, float* %31
%146 = fadd float %144, %145
%147 = load float*, float** %5
%148 = getelementptr inbounds float, float* %147, i64 1
store float %146, float* %148
%149 = load float, float* %26
%150 = load float, float* %30
%151 = fsub float %149, %150
%152 = load float*, float** %5
%153 = load i32, i32* %9
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds float, float* %152, i64 %154
store float %151, float* %155
%156 = load float, float* %27
%157 = load float, float* %31
%158 = fsub float %156, %157
%159 = load float*, float** %5
%160 = load i32, i32* %9
%161 = add nsw i32 %160, 1
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds float, float* %159, i64 %162
store float %158, float* %163
%164 = load float, float* %28
%165 = load float, float* %33
%166 = fsub float %164, %165
%167 = load float*, float** %5
%168 = load i32, i32* %10
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds float, float* %167, i64 %169
store float %166, float* %170
%171 = load float, float* %29
%172 = load float, float* %32
%173 = fadd float %171, %172
%174 = load float*, float** %5
%175 = load i32, i32* %10
%176 = add nsw i32 %175, 1
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds float, float* %174, i64 %177
store float %173, float* %178
%179 = load float, float* %28
%180 = load float, float* %33
%181 = fadd float %179, %180
%182 = load float*, float** %5
%183 = load i32, i32* %11
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds float, float* %182, i64 %184
store float %181, float* %185
%186 = load float, float* %29
%187 = load float, float* %32
%188 = fsub float %186, %187
%189 = load float*, float** %5
%190 = load i32, i32* %11
%191 = add nsw i32 %190, 1
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds float, float* %189, i64 %192
store float %188, float* %193
%194 = load float*, float** %6
%195 = getelementptr inbounds float, float* %194, i64 1
%196 = load float, float* %195
store float %196, float* %15
%197 = load float*, float** %6
%198 = getelementptr inbounds float, float* %197, i64 2
%199 = load float, float* %198
store float %199, float* %16
%200 = load float*, float** %6
%201 = getelementptr inbounds float, float* %200, i64 3
%202 = load float, float* %201
store float %202, float* %17
store float 1.000000e+00, float* %22
store float 0.000000e+00, float* %23
store float 1.000000e+00, float* %24
store float 0.000000e+00, float* %25
store i32 0, i32* %12
store i32 2, i32* %7
br label %203
203: ; preds = %1046, %3
%204 = load i32, i32* %7
%205 = load i32, i32* %14
%206 = sub nsw i32 %205, 2
%207 = icmp slt i32 %204, %206
br i1 %207, label %208, label %1049
208: ; preds = %203
%209 = load i32, i32* %12
%210 = add nsw i32 %209, 4
store i32 %210, i32* %12
%211 = load float, float* %16
%212 = load float, float* %22
%213 = load float*, float** %6
%214 = load i32, i32* %12
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds float, float* %213, i64 %215
%217 = load float, float* %216
%218 = fadd float %212, %217
%219 = fmul float %211, %218
store float %219, float* %18
%220 = load float, float* %16
%221 = load float, float* %23
%222 = load float*, float** %6
%223 = load i32, i32* %12
%224 = add nsw i32 %223, 1
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds float, float* %222, i64 %225
%227 = load float, float* %226
%228 = fadd float %221, %227
%229 = fmul float %220, %228
store float %229, float* %19
%230 = load float, float* %17
%231 = load float, float* %24
%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
%238 = fadd float %231, %237
%239 = fmul float %230, %238
store float %239, float* %20
%240 = load float, float* %17
%241 = load float, float* %25
%242 = load float*, float** %6
%243 = load i32, i32* %12
%244 = add nsw i32 %243, 3
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds float, float* %242, i64 %245
%247 = load float, float* %246
%248 = fadd float %241, %247
%249 = fmul float %240, %248
store float %249, float* %21
%250 = load float*, float** %6
%251 = load i32, i32* %12
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds float, float* %250, i64 %252
%254 = load float, float* %253
store float %254, float* %22
%255 = load float*, float** %6
%256 = load i32, i32* %12
%257 = add nsw i32 %256, 1
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds float, float* %255, i64 %258
%260 = load float, float* %259
store float %260, float* %23
%261 = load float*, float** %6
%262 = load i32, i32* %12
%263 = add nsw i32 %262, 2
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds float, float* %261, i64 %264
%266 = load float, float* %265
store float %266, float* %24
%267 = load float*, float** %6
%268 = load i32, i32* %12
%269 = add nsw i32 %268, 3
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds float, float* %267, i64 %270
%272 = load float, float* %271
store float %272, float* %25
%273 = load i32, i32* %7
%274 = load i32, i32* %13
%275 = add nsw i32 %273, %274
store i32 %275, i32* %9
%276 = load i32, i32* %9
%277 = load i32, i32* %13
%278 = add nsw i32 %276, %277
store i32 %278, i32* %10
%279 = load i32, i32* %10
%280 = load i32, i32* %13
%281 = add nsw i32 %279, %280
store i32 %281, i32* %11
%282 = load float*, float** %5
%283 = load i32, i32* %7
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds float, float* %282, i64 %284
%286 = load float, float* %285
%287 = load float*, float** %5
%288 = load i32, i32* %10
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds float, float* %287, i64 %289
%291 = load float, float* %290
%292 = fadd float %286, %291
store float %292, float* %26
%293 = load float*, float** %5
%294 = load i32, i32* %7
%295 = add nsw i32 %294, 1
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds float, float* %293, i64 %296
%298 = load float, float* %297
%299 = load float*, float** %5
%300 = load i32, i32* %10
%301 = add nsw i32 %300, 1
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds float, float* %299, i64 %302
%304 = load float, float* %303
%305 = fadd float %298, %304
store float %305, float* %27
%306 = load float*, float** %5
%307 = load i32, i32* %7
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds float, float* %306, i64 %308
%310 = load float, float* %309
%311 = load float*, float** %5
%312 = load i32, i32* %10
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds float, float* %311, i64 %313
%315 = load float, float* %314
%316 = fsub float %310, %315
store float %316, float* %28
%317 = load float*, float** %5
%318 = load i32, i32* %7
%319 = add nsw i32 %318, 1
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds float, float* %317, i64 %320
%322 = load float, float* %321
%323 = load float*, float** %5
%324 = load i32, i32* %10
%325 = add nsw i32 %324, 1
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds float, float* %323, i64 %326
%328 = load float, float* %327
%329 = fsub float %322, %328
store float %329, float* %29
%330 = load float*, float** %5
%331 = load i32, i32* %7
%332 = add nsw i32 %331, 2
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds float, float* %330, i64 %333
%335 = load float, float* %334
%336 = load float*, float** %5
%337 = load i32, i32* %10
%338 = add nsw i32 %337, 2
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds float, float* %336, i64 %339
%341 = load float, float* %340
%342 = fadd float %335, %341
store float %342, float* %34
%343 = load float*, float** %5
%344 = load i32, i32* %7
%345 = add nsw i32 %344, 3
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds float, float* %343, i64 %346
%348 = load float, float* %347
%349 = load float*, float** %5
%350 = load i32, i32* %10
%351 = add nsw i32 %350, 3
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds float, float* %349, i64 %352
%354 = load float, float* %353
%355 = fadd float %348, %354
store float %355, float* %35
%356 = load float*, float** %5
%357 = load i32, i32* %7
%358 = add nsw i32 %357, 2
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds float, float* %356, i64 %359
%361 = load float, float* %360
%362 = load float*, float** %5
%363 = load i32, i32* %10
%364 = add nsw i32 %363, 2
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds float, float* %362, i64 %365
%367 = load float, float* %366
%368 = fsub float %361, %367
store float %368, float* %36
%369 = load float*, float** %5
%370 = load i32, i32* %7
%371 = add nsw i32 %370, 3
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds float, float* %369, i64 %372
%374 = load float, float* %373
%375 = load float*, float** %5
%376 = load i32, i32* %10
%377 = add nsw i32 %376, 3
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds float, float* %375, i64 %378
%380 = load float, float* %379
%381 = fsub float %374, %380
store float %381, float* %37
%382 = load float*, float** %5
%383 = load i32, i32* %9
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds float, float* %382, i64 %384
%386 = load float, float* %385
%387 = load float*, float** %5
%388 = load i32, i32* %11
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds float, float* %387, i64 %389
%391 = load float, float* %390
%392 = fadd float %386, %391
store float %392, float* %30
%393 = load float*, float** %5
%394 = load i32, i32* %9
%395 = add nsw i32 %394, 1
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds float, float* %393, i64 %396
%398 = load float, 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
%404 = load float, float* %403
%405 = fadd float %398, %404
store float %405, float* %31
%406 = load float*, float** %5
%407 = load i32, i32* %9
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds float, float* %406, i64 %408
%410 = load float, float* %409
%411 = load float*, float** %5
%412 = load i32, i32* %11
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds float, float* %411, i64 %413
%415 = load float, float* %414
%416 = fsub float %410, %415
store float %416, float* %32
%417 = load float*, float** %5
%418 = load i32, i32* %9
%419 = add nsw i32 %418, 1
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds float, float* %417, i64 %420
%422 = load float, float* %421
%423 = load float*, float** %5
%424 = load i32, i32* %11
%425 = add nsw i32 %424, 1
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds float, float* %423, i64 %426
%428 = load float, float* %427
%429 = fsub float %422, %428
store float %429, float* %33
%430 = load float*, float** %5
%431 = load i32, i32* %9
%432 = add nsw i32 %431, 2
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds float, float* %430, i64 %433
%435 = load float, float* %434
%436 = load float*, float** %5
%437 = load i32, i32* %11
%438 = add nsw i32 %437, 2
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds float, float* %436, i64 %439
%441 = load float, float* %440
%442 = fadd float %435, %441
store float %442, float* %38
%443 = load float*, float** %5
%444 = load i32, i32* %9
%445 = add nsw i32 %444, 3
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds float, float* %443, i64 %446
%448 = load float, float* %447
%449 = load float*, float** %5
%450 = load i32, i32* %11
%451 = add nsw i32 %450, 3
%452 = sext i32 %451 to i64
%453 = getelementptr inbounds float, float* %449, i64 %452
%454 = load float, float* %453
%455 = fadd float %448, %454
store float %455, float* %39
%456 = load float*, float** %5
%457 = load i32, i32* %9
%458 = add nsw i32 %457, 2
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds float, float* %456, i64 %459
%461 = load float, float* %460
%462 = load float*, float** %5
%463 = load i32, i32* %11
%464 = add nsw i32 %463, 2
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds float, float* %462, i64 %465
%467 = load float, float* %466
%468 = fsub float %461, %467
store float %468, float* %40
%469 = load float*, float** %5
%470 = load i32, i32* %9
%471 = add nsw i32 %470, 3
%472 = sext i32 %471 to i64
%473 = getelementptr inbounds float, float* %469, i64 %472
%474 = load float, float* %473
%475 = load float*, float** %5
%476 = load i32, i32* %11
%477 = add nsw i32 %476, 3
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds float, float* %475, i64 %478
%480 = load float, float* %479
%481 = fsub float %474, %480
store float %481, float* %41
%482 = load float, float* %26
%483 = load float, float* %30
%484 = fadd float %482, %483
%485 = load float*, float** %5
%486 = load i32, i32* %7
%487 = sext i32 %486 to i64
%488 = getelementptr inbounds float, float* %485, i64 %487
store float %484, float* %488
%489 = load float, float* %27
%490 = load float, float* %31
%491 = fadd float %489, %490
%492 = load float*, float** %5
%493 = load i32, i32* %7
%494 = add nsw i32 %493, 1
%495 = sext i32 %494 to i64
%496 = getelementptr inbounds float, float* %492, i64 %495
store float %491, float* %496
%497 = load float, float* %34
%498 = load float, float* %38
%499 = fadd float %497, %498
%500 = load float*, float** %5
%501 = load i32, i32* %7
%502 = add nsw i32 %501, 2
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds float, float* %500, i64 %503
store float %499, float* %504
%505 = load float, float* %35
%506 = load float, float* %39
%507 = fadd float %505, %506
%508 = load float*, float** %5
%509 = load i32, i32* %7
%510 = add nsw i32 %509, 3
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds float, float* %508, i64 %511
store float %507, float* %512
%513 = load float, float* %26
%514 = load float, float* %30
%515 = fsub float %513, %514
%516 = load float*, float** %5
%517 = load i32, i32* %9
%518 = sext i32 %517 to i64
%519 = getelementptr inbounds float, float* %516, i64 %518
store float %515, float* %519
%520 = load float, float* %27
%521 = load float, float* %31
%522 = fsub float %520, %521
%523 = load float*, float** %5
%524 = load i32, i32* %9
%525 = add nsw i32 %524, 1
%526 = sext i32 %525 to i64
%527 = getelementptr inbounds float, float* %523, i64 %526
store float %522, float* %527
%528 = load float, float* %34
%529 = load float, float* %38
%530 = fsub float %528, %529
%531 = load float*, float** %5
%532 = load i32, i32* %9
%533 = add nsw i32 %532, 2
%534 = sext i32 %533 to i64
%535 = getelementptr inbounds float, float* %531, i64 %534
store float %530, float* %535
%536 = load float, float* %35
%537 = load float, float* %39
%538 = fsub float %536, %537
%539 = load float*, float** %5
%540 = load i32, i32* %9
%541 = add nsw i32 %540, 3
%542 = sext i32 %541 to i64
%543 = getelementptr inbounds float, float* %539, i64 %542
store float %538, float* %543
%544 = load float, float* %28
%545 = load float, float* %33
%546 = fsub float %544, %545
store float %546, float* %26
%547 = load float, float* %29
%548 = load float, float* %32
%549 = fadd float %547, %548
store float %549, float* %27
%550 = load float, float* %18
%551 = load float, float* %26
%552 = load float, float* %19
%553 = load float, float* %27
%554 = fmul float %552, %553
%555 = fneg float %554
%556 = call float @llvm.fmuladd.f32(float %550, float %551, float %555)
%557 = load float*, float** %5
%558 = load i32, i32* %10
%559 = sext i32 %558 to i64
%560 = getelementptr inbounds float, float* %557, i64 %559
store float %556, float* %560
%561 = load float, float* %18
%562 = load float, float* %27
%563 = load float, float* %19
%564 = load float, float* %26
%565 = fmul float %563, %564
%566 = call float @llvm.fmuladd.f32(float %561, float %562, float %565)
%567 = load float*, float** %5
%568 = load i32, i32* %10
%569 = add nsw i32 %568, 1
%570 = sext i32 %569 to i64
%571 = getelementptr inbounds float, float* %567, i64 %570
store float %566, float* %571
%572 = load float, float* %36
%573 = load float, float* %41
%574 = fsub float %572, %573
store float %574, float* %26
%575 = load float, float* %37
%576 = load float, float* %40
%577 = fadd float %575, %576
store float %577, float* %27
%578 = load float, float* %22
%579 = load float, float* %26
%580 = load float, float* %23
%581 = load float, float* %27
%582 = fmul float %580, %581
%583 = fneg float %582
%584 = call float @llvm.fmuladd.f32(float %578, float %579, float %583)
%585 = load float*, float** %5
%586 = load i32, i32* %10
%587 = add nsw i32 %586, 2
%588 = sext i32 %587 to i64
%589 = getelementptr inbounds float, float* %585, i64 %588
store float %584, float* %589
%590 = load float, float* %22
%591 = load float, float* %27
%592 = load float, float* %23
%593 = load float, float* %26
%594 = fmul float %592, %593
%595 = call float @llvm.fmuladd.f32(float %590, float %591, float %594)
%596 = load float*, float** %5
%597 = load i32, i32* %10
%598 = add nsw i32 %597, 3
%599 = sext i32 %598 to i64
%600 = getelementptr inbounds float, float* %596, i64 %599
store float %595, float* %600
%601 = load float, float* %28
%602 = load float, float* %33
%603 = fadd float %601, %602
store float %603, float* %26
%604 = load float, float* %29
%605 = load float, float* %32
%606 = fsub float %604, %605
store float %606, float* %27
%607 = load float, float* %20
%608 = load float, float* %26
%609 = load float, float* %21
%610 = load float, float* %27
%611 = fmul float %609, %610
%612 = call float @llvm.fmuladd.f32(float %607, float %608, float %611)
%613 = load float*, float** %5
%614 = load i32, i32* %11
%615 = sext i32 %614 to i64
%616 = getelementptr inbounds float, float* %613, i64 %615
store float %612, float* %616
%617 = load float, float* %20
%618 = load float, float* %27
%619 = load float, float* %21
%620 = load float, float* %26
%621 = fmul float %619, %620
%622 = fneg float %621
%623 = call float @llvm.fmuladd.f32(float %617, float %618, float %622)
%624 = load float*, float** %5
%625 = load i32, i32* %11
%626 = add nsw i32 %625, 1
%627 = sext i32 %626 to i64
%628 = getelementptr inbounds float, float* %624, i64 %627
store float %623, float* %628
%629 = load float, float* %36
%630 = load float, float* %41
%631 = fadd float %629, %630
store float %631, float* %26
%632 = load float, float* %37
%633 = load float, float* %40
%634 = fsub float %632, %633
store float %634, float* %27
%635 = load float, float* %24
%636 = load float, float* %26
%637 = load float, float* %25
%638 = load float, float* %27
%639 = fmul float %637, %638
%640 = call float @llvm.fmuladd.f32(float %635, float %636, float %639)
%641 = load float*, float** %5
%642 = load i32, i32* %11
%643 = add nsw i32 %642, 2
%644 = sext i32 %643 to i64
%645 = getelementptr inbounds float, float* %641, i64 %644
store float %640, float* %645
%646 = load float, float* %24
%647 = load float, float* %27
%648 = load float, float* %25
%649 = load float, float* %26
%650 = fmul float %648, %649
%651 = fneg float %650
%652 = call float @llvm.fmuladd.f32(float %646, float %647, float %651)
%653 = load float*, float** %5
%654 = load i32, i32* %11
%655 = add nsw i32 %654, 3
%656 = sext i32 %655 to i64
%657 = getelementptr inbounds float, float* %653, i64 %656
store float %652, float* %657
%658 = load i32, i32* %13
%659 = load i32, i32* %7
%660 = sub nsw i32 %658, %659
store i32 %660, i32* %8
%661 = load i32, i32* %8
%662 = load i32, i32* %13
%663 = add nsw i32 %661, %662
store i32 %663, i32* %9
%664 = load i32, i32* %9
%665 = load i32, i32* %13
%666 = add nsw i32 %664, %665
store i32 %666, i32* %10
%667 = load i32, i32* %10
%668 = load i32, i32* %13
%669 = add nsw i32 %667, %668
store i32 %669, i32* %11
%670 = load float*, float** %5
%671 = load i32, i32* %8
%672 = sext i32 %671 to i64
%673 = getelementptr inbounds float, float* %670, i64 %672
%674 = load float, float* %673
%675 = load float*, float** %5
%676 = load i32, i32* %10
%677 = sext i32 %676 to i64
%678 = getelementptr inbounds float, float* %675, i64 %677
%679 = load float, float* %678
%680 = fadd float %674, %679
store float %680, float* %26
%681 = load float*, float** %5
%682 = load i32, i32* %8
%683 = add nsw i32 %682, 1
%684 = sext i32 %683 to i64
%685 = getelementptr inbounds float, float* %681, i64 %684
%686 = load float, float* %685
%687 = load float*, float** %5
%688 = load i32, i32* %10
%689 = add nsw i32 %688, 1
%690 = sext i32 %689 to i64
%691 = getelementptr inbounds float, float* %687, i64 %690
%692 = load float, float* %691
%693 = fadd float %686, %692
store float %693, float* %27
%694 = load float*, float** %5
%695 = load i32, i32* %8
%696 = sext i32 %695 to i64
%697 = getelementptr inbounds float, float* %694, i64 %696
%698 = load float, float* %697
%699 = load float*, float** %5
%700 = load i32, i32* %10
%701 = sext i32 %700 to i64
%702 = getelementptr inbounds float, float* %699, i64 %701
%703 = load float, float* %702
%704 = fsub float %698, %703
store float %704, float* %28
%705 = load float*, float** %5
%706 = load i32, i32* %8
%707 = add nsw i32 %706, 1
%708 = sext i32 %707 to i64
%709 = getelementptr inbounds float, float* %705, i64 %708
%710 = load float, float* %709
%711 = load float*, float** %5
%712 = load i32, i32* %10
%713 = add nsw i32 %712, 1
%714 = sext i32 %713 to i64
%715 = getelementptr inbounds float, float* %711, i64 %714
%716 = load float, float* %715
%717 = fsub float %710, %716
store float %717, float* %29
%718 = load float*, float** %5
%719 = load i32, i32* %8
%720 = sub nsw i32 %719, 2
%721 = sext i32 %720 to i64
%722 = getelementptr inbounds float, float* %718, i64 %721
%723 = load float, float* %722
%724 = load float*, float** %5
%725 = load i32, i32* %10
%726 = sub nsw i32 %725, 2
%727 = sext i32 %726 to i64
%728 = getelementptr inbounds float, float* %724, i64 %727
%729 = load float, float* %728
%730 = fadd float %723, %729
store float %730, float* %34
%731 = load float*, float** %5
%732 = load i32, i32* %8
%733 = sub nsw i32 %732, 1
%734 = sext i32 %733 to i64
%735 = getelementptr inbounds float, float* %731, i64 %734
%736 = load float, float* %735
%737 = load float*, float** %5
%738 = load i32, i32* %10
%739 = sub nsw i32 %738, 1
%740 = sext i32 %739 to i64
%741 = getelementptr inbounds float, float* %737, i64 %740
%742 = load float, float* %741
%743 = fadd float %736, %742
store float %743, float* %35
%744 = load float*, float** %5
%745 = load i32, i32* %8
%746 = sub nsw i32 %745, 2
%747 = sext i32 %746 to i64
%748 = getelementptr inbounds float, float* %744, i64 %747
%749 = load float, float* %748
%750 = load float*, float** %5
%751 = load i32, i32* %10
%752 = sub nsw i32 %751, 2
%753 = sext i32 %752 to i64
%754 = getelementptr inbounds float, float* %750, i64 %753
%755 = load float, float* %754
%756 = fsub float %749, %755
store float %756, float* %36
%757 = load float*, float** %5
%758 = load i32, i32* %8
%759 = sub nsw i32 %758, 1
%760 = sext i32 %759 to i64
%761 = getelementptr inbounds float, float* %757, i64 %760
%762 = load float, float* %761
%763 = load float*, float** %5
%764 = load i32, i32* %10
%765 = sub nsw i32 %764, 1
%766 = sext i32 %765 to i64
%767 = getelementptr inbounds float, float* %763, i64 %766
%768 = load float, float* %767
%769 = fsub float %762, %768
store float %769, float* %37
%770 = load float*, float** %5
%771 = load i32, i32* %9
%772 = sext i32 %771 to i64
%773 = getelementptr inbounds float, float* %770, i64 %772
%774 = load float, float* %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
%779 = load float, float* %778
%780 = fadd float %774, %779
store float %780, float* %30
%781 = load float*, float** %5
%782 = load i32, i32* %9
%783 = add nsw i32 %782, 1
%784 = sext i32 %783 to i64
%785 = getelementptr inbounds float, float* %781, i64 %784
%786 = load float, float* %785
%787 = load float*, float** %5
%788 = load i32, i32* %11
%789 = add nsw i32 %788, 1
%790 = sext i32 %789 to i64
%791 = getelementptr inbounds float, float* %787, i64 %790
%792 = load float, float* %791
%793 = fadd float %786, %792
store float %793, float* %31
%794 = load float*, float** %5
%795 = load i32, i32* %9
%796 = sext i32 %795 to i64
%797 = getelementptr inbounds float, float* %794, i64 %796
%798 = load float, float* %797
%799 = load float*, float** %5
%800 = load i32, i32* %11
%801 = sext i32 %800 to i64
%802 = getelementptr inbounds float, float* %799, i64 %801
%803 = load float, float* %802
%804 = fsub float %798, %803
store float %804, float* %32
%805 = load float*, float** %5
%806 = load i32, i32* %9
%807 = add nsw i32 %806, 1
%808 = sext i32 %807 to i64
%809 = getelementptr inbounds float, float* %805, i64 %808
%810 = load float, float* %809
%811 = load float*, float** %5
%812 = load i32, i32* %11
%813 = add nsw i32 %812, 1
%814 = sext i32 %813 to i64
%815 = getelementptr inbounds float, float* %811, i64 %814
%816 = load float, float* %815
%817 = fsub float %810, %816
store float %817, float* %33
%818 = load float*, float** %5
%819 = load i32, i32* %9
%820 = sub nsw i32 %819, 2
%821 = sext i32 %820 to i64
%822 = getelementptr inbounds float, float* %818, i64 %821
%823 = load float, float* %822
%824 = load float*, float** %5
%825 = load i32, i32* %11
%826 = sub nsw i32 %825, 2
%827 = sext i32 %826 to i64
%828 = getelementptr inbounds float, float* %824, i64 %827
%829 = load float, float* %828
%830 = fadd float %823, %829
store float %830, float* %38
%831 = load float*, float** %5
%832 = load i32, i32* %9
%833 = sub nsw i32 %832, 1
%834 = sext i32 %833 to i64
%835 = getelementptr inbounds float, float* %831, i64 %834
%836 = load float, float* %835
%837 = load float*, float** %5
%838 = load i32, i32* %11
%839 = sub nsw i32 %838, 1
%840 = sext i32 %839 to i64
%841 = getelementptr inbounds float, float* %837, i64 %840
%842 = load float, float* %841
%843 = fadd float %836, %842
store float %843, float* %39
%844 = load float*, float** %5
%845 = load i32, i32* %9
%846 = sub nsw i32 %845, 2
%847 = sext i32 %846 to i64
%848 = getelementptr inbounds float, float* %844, i64 %847
%849 = load float, float* %848
%850 = load float*, float** %5
%851 = load i32, i32* %11
%852 = sub nsw i32 %851, 2
%853 = sext i32 %852 to i64
%854 = getelementptr inbounds float, float* %850, i64 %853
%855 = load float, float* %854
%856 = fsub float %849, %855
store float %856, float* %40
%857 = load float*, float** %5
%858 = load i32, i32* %9
%859 = sub nsw i32 %858, 1
%860 = sext i32 %859 to i64
%861 = getelementptr inbounds float, float* %857, i64 %860
%862 = load float, float* %861
%863 = load float*, float** %5
%864 = load i32, i32* %11
%865 = sub nsw i32 %864, 1
%866 = sext i32 %865 to i64
%867 = getelementptr inbounds float, float* %863, i64 %866
%868 = load float, float* %867
%869 = fsub float %862, %868
store float %869, float* %41
%870 = load float, float* %26
%871 = load float, float* %30
%872 = fadd float %870, %871
%873 = load float*, float** %5
%874 = load i32, i32* %8
%875 = sext i32 %874 to i64
%876 = getelementptr inbounds float, float* %873, i64 %875
store float %872, float* %876
%877 = load float, float* %27
%878 = load float, float* %31
%879 = fadd float %877, %878
%880 = load float*, float** %5
%881 = load i32, i32* %8
%882 = add nsw i32 %881, 1
%883 = sext i32 %882 to i64
%884 = getelementptr inbounds float, float* %880, i64 %883
store float %879, float* %884
%885 = load float, float* %34
%886 = load float, float* %38
%887 = fadd float %885, %886
%888 = load float*, float** %5
%889 = load i32, i32* %8
%890 = sub nsw i32 %889, 2
%891 = sext i32 %890 to i64
%892 = getelementptr inbounds float, float* %888, i64 %891
store float %887, float* %892
%893 = load float, float* %35
%894 = load float, float* %39
%895 = fadd float %893, %894
%896 = load float*, float** %5
%897 = load i32, i32* %8
%898 = sub nsw i32 %897, 1
%899 = sext i32 %898 to i64
%900 = getelementptr inbounds float, float* %896, i64 %899
store float %895, float* %900
%901 = load float, float* %26
%902 = load float, float* %30
%903 = fsub float %901, %902
%904 = load float*, float** %5
%905 = load i32, i32* %9
%906 = sext i32 %905 to i64
%907 = getelementptr inbounds float, float* %904, i64 %906
store float %903, float* %907
%908 = load float, float* %27
%909 = load float, float* %31
%910 = fsub float %908, %909
%911 = load float*, float** %5
%912 = load i32, i32* %9
%913 = add nsw i32 %912, 1
%914 = sext i32 %913 to i64
%915 = getelementptr inbounds float, float* %911, i64 %914
store float %910, float* %915
%916 = load float, float* %34
%917 = load float, float* %38
%918 = fsub float %916, %917
%919 = load float*, float** %5
%920 = load i32, i32* %9
%921 = sub nsw i32 %920, 2
%922 = sext i32 %921 to i64
%923 = getelementptr inbounds float, float* %919, i64 %922
store float %918, float* %923
%924 = load float, float* %35
%925 = load float, float* %39
%926 = fsub float %924, %925
%927 = load float*, float** %5
%928 = load i32, i32* %9
%929 = sub nsw i32 %928, 1
%930 = sext i32 %929 to i64
%931 = getelementptr inbounds float, float* %927, i64 %930
store float %926, float* %931
%932 = load float, float* %28
%933 = load float, float* %33
%934 = fsub float %932, %933
store float %934, float* %26
%935 = load float, float* %29
%936 = load float, float* %32
%937 = fadd float %935, %936
store float %937, float* %27
%938 = load float, float* %19
%939 = load float, float* %26
%940 = load float, float* %18
%941 = load float, float* %27
%942 = fmul float %940, %941
%943 = fneg float %942
%944 = call float @llvm.fmuladd.f32(float %938, float %939, float %943)
%945 = load float*, float** %5
%946 = load i32, i32* %10
%947 = sext i32 %946 to i64
%948 = getelementptr inbounds float, float* %945, i64 %947
store float %944, float* %948
%949 = load float, float* %19
%950 = load float, float* %27
%951 = load float, float* %18
%952 = load float, float* %26
%953 = fmul float %951, %952
%954 = call float @llvm.fmuladd.f32(float %949, float %950, float %953)
%955 = load float*, float** %5
%956 = load i32, i32* %10
%957 = add nsw i32 %956, 1
%958 = sext i32 %957 to i64
%959 = getelementptr inbounds float, float* %955, i64 %958
store float %954, float* %959
%960 = load float, float* %36
%961 = load float, float* %41
%962 = fsub float %960, %961
store float %962, float* %26
%963 = load float, float* %37
%964 = load float, float* %40
%965 = fadd float %963, %964
store float %965, float* %27
%966 = load float, float* %23
%967 = load float, float* %26
%968 = load float, float* %22
%969 = load float, float* %27
%970 = fmul float %968, %969
%971 = fneg float %970
%972 = call float @llvm.fmuladd.f32(float %966, float %967, float %971)
%973 = load float*, float** %5
%974 = load i32, i32* %10
%975 = sub nsw i32 %974, 2
%976 = sext i32 %975 to i64
%977 = getelementptr inbounds float, float* %973, i64 %976
store float %972, float* %977
%978 = load float, float* %23
%979 = load float, float* %27
%980 = load float, float* %22
%981 = load float, float* %26
%982 = fmul float %980, %981
%983 = call float @llvm.fmuladd.f32(float %978, float %979, float %982)
%984 = load float*, float** %5
%985 = load i32, i32* %10
%986 = sub nsw i32 %985, 1
%987 = sext i32 %986 to i64
%988 = getelementptr inbounds float, float* %984, i64 %987
store float %983, float* %988
%989 = load float, float* %28
%990 = load float, float* %33
%991 = fadd float %989, %990
store float %991, float* %26
%992 = load float, float* %29
%993 = load float, float* %32
%994 = fsub float %992, %993
store float %994, float* %27
%995 = load float, float* %21
%996 = load float, float* %26
%997 = load float, float* %20
%998 = load float, float* %27
%999 = fmul float %997, %998
%1000 = call float @llvm.fmuladd.f32(float %995, float %996, float %999)
%1001 = load float*, float** %5
%1002 = load i32, i32* %11
%1003 = sext i32 %1002 to i64
%1004 = getelementptr inbounds float, float* %1001, i64 %1003
store float %1000, float* %1004
%1005 = load float, float* %21
%1006 = load float, float* %27
%1007 = load float, float* %20
%1008 = load float, float* %26
%1009 = fmul float %1007, %1008
%1010 = fneg float %1009
%1011 = call float @llvm.fmuladd.f32(float %1005, float %1006, float %1010)
%1012 = load float*, float** %5
%1013 = load i32, i32* %11
%1014 = add nsw i32 %1013, 1
%1015 = sext i32 %1014 to i64
%1016 = getelementptr inbounds float, float* %1012, i64 %1015
store float %1011, float* %1016
%1017 = load float, float* %36
%1018 = load float, float* %41
%1019 = fadd float %1017, %1018
store float %1019, float* %26
%1020 = load float, float* %37
%1021 = load float, float* %40
%1022 = fsub float %1020, %1021
store float %1022, float* %27
%1023 = load float, float* %25
%1024 = load float, float* %26
%1025 = load float, float* %24
%1026 = load float, float* %27
%1027 = fmul float %1025, %1026
%1028 = call float @llvm.fmuladd.f32(float %1023, float %1024, float %1027)
%1029 = load float*, float** %5
%1030 = load i32, i32* %11
%1031 = sub nsw i32 %1030, 2
%1032 = sext i32 %1031 to i64
%1033 = getelementptr inbounds float, float* %1029, i64 %1032
store float %1028, float* %1033
%1034 = load float, float* %25
%1035 = load float, float* %27
%1036 = load float, float* %24
%1037 = load float, float* %26
%1038 = fmul float %1036, %1037
%1039 = fneg float %1038
%1040 = call float @llvm.fmuladd.f32(float %1034, float %1035, float %1039)
%1041 = load float*, float** %5
%1042 = load i32, i32* %11
%1043 = sub nsw i32 %1042, 1
%1044 = sext i32 %1043 to i64
%1045 = getelementptr inbounds float, float* %1041, i64 %1044
store float %1040, float* %1045
br label %1046
1046: ; preds = %208
%1047 = load i32, i32* %7
%1048 = add nsw i32 %1047, 4
store i32 %1048, i32* %7
br label %203
1049: ; preds = %203
%1050 = load float, float* %16
%1051 = load float, float* %22
%1052 = load float, float* %15
%1053 = fadd float %1051, %1052
%1054 = fmul float %1050, %1053
store float %1054, float* %18
%1055 = load float, float* %16
%1056 = load float, float* %23
%1057 = load float, float* %15
%1058 = fadd float %1056, %1057
%1059 = fmul float %1055, %1058
store float %1059, float* %19
%1060 = load float, float* %17
%1061 = load float, float* %24
%1062 = load float, float* %15
%1063 = fsub float %1061, %1062
%1064 = fmul float %1060, %1063
store float %1064, float* %20
%1065 = load float, float* %17
%1066 = load float, float* %25
%1067 = load float, float* %15
%1068 = fsub float %1066, %1067
%1069 = fmul float %1065, %1068
store float %1069, float* %21
%1070 = load i32, i32* %14
store i32 %1070, i32* %8
%1071 = load i32, i32* %8
%1072 = load i32, i32* %13
%1073 = add nsw i32 %1071, %1072
store i32 %1073, i32* %9
%1074 = load i32, i32* %9
%1075 = load i32, i32* %13
%1076 = add nsw i32 %1074, %1075
store i32 %1076, i32* %10
%1077 = load i32, i32* %10
%1078 = load i32, i32* %13
%1079 = add nsw i32 %1077, %1078
store i32 %1079, i32* %11
%1080 = load float*, float** %5
%1081 = load i32, i32* %8
%1082 = sub nsw i32 %1081, 2
%1083 = sext i32 %1082 to i64
%1084 = getelementptr inbounds float, float* %1080, i64 %1083
%1085 = load float, float* %1084
%1086 = load float*, float** %5
%1087 = load i32, i32* %10
%1088 = sub nsw i32 %1087, 2
%1089 = sext i32 %1088 to i64
%1090 = getelementptr inbounds float, float* %1086, i64 %1089
%1091 = load float, float* %1090
%1092 = fadd float %1085, %1091
store float %1092, float* %26
%1093 = load float*, float** %5
%1094 = load i32, i32* %8
%1095 = sub nsw i32 %1094, 1
%1096 = sext i32 %1095 to i64
%1097 = getelementptr inbounds float, float* %1093, i64 %1096
%1098 = load float, float* %1097
%1099 = load float*, float** %5
%1100 = load i32, i32* %10
%1101 = sub nsw i32 %1100, 1
%1102 = sext i32 %1101 to i64
%1103 = getelementptr inbounds float, float* %1099, i64 %1102
%1104 = load float, float* %1103
%1105 = fadd float %1098, %1104
store float %1105, float* %27
%1106 = load float*, float** %5
%1107 = load i32, i32* %8
%1108 = sub nsw i32 %1107, 2
%1109 = sext i32 %1108 to i64
%1110 = getelementptr inbounds float, float* %1106, i64 %1109
%1111 = load float, float* %1110
%1112 = load float*, float** %5
%1113 = load i32, i32* %10
%1114 = sub nsw i32 %1113, 2
%1115 = sext i32 %1114 to i64
%1116 = getelementptr inbounds float, float* %1112, i64 %1115
%1117 = load float, float* %1116
%1118 = fsub float %1111, %1117
store float %1118, float* %28
%1119 = load float*, float** %5
%1120 = load i32, i32* %8
%1121 = sub nsw i32 %1120, 1
%1122 = sext i32 %1121 to i64
%1123 = getelementptr inbounds float, float* %1119, i64 %1122
%1124 = load float, float* %1123
%1125 = load float*, float** %5
%1126 = load i32, i32* %10
%1127 = sub nsw i32 %1126, 1
%1128 = sext i32 %1127 to i64
%1129 = getelementptr inbounds float, float* %1125, i64 %1128
%1130 = load float, float* %1129
%1131 = fsub float %1124, %1130
store float %1131, float* %29
%1132 = load float*, float** %5
%1133 = load i32, i32* %9
%1134 = sub nsw i32 %1133, 2
%1135 = sext i32 %1134 to i64
%1136 = getelementptr inbounds float, float* %1132, i64 %1135
%1137 = load float, float* %1136
%1138 = load float*, float** %5
%1139 = load i32, i32* %11
%1140 = sub nsw i32 %1139, 2
%1141 = sext i32 %1140 to i64
%1142 = getelementptr inbounds float, float* %1138, i64 %1141
%1143 = load float, float* %1142
%1144 = fadd float %1137, %1143
store float %1144, float* %30
%1145 = load float*, float** %5
%1146 = load i32, i32* %9
%1147 = sub nsw i32 %1146, 1
%1148 = sext i32 %1147 to i64
%1149 = getelementptr inbounds float, float* %1145, i64 %1148
%1150 = load float, float* %1149
%1151 = load float*, float** %5
%1152 = load i32, i32* %11
%1153 = sub nsw i32 %1152, 1
%1154 = sext i32 %1153 to i64
%1155 = getelementptr inbounds float, float* %1151, i64 %1154
%1156 = load float, float* %1155
%1157 = fadd float %1150, %1156
store float %1157, float* %31
%1158 = load float*, float** %5
%1159 = load i32, i32* %9
%1160 = sub nsw i32 %1159, 2
%1161 = sext i32 %1160 to i64
%1162 = getelementptr inbounds float, float* %1158, i64 %1161
%1163 = load float, float* %1162
%1164 = load float*, float** %5
%1165 = load i32, i32* %11
%1166 = sub nsw i32 %1165, 2
%1167 = sext i32 %1166 to i64
%1168 = getelementptr inbounds float, float* %1164, i64 %1167
%1169 = load float, float* %1168
%1170 = fsub float %1163, %1169
store float %1170, float* %32
%1171 = load float*, float** %5
%1172 = load i32, i32* %9
%1173 = sub nsw i32 %1172, 1
%1174 = sext i32 %1173 to i64
%1175 = getelementptr inbounds float, float* %1171, i64 %1174
%1176 = load float, float* %1175
%1177 = load float*, float** %5
%1178 = load i32, i32* %11
%1179 = sub nsw i32 %1178, 1
%1180 = sext i32 %1179 to i64
%1181 = getelementptr inbounds float, float* %1177, i64 %1180
%1182 = load float, float* %1181
%1183 = fsub float %1176, %1182
store float %1183, float* %33
%1184 = load float, float* %26
%1185 = load float, float* %30
%1186 = fadd float %1184, %1185
%1187 = load float*, float** %5
%1188 = load i32, i32* %8
%1189 = sub nsw i32 %1188, 2
%1190 = sext i32 %1189 to i64
%1191 = getelementptr inbounds float, float* %1187, i64 %1190
store float %1186, float* %1191
%1192 = load float, float* %27
%1193 = load float, float* %31
%1194 = fadd float %1192, %1193
%1195 = load float*, float** %5
%1196 = load i32, i32* %8
%1197 = sub nsw i32 %1196, 1
%1198 = sext i32 %1197 to i64
%1199 = getelementptr inbounds float, float* %1195, i64 %1198
store float %1194, float* %1199
%1200 = load float, float* %26
%1201 = load float, float* %30
%1202 = fsub float %1200, %1201
%1203 = load float*, float** %5
%1204 = load i32, i32* %9
%1205 = sub nsw i32 %1204, 2
%1206 = sext i32 %1205 to i64
%1207 = getelementptr inbounds float, float* %1203, i64 %1206
store float %1202, float* %1207
%1208 = load float, float* %27
%1209 = load float, float* %31
%1210 = fsub float %1208, %1209
%1211 = load float*, float** %5
%1212 = load i32, i32* %9
%1213 = sub nsw i32 %1212, 1
%1214 = sext i32 %1213 to i64
%1215 = getelementptr inbounds float, float* %1211, i64 %1214
store float %1210, float* %1215
%1216 = load float, float* %28
%1217 = load float, float* %33
%1218 = fsub float %1216, %1217
store float %1218, float* %26
%1219 = load float, float* %29
%1220 = load float, float* %32
%1221 = fadd float %1219, %1220
store float %1221, float* %27
%1222 = load float, float* %18
%1223 = load float, float* %26
%1224 = load float, float* %19
%1225 = load float, float* %27
%1226 = fmul float %1224, %1225
%1227 = fneg float %1226
%1228 = call float @llvm.fmuladd.f32(float %1222, float %1223, float %1227)
%1229 = load float*, float** %5
%1230 = load i32, i32* %10
%1231 = sub nsw i32 %1230, 2
%1232 = sext i32 %1231 to i64
%1233 = getelementptr inbounds float, float* %1229, i64 %1232
store float %1228, float* %1233
%1234 = load float, float* %18
%1235 = load float, float* %27
%1236 = load float, float* %19
%1237 = load float, float* %26
%1238 = fmul float %1236, %1237
%1239 = call float @llvm.fmuladd.f32(float %1234, float %1235, float %1238)
%1240 = load float*, float** %5
%1241 = load i32, i32* %10
%1242 = sub nsw i32 %1241, 1
%1243 = sext i32 %1242 to i64
%1244 = getelementptr inbounds float, float* %1240, i64 %1243
store float %1239, float* %1244
%1245 = load float, float* %28
%1246 = load float, float* %33
%1247 = fadd float %1245, %1246
store float %1247, float* %26
%1248 = load float, float* %29
%1249 = load float, float* %32
%1250 = fsub float %1248, %1249
store float %1250, float* %27
%1251 = load float, float* %20
%1252 = load float, float* %26
%1253 = load float, float* %21
%1254 = load float, float* %27
%1255 = fmul float %1253, %1254
%1256 = call float @llvm.fmuladd.f32(float %1251, float %1252, float %1255)
%1257 = load float*, float** %5
%1258 = load i32, i32* %11
%1259 = sub nsw i32 %1258, 2
%1260 = sext i32 %1259 to i64
%1261 = getelementptr inbounds float, float* %1257, i64 %1260
store float %1256, float* %1261
%1262 = load float, float* %20
%1263 = load float, float* %27
%1264 = load float, float* %21
%1265 = load float, float* %26
%1266 = fmul float %1264, %1265
%1267 = fneg float %1266
%1268 = call float @llvm.fmuladd.f32(float %1262, float %1263, float %1267)
%1269 = load float*, float** %5
%1270 = load i32, i32* %11
%1271 = sub nsw i32 %1270, 1
%1272 = sext i32 %1271 to i64
%1273 = getelementptr inbounds float, float* %1269, i64 %1272
store float %1268, float* %1273
%1274 = load float*, float** %5
%1275 = load i32, i32* %8
%1276 = sext i32 %1275 to i64
%1277 = getelementptr inbounds float, float* %1274, i64 %1276
%1278 = load float, float* %1277
%1279 = load float*, float** %5
%1280 = load i32, i32* %10
%1281 = sext i32 %1280 to i64
%1282 = getelementptr inbounds float, float* %1279, i64 %1281
%1283 = load float, float* %1282
%1284 = fadd float %1278, %1283
store float %1284, float* %26
%1285 = load float*, float** %5
%1286 = load i32, i32* %8
%1287 = add nsw i32 %1286, 1
%1288 = sext i32 %1287 to i64
%1289 = getelementptr inbounds float, float* %1285, i64 %1288
%1290 = load float, float* %1289
%1291 = load float*, float** %5
%1292 = load i32, i32* %10
%1293 = add nsw i32 %1292, 1
%1294 = sext i32 %1293 to i64
%1295 = getelementptr inbounds float, float* %1291, i64 %1294
%1296 = load float, float* %1295
%1297 = fadd float %1290, %1296
store float %1297, float* %27
%1298 = load float*, float** %5
%1299 = load i32, i32* %8
%1300 = sext i32 %1299 to i64
%1301 = getelementptr inbounds float, float* %1298, i64 %1300
%1302 = load float, float* %1301
%1303 = load float*, float** %5
%1304 = load i32, i32* %10
%1305 = sext i32 %1304 to i64
%1306 = getelementptr inbounds float, float* %1303, i64 %1305
%1307 = load float, float* %1306
%1308 = fsub float %1302, %1307
store float %1308, float* %28
%1309 = load float*, float** %5
%1310 = load i32, i32* %8
%1311 = add nsw i32 %1310, 1
%1312 = sext i32 %1311 to i64
%1313 = getelementptr inbounds float, float* %1309, i64 %1312
%1314 = load float, float* %1313
%1315 = load float*, float** %5
%1316 = load i32, i32* %10
%1317 = add nsw i32 %1316, 1
%1318 = sext i32 %1317 to i64
%1319 = getelementptr inbounds float, float* %1315, i64 %1318
%1320 = load float, float* %1319
%1321 = fsub float %1314, %1320
store float %1321, float* %29
%1322 = load float*, float** %5
%1323 = load i32, i32* %9
%1324 = sext i32 %1323 to i64
%1325 = getelementptr inbounds float, float* %1322, i64 %1324
%1326 = load float, float* %1325
%1327 = load float*, float** %5
%1328 = load i32, i32* %11
%1329 = sext i32 %1328 to i64
%1330 = getelementptr inbounds float, float* %1327, i64 %1329
%1331 = load float, float* %1330
%1332 = fadd float %1326, %1331
store float %1332, float* %30
%1333 = load float*, float** %5
%1334 = load i32, i32* %9
%1335 = add nsw i32 %1334, 1
%1336 = sext i32 %1335 to i64
%1337 = getelementptr inbounds float, float* %1333, i64 %1336
%1338 = load float, float* %1337
%1339 = load float*, float** %5
%1340 = load i32, i32* %11
%1341 = add nsw i32 %1340, 1
%1342 = sext i32 %1341 to i64
%1343 = getelementptr inbounds float, float* %1339, i64 %1342
%1344 = load float, float* %1343
%1345 = fadd float %1338, %1344
store float %1345, float* %31
%1346 = load float*, float** %5
%1347 = load i32, i32* %9
%1348 = sext i32 %1347 to i64
%1349 = getelementptr inbounds float, float* %1346, i64 %1348
%1350 = load float, float* %1349
%1351 = load float*, float** %5
%1352 = load i32, i32* %11
%1353 = sext i32 %1352 to i64
%1354 = getelementptr inbounds float, float* %1351, i64 %1353
%1355 = load float, float* %1354
%1356 = fsub float %1350, %1355
store float %1356, float* %32
%1357 = load float*, float** %5
%1358 = load i32, i32* %9
%1359 = add nsw i32 %1358, 1
%1360 = sext i32 %1359 to i64
%1361 = getelementptr inbounds float, float* %1357, i64 %1360
%1362 = load float, float* %1361
%1363 = load float*, float** %5
%1364 = load i32, i32* %11
%1365 = add nsw i32 %1364, 1
%1366 = sext i32 %1365 to i64
%1367 = getelementptr inbounds float, float* %1363, i64 %1366
%1368 = load float, float* %1367
%1369 = fsub float %1362, %1368
store float %1369, float* %33
%1370 = load float, float* %26
%1371 = load float, float* %30
%1372 = fadd float %1370, %1371
%1373 = load float*, float** %5
%1374 = load i32, i32* %8
%1375 = sext i32 %1374 to i64
%1376 = getelementptr inbounds float, float* %1373, i64 %1375
store float %1372, float* %1376
%1377 = load float, float* %27
%1378 = load float, float* %31
%1379 = fadd float %1377, %1378
%1380 = load float*, float** %5
%1381 = load i32, i32* %8
%1382 = add nsw i32 %1381, 1
%1383 = sext i32 %1382 to i64
%1384 = getelementptr inbounds float, float* %1380, i64 %1383
store float %1379, float* %1384
%1385 = load float, float* %26
%1386 = load float, float* %30
%1387 = fsub float %1385, %1386
%1388 = load float*, float** %5
%1389 = load i32, i32* %9
%1390 = sext i32 %1389 to i64
%1391 = getelementptr inbounds float, float* %1388, i64 %1390
store float %1387, float* %1391
%1392 = load float, float* %27
%1393 = load float, float* %31
%1394 = fsub float %1392, %1393
%1395 = load float*, float** %5
%1396 = load i32, i32* %9
%1397 = add nsw i32 %1396, 1
%1398 = sext i32 %1397 to i64
%1399 = getelementptr inbounds float, float* %1395, i64 %1398
store float %1394, float* %1399
%1400 = load float, float* %28
%1401 = load float, float* %33
%1402 = fsub float %1400, %1401
store float %1402, float* %26
%1403 = load float, float* %29
%1404 = load float, float* %32
%1405 = fadd float %1403, %1404
store float %1405, float* %27
%1406 = load float, float* %15
%1407 = load float, float* %26
%1408 = load float, float* %27
%1409 = fsub float %1407, %1408
%1410 = fmul float %1406, %1409
%1411 = load float*, float** %5
%1412 = load i32, i32* %10
%1413 = sext i32 %1412 to i64
%1414 = getelementptr inbounds float, float* %1411, i64 %1413
store float %1410, float* %1414
%1415 = load float, float* %15
%1416 = load float, float* %27
%1417 = load float, float* %26
%1418 = fadd float %1416, %1417
%1419 = fmul float %1415, %1418
%1420 = load float*, float** %5
%1421 = load i32, i32* %10
%1422 = add nsw i32 %1421, 1
%1423 = sext i32 %1422 to i64
%1424 = getelementptr inbounds float, float* %1420, i64 %1423
store float %1419, float* %1424
%1425 = load float, float* %28
%1426 = load float, float* %33
%1427 = fadd float %1425, %1426
store float %1427, float* %26
%1428 = load float, float* %29
%1429 = load float, float* %32
%1430 = fsub float %1428, %1429
store float %1430, float* %27
%1431 = load float, float* %15
%1432 = fneg float %1431
%1433 = load float, float* %26
%1434 = load float, float* %27
%1435 = fadd float %1433, %1434
%1436 = fmul float %1432, %1435
%1437 = load float*, float** %5
%1438 = load i32, i32* %11
%1439 = sext i32 %1438 to i64
%1440 = getelementptr inbounds float, float* %1437, i64 %1439
store float %1436, float* %1440
%1441 = load float, float* %15
%1442 = fneg float %1441
%1443 = load float, float* %27
%1444 = load float, float* %26
%1445 = fsub float %1443, %1444
%1446 = fmul float %1442, %1445
%1447 = load float*, float** %5
%1448 = load i32, i32* %11
%1449 = add nsw i32 %1448, 1
%1450 = sext i32 %1449 to i64
%1451 = getelementptr inbounds float, float* %1447, i64 %1450
store float %1446, float* %1451
%1452 = load float*, float** %5
%1453 = load i32, i32* %8
%1454 = add nsw i32 %1453, 2
%1455 = sext i32 %1454 to i64
%1456 = getelementptr inbounds float, float* %1452, i64 %1455
%1457 = load float, float* %1456
%1458 = load float*, float** %5
%1459 = load i32, i32* %10
%1460 = add nsw i32 %1459, 2
%1461 = sext i32 %1460 to i64
%1462 = getelementptr inbounds float, float* %1458, i64 %1461
%1463 = load float, float* %1462
%1464 = fadd float %1457, %1463
store float %1464, float* %26
%1465 = load float*, float** %5
%1466 = load i32, i32* %8
%1467 = add nsw i32 %1466, 3
%1468 = sext i32 %1467 to i64
%1469 = getelementptr inbounds float, float* %1465, i64 %1468
%1470 = load float, float* %1469
%1471 = load float*, float** %5
%1472 = load i32, i32* %10
%1473 = add nsw i32 %1472, 3
%1474 = sext i32 %1473 to i64
%1475 = getelementptr inbounds float, float* %1471, i64 %1474
%1476 = load float, float* %1475
%1477 = fadd float %1470, %1476
store float %1477, float* %27
%1478 = load float*, float** %5
%1479 = load i32, i32* %8
%1480 = add nsw i32 %1479, 2
%1481 = sext i32 %1480 to i64
%1482 = getelementptr inbounds float, float* %1478, i64 %1481
%1483 = load float, float* %1482
%1484 = load float*, float** %5
%1485 = load i32, i32* %10
%1486 = add nsw i32 %1485, 2
%1487 = sext i32 %1486 to i64
%1488 = getelementptr inbounds float, float* %1484, i64 %1487
%1489 = load float, float* %1488
%1490 = fsub float %1483, %1489
store float %1490, float* %28
%1491 = load float*, float** %5
%1492 = load i32, i32* %8
%1493 = add nsw i32 %1492, 3
%1494 = sext i32 %1493 to i64
%1495 = getelementptr inbounds float, float* %1491, i64 %1494
%1496 = load float, float* %1495
%1497 = load float*, float** %5
%1498 = load i32, i32* %10
%1499 = add nsw i32 %1498, 3
%1500 = sext i32 %1499 to i64
%1501 = getelementptr inbounds float, float* %1497, i64 %1500
%1502 = load float, float* %1501
%1503 = fsub float %1496, %1502
store float %1503, float* %29
%1504 = load float*, float** %5
%1505 = load i32, i32* %9
%1506 = add nsw i32 %1505, 2
%1507 = sext i32 %1506 to i64
%1508 = getelementptr inbounds float, float* %1504, i64 %1507
%1509 = load float, float* %1508
%1510 = load float*, float** %5
%1511 = load i32, i32* %11
%1512 = add nsw i32 %1511, 2
%1513 = sext i32 %1512 to i64
%1514 = getelementptr inbounds float, float* %1510, i64 %1513
%1515 = load float, float* %1514
%1516 = fadd float %1509, %1515
store float %1516, float* %30
%1517 = load float*, float** %5
%1518 = load i32, i32* %9
%1519 = add nsw i32 %1518, 3
%1520 = sext i32 %1519 to i64
%1521 = getelementptr inbounds float, float* %1517, i64 %1520
%1522 = load float, float* %1521
%1523 = load float*, float** %5
%1524 = load i32, i32* %11
%1525 = add nsw i32 %1524, 3
%1526 = sext i32 %1525 to i64
%1527 = getelementptr inbounds float, float* %1523, i64 %1526
%1528 = load float, float* %1527
%1529 = fadd float %1522, %1528
store float %1529, float* %31
%1530 = load float*, float** %5
%1531 = load i32, i32* %9
%1532 = add nsw i32 %1531, 2
%1533 = sext i32 %1532 to i64
%1534 = getelementptr inbounds float, float* %1530, i64 %1533
%1535 = load float, float* %1534
%1536 = load float*, float** %5
%1537 = load i32, i32* %11
%1538 = add nsw i32 %1537, 2
%1539 = sext i32 %1538 to i64
%1540 = getelementptr inbounds float, float* %1536, i64 %1539
%1541 = load float, float* %1540
%1542 = fsub float %1535, %1541
store float %1542, float* %32
%1543 = load float*, float** %5
%1544 = load i32, i32* %9
%1545 = add nsw i32 %1544, 3
%1546 = sext i32 %1545 to i64
%1547 = getelementptr inbounds float, float* %1543, i64 %1546
%1548 = load float, float* %1547
%1549 = load float*, float** %5
%1550 = load i32, i32* %11
%1551 = add nsw i32 %1550, 3
%1552 = sext i32 %1551 to i64
%1553 = getelementptr inbounds float, float* %1549, i64 %1552
%1554 = load float, float* %1553
%1555 = fsub float %1548, %1554
store float %1555, float* %33
%1556 = load float, float* %26
%1557 = load float, float* %30
%1558 = fadd float %1556, %1557
%1559 = load float*, float** %5
%1560 = load i32, i32* %8
%1561 = add nsw i32 %1560, 2
%1562 = sext i32 %1561 to i64
%1563 = getelementptr inbounds float, float* %1559, i64 %1562
store float %1558, float* %1563
%1564 = load float, float* %27
%1565 = load float, float* %31
%1566 = fadd float %1564, %1565
%1567 = load float*, float** %5
%1568 = load i32, i32* %8
%1569 = add nsw i32 %1568, 3
%1570 = sext i32 %1569 to i64
%1571 = getelementptr inbounds float, float* %1567, i64 %1570
store float %1566, float* %1571
%1572 = load float, float* %26
%1573 = load float, float* %30
%1574 = fsub float %1572, %1573
%1575 = load float*, float** %5
%1576 = load i32, i32* %9
%1577 = add nsw i32 %1576, 2
%1578 = sext i32 %1577 to i64
%1579 = getelementptr inbounds float, float* %1575, i64 %1578
store float %1574, float* %1579
%1580 = load float, float* %27
%1581 = load float, float* %31
%1582 = fsub float %1580, %1581
%1583 = load float*, float** %5
%1584 = load i32, i32* %9
%1585 = add nsw i32 %1584, 3
%1586 = sext i32 %1585 to i64
%1587 = getelementptr inbounds float, float* %1583, i64 %1586
store float %1582, float* %1587
%1588 = load float, float* %28
%1589 = load float, float* %33
%1590 = fsub float %1588, %1589
store float %1590, float* %26
%1591 = load float, float* %29
%1592 = load float, float* %32
%1593 = fadd float %1591, %1592
store float %1593, float* %27
%1594 = load float, float* %19
%1595 = load float, float* %26
%1596 = load float, float* %18
%1597 = load float, float* %27
%1598 = fmul float %1596, %1597
%1599 = fneg float %1598
%1600 = call float @llvm.fmuladd.f32(float %1594, float %1595, float %1599)
%1601 = load float*, float** %5
%1602 = load i32, i32* %10
%1603 = add nsw i32 %1602, 2
%1604 = sext i32 %1603 to i64
%1605 = getelementptr inbounds float, float* %1601, i64 %1604
store float %1600, float* %1605
%1606 = load float, float* %19
%1607 = load float, float* %27
%1608 = load float, float* %18
%1609 = load float, float* %26
%1610 = fmul float %1608, %1609
%1611 = call float @llvm.fmuladd.f32(float %1606, float %1607, float %1610)
%1612 = load float*, float** %5
%1613 = load i32, i32* %10
%1614 = add nsw i32 %1613, 3
%1615 = sext i32 %1614 to i64
%1616 = getelementptr inbounds float, float* %1612, i64 %1615
store float %1611, float* %1616
%1617 = load float, float* %28
%1618 = load float, float* %33
%1619 = fadd float %1617, %1618
store float %1619, float* %26
%1620 = load float, float* %29
%1621 = load float, float* %32
%1622 = fsub float %1620, %1621
store float %1622, float* %27
%1623 = load float, float* %21
%1624 = load float, float* %26
%1625 = load float, float* %20
%1626 = load float, float* %27
%1627 = fmul float %1625, %1626
%1628 = call float @llvm.fmuladd.f32(float %1623, float %1624, float %1627)
%1629 = load float*, float** %5
%1630 = load i32, i32* %11
%1631 = add nsw i32 %1630, 2
%1632 = sext i32 %1631 to i64
%1633 = getelementptr inbounds float, float* %1629, i64 %1632
store float %1628, float* %1633
%1634 = load float, float* %21
%1635 = load float, float* %27
%1636 = load float, float* %20
%1637 = load float, float* %26
%1638 = fmul float %1636, %1637
%1639 = fneg float %1638
%1640 = call float @llvm.fmuladd.f32(float %1634, float %1635, float %1639)
%1641 = load float*, float** %5
%1642 = load i32, i32* %11
%1643 = add nsw i32 %1642, 3
%1644 = sext i32 %1643 to i64
%1645 = getelementptr inbounds float, float* %1641, i64 %1644
store float %1640, float* %1645
ret void
}

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