#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 atan(int);
int /*<<< orphan*/ cford1(int, float *);
int /*<<< orphan*/ cford2(int, float *);
int /*<<< orphan*/ cfr2tr(long, float *, float *);
int /*<<< orphan*/ cfr4syn(long, long, float *, float *, float *, float *,
                           float *, float *, float *, float *);
double cos(float);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
double sin(float);
int sqrt(int);
int /*<<< orphan*/ stderr;
void cfsst(float *b, long N) {
  extern double pii, pi2, p7, p7two, c22, s22;
  float pi8, invN;
  int M;
  long i, Nt, off;
  pii = 4. * atan(1.);
  pi2 = pii * 2.;
  pi8 = pii / 8.;
  p7 = 1. / sqrt(2.);
  p7two = 2. * p7;
  c22 = cos(pi8);
  s22 = sin(pi8);
  for (i = 1, Nt = 2; i < 20; i++, Nt *= 2)
    if (Nt == N)
      break;
  M = i;
  if (M == 20) {
    fprintf(stderr, "fast: N is not an allowable power of two\n");
    exit(1);
  }
  b[1] = b[N];
  for (i = 3; i < N; i += 2)
    b[i] *= -1.;
  invN = 1. / N;
  for (i = 0; i < N; i++)
    b[i] *= invN;
  cford2(M, b);
  cford1(M, b);
  Nt = 4 * N;
  if (M != 1)
    for (i = 1; i <= M / 2; i++) {
      Nt /= 4;
      off = N / Nt;
      cfr4syn(off, Nt, b, b + off, b + 2 * off, b + 3 * off, b, b + off,
              b + 2 * off, b + 3 * off);
    }
  if (M % 2 != 0) {
    off = N / 2;
    cfr2tr(off, b, b + off);
  }
}


