void realft(data, n, isign) double data[];
int n, isign;
{
  int i, i1, i2, i3, i4, n2p3;
  double c1 = 0.5, c2, h1r, h1i, h2r, h2i;
  double wr, wi, wpr, wpi, wtemp, theta;
  void four1();
  theta = 3.141592653589793 / (double)n;
  if (isign == 1) {
    c2 = -0.5;
    four1(data, n, 1);
  } else {
    c2 = 0.5;
    theta = -theta;
  }
  wtemp = sin(0.5 * theta);
  wpr = -2.0 * wtemp * wtemp;
  wpi = sin(theta);
  wr = 1.0 + wpr;
  wi = wpi;
  n2p3 = 2 * n + 3;
  for (i = 2; i <= n / 2; i++) {
    i4 = 1 + (i3 = n2p3 - (i2 = 1 + (i1 = i + i - 1)));
    h1r = c1 * (data[i1] + data[i3]);
    h1i = c1 * (data[i2] - data[i4]);
    h2r = -c2 * (data[i2] + data[i4]);
    h2i = c2 * (data[i1] - data[i3]);
    data[i1] = h1r + wr * h2r - wi * h2i;
    data[i2] = h1i + wr * h2i + wi * h2r;
    data[i3] = h1r - wr * h2r + wi * h2i;
    data[i4] = -h1i + wr * h2i + wi * h2r;
    wr = (wtemp = wr) * wpr - wi * wpi + wr;
    wi = wi * wpr + wtemp * wpi + wi;
  }
  if (isign == 1) {
    data[1] = (h1r = data[1]) + data[2];
    data[2] = h1r - data[2];
  } else {
    data[1] = c1 * ((h1r = data[1]) + data[2]);
    data[2] = c1 * (h1r - data[2]);
    four1(data, n, -1);
  }
}


