#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 pow(float, int);
float sin(float);
void rfft(float *x, int N, int forward) {
  float c1, c2, h1r, h1i, h2r, h2i, wr, wi, wpr, wpi, temp, theta;
  float xr, xi;
  int i, i1, i2, i3, i4, N2p1;
  static int first = 1;
  void cfft();
  if (first) {
    first = 0;
  }
  theta = 3.141592653589793115997963468544185161590576171875 / N;
  wr = 1.;
  wi = 0.;
  c1 = 0.5;
  if (forward) {
    c2 = -0.5;
    cfft(x, N, forward);
    xr = x[0];
    xi = x[1];
  } else {
    c2 = 0.5;
    theta = -theta;
    xr = x[1];
    xi = 0.;
    x[1] = 0.;
  }
  wpr = -2. * pow(sin(0.5 * theta), 2.);
  wpi = sin(theta);
  N2p1 = (N << 1) + 1;
  for (i = 0; i <= N >> 1; i++) {
    i1 = i << 1;
    i2 = i1 + 1;
    i3 = N2p1 - i2;
    i4 = i3 + 1;
    if (i == 0) {
      h1r = c1 * (x[i1] + xr);
      h1i = c1 * (x[i2] - xi);
      h2r = -c2 * (x[i2] + xi);
      h2i = c2 * (x[i1] - xr);
      x[i1] = h1r + wr * h2r - wi * h2i;
      x[i2] = h1i + wr * h2i + wi * h2r;
      xr = h1r - wr * h2r + wi * h2i;
      xi = -h1i + wr * h2i + wi * h2r;
    } else {
      h1r = c1 * (x[i1] + x[i3]);
      h1i = c1 * (x[i2] - x[i4]);
      h2r = -c2 * (x[i2] + x[i4]);
      h2i = c2 * (x[i1] - x[i3]);
      x[i1] = h1r + wr * h2r - wi * h2i;
      x[i2] = h1i + wr * h2i + wi * h2r;
      x[i3] = h1r - wr * h2r + wi * h2i;
      x[i4] = -h1i + wr * h2i + wi * h2r;
    }
    wr = (temp = wr) * wpr - wi * wpi + wr;
    wi = wi * wpr + temp * wpi + wi;
  }
  if (forward)
    x[1] = xr;
  else
    cfft(x, N, forward);
}


