#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 cft1st(int n, double *a) {
  int j, kj, kr;
  double ew, wn4r, wk1r, wk1i, wk2r, wk2i, wk3r, wk3i;
  double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
  x0r = a[0] + a[2];
  x0i = a[1] + a[3];
  x1r = a[0] - a[2];
  x1i = a[1] - a[3];
  x2r = a[4] + a[6];
  x2i = a[5] + a[7];
  x3r = a[4] - a[6];
  x3i = a[5] - a[7];
  a[0] = x0r + x2r;
  a[1] = x0i + x2i;
  a[4] = x0r - x2r;
  a[5] = x0i - x2i;
  a[2] = x1r - x3i;
  a[3] = x1i + x3r;
  a[6] = x1r + x3i;
  a[7] = x1i - x3r;
  wn4r = 0.707106781186547524400844362104849039284835937688;
  x0r = a[8] + a[10];
  x0i = a[9] + a[11];
  x1r = a[8] - a[10];
  x1i = a[9] - a[11];
  x2r = a[12] + a[14];
  x2i = a[13] + a[15];
  x3r = a[12] - a[14];
  x3i = a[13] - a[15];
  a[8] = x0r + x2r;
  a[9] = x0i + x2i;
  a[12] = x2i - x0i;
  a[13] = x0r - x2r;
  x0r = x1r - x3i;
  x0i = x1i + x3r;
  a[10] = wn4r * (x0r - x0i);
  a[11] = wn4r * (x0r + x0i);
  x0r = x3i + x1r;
  x0i = x3r - x1i;
  a[14] = wn4r * (x0i - x0r);
  a[15] = wn4r * (x0i + x0r);
  ew = 1.570796326794896619231321691639751442098584699687 / n;
  kr = 0;
  for (j = 16; j < n; j += 16) {
    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;
    x0r = a[j] + a[j + 2];
    x0i = a[j + 1] + a[j + 3];
    x1r = a[j] - a[j + 2];
    x1i = a[j + 1] - a[j + 3];
    x2r = a[j + 4] + a[j + 6];
    x2i = a[j + 5] + a[j + 7];
    x3r = a[j + 4] - a[j + 6];
    x3i = a[j + 5] - a[j + 7];
    a[j] = x0r + x2r;
    a[j + 1] = x0i + x2i;
    x0r -= x2r;
    x0i -= x2i;
    a[j + 4] = wk2r * x0r - wk2i * x0i;
    a[j + 5] = wk2r * x0i + wk2i * x0r;
    x0r = x1r - x3i;
    x0i = x1i + x3r;
    a[j + 2] = wk1r * x0r - wk1i * x0i;
    a[j + 3] = wk1r * x0i + wk1i * x0r;
    x0r = x1r + x3i;
    x0i = x1i - x3r;
    a[j + 6] = wk3r * x0r - wk3i * x0i;
    a[j + 7] = wk3r * x0i + wk3i * x0r;
    x0r = wn4r * (wk1r - wk1i);
    wk1i = wn4r * (wk1r + wk1i);
    wk1r = x0r;
    wk3r = wk1r - 2 * wk2r * wk1i;
    wk3i = 2 * wk2r * wk1r - wk1i;
    x0r = a[j + 8] + a[j + 10];
    x0i = a[j + 9] + a[j + 11];
    x1r = a[j + 8] - a[j + 10];
    x1i = a[j + 9] - a[j + 11];
    x2r = a[j + 12] + a[j + 14];
    x2i = a[j + 13] + a[j + 15];
    x3r = a[j + 12] - a[j + 14];
    x3i = a[j + 13] - a[j + 15];
    a[j + 8] = x0r + x2r;
    a[j + 9] = x0i + x2i;
    x0r -= x2r;
    x0i -= x2i;
    a[j + 12] = -wk2i * x0r - wk2r * x0i;
    a[j + 13] = -wk2i * x0i + wk2r * x0r;
    x0r = x1r - x3i;
    x0i = x1i + x3r;
    a[j + 10] = wk1r * x0r - wk1i * x0i;
    a[j + 11] = wk1r * x0i + wk1i * x0r;
    x0r = x1r + x3i;
    x0i = x1i - x3r;
    a[j + 14] = wk3r * x0r - wk3i * x0i;
    a[j + 15] = wk3r * x0i + wk3i * x0r;
  }
}


