void fft_real_to_hermitian(float *z, int n) {
  float *x, e, a, a3, sqrthalf = 1 / (float)sqrt(2.0);
  float cc1, ss1, cc3, ss3;
  int nn = n >> 1, is, id, i0, i1, i2, i3, i4, i5, i6, i7, i8;
  float t1, t2, t3, t4, t5, t6;
  int n2, n4, n8, i, j;
  scramble_real(z, n);
  x = z - 1;
  is = 1;
  id = 4;
  do {
    for (i0 = is; i0 <= n; i0 += id) {
      i1 = i0 + 1;
      e = x[i0];
      x[i0] = e + x[i1];
      x[i1] = e - x[i1];
    }
    is = (id << 1) - 1;
    id <<= 2;
  } while (is < n);
  n2 = 2;
  while (nn >>= 1) {
    n2 <<= 1;
    n4 = n2 >> 2;
    n8 = n2 >> 3;
    e = 6.28318530717958647692 / n2;
    is = 0;
    id = n2 << 1;
    do {
      for (i = is; i < n; i += id) {
        i1 = i + 1;
        i2 = i1 + n4;
        i3 = i2 + n4;
        i4 = i3 + n4;
        t1 = x[i4] + x[i3];
        x[i4] -= x[i3];
        x[i3] = x[i1] - t1;
        x[i1] += t1;
        if (n4 == 1)
          continue;
        i1 += n8;
        i2 += n8;
        i3 += n8;
        i4 += n8;
        t1 = (x[i3] + x[i4]) * sqrthalf;
        t2 = (x[i3] - x[i4]) * sqrthalf;
        x[i4] = x[i2] - t1;
        x[i3] = -x[i2] - t1;
        x[i2] = x[i1] - t2;
        x[i1] += t2;
      }
      is = (id << 1) - n2;
      id <<= 2;
    } while (is < n);
    a = e;
    for (j = 2; j <= n8; j++) {
      a3 = 3 * a;
      cc1 = (float)cos(a);
      ss1 = (float)sin(a);
      cc3 = (float)cos(a3);
      ss3 = (float)sin(a3);
      a = e * j;
      is = 0;
      id = n2 << 1;
      do {
        for (i = is; i < n; i += id) {
          i1 = i + j;
          i2 = i1 + n4;
          i3 = i2 + n4;
          i4 = i3 + n4;
          i5 = i + n4 - j + 2;
          i6 = i5 + n4;
          i7 = i6 + n4;
          i8 = i7 + n4;
          t1 = x[i3] * cc1 + x[i7] * ss1;
          t2 = x[i7] * cc1 - x[i3] * ss1;
          t3 = x[i4] * cc3 + x[i8] * ss3;
          t4 = x[i8] * cc3 - x[i4] * ss3;
          t5 = t1 + t3;
          t6 = t2 + t4;
          t3 = t1 - t3;
          t4 = t2 - t4;
          t2 = x[i6] + t6;
          x[i3] = t6 - x[i6];
          x[i8] = t2;
          t2 = x[i2] - t3;
          x[i7] = -x[i2] - t3;
          x[i4] = t2;
          t1 = x[i1] + t5;
          x[i6] = x[i1] - t5;
          x[i1] = t1;
          t1 = x[i5] + t4;
          x[i5] -= t4;
          x[i2] = t1;
        }
        is = (id << 1) - n2;
        id <<= 2;
      } while (is < n);
    }
  }
}


