#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 sqrtf(float);
void FFT(int m, float *x, float *y, int dir) {
  int n, i, i1, j, k, i2, l, l1, l2;
  float c1, c2, tx, ty, t1, t2, u1, u2, z;
  n = 1 << m;
  i2 = n >> 1;
  j = 0;
  for (i = 0; i < n - 1; i++) {
    if (i < j) {
      tx = x[i];
      ty = y[i];
      x[i] = x[j];
      y[i] = y[j];
      x[j] = tx;
      y[j] = ty;
    }
    k = i2;
    while (k <= j) {
      j -= k;
      k >>= 1;
    }
    j += k;
  }
  c1 = -1.0f;
  c2 = 0;
  l2 = 1;
  for (l = 0; l < m; l++) {
    l1 = l2;
    l2 <<= 1;
    u1 = 1.0f;
    u2 = 0;
    for (j = 0; j < l1; j++) {
      for (i = j; i < n; i += l2) {
        i1 = i + l1;
        t1 = u1 * x[i1] - u2 * y[i1];
        t2 = u1 * y[i1] + u2 * x[i1];
        x[i1] = x[i] - t1;
        y[i1] = y[i] - t2;
        x[i] += t1;
        y[i] += t2;
      }
      z = u1 * c1 - u2 * c2;
      u2 = u1 * c2 + u2 * c1;
      u1 = z;
    }
    c2 = sqrtf(0.5f * (1.0f - c1));
    c1 = sqrtf(0.5f * (1.0f + c1));
    if (dir == 1)
      c2 = -c2;
  }
  if (dir == 1) {
    float scale = 1.0f / n;
    for (i = 0; i < n; i++) {
      x[i] *= scale;
      y[i] *= scale;
    }
  }
}


