#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 cftmdl2(int n, double *a) {
  int i, i0, j, j0, j1, j2, j3, m, mh;
  double ew, w1r, w1i, wn4r, wk1r, wk1i, wk3r, wk3i, wl1r, wl1i, wl3r, wl3i,
      wd1r, wd1i, wd3r, wd3i, we1r, we1i, we3r, we3i, ss1, ss3;
  double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, y0r, y0i, y2r, y2i;
  mh = n >> 3;
  m = 2 * mh;
  wn4r = ((double)0.707106781186547524400844362104849039284835);
  j1 = m;
  j2 = j1 + m;
  j3 = j2 + m;
  x0r = a[0] - a[j2 + 1];
  x0i = a[1] + a[j2];
  x1r = a[0] + a[j2 + 1];
  x1i = a[1] - a[j2];
  x2r = a[j1] - a[j3 + 1];
  x2i = a[j1 + 1] + a[j3];
  x3r = a[j1] + a[j3 + 1];
  x3i = a[j1 + 1] - a[j3];
  y0r = wn4r * (x2r - x2i);
  y0i = wn4r * (x2i + x2r);
  a[0] = x0r + y0r;
  a[1] = x0i + y0i;
  a[j1] = x0r - y0r;
  a[j1 + 1] = x0i - y0i;
  y0r = wn4r * (x3r - x3i);
  y0i = wn4r * (x3i + x3r);
  a[j2] = x1r - y0i;
  a[j2 + 1] = x1i + y0r;
  a[j3] = x1r + y0i;
  a[j3 + 1] = x1i - y0r;
  wl1r = 1;
  wl1i = 0;
  wl3r = 1;
  wl3i = 0;
  we1r = wn4r;
  we1i = wn4r;
  we3r = -wn4r;
  we3i = -wn4r;
  ew = ((double)1.570796326794896619231321691639751442098584) / (2 * m);
  w1r = cos(2 * ew);
  w1i = sin(2 * ew);
  wk1r = w1r;
  wk1i = w1i;
  wd1r = wn4r * (w1r - w1i);
  wd1i = wn4r * (w1i + w1r);
  ss1 = 2 * w1i;
  wk3i = 2 * ss1 * wk1r;
  wk3r = wk1r - wk3i * wk1i;
  wk3i = wk1i - wk3i * wk1r;
  ss3 = 2 * wk3i;
  wd3r = -wn4r * (wk3r - wk3i);
  wd3i = -wn4r * (wk3i + wk3r);
  i = 0;
  for (;;) {
    i0 = i + 4 * 32;
    if (i0 > mh - 4) {
      i0 = mh - 4;
    }
    for (j = i + 2; j < i0; j += 4) {
      wl1r -= ss1 * wk1i;
      wl1i += ss1 * wk1r;
      wl3r -= ss3 * wk3i;
      wl3i += ss3 * wk3r;
      we1r -= ss1 * wd1i;
      we1i += ss1 * wd1r;
      we3r -= ss3 * wd3i;
      we3i += ss3 * wd3r;
      j1 = j + m;
      j2 = j1 + m;
      j3 = j2 + m;
      x0r = a[j] - a[j2 + 1];
      x0i = a[j + 1] + a[j2];
      x1r = a[j] + a[j2 + 1];
      x1i = a[j + 1] - a[j2];
      x2r = a[j1] - a[j3 + 1];
      x2i = a[j1 + 1] + a[j3];
      x3r = a[j1] + a[j3 + 1];
      x3i = a[j1 + 1] - a[j3];
      y0r = wk1r * x0r - wk1i * x0i;
      y0i = wk1r * x0i + wk1i * x0r;
      y2r = wd1r * x2r - wd1i * x2i;
      y2i = wd1r * x2i + wd1i * x2r;
      a[j] = y0r + y2r;
      a[j + 1] = y0i + y2i;
      a[j1] = y0r - y2r;
      a[j1 + 1] = y0i - y2i;
      y0r = wk3r * x1r + wk3i * x1i;
      y0i = wk3r * x1i - wk3i * x1r;
      y2r = wd3r * x3r + wd3i * x3i;
      y2i = wd3r * x3i - wd3i * x3r;
      a[j2] = y0r + y2r;
      a[j2 + 1] = y0i + y2i;
      a[j3] = y0r - y2r;
      a[j3 + 1] = y0i - y2i;
      x0r = a[j + 2] - a[j2 + 3];
      x0i = a[j + 3] + a[j2 + 2];
      x1r = a[j + 2] + a[j2 + 3];
      x1i = a[j + 3] - a[j2 + 2];
      x2r = a[j1 + 2] - a[j3 + 3];
      x2i = a[j1 + 3] + a[j3 + 2];
      x3r = a[j1 + 2] + a[j3 + 3];
      x3i = a[j1 + 3] - a[j3 + 2];
      y0r = wl1r * x0r - wl1i * x0i;
      y0i = wl1r * x0i + wl1i * x0r;
      y2r = we1r * x2r - we1i * x2i;
      y2i = we1r * x2i + we1i * x2r;
      a[j + 2] = y0r + y2r;
      a[j + 3] = y0i + y2i;
      a[j1 + 2] = y0r - y2r;
      a[j1 + 3] = y0i - y2i;
      y0r = wl3r * x1r + wl3i * x1i;
      y0i = wl3r * x1i - wl3i * x1r;
      y2r = we3r * x3r + we3i * x3i;
      y2i = we3r * x3i - we3i * x3r;
      a[j2 + 2] = y0r + y2r;
      a[j2 + 3] = y0i + y2i;
      a[j3 + 2] = y0r - y2r;
      a[j3 + 3] = y0i - y2i;
      j0 = m - j;
      j1 = j0 + m;
      j2 = j1 + m;
      j3 = j2 + m;
      x0r = a[j0] - a[j2 + 1];
      x0i = a[j0 + 1] + a[j2];
      x1r = a[j0] + a[j2 + 1];
      x1i = a[j0 + 1] - a[j2];
      x2r = a[j1] - a[j3 + 1];
      x2i = a[j1 + 1] + a[j3];
      x3r = a[j1] + a[j3 + 1];
      x3i = a[j1 + 1] - a[j3];
      y0r = wd1i * x0r - wd1r * x0i;
      y0i = wd1i * x0i + wd1r * x0r;
      y2r = wk1i * x2r - wk1r * x2i;
      y2i = wk1i * x2i + wk1r * x2r;
      a[j0] = y0r + y2r;
      a[j0 + 1] = y0i + y2i;
      a[j1] = y0r - y2r;
      a[j1 + 1] = y0i - y2i;
      y0r = wd3i * x1r + wd3r * x1i;
      y0i = wd3i * x1i - wd3r * x1r;
      y2r = wk3i * x3r + wk3r * x3i;
      y2i = wk3i * x3i - wk3r * x3r;
      a[j2] = y0r + y2r;
      a[j2 + 1] = y0i + y2i;
      a[j3] = y0r - y2r;
      a[j3 + 1] = y0i - y2i;
      x0r = a[j0 - 2] - a[j2 - 1];
      x0i = a[j0 - 1] + a[j2 - 2];
      x1r = a[j0 - 2] + a[j2 - 1];
      x1i = a[j0 - 1] - a[j2 - 2];
      x2r = a[j1 - 2] - a[j3 - 1];
      x2i = a[j1 - 1] + a[j3 - 2];
      x3r = a[j1 - 2] + a[j3 - 1];
      x3i = a[j1 - 1] - a[j3 - 2];
      y0r = we1i * x0r - we1r * x0i;
      y0i = we1i * x0i + we1r * x0r;
      y2r = wl1i * x2r - wl1r * x2i;
      y2i = wl1i * x2i + wl1r * x2r;
      a[j0 - 2] = y0r + y2r;
      a[j0 - 1] = y0i + y2i;
      a[j1 - 2] = y0r - y2r;
      a[j1 - 1] = y0i - y2i;
      y0r = we3i * x1r + we3r * x1i;
      y0i = we3i * x1i - we3r * x1r;
      y2r = wl3i * x3r + wl3r * x3i;
      y2i = wl3i * x3i - wl3r * x3r;
      a[j2 - 2] = y0r + y2r;
      a[j2 - 1] = y0i + y2i;
      a[j3 - 2] = y0r - y2r;
      a[j3 - 1] = y0i - y2i;
      wk1r -= ss1 * wl1i;
      wk1i += ss1 * wl1r;
      wk3r -= ss3 * wl3i;
      wk3i += ss3 * wl3r;
      wd1r -= ss1 * we1i;
      wd1i += ss1 * we1r;
      wd3r -= ss3 * we3i;
      wd3i += ss3 * we3r;
    }
    if (i0 == mh - 4) {
      break;
    }
    wl1r = cos(ew * i0);
    wl1i = sin(ew * i0);
    wl3i = 4 * wl1i * wl1r;
    wl3r = wl1r - wl3i * wl1i;
    wl3i = wl1i - wl3i * wl1r;
    we1r = wn4r * (wl1r - wl1i);
    we1i = wn4r * (wl1i + wl1r);
    we3r = -wn4r * (wl3r - wl3i);
    we3i = -wn4r * (wl3i + wl3r);
    wk1r = w1r * wl1r - w1i * wl1i;
    wk1i = w1r * wl1i + w1i * wl1r;
    wk3i = 4 * wk1i * wk1r;
    wk3r = wk1r - wk3i * wk1i;
    wk3i = wk1i - wk3i * wk1r;
    wd1r = wn4r * (wk1r - wk1i);
    wd1i = wn4r * (wk1i + wk1r);
    wd3r = -wn4r * (wk3r - wk3i);
    wd3i = -wn4r * (wk3i + wk3r);
    i = i0;
  }
  wl1r = ((double)0.923879532511286756128183189396788286822416);
  wl1i = ((double)0.382683432365089771728459984030398866761344);
  j0 = mh;
  j1 = j0 + m;
  j2 = j1 + m;
  j3 = j2 + m;
  x0r = a[j0 - 2] - a[j2 - 1];
  x0i = a[j0 - 1] + a[j2 - 2];
  x1r = a[j0 - 2] + a[j2 - 1];
  x1i = a[j0 - 1] - a[j2 - 2];
  x2r = a[j1 - 2] - a[j3 - 1];
  x2i = a[j1 - 1] + a[j3 - 2];
  x3r = a[j1 - 2] + a[j3 - 1];
  x3i = a[j1 - 1] - a[j3 - 2];
  y0r = wk1r * x0r - wk1i * x0i;
  y0i = wk1r * x0i + wk1i * x0r;
  y2r = wd1r * x2r - wd1i * x2i;
  y2i = wd1r * x2i + wd1i * x2r;
  a[j0 - 2] = y0r + y2r;
  a[j0 - 1] = y0i + y2i;
  a[j1 - 2] = y0r - y2r;
  a[j1 - 1] = y0i - y2i;
  y0r = wk3r * x1r + wk3i * x1i;
  y0i = wk3r * x1i - wk3i * x1r;
  y2r = wd3r * x3r + wd3i * x3i;
  y2i = wd3r * x3i - wd3i * x3r;
  a[j2 - 2] = y0r + y2r;
  a[j2 - 1] = y0i + y2i;
  a[j3 - 2] = y0r - y2r;
  a[j3 - 1] = y0i - y2i;
  x0r = a[j0] - a[j2 + 1];
  x0i = a[j0 + 1] + a[j2];
  x1r = a[j0] + a[j2 + 1];
  x1i = a[j0 + 1] - a[j2];
  x2r = a[j1] - a[j3 + 1];
  x2i = a[j1 + 1] + a[j3];
  x3r = a[j1] + a[j3 + 1];
  x3i = a[j1 + 1] - a[j3];
  y0r = wl1r * x0r - wl1i * x0i;
  y0i = wl1r * x0i + wl1i * x0r;
  y2r = wl1i * x2r - wl1r * x2i;
  y2i = wl1i * x2i + wl1r * x2r;
  a[j0] = y0r + y2r;
  a[j0 + 1] = y0i + y2i;
  a[j1] = y0r - y2r;
  a[j1 + 1] = y0i - y2i;
  y0r = wl1i * x1r - wl1r * x1i;
  y0i = wl1i * x1i + wl1r * x1r;
  y2r = wl1r * x3r - wl1i * x3i;
  y2i = wl1r * x3i + wl1i * x3r;
  a[j2] = y0r - y2r;
  a[j2 + 1] = y0i - y2i;
  a[j3] = y0r + y2r;
  a[j3 + 1] = y0i + y2i;
  x0r = a[j0 + 2] - a[j2 + 3];
  x0i = a[j0 + 3] + a[j2 + 2];
  x1r = a[j0 + 2] + a[j2 + 3];
  x1i = a[j0 + 3] - a[j2 + 2];
  x2r = a[j1 + 2] - a[j3 + 3];
  x2i = a[j1 + 3] + a[j3 + 2];
  x3r = a[j1 + 2] + a[j3 + 3];
  x3i = a[j1 + 3] - a[j3 + 2];
  y0r = wd1i * x0r - wd1r * x0i;
  y0i = wd1i * x0i + wd1r * x0r;
  y2r = wk1i * x2r - wk1r * x2i;
  y2i = wk1i * x2i + wk1r * x2r;
  a[j0 + 2] = y0r + y2r;
  a[j0 + 3] = y0i + y2i;
  a[j1 + 2] = y0r - y2r;
  a[j1 + 3] = y0i - y2i;
  y0r = wd3i * x1r + wd3r * x1i;
  y0i = wd3i * x1i - wd3r * x1r;
  y2r = wk3i * x3r + wk3r * x3i;
  y2i = wk3i * x3i - wk3r * x3r;
  a[j2 + 2] = y0r + y2r;
  a[j2 + 3] = y0i + y2i;
  a[j3 + 2] = y0r - y2r;
  a[j3 + 3] = y0i - y2i;
}