x86 assembly (clang, -O0):
<fft_real_to_hermitian>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movsd  0xeae(%rip),%xmm0
call   1060 <sqrt@plt>
cvtsd2ss %xmm0,%xmm1
movss  0xe95(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0xc(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    $0x0,%al
call   1030 <scramble_real@plt>
mov    -0x8(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x18(%rbp)
movl   $0x1,-0x40(%rbp)
movl   $0x4,-0x44(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     121e <fft_real_to_hermitian+0xde>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    11ab <fft_real_to_hermitian+0x6b>
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     11a5 <fft_real_to_hermitian+0x65>
movl   $0x2,-0x84(%rbp)
mov    -0x3c(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x3c(%rbp)
cmp    $0x0,%eax
je     1898 <fft_real_to_hermitian+0x758>
mov    -0x84(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
sar    $0x2,%eax
mov    %eax,-0x88(%rbp)
mov    -0x84(%rbp),%eax
sar    $0x3,%eax
mov    %eax,-0x8c(%rbp)
cvtsi2sdl -0x84(%rbp),%xmm1
ff
movsd  0xd78(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x84(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1497 <fft_real_to_hermitian+0x357>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x6c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x1,-0x88(%rbp)
jne    138a <fft_real_to_hermitian+0x24a>
jmp    1483 <fft_real_to_hermitian+0x343>
mov    -0x8c(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x8c(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x8c(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x8c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mulss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mulss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x6c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
subss  -0x6c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    -0x90(%rbp),%eax
mov    %eax,-0x90(%rbp)
jmp    12c1 <fft_real_to_hermitian+0x181>
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
sub    -0x84(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     12b8 <fft_real_to_hermitian+0x178>
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
movl   $0x2,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jg     1893 <fft_real_to_hermitian+0x753>
movss  0xb1b(%rip),%xmm0
mulss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1040 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1040 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x1c(%rbp),%xmm0
cvtsi2ssl -0x94(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x84(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1856 <fft_real_to_hermitian+0x716>
mov    -0x90(%rbp),%eax
add    -0x94(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x90(%rbp),%eax
add    -0x88(%rbp),%eax
sub    -0x94(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x30(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x34(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x38(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x34(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x38(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x6c(%rbp),%xmm0
addss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x70(%rbp),%xmm0
addss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x6c(%rbp),%xmm0
subss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x70(%rbp),%xmm0
subss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x80(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
subss  -0x74(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x7c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x78(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    -0x90(%rbp),%eax
mov    %eax,-0x90(%rbp)
jmp    1581 <fft_real_to_hermitian+0x441>
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
sub    -0x84(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1578 <fft_real_to_hermitian+0x438>
jmp    187f <fft_real_to_hermitian+0x73f>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    14cf <fft_real_to_hermitian+0x38f>
jmp    1249 <fft_real_to_hermitian+0x109>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fft_real_to_hermitian>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %esi,%ebp
mov    %rdi,%rbx
xor    %eax,%eax
call   1030 <scramble_real@plt>
movslq %ebp,%rsi
mov    $0x1,%ecx
mov    $0x4,%eax
jmp    1170 <fft_real_to_hermitian+0x40>
nopl   0x0(%rax)
lea    (%rax,%rax,1),%edx
lea    (%rax,%rax,1),%ecx
add    $0xffffffff,%ecx
shl    $0x2,%eax
cmp    %ebp,%edx
jg     11ab <fft_real_to_hermitian+0x7b>
cmp    %ebp,%ecx
jg     1160 <fft_real_to_hermitian+0x30>
movslq %ecx,%rcx
movslq %eax,%rdx
nopw   0x0(%rax,%rax,1)
movss  -0x4(%rbx,%rcx,4),%xmm0
movss  (%rbx,%rcx,4),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,-0x4(%rbx,%rcx,4)
subss  %xmm1,%xmm0
movss  %xmm0,(%rbx,%rcx,4)
add    %rdx,%rcx
cmp    %rsi,%rcx
jle    1180 <fft_real_to_hermitian+0x50>
jmp    1160 <fft_real_to_hermitian+0x30>
mov    %rsi,0x60(%rsp)
mov    %ebp,0xc(%rsp)
cmp    $0x4,%ebp
jae    11c8 <fft_real_to_hermitian+0x98>
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x4(%rbx),%rax
mov    %rax,0x68(%rsp)
movss  0xe2f(%rip),%xmm4
movaps 0xe30(%rip),%xmm7
mov    0xc(%rsp),%eax
mov    $0x2,%ecx
jmp    1209 <fft_real_to_hermitian+0xd9>
nopl   0x0(%rax,%rax,1)
mov    0x44(%rsp),%ecx
mov    %ecx,%eax
sar    %eax
cmp    $0x8,%ecx
movss  0xe05(%rip),%xmm4
mov    0x40(%rsp),%ecx
jb     11b9 <fft_real_to_hermitian+0x89>
mov    %eax,0x44(%rsp)
mov    %ecx,%eax
lea    (%rax,%rax,1),%r14d
mov    %r14d,%ecx
sar    $0x2,%ecx
mov    %r14d,%edx
xorps  %xmm1,%xmm1
cvtsi2sd %r14d,%xmm1
sar    $0x3,%edx
movsd  0xdd1(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    %rax,0x58(%rsp)
lea    0x0(,%rax,4),%r9d
mov    %rdx,%r15
movslq %edx,%rax
mov    %ecx,0x1c(%rsp)
movslq %ecx,%rdi
lea    (%rax,%rdi,1),%rcx
lea    (%rbx,%rcx,4),%rcx
lea    (%rax,%rdi,2),%rdx
lea    (%rbx,%rdx,4),%r10
lea    (%rbx,%rdi,8),%rsi
mov    %rdi,%r12
lea    (%rdi,%rdi,2),%r8
lea    (%r8,%rax,1),%rdx
lea    (%rbx,%rdx,4),%r11
lea    (%rbx,%r8,4),%rbp
lea    (%rbx,%rax,4),%rax
xor    %edx,%edx
mov    %r9d,0x4c(%rsp)
mov    0xc(%rsp),%edi
jmp    12a9 <fft_real_to_hermitian+0x179>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r9d,%edx
sub    0x58(%rsp),%edx
add    %edx,%edx
shl    $0x2,%r9d
mov    0xc(%rsp),%edi
cmp    %edi,%edx
jge    1370 <fft_real_to_hermitian+0x240>
cmp    %edi,%edx
jge    1290 <fft_real_to_hermitian+0x160>
movslq %edx,%rdx
movslq %r9d,%rdi
jmp    12ca <fft_real_to_hermitian+0x19a>
cs nopw 0x0(%rax,%rax,1)
nop
add    %rdi,%rdx
cmp    0x60(%rsp),%rdx
jge    1290 <fft_real_to_hermitian+0x160>
movss  0x0(%rbp,%rdx,4),%xmm1
movss  (%rsi,%rdx,4),%xmm2
movaps %xmm1,%xmm3
addss  %xmm2,%xmm3
subss  %xmm2,%xmm1
movss  %xmm1,0x0(%rbp,%rdx,4)
movss  (%rbx,%rdx,4),%xmm1
subss  %xmm3,%xmm1
movss  %xmm1,(%rsi,%rdx,4)
addss  (%rbx,%rdx,4),%xmm3
movss  %xmm3,(%rbx,%rdx,4)
cmp    $0x4,%r14d
je     12c0 <fft_real_to_hermitian+0x190>
movss  (%r10,%rdx,4),%xmm1
movss  (%r11,%rdx,4),%xmm2
movaps %xmm1,%xmm3
addss  %xmm2,%xmm3
mulss  %xmm4,%xmm3
subss  %xmm2,%xmm1
mulss  %xmm4,%xmm1
movss  (%rcx,%rdx,4),%xmm2
subss  %xmm3,%xmm2
movss  %xmm2,(%r11,%rdx,4)
movss  (%rcx,%rdx,4),%xmm2
xorps  %xmm7,%xmm2
subss  %xmm3,%xmm2
movss  %xmm2,(%r10,%rdx,4)
movss  (%rax,%rdx,4),%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,(%rcx,%rdx,4)
addss  (%rax,%rdx,4),%xmm1
movss  %xmm1,(%rax,%rdx,4)
jmp    12c0 <fft_real_to_hermitian+0x190>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r14d,0x40(%rsp)
cmp    $0x10,%r14d
jl     11f0 <fft_real_to_hermitian+0xc0>
cvtsd2ss %xmm0,%xmm0
cmp    $0x3,%r15d
mov    $0x2,%eax
cmovl  %eax,%r15d
add    $0x1,%r15d
mov    %r15,0x70(%rsp)
mov    0x68(%rsp),%r14
mov    %r12,%rax
lea    (%r14,%r12,4),%r13
lea    (%r14,%r12,8),%r12
lea    (%r14,%r8,4),%r15
lea    0x0(,%rax,4),%ecx
mov    %rcx,0x30(%rsp)
lea    (%rax,%rax,2),%ecx
mov    %rcx,0x28(%rsp)
add    %eax,%eax
mov    %rax,0x38(%rsp)
mov    $0x2,%ebp
movss  %xmm0,0x48(%rsp)
movaps %xmm0,%xmm8
jmp    1437 <fft_real_to_hermitian+0x307>
nopl   0x0(%rax)
mulss  0x48(%rsp),%xmm8
mov    0x10(%rsp),%rbp
add    $0x1,%rbp
add    $0x4,%r14
add    $0x4,%r13
add    $0x4,%r12
add    $0x4,%r15
mov    0x30(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x30(%rsp)
mov    0x28(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x28(%rsp)
mov    0x38(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x38(%rsp)
addl   $0xffffffff,0x1c(%rsp)
cmp    0x70(%rsp),%rbp
je     11f0 <fft_real_to_hermitian+0xc0>
xorps  %xmm0,%xmm0
cvtss2sd %xmm8,%xmm0
movsd  %xmm0,0x20(%rsp)
mulss  0xbbe(%rip),%xmm8
movss  %xmm8,0x10(%rsp)
call   1050 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x54(%rsp)
movsd  0x20(%rsp),%xmm0
call   1040 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x20(%rsp)
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x10(%rsp)
call   1050 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x50(%rsp)
movsd  0x10(%rsp),%xmm0
call   1040 <sin@plt>
movss  0x50(%rsp),%xmm11
movss  0x20(%rsp),%xmm10
movss  0x54(%rsp),%xmm9
movaps 0xb51(%rip),%xmm7
cvtsd2ss %xmm0,%xmm0
mov    %rbp,0x10(%rsp)
xorps  %xmm8,%xmm8
cvtsi2ss %ebp,%xmm8
xor    %ecx,%ecx
mov    0x4c(%rsp),%eax
mov    0xc(%rsp),%r9d
mov    0x60(%rsp),%r10
mov    0x58(%rsp),%r11
jmp    1503 <fft_real_to_hermitian+0x3d3>
nopl   0x0(%rax,%rax,1)
mov    %eax,%ecx
sub    %r11d,%ecx
add    %ecx,%ecx
shl    $0x2,%eax
cmp    %r9d,%ecx
jge    13e0 <fft_real_to_hermitian+0x2b0>
cmp    %r9d,%ecx
jge    14f0 <fft_real_to_hermitian+0x3c0>
movslq %ecx,%rdx
movslq %eax,%r8
mov    0x30(%rsp),%rsi
lea    (%rsi,%rcx,1),%edi
mov    0x28(%rsp),%rsi
lea    (%rsi,%rcx,1),%ebp
mov    0x38(%rsp),%rsi
add    %ecx,%esi
add    0x1c(%rsp),%ecx
nopl   0x0(%rax)
movss  (%r12,%rdx,4),%xmm2
movslq %ebp,%rbp
movss  -0x4(%rbx,%rbp,4),%xmm1
movaps %xmm1,%xmm3
mulss  %xmm10,%xmm3
movaps %xmm10,%xmm4
mulss  %xmm2,%xmm4
mulss  %xmm9,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm9,%xmm1
subss  %xmm4,%xmm1
movss  (%r15,%rdx,4),%xmm3
movslq %edi,%rdi
movss  -0x4(%rbx,%rdi,4),%xmm4
movaps %xmm4,%xmm5
mulss  %xmm0,%xmm5
movaps %xmm0,%xmm6
mulss  %xmm3,%xmm6
mulss  %xmm11,%xmm3
addss  %xmm5,%xmm3
mulss  %xmm11,%xmm4
subss  %xmm6,%xmm4
movaps %xmm2,%xmm5
addss  %xmm3,%xmm5
movaps %xmm1,%xmm6
addss  %xmm4,%xmm6
subss  %xmm3,%xmm2
subss  %xmm4,%xmm1
movslq %esi,%rsi
movss  -0x4(%rbx,%rsi,4),%xmm3
movaps %xmm3,%xmm4
addss  %xmm6,%xmm4
subss  %xmm3,%xmm6
movss  %xmm6,(%r12,%rdx,4)
movss  %xmm4,-0x4(%rbx,%rdi,4)
movss  0x0(%r13,%rdx,4),%xmm3
movaps %xmm3,%xmm4
subss  %xmm2,%xmm4
xorps  %xmm7,%xmm3
subss  %xmm2,%xmm3
movss  %xmm3,-0x4(%rbx,%rbp,4)
movss  %xmm4,(%r15,%rdx,4)
movss  (%r14,%rdx,4),%xmm2
movaps %xmm5,%xmm3
addss  %xmm2,%xmm3
subss  %xmm5,%xmm2
movss  %xmm2,-0x4(%rbx,%rsi,4)
movss  %xmm3,(%r14,%rdx,4)
movslq %ecx,%rcx
movss  -0x4(%rbx,%rcx,4),%xmm2
movaps %xmm1,%xmm3
addss  %xmm2,%xmm3
subss  %xmm1,%xmm2
movss  %xmm2,-0x4(%rbx,%rcx,4)
movss  %xmm3,0x0(%r13,%rdx,4)
add    %r8,%rdx
add    %eax,%edi
add    %eax,%ebp
add    %eax,%esi
add    %eax,%ecx
cmp    %r10,%rdx
jl     1530 <fft_real_to_hermitian+0x400>
jmp    14f0 <fft_real_to_hermitian+0x3c0>

LLVM IR (-O0):
define void @fft_real_to_hermitian(float* %0, i32 %1) {
%3 = alloca float*
%4 = alloca i32
%5 = alloca float*
%6 = alloca float
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca float
%27 = alloca float
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
store float* %0, float** %3
store i32 %1, i32* %4
%37 = call double @sqrt(double 2.000000e+00)
%38 = fptrunc double %37 to float
%39 = fdiv float 1.000000e+00, %38
store float %39, float* %9
%40 = load i32, i32* %4
%41 = ashr i32 %40, 1
store i32 %41, i32* %14
%42 = load float*, float** %3
%43 = load i32, i32* %4
%44 = call i32 (float*, i32, ...) bitcast (i32 (...)* @scramble_real to i32 (float*, i32, ...)*)(float* %42, i32 %43)
%45 = load float*, float** %3
%46 = getelementptr inbounds float, float* %45, i64 -1
store float* %46, float** %5
store i32 1, i32* %15
store i32 4, i32* %16
br label %47
47: ; preds = %93, %2
%48 = load i32, i32* %15
store i32 %48, i32* %17
br label %49
49: ; preds = %83, %47
%50 = load i32, i32* %17
%51 = load i32, i32* %4
%52 = icmp sle i32 %50, %51
br i1 %52, label %53, label %87
53: ; preds = %49
%54 = load i32, i32* %17
%55 = add nsw i32 %54, 1
store i32 %55, i32* %18
%56 = load float*, float** %5
%57 = load i32, i32* %17
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds float, float* %56, i64 %58
%60 = load float, float* %59
store float %60, float* %6
%61 = load float, float* %6
%62 = load float*, float** %5
%63 = load i32, i32* %18
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds float, float* %62, i64 %64
%66 = load float, float* %65
%67 = fadd float %61, %66
%68 = load float*, float** %5
%69 = load i32, i32* %17
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds float, float* %68, i64 %70
store float %67, float* %71
%72 = load float, float* %6
%73 = load float*, float** %5
%74 = load i32, i32* %18
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds float, float* %73, i64 %75
%77 = load float, float* %76
%78 = fsub float %72, %77
%79 = load float*, float** %5
%80 = load i32, i32* %18
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds float, float* %79, i64 %81
store float %78, float* %82
br label %83
83: ; preds = %53
%84 = load i32, i32* %16
%85 = load i32, i32* %17
%86 = add nsw i32 %85, %84
store i32 %86, i32* %17
br label %49
87: ; preds = %49
%88 = load i32, i32* %16
%89 = shl i32 %88, 1
%90 = sub nsw i32 %89, 1
store i32 %90, i32* %15
%91 = load i32, i32* %16
%92 = shl i32 %91, 2
store i32 %92, i32* %16
br label %93
93: ; preds = %87
%94 = load i32, i32* %15
%95 = load i32, i32* %4
%96 = icmp slt i32 %94, %95
br i1 %96, label %47, label %97
97: ; preds = %93
store i32 2, i32* %32
br label %98
98: ; preds = %514, %97
%99 = load i32, i32* %14
%100 = ashr i32 %99, 1
store i32 %100, i32* %14
%101 = icmp ne i32 %100, 0
br i1 %101, label %102, label %515
102: ; preds = %98
%103 = load i32, i32* %32
%104 = shl i32 %103, 1
store i32 %104, i32* %32
%105 = load i32, i32* %32
%106 = ashr i32 %105, 2
store i32 %106, i32* %33
%107 = load i32, i32* %32
%108 = ashr i32 %107, 3
store i32 %108, i32* %34
%109 = load i32, i32* %32
%110 = sitofp i32 %109 to double
%111 = fdiv double 0x401921FB54442D18, %110
%112 = fptrunc double %111 to float
store float %112, float* %6
store i32 0, i32* %15
%113 = load i32, i32* %32
%114 = shl i32 %113, 1
store i32 %114, i32* %16
br label %115
115: ; preds = %267, %102
%116 = load i32, i32* %15
store i32 %116, i32* %35
br label %117
117: ; preds = %256, %115
%118 = load i32, i32* %35
%119 = load i32, i32* %4
%120 = icmp slt i32 %118, %119
br i1 %120, label %121, label %260
121: ; preds = %117
%122 = load i32, i32* %35
%123 = add nsw i32 %122, 1
store i32 %123, i32* %18
%124 = load i32, i32* %18
%125 = load i32, i32* %33
%126 = add nsw i32 %124, %125
store i32 %126, i32* %19
%127 = load i32, i32* %19
%128 = load i32, i32* %33
%129 = add nsw i32 %127, %128
store i32 %129, i32* %20
%130 = load i32, i32* %20
%131 = load i32, i32* %33
%132 = add nsw i32 %130, %131
store i32 %132, i32* %21
%133 = load float*, float** %5
%134 = load i32, i32* %21
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds float, float* %133, i64 %135
%137 = load float, float* %136
%138 = load float*, float** %5
%139 = load i32, i32* %20
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds float, float* %138, i64 %140
%142 = load float, float* %141
%143 = fadd float %137, %142
store float %143, float* %26
%144 = load float*, float** %5
%145 = load i32, i32* %20
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds float, float* %144, i64 %146
%148 = load float, float* %147
%149 = load float*, float** %5
%150 = load i32, i32* %21
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds float, float* %149, i64 %151
%153 = load float, float* %152
%154 = fsub float %153, %148
store float %154, float* %152
%155 = load float*, float** %5
%156 = load i32, i32* %18
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds float, float* %155, i64 %157
%159 = load float, float* %158
%160 = load float, float* %26
%161 = fsub float %159, %160
%162 = load float*, float** %5
%163 = load i32, i32* %20
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds float, float* %162, i64 %164
store float %161, float* %165
%166 = load float, float* %26
%167 = load float*, float** %5
%168 = load i32, i32* %18
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds float, float* %167, i64 %169
%171 = load float, float* %170
%172 = fadd float %171, %166
store float %172, float* %170
%173 = load i32, i32* %33
%174 = icmp eq i32 %173, 1
br i1 %174, label %175, label %176
175: ; preds = %121
br label %256
176: ; preds = %121
%177 = load i32, i32* %34
%178 = load i32, i32* %18
%179 = add nsw i32 %178, %177
store i32 %179, i32* %18
%180 = load i32, i32* %34
%181 = load i32, i32* %19
%182 = add nsw i32 %181, %180
store i32 %182, i32* %19
%183 = load i32, i32* %34
%184 = load i32, i32* %20
%185 = add nsw i32 %184, %183
store i32 %185, i32* %20
%186 = load i32, i32* %34
%187 = load i32, i32* %21
%188 = add nsw i32 %187, %186
store i32 %188, i32* %21
%189 = load float*, float** %5
%190 = load i32, i32* %20
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds float, float* %189, i64 %191
%193 = load float, float* %192
%194 = load float*, float** %5
%195 = load i32, i32* %21
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds float, float* %194, i64 %196
%198 = load float, float* %197
%199 = fadd float %193, %198
%200 = load float, float* %9
%201 = fmul float %199, %200
store float %201, float* %26
%202 = load float*, float** %5
%203 = load i32, i32* %20
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds float, float* %202, i64 %204
%206 = load float, float* %205
%207 = load float*, float** %5
%208 = load i32, i32* %21
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds float, float* %207, i64 %209
%211 = load float, float* %210
%212 = fsub float %206, %211
%213 = load float, float* %9
%214 = fmul float %212, %213
store float %214, float* %27
%215 = load float*, float** %5
%216 = load i32, i32* %19
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds float, float* %215, i64 %217
%219 = load float, float* %218
%220 = load float, float* %26
%221 = fsub float %219, %220
%222 = load float*, float** %5
%223 = load i32, i32* %21
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds float, float* %222, i64 %224
store float %221, float* %225
%226 = load float*, float** %5
%227 = load i32, i32* %19
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds float, float* %226, i64 %228
%230 = load float, float* %229
%231 = fneg float %230
%232 = load float, float* %26
%233 = fsub float %231, %232
%234 = load float*, float** %5
%235 = load i32, i32* %20
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds float, float* %234, i64 %236
store float %233, float* %237
%238 = load float*, float** %5
%239 = load i32, i32* %18
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds float, float* %238, i64 %240
%242 = load float, float* %241
%243 = load float, float* %27
%244 = fsub float %242, %243
%245 = load float*, float** %5
%246 = load i32, i32* %19
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds float, float* %245, i64 %247
store float %244, float* %248
%249 = load float, float* %27
%250 = load float*, float** %5
%251 = load i32, i32* %18
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds float, float* %250, i64 %252
%254 = load float, float* %253
%255 = fadd float %254, %249
store float %255, float* %253
br label %256
256: ; preds = %176, %175
%257 = load i32, i32* %16
%258 = load i32, i32* %35
%259 = add nsw i32 %258, %257
store i32 %259, i32* %35
br label %117
260: ; preds = %117
%261 = load i32, i32* %16
%262 = shl i32 %261, 1
%263 = load i32, i32* %32
%264 = sub nsw i32 %262, %263
store i32 %264, i32* %15
%265 = load i32, i32* %16
%266 = shl i32 %265, 2
store i32 %266, i32* %16
br label %267
267: ; preds = %260
%268 = load i32, i32* %15
%269 = load i32, i32* %4
%270 = icmp slt i32 %268, %269
br i1 %270, label %115, label %271
271: ; preds = %267
%272 = load float, float* %6
store float %272, float* %7
store i32 2, i32* %36
br label %273
273: ; preds = %511, %271
%274 = load i32, i32* %36
%275 = load i32, i32* %34
%276 = icmp sle i32 %274, %275
br i1 %276, label %277, label %514
277: ; preds = %273
%278 = load float, float* %7
%279 = fmul float 3.000000e+00, %278
store float %279, float* %8
%280 = load float, float* %7
%281 = fpext float %280 to double
%282 = call double @cos(double %281)
%283 = fptrunc double %282 to float
store float %283, float* %10
%284 = load float, float* %7
%285 = fpext float %284 to double
%286 = call double @sin(double %285)
%287 = fptrunc double %286 to float
store float %287, float* %11
%288 = load float, float* %8
%289 = fpext float %288 to double
%290 = call double @cos(double %289)
%291 = fptrunc double %290 to float
store float %291, float* %12
%292 = load float, float* %8
%293 = fpext float %292 to double
%294 = call double @sin(double %293)
%295 = fptrunc double %294 to float
store float %295, float* %13
%296 = load float, float* %6
%297 = load i32, i32* %36
%298 = sitofp i32 %297 to float
%299 = fmul float %296, %298
store float %299, float* %7
store i32 0, i32* %15
%300 = load i32, i32* %32
%301 = shl i32 %300, 1
store i32 %301, i32* %16
br label %302
302: ; preds = %506, %277
%303 = load i32, i32* %15
store i32 %303, i32* %35
br label %304
304: ; preds = %495, %302
%305 = load i32, i32* %35
%306 = load i32, i32* %4
%307 = icmp slt i32 %305, %306
br i1 %307, label %308, label %499
308: ; preds = %304
%309 = load i32, i32* %35
%310 = load i32, i32* %36
%311 = add nsw i32 %309, %310
store i32 %311, i32* %18
%312 = load i32, i32* %18
%313 = load i32, i32* %33
%314 = add nsw i32 %312, %313
store i32 %314, i32* %19
%315 = load i32, i32* %19
%316 = load i32, i32* %33
%317 = add nsw i32 %315, %316
store i32 %317, i32* %20
%318 = load i32, i32* %20
%319 = load i32, i32* %33
%320 = add nsw i32 %318, %319
store i32 %320, i32* %21
%321 = load i32, i32* %35
%322 = load i32, i32* %33
%323 = add nsw i32 %321, %322
%324 = load i32, i32* %36
%325 = sub nsw i32 %323, %324
%326 = add nsw i32 %325, 2
store i32 %326, i32* %22
%327 = load i32, i32* %22
%328 = load i32, i32* %33
%329 = add nsw i32 %327, %328
store i32 %329, i32* %23
%330 = load i32, i32* %23
%331 = load i32, i32* %33
%332 = add nsw i32 %330, %331
store i32 %332, i32* %24
%333 = load i32, i32* %24
%334 = load i32, i32* %33
%335 = add nsw i32 %333, %334
store i32 %335, i32* %25
%336 = load float*, float** %5
%337 = load i32, i32* %20
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds float, float* %336, i64 %338
%340 = load float, float* %339
%341 = load float, float* %10
%342 = load float*, float** %5
%343 = load i32, i32* %24
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds float, float* %342, i64 %344
%346 = load float, float* %345
%347 = load float, float* %11
%348 = fmul float %346, %347
%349 = call float @llvm.fmuladd.f32(float %340, float %341, float %348)
store float %349, float* %26
%350 = load float*, float** %5
%351 = load i32, i32* %24
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds float, float* %350, i64 %352
%354 = load float, float* %353
%355 = load float, float* %10
%356 = load float*, float** %5
%357 = load i32, i32* %20
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds float, float* %356, i64 %358
%360 = load float, float* %359
%361 = load float, float* %11
%362 = fmul float %360, %361
%363 = fneg float %362
%364 = call float @llvm.fmuladd.f32(float %354, float %355, float %363)
store float %364, float* %27
%365 = load float*, float** %5
%366 = load i32, i32* %21
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds float, float* %365, i64 %367
%369 = load float, float* %368
%370 = load float, float* %12
%371 = load float*, float** %5
%372 = load i32, i32* %25
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds float, float* %371, i64 %373
%375 = load float, float* %374
%376 = load float, float* %13
%377 = fmul float %375, %376
%378 = call float @llvm.fmuladd.f32(float %369, float %370, float %377)
store float %378, float* %28
%379 = load float*, float** %5
%380 = load i32, i32* %25
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds float, float* %379, i64 %381
%383 = load float, float* %382
%384 = load float, float* %12
%385 = load float*, float** %5
%386 = load i32, i32* %21
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds float, float* %385, i64 %387
%389 = load float, float* %388
%390 = load float, float* %13
%391 = fmul float %389, %390
%392 = fneg float %391
%393 = call float @llvm.fmuladd.f32(float %383, float %384, float %392)
store float %393, float* %29
%394 = load float, float* %26
%395 = load float, float* %28
%396 = fadd float %394, %395
store float %396, float* %30
%397 = load float, float* %27
%398 = load float, float* %29
%399 = fadd float %397, %398
store float %399, float* %31
%400 = load float, float* %26
%401 = load float, float* %28
%402 = fsub float %400, %401
store float %402, float* %28
%403 = load float, float* %27
%404 = load float, float* %29
%405 = fsub float %403, %404
store float %405, float* %29
%406 = load float*, float** %5
%407 = load i32, i32* %23
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds float, float* %406, i64 %408
%410 = load float, float* %409
%411 = load float, float* %31
%412 = fadd float %410, %411
store float %412, float* %27
%413 = load float, float* %31
%414 = load float*, float** %5
%415 = load i32, i32* %23
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds float, float* %414, i64 %416
%418 = load float, float* %417
%419 = fsub float %413, %418
%420 = load float*, float** %5
%421 = load i32, i32* %20
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds float, float* %420, i64 %422
store float %419, float* %423
%424 = load float, float* %27
%425 = load float*, float** %5
%426 = load i32, i32* %25
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds float, float* %425, i64 %427
store float %424, float* %428
%429 = load float*, float** %5
%430 = load i32, i32* %19
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds float, float* %429, i64 %431
%433 = load float, float* %432
%434 = load float, float* %28
%435 = fsub float %433, %434
store float %435, float* %27
%436 = load float*, float** %5
%437 = load i32, i32* %19
%438 = sext i32 %437 to i64
%439 = getelementptr inbounds float, float* %436, i64 %438
%440 = load float, float* %439
%441 = fneg float %440
%442 = load float, float* %28
%443 = fsub float %441, %442
%444 = load float*, float** %5
%445 = load i32, i32* %24
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds float, float* %444, i64 %446
store float %443, float* %447
%448 = load float, float* %27
%449 = load float*, float** %5
%450 = load i32, i32* %21
%451 = sext i32 %450 to i64
%452 = getelementptr inbounds float, float* %449, i64 %451
store float %448, float* %452
%453 = load float*, float** %5
%454 = load i32, i32* %18
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds float, float* %453, i64 %455
%457 = load float, float* %456
%458 = load float, float* %30
%459 = fadd float %457, %458
store float %459, float* %26
%460 = load float*, float** %5
%461 = load i32, i32* %18
%462 = sext i32 %461 to i64
%463 = getelementptr inbounds float, float* %460, i64 %462
%464 = load float, float* %463
%465 = load float, float* %30
%466 = fsub float %464, %465
%467 = load float*, float** %5
%468 = load i32, i32* %23
%469 = sext i32 %468 to i64
%470 = getelementptr inbounds float, float* %467, i64 %469
store float %466, float* %470
%471 = load float, float* %26
%472 = load float*, float** %5
%473 = load i32, i32* %18
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds float, float* %472, i64 %474
store float %471, float* %475
%476 = load float*, float** %5
%477 = load i32, i32* %22
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds float, float* %476, i64 %478
%480 = load float, float* %479
%481 = load float, float* %29
%482 = fadd float %480, %481
store float %482, float* %26
%483 = load float, float* %29
%484 = load float*, float** %5
%485 = load i32, i32* %22
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds float, float* %484, i64 %486
%488 = load float, float* %487
%489 = fsub float %488, %483
store float %489, float* %487
%490 = load float, float* %26
%491 = load float*, float** %5
%492 = load i32, i32* %19
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds float, float* %491, i64 %493
store float %490, float* %494
br label %495
495: ; preds = %308
%496 = load i32, i32* %16
%497 = load i32, i32* %35
%498 = add nsw i32 %497, %496
store i32 %498, i32* %35
br label %304
499: ; preds = %304
%500 = load i32, i32* %16
%501 = shl i32 %500, 1
%502 = load i32, i32* %32
%503 = sub nsw i32 %501, %502
store i32 %503, i32* %15
%504 = load i32, i32* %16
%505 = shl i32 %504, 2
store i32 %505, i32* %16
br label %506
506: ; preds = %499
%507 = load i32, i32* %15
%508 = load i32, i32* %4
%509 = icmp slt i32 %507, %508
br i1 %509, label %302, label %510
510: ; preds = %506
br label %511
511: ; preds = %510
%512 = load i32, i32* %36
%513 = add nsw i32 %512, 1
store i32 %513, i32* %36
br label %273
514: ; preds = %273
br label %98
515: ; preds = %98
ret void
}

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