#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 cftmdl1(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):
<cftmdl1>:
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
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
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
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%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
addsd  -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
subsd  -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
subsd  -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
addsd  -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  0x1ca2(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x1c8d(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
cvtsi2sdl -0x30(%rbp),%xmm1
movsd  0x1c65(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0x1c4c(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x48(%rbp)
movsd  0x1c35(%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  0x1c0a(%rip),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0x1bf5(%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  0x1b75(%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    14c4 <cftmdl1+0x3a4>
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    2344 <cftmdl1+0x1224>
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
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -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
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%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
addsd  -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
subsd  -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
subsd  -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
addsd  -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
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -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
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%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
addsd  -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
subsd  -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
subsd  -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
addsd  -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
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -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
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%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
addsd  -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
subsd  -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
subsd  -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
addsd  -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
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -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
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%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)
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
addsd  -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
subsd  -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
subsd  -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
addsd  -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
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
movsd  -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    14cd <cftmdl1+0x3ad>
mov    -0x18(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jne    235a <cftmdl1+0x123a>
jmp    24f7 <cftmdl1+0x13d7>
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  0xc86(%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  0xba1(%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    149f <cftmdl1+0x37f>
movsd  0xb21(%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
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -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
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%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)
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
addsd  -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
subsd  -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
subsd  -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
addsd  -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
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -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
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%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
addsd  -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
subsd  -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
subsd  -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
addsd  -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
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -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
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
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
addsd  -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
subsd  -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
subsd  -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
addsd  -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):
<cftmdl1>:
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),%eax
lea    0x0(,%r14,4),%ecx
lea    (%rax,%rax,2),%edx
movslq %ecx,%rcx
movupd (%rsi),%xmm0
movupd (%rsi,%rcx,8),%xmm1
movapd %xmm0,%xmm2
addpd  %xmm1,%xmm2
subpd  %xmm1,%xmm0
movslq %eax,%rbp
movslq %edx,%rax
movupd (%rsi,%rbp,8),%xmm1
movupd (%rsi,%rax,8),%xmm3
movapd %xmm1,%xmm4
addpd  %xmm3,%xmm4
subpd  %xmm3,%xmm1
shufpd $0x1,%xmm1,%xmm1
movapd %xmm2,%xmm3
addpd  %xmm4,%xmm3
movupd %xmm3,(%rsi)
subpd  %xmm4,%xmm2
movupd %xmm2,(%rsi,%rbp,8)
movapd %xmm0,%xmm2
subpd  %xmm1,%xmm2
addpd  %xmm0,%xmm1
movapd %xmm1,%xmm0
movsd  %xmm2,%xmm0
movupd %xmm0,(%rsi,%rcx,8)
shufpd $0x2,%xmm2,%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
movupd %xmm1,(%rsi,%rax,8)
movsd  0xe36(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x50(%rsp)
movapd %xmm1,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rsp)
call   1040 <cos@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rsp),%xmm0
call   1030 <sin@plt>
movapd %xmm0,%xmm11
addsd  %xmm0,%xmm0
movsd  0xdfe(%rip),%xmm9
mulsd  %xmm0,%xmm9
movsd  0x8(%rsp),%xmm10
mulsd  %xmm10,%xmm9
movapd %xmm9,%xmm8
mulsd  %xmm11,%xmm8
addsd  %xmm10,%xmm8
mulsd  %xmm10,%xmm9
addsd  %xmm11,%xmm9
movapd %xmm9,%xmm1
addsd  %xmm9,%xmm1
mov    %r14,0x20(%rsp)
lea    -0x4(%r14),%r15d
movapd 0xde0(%rip),%xmm15
movapd %xmm0,0x10(%rsp)
xorpd  %xmm15,%xmm0
movapd %xmm0,0x70(%rsp)
movapd %xmm1,0xb0(%rsp)
movapd %xmm1,%xmm0
xorpd  %xmm15,%xmm0
movapd %xmm0,0x60(%rsp)
movapd %xmm11,%xmm0
xorpd  %xmm15,%xmm0
movapd %xmm0,0x80(%rsp)
lea    -0x2(%rbp),%rax
mov    %rax,0x48(%rsp)
mov    %rbp,%r12
shl    $0x4,%r12
add    $0xfffffffffffffff0,%r12
lea    0x0(,%rbp,2),%rax
add    %rbp,%rax
lea    -0x10(,%rax,8),%rax
ff
mov    %rax,0x40(%rsp)
mov    %rbp,%r14
shl    $0x5,%r14
add    $0xfffffffffffffff0,%r14
lea    0x4(%rbp),%rax
mov    %rax,0x38(%rsp)
lea    0x4(,%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  0xd15(%rip),%xmm14
movapd %xmm11,0x90(%rsp)
movapd %xmm14,%xmm12
xorpd  %xmm5,%xmm5
xchg   %ax,%ax
lea    0x80(%rax),%r8d
cmp    %r15d,%r8d
mov    %r8d,%r13d
cmovg  %r15d,%r13d
lea    0x2(%rax),%ecx
cmp    %r13d,%ecx
jge    173c <cftmdl1+0x61c>
movslq %eax,%r10
lea    0x2(%r10),%rdx
movslq %r13d,%r9
mov    0x48(%rsp),%r11
sub    %r10,%r11
lea    0x0(,%r10,8),%rcx
mov    %r12,%rbp
sub    %rcx,%rbp
mov    0x40(%rsp),%rax
sub    %rcx,%rax
mov    %r14,%rsi
sub    %rcx,%rsi
mov    0x38(%rsp),%rcx
add    %r10,%rcx
mov    0x30(%rsp),%rdi
add    %r10,%rdi
add    0x28(%rsp),%r10
movapd 0x70(%rsp),%xmm2
mulsd  %xmm11,%xmm2
addsd  %xmm2,%xmm14
movapd 0x10(%rsp),%xmm2
mulsd  %xmm10,%xmm2
movapd 0x60(%rsp),%xmm7
mulsd  %xmm9,%xmm7
addsd  %xmm2,%xmm0
addsd  %xmm7,%xmm12
movupd (%rbx,%rdx,8),%xmm3
movupd -0x10(%rbx,%rdi,8),%xmm2
movapd %xmm3,%xmm1
addpd  %xmm2,%xmm1
subpd  %xmm2,%xmm3
movupd -0x10(%rbx,%rcx,8),%xmm7
movupd -0x10(%rbx,%r10,8),%xmm2
movapd %xmm7,%xmm4
addpd  %xmm2,%xmm4
subpd  %xmm2,%xmm7
shufpd $0x1,%xmm7,%xmm7
movapd %xmm1,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm2,(%rbx,%rdx,8)
subpd  %xmm4,%xmm1
movapd %xmm3,%xmm2
subpd  %xmm7,%xmm2
addpd  %xmm3,%xmm7
movupd %xmm1,-0x10(%rbx,%rcx,8)
movapd %xmm7,%xmm1
movapd %xmm2,%xmm3
movsd  %xmm7,%xmm3
movapd %xmm9,%xmm4
unpcklpd %xmm7,%xmm4
movapd %xmm11,%xmm6
xorpd  %xmm15,%xmm6
shufpd $0x1,%xmm11,%xmm1
unpcklpd %xmm2,%xmm6
mulpd  %xmm1,%xmm6
movapd %xmm10,%xmm1
unpcklpd %xmm10,%xmm1
movsd  %xmm2,%xmm7
mulpd  %xmm7,%xmm1
movapd 0xb0(%rsp),%xmm13
movapd %xmm13,%xmm7
addpd  %xmm6,%xmm1
movapd %xmm9,%xmm6
xorpd  %xmm15,%xmm6
mulsd  %xmm8,%xmm7
shufpd $0x1,%xmm6,%xmm2
mulpd  %xmm4,%xmm2
movapd %xmm8,%xmm4
unpcklpd %xmm8,%xmm4
movupd %xmm1,-0x10(%rbx,%rdi,8)
mulpd  %xmm3,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm4,-0x10(%rbx,%r10,8)
addsd  %xmm7,%xmm5
movupd 0x10(%rbx,%rdx,8),%xmm1
movupd (%rbx,%rdi,8),%xmm2
movapd %xmm1,%xmm3
addpd  %xmm2,%xmm3
subpd  %xmm2,%xmm1
movupd (%rbx,%rcx,8),%xmm7
movupd (%rbx,%r10,8),%xmm2
movapd %xmm7,%xmm4
subpd  %xmm2,%xmm7
addpd  %xmm2,%xmm4
shufpd $0x1,%xmm7,%xmm7
movapd %xmm3,%xmm2
addpd  %xmm4,%xmm2
subpd  %xmm4,%xmm3
movupd %xmm2,0x10(%rbx,%rdx,8)
movupd %xmm3,(%rbx,%rcx,8)
movapd %xmm1,%xmm2
subpd  %xmm7,%xmm2
addpd  %xmm1,%xmm7
movapd %xmm7,%xmm1
movapd %xmm2,%xmm3
movapd %xmm5,%xmm4
movsd  %xmm7,%xmm3
unpcklpd %xmm7,%xmm4
movsd  %xmm2,%xmm7
movapd %xmm0,%xmm6
xorpd  %xmm15,%xmm6
shufpd $0x1,%xmm0,%xmm1
unpcklpd %xmm2,%xmm6
mulpd  %xmm1,%xmm6
movapd %xmm14,%xmm1
unpcklpd %xmm14,%xmm1
mulpd  %xmm7,%xmm1
movapd %xmm5,%xmm7
xorpd  %xmm15,%xmm7
shufpd $0x1,%xmm7,%xmm2
mulpd  %xmm4,%xmm2
movapd %xmm12,%xmm4
addpd  %xmm6,%xmm1
unpcklpd %xmm12,%xmm4
mulpd  %xmm3,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm1,(%rbx,%rdi,8)
movupd %xmm4,(%rbx,%r10,8)
movupd (%rbx,%r11,8),%xmm1
movupd (%rbx,%rax,1),%xmm2
movapd %xmm1,%xmm3
addpd  %xmm2,%xmm3
subpd  %xmm2,%xmm1
movupd (%rbx,%rbp,1),%xmm7
movupd (%rbx,%rsi,1),%xmm2
movapd %xmm7,%xmm4
addpd  %xmm2,%xmm4
subpd  %xmm2,%xmm7
shufpd $0x1,%xmm7,%xmm7
movapd %xmm3,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm2,(%rbx,%r11,8)
subpd  %xmm4,%xmm3
movapd %xmm1,%xmm2
subpd  %xmm7,%xmm2
addpd  %xmm1,%xmm7
movupd %xmm3,(%rbx,%rbp,1)
movapd %xmm7,%xmm1
movapd %xmm2,%xmm3
movsd  %xmm7,%xmm3
movapd %xmm8,%xmm4
unpcklpd %xmm7,%xmm4
movapd %xmm10,%xmm6
xorpd  %xmm15,%xmm6
shufpd $0x1,%xmm10,%xmm1
unpcklpd %xmm2,%xmm6
mulpd  %xmm1,%xmm6
movapd %xmm11,%xmm1
unpcklpd %xmm11,%xmm1
movsd  %xmm2,%xmm7
mulpd  %xmm7,%xmm1
movapd %xmm8,%xmm7
xorpd  %xmm15,%xmm7
shufpd $0x1,%xmm7,%xmm2
addpd  %xmm6,%xmm1
mulpd  %xmm4,%xmm2
movapd %xmm9,%xmm4
unpcklpd %xmm9,%xmm4
mulpd  %xmm3,%xmm4
movupd %xmm1,(%rbx,%rax,1)
addpd  %xmm2,%xmm4
movupd %xmm4,(%rbx,%rsi,1)
movupd -0x10(%rbx,%r11,8),%xmm1
movupd -0x10(%rbx,%rax,1),%xmm2
movapd %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd -0x10(%rbx,%rbp,1),%xmm7
movupd -0x10(%rbx,%rsi,1),%xmm4
subpd  %xmm2,%xmm1
movapd %xmm7,%xmm2
addpd  %xmm4,%xmm2
subpd  %xmm4,%xmm7
shufpd $0x1,%xmm7,%xmm7
movapd %xmm3,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm4,-0x10(%rbx,%r11,8)
subpd  %xmm2,%xmm3
movapd %xmm1,%xmm2
subpd  %xmm7,%xmm2
movupd %xmm3,-0x10(%rbx,%rbp,1)
addpd  %xmm1,%xmm7
movapd %xmm14,%xmm1
xorpd  %xmm15,%xmm1
movapd %xmm7,%xmm3
movapd %xmm2,%xmm4
movsd  %xmm7,%xmm4
movapd %xmm12,%xmm6
unpcklpd %xmm7,%xmm6
shufpd $0x1,%xmm14,%xmm3
unpcklpd %xmm2,%xmm1
mulpd  %xmm3,%xmm1
movapd %xmm0,%xmm3
movsd  %xmm2,%xmm7
unpcklpd %xmm3,%xmm3
mulpd  %xmm7,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm3,-0x10(%rbx,%rax,1)
movapd %xmm12,%xmm1
xorpd  %xmm15,%xmm1
shufpd $0x1,%xmm1,%xmm2
mulpd  %xmm6,%xmm2
movapd %xmm5,%xmm1
unpcklpd %xmm5,%xmm1
mulpd  %xmm4,%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,-0x10(%rbx,%rsi,1)
movapd 0x70(%rsp),%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm1,%xmm10
movapd 0x10(%rsp),%xmm1
mulsd  %xmm14,%xmm1
addsd  %xmm1,%xmm11
movapd 0x60(%rsp),%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm1,%xmm8
mulsd  %xmm12,%xmm13
addsd  %xmm13,%xmm9
add    $0x4,%rdx
add    $0xfffffffffffffffc,%r11
add    $0xffffffffffffffe0,%rbp
add    $0xffffffffffffffe0,%rax
add    $0xffffffffffffffe0,%rsi
add    $0x4,%rcx
add    $0x4,%rdi
add    $0x4,%r10
cmp    %r9,%rdx
jl     1370 <cftmdl1+0x250>
cmp    %r8d,%r15d
jle    181d <cftmdl1+0x6fd>
xorps  %xmm0,%xmm0
cvtsi2sd %r13d,%xmm0
mulsd  0x50(%rsp),%xmm0
movsd  %xmm0,0x58(%rsp)
call   1040 <cos@plt>
movapd %xmm0,0xa0(%rsp)
movsd  0x58(%rsp),%xmm0
call   1030 <sin@plt>
movapd 0xa0(%rsp),%xmm14
movapd 0x8ab(%rip),%xmm15
movapd %xmm0,%xmm5
movsd  0x897(%rip),%xmm3
mulsd  %xmm3,%xmm5
mulsd  %xmm14,%xmm5
movapd %xmm5,%xmm12
mulsd  %xmm0,%xmm12
addsd  %xmm14,%xmm12
mulsd  %xmm14,%xmm5
addsd  %xmm0,%xmm5
movsd  0x8(%rsp),%xmm10
movapd %xmm10,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm0,%xmm2
mulsd  0x80(%rsp),%xmm2
mulsd  %xmm14,%xmm10
addsd  %xmm2,%xmm10
movapd %xmm14,%xmm11
mulsd  0x90(%rsp),%xmm11
addsd  %xmm1,%xmm11
movapd %xmm11,%xmm9
mulsd  %xmm3,%xmm9
mulsd  %xmm10,%xmm9
movapd %xmm9,%xmm8
mulsd  %xmm11,%xmm8
addsd  %xmm10,%xmm8
mulsd  %xmm10,%xmm9
addsd  %xmm11,%xmm9
mov    %r13d,%eax
jmp    1310 <cftmdl1+0x1f0>
mov    0x20(%rsp),%rdx
lea    (%rdx,%rdx,2),%ecx
lea    (%rdx,%rdx,4),%eax
lea    0x0(,%rdx,8),%edi
sub    %edx,%edi
movslq %edx,%rdx
movupd -0x10(%rbx,%rdx,8),%xmm1
cltq
movupd -0x10(%rbx,%rax,8),%xmm0
movapd %xmm1,%xmm2
addpd  %xmm0,%xmm2
subpd  %xmm0,%xmm1
movslq %ecx,%rsi
movupd -0x10(%rbx,%rsi,8),%xmm0
movslq %edi,%rcx
movupd -0x10(%rbx,%rcx,8),%xmm3
movapd %xmm0,%xmm4
addpd  %xmm3,%xmm4
subpd  %xmm3,%xmm0
shufpd $0x1,%xmm0,%xmm0
movapd %xmm2,%xmm3
addpd  %xmm4,%xmm3
movupd %xmm3,-0x10(%rbx,%rdx,8)
subpd  %xmm4,%xmm2
movupd %xmm2,-0x10(%rbx,%rsi,8)
movapd %xmm1,%xmm2
subpd  %xmm0,%xmm2
addpd  %xmm1,%xmm0
movapd %xmm0,%xmm1
movapd %xmm2,%xmm3
movsd  %xmm0,%xmm3
movapd %xmm9,%xmm4
unpcklpd %xmm0,%xmm4
movsd  %xmm2,%xmm0
movapd %xmm11,%xmm5
xorpd  %xmm15,%xmm5
shufpd $0x1,%xmm11,%xmm1
unpcklpd %xmm2,%xmm5
mulpd  %xmm1,%xmm5
movapd %xmm10,%xmm1
unpcklpd %xmm10,%xmm1
mulpd  %xmm0,%xmm1
addpd  %xmm5,%xmm1
movupd %xmm1,-0x10(%rbx,%rax,8)
movapd %xmm9,%xmm0
xorpd  %xmm15,%xmm0
shufpd $0x1,%xmm0,%xmm2
mulpd  %xmm4,%xmm2
movapd %xmm8,%xmm0
unpcklpd %xmm8,%xmm0
mulpd  %xmm3,%xmm0
addpd  %xmm2,%xmm0
movupd %xmm0,-0x10(%rbx,%rcx,8)
movupd (%rbx,%rdx,8),%xmm2
movupd (%rbx,%rax,8),%xmm0
movapd %xmm2,%xmm5
addpd  %xmm0,%xmm5
subpd  %xmm0,%xmm2
movupd (%rbx,%rsi,8),%xmm0
movupd (%rbx,%rcx,8),%xmm1
movapd %xmm0,%xmm3
subpd  %xmm1,%xmm0
movapd %xmm0,%xmm6
unpckhpd %xmm0,%xmm6
movapd %xmm2,%xmm4
subsd  %xmm6,%xmm4
addsd  %xmm2,%xmm6
unpckhpd %xmm2,%xmm2
addpd  %xmm1,%xmm3
movapd %xmm5,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm1,(%rbx,%rdx,8)
subpd  %xmm3,%xmm5
movupd %xmm5,(%rbx,%rsi,8)
movapd %xmm2,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm4,%xmm3
subsd  %xmm1,%xmm3
movsd  0x69d(%rip),%xmm5
mulsd  %xmm5,%xmm3
movsd  %xmm3,(%rbx,%rax,8)
addsd  %xmm4,%xmm1
mulsd  %xmm5,%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
subsd  %xmm0,%xmm2
movapd %xmm2,%xmm0
addsd  %xmm6,%xmm0
movsd  0x67a(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
subsd  %xmm6,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%rbx,%rcx,8)
movupd 0x10(%rbx,%rdx,8),%xmm1
movupd 0x10(%rbx,%rax,8),%xmm0
movapd %xmm1,%xmm2
addpd  %xmm0,%xmm2
subpd  %xmm0,%xmm1
movupd 0x10(%rbx,%rsi,8),%xmm0
movupd 0x10(%rbx,%rcx,8),%xmm3
movapd %xmm0,%xmm4
addpd  %xmm3,%xmm4
subpd  %xmm3,%xmm0
shufpd $0x1,%xmm0,%xmm0
movapd %xmm2,%xmm3
addpd  %xmm4,%xmm3
movupd %xmm3,0x10(%rbx,%rdx,8)
subpd  %xmm4,%xmm2
movupd %xmm2,0x10(%rbx,%rsi,8)
movapd %xmm1,%xmm2
subpd  %xmm0,%xmm2
addpd  %xmm1,%xmm0
movapd %xmm0,%xmm1
shufpd $0x1,%xmm10,%xmm1
xorpd  %xmm15,%xmm10
movapd %xmm2,%xmm3
movsd  %xmm0,%xmm3
xorpd  %xmm8,%xmm15
unpcklpd %xmm0,%xmm8
movsd  %xmm2,%xmm0
unpcklpd %xmm2,%xmm10
mulpd  %xmm1,%xmm10
unpcklpd %xmm11,%xmm11
mulpd  %xmm0,%xmm11
addpd  %xmm10,%xmm11
movupd %xmm11,0x10(%rbx,%rax,8)
shufpd $0x1,%xmm15,%xmm2
mulpd  %xmm8,%xmm2
unpcklpd %xmm9,%xmm9
mulpd  %xmm3,%xmm9
addpd  %xmm2,%xmm9
movupd %xmm9,0x10(%rbx,%rcx,8)
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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