#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 */
float sin(float);
void FFT(float *data, unsigned long nn, int isign) {
  unsigned long n, mmax, m, j, istep, i;
  float wtemp, wr, wpr, wpi, wi, theta;
  float tempr, tempi;
  n = nn << 1;
  j = 1;
  for (i = 1; i < n; i += 2) {
    if (j > i) {
      tempr = (data[j - 1]);
      (data[j - 1]) = (data[i - 1]);
      (data[i - 1]) = tempr;
      tempr = (data[j]);
      (data[j]) = (data[i]);
      (data[i]) = tempr;
    }
    m = n >> 1;
    while ((m >= 2) && (j > m)) {
      j -= m;
      m >>= 1;
    }
    j += m;
  }
  mmax = 2;
  while (n > mmax) {
    istep = mmax << 1;
    theta = isign * (-2 * 3.14159264359 / mmax);
    wtemp = sin(0.5 * theta);
    wpr = -2.0 * wtemp * wtemp;
    wpi = sin(theta);
    wr = 1.0;
    wi = 0.0;
    for (m = 1; m < mmax; m += 2) {
      for (i = m; i <= n; i += istep) {
        j = i + mmax;
        tempr = wr * data[j - 1] - wi * data[j];
        tempi = wr * data[j] + wi * data[j - 1];
        data[j - 1] = data[i - 1] - tempr;
        data[j] = data[i] - tempi;
        data[i - 1] += tempr;
        data[i] += tempi;
      }
      wr = (wtemp = wr) * wpr - wi * wpi + wr;
      wi = wi * wpr + wtemp * wpi + wi;
    }
    mmax = istep;
  }
}


