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