x86 assembly (clang, -O0):
<rfft>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
cmpl   $0x0,0x2eef(%rip)
je     1159 <rfft+0x29>
movl   $0x0,0x2edf(%rip)
cvtsi2sdl -0xc(%rbp),%xmm1
movsd  0xeaa(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  0xe89(%rip),%xmm0
movss  %xmm0,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  0xe70(%rip),%xmm0
movss  %xmm0,-0x14(%rbp)
cmpl   $0x0,-0x10(%rbp)
je     11dd <rfft+0xad>
movss  0xe61(%rip),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    $0x0,%al
call   1030 <cfft@plt>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
jmp    1223 <rfft+0xf3>
movss  0xe1b(%rip),%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x40(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xdec(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1040 <sin@plt>
mov    $0x2,%edi
call   1050 <pow@plt>
cvtsi2sd %eax,%xmm1
movsd  0xdc1(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x40(%rbp),%xmm0
call   1040 <sin@plt>
movss  %xmm0,-0x38(%rbp)
mov    -0xc(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sar    $0x1,%ecx
cmp    %ecx,%eax
jg     165e <rfft+0x52e>
mov    -0x4c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x60(%rbp),%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    1446 <rfft+0x316>
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
addss  -0x44(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
subss  -0x48(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x18(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
addss  -0x48(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
subss  -0x44(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x1c(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  -0x28(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x2c(%rbp),%xmm1
movss  -0x28(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
jmp    15f2 <rfft+0x4c2>
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x18(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x1c(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  -0x28(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x2c(%rbp),%xmm1
movss  -0x28(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x34(%rbp),%xmm2
movss  -0x30(%rbp),%xmm1
mulss  -0x38(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x30(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x38(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1286 <rfft+0x156>
cmpl   $0x0,-0x10(%rbp)
je     167b <rfft+0x54b>
movss  -0x44(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
jmp    168c <rfft+0x55c>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    $0x0,%al
call   1030 <cfft@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rfft>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x38,%rsp
mov    %edx,%r15d
mov    %esi,%r14d
mov    %rdi,%rbx
cmpb   $0x0,0x2ef2(%rip)
jne    1153 <rfft+0x23>
movb   $0x1,0x2ee9(%rip)
cvtsi2sd %r14d,%xmm0
movsd  0xea0(%rip),%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
test   %r15d,%r15d
je     1197 <rfft+0x67>
mov    %rbx,%rdi
mov    %r14d,%esi
mov    %r15d,%edx
xor    %eax,%eax
movaps %xmm0,0x10(%rsp)
call   1030 <cfft@plt>
movsd  (%rbx),%xmm0
movaps %xmm0,(%rsp)
movss  0xe7b(%rip),%xmm0
jmp    11bb <rfft+0x8b>
xorps  0xe82(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movss  0x4(%rbx),%xmm0
movaps %xmm0,(%rsp)
movl   $0x0,0x4(%rbx)
movss  0xe59(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movss  0xe4c(%rip),%xmm0
mulss  0x10(%rsp),%xmm0
call   1040 <sin@plt>
mov    $0x2,%edi
call   1050 <pow@plt>
mov    %eax,%ebp
movaps 0x10(%rsp),%xmm0
call   1040 <sin@plt>
test   %r14d,%r14d
js     13f4 <rfft+0x2c4>
lea    (%r14,%r14,1),%ecx
xorps  %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
mulsd  0xe03(%rip),%xmm1
cvtsd2ss %xmm1,%xmm11
mov    %r14d,%eax
and    $0xfffffffe,%eax
movaps 0xe08(%rip),%xmm9
movaps 0x20(%rsp),%xmm8
xorps  %xmm8,%xmm9
unpcklps %xmm9,%xmm8
shufps $0x0,%xmm11,%xmm11
shufps $0x0,%xmm0,%xmm0
mov    %ecx,%ecx
add    $0x2,%rax
movss  0xdda(%rip),%xmm13
xor    %edx,%edx
movss  0xdcb(%rip),%xmm12
movaps 0xdcf(%rip),%xmm10
mov    %rbx,%rsi
jmp    1340 <rfft+0x210>
nopl   0x0(%rax)
lea    (%rcx,%rdx,1),%rdi
lea    (%rcx,%rdx,1),%ebp
add    $0x1,%ebp
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm4
movss  (%rsi),%xmm2
movss  0x4(%rsi),%xmm6
movaps %xmm2,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm12,%xmm3
movslq %ebp,%rbp
movss  (%rbx,%rbp,4),%xmm5
movaps %xmm6,%xmm15
subss  %xmm5,%xmm15
mulss  %xmm12,%xmm15
addss  %xmm5,%xmm6
mulss  %xmm9,%xmm6
subss  %xmm4,%xmm2
mulss  0x20(%rsp),%xmm2
movaps %xmm13,%xmm14
mulss  %xmm6,%xmm14
movaps %xmm14,%xmm5
addss  %xmm3,%xmm5
movaps %xmm13,%xmm7
shufps $0x55,%xmm13,%xmm7
movaps %xmm7,%xmm4
xorps  %xmm10,%xmm4
movaps %xmm7,%xmm1
mulss  %xmm2,%xmm1
subss  %xmm1,%xmm5
movss  %xmm5,(%rsi)
mulss  %xmm13,%xmm2
movaps %xmm2,%xmm5
addss  %xmm15,%xmm5
mulss  %xmm6,%xmm7
addss  %xmm7,%xmm5
movss  %xmm5,0x4(%rsi)
subss  %xmm14,%xmm3
addss  %xmm1,%xmm3
movss  %xmm3,(%rbx,%rdi,4)
subss  %xmm15,%xmm2
addss  %xmm7,%xmm2
movss  %xmm2,(%rbx,%rbp,4)
unpcklps %xmm13,%xmm4
mulps  %xmm0,%xmm4
movaps %xmm13,%xmm1
mulps  %xmm11,%xmm1
addps  %xmm4,%xmm1
addps  %xmm1,%xmm13
add    $0xfffffffffffffffe,%rdx
add    $0x8,%rsi
mov    %rax,%rdi
add    %rdx,%rdi
je     13f4 <rfft+0x2c4>
test   %rdx,%rdx
jne    1260 <rfft+0x130>
movsd  (%rsi),%xmm6
movaps (%rsp),%xmm1
movaps %xmm1,%xmm3
addps  %xmm6,%xmm3
subps  %xmm1,%xmm6
movaps %xmm3,%xmm14
mulss  %xmm12,%xmm14
shufps $0x1,%xmm6,%xmm3
shufps $0xe2,%xmm6,%xmm3
shufps $0x55,%xmm6,%xmm6
mulss  %xmm12,%xmm6
mulps  %xmm8,%xmm3
movaps %xmm3,%xmm5
shufps $0x55,%xmm3,%xmm5
movaps %xmm13,%xmm7
mulss  %xmm5,%xmm7
addss  %xmm14,%xmm7
movaps %xmm13,%xmm2
shufps $0x55,%xmm13,%xmm2
movaps %xmm2,%xmm4
xorps  %xmm10,%xmm4
movaps %xmm2,%xmm1
mulss  %xmm3,%xmm1
subss  %xmm1,%xmm7
movss  %xmm7,(%rsi)
movaps %xmm13,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm6,%xmm1
mulss  %xmm2,%xmm5
addss  %xmm1,%xmm5
movss  %xmm5,0x4(%rsi)
movaps %xmm13,%xmm1
xorps  %xmm10,%xmm1
xorps  %xmm10,%xmm6
unpcklps %xmm13,%xmm1
mulps  %xmm3,%xmm2
shufps $0xe1,%xmm3,%xmm3
mulps  %xmm1,%xmm3
unpcklps %xmm6,%xmm14
addps  %xmm3,%xmm14
addps  %xmm2,%xmm14
movaps %xmm14,(%rsp)
jmp    1316 <rfft+0x1e6>
test   %r15d,%r15d
je     140d <rfft+0x2dd>
movaps (%rsp),%xmm0
movss  %xmm0,0x4(%rbx)
add    $0x38,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rbx,%rdi
mov    %r14d,%esi
xor    %edx,%edx
xor    %eax,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <cfft@plt>

LLVM IR (-O0):
@rfft.first = internal global i32 1
define void @rfft(float* %0, i32 %1, i32 %2) {
%4 = alloca float*
%5 = alloca i32
%6 = alloca i32
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
store float* %0, float** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%27 = load i32, i32* @rfft.first
%28 = icmp ne i32 %27, 0
br i1 %28, label %29, label %30
29: ; preds = %3
store i32 0, i32* @rfft.first
br label %30
30: ; preds = %29, %3
%31 = load i32, i32* %5
%32 = sitofp i32 %31 to double
%33 = fdiv double 0x400921FB54442D18, %32
%34 = fptrunc double %33 to float
store float %34, float* %18
store float 1.000000e+00, float* %13
store float 0.000000e+00, float* %14
store float 5.000000e-01, float* %7
%35 = load i32, i32* %6
%36 = icmp ne i32 %35, 0
br i1 %36, label %37, label %47
37: ; preds = %30
store float -5.000000e-01, float* %8
%38 = load float*, float** %4
%39 = load i32, i32* %5
%40 = load i32, i32* %6
%41 = load float*, float** %4
%42 = getelementptr inbounds float, float* %41, i64 0
%43 = load float, float* %42
store float %43, float* %19
%44 = load float*, float** %4
%45 = getelementptr inbounds float, float* %44, i64 1
%46 = load float, float* %45
store float %46, float* %20
br label %55
47: ; preds = %30
store float 5.000000e-01, float* %8
%48 = load float, float* %18
%49 = fneg float %48
store float %49, float* %18
%50 = load float*, float** %4
%51 = getelementptr inbounds float, float* %50, i64 1
%52 = load float, float* %51
store float %52, float* %19
store float 0.000000e+00, float* %20
%53 = load float*, float** %4
%54 = getelementptr inbounds float, float* %53, i64 1
store float 0.000000e+00, float* %54
br label %55
55: ; preds = %47, %37
%56 = load float, float* %18
%57 = fpext float %56 to double
%58 = fmul double 5.000000e-01, %57
%59 = fptrunc double %58 to float
%60 = call float @sin(float %59)
%61 = call i32 @pow(float %60, i32 2)
%62 = sitofp i32 %61 to double
%63 = fmul double -2.000000e+00, %62
%64 = fptrunc double %63 to float
store float %64, float* %15
%65 = load float, float* %18
%66 = call float @sin(float %65)
store float %66, float* %16
%67 = load i32, i32* %5
%68 = shl i32 %67, 1
%69 = add nsw i32 %68, 1
store i32 %69, i32* %26
store i32 0, i32* %21
br label %70
70: ; preds = %283, %55
%71 = load i32, i32* %21
%72 = load i32, i32* %5
%73 = ashr i32 %72, 1
%74 = icmp sle i32 %71, %73
br i1 %74, label %75, label %286
75: ; preds = %70
%76 = load i32, i32* %21
%77 = shl i32 %76, 1
store i32 %77, i32* %22
%78 = load i32, i32* %22
%79 = add nsw i32 %78, 1
store i32 %79, i32* %23
%80 = load i32, i32* %26
%81 = load i32, i32* %23
%82 = sub nsw i32 %80, %81
store i32 %82, i32* %24
%83 = load i32, i32* %24
%84 = add nsw i32 %83, 1
store i32 %84, i32* %25
%85 = load i32, i32* %21
%86 = icmp eq i32 %85, 0
br i1 %86, label %87, label %164
87: ; preds = %75
%88 = load float, float* %7
%89 = load float*, float** %4
%90 = load i32, i32* %22
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds float, float* %89, i64 %91
%93 = load float, float* %92
%94 = load float, float* %19
%95 = fadd float %93, %94
%96 = fmul float %88, %95
store float %96, float* %9
%97 = load float, float* %7
%98 = load float*, float** %4
%99 = load i32, i32* %23
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds float, float* %98, i64 %100
%102 = load float, float* %101
%103 = load float, float* %20
%104 = fsub float %102, %103
%105 = fmul float %97, %104
store float %105, float* %10
%106 = load float, float* %8
%107 = fneg float %106
%108 = load float*, float** %4
%109 = load i32, i32* %23
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds float, float* %108, i64 %110
%112 = load float, float* %111
%113 = load float, float* %20
%114 = fadd float %112, %113
%115 = fmul float %107, %114
store float %115, float* %11
%116 = load float, float* %8
%117 = load float*, float** %4
%118 = load i32, i32* %22
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds float, float* %117, i64 %119
%121 = load float, float* %120
%122 = load float, float* %19
%123 = fsub float %121, %122
%124 = fmul float %116, %123
store float %124, float* %12
%125 = load float, float* %9
%126 = load float, float* %13
%127 = load float, float* %11
%128 = call float @llvm.fmuladd.f32(float %126, float %127, float %125)
%129 = load float, float* %14
%130 = load float, float* %12
%131 = fneg float %129
%132 = call float @llvm.fmuladd.f32(float %131, float %130, float %128)
%133 = load float*, float** %4
%134 = load i32, i32* %22
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds float, float* %133, i64 %135
store float %132, float* %136
%137 = load float, float* %10
%138 = load float, float* %13
%139 = load float, float* %12
%140 = call float @llvm.fmuladd.f32(float %138, float %139, float %137)
%141 = load float, float* %14
%142 = load float, float* %11
%143 = call float @llvm.fmuladd.f32(float %141, float %142, float %140)
%144 = load float*, float** %4
%145 = load i32, i32* %23
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds float, float* %144, i64 %146
store float %143, float* %147
%148 = load float, float* %9
%149 = load float, float* %13
%150 = load float, float* %11
%151 = fneg float %149
%152 = call float @llvm.fmuladd.f32(float %151, float %150, float %148)
%153 = load float, float* %14
%154 = load float, float* %12
%155 = call float @llvm.fmuladd.f32(float %153, float %154, float %152)
store float %155, float* %19
%156 = load float, float* %10
%157 = fneg float %156
%158 = load float, float* %13
%159 = load float, float* %12
%160 = call float @llvm.fmuladd.f32(float %158, float %159, float %157)
%161 = load float, float* %14
%162 = load float, float* %11
%163 = call float @llvm.fmuladd.f32(float %161, float %162, float %160)
store float %163, float* %20
br label %265
164: ; preds = %75
%165 = load float, float* %7
%166 = load float*, float** %4
%167 = load i32, i32* %22
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds float, float* %166, i64 %168
%170 = load float, float* %169
%171 = load float*, float** %4
%172 = load i32, i32* %24
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds float, float* %171, i64 %173
%175 = load float, float* %174
%176 = fadd float %170, %175
%177 = fmul float %165, %176
store float %177, float* %9
%178 = load float, float* %7
%179 = load float*, float** %4
%180 = load i32, i32* %23
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds float, float* %179, i64 %181
%183 = load float, float* %182
%184 = load float*, float** %4
%185 = load i32, i32* %25
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds float, float* %184, i64 %186
%188 = load float, float* %187
%189 = fsub float %183, %188
%190 = fmul float %178, %189
store float %190, float* %10
%191 = load float, float* %8
%192 = fneg float %191
%193 = load float*, float** %4
%194 = load i32, i32* %23
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds float, float* %193, i64 %195
%197 = load float, float* %196
%198 = load float*, float** %4
%199 = load i32, i32* %25
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds float, float* %198, i64 %200
%202 = load float, float* %201
%203 = fadd float %197, %202
%204 = fmul float %192, %203
store float %204, float* %11
%205 = load float, float* %8
%206 = load float*, float** %4
%207 = load i32, i32* %22
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds float, float* %206, i64 %208
%210 = load float, float* %209
%211 = load float*, float** %4
%212 = load i32, i32* %24
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds float, float* %211, i64 %213
%215 = load float, float* %214
%216 = fsub float %210, %215
%217 = fmul float %205, %216
store float %217, float* %12
%218 = load float, float* %9
%219 = load float, float* %13
%220 = load float, float* %11
%221 = call float @llvm.fmuladd.f32(float %219, float %220, float %218)
%222 = load float, float* %14
%223 = load float, float* %12
%224 = fneg float %222
%225 = call float @llvm.fmuladd.f32(float %224, float %223, float %221)
%226 = load float*, float** %4
%227 = load i32, i32* %22
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds float, float* %226, i64 %228
store float %225, float* %229
%230 = load float, float* %10
%231 = load float, float* %13
%232 = load float, float* %12
%233 = call float @llvm.fmuladd.f32(float %231, float %232, float %230)
%234 = load float, float* %14
%235 = load float, float* %11
%236 = call float @llvm.fmuladd.f32(float %234, float %235, float %233)
%237 = load float*, float** %4
%238 = load i32, i32* %23
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds float, float* %237, i64 %239
store float %236, float* %240
%241 = load float, float* %9
%242 = load float, float* %13
%243 = load float, float* %11
%244 = fneg float %242
%245 = call float @llvm.fmuladd.f32(float %244, float %243, float %241)
%246 = load float, float* %14
%247 = load float, float* %12
%248 = call float @llvm.fmuladd.f32(float %246, float %247, float %245)
%249 = load float*, float** %4
%250 = load i32, i32* %24
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds float, float* %249, i64 %251
store float %248, float* %252
%253 = load float, float* %10
%254 = fneg float %253
%255 = load float, float* %13
%256 = load float, float* %12
%257 = call float @llvm.fmuladd.f32(float %255, float %256, float %254)
%258 = load float, float* %14
%259 = load float, float* %11
%260 = call float @llvm.fmuladd.f32(float %258, float %259, float %257)
%261 = load float*, float** %4
%262 = load i32, i32* %25
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds float, float* %261, i64 %263
store float %260, float* %264
br label %265
265: ; preds = %164, %87
%266 = load float, float* %13
store float %266, float* %17
%267 = load float, float* %15
%268 = load float, float* %14
%269 = load float, float* %16
%270 = fmul float %268, %269
%271 = fneg float %270
%272 = call float @llvm.fmuladd.f32(float %266, float %267, float %271)
%273 = load float, float* %13
%274 = fadd float %272, %273
store float %274, float* %13
%275 = load float, float* %14
%276 = load float, float* %15
%277 = load float, float* %17
%278 = load float, float* %16
%279 = fmul float %277, %278
%280 = call float @llvm.fmuladd.f32(float %275, float %276, float %279)
%281 = load float, float* %14
%282 = fadd float %280, %281
store float %282, float* %14
br label %283
283: ; preds = %265
%284 = load i32, i32* %21
%285 = add nsw i32 %284, 1
store i32 %285, i32* %21
br label %70
286: ; preds = %70
%287 = load i32, i32* %6
%288 = icmp ne i32 %287, 0
br i1 %288, label %289, label %293
289: ; preds = %286
%290 = load float, float* %19
%291 = load float*, float** %4
%292 = getelementptr inbounds float, float* %291, i64 1
store float %290, float* %292
br label %297
293: ; preds = %286
%294 = load float*, float** %4
%295 = load i32, i32* %5
%296 = load i32, i32* %6
br label %297
297: ; preds = %293, %289
ret void
}

LLVM IR (-O2):
@rfft.first = internal unnamed_addr global i1 false
define void @rfft(float* %0, i32 %1, i32 %2) {
%4 = load i1, i1* @rfft.first
br i1 %4, label %6, label %5
5: ; preds = %3
store i1 true, i1* @rfft.first
br label %6
6: ; preds = %5, %3
%7 = sitofp i32 %1 to double
%8 = fdiv double 0x400921FB54442D18, %7
%9 = fptrunc double %8 to float
%10 = icmp eq i32 %2, 0
br i1 %10, label %14, label %11
11: ; preds = %6
tail call void (float*, i32, i32, ...) bitcast (void (...)* @cfft to void (float*, i32, i32, ...)*)(float* %0, i32 %1, i32 %2)
%12 = bitcast float* %0 to <2 x float>*
%13 = load <2 x float>, <2 x float>* %12
br label %19
14: ; preds = %6
%15 = fneg float %9
%16 = getelementptr inbounds float, float* %0, i64 1
%17 = load float, float* %16
store float 0.000000e+00, float* %16
%18 = insertelement <2 x float> <float poison, float 0.000000e+00>, float %17, i64 0
br label %19
19: ; preds = %14, %11
%20 = phi float [ %9, %11 ], [ %15, %14 ]
%21 = phi float [ -5.000000e-01, %11 ], [ 5.000000e-01, %14 ]
%22 = phi <2 x float> [ %13, %11 ], [ %18, %14 ]
%23 = fmul float %20, 5.000000e-01
%24 = tail call float @sin(float %23)
%25 = tail call i32 @pow(float %24, i32 2)
%26 = tail call float @sin(float %20)
%27 = shl i32 %1, 1
%28 = or i32 %27, 1
%29 = icmp slt i32 %1, 0
%30 = extractelement <2 x float> %22, i64 0
br i1 %29, label %133, label %31
31: ; preds = %19
%32 = sitofp i32 %25 to double
%33 = fmul double %32, -2.000000e+00
%34 = fptrunc double %33 to float
%35 = lshr i32 %1, 1
%36 = fneg float %21
%37 = add nuw nsw i32 %35, 1
%38 = zext i32 %37 to i64
%39 = insertelement <2 x float> poison, float %21, i64 0
%40 = insertelement <2 x float> %39, float %36, i64 1
%41 = insertelement <2 x float> poison, float %34, i64 0
%42 = shufflevector <2 x float> %41, <2 x float> poison, <2 x i32> zeroinitializer
%43 = insertelement <2 x float> poison, float %26, i64 0
%44 = shufflevector <2 x float> %43, <2 x float> poison, <2 x i32> zeroinitializer
br label %45
45: ; preds = %31, %121
%46 = phi i64 [ 0, %31 ], [ %129, %121 ]
%47 = phi <2 x float> [ %22, %31 ], [ %123, %121 ]
%48 = phi <2 x float> [ <float 1.000000e+00, float 0.000000e+00>, %31 ], [ %128, %121 ]
%49 = shl nuw i64 %46, 1
%50 = or i64 %49, 1
%51 = trunc i64 %50 to i32
%52 = sub i32 %28, %51
%53 = icmp eq i64 %46, 0
br i1 %53, label %54, label %88
54: ; preds = %45
%55 = getelementptr inbounds float, float* %0, i64 %49
%56 = getelementptr inbounds float, float* %0, i64 %50
%57 = bitcast float* %55 to <2 x float>*
%58 = load <2 x float>, <2 x float>* %57
%59 = fadd <2 x float> %47, %58
%60 = extractelement <2 x float> %59, i64 0
%61 = fmul float %60, 5.000000e-01
%62 = fsub <2 x float> %58, %47
%63 = extractelement <2 x float> %62, i64 1
%64 = fmul float %63, 5.000000e-01
%65 = fadd <2 x float> %58, %47
%66 = fsub <2 x float> %58, %47
%67 = shufflevector <2 x float> %66, <2 x float> %65, <2 x i32> <i32 0, i32 3>
%68 = fmul <2 x float> %67, %40
%69 = extractelement <2 x float> %68, i64 1
%70 = extractelement <2 x float> %48, i64 0
%71 = tail call float @llvm.fmuladd.f32(float %70, float %69, float %61)
%72 = extractelement <2 x float> %48, i64 1
%73 = fneg float %72
%74 = extractelement <2 x float> %68, i64 0
%75 = tail call float @llvm.fmuladd.f32(float %73, float %74, float %71)
store float %75, float* %55
%76 = tail call float @llvm.fmuladd.f32(float %70, float %74, float %64)
%77 = tail call float @llvm.fmuladd.f32(float %72, float %69, float %76)
store float %77, float* %56
%78 = fneg float %70
%79 = fneg float %64
%80 = insertelement <2 x float> poison, float %78, i64 0
%81 = shufflevector <2 x float> %80, <2 x float> %48, <2 x i32> <i32 0, i32 2>
%82 = shufflevector <2 x float> %68, <2 x float> undef, <2 x i32> <i32 1, i32 0>
%83 = insertelement <2 x float> poison, float %61, i64 0
%84 = insertelement <2 x float> %83, float %79, i64 1
%85 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %81, <2 x float> %82, <2 x float> %84)
%86 = shufflevector <2 x float> %48, <2 x float> undef, <2 x i32> <i32 1, i32 1>
%87 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %86, <2 x float> %68, <2 x float> %85)
br label %121
88: ; preds = %45
%89 = or i32 %52, 1
%90 = getelementptr inbounds float, float* %0, i64 %49
%91 = load float, float* %90
%92 = sext i32 %52 to i64
%93 = getelementptr inbounds float, float* %0, i64 %92
%94 = load float, float* %93
%95 = fadd float %91, %94
%96 = fmul float %95, 5.000000e-01
%97 = getelementptr inbounds float, float* %0, i64 %50
%98 = load float, float* %97
%99 = sext i32 %89 to i64
%100 = getelementptr inbounds float, float* %0, i64 %99
%101 = load float, float* %100
%102 = fsub float %98, %101
%103 = fmul float %102, 5.000000e-01
%104 = fadd float %98, %101
%105 = fmul float %104, %36
%106 = fsub float %91, %94
%107 = fmul float %21, %106
%108 = extractelement <2 x float> %48, i64 0
%109 = tail call float @llvm.fmuladd.f32(float %108, float %105, float %96)
%110 = extractelement <2 x float> %48, i64 1
%111 = fneg float %110
%112 = tail call float @llvm.fmuladd.f32(float %111, float %107, float %109)
store float %112, float* %90
%113 = tail call float @llvm.fmuladd.f32(float %108, float %107, float %103)
%114 = tail call float @llvm.fmuladd.f32(float %110, float %105, float %113)
store float %114, float* %97
%115 = fneg float %108
%116 = tail call float @llvm.fmuladd.f32(float %115, float %105, float %96)
%117 = tail call float @llvm.fmuladd.f32(float %110, float %107, float %116)
store float %117, float* %93
%118 = fneg float %103
%119 = tail call float @llvm.fmuladd.f32(float %108, float %107, float %118)
%120 = tail call float @llvm.fmuladd.f32(float %110, float %105, float %119)
store float %120, float* %100
br label %121
121: ; preds = %88, %54
%122 = phi float [ %111, %88 ], [ %73, %54 ]
%123 = phi <2 x float> [ %47, %88 ], [ %87, %54 ]
%124 = insertelement <2 x float> poison, float %122, i64 0
%125 = shufflevector <2 x float> %124, <2 x float> %48, <2 x i32> <i32 0, i32 2>
%126 = fmul <2 x float> %44, %125
%127 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %48, <2 x float> %42, <2 x float> %126)
%128 = fadd <2 x float> %48, %127
%129 = add nuw nsw i64 %46, 1
%130 = icmp eq i64 %129, %38
br i1 %130, label %131, label %45
131: ; preds = %121
%132 = extractelement <2 x float> %123, i64 0
br label %133
133: ; preds = %131, %19
%134 = phi float [ %30, %19 ], [ %132, %131 ]
br i1 %10, label %137, label %135
135: ; preds = %133
%136 = getelementptr inbounds float, float* %0, i64 1
store float %134, float* %136
br label %138
137: ; preds = %133
tail call void (float*, i32, i32, ...) bitcast (void (...)* @cfft to void (float*, i32, i32, ...)*)(float* %0, i32 %1, i32 0)
br label %138
138: ; preds = %137, %135
ret void
}