x86 assembly (clang, -O0):
<FFT>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x10(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x20(%rbp)
movq   $0x1,-0x38(%rbp)
movq   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    125e <FFT+0x14e>
mov    -0x38(%rbp),%rax
cmp    -0x48(%rbp),%rax
jbe    11e7 <FFT+0xd7>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x64(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x64(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x30(%rbp)
xor    %eax,%eax
cmpq   $0x2,-0x30(%rbp)
mov    %al,-0x69(%rbp)
jb     1211 <FFT+0x101>
mov    -0x38(%rbp),%rax
cmp    -0x30(%rbp),%rax
seta   %al
mov    %al,-0x69(%rbp)
mov    -0x69(%rbp),%al
test   $0x1,%al
jne    1221 <FFT+0x111>
jmp    1241 <FFT+0x131>
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    11f3 <FFT+0xe3>
mov    -0x30(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x48(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x48(%rbp)
jmp    113f <FFT+0x2f>
movq   $0x2,-0x28(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jbe    14ea <FFT+0x3da>
mov    -0x28(%rbp),%rax
add    %rax,%rax
mov    %rax,-0x40(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm0
movaps 0xd95(%rip),%xmm1
movq   -0x28(%rbp),%xmm2
punpckldq %xmm1,%xmm2
movapd 0xd94(%rip),%xmm1
subpd  %xmm1,%xmm2
movaps %xmm2,%xmm1
unpckhpd %xmm2,%xmm2
addsd  %xmm1,%xmm2
movsd  0xd65(%rip),%xmm1
divsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd3b(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1030 <sin@plt>
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd10(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x4c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x60(%rbp),%xmm0
call   1030 <sin@plt>
movss  %xmm0,-0x58(%rbp)
movss  0xcd7(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
movq   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    14dd <FFT+0x3cd>
mov    -0x30(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x20(%rbp),%rax
ja     146e <FFT+0x35e>
mov    -0x48(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x38(%rbp)
movss  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x5c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x5c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x64(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x64(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
jmp    1354 <FFT+0x244>
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x54(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x30(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x30(%rbp)
jmp    133e <FFT+0x22e>
mov    -0x40(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    1266 <FFT+0x156>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<FFT>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rsi,%r14
add    %rsi,%r14
je     134c <FFT+0x23c>
mov    %rdi,%rbx
movabs $0x7fffffffffffffff,%rax
ff ff 7f
and    %rax,%rsi
mov    $0x1,%eax
mov    $0x1,%r8d
jmp    115c <FFT+0x4c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    %rdi,%rax
add    $0x2,%r8
cmp    %r14,%r8
jae    11b6 <FFT+0xa6>
cmp    %r8,%rax
jbe    1191 <FFT+0x81>
movss  -0x4(%rbx,%rax,4),%xmm0
movss  -0x4(%rbx,%r8,4),%xmm1
movss  %xmm1,-0x4(%rbx,%rax,4)
movss  %xmm0,-0x4(%rbx,%r8,4)
movss  (%rbx,%rax,4),%xmm0
movss  (%rbx,%r8,4),%xmm1
movss  %xmm1,(%rbx,%rax,4)
movss  %xmm0,(%rbx,%r8,4)
mov    %rsi,%rdi
cmp    $0x2,%rsi
jb     1150 <FFT+0x40>
cmp    %rsi,%rax
jbe    1150 <FFT+0x40>
nop
mov    %rdi,%rcx
sub    %rdi,%rax
shr    %rdi
cmp    $0x4,%rcx
jb     1150 <FFT+0x40>
cmp    %rdi,%rax
ja     11a0 <FFT+0x90>
jmp    1150 <FFT+0x40>
cmp    $0x3,%r14
jb     134c <FFT+0x23c>
xorps  %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x2,%r15d
jmp    11e9 <FFT+0xd9>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %r15,%r14
jbe    134c <FFT+0x23c>
mov    %r15,%r12
add    %r15,%r15
movq   %r12,%xmm0
punpckldq 0xe04(%rip),%xmm0
subpd  0xe0c(%rip),%xmm0
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
addsd  %xmm0,%xmm1
movsd  0xe28(%rip),%xmm0
divsd  %xmm1,%xmm0
mulsd  0x10(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0xc(%rsp)
mulss  0xe1c(%rip),%xmm0
call   1030 <sin@plt>
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x20(%rsp)
mulsd  0xdfd(%rip),%xmm0
movsd  %xmm0,0x18(%rsp)
movss  0xc(%rsp),%xmm0
call   1030 <sin@plt>
movaps 0xdcc(%rip),%xmm9
test   %r12,%r12
je     11e0 <FFT+0xd0>
movsd  0x18(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
xorps  %xmm8,%xmm8
cvtsd2ss %xmm1,%xmm8
shufps $0x0,%xmm0,%xmm0
shufps $0x0,%xmm8,%xmm8
lea    (%rbx,%r12,4),%rax
mov    $0x1,%ecx
movaps 0xd85(%rip),%xmm1
jmp    12c5 <FFT+0x1b5>
nopl   (%rax)
shufps $0xd4,%xmm1,%xmm3
shufps $0x52,%xmm1,%xmm3
mulps  %xmm0,%xmm3
movaps %xmm1,%xmm2
mulps  %xmm8,%xmm2
addps  %xmm3,%xmm2
addps  %xmm2,%xmm1
add    $0x2,%rcx
cmp    %r12,%rcx
jae    11e0 <FFT+0xd0>
movaps %xmm1,%xmm3
xorps  %xmm9,%xmm3
cmp    %r14,%rcx
ja     12a0 <FFT+0x190>
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
mov    %rcx,%rdx
nopl   0x0(%rax,%rax,1)
movss  -0x4(%rax,%rdx,4),%xmm5
movss  (%rax,%rdx,4),%xmm6
movaps %xmm6,%xmm7
mulss  %xmm3,%xmm7
movaps %xmm2,%xmm4
mulss  %xmm5,%xmm4
addss  %xmm7,%xmm4
mulss  %xmm1,%xmm5
mulss  %xmm2,%xmm6
addss  %xmm5,%xmm6
movss  -0x4(%rbx,%rdx,4),%xmm5
subss  %xmm4,%xmm5
movss  %xmm5,-0x4(%rax,%rdx,4)
movss  (%rbx,%rdx,4),%xmm5
movaps %xmm5,%xmm7
subss  %xmm6,%xmm7
movss  %xmm7,(%rax,%rdx,4)
addss  -0x4(%rbx,%rdx,4),%xmm4
movss  %xmm4,-0x4(%rbx,%rdx,4)
addss  %xmm5,%xmm6
movss  %xmm6,(%rbx,%rdx,4)
add    %r15,%rdx
cmp    %r14,%rdx
jbe    12e0 <FFT+0x1d0>
jmp    12a0 <FFT+0x190>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

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