#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 cftmdl1(int n, float *a) {
  int i, i0, j, j0, j1, j2, j3, m, mh;
  float ew, w1r, w1i, wk1r, wk1i, wk3r, wk3i, wd1r, wd1i, wd3r, wd3i, ss1, ss3;
  float x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
  mh = n >> 3;
  m = 2 * mh;
  j1 = m;
  j2 = j1 + m;
  j3 = j2 + m;
  x0r = a[0] + a[j2];
  x0i = a[1] + a[j2 + 1];
  x1r = a[0] - a[j2];
  x1i = a[1] - a[j2 + 1];
  x2r = a[j1] + a[j3];
  x2i = a[j1 + 1] + a[j3 + 1];
  x3r = a[j1] - a[j3];
  x3i = a[j1 + 1] - a[j3 + 1];
  a[0] = x0r + x2r;
  a[1] = x0i + x2i;
  a[j1] = x0r - x2r;
  a[j1 + 1] = x0i - x2i;
  a[j2] = x1r - x3i;
  a[j2 + 1] = x1i + x3r;
  a[j3] = x1r + x3i;
  a[j3 + 1] = x1i - x3r;
  wd1r = 1;
  wd1i = 0;
  wd3r = 1;
  wd3i = 0;
  ew = ((float)1.570796326794896619231321691639751442098584699687) / m;
  w1r = (float)cos(2 * ew);
  w1i = (float)sin(2 * ew);
  wk1r = w1r;
  wk1i = w1i;
  ss1 = 2 * w1i;
  wk3i = 2 * ss1 * wk1r;
  wk3r = wk1r - wk3i * wk1i;
  wk3i = wk1i - wk3i * wk1r;
  ss3 = 2 * wk3i;
  i = 0;
  for (;;) {
    i0 = i + 4 * 32;
    if (i0 > mh - 4) {
      i0 = mh - 4;
    }
    for (j = i + 2; j < i0; j += 4) {
      wd1r -= ss1 * wk1i;
      wd1i += ss1 * wk1r;
      wd3r -= ss3 * wk3i;
      wd3i += ss3 * wk3r;
      j1 = j + m;
      j2 = j1 + m;
      j3 = j2 + m;
      x0r = a[j] + a[j2];
      x0i = a[j + 1] + a[j2 + 1];
      x1r = a[j] - a[j2];
      x1i = a[j + 1] - a[j2 + 1];
      x2r = a[j1] + a[j3];
      x2i = a[j1 + 1] + a[j3 + 1];
      x3r = a[j1] - a[j3];
      x3i = a[j1 + 1] - a[j3 + 1];
      a[j] = x0r + x2r;
      a[j + 1] = x0i + x2i;
      a[j1] = x0r - x2r;
      a[j1 + 1] = x0i - x2i;
      x0r = x1r - x3i;
      x0i = x1i + x3r;
      a[j2] = wk1r * x0r - wk1i * x0i;
      a[j2 + 1] = wk1r * x0i + wk1i * x0r;
      x0r = x1r + x3i;
      x0i = x1i - x3r;
      a[j3] = wk3r * x0r + wk3i * x0i;
      a[j3 + 1] = wk3r * x0i - wk3i * x0r;
      x0r = a[j + 2] + a[j2 + 2];
      x0i = a[j + 3] + a[j2 + 3];
      x1r = a[j + 2] - a[j2 + 2];
      x1i = a[j + 3] - a[j2 + 3];
      x2r = a[j1 + 2] + a[j3 + 2];
      x2i = a[j1 + 3] + a[j3 + 3];
      x3r = a[j1 + 2] - a[j3 + 2];
      x3i = a[j1 + 3] - a[j3 + 3];
      a[j + 2] = x0r + x2r;
      a[j + 3] = x0i + x2i;
      a[j1 + 2] = x0r - x2r;
      a[j1 + 3] = x0i - x2i;
      x0r = x1r - x3i;
      x0i = x1i + x3r;
      a[j2 + 2] = wd1r * x0r - wd1i * x0i;
      a[j2 + 3] = wd1r * x0i + wd1i * x0r;
      x0r = x1r + x3i;
      x0i = x1i - x3r;
      a[j3 + 2] = wd3r * x0r + wd3i * x0i;
      a[j3 + 3] = wd3r * x0i - wd3i * x0r;
      j0 = m - j;
      j1 = j0 + m;
      j2 = j1 + m;
      j3 = j2 + m;
      x0r = a[j0] + a[j2];
      x0i = a[j0 + 1] + a[j2 + 1];
      x1r = a[j0] - a[j2];
      x1i = a[j0 + 1] - a[j2 + 1];
      x2r = a[j1] + a[j3];
      x2i = a[j1 + 1] + a[j3 + 1];
      x3r = a[j1] - a[j3];
      x3i = a[j1 + 1] - a[j3 + 1];
      a[j0] = x0r + x2r;
      a[j0 + 1] = x0i + x2i;
      a[j1] = x0r - x2r;
      a[j1 + 1] = x0i - x2i;
      x0r = x1r - x3i;
      x0i = x1i + x3r;
      a[j2] = wk1i * x0r - wk1r * x0i;
      a[j2 + 1] = wk1i * x0i + wk1r * x0r;
      x0r = x1r + x3i;
      x0i = x1i - x3r;
      a[j3] = wk3i * x0r + wk3r * x0i;
      a[j3 + 1] = wk3i * x0i - wk3r * x0r;
      x0r = a[j0 - 2] + a[j2 - 2];
      x0i = a[j0 - 1] + a[j2 - 1];
      x1r = a[j0 - 2] - a[j2 - 2];
      x1i = a[j0 - 1] - a[j2 - 1];
      x2r = a[j1 - 2] + a[j3 - 2];
      x2i = a[j1 - 1] + a[j3 - 1];
      x3r = a[j1 - 2] - a[j3 - 2];
      x3i = a[j1 - 1] - a[j3 - 1];
      a[j0 - 2] = x0r + x2r;
      a[j0 - 1] = x0i + x2i;
      a[j1 - 2] = x0r - x2r;
      a[j1 - 1] = x0i - x2i;
      x0r = x1r - x3i;
      x0i = x1i + x3r;
      a[j2 - 2] = wd1i * x0r - wd1r * x0i;
      a[j2 - 1] = wd1i * x0i + wd1r * x0r;
      x0r = x1r + x3i;
      x0i = x1i - x3r;
      a[j3 - 2] = wd3i * x0r + wd3r * x0i;
      a[j3 - 1] = wd3i * x0i - wd3r * x0r;
      wk1r -= ss1 * wd1i;
      wk1i += ss1 * wd1r;
      wk3r -= ss3 * wd3i;
      wk3i += ss3 * wd3r;
    }
    if (i0 == mh - 4) {
      break;
    }
    wd1r = (float)cos(ew * i0);
    wd1i = (float)sin(ew * i0);
    wd3i = 4 * wd1i * wd1r;
    wd3r = wd1r - wd3i * wd1i;
    wd3i = wd1i - wd3i * wd1r;
    wk1r = w1r * wd1r - w1i * wd1i;
    wk1i = w1r * wd1i + w1i * wd1r;
    wk3i = 4 * wk1i * wk1r;
    wk3r = wk1r - wk3i * wk1i;
    wk3i = wk1i - wk3i * wk1r;
    i = i0;
  }
  wd1r = ((float)0.707106781186547524400844362104849039284835937688);
  j0 = mh;
  j1 = j0 + m;
  j2 = j1 + m;
  j3 = j2 + m;
  x0r = a[j0 - 2] + a[j2 - 2];
  x0i = a[j0 - 1] + a[j2 - 1];
  x1r = a[j0 - 2] - a[j2 - 2];
  x1i = a[j0 - 1] - a[j2 - 1];
  x2r = a[j1 - 2] + a[j3 - 2];
  x2i = a[j1 - 1] + a[j3 - 1];
  x3r = a[j1 - 2] - a[j3 - 2];
  x3i = a[j1 - 1] - a[j3 - 1];
  a[j0 - 2] = x0r + x2r;
  a[j0 - 1] = x0i + x2i;
  a[j1 - 2] = x0r - x2r;
  a[j1 - 1] = x0i - x2i;
  x0r = x1r - x3i;
  x0i = x1i + x3r;
  a[j2 - 2] = wk1r * x0r - wk1i * x0i;
  a[j2 - 1] = wk1r * x0i + wk1i * x0r;
  x0r = x1r + x3i;
  x0i = x1i - x3r;
  a[j3 - 2] = wk3r * x0r + wk3i * x0i;
  a[j3 - 1] = wk3r * x0i - wk3i * x0r;
  x0r = a[j0] + a[j2];
  x0i = a[j0 + 1] + a[j2 + 1];
  x1r = a[j0] - a[j2];
  x1i = a[j0 + 1] - a[j2 + 1];
  x2r = a[j1] + a[j3];
  x2i = a[j1 + 1] + a[j3 + 1];
  x3r = a[j1] - a[j3];
  x3i = a[j1 + 1] - a[j3 + 1];
  a[j0] = x0r + x2r;
  a[j0 + 1] = x0i + x2i;
  a[j1] = x0r - x2r;
  a[j1 + 1] = x0i - x2i;
  x0r = x1r - x3i;
  x0i = x1i + x3r;
  a[j2] = wd1r * (x0r - x0i);
  a[j2 + 1] = wd1r * (x0i + x0r);
  x0r = x1r + x3i;
  x0i = x1i - x3r;
  a[j3] = -wd1r * (x0r + x0i);
  a[j3 + 1] = -wd1r * (x0i - x0r);
  x0r = a[j0 + 2] + a[j2 + 2];
  x0i = a[j0 + 3] + a[j2 + 3];
  x1r = a[j0 + 2] - a[j2 + 2];
  x1i = a[j0 + 3] - a[j2 + 3];
  x2r = a[j1 + 2] + a[j3 + 2];
  x2i = a[j1 + 3] + a[j3 + 3];
  x3r = a[j1 + 2] - a[j3 + 2];
  x3i = a[j1 + 3] - a[j3 + 3];
  a[j0 + 2] = x0r + x2r;
  a[j0 + 3] = x0i + x2i;
  a[j1 + 2] = x0r - x2r;
  a[j1 + 3] = x0i - x2i;
  x0r = x1r - x3i;
  x0i = x1i + x3r;
  a[j2 + 2] = wk1i * x0r - wk1r * x0i;
  a[j2 + 3] = wk1i * x0i + wk1r * x0r;
  x0r = x1r + x3i;
  x0i = x1i - x3r;
  a[j3 + 2] = wk3i * x0r + wk3r * x0i;
  a[j3 + 3] = wk3i * x0i - wk3r * x0r;
}


