#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 */
int /*<<< orphan*/ btrfly(int, double, double, double, double, double, double,
                          double *, double *, double *, double *);
int /*<<< orphan*/ writeA(double *);
void cft1st(int n, double *a, double *w) {
  int j, k1;
  double *v = w + 1;
  double *b = a + 2;
  double *c = a + 4;
  double *d = a + 6;
  double wk1r = w[2];
  writeA(a);
  double x0r = a[0] + a[2];
  double x0i = a[1] + a[3];
  double x1r = a[0] - a[2];
  double x1i = a[1] - a[3];
  double x2r = a[4] + a[6];
  double x2i = a[5] + a[7];
  double x3r = a[4] - a[6];
  double 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;
  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] = wk1r * (x0r - x0i);
  a[11] = wk1r * (x0r + x0i);
  x0r = x3i + x1r;
  x0i = x3r - x1i;
  a[14] = wk1r * (x0i - x0r);
  a[15] = wk1r * (x0i + x0r);
  writeA(a);
#pragma mta use 100 streams
#pragma mta no scalar expansion
#pragma mta assert no dependence
  for (j = 16, k1 = 2; j < n; j += 16, k1 += 2) {
    double wk2r = w[k1];
    double wk2i = v[k1];
    double wk1r = w[k1 + k1];
    double wk1i = v[k1 + k1];
    double wk3r = wk1r - 2 * wk2i * wk1i;
    double wk3i = 2 * wk2i * wk1r - wk1i;
    btrfly(j, wk1r, wk1i, wk2r, wk2i, wk3r, wk3i, a, b, c, d);
    wk1r = w[k1 + k1 + 2];
    wk1i = v[k1 + k1 + 2];
    wk3r = wk1r - 2 * wk2r * wk1i;
    wk3i = 2 * wk2r * wk1r - wk1i;
    btrfly(j + 8, wk1r, wk1i, -wk2i, wk2r, wk3r, wk3i, a, b, c, d);
  }
}