x86 assembly (clang, -O0):
<realft>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movsd  0xecb(%rip),%xmm0
movsd  %xmm0,-0x30(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm1
movsd  0xeb1(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x1,-0x10(%rbp)
jne    118a <realft+0x6a>
movsd  0xea3(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    $0x1,%edx
mov    $0x0,%al
call   1030 <four1@plt>
jmp    11be <realft+0x9e>
movsd  0xe76(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0xe42(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  0xe40(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  0xe0f(%rip),%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0xc(%rbp),%eax
shl    $0x1,%eax
add    $0x3,%eax
mov    %eax,-0x28(%rbp)
movl   $0x2,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x8c(%rbp),%eax
cmp    %ecx,%eax
jg     14be <realft+0x39e>
mov    -0x28(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,-0x18(%rbp)
add    $0x1,%ecx
mov    %ecx,-0x1c(%rbp)
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movsd  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x60(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1230 <realft+0x110>
cmpl   $0x1,-0x10(%rbp)
jne    1504 <realft+0x3e4>
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
addsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
subsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x10(%rax)
jmp    1560 <realft+0x440>
movsd  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
movsd  %xmm1,-0x40(%rbp)
mov    -0x8(%rbp),%rax
addsd  0x10(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x30(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
subsd  0x10(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    $0xffffffff,%edx
mov    $0x0,%al
call   1030 <four1@plt>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<realft>:
push   %rbp
push   %r14
push   %rbx
sub    $0x30,%rsp
mov    %esi,%r14d
cvtsi2sd %esi,%xmm0
mov    %edx,%ebp
mov    %rdi,%rbx
movsd  0xec4(%rip),%xmm1
divsd  %xmm0,%xmm1
cmp    $0x1,%edx
jne    116b <realft+0x4b>
mov    %rbx,%rdi
mov    %r14d,%esi
mov    $0x1,%edx
xor    %eax,%eax
movapd %xmm1,(%rsp)
call   1030 <four1@plt>
movapd (%rsp),%xmm1
movsd  0xea7(%rip),%xmm0
jmp    117b <realft+0x5b>
xorpd  0xebd(%rip),%xmm1
movsd  0xe8d(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movapd %xmm1,(%rsp)
movsd  0xe7b(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x18(%rsp)
movapd (%rsp),%xmm0
call   1040 <sin@plt>
cmp    $0x4,%r14d
movapd 0x20(%rsp),%xmm12
jl     1314 <realft+0x1f4>
movsd  0xe58(%rip),%xmm10
movsd  0x18(%rsp),%xmm1
mulsd  %xmm1,%xmm10
mulsd  %xmm1,%xmm10
lea    (%r14,%r14,1),%eax
mov    %r14d,%ecx
shr    %ecx
movsd  0xe3f(%rip),%xmm3
addsd  %xmm10,%xmm3
movapd 0xe42(%rip),%xmm4
xorpd  %xmm12,%xmm4
shl    $0x4,%rcx
movapd %xmm0,%xmm11
unpcklpd %xmm3,%xmm11
unpcklpd %xmm4,%xmm12
unpcklpd %xmm10,%xmm10
unpcklpd %xmm0,%xmm0
add    $0xfffffffffffffff0,%rcx
xor    %edx,%edx
movapd 0xe22(%rip),%xmm8
movapd 0xe09(%rip),%xmm9
nopw   0x0(%rax,%rax,1)
lea    -0x1(%rax),%esi
movslq %esi,%rsi
cltq
movsd  (%rbx,%rsi,8),%xmm3
movhpd (%rbx,%rax,8),%xmm3
movupd 0x18(%rbx,%rdx,1),%xmm6
movapd %xmm6,%xmm4
addpd  %xmm3,%xmm4
subpd  %xmm3,%xmm6
movapd %xmm6,%xmm5
movsd  %xmm4,%xmm5
mulpd  %xmm8,%xmm5
shufpd $0x2,%xmm4,%xmm6
mulpd  %xmm12,%xmm6
movapd %xmm11,%xmm3
xorpd  %xmm9,%xmm3
movapd %xmm11,%xmm7
unpckhpd %xmm11,%xmm7
movapd %xmm6,%xmm4
shufpd $0x1,%xmm6,%xmm4
mulpd  %xmm7,%xmm4
addpd  %xmm5,%xmm4
movapd %xmm11,%xmm2
shufpd $0x1,%xmm3,%xmm2
unpcklpd %xmm11,%xmm3
mulpd  %xmm6,%xmm3
addpd  %xmm4,%xmm3
movapd %xmm7,%xmm4
movapd %xmm11,%xmm1
mulsd  %xmm6,%xmm1
mulsd  %xmm6,%xmm7
unpckhpd %xmm6,%xmm6
movupd %xmm3,0x18(%rbx,%rdx,1)
mulsd  %xmm6,%xmm4
movapd %xmm5,%xmm3
subsd  %xmm4,%xmm3
addsd  %xmm3,%xmm1
movsd  %xmm1,(%rbx,%rsi,8)
unpckhpd %xmm5,%xmm5
subsd  %xmm5,%xmm7
mulsd  %xmm11,%xmm6
addsd  %xmm7,%xmm6
movsd  %xmm6,(%rbx,%rax,8)
mulpd  %xmm0,%xmm2
movapd %xmm11,%xmm1
mulpd  %xmm10,%xmm1
addpd  %xmm2,%xmm1
addpd  %xmm1,%xmm11
add    $0xfffffffe,%eax
add    $0x10,%rdx
cmp    %rdx,%rcx
jne    1230 <realft+0x110>
movsd  0x8(%rbx),%xmm0
movsd  0x10(%rbx),%xmm2
movapd %xmm0,%xmm1
addsd  %xmm2,%xmm1
cmp    $0x1,%ebp
jne    1342 <realft+0x222>
movsd  %xmm1,0x8(%rbx)
subsd  %xmm2,%xmm0
movsd  %xmm0,0x10(%rbx)
add    $0x30,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret
subsd  %xmm2,%xmm0
unpcklpd %xmm0,%xmm1
mulpd  0xcee(%rip),%xmm1
movupd %xmm1,0x8(%rbx)
mov    %rbx,%rdi
mov    %r14d,%esi
mov    $0xffffffff,%edx
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbx
pop    %r14
pop    %rbp
jmp    1030 <four1@plt>

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

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