#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double cos(double);
double sin(double);
void cftb1st(int n, double *a) {
  int i, i0, j, j0, j1, j2, j3, m, mh;
  double ew, w1r, w1i, wk1r, wk1i, wk3r, wk3i, wd1r, wd1i, wd3r, wd3i, ss1, ss3;
  double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
  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;
  wd1r = 1;
  wd1i = 0;
  wd3r = 1;
  wd3i = 0;
  ew = ((double)1.570796326794896619231321691639751442098584) / m;
  w1r = cos(2 * ew);
  w1i = sin(2 * ew);
  wk1r = w1r;
  wk1i = w1i;
  ss1 = 2 * w1i;
  wk3i = 2 * ss1 * wk1r;
  wk3r = wk1r - wk3i * wk1i;
  wk3i = wk1i - wk3i * wk1r;
  ss3 = 2 * wk3i;
  i = 0;
  for (;;) {
    i0 = i + 4 * 32;
    if (i0 > mh - 4) {
      i0 = mh - 4;
    }
    for (j = i + 2; j < i0; j += 4) {
      wd1r -= ss1 * wk1i;
      wd1i += ss1 * wk1r;
      wd3r -= ss3 * wk3i;
      wd3i += ss3 * wk3r;
      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];
      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[j] = x0r + x2r;
      a[j + 1] = x0i - x2i;
      a[j1] = x0r - x2r;
      a[j1 + 1] = x0i + x2i;
      x0r = x1r + x3i;
      x0i = x1i + x3r;
      a[j2] = wk1r * x0r - wk1i * x0i;
      a[j2 + 1] = wk1r * x0i + wk1i * x0r;
      x0r = x1r - x3i;
      x0i = x1i - x3r;
      a[j3] = wk3r * x0r + wk3i * x0i;
      a[j3 + 1] = wk3r * x0i - wk3i * x0r;
      x0r = a[j + 2] + a[j2 + 2];
      x0i = -a[j + 3] - a[j2 + 3];
      x1r = a[j + 2] - a[j2 + 2];
      x1i = -a[j + 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[j + 2] = x0r + x2r;
      a[j + 3] = x0i - x2i;
      a[j1 + 2] = x0r - x2r;
      a[j1 + 3] = x0i + x2i;
      x0r = x1r + x3i;
      x0i = x1i + x3r;
      a[j2 + 2] = wd1r * x0r - wd1i * x0i;
      a[j2 + 3] = wd1r * x0i + wd1i * x0r;
      x0r = x1r - x3i;
      x0i = x1i - x3r;
      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];
      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] = wk1i * x0r - wk1r * x0i;
      a[j2 + 1] = wk1i * x0i + wk1r * x0r;
      x0r = x1r - x3i;
      x0i = x1i - x3r;
      a[j3] = wk3i * x0r + wk3r * x0i;
      a[j3 + 1] = wk3i * x0i - wk3r * x0r;
      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] = wd1i * x0r - wd1r * x0i;
      a[j2 - 1] = wd1i * x0i + wd1r * x0r;
      x0r = x1r - x3i;
      x0i = x1i - x3r;
      a[j3 - 2] = wd3i * x0r + wd3r * x0i;
      a[j3 - 1] = wd3i * x0i - wd3r * x0r;
      wk1r -= ss1 * wd1i;
      wk1i += ss1 * wd1r;
      wk3r -= ss3 * wd3i;
      wk3i += ss3 * wd3r;
    }
    if (i0 == mh - 4) {
      break;
    }
    wd1r = cos(ew * i0);
    wd1i = sin(ew * i0);
    wd3i = 4 * wd1i * wd1r;
    wd3r = wd1r - wd3i * wd1i;
    wd3i = wd1i - wd3i * wd1r;
    wk1r = w1r * wd1r - w1i * wd1i;
    wk1i = w1r * wd1i + w1i * wd1r;
    wk3i = 4 * wk1i * wk1r;
    wk3r = wk1r - wk3i * wk1i;
    wk3i = wk1i - wk3i * wk1r;
    i = i0;
  }
  wd1r = ((double)0.707106781186547524400844362104849039284835);
  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] = wd1r * (x0r - x0i);
  a[j2 + 1] = wd1r * (x0i + x0r);
  x0r = x1r - x3i;
  x0i = x1i - x3r;
  a[j3] = -wd1r * (x0r + x0i);
  a[j3 + 1] = -wd1r * (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    $0xe0,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x4(%rbp),%eax
sar    $0x3,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x30(%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,-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
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%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,-0xc0(%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,-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
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%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,-0xd8(%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,-0xe0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0xe0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc0(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
subsd  -0xe0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc0(%rbp),%xmm0
ff
subsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x2c74(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x2c5f(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
cvtsi2sdl -0x30(%rbp),%xmm1
movsd  0x2c37(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0x2c1e(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x48(%rbp)
movsd  0x2c07(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0x2bdc(%rip),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0x2bc7(%rip),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0x2b47(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
add    $0x80,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jle    14f2 <cftb1st+0x3d2>
mov    -0x34(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    242a <cftb1st+0x130a>
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x1c(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x30(%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,-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
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%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,-0xb8(%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,-0xc0(%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,-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
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%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,-0xd8(%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,-0xe0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0xb0(%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  -0xb0(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0xa8(%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  -0xb8(%rbp),%xmm0
ff
subsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
subsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0xb0(%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  -0xb0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0xa8(%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)
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,-0xa8(%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,-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
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%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,-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
addsd  (%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
addsd  (%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
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%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,-0xe0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0xb0(%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  -0xb0(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0xa8(%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  -0xb8(%rbp),%xmm0
ff
subsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
subsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0xb0(%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  -0xb0(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0xa8(%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    -0x30(%rbp),%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x30(%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,-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
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%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,-0xb8(%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,-0xc0(%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,-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
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%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,-0xd8(%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,-0xe0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0xb0(%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  -0xb0(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0xa8(%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  -0xb8(%rbp),%xmm0
ff
subsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
subsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0xb0(%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  -0xb0(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0xa8(%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)
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,-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
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%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,-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
addsd  (%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
addsd  (%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
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%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,-0xe0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0xb0(%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  -0xb0(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0xa8(%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  -0xb8(%rbp),%xmm0
ff
subsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
subsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
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  -0xb0(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0xa8(%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)
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x1c(%rbp)
jmp    14fb <cftb1st+0x3db>
mov    -0x18(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jne    2440 <cftb1st+0x1320>
jmp    25dd <cftb1st+0x14bd>
movsd  -0x40(%rbp),%xmm0
cvtsi2sdl -0x18(%rbp),%xmm1
mulsd  %xmm1,%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0x40(%rbp),%xmm0
cvtsi2sdl -0x18(%rbp),%xmm1
mulsd  %xmm1,%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  0x1ba0(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x78(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0x1abb(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    14cd <cftb1st+0x3ad>
movsd  0x1a3b(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x30(%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,-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
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%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,-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
addsd  (%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
addsd  (%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
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%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,-0xe0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0xb0(%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  -0xb0(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0xa8(%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  -0xb8(%rbp),%xmm0
ff
subsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
subsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0xb0(%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  -0xb0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0xa8(%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,-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
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%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,-0xb8(%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,-0xc0(%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,-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
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%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,-0xd8(%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,-0xe0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm1
ff
subsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
addsd  -0xa8(%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  -0xb8(%rbp),%xmm0
ff
subsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
subsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0xa8(%rbp),%xmm1
ff
addsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
subsd  -0xa8(%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,-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
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%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,-0xb8(%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,-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
addsd  (%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
addsd  (%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
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%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,-0xe0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0xb0(%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  -0xb0(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0xa8(%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  -0xb8(%rbp),%xmm0
ff
subsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
subsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0xb0(%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  -0xb0(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0xa8(%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    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cftb1st>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    %rsi,%rbx
mov    %edi,%r14d
sar    $0x3,%r14d
lea    (%r14,%r14,1),%ecx
lea    0x0(,%r14,4),%eax
lea    (%rcx,%rcx,2),%edx
cltq
movsd  (%rsi),%xmm1
movq   0x8(%rsi),%xmm2
movdqa %xmm2,%xmm0
pxor   0xe9f(%rip),%xmm0
movupd (%rsi,%rax,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 %ecx,%rbp
movslq %edx,%rcx
movupd (%rsi,%rbp,8),%xmm1
movupd (%rsi,%rcx,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,%rbp,8)
movapd %xmm0,%xmm2
addpd  %xmm1,%xmm2
shufpd $0x1,%xmm2,%xmm2
movupd %xmm2,(%rsi,%rax,8)
subpd  %xmm1,%xmm0
shufpd $0x1,%xmm0,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
movupd %xmm0,(%rsi,%rcx,8)
movsd  0xe1b(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x50(%rsp)
addsd  %xmm0,%xmm0
movsd  %xmm0,0x10(%rsp)
call   1040 <cos@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rsp),%xmm0
call   1030 <sin@plt>
movapd 0xdd8(%rip),%xmm14
movapd %xmm0,%xmm11
movapd %xmm0,%xmm2
addsd  %xmm0,%xmm2
movsd  0xdda(%rip),%xmm9
mulsd  %xmm2,%xmm9
movsd  0x8(%rsp),%xmm10
mulsd  %xmm10,%xmm9
movapd %xmm9,%xmm8
mulsd  %xmm0,%xmm8
addsd  %xmm10,%xmm8
mulsd  %xmm10,%xmm9
addsd  %xmm0,%xmm9
movapd %xmm9,%xmm3
addsd  %xmm9,%xmm3
mov    %r14,0x20(%rsp)
lea    -0x4(%r14),%r13d
movapd %xmm2,0x10(%rsp)
xorpd  %xmm14,%xmm2
movapd %xmm3,%xmm4
xorpd  %xmm14,%xmm4
xorpd  %xmm14,%xmm0
movapd %xmm0,0x90(%rsp)
lea    -0x1(%rbp),%rax
mov    %rax,0x48(%rsp)
mov    %rbp,%r12
shl    $0x4,%r12
add    $0xffffffffffffffe0,%r12
lea    0x0(,%rbp,2),%rax
add    %rbp,%rax
lea    -0x20(,%rax,8),%rax
ff
mov    %rax,0x40(%rsp)
mov    %rbp,%r14
shl    $0x5,%r14
add    $0xfffffffffffffff0,%r14
lea    0x2(%rbp),%rax
mov    %rax,0x38(%rsp)
lea    0x2(,%rbp,1),%rax
add    %rbp,%rax
mov    %rax,0x30(%rsp)
lea    0x4(,%rbp,2),%rax
add    %rbp,%rax
mov    %rax,0x28(%rsp)
xor    %eax,%eax
xorpd  %xmm0,%xmm0
movsd  0xd14(%rip),%xmm15
movapd %xmm11,0xa0(%rsp)
movapd %xmm15,%xmm12
xorpd  %xmm13,%xmm13
movapd %xmm3,0x80(%rsp)
movapd %xmm2,0x70(%rsp)
movapd %xmm4,0x60(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x80(%rax),%r8d
cmp    %r13d,%r8d
mov    %r8d,%r15d
cmovg  %r13d,%r15d
lea    0x2(%rax),%ecx
cmp    %r15d,%ecx
jge    1830 <cftb1st+0x710>
movslq %eax,%r10
lea    0x2(%r10),%rdx
movslq %r15d,%r9
mov    0x48(%rsp),%rdi
sub    %r10,%rdi
lea    0x0(,%r10,8),%rcx
mov    %r12,%rbp
sub    %rcx,%rbp
mov    0x40(%rsp),%rax
sub    %rcx,%rax
mov    %r14,%r11
sub    %rcx,%r11
mov    0x38(%rsp),%rcx
add    %r10,%rcx
mov    0x30(%rsp),%rsi
add    %r10,%rsi
add    0x28(%rsp),%r10
movapd %xmm2,%xmm1
mulsd  %xmm11,%xmm1
addsd  %xmm1,%xmm15
movapd 0x10(%rsp),%xmm1
mulsd  %xmm10,%xmm1
movapd %xmm4,%xmm2
mulsd  %xmm9,%xmm2
addsd  %xmm1,%xmm0
addsd  %xmm2,%xmm12
movapd %xmm3,%xmm2
mulsd  %xmm8,%xmm2
movsd  (%rbx,%rdx,8),%xmm1
addsd  %xmm2,%xmm13
movsd  (%rbx,%rsi,8),%xmm2
movsd  0x8(%rbx,%rsi,8),%xmm7
movsd  0x8(%rbx,%rdx,8),%xmm4
movapd %xmm4,%xmm3
xorpd  %xmm14,%xmm3
subsd  %xmm7,%xmm3
unpcklpd %xmm1,%xmm7
unpcklpd %xmm2,%xmm4
addsd  %xmm2,%xmm1
movupd (%rbx,%rcx,8),%xmm5
movupd -0x10(%rbx,%r10,8),%xmm6
movapd %xmm5,%xmm2
addpd  %xmm6,%xmm2
subpd  %xmm4,%xmm7
movapd %xmm1,%xmm4
addsd  %xmm2,%xmm4
subsd  %xmm2,%xmm1
subpd  %xmm6,%xmm5
unpckhpd %xmm2,%xmm2
movsd  %xmm4,(%rbx,%rdx,8)
movapd %xmm3,%xmm4
subsd  %xmm2,%xmm4
movsd  %xmm4,0x8(%rbx,%rdx,8)
movsd  %xmm1,(%rbx,%rcx,8)
addsd  %xmm3,%xmm2
movapd %xmm7,%xmm1
addpd  %xmm5,%xmm1
movapd %xmm11,%xmm3
xorpd  %xmm14,%xmm3
movapd %xmm11,%xmm4
movsd  %xmm2,0x8(%rbx,%rcx,8)
unpcklpd %xmm1,%xmm4
movapd %xmm10,%xmm2
unpcklpd %xmm10,%xmm2
mulpd  %xmm1,%xmm2
shufpd $0x1,%xmm3,%xmm1
mulpd  %xmm4,%xmm1
subpd  %xmm5,%xmm7
movapd %xmm9,%xmm3
xorpd  %xmm14,%xmm3
addpd  %xmm1,%xmm2
unpcklpd %xmm7,%xmm3
movapd %xmm8,%xmm1
unpcklpd %xmm8,%xmm1
mulpd  %xmm7,%xmm1
shufpd $0x1,%xmm2,%xmm2
shufpd $0x1,%xmm9,%xmm7
mulpd  %xmm7,%xmm3
addpd  %xmm3,%xmm1
movupd %xmm2,(%rbx,%rsi,8)
shufpd $0x1,%xmm1,%xmm1
movupd %xmm1,-0x10(%rbx,%r10,8)
movsd  0x10(%rbx,%rdx,8),%xmm1
movsd  0x10(%rbx,%rsi,8),%xmm3
movsd  0x18(%rbx,%rsi,8),%xmm7
movsd  0x18(%rbx,%rdx,8),%xmm4
movapd %xmm4,%xmm5
xorpd  %xmm14,%xmm5
subsd  %xmm7,%xmm5
unpcklpd %xmm1,%xmm7
unpcklpd %xmm3,%xmm4
movupd 0x10(%rbx,%rcx,8),%xmm2
subpd  %xmm4,%xmm7
movupd (%rbx,%r10,8),%xmm4
movapd %xmm2,%xmm6
addpd  %xmm4,%xmm6
subpd  %xmm4,%xmm2
addsd  %xmm3,%xmm1
movapd %xmm1,%xmm3
addsd  %xmm6,%xmm3
subsd  %xmm6,%xmm1
unpckhpd %xmm6,%xmm6
movsd  %xmm3,0x10(%rbx,%rdx,8)
movapd %xmm5,%xmm3
subsd  %xmm6,%xmm3
movsd  %xmm3,0x18(%rbx,%rdx,8)
addsd  %xmm5,%xmm6
movsd  %xmm1,0x10(%rbx,%rcx,8)
movsd  %xmm6,0x18(%rbx,%rcx,8)
movapd %xmm7,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm0,%xmm3
xorpd  %xmm14,%xmm3
movapd %xmm0,%xmm4
movapd %xmm15,%xmm5
unpcklpd %xmm1,%xmm4
unpcklpd %xmm15,%xmm5
mulpd  %xmm1,%xmm5
shufpd $0x1,%xmm3,%xmm1
mulpd  %xmm4,%xmm1
subpd  %xmm2,%xmm7
movapd %xmm13,%xmm2
xorpd  %xmm14,%xmm2
unpcklpd %xmm7,%xmm2
movapd %xmm12,%xmm3
addpd  %xmm1,%xmm5
unpcklpd %xmm12,%xmm3
mulpd  %xmm7,%xmm3
shufpd $0x1,%xmm13,%xmm7
shufpd $0x1,%xmm5,%xmm5
mulpd  %xmm7,%xmm2
addpd  %xmm2,%xmm3
shufpd $0x1,%xmm3,%xmm3
movupd %xmm5,0x10(%rbx,%rsi,8)
movupd %xmm3,(%rbx,%r10,8)
movsd  -0x8(%rbx,%rdi,8),%xmm1
movsd  0x10(%rbx,%rax,1),%xmm2
movsd  0x18(%rbx,%rax,1),%xmm7
movsd  (%rbx,%rdi,8),%xmm3
movapd %xmm3,%xmm4
xorpd  %xmm14,%xmm4
subsd  %xmm7,%xmm4
unpcklpd %xmm1,%xmm7
addsd  %xmm2,%xmm1
unpcklpd %xmm2,%xmm3
movupd 0x10(%rbx,%rbp,1),%xmm2
subpd  %xmm3,%xmm7
movupd (%rbx,%r11,1),%xmm3
movapd %xmm2,%xmm5
addpd  %xmm3,%xmm5
subpd  %xmm3,%xmm2
movapd %xmm1,%xmm3
addsd  %xmm5,%xmm3
subsd  %xmm5,%xmm1
unpckhpd %xmm5,%xmm5
movsd  %xmm3,-0x8(%rbx,%rdi,8)
movapd %xmm4,%xmm3
subsd  %xmm5,%xmm3
movsd  %xmm3,(%rbx,%rdi,8)
movsd  %xmm1,0x10(%rbx,%rbp,1)
addsd  %xmm4,%xmm5
movapd %xmm7,%xmm1
movsd  %xmm5,0x18(%rbx,%rbp,1)
addpd  %xmm2,%xmm1
movapd %xmm10,%xmm3
xorpd  %xmm14,%xmm3
movapd %xmm10,%xmm4
movapd %xmm11,%xmm5
unpcklpd %xmm11,%xmm5
unpcklpd %xmm1,%xmm4
mulpd  %xmm1,%xmm5
shufpd $0x1,%xmm3,%xmm1
mulpd  %xmm4,%xmm1
addpd  %xmm1,%xmm5
subpd  %xmm2,%xmm7
movapd %xmm8,%xmm1
xorpd  %xmm14,%xmm1
unpcklpd %xmm7,%xmm1
movapd %xmm9,%xmm2
shufpd $0x1,%xmm5,%xmm5
unpcklpd %xmm9,%xmm2
mulpd  %xmm7,%xmm2
shufpd $0x1,%xmm8,%xmm7
movupd %xmm5,0x10(%rbx,%rax,1)
mulpd  %xmm7,%xmm1
addpd  %xmm1,%xmm2
shufpd $0x1,%xmm2,%xmm2
movupd %xmm2,(%rbx,%r11,1)
movsd  -0x18(%rbx,%rdi,8),%xmm1
movsd  (%rbx,%rax,1),%xmm2
movsd  -0x10(%rbx,%rdi,8),%xmm3
movsd  0x8(%rbx,%rax,1),%xmm7
movapd %xmm3,%xmm4
xorpd  %xmm14,%xmm4
subsd  %xmm7,%xmm4
unpcklpd %xmm1,%xmm7
addsd  %xmm2,%xmm1
unpcklpd %xmm2,%xmm3
movupd (%rbx,%rbp,1),%xmm2
movupd -0x10(%rbx,%r11,1),%xmm5
subpd  %xmm3,%xmm7
movapd %xmm2,%xmm3
addpd  %xmm5,%xmm3
subpd  %xmm5,%xmm2
movapd %xmm1,%xmm5
addsd  %xmm3,%xmm5
subsd  %xmm3,%xmm1
unpckhpd %xmm3,%xmm3
movsd  %xmm5,-0x18(%rbx,%rdi,8)
movapd %xmm4,%xmm5
subsd  %xmm3,%xmm5
movsd  %xmm5,-0x10(%rbx,%rdi,8)
movsd  %xmm1,(%rbx,%rbp,1)
addsd  %xmm4,%xmm3
movapd %xmm7,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm15,%xmm4
movsd  %xmm3,0x8(%rbx,%rbp,1)
xorpd  %xmm14,%xmm4
movapd %xmm15,%xmm3
unpcklpd %xmm1,%xmm3
movapd %xmm0,%xmm5
unpcklpd %xmm0,%xmm5
mulpd  %xmm1,%xmm5
shufpd $0x1,%xmm4,%xmm1
movapd 0x60(%rsp),%xmm4
mulpd  %xmm3,%xmm1
movapd 0x80(%rsp),%xmm3
subpd  %xmm2,%xmm7
movapd %xmm12,%xmm2
addpd  %xmm1,%xmm5
xorpd  %xmm14,%xmm2
unpcklpd %xmm7,%xmm2
movapd %xmm13,%xmm1
unpcklpd %xmm13,%xmm1
mulpd  %xmm7,%xmm1
shufpd $0x1,%xmm12,%xmm7
mulpd  %xmm7,%xmm2
shufpd $0x1,%xmm5,%xmm5
movupd %xmm5,(%rbx,%rax,1)
addpd  %xmm2,%xmm1
movapd 0x70(%rsp),%xmm2
shufpd $0x1,%xmm1,%xmm1
movupd %xmm1,-0x10(%rbx,%r11,1)
movapd %xmm2,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm1,%xmm10
movapd 0x10(%rsp),%xmm1
mulsd  %xmm15,%xmm1
addsd  %xmm1,%xmm11
movapd %xmm4,%xmm1
mulsd  %xmm13,%xmm1
addsd  %xmm1,%xmm8
movapd %xmm3,%xmm1
mulsd  %xmm12,%xmm1
addsd  %xmm1,%xmm9
add    $0x4,%rdx
add    $0xfffffffffffffffc,%rdi
add    $0xffffffffffffffe0,%rbp
add    $0xffffffffffffffe0,%rax
add    $0xffffffffffffffe0,%r11
add    $0x4,%rcx
add    $0x4,%rsi
add    $0x4,%r10
cmp    %r9,%rdx
jl     13a0 <cftb1st+0x280>
cmp    %r8d,%r13d
jle    1929 <cftb1st+0x809>
xorps  %xmm0,%xmm0
cvtsi2sd %r15d,%xmm0
mulsd  0x50(%rsp),%xmm0
movsd  %xmm0,0x58(%rsp)
call   1040 <cos@plt>
movapd %xmm0,0xb0(%rsp)
movsd  0x58(%rsp),%xmm0
call   1030 <sin@plt>
movapd 0xb0(%rsp),%xmm15
movapd 0x60(%rsp),%xmm4
movapd 0x80(%rsp),%xmm3
movapd 0x778(%rip),%xmm14
movapd %xmm0,%xmm13
movsd  0x7a3(%rip),%xmm5
mulsd  %xmm5,%xmm13
mulsd  %xmm15,%xmm13
movapd %xmm13,%xmm12
mulsd  %xmm0,%xmm12
addsd  %xmm15,%xmm12
mulsd  %xmm15,%xmm13
addsd  %xmm0,%xmm13
movsd  0x8(%rsp),%xmm10
movapd %xmm10,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm0,%xmm2
mulsd  0x90(%rsp),%xmm2
mulsd  %xmm15,%xmm10
addsd  %xmm2,%xmm10
movapd 0x70(%rsp),%xmm2
movapd %xmm15,%xmm11
mulsd  0xa0(%rsp),%xmm11
addsd  %xmm1,%xmm11
movapd %xmm11,%xmm9
mulsd  %xmm5,%xmm9
mulsd  %xmm10,%xmm9
movapd %xmm9,%xmm8
mulsd  %xmm11,%xmm8
addsd  %xmm10,%xmm8
mulsd  %xmm10,%xmm9
addsd  %xmm11,%xmm9
mov    %r15d,%eax
jmp    1340 <cftb1st+0x220>
mov    0x20(%rsp),%rdx
lea    (%rdx,%rdx,2),%eax
lea    (%rdx,%rdx,4),%ecx
lea    0x0(,%rdx,8),%edi
sub    %edx,%edi
movslq %edx,%rdx
movsd  -0x10(%rbx,%rdx,8),%xmm2
movslq %ecx,%rcx
movsd  -0x10(%rbx,%rcx,8),%xmm3
movsd  -0x8(%rbx,%rcx,8),%xmm0
movsd  -0x8(%rbx,%rdx,8),%xmm4
movapd %xmm4,%xmm1
xorpd  %xmm14,%xmm1
subsd  %xmm0,%xmm1
unpcklpd %xmm2,%xmm0
addsd  %xmm3,%xmm2
unpcklpd %xmm3,%xmm4
subpd  %xmm4,%xmm0
movslq %eax,%rsi
movupd -0x10(%rbx,%rsi,8),%xmm5
movslq %edi,%rax
movupd -0x10(%rbx,%rax,8),%xmm3
movapd %xmm5,%xmm4
addpd  %xmm3,%xmm4
movapd %xmm2,%xmm6
addsd  %xmm4,%xmm6
subsd  %xmm4,%xmm2
unpckhpd %xmm4,%xmm4
subpd  %xmm3,%xmm5
movsd  %xmm6,-0x10(%rbx,%rdx,8)
movapd %xmm1,%xmm3
subsd  %xmm4,%xmm3
movsd  %xmm3,-0x8(%rbx,%rdx,8)
movsd  %xmm2,-0x10(%rbx,%rsi,8)
addsd  %xmm1,%xmm4
movsd  %xmm4,-0x8(%rbx,%rsi,8)
movapd %xmm0,%xmm1
addpd  %xmm5,%xmm1
movapd %xmm11,%xmm2
xorpd  %xmm14,%xmm2
movapd %xmm11,%xmm3
unpcklpd %xmm1,%xmm3
movapd %xmm10,%xmm4
unpcklpd %xmm10,%xmm4
mulpd  %xmm1,%xmm4
shufpd $0x1,%xmm2,%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm1,%xmm4
shufpd $0x1,%xmm4,%xmm4
movupd %xmm4,-0x10(%rbx,%rcx,8)
subpd  %xmm5,%xmm0
movapd %xmm9,%xmm1
xorpd  %xmm14,%xmm1
unpcklpd %xmm0,%xmm1
movapd %xmm8,%xmm2
unpcklpd %xmm8,%xmm2
mulpd  %xmm0,%xmm2
shufpd $0x1,%xmm9,%xmm0
mulpd  %xmm0,%xmm1
addpd  %xmm1,%xmm2
shufpd $0x1,%xmm2,%xmm2
movupd %xmm2,-0x10(%rbx,%rax,8)
movsd  (%rbx,%rdx,8),%xmm0
movsd  0x8(%rbx,%rdx,8),%xmm1
movsd  (%rbx,%rcx,8),%xmm2
movsd  0x8(%rbx,%rcx,8),%xmm5
movapd %xmm0,%xmm3
addsd  %xmm2,%xmm3
movapd %xmm1,%xmm4
xorpd  %xmm14,%xmm4
subsd  %xmm5,%xmm4
subsd  %xmm2,%xmm0
subsd  %xmm1,%xmm5
movsd  (%rbx,%rsi,8),%xmm12
movsd  0x8(%rbx,%rsi,8),%xmm7
movsd  (%rbx,%rax,8),%xmm1
movsd  0x8(%rbx,%rax,8),%xmm13
movapd %xmm12,%xmm6
addsd  %xmm1,%xmm6
movapd %xmm7,%xmm2
addsd  %xmm13,%xmm2
subsd  %xmm1,%xmm12
subsd  %xmm13,%xmm7
movapd %xmm3,%xmm1
addsd  %xmm6,%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
movapd %xmm4,%xmm1
subsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%rbx,%rdx,8)
subsd  %xmm6,%xmm3
movsd  %xmm3,(%rbx,%rsi,8)
addsd  %xmm4,%xmm2
movsd  %xmm2,0x8(%rbx,%rsi,8)
movapd %xmm0,%xmm1
addsd  %xmm7,%xmm1
movapd %xmm5,%xmm2
addsd  %xmm12,%xmm2
movapd %xmm1,%xmm3
subsd  %xmm2,%xmm3
movsd  0x52e(%rip),%xmm4
mulsd  %xmm4,%xmm3
movsd  %xmm3,(%rbx,%rcx,8)
addsd  %xmm1,%xmm2
mulsd  %xmm4,%xmm2
movsd  %xmm2,0x8(%rbx,%rcx,8)
subsd  %xmm7,%xmm0
subsd  %xmm12,%xmm5
movapd %xmm5,%xmm1
addsd  %xmm0,%xmm1
movsd  0x506(%rip),%xmm2
mulsd  %xmm2,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
subsd  %xmm0,%xmm5
mulsd  %xmm2,%xmm5
movsd  %xmm5,0x8(%rbx,%rax,8)
movsd  0x10(%rbx,%rdx,8),%xmm1
movsd  0x10(%rbx,%rcx,8),%xmm2
movsd  0x18(%rbx,%rcx,8),%xmm0
movsd  0x18(%rbx,%rdx,8),%xmm3
movapd %xmm3,%xmm4
xorpd  %xmm14,%xmm4
subsd  %xmm0,%xmm4
unpcklpd %xmm1,%xmm0
addsd  %xmm2,%xmm1
unpcklpd %xmm2,%xmm3
subpd  %xmm3,%xmm0
movupd 0x10(%rbx,%rsi,8),%xmm2
movupd 0x10(%rbx,%rax,8),%xmm3
movapd %xmm2,%xmm5
addpd  %xmm3,%xmm5
movapd %xmm1,%xmm6
addsd  %xmm5,%xmm6
subsd  %xmm5,%xmm1
unpckhpd %xmm5,%xmm5
subpd  %xmm3,%xmm2
movsd  %xmm6,0x10(%rbx,%rdx,8)
movapd %xmm4,%xmm3
subsd  %xmm5,%xmm3
movsd  %xmm3,0x18(%rbx,%rdx,8)
movsd  %xmm1,0x10(%rbx,%rsi,8)
addsd  %xmm4,%xmm5
movsd  %xmm5,0x18(%rbx,%rsi,8)
movapd %xmm0,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm10,%xmm3
xorpd  %xmm14,%xmm3
unpcklpd %xmm1,%xmm10
unpcklpd %xmm11,%xmm11
mulpd  %xmm1,%xmm11
shufpd $0x1,%xmm3,%xmm1
mulpd  %xmm10,%xmm1
addpd  %xmm1,%xmm11
shufpd $0x1,%xmm11,%xmm11
movupd %xmm11,0x10(%rbx,%rcx,8)
subpd  %xmm2,%xmm0
xorpd  %xmm8,%xmm14
unpcklpd %xmm0,%xmm14
unpcklpd %xmm9,%xmm9
mulpd  %xmm0,%xmm9
shufpd $0x1,%xmm8,%xmm0
mulpd  %xmm0,%xmm14
addpd  %xmm14,%xmm9
shufpd $0x1,%xmm9,%xmm9
movupd %xmm9,0x10(%rbx,%rax,8)
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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