void cftb1st(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):
<cftb1st>:
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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%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
subsd  -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
addsd  -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
addsd  -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
subsd  -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  0x1c56(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x1c41(%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    22a9 <cftb1st+0x11a9>
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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addsd  (%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
subsd  -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
subsd  -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
addsd  -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
addsd  -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
addsd  -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
addsd  -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
subsd  -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
subsd  -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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -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
subsd  -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
addsd  -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
addsd  -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
addsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
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
addsd  -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
subsd  -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
subsd  -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    13e0 <cftb1st+0x2e0>
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
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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%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
subsd  -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
addsd  -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
addsd  -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
subsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%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
subsd  -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
addsd  -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
addsd  -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
subsd  -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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addsd  (%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
subsd  -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
addsd  -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
addsd  -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
subsd  -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):
<cftb1st>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %edi,%ebp
sar    $0x3,%ebp
lea    0x0(%rbp,%rbp,1),%eax
lea    0x0(,%rbp,4),%ecx
lea    (%rax,%rax,2),%r8d
movslq %ecx,%rbx
movsd  (%rsi),%xmm1
movq   0x8(%rsi),%xmm2
movdqa 0xeca(%rip),%xmm0
pxor   %xmm2,%xmm0
movupd (%rsi,%rbx,8),%xmm3
pshufd $0x44,%xmm0,%xmm4
movapd %xmm3,%xmm0
shufpd $0x1,%xmm1,%xmm0
addpd  %xmm3,%xmm1
subpd  %xmm3,%xmm4
movsd  %xmm1,%xmm4
punpcklqdq %xmm3,%xmm2
subpd  %xmm2,%xmm0
movslq %eax,%r14
movslq %r8d,%rax
movupd (%rsi,%r14,8),%xmm1
movupd (%rsi,%rax,8),%xmm2
movapd %xmm1,%xmm3
addpd  %xmm2,%xmm3
subpd  %xmm2,%xmm1
movapd %xmm4,%xmm2
addpd  %xmm3,%xmm2
subpd  %xmm3,%xmm4
movapd %xmm4,%xmm3
movsd  %xmm2,%xmm3
movupd %xmm3,(%rsi)
shufpd $0x2,%xmm2,%xmm4
movupd %xmm4,(%rsi,%r14,8)
movapd %xmm0,%xmm2
addpd  %xmm1,%xmm2
shufpd $0x1,%xmm2,%xmm2
movupd %xmm2,(%rsi,%rbx,8)
subpd  %xmm1,%xmm0
shufpd $0x1,%xmm0,%xmm0
movupd %xmm0,(%rsi,%rax,8)
movsd  0x8(%rdx),%xmm0
movaps %xmm0,0x10(%rsp)
movsd  0x10(%rdx),%xmm1
movsd  0x18(%rdx),%xmm0
mov    %rbp,-0x48(%rsp)
lea    -0x2(%rbp),%eax
movslq %eax,%r10
cmp    $0x28,%edi
movsd  %xmm0,-0x60(%rsp)
movsd  %xmm1,-0x68(%rsp)
jl     187f <cftb1st+0x77f>
lea    (%r14,%r14,2),%eax
movslq %eax,%rdi
lea    0x3(%rdi),%rax
mov    %rax,-0x58(%rsp)
lea    0x3(%rbx),%r15
add    $0xffffffffffffffff,%rbx
mov    %rbx,-0x50(%rsp)
add    $0xffffffffffffffff,%rdi
lea    -0x1(%r14),%r12
mov    %r14,%r11
shl    $0x4,%r11
lea    -0x10(%r11),%rbx
lea    0x0(,%r14,8),%rax
lea    (%rax,%rax,2),%r8
add    $0xfffffffffffffff0,%r8
mov    %r14,%r9
shl    $0x22,%r9
movabs $0xfffffffe00000000,%rbp
ff ff ff
add    %r9,%rbp
mov    %r14,%rcx
shl    $0x5,%rcx
add    $0xfffffffffffffff0,%rcx
add    $0x2,%r14
add    $0x10,%r11
mov    %rdx,-0x40(%rsp)
lea    (%rax,%rax,2),%rax
add    $0x20,%rax
movsd  0xd9f(%rip),%xmm5
xorpd  %xmm3,%xmm3
mov    $0x3,%r9d
xorpd  %xmm15,%xmm15
movapd %xmm5,%xmm9
cs nopw 0x0(%rax,%rax,1)
nop
movsd  %xmm3,-0x78(%rsp)
movsd  %xmm5,-0x70(%rsp)
movsd  -0x8(%rsi,%r9,8),%xmm13
movsd  (%rsi,%r9,8),%xmm0
movsd  (%rsi,%r11,1),%xmm2
movsd  0x10(%rsi,%r11,1),%xmm4
movapd %xmm13,%xmm5
addsd  %xmm2,%xmm5
movapd %xmm0,%xmm12
movapd 0xd34(%rip),%xmm1
xorpd  %xmm1,%xmm12
movsd  (%rsi,%r15,8),%xmm7
mov    %r15,%r13
mov    %r15,-0x38(%rsp)
subsd  %xmm7,%xmm12
subsd  %xmm2,%xmm13
subsd  %xmm0,%xmm7
movsd  0x8(%rsi,%r9,8),%xmm3
movsd  0x10(%rsi,%r9,8),%xmm6
movapd %xmm6,%xmm2
xorpd  %xmm1,%xmm2
movsd  0x18(%rsi,%r11,1),%xmm0
subsd  %xmm0,%xmm2
unpcklpd %xmm3,%xmm0
addsd  %xmm4,%xmm3
unpcklpd %xmm4,%xmm6
subpd  %xmm6,%xmm0
movsd  -0x10(%rsi,%rax,1),%xmm6
movsd  (%rsi,%r14,8),%xmm11
movsd  0x8(%rsi,%r14,8),%xmm10
movapd %xmm11,%xmm4
addsd  %xmm6,%xmm4
mov    -0x58(%rsp),%r15
movsd  (%rsi,%r15,8),%xmm8
subsd  %xmm6,%xmm11
movapd %xmm10,%xmm6
addsd  %xmm8,%xmm6
subsd  %xmm8,%xmm10
movupd 0x10(%rsi,%r14,8),%xmm1
movupd (%rsi,%rax,1),%xmm14
movapd %xmm1,%xmm8
addpd  %xmm14,%xmm8
subpd  %xmm14,%xmm1
movapd %xmm1,0x20(%rsp)
movapd %xmm5,%xmm14
addsd  %xmm4,%xmm14
mov    -0x40(%rsp),%rdx
movsd  0x8(%rdx,%r9,8),%xmm1
movaps %xmm1,(%rsp)
movsd  0x10(%rdx,%r9,8),%xmm1
movaps %xmm1,-0x10(%rsp)
movsd  0x18(%rdx,%r9,8),%xmm1
movaps %xmm1,-0x30(%rsp)
movsd  0x20(%rdx,%r9,8),%xmm1
movaps %xmm1,-0x20(%rsp)
movsd  %xmm14,-0x8(%rsi,%r9,8)
movapd %xmm12,%xmm1
subsd  %xmm6,%xmm1
movsd  %xmm1,(%rsi,%r9,8)
movapd %xmm3,%xmm1
addsd  %xmm8,%xmm1
movsd  %xmm1,0x8(%rsi,%r9,8)
subsd  %xmm8,%xmm3
unpckhpd %xmm8,%xmm8
movapd %xmm2,%xmm1
subsd  %xmm8,%xmm1
movsd  %xmm1,0x10(%rsi,%r9,8)
subsd  %xmm4,%xmm5
movsd  %xmm5,(%rsi,%r14,8)
addsd  %xmm12,%xmm6
movsd  %xmm6,0x8(%rsi,%r14,8)
movsd  %xmm3,0x10(%rsi,%r14,8)
movapd (%rsp),%xmm5
addsd  %xmm5,%xmm9
movsd  -0x68(%rsp),%xmm1
mulsd  %xmm1,%xmm9
movapd -0x10(%rsp),%xmm6
addsd  %xmm6,%xmm15
mulsd  %xmm1,%xmm15
addsd  %xmm2,%xmm8
movsd  %xmm8,0x18(%rsi,%r14,8)
movapd %xmm13,%xmm1
addsd  %xmm10,%xmm1
movapd %xmm7,%xmm2
addsd  %xmm11,%xmm2
movapd %xmm9,%xmm3
mulsd  %xmm2,%xmm3
mulsd  %xmm15,%xmm2
movapd %xmm9,%xmm4
mulsd  %xmm1,%xmm4
subsd  %xmm2,%xmm4
movsd  %xmm4,(%rsi,%r11,1)
mulsd  %xmm15,%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,(%rsi,%r13,8)
movapd %xmm0,%xmm1
movapd 0x20(%rsp),%xmm12
addpd  %xmm12,%xmm1
movapd %xmm6,%xmm3
movapd %xmm6,%xmm2
movapd 0xb55(%rip),%xmm8
xorpd  %xmm8,%xmm2
unpcklpd %xmm1,%xmm3
movapd %xmm5,%xmm4
unpcklpd %xmm5,%xmm4
mulpd  %xmm1,%xmm4
shufpd $0x1,%xmm2,%xmm1
mulpd  %xmm3,%xmm1
movsd  -0x70(%rsp),%xmm3
movapd -0x30(%rsp),%xmm5
addsd  %xmm5,%xmm3
movsd  -0x60(%rsp),%xmm2
mulsd  %xmm2,%xmm3
movapd %xmm3,%xmm6
movsd  -0x78(%rsp),%xmm3
movapd -0x20(%rsp),%xmm14
addsd  %xmm14,%xmm3
mulsd  %xmm2,%xmm3
addpd  %xmm1,%xmm4
shufpd $0x1,%xmm4,%xmm4
movupd %xmm4,0x10(%rsi,%r11,1)
subsd  %xmm10,%xmm13
subsd  %xmm11,%xmm7
movapd %xmm3,%xmm1
movsd  %xmm3,-0x78(%rsp)
mulsd  %xmm7,%xmm1
movsd  %xmm6,-0x70(%rsp)
movapd %xmm6,%xmm2
mulsd  %xmm13,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,-0x10(%rsi,%rax,1)
mulsd  %xmm3,%xmm13
mulsd  %xmm6,%xmm7
subsd  %xmm13,%xmm7
movsd  %xmm7,(%rsi,%r15,8)
subpd  %xmm12,%xmm0
movapd %xmm14,%xmm3
movapd %xmm14,%xmm1
xorpd  %xmm8,%xmm1
movapd %xmm8,%xmm6
unpcklpd %xmm0,%xmm1
movapd %xmm5,%xmm2
unpcklpd %xmm5,%xmm2
mulpd  %xmm0,%xmm2
shufpd $0x1,%xmm14,%xmm0
mulpd  %xmm0,%xmm1
addpd  %xmm1,%xmm2
shufpd $0x1,%xmm2,%xmm2
movupd %xmm2,(%rsi,%rax,1)
movsd  -0x8(%rsi,%r12,8),%xmm7
movsd  (%rsi,%r8,1),%xmm3
movapd %xmm7,%xmm14
addsd  %xmm3,%xmm14
movsd  (%rsi,%r12,8),%xmm4
movapd %xmm4,%xmm2
movapd %xmm8,%xmm1
xorpd  %xmm8,%xmm2
movsd  (%rsi,%rdi,8),%xmm0
subsd  %xmm0,%xmm2
subsd  %xmm3,%xmm7
subsd  %xmm4,%xmm0
movsd  -0x18(%rsi,%r12,8),%xmm10
movsd  -0x8(%rsi,%r8,1),%xmm5
movsd  -0x10(%rsi,%r12,8),%xmm3
movapd %xmm3,%xmm13
xorpd  %xmm8,%xmm13
subsd  %xmm5,%xmm13
unpcklpd %xmm10,%xmm5
movsd  -0x10(%rsi,%r8,1),%xmm4
addsd  %xmm4,%xmm10
unpcklpd %xmm4,%xmm3
subpd  %xmm3,%xmm5
movsd  (%rsi,%rbx,1),%xmm12
movsd  (%rsi,%rcx,1),%xmm4
movapd %xmm12,%xmm3
addsd  %xmm4,%xmm3
subsd  %xmm4,%xmm12
mov    %r10,%rdx
mov    %rbp,%r13
sar    $0x1d,%r13
or     $0x8,%r13
mov    -0x50(%rsp),%r10
movsd  (%rsi,%r10,8),%xmm11
movsd  (%rsi,%r13,1),%xmm4
movapd %xmm11,%xmm6
addsd  %xmm4,%xmm6
subsd  %xmm4,%xmm11
movupd -0x10(%rsi,%rbx,1),%xmm8
movupd -0x10(%rsi,%rcx,1),%xmm4
movapd %xmm8,%xmm1
addpd  %xmm4,%xmm1
subpd  %xmm4,%xmm8
movapd %xmm14,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,-0x8(%rsi,%r12,8)
movapd %xmm2,%xmm4
subsd  %xmm6,%xmm4
movsd  %xmm4,(%rsi,%r12,8)
movapd %xmm10,%xmm4
addsd  %xmm1,%xmm4
movsd  %xmm4,-0x18(%rsi,%r12,8)
subsd  %xmm1,%xmm10
unpckhpd %xmm1,%xmm1
movapd %xmm13,%xmm4
subsd  %xmm1,%xmm4
movsd  %xmm4,-0x10(%rsi,%r12,8)
subsd  %xmm3,%xmm14
movsd  %xmm14,(%rsi,%rbx,1)
movapd -0x10(%rsp),%xmm14
addsd  %xmm2,%xmm6
movsd  %xmm6,(%rsi,%r10,8)
movsd  %xmm10,-0x10(%rsi,%rbx,1)
addsd  %xmm13,%xmm1
movapd -0x30(%rsp),%xmm13
movsd  %xmm1,-0x8(%rsi,%rbx,1)
movapd %xmm7,%xmm1
addsd  %xmm11,%xmm1
movapd %xmm0,%xmm2
addsd  %xmm12,%xmm2
movapd %xmm2,%xmm3
mulsd  %xmm9,%xmm3
mulsd  %xmm15,%xmm2
mulsd  %xmm1,%xmm15
subsd  %xmm3,%xmm15
movsd  %xmm15,(%rsi,%r8,1)
mulsd  %xmm9,%xmm1
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi,%rdi,8)
movapd %xmm5,%xmm1
addpd  %xmm8,%xmm1
movapd (%rsp),%xmm4
movapd %xmm4,%xmm2
movapd 0x8be(%rip),%xmm9
xorpd  %xmm9,%xmm2
movapd %xmm4,%xmm3
movapd %xmm4,%xmm6
unpcklpd %xmm1,%xmm3
movapd %xmm14,%xmm4
unpcklpd %xmm14,%xmm4
mulpd  %xmm1,%xmm4
shufpd $0x1,%xmm2,%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm1,%xmm4
shufpd $0x1,%xmm4,%xmm4
movupd %xmm4,-0x10(%rsi,%r8,1)
subsd  %xmm11,%xmm7
subsd  %xmm12,%xmm0
movapd -0x20(%rsp),%xmm4
movsd  -0x78(%rsp),%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm7,%xmm1
movsd  -0x70(%rsp),%xmm2
mulsd  %xmm2,%xmm7
mulsd  %xmm0,%xmm2
addsd  %xmm2,%xmm1
movapd %xmm6,%xmm2
movsd  %xmm1,(%rsi,%rcx,1)
mulsd  %xmm3,%xmm0
subsd  %xmm7,%xmm0
movsd  %xmm0,(%rsi,%r13,1)
subpd  %xmm8,%xmm5
movapd %xmm13,%xmm0
xorpd  %xmm9,%xmm0
unpcklpd %xmm5,%xmm0
movapd %xmm4,%xmm1
unpcklpd %xmm4,%xmm1
mulpd  %xmm5,%xmm1
shufpd $0x1,%xmm13,%xmm5
mulpd  %xmm5,%xmm0
addpd  %xmm0,%xmm1
shufpd $0x1,%xmm1,%xmm1
movupd %xmm1,-0x10(%rsi,%rcx,1)
lea    0x4(%r9),%r13
add    $0x4,%r15
mov    %r15,-0x58(%rsp)
mov    -0x38(%rsp),%r15
add    $0x4,%r15
add    $0xfffffffffffffffc,%r10
mov    %r10,-0x50(%rsp)
add    $0xfffffffffffffffc,%rdi
add    $0xfffffffffffffffc,%r12
add    $0xffffffffffffffe0,%rbx
add    $0xffffffffffffffe0,%r8
mov    %rbx,%r10
mov    %rcx,%rbx
mov    %rax,%rcx
movabs $0xfffffffc00000000,%rax
ff ff ff
add    %rax,%rbp
mov    %rcx,%rax
mov    %rbx,%rcx
mov    %r10,%rbx
add    $0xffffffffffffffe0,%rcx
add    $0x4,%r14
add    $0x20,%r11
add    $0x20,%rax
add    $0x3,%r9
movapd %xmm4,%xmm3
movapd %xmm13,%xmm5
movapd %xmm14,%xmm15
movapd %xmm6,%xmm9
mov    %rdx,%r10
cmp    %rdx,%r9
mov    %r13,%r9
jl     1290 <cftb1st+0x190>
jmp    1895 <cftb1st+0x795>
xorpd  %xmm14,%xmm14
movsd  0x784(%rip),%xmm2
movapd %xmm2,%xmm13
xorpd  %xmm4,%xmm4
movapd 0x10(%rsp),%xmm11
addsd  %xmm11,%xmm2
movsd  -0x68(%rsp),%xmm0
mulsd  %xmm0,%xmm2
addsd  %xmm11,%xmm14
mulsd  %xmm0,%xmm14
subsd  %xmm11,%xmm13
movsd  -0x60(%rsp),%xmm0
mulsd  %xmm0,%xmm13
subsd  %xmm11,%xmm4
mulsd  %xmm0,%xmm4
mov    -0x48(%rsp),%rdx
lea    (%rdx,%rdx,2),%ecx
lea    (%rdx,%rdx,4),%eax
lea    0x0(,%rdx,8),%ebp
sub    %edx,%ebp
movsd  (%rsi,%r10,8),%xmm3
cltq
movapd %xmm2,%xmm15
movsd  -0x10(%rsi,%rax,8),%xmm2
movsd  -0x8(%rsi,%rax,8),%xmm0
movslq %edx,%rdx
movsd  -0x8(%rsi,%rdx,8),%xmm5
movapd 0x6f3(%rip),%xmm8
movapd %xmm5,%xmm1
xorpd  %xmm8,%xmm1
subsd  %xmm0,%xmm1
unpcklpd %xmm3,%xmm0
addsd  %xmm2,%xmm3
unpcklpd %xmm2,%xmm5
subpd  %xmm5,%xmm0
movslq %ecx,%rdi
movupd -0x10(%rsi,%rdi,8),%xmm2
movslq %ebp,%rcx
movupd -0x10(%rsi,%rcx,8),%xmm5
movapd %xmm2,%xmm6
addpd  %xmm5,%xmm6
movapd %xmm3,%xmm7
addsd  %xmm6,%xmm7
subsd  %xmm6,%xmm3
unpckhpd %xmm6,%xmm6
subpd  %xmm5,%xmm2
movsd  %xmm7,(%rsi,%r10,8)
movapd %xmm1,%xmm5
subsd  %xmm6,%xmm5
movsd  %xmm5,-0x8(%rsi,%rdx,8)
movsd  %xmm3,-0x10(%rsi,%rdi,8)
addsd  %xmm1,%xmm6
movsd  %xmm6,-0x8(%rsi,%rdi,8)
movapd %xmm0,%xmm3
addpd  %xmm2,%xmm3
movapd %xmm14,%xmm1
xorpd  %xmm8,%xmm1
movapd %xmm14,%xmm5
unpcklpd %xmm3,%xmm5
movapd %xmm15,%xmm6
unpcklpd %xmm15,%xmm6
mulpd  %xmm3,%xmm6
shufpd $0x1,%xmm1,%xmm3
mulpd  %xmm5,%xmm3
addpd  %xmm3,%xmm6
shufpd $0x1,%xmm6,%xmm6
movupd %xmm6,-0x10(%rsi,%rax,8)
subpd  %xmm2,%xmm0
movapd %xmm4,%xmm2
xorpd  %xmm8,%xmm2
unpcklpd %xmm0,%xmm2
movapd %xmm13,%xmm3
unpcklpd %xmm13,%xmm3
mulpd  %xmm0,%xmm3
shufpd $0x1,%xmm4,%xmm0
mulpd  %xmm0,%xmm2
addpd  %xmm2,%xmm3
shufpd $0x1,%xmm3,%xmm3
movupd %xmm3,-0x10(%rsi,%rcx,8)
movsd  (%rsi,%rdx,8),%xmm0
movsd  0x8(%rsi,%rdx,8),%xmm3
movsd  (%rsi,%rax,8),%xmm1
movsd  0x8(%rsi,%rax,8),%xmm2
movapd %xmm0,%xmm5
addsd  %xmm1,%xmm5
movapd %xmm3,%xmm6
xorpd  %xmm8,%xmm6
subsd  %xmm2,%xmm6
subsd  %xmm1,%xmm0
subsd  %xmm3,%xmm2
movsd  (%rsi,%rdi,8),%xmm10
movsd  0x8(%rsi,%rdi,8),%xmm12
movsd  (%rsi,%rcx,8),%xmm7
movsd  0x8(%rsi,%rcx,8),%xmm9
movapd %xmm10,%xmm3
addsd  %xmm7,%xmm3
movapd %xmm12,%xmm1
addsd  %xmm9,%xmm1
subsd  %xmm7,%xmm10
subsd  %xmm9,%xmm12
movapd %xmm5,%xmm7
addsd  %xmm3,%xmm7
movsd  %xmm7,(%rsi,%rdx,8)
movapd %xmm6,%xmm7
subsd  %xmm1,%xmm7
movsd  %xmm7,0x8(%rsi,%rdx,8)
subsd  %xmm3,%xmm5
movsd  %xmm5,(%rsi,%rdi,8)
addsd  %xmm6,%xmm1
movsd  %xmm1,0x8(%rsi,%rdi,8)
movapd %xmm0,%xmm3
addsd  %xmm12,%xmm3
movapd %xmm2,%xmm1
addsd  %xmm10,%xmm1
movapd %xmm3,%xmm5
subsd  %xmm1,%xmm5
mulsd  %xmm11,%xmm5
movsd  %xmm5,(%rsi,%rax,8)
addsd  %xmm3,%xmm1
mulsd  %xmm11,%xmm1
movsd  %xmm1,0x8(%rsi,%rax,8)
subsd  %xmm12,%xmm0
subsd  %xmm10,%xmm2
xorpd  %xmm8,%xmm11
movapd %xmm2,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm11,%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
subsd  %xmm0,%xmm2
mulsd  %xmm11,%xmm2
movsd  %xmm2,0x8(%rsi,%rcx,8)
movsd  0x10(%rsi,%rdx,8),%xmm3
movsd  0x10(%rsi,%rax,8),%xmm1
movsd  0x18(%rsi,%rax,8),%xmm0
movsd  0x18(%rsi,%rdx,8),%xmm2
movapd %xmm2,%xmm7
xorpd  %xmm8,%xmm7
subsd  %xmm0,%xmm7
unpcklpd %xmm3,%xmm0
addsd  %xmm1,%xmm3
unpcklpd %xmm1,%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%rsi,%rdi,8),%xmm2
movupd 0x10(%rsi,%rcx,8),%xmm1
movapd %xmm2,%xmm5
addpd  %xmm1,%xmm5
movapd %xmm3,%xmm6
addsd  %xmm5,%xmm6
subsd  %xmm5,%xmm3
unpckhpd %xmm5,%xmm5
subpd  %xmm1,%xmm2
movsd  %xmm6,0x10(%rsi,%rdx,8)
movapd %xmm7,%xmm1
subsd  %xmm5,%xmm1
movsd  %xmm1,0x18(%rsi,%rdx,8)
movsd  %xmm3,0x10(%rsi,%rdi,8)
addsd  %xmm7,%xmm5
movsd  %xmm5,0x18(%rsi,%rdi,8)
movapd %xmm0,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm15,%xmm3
xorpd  %xmm8,%xmm3
unpcklpd %xmm1,%xmm15
unpcklpd %xmm14,%xmm14
mulpd  %xmm1,%xmm14
shufpd $0x1,%xmm3,%xmm1
mulpd  %xmm15,%xmm1
addpd  %xmm1,%xmm14
shufpd $0x1,%xmm14,%xmm14
movupd %xmm14,0x10(%rsi,%rax,8)
subpd  %xmm2,%xmm0
xorpd  %xmm13,%xmm8
unpcklpd %xmm0,%xmm8
unpcklpd %xmm4,%xmm4
mulpd  %xmm0,%xmm4
shufpd $0x1,%xmm13,%xmm0
mulpd  %xmm0,%xmm8
addpd  %xmm8,%xmm4
shufpd $0x1,%xmm4,%xmm4
movupd %xmm4,0x10(%rsi,%rcx,8)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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