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    22c0 <cftb1st+0x11c0>
mov    -0x30(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x30(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x1c(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
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
movsd  %xmm0,-0x98(%rbp)
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe8(%rbp),%xmm0
ff
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
ff
subsd  -0x40(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
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    $0x48,%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
movapd %xmm0,0x10(%rsp)
movsd  0x10(%rdx),%xmm3
movsd  0x18(%rdx),%xmm1
mov    %rbp,-0x50(%rsp)
lea    -0x2(%rbp),%eax
movslq %eax,%r10
cmp    $0x28,%edi
movsd  %xmm1,-0x68(%rsp)
movsd  %xmm3,-0x70(%rsp)
jl     1886 <cftb1st+0x786>
lea    (%r14,%r14,2),%eax
movslq %eax,%rdi
lea    0x3(%rdi),%rax
mov    %rax,-0x60(%rsp)
lea    0x3(%rbx),%r15
add    $0xffffffffffffffff,%rbx
mov    %rbx,-0x58(%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,-0x48(%rsp)
lea    (%rax,%rax,2),%rax
add    $0x20,%rax
movsd  0xd9e(%rip),%xmm5
xorpd  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rsp)
mov    $0x3,%r9d
xorpd  %xmm14,%xmm14
movapd %xmm5,%xmm9
nopl   0x0(%rax)
movsd  %xmm5,-0x78(%rsp)
movsd  -0x8(%rsi,%r9,8),%xmm13
movsd  (%rsi,%r9,8),%xmm0
movsd  (%rsi,%r11,1),%xmm1
movsd  0x10(%rsi,%r11,1),%xmm8
movapd %xmm13,%xmm5
addsd  %xmm1,%xmm5
movapd %xmm0,%xmm12
movapd 0xd3a(%rip),%xmm2
xorpd  %xmm2,%xmm12
movapd %xmm2,%xmm6
movsd  (%rsi,%r15,8),%xmm7
mov    %r15,%r13
mov    %r15,-0x38(%rsp)
subsd  %xmm7,%xmm12
subsd  %xmm1,%xmm13
subsd  %xmm0,%xmm7
movsd  0x8(%rsi,%r9,8),%xmm3
movsd  0x10(%rsi,%r9,8),%xmm0
movapd %xmm0,%xmm2
xorpd  %xmm6,%xmm2
movsd  0x18(%rsi,%r11,1),%xmm6
subsd  %xmm6,%xmm2
unpcklpd %xmm3,%xmm6
addsd  %xmm8,%xmm3
unpcklpd %xmm8,%xmm0
subpd  %xmm0,%xmm6
movsd  -0x10(%rsi,%rax,1),%xmm8
movsd  (%rsi,%r14,8),%xmm0
movsd  0x8(%rsi,%r14,8),%xmm10
movapd %xmm0,%xmm1
addsd  %xmm8,%xmm1
mov    -0x60(%rsp),%r15
movsd  (%rsi,%r15,8),%xmm15
subsd  %xmm8,%xmm0
movsd  %xmm0,-0x40(%rsp)
movapd %xmm10,%xmm11
addsd  %xmm15,%xmm11
subsd  %xmm15,%xmm10
movupd 0x10(%rsi,%r14,8),%xmm4
movupd (%rsi,%rax,1),%xmm15
movapd %xmm4,%xmm0
addpd  %xmm15,%xmm0
subpd  %xmm15,%xmm4
movapd %xmm4,0x20(%rsp)
movapd %xmm5,%xmm15
addsd  %xmm1,%xmm15
mov    -0x48(%rsp),%rdx
movsd  0x8(%rdx,%r9,8),%xmm4
movaps %xmm4,-0x10(%rsp)
movsd  0x10(%rdx,%r9,8),%xmm4
movaps %xmm4,-0x30(%rsp)
movsd  0x18(%rdx,%r9,8),%xmm4
movaps %xmm4,-0x20(%rsp)
movsd  0x20(%rdx,%r9,8),%xmm4
movaps %xmm4,(%rsp)
movsd  %xmm15,-0x8(%rsi,%r9,8)
movapd %xmm12,%xmm4
subsd  %xmm11,%xmm4
movsd  %xmm4,(%rsi,%r9,8)
movapd %xmm3,%xmm4
addsd  %xmm0,%xmm4
movsd  %xmm4,0x8(%rsi,%r9,8)
subsd  %xmm0,%xmm3
unpckhpd %xmm0,%xmm0
movapd %xmm2,%xmm4
subsd  %xmm0,%xmm4
movsd  %xmm4,0x10(%rsi,%r9,8)
subsd  %xmm1,%xmm5
movsd  %xmm5,(%rsi,%r14,8)
addsd  %xmm12,%xmm11
movsd  %xmm11,0x8(%rsi,%r14,8)
movsd  %xmm3,0x10(%rsi,%r14,8)
movapd -0x10(%rsp),%xmm5
addsd  %xmm5,%xmm9
movsd  -0x70(%rsp),%xmm1
mulsd  %xmm1,%xmm9
movapd -0x30(%rsp),%xmm11
addsd  %xmm11,%xmm14
mulsd  %xmm1,%xmm14
addsd  %xmm2,%xmm0
movsd  %xmm0,0x18(%rsi,%r14,8)
movapd %xmm13,%xmm1
addsd  %xmm10,%xmm1
movapd %xmm7,%xmm2
movsd  -0x40(%rsp),%xmm0
addsd  %xmm0,%xmm2
movapd %xmm9,%xmm3
mulsd  %xmm2,%xmm3
mulsd  %xmm14,%xmm2
movapd %xmm9,%xmm4
mulsd  %xmm1,%xmm4
subsd  %xmm2,%xmm4
movsd  %xmm4,(%rsi,%r11,1)
mulsd  %xmm14,%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,(%rsi,%r13,8)
movapd %xmm6,%xmm1
movapd 0x20(%rsp),%xmm12
addpd  %xmm12,%xmm1
movapd %xmm11,%xmm3
movapd %xmm11,%xmm2
movapd 0xb4a(%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  -0x78(%rsp),%xmm3
movapd -0x20(%rsp),%xmm5
addsd  %xmm5,%xmm3
movsd  -0x68(%rsp),%xmm2
mulsd  %xmm2,%xmm3
movapd %xmm3,%xmm11
movapd (%rsp),%xmm3
movsd  -0x80(%rsp),%xmm15
subsd  %xmm3,%xmm15
mulsd  %xmm2,%xmm15
movsd  %xmm15,-0x80(%rsp)
addpd  %xmm1,%xmm4
movapd %xmm3,%xmm1
xorpd  %xmm8,%xmm1
movapd %xmm1,%xmm2
movapd %xmm1,0x30(%rsp)
shufpd $0x1,%xmm4,%xmm4
movupd %xmm4,0x10(%rsi,%r11,1)
subsd  %xmm10,%xmm13
subsd  %xmm0,%xmm7
movapd %xmm15,%xmm0
mulsd  %xmm7,%xmm0
movsd  %xmm11,-0x78(%rsp)
movapd %xmm11,%xmm1
mulsd  %xmm13,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,-0x10(%rsi,%rax,1)
mulsd  %xmm15,%xmm13
mulsd  %xmm11,%xmm7
subsd  %xmm13,%xmm7
movsd  %xmm7,(%rsi,%r15,8)
subpd  %xmm12,%xmm6
movapd %xmm3,%xmm0
unpcklpd %xmm6,%xmm0
movapd %xmm5,%xmm1
unpcklpd %xmm5,%xmm1
mulpd  %xmm6,%xmm1
shufpd $0x1,%xmm2,%xmm6
mulpd  %xmm0,%xmm6
addpd  %xmm6,%xmm1
shufpd $0x1,%xmm1,%xmm1
movupd %xmm1,(%rsi,%rax,1)
movsd  -0x8(%rsi,%r12,8),%xmm5
movsd  (%rsi,%r8,1),%xmm0
movapd %xmm5,%xmm4
addsd  %xmm0,%xmm4
movsd  (%rsi,%r12,8),%xmm1
movapd %xmm1,%xmm11
xorpd  %xmm8,%xmm11
movsd  (%rsi,%rdi,8),%xmm7
subsd  %xmm7,%xmm11
subsd  %xmm0,%xmm5
subsd  %xmm1,%xmm7
movsd  -0x8(%rsi,%r8,1),%xmm6
movsd  -0x10(%rsi,%r12,8),%xmm0
movapd %xmm0,%xmm13
xorpd  %xmm8,%xmm13
subsd  %xmm6,%xmm13
movsd  -0x18(%rsi,%r12,8),%xmm2
unpcklpd %xmm2,%xmm6
movsd  -0x10(%rsi,%r8,1),%xmm1
addsd  %xmm1,%xmm2
unpcklpd %xmm1,%xmm0
subpd  %xmm0,%xmm6
movsd  (%rsi,%rbx,1),%xmm12
movsd  (%rsi,%rcx,1),%xmm0
movapd %xmm12,%xmm8
addsd  %xmm0,%xmm8
subsd  %xmm0,%xmm12
mov    %r10,%rdx
mov    %rbp,%r13
sar    $0x1d,%r13
or     $0x8,%r13
mov    -0x58(%rsp),%r10
movsd  (%rsi,%r10,8),%xmm10
movsd  (%rsi,%r13,1),%xmm0
movapd %xmm10,%xmm3
addsd  %xmm0,%xmm3
subsd  %xmm0,%xmm10
movupd -0x10(%rsi,%rbx,1),%xmm15
movupd -0x10(%rsi,%rcx,1),%xmm0
movapd %xmm15,%xmm1
addpd  %xmm0,%xmm1
subpd  %xmm0,%xmm15
movapd %xmm4,%xmm0
addsd  %xmm8,%xmm0
movsd  %xmm0,-0x8(%rsi,%r12,8)
movapd %xmm11,%xmm0
subsd  %xmm3,%xmm0
movsd  %xmm0,(%rsi,%r12,8)
movapd %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rsi,%r12,8)
subsd  %xmm1,%xmm2
unpckhpd %xmm1,%xmm1
movapd %xmm13,%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x10(%rsi,%r12,8)
subsd  %xmm8,%xmm4
movsd  %xmm4,(%rsi,%rbx,1)
addsd  %xmm11,%xmm3
movsd  %xmm3,(%rsi,%r10,8)
movsd  %xmm2,-0x10(%rsi,%rbx,1)
addsd  %xmm13,%xmm1
movapd -0x30(%rsp),%xmm13
movsd  %xmm1,-0x8(%rsi,%rbx,1)
movapd %xmm5,%xmm0
addsd  %xmm10,%xmm0
movapd %xmm7,%xmm1
addsd  %xmm12,%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm9,%xmm2
mulsd  %xmm14,%xmm1
mulsd  %xmm0,%xmm14
subsd  %xmm2,%xmm14
movsd  %xmm14,(%rsi,%r8,1)
mulsd  %xmm9,%xmm0
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rdi,8)
movapd %xmm6,%xmm0
addpd  %xmm15,%xmm0
movapd -0x10(%rsp),%xmm4
movapd %xmm4,%xmm1
movapd 0x8ba(%rip),%xmm8
xorpd  %xmm8,%xmm1
movapd %xmm4,%xmm2
unpcklpd %xmm0,%xmm2
movapd %xmm13,%xmm3
unpcklpd %xmm13,%xmm3
mulpd  %xmm0,%xmm3
shufpd $0x1,%xmm1,%xmm0
mulpd  %xmm2,%xmm0
addpd  %xmm0,%xmm3
shufpd $0x1,%xmm3,%xmm3
movupd %xmm3,-0x10(%rsi,%r8,1)
subsd  %xmm10,%xmm5
subsd  %xmm12,%xmm7
movapd -0x20(%rsp),%xmm2
movsd  -0x80(%rsp),%xmm3
movapd %xmm3,%xmm0
mulsd  %xmm5,%xmm0
movsd  -0x78(%rsp),%xmm1
mulsd  %xmm1,%xmm5
mulsd  %xmm7,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rsi,%rcx,1)
mulsd  %xmm3,%xmm7
subsd  %xmm5,%xmm7
movsd  %xmm7,(%rsi,%r13,1)
subpd  %xmm15,%xmm6
movapd %xmm4,%xmm15
movapd %xmm2,%xmm0
xorpd  %xmm8,%xmm0
unpcklpd %xmm6,%xmm0
movapd (%rsp),%xmm1
unpcklpd %xmm1,%xmm1
mulpd  %xmm6,%xmm1
shufpd $0x1,%xmm2,%xmm6
mulpd  %xmm6,%xmm0
subpd  %xmm1,%xmm0
shufpd $0x1,%xmm0,%xmm0
movupd %xmm0,-0x10(%rsi,%rcx,1)
movapd 0x30(%rsp),%xmm0
lea    0x4(%r9),%r13
add    $0x4,%r15
mov    %r15,-0x60(%rsp)
mov    -0x38(%rsp),%r15
add    $0x4,%r15
add    $0xfffffffffffffffc,%r10
mov    %r10,-0x58(%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
movsd  %xmm0,-0x80(%rsp)
movapd %xmm2,%xmm5
movapd %xmm13,%xmm14
movapd %xmm4,%xmm9
mov    %rdx,%r10
cmp    %rdx,%r9
mov    %r13,%r9
jl     1290 <cftb1st+0x190>
jmp    189d <cftb1st+0x79d>
xorpd  %xmm13,%xmm13
movsd  0x77c(%rip),%xmm15
movapd %xmm15,%xmm2
xorpd  %xmm0,%xmm0
movapd 0x10(%rsp),%xmm11
addsd  %xmm11,%xmm15
movsd  -0x70(%rsp),%xmm1
mulsd  %xmm1,%xmm15
addsd  %xmm11,%xmm13
mulsd  %xmm1,%xmm13
subsd  %xmm11,%xmm2
movsd  -0x68(%rsp),%xmm1
mulsd  %xmm1,%xmm2
subsd  %xmm11,%xmm0
mulsd  %xmm1,%xmm0
mov    -0x50(%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 %xmm0,%xmm14
movsd  -0x10(%rsi,%rax,8),%xmm0
movsd  -0x8(%rsi,%rax,8),%xmm1
movslq %edx,%rdx
movsd  -0x8(%rsi,%rdx,8),%xmm5
movapd 0x6eb(%rip),%xmm8
movapd %xmm5,%xmm4
xorpd  %xmm8,%xmm4
subsd  %xmm1,%xmm4
unpcklpd %xmm3,%xmm1
addsd  %xmm0,%xmm3
unpcklpd %xmm0,%xmm5
subpd  %xmm5,%xmm1
movslq %ecx,%rdi
movupd -0x10(%rsi,%rdi,8),%xmm0
movslq %ebp,%rcx
movupd -0x10(%rsi,%rcx,8),%xmm5
movapd %xmm0,%xmm6
addpd  %xmm5,%xmm6
movapd %xmm3,%xmm7
addsd  %xmm6,%xmm7
subsd  %xmm6,%xmm3
unpckhpd %xmm6,%xmm6
subpd  %xmm5,%xmm0
movsd  %xmm7,(%rsi,%r10,8)
movapd %xmm4,%xmm5
subsd  %xmm6,%xmm5
movsd  %xmm5,-0x8(%rsi,%rdx,8)
movsd  %xmm3,-0x10(%rsi,%rdi,8)
addsd  %xmm4,%xmm6
movsd  %xmm6,-0x8(%rsi,%rdi,8)
movapd %xmm1,%xmm3
addpd  %xmm0,%xmm3
movapd %xmm13,%xmm4
xorpd  %xmm8,%xmm4
movapd %xmm13,%xmm5
unpcklpd %xmm3,%xmm5
movapd %xmm15,%xmm6
unpcklpd %xmm15,%xmm6
mulpd  %xmm3,%xmm6
shufpd $0x1,%xmm4,%xmm3
mulpd  %xmm5,%xmm3
addpd  %xmm3,%xmm6
shufpd $0x1,%xmm6,%xmm6
movupd %xmm6,-0x10(%rsi,%rax,8)
subpd  %xmm0,%xmm1
movapd %xmm14,%xmm0
xorpd  %xmm8,%xmm0
unpcklpd %xmm1,%xmm0
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
mulpd  %xmm1,%xmm3
shufpd $0x1,%xmm14,%xmm1
mulpd  %xmm1,%xmm0
addpd  %xmm0,%xmm3
shufpd $0x1,%xmm3,%xmm3
movupd %xmm3,-0x10(%rsi,%rcx,8)
movsd  (%rsi,%rdx,8),%xmm12
movsd  0x8(%rsi,%rdx,8),%xmm3
movsd  (%rsi,%rax,8),%xmm4
movsd  0x8(%rsi,%rax,8),%xmm1
movapd %xmm12,%xmm5
addsd  %xmm4,%xmm5
movapd %xmm3,%xmm6
xorpd  %xmm8,%xmm6
subsd  %xmm1,%xmm6
subsd  %xmm4,%xmm12
subsd  %xmm3,%xmm1
movsd  (%rsi,%rdi,8),%xmm10
movsd  0x8(%rsi,%rdi,8),%xmm0
movsd  (%rsi,%rcx,8),%xmm7
movsd  0x8(%rsi,%rcx,8),%xmm9
movapd %xmm10,%xmm3
addsd  %xmm7,%xmm3
movapd %xmm0,%xmm4
addsd  %xmm9,%xmm4
subsd  %xmm7,%xmm10
subsd  %xmm9,%xmm0
movapd %xmm5,%xmm7
addsd  %xmm3,%xmm7
movsd  %xmm7,(%rsi,%rdx,8)
movapd %xmm6,%xmm7
subsd  %xmm4,%xmm7
movsd  %xmm7,0x8(%rsi,%rdx,8)
subsd  %xmm3,%xmm5
movsd  %xmm5,(%rsi,%rdi,8)
addsd  %xmm6,%xmm4
movsd  %xmm4,0x8(%rsi,%rdi,8)
movapd %xmm12,%xmm3
addsd  %xmm0,%xmm3
movapd %xmm1,%xmm4
addsd  %xmm10,%xmm4
movapd %xmm3,%xmm5
subsd  %xmm4,%xmm5
mulsd  %xmm11,%xmm5
movsd  %xmm5,(%rsi,%rax,8)
addsd  %xmm3,%xmm4
mulsd  %xmm11,%xmm4
movsd  %xmm4,0x8(%rsi,%rax,8)
subsd  %xmm0,%xmm12
subsd  %xmm10,%xmm1
xorpd  %xmm8,%xmm11
movapd %xmm1,%xmm0
addsd  %xmm12,%xmm0
mulsd  %xmm11,%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
subsd  %xmm12,%xmm1
mulsd  %xmm11,%xmm1
movsd  %xmm1,0x8(%rsi,%rcx,8)
movsd  0x10(%rsi,%rdx,8),%xmm3
movsd  0x10(%rsi,%rax,8),%xmm0
movsd  0x18(%rsi,%rax,8),%xmm1
movsd  0x18(%rsi,%rdx,8),%xmm5
movapd %xmm5,%xmm4
xorpd  %xmm8,%xmm4
subsd  %xmm1,%xmm4
unpcklpd %xmm3,%xmm1
addsd  %xmm0,%xmm3
unpcklpd %xmm0,%xmm5
subpd  %xmm5,%xmm1
movupd 0x10(%rsi,%rdi,8),%xmm7
movupd 0x10(%rsi,%rcx,8),%xmm0
movapd %xmm7,%xmm5
addpd  %xmm0,%xmm5
movapd %xmm3,%xmm6
addsd  %xmm5,%xmm6
subsd  %xmm5,%xmm3
unpckhpd %xmm5,%xmm5
subpd  %xmm0,%xmm7
movsd  %xmm6,0x10(%rsi,%rdx,8)
movapd %xmm4,%xmm0
subsd  %xmm5,%xmm0
movsd  %xmm0,0x18(%rsi,%rdx,8)
movsd  %xmm3,0x10(%rsi,%rdi,8)
addsd  %xmm4,%xmm5
movsd  %xmm5,0x18(%rsi,%rdi,8)
movapd %xmm1,%xmm0
addpd  %xmm7,%xmm0
movapd %xmm15,%xmm3
xorpd  %xmm8,%xmm3
unpcklpd %xmm0,%xmm15
unpcklpd %xmm13,%xmm13
mulpd  %xmm0,%xmm13
shufpd $0x1,%xmm3,%xmm0
mulpd  %xmm15,%xmm0
addpd  %xmm0,%xmm13
shufpd $0x1,%xmm13,%xmm13
movupd %xmm13,0x10(%rsi,%rax,8)
subpd  %xmm7,%xmm1
xorpd  %xmm2,%xmm8
unpcklpd %xmm1,%xmm8
unpcklpd %xmm14,%xmm14
mulpd  %xmm1,%xmm14
shufpd $0x1,%xmm2,%xmm1
mulpd  %xmm1,%xmm8
addpd  %xmm8,%xmm14
shufpd $0x1,%xmm14,%xmm14
movupd %xmm14,0x10(%rsi,%rcx,8)
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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