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


x86 assembly (clang, -O0):
<cftf1st>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%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
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xc0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0x1c84(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x1c6f(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x30(%rbp)
movl   $0x2,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    21da <cftf1st+0x10da>
mov    -0x30(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x30(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
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
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0xf8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe0(%rbp),%xmm0
ff
addsd  -0x100(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xc0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0xf8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe0(%rbp),%xmm0
ff
subsd  -0x100(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe8(%rbp),%xmm0
ff
subsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
addsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe8(%rbp),%xmm0
ff
addsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
subsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x98(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
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
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0xf8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe0(%rbp),%xmm0
ff
addsd  -0x100(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xc0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0xf8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe0(%rbp),%xmm0
ff
subsd  -0x100(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe8(%rbp),%xmm0
ff
subsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
addsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe8(%rbp),%xmm0
ff
addsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
subsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0x98(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x1c(%rbp)
jmp    13b2 <cftf1st+0x2b2>
movsd  -0x48(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm1
addsd  -0x40(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm1
addsd  -0x40(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
subsd  -0x40(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm1
ff
subsd  -0x40(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%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
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xc0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xc0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm1
ff
subsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm1
ff
addsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x98(%rbp),%xmm1
ff
addsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0xa0(%rbp),%xmm1
ff
subsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xc0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cftf1st>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %edi,%ebp
sar    $0x3,%ebp
lea    0x0(%rbp,%rbp,1),%eax
lea    0x0(,%rbp,4),%ecx
lea    (%rax,%rax,2),%ebx
movslq %ecx,%r8
movupd (%rsi),%xmm0
movupd (%rsi,%r8,8),%xmm1
movapd %xmm0,%xmm2
addpd  %xmm1,%xmm2
subpd  %xmm1,%xmm0
movslq %eax,%rcx
movslq %ebx,%rax
movupd (%rsi,%rcx,8),%xmm1
movupd (%rsi,%rax,8),%xmm3
movapd %xmm1,%xmm4
addpd  %xmm3,%xmm4
subpd  %xmm3,%xmm1
shufpd $0x1,%xmm1,%xmm1
movapd %xmm2,%xmm3
addpd  %xmm4,%xmm3
movupd %xmm3,(%rsi)
subpd  %xmm4,%xmm2
movupd %xmm2,(%rsi,%rcx,8)
movapd %xmm0,%xmm2
subpd  %xmm1,%xmm2
addpd  %xmm0,%xmm1
movapd %xmm1,%xmm0
movsd  %xmm2,%xmm0
movupd %xmm0,(%rsi,%r8,8)
shufpd $0x2,%xmm2,%xmm1
movupd %xmm1,(%rsi,%rax,8)
movsd  0x8(%rdx),%xmm0
movaps %xmm0,(%rsp)
movsd  0x10(%rdx),%xmm1
movsd  0x18(%rdx),%xmm0
mov    %rbp,-0x48(%rsp)
lea    -0x2(%rbp),%eax
cltq
mov    %rax,-0x68(%rsp)
cmp    $0x28,%edi
movsd  %xmm0,-0x70(%rsp)
movsd  %xmm1,-0x78(%rsp)
jl     1772 <cftf1st+0x672>
lea    (%rcx,%rcx,2),%eax
movslq %eax,%rbx
lea    0x3(%rbx),%rax
mov    %rax,-0x60(%rsp)
lea    0x3(%r8),%r15
add    $0xffffffffffffffff,%r8
mov    %r8,-0x58(%rsp)
add    $0xffffffffffffffff,%rbx
lea    -0x2(%rcx),%rdi
mov    %rcx,%r12
shl    $0x4,%r12
lea    -0x10(%r12),%rax
lea    0x0(,%rcx,8),%r8
lea    (%r8,%r8,2),%r11
add    $0xfffffffffffffff0,%r11
mov    %rcx,%r9
shl    $0x22,%r9
movabs $0xfffffffe00000000,%rbp
ff ff ff
add    %r9,%rbp
mov    %rbp,-0x50(%rsp)
mov    %rcx,%r14
shl    $0x5,%r14
add    $0xfffffffffffffff0,%r14
add    $0x4,%rcx
add    $0x20,%r12
mov    %rdx,-0x40(%rsp)
lea    (%r8,%r8,2),%r8
add    $0x20,%r8
movsd  0xdb3(%rip),%xmm13
xorpd  %xmm15,%xmm15
mov    $0x3,%r9d
xorpd  %xmm8,%xmm8
movapd %xmm13,%xmm14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x40(%rsp),%rdx
movsd  0x8(%rdx,%r9,8),%xmm0
movaps %xmm0,-0x30(%rsp)
movsd  -0x10(%rsi,%r12,1),%xmm7
movsd  (%rsi,%r15,8),%xmm0
mov    %r15,%rbp
mov    %r15,-0x38(%rsp)
movupd -0x8(%rsi,%r9,8),%xmm10
movapd %xmm10,%xmm2
subsd  %xmm7,%xmm2
movapd %xmm2,-0x20(%rsp)
unpcklpd %xmm0,%xmm7
movupd 0x8(%rsi,%r9,8),%xmm11
addpd  %xmm10,%xmm7
unpckhpd %xmm10,%xmm10
subsd  %xmm0,%xmm10
movupd (%rsi,%r12,1),%xmm0
movapd %xmm11,%xmm6
addpd  %xmm0,%xmm6
subpd  %xmm0,%xmm11
movsd  -0x10(%rsi,%r8,1),%xmm0
mov    -0x60(%rsp),%r15
movsd  (%rsi,%r15,8),%xmm3
movupd -0x10(%rsi,%rcx,8),%xmm5
movapd %xmm5,%xmm12
subsd  %xmm0,%xmm12
unpcklpd %xmm3,%xmm0
movupd (%rsi,%rcx,8),%xmm9
addpd  %xmm5,%xmm0
unpckhpd %xmm5,%xmm5
subsd  %xmm3,%xmm5
movupd (%rsi,%r8,1),%xmm3
movapd %xmm9,%xmm4
addpd  %xmm3,%xmm4
subpd  %xmm3,%xmm9
movapd %xmm7,%xmm2
addpd  %xmm0,%xmm2
movsd  0x10(%rdx,%r9,8),%xmm3
movsd  0x18(%rdx,%r9,8),%xmm1
movaps %xmm1,0x10(%rsp)
movsd  0x20(%rdx,%r9,8),%xmm1
movaps %xmm1,-0x10(%rsp)
movupd %xmm2,-0x8(%rsi,%r9,8)
movapd %xmm6,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm2,0x8(%rsi,%r9,8)
subpd  %xmm0,%xmm7
movupd %xmm7,-0x10(%rsi,%rcx,8)
movapd -0x30(%rsp),%xmm1
addsd  %xmm1,%xmm14
movsd  -0x78(%rsp),%xmm0
mulsd  %xmm0,%xmm14
addsd  %xmm3,%xmm8
mulsd  %xmm0,%xmm8
subpd  %xmm4,%xmm6
movupd %xmm6,(%rsi,%rcx,8)
movapd -0x20(%rsp),%xmm0
subsd  %xmm5,%xmm0
movapd %xmm10,%xmm2
addsd  %xmm12,%xmm2
movapd %xmm14,%xmm4
mulsd  %xmm2,%xmm4
mulsd  %xmm8,%xmm2
movapd %xmm14,%xmm6
mulsd  %xmm0,%xmm6
subsd  %xmm2,%xmm6
movsd  %xmm6,-0x10(%rsi,%r12,1)
shufpd $0x1,%xmm9,%xmm9
mulsd  %xmm8,%xmm0
addsd  %xmm4,%xmm0
movsd  %xmm0,(%rsi,%rbp,8)
movapd %xmm11,%xmm7
subpd  %xmm9,%xmm7
addpd  %xmm11,%xmm9
movapd %xmm3,0x30(%rsp)
movapd %xmm3,%xmm6
movapd 0xc0f(%rip),%xmm2
xorpd  %xmm2,%xmm6
movapd %xmm9,%xmm0
shufpd $0x1,%xmm3,%xmm0
unpcklpd %xmm7,%xmm6
mulpd  %xmm0,%xmm6
movapd -0x10(%rsp),%xmm3
movapd %xmm3,%xmm0
xorpd  %xmm2,%xmm0
movapd %xmm0,%xmm4
movapd %xmm0,0x20(%rsp)
movapd %xmm7,%xmm11
movsd  %xmm9,%xmm11
unpcklpd %xmm9,%xmm4
movsd  %xmm7,%xmm9
unpcklpd %xmm1,%xmm1
mulpd  %xmm9,%xmm1
addpd  %xmm6,%xmm1
movupd %xmm1,(%rsi,%r12,1)
movapd 0x10(%rsp),%xmm2
addsd  %xmm2,%xmm13
movsd  -0x70(%rsp),%xmm0
mulsd  %xmm0,%xmm13
subsd  %xmm3,%xmm15
mulsd  %xmm0,%xmm15
addsd  -0x20(%rsp),%xmm5
subsd  %xmm12,%xmm10
movapd %xmm15,%xmm0
mulsd  %xmm10,%xmm0
movapd %xmm13,%xmm6
mulsd  %xmm5,%xmm6
addsd  %xmm0,%xmm6
movsd  %xmm6,-0x10(%rsi,%r8,1)
mulsd  %xmm15,%xmm5
mulsd  %xmm13,%xmm10
subsd  %xmm5,%xmm10
movsd  %xmm10,(%rsi,%r15,8)
shufpd $0x1,%xmm3,%xmm7
mulpd  %xmm7,%xmm4
movapd %xmm2,%xmm0
movapd %xmm2,%xmm3
unpcklpd %xmm0,%xmm0
mulpd  %xmm11,%xmm0
addpd  %xmm4,%xmm0
movupd %xmm0,(%rsi,%r8,1)
movsd  (%rsi,%r11,1),%xmm11
movupd -0x10(%rsi,%rdi,8),%xmm12
movupd (%rsi,%rdi,8),%xmm1
movsd  (%rsi,%rbx,8),%xmm0
movapd %xmm1,%xmm9
subsd  %xmm11,%xmm9
unpcklpd %xmm0,%xmm11
addpd  %xmm1,%xmm11
unpckhpd %xmm1,%xmm1
subsd  %xmm0,%xmm1
movupd -0x10(%rsi,%r11,1),%xmm0
movapd %xmm12,%xmm10
addpd  %xmm0,%xmm10
subpd  %xmm0,%xmm12
movsd  (%rsi,%rax,1),%xmm6
mov    %r11,%rbp
mov    -0x58(%rsp),%r11
movsd  (%rsi,%r11,8),%xmm5
mov    -0x50(%rsp),%r10
mov    %r10,%r13
sar    $0x1d,%r13
or     $0x8,%r13
movapd %xmm6,%xmm0
unpcklpd %xmm5,%xmm0
movsd  (%rsi,%r14,1),%xmm2
subsd  %xmm2,%xmm6
movsd  (%rsi,%r13,1),%xmm4
unpcklpd %xmm4,%xmm2
addpd  %xmm0,%xmm2
subsd  %xmm4,%xmm5
movupd -0x10(%rsi,%rax,1),%xmm7
movupd -0x10(%rsi,%r14,1),%xmm0
movapd %xmm7,%xmm4
addpd  %xmm0,%xmm4
subpd  %xmm0,%xmm7
movapd %xmm11,%xmm0
addpd  %xmm2,%xmm0
movupd %xmm0,(%rsi,%rdi,8)
movapd %xmm10,%xmm0
addpd  %xmm4,%xmm0
movupd %xmm0,-0x10(%rsi,%rdi,8)
subpd  %xmm2,%xmm11
movlpd %xmm11,(%rsi,%rax,1)
movhpd %xmm11,(%rsi,%r11,8)
movapd %xmm3,%xmm11
subpd  %xmm4,%xmm10
movupd %xmm10,-0x10(%rsi,%rax,1)
movapd 0x30(%rsp),%xmm10
movapd %xmm9,%xmm0
subsd  %xmm5,%xmm0
movapd %xmm1,%xmm2
addsd  %xmm6,%xmm2
movapd %xmm2,%xmm4
mulsd  %xmm14,%xmm4
mulsd  %xmm8,%xmm2
mulsd  %xmm0,%xmm8
subsd  %xmm4,%xmm8
movsd  %xmm8,(%rsi,%rbp,1)
shufpd $0x1,%xmm7,%xmm7
mulsd  %xmm14,%xmm0
addsd  %xmm0,%xmm2
movsd  %xmm2,(%rsi,%rbx,8)
movapd %xmm12,%xmm2
subpd  %xmm7,%xmm2
addpd  %xmm12,%xmm7
movapd 0x20(%rsp),%xmm12
movapd -0x30(%rsp),%xmm14
movapd %xmm14,%xmm4
xorpd  0x9de(%rip),%xmm4
movapd %xmm7,%xmm0
shufpd $0x1,%xmm14,%xmm0
unpcklpd %xmm2,%xmm4
mulpd  %xmm0,%xmm4
movapd %xmm2,%xmm8
movsd  %xmm7,%xmm8
movapd %xmm3,%xmm0
unpcklpd %xmm7,%xmm0
movsd  %xmm2,%xmm7
movapd %xmm10,%xmm3
unpcklpd %xmm10,%xmm3
mulpd  %xmm7,%xmm3
addpd  %xmm4,%xmm3
movupd %xmm3,-0x10(%rsi,%rbp,1)
addsd  %xmm9,%xmm5
movapd %xmm14,%xmm7
subsd  %xmm6,%xmm1
movapd %xmm15,%xmm3
mulsd  %xmm5,%xmm3
mulsd  %xmm13,%xmm5
mulsd  %xmm1,%xmm13
addsd  %xmm13,%xmm3
movsd  %xmm3,(%rsi,%r14,1)
mulsd  %xmm15,%xmm1
subsd  %xmm5,%xmm1
movsd  %xmm1,(%rsi,%r13,1)
mov    -0x68(%rsp),%rdx
movapd %xmm11,%xmm1
xorpd  0x951(%rip),%xmm1
shufpd $0x1,%xmm1,%xmm2
mulpd  %xmm0,%xmm2
movapd -0x10(%rsp),%xmm0
unpcklpd %xmm0,%xmm0
mulpd  %xmm8,%xmm0
subpd  %xmm0,%xmm2
movupd %xmm2,-0x10(%rsi,%r14,1)
lea    0x4(%r9),%r13
add    $0x4,%r15
mov    %r15,-0x60(%rsp)
mov    -0x38(%rsp),%r15
add    $0x4,%r15
add    $0xfffffffffffffffc,%r11
mov    %r11,-0x58(%rsp)
mov    %rbp,%r11
add    $0xfffffffffffffffc,%rbx
add    $0xfffffffffffffffc,%rdi
add    $0xffffffffffffffe0,%rax
add    $0xffffffffffffffe0,%r11
mov    %rax,%rbp
mov    %rdi,%rax
movabs $0xfffffffc00000000,%rdi
ff ff ff
add    %rdi,%r10
mov    %rax,%rdi
mov    %rbp,%rax
mov    %r10,-0x50(%rsp)
add    $0xffffffffffffffe0,%r14
add    $0x4,%rcx
add    $0x20,%r12
add    $0x20,%r8
add    $0x3,%r9
movapd %xmm12,%xmm2
movapd %xmm12,%xmm15
movapd %xmm11,%xmm3
movapd %xmm11,%xmm13
movapd %xmm10,%xmm4
movapd %xmm10,%xmm8
cmp    %rdx,%r9
mov    %r13,%r9
jl     1270 <cftf1st+0x170>
jmp    1786 <cftf1st+0x686>
xorpd  %xmm4,%xmm4
movsd  0x882(%rip),%xmm7
movapd %xmm7,%xmm3
xorpd  %xmm2,%xmm2
movapd (%rsp),%xmm9
addsd  %xmm9,%xmm7
movsd  -0x78(%rsp),%xmm0
mulsd  %xmm0,%xmm7
movapd %xmm4,%xmm10
addsd  %xmm9,%xmm10
mulsd  %xmm0,%xmm10
movapd %xmm3,%xmm11
subsd  %xmm9,%xmm11
movsd  -0x70(%rsp),%xmm0
mulsd  %xmm0,%xmm11
movapd %xmm2,%xmm12
subsd  %xmm9,%xmm12
mulsd  %xmm0,%xmm12
mov    -0x48(%rsp),%rbp
lea    0x0(%rbp,%rbp,2),%ecx
lea    0x0(%rbp,%rbp,4),%eax
lea    0x0(,%rbp,8),%edi
sub    %ebp,%edi
mov    -0x68(%rsp),%rbx
movupd (%rsi,%rbx,8),%xmm0
cltq
movupd -0x10(%rsi,%rax,8),%xmm1
movapd %xmm0,%xmm3
addpd  %xmm1,%xmm3
subpd  %xmm1,%xmm0
movslq %ecx,%rdx
movupd -0x10(%rsi,%rdx,8),%xmm2
movslq %edi,%rcx
movupd -0x10(%rsi,%rcx,8),%xmm1
movapd %xmm2,%xmm4
addpd  %xmm1,%xmm4
subpd  %xmm1,%xmm2
shufpd $0x1,%xmm2,%xmm2
movapd %xmm3,%xmm1
addpd  %xmm4,%xmm1
movupd %xmm1,(%rsi,%rbx,8)
subpd  %xmm4,%xmm3
movupd %xmm3,-0x10(%rsi,%rdx,8)
movapd %xmm0,%xmm1
subpd  %xmm2,%xmm1
addpd  %xmm0,%xmm2
movapd %xmm2,%xmm0
movapd %xmm1,%xmm3
movsd  %xmm2,%xmm3
movapd %xmm12,%xmm4
unpcklpd %xmm2,%xmm4
movsd  %xmm1,%xmm2
movapd 0x7a6(%rip),%xmm8
movapd %xmm10,%xmm6
xorpd  %xmm8,%xmm6
shufpd $0x1,%xmm10,%xmm0
unpcklpd %xmm1,%xmm6
mulpd  %xmm0,%xmm6
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
mulpd  %xmm2,%xmm0
addpd  %xmm6,%xmm0
movupd %xmm0,-0x10(%rsi,%rax,8)
movapd %xmm12,%xmm0
xorpd  %xmm8,%xmm0
shufpd $0x1,%xmm0,%xmm1
mulpd  %xmm4,%xmm1
movapd %xmm11,%xmm0
unpcklpd %xmm11,%xmm0
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,-0x10(%rsi,%rcx,8)
movslq %ebp,%rdi
movupd (%rsi,%rdi,8),%xmm4
movupd (%rsi,%rax,8),%xmm0
movapd %xmm4,%xmm1
addpd  %xmm0,%xmm1
subpd  %xmm0,%xmm4
movupd (%rsi,%rdx,8),%xmm2
movupd (%rsi,%rcx,8),%xmm0
movapd %xmm2,%xmm6
subpd  %xmm0,%xmm2
movapd %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
movapd %xmm4,%xmm5
subsd  %xmm3,%xmm5
addsd  %xmm4,%xmm3
unpckhpd %xmm4,%xmm4
addpd  %xmm0,%xmm6
movapd %xmm1,%xmm0
addpd  %xmm6,%xmm0
movupd %xmm0,(%rsi,%rdi,8)
subpd  %xmm6,%xmm1
movupd %xmm1,(%rsi,%rdx,8)
movapd %xmm4,%xmm0
addsd  %xmm2,%xmm0
movapd %xmm5,%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm9,%xmm1
movsd  %xmm1,(%rsi,%rax,8)
addsd  %xmm5,%xmm0
mulsd  %xmm9,%xmm0
movsd  %xmm0,0x8(%rsi,%rax,8)
subsd  %xmm2,%xmm4
xorpd  %xmm8,%xmm9
movapd %xmm4,%xmm0
addsd  %xmm3,%xmm0
mulsd  %xmm9,%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
subsd  %xmm3,%xmm4
mulsd  %xmm9,%xmm4
movsd  %xmm4,0x8(%rsi,%rcx,8)
movupd 0x10(%rsi,%rdi,8),%xmm0
movupd 0x10(%rsi,%rax,8),%xmm1
movapd %xmm0,%xmm2
addpd  %xmm1,%xmm2
subpd  %xmm1,%xmm0
movupd 0x10(%rsi,%rdx,8),%xmm1
movupd 0x10(%rsi,%rcx,8),%xmm3
movapd %xmm1,%xmm4
addpd  %xmm3,%xmm4
subpd  %xmm3,%xmm1
shufpd $0x1,%xmm1,%xmm1
movapd %xmm2,%xmm3
addpd  %xmm4,%xmm3
movupd %xmm3,0x10(%rsi,%rdi,8)
subpd  %xmm4,%xmm2
movupd %xmm2,0x10(%rsi,%rdx,8)
movapd %xmm0,%xmm2
subpd  %xmm1,%xmm2
addpd  %xmm0,%xmm1
movapd %xmm1,%xmm0
shufpd $0x1,%xmm7,%xmm0
xorpd  %xmm8,%xmm7
movapd %xmm2,%xmm3
movsd  %xmm1,%xmm3
xorpd  %xmm11,%xmm8
unpcklpd %xmm1,%xmm11
movsd  %xmm2,%xmm1
unpcklpd %xmm2,%xmm7
mulpd  %xmm0,%xmm7
unpcklpd %xmm10,%xmm10
mulpd  %xmm1,%xmm10
addpd  %xmm7,%xmm10
movupd %xmm10,0x10(%rsi,%rax,8)
shufpd $0x1,%xmm8,%xmm2
mulpd  %xmm11,%xmm2
unpcklpd %xmm12,%xmm12
mulpd  %xmm3,%xmm12
addpd  %xmm2,%xmm12
movupd %xmm12,0x10(%rsi,%rcx,8)
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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