x86 assembly (clang, -O0):
<cftmdl1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x4(%rbp),%eax
sar    $0x3,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%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
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x70(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x6c(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
subss  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
subss  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x78(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
addss  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x78(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  0x1cd0(%rip),%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  0x1cbb(%rip),%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
cvtsi2ssl -0x30(%rbp),%xmm1
movss  0x1c9d(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  0x1c88(%rip),%xmm0
mulss  -0x38(%rbp),%xmm0
call   1040 <cos@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  0x1c6c(%rip),%xmm0
mulss  -0x38(%rbp),%xmm0
call   1030 <sin@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  0x1c3c(%rip),%xmm0
mulss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  0x1c2a(%rip),%xmm0
mulss  -0x64(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x44(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x48(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  0x1bc1(%rip),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x68(%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    1475 <cftmdl1+0x355>
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    20d3 <cftmdl1+0xfb3>
movss  -0x64(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x64(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x68(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x68(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
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
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%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
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
subss  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
subss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x6c(%rbp)
movss  -0x78(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x70(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x44(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
addss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x6c(%rbp)
movss  -0x78(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x70(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
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    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
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    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
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    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
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    $0x3,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
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    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
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    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%rbp)
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    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%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    $0x3,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
subss  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
subss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x6c(%rbp)
movss  -0x78(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x70(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
addss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x6c(%rbp)
movss  -0x78(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x70(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
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
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%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
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
subss  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
subss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x6c(%rbp)
movss  -0x78(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x70(%rbp)
movss  -0x48(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
addss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x6c(%rbp)
movss  -0x78(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x70(%rbp)
movss  -0x50(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
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    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
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    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%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    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
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    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%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    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
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    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%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    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%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    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
subss  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
subss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x6c(%rbp)
movss  -0x78(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x70(%rbp)
movss  -0x58(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
addss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x6c(%rbp)
movss  -0x78(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x70(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x64(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x64(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x68(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x68(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x1c(%rbp)
jmp    147e <cftmdl1+0x35e>
mov    -0x18(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jne    20e9 <cftmdl1+0xfc9>
jmp    224f <cftmdl1+0x112f>
movss  -0x38(%rbp),%xmm0
cvtsi2ssl -0x18(%rbp),%xmm1
mulss  %xmm1,%xmm0
call   1040 <cos@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x38(%rbp),%xmm0
cvtsi2ssl -0x18(%rbp),%xmm1
mulss  %xmm1,%xmm0
call   1030 <sin@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  0xee1(%rip),%xmm0
mulss  -0x58(%rbp),%xmm0
mulss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x54(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x58(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  0xe29(%rip),%xmm0
mulss  -0x48(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x44(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x48(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1450 <cftmdl1+0x330>
movss  0xdb9(%rip),%xmm0
movss  %xmm0,-0x54(%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    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
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    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%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    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
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    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%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    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
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    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%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    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%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    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
subss  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
subss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x6c(%rbp)
movss  -0x78(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x70(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x44(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
addss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x6c(%rbp)
movss  -0x78(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x70(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
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
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%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
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
subss  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
subss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x6c(%rbp)
movss  -0x78(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x70(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm1
subss  -0x70(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
movss  -0x70(%rbp),%xmm1
addss  -0x6c(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
addss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x6c(%rbp)
movss  -0x78(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x70(%rbp)
movss  -0x54(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x6c(%rbp),%xmm1
addss  -0x70(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x70(%rbp),%xmm1
subss  -0x6c(%rbp),%xmm1
mulss  %xmm1,%xmm0
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    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
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    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
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    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
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    $0x3,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
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    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
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    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%rbp)
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    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%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    $0x3,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
subss  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
subss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x6c(%rbp)
movss  -0x78(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x70(%rbp)
movss  -0x48(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
addss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x6c(%rbp)
movss  -0x78(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x70(%rbp)
movss  -0x50(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cftmdl1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %rsi,%rbx
mov    %edi,%r14d
sar    $0x3,%r14d
lea    (%r14,%r14,1),%edx
lea    0x0(,%r14,4),%eax
lea    (%rdx,%rdx,2),%esi
cltq
movss  (%rbx,%rax,4),%xmm2
movss  (%rbx),%xmm9
movss  0x4(%rbx),%xmm0
movaps %xmm9,%xmm3
addss  %xmm2,%xmm3
lea    0x1(,%r14,4),%ecx
movslq %ecx,%rcx
movss  (%rbx,%rcx,4),%xmm5
movaps %xmm0,%xmm4
addss  %xmm5,%xmm4
subss  %xmm2,%xmm9
subss  %xmm5,%xmm0
movslq %edx,%rbp
movss  (%rbx,%rbp,4),%xmm2
movslq %esi,%rdx
movss  (%rbx,%rdx,4),%xmm8
movaps %xmm2,%xmm6
addss  %xmm8,%xmm6
lea    0x1(%r14,%r14,1),%esi
movslq %esi,%rdi
movss  (%rbx,%rdi,4),%xmm7
mov    %edx,%esi
or     $0x1,%esi
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm5
movaps %xmm7,%xmm1
addss  %xmm5,%xmm1
subss  %xmm8,%xmm2
subss  %xmm5,%xmm7
movaps %xmm3,%xmm5
addss  %xmm6,%xmm5
movss  %xmm5,(%rbx)
movaps %xmm4,%xmm5
addss  %xmm1,%xmm5
movss  %xmm5,0x4(%rbx)
subss  %xmm6,%xmm3
movss  %xmm3,(%rbx,%rbp,4)
subss  %xmm1,%xmm4
movss  %xmm4,(%rbx,%rdi,4)
movaps %xmm9,%xmm1
subss  %xmm7,%xmm1
movss  %xmm1,(%rbx,%rax,4)
movaps %xmm0,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,(%rbx,%rcx,4)
addss  %xmm9,%xmm7
movss  %xmm7,(%rbx,%rdx,4)
subss  %xmm2,%xmm0
xorps  %xmm1,%xmm1
cvtsi2ss %ebp,%xmm1
movss  %xmm0,(%rbx,%rsi,4)
movss  0xdd6(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x8(%rsp)
addss  %xmm0,%xmm0
movss  %xmm0,0x10(%rsp)
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movaps %xmm0,0x50(%rsp)
movss  0x10(%rsp),%xmm0
call   1030 <sin@plt>
xorps  %xmm5,%xmm5
cvtsi2ss %rax,%xmm5
movaps %xmm5,%xmm6
addss  %xmm5,%xmm6
movss  0xd92(%rip),%xmm0
mulss  %xmm6,%xmm0
movaps 0x50(%rsp),%xmm7
mulss  %xmm7,%xmm0
movaps %xmm0,%xmm2
mulss  %xmm5,%xmm2
addss  %xmm7,%xmm2
mulss  %xmm7,%xmm0
addss  %xmm5,%xmm0
unpcklps %xmm0,%xmm2
addss  %xmm0,%xmm0
mov    %r14,0x20(%rsp)
lea    -0x4(%r14),%r12d
movaps 0xd77(%rip),%xmm1
movaps %xmm6,%xmm3
xorps  %xmm1,%xmm3
movaps %xmm0,%xmm4
xorps  %xmm1,%xmm4
xorps  %xmm5,%xmm1
movaps %xmm1,0x70(%rsp)
movaps %xmm7,%xmm1
movaps %xmm5,0x80(%rsp)
unpcklps %xmm5,%xmm1
movlhps %xmm2,%xmm1
movaps %xmm4,%xmm2
unpcklps %xmm0,%xmm2
movaps %xmm3,%xmm5
unpcklps %xmm6,%xmm5
movlhps %xmm2,%xmm5
movaps %xmm5,0x90(%rsp)
unpcklps %xmm4,%xmm0
unpcklps %xmm3,%xmm6
movlhps %xmm0,%xmm6
lea    -0x1(%rbp),%rax
mov    %rax,0x48(%rsp)
lea    -0x4(,%rbp,8),%rax
ff
mov    %rax,0x40(%rsp)
lea    0x0(%rbp,%rbp,2),%rax
lea    -0x4(,%rax,4),%rax
ff
mov    %rax,0x38(%rsp)
mov    %rbp,%r14
shl    $0x4,%r14
add    $0xfffffffffffffffc,%r14
lea    0x5(%rbp),%rax
mov    %rax,0x30(%rsp)
lea    0x5(,%rbp,1),%rax
add    %rbp,%rax
mov    %rax,0x28(%rsp)
lea    0x5(,%rbp,2),%r15
add    %rbp,%r15
movaps 0xce3(%rip),%xmm15
xor    %eax,%eax
movaps %xmm6,0x60(%rsp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x80(%rax),%r8d
cmp    %r12d,%r8d
mov    %r8d,%r13d
cmovg  %r12d,%r13d
lea    0x2(%rax),%ecx
cmp    %r13d,%ecx
jge    185d <cftmdl1+0x73d>
movslq %eax,%r10
lea    0x2(%r10),%rdx
movslq %r13d,%r9
mov    0x48(%rsp),%r11
sub    %r10,%r11
lea    0x0(,%r10,4),%rcx
mov    0x40(%rsp),%rbp
sub    %rcx,%rbp
mov    0x38(%rsp),%rax
sub    %rcx,%rax
mov    %r14,%rsi
sub    %rcx,%rsi
mov    0x30(%rsp),%rcx
add    %r10,%rcx
mov    0x28(%rsp),%rdi
add    %r10,%rdi
add    %r15,%r10
movaps %xmm1,%xmm9
movaps %xmm6,%xmm0
mulps  %xmm1,%xmm0
movss  (%rbx,%rdx,4),%xmm11
addps  %xmm0,%xmm15
movss  0x4(%rbx,%rdx,4),%xmm4
movss  -0xc(%rbx,%rdi,4),%xmm0
movss  -0x8(%rbx,%rdi,4),%xmm3
movaps %xmm11,%xmm5
addss  %xmm0,%xmm5
movaps %xmm4,%xmm6
addss  %xmm3,%xmm6
subss  %xmm0,%xmm11
movss  -0xc(%rbx,%rcx,4),%xmm12
subss  %xmm3,%xmm4
movss  -0x8(%rbx,%rcx,4),%xmm0
movss  -0xc(%rbx,%r10,4),%xmm3
movss  -0x8(%rbx,%r10,4),%xmm7
movaps %xmm12,%xmm1
addss  %xmm3,%xmm1
movaps %xmm0,%xmm2
addss  %xmm7,%xmm2
subss  %xmm3,%xmm12
subss  %xmm7,%xmm0
movaps %xmm5,%xmm3
addss  %xmm1,%xmm3
movss  %xmm3,(%rbx,%rdx,4)
movaps %xmm6,%xmm3
addss  %xmm2,%xmm3
subss  %xmm1,%xmm5
movss  %xmm3,0x4(%rbx,%rdx,4)
movss  %xmm5,-0xc(%rbx,%rcx,4)
subss  %xmm2,%xmm6
movaps %xmm11,%xmm1
subss  %xmm0,%xmm1
movaps %xmm4,%xmm2
movss  %xmm6,-0x8(%rbx,%rcx,4)
addss  %xmm12,%xmm2
movaps %xmm9,%xmm10
shufps $0x55,%xmm9,%xmm10
movaps %xmm9,%xmm3
mulss  %xmm2,%xmm3
movaps %xmm9,%xmm5
mulss  %xmm10,%xmm2
mulss  %xmm1,%xmm5
subss  %xmm2,%xmm5
mulss  %xmm10,%xmm1
addss  %xmm3,%xmm1
addss  %xmm11,%xmm0
subss  %xmm12,%xmm4
movaps %xmm9,%xmm3
shufps $0xff,%xmm9,%xmm3
movaps %xmm3,%xmm2
movaps %xmm3,%xmm6
movaps %xmm3,0x10(%rsp)
movss  %xmm5,-0xc(%rbx,%rdi,4)
mulss  %xmm4,%xmm2
movaps %xmm9,%xmm12
unpckhpd %xmm9,%xmm12
movaps %xmm12,%xmm3
mulss  %xmm0,%xmm3
movss  %xmm1,-0x8(%rbx,%rdi,4)
addss  %xmm2,%xmm3
mulss  %xmm6,%xmm0
mulss  %xmm12,%xmm4
movss  %xmm3,-0xc(%rbx,%r10,4)
subss  %xmm0,%xmm4
movss  %xmm4,-0x8(%rbx,%r10,4)
movss  0x8(%rbx,%rdx,4),%xmm13
movss  0xc(%rbx,%rdx,4),%xmm0
movss  -0x4(%rbx,%rdi,4),%xmm1
movss  (%rbx,%rdi,4),%xmm6
movaps %xmm13,%xmm7
addss  %xmm1,%xmm7
movaps %xmm0,%xmm3
addss  %xmm6,%xmm3
subss  %xmm1,%xmm13
movss  -0x4(%rbx,%rcx,4),%xmm14
movss  (%rbx,%rcx,4),%xmm2
subss  %xmm6,%xmm0
movss  -0x4(%rbx,%r10,4),%xmm6
movss  (%rbx,%r10,4),%xmm5
movaps %xmm14,%xmm1
addss  %xmm6,%xmm1
movaps %xmm2,%xmm4
addss  %xmm5,%xmm4
subss  %xmm6,%xmm14
subss  %xmm5,%xmm2
movaps %xmm7,%xmm5
addss  %xmm1,%xmm5
movaps %xmm3,%xmm6
movss  %xmm5,0x8(%rbx,%rdx,4)
addss  %xmm4,%xmm6
movss  %xmm6,0xc(%rbx,%rdx,4)
subss  %xmm1,%xmm7
movss  %xmm7,-0x4(%rbx,%rcx,4)
subss  %xmm4,%xmm3
movaps %xmm13,%xmm1
subss  %xmm2,%xmm1
movaps %xmm0,%xmm5
addss  %xmm14,%xmm5
movss  %xmm3,(%rbx,%rcx,4)
movaps %xmm5,%xmm3
mulss  %xmm15,%xmm3
movaps %xmm15,%xmm11
shufps $0x55,%xmm15,%xmm11
movaps %xmm11,%xmm6
mulss  %xmm1,%xmm6
subss  %xmm3,%xmm6
mulss  %xmm15,%xmm1
mulss  %xmm11,%xmm5
addss  %xmm13,%xmm2
addss  %xmm1,%xmm5
subss  %xmm14,%xmm0
movaps %xmm15,%xmm13
unpckhpd %xmm15,%xmm13
movaps %xmm13,%xmm1
mulss  %xmm0,%xmm1
movaps %xmm15,%xmm14
movss  %xmm6,-0x4(%rbx,%rdi,4)
shufps $0xff,%xmm15,%xmm14
movaps %xmm14,%xmm3
mulss  %xmm2,%xmm3
addss  %xmm1,%xmm3
movss  %xmm5,(%rbx,%rdi,4)
mulss  %xmm13,%xmm2
mulss  %xmm14,%xmm0
subss  %xmm2,%xmm0
movss  %xmm3,-0x4(%rbx,%r10,4)
movss  %xmm0,(%rbx,%r10,4)
movss  -0x4(%rbx,%r11,4),%xmm1
movss  (%rbx,%r11,4),%xmm0
movss  -0x4(%rbx,%rax,1),%xmm2
movss  (%rbx,%rax,1),%xmm5
movaps %xmm1,%xmm6
addss  %xmm2,%xmm6
movaps %xmm0,%xmm4
addss  %xmm5,%xmm4
subss  %xmm2,%xmm1
movss  -0x4(%rbx,%rbp,1),%xmm8
movss  (%rbx,%rbp,1),%xmm2
movss  -0x4(%rbx,%rsi,1),%xmm7
subss  %xmm5,%xmm0
movss  (%rbx,%rsi,1),%xmm5
movaps %xmm8,%xmm3
addss  %xmm7,%xmm3
subss  %xmm7,%xmm8
movaps %xmm2,%xmm7
addss  %xmm5,%xmm7
subss  %xmm5,%xmm2
movaps %xmm6,%xmm5
addss  %xmm3,%xmm5
movss  %xmm5,-0x4(%rbx,%r11,4)
movaps %xmm4,%xmm5
addss  %xmm7,%xmm5
movss  %xmm5,(%rbx,%r11,4)
subss  %xmm3,%xmm6
subss  %xmm7,%xmm4
movss  %xmm6,-0x4(%rbx,%rbp,1)
movss  %xmm4,(%rbx,%rbp,1)
movaps %xmm1,%xmm3
subss  %xmm2,%xmm3
movaps %xmm0,%xmm4
addss  %xmm8,%xmm4
movaps %xmm4,%xmm5
mulss  %xmm9,%xmm5
mulss  %xmm10,%xmm4
mulss  %xmm3,%xmm10
subss  %xmm5,%xmm10
mulss  %xmm9,%xmm3
addss  %xmm3,%xmm4
addss  %xmm1,%xmm2
subss  %xmm8,%xmm0
movaps 0x10(%rsp),%xmm3
movaps %xmm3,%xmm1
movss  %xmm10,-0x4(%rbx,%rax,1)
mulss  %xmm2,%xmm1
mulss  %xmm12,%xmm2
mulss  %xmm0,%xmm12
movss  %xmm4,(%rbx,%rax,1)
addss  %xmm12,%xmm1
mulss  %xmm3,%xmm0
subss  %xmm2,%xmm0
movss  %xmm1,-0x4(%rbx,%rsi,1)
movss  %xmm0,(%rbx,%rsi,1)
movss  -0xc(%rbx,%r11,4),%xmm8
movss  -0x8(%rbx,%r11,4),%xmm0
movss  -0xc(%rbx,%rax,1),%xmm1
movss  -0x8(%rbx,%rax,1),%xmm4
movaps %xmm8,%xmm5
addss  %xmm1,%xmm5
movaps %xmm0,%xmm6
addss  %xmm4,%xmm6
subss  %xmm1,%xmm8
movss  -0xc(%rbx,%rbp,1),%xmm2
movss  -0x8(%rbx,%rbp,1),%xmm1
movss  -0xc(%rbx,%rsi,1),%xmm7
subss  %xmm4,%xmm0
movss  -0x8(%rbx,%rsi,1),%xmm4
movaps %xmm2,%xmm3
addss  %xmm7,%xmm3
subss  %xmm7,%xmm2
movaps %xmm1,%xmm7
addss  %xmm4,%xmm7
subss  %xmm4,%xmm1
movaps %xmm5,%xmm4
addss  %xmm3,%xmm4
movss  %xmm4,-0xc(%rbx,%r11,4)
movaps %xmm6,%xmm4
addss  %xmm7,%xmm4
movss  %xmm4,-0x8(%rbx,%r11,4)
subss  %xmm3,%xmm5
subss  %xmm7,%xmm6
movss  %xmm5,-0xc(%rbx,%rbp,1)
movss  %xmm6,-0x8(%rbx,%rbp,1)
movaps %xmm8,%xmm3
subss  %xmm1,%xmm3
movaps %xmm0,%xmm4
addss  %xmm2,%xmm4
movaps %xmm15,%xmm5
mulss  %xmm4,%xmm5
mulss  %xmm11,%xmm4
movaps %xmm15,%xmm6
mulss  %xmm3,%xmm6
subss  %xmm4,%xmm6
movss  %xmm6,-0xc(%rbx,%rax,1)
movaps 0x60(%rsp),%xmm6
mulss  %xmm11,%xmm3
addss  %xmm5,%xmm3
addss  %xmm8,%xmm1
movss  %xmm3,-0x8(%rbx,%rax,1)
subss  %xmm2,%xmm0
movaps %xmm13,%xmm2
mulss  %xmm1,%xmm2
mulss  %xmm14,%xmm1
mulss  %xmm0,%xmm14
addss  %xmm14,%xmm2
mulss  %xmm13,%xmm0
subss  %xmm1,%xmm0
movss  %xmm2,-0xc(%rbx,%rsi,1)
movss  %xmm0,-0x8(%rbx,%rsi,1)
movaps 0x90(%rsp),%xmm0
mulps  %xmm15,%xmm0
movaps %xmm0,%xmm1
addps  %xmm9,%xmm1
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     13c0 <cftmdl1+0x2a0>
addps  %xmm9,%xmm0
movaps %xmm0,%xmm1
cmp    %r8d,%r12d
jle    193c <cftmdl1+0x81c>
xorps  %xmm0,%xmm0
cvtsi2ss %r13d,%xmm0
mulss  0x8(%rsp),%xmm0
movss  %xmm0,0xc(%rsp)
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movaps %xmm0,0x10(%rsp)
movss  0xc(%rsp),%xmm0
call   1030 <sin@plt>
movaps 0x60(%rsp),%xmm6
xorps  %xmm15,%xmm15
cvtsi2ss %rax,%xmm15
movaps %xmm15,%xmm0
movss  0x75f(%rip),%xmm4
mulss  %xmm4,%xmm0
movaps 0x10(%rsp),%xmm5
mulss  %xmm5,%xmm0
movaps %xmm0,%xmm1
mulss  %xmm15,%xmm1
addss  %xmm5,%xmm1
mulss  %xmm5,%xmm0
addss  %xmm15,%xmm0
unpcklps %xmm1,%xmm0
movaps 0x70(%rsp),%xmm2
mulss  %xmm15,%xmm2
movaps 0x50(%rsp),%xmm3
movaps %xmm3,%xmm1
mulss  %xmm5,%xmm1
addss  %xmm2,%xmm1
movaps 0x80(%rsp),%xmm2
mulss  %xmm5,%xmm2
mulss  %xmm15,%xmm3
addss  %xmm2,%xmm3
movaps %xmm3,%xmm2
mulss  %xmm4,%xmm2
mulss  %xmm1,%xmm2
movaps %xmm2,%xmm4
mulss  %xmm3,%xmm4
addss  %xmm1,%xmm4
mulss  %xmm1,%xmm2
addss  %xmm3,%xmm2
unpcklps %xmm2,%xmm4
unpcklps %xmm3,%xmm1
movlhps %xmm4,%xmm1
unpcklps %xmm5,%xmm15
movlhps %xmm0,%xmm15
mov    %r13d,%eax
jmp    1360 <cftmdl1+0x240>
mov    0x20(%rsp),%rdx
lea    (%rdx,%rdx,2),%eax
lea    (%rdx,%rdx,4),%ecx
lea    0x0(,%rdx,8),%edi
sub    %edx,%edi
movslq %edx,%rdx
movss  -0x8(%rbx,%rdx,4),%xmm8
movss  -0x4(%rbx,%rdx,4),%xmm4
movslq %ecx,%rcx
movss  -0x8(%rbx,%rcx,4),%xmm0
movss  -0x4(%rbx,%rcx,4),%xmm3
movaps %xmm8,%xmm6
addss  %xmm0,%xmm6
movaps %xmm4,%xmm7
addss  %xmm3,%xmm7
subss  %xmm0,%xmm8
subss  %xmm3,%xmm4
movslq %eax,%rsi
movss  -0x8(%rbx,%rsi,4),%xmm9
movss  -0x4(%rbx,%rsi,4),%xmm5
movslq %edi,%rax
movss  -0x8(%rbx,%rax,4),%xmm0
movss  -0x4(%rbx,%rax,4),%xmm10
movaps %xmm9,%xmm3
addss  %xmm0,%xmm3
movaps %xmm5,%xmm2
addss  %xmm10,%xmm2
subss  %xmm0,%xmm9
subss  %xmm10,%xmm5
movaps %xmm6,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,-0x8(%rbx,%rdx,4)
movaps %xmm7,%xmm0
addss  %xmm2,%xmm0
movss  %xmm0,-0x4(%rbx,%rdx,4)
subss  %xmm3,%xmm6
movss  %xmm6,-0x8(%rbx,%rsi,4)
subss  %xmm2,%xmm7
movss  %xmm7,-0x4(%rbx,%rsi,4)
movaps %xmm8,%xmm2
subss  %xmm5,%xmm2
movaps %xmm4,%xmm3
addss  %xmm9,%xmm3
movaps %xmm1,%xmm10
shufps $0x55,%xmm1,%xmm10
movaps %xmm1,%xmm6
mulss  %xmm3,%xmm6
mulss  %xmm10,%xmm3
movaps %xmm1,%xmm7
mulss  %xmm2,%xmm7
subss  %xmm3,%xmm7
movss  %xmm7,-0x8(%rbx,%rcx,4)
mulss  %xmm10,%xmm2
addss  %xmm6,%xmm2
movss  %xmm2,-0x4(%rbx,%rcx,4)
addss  %xmm8,%xmm5
subss  %xmm9,%xmm4
movaps %xmm1,%xmm8
shufps $0xff,%xmm1,%xmm8
movaps %xmm8,%xmm6
mulss  %xmm4,%xmm6
movaps %xmm1,%xmm9
unpckhpd %xmm1,%xmm9
movaps %xmm9,%xmm7
mulss  %xmm5,%xmm7
addss  %xmm6,%xmm7
movss  %xmm7,-0x8(%rbx,%rax,4)
mulss  %xmm8,%xmm5
mulss  %xmm9,%xmm4
subss  %xmm5,%xmm4
movss  %xmm4,-0x4(%rbx,%rax,4)
movss  (%rbx,%rdx,4),%xmm11
movss  0x4(%rbx,%rdx,4),%xmm4
movss  (%rbx,%rcx,4),%xmm6
movss  0x4(%rbx,%rcx,4),%xmm7
movaps %xmm11,%xmm5
addss  %xmm6,%xmm5
movaps %xmm4,%xmm2
addss  %xmm7,%xmm2
subss  %xmm6,%xmm11
subss  %xmm7,%xmm4
movss  (%rbx,%rsi,4),%xmm12
movss  0x4(%rbx,%rsi,4),%xmm0
movss  (%rbx,%rax,4),%xmm3
movss  0x4(%rbx,%rax,4),%xmm13
movaps %xmm12,%xmm7
addss  %xmm3,%xmm7
movaps %xmm0,%xmm6
addss  %xmm13,%xmm6
subss  %xmm3,%xmm12
subss  %xmm13,%xmm0
movaps %xmm5,%xmm3
addss  %xmm7,%xmm3
movss  %xmm3,(%rbx,%rdx,4)
movaps %xmm2,%xmm3
addss  %xmm6,%xmm3
movss  %xmm3,0x4(%rbx,%rdx,4)
subss  %xmm7,%xmm5
movss  %xmm5,(%rbx,%rsi,4)
subss  %xmm6,%xmm2
movss  %xmm2,0x4(%rbx,%rsi,4)
movaps %xmm11,%xmm2
subss  %xmm0,%xmm2
movaps %xmm4,%xmm3
addss  %xmm12,%xmm3
movaps %xmm2,%xmm5
subss  %xmm3,%xmm5
movss  0x4de(%rip),%xmm6
mulss  %xmm6,%xmm5
movss  %xmm5,(%rbx,%rcx,4)
addss  %xmm2,%xmm3
mulss  %xmm6,%xmm3
movss  %xmm3,0x4(%rbx,%rcx,4)
addss  %xmm11,%xmm0
subss  %xmm12,%xmm4
movaps %xmm4,%xmm2
addss  %xmm0,%xmm2
movss  0x4b2(%rip),%xmm3
mulss  %xmm3,%xmm2
movss  %xmm2,(%rbx,%rax,4)
subss  %xmm0,%xmm4
mulss  %xmm3,%xmm4
movss  %xmm4,0x4(%rbx,%rax,4)
movss  0x8(%rbx,%rdx,4),%xmm11
movss  0xc(%rbx,%rdx,4),%xmm4
movss  0x8(%rbx,%rcx,4),%xmm0
movss  0xc(%rbx,%rcx,4),%xmm2
movaps %xmm11,%xmm3
addss  %xmm0,%xmm3
movaps %xmm4,%xmm6
addss  %xmm2,%xmm6
subss  %xmm0,%xmm11
subss  %xmm2,%xmm4
movss  0x8(%rbx,%rsi,4),%xmm12
movss  0xc(%rbx,%rsi,4),%xmm5
movss  0x8(%rbx,%rax,4),%xmm0
movss  0xc(%rbx,%rax,4),%xmm13
movaps %xmm12,%xmm7
addss  %xmm0,%xmm7
movaps %xmm5,%xmm2
addss  %xmm13,%xmm2
subss  %xmm0,%xmm12
subss  %xmm13,%xmm5
movaps %xmm3,%xmm0
addss  %xmm7,%xmm0
movss  %xmm0,0x8(%rbx,%rdx,4)
movaps %xmm6,%xmm0
addss  %xmm2,%xmm0
movss  %xmm0,0xc(%rbx,%rdx,4)
subss  %xmm7,%xmm3
movss  %xmm3,0x8(%rbx,%rsi,4)
subss  %xmm2,%xmm6
movss  %xmm6,0xc(%rbx,%rsi,4)
movaps %xmm11,%xmm0
subss  %xmm5,%xmm0
movaps %xmm4,%xmm2
addss  %xmm12,%xmm2
movaps %xmm2,%xmm3
mulss  %xmm1,%xmm3
mulss  %xmm10,%xmm2
mulss  %xmm0,%xmm10
subss  %xmm3,%xmm10
movss  %xmm10,0x8(%rbx,%rcx,4)
mulss  %xmm1,%xmm0
addss  %xmm0,%xmm2
movss  %xmm2,0xc(%rbx,%rcx,4)
addss  %xmm11,%xmm5
subss  %xmm12,%xmm4
movaps %xmm8,%xmm0
mulss  %xmm5,%xmm0
mulss  %xmm9,%xmm5
mulss  %xmm4,%xmm9
addss  %xmm9,%xmm0
movss  %xmm0,0x8(%rbx,%rax,4)
mulss  %xmm8,%xmm4
subss  %xmm5,%xmm4
movss  %xmm4,0xc(%rbx,%rax,4)
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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