x86 assembly (clang, -O0):
<cftmdl2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%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)
movsd  0x2ecc(%rip),%xmm0
movsd  %xmm0,-0x58(%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
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%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,-0x110(%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
movslq -0x2c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%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,-0x120(%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
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x110(%rbp),%xmm1
ff
subsd  -0x118(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x118(%rbp),%xmm1
ff
addsd  -0x110(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
addsd  -0x130(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xf8(%rbp),%xmm0
ff
addsd  -0x138(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xf0(%rbp),%xmm0
ff
subsd  -0x130(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xf8(%rbp),%xmm0
ff
subsd  -0x138(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
movsd  -0x120(%rbp),%xmm1
ff
subsd  -0x128(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x128(%rbp),%xmm1
ff
addsd  -0x120(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
subsd  -0x138(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x108(%rbp),%xmm0
ff
addsd  -0x130(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x100(%rbp),%xmm0
ff
addsd  -0x138(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x108(%rbp),%xmm0
ff
subsd  -0x130(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x2c11(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x2bf9(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x30(%rbp),%eax
shl    $0x1,%eax
cvtsi2sd %eax,%xmm1
movsd  0x2b6a(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0x2b51(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x48(%rbp)
movsd  0x2b3a(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
subsd  -0x50(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
addsd  -0x48(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0x2ad9(%rip),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  0x2ac4(%rip),%xmm0
mulsd  -0xe0(%rbp),%xmm0
ff
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x60(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  -0x68(%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  -0x68(%rbp),%xmm1
movsd  -0x78(%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,-0x78(%rbp)
movsd  0x2a44(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x70(%rbp),%xmm1
subsd  -0x78(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x78(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%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    1659 <cftmdl2+0x539>
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    2a42 <cftmdl2+0x1922>
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0xc0(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xd8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%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
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%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
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%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,-0x100(%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
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%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,-0x110(%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
movslq -0x2c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%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,-0x120(%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
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0xf8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0xf0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0x118(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0x110(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
addsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
addsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm0
ff
subsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
subsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movsd  -0x100(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0x108(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0x108(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0x100(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  -0x128(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x128(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  -0x120(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
addsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
addsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm0
ff
subsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
subsd  -0x148(%rbp),%xmm0
ff
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    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%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    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%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    $0x3,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%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    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%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    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x110(%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    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%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    $0x3,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x120(%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    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0xf8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0xf0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  -0x118(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  -0x110(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
addsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
addsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm0
ff
subsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
subsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x100(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x108(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x100(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm2
ff
movsd  -0xd8(%rbp),%xmm1
ff
mulsd  -0x128(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0x128(%rbp),%xmm2
ff
movsd  -0xd8(%rbp),%xmm1
ff
mulsd  -0x120(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
addsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
addsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm0
ff
subsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
subsd  -0x148(%rbp),%xmm0
ff
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
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%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
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%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,-0x100(%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
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%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,-0x110(%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
movslq -0x2c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%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,-0x120(%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
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0xf8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0xf0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0x110(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0x118(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0x118(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0x110(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
addsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
addsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm0
ff
subsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
subsd  -0x148(%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
movsd  -0x100(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  -0x108(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  -0x100(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x120(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0x128(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x128(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0x120(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
addsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
addsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm0
ff
subsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
subsd  -0x148(%rbp),%xmm0
ff
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    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%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    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%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    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%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    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%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    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x110(%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    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%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    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x120(%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    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  -0xf8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  -0xf0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0x118(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0x110(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
addsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
addsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm0
subsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
subsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0x100(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  -0x108(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  -0x100(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x128(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x128(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x120(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
addsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
addsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm0
ff
subsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
subsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x1c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x1c(%rbp)
jmp    1662 <cftmdl2+0x542>
mov    -0x18(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jne    2a58 <cftmdl2+0x1938>
jmp    2d4d <cftmdl2+0x1c2d>
movsd  -0x40(%rbp),%xmm0
cvtsi2sdl -0x18(%rbp),%xmm1
mulsd  %xmm1,%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  -0x40(%rbp),%xmm0
cvtsi2sdl -0x18(%rbp),%xmm1
mulsd  %xmm1,%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x158d(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x98(%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,-0x98(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm1
subsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
addsd  -0x80(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x90(%rbp),%xmm1
ff
subsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x98(%rbp),%xmm1
ff
addsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0x13ed(%rip),%xmm0
mulsd  -0x68(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x60(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
movsd  -0x68(%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  -0x68(%rbp),%xmm1
movsd  -0x78(%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,-0x78(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
subsd  -0x68(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
addsd  -0x60(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x70(%rbp),%xmm1
subsd  -0x78(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x78(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1634 <cftmdl2+0x514>
movsd  0x12db(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x12c6(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
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    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%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    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%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    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%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    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%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    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x110(%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    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%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    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x120(%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    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0xf8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0xf0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0x118(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0x110(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
addsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
addsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm0
ff
subsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
subsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movsd  -0x100(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0x108(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0x108(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0x100(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  -0x128(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x128(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  -0x120(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
addsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
addsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm0
ff
subsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
subsd  -0x148(%rbp),%xmm0
ff
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
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%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
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%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,-0x100(%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
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%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,-0x110(%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
movslq -0x2c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%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,-0x120(%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
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0xf8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0xf0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0x118(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0x110(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
addsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
addsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm0
ff
subsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
subsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x100(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0x108(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0x100(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x120(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0x128(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x128(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0x120(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
subsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
subsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm0
ff
addsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
addsd  -0x148(%rbp),%xmm0
ff
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    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%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    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%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    $0x3,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%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    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%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    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x110(%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    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%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    $0x3,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x120(%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    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0xf8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0xf0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0x110(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0x118(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0x118(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0x110(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
addsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
addsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm0
ff
subsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
subsd  -0x148(%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
movsd  -0x100(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  -0x108(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  -0x100(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x120(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0x128(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x128(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0x120(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
addsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
addsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm0
ff
subsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
subsd  -0x148(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cftmdl2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1b8,%rsp
mov    %rsi,%rbx
mov    %edi,%r14d
sar    $0x3,%r14d
lea    (%r14,%r14,1),%edx
lea    0x0(,%r14,4),%eax
lea    (%rdx,%rdx,2),%edi
lea    0x1(,%r14,4),%ecx
movslq %ecx,%rcx
movsd  (%rsi,%rcx,8),%xmm4
movsd  (%rsi),%xmm8
movsd  0x8(%rsi),%xmm9
movapd %xmm8,%xmm2
subsd  %xmm4,%xmm2
cltq
movsd  (%rsi,%rax,8),%xmm5
movapd %xmm9,%xmm3
addsd  %xmm5,%xmm3
addsd  %xmm4,%xmm8
subsd  %xmm5,%xmm9
movslq %edx,%rbp
movsd  (%rsi,%rbp,8),%xmm5
movslq %edi,%rsi
or     $0x1,%edi
movslq %edi,%rdx
movsd  (%rbx,%rdx,8),%xmm6
movapd %xmm5,%xmm7
subsd  %xmm6,%xmm7
lea    0x1(%r14,%r14,1),%edi
movslq %edi,%rdi
movsd  (%rbx,%rdi,8),%xmm0
movsd  (%rbx,%rsi,8),%xmm1
movapd %xmm0,%xmm4
addsd  %xmm1,%xmm4
addsd  %xmm6,%xmm5
subsd  %xmm1,%xmm0
movapd %xmm7,%xmm1
subsd  %xmm4,%xmm1
movsd  0x1e27(%rip),%xmm10
mulsd  %xmm10,%xmm1
addsd  %xmm7,%xmm4
mulsd  %xmm10,%xmm4
movapd %xmm2,%xmm6
addsd  %xmm1,%xmm6
movsd  %xmm6,(%rbx)
movapd %xmm3,%xmm6
addsd  %xmm4,%xmm6
movsd  %xmm6,0x8(%rbx)
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rbx,%rbp,8)
subsd  %xmm4,%xmm3
movsd  %xmm3,(%rbx,%rdi,8)
movapd %xmm5,%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm10,%xmm1
addsd  %xmm5,%xmm0
mulsd  %xmm10,%xmm0
movapd %xmm8,%xmm2
subsd  %xmm0,%xmm2
movsd  %xmm2,(%rbx,%rax,8)
movapd %xmm9,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rbx,%rcx,8)
addsd  %xmm8,%xmm0
movsd  %xmm0,(%rbx,%rsi,8)
subsd  %xmm1,%xmm9
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm9,(%rbx,%rdx,8)
movsd  0x1da0(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x138(%rsp)
movapd %xmm1,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
call   1040 <cos@plt>
movapd %xmm0,0x10(%rsp)
movsd  (%rsp),%xmm0
call   1030 <sin@plt>
movsd  0x1d60(%rip),%xmm11
movapd 0x10(%rsp),%xmm6
movapd %xmm0,%xmm4
movapd %xmm6,%xmm14
subsd  %xmm0,%xmm14
movapd %xmm6,%xmm0
addsd  %xmm4,%xmm0
movapd %xmm0,0x20(%rsp)
movapd %xmm4,%xmm3
addsd  %xmm4,%xmm3
movsd  0x1d3d(%rip),%xmm12
mulsd  %xmm3,%xmm12
mulsd  %xmm6,%xmm12
movapd %xmm12,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm6,%xmm0
mulsd  %xmm6,%xmm12
addsd  %xmm4,%xmm12
movapd %xmm12,%xmm8
addsd  %xmm12,%xmm8
movapd %xmm0,%xmm2
subsd  %xmm12,%xmm2
movapd %xmm2,%xmm5
movapd %xmm12,0x30(%rsp)
movapd %xmm0,0x70(%rsp)
addsd  %xmm0,%xmm12
mov    %r14,0x108(%rsp)
lea    -0x4(%r14),%r13d
movapd 0x1cfe(%rip),%xmm13
movapd %xmm3,%xmm9
xorpd  %xmm13,%xmm9
movapd %xmm8,%xmm10
xorpd  %xmm13,%xmm10
movapd %xmm6,%xmm0
unpcklpd %xmm6,%xmm0
movapd %xmm0,0x1a0(%rsp)
unpcklpd %xmm4,%xmm0
movapd %xmm0,0x190(%rsp)
movapd %xmm4,0x40(%rsp)
movapd %xmm4,%xmm0
xorpd  %xmm13,%xmm0
movapd %xmm3,%xmm4
movapd %xmm0,0x180(%rsp)
lea    -0x2(%rbp),%rax
mov    %rax,0x130(%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,0x128(%rsp)
mov    %rbp,%r14
shl    $0x5,%r14
add    $0xfffffffffffffff0,%r14
lea    0x4(%rbp),%rax
mov    %rax,0x120(%rsp)
lea    0x4(,%rbp,1),%rax
add    %rbp,%rax
mov    %rax,0x118(%rsp)
lea    0x4(,%rbp,2),%rax
add    %rbp,%rax
mov    %rax,0x110(%rsp)
xor    %eax,%eax
movsd  0x1c1f(%rip),%xmm6
xorpd  %xmm0,%xmm0
movapd %xmm0,0x80(%rsp)
movsd  0x1c12(%rip),%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0xb0(%rsp)
xorps  %xmm0,%xmm0
movaps %xmm0,0xd0(%rsp)
movapd %xmm11,%xmm0
movapd %xmm11,0xe0(%rsp)
movapd %xmm11,0xc0(%rsp)
movapd %xmm6,%xmm0
movapd %xmm6,0xa0(%rsp)
movapd %xmm6,0x90(%rsp)
movapd %xmm3,0x170(%rsp)
movapd %xmm8,0x160(%rsp)
movapd %xmm9,0x150(%rsp)
movapd %xmm10,0x140(%rsp)
nopl   0x0(%rax,%rax,1)
mulsd  %xmm6,%xmm12
mulsd  %xmm6,%xmm5
movapd 0x20(%rsp),%xmm0
mulsd  %xmm11,%xmm0
movapd %xmm0,0x20(%rsp)
mulsd  %xmm11,%xmm14
lea    0x80(%rax),%r8d
cmp    %r13d,%r8d
mov    %r8d,%r15d
cmovg  %r13d,%r15d
lea    0x2(%rax),%ecx
cmp    %r15d,%ecx
jge    1d65 <cftmdl2+0xc45>
movslq %eax,%rcx
lea    0x2(%rcx),%rdx
movslq %r15d,%r9
mov    0x130(%rsp),%r11
sub    %rcx,%r11
lea    0x0(,%rcx,8),%rdi
mov    %r12,%rbp
sub    %rdi,%rbp
mov    0x128(%rsp),%rax
sub    %rdi,%rax
mov    %r14,%rsi
sub    %rdi,%rsi
mov    0x120(%rsp),%rdi
lea    (%rdi,%rcx,1),%r10
mov    0x118(%rsp),%rdi
add    %rcx,%rdi
add    0x110(%rsp),%rcx
movapd 0x80(%rsp),%xmm11
movapd 0xb0(%rsp),%xmm1
movapd %xmm9,%xmm6
movapd 0xe0(%rsp),%xmm9
movapd 0xa0(%rsp),%xmm15
movapd 0x90(%rsp),%xmm13
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm5,%xmm7
movapd %xmm5,0x50(%rsp)
movapd %xmm12,0xf0(%rsp)
movapd %xmm14,%xmm5
movapd %xmm14,0x60(%rsp)
movapd %xmm6,%xmm0
mulsd  0x40(%rsp),%xmm0
movapd (%rsp),%xmm2
addsd  %xmm0,%xmm2
movapd %xmm2,(%rsp)
movapd %xmm4,%xmm0
mulsd  0x10(%rsp),%xmm0
movapd %xmm10,%xmm2
mulsd  0x30(%rsp),%xmm2
addsd  %xmm0,%xmm11
movapd %xmm11,0x80(%rsp)
addsd  %xmm2,%xmm1
movapd %xmm1,0xb0(%rsp)
movapd %xmm8,%xmm0
movapd 0x70(%rsp),%xmm11
mulsd  %xmm11,%xmm0
movapd 0x20(%rsp),%xmm14
mulsd  %xmm14,%xmm6
movapd 0xd0(%rsp),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,0xd0(%rsp)
addsd  %xmm6,%xmm9
movapd %xmm9,0xe0(%rsp)
mulsd  %xmm5,%xmm4
mulsd  %xmm12,%xmm10
movapd 0xc0(%rsp),%xmm1
addsd  %xmm4,%xmm1
movapd %xmm1,0xc0(%rsp)
addsd  %xmm10,%xmm15
movapd %xmm15,0xa0(%rsp)
mulsd  %xmm7,%xmm8
movupd (%rbx,%rdx,8),%xmm4
addsd  %xmm8,%xmm13
movapd %xmm13,0x90(%rsp)
movupd -0x10(%rbx,%rdi,8),%xmm12
shufpd $0x1,%xmm12,%xmm12
movapd %xmm4,%xmm2
subpd  %xmm12,%xmm2
addpd  %xmm4,%xmm12
movapd %xmm2,%xmm15
movsd  %xmm12,%xmm15
movupd -0x10(%rbx,%r10,8),%xmm6
movupd -0x10(%rbx,%rcx,8),%xmm8
movapd %xmm12,%xmm5
movapd 0x30(%rsp),%xmm4
unpcklpd %xmm12,%xmm4
shufpd $0x1,%xmm8,%xmm8
movapd %xmm6,%xmm0
subpd  %xmm8,%xmm0
addpd  %xmm6,%xmm8
movsd  %xmm2,%xmm12
movapd %xmm0,%xmm6
movsd  %xmm8,%xmm6
movapd %xmm8,%xmm13
movapd %xmm14,%xmm9
movapd %xmm11,%xmm10
movapd %xmm11,0x70(%rsp)
movapd 0xf0(%rsp),%xmm14
unpcklpd %xmm8,%xmm14
movapd 0x40(%rsp),%xmm11
movapd 0x1955(%rip),%xmm1
xorpd  %xmm1,%xmm11
shufpd $0x1,0x40(%rsp),%xmm5
unpcklpd %xmm2,%xmm11
mulpd  %xmm5,%xmm11
movapd 0x10(%rsp),%xmm5
unpcklpd %xmm5,%xmm5
movsd  %xmm0,%xmm8
mulpd  %xmm12,%xmm5
movapd %xmm9,%xmm3
xorpd  %xmm1,%xmm3
shufpd $0x1,%xmm9,%xmm13
unpcklpd %xmm0,%xmm3
mulpd  %xmm13,%xmm3
movapd 0x60(%rsp),%xmm1
unpcklpd %xmm1,%xmm1
mulpd  %xmm8,%xmm1
addpd  %xmm11,%xmm5
addpd  %xmm3,%xmm1
movapd %xmm5,%xmm3
movapd 0x30(%rsp),%xmm7
xorpd  0x18e9(%rip),%xmm7
shufpd $0x1,%xmm7,%xmm2
addpd  %xmm1,%xmm3
mulpd  %xmm4,%xmm2
unpcklpd %xmm10,%xmm10
mulpd  %xmm15,%xmm10
subpd  %xmm1,%xmm5
addpd  %xmm2,%xmm10
movapd 0xf0(%rsp),%xmm1
xorpd  0x18b8(%rip),%xmm1
shufpd $0x1,%xmm1,%xmm0
movupd %xmm3,(%rbx,%rdx,8)
mulpd  %xmm14,%xmm0
movapd %xmm9,%xmm14
movapd %xmm9,0x20(%rsp)
movapd 0x50(%rsp),%xmm1
unpcklpd %xmm1,%xmm1
mulpd  %xmm6,%xmm1
movupd %xmm5,-0x10(%rbx,%r10,8)
addpd  %xmm0,%xmm1
movapd %xmm10,%xmm0
addpd  %xmm1,%xmm0
subpd  %xmm1,%xmm10
movupd %xmm0,-0x10(%rbx,%rdi,8)
movupd %xmm10,-0x10(%rbx,%rcx,8)
movupd 0x10(%rbx,%rdx,8),%xmm1
movupd (%rbx,%rdi,8),%xmm0
shufpd $0x1,%xmm0,%xmm0
movapd %xmm1,%xmm2
subpd  %xmm0,%xmm2
addpd  %xmm1,%xmm0
movapd %xmm2,%xmm8
movsd  %xmm0,%xmm8
movapd %xmm0,%xmm4
movapd 0xd0(%rsp),%xmm9
movapd %xmm9,%xmm12
unpcklpd %xmm0,%xmm12
movupd (%rbx,%r10,8),%xmm3
movupd (%rbx,%rcx,8),%xmm5
shufpd $0x1,%xmm5,%xmm5
movapd %xmm3,%xmm6
movsd  %xmm2,%xmm0
subpd  %xmm5,%xmm6
addpd  %xmm3,%xmm5
movapd %xmm6,%xmm11
movapd 0x80(%rsp),%xmm7
xorpd  0x17f5(%rip),%xmm7
movsd  %xmm5,%xmm11
shufpd $0x1,0x80(%rsp),%xmm4
unpcklpd %xmm2,%xmm7
mulpd  %xmm4,%xmm7
movapd (%rsp),%xmm4
movapd %xmm5,%xmm3
movapd 0x90(%rsp),%xmm13
movapd %xmm13,%xmm10
unpcklpd %xmm5,%xmm10
unpcklpd %xmm4,%xmm4
mulpd  %xmm0,%xmm4
movapd 0xc0(%rsp),%xmm1
movapd %xmm1,%xmm0
xorpd  0x17a4(%rip),%xmm0
movsd  %xmm6,%xmm5
shufpd $0x1,%xmm1,%xmm3
unpcklpd %xmm6,%xmm0
mulpd  %xmm3,%xmm0
movapd 0xe0(%rsp),%xmm15
movapd %xmm15,%xmm3
addpd  %xmm7,%xmm4
unpcklpd %xmm15,%xmm3
mulpd  %xmm5,%xmm3
movapd %xmm9,%xmm5
xorpd  0x176a(%rip),%xmm5
addpd  %xmm0,%xmm3
movapd %xmm4,%xmm0
shufpd $0x1,%xmm5,%xmm2
mulpd  %xmm12,%xmm2
movapd 0xb0(%rsp),%xmm5
unpcklpd %xmm5,%xmm5
addpd  %xmm3,%xmm0
mulpd  %xmm8,%xmm5
addpd  %xmm2,%xmm5
movapd %xmm13,%xmm2
xorpd  0x1731(%rip),%xmm2
subpd  %xmm3,%xmm4
shufpd $0x1,%xmm2,%xmm6
mulpd  %xmm10,%xmm6
movapd 0xa0(%rsp),%xmm10
movapd %xmm10,%xmm1
unpcklpd %xmm10,%xmm1
movupd %xmm0,0x10(%rbx,%rdx,8)
mulpd  %xmm11,%xmm1
addpd  %xmm6,%xmm1
movapd %xmm5,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm4,(%rbx,%r10,8)
movupd %xmm0,(%rbx,%rdi,8)
subpd  %xmm1,%xmm5
movupd %xmm5,(%rbx,%rcx,8)
movupd (%rbx,%r11,8),%xmm0
movupd (%rbx,%rax,1),%xmm5
shufpd $0x1,%xmm5,%xmm5
movapd %xmm0,%xmm2
subpd  %xmm5,%xmm2
addpd  %xmm0,%xmm5
movapd %xmm2,%xmm9
movsd  %xmm5,%xmm9
movupd (%rbx,%rbp,1),%xmm4
movupd (%rbx,%rsi,1),%xmm0
movapd %xmm5,%xmm11
movapd 0x50(%rsp),%xmm13
unpcklpd %xmm5,%xmm13
movapd %xmm5,%xmm3
shufpd $0x1,%xmm0,%xmm0
movapd %xmm4,%xmm5
subpd  %xmm0,%xmm5
addpd  %xmm4,%xmm0
movsd  %xmm2,%xmm3
movapd %xmm5,%xmm12
movsd  %xmm0,%xmm12
movapd %xmm0,%xmm7
movapd 0x70(%rsp),%xmm6
movapd %xmm6,%xmm8
unpcklpd %xmm0,%xmm8
movapd 0x60(%rsp),%xmm4
xorpd  0x165e(%rip),%xmm4
shufpd $0x1,0x60(%rsp),%xmm11
01
unpcklpd %xmm2,%xmm4
mulpd  %xmm11,%xmm4
movapd %xmm14,%xmm1
unpcklpd %xmm14,%xmm1
movsd  %xmm5,%xmm0
mulpd  %xmm3,%xmm1
movapd 0x10(%rsp),%xmm3
xorpd  0x162d(%rip),%xmm3
shufpd $0x1,0x10(%rsp),%xmm7
unpcklpd %xmm5,%xmm3
mulpd  %xmm7,%xmm3
movapd 0x40(%rsp),%xmm7
unpcklpd %xmm7,%xmm7
mulpd  %xmm0,%xmm7
addpd  %xmm4,%xmm1
addpd  %xmm3,%xmm7
movapd %xmm1,%xmm0
movapd 0x50(%rsp),%xmm3
xorpd  0x15f6(%rip),%xmm3
shufpd $0x1,%xmm3,%xmm2
addpd  %xmm7,%xmm0
mulpd  %xmm13,%xmm2
movapd 0xf0(%rsp),%xmm3
unpcklpd %xmm3,%xmm3
mulpd  %xmm9,%xmm3
subpd  %xmm7,%xmm1
addpd  %xmm2,%xmm3
xorpd  0x15c6(%rip),%xmm6
shufpd $0x1,%xmm6,%xmm5
movupd %xmm0,(%rbx,%r11,8)
mulpd  %xmm8,%xmm5
movapd 0x30(%rsp),%xmm0
unpcklpd %xmm0,%xmm0
mulpd  %xmm12,%xmm0
movupd %xmm1,(%rbx,%rbp,1)
addpd  %xmm5,%xmm0
movapd %xmm3,%xmm1
addpd  %xmm0,%xmm1
subpd  %xmm0,%xmm3
movupd %xmm1,(%rbx,%rax,1)
movupd %xmm3,(%rbx,%rsi,1)
movupd -0x10(%rbx,%r11,8),%xmm1
movupd -0x10(%rbx,%rax,1),%xmm0
shufpd $0x1,%xmm0,%xmm0
movapd %xmm1,%xmm2
subpd  %xmm0,%xmm2
addpd  %xmm1,%xmm0
movapd %xmm2,%xmm8
movsd  %xmm0,%xmm8
movapd %xmm0,%xmm11
movapd %xmm10,%xmm1
unpcklpd %xmm0,%xmm10
movupd -0x10(%rbx,%rbp,1),%xmm3
movupd -0x10(%rbx,%rsi,1),%xmm5
shufpd $0x1,%xmm5,%xmm5
movapd %xmm3,%xmm6
movsd  %xmm2,%xmm0
subpd  %xmm5,%xmm6
addpd  %xmm3,%xmm5
movapd %xmm6,%xmm12
movapd %xmm15,%xmm7
xorpd  0x151e(%rip),%xmm7
movsd  %xmm5,%xmm12
shufpd $0x1,%xmm15,%xmm11
unpcklpd %xmm2,%xmm7
movapd 0xc0(%rsp),%xmm14
movapd %xmm14,%xmm4
unpcklpd %xmm14,%xmm4
mulpd  %xmm11,%xmm7
movapd 0x80(%rsp),%xmm11
mulpd  %xmm0,%xmm4
addpd  %xmm7,%xmm4
movapd (%rsp),%xmm0
xorpd  0x14d7(%rip),%xmm0
movapd %xmm5,%xmm7
movapd 0xb0(%rsp),%xmm9
movapd %xmm9,%xmm3
unpcklpd %xmm5,%xmm3
shufpd $0x1,(%rsp),%xmm7
unpcklpd %xmm6,%xmm0
mulpd  %xmm7,%xmm0
movapd %xmm11,%xmm7
movsd  %xmm6,%xmm5
unpcklpd %xmm7,%xmm7
mulpd  %xmm5,%xmm7
movapd 0x160(%rsp),%xmm13
addpd  %xmm0,%xmm7
movapd %xmm1,%xmm0
xorpd  0x1487(%rip),%xmm0
shufpd $0x1,%xmm0,%xmm2
mulpd  %xmm10,%xmm2
movapd %xmm4,%xmm0
addpd  %xmm7,%xmm0
subpd  %xmm7,%xmm4
movapd 0x1469(%rip),%xmm7
movapd 0x90(%rsp),%xmm5
movapd %xmm5,%xmm1
unpcklpd %xmm5,%xmm1
mulpd  %xmm8,%xmm1
movapd 0x140(%rsp),%xmm10
addpd  %xmm2,%xmm1
movupd %xmm0,-0x10(%rbx,%r11,8)
movapd %xmm9,%xmm0
xorpd  %xmm7,%xmm0
shufpd $0x1,%xmm0,%xmm6
mulpd  %xmm3,%xmm6
movapd 0x50(%rsp),%xmm7
movupd %xmm4,-0x10(%rbx,%rbp,1)
movapd 0x170(%rsp),%xmm4
movapd 0xd0(%rsp),%xmm3
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
mulpd  %xmm12,%xmm0
addpd  %xmm6,%xmm0
movapd 0x150(%rsp),%xmm6
movapd %xmm1,%xmm2
addpd  %xmm0,%xmm2
movupd %xmm2,-0x10(%rbx,%rax,1)
subpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rbx,%rsi,1)
movapd 0xf0(%rsp),%xmm12
movapd 0x60(%rsp),%xmm8
movapd %xmm6,%xmm0
mulsd  %xmm11,%xmm0
movapd 0x10(%rsp),%xmm2
addsd  %xmm0,%xmm2
movapd %xmm2,0x10(%rsp)
movapd %xmm4,%xmm0
mulsd  (%rsp),%xmm0
movapd 0x40(%rsp),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,0x40(%rsp)
movapd %xmm10,%xmm0
mulsd  %xmm3,%xmm0
movapd 0x70(%rsp),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,0x70(%rsp)
movapd %xmm13,%xmm0
movapd %xmm9,%xmm3
movapd %xmm9,%xmm1
mulsd  %xmm9,%xmm0
movapd 0x30(%rsp),%xmm2
addsd  %xmm0,%xmm2
movapd %xmm2,0x30(%rsp)
movapd %xmm6,%xmm0
mulsd  %xmm14,%xmm0
addsd  %xmm0,%xmm8
movapd %xmm8,%xmm14
movapd %xmm4,%xmm0
movapd %xmm15,%xmm9
mulsd  %xmm15,%xmm0
movapd %xmm13,%xmm8
movapd 0x20(%rsp),%xmm2
addsd  %xmm0,%xmm2
movapd %xmm2,0x20(%rsp)
movapd %xmm10,%xmm0
movapd %xmm5,%xmm13
mulsd  %xmm5,%xmm0
addsd  %xmm0,%xmm7
movapd %xmm7,%xmm5
movapd %xmm8,%xmm0
movapd 0xa0(%rsp),%xmm7
movapd %xmm7,%xmm15
mulsd  %xmm7,%xmm0
addsd  %xmm0,%xmm12
add    $0x4,%rdx
add    $0xfffffffffffffffc,%r11
add    $0xffffffffffffffe0,%rbp
add    $0xffffffffffffffe0,%rax
add    $0xffffffffffffffe0,%rsi
add    $0x4,%r10
add    $0x4,%rdi
add    $0x4,%rcx
cmp    %r9,%rdx
jl     1550 <cftmdl2+0x430>
cmp    %r8d,%r13d
jle    1f18 <cftmdl2+0xdf8>
xorps  %xmm0,%xmm0
cvtsi2sd %r15d,%xmm0
mulsd  0x138(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
call   1040 <cos@plt>
movapd %xmm0,(%rsp)
movsd  0x10(%rsp),%xmm0
call   1030 <sin@plt>
movapd (%rsp),%xmm5
movapd 0x140(%rsp),%xmm10
movapd 0x150(%rsp),%xmm9
movapd 0x160(%rsp),%xmm8
movapd 0x170(%rsp),%xmm4
movapd %xmm0,%xmm1
movsd  0x1255(%rip),%xmm12
mulsd  %xmm12,%xmm1
mulsd  %xmm5,%xmm1
movapd %xmm1,%xmm7
mulsd  %xmm0,%xmm7
addsd  %xmm5,%xmm7
mulsd  %xmm5,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm5,%xmm3
subsd  %xmm0,%xmm3
movsd  0x11ff(%rip),%xmm11
mulsd  %xmm11,%xmm3
movapd %xmm3,0xe0(%rsp)
movapd %xmm5,%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm11,%xmm2
movapd %xmm2,0xc0(%rsp)
movapd %xmm7,%xmm3
subsd  %xmm1,%xmm3
movsd  0x11e3(%rip),%xmm6
mulsd  %xmm6,%xmm3
movapd %xmm3,0xa0(%rsp)
movapd %xmm1,0xd0(%rsp)
movapd %xmm7,0xb0(%rsp)
addsd  %xmm7,%xmm1
mulsd  %xmm6,%xmm1
movapd %xmm1,0x90(%rsp)
movapd 0x190(%rsp),%xmm7
movsd  %xmm0,%xmm7
movapd 0x180(%rsp),%xmm1
unpcklpd %xmm5,%xmm1
mulpd  %xmm7,%xmm1
movapd %xmm0,0x80(%rsp)
unpcklpd %xmm0,%xmm5
mulpd  0x1a0(%rsp),%xmm5
addpd  %xmm1,%xmm5
movapd %xmm5,%xmm3
unpckhpd %xmm5,%xmm3
movapd %xmm3,%xmm0
mulsd  %xmm12,%xmm0
mulsd  %xmm5,%xmm0
movapd %xmm5,%xmm1
shufpd $0x1,%xmm5,%xmm1
unpcklpd %xmm0,%xmm0
mulpd  %xmm1,%xmm0
addpd  %xmm5,%xmm0
movapd %xmm5,%xmm14
subsd  %xmm3,%xmm14
movapd %xmm3,0x40(%rsp)
movapd %xmm5,0x10(%rsp)
addsd  %xmm5,%xmm3
movapd %xmm3,0x20(%rsp)
movapd %xmm0,%xmm12
unpckhpd %xmm0,%xmm12
movapd %xmm0,%xmm3
subsd  %xmm12,%xmm3
movapd %xmm3,%xmm5
movapd %xmm12,0x30(%rsp)
movapd %xmm0,0x70(%rsp)
addsd  %xmm0,%xmm12
mov    %r15d,%eax
jmp    1480 <cftmdl2+0x360>
mov    0x108(%rsp),%rcx
lea    (%rcx,%rcx,2),%edx
lea    (%rcx,%rcx,4),%eax
lea    0x0(,%rcx,8),%edi
sub    %ecx,%edi
movslq %ecx,%rcx
movupd -0x10(%rbx,%rcx,8),%xmm0
cltq
movupd -0x10(%rbx,%rax,8),%xmm3
shufpd $0x1,%xmm3,%xmm3
movapd %xmm14,0x60(%rsp)
movapd %xmm0,%xmm1
subpd  %xmm3,%xmm1
addpd  %xmm0,%xmm3
movapd %xmm1,%xmm0
movsd  %xmm3,%xmm0
movapd %xmm0,(%rsp)
movslq %edx,%rsi
movupd -0x10(%rbx,%rsi,8),%xmm0
movslq %edi,%rdx
movupd -0x10(%rbx,%rdx,8),%xmm4
shufpd $0x1,%xmm4,%xmm4
movapd %xmm5,0x50(%rsp)
movapd %xmm0,%xmm9
subpd  %xmm4,%xmm9
addpd  %xmm0,%xmm4
movapd 0x40(%rsp),%xmm13
movapd %xmm13,%xmm0
movapd 0x108b(%rip),%xmm11
xorpd  %xmm11,%xmm0
movapd %xmm3,%xmm6
shufpd $0x1,%xmm13,%xmm6
unpcklpd %xmm1,%xmm0
mulpd  %xmm6,%xmm0
movapd 0x30(%rsp),%xmm15
movapd %xmm15,%xmm10
unpcklpd %xmm3,%xmm10
movapd %xmm3,%xmm14
movsd  %xmm1,%xmm14
movapd 0x10(%rsp),%xmm7
movapd %xmm7,%xmm6
unpcklpd %xmm7,%xmm6
mulpd  %xmm14,%xmm6
addpd  %xmm0,%xmm6
movapd 0x20(%rsp),%xmm8
movapd %xmm8,%xmm0
xorpd  %xmm11,%xmm0
movapd %xmm4,%xmm5
shufpd $0x1,%xmm8,%xmm5
unpcklpd %xmm9,%xmm0
mulpd  %xmm5,%xmm0
movapd %xmm9,%xmm3
movsd  %xmm4,%xmm3
movapd %xmm12,%xmm2
unpcklpd %xmm4,%xmm2
movsd  %xmm9,%xmm4
movapd 0x60(%rsp),%xmm5
unpcklpd %xmm5,%xmm5
mulpd  %xmm4,%xmm5
addpd  %xmm0,%xmm5
movapd %xmm6,%xmm0
addpd  %xmm5,%xmm0
movupd %xmm0,-0x10(%rbx,%rcx,8)
subpd  %xmm5,%xmm6
movupd %xmm6,-0x10(%rbx,%rsi,8)
movapd %xmm15,%xmm0
xorpd  %xmm11,%xmm0
shufpd $0x1,%xmm0,%xmm1
mulpd  %xmm10,%xmm1
movapd 0x70(%rsp),%xmm14
movapd %xmm14,%xmm0
unpcklpd %xmm14,%xmm0
mulpd  (%rsp),%xmm0
addpd  %xmm1,%xmm0
movapd %xmm12,%xmm1
xorpd  %xmm11,%xmm1
shufpd $0x1,%xmm1,%xmm9
mulpd  %xmm2,%xmm9
movapd 0x50(%rsp),%xmm1
unpcklpd %xmm1,%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm9,%xmm1
movapd %xmm0,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,-0x10(%rbx,%rax,8)
subpd  %xmm1,%xmm0
movupd %xmm0,-0x10(%rbx,%rdx,8)
movupd (%rbx,%rcx,8),%xmm1
movupd (%rbx,%rax,8),%xmm2
shufpd $0x1,%xmm2,%xmm2
movapd %xmm1,%xmm0
subpd  %xmm2,%xmm0
addpd  %xmm1,%xmm2
movapd %xmm2,%xmm4
movsd  %xmm0,%xmm4
movupd (%rbx,%rsi,8),%xmm3
movupd (%rbx,%rdx,8),%xmm5
shufpd $0x1,%xmm5,%xmm5
movapd %xmm3,%xmm1
subpd  %xmm5,%xmm1
addpd  %xmm3,%xmm5
movapd %xmm2,%xmm3
shufpd $0x1,%xmm0,%xmm3
mulpd  0xf30(%rip),%xmm3
mulpd  0xf38(%rip),%xmm4
addpd  %xmm3,%xmm4
movapd %xmm5,%xmm6
movsd  %xmm1,%xmm6
movapd %xmm5,%xmm3
shufpd $0x1,%xmm1,%xmm3
movapd 0xf2a(%rip),%xmm10
mulpd  %xmm10,%xmm3
movapd 0xf2c(%rip),%xmm9
mulpd  %xmm9,%xmm6
addpd  %xmm3,%xmm6
movapd %xmm4,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm3,(%rbx,%rcx,8)
subpd  %xmm6,%xmm4
movupd %xmm4,(%rbx,%rsi,8)
movapd %xmm0,%xmm3
movsd  %xmm2,%xmm3
shufpd $0x1,%xmm2,%xmm0
mulpd  %xmm10,%xmm0
mulpd  %xmm9,%xmm3
addpd  %xmm0,%xmm3
movapd %xmm1,%xmm0
movsd  %xmm5,%xmm0
shufpd $0x1,%xmm5,%xmm1
mulpd  0xead(%rip),%xmm1
mulpd  0xeb5(%rip),%xmm0
addpd  %xmm1,%xmm0
movapd %xmm3,%xmm1
subpd  %xmm0,%xmm1
movupd %xmm1,(%rbx,%rax,8)
addpd  %xmm3,%xmm0
movupd %xmm0,(%rbx,%rdx,8)
movupd 0x10(%rbx,%rcx,8),%xmm2
movupd 0x10(%rbx,%rax,8),%xmm0
shufpd $0x1,%xmm0,%xmm0
movapd %xmm2,%xmm1
subpd  %xmm0,%xmm1
addpd  %xmm2,%xmm0
movapd %xmm1,%xmm2
movsd  %xmm0,%xmm2
movupd 0x10(%rbx,%rsi,8),%xmm5
movupd 0x10(%rbx,%rdx,8),%xmm4
shufpd $0x1,%xmm4,%xmm4
movapd %xmm5,%xmm3
subpd  %xmm4,%xmm3
addpd  %xmm5,%xmm4
movapd %xmm0,%xmm5
movapd 0x60(%rsp),%xmm6
shufpd $0x1,%xmm6,%xmm5
xorpd  %xmm11,%xmm6
unpcklpd %xmm1,%xmm6
mulpd  %xmm5,%xmm6
movapd %xmm6,%xmm9
movapd 0x50(%rsp),%xmm6
movapd %xmm6,%xmm5
unpcklpd %xmm0,%xmm6
movsd  %xmm1,%xmm0
unpcklpd %xmm8,%xmm8
mulpd  %xmm0,%xmm8
addpd  %xmm9,%xmm8
movapd %xmm4,%xmm0
shufpd $0x1,%xmm7,%xmm0
xorpd  %xmm11,%xmm7
unpcklpd %xmm3,%xmm7
mulpd  %xmm0,%xmm7
movapd %xmm3,%xmm0
movsd  %xmm4,%xmm0
xorpd  %xmm11,%xmm5
xorpd  %xmm14,%xmm11
unpcklpd %xmm4,%xmm14
movsd  %xmm3,%xmm4
unpcklpd %xmm13,%xmm13
mulpd  %xmm4,%xmm13
addpd  %xmm7,%xmm13
movapd %xmm8,%xmm4
addpd  %xmm13,%xmm4
movupd %xmm4,0x10(%rbx,%rcx,8)
subpd  %xmm13,%xmm8
movupd %xmm8,0x10(%rbx,%rsi,8)
shufpd $0x1,%xmm5,%xmm1
mulpd  %xmm6,%xmm1
unpcklpd %xmm12,%xmm12
mulpd  %xmm2,%xmm12
addpd  %xmm1,%xmm12
shufpd $0x1,%xmm11,%xmm3
mulpd  %xmm14,%xmm3
unpcklpd %xmm15,%xmm15
mulpd  %xmm0,%xmm15
addpd  %xmm3,%xmm15
movapd %xmm12,%xmm0
addpd  %xmm15,%xmm0
movupd %xmm0,0x10(%rbx,%rax,8)
subpd  %xmm15,%xmm12
movupd %xmm12,0x10(%rbx,%rdx,8)
add    $0x1b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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