x86 assembly (clang, -O0):
<cft1st>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x38(%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x70(%rbp),%xmm0
addsd  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x68(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x70(%rbp),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0x78(%rbp),%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x80(%rbp),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x78(%rbp),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0x80(%rbp),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x38(%rax)
movsd  0xd5d(%rip),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x50(%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x58(%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x50(%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x58(%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x70(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x68(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x78(%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x70(%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x68(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x78(%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x40(%rax)
movsd  -0x70(%rbp),%xmm0
addsd  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x48(%rax)
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x60(%rax)
movsd  -0x68(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x68(%rax)
movsd  -0x78(%rbp),%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x80(%rbp),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x30(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
subsd  -0x70(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x50(%rax)
movsd  -0x30(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x58(%rax)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x30(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
subsd  -0x68(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x70(%rax)
movsd  -0x30(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
addsd  -0x68(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x78(%rax)
cvtsi2sdl -0x4(%rbp),%xmm1
movsd  0xb6f(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x10,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1d7a <cft1st+0xc5a>
mov    -0x4(%rbp),%eax
sar    $0x2,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x18(%rbp),%ecx
xor    -0x1c(%rbp),%ecx
mov    %ecx,-0x1c(%rbp)
cmp    %ecx,%eax
jle    14e4 <cft1st+0x3c4>
jmp    14d6 <cft1st+0x3b6>
mov    -0x18(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    14bd <cft1st+0x39d>
movsd  -0x28(%rbp),%xmm0
cvtsi2sdl -0x1c(%rbp),%xmm1
mulsd  %xmm1,%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x38(%rbp)
movsd  -0x28(%rbp),%xmm0
cvtsi2sdl -0x1c(%rbp),%xmm1
mulsd  %xmm1,%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x40(%rbp)
movsd  0xaf4(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0xacf(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xab6(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x38(%rbp),%xmm1
movsd  0xa9a(%rip),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0xa64(%rip),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%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    -0x14(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%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    -0x14(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
addsd  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x68(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x70(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x80(%rbp),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x80(%rbp),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
subsd  -0x40(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x30(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
addsd  -0x40(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm1
movsd  0x69a(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0x664(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xa,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x9,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xb,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xa,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x9,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xb,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xc,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xe,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xd,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xf,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xc,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xe,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xd,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xf,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
addsd  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x9,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x68(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x70(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xc,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xd,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x80(%rbp),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xa,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xb,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x80(%rbp),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xe,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xf,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x14(%rbp)
jmp    14a8 <cft1st+0x388>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cft1st>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x20,%rsp
movupd (%rsi),%xmm0
movupd 0x10(%rsi),%xmm1
movupd 0x20(%rsi),%xmm2
movupd 0x30(%rsi),%xmm3
movapd %xmm0,%xmm4
addpd  %xmm1,%xmm4
subpd  %xmm1,%xmm0
movapd %xmm2,%xmm1
addpd  %xmm3,%xmm1
subpd  %xmm3,%xmm2
shufpd $0x1,%xmm2,%xmm2
movapd %xmm4,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm3,(%rsi)
subpd  %xmm1,%xmm4
movupd %xmm4,0x20(%rsi)
movapd %xmm0,%xmm1
subpd  %xmm2,%xmm1
addpd  %xmm0,%xmm2
movapd %xmm2,%xmm0
movsd  %xmm1,%xmm0
movupd %xmm0,0x10(%rsi)
shufpd $0x2,%xmm1,%xmm2
movupd %xmm2,0x30(%rsi)
movupd 0x40(%rsi),%xmm3
movupd 0x50(%rsi),%xmm0
movapd %xmm3,%xmm1
addpd  %xmm0,%xmm1
subpd  %xmm0,%xmm3
movupd 0x60(%rsi),%xmm0
movupd 0x70(%rsi),%xmm5
movapd %xmm0,%xmm4
subpd  %xmm5,%xmm0
movapd %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
movapd %xmm3,%xmm6
subsd  %xmm2,%xmm6
addsd  %xmm3,%xmm2
unpckhpd %xmm3,%xmm3
addpd  %xmm5,%xmm4
movapd %xmm1,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,0x40(%rsi)
movapd %xmm4,%xmm5
shufpd $0x1,%xmm1,%xmm5
shufpd $0x1,%xmm4,%xmm1
subpd  %xmm1,%xmm5
movupd %xmm5,0x60(%rsi)
movapd %xmm3,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm6,%xmm4
subsd  %xmm1,%xmm4
movsd  0xdec(%rip),%xmm5
mulsd  %xmm5,%xmm4
movsd  %xmm4,0x50(%rsi)
addsd  %xmm6,%xmm1
mulsd  %xmm5,%xmm1
movsd  %xmm1,0x58(%rsi)
subsd  %xmm3,%xmm0
movapd %xmm0,%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm5,%xmm1
movsd  %xmm1,0x70(%rsi)
addsd  %xmm2,%xmm0
mulsd  %xmm5,%xmm0
movsd  %xmm0,0x78(%rsi)
cmp    $0x11,%edi
jl     156e <cft1st+0x44e>
mov    %rsi,%rbx
mov    %edi,%r14d
xorps  %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
movsd  0xd9e(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
mov    %edi,%r15d
shr    $0x2,%r14d
xor    %ebp,%ebp
mov    $0x10,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r14d,%ecx
mov    %r14d,%eax
cs nopw 0x0(%rax,%rax,1)
xor    %ecx,%ebp
shr    %eax
cmp    %ebp,%ecx
mov    %eax,%ecx
jg     12a0 <cft1st+0x180>
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
mulsd  (%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
call   1040 <cos@plt>
movapd %xmm0,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
movapd 0x10(%rsp),%xmm2
movapd %xmm2,%xmm8
mulsd  %xmm1,%xmm8
mulsd  %xmm0,%xmm1
movsd  0xd19(%rip),%xmm11
subsd  %xmm1,%xmm11
movapd %xmm8,%xmm3
addsd  %xmm8,%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm2,%xmm10
subsd  %xmm1,%xmm10
mulsd  %xmm2,%xmm3
subsd  %xmm0,%xmm3
lea    0x0(,%r12,8),%rax
mov    %rax,%rcx
or     $0x10,%rcx
movupd (%rbx,%r12,8),%xmm5
movupd (%rbx,%rcx,1),%xmm1
movapd %xmm5,%xmm4
addpd  %xmm1,%xmm4
subpd  %xmm1,%xmm5
mov    %rax,%rsi
or     $0x20,%rsi
mov    %rax,%rdx
or     $0x30,%rdx
movupd (%rbx,%rsi,1),%xmm6
movupd (%rbx,%rdx,1),%xmm1
movapd %xmm6,%xmm7
addpd  %xmm1,%xmm7
subpd  %xmm1,%xmm6
shufpd $0x1,%xmm6,%xmm6
movapd %xmm4,%xmm1
addpd  %xmm7,%xmm1
movupd %xmm1,(%rbx,%r12,8)
subpd  %xmm7,%xmm4
movapd %xmm8,%xmm1
movapd 0xc91(%rip),%xmm12
xorpd  %xmm12,%xmm1
unpcklpd %xmm4,%xmm1
movapd %xmm11,%xmm7
unpcklpd %xmm11,%xmm7
mulpd  %xmm4,%xmm7
shufpd $0x1,%xmm8,%xmm4
mulpd  %xmm4,%xmm1
addpd  %xmm1,%xmm7
movapd %xmm5,%xmm1
subpd  %xmm6,%xmm1
addpd  %xmm5,%xmm6
movapd %xmm6,%xmm9
shufpd $0x1,%xmm0,%xmm9
movapd %xmm2,%xmm4
movapd %xmm2,%xmm5
subsd  %xmm0,%xmm5
addsd  %xmm0,%xmm2
xorpd  %xmm12,%xmm0
movupd %xmm7,(%rbx,%rsi,1)
movapd %xmm6,%xmm7
movsd  %xmm1,%xmm7
unpcklpd %xmm1,%xmm0
mulpd  %xmm9,%xmm0
unpcklpd %xmm4,%xmm4
mulpd  %xmm7,%xmm4
addpd  %xmm0,%xmm4
movupd %xmm4,(%rbx,%rcx,1)
movapd %xmm1,%xmm0
movsd  %xmm6,%xmm0
shufpd $0x1,%xmm3,%xmm1
xorpd  %xmm12,%xmm3
unpcklpd %xmm6,%xmm3
mulpd  %xmm1,%xmm3
unpcklpd %xmm10,%xmm10
mulpd  %xmm0,%xmm10
addpd  %xmm3,%xmm10
movupd %xmm10,(%rbx,%rdx,1)
movsd  0xbc2(%rip),%xmm0
mulsd  %xmm0,%xmm5
mulsd  %xmm0,%xmm2
movapd %xmm11,%xmm0
addsd  %xmm11,%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm5,%xmm3
subsd  %xmm1,%xmm3
movapd %xmm2,%xmm9
xorpd  %xmm12,%xmm9
mulsd  %xmm5,%xmm0
subsd  %xmm2,%xmm0
movapd %xmm2,%xmm10
mov    %rax,%rsi
or     $0x40,%rsi
mov    %rax,%rcx
or     $0x50,%rcx
movupd (%rbx,%rsi,1),%xmm1
movupd (%rbx,%rcx,1),%xmm6
movapd %xmm1,%xmm7
addpd  %xmm6,%xmm7
subpd  %xmm6,%xmm1
mov    %rax,%rdx
or     $0x60,%rdx
or     $0x70,%rax
movupd (%rbx,%rdx,1),%xmm6
movupd (%rbx,%rax,1),%xmm4
movapd %xmm6,%xmm2
addpd  %xmm4,%xmm2
subpd  %xmm4,%xmm6
shufpd $0x1,%xmm6,%xmm6
movapd %xmm7,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm4,(%rbx,%rsi,1)
subpd  %xmm2,%xmm7
movapd %xmm7,%xmm2
shufpd $0x1,%xmm11,%xmm2
xorpd  %xmm12,%xmm11
unpcklpd %xmm7,%xmm11
mulpd  %xmm2,%xmm11
unpcklpd %xmm8,%xmm8
mulpd  %xmm7,%xmm8
subpd  %xmm8,%xmm11
movupd %xmm11,(%rbx,%rdx,1)
movapd %xmm1,%xmm2
subpd  %xmm6,%xmm2
addpd  %xmm1,%xmm6
movapd %xmm6,%xmm1
movsd  %xmm2,%xmm1
unpcklpd %xmm2,%xmm9
movapd %xmm2,%xmm4
movsd  %xmm6,%xmm4
shufpd $0x1,%xmm0,%xmm2
xorpd  %xmm12,%xmm0
unpcklpd %xmm6,%xmm0
shufpd $0x1,%xmm10,%xmm6
mulpd  %xmm6,%xmm9
unpcklpd %xmm5,%xmm5
mulpd  %xmm1,%xmm5
addpd  %xmm9,%xmm5
movupd %xmm5,(%rbx,%rcx,1)
mulpd  %xmm2,%xmm0
unpcklpd %xmm3,%xmm3
mulpd  %xmm4,%xmm3
addpd  %xmm0,%xmm3
movupd %xmm3,(%rbx,%rax,1)
add    $0x10,%r12
cmp    %r15,%r12
jb     1290 <cft1st+0x170>
add    $0x20,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

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