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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double cos(double);
double sin(double);
void cftmdl(int n, int l, double *a) {
  int j, j1, j2, j3, k, kj, kr, m, m2;
  double ew, wn4r, wk1r, wk1i, wk2r, wk2i, wk3r, wk3i;
  double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
  m = l << 2;
  for (j = 0; j < l; j += 2) {
    j1 = j + l;
    j2 = j1 + l;
    j3 = j2 + l;
    x0r = a[j] + a[j1];
    x0i = a[j + 1] + a[j1 + 1];
    x1r = a[j] - a[j1];
    x1i = a[j + 1] - a[j1 + 1];
    x2r = a[j2] + a[j3];
    x2i = a[j2 + 1] + a[j3 + 1];
    x3r = a[j2] - a[j3];
    x3i = a[j2 + 1] - a[j3 + 1];
    a[j] = x0r + x2r;
    a[j + 1] = x0i + x2i;
    a[j2] = x0r - x2r;
    a[j2 + 1] = x0i - x2i;
    a[j1] = x1r - x3i;
    a[j1 + 1] = x1i + x3r;
    a[j3] = x1r + x3i;
    a[j3 + 1] = x1i - x3r;
  }
  wn4r = 0.707106781186547524400844362104849039284835937688;
  for (j = m; j < l + m; j += 2) {
    j1 = j + l;
    j2 = j1 + l;
    j3 = j2 + l;
    x0r = a[j] + a[j1];
    x0i = a[j + 1] + a[j1 + 1];
    x1r = a[j] - a[j1];
    x1i = a[j + 1] - a[j1 + 1];
    x2r = a[j2] + a[j3];
    x2i = a[j2 + 1] + a[j3 + 1];
    x3r = a[j2] - a[j3];
    x3i = a[j2 + 1] - a[j3 + 1];
    a[j] = x0r + x2r;
    a[j + 1] = x0i + x2i;
    a[j2] = x2i - x0i;
    a[j2 + 1] = x0r - x2r;
    x0r = x1r - x3i;
    x0i = x1i + x3r;
    a[j1] = wn4r * (x0r - x0i);
    a[j1 + 1] = wn4r * (x0r + x0i);
    x0r = x3i + x1r;
    x0i = x3r - x1i;
    a[j3] = wn4r * (x0i - x0r);
    a[j3 + 1] = wn4r * (x0i + x0r);
  }
  ew = 1.570796326794896619231321691639751442098584699687 / n;
  kr = 0;
  m2 = 2 * m;
  for (k = m2; k < n; k += m2) {
    for (kj = n >> 2; kj > (kr ^= kj); kj >>= 1)
      ;
    wk1r = cos(ew * kr);
    wk1i = sin(ew * kr);
    wk2r = 1 - 2 * wk1i * wk1i;
    wk2i = 2 * wk1i * wk1r;
    wk3r = wk1r - 2 * wk2i * wk1i;
    wk3i = 2 * wk2i * wk1r - wk1i;
    for (j = k; j < l + k; j += 2) {
      j1 = j + l;
      j2 = j1 + l;
      j3 = j2 + l;
      x0r = a[j] + a[j1];
      x0i = a[j + 1] + a[j1 + 1];
      x1r = a[j] - a[j1];
      x1i = a[j + 1] - a[j1 + 1];
      x2r = a[j2] + a[j3];
      x2i = a[j2 + 1] + a[j3 + 1];
      x3r = a[j2] - a[j3];
      x3i = a[j2 + 1] - a[j3 + 1];
      a[j] = x0r + x2r;
      a[j + 1] = x0i + x2i;
      x0r -= x2r;
      x0i -= x2i;
      a[j2] = wk2r * x0r - wk2i * x0i;
      a[j2 + 1] = wk2r * x0i + wk2i * x0r;
      x0r = x1r - x3i;
      x0i = x1i + x3r;
      a[j1] = wk1r * x0r - wk1i * x0i;
      a[j1 + 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 = wn4r * (wk1r - wk1i);
    wk1i = wn4r * (wk1r + wk1i);
    wk1r = x0r;
    wk3r = wk1r - 2 * wk2r * wk1i;
    wk3i = 2 * wk2r * wk1r - wk1i;
    for (j = k + m; j < l + (k + m); j += 2) {
      j1 = j + l;
      j2 = j1 + l;
      j3 = j2 + l;
      x0r = a[j] + a[j1];
      x0i = a[j + 1] + a[j1 + 1];
      x1r = a[j] - a[j1];
      x1i = a[j + 1] - a[j1 + 1];
      x2r = a[j2] + a[j3];
      x2i = a[j2 + 1] + a[j3 + 1];
      x3r = a[j2] - a[j3];
      x3i = a[j2 + 1] - a[j3 + 1];
      a[j] = x0r + x2r;
      a[j + 1] = x0i + x2i;
      x0r -= x2r;
      x0i -= x2i;
      a[j2] = -wk2i * x0r - wk2r * x0i;
      a[j2 + 1] = -wk2i * x0i + wk2r * x0r;
      x0r = x1r - x3i;
      x0i = x1i + x3r;
      a[j1] = wk1r * x0r - wk1i * x0i;
      a[j1 + 1] = wk1r * x0i + wk1i * x0r;
      x0r = x1r + x3i;
      x0i = x1i - x3r;
      a[j3] = wk3r * x0r - wk3i * x0i;
      a[j3 + 1] = wk3r * x0i + wk3i * x0r;
    }
  }
}


x86 assembly (clang, -O0):
<cftmdl>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    -0x8(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13a5 <cftmdl+0x285>
mov    -0x14(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0xa8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0xa8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
addsd  -0xb0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0xb0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
jmp    1145 <cftmdl+0x25>
movsd  0x1c53(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
cmp    %ecx,%eax
jge    168f <cftmdl+0x56f>
mov    -0x14(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0xa8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm1
subsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm1
addsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
subsd  -0x80(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
addsd  -0x80(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
jmp    13b8 <cftmdl+0x298>
cvtsi2sdl -0x4(%rbp),%xmm1
movsd  0x196c(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    201d <cftmdl+0xefd>
mov    -0x4(%rbp),%eax
sar    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x28(%rbp),%ecx
xor    -0x2c(%rbp),%ecx
mov    %ecx,-0x2c(%rbp)
cmp    %ecx,%eax
jle    16f7 <cftmdl+0x5d7>
jmp    16e9 <cftmdl+0x5c9>
mov    -0x28(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    16d0 <cftmdl+0x5b0>
movsd  -0x40(%rbp),%xmm0
cvtsi2sdl -0x2c(%rbp),%xmm1
mulsd  %xmm1,%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x40(%rbp),%xmm0
cvtsi2sdl -0x2c(%rbp),%xmm1
mulsd  %xmm1,%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  0x18e1(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0x18bc(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0x18a3(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  0x1887(%rip),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0x1851(%rip),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    1b8b <cftmdl+0xa6b>
mov    -0x14(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0xa8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x88(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0xb0(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
jmp    17f8 <cftmdl+0x6d8>
movsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
subsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
addsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  0x143e(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0x1408(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x24(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x8(%rbp),%ecx
mov    -0x24(%rbp),%edx
add    -0x30(%rbp),%edx
add    %edx,%ecx
cmp    %ecx,%eax
jge    200a <cftmdl+0xeea>
mov    -0x14(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0xa8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x88(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
jmp    1c44 <cftmdl+0xb24>
jmp    200f <cftmdl+0xeef>
mov    -0x34(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    16bb <cftmdl+0x59b>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cftmdl>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
lea    0x0(,%rsi,4),%r8d
test   %esi,%esi
jle    11d3 <cftmdl+0xb3>
mov    %esi,%r9d
lea    (%rdx,%r9,8),%rbx
mov    %r9,%rcx
shl    $0x4,%rcx
add    %rdx,%rcx
lea    (%r9,%r9,2),%rax
lea    (%rdx,%rax,8),%rax
xor    %ebp,%ebp
nopl   0x0(%rax)
movupd (%rdx,%rbp,8),%xmm0
movupd (%rbx,%rbp,8),%xmm1
movapd %xmm0,%xmm2
addpd  %xmm1,%xmm2
subpd  %xmm1,%xmm0
movupd (%rcx,%rbp,8),%xmm1
movupd (%rax,%rbp,8),%xmm3
movapd %xmm1,%xmm4
addpd  %xmm3,%xmm4
subpd  %xmm3,%xmm1
shufpd $0x1,%xmm1,%xmm1
movapd %xmm2,%xmm3
addpd  %xmm4,%xmm3
movupd %xmm3,(%rdx,%rbp,8)
subpd  %xmm4,%xmm2
movupd %xmm2,(%rcx,%rbp,8)
movapd %xmm0,%xmm2
subpd  %xmm1,%xmm2
addpd  %xmm0,%xmm1
movapd %xmm1,%xmm0
movsd  %xmm2,%xmm0
movupd %xmm0,(%rbx,%rbp,8)
shufpd $0x2,%xmm2,%xmm1
movupd %xmm1,(%rax,%rbp,8)
add    $0x2,%rbp
cmp    %r9,%rbp
jb     1160 <cftmdl+0x40>
lea    (%rsi,%rsi,4),%ecx
movslq %r8d,%rax
mov    %rax,0x28(%rsp)
movslq %esi,%rax
mov    %rax,0x8(%rsp)
cmp    %ecx,%r8d
jge    1311 <cftmdl+0x1f1>
movslq %ecx,%r9
mov    0x8(%rsp),%rcx
lea    (%rdx,%rcx,8),%rbx
add    $0x8,%rbx
mov    %rcx,%rax
shl    $0x4,%rax
add    %rdx,%rax
lea    (%rcx,%rcx,2),%rcx
lea    (%rdx,%rcx,8),%rcx
add    $0x8,%rcx
movsd  0xde2(%rip),%xmm8
mov    0x28(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx,%rbp,8),%xmm3
movsd  0x8(%rdx,%rbp,8),%xmm5
movsd  -0x8(%rbx,%rbp,8),%xmm9
movsd  (%rbx,%rbp,8),%xmm7
movapd %xmm5,%xmm4
subsd  %xmm7,%xmm4
movsd  (%rax,%rbp,8),%xmm1
movsd  0x8(%rax,%rbp,8),%xmm2
unpcklpd %xmm1,%xmm5
movsd  -0x8(%rcx,%rbp,8),%xmm0
movsd  (%rcx,%rbp,8),%xmm6
unpcklpd %xmm0,%xmm7
addpd  %xmm5,%xmm7
movapd %xmm2,%xmm5
unpcklpd %xmm3,%xmm5
subsd  %xmm9,%xmm3
subsd  %xmm6,%xmm2
unpcklpd %xmm9,%xmm6
addpd  %xmm5,%xmm6
subsd  %xmm0,%xmm1
movapd %xmm7,%xmm0
addpd  %xmm6,%xmm0
shufpd $0x1,%xmm0,%xmm0
movupd %xmm0,(%rdx,%rbp,8)
subpd  %xmm7,%xmm6
movupd %xmm6,(%rax,%rbp,8)
movapd %xmm3,%xmm0
subsd  %xmm2,%xmm0
movapd %xmm4,%xmm5
addsd  %xmm1,%xmm5
movapd %xmm0,%xmm6
subsd  %xmm5,%xmm6
mulsd  %xmm8,%xmm6
movsd  %xmm6,-0x8(%rbx,%rbp,8)
addsd  %xmm0,%xmm5
mulsd  %xmm8,%xmm5
movsd  %xmm5,(%rbx,%rbp,8)
addsd  %xmm3,%xmm2
subsd  %xmm4,%xmm1
movapd %xmm1,%xmm0
subsd  %xmm2,%xmm0
mulsd  %xmm8,%xmm0
movsd  %xmm0,-0x8(%rcx,%rbp,8)
addsd  %xmm2,%xmm1
mulsd  %xmm8,%xmm1
movsd  %xmm1,(%rcx,%rbp,8)
add    $0x2,%rbp
cmp    %r9,%rbp
jl     1230 <cftmdl+0x110>
lea    0x0(,%rsi,8),%eax
mov    %eax,0x14(%rsp)
cmp    %edi,%eax
jge    1805 <cftmdl+0x6e5>
xorps  %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
movsd  0xcd5(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0xa0(%rsp)
movslq 0x14(%rsp),%r9
lea    (%r8,%r8,2),%ecx
movslq %edi,%rax
mov    %rax,0x90(%rsp)
sar    $0x2,%edi
mov    %edi,0x20(%rsp)
lea    (%rdx,%r9,8),%r8
mov    0x8(%rsp),%rbp
lea    (%r9,%rbp,1),%rax
lea    (%rdx,%rax,8),%r11
lea    (%r9,%rbp,2),%rax
lea    (%rdx,%rax,8),%rdi
lea    0x0(,%rbp,2),%rax
add    %rbp,%rax
add    %r9,%rax
lea    (%rdx,%rax,8),%rax
mov    %rax,0x70(%rsp)
mov    %rbp,%r15
shl    $0x4,%r15
lea    0x0(,%rbp,8),%rax
lea    (%rax,%rax,2),%rax
mov    %rax,0x68(%rsp)
xor    %eax,%eax
mov    %rax,0x30(%rsp)
mov    %r9,0x18(%rsp)
xor    %r13d,%r13d
mov    %rdx,0xa8(%rsp)
mov    %rsi,0x38(%rsp)
mov    %r9,0x98(%rsp)
mov    %r8,0x88(%rsp)
mov    %r11,0x80(%rsp)
mov    %rdi,0x78(%rsp)
jmp    1408 <cftmdl+0x2e8>
xchg   %ax,%ax
mov    0x18(%rsp),%rax
add    %r9,%rax
mov    0x24(%rsp),%ecx
add    0x14(%rsp),%ecx
add    %r9,0x30(%rsp)
mov    %rax,0x18(%rsp)
cmp    0x90(%rsp),%rax
jge    1805 <cftmdl+0x6e5>
mov    %ecx,0x24(%rsp)
movslq %ecx,%r14
mov    %r14,%rbp
shl    $0x20,%rbp
lea    (%rdx,%r14,8),%r12
mov    0x8(%rsp),%rax
add    %r14,%rax
lea    (%rdx,%rax,8),%rbx
mov    0x20(%rsp),%ecx
mov    %ecx,%eax
nopl   0x0(%rax)
xor    %ecx,%r13d
sar    %eax
cmp    %r13d,%ecx
mov    %eax,%ecx
jg     1430 <cftmdl+0x310>
xorps  %xmm0,%xmm0
cvtsi2sd %r13d,%xmm0
mulsd  0xa0(%rsp),%xmm0
movsd  %xmm0,0x40(%rsp)
call   1040 <cos@plt>
movapd %xmm0,0x50(%rsp)
movsd  0x40(%rsp),%xmm0
call   1030 <sin@plt>
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
movapd 0x50(%rsp),%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm2,0xb0(%rsp)
mulsd  %xmm0,%xmm1
movsd  0xb80(%rip),%xmm2
subsd  %xmm1,%xmm2
movapd %xmm2,0x40(%rsp)
cmpl   $0x0,0x38(%rsp)
mov    0x8(%rsp),%rsi
mov    0x98(%rsp),%r9
mov    0x88(%rsp),%r8
mov    0x80(%rsp),%r11
mov    0x78(%rsp),%rdi
mov    0x70(%rsp),%r10
jle    163f <cftmdl+0x51f>
mov    0x18(%rsp),%rax
add    %rsi,%rax
movapd 0xb0(%rsp),%xmm4
movapd %xmm4,%xmm2
addsd  %xmm4,%xmm2
movapd %xmm0,%xmm10
xorpd  0xb2d(%rip),%xmm10
movapd %xmm2,%xmm8
movapd 0x50(%rsp),%xmm7
mulsd  %xmm7,%xmm8
subsd  %xmm0,%xmm8
mulsd  %xmm0,%xmm2
movapd %xmm7,%xmm14
subsd  %xmm2,%xmm14
movapd %xmm4,%xmm12
movapd 0xafd(%rip),%xmm1
xorpd  %xmm1,%xmm12
unpcklpd %xmm14,%xmm14
unpcklpd %xmm8,%xmm11
xorpd  %xmm1,%xmm8
unpcklpd %xmm7,%xmm7
unpcklpd %xmm0,%xmm13
movapd 0x40(%rsp),%xmm3
unpcklpd %xmm3,%xmm3
unpcklpd %xmm4,%xmm15
mov    0x30(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%r8,%rcx,8),%xmm4
movupd (%r11,%rcx,8),%xmm5
movapd %xmm4,%xmm2
addpd  %xmm5,%xmm2
subpd  %xmm5,%xmm4
movupd (%rdi,%rcx,8),%xmm5
movupd (%r10,%rcx,8),%xmm6
movapd %xmm5,%xmm9
addpd  %xmm6,%xmm9
subpd  %xmm6,%xmm5
shufpd $0x1,%xmm5,%xmm5
movapd %xmm2,%xmm6
addpd  %xmm9,%xmm6
movupd %xmm6,(%r8,%rcx,8)
subpd  %xmm9,%xmm2
movapd %xmm2,%xmm6
unpckhpd %xmm15,%xmm6
movapd %xmm12,%xmm1
unpcklpd %xmm2,%xmm1
mulpd  %xmm6,%xmm1
mulpd  %xmm3,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,(%rdi,%rcx,8)
movapd %xmm4,%xmm1
subpd  %xmm5,%xmm1
addpd  %xmm4,%xmm5
movapd %xmm5,%xmm2
unpckhpd %xmm13,%xmm2
movapd %xmm10,%xmm4
unpcklpd %xmm1,%xmm4
mulpd  %xmm2,%xmm4
movapd %xmm1,%xmm2
movsd  %xmm5,%xmm2
movapd %xmm8,%xmm6
unpcklpd %xmm5,%xmm6
movsd  %xmm1,%xmm5
mulpd  %xmm7,%xmm5
addpd  %xmm5,%xmm4
movupd %xmm4,(%r11,%rcx,8)
mulpd  %xmm14,%xmm2
unpckhpd %xmm11,%xmm1
mulpd  %xmm1,%xmm6
addpd  %xmm2,%xmm6
movupd %xmm6,(%r10,%rcx,8)
lea    (%r9,%rcx,1),%rdx
add    $0x2,%rdx
add    $0x2,%rcx
cmp    %rax,%rdx
jl     1560 <cftmdl+0x440>
cmpl   $0x0,0x38(%rsp)
mov    0xa8(%rsp),%rdx
mov    0x68(%rsp),%rsi
movabs $0x200000000,%r10
movapd 0x40(%rsp),%xmm13
jle    13e0 <cftmdl+0x2c0>
mov    0x28(%rsp),%rax
mov    0x18(%rsp),%rcx
add    %rcx,%rax
add    0x8(%rsp),%rax
movapd 0x50(%rsp),%xmm2
movapd %xmm2,%xmm8
subsd  %xmm0,%xmm8
movsd  0x96e(%rip),%xmm1
mulsd  %xmm1,%xmm8
addsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm13,%xmm0
addsd  %xmm13,%xmm0
movapd %xmm2,%xmm10
xorpd  0x969(%rip),%xmm10
movapd %xmm0,%xmm4
mulsd  %xmm8,%xmm4
subsd  %xmm2,%xmm4
mulsd  %xmm2,%xmm0
movapd %xmm8,%xmm5
subsd  %xmm0,%xmm5
movapd 0x947(%rip),%xmm0
movapd 0xb0(%rsp),%xmm1
xorpd  %xmm0,%xmm1
unpcklpd %xmm5,%xmm5
unpcklpd %xmm4,%xmm11
xorpd  %xmm0,%xmm4
unpcklpd %xmm8,%xmm8
unpcklpd %xmm2,%xmm9
pshufd $0x44,%xmm1,%xmm12
unpcklpd %xmm13,%xmm1
xorpd  %xmm0,%xmm13
nopl   (%rax)
movupd (%rbx),%xmm0
mov    %rbp,%rcx
sar    $0x1d,%rcx
or     $0x8,%rcx
movsd  (%r12),%xmm3
movhpd (%rdx,%rcx,1),%xmm3
movapd %xmm3,%xmm6
addpd  %xmm0,%xmm6
subpd  %xmm0,%xmm3
movupd (%r12,%r15,1),%xmm0
movupd (%r12,%rsi,1),%xmm7
movapd %xmm0,%xmm2
addpd  %xmm7,%xmm2
subpd  %xmm7,%xmm0
shufpd $0x1,%xmm0,%xmm0
movapd %xmm6,%xmm7
addpd  %xmm2,%xmm7
movlpd %xmm7,(%r12)
movhpd %xmm7,(%rdx,%rcx,1)
subpd  %xmm2,%xmm6
movapd %xmm6,%xmm2
unpckhpd %xmm1,%xmm2
movapd %xmm13,%xmm7
unpcklpd %xmm6,%xmm7
mulpd  %xmm2,%xmm7
mulpd  %xmm12,%xmm6
addpd  %xmm7,%xmm6
movupd %xmm6,(%r12,%r15,1)
movapd %xmm3,%xmm2
subpd  %xmm0,%xmm2
addpd  %xmm3,%xmm0
movapd %xmm0,%xmm3
unpckhpd %xmm9,%xmm3
movapd %xmm10,%xmm6
unpcklpd %xmm2,%xmm6
mulpd  %xmm3,%xmm6
movapd %xmm2,%xmm3
movsd  %xmm0,%xmm3
movapd %xmm4,%xmm7
unpcklpd %xmm0,%xmm7
movsd  %xmm2,%xmm0
mulpd  %xmm8,%xmm0
addpd  %xmm0,%xmm6
movupd %xmm6,(%rbx)
mulpd  %xmm5,%xmm3
unpckhpd %xmm11,%xmm2
mulpd  %xmm2,%xmm7
addpd  %xmm3,%xmm7
movupd %xmm7,(%r12,%rsi,1)
add    $0x2,%r14
add    %r10,%rbp
add    $0x10,%r12
add    $0x10,%rbx
cmp    %rax,%r14
jl     1710 <cftmdl+0x5f0>
jmp    13e0 <cftmdl+0x2c0>
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @cftmdl(i32 %0, i32 %1, double* %2) {
%4 = alloca i32
%5 = alloca i32
%6 = alloca double*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca double
%31 = alloca double
store i32 %0, i32* %4
store i32 %1, i32* %5
store double* %2, double** %6
%32 = load i32, i32* %5
%33 = shl i32 %32, 2
store i32 %33, i32* %14
store i32 0, i32* %7
br label %34
34: ; preds = %204, %3
%35 = load i32, i32* %7
%36 = load i32, i32* %5
%37 = icmp slt i32 %35, %36
br i1 %37, label %38, label %207
38: ; preds = %34
%39 = load i32, i32* %7
%40 = load i32, i32* %5
%41 = add nsw i32 %39, %40
store i32 %41, i32* %8
%42 = load i32, i32* %8
%43 = load i32, i32* %5
%44 = add nsw i32 %42, %43
store i32 %44, i32* %9
%45 = load i32, i32* %9
%46 = load i32, i32* %5
%47 = add nsw i32 %45, %46
store i32 %47, i32* %10
%48 = load double*, double** %6
%49 = load i32, i32* %7
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds double, double* %48, i64 %50
%52 = load double, double* %51
%53 = load double*, double** %6
%54 = load i32, i32* %8
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds double, double* %53, i64 %55
%57 = load double, double* %56
%58 = fadd double %52, %57
store double %58, double* %24
%59 = load double*, double** %6
%60 = load i32, i32* %7
%61 = add nsw i32 %60, 1
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds double, double* %59, i64 %62
%64 = load double, double* %63
%65 = load double*, double** %6
%66 = load i32, i32* %8
%67 = add nsw i32 %66, 1
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds double, double* %65, i64 %68
%70 = load double, double* %69
%71 = fadd double %64, %70
store double %71, double* %25
%72 = load double*, double** %6
%73 = load i32, i32* %7
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds double, double* %72, i64 %74
%76 = load double, double* %75
%77 = load double*, double** %6
%78 = load i32, i32* %8
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds double, double* %77, i64 %79
%81 = load double, double* %80
%82 = fsub double %76, %81
store double %82, double* %26
%83 = load double*, double** %6
%84 = load i32, i32* %7
%85 = add nsw i32 %84, 1
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds double, double* %83, i64 %86
%88 = load double, double* %87
%89 = load double*, double** %6
%90 = load i32, i32* %8
%91 = add nsw i32 %90, 1
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds double, double* %89, i64 %92
%94 = load double, double* %93
%95 = fsub double %88, %94
store double %95, double* %27
%96 = load double*, double** %6
%97 = load i32, i32* %9
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds double, double* %96, i64 %98
%100 = load double, double* %99
%101 = load double*, double** %6
%102 = load i32, i32* %10
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds double, double* %101, i64 %103
%105 = load double, double* %104
%106 = fadd double %100, %105
store double %106, double* %28
%107 = load double*, double** %6
%108 = load i32, i32* %9
%109 = add nsw i32 %108, 1
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds double, double* %107, i64 %110
%112 = load double, double* %111
%113 = load double*, double** %6
%114 = load i32, i32* %10
%115 = add nsw i32 %114, 1
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds double, double* %113, i64 %116
%118 = load double, double* %117
%119 = fadd double %112, %118
store double %119, double* %29
%120 = load double*, double** %6
%121 = load i32, i32* %9
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds double, double* %120, i64 %122
%124 = load double, double* %123
%125 = load double*, double** %6
%126 = load i32, i32* %10
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds double, double* %125, i64 %127
%129 = load double, double* %128
%130 = fsub double %124, %129
store double %130, double* %30
%131 = load double*, double** %6
%132 = load i32, i32* %9
%133 = add nsw i32 %132, 1
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds double, double* %131, i64 %134
%136 = load double, double* %135
%137 = load double*, double** %6
%138 = load i32, i32* %10
%139 = add nsw i32 %138, 1
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds double, double* %137, i64 %140
%142 = load double, double* %141
%143 = fsub double %136, %142
store double %143, double* %31
%144 = load double, double* %24
%145 = load double, double* %28
%146 = fadd double %144, %145
%147 = load double*, double** %6
%148 = load i32, i32* %7
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds double, double* %147, i64 %149
store double %146, double* %150
%151 = load double, double* %25
%152 = load double, double* %29
%153 = fadd double %151, %152
%154 = load double*, double** %6
%155 = load i32, i32* %7
%156 = add nsw i32 %155, 1
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds double, double* %154, i64 %157
store double %153, double* %158
%159 = load double, double* %24
%160 = load double, double* %28
%161 = fsub double %159, %160
%162 = load double*, double** %6
%163 = load i32, i32* %9
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds double, double* %162, i64 %164
store double %161, double* %165
%166 = load double, double* %25
%167 = load double, double* %29
%168 = fsub double %166, %167
%169 = load double*, double** %6
%170 = load i32, i32* %9
%171 = add nsw i32 %170, 1
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds double, double* %169, i64 %172
store double %168, double* %173
%174 = load double, double* %26
%175 = load double, double* %31
%176 = fsub double %174, %175
%177 = load double*, double** %6
%178 = load i32, i32* %8
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds double, double* %177, i64 %179
store double %176, double* %180
%181 = load double, double* %27
%182 = load double, double* %30
%183 = fadd double %181, %182
%184 = load double*, double** %6
%185 = load i32, i32* %8
%186 = add nsw i32 %185, 1
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds double, double* %184, i64 %187
store double %183, double* %188
%189 = load double, double* %26
%190 = load double, double* %31
%191 = fadd double %189, %190
%192 = load double*, double** %6
%193 = load i32, i32* %10
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds double, double* %192, i64 %194
store double %191, double* %195
%196 = load double, double* %27
%197 = load double, double* %30
%198 = fsub double %196, %197
%199 = load double*, double** %6
%200 = load i32, i32* %10
%201 = add nsw i32 %200, 1
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds double, double* %199, i64 %202
store double %198, double* %203
br label %204
204: ; preds = %38
%205 = load i32, i32* %7
%206 = add nsw i32 %205, 2
store i32 %206, i32* %7
br label %34
207: ; preds = %34
store double 0x3FE6A09E667F3BCD, double* %17
%208 = load i32, i32* %14
store i32 %208, i32* %7
br label %209
209: ; preds = %401, %207
%210 = load i32, i32* %7
%211 = load i32, i32* %5
%212 = load i32, i32* %14
%213 = add nsw i32 %211, %212
%214 = icmp slt i32 %210, %213
br i1 %214, label %215, label %404
215: ; preds = %209
%216 = load i32, i32* %7
%217 = load i32, i32* %5
%218 = add nsw i32 %216, %217
store i32 %218, i32* %8
%219 = load i32, i32* %8
%220 = load i32, i32* %5
%221 = add nsw i32 %219, %220
store i32 %221, i32* %9
%222 = load i32, i32* %9
%223 = load i32, i32* %5
%224 = add nsw i32 %222, %223
store i32 %224, i32* %10
%225 = load double*, double** %6
%226 = load i32, i32* %7
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds double, double* %225, i64 %227
%229 = load double, double* %228
%230 = load double*, double** %6
%231 = load i32, i32* %8
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds double, double* %230, i64 %232
%234 = load double, double* %233
%235 = fadd double %229, %234
store double %235, double* %24
%236 = load double*, double** %6
%237 = load i32, i32* %7
%238 = add nsw i32 %237, 1
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds double, double* %236, i64 %239
%241 = load double, double* %240
%242 = load double*, double** %6
%243 = load i32, i32* %8
%244 = add nsw i32 %243, 1
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds double, double* %242, i64 %245
%247 = load double, double* %246
%248 = fadd double %241, %247
store double %248, double* %25
%249 = load double*, double** %6
%250 = load i32, i32* %7
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds double, double* %249, i64 %251
%253 = load double, double* %252
%254 = load double*, double** %6
%255 = load i32, i32* %8
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds double, double* %254, i64 %256
%258 = load double, double* %257
%259 = fsub double %253, %258
store double %259, double* %26
%260 = load double*, double** %6
%261 = load i32, i32* %7
%262 = add nsw i32 %261, 1
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds double, double* %260, i64 %263
%265 = load double, double* %264
%266 = load double*, double** %6
%267 = load i32, i32* %8
%268 = add nsw i32 %267, 1
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds double, double* %266, i64 %269
%271 = load double, double* %270
%272 = fsub double %265, %271
store double %272, double* %27
%273 = load double*, double** %6
%274 = load i32, i32* %9
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds double, double* %273, i64 %275
%277 = load double, double* %276
%278 = load double*, double** %6
%279 = load i32, i32* %10
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds double, double* %278, i64 %280
%282 = load double, double* %281
%283 = fadd double %277, %282
store double %283, double* %28
%284 = load double*, double** %6
%285 = load i32, i32* %9
%286 = add nsw i32 %285, 1
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds double, double* %284, i64 %287
%289 = load double, double* %288
%290 = load double*, double** %6
%291 = load i32, i32* %10
%292 = add nsw i32 %291, 1
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds double, double* %290, i64 %293
%295 = load double, double* %294
%296 = fadd double %289, %295
store double %296, double* %29
%297 = load double*, double** %6
%298 = load i32, i32* %9
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds double, double* %297, i64 %299
%301 = load double, double* %300
%302 = load double*, double** %6
%303 = load i32, i32* %10
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds double, double* %302, i64 %304
%306 = load double, double* %305
%307 = fsub double %301, %306
store double %307, double* %30
%308 = load double*, double** %6
%309 = load i32, i32* %9
%310 = add nsw i32 %309, 1
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds double, double* %308, i64 %311
%313 = load double, double* %312
%314 = load double*, double** %6
%315 = load i32, i32* %10
%316 = add nsw i32 %315, 1
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds double, double* %314, i64 %317
%319 = load double, double* %318
%320 = fsub double %313, %319
store double %320, double* %31
%321 = load double, double* %24
%322 = load double, double* %28
%323 = fadd double %321, %322
%324 = load double*, double** %6
%325 = load i32, i32* %7
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds double, double* %324, i64 %326
store double %323, double* %327
%328 = load double, double* %25
%329 = load double, double* %29
%330 = fadd double %328, %329
%331 = load double*, double** %6
%332 = load i32, i32* %7
%333 = add nsw i32 %332, 1
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds double, double* %331, i64 %334
store double %330, double* %335
%336 = load double, double* %29
%337 = load double, double* %25
%338 = fsub double %336, %337
%339 = load double*, double** %6
%340 = load i32, i32* %9
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds double, double* %339, i64 %341
store double %338, double* %342
%343 = load double, double* %24
%344 = load double, double* %28
%345 = fsub double %343, %344
%346 = load double*, double** %6
%347 = load i32, i32* %9
%348 = add nsw i32 %347, 1
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds double, double* %346, i64 %349
store double %345, double* %350
%351 = load double, double* %26
%352 = load double, double* %31
%353 = fsub double %351, %352
store double %353, double* %24
%354 = load double, double* %27
%355 = load double, double* %30
%356 = fadd double %354, %355
store double %356, double* %25
%357 = load double, double* %17
%358 = load double, double* %24
%359 = load double, double* %25
%360 = fsub double %358, %359
%361 = fmul double %357, %360
%362 = load double*, double** %6
%363 = load i32, i32* %8
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds double, double* %362, i64 %364
store double %361, double* %365
%366 = load double, double* %17
%367 = load double, double* %24
%368 = load double, double* %25
%369 = fadd double %367, %368
%370 = fmul double %366, %369
%371 = load double*, double** %6
%372 = load i32, i32* %8
%373 = add nsw i32 %372, 1
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds double, double* %371, i64 %374
store double %370, double* %375
%376 = load double, double* %31
%377 = load double, double* %26
%378 = fadd double %376, %377
store double %378, double* %24
%379 = load double, double* %30
%380 = load double, double* %27
%381 = fsub double %379, %380
store double %381, double* %25
%382 = load double, double* %17
%383 = load double, double* %25
%384 = load double, double* %24
%385 = fsub double %383, %384
%386 = fmul double %382, %385
%387 = load double*, double** %6
%388 = load i32, i32* %10
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds double, double* %387, i64 %389
store double %386, double* %390
%391 = load double, double* %17
%392 = load double, double* %25
%393 = load double, double* %24
%394 = fadd double %392, %393
%395 = fmul double %391, %394
%396 = load double*, double** %6
%397 = load i32, i32* %10
%398 = add nsw i32 %397, 1
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds double, double* %396, i64 %399
store double %395, double* %400
br label %401
401: ; preds = %215
%402 = load i32, i32* %7
%403 = add nsw i32 %402, 2
store i32 %403, i32* %7
br label %209
404: ; preds = %209
%405 = load i32, i32* %4
%406 = sitofp i32 %405 to double
%407 = fdiv double 0x3FF921FB54442D18, %406
store double %407, double* %16
store i32 0, i32* %13
%408 = load i32, i32* %14
%409 = mul nsw i32 2, %408
store i32 %409, i32* %15
%410 = load i32, i32* %15
store i32 %410, i32* %11
br label %411
411: ; preds = %921, %404
%412 = load i32, i32* %11
%413 = load i32, i32* %4
%414 = icmp slt i32 %412, %413
br i1 %414, label %415, label %925
415: ; preds = %411
%416 = load i32, i32* %4
%417 = ashr i32 %416, 2
store i32 %417, i32* %12
br label %418
418: ; preds = %425, %415
%419 = load i32, i32* %12
%420 = load i32, i32* %12
%421 = load i32, i32* %13
%422 = xor i32 %421, %420
store i32 %422, i32* %13
%423 = icmp sgt i32 %419, %422
br i1 %423, label %424, label %428
424: ; preds = %418
br label %425
425: ; preds = %424
%426 = load i32, i32* %12
%427 = ashr i32 %426, 1
store i32 %427, i32* %12
br label %418
428: ; preds = %418
%429 = load double, double* %16
%430 = load i32, i32* %13
%431 = sitofp i32 %430 to double
%432 = fmul double %429, %431
%433 = call double @cos(double %432)
store double %433, double* %18
%434 = load double, double* %16
%435 = load i32, i32* %13
%436 = sitofp i32 %435 to double
%437 = fmul double %434, %436
%438 = call double @sin(double %437)
store double %438, double* %19
%439 = load double, double* %19
%440 = fmul double 2.000000e+00, %439
%441 = load double, double* %19
%442 = fneg double %440
%443 = call double @llvm.fmuladd.f64(double %442, double %441, double 1.000000e+00)
store double %443, double* %20
%444 = load double, double* %19
%445 = fmul double 2.000000e+00, %444
%446 = load double, double* %18
%447 = fmul double %445, %446
store double %447, double* %21
%448 = load double, double* %18
%449 = load double, double* %21
%450 = fmul double 2.000000e+00, %449
%451 = load double, double* %19
%452 = fneg double %450
%453 = call double @llvm.fmuladd.f64(double %452, double %451, double %448)
store double %453, double* %22
%454 = load double, double* %21
%455 = fmul double 2.000000e+00, %454
%456 = load double, double* %18
%457 = load double, double* %19
%458 = fneg double %457
%459 = call double @llvm.fmuladd.f64(double %455, double %456, double %458)
store double %459, double* %23
%460 = load i32, i32* %11
store i32 %460, i32* %7
br label %461
461: ; preds = %672, %428
%462 = load i32, i32* %7
%463 = load i32, i32* %5
%464 = load i32, i32* %11
%465 = add nsw i32 %463, %464
%466 = icmp slt i32 %462, %465
br i1 %466, label %467, label %675
467: ; preds = %461
%468 = load i32, i32* %7
%469 = load i32, i32* %5
%470 = add nsw i32 %468, %469
store i32 %470, i32* %8
%471 = load i32, i32* %8
%472 = load i32, i32* %5
%473 = add nsw i32 %471, %472
store i32 %473, i32* %9
%474 = load i32, i32* %9
%475 = load i32, i32* %5
%476 = add nsw i32 %474, %475
store i32 %476, i32* %10
%477 = load double*, double** %6
%478 = load i32, i32* %7
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds double, double* %477, i64 %479
%481 = load double, double* %480
%482 = load double*, double** %6
%483 = load i32, i32* %8
%484 = sext i32 %483 to i64
%485 = getelementptr inbounds double, double* %482, i64 %484
%486 = load double, double* %485
%487 = fadd double %481, %486
store double %487, double* %24
%488 = load double*, double** %6
%489 = load i32, i32* %7
%490 = add nsw i32 %489, 1
%491 = sext i32 %490 to i64
%492 = getelementptr inbounds double, double* %488, i64 %491
%493 = load double, double* %492
%494 = load double*, double** %6
%495 = load i32, i32* %8
%496 = add nsw i32 %495, 1
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds double, double* %494, i64 %497
%499 = load double, double* %498
%500 = fadd double %493, %499
store double %500, double* %25
%501 = load double*, double** %6
%502 = load i32, i32* %7
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds double, double* %501, i64 %503
%505 = load double, double* %504
%506 = load double*, double** %6
%507 = load i32, i32* %8
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds double, double* %506, i64 %508
%510 = load double, double* %509
%511 = fsub double %505, %510
store double %511, double* %26
%512 = load double*, double** %6
%513 = load i32, i32* %7
%514 = add nsw i32 %513, 1
%515 = sext i32 %514 to i64
%516 = getelementptr inbounds double, double* %512, i64 %515
%517 = load double, double* %516
%518 = load double*, double** %6
%519 = load i32, i32* %8
%520 = add nsw i32 %519, 1
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds double, double* %518, i64 %521
%523 = load double, double* %522
%524 = fsub double %517, %523
store double %524, double* %27
%525 = load double*, double** %6
%526 = load i32, i32* %9
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds double, double* %525, i64 %527
%529 = load double, double* %528
%530 = load double*, double** %6
%531 = load i32, i32* %10
%532 = sext i32 %531 to i64
%533 = getelementptr inbounds double, double* %530, i64 %532
%534 = load double, double* %533
%535 = fadd double %529, %534
store double %535, double* %28
%536 = load double*, double** %6
%537 = load i32, i32* %9
%538 = add nsw i32 %537, 1
%539 = sext i32 %538 to i64
%540 = getelementptr inbounds double, double* %536, i64 %539
%541 = load double, double* %540
%542 = load double*, double** %6
%543 = load i32, i32* %10
%544 = add nsw i32 %543, 1
%545 = sext i32 %544 to i64
%546 = getelementptr inbounds double, double* %542, i64 %545
%547 = load double, double* %546
%548 = fadd double %541, %547
store double %548, double* %29
%549 = load double*, double** %6
%550 = load i32, i32* %9
%551 = sext i32 %550 to i64
%552 = getelementptr inbounds double, double* %549, i64 %551
%553 = load double, double* %552
%554 = load double*, double** %6
%555 = load i32, i32* %10
%556 = sext i32 %555 to i64
%557 = getelementptr inbounds double, double* %554, i64 %556
%558 = load double, double* %557
%559 = fsub double %553, %558
store double %559, double* %30
%560 = load double*, double** %6
%561 = load i32, i32* %9
%562 = add nsw i32 %561, 1
%563 = sext i32 %562 to i64
%564 = getelementptr inbounds double, double* %560, i64 %563
%565 = load double, double* %564
%566 = load double*, double** %6
%567 = load i32, i32* %10
%568 = add nsw i32 %567, 1
%569 = sext i32 %568 to i64
%570 = getelementptr inbounds double, double* %566, i64 %569
%571 = load double, double* %570
%572 = fsub double %565, %571
store double %572, double* %31
%573 = load double, double* %24
%574 = load double, double* %28
%575 = fadd double %573, %574
%576 = load double*, double** %6
%577 = load i32, i32* %7
%578 = sext i32 %577 to i64
%579 = getelementptr inbounds double, double* %576, i64 %578
store double %575, double* %579
%580 = load double, double* %25
%581 = load double, double* %29
%582 = fadd double %580, %581
%583 = load double*, double** %6
%584 = load i32, i32* %7
%585 = add nsw i32 %584, 1
%586 = sext i32 %585 to i64
%587 = getelementptr inbounds double, double* %583, i64 %586
store double %582, double* %587
%588 = load double, double* %28
%589 = load double, double* %24
%590 = fsub double %589, %588
store double %590, double* %24
%591 = load double, double* %29
%592 = load double, double* %25
%593 = fsub double %592, %591
store double %593, double* %25
%594 = load double, double* %20
%595 = load double, double* %24
%596 = load double, double* %21
%597 = load double, double* %25
%598 = fmul double %596, %597
%599 = fneg double %598
%600 = call double @llvm.fmuladd.f64(double %594, double %595, double %599)
%601 = load double*, double** %6
%602 = load i32, i32* %9
%603 = sext i32 %602 to i64
%604 = getelementptr inbounds double, double* %601, i64 %603
store double %600, double* %604
%605 = load double, double* %20
%606 = load double, double* %25
%607 = load double, double* %21
%608 = load double, double* %24
%609 = fmul double %607, %608
%610 = call double @llvm.fmuladd.f64(double %605, double %606, double %609)
%611 = load double*, double** %6
%612 = load i32, i32* %9
%613 = add nsw i32 %612, 1
%614 = sext i32 %613 to i64
%615 = getelementptr inbounds double, double* %611, i64 %614
store double %610, double* %615
%616 = load double, double* %26
%617 = load double, double* %31
%618 = fsub double %616, %617
store double %618, double* %24
%619 = load double, double* %27
%620 = load double, double* %30
%621 = fadd double %619, %620
store double %621, double* %25
%622 = load double, double* %18
%623 = load double, double* %24
%624 = load double, double* %19
%625 = load double, double* %25
%626 = fmul double %624, %625
%627 = fneg double %626
%628 = call double @llvm.fmuladd.f64(double %622, double %623, double %627)
%629 = load double*, double** %6
%630 = load i32, i32* %8
%631 = sext i32 %630 to i64
%632 = getelementptr inbounds double, double* %629, i64 %631
store double %628, double* %632
%633 = load double, double* %18
%634 = load double, double* %25
%635 = load double, double* %19
%636 = load double, double* %24
%637 = fmul double %635, %636
%638 = call double @llvm.fmuladd.f64(double %633, double %634, double %637)
%639 = load double*, double** %6
%640 = load i32, i32* %8
%641 = add nsw i32 %640, 1
%642 = sext i32 %641 to i64
%643 = getelementptr inbounds double, double* %639, i64 %642
store double %638, double* %643
%644 = load double, double* %26
%645 = load double, double* %31
%646 = fadd double %644, %645
store double %646, double* %24
%647 = load double, double* %27
%648 = load double, double* %30
%649 = fsub double %647, %648
store double %649, double* %25
%650 = load double, double* %22
%651 = load double, double* %24
%652 = load double, double* %23
%653 = load double, double* %25
%654 = fmul double %652, %653
%655 = fneg double %654
%656 = call double @llvm.fmuladd.f64(double %650, double %651, double %655)
%657 = load double*, double** %6
%658 = load i32, i32* %10
%659 = sext i32 %658 to i64
%660 = getelementptr inbounds double, double* %657, i64 %659
store double %656, double* %660
%661 = load double, double* %22
%662 = load double, double* %25
%663 = load double, double* %23
%664 = load double, double* %24
%665 = fmul double %663, %664
%666 = call double @llvm.fmuladd.f64(double %661, double %662, double %665)
%667 = load double*, double** %6
%668 = load i32, i32* %10
%669 = add nsw i32 %668, 1
%670 = sext i32 %669 to i64
%671 = getelementptr inbounds double, double* %667, i64 %670
store double %666, double* %671
br label %672
672: ; preds = %467
%673 = load i32, i32* %7
%674 = add nsw i32 %673, 2
store i32 %674, i32* %7
br label %461
675: ; preds = %461
%676 = load double, double* %17
%677 = load double, double* %18
%678 = load double, double* %19
%679 = fsub double %677, %678
%680 = fmul double %676, %679
store double %680, double* %24
%681 = load double, double* %17
%682 = load double, double* %18
%683 = load double, double* %19
%684 = fadd double %682, %683
%685 = fmul double %681, %684
store double %685, double* %19
%686 = load double, double* %24
store double %686, double* %18
%687 = load double, double* %18
%688 = load double, double* %20
%689 = fmul double 2.000000e+00, %688
%690 = load double, double* %19
%691 = fneg double %689
%692 = call double @llvm.fmuladd.f64(double %691, double %690, double %687)
store double %692, double* %22
%693 = load double, double* %20
%694 = fmul double 2.000000e+00, %693
%695 = load double, double* %18
%696 = load double, double* %19
%697 = fneg double %696
%698 = call double @llvm.fmuladd.f64(double %694, double %695, double %697)
store double %698, double* %23
%699 = load i32, i32* %11
%700 = load i32, i32* %14
%701 = add nsw i32 %699, %700
store i32 %701, i32* %7
br label %702
702: ; preds = %917, %675
%703 = load i32, i32* %7
%704 = load i32, i32* %5
%705 = load i32, i32* %11
%706 = load i32, i32* %14
%707 = add nsw i32 %705, %706
%708 = add nsw i32 %704, %707
%709 = icmp slt i32 %703, %708
br i1 %709, label %710, label %920
710: ; preds = %702
%711 = load i32, i32* %7
%712 = load i32, i32* %5
%713 = add nsw i32 %711, %712
store i32 %713, i32* %8
%714 = load i32, i32* %8
%715 = load i32, i32* %5
%716 = add nsw i32 %714, %715
store i32 %716, i32* %9
%717 = load i32, i32* %9
%718 = load i32, i32* %5
%719 = add nsw i32 %717, %718
store i32 %719, i32* %10
%720 = load double*, double** %6
%721 = load i32, i32* %7
%722 = sext i32 %721 to i64
%723 = getelementptr inbounds double, double* %720, i64 %722
%724 = load double, double* %723
%725 = load double*, double** %6
%726 = load i32, i32* %8
%727 = sext i32 %726 to i64
%728 = getelementptr inbounds double, double* %725, i64 %727
%729 = load double, double* %728
%730 = fadd double %724, %729
store double %730, double* %24
%731 = load double*, double** %6
%732 = load i32, i32* %7
%733 = add nsw i32 %732, 1
%734 = sext i32 %733 to i64
%735 = getelementptr inbounds double, double* %731, i64 %734
%736 = load double, double* %735
%737 = load double*, double** %6
%738 = load i32, i32* %8
%739 = add nsw i32 %738, 1
%740 = sext i32 %739 to i64
%741 = getelementptr inbounds double, double* %737, i64 %740
%742 = load double, double* %741
%743 = fadd double %736, %742
store double %743, double* %25
%744 = load double*, double** %6
%745 = load i32, i32* %7
%746 = sext i32 %745 to i64
%747 = getelementptr inbounds double, double* %744, i64 %746
%748 = load double, double* %747
%749 = load double*, double** %6
%750 = load i32, i32* %8
%751 = sext i32 %750 to i64
%752 = getelementptr inbounds double, double* %749, i64 %751
%753 = load double, double* %752
%754 = fsub double %748, %753
store double %754, double* %26
%755 = load double*, double** %6
%756 = load i32, i32* %7
%757 = add nsw i32 %756, 1
%758 = sext i32 %757 to i64
%759 = getelementptr inbounds double, double* %755, i64 %758
%760 = load double, double* %759
%761 = load double*, double** %6
%762 = load i32, i32* %8
%763 = add nsw i32 %762, 1
%764 = sext i32 %763 to i64
%765 = getelementptr inbounds double, double* %761, i64 %764
%766 = load double, double* %765
%767 = fsub double %760, %766
store double %767, double* %27
%768 = load double*, double** %6
%769 = load i32, i32* %9
%770 = sext i32 %769 to i64
%771 = getelementptr inbounds double, double* %768, i64 %770
%772 = load double, double* %771
%773 = load double*, double** %6
%774 = load i32, i32* %10
%775 = sext i32 %774 to i64
%776 = getelementptr inbounds double, double* %773, i64 %775
%777 = load double, double* %776
%778 = fadd double %772, %777
store double %778, double* %28
%779 = load double*, double** %6
%780 = load i32, i32* %9
%781 = add nsw i32 %780, 1
%782 = sext i32 %781 to i64
%783 = getelementptr inbounds double, double* %779, i64 %782
%784 = load double, double* %783
%785 = load double*, double** %6
%786 = load i32, i32* %10
%787 = add nsw i32 %786, 1
%788 = sext i32 %787 to i64
%789 = getelementptr inbounds double, double* %785, i64 %788
%790 = load double, double* %789
%791 = fadd double %784, %790
store double %791, double* %29
%792 = load double*, double** %6
%793 = load i32, i32* %9
%794 = sext i32 %793 to i64
%795 = getelementptr inbounds double, double* %792, i64 %794
%796 = load double, double* %795
%797 = load double*, double** %6
%798 = load i32, i32* %10
%799 = sext i32 %798 to i64
%800 = getelementptr inbounds double, double* %797, i64 %799
%801 = load double, double* %800
%802 = fsub double %796, %801
store double %802, double* %30
%803 = load double*, double** %6
%804 = load i32, i32* %9
%805 = add nsw i32 %804, 1
%806 = sext i32 %805 to i64
%807 = getelementptr inbounds double, double* %803, i64 %806
%808 = load double, double* %807
%809 = load double*, double** %6
%810 = load i32, i32* %10
%811 = add nsw i32 %810, 1
%812 = sext i32 %811 to i64
%813 = getelementptr inbounds double, double* %809, i64 %812
%814 = load double, double* %813
%815 = fsub double %808, %814
store double %815, double* %31
%816 = load double, double* %24
%817 = load double, double* %28
%818 = fadd double %816, %817
%819 = load double*, double** %6
%820 = load i32, i32* %7
%821 = sext i32 %820 to i64
%822 = getelementptr inbounds double, double* %819, i64 %821
store double %818, double* %822
%823 = load double, double* %25
%824 = load double, double* %29
%825 = fadd double %823, %824
%826 = load double*, double** %6
%827 = load i32, i32* %7
%828 = add nsw i32 %827, 1
%829 = sext i32 %828 to i64
%830 = getelementptr inbounds double, double* %826, i64 %829
store double %825, double* %830
%831 = load double, double* %28
%832 = load double, double* %24
%833 = fsub double %832, %831
store double %833, double* %24
%834 = load double, double* %29
%835 = load double, double* %25
%836 = fsub double %835, %834
store double %836, double* %25
%837 = load double, double* %21
%838 = fneg double %837
%839 = load double, double* %24
%840 = load double, double* %20
%841 = load double, double* %25
%842 = fmul double %840, %841
%843 = fneg double %842
%844 = call double @llvm.fmuladd.f64(double %838, double %839, double %843)
%845 = load double*, double** %6
%846 = load i32, i32* %9
%847 = sext i32 %846 to i64
%848 = getelementptr inbounds double, double* %845, i64 %847
store double %844, double* %848
%849 = load double, double* %21
%850 = fneg double %849
%851 = load double, double* %25
%852 = load double, double* %20
%853 = load double, double* %24
%854 = fmul double %852, %853
%855 = call double @llvm.fmuladd.f64(double %850, double %851, double %854)
%856 = load double*, double** %6
%857 = load i32, i32* %9
%858 = add nsw i32 %857, 1
%859 = sext i32 %858 to i64
%860 = getelementptr inbounds double, double* %856, i64 %859
store double %855, double* %860
%861 = load double, double* %26
%862 = load double, double* %31
%863 = fsub double %861, %862
store double %863, double* %24
%864 = load double, double* %27
%865 = load double, double* %30
%866 = fadd double %864, %865
store double %866, double* %25
%867 = load double, double* %18
%868 = load double, double* %24
%869 = load double, double* %19
%870 = load double, double* %25
%871 = fmul double %869, %870
%872 = fneg double %871
%873 = call double @llvm.fmuladd.f64(double %867, double %868, double %872)
%874 = load double*, double** %6
%875 = load i32, i32* %8
%876 = sext i32 %875 to i64
%877 = getelementptr inbounds double, double* %874, i64 %876
store double %873, double* %877
%878 = load double, double* %18
%879 = load double, double* %25
%880 = load double, double* %19
%881 = load double, double* %24
%882 = fmul double %880, %881
%883 = call double @llvm.fmuladd.f64(double %878, double %879, double %882)
%884 = load double*, double** %6
%885 = load i32, i32* %8
%886 = add nsw i32 %885, 1
%887 = sext i32 %886 to i64
%888 = getelementptr inbounds double, double* %884, i64 %887
store double %883, double* %888
%889 = load double, double* %26
%890 = load double, double* %31
%891 = fadd double %889, %890
store double %891, double* %24
%892 = load double, double* %27
%893 = load double, double* %30
%894 = fsub double %892, %893
store double %894, double* %25
%895 = load double, double* %22
%896 = load double, double* %24
%897 = load double, double* %23
%898 = load double, double* %25
%899 = fmul double %897, %898
%900 = fneg double %899
%901 = call double @llvm.fmuladd.f64(double %895, double %896, double %900)
%902 = load double*, double** %6
%903 = load i32, i32* %10
%904 = sext i32 %903 to i64
%905 = getelementptr inbounds double, double* %902, i64 %904
store double %901, double* %905
%906 = load double, double* %22
%907 = load double, double* %25
%908 = load double, double* %23
%909 = load double, double* %24
%910 = fmul double %908, %909
%911 = call double @llvm.fmuladd.f64(double %906, double %907, double %910)
%912 = load double*, double** %6
%913 = load i32, i32* %10
%914 = add nsw i32 %913, 1
%915 = sext i32 %914 to i64
%916 = getelementptr inbounds double, double* %912, i64 %915
store double %911, double* %916
br label %917
917: ; preds = %710
%918 = load i32, i32* %7
%919 = add nsw i32 %918, 2
store i32 %919, i32* %7
br label %702
920: ; preds = %702
br label %921
921: ; preds = %920
%922 = load i32, i32* %15
%923 = load i32, i32* %11
%924 = add nsw i32 %923, %922
store i32 %924, i32* %11
br label %411
925: ; preds = %411
ret void
}

LLVM IR (-O2):
define void @cftmdl(i32 %0, i32 %1, double* %2) {
%4 = shl i32 %1, 2
%5 = icmp sgt i32 %1, 0
br i1 %5, label %6, label %8
6: ; preds = %3
%7 = zext i32 %1 to i64
br label %15
8: ; preds = %15, %3
%9 = mul i32 %1, 5
%10 = icmp slt i32 %4, %9
br i1 %10, label %11, label %107
11: ; preds = %8
%12 = sext i32 %4 to i64
%13 = sext i32 %1 to i64
%14 = sext i32 %9 to i64
br label %49
15: ; preds = %6, %15
%16 = phi i64 [ 0, %6 ], [ %47, %15 ]
%17 = add nuw nsw i64 %16, %7
%18 = add nuw nsw i64 %17, %7
%19 = add nuw nsw i64 %18, %7
%20 = getelementptr inbounds double, double* %2, i64 %16
%21 = getelementptr inbounds double, double* %2, i64 %17
%22 = bitcast double* %20 to <2 x double>*
%23 = load <2 x double>, <2 x double>* %22
%24 = bitcast double* %21 to <2 x double>*
%25 = load <2 x double>, <2 x double>* %24
%26 = fadd <2 x double> %23, %25
%27 = fsub <2 x double> %23, %25
%28 = getelementptr inbounds double, double* %2, i64 %18
%29 = getelementptr inbounds double, double* %2, i64 %19
%30 = bitcast double* %28 to <2 x double>*
%31 = load <2 x double>, <2 x double>* %30
%32 = bitcast double* %29 to <2 x double>*
%33 = load <2 x double>, <2 x double>* %32
%34 = fadd <2 x double> %31, %33
%35 = fsub <2 x double> %31, %33
%36 = shufflevector <2 x double> %35, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%37 = fadd <2 x double> %26, %34
%38 = bitcast double* %20 to <2 x double>*
store <2 x double> %37, <2 x double>* %38
%39 = fsub <2 x double> %26, %34
%40 = bitcast double* %28 to <2 x double>*
store <2 x double> %39, <2 x double>* %40
%41 = fsub <2 x double> %27, %36
%42 = fadd <2 x double> %27, %36
%43 = shufflevector <2 x double> %41, <2 x double> %42, <2 x i32> <i32 0, i32 3>
%44 = bitcast double* %21 to <2 x double>*
store <2 x double> %43, <2 x double>* %44
%45 = shufflevector <2 x double> %42, <2 x double> %41, <2 x i32> <i32 0, i32 3>
%46 = bitcast double* %29 to <2 x double>*
store <2 x double> %45, <2 x double>* %46
%47 = add nuw nsw i64 %16, 2
%48 = icmp ult i64 %47, %7
br i1 %48, label %15, label %8
49: ; preds = %11, %49
%50 = phi i64 [ %12, %11 ], [ %105, %49 ]
%51 = add nsw i64 %50, %13
%52 = add nsw i64 %51, %13
%53 = add nsw i64 %52, %13
%54 = getelementptr inbounds double, double* %2, i64 %50
%55 = load double, double* %54
%56 = getelementptr inbounds double, double* %2, i64 %51
%57 = load double, double* %56
%58 = or i64 %50, 1
%59 = getelementptr inbounds double, double* %2, i64 %58
%60 = load double, double* %59
%61 = add nsw i64 %51, 1
%62 = getelementptr inbounds double, double* %2, i64 %61
%63 = load double, double* %62
%64 = fsub double %55, %57
%65 = fsub double %60, %63
%66 = getelementptr inbounds double, double* %2, i64 %52
%67 = load double, double* %66
%68 = getelementptr inbounds double, double* %2, i64 %53
%69 = load double, double* %68
%70 = insertelement <2 x double> poison, double %60, i64 0
%71 = insertelement <2 x double> %70, double %67, i64 1
%72 = insertelement <2 x double> poison, double %63, i64 0
%73 = insertelement <2 x double> %72, double %69, i64 1
%74 = fadd <2 x double> %71, %73
%75 = add nsw i64 %52, 1
%76 = getelementptr inbounds double, double* %2, i64 %75
%77 = load double, double* %76
%78 = add nsw i64 %53, 1
%79 = getelementptr inbounds double, double* %2, i64 %78
%80 = load double, double* %79
%81 = insertelement <2 x double> poison, double %77, i64 0
%82 = insertelement <2 x double> %81, double %55, i64 1
%83 = insertelement <2 x double> poison, double %80, i64 0
%84 = insertelement <2 x double> %83, double %57, i64 1
%85 = fadd <2 x double> %82, %84
%86 = fsub double %67, %69
%87 = fsub double %77, %80
%88 = fadd <2 x double> %74, %85
%89 = shufflevector <2 x double> %88, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%90 = bitcast double* %54 to <2 x double>*
store <2 x double> %89, <2 x double>* %90
%91 = fsub <2 x double> %85, %74
%92 = bitcast double* %66 to <2 x double>*
store <2 x double> %91, <2 x double>* %92
%93 = fsub double %64, %87
%94 = fadd double %65, %86
%95 = fsub double %93, %94
%96 = fmul double %95, 0x3FE6A09E667F3BCD
store double %96, double* %56
%97 = fadd double %94, %93
%98 = fmul double %97, 0x3FE6A09E667F3BCD
store double %98, double* %62
%99 = fadd double %64, %87
%100 = fsub double %86, %65
%101 = fsub double %100, %99
%102 = fmul double %101, 0x3FE6A09E667F3BCD
store double %102, double* %68
%103 = fadd double %100, %99
%104 = fmul double %103, 0x3FE6A09E667F3BCD
store double %104, double* %79
%105 = add nsw i64 %50, 2
%106 = icmp slt i64 %105, %14
br i1 %106, label %49, label %107
107: ; preds = %49, %8
%108 = sitofp i32 %0 to double
%109 = fdiv double 0x3FF921FB54442D18, %108
%110 = shl i32 %1, 3
%111 = icmp slt i32 %110, %0
br i1 %111, label %112, label %292
112: ; preds = %107
%113 = ashr i32 %0, 2
%114 = sext i32 %110 to i64
%115 = sext i32 %1 to i64
%116 = mul i32 %1, 12
%117 = sext i32 %0 to i64
%118 = sext i32 %4 to i64
br label %119
119: ; preds = %112, %288
%120 = phi i32 [ %116, %112 ], [ %291, %288 ]
%121 = phi i64 [ %114, %112 ], [ %289, %288 ]
%122 = phi i32 [ 0, %112 ], [ %127, %288 ]
%123 = sext i32 %120 to i64
br label %124
124: ; preds = %124, %119
%125 = phi i32 [ %122, %119 ], [ %127, %124 ]
%126 = phi i32 [ %113, %119 ], [ %129, %124 ]
%127 = xor i32 %126, %125
%128 = icmp sgt i32 %126, %127
%129 = ashr i32 %126, 1
br i1 %128, label %124, label %130
130: ; preds = %124
%131 = sitofp i32 %127 to double
%132 = fmul double %109, %131
%133 = tail call double @cos(double %132)
%134 = tail call double @sin(double %132)
%135 = fmul double %134, 2.000000e+00
%136 = fneg double %135
%137 = tail call double @llvm.fmuladd.f64(double %136, double %134, double 1.000000e+00)
%138 = fmul double %133, %135
%139 = fmul double %138, 2.000000e+00
%140 = fneg double %134
%141 = tail call double @llvm.fmuladd.f64(double %139, double %133, double %140)
%142 = add nsw i64 %121, %115
br i1 %5, label %143, label %206
143: ; preds = %130
%144 = fneg double %139
%145 = tail call double @llvm.fmuladd.f64(double %144, double %134, double %133)
%146 = fneg double %138
%147 = fneg double %141
%148 = insertelement <2 x double> poison, double %145, i64 0
%149 = shufflevector <2 x double> %148, <2 x double> poison, <2 x i32> zeroinitializer
%150 = insertelement <2 x double> poison, double %141, i64 1
%151 = insertelement <2 x double> poison, double %147, i64 0
%152 = insertelement <2 x double> poison, double %133, i64 0
%153 = shufflevector <2 x double> %152, <2 x double> poison, <2 x i32> zeroinitializer
%154 = insertelement <2 x double> poison, double %134, i64 1
%155 = insertelement <2 x double> poison, double %140, i64 0
%156 = insertelement <2 x double> poison, double %137, i64 0
%157 = shufflevector <2 x double> %156, <2 x double> poison, <2 x i32> zeroinitializer
%158 = insertelement <2 x double> poison, double %138, i64 1
%159 = insertelement <2 x double> poison, double %146, i64 0
br label %160
160: ; preds = %143, %160
%161 = phi i64 [ %121, %143 ], [ %204, %160 ]
%162 = add nsw i64 %161, %115
%163 = add nsw i64 %162, %115
%164 = add nsw i64 %163, %115
%165 = getelementptr inbounds double, double* %2, i64 %161
%166 = getelementptr inbounds double, double* %2, i64 %162
%167 = bitcast double* %165 to <2 x double>*
%168 = load <2 x double>, <2 x double>* %167
%169 = bitcast double* %166 to <2 x double>*
%170 = load <2 x double>, <2 x double>* %169
%171 = fadd <2 x double> %168, %170
%172 = fsub <2 x double> %168, %170
%173 = getelementptr inbounds double, double* %2, i64 %163
%174 = getelementptr inbounds double, double* %2, i64 %164
%175 = bitcast double* %173 to <2 x double>*
%176 = load <2 x double>, <2 x double>* %175
%177 = bitcast double* %174 to <2 x double>*
%178 = load <2 x double>, <2 x double>* %177
%179 = fadd <2 x double> %176, %178
%180 = fsub <2 x double> %176, %178
%181 = shufflevector <2 x double> %180, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%182 = fadd <2 x double> %171, %179
%183 = bitcast double* %165 to <2 x double>*
store <2 x double> %182, <2 x double>* %183
%184 = fsub <2 x double> %171, %179
%185 = shufflevector <2 x double> %158, <2 x double> %184, <2 x i32> <i32 3, i32 1>
%186 = shufflevector <2 x double> %159, <2 x double> %184, <2 x i32> <i32 0, i32 2>
%187 = fmul <2 x double> %185, %186
%188 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %157, <2 x double> %184, <2 x double> %187)
%189 = bitcast double* %173 to <2 x double>*
store <2 x double> %188, <2 x double>* %189
%190 = fsub <2 x double> %172, %181
%191 = fadd <2 x double> %172, %181
%192 = shufflevector <2 x double> %190, <2 x double> %191, <2 x i32> <i32 0, i32 3>
%193 = shufflevector <2 x double> %154, <2 x double> %191, <2 x i32> <i32 3, i32 1>
%194 = shufflevector <2 x double> %155, <2 x double> %190, <2 x i32> <i32 0, i32 2>
%195 = fmul <2 x double> %193, %194
%196 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %153, <2 x double> %192, <2 x double> %195)
%197 = bitcast double* %166 to <2 x double>*
store <2 x double> %196, <2 x double>* %197
%198 = shufflevector <2 x double> %191, <2 x double> %190, <2 x i32> <i32 0, i32 3>
%199 = shufflevector <2 x double> %150, <2 x double> %190, <2 x i32> <i32 3, i32 1>
%200 = shufflevector <2 x double> %151, <2 x double> %191, <2 x i32> <i32 0, i32 2>
%201 = fmul <2 x double> %199, %200
%202 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %149, <2 x double> %198, <2 x double> %201)
%203 = bitcast double* %174 to <2 x double>*
store <2 x double> %202, <2 x double>* %203
%204 = add nsw i64 %161, 2
%205 = icmp slt i64 %204, %142
br i1 %205, label %160, label %206
206: ; preds = %160, %130
%207 = fsub double %133, %134
%208 = fmul double %207, 0x3FE6A09E667F3BCD
%209 = fadd double %133, %134
%210 = fmul double %209, 0x3FE6A09E667F3BCD
%211 = fmul double %137, 2.000000e+00
%212 = fneg double %210
%213 = tail call double @llvm.fmuladd.f64(double %211, double %208, double %212)
%214 = add nsw i64 %121, %118
%215 = add nsw i64 %214, %115
br i1 %5, label %216, label %288
216: ; preds = %206
%217 = fneg double %211
%218 = tail call double @llvm.fmuladd.f64(double %217, double %210, double %208)
%219 = fneg double %138
%220 = fneg double %137
%221 = fneg double %213
%222 = insertelement <2 x double> poison, double %218, i64 0
%223 = shufflevector <2 x double> %222, <2 x double> poison, <2 x i32> zeroinitializer
%224 = insertelement <2 x double> poison, double %213, i64 1
%225 = insertelement <2 x double> poison, double %221, i64 0
%226 = insertelement <2 x double> poison, double %208, i64 0
%227 = shufflevector <2 x double> %226, <2 x double> poison, <2 x i32> zeroinitializer
%228 = insertelement <2 x double> poison, double %210, i64 1
%229 = insertelement <2 x double> poison, double %212, i64 0
%230 = insertelement <2 x double> poison, double %219, i64 0
%231 = shufflevector <2 x double> %230, <2 x double> poison, <2 x i32> zeroinitializer
%232 = insertelement <2 x double> poison, double %137, i64 1
%233 = insertelement <2 x double> poison, double %220, i64 0
br label %234
234: ; preds = %216, %234
%235 = phi i64 [ %123, %216 ], [ %286, %234 ]
%236 = add nsw i64 %235, %115
%237 = add nsw i64 %236, %115
%238 = add nsw i64 %237, %115
%239 = getelementptr inbounds double, double* %2, i64 %235
%240 = load double, double* %239
%241 = getelementptr inbounds double, double* %2, i64 %236
%242 = bitcast double* %241 to <2 x double>*
%243 = load <2 x double>, <2 x double>* %242
%244 = shl i64 %235, 32
%245 = ashr exact i64 %244, 32
%246 = or i64 %245, 1
%247 = getelementptr inbounds double, double* %2, i64 %246
%248 = load double, double* %247
%249 = insertelement <2 x double> poison, double %240, i64 0
%250 = insertelement <2 x double> %249, double %248, i64 1
%251 = fadd <2 x double> %250, %243
%252 = fsub <2 x double> %250, %243
%253 = getelementptr inbounds double, double* %2, i64 %237
%254 = getelementptr inbounds double, double* %2, i64 %238
%255 = bitcast double* %253 to <2 x double>*
%256 = load <2 x double>, <2 x double>* %255
%257 = bitcast double* %254 to <2 x double>*
%258 = load <2 x double>, <2 x double>* %257
%259 = fadd <2 x double> %256, %258
%260 = fsub <2 x double> %256, %258
%261 = shufflevector <2 x double> %260, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%262 = fadd <2 x double> %251, %259
%263 = extractelement <2 x double> %262, i64 0
store double %263, double* %239
%264 = fadd <2 x double> %251, %259
%265 = extractelement <2 x double> %264, i64 1
store double %265, double* %247
%266 = fsub <2 x double> %251, %259
%267 = shufflevector <2 x double> %232, <2 x double> %266, <2 x i32> <i32 3, i32 1>
%268 = shufflevector <2 x double> %233, <2 x double> %266, <2 x i32> <i32 0, i32 2>
%269 = fmul <2 x double> %267, %268
%270 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %231, <2 x double> %266, <2 x double> %269)
%271 = bitcast double* %253 to <2 x double>*
store <2 x double> %270, <2 x double>* %271
%272 = fsub <2 x double> %252, %261
%273 = fadd <2 x double> %252, %261
%274 = shufflevector <2 x double> %272, <2 x double> %273, <2 x i32> <i32 0, i32 3>
%275 = shufflevector <2 x double> %228, <2 x double> %273, <2 x i32> <i32 3, i32 1>
%276 = shufflevector <2 x double> %229, <2 x double> %272, <2 x i32> <i32 0, i32 2>
%277 = fmul <2 x double> %275, %276
%278 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %227, <2 x double> %274, <2 x double> %277)
%279 = bitcast double* %241 to <2 x double>*
store <2 x double> %278, <2 x double>* %279
%280 = shufflevector <2 x double> %273, <2 x double> %272, <2 x i32> <i32 0, i32 3>
%281 = shufflevector <2 x double> %224, <2 x double> %272, <2 x i32> <i32 3, i32 1>
%282 = shufflevector <2 x double> %225, <2 x double> %273, <2 x i32> <i32 0, i32 2>
%283 = fmul <2 x double> %281, %282
%284 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %223, <2 x double> %280, <2 x double> %283)
%285 = bitcast double* %254 to <2 x double>*
store <2 x double> %284, <2 x double>* %285
%286 = add nsw i64 %235, 2
%287 = icmp slt i64 %286, %215
br i1 %287, label %234, label %288
288: ; preds = %234, %206
%289 = add i64 %121, %114
%290 = icmp slt i64 %289, %117
%291 = add i32 %120, %110
br i1 %290, label %119, label %292
292: ; preds = %288, %107
ret void
}