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


x86 assembly (clang, -O0):
<rfftb1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x1,-0x34(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1416 <rfftb1+0x2c6>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
imul   -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x4(%rbp),%eax
cltd
idivl  -0x38(%rbp)
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
imul   -0x34(%rbp),%eax
mov    %eax,-0x5c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
je     11f0 <rfftb1+0xa0>
mov    -0x18(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x70(%rbp)
jmp    1200 <rfftb1+0xb0>
mov    -0x10(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x44(%rbp),%eax
add    $0xfffffffe,%eax
mov    %eax,%ecx
mov    %rcx,-0x78(%rbp)
sub    $0x3,%eax
ja     13a6 <rfftb1+0x256>
mov    -0x78(%rbp),%rax
lea    0xde0(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x48(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x58(%rbp),%edi
mov    -0x34(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    -0x70(%rbp),%rcx
mov    -0x20(%rbp),%r8
movslq -0x48(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r8
mov    -0x20(%rbp),%r9
movslq -0x4c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r9
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%r10
shl    $0x2,%r10
add    %r10,%rax
mov    %rax,(%rsp)
call   1050 <radb4@plt>
cmpl   $0x0,-0x3c(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x3c(%rbp)
jmp    13f2 <rfftb1+0x2a2>
mov    -0x58(%rbp),%edi
mov    -0x34(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    -0x70(%rbp),%rcx
mov    -0x20(%rbp),%r8
movslq -0x48(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r8
call   1030 <radb2@plt>
cmpl   $0x0,-0x3c(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x3c(%rbp)
jmp    13f2 <rfftb1+0x2a2>
mov    -0x48(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x58(%rbp),%edi
mov    -0x34(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    -0x70(%rbp),%rcx
mov    -0x20(%rbp),%r8
movslq -0x48(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r8
mov    -0x20(%rbp),%r9
movslq -0x4c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r9
call   1060 <radb3@plt>
cmpl   $0x0,-0x3c(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x3c(%rbp)
jmp    13f2 <rfftb1+0x2a2>
mov    -0x48(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%edi
mov    -0x34(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    -0x70(%rbp),%rcx
mov    -0x20(%rbp),%r8
movslq -0x48(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r8
mov    -0x20(%rbp),%r9
movslq -0x4c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r9
mov    -0x20(%rbp),%r10
movslq -0x50(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r10
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%r11
shl    $0x2,%r11
add    %r11,%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1070 <radb5@plt>
cmpl   $0x0,-0x3c(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x3c(%rbp)
jmp    13f2 <rfftb1+0x2a2>
mov    -0x58(%rbp),%edi
mov    -0x44(%rbp),%esi
mov    -0x34(%rbp),%edx
mov    -0x5c(%rbp),%ecx
mov    -0x68(%rbp),%r8
mov    -0x70(%rbp),%r9
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%r10
shl    $0x2,%r10
add    %r10,%rax
mov    %rax,(%rsp)
call   1040 <radbg@plt>
cmpl   $0x1,-0x58(%rbp)
jne    13ed <rfftb1+0x29d>
cmpl   $0x0,-0x3c(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x3c(%rbp)
jmp    13f2 <rfftb1+0x2a2>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
imul   -0x58(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1194 <rfftb1+0x44>
cmpl   $0x0,-0x3c(%rbp)
jne    1425 <rfftb1+0x2d5>
jmp    1460 <rfftb1+0x310>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1460 <rfftb1+0x310>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    142c <rfftb1+0x2dc>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rfftb1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rcx,0x18(%rsp)
mov    %edi,0x14(%rsp)
mov    %r8,0x40(%rsp)
mov    0x4(%r8),%eax
mov    %rax,0x38(%rsp)
test   %eax,%eax
jle    14e4 <rfftb1+0x394>
mov    %rdx,%r9
xor    %r14d,%r14d
mov    $0x1,%r10d
xor    %r12d,%r12d
xor    %r13d,%r13d
mov    %rdx,0x30(%rsp)
mov    %rsi,0x28(%rsp)
jmp    1208 <rfftb1+0xb8>
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
test   %r13d,%r13d
sete   %cl
mov    %ecx,0x20(%rsp)
mov    %r15d,%ecx
imul   %r10d,%ecx
movslq %r12d,%rdx
mov    0x18(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
mov    %rdx,(%rsp)
mov    %r15d,%edi
mov    %ebx,%esi
mov    %r10d,%edx
mov    %rax,%r8
mov    %rbp,%r9
call   1040 <radbg@plt>
cmp    $0x1,%r15d
cmove  0x20(%rsp),%r13d
add    $0xffffffff,%ebx
imul   %r15d,%ebx
add    %ebx,%r12d
add    $0x1,%r14
cmp    %r14,0x38(%rsp)
mov    0x30(%rsp),%r9
mov    0x28(%rsp),%rsi
mov    0x24(%rsp),%r10d
je     1366 <rfftb1+0x216>
mov    0x40(%rsp),%rax
mov    0x8(%rax,%r14,4),%ebx
mov    %ebx,%ecx
imul   %r10d,%ecx
mov    0x14(%rsp),%eax
cltd
mov    %ecx,0x24(%rsp)
idiv   %ecx
mov    %eax,%r15d
test   %r13d,%r13d
mov    %r9,%rax
cmove  %rsi,%rax
mov    %rsi,%rbp
cmove  %r9,%rbp
lea    -0x2(%rbx),%ecx
cmp    $0x3,%ecx
ja     11a0 <rfftb1+0x50>
lea    0xdb6(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
xor    %ecx,%ecx
test   %r13d,%r13d
sete   %cl
mov    %ecx,%r13d
movslq %r12d,%rcx
mov    0x18(%rsp),%rdx
lea    (%rdx,%rcx,4),%r8
mov    %r15d,%edi
mov    %r10d,%esi
mov    %rax,%rdx
mov    %rbp,%rcx
call   1030 <radb2@plt>
jmp    11e0 <rfftb1+0x90>
xor    %ecx,%ecx
test   %r13d,%r13d
sete   %cl
mov    %ecx,%r13d
lea    (%r15,%r12,1),%ecx
movslq %r12d,%rdx
mov    0x18(%rsp),%rsi
lea    (%rsi,%rdx,4),%r8
movslq %ecx,%rcx
lea    (%rsi,%rcx,4),%r9
mov    %r15d,%edi
mov    %r10d,%esi
mov    %rax,%rdx
mov    %rbp,%rcx
call   1060 <radb3@plt>
jmp    11e0 <rfftb1+0x90>
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
test   %r13d,%r13d
sete   %cl
mov    %ecx,%r13d
lea    (%r15,%r12,1),%ecx
movslq %r12d,%rdx
mov    0x18(%rsp),%rsi
lea    (%rsi,%rdx,4),%r8
movslq %ecx,%rdx
add    %r15d,%ecx
lea    (%rsi,%rdx,4),%r9
movslq %ecx,%rcx
lea    (%rsi,%rcx,4),%rcx
mov    %rcx,(%rsp)
mov    %r15d,%edi
mov    %r10d,%esi
mov    %rax,%rdx
mov    %rbp,%rcx
call   1050 <radb4@plt>
jmp    11e0 <rfftb1+0x90>
cs nopw 0x0(%rax,%rax,1)
xor    %ecx,%ecx
test   %r13d,%r13d
sete   %cl
mov    %ecx,%r13d
lea    (%r15,%r12,1),%ecx
lea    (%rcx,%r15,1),%edx
movslq %r12d,%rsi
mov    0x18(%rsp),%rdi
lea    (%rdi,%rsi,4),%r8
movslq %ecx,%rcx
lea    (%rdi,%rcx,4),%r9
movslq %edx,%rcx
add    %r15d,%edx
lea    (%rdi,%rcx,4),%rcx
movslq %edx,%rdx
lea    (%rdi,%rdx,4),%rdx
mov    %rcx,(%rsp)
mov    %rdx,0x8(%rsp)
mov    %r15d,%edi
mov    %r10d,%esi
mov    %rax,%rdx
mov    %rbp,%rcx
call   1070 <radb5@plt>
jmp    11e0 <rfftb1+0x90>
test   %r13d,%r13d
je     14e4 <rfftb1+0x394>
cmpl   $0x0,0x14(%rsp)
jle    14e4 <rfftb1+0x394>
mov    0x14(%rsp),%ecx
mov    %ecx,%eax
cmp    $0x8,%ecx
jb     139b <rfftb1+0x24b>
lea    (%r9,%rax,4),%rcx
cmp    %rsi,%rcx
jbe    1410 <rfftb1+0x2c0>
lea    (%rsi,%rax,4),%rcx
cmp    %r9,%rcx
jbe    1410 <rfftb1+0x2c0>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rdi
and    $0x3,%rdi
je     13c5 <rfftb1+0x275>
nop
movss  (%r9,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    13b0 <rfftb1+0x260>
cmp    $0x3,%rdx
jb     14e4 <rfftb1+0x394>
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    13d0 <rfftb1+0x280>
jmp    14e4 <rfftb1+0x394>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ebx
and    $0x3,%ebx
cmp    $0x18,%rdi
jae    1433 <rfftb1+0x2e3>
xor    %edi,%edi
jmp    14a0 <rfftb1+0x350>
and    $0xfffffffffffffffc,%rdx
xor    %edi,%edi
nopl   0x0(%rax)
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    1440 <rfftb1+0x2f0>
test   %rbx,%rbx
je     14db <rfftb1+0x38b>
lea    (%rsi,%rdi,4),%rdx
add    $0x10,%rdx
lea    (%r9,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rbx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdx,%rbp,1)
movups %xmm1,(%rdx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rbx
jne    14c0 <rfftb1+0x370>
cmp    %rax,%rcx
jne    139d <rfftb1+0x24d>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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