x86 assembly (clang, -O0):
<cft1st>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x18(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
add    $0x30,%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rdi
call   1040 <writeA@plt>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
addsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
addsd  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x50(%rbp),%xmm0
subsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x58(%rbp),%xmm0
subsd  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x68(%rbp),%xmm0
addsd  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x60(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0x68(%rbp),%xmm0
subsd  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x38(%rax)
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x50(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x58(%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x50(%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x58(%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x70(%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x68(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x78(%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x70(%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x68(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x78(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
addsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x40(%rax)
movsd  -0x58(%rbp),%xmm0
addsd  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x48(%rax)
movsd  -0x78(%rbp),%xmm0
subsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x60(%rax)
movsd  -0x50(%rbp),%xmm0
subsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x68(%rax)
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movsd  -0x68(%rbp),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
subsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x50(%rax)
movsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
addsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x58(%rax)
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x80(%rbp),%xmm0
subsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
subsd  -0x50(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x70(%rax)
movsd  -0x48(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
addsd  -0x50(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x78(%rax)
mov    -0x10(%rbp),%rdi
call   1040 <writeA@plt>
movl   $0x10,-0x1c(%rbp)
movl   $0x2,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1724 <cft1st+0x604>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x28(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm1
ff
movsd  0xae3(%rip),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0xaa4(%rip),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x1c(%rbp),%edi
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm3
ff
movsd  -0xb0(%rbp),%xmm4
ff
movsd  -0xb8(%rbp),%xmm5
ff
mov    -0x10(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%r8
call   1030 <btrfly@plt>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm1
ff
movsd  0x9d3(%rip),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0x994(%rip),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x1c(%rbp),%edi
add    $0x8,%edi
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
movsd  -0x90(%rbp),%xmm3
ff
movsd  -0xb0(%rbp),%xmm4
ff
movsd  -0xb8(%rbp),%xmm5
ff
mov    -0x10(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%r8
call   1030 <btrfly@plt>
mov    -0x1c(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
jmp    14a3 <cft1st+0x383>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cft1st>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rdx,%rbx
mov    %rsi,%rbp
mov    %edi,%r14d
movsd  0x10(%rdx),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %rsi,%rdi
call   1040 <writeA@plt>
movupd 0x0(%rbp),%xmm0
movupd 0x10(%rbp),%xmm1
movupd 0x20(%rbp),%xmm2
movupd 0x30(%rbp),%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,0x0(%rbp)
subpd  %xmm1,%xmm4
movupd %xmm4,0x20(%rbp)
movapd %xmm0,%xmm1
subpd  %xmm2,%xmm1
addpd  %xmm0,%xmm2
movapd %xmm2,%xmm0
movsd  %xmm1,%xmm0
movupd %xmm0,0x10(%rbp)
shufpd $0x2,%xmm1,%xmm2
movupd %xmm2,0x30(%rbp)
movupd 0x40(%rbp),%xmm2
movupd 0x50(%rbp),%xmm0
movapd %xmm2,%xmm1
addpd  %xmm0,%xmm1
subpd  %xmm0,%xmm2
movupd 0x60(%rbp),%xmm0
movupd 0x70(%rbp),%xmm5
movapd %xmm0,%xmm4
subpd  %xmm5,%xmm0
movapd %xmm0,%xmm3
unpckhpd %xmm0,%xmm3
movapd %xmm2,%xmm6
subsd  %xmm3,%xmm6
addsd  %xmm2,%xmm3
unpckhpd %xmm2,%xmm2
addpd  %xmm5,%xmm4
movapd %xmm1,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,0x40(%rbp)
movapd %xmm4,%xmm5
shufpd $0x1,%xmm1,%xmm5
shufpd $0x1,%xmm4,%xmm1
subpd  %xmm1,%xmm5
movupd %xmm5,0x60(%rbp)
movapd %xmm2,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm6,%xmm4
subsd  %xmm1,%xmm4
movsd  0x10(%rsp),%xmm5
mulsd  %xmm5,%xmm4
movsd  %xmm4,0x50(%rbp)
addsd  %xmm6,%xmm1
mulsd  %xmm5,%xmm1
movsd  %xmm1,0x58(%rbp)
subsd  %xmm2,%xmm0
movapd %xmm0,%xmm1
subsd  %xmm3,%xmm1
mulsd  %xmm5,%xmm1
movsd  %xmm1,0x70(%rbp)
addsd  %xmm3,%xmm0
mulsd  %xmm5,%xmm0
movsd  %xmm0,0x78(%rbp)
mov    %rbp,0x8(%rsp)
mov    %rbp,%rdi
call   1040 <writeA@plt>
cmp    $0x11,%r14d
jl     1388 <cft1st+0x268>
mov    0x8(%rsp),%rax
lea    0x10(%rax),%rcx
mov    %rcx,0x38(%rsp)
lea    0x20(%rax),%rcx
mov    %rcx,0x30(%rsp)
add    $0x30,%rax
mov    %rax,0x28(%rsp)
mov    $0x10,%r15d
mov    %r14d,0x4(%rsp)
mov    0x8(%rsp),%r12
mov    0x38(%rsp),%r13
mov    0x30(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%r15,1),%xmm2
movsd  %xmm2,0x40(%rsp)
movsd  0x8(%rbx,%r15,1),%xmm3
movsd  (%rbx,%r15,2),%xmm0
movsd  0x8(%rbx,%r15,2),%xmm1
movapd %xmm3,%xmm5
movapd %xmm3,0x10(%rsp)
addsd  %xmm3,%xmm5
movapd %xmm5,%xmm6
mulsd  %xmm1,%xmm6
movapd %xmm0,%xmm4
subsd  %xmm6,%xmm4
mulsd  %xmm0,%xmm5
subsd  %xmm1,%xmm5
mov    %r15d,%edi
mov    %r12,%rsi
mov    %r13,%rdx
mov    %rbp,%rcx
mov    0x28(%rsp),%r14
mov    %r14,%r8
call   1030 <btrfly@plt>
movsd  0x10(%rbx,%r15,2),%xmm0
movsd  0x18(%rbx,%r15,2),%xmm1
movsd  0x40(%rsp),%xmm3
movapd %xmm3,%xmm5
addsd  %xmm3,%xmm5
movapd %xmm5,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm0,%xmm4
subsd  %xmm2,%xmm4
mulsd  %xmm0,%xmm5
subsd  %xmm1,%xmm5
movapd 0x10(%rsp),%xmm2
xorpd  0xc9f(%rip),%xmm2
lea    0x8(%r15),%edi
mov    %r12,%rsi
mov    %r13,%rdx
mov    %rbp,%rcx
mov    %r14,%r8
call   1030 <btrfly@plt>
mov    0x4(%rsp),%r14d
add    $0x10,%r15
cmp    %r14d,%r15d
jl     12c0 <cft1st+0x1a0>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @cft1st(i32 %0, double* %1, double* %2) {
%4 = alloca i32
%5 = alloca double*
%6 = alloca double*
%7 = alloca i32
%8 = alloca i32
%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
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
store i32 %0, i32* %4
store double* %1, double** %5
store double* %2, double** %6
%28 = load double*, double** %6
%29 = getelementptr inbounds double, double* %28, i64 1
store double* %29, double** %9
%30 = load double*, double** %5
%31 = getelementptr inbounds double, double* %30, i64 2
store double* %31, double** %10
%32 = load double*, double** %5
%33 = getelementptr inbounds double, double* %32, i64 4
store double* %33, double** %11
%34 = load double*, double** %5
%35 = getelementptr inbounds double, double* %34, i64 6
store double* %35, double** %12
%36 = load double*, double** %6
%37 = getelementptr inbounds double, double* %36, i64 2
%38 = load double, double* %37
store double %38, double* %13
%39 = load double*, double** %5
%40 = call i32 @writeA(double* %39)
%41 = load double*, double** %5
%42 = getelementptr inbounds double, double* %41, i64 0
%43 = load double, double* %42
%44 = load double*, double** %5
%45 = getelementptr inbounds double, double* %44, i64 2
%46 = load double, double* %45
%47 = fadd double %43, %46
store double %47, double* %14
%48 = load double*, double** %5
%49 = getelementptr inbounds double, double* %48, i64 1
%50 = load double, double* %49
%51 = load double*, double** %5
%52 = getelementptr inbounds double, double* %51, i64 3
%53 = load double, double* %52
%54 = fadd double %50, %53
store double %54, double* %15
%55 = load double*, double** %5
%56 = getelementptr inbounds double, double* %55, i64 0
%57 = load double, double* %56
%58 = load double*, double** %5
%59 = getelementptr inbounds double, double* %58, i64 2
%60 = load double, double* %59
%61 = fsub double %57, %60
store double %61, double* %16
%62 = load double*, double** %5
%63 = getelementptr inbounds double, double* %62, i64 1
%64 = load double, double* %63
%65 = load double*, double** %5
%66 = getelementptr inbounds double, double* %65, i64 3
%67 = load double, double* %66
%68 = fsub double %64, %67
store double %68, double* %17
%69 = load double*, double** %5
%70 = getelementptr inbounds double, double* %69, i64 4
%71 = load double, double* %70
%72 = load double*, double** %5
%73 = getelementptr inbounds double, double* %72, i64 6
%74 = load double, double* %73
%75 = fadd double %71, %74
store double %75, double* %18
%76 = load double*, double** %5
%77 = getelementptr inbounds double, double* %76, i64 5
%78 = load double, double* %77
%79 = load double*, double** %5
%80 = getelementptr inbounds double, double* %79, i64 7
%81 = load double, double* %80
%82 = fadd double %78, %81
store double %82, double* %19
%83 = load double*, double** %5
%84 = getelementptr inbounds double, double* %83, i64 4
%85 = load double, double* %84
%86 = load double*, double** %5
%87 = getelementptr inbounds double, double* %86, i64 6
%88 = load double, double* %87
%89 = fsub double %85, %88
store double %89, double* %20
%90 = load double*, double** %5
%91 = getelementptr inbounds double, double* %90, i64 5
%92 = load double, double* %91
%93 = load double*, double** %5
%94 = getelementptr inbounds double, double* %93, i64 7
%95 = load double, double* %94
%96 = fsub double %92, %95
store double %96, double* %21
%97 = load double, double* %14
%98 = load double, double* %18
%99 = fadd double %97, %98
%100 = load double*, double** %5
%101 = getelementptr inbounds double, double* %100, i64 0
store double %99, double* %101
%102 = load double, double* %15
%103 = load double, double* %19
%104 = fadd double %102, %103
%105 = load double*, double** %5
%106 = getelementptr inbounds double, double* %105, i64 1
store double %104, double* %106
%107 = load double, double* %14
%108 = load double, double* %18
%109 = fsub double %107, %108
%110 = load double*, double** %5
%111 = getelementptr inbounds double, double* %110, i64 4
store double %109, double* %111
%112 = load double, double* %15
%113 = load double, double* %19
%114 = fsub double %112, %113
%115 = load double*, double** %5
%116 = getelementptr inbounds double, double* %115, i64 5
store double %114, double* %116
%117 = load double, double* %16
%118 = load double, double* %21
%119 = fsub double %117, %118
%120 = load double*, double** %5
%121 = getelementptr inbounds double, double* %120, i64 2
store double %119, double* %121
%122 = load double, double* %17
%123 = load double, double* %20
%124 = fadd double %122, %123
%125 = load double*, double** %5
%126 = getelementptr inbounds double, double* %125, i64 3
store double %124, double* %126
%127 = load double, double* %16
%128 = load double, double* %21
%129 = fadd double %127, %128
%130 = load double*, double** %5
%131 = getelementptr inbounds double, double* %130, i64 6
store double %129, double* %131
%132 = load double, double* %17
%133 = load double, double* %20
%134 = fsub double %132, %133
%135 = load double*, double** %5
%136 = getelementptr inbounds double, double* %135, i64 7
store double %134, double* %136
%137 = load double*, double** %5
%138 = getelementptr inbounds double, double* %137, i64 8
%139 = load double, double* %138
%140 = load double*, double** %5
%141 = getelementptr inbounds double, double* %140, i64 10
%142 = load double, double* %141
%143 = fadd double %139, %142
store double %143, double* %14
%144 = load double*, double** %5
%145 = getelementptr inbounds double, double* %144, i64 9
%146 = load double, double* %145
%147 = load double*, double** %5
%148 = getelementptr inbounds double, double* %147, i64 11
%149 = load double, double* %148
%150 = fadd double %146, %149
store double %150, double* %15
%151 = load double*, double** %5
%152 = getelementptr inbounds double, double* %151, i64 8
%153 = load double, double* %152
%154 = load double*, double** %5
%155 = getelementptr inbounds double, double* %154, i64 10
%156 = load double, double* %155
%157 = fsub double %153, %156
store double %157, double* %16
%158 = load double*, double** %5
%159 = getelementptr inbounds double, double* %158, i64 9
%160 = load double, double* %159
%161 = load double*, double** %5
%162 = getelementptr inbounds double, double* %161, i64 11
%163 = load double, double* %162
%164 = fsub double %160, %163
store double %164, double* %17
%165 = load double*, double** %5
%166 = getelementptr inbounds double, double* %165, i64 12
%167 = load double, double* %166
%168 = load double*, double** %5
%169 = getelementptr inbounds double, double* %168, i64 14
%170 = load double, double* %169
%171 = fadd double %167, %170
store double %171, double* %18
%172 = load double*, double** %5
%173 = getelementptr inbounds double, double* %172, i64 13
%174 = load double, double* %173
%175 = load double*, double** %5
%176 = getelementptr inbounds double, double* %175, i64 15
%177 = load double, double* %176
%178 = fadd double %174, %177
store double %178, double* %19
%179 = load double*, double** %5
%180 = getelementptr inbounds double, double* %179, i64 12
%181 = load double, double* %180
%182 = load double*, double** %5
%183 = getelementptr inbounds double, double* %182, i64 14
%184 = load double, double* %183
%185 = fsub double %181, %184
store double %185, double* %20
%186 = load double*, double** %5
%187 = getelementptr inbounds double, double* %186, i64 13
%188 = load double, double* %187
%189 = load double*, double** %5
%190 = getelementptr inbounds double, double* %189, i64 15
%191 = load double, double* %190
%192 = fsub double %188, %191
store double %192, double* %21
%193 = load double, double* %14
%194 = load double, double* %18
%195 = fadd double %193, %194
%196 = load double*, double** %5
%197 = getelementptr inbounds double, double* %196, i64 8
store double %195, double* %197
%198 = load double, double* %15
%199 = load double, double* %19
%200 = fadd double %198, %199
%201 = load double*, double** %5
%202 = getelementptr inbounds double, double* %201, i64 9
store double %200, double* %202
%203 = load double, double* %19
%204 = load double, double* %15
%205 = fsub double %203, %204
%206 = load double*, double** %5
%207 = getelementptr inbounds double, double* %206, i64 12
store double %205, double* %207
%208 = load double, double* %14
%209 = load double, double* %18
%210 = fsub double %208, %209
%211 = load double*, double** %5
%212 = getelementptr inbounds double, double* %211, i64 13
store double %210, double* %212
%213 = load double, double* %16
%214 = load double, double* %21
%215 = fsub double %213, %214
store double %215, double* %14
%216 = load double, double* %17
%217 = load double, double* %20
%218 = fadd double %216, %217
store double %218, double* %15
%219 = load double, double* %13
%220 = load double, double* %14
%221 = load double, double* %15
%222 = fsub double %220, %221
%223 = fmul double %219, %222
%224 = load double*, double** %5
%225 = getelementptr inbounds double, double* %224, i64 10
store double %223, double* %225
%226 = load double, double* %13
%227 = load double, double* %14
%228 = load double, double* %15
%229 = fadd double %227, %228
%230 = fmul double %226, %229
%231 = load double*, double** %5
%232 = getelementptr inbounds double, double* %231, i64 11
store double %230, double* %232
%233 = load double, double* %21
%234 = load double, double* %16
%235 = fadd double %233, %234
store double %235, double* %14
%236 = load double, double* %20
%237 = load double, double* %17
%238 = fsub double %236, %237
store double %238, double* %15
%239 = load double, double* %13
%240 = load double, double* %15
%241 = load double, double* %14
%242 = fsub double %240, %241
%243 = fmul double %239, %242
%244 = load double*, double** %5
%245 = getelementptr inbounds double, double* %244, i64 14
store double %243, double* %245
%246 = load double, double* %13
%247 = load double, double* %15
%248 = load double, double* %14
%249 = fadd double %247, %248
%250 = fmul double %246, %249
%251 = load double*, double** %5
%252 = getelementptr inbounds double, double* %251, i64 15
store double %250, double* %252
%253 = load double*, double** %5
%254 = call i32 @writeA(double* %253)
store i32 16, i32* %7
store i32 2, i32* %8
br label %255
255: ; preds = %350, %3
%256 = load i32, i32* %7
%257 = load i32, i32* %4
%258 = icmp slt i32 %256, %257
br i1 %258, label %259, label %355
259: ; preds = %255
%260 = load double*, double** %6
%261 = load i32, i32* %8
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds double, double* %260, i64 %262
%264 = load double, double* %263
store double %264, double* %22
%265 = load double*, double** %9
%266 = load i32, i32* %8
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds double, double* %265, i64 %267
%269 = load double, double* %268
store double %269, double* %23
%270 = load double*, double** %6
%271 = load i32, i32* %8
%272 = load i32, i32* %8
%273 = add nsw i32 %271, %272
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds double, double* %270, i64 %274
%276 = load double, double* %275
store double %276, double* %24
%277 = load double*, double** %9
%278 = load i32, i32* %8
%279 = load i32, i32* %8
%280 = add nsw i32 %278, %279
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds double, double* %277, i64 %281
%283 = load double, double* %282
store double %283, double* %25
%284 = load double, double* %24
%285 = load double, double* %23
%286 = fmul double 2.000000e+00, %285
%287 = load double, double* %25
%288 = fneg double %286
%289 = call double @llvm.fmuladd.f64(double %288, double %287, double %284)
store double %289, double* %26
%290 = load double, double* %23
%291 = fmul double 2.000000e+00, %290
%292 = load double, double* %24
%293 = load double, double* %25
%294 = fneg double %293
%295 = call double @llvm.fmuladd.f64(double %291, double %292, double %294)
store double %295, double* %27
%296 = load i32, i32* %7
%297 = load double, double* %24
%298 = load double, double* %25
%299 = load double, double* %22
%300 = load double, double* %23
%301 = load double, double* %26
%302 = load double, double* %27
%303 = load double*, double** %5
%304 = load double*, double** %10
%305 = load double*, double** %11
%306 = load double*, double** %12
%307 = call i32 @btrfly(i32 %296, double %297, double %298, double %299, double %300, double %301, double %302, double* %303, double* %304, double* %305, double* %306)
%308 = load double*, double** %6
%309 = load i32, i32* %8
%310 = load i32, i32* %8
%311 = add nsw i32 %309, %310
%312 = add nsw i32 %311, 2
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds double, double* %308, i64 %313
%315 = load double, double* %314
store double %315, double* %24
%316 = load double*, double** %9
%317 = load i32, i32* %8
%318 = load i32, i32* %8
%319 = add nsw i32 %317, %318
%320 = add nsw i32 %319, 2
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds double, double* %316, i64 %321
%323 = load double, double* %322
store double %323, double* %25
%324 = load double, double* %24
%325 = load double, double* %22
%326 = fmul double 2.000000e+00, %325
%327 = load double, double* %25
%328 = fneg double %326
%329 = call double @llvm.fmuladd.f64(double %328, double %327, double %324)
store double %329, double* %26
%330 = load double, double* %22
%331 = fmul double 2.000000e+00, %330
%332 = load double, double* %24
%333 = load double, double* %25
%334 = fneg double %333
%335 = call double @llvm.fmuladd.f64(double %331, double %332, double %334)
store double %335, double* %27
%336 = load i32, i32* %7
%337 = add nsw i32 %336, 8
%338 = load double, double* %24
%339 = load double, double* %25
%340 = load double, double* %23
%341 = fneg double %340
%342 = load double, double* %22
%343 = load double, double* %26
%344 = load double, double* %27
%345 = load double*, double** %5
%346 = load double*, double** %10
%347 = load double*, double** %11
%348 = load double*, double** %12
%349 = call i32 @btrfly(i32 %337, double %338, double %339, double %341, double %342, double %343, double %344, double* %345, double* %346, double* %347, double* %348)
br label %350
350: ; preds = %259
%351 = load i32, i32* %7
%352 = add nsw i32 %351, 16
store i32 %352, i32* %7
%353 = load i32, i32* %8
%354 = add nsw i32 %353, 2
store i32 %354, i32* %8
br label %255
355: ; preds = %255
ret void
}

LLVM IR (-O2):
define void @cft1st(i32 %0, double* %1, double* nocapture %2) {
%4 = getelementptr inbounds double, double* %2, i64 1
%5 = getelementptr inbounds double, double* %1, i64 2
%6 = getelementptr inbounds double, double* %1, i64 4
%7 = getelementptr inbounds double, double* %1, i64 6
%8 = getelementptr inbounds double, double* %2, i64 2
%9 = load double, double* %8
%10 = tail call i32 @writeA(double* %1)
%11 = bitcast double* %1 to <2 x double>*
%12 = load <2 x double>, <2 x double>* %11
%13 = bitcast double* %5 to <2 x double>*
%14 = load <2 x double>, <2 x double>* %13
%15 = fadd <2 x double> %12, %14
%16 = fsub <2 x double> %12, %14
%17 = bitcast double* %6 to <2 x double>*
%18 = load <2 x double>, <2 x double>* %17
%19 = bitcast double* %7 to <2 x double>*
%20 = load <2 x double>, <2 x double>* %19
%21 = fadd <2 x double> %18, %20
%22 = fsub <2 x double> %18, %20
%23 = shufflevector <2 x double> %22, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%24 = fadd <2 x double> %15, %21
%25 = bitcast double* %1 to <2 x double>*
store <2 x double> %24, <2 x double>* %25
%26 = fsub <2 x double> %15, %21
%27 = bitcast double* %6 to <2 x double>*
store <2 x double> %26, <2 x double>* %27
%28 = fsub <2 x double> %16, %23
%29 = fadd <2 x double> %16, %23
%30 = shufflevector <2 x double> %28, <2 x double> %29, <2 x i32> <i32 0, i32 3>
%31 = bitcast double* %5 to <2 x double>*
store <2 x double> %30, <2 x double>* %31
%32 = shufflevector <2 x double> %29, <2 x double> %28, <2 x i32> <i32 0, i32 3>
%33 = bitcast double* %7 to <2 x double>*
store <2 x double> %32, <2 x double>* %33
%34 = getelementptr inbounds double, double* %1, i64 8
%35 = getelementptr inbounds double, double* %1, i64 10
%36 = bitcast double* %34 to <2 x double>*
%37 = load <2 x double>, <2 x double>* %36
%38 = getelementptr inbounds double, double* %1, i64 11
%39 = bitcast double* %35 to <2 x double>*
%40 = load <2 x double>, <2 x double>* %39
%41 = fadd <2 x double> %37, %40
%42 = fsub <2 x double> %37, %40
%43 = extractelement <2 x double> %42, i64 0
%44 = fsub <2 x double> %37, %40
%45 = extractelement <2 x double> %44, i64 1
%46 = getelementptr inbounds double, double* %1, i64 12
%47 = getelementptr inbounds double, double* %1, i64 14
%48 = bitcast double* %46 to <2 x double>*
%49 = load <2 x double>, <2 x double>* %48
%50 = getelementptr inbounds double, double* %1, i64 15
%51 = bitcast double* %47 to <2 x double>*
%52 = load <2 x double>, <2 x double>* %51
%53 = fadd <2 x double> %49, %52
%54 = fsub <2 x double> %49, %52
%55 = extractelement <2 x double> %54, i64 0
%56 = fsub <2 x double> %49, %52
%57 = extractelement <2 x double> %56, i64 1
%58 = fadd <2 x double> %41, %53
%59 = bitcast double* %34 to <2 x double>*
store <2 x double> %58, <2 x double>* %59
%60 = shufflevector <2 x double> %53, <2 x double> %41, <2 x i32> <i32 1, i32 2>
%61 = shufflevector <2 x double> %41, <2 x double> %53, <2 x i32> <i32 1, i32 2>
%62 = fsub <2 x double> %60, %61
%63 = bitcast double* %46 to <2 x double>*
store <2 x double> %62, <2 x double>* %63
%64 = fsub double %43, %57
%65 = fadd double %45, %55
%66 = fsub double %64, %65
%67 = fmul double %9, %66
store double %67, double* %35
%68 = fadd double %65, %64
%69 = fmul double %9, %68
store double %69, double* %38
%70 = fadd double %43, %57
%71 = fsub double %55, %45
%72 = fsub double %71, %70
%73 = fmul double %9, %72
store double %73, double* %47
%74 = fadd double %71, %70
%75 = fmul double %9, %74
store double %75, double* %50
%76 = tail call i32 @writeA(double* %1)
%77 = icmp sgt i32 %0, 16
br i1 %77, label %78, label %112
78: ; preds = %3, %78
%79 = phi i64 [ %110, %78 ], [ 2, %3 ]
%80 = phi i32 [ %109, %78 ], [ 16, %3 ]
%81 = getelementptr inbounds double, double* %2, i64 %79
%82 = load double, double* %81
%83 = getelementptr inbounds double, double* %4, i64 %79
%84 = load double, double* %83
%85 = shl nuw nsw i64 %79, 1
%86 = getelementptr inbounds double, double* %2, i64 %85
%87 = load double, double* %86
%88 = getelementptr inbounds double, double* %4, i64 %85
%89 = load double, double* %88
%90 = fmul double %84, 2.000000e+00
%91 = fneg double %90
%92 = tail call double @llvm.fmuladd.f64(double %91, double %89, double %87)
%93 = fneg double %89
%94 = tail call double @llvm.fmuladd.f64(double %90, double %87, double %93)
%95 = tail call i32 @btrfly(i32 %80, double %87, double %89, double %82, double %84, double %92, double %94, double* %1, double* %5, double* %6, double* %7)
%96 = or i64 %85, 2
%97 = getelementptr inbounds double, double* %2, i64 %96
%98 = load double, double* %97
%99 = getelementptr inbounds double, double* %4, i64 %96
%100 = load double, double* %99
%101 = fmul double %82, 2.000000e+00
%102 = fneg double %101
%103 = tail call double @llvm.fmuladd.f64(double %102, double %100, double %98)
%104 = fneg double %100
%105 = tail call double @llvm.fmuladd.f64(double %101, double %98, double %104)
%106 = or i32 %80, 8
%107 = fneg double %84
%108 = tail call i32 @btrfly(i32 %106, double %98, double %100, double %107, double %82, double %103, double %105, double* %1, double* %5, double* %6, double* %7)
%109 = add nuw nsw i32 %80, 16
%110 = add nuw i64 %79, 2
%111 = icmp slt i32 %109, %0
br i1 %111, label %78, label %112
112: ; preds = %78, %3
ret void
}