#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*/ passf(int *, int, int, int, int, float *, float *,
                         float const *, int);
int /*<<< orphan*/ passf2(int, int, float *, float *, float const *, int);
int /*<<< orphan*/ passf3(int, int, float *, float *, float const *,
                          float const *, int);
int /*<<< orphan*/ passf4(int, int, float *, float *, float const *,
                          float const *, float const *, int);
int /*<<< orphan*/ passf5(int, int, float *, float *, float const *,
                          float const *, float const *, float const *, int);
void cfftf1(int n, float c[], float ch[], const float wa[],
            const int ifac[13 + 2], int isign) {
  int idot, i;
  int k1, l1, l2;
  int na, nf, ip, iw, ix2, ix3, ix4, nac, ido, idl1;
  float *cinput, *coutput;
  nf = ifac[1];
  na = 0;
  l1 = 1;
  iw = 0;
  for (k1 = 2; k1 <= nf + 1; k1++) {
    ip = ifac[k1];
    l2 = ip * l1;
    ido = n / l2;
    idot = ido + ido;
    idl1 = idot * l1;
    if (na) {
      cinput = ch;
      coutput = c;
    } else {
      cinput = c;
      coutput = ch;
    }
    switch (ip) {
    case 4:
      ix2 = iw + idot;
      ix3 = ix2 + idot;
      passf4(idot, l1, cinput, coutput, &wa[iw], &wa[ix2], &wa[ix3], isign);
      na = !na;
      break;
    case 2:
      passf2(idot, l1, cinput, coutput, &wa[iw], isign);
      na = !na;
      break;
    case 3:
      ix2 = iw + idot;
      passf3(idot, l1, cinput, coutput, &wa[iw], &wa[ix2], isign);
      na = !na;
      break;
    case 5:
      ix2 = iw + idot;
      ix3 = ix2 + idot;
      ix4 = ix3 + idot;
      passf5(idot, l1, cinput, coutput, &wa[iw], &wa[ix2], &wa[ix3], &wa[ix4],
             isign);
      na = !na;
      break;
    default:
      passf(&nac, idot, ip, l1, idl1, cinput, coutput, &wa[iw], isign);
      if (nac != 0)
        na = !na;
    }
    l1 = l2;
    iw += (ip - 1) * idot;
  }
  if (na == 0)
    return;
  for (i = 0; i < 2 * n; i++)
    c[i] = ch[i];
}


x86 assembly (clang, -O0):
<cfftf1>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x28(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x1,-0x3c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x2,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     144c <cfftf1+0x2fc>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
imul   -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x4(%rbp),%eax
cltd
idivl  -0x40(%rbp)
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x3c(%rbp),%eax
mov    %eax,-0x68(%rbp)
cmpl   $0x0,-0x44(%rbp)
je     11fd <cfftf1+0xad>
mov    -0x18(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x78(%rbp)
jmp    120d <cfftf1+0xbd>
mov    -0x10(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x4c(%rbp),%eax
add    $0xfffffffe,%eax
mov    %eax,%ecx
mov    %rcx,-0x80(%rbp)
sub    $0x3,%eax
ja     13cb <cfftf1+0x27b>
mov    -0x80(%rbp),%rax
lea    0xdd3(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x50(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x30(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x70(%rbp),%rdx
mov    -0x78(%rbp),%rcx
mov    -0x20(%rbp),%r8
movslq -0x50(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r8
mov    -0x20(%rbp),%r9
movslq -0x54(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r9
mov    -0x20(%rbp),%r10
movslq -0x58(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r10
mov    -0x2c(%rbp),%eax
mov    %r10,(%rsp)
mov    %eax,0x8(%rsp)
call   1040 <passf4@plt>
cmpl   $0x0,-0x44(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x44(%rbp)
jmp    1428 <cfftf1+0x2d8>
mov    -0x30(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x70(%rbp),%rdx
mov    -0x78(%rbp),%rcx
mov    -0x20(%rbp),%r8
movslq -0x50(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r8
mov    -0x2c(%rbp),%r9d
call   1050 <passf2@plt>
cmpl   $0x0,-0x44(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x44(%rbp)
jmp    1428 <cfftf1+0x2d8>
mov    -0x50(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x30(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x70(%rbp),%rdx
mov    -0x78(%rbp),%rcx
mov    -0x20(%rbp),%r8
movslq -0x50(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r8
mov    -0x20(%rbp),%r9
movslq -0x54(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r9
mov    -0x2c(%rbp),%eax
mov    %eax,(%rsp)
call   1060 <passf3@plt>
cmpl   $0x0,-0x44(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x44(%rbp)
jmp    1428 <cfftf1+0x2d8>
mov    -0x50(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x30(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x70(%rbp),%rdx
mov    -0x78(%rbp),%rcx
mov    -0x20(%rbp),%r8
movslq -0x50(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r8
mov    -0x20(%rbp),%r9
movslq -0x54(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r9
mov    -0x20(%rbp),%r11
movslq -0x58(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r11
mov    -0x20(%rbp),%r10
movslq -0x5c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r10
mov    -0x2c(%rbp),%eax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1070 <passf5@plt>
cmpl   $0x0,-0x44(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x44(%rbp)
jmp    1428 <cfftf1+0x2d8>
mov    -0x30(%rbp),%esi
mov    -0x4c(%rbp),%edx
mov    -0x3c(%rbp),%ecx
mov    -0x68(%rbp),%r8d
mov    -0x70(%rbp),%r9
mov    -0x78(%rbp),%r11
mov    -0x20(%rbp),%r10
movslq -0x50(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r10
mov    -0x2c(%rbp),%eax
lea    -0x60(%rbp),%rdi
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1030 <passf@plt>
cmpl   $0x0,-0x60(%rbp)
je     1423 <cfftf1+0x2d3>
cmpl   $0x0,-0x44(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x44(%rbp)
jmp    1428 <cfftf1+0x2d8>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
imul   -0x30(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1198 <cfftf1+0x48>
cmpl   $0x0,-0x44(%rbp)
jne    145b <cfftf1+0x30b>
jmp    149b <cfftf1+0x34b>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    149b <cfftf1+0x34b>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1462 <cfftf1+0x312>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cfftf1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9,0x18(%rsp)
mov    %rcx,0x10(%rsp)
mov    %edi,0xc(%rsp)
mov    %r8,0x40(%rsp)
mov    0x4(%r8),%eax
test   %eax,%eax
jle    1554 <cfftf1+0x404>
mov    %rdx,%r9
add    $0x2,%rax
xor    %r14d,%r14d
mov    $0x1,%ecx
mov    $0x2,%r13d
xor    %ebp,%ebp
mov    %rdx,0x38(%rsp)
mov    %rsi,0x30(%rsp)
mov    %rax,0x28(%rsp)
jmp    122b <cfftf1+0xdb>
nopl   0x0(%rax,%rax,1)
xor    %edx,%edx
test   %ebp,%ebp
sete   %dl
mov    %edx,0x8(%rsp)
mov    %r12d,%r8d
imul   %ecx,%r8d
movslq %r14d,%rdx
mov    0x10(%rsp),%rsi
lea    (%rsi,%rdx,4),%r10
sub    $0x8,%rsp
lea    0x2c(%rsp),%rdi
mov    %r12d,%esi
mov    %r15d,%edx
mov    %rbx,%r9
push   0x20(%rsp)
push   %r10
push   %rax
call   1030 <passf@plt>
add    $0x20,%rsp
cmpl   $0x0,0x24(%rsp)
cmovne 0x8(%rsp),%ebp
nopw   0x0(%rax,%rax,1)
add    $0xffffffff,%r15d
imul   %r15d,%r12d
add    %r12d,%r14d
add    $0x1,%r13
mov    0x28(%rsp),%rax
cmp    %r13,%rax
mov    0x38(%rsp),%r9
mov    0x30(%rsp),%rsi
mov    0x20(%rsp),%ecx
je     13bf <cfftf1+0x26f>
mov    0x40(%rsp),%rax
mov    (%rax,%r13,4),%r15d
mov    %r15d,%edi
imul   %ecx,%edi
mov    0xc(%rsp),%eax
cltd
mov    %edi,0x20(%rsp)
idiv   %edi
mov    %eax,%r12d
add    %r12d,%r12d
test   %ebp,%ebp
mov    %r9,%rbx
cmove  %rsi,%rbx
mov    %rsi,%rax
cmove  %r9,%rax
lea    -0x2(%r15),%edx
cmp    $0x3,%edx
ja     11b0 <cfftf1+0x60>
lea    0xd91(%rip),%rsi
movslq (%rsi,%rdx,4),%rdx
add    %rsi,%rdx
jmp    *%rdx
xor    %edx,%edx
test   %ebp,%ebp
sete   %dl
mov    %edx,%ebp
movslq %r14d,%rdx
mov    0x10(%rsp),%rsi
lea    (%rsi,%rdx,4),%r8
mov    %r12d,%edi
mov    %ecx,%esi
mov    %rbx,%rdx
mov    %rax,%rcx
mov    0x18(%rsp),%r9
call   1050 <passf2@plt>
jmp    1200 <cfftf1+0xb0>
nopw   0x0(%rax,%rax,1)
xor    %edx,%edx
test   %ebp,%ebp
sete   %dl
mov    %edx,%ebp
lea    (%r12,%r14,1),%edx
movslq %r14d,%rsi
mov    0x10(%rsp),%rdi
lea    (%rdi,%rsi,4),%r8
movslq %edx,%rdx
lea    (%rdi,%rdx,4),%r9
sub    $0x8,%rsp
mov    %r12d,%edi
mov    %ecx,%esi
mov    %rbx,%rdx
mov    %rax,%rcx
push   0x20(%rsp)
call   1060 <passf3@plt>
add    $0x10,%rsp
jmp    1200 <cfftf1+0xb0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %edx,%edx
test   %ebp,%ebp
sete   %dl
mov    %edx,0x8(%rsp)
lea    (%r12,%r14,1),%edx
movslq %r14d,%rsi
mov    0x10(%rsp),%rdi
lea    (%rdi,%rsi,4),%r8
movslq %edx,%rsi
add    %r12d,%edx
lea    (%rdi,%rsi,4),%r9
movslq %edx,%rdx
lea    (%rdi,%rdx,4),%rbp
mov    %r12d,%edi
mov    %ecx,%esi
mov    %rbx,%rdx
mov    %rax,%rcx
push   0x18(%rsp)
push   %rbp
call   1040 <passf4@plt>
add    $0x10,%rsp
mov    0x8(%rsp),%ebp
jmp    1200 <cfftf1+0xb0>
xchg   %ax,%ax
xor    %edx,%edx
test   %ebp,%ebp
sete   %dl
mov    %edx,0x8(%rsp)
lea    (%r12,%r14,1),%edx
lea    (%rdx,%r12,1),%esi
movslq %r14d,%rdi
mov    0x10(%rsp),%rbp
lea    0x0(%rbp,%rdi,4),%r8
movslq %edx,%rdx
lea    0x0(,%rdx,4),%r9
add    %rbp,%r9
movslq %esi,%rdx
add    %r12d,%esi
lea    0x0(,%rdx,4),%r10
add    %rbp,%r10
movslq %esi,%rdx
lea    0x0(%rbp,%rdx,4),%rbp
sub    $0x8,%rsp
mov    %r12d,%edi
mov    %ecx,%esi
mov    %rbx,%rdx
mov    %rax,%rcx
push   0x20(%rsp)
push   %rbp
push   %r10
call   1070 <passf5@plt>
add    $0x20,%rsp
mov    0x8(%rsp),%ebp
jmp    1200 <cfftf1+0xb0>
test   %ebp,%ebp
je     1554 <cfftf1+0x404>
cmpl   $0x0,0xc(%rsp)
jle    1554 <cfftf1+0x404>
mov    0xc(%rsp),%ecx
add    %ecx,%ecx
cmp    $0x2,%ecx
mov    $0x1,%eax
cmovge %ecx,%eax
cmp    $0x8,%eax
jb     1402 <cfftf1+0x2b2>
lea    (%r9,%rax,4),%rcx
cmp    %rsi,%rcx
jbe    1480 <cfftf1+0x330>
lea    (%rsi,%rax,4),%rcx
cmp    %r9,%rcx
jbe    1480 <cfftf1+0x330>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rdi
and    $0x3,%rdi
je     1435 <cfftf1+0x2e5>
cs nopw 0x0(%rax,%rax,1)
movss  (%r9,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1420 <cfftf1+0x2d0>
cmp    $0x3,%rdx
jb     1554 <cfftf1+0x404>
nop
movss  (%r9,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
movss  0x4(%r9,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsi,%rcx,4)
movss  0x8(%r9,%rcx,4),%xmm0
movss  %xmm0,0x8(%rsi,%rcx,4)
movss  0xc(%r9,%rcx,4),%xmm0
movss  %xmm0,0xc(%rsi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1440 <cfftf1+0x2f0>
jmp    1554 <cfftf1+0x404>
mov    %eax,%ecx
and    $0x7ffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%r8d
and    $0x3,%r8d
cmp    $0x18,%rdi
jae    14a8 <cfftf1+0x358>
xor    %edi,%edi
jmp    1510 <cfftf1+0x3c0>
and    $0xfffffffffffffffc,%rdx
xor    %edi,%edi
xchg   %ax,%ax
movups (%r9,%rdi,4),%xmm0
movups 0x10(%r9,%rdi,4),%xmm1
movups %xmm0,(%rsi,%rdi,4)
movups %xmm1,0x10(%rsi,%rdi,4)
movups 0x20(%r9,%rdi,4),%xmm0
movups 0x30(%r9,%rdi,4),%xmm1
movups %xmm0,0x20(%rsi,%rdi,4)
movups %xmm1,0x30(%rsi,%rdi,4)
movups 0x40(%r9,%rdi,4),%xmm0
movups 0x50(%r9,%rdi,4),%xmm1
movups %xmm0,0x40(%rsi,%rdi,4)
movups %xmm1,0x50(%rsi,%rdi,4)
movups 0x60(%r9,%rdi,4),%xmm0
movups 0x70(%r9,%rdi,4),%xmm1
movups %xmm0,0x60(%rsi,%rdi,4)
movups %xmm1,0x70(%rsi,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rdx
jne    14b0 <cfftf1+0x360>
test   %r8,%r8
je     154b <cfftf1+0x3fb>
lea    (%rsi,%rdi,4),%rdx
add    $0x10,%rdx
lea    (%r9,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%r8
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbx,1),%xmm0
movups (%rdi,%rbx,1),%xmm1
movups %xmm0,-0x10(%rdx,%rbx,1)
movups %xmm1,(%rdx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r8
jne    1530 <cfftf1+0x3e0>
cmp    %rax,%rcx
jne    1404 <cfftf1+0x2b4>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @cfftf1(i32 %0, float* %1, float* %2, float* %3, i32* nocapture %4, i32 %5) {
%7 = alloca i32
%8 = bitcast i32* %7 to i8*
%9 = getelementptr inbounds i32, i32* %4, i64 1
%10 = load i32, i32* %9
%11 = icmp slt i32 %10, 1
br i1 %11, label %213, label %12
12: ; preds = %6
%13 = add nuw i32 %10, 2
%14 = zext i32 %13 to i64
br label %15
15: ; preds = %12, %75
%16 = phi i64 [ 2, %12 ], [ %80, %75 ]
%17 = phi i32 [ 1, %12 ], [ %22, %75 ]
%18 = phi i32 [ 0, %12 ], [ %79, %75 ]
%19 = phi i32 [ 0, %12 ], [ %76, %75 ]
%20 = getelementptr inbounds i32, i32* %4, i64 %16
%21 = load i32, i32* %20
%22 = mul nsw i32 %21, %17
%23 = sdiv i32 %0, %22
%24 = shl nsw i32 %23, 1
%25 = icmp eq i32 %19, 0
%26 = select i1 %25, float* %1, float* %2
%27 = select i1 %25, float* %2, float* %1
switch i32 %21, label %66 [
i32 4, label %28
i32 2, label %39
i32 3, label %44
i32 5, label %52
]
28: ; preds = %15
%29 = add nsw i32 %24, %18
%30 = add nsw i32 %29, %24
%31 = sext i32 %18 to i64
%32 = getelementptr inbounds float, float* %3, i64 %31
%33 = sext i32 %29 to i64
%34 = getelementptr inbounds float, float* %3, i64 %33
%35 = sext i32 %30 to i64
%36 = getelementptr inbounds float, float* %3, i64 %35
%37 = call i32 @passf4(i32 %24, i32 %17, float* %26, float* %27, float* %32, float* %34, float* %36, i32 %5)
%38 = zext i1 %25 to i32
br label %75
39: ; preds = %15
%40 = sext i32 %18 to i64
%41 = getelementptr inbounds float, float* %3, i64 %40
%42 = call i32 @passf2(i32 %24, i32 %17, float* %26, float* %27, float* %41, i32 %5)
%43 = zext i1 %25 to i32
br label %75
44: ; preds = %15
%45 = add nsw i32 %24, %18
%46 = sext i32 %18 to i64
%47 = getelementptr inbounds float, float* %3, i64 %46
%48 = sext i32 %45 to i64
%49 = getelementptr inbounds float, float* %3, i64 %48
%50 = call i32 @passf3(i32 %24, i32 %17, float* %26, float* %27, float* %47, float* %49, i32 %5)
%51 = zext i1 %25 to i32
br label %75
52: ; preds = %15
%53 = add nsw i32 %24, %18
%54 = add nsw i32 %53, %24
%55 = add nsw i32 %54, %24
%56 = sext i32 %18 to i64
%57 = getelementptr inbounds float, float* %3, i64 %56
%58 = sext i32 %53 to i64
%59 = getelementptr inbounds float, float* %3, i64 %58
%60 = sext i32 %54 to i64
%61 = getelementptr inbounds float, float* %3, i64 %60
%62 = sext i32 %55 to i64
%63 = getelementptr inbounds float, float* %3, i64 %62
%64 = call i32 @passf5(i32 %24, i32 %17, float* %26, float* %27, float* %57, float* %59, float* %61, float* %63, i32 %5)
%65 = zext i1 %25 to i32
br label %75
66: ; preds = %15
%67 = mul nsw i32 %24, %17
%68 = sext i32 %18 to i64
%69 = getelementptr inbounds float, float* %3, i64 %68
%70 = call i32 @passf(i32* %7, i32 %24, i32 %21, i32 %17, i32 %67, float* %26, float* %27, float* %69, i32 %5)
%71 = load i32, i32* %7
%72 = icmp eq i32 %71, 0
%73 = zext i1 %25 to i32
%74 = select i1 %72, i32 %19, i32 %73
br label %75
75: ; preds = %66, %52, %44, %39, %28
%76 = phi i32 [ %65, %52 ], [ %51, %44 ], [ %43, %39 ], [ %38, %28 ], [ %74, %66 ]
%77 = add nsw i32 %21, -1
%78 = mul nsw i32 %24, %77
%79 = add nsw i32 %78, %18
%80 = add nuw nsw i64 %16, 1
%81 = icmp eq i64 %80, %14
br i1 %81, label %82, label %15
82: ; preds = %75
%83 = icmp ne i32 %76, 0
%84 = icmp sgt i32 %0, 0
%85 = and i1 %83, %84
br i1 %85, label %86, label %213
86: ; preds = %82
%87 = shl nuw i32 %0, 1
%88 = call i32 @llvm.smax.i32(i32 %87, i32 1)
%89 = zext i32 %88 to i64
%90 = icmp ult i32 %88, 8
br i1 %90, label %176, label %91
91: ; preds = %86
%92 = getelementptr float, float* %1, i64 %89
%93 = getelementptr float, float* %2, i64 %89
%94 = icmp ugt float* %93, %1
%95 = icmp ugt float* %92, %2
%96 = and i1 %94, %95
br i1 %96, label %176, label %97
97: ; preds = %91
%98 = and i64 %89, 2147483640
%99 = add nsw i64 %98, -8
%100 = lshr exact i64 %99, 3
%101 = add nuw nsw i64 %100, 1
%102 = and i64 %101, 3
%103 = icmp ult i64 %99, 24
br i1 %103, label %155, label %104
104: ; preds = %97
%105 = and i64 %101, 4611686018427387900
br label %106
106: ; preds = %106, %104
%107 = phi i64 [ 0, %104 ], [ %152, %106 ]
%108 = phi i64 [ 0, %104 ], [ %153, %106 ]
%109 = getelementptr inbounds float, float* %2, i64 %107
%110 = bitcast float* %109 to <4 x float>*
%111 = load <4 x float>, <4 x float>* %110
%112 = getelementptr inbounds float, float* %109, i64 4
%113 = bitcast float* %112 to <4 x float>*
%114 = load <4 x float>, <4 x float>* %113
%115 = getelementptr inbounds float, float* %1, i64 %107
%116 = bitcast float* %115 to <4 x float>*
store <4 x float> %111, <4 x float>* %116
%117 = getelementptr inbounds float, float* %115, i64 4
%118 = bitcast float* %117 to <4 x float>*
store <4 x float> %114, <4 x float>* %118
%119 = or i64 %107, 8
%120 = getelementptr inbounds float, float* %2, i64 %119
%121 = bitcast float* %120 to <4 x float>*
%122 = load <4 x float>, <4 x float>* %121
%123 = getelementptr inbounds float, float* %120, i64 4
%124 = bitcast float* %123 to <4 x float>*
%125 = load <4 x float>, <4 x float>* %124
%126 = getelementptr inbounds float, float* %1, i64 %119
%127 = bitcast float* %126 to <4 x float>*
store <4 x float> %122, <4 x float>* %127
%128 = getelementptr inbounds float, float* %126, i64 4
%129 = bitcast float* %128 to <4 x float>*
store <4 x float> %125, <4 x float>* %129
%130 = or i64 %107, 16
%131 = getelementptr inbounds float, float* %2, i64 %130
%132 = bitcast float* %131 to <4 x float>*
%133 = load <4 x float>, <4 x float>* %132
%134 = getelementptr inbounds float, float* %131, i64 4
%135 = bitcast float* %134 to <4 x float>*
%136 = load <4 x float>, <4 x float>* %135
%137 = getelementptr inbounds float, float* %1, i64 %130
%138 = bitcast float* %137 to <4 x float>*
store <4 x float> %133, <4 x float>* %138
%139 = getelementptr inbounds float, float* %137, i64 4
%140 = bitcast float* %139 to <4 x float>*
store <4 x float> %136, <4 x float>* %140
%141 = or i64 %107, 24
%142 = getelementptr inbounds float, float* %2, i64 %141
%143 = bitcast float* %142 to <4 x float>*
%144 = load <4 x float>, <4 x float>* %143
%145 = getelementptr inbounds float, float* %142, i64 4
%146 = bitcast float* %145 to <4 x float>*
%147 = load <4 x float>, <4 x float>* %146
%148 = getelementptr inbounds float, float* %1, i64 %141
%149 = bitcast float* %148 to <4 x float>*
store <4 x float> %144, <4 x float>* %149
%150 = getelementptr inbounds float, float* %148, i64 4
%151 = bitcast float* %150 to <4 x float>*
store <4 x float> %147, <4 x float>* %151
%152 = add nuw i64 %107, 32
%153 = add i64 %108, 4
%154 = icmp eq i64 %153, %105
br i1 %154, label %155, label %106
155: ; preds = %106, %97
%156 = phi i64 [ 0, %97 ], [ %152, %106 ]
%157 = icmp eq i64 %102, 0
br i1 %157, label %174, label %158
158: ; preds = %155, %158
%159 = phi i64 [ %171, %158 ], [ %156, %155 ]
%160 = phi i64 [ %172, %158 ], [ 0, %155 ]
%161 = getelementptr inbounds float, float* %2, i64 %159
%162 = bitcast float* %161 to <4 x float>*
%163 = load <4 x float>, <4 x float>* %162
%164 = getelementptr inbounds float, float* %161, i64 4
%165 = bitcast float* %164 to <4 x float>*
%166 = load <4 x float>, <4 x float>* %165
%167 = getelementptr inbounds float, float* %1, i64 %159
%168 = bitcast float* %167 to <4 x float>*
store <4 x float> %163, <4 x float>* %168
%169 = getelementptr inbounds float, float* %167, i64 4
%170 = bitcast float* %169 to <4 x float>*
store <4 x float> %166, <4 x float>* %170
%171 = add nuw i64 %159, 8
%172 = add i64 %160, 1
%173 = icmp eq i64 %172, %102
br i1 %173, label %174, label %158
174: ; preds = %158, %155
%175 = icmp eq i64 %98, %89
br i1 %175, label %213, label %176
176: ; preds = %91, %86, %174
%177 = phi i64 [ 0, %91 ], [ 0, %86 ], [ %98, %174 ]
%178 = xor i64 %177, -1
%179 = add nsw i64 %178, %89
%180 = and i64 %89, 3
%181 = icmp eq i64 %180, 0
br i1 %181, label %191, label %182
182: ; preds = %176, %182
%183 = phi i64 [ %188, %182 ], [ %177, %176 ]
%184 = phi i64 [ %189, %182 ], [ 0, %176 ]
%185 = getelementptr inbounds float, float* %2, i64 %183
%186 = load float, float* %185
%187 = getelementptr inbounds float, float* %1, i64 %183
store float %186, float* %187
%188 = add nuw nsw i64 %183, 1
%189 = add i64 %184, 1
%190 = icmp eq i64 %189, %180
br i1 %190, label %191, label %182
191: ; preds = %182, %176
%192 = phi i64 [ %177, %176 ], [ %188, %182 ]
%193 = icmp ult i64 %179, 3
br i1 %193, label %213, label %194
194: ; preds = %191, %194
%195 = phi i64 [ %211, %194 ], [ %192, %191 ]
%196 = getelementptr inbounds float, float* %2, i64 %195
%197 = load float, float* %196
%198 = getelementptr inbounds float, float* %1, i64 %195
store float %197, float* %198
%199 = add nuw nsw i64 %195, 1
%200 = getelementptr inbounds float, float* %2, i64 %199
%201 = load float, float* %200
%202 = getelementptr inbounds float, float* %1, i64 %199
store float %201, float* %202
%203 = add nuw nsw i64 %195, 2
%204 = getelementptr inbounds float, float* %2, i64 %203
%205 = load float, float* %204
%206 = getelementptr inbounds float, float* %1, i64 %203
store float %205, float* %206
%207 = add nuw nsw i64 %195, 3
%208 = getelementptr inbounds float, float* %2, i64 %207
%209 = load float, float* %208
%210 = getelementptr inbounds float, float* %1, i64 %207
store float %209, float* %210
%211 = add nuw nsw i64 %195, 4
%212 = icmp eq i64 %211, %89
br i1 %212, label %213, label %194
213: ; preds = %191, %194, %174, %6, %82
ret void
}