x86 assembly (clang, -O0):
<FFT>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x4(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1225 <FFT+0x115>
mov    -0x24(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    11e3 <FFT+0xd3>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     120e <FFT+0xfe>
mov    -0x30(%rbp),%ecx
mov    -0x2c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11e9 <FFT+0xd9>
mov    -0x30(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    114a <FFT+0x3a>
movss  0xdd3(%rip),%xmm0
movss  %xmm0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movl   $0x1,-0x40(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1470 <FFT+0x360>
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x40(%rbp)
movss  0xd99(%rip),%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    13f6 <FFT+0x2e6>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    138f <FFT+0x27f>
mov    -0x24(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x28(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x60(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x60(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x54(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1291 <FFT+0x181>
movss  -0x5c(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    127f <FFT+0x16f>
movss  0xc06(%rip),%xmm1
subss  -0x44(%rbp),%xmm1
movss  0xbfd(%rip),%xmm0
mulss  %xmm1,%xmm0
call   1030 <sqrtf@plt>
movss  %xmm0,-0x48(%rbp)
movss  0xbe3(%rip),%xmm1
addss  -0x44(%rbp),%xmm1
movss  0xbda(%rip),%xmm0
mulss  %xmm1,%xmm0
call   1030 <sqrtf@plt>
movss  %xmm0,-0x44(%rbp)
cmpl   $0x1,-0x1c(%rbp)
jne    145d <FFT+0x34d>
movss  -0x48(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
jmp    1462 <FFT+0x352>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1248 <FFT+0x138>
cmpl   $0x1,-0x1c(%rbp)
jne    14e4 <FFT+0x3d4>
cvtsi2ssl -0x20(%rbp),%xmm1
movss  0xb7d(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    14df <FFT+0x3cf>
movss  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1497 <FFT+0x387>
jmp    14e4 <FFT+0x3d4>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<FFT>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %ecx,0x4(%rsp)
mov    %rsi,%r13
mov    %edi,%ecx
mov    $0x1,%r14d
mov    %edi,(%rsp)
shl    %cl,%r14d
cmp    $0x2,%r14d
jl     11a5 <FFT+0x95>
lea    -0x1(%r14),%eax
xor    %ecx,%ecx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %esi,%rdi
cmp    %rdi,%rcx
jge    1188 <FFT+0x78>
movss  0x0(%r13,%rcx,4),%xmm0
movss  (%rdx,%rcx,4),%xmm1
movss  0x0(%r13,%rdi,4),%xmm2
movss  %xmm2,0x0(%r13,%rcx,4)
movss  (%rdx,%rdi,4),%xmm2
movss  %xmm2,(%rdx,%rcx,4)
movss  %xmm0,0x0(%r13,%rdi,4)
movss  %xmm1,(%rdx,%rdi,4)
mov    %r14d,%edi
nopl   0x0(%rax,%rax,1)
mov    %esi,%ebp
sar    %edi
sub    %edi,%esi
jge    1190 <FFT+0x80>
add    %edi,%ebp
add    $0x1,%rcx
mov    %ebp,%esi
cmp    %rax,%rcx
jne    1150 <FFT+0x40>
mov    %rdx,0x8(%rsp)
cmpl   $0x0,(%rsp)
jle    13aa <FFT+0x29a>
movslq %r14d,%rbx
xorps  %xmm8,%xmm8
movss  0xe3c(%rip),%xmm9
mov    $0x1,%ecx
xor    %r15d,%r15d
movss  0xe2f(%rip),%xmm10
movaps 0xe34(%rip),%xmm7
movss  0xe23(%rip),%xmm11
xorps  %xmm12,%xmm12
jmp    1201 <FFT+0xf1>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15d
mov    %r12d,%ecx
cmp    (%rsp),%r15d
je     13aa <FFT+0x29a>
lea    (%rcx,%rcx,1),%r12d
test   %ecx,%ecx
jle    12f0 <FFT+0x1e0>
movslq %r12d,%rax
mov    %ecx,%ecx
lea    0x0(,%rax,4),%rdx
xorps  %xmm0,%xmm0
mov    0x8(%rsp),%r8
mov    %r13,%r9
xor    %r10d,%r10d
movaps %xmm10,%xmm1
jmp    1267 <FFT+0x157>
xchg   %ax,%ax
mulss  %xmm12,%xmm2
movaps %xmm1,%xmm3
mulss  %xmm9,%xmm3
addss  %xmm2,%xmm3
mulss  %xmm9,%xmm0
mulss  %xmm12,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%r10
add    $0x4,%r9
add    $0x4,%r8
movaps %xmm3,%xmm1
cmp    %rcx,%r10
je     12f0 <FFT+0x1e0>
movaps %xmm0,%xmm2
xorps  %xmm7,%xmm2
cmp    %r10d,%r14d
jle    1230 <FFT+0x120>
mov    %r8,%rsi
mov    %r9,%rdi
mov    %r10,%rbp
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rcx,4),%xmm3
movss  (%rsi,%rcx,4),%xmm4
movaps %xmm4,%xmm5
mulss  %xmm2,%xmm5
movaps %xmm1,%xmm6
mulss  %xmm3,%xmm6
addss  %xmm5,%xmm6
mulss  %xmm0,%xmm3
mulss  %xmm1,%xmm4
addss  %xmm3,%xmm4
movss  (%rdi),%xmm3
subss  %xmm6,%xmm3
movss  %xmm3,(%rdi,%rcx,4)
movss  (%rsi),%xmm3
subss  %xmm4,%xmm3
movss  %xmm3,(%rsi,%rcx,4)
addss  (%rdi),%xmm6
movss  %xmm6,(%rdi)
addss  (%rsi),%xmm4
movss  %xmm4,(%rsi)
add    %rax,%rbp
add    %rdx,%rdi
add    %rdx,%rsi
cmp    %rbx,%rbp
jl     1280 <FFT+0x170>
jmp    1230 <FFT+0x120>
cs nopw 0x0(%rax,%rax,1)
nop
movaps %xmm10,%xmm0
subss  %xmm9,%xmm0
mulss  %xmm11,%xmm0
ucomiss %xmm8,%xmm0
jb     1310 <FFT+0x200>
xorps  %xmm12,%xmm12
sqrtss %xmm0,%xmm12
jmp    133d <FFT+0x22d>
nop
movss  %xmm9,0x10(%rsp)
call   1030 <sqrtf@plt>
movss  0xce3(%rip),%xmm11
movss  0x10(%rsp),%xmm9
movss  0xccf(%rip),%xmm10
xorps  %xmm8,%xmm8
movaps %xmm0,%xmm12
addss  %xmm10,%xmm9
mulss  %xmm11,%xmm9
ucomiss %xmm8,%xmm9
jb     1360 <FFT+0x250>
sqrtss %xmm9,%xmm9
jmp    138f <FFT+0x27f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movaps %xmm9,%xmm0
movaps %xmm12,0x10(%rsp)
call   1030 <sqrtf@plt>
movaps 0x10(%rsp),%xmm12
movss  0xc8a(%rip),%xmm11
movss  0xc7d(%rip),%xmm10
xorps  %xmm8,%xmm8
movaps %xmm0,%xmm9
movaps 0xc7a(%rip),%xmm7
cmpl   $0x1,0x4(%rsp)
jne    11f0 <FFT+0xe0>
xorps  %xmm7,%xmm12
jmp    11f0 <FFT+0xe0>
cmpl   $0x1,0x4(%rsp)
mov    0x8(%rsp),%rbp
jne    15a1 <FFT+0x491>
cmpl   $0x1f,(%rsp)
je     15a1 <FFT+0x491>
xorps  %xmm1,%xmm1
cvtsi2ss %r14d,%xmm1
movss  0xc30(%rip),%xmm0
divss  %xmm1,%xmm0
cmp    $0x2,%r14d
mov    $0x1,%eax
cmovge %r14d,%eax
cmp    $0x8,%eax
jb     1412 <FFT+0x302>
lea    0x0(,%rax,4),%rcx
add    %rbp,%rcx
cmp    %r13,%rcx
jbe    14a2 <FFT+0x392>
lea    0x0(,%rax,4),%rcx
add    %r13,%rcx
cmp    %rbp,%rcx
jbe    14a2 <FFT+0x392>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
test   $0x1,%al
je     1444 <FFT+0x334>
movss  0x0(%r13,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x0(%r13,%rcx,4)
movss  0x0(%rbp,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x0(%rbp,%rcx,4)
or     $0x1,%rcx
add    %rax,%rdx
je     15a1 <FFT+0x491>
nopl   (%rax)
movss  0x0(%r13,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x0(%r13,%rcx,4)
movss  0x0(%rbp,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x0(%rbp,%rcx,4)
movss  0x4(%r13,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%r13,%rcx,4)
movss  0x4(%rbp,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%rbp,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1450 <FFT+0x340>
jmp    15a1 <FFT+0x491>
mov    %eax,%ecx
and    $0x7ffffff8,%ecx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     15b0 <FFT+0x4a0>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups 0x0(%r13,%rdx,4),%xmm2
movups 0x10(%r13,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x0(%r13,%rdx,4)
movups %xmm3,0x10(%r13,%rdx,4)
movups 0x0(%rbp,%rdx,4),%xmm2
movups 0x10(%rbp,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x0(%rbp,%rdx,4)
movups %xmm3,0x10(%rbp,%rdx,4)
movups 0x20(%r13,%rdx,4),%xmm2
movups 0x30(%r13,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x20(%r13,%rdx,4)
movups %xmm3,0x30(%r13,%rdx,4)
movups 0x20(%rbp,%rdx,4),%xmm2
movups 0x30(%rbp,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x20(%rbp,%rdx,4)
movups %xmm3,0x30(%rbp,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    14e0 <FFT+0x3d0>
test   $0x1,%sil
je     1598 <FFT+0x488>
movups 0x0(%r13,%rdx,4),%xmm2
movups 0x10(%r13,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x0(%r13,%rdx,4)
movups %xmm3,0x10(%r13,%rdx,4)
movups 0x0(%rbp,%rdx,4),%xmm2
movups 0x10(%rbp,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x0(%rbp,%rdx,4)
movups %xmm3,0x10(%rbp,%rdx,4)
cmp    %rax,%rcx
jne    1414 <FFT+0x304>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%sil
jne    1560 <FFT+0x450>
jmp    1598 <FFT+0x488>

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

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