#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 */
scalar_t__ cos(float);
scalar_t__ sin(float);
void cftmdl2(int n, float *a) {
  int i, i0, j, j0, j1, j2, j3, m, mh;
  float ew, w1r, w1i, wn4r, wk1r, wk1i, wk3r, wk3i, wl1r, wl1i, wl3r, wl3i,
      wd1r, wd1i, wd3r, wd3i, we1r, we1i, we3r, we3i, ss1, ss3;
  float x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, y0r, y0i, y2r, y2i;
  mh = n >> 3;
  m = 2 * mh;
  wn4r = ((float)0.707106781186547524400844362104849039284835937688);
  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 = ((float)1.570796326794896619231321691639751442098584699687) / (2 * m);
  w1r = (float)cos(2 * ew);
  w1i = (float)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 = (float)cos(ew * i0);
    wl1i = (float)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 = ((float)0.923879532511286756128183189396788286822416625863);
  wl1i = ((float)0.382683432365089771728459984030398866761344562485);
  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    $0xc0,%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)
movss  0x2ec0(%rip),%xmm0
movss  %xmm0,-0x44(%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
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0x44(%rbp),%xmm0
movss  -0xa0(%rbp),%xmm1
ff
subss  -0xa4(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x44(%rbp),%xmm0
movss  -0xa4(%rbp),%xmm1
ff
addss  -0xa0(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0x90(%rbp),%xmm0
ff
addss  -0xb0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x94(%rbp),%xmm0
ff
addss  -0xb4(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x90(%rbp),%xmm0
ff
subss  -0xb0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x94(%rbp),%xmm0
ff
subss  -0xb4(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x44(%rbp),%xmm0
movss  -0xa8(%rbp),%xmm1
ff
subss  -0xac(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x44(%rbp),%xmm0
movss  -0xac(%rbp),%xmm1
ff
addss  -0xa8(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
subss  -0xb4(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x9c(%rbp),%xmm0
ff
addss  -0xb0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x98(%rbp),%xmm0
ff
addss  -0xb4(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x9c(%rbp),%xmm0
ff
subss  -0xb0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  0x2c09(%rip),%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  0x2bf4(%rip),%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x44(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x44(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x30(%rbp),%eax
shl    $0x1,%eax
cvtsi2ss %eax,%xmm1
movss  0x2b8c(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  0x2b77(%rip),%xmm0
mulss  -0x38(%rbp),%xmm0
call   1040 <cos@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  0x2b5b(%rip),%xmm0
mulss  -0x38(%rbp),%xmm0
call   1030 <sin@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm1
subss  -0x40(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x40(%rbp),%xmm1
addss  -0x3c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  0x2afb(%rip),%xmm0
mulss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  0x2ae6(%rip),%xmm0
mulss  -0x88(%rbp),%xmm0
ff
mulss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x48(%rbp),%xmm1
movss  -0x54(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x4c(%rbp),%xmm1
movss  -0x54(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  0x2a7a(%rip),%xmm0
mulss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x44(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x50(%rbp),%xmm1
subss  -0x54(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x44(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x54(%rbp),%xmm1
addss  -0x50(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
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    1609 <cftmdl2+0x4e9>
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    2830 <cftmdl2+0x1710>
movss  -0x88(%rbp),%xmm0
ff
movss  -0x4c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x88(%rbp),%xmm0
ff
movss  -0x48(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x8c(%rbp),%xmm0
ff
movss  -0x54(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x8c(%rbp),%xmm0
ff
movss  -0x50(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x88(%rbp),%xmm0
ff
movss  -0x6c(%rbp),%xmm2
movss  -0x78(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x88(%rbp),%xmm0
ff
movss  -0x68(%rbp),%xmm2
movss  -0x7c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x8c(%rbp),%xmm0
ff
movss  -0x74(%rbp),%xmm2
movss  -0x80(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x8c(%rbp),%xmm0
ff
movss  -0x70(%rbp),%xmm2
movss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%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
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0x48(%rbp),%xmm0
movss  -0x90(%rbp),%xmm2
ff
movss  -0x4c(%rbp),%xmm1
mulss  -0x94(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x48(%rbp),%xmm0
movss  -0x94(%rbp),%xmm2
ff
movss  -0x4c(%rbp),%xmm1
mulss  -0x90(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0x68(%rbp),%xmm0
movss  -0xa0(%rbp),%xmm2
ff
movss  -0x6c(%rbp),%xmm1
mulss  -0xa4(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0x68(%rbp),%xmm0
movss  -0xa4(%rbp),%xmm2
ff
movss  -0x6c(%rbp),%xmm1
mulss  -0xa0(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
addss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
addss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
subss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
subss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
movss  -0x98(%rbp),%xmm2
ff
movss  -0x54(%rbp),%xmm1
mulss  -0x9c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x50(%rbp),%xmm0
movss  -0x9c(%rbp),%xmm2
ff
movss  -0x54(%rbp),%xmm1
mulss  -0x98(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0x70(%rbp),%xmm0
movss  -0xa8(%rbp),%xmm2
ff
movss  -0x74(%rbp),%xmm1
mulss  -0xac(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0x70(%rbp),%xmm0
movss  -0xac(%rbp),%xmm2
ff
movss  -0x74(%rbp),%xmm1
mulss  -0xa8(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
addss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
addss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
subss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
subss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0x58(%rbp),%xmm0
movss  -0x90(%rbp),%xmm2
ff
movss  -0x5c(%rbp),%xmm1
mulss  -0x94(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x58(%rbp),%xmm0
movss  -0x94(%rbp),%xmm2
ff
movss  -0x5c(%rbp),%xmm1
mulss  -0x90(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0x78(%rbp),%xmm0
movss  -0xa0(%rbp),%xmm2
ff
movss  -0x7c(%rbp),%xmm1
mulss  -0xa4(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0x78(%rbp),%xmm0
movss  -0xa4(%rbp),%xmm2
ff
movss  -0x7c(%rbp),%xmm1
mulss  -0xa0(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
addss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
addss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
subss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
subss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
movss  -0x98(%rbp),%xmm2
ff
movss  -0x64(%rbp),%xmm1
mulss  -0x9c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x60(%rbp),%xmm0
movss  -0x9c(%rbp),%xmm2
ff
movss  -0x64(%rbp),%xmm1
mulss  -0x98(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0x80(%rbp),%xmm0
movss  -0xa8(%rbp),%xmm2
ff
movss  -0x84(%rbp),%xmm1
ff
mulss  -0xac(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0x80(%rbp),%xmm0
movss  -0xac(%rbp),%xmm2
ff
movss  -0x84(%rbp),%xmm1
ff
mulss  -0xa8(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
addss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
addss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
subss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
subss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
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
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa0(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
movss  -0x90(%rbp),%xmm2
ff
movss  -0x68(%rbp),%xmm1
mulss  -0x94(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
movss  -0x94(%rbp),%xmm2
ff
movss  -0x68(%rbp),%xmm1
mulss  -0x90(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0x4c(%rbp),%xmm0
movss  -0xa0(%rbp),%xmm2
ff
movss  -0x48(%rbp),%xmm1
mulss  -0xa4(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0x4c(%rbp),%xmm0
movss  -0xa4(%rbp),%xmm2
ff
movss  -0x48(%rbp),%xmm1
mulss  -0xa0(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
addss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
addss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
subss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
subss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
movss  -0x98(%rbp),%xmm2
ff
movss  -0x70(%rbp),%xmm1
mulss  -0x9c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x74(%rbp),%xmm0
movss  -0x9c(%rbp),%xmm2
ff
movss  -0x70(%rbp),%xmm1
mulss  -0x98(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0xa8(%rbp),%xmm2
ff
movss  -0x50(%rbp),%xmm1
mulss  -0xac(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0xac(%rbp),%xmm2
ff
movss  -0x50(%rbp),%xmm1
mulss  -0xa8(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
addss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
addss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
subss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
subss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa4(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
movss  -0x90(%rbp),%xmm2
ff
movss  -0x78(%rbp),%xmm1
mulss  -0x94(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
movss  -0x94(%rbp),%xmm2
ff
movss  -0x78(%rbp),%xmm1
mulss  -0x90(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0x5c(%rbp),%xmm0
movss  -0xa0(%rbp),%xmm2
ff
movss  -0x58(%rbp),%xmm1
mulss  -0xa4(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0x5c(%rbp),%xmm0
movss  -0xa4(%rbp),%xmm2
ff
movss  -0x58(%rbp),%xmm1
mulss  -0xa0(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
addss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
addss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
subss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
subss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
movss  -0x98(%rbp),%xmm2
ff
movss  -0x80(%rbp),%xmm1
mulss  -0x9c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
movss  -0x9c(%rbp),%xmm2
ff
movss  -0x80(%rbp),%xmm1
mulss  -0x98(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0x64(%rbp),%xmm0
movss  -0xa8(%rbp),%xmm2
ff
movss  -0x60(%rbp),%xmm1
mulss  -0xac(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0x64(%rbp),%xmm0
movss  -0xac(%rbp),%xmm2
ff
movss  -0x60(%rbp),%xmm1
mulss  -0xa8(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
addss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
addss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
subss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
subss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
movss  -0x5c(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x88(%rbp),%xmm0
ff
movss  -0x58(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x8c(%rbp),%xmm0
ff
movss  -0x64(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x8c(%rbp),%xmm0
ff
movss  -0x60(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x88(%rbp),%xmm0
ff
movss  -0x7c(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x88(%rbp),%xmm0
ff
movss  -0x78(%rbp),%xmm2
movss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x8c(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
movss  -0x70(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x8c(%rbp),%xmm0
ff
movss  -0x80(%rbp),%xmm2
movss  -0x74(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x1c(%rbp)
jmp    1612 <cftmdl2+0x4f2>
mov    -0x18(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jne    2846 <cftmdl2+0x1726>
jmp    2aa3 <cftmdl2+0x1983>
movss  -0x38(%rbp),%xmm0
cvtsi2ssl -0x18(%rbp),%xmm1
mulss  %xmm1,%xmm0
call   1040 <cos@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x38(%rbp),%xmm0
cvtsi2ssl -0x18(%rbp),%xmm1
mulss  %xmm1,%xmm0
call   1030 <sin@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  0x1788(%rip),%xmm0
mulss  -0x5c(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x58(%rbp),%xmm1
movss  -0x64(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x5c(%rbp),%xmm1
movss  -0x64(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
subss  -0x5c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm1
addss  -0x58(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x44(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x60(%rbp),%xmm1
subss  -0x64(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x44(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x64(%rbp),%xmm1
addss  -0x60(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x3c(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x5c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  0x1653(%rip),%xmm0
mulss  -0x4c(%rbp),%xmm0
mulss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x48(%rbp),%xmm1
movss  -0x54(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x4c(%rbp),%xmm1
movss  -0x54(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x48(%rbp),%xmm1
subss  -0x4c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm1
addss  -0x48(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x44(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x50(%rbp),%xmm1
subss  -0x54(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x44(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x54(%rbp),%xmm1
addss  -0x50(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    15e4 <cftmdl2+0x4c4>
movss  0x156d(%rip),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  0x155c(%rip),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0x48(%rbp),%xmm0
movss  -0x90(%rbp),%xmm2
ff
movss  -0x4c(%rbp),%xmm1
mulss  -0x94(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x48(%rbp),%xmm0
movss  -0x94(%rbp),%xmm2
ff
movss  -0x4c(%rbp),%xmm1
mulss  -0x90(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0x68(%rbp),%xmm0
movss  -0xa0(%rbp),%xmm2
ff
movss  -0x6c(%rbp),%xmm1
mulss  -0xa4(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0x68(%rbp),%xmm0
movss  -0xa4(%rbp),%xmm2
ff
movss  -0x6c(%rbp),%xmm1
mulss  -0xa0(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
addss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
addss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
subss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
subss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
movss  -0x98(%rbp),%xmm2
ff
movss  -0x54(%rbp),%xmm1
mulss  -0x9c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x50(%rbp),%xmm0
movss  -0x9c(%rbp),%xmm2
ff
movss  -0x54(%rbp),%xmm1
mulss  -0x98(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0x70(%rbp),%xmm0
movss  -0xa8(%rbp),%xmm2
ff
movss  -0x74(%rbp),%xmm1
mulss  -0xac(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0x70(%rbp),%xmm0
movss  -0xac(%rbp),%xmm2
ff
movss  -0x74(%rbp),%xmm1
mulss  -0xa8(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
addss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
addss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
subss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
subss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xac(%rbp)
movss  -0x58(%rbp),%xmm0
movss  -0x90(%rbp),%xmm2
ff
movss  -0x5c(%rbp),%xmm1
mulss  -0x94(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x58(%rbp),%xmm0
movss  -0x94(%rbp),%xmm2
ff
movss  -0x5c(%rbp),%xmm1
mulss  -0x90(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0x5c(%rbp),%xmm0
movss  -0xa0(%rbp),%xmm2
ff
movss  -0x58(%rbp),%xmm1
mulss  -0xa4(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0x5c(%rbp),%xmm0
movss  -0xa4(%rbp),%xmm2
ff
movss  -0x58(%rbp),%xmm1
mulss  -0xa0(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
addss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
addss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
subss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
subss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
movss  -0x98(%rbp),%xmm2
ff
movss  -0x58(%rbp),%xmm1
mulss  -0x9c(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x5c(%rbp),%xmm0
movss  -0x9c(%rbp),%xmm2
ff
movss  -0x58(%rbp),%xmm1
mulss  -0x98(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0x58(%rbp),%xmm0
movss  -0xa8(%rbp),%xmm2
ff
movss  -0x5c(%rbp),%xmm1
mulss  -0xac(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0x58(%rbp),%xmm0
movss  -0xac(%rbp),%xmm2
ff
movss  -0x5c(%rbp),%xmm1
mulss  -0xa8(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
subss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
subss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
addss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
addss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
movss  -0x90(%rbp),%xmm2
ff
movss  -0x68(%rbp),%xmm1
mulss  -0x94(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
movss  -0x94(%rbp),%xmm2
ff
movss  -0x68(%rbp),%xmm1
mulss  -0x90(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0x4c(%rbp),%xmm0
movss  -0xa0(%rbp),%xmm2
ff
movss  -0x48(%rbp),%xmm1
mulss  -0xa4(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0x4c(%rbp),%xmm0
movss  -0xa4(%rbp),%xmm2
ff
movss  -0x48(%rbp),%xmm1
mulss  -0xa0(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
addss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
addss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
subss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
subss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
movss  -0x98(%rbp),%xmm2
ff
movss  -0x70(%rbp),%xmm1
mulss  -0x9c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x74(%rbp),%xmm0
movss  -0x9c(%rbp),%xmm2
ff
movss  -0x70(%rbp),%xmm1
mulss  -0x98(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0xa8(%rbp),%xmm2
ff
movss  -0x50(%rbp),%xmm1
mulss  -0xac(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0xac(%rbp),%xmm2
ff
movss  -0x50(%rbp),%xmm1
mulss  -0xa8(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
addss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
addss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
subss  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
subss  -0xbc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cftmdl2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%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
movss  (%rsi,%rcx,4),%xmm4
movss  (%rsi),%xmm8
movss  0x4(%rsi),%xmm9
movaps %xmm8,%xmm2
subss  %xmm4,%xmm2
cltq
movss  (%rsi,%rax,4),%xmm5
movaps %xmm9,%xmm3
addss  %xmm5,%xmm3
addss  %xmm4,%xmm8
subss  %xmm5,%xmm9
movslq %edx,%rbp
movss  (%rsi,%rbp,4),%xmm5
movslq %edi,%rsi
or     $0x1,%edi
movslq %edi,%rdx
movss  (%rbx,%rdx,4),%xmm6
movaps %xmm5,%xmm7
subss  %xmm6,%xmm7
lea    0x1(%r14,%r14,1),%edi
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm0
movss  (%rbx,%rsi,4),%xmm1
movaps %xmm0,%xmm4
addss  %xmm1,%xmm4
addss  %xmm6,%xmm5
subss  %xmm1,%xmm0
movaps %xmm7,%xmm1
subss  %xmm4,%xmm1
movss  0x1e2d(%rip),%xmm6
mulss  %xmm6,%xmm1
addss  %xmm7,%xmm4
mulss  %xmm6,%xmm4
movaps %xmm2,%xmm7
addss  %xmm1,%xmm7
movss  %xmm7,(%rbx)
movaps %xmm3,%xmm7
addss  %xmm4,%xmm7
movss  %xmm7,0x4(%rbx)
subss  %xmm1,%xmm2
movss  %xmm2,(%rbx,%rbp,4)
subss  %xmm4,%xmm3
movss  %xmm3,(%rbx,%rdi,4)
movaps %xmm5,%xmm1
subss  %xmm0,%xmm1
mulss  %xmm6,%xmm1
addss  %xmm5,%xmm0
mulss  %xmm6,%xmm0
movaps %xmm8,%xmm2
subss  %xmm0,%xmm2
movss  %xmm2,(%rbx,%rax,4)
movaps %xmm9,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rbx,%rcx,4)
addss  %xmm8,%xmm0
movss  %xmm0,(%rbx,%rsi,4)
subss  %xmm1,%xmm9
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm9,(%rbx,%rdx,4)
movss  0x1dab(%rip),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x2c(%rsp)
movaps %xmm1,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rsp)
call   1040 <cos@plt>
mov    %rax,%r15
movss  (%rsp),%xmm0
call   1030 <sin@plt>
xorps  %xmm3,%xmm3
cvtsi2ss %r15,%xmm3
xorps  %xmm4,%xmm4
cvtsi2ss %rax,%xmm4
movaps %xmm3,%xmm2
unpcklps %xmm4,%xmm2
movaps %xmm4,%xmm7
addss  %xmm4,%xmm7
movss  0x1d62(%rip),%xmm0
mulss  %xmm7,%xmm0
mulss  %xmm3,%xmm0
shufps $0x0,%xmm0,%xmm0
movaps %xmm2,%xmm1
shufps $0xe1,%xmm2,%xmm1
mulps  %xmm2,%xmm0
addps  %xmm1,%xmm0
movaps %xmm3,0xc0(%rsp)
movaps %xmm3,%xmm1
shufps $0x10,%xmm0,%xmm1
movaps %xmm4,%xmm3
shufps $0x40,%xmm0,%xmm3
shufps $0x14,%xmm0,%xmm2
addss  %xmm0,%xmm0
movaps %xmm1,%xmm5
subps  %xmm3,%xmm5
addps  %xmm1,%xmm3
shufps $0xd8,%xmm3,%xmm5
shufps $0xd8,%xmm5,%xmm5
mov    %r14,0x70(%rsp)
lea    -0x4(%r14),%r13d
movaps 0x1d22(%rip),%xmm6
movaps %xmm7,%xmm1
xorps  %xmm6,%xmm1
movaps %xmm0,%xmm3
xorps  %xmm6,%xmm3
movaps %xmm4,0xb0(%rsp)
xorps  %xmm4,%xmm6
movaps %xmm6,0xa0(%rsp)
movaps %xmm3,%xmm4
unpcklps %xmm0,%xmm4
movaps %xmm1,%xmm6
unpcklps %xmm7,%xmm6
movlhps %xmm4,%xmm6
movaps %xmm6,0xd0(%rsp)
unpcklps %xmm3,%xmm0
unpcklps %xmm1,%xmm7
movlhps %xmm0,%xmm7
lea    -0x1(%rbp),%rax
mov    %rax,0x98(%rsp)
lea    -0x4(,%rbp,8),%rax
ff
mov    %rax,0x90(%rsp)
lea    0x0(%rbp,%rbp,2),%rax
lea    -0x4(,%rax,4),%rax
ff
mov    %rax,0x88(%rsp)
mov    %rbp,%r14
shl    $0x4,%r14
add    $0xfffffffffffffffc,%r14
lea    0x5(%rbp),%rax
mov    %rax,0x80(%rsp)
lea    0x5(,%rbp,1),%rax
add    %rbp,%rax
mov    %rax,0x78(%rsp)
lea    0x5(,%rbp,2),%r15
add    %rbp,%r15
movaps 0x1c88(%rip),%xmm13
movaps 0x1c91(%rip),%xmm0
xor    %eax,%eax
movaps %xmm0,%xmm14
movaps %xmm7,0x30(%rsp)
nopw   0x0(%rax,%rax,1)
mulps  %xmm0,%xmm5
lea    0x80(%rax),%r8d
cmp    %r13d,%r8d
mov    %r8d,%r12d
cmovg  %r13d,%r12d
lea    0x2(%rax),%ecx
cmp    %r12d,%ecx
jge    1ae5 <cftmdl2+0x9c5>
movslq %eax,%r10
lea    0x2(%r10),%rdx
movslq %r12d,%r9
mov    0x98(%rsp),%r11
sub    %r10,%r11
lea    0x0(,%r10,4),%rcx
mov    0x90(%rsp),%rbp
sub    %rcx,%rbp
mov    0x88(%rsp),%rax
sub    %rcx,%rax
mov    %r14,%rsi
sub    %rcx,%rsi
mov    0x80(%rsp),%rcx
add    %r10,%rcx
mov    0x78(%rsp),%rdi
add    %r10,%rdi
add    %r15,%r10
nop
movaps %xmm5,%xmm15
movaps %xmm7,%xmm0
mulps  %xmm2,%xmm0
movaps 0x30(%rsp),%xmm9
mulps  %xmm5,%xmm9
movss  -0xc(%rbx,%rdi,4),%xmm1
movss  -0x8(%rbx,%rdi,4),%xmm3
addps  %xmm0,%xmm13
movaps %xmm13,0x10(%rsp)
movss  (%rbx,%rdx,4),%xmm11
movss  0x4(%rbx,%rdx,4),%xmm12
movaps %xmm11,%xmm5
subss  %xmm3,%xmm5
movaps %xmm12,%xmm6
addss  %xmm1,%xmm6
addss  %xmm3,%xmm11
movss  -0xc(%rbx,%r10,4),%xmm7
movss  -0x8(%rbx,%r10,4),%xmm4
subss  %xmm1,%xmm12
movss  -0xc(%rbx,%rcx,4),%xmm8
movss  -0x8(%rbx,%rcx,4),%xmm10
movaps %xmm8,%xmm3
subss  %xmm4,%xmm3
movaps %xmm10,%xmm1
addss  %xmm7,%xmm1
addss  %xmm4,%xmm8
subss  %xmm7,%xmm10
movaps %xmm2,%xmm0
movaps %xmm2,%xmm4
shufps $0x55,%xmm2,%xmm4
movaps %xmm4,0x60(%rsp)
addps  %xmm9,%xmm14
movaps %xmm14,(%rsp)
mulss  %xmm6,%xmm2
mulss  %xmm4,%xmm6
movaps %xmm0,%xmm7
mulss  %xmm5,%xmm7
subss  %xmm6,%xmm7
mulss  %xmm4,%xmm5
movaps %xmm15,%xmm4
shufps $0x55,%xmm15,%xmm4
movaps %xmm15,%xmm6
mulss  %xmm1,%xmm6
addss  %xmm2,%xmm5
mulss  %xmm4,%xmm1
movaps %xmm15,%xmm2
mulss  %xmm3,%xmm2
mulss  %xmm4,%xmm3
subss  %xmm1,%xmm2
addss  %xmm6,%xmm3
movaps %xmm7,%xmm14
addss  %xmm2,%xmm14
movaps %xmm5,%xmm9
addss  %xmm3,%xmm9
subss  %xmm2,%xmm7
subss  %xmm3,%xmm5
movaps %xmm0,0x50(%rsp)
movaps %xmm0,%xmm3
shufps $0xff,%xmm0,%xmm3
movaps %xmm3,%xmm2
movaps %xmm3,%xmm1
movaps %xmm3,0x110(%rsp)
movaps %xmm0,%xmm3
unpckhpd %xmm0,%xmm3
movaps %xmm3,0x120(%rsp)
movaps %xmm3,%xmm6
mulss  %xmm12,%xmm2
mulss  %xmm11,%xmm6
addss  %xmm2,%xmm6
mulss  %xmm1,%xmm11
movss  %xmm14,(%rbx,%rdx,4)
mulss  %xmm3,%xmm12
subss  %xmm11,%xmm12
movaps %xmm15,%xmm14
movaps %xmm15,0x40(%rsp)
movaps %xmm15,%xmm0
shufps $0xff,%xmm15,%xmm0
movaps %xmm0,%xmm1
movaps %xmm0,%xmm2
movaps %xmm0,0xf0(%rsp)
movss  %xmm9,0x4(%rbx,%rdx,4)
mulss  %xmm10,%xmm1
unpckhpd %xmm15,%xmm14
movaps %xmm14,%xmm0
mulss  %xmm8,%xmm0
movss  %xmm7,-0xc(%rbx,%rcx,4)
addss  %xmm1,%xmm0
mulss  %xmm2,%xmm8
mulss  %xmm14,%xmm10
movss  %xmm5,-0x8(%rbx,%rcx,4)
subss  %xmm8,%xmm10
movaps %xmm6,%xmm1
addss  %xmm0,%xmm1
movaps %xmm12,%xmm5
addss  %xmm10,%xmm5
movss  %xmm1,-0xc(%rbx,%rdi,4)
movss  %xmm5,-0x8(%rbx,%rdi,4)
subss  %xmm0,%xmm6
subss  %xmm10,%xmm12
movss  %xmm6,-0xc(%rbx,%r10,4)
movss  %xmm12,-0x8(%rbx,%r10,4)
movss  -0x4(%rbx,%rdi,4),%xmm9
movss  (%rbx,%rdi,4),%xmm1
movss  0x8(%rbx,%rdx,4),%xmm6
movss  0xc(%rbx,%rdx,4),%xmm10
movaps %xmm6,%xmm5
subss  %xmm1,%xmm5
movaps %xmm10,%xmm8
addss  %xmm9,%xmm8
addss  %xmm1,%xmm6
movss  -0x4(%rbx,%r10,4),%xmm7
movss  (%rbx,%r10,4),%xmm0
movss  -0x4(%rbx,%rcx,4),%xmm11
subss  %xmm9,%xmm10
movaps %xmm11,%xmm12
subss  %xmm0,%xmm12
addss  %xmm0,%xmm11
movss  (%rbx,%rcx,4),%xmm9
movaps %xmm9,%xmm0
addss  %xmm7,%xmm0
subss  %xmm7,%xmm9
movaps %xmm8,%xmm1
mulss  %xmm13,%xmm1
movaps %xmm13,%xmm2
shufps $0x55,%xmm13,%xmm2
movaps %xmm2,0x100(%rsp)
movaps %xmm2,%xmm15
mulss  %xmm5,%xmm15
subss  %xmm1,%xmm15
mulss  %xmm13,%xmm5
mulss  %xmm2,%xmm8
addss  %xmm5,%xmm8
movaps %xmm0,%xmm13
mulss  (%rsp),%xmm13
movaps (%rsp),%xmm2
shufps $0x55,%xmm2,%xmm2
movaps %xmm2,0xe0(%rsp)
movaps %xmm2,%xmm1
mulss  %xmm12,%xmm1
subss  %xmm13,%xmm1
mulss  (%rsp),%xmm12
mulss  %xmm2,%xmm0
addss  %xmm12,%xmm0
movaps %xmm15,%xmm7
addss  %xmm1,%xmm7
movss  %xmm7,0x8(%rbx,%rdx,4)
subss  %xmm1,%xmm15
movaps %xmm8,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0xc(%rbx,%rdx,4)
movss  %xmm15,-0x4(%rbx,%rcx,4)
subss  %xmm0,%xmm8
movaps 0x10(%rsp),%xmm13
movhlps %xmm13,%xmm13
movaps %xmm13,%xmm1
mulss  %xmm10,%xmm1
movaps 0x10(%rsp),%xmm12
shufps $0xff,%xmm12,%xmm12
movaps %xmm12,%xmm0
mulss  %xmm6,%xmm0
addss  %xmm1,%xmm0
mulss  %xmm13,%xmm6
mulss  %xmm12,%xmm10
subss  %xmm6,%xmm10
movaps (%rsp),%xmm15
movhlps %xmm15,%xmm15
movaps %xmm15,%xmm1
mulss  %xmm9,%xmm1
movaps (%rsp),%xmm6
shufps $0xff,%xmm6,%xmm6
movaps %xmm6,%xmm7
mulss  %xmm11,%xmm7
addss  %xmm1,%xmm7
movss  %xmm8,(%rbx,%rcx,4)
mulss  %xmm15,%xmm11
mulss  %xmm6,%xmm9
subss  %xmm11,%xmm9
movaps %xmm0,%xmm1
addss  %xmm7,%xmm1
movss  %xmm1,-0x4(%rbx,%rdi,4)
subss  %xmm7,%xmm0
movaps %xmm10,%xmm1
addss  %xmm9,%xmm1
movss  %xmm1,(%rbx,%rdi,4)
movss  %xmm0,-0x4(%rbx,%r10,4)
subss  %xmm9,%xmm10
movss  %xmm10,(%rbx,%r10,4)
movss  (%rbx,%rax,1),%xmm0
movss  -0x4(%rbx,%r11,4),%xmm11
movaps %xmm11,%xmm7
subss  %xmm0,%xmm7
addss  %xmm0,%xmm11
movss  -0x4(%rbx,%rax,1),%xmm0
movss  (%rbx,%r11,4),%xmm8
movaps %xmm8,%xmm9
addss  %xmm0,%xmm9
subss  %xmm0,%xmm8
movss  (%rbx,%rsi,1),%xmm0
movss  -0x4(%rbx,%rbp,1),%xmm3
movaps %xmm3,%xmm1
subss  %xmm0,%xmm1
addss  %xmm0,%xmm3
movss  -0x4(%rbx,%rsi,1),%xmm2
movss  (%rbx,%rbp,1),%xmm5
movaps %xmm5,%xmm10
addss  %xmm2,%xmm10
subss  %xmm2,%xmm5
movaps %xmm9,%xmm2
movaps 0x40(%rsp),%xmm0
mulss  %xmm0,%xmm2
mulss  %xmm4,%xmm9
mulss  %xmm7,%xmm4
subss  %xmm2,%xmm4
mulss  %xmm0,%xmm7
addss  %xmm7,%xmm9
movaps %xmm10,%xmm2
movaps 0x50(%rsp),%xmm0
mulss  %xmm0,%xmm2
movaps 0x60(%rsp),%xmm7
mulss  %xmm7,%xmm10
mulss  %xmm1,%xmm7
subss  %xmm2,%xmm7
mulss  %xmm0,%xmm1
addss  %xmm1,%xmm10
movaps %xmm4,%xmm1
addss  %xmm7,%xmm1
movss  %xmm1,-0x4(%rbx,%r11,4)
subss  %xmm7,%xmm4
movaps %xmm9,%xmm1
addss  %xmm10,%xmm1
movss  %xmm1,(%rbx,%r11,4)
subss  %xmm10,%xmm9
movaps 0xf0(%rsp),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm11,%xmm1
mulss  %xmm14,%xmm11
mulss  %xmm8,%xmm14
addss  %xmm14,%xmm1
mulss  %xmm0,%xmm8
subss  %xmm11,%xmm8
movaps 0x110(%rsp),%xmm0
movaps %xmm0,%xmm2
mulss  %xmm3,%xmm2
movaps 0x120(%rsp),%xmm7
mulss  %xmm7,%xmm3
mulss  %xmm5,%xmm7
addss  %xmm7,%xmm2
movss  %xmm4,-0x4(%rbx,%rbp,1)
mulss  %xmm0,%xmm5
subss  %xmm3,%xmm5
movaps %xmm1,%xmm3
addss  %xmm2,%xmm3
movss  %xmm9,(%rbx,%rbp,1)
movss  %xmm3,-0x4(%rbx,%rax,1)
movaps %xmm8,%xmm3
addss  %xmm5,%xmm3
subss  %xmm2,%xmm1
movss  %xmm3,(%rbx,%rax,1)
movss  %xmm1,-0x4(%rbx,%rsi,1)
subss  %xmm5,%xmm8
movss  %xmm8,(%rbx,%rsi,1)
movss  -0xc(%rbx,%rax,1),%xmm4
movss  -0x8(%rbx,%rax,1),%xmm2
movss  -0xc(%rbx,%r11,4),%xmm8
movss  -0x8(%rbx,%r11,4),%xmm11
movaps %xmm8,%xmm0
subss  %xmm2,%xmm0
movaps %xmm11,%xmm7
addss  %xmm4,%xmm7
addss  %xmm2,%xmm8
movss  -0xc(%rbx,%rsi,1),%xmm10
subss  %xmm4,%xmm11
movss  -0x8(%rbx,%rsi,1),%xmm2
movss  -0xc(%rbx,%rbp,1),%xmm9
movaps %xmm9,%xmm4
subss  %xmm2,%xmm4
addss  %xmm2,%xmm9
movss  -0x8(%rbx,%rbp,1),%xmm1
movaps %xmm1,%xmm2
addss  %xmm10,%xmm2
subss  %xmm10,%xmm1
movaps (%rsp),%xmm10
mulss  %xmm7,%xmm10
movaps 0xe0(%rsp),%xmm5
mulss  %xmm5,%xmm7
movaps (%rsp),%xmm3
mulss  %xmm0,%xmm3
mulss  %xmm5,%xmm0
subss  %xmm7,%xmm3
addss  %xmm10,%xmm0
movaps 0x10(%rsp),%xmm5
mulss  %xmm2,%xmm5
movaps 0x100(%rsp),%xmm10
mulss  %xmm10,%xmm2
movaps 0x10(%rsp),%xmm7
mulss  %xmm4,%xmm7
subss  %xmm2,%xmm7
mulss  %xmm10,%xmm4
addss  %xmm5,%xmm4
movaps %xmm3,%xmm2
addss  %xmm7,%xmm2
movss  %xmm2,-0xc(%rbx,%r11,4)
subss  %xmm7,%xmm3
movaps %xmm0,%xmm2
addss  %xmm4,%xmm2
movss  %xmm2,-0x8(%rbx,%r11,4)
movss  %xmm3,-0xc(%rbx,%rbp,1)
subss  %xmm4,%xmm0
movaps %xmm15,%xmm2
mulss  %xmm8,%xmm2
mulss  %xmm6,%xmm8
mulss  %xmm11,%xmm6
addss  %xmm6,%xmm2
movaps 0xd0(%rsp),%xmm4
mulss  %xmm15,%xmm11
movaps (%rsp),%xmm14
movss  %xmm0,-0x8(%rbx,%rbp,1)
subss  %xmm8,%xmm11
movaps %xmm13,%xmm0
mulss  %xmm9,%xmm0
mulss  %xmm12,%xmm9
mulss  %xmm1,%xmm12
addss  %xmm12,%xmm0
mulss  %xmm13,%xmm1
movaps 0x10(%rsp),%xmm13
subss  %xmm9,%xmm1
movaps 0x30(%rsp),%xmm7
movaps %xmm2,%xmm3
addss  %xmm0,%xmm3
movss  %xmm3,-0xc(%rbx,%rax,1)
movaps 0x50(%rsp),%xmm3
subss  %xmm0,%xmm2
movaps %xmm11,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8(%rbx,%rax,1)
movss  %xmm2,-0xc(%rbx,%rsi,1)
subss  %xmm1,%xmm11
movaps %xmm4,%xmm0
mulps  %xmm13,%xmm0
movaps %xmm0,%xmm2
movss  %xmm11,-0x8(%rbx,%rsi,1)
addps  %xmm3,%xmm2
movaps %xmm4,%xmm1
movaps 0x40(%rsp),%xmm4
mulps  %xmm14,%xmm1
movaps %xmm1,%xmm5
addps  %xmm4,%xmm5
add    $0x4,%rdx
add    $0xfffffffffffffffc,%r11
add    $0xfffffffffffffff0,%rbp
add    $0xfffffffffffffff0,%rax
add    $0xfffffffffffffff0,%rsi
add    $0x4,%rcx
add    $0x4,%rdi
add    $0x4,%r10
cmp    %r9,%rdx
jl     1430 <cftmdl2+0x310>
addps  %xmm4,%xmm1
addps  %xmm3,%xmm0
movaps %xmm1,%xmm5
movaps %xmm0,%xmm2
cmp    %r8d,%r13d
jle    1c2e <cftmdl2+0xb0e>
xorps  %xmm0,%xmm0
cvtsi2ss %r12d,%xmm0
mulss  0x2c(%rsp),%xmm0
movss  %xmm0,0x10(%rsp)
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movaps %xmm0,(%rsp)
movss  0x10(%rsp),%xmm0
call   1030 <sin@plt>
movaps 0x30(%rsp),%xmm7
xorps  %xmm13,%xmm13
cvtsi2ss %rax,%xmm13
movaps %xmm13,%xmm0
movss  0x14e4(%rip),%xmm1
mulss  %xmm1,%xmm0
movaps (%rsp),%xmm4
mulss  %xmm4,%xmm0
movaps %xmm0,%xmm8
mulss  %xmm13,%xmm8
addss  %xmm4,%xmm8
mulss  %xmm4,%xmm0
addss  %xmm13,%xmm0
movaps %xmm4,%xmm2
movlhps %xmm0,%xmm2
movaps %xmm4,%xmm3
movaps %xmm4,%xmm9
shufps $0x0,%xmm8,%xmm3
movaps %xmm13,%xmm14
movlhps %xmm8,%xmm14
addps  %xmm2,%xmm14
movaps %xmm13,%xmm2
shufps $0x20,%xmm0,%xmm2
subps  %xmm2,%xmm3
shufps $0xd8,%xmm3,%xmm14
movaps 0xa0(%rsp),%xmm2
mulss  %xmm13,%xmm2
movaps 0xc0(%rsp),%xmm4
movaps %xmm4,%xmm3
mulss  %xmm9,%xmm3
addss  %xmm2,%xmm3
movaps 0xb0(%rsp),%xmm2
mulss  %xmm9,%xmm2
mulss  %xmm13,%xmm4
addss  %xmm2,%xmm4
movaps %xmm4,%xmm6
mulss  %xmm1,%xmm6
mulss  %xmm3,%xmm6
movaps %xmm6,%xmm1
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
mulss  %xmm3,%xmm6
addss  %xmm4,%xmm6
movaps %xmm3,%xmm2
unpcklps %xmm4,%xmm2
movaps %xmm2,%xmm5
unpcklps %xmm3,%xmm4
movlhps %xmm6,%xmm4
movlhps %xmm1,%xmm6
shufps $0x24,%xmm6,%xmm2
movlhps %xmm1,%xmm5
subps  %xmm4,%xmm5
shufps $0x0,%xmm1,%xmm3
addps  %xmm2,%xmm3
shufps $0xd8,%xmm3,%xmm5
unpcklps %xmm9,%xmm13
movlhps %xmm0,%xmm8
movaps 0x142c(%rip),%xmm0
shufps $0x24,%xmm8,%xmm13
shufps $0xd8,%xmm14,%xmm14
mulps  %xmm0,%xmm14
shufps $0xd8,%xmm5,%xmm5
mov    %r12d,%eax
jmp    13c0 <cftmdl2+0x2a0>
mov    0x70(%rsp),%rdx
lea    (%rdx,%rdx,2),%esi
lea    (%rdx,%rdx,4),%eax
lea    0x0(,%rdx,8),%ecx
sub    %edx,%ecx
cltq
movss  -0x8(%rbx,%rax,4),%xmm1
movss  -0x4(%rbx,%rax,4),%xmm3
movslq %edx,%rdx
movss  -0x8(%rbx,%rdx,4),%xmm8
movss  -0x4(%rbx,%rdx,4),%xmm15
movaps %xmm8,%xmm4
subss  %xmm3,%xmm4
movaps %xmm15,%xmm0
addss  %xmm1,%xmm0
addss  %xmm3,%xmm8
subss  %xmm1,%xmm15
movslq %ecx,%rcx
movss  -0x8(%rbx,%rcx,4),%xmm10
movss  -0x4(%rbx,%rcx,4),%xmm11
movslq %esi,%rsi
movss  -0x8(%rbx,%rsi,4),%xmm9
movss  -0x4(%rbx,%rsi,4),%xmm14
movaps %xmm9,%xmm7
subss  %xmm11,%xmm7
movaps %xmm14,%xmm1
addss  %xmm10,%xmm1
addss  %xmm11,%xmm9
subss  %xmm10,%xmm14
movaps %xmm2,%xmm3
shufps $0x55,%xmm2,%xmm3
movaps %xmm3,(%rsp)
movaps %xmm2,%xmm10
mulss  %xmm0,%xmm10
mulss  %xmm3,%xmm0
movaps %xmm2,%xmm6
mulss  %xmm4,%xmm6
subss  %xmm0,%xmm6
mulss  %xmm3,%xmm4
addss  %xmm10,%xmm4
movaps %xmm5,%xmm0
shufps $0x55,%xmm5,%xmm0
movaps %xmm0,0x40(%rsp)
movaps %xmm5,%xmm10
mulss  %xmm1,%xmm10
mulss  %xmm0,%xmm1
movaps %xmm5,%xmm3
mulss  %xmm7,%xmm3
subss  %xmm1,%xmm3
mulss  %xmm0,%xmm7
addss  %xmm10,%xmm7
movaps %xmm6,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,-0x8(%rbx,%rdx,4)
movaps %xmm4,%xmm0
addss  %xmm7,%xmm0
movss  %xmm0,-0x4(%rbx,%rdx,4)
subss  %xmm3,%xmm6
movss  %xmm6,-0x8(%rbx,%rsi,4)
subss  %xmm7,%xmm4
movss  %xmm4,-0x4(%rbx,%rsi,4)
movaps %xmm2,%xmm1
shufps $0xff,%xmm2,%xmm1
movaps %xmm1,%xmm0
movaps %xmm1,%xmm3
movaps %xmm1,0x50(%rsp)
mulss  %xmm15,%xmm0
movaps %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm1,%xmm4
mulss  %xmm8,%xmm4
addss  %xmm0,%xmm4
mulss  %xmm3,%xmm8
mulss  %xmm1,%xmm15
subss  %xmm8,%xmm15
movaps %xmm5,%xmm1
shufps $0xff,%xmm5,%xmm1
movaps %xmm1,%xmm0
movaps %xmm1,%xmm6
movaps %xmm1,0x60(%rsp)
mulss  %xmm14,%xmm0
movaps %xmm5,%xmm3
unpckhpd %xmm5,%xmm3
movaps %xmm3,0x30(%rsp)
movaps %xmm3,%xmm1
mulss  %xmm9,%xmm1
addss  %xmm0,%xmm1
mulss  %xmm6,%xmm9
mulss  %xmm3,%xmm14
subss  %xmm9,%xmm14
movaps %xmm4,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8(%rbx,%rax,4)
movaps %xmm15,%xmm0
addss  %xmm14,%xmm0
movss  %xmm0,-0x4(%rbx,%rax,4)
subss  %xmm1,%xmm4
movss  %xmm4,-0x8(%rbx,%rcx,4)
subss  %xmm14,%xmm15
movss  %xmm15,-0x4(%rbx,%rcx,4)
movss  (%rbx,%rax,4),%xmm1
movss  0x4(%rbx,%rax,4),%xmm3
movss  (%rbx,%rdx,4),%xmm10
movss  0x4(%rbx,%rdx,4),%xmm7
movaps %xmm10,%xmm9
subss  %xmm3,%xmm9
movaps %xmm7,%xmm0
addss  %xmm1,%xmm0
addss  %xmm3,%xmm10
subss  %xmm1,%xmm7
movss  (%rbx,%rcx,4),%xmm6
movss  0x4(%rbx,%rcx,4),%xmm1
movss  (%rbx,%rsi,4),%xmm12
movaps %xmm12,%xmm11
subss  %xmm1,%xmm11
addss  %xmm1,%xmm12
movss  0x4(%rbx,%rsi,4),%xmm4
movaps %xmm4,%xmm1
addss  %xmm6,%xmm1
subss  %xmm6,%xmm4
movss  0x11b5(%rip),%xmm13
movaps %xmm0,%xmm15
mulss  %xmm13,%xmm15
movss  0x11a7(%rip),%xmm14
movaps %xmm9,%xmm6
mulss  %xmm14,%xmm6
addss  %xmm15,%xmm6
movss  0x1194(%rip),%xmm15
mulss  %xmm15,%xmm9
mulss  %xmm14,%xmm0
addss  %xmm9,%xmm0
movss  0x1180(%rip),%xmm9
movaps %xmm1,%xmm3
mulss  %xmm9,%xmm3
movaps %xmm11,%xmm8
mulss  %xmm15,%xmm8
addss  %xmm3,%xmm8
mulss  %xmm14,%xmm11
mulss  %xmm15,%xmm1
addss  %xmm11,%xmm1
movaps %xmm6,%xmm3
addss  %xmm8,%xmm3
movss  %xmm3,(%rbx,%rdx,4)
movaps %xmm0,%xmm3
addss  %xmm1,%xmm3
movss  %xmm3,0x4(%rbx,%rdx,4)
subss  %xmm8,%xmm6
movss  %xmm6,(%rbx,%rsi,4)
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%rbx,%rsi,4)
mulss  %xmm7,%xmm9
movaps %xmm10,%xmm0
mulss  %xmm15,%xmm0
addss  %xmm9,%xmm0
mulss  %xmm14,%xmm10
mulss  %xmm15,%xmm7
addss  %xmm10,%xmm7
mulss  %xmm4,%xmm13
movaps %xmm12,%xmm1
mulss  %xmm14,%xmm1
addss  %xmm13,%xmm1
mulss  %xmm15,%xmm12
mulss  %xmm14,%xmm4
addss  %xmm12,%xmm4
movaps %xmm0,%xmm3
subss  %xmm1,%xmm3
movss  %xmm3,(%rbx,%rax,4)
movaps %xmm7,%xmm3
subss  %xmm4,%xmm3
movss  %xmm3,0x4(%rbx,%rax,4)
addss  %xmm0,%xmm1
movss  %xmm1,(%rbx,%rcx,4)
addss  %xmm7,%xmm4
movss  %xmm4,0x4(%rbx,%rcx,4)
movss  0x8(%rbx,%rax,4),%xmm1
movss  0xc(%rbx,%rax,4),%xmm4
movss  0x8(%rbx,%rdx,4),%xmm8
movss  0xc(%rbx,%rdx,4),%xmm11
movaps %xmm8,%xmm3
subss  %xmm4,%xmm3
movaps %xmm11,%xmm6
addss  %xmm1,%xmm6
addss  %xmm4,%xmm8
subss  %xmm1,%xmm11
movss  0x8(%rbx,%rcx,4),%xmm9
movss  0xc(%rbx,%rcx,4),%xmm1
movss  0x8(%rbx,%rsi,4),%xmm10
movaps %xmm10,%xmm4
subss  %xmm1,%xmm4
addss  %xmm1,%xmm10
movss  0xc(%rbx,%rsi,4),%xmm12
movaps %xmm12,%xmm7
addss  %xmm9,%xmm7
subss  %xmm9,%xmm12
movaps %xmm6,%xmm0
mulss  %xmm5,%xmm0
movaps 0x40(%rsp),%xmm1
mulss  %xmm1,%xmm6
mulss  %xmm3,%xmm1
subss  %xmm0,%xmm1
mulss  %xmm5,%xmm3
addss  %xmm3,%xmm6
movaps %xmm7,%xmm0
mulss  %xmm2,%xmm0
movaps (%rsp),%xmm3
mulss  %xmm3,%xmm7
mulss  %xmm4,%xmm3
subss  %xmm0,%xmm3
mulss  %xmm2,%xmm4
addss  %xmm4,%xmm7
movaps %xmm1,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,0x8(%rbx,%rdx,4)
movaps %xmm6,%xmm0
addss  %xmm7,%xmm0
movss  %xmm0,0xc(%rbx,%rdx,4)
subss  %xmm3,%xmm1
movss  %xmm1,0x8(%rbx,%rsi,4)
subss  %xmm7,%xmm6
movss  %xmm6,0xc(%rbx,%rsi,4)
movaps 0x60(%rsp),%xmm2
movaps %xmm2,%xmm0
mulss  %xmm8,%xmm0
movaps 0x30(%rsp),%xmm1
mulss  %xmm1,%xmm8
mulss  %xmm11,%xmm1
addss  %xmm1,%xmm0
mulss  %xmm2,%xmm11
subss  %xmm8,%xmm11
movaps 0x50(%rsp),%xmm3
movaps %xmm3,%xmm1
mulss  %xmm10,%xmm1
movaps 0x10(%rsp),%xmm2
mulss  %xmm2,%xmm10
mulss  %xmm12,%xmm2
addss  %xmm2,%xmm1
mulss  %xmm3,%xmm12
subss  %xmm10,%xmm12
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x8(%rbx,%rax,4)
movaps %xmm11,%xmm2
addss  %xmm12,%xmm2
movss  %xmm2,0xc(%rbx,%rax,4)
subss  %xmm1,%xmm0
movss  %xmm0,0x8(%rbx,%rcx,4)
subss  %xmm12,%xmm11
movss  %xmm11,0xc(%rbx,%rcx,4)
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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