void cftb1st(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):
<cftb1st>:
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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%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
subss  -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
addss  -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
addss  -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
subss  -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  0x1cac(%rip),%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  0x1c97(%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    207b <cftb1st+0xf7b>
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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subss  (%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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%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
subss  -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
subss  -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
addss  -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
addss  -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
addss  -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
addss  -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
subss  -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
subss  -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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%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
subss  -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
subss  -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
addss  -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
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
addss  -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
addss  -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
addss  -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
subss  -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
subss  -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    1384 <cftb1st+0x284>
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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%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
subss  -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
addss  -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
addss  -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
subss  -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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%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
subss  -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
addss  -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
addss  -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
subss  -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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subss  (%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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%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
subss  -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
addss  -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
addss  -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
subss  -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):
<cftb1st>:
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,%r10
movss  (%rsi,%r10,4),%xmm4
movss  (%rsi),%xmm0
movss  0x4(%rsi),%xmm5
movaps %xmm0,%xmm3
addss  %xmm4,%xmm3
movaps 0xec3(%rip),%xmm2
xorps  %xmm5,%xmm2
lea    0x1(,%rbx,4),%eax
movslq %eax,%r8
movss  (%rsi,%r8,4),%xmm1
subss  %xmm1,%xmm2
subss  %xmm4,%xmm0
subss  %xmm5,%xmm1
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm9
movslq %ebp,%rax
movss  (%rsi,%rax,4),%xmm8
movaps %xmm9,%xmm6
addss  %xmm8,%xmm6
lea    0x1(%rbx,%rbx,1),%ebp
movslq %ebp,%r9
movss  (%rsi,%r9,4),%xmm4
mov    %eax,%ebp
or     $0x1,%ebp
movslq %ebp,%rbp
movss  (%rsi,%rbp,4),%xmm5
movaps %xmm4,%xmm7
addss  %xmm5,%xmm7
subss  %xmm8,%xmm9
subss  %xmm5,%xmm4
movaps %xmm3,%xmm5
addss  %xmm6,%xmm5
movss  %xmm5,(%rsi)
movaps %xmm2,%xmm5
subss  %xmm7,%xmm5
movss  %xmm5,0x4(%rsi)
subss  %xmm6,%xmm3
movss  %xmm3,(%rsi,%rcx,4)
addss  %xmm2,%xmm7
movss  %xmm7,(%rsi,%r9,4)
movaps %xmm0,%xmm2
addss  %xmm4,%xmm2
movss  %xmm2,(%rsi,%r10,4)
movaps %xmm1,%xmm2
addss  %xmm9,%xmm2
movss  %xmm2,(%rsi,%r8,4)
subss  %xmm4,%xmm0
movss  %xmm0,(%rsi,%rax,4)
subss  %xmm9,%xmm1
movss  %xmm1,(%rsi,%rbp,4)
movss  0x4(%rdx),%xmm0
movaps %xmm0,-0x10(%rsp)
movss  0x8(%rdx),%xmm2
mov    %rdx,-0x18(%rsp)
movss  0xc(%rdx),%xmm1
mov    %rbx,-0x20(%rsp)
lea    -0x2(%rbx),%eax
cltq
mov    %rax,-0x38(%rsp)
cmp    $0x28,%edi
movss  %xmm1,-0x58(%rsp)
movss  %xmm2,-0x5c(%rsp)
jl     18fa <cftb1st+0x7fa>
lea    (%rcx,%rcx,2),%eax
movslq %eax,%rbp
lea    0x3(%rbp),%rax
mov    %rax,-0x30(%rsp)
lea    0x3(%r10),%rax
mov    %rax,-0x48(%rsp)
add    $0xffffffffffffffff,%r10
mov    %r10,-0x28(%rsp)
add    $0xffffffffffffffff,%rbp
lea    -0x1(%rcx),%rbx
lea    -0x8(,%rcx,8),%r14
ff
lea    0x0(,%rcx,4),%rdi
lea    (%rdi,%rdi,2),%r10
add    $0xfffffffffffffff8,%r10
mov    %rcx,%rax
shl    $0x22,%rax
movabs $0xfffffffe00000000,%r11
ff ff ff
add    %rax,%r11
mov    %rcx,%r15
shl    $0x4,%r15
add    $0xfffffffffffffff8,%r15
lea    0x14(,%rcx,8),%r13
add    $0x5,%rcx
lea    (%rdi,%rdi,2),%r8
add    $0x14,%r8
movss  0xd5e(%rip),%xmm4
xorps  %xmm3,%xmm3
mov    $0x3,%r9d
xorps  %xmm5,%xmm5
movaps %xmm4,%xmm6
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  %xmm6,-0x68(%rsp)
movss  %xmm5,-0x60(%rsp)
movss  %xmm4,-0x64(%rsp)
movss  %xmm3,-0x6c(%rsp)
movss  -0x4(%rsi,%r9,4),%xmm2
movss  (%rsi,%r9,4),%xmm0
movss  -0xc(%rsi,%r13,1),%xmm3
movss  -0x4(%rsi,%r13,1),%xmm8
movaps %xmm2,%xmm7
addss  %xmm3,%xmm7
movaps %xmm0,%xmm12
movaps 0xcea(%rip),%xmm15
xorps  %xmm15,%xmm12
mov    -0x48(%rsp),%rax
movss  (%rsi,%rax,4),%xmm5
mov    %rax,%rdx
mov    %rax,-0x48(%rsp)
subss  %xmm5,%xmm12
subss  %xmm3,%xmm2
subss  %xmm0,%xmm5
movss  0x4(%rsi,%r9,4),%xmm14
movaps %xmm14,%xmm0
addss  %xmm8,%xmm0
movss  0x8(%rsi,%r9,4),%xmm3
movaps %xmm3,%xmm4
xorps  %xmm15,%xmm4
movss  (%rsi,%r13,1),%xmm6
subss  %xmm6,%xmm4
subss  %xmm8,%xmm14
subss  %xmm3,%xmm6
movss  -0xc(%rsi,%rcx,4),%xmm1
movss  -0x8(%rsi,%rcx,4),%xmm9
movss  -0xc(%rsi,%r8,1),%xmm8
movaps %xmm1,%xmm3
addss  %xmm8,%xmm3
subss  %xmm8,%xmm1
movss  %xmm1,-0x74(%rsp)
mov    -0x30(%rsp),%rax
movss  (%rsi,%rax,4),%xmm8
movaps %xmm9,%xmm10
addss  %xmm8,%xmm10
subss  %xmm8,%xmm9
movss  %xmm9,-0x40(%rsp)
movss  -0x4(%rsi,%r8,1),%xmm11
movss  -0x4(%rsi,%rcx,4),%xmm1
movaps %xmm1,%xmm8
addss  %xmm11,%xmm8
subss  %xmm11,%xmm1
movss  %xmm1,-0x70(%rsp)
movss  (%rsi,%rcx,4),%xmm9
movss  (%rsi,%r8,1),%xmm13
movaps %xmm9,%xmm11
addss  %xmm13,%xmm11
subss  %xmm13,%xmm9
movaps %xmm7,%xmm13
addss  %xmm3,%xmm13
mov    -0x18(%rsp),%rdi
movss  0x4(%rdi,%r9,4),%xmm15
movss  0x8(%rdi,%r9,4),%xmm1
movss  %xmm1,-0x4c(%rsp)
movss  0xc(%rdi,%r9,4),%xmm1
movss  %xmm1,-0x54(%rsp)
movss  0x10(%rdi,%r9,4),%xmm1
movss  %xmm1,-0x50(%rsp)
movss  %xmm13,-0x4(%rsi,%r9,4)
movaps %xmm12,%xmm1
subss  %xmm10,%xmm1
movss  %xmm1,(%rsi,%r9,4)
movaps %xmm0,%xmm1
addss  %xmm8,%xmm1
movss  %xmm1,0x4(%rsi,%r9,4)
movaps %xmm4,%xmm1
subss  %xmm11,%xmm1
movss  %xmm1,0x8(%rsi,%r9,4)
subss  %xmm3,%xmm7
movss  %xmm7,-0xc(%rsi,%rcx,4)
addss  %xmm12,%xmm10
movss  %xmm10,-0x8(%rsi,%rcx,4)
subss  %xmm8,%xmm0
movss  %xmm0,-0x4(%rsi,%rcx,4)
addss  %xmm4,%xmm11
movss  %xmm11,(%rsi,%rcx,4)
movss  -0x68(%rsp),%xmm4
addss  %xmm15,%xmm4
movss  -0x5c(%rsp),%xmm0
mulss  %xmm0,%xmm4
movss  %xmm4,-0x68(%rsp)
movss  -0x60(%rsp),%xmm3
movss  -0x4c(%rsp),%xmm7
addss  %xmm7,%xmm3
mulss  %xmm0,%xmm3
movss  %xmm3,-0x60(%rsp)
movaps %xmm2,%xmm0
movss  -0x40(%rsp),%xmm12
addss  %xmm12,%xmm0
movaps %xmm5,%xmm1
movss  -0x74(%rsp),%xmm11
addss  %xmm11,%xmm1
movaps %xmm4,%xmm8
mulss  %xmm1,%xmm8
mulss  %xmm3,%xmm1
mulss  %xmm0,%xmm4
subss  %xmm1,%xmm4
movss  %xmm4,-0xc(%rsi,%r13,1)
mulss  %xmm3,%xmm0
addss  %xmm8,%xmm0
movss  %xmm0,(%rsi,%rdx,4)
movaps %xmm14,%xmm0
addss  %xmm9,%xmm0
movaps %xmm6,%xmm1
movss  -0x70(%rsp),%xmm10
addss  %xmm10,%xmm1
movss  %xmm15,-0x3c(%rsp)
movaps %xmm15,%xmm8
mulss  %xmm1,%xmm8
mulss  %xmm7,%xmm1
mulss  %xmm0,%xmm15
subss  %xmm1,%xmm15
movss  %xmm15,-0x4(%rsi,%r13,1)
mulss  %xmm7,%xmm0
addss  %xmm8,%xmm0
movss  %xmm0,(%rsi,%r13,1)
movss  -0x64(%rsp),%xmm15
movss  -0x54(%rsp),%xmm4
addss  %xmm4,%xmm15
movss  -0x58(%rsp),%xmm0
mulss  %xmm0,%xmm15
movss  -0x6c(%rsp),%xmm1
movss  -0x50(%rsp),%xmm7
addss  %xmm7,%xmm1
mulss  %xmm0,%xmm1
subss  %xmm12,%xmm2
subss  %xmm11,%xmm5
movaps %xmm1,%xmm0
movaps %xmm1,%xmm3
movss  %xmm1,-0x6c(%rsp)
mulss  %xmm5,%xmm0
movaps %xmm15,%xmm1
movss  %xmm15,-0x64(%rsp)
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,-0xc(%rsi,%r8,1)
mulss  %xmm3,%xmm2
mulss  %xmm15,%xmm5
subss  %xmm2,%xmm5
movss  %xmm5,(%rsi,%rax,4)
subss  %xmm9,%xmm14
subss  %xmm10,%xmm6
movaps %xmm7,%xmm2
movaps %xmm7,%xmm0
mulss  %xmm6,%xmm0
movaps %xmm4,%xmm3
movaps %xmm4,%xmm1
mulss  %xmm14,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,-0x4(%rsi,%r8,1)
mulss  %xmm7,%xmm14
mulss  %xmm4,%xmm6
subss  %xmm14,%xmm6
movss  %xmm6,(%rsi,%r8,1)
movss  -0x4(%rsi,%rbx,4),%xmm9
movss  (%rsi,%r10,1),%xmm0
movaps %xmm9,%xmm13
addss  %xmm0,%xmm13
movss  (%rsi,%rbx,4),%xmm1
movaps %xmm1,%xmm10
movaps 0x9d4(%rip),%xmm4
xorps  %xmm4,%xmm10
movss  (%rsi,%rbp,4),%xmm6
subss  %xmm6,%xmm10
subss  %xmm0,%xmm9
subss  %xmm1,%xmm6
movss  -0xc(%rsi,%rbx,4),%xmm14
movss  -0x8(%rsi,%rbx,4),%xmm1
movss  -0x8(%rsi,%r10,1),%xmm2
movaps %xmm14,%xmm0
addss  %xmm2,%xmm0
subss  %xmm2,%xmm14
movaps %xmm1,%xmm3
xorps  %xmm4,%xmm3
movss  -0x4(%rsi,%r10,1),%xmm5
subss  %xmm5,%xmm3
subss  %xmm1,%xmm5
movss  (%rsi,%r14,1),%xmm2
movss  (%rsi,%r15,1),%xmm1
movaps %xmm2,%xmm8
addss  %xmm1,%xmm8
subss  %xmm1,%xmm2
movss  %xmm2,-0x74(%rsp)
mov    %r11,%rdx
mov    %r11,%r12
sar    $0x1e,%r12
or     $0x4,%r12
mov    -0x28(%rsp),%r11
movss  (%rsi,%r11,4),%xmm12
movss  (%rsi,%r12,1),%xmm1
movaps %xmm12,%xmm2
addss  %xmm1,%xmm2
subss  %xmm1,%xmm12
movss  -0x8(%rsi,%r14,1),%xmm4
movss  -0x8(%rsi,%r15,1),%xmm1
movaps %xmm4,%xmm7
addss  %xmm1,%xmm7
subss  %xmm1,%xmm4
movss  %xmm4,-0x70(%rsp)
movss  -0x4(%rsi,%r14,1),%xmm11
movss  -0x4(%rsi,%r15,1),%xmm15
movaps %xmm11,%xmm1
addss  %xmm15,%xmm1
subss  %xmm15,%xmm11
movss  -0x3c(%rsp),%xmm15
movaps %xmm13,%xmm4
addss  %xmm8,%xmm4
movss  %xmm4,-0x4(%rsi,%rbx,4)
movaps %xmm10,%xmm4
subss  %xmm2,%xmm4
movss  %xmm4,(%rsi,%rbx,4)
movaps %xmm0,%xmm4
addss  %xmm7,%xmm4
movss  %xmm4,-0xc(%rsi,%rbx,4)
movaps %xmm3,%xmm4
subss  %xmm1,%xmm4
movss  %xmm4,-0x8(%rsi,%rbx,4)
subss  %xmm8,%xmm13
movss  %xmm13,(%rsi,%r14,1)
movss  -0x54(%rsp),%xmm13
addss  %xmm10,%xmm2
movss  %xmm2,(%rsi,%r11,4)
subss  %xmm7,%xmm0
movss  %xmm0,-0x8(%rsi,%r14,1)
addss  %xmm3,%xmm1
movss  %xmm1,-0x4(%rsi,%r14,1)
movaps %xmm9,%xmm0
addss  %xmm12,%xmm0
movaps %xmm6,%xmm1
movss  -0x74(%rsp),%xmm10
addss  %xmm10,%xmm1
movaps %xmm1,%xmm2
movss  -0x68(%rsp),%xmm4
mulss  %xmm4,%xmm2
movss  -0x60(%rsp),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm0,%xmm3
subss  %xmm2,%xmm3
movss  %xmm3,(%rsi,%r10,1)
mulss  %xmm4,%xmm0
addss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rbp,4)
movaps %xmm14,%xmm0
addss  %xmm11,%xmm0
movaps %xmm5,%xmm1
movss  -0x70(%rsp),%xmm7
addss  %xmm7,%xmm1
movss  -0x4c(%rsp),%xmm4
movaps %xmm4,%xmm2
mulss  %xmm1,%xmm2
mulss  %xmm15,%xmm1
movaps %xmm4,%xmm3
mulss  %xmm0,%xmm3
subss  %xmm1,%xmm3
movss  %xmm3,-0x8(%rsi,%r10,1)
mulss  %xmm15,%xmm0
addss  %xmm2,%xmm0
movss  %xmm0,-0x4(%rsi,%r10,1)
subss  %xmm12,%xmm9
movss  -0x50(%rsp),%xmm8
subss  %xmm10,%xmm6
movss  -0x6c(%rsp),%xmm2
movaps %xmm2,%xmm0
mulss  %xmm9,%xmm0
movss  -0x64(%rsp),%xmm1
mulss  %xmm1,%xmm9
mulss  %xmm6,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,(%rsi,%r15,1)
mulss  %xmm2,%xmm6
subss  %xmm9,%xmm6
movss  %xmm6,(%rsi,%r12,1)
mov    -0x38(%rsp),%rdi
subss  %xmm11,%xmm14
subss  %xmm7,%xmm5
movaps %xmm13,%xmm0
mulss  %xmm5,%xmm0
movaps %xmm8,%xmm1
mulss  %xmm14,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,-0x8(%rsi,%r15,1)
mulss  %xmm13,%xmm14
mulss  %xmm8,%xmm5
subss  %xmm14,%xmm5
movaps %xmm4,%xmm0
movss  %xmm5,-0x4(%rsi,%r15,1)
lea    0x4(%r9),%r12
add    $0x4,%rax
mov    %rax,-0x30(%rsp)
addq   $0x4,-0x48(%rsp)
add    $0xfffffffffffffffc,%r11
mov    %r11,-0x28(%rsp)
add    $0xfffffffffffffffc,%rbp
add    $0xfffffffffffffffc,%rbx
add    $0xfffffffffffffff0,%r14
add    $0xfffffffffffffff0,%r10
movabs $0xfffffffc00000000,%rax
ff ff ff
add    %rax,%rdx
mov    %rdx,%r11
add    $0xfffffffffffffff0,%r15
add    $0x4,%rcx
add    $0x10,%r13
add    $0x10,%r8
add    $0x3,%r9
movaps %xmm8,%xmm3
movaps %xmm13,%xmm4
movaps %xmm0,%xmm5
movaps %xmm15,%xmm6
cmp    %rdi,%r9
mov    %r12,%r9
jl     12d0 <cftb1st+0x1d0>
jmp    190e <cftb1st+0x80e>
xorps  %xmm0,%xmm0
movss  0x70a(%rip),%xmm15
movaps %xmm15,%xmm13
xorps  %xmm8,%xmm8
movaps -0x10(%rsp),%xmm11
addss  %xmm11,%xmm15
movss  -0x5c(%rsp),%xmm1
mulss  %xmm1,%xmm15
addss  %xmm11,%xmm0
mulss  %xmm1,%xmm0
subss  %xmm11,%xmm13
movss  -0x58(%rsp),%xmm1
mulss  %xmm1,%xmm13
subss  %xmm11,%xmm8
mulss  %xmm1,%xmm8
mov    -0x20(%rsp),%rdx
lea    (%rdx,%rdx,2),%ecx
lea    (%rdx,%rdx,4),%eax
lea    0x0(,%rdx,8),%ebp
sub    %edx,%ebp
mov    -0x38(%rsp),%r11
movss  (%rsi,%r11,4),%xmm14
cltq
movss  -0x8(%rsi,%rax,4),%xmm3
movss  -0x4(%rsi,%rax,4),%xmm2
movaps %xmm14,%xmm5
addss  %xmm3,%xmm5
movslq %edx,%rdx
movss  -0x4(%rsi,%rdx,4),%xmm4
movaps 0x674(%rip),%xmm7
movaps %xmm4,%xmm6
xorps  %xmm7,%xmm6
subss  %xmm2,%xmm6
subss  %xmm3,%xmm14
subss  %xmm4,%xmm2
movslq %ecx,%rdi
movss  -0x8(%rsi,%rdi,4),%xmm9
movss  -0x4(%rsi,%rdi,4),%xmm10
movslq %ebp,%rcx
movss  -0x8(%rsi,%rcx,4),%xmm1
movss  -0x4(%rsi,%rcx,4),%xmm12
movaps %xmm9,%xmm3
addss  %xmm1,%xmm3
movaps %xmm10,%xmm4
addss  %xmm12,%xmm4
subss  %xmm1,%xmm9
subss  %xmm12,%xmm10
movaps %xmm5,%xmm1
addss  %xmm3,%xmm1
movss  %xmm1,(%rsi,%r11,4)
movaps %xmm6,%xmm1
subss  %xmm4,%xmm1
movss  %xmm1,-0x4(%rsi,%rdx,4)
subss  %xmm3,%xmm5
movss  %xmm5,-0x8(%rsi,%rdi,4)
addss  %xmm6,%xmm4
movss  %xmm4,-0x4(%rsi,%rdi,4)
movaps %xmm14,%xmm1
addss  %xmm10,%xmm1
movaps %xmm2,%xmm3
addss  %xmm9,%xmm3
movaps %xmm15,%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm0,%xmm3
movaps %xmm15,%xmm5
mulss  %xmm1,%xmm5
subss  %xmm3,%xmm5
movss  %xmm5,-0x8(%rsi,%rax,4)
mulss  %xmm0,%xmm1
addss  %xmm4,%xmm1
movss  %xmm1,-0x4(%rsi,%rax,4)
subss  %xmm10,%xmm14
subss  %xmm9,%xmm2
movaps %xmm8,%xmm1
mulss  %xmm2,%xmm1
movaps %xmm13,%xmm3
mulss  %xmm14,%xmm3
addss  %xmm1,%xmm3
movss  %xmm3,-0x8(%rsi,%rcx,4)
mulss  %xmm8,%xmm14
mulss  %xmm13,%xmm2
subss  %xmm14,%xmm2
movss  %xmm2,-0x4(%rsi,%rcx,4)
movss  (%rsi,%rdx,4),%xmm14
movss  0x4(%rsi,%rdx,4),%xmm1
movss  (%rsi,%rax,4),%xmm3
movss  0x4(%rsi,%rax,4),%xmm2
movaps %xmm14,%xmm5
addss  %xmm3,%xmm5
movaps %xmm1,%xmm6
xorps  %xmm7,%xmm6
subss  %xmm2,%xmm6
subss  %xmm3,%xmm14
subss  %xmm1,%xmm2
movss  (%rsi,%rdi,4),%xmm10
movss  0x4(%rsi,%rdi,4),%xmm12
movss  (%rsi,%rcx,4),%xmm1
movss  0x4(%rsi,%rcx,4),%xmm9
movaps %xmm10,%xmm3
addss  %xmm1,%xmm3
movaps %xmm12,%xmm4
addss  %xmm9,%xmm4
subss  %xmm1,%xmm10
subss  %xmm9,%xmm12
movaps %xmm5,%xmm1
addss  %xmm3,%xmm1
movss  %xmm1,(%rsi,%rdx,4)
movaps %xmm6,%xmm1
subss  %xmm4,%xmm1
movss  %xmm1,0x4(%rsi,%rdx,4)
subss  %xmm3,%xmm5
movss  %xmm5,(%rsi,%rdi,4)
addss  %xmm6,%xmm4
movss  %xmm4,0x4(%rsi,%rdi,4)
movaps %xmm14,%xmm1
addss  %xmm12,%xmm1
movaps %xmm2,%xmm3
addss  %xmm10,%xmm3
movaps %xmm1,%xmm4
subss  %xmm3,%xmm4
mulss  %xmm11,%xmm4
movss  %xmm4,(%rsi,%rax,4)
addss  %xmm1,%xmm3
mulss  %xmm11,%xmm3
movss  %xmm3,0x4(%rsi,%rax,4)
subss  %xmm12,%xmm14
subss  %xmm10,%xmm2
xorps  %xmm7,%xmm11
movaps %xmm2,%xmm1
addss  %xmm14,%xmm1
mulss  %xmm11,%xmm1
movss  %xmm1,(%rsi,%rcx,4)
subss  %xmm14,%xmm2
mulss  %xmm11,%xmm2
movss  %xmm2,0x4(%rsi,%rcx,4)
movss  0x8(%rsi,%rdx,4),%xmm11
movss  0xc(%rsi,%rdx,4),%xmm1
movss  0x8(%rsi,%rax,4),%xmm3
movss  0xc(%rsi,%rax,4),%xmm2
movaps %xmm11,%xmm5
addss  %xmm3,%xmm5
xorps  %xmm1,%xmm7
subss  %xmm2,%xmm7
subss  %xmm3,%xmm11
subss  %xmm1,%xmm2
movss  0x8(%rsi,%rdi,4),%xmm9
movss  0xc(%rsi,%rdi,4),%xmm10
movss  0x8(%rsi,%rcx,4),%xmm1
movss  0xc(%rsi,%rcx,4),%xmm6
movaps %xmm9,%xmm3
addss  %xmm1,%xmm3
movaps %xmm10,%xmm4
addss  %xmm6,%xmm4
subss  %xmm1,%xmm9
subss  %xmm6,%xmm10
movaps %xmm5,%xmm1
addss  %xmm3,%xmm1
movss  %xmm1,0x8(%rsi,%rdx,4)
movaps %xmm7,%xmm1
subss  %xmm4,%xmm1
movss  %xmm1,0xc(%rsi,%rdx,4)
subss  %xmm3,%xmm5
movss  %xmm5,0x8(%rsi,%rdi,4)
addss  %xmm7,%xmm4
movss  %xmm4,0xc(%rsi,%rdi,4)
movaps %xmm11,%xmm1
addss  %xmm10,%xmm1
movaps %xmm2,%xmm4
addss  %xmm9,%xmm4
movaps %xmm4,%xmm5
mulss  %xmm15,%xmm5
movaps %xmm0,%xmm6
mulss  %xmm1,%xmm6
subss  %xmm5,%xmm6
movss  %xmm6,0x8(%rsi,%rax,4)
mulss  %xmm15,%xmm1
mulss  %xmm0,%xmm4
addss  %xmm1,%xmm4
movss  %xmm4,0xc(%rsi,%rax,4)
subss  %xmm10,%xmm11
subss  %xmm9,%xmm2
movaps %xmm13,%xmm1
mulss  %xmm2,%xmm1
movaps %xmm8,%xmm3
mulss  %xmm11,%xmm3
addss  %xmm1,%xmm3
movss  %xmm3,0x8(%rsi,%rcx,4)
mulss  %xmm13,%xmm11
mulss  %xmm8,%xmm2
subss  %xmm11,%xmm2
movss  %xmm2,0xc(%rsi,%rcx,4)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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