x86 assembly (clang, -O0):
<cfsst>:
push   %rbp
mov    %rsp,%rbp
push   %r14
push   %rbx
sub    $0x60,%rsp
mov    %rdi,-0x18(%rbp)
mov    %rsi,-0x20(%rbp)
mov    $0x1,%edi
call   1080 <atan@plt>
cvtsi2sd %eax,%xmm1
movsd  0xe4f(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    0x2de4(%rip),%rax
movsd  %xmm0,(%rax)
movsd  0xe20(%rip),%xmm0
mov    0x2dd1(%rip),%rax
mulsd  (%rax),%xmm0
mov    0x2dde(%rip),%rax
movsd  %xmm0,(%rax)
mov    0x2dbb(%rip),%rax
movsd  (%rax),%xmm0
movsd  0xe07(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    $0x2,%edi
call   10b0 <sqrt@plt>
cvtsi2sd %eax,%xmm1
movsd  0xddc(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    0x2da9(%rip),%rax
movsd  %xmm0,(%rax)
movsd  0xdbd(%rip),%xmm0
mov    0x2d96(%rip),%rax
mulsd  (%rax),%xmm0
mov    0x2d93(%rip),%rax
movsd  %xmm0,(%rax)
movss  -0x24(%rbp),%xmm0
call   1090 <cos@plt>
mov    0x2d46(%rip),%rax
movsd  %xmm0,(%rax)
movss  -0x24(%rbp),%xmm0
call   1070 <sin@plt>
mov    0x2d59(%rip),%rax
movsd  %xmm0,(%rax)
movq   $0x1,-0x38(%rbp)
movq   $0x2,-0x40(%rbp)
cmpq   $0x14,-0x38(%rbp)
jge    12d3 <cfsst+0x133>
mov    -0x40(%rbp),%rax
cmp    -0x20(%rbp),%rax
jne    12b1 <cfsst+0x111>
jmp    12d3 <cfsst+0x133>
jmp    12b6 <cfsst+0x116>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1293 <cfsst+0xf3>
mov    -0x38(%rbp),%rax
mov    %eax,-0x2c(%rbp)
cmpl   $0x14,-0x2c(%rbp)
jne    1303 <cfsst+0x163>
mov    0x2cd5(%rip),%rax
mov    (%rax),%edi
lea    0xd34(%rip),%rsi
call   1060 <fprintf@plt>
mov    $0x1,%edi
call   10c0 <exit@plt>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movq   $0x3,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1366 <cfsst+0x1c6>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcd8(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x38(%rbp)
jmp    1321 <cfsst+0x181>
cvtsi2sdq -0x20(%rbp),%xmm1
movsd  0xc94(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    13bf <cfsst+0x21f>
movss  -0x28(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1389 <cfsst+0x1e9>
mov    -0x2c(%rbp),%edi
mov    -0x18(%rbp),%rsi
call   1040 <cford2@plt>
mov    -0x2c(%rbp),%edi
mov    -0x18(%rbp),%rsi
call   10a0 <cford1@plt>
mov    -0x20(%rbp),%rax
shl    $0x2,%rax
mov    %rax,-0x40(%rbp)
cmpl   $0x1,-0x2c(%rbp)
je     14dc <cfsst+0x33c>
movq   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
cmp    %rcx,%rax
jg     14d7 <cfsst+0x337>
mov    -0x40(%rbp),%rax
mov    $0x4,%ecx
cqto
idiv   %rcx
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
cqto
idivq  -0x40(%rbp)
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x18(%rbp),%rcx
mov    -0x48(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x18(%rbp),%r8
mov    -0x48(%rbp),%rax
shl    $0x1,%rax
shl    $0x2,%rax
add    %rax,%r8
mov    -0x18(%rbp),%r9
imul   $0x3,-0x48(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r9
mov    -0x18(%rbp),%rbx
mov    -0x18(%rbp),%r11
mov    -0x48(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r11
mov    -0x18(%rbp),%r10
mov    -0x48(%rbp),%rax
shl    $0x1,%rax
shl    $0x2,%rax
add    %rax,%r10
mov    -0x18(%rbp),%rax
imul   $0x3,-0x48(%rbp),%r14
shl    $0x2,%r14
add    %r14,%rax
mov    %rbx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
call   1050 <cfr4syn@plt>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    13f5 <cfsst+0x255>
jmp    14dc <cfsst+0x33c>
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     151e <cfsst+0x37e>
mov    -0x20(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x48(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
call   1030 <cfr2tr@plt>
add    $0x60,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

x86 assembly (clang, -O2):
<cfsst>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    %rsi,%r14
mov    %rdi,%r12
mov    $0x1,%r15d
mov    $0x1,%edi
call   1080 <atan@plt>
cvtsi2sd %eax,%xmm0
mulsd  0xe31(%rip),%xmm0
mov    0x2de2(%rip),%rax
movsd  %xmm0,(%rax)
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
mov    0x2de7(%rip),%rax
movsd  %xmm1,(%rax)
mulsd  0xe13(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0xc(%rsp)
mov    $0x2,%edi
call   10b0 <sqrt@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0xdf8(%rip),%xmm1
divsd  %xmm0,%xmm1
mov    0x2dbd(%rip),%rax
movsd  %xmm1,(%rax)
addsd  %xmm1,%xmm1
mov    0x2db6(%rip),%rax
movsd  %xmm1,(%rax)
movss  0xc(%rsp),%xmm0
call   1090 <cos@plt>
mov    0x2d68(%rip),%rax
movsd  %xmm0,(%rax)
movss  0xc(%rsp),%xmm0
call   1070 <sin@plt>
mov    0x2d7a(%rip),%rax
movsd  %xmm0,(%rax)
cmp    $0x2,%r14
jne    127a <cfsst+0xda>
movss  (%r12,%r14,4),%xmm0
movss  %xmm0,0x4(%r12)
jmp    1390 <cfsst+0x1f0>
mov    $0x1,%r15d
mov    $0x2,%eax
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r15,%rcx
add    $0x1,%r15
cmp    $0x12,%rcx
ja     12a5 <cfsst+0x105>
add    %rax,%rax
cmp    %r14,%rax
jne    1290 <cfsst+0xf0>
cmp    $0x14,%r15d
je     155f <cfsst+0x3bf>
movss  (%r12,%r14,4),%xmm0
movss  %xmm0,0x4(%r12)
cmp    $0x4,%r14
jl     1387 <cfsst+0x1e7>
lea    -0x4(%r14),%rsi
mov    %rsi,%rcx
shr    %rcx
add    $0x1,%rcx
mov    %ecx,%eax
and    $0x3,%eax
mov    $0x3,%edx
cmp    $0x6,%rsi
jb     1350 <cfsst+0x1b0>
and    $0xfffffffffffffffc,%rcx
mov    $0x3,%edx
movapd 0xd2b(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r12,%rdx,4),%xmm1
movss  0x8(%r12,%rdx,4),%xmm2
movss  0x10(%r12,%rdx,4),%xmm3
movss  0x18(%r12,%rdx,4),%xmm4
xorpd  %xmm0,%xmm1
movss  %xmm1,(%r12,%rdx,4)
xorpd  %xmm0,%xmm2
movss  %xmm2,0x8(%r12,%rdx,4)
xorpd  %xmm0,%xmm3
movss  %xmm3,0x10(%r12,%rdx,4)
xorpd  %xmm0,%xmm4
movss  %xmm4,0x18(%r12,%rdx,4)
add    $0x8,%rdx
add    $0xfffffffffffffffc,%rcx
jne    1300 <cfsst+0x160>
test   %rax,%rax
je     1387 <cfsst+0x1e7>
lea    (%r12,%rdx,4),%rcx
xor    %edx,%edx
movapd 0xcbd(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rcx,%rdx,8),%xmm1
xorpd  %xmm0,%xmm1
movss  %xmm1,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1370 <cfsst+0x1d0>
test   %r14,%r14
jle    1479 <cfsst+0x2d9>
xorps  %xmm0,%xmm0
cvtsi2sd %r14,%xmm0
movsd  0xc70(%rip),%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
cmp    $0x8,%r14
jae    13b8 <cfsst+0x218>
xor    %eax,%eax
jmp    1460 <cfsst+0x2c0>
mov    %r14,%rax
and    $0xfffffffffffffff8,%rax
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     154f <cfsst+0x3af>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movups (%r12,%rcx,4),%xmm2
movups 0x10(%r12,%rcx,4),%xmm3
movups 0x20(%r12,%rcx,4),%xmm4
movups 0x30(%r12,%rcx,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r12,%rcx,4)
movups %xmm3,0x10(%r12,%rcx,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,0x20(%r12,%rcx,4)
movups %xmm5,0x30(%r12,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    13f0 <cfsst+0x250>
test   $0x1,%dl
je     1455 <cfsst+0x2b5>
movups (%r12,%rcx,4),%xmm2
movups 0x10(%r12,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r12,%rcx,4)
movups %xmm3,0x10(%r12,%rcx,4)
cmp    %r14,%rax
je     1479 <cfsst+0x2d9>
nopw   0x0(%rax,%rax,1)
movss  (%r12,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r12,%rax,4)
add    $0x1,%rax
cmp    %rax,%r14
jne    1460 <cfsst+0x2c0>
mov    %r15d,%edi
mov    %r12,%rsi
call   1040 <cford2@plt>
mov    %r15d,%edi
mov    %r12,%rsi
call   10a0 <cford1@plt>
cmp    $0x1,%r15d
je     14ab <cfsst+0x30b>
jg     14d1 <cfsst+0x331>
test   $0x1,%r15b
jne    14ab <cfsst+0x30b>
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret
mov    %r14,%rdi
shr    $0x3f,%rdi
add    %r14,%rdi
sar    %rdi
lea    (%r12,%rdi,4),%rdx
mov    %r12,%rsi
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
jmp    1030 <cfr2tr@plt>
mov    %r15d,%r13d
shr    %r13d
lea    0x0(,%r14,4),%rbx
jmp    152b <cfsst+0x38b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r14,%rax
cqto
idiv   %rbx
lea    (%r12,%rax,4),%rcx
lea    (%r12,%rax,8),%r8
lea    (%rax,%rax,2),%rdx
lea    (%r12,%rdx,4),%r9
mov    %rax,%rdi
mov    %rbx,%rsi
mov    %r12,%rdx
push   %r9
push   %r8
push   %rcx
push   %r12
call   1050 <cfr4syn@plt>
add    $0x20,%rsp
add    $0xffffffffffffffff,%r13
je     1497 <cfsst+0x2f7>
lea    0x3(%rbx),%rax
test   %rbx,%rbx
cmovs  %rax,%rbx
sar    $0x2,%rbx
mov    %r14,%rax
or     %rbx,%rax
shr    $0x20,%rax
jne    14f0 <cfsst+0x350>
mov    %r14d,%eax
xor    %edx,%edx
div    %ebx
jmp    14f8 <cfsst+0x358>
xor    %ecx,%ecx
test   $0x1,%dl
jne    1439 <cfsst+0x299>
jmp    1455 <cfsst+0x2b5>
mov    0x2a5a(%rip),%rax
mov    (%rax),%edi
lea    0xac1(%rip),%rsi
call   1060 <fprintf@plt>
mov    $0x1,%edi
call   10c0 <exit@plt>

LLVM IR (-O0):
@pii = external global double
@pi2 = external global double
@p7 = external global double
@p7two = external global double
@c22 = external global double
@s22 = external global double
@stderr = global i32 0
@.str = [42 x i8] c"fast: N is not an allowable power of two\0A\00"
define void @cfsst(float* %0, i64 %1) {
%3 = alloca float*
%4 = alloca i64
%5 = alloca float
%6 = alloca float
%7 = alloca i32
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
store float* %0, float** %3
store i64 %1, i64* %4
%11 = call i32 @atan(i32 1)
%12 = sitofp i32 %11 to double
%13 = fmul double 4.000000e+00, %12
store double %13, double* @pii
%14 = load double, double* @pii
%15 = fmul double %14, 2.000000e+00
store double %15, double* @pi2
%16 = load double, double* @pii
%17 = fdiv double %16, 8.000000e+00
%18 = fptrunc double %17 to float
store float %18, float* %5
%19 = call i32 @sqrt(i32 2)
%20 = sitofp i32 %19 to double
%21 = fdiv double 1.000000e+00, %20
store double %21, double* @p7
%22 = load double, double* @p7
%23 = fmul double 2.000000e+00, %22
store double %23, double* @p7two
%24 = load float, float* %5
%25 = call double @cos(float %24)
store double %25, double* @c22
%26 = load float, float* %5
%27 = call double @sin(float %26)
store double %27, double* @s22
store i64 1, i64* %8
store i64 2, i64* %9
br label %28
28: ; preds = %37, %2
%29 = load i64, i64* %8
%30 = icmp slt i64 %29, 20
br i1 %30, label %31, label %42
31: ; preds = %28
%32 = load i64, i64* %9
%33 = load i64, i64* %4
%34 = icmp eq i64 %32, %33
br i1 %34, label %35, label %36
35: ; preds = %31
br label %42
36: ; preds = %31
br label %37
37: ; preds = %36
%38 = load i64, i64* %8
%39 = add nsw i64 %38, 1
store i64 %39, i64* %8
%40 = load i64, i64* %9
%41 = mul nsw i64 %40, 2
store i64 %41, i64* %9
br label %28
42: ; preds = %35, %28
%43 = load i64, i64* %8
%44 = trunc i64 %43 to i32
store i32 %44, i32* %7
%45 = load i32, i32* %7
%46 = icmp eq i32 %45, 20
br i1 %46, label %47, label %51
47: ; preds = %42
%48 = load i32, i32* @stderr
%49 = call i32 @fprintf(i32 %48, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str, i64 0, i64 0))
%50 = call i32 @exit(i32 1)
unreachable
51: ; preds = %42
%52 = load float*, float** %3
%53 = load i64, i64* %4
%54 = getelementptr inbounds float, float* %52, i64 %53
%55 = load float, float* %54
%56 = load float*, float** %3
%57 = getelementptr inbounds float, float* %56, i64 1
store float %55, float* %57
store i64 3, i64* %8
br label %58
58: ; preds = %70, %51
%59 = load i64, i64* %8
%60 = load i64, i64* %4
%61 = icmp slt i64 %59, %60
br i1 %61, label %62, label %73
62: ; preds = %58
%63 = load float*, float** %3
%64 = load i64, i64* %8
%65 = getelementptr inbounds float, float* %63, i64 %64
%66 = load float, float* %65
%67 = fpext float %66 to double
%68 = fmul double %67, -1.000000e+00
%69 = fptrunc double %68 to float
store float %69, float* %65
br label %70
70: ; preds = %62
%71 = load i64, i64* %8
%72 = add nsw i64 %71, 2
store i64 %72, i64* %8
br label %58
73: ; preds = %58
%74 = load i64, i64* %4
%75 = sitofp i64 %74 to double
%76 = fdiv double 1.000000e+00, %75
%77 = fptrunc double %76 to float
store float %77, float* %6
store i64 0, i64* %8
br label %78
78: ; preds = %89, %73
%79 = load i64, i64* %8
%80 = load i64, i64* %4
%81 = icmp slt i64 %79, %80
br i1 %81, label %82, label %92
82: ; preds = %78
%83 = load float, float* %6
%84 = load float*, float** %3
%85 = load i64, i64* %8
%86 = getelementptr inbounds float, float* %84, i64 %85
%87 = load float, float* %86
%88 = fmul float %87, %83
store float %88, float* %86
br label %89
89: ; preds = %82
%90 = load i64, i64* %8
%91 = add nsw i64 %90, 1
store i64 %91, i64* %8
br label %78
92: ; preds = %78
%93 = load i32, i32* %7
%94 = load float*, float** %3
%95 = call i32 @cford2(i32 %93, float* %94)
%96 = load i32, i32* %7
%97 = load float*, float** %3
%98 = call i32 @cford1(i32 %96, float* %97)
%99 = load i64, i64* %4
%100 = mul nsw i64 4, %99
store i64 %100, i64* %9
%101 = load i32, i32* %7
%102 = icmp ne i32 %101, 1
br i1 %102, label %103, label %147
103: ; preds = %92
store i64 1, i64* %8
br label %104
104: ; preds = %143, %103
%105 = load i64, i64* %8
%106 = load i32, i32* %7
%107 = sdiv i32 %106, 2
%108 = sext i32 %107 to i64
%109 = icmp sle i64 %105, %108
br i1 %109, label %110, label %146
110: ; preds = %104
%111 = load i64, i64* %9
%112 = sdiv i64 %111, 4
store i64 %112, i64* %9
%113 = load i64, i64* %4
%114 = load i64, i64* %9
%115 = sdiv i64 %113, %114
store i64 %115, i64* %10
%116 = load i64, i64* %10
%117 = load i64, i64* %9
%118 = load float*, float** %3
%119 = load float*, float** %3
%120 = load i64, i64* %10
%121 = getelementptr inbounds float, float* %119, i64 %120
%122 = load float*, float** %3
%123 = load i64, i64* %10
%124 = mul nsw i64 2, %123
%125 = getelementptr inbounds float, float* %122, i64 %124
%126 = load float*, float** %3
%127 = load i64, i64* %10
%128 = mul nsw i64 3, %127
%129 = getelementptr inbounds float, float* %126, i64 %128
%130 = load float*, float** %3
%131 = load float*, float** %3
%132 = load i64, i64* %10
%133 = getelementptr inbounds float, float* %131, i64 %132
%134 = load float*, float** %3
%135 = load i64, i64* %10
%136 = mul nsw i64 2, %135
%137 = getelementptr inbounds float, float* %134, i64 %136
%138 = load float*, float** %3
%139 = load i64, i64* %10
%140 = mul nsw i64 3, %139
%141 = getelementptr inbounds float, float* %138, i64 %140
%142 = call i32 @cfr4syn(i64 %116, i64 %117, float* %118, float* %121, float* %125, float* %129, float* %130, float* %133, float* %137, float* %141)
br label %143
143: ; preds = %110
%144 = load i64, i64* %8
%145 = add nsw i64 %144, 1
store i64 %145, i64* %8
br label %104
146: ; preds = %104
br label %147
147: ; preds = %146, %92
%148 = load i32, i32* %7
%149 = srem i32 %148, 2
%150 = icmp ne i32 %149, 0
br i1 %150, label %151, label %160
151: ; preds = %147
%152 = load i64, i64* %4
%153 = sdiv i64 %152, 2
store i64 %153, i64* %10
%154 = load i64, i64* %10
%155 = load float*, float** %3
%156 = load float*, float** %3
%157 = load i64, i64* %10
%158 = getelementptr inbounds float, float* %156, i64 %157
%159 = call i32 @cfr2tr(i64 %154, float* %155, float* %158)
br label %160
160: ; preds = %151, %147
ret void
}

LLVM IR (-O2):
@pii = external global double
@pi2 = external global double
@p7 = external global double
@p7two = external global double
@c22 = external global double
@s22 = external global double
@stderr = global i32 0
@.str = [42 x i8] c"fast: N is not an allowable power of two\0A\00"
define void @cfsst(float* %0, i64 %1) {
%3 = tail call i32 @atan(i32 1)
%4 = sitofp i32 %3 to double
%5 = fmul double %4, 4.000000e+00
store double %5, double* @pii
%6 = fmul double %5, 2.000000e+00
store double %6, double* @pi2
%7 = fmul double %5, 1.250000e-01
%8 = fptrunc double %7 to float
%9 = tail call i32 @sqrt(i32 2)
%10 = sitofp i32 %9 to double
%11 = fdiv double 1.000000e+00, %10
store double %11, double* @p7
%12 = fmul double %11, 2.000000e+00
store double %12, double* @p7two
%13 = tail call double @cos(float %8)
store double %13, double* @c22
%14 = tail call double @sin(float %8)
store double %14, double* @s22
%15 = icmp eq i64 %1, 2
br i1 %15, label %16, label %20
16: ; preds = %2
%17 = getelementptr inbounds float, float* %0, i64 %1
%18 = load float, float* %17
%19 = getelementptr inbounds float, float* %0, i64 1
store float %18, float* %19
br label %83
20: ; preds = %2, %20
%21 = phi i64 [ %24, %20 ], [ 2, %2 ]
%22 = phi i64 [ %23, %20 ], [ 1, %2 ]
%23 = add nuw nsw i64 %22, 1
%24 = shl nsw i64 %21, 1
%25 = icmp ugt i64 %22, 18
%26 = icmp eq i64 %24, %1
%27 = select i1 %25, i1 true, i1 %26
br i1 %27, label %28, label %20
28: ; preds = %20
%29 = trunc i64 %23 to i32
%30 = icmp eq i32 %29, 20
br i1 %30, label %31, label %35
31: ; preds = %28
%32 = load i32, i32* @stderr
%33 = tail call i32 @fprintf(i32 %32, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str, i64 0, i64 0))
%34 = tail call i32 @exit(i32 1)
unreachable
35: ; preds = %28
%36 = getelementptr inbounds float, float* %0, i64 %1
%37 = load float, float* %36
%38 = getelementptr inbounds float, float* %0, i64 1
store float %37, float* %38
%39 = icmp sgt i64 %1, 3
br i1 %39, label %40, label %81
40: ; preds = %35
%41 = add i64 %1, -4
%42 = lshr i64 %41, 1
%43 = add nuw i64 %42, 1
%44 = and i64 %43, 3
%45 = icmp ult i64 %41, 6
br i1 %45, label %69, label %46
46: ; preds = %40
%47 = and i64 %43, -4
br label %48
48: ; preds = %48, %46
%49 = phi i64 [ 3, %46 ], [ %66, %48 ]
%50 = phi i64 [ 0, %46 ], [ %67, %48 ]
%51 = getelementptr inbounds float, float* %0, i64 %49
%52 = load float, float* %51
%53 = fneg float %52
store float %53, float* %51
%54 = add nuw nsw i64 %49, 2
%55 = getelementptr inbounds float, float* %0, i64 %54
%56 = load float, float* %55
%57 = fneg float %56
store float %57, float* %55
%58 = add nuw nsw i64 %49, 4
%59 = getelementptr inbounds float, float* %0, i64 %58
%60 = load float, float* %59
%61 = fneg float %60
store float %61, float* %59
%62 = add nuw nsw i64 %49, 6
%63 = getelementptr inbounds float, float* %0, i64 %62
%64 = load float, float* %63
%65 = fneg float %64
store float %65, float* %63
%66 = add nuw nsw i64 %49, 8
%67 = add i64 %50, 4
%68 = icmp eq i64 %67, %47
br i1 %68, label %69, label %48
69: ; preds = %48, %40
%70 = phi i64 [ 3, %40 ], [ %66, %48 ]
%71 = icmp eq i64 %44, 0
br i1 %71, label %81, label %72
72: ; preds = %69, %72
%73 = phi i64 [ %78, %72 ], [ %70, %69 ]
%74 = phi i64 [ %79, %72 ], [ 0, %69 ]
%75 = getelementptr inbounds float, float* %0, i64 %73
%76 = load float, float* %75
%77 = fneg float %76
store float %77, float* %75
%78 = add nuw nsw i64 %73, 2
%79 = add i64 %74, 1
%80 = icmp eq i64 %79, %44
br i1 %80, label %81, label %72
81: ; preds = %69, %72, %35
%82 = icmp sgt i64 %1, 0
br i1 %82, label %83, label %154
83: ; preds = %16, %81
%84 = phi i32 [ 1, %16 ], [ %29, %81 ]
%85 = sitofp i64 %1 to double
%86 = fdiv double 1.000000e+00, %85
%87 = fptrunc double %86 to float
%88 = icmp ult i64 %1, 8
br i1 %88, label %145, label %89
89: ; preds = %83
%90 = and i64 %1, -8
%91 = insertelement <4 x float> poison, float %87, i64 0
%92 = shufflevector <4 x float> %91, <4 x float> poison, <4 x i32> zeroinitializer
%93 = insertelement <4 x float> poison, float %87, i64 0
%94 = shufflevector <4 x float> %93, <4 x float> poison, <4 x i32> zeroinitializer
%95 = add i64 %90, -8
%96 = lshr exact i64 %95, 3
%97 = add nuw nsw i64 %96, 1
%98 = and i64 %97, 1
%99 = icmp eq i64 %95, 0
br i1 %99, label %129, label %100
100: ; preds = %89
%101 = and i64 %97, 4611686018427387902
br label %102
102: ; preds = %102, %100
%103 = phi i64 [ 0, %100 ], [ %126, %102 ]
%104 = phi i64 [ 0, %100 ], [ %127, %102 ]
%105 = getelementptr inbounds float, float* %0, i64 %103
%106 = bitcast float* %105 to <4 x float>*
%107 = load <4 x float>, <4 x float>* %106
%108 = getelementptr inbounds float, float* %105, i64 4
%109 = bitcast float* %108 to <4 x float>*
%110 = load <4 x float>, <4 x float>* %109
%111 = fmul <4 x float> %107, %92
%112 = fmul <4 x float> %110, %94
%113 = bitcast float* %105 to <4 x float>*
store <4 x float> %111, <4 x float>* %113
%114 = bitcast float* %108 to <4 x float>*
store <4 x float> %112, <4 x float>* %114
%115 = or i64 %103, 8
%116 = getelementptr inbounds float, float* %0, i64 %115
%117 = bitcast float* %116 to <4 x float>*
%118 = load <4 x float>, <4 x float>* %117
%119 = getelementptr inbounds float, float* %116, i64 4
%120 = bitcast float* %119 to <4 x float>*
%121 = load <4 x float>, <4 x float>* %120
%122 = fmul <4 x float> %118, %92
%123 = fmul <4 x float> %121, %94
%124 = bitcast float* %116 to <4 x float>*
store <4 x float> %122, <4 x float>* %124
%125 = bitcast float* %119 to <4 x float>*
store <4 x float> %123, <4 x float>* %125
%126 = add nuw i64 %103, 16
%127 = add i64 %104, 2
%128 = icmp eq i64 %127, %101
br i1 %128, label %129, label %102
129: ; preds = %102, %89
%130 = phi i64 [ 0, %89 ], [ %126, %102 ]
%131 = icmp eq i64 %98, 0
br i1 %131, label %143, label %132
132: ; preds = %129
%133 = getelementptr inbounds float, float* %0, i64 %130
%134 = bitcast float* %133 to <4 x float>*
%135 = load <4 x float>, <4 x float>* %134
%136 = getelementptr inbounds float, float* %133, i64 4
%137 = bitcast float* %136 to <4 x float>*
%138 = load <4 x float>, <4 x float>* %137
%139 = fmul <4 x float> %135, %92
%140 = fmul <4 x float> %138, %94
%141 = bitcast float* %133 to <4 x float>*
store <4 x float> %139, <4 x float>* %141
%142 = bitcast float* %136 to <4 x float>*
store <4 x float> %140, <4 x float>* %142
br label %143
143: ; preds = %129, %132
%144 = icmp eq i64 %90, %1
br i1 %144, label %154, label %145
145: ; preds = %83, %143
%146 = phi i64 [ 0, %83 ], [ %90, %143 ]
br label %147
147: ; preds = %145, %147
%148 = phi i64 [ %152, %147 ], [ %146, %145 ]
%149 = getelementptr inbounds float, float* %0, i64 %148
%150 = load float, float* %149
%151 = fmul float %150, %87
store float %151, float* %149
%152 = add nuw nsw i64 %148, 1
%153 = icmp eq i64 %152, %1
br i1 %153, label %154, label %147
154: ; preds = %147, %143, %81
%155 = phi i32 [ %29, %81 ], [ %84, %143 ], [ %84, %147 ]
%156 = tail call i32 @cford2(i32 %155, float* %0)
%157 = tail call i32 @cford1(i32 %155, float* %0)
%158 = icmp eq i32 %155, 1
br i1 %158, label %182, label %159
159: ; preds = %154
%160 = icmp slt i32 %155, 2
br i1 %160, label %179, label %161
161: ; preds = %159
%162 = lshr i32 %155, 1
%163 = shl nsw i64 %1, 2
%164 = add nuw nsw i32 %162, 1
%165 = zext i32 %164 to i64
br label %166
166: ; preds = %161, %166
%167 = phi i64 [ %169, %166 ], [ %163, %161 ]
%168 = phi i64 [ %177, %166 ], [ 1, %161 ]
%169 = sdiv i64 %167, 4
%170 = sdiv i64 %1, %169
%171 = getelementptr inbounds float, float* %0, i64 %170
%172 = shl nsw i64 %170, 1
%173 = getelementptr inbounds float, float* %0, i64 %172
%174 = mul nsw i64 %170, 3
%175 = getelementptr inbounds float, float* %0, i64 %174
%176 = tail call i32 @cfr4syn(i64 %170, i64 %169, float* %0, float* %171, float* %173, float* %175, float* %0, float* %171, float* %173, float* %175)
%177 = add nuw nsw i64 %168, 1
%178 = icmp eq i64 %177, %165
br i1 %178, label %179, label %166
179: ; preds = %166, %159
%180 = and i32 %155, 1
%181 = icmp eq i32 %180, 0
br i1 %181, label %186, label %182
182: ; preds = %154, %179
%183 = sdiv i64 %1, 2
%184 = getelementptr inbounds float, float* %0, i64 %183
%185 = tail call i32 @cfr2tr(i64 %183, float* %0, float* %184)
br label %186
186: ; preds = %182, %179
ret void
}