#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 /*<<< orphan*/ assert(int);
float cos(float);
int floor(int);
int log(double);
float sin(float);
void rfft(float X[], int N) {
  assert(log(N) / log(2.0) == floor(log(N) / log(2.0)));
  int I, I0, I1, I2, I3, I4, I5, I6, I7, I8, IS, ID;
  int J, K, M, N2, N4, N8;
  float A, A3, CC1, SS1, CC3, SS3, E, R1, XT;
  float T1, T2, T3, T4, T5, T6;
  M = (int)(log(N) / log(2.0));
  J = 1;
  for (I = 1; I < N; I++) {
    if (I < J) {
      XT = X[J];
      X[J] = X[I];
      X[I] = XT;
    }
    K = N / 2;
    while (K < J) {
      J -= K;
      K /= 2;
    }
    J += K;
  }
  IS = 1;
  ID = 4;
  do {
    for (I0 = IS; I0 <= N; I0 += ID) {
      I1 = I0 + 1;
      R1 = X[I0];
      X[I0] = R1 + X[I1];
      X[I1] = R1 - X[I1];
    }
    IS = 2 * ID - 1;
    ID = 4 * ID;
  } while (IS < N);
  N2 = 2;
  for (K = 2; K <= M; K++) {
    N2 = N2 * 2;
    N4 = N2 / 4;
    N8 = N2 / 8;
    E = (float)6.2831853071719586f / N2;
    IS = 0;
    ID = N2 * 2;
    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[I4] - X[I3];
        X[I3] = X[I1] - T1;
        X[I1] = X[I1] + T1;
        if (N4 != 1) {
          I1 += N8;
          I2 += N8;
          I3 += N8;
          I4 += N8;
          T1 = (X[I3] + X[I4]) * .7071067811865475244f;
          T2 = (X[I3] - X[I4]) * .7071067811865475244f;
          X[I4] = X[I2] - T1;
          X[I3] = -X[I2] - T1;
          X[I2] = X[I1] - T2;
          X[I1] = X[I1] + T2;
        }
      }
      IS = 2 * ID - N2;
      ID = 4 * ID;
    } while (IS < N);
    A = E;
    for (J = 2; J <= N8; J++) {
      A3 = 3.0 * A;
      CC1 = cos(A);
      SS1 = sin(A);
      CC3 = cos(A3);
      SS3 = sin(A3);
      A = (float)J * E;
      IS = 0;
      ID = 2 * N2;
      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] = X[I5] - T4;
          X[I2] = T1;
        }
        IS = 2 * ID - N2;
        ID = 4 * ID;
      } while (IS < N);
    }
  }
  return;
}


x86 assembly (clang, -O0):
<rfft>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm0
call   1060 <log@plt>
mov    %eax,-0xa0(%rbp)
movsd  0xe86(%rip),%xmm0
call   1060 <log@plt>
mov    %eax,%ecx
mov    -0xa0(%rbp),%eax
cltd
idiv   %ecx
mov    %eax,-0x98(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm0
call   1060 <log@plt>
mov    %eax,-0x9c(%rbp)
movsd  0xe58(%rip),%xmm0
call   1060 <log@plt>
mov    %eax,%ecx
mov    -0x9c(%rbp),%eax
cltd
idiv   %ecx
mov    %eax,%edi
call   1070 <floor@plt>
mov    %eax,%ecx
mov    -0x98(%rbp),%eax
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cvtsi2sdl -0xc(%rbp),%xmm0
call   1060 <log@plt>
mov    %eax,-0x94(%rbp)
movsd  0xe12(%rip),%xmm0
call   1060 <log@plt>
mov    %eax,%ecx
mov    -0x94(%rbp),%eax
cltd
idiv   %ecx
mov    %eax,-0x48(%rbp)
movl   $0x1,-0x40(%rbp)
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12b4 <rfft+0x164>
mov    -0x10(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1265 <rfft+0x115>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x78(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    129d <rfft+0x14d>
mov    -0x44(%rbp),%ecx
mov    -0x40(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x44(%rbp)
jmp    1273 <rfft+0x123>
mov    -0x44(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    120f <rfft+0xbf>
movl   $0x1,-0x38(%rbp)
movl   $0x4,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     133b <rfft+0x1eb>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    12c8 <rfft+0x178>
mov    -0x3c(%rbp),%eax
shl    $0x1,%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x3c(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     12c2 <rfft+0x172>
movl   $0x2,-0x4c(%rbp)
movl   $0x2,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     1984 <rfft+0x834>
mov    -0x4c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,-0x54(%rbp)
cvtsi2ssl -0x4c(%rbp),%xmm1
movss  0xc68(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x4c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    159b <rfft+0x44b>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x1,-0x50(%rbp)
je     1588 <rfft+0x438>
mov    -0x54(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x54(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x54(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x54(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  0xb49(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  0xb1e(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
subss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x80(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x80(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    158d <rfft+0x43d>
mov    -0x3c(%rbp),%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x10(%rbp)
jmp    13c7 <rfft+0x277>
mov    -0x3c(%rbp),%eax
shl    $0x1,%eax
sub    -0x4c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x3c(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     13c1 <rfft+0x271>
movss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x2,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     1971 <rfft+0x821>
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xa1e(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x58(%rbp),%xmm0
call   1050 <cos@plt>
movss  %xmm0,-0x60(%rbp)
movss  -0x58(%rbp),%xmm0
call   1040 <sin@plt>
movss  %xmm0,-0x64(%rbp)
movss  -0x5c(%rbp),%xmm0
call   1050 <cos@plt>
movss  %xmm0,-0x68(%rbp)
movss  -0x5c(%rbp),%xmm0
call   1040 <sin@plt>
movss  %xmm0,-0x6c(%rbp)
cvtsi2ssl -0x40(%rbp),%xmm0
mulss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x4c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    193d <rfft+0x7ed>
mov    -0x10(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%eax
add    -0x50(%rbp),%eax
sub    -0x40(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x60(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x60(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x64(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x68(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x68(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x6c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x80(%rbp),%xmm0
addss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x80(%rbp),%xmm0
subss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x80(%rbp)
movss  -0x90(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x80(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
subss  -0x84(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x80(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0x7c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x8c(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x7c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x88(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x10(%rbp)
jmp    1658 <rfft+0x508>
mov    -0x3c(%rbp),%eax
shl    $0x1,%eax
sub    -0x4c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x3c(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1652 <rfft+0x502>
jmp    1963 <rfft+0x813>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    15cd <rfft+0x47d>
jmp    1976 <rfft+0x826>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    136a <rfft+0x21a>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rfft>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %esi,%ebp
mov    %rdi,%rbx
cvtsi2sd %esi,%xmm0
movsd  %xmm0,0x8(%rsp)
call   1060 <log@plt>
mov    %eax,%r14d
movsd  0xe83(%rip),%xmm0
call   1060 <log@plt>
mov    %eax,%ecx
mov    %r14d,%eax
cltd
idiv   %ecx
mov    %eax,%r14d
movsd  0x8(%rsp),%xmm0
call   1060 <log@plt>
mov    %eax,%r15d
movsd  0xe5d(%rip),%xmm0
call   1060 <log@plt>
mov    %eax,%ecx
mov    %r15d,%eax
cltd
idiv   %ecx
mov    %eax,%edi
call   1070 <floor@plt>
xor    %edi,%edi
cmp    %eax,%r14d
sete   %dil
call   1030 <assert@plt>
movsd  0x8(%rsp),%xmm0
call   1060 <log@plt>
mov    %eax,%r14d
movsd  0xe25(%rip),%xmm0
call   1060 <log@plt>
mov    %ebp,%r8d
mov    %eax,%ecx
mov    %r14d,%eax
cltd
idiv   %ecx
mov    %eax,0x10(%rsp)
cmp    $0x2,%ebp
jl     124c <rfft+0xfc>
mov    %r8d,%eax
mov    $0x1,%edx
mov    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %edx,%rsi
cmp    %rsi,%rcx
jge    122c <rfft+0xdc>
movss  (%rbx,%rsi,4),%xmm0
movss  (%rbx,%rcx,4),%xmm1
movss  %xmm1,(%rbx,%rsi,4)
movss  %xmm0,(%rbx,%rcx,4)
mov    %r8d,%ebp
nop
mov    %edx,%esi
mov    %ebp,%edi
shr    $0x1f,%edi
add    %edi,%ebp
sar    %ebp
sub    %ebp,%edx
jg     1230 <rfft+0xe0>
add    %ebp,%esi
add    $0x1,%rcx
mov    %esi,%edx
cmp    %rax,%rcx
jne    1210 <rfft+0xc0>
movslq %r8d,%rsi
mov    $0x1,%ecx
mov    $0x4,%eax
jmp    1271 <rfft+0x121>
nopl   0x0(%rax,%rax,1)
lea    (%rax,%rax,1),%edx
lea    (%rax,%rax,1),%ecx
add    $0xffffffff,%ecx
shl    $0x2,%eax
cmp    %r8d,%edx
jg     12ab <rfft+0x15b>
cmp    %r8d,%ecx
jg     1260 <rfft+0x110>
movslq %ecx,%rcx
movslq %eax,%rdx
nopl   0x0(%rax)
movss  (%rbx,%rcx,4),%xmm0
movss  0x4(%rbx,%rcx,4),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rbx,%rcx,4)
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%rbx,%rcx,4)
add    %rdx,%rcx
cmp    %rsi,%rcx
jle    1280 <rfft+0x130>
jmp    1260 <rfft+0x110>
mov    %rsi,0x8(%rsp)
mov    %r8d,0x4(%rsp)
cmpl   $0x2,0x10(%rsp)
jge    12cb <rfft+0x17b>
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x4(%rbx),%rax
mov    %rax,0x58(%rsp)
lea    0x8(%rbx),%rax
mov    %rax,0x50(%rsp)
movss  0xd23(%rip),%xmm4
movaps 0xd34(%rip),%xmm7
mov    $0x2,%eax
mov    $0x2,%ecx
jmp    131a <rfft+0x1ca>
nopl   0x0(%rax,%rax,1)
mov    0x60(%rsp),%rcx
lea    0x1(%rcx),%eax
cmp    0x10(%rsp),%ecx
movss  0xcf4(%rip),%xmm4
mov    0x3c(%rsp),%ecx
je     12bc <rfft+0x16c>
mov    %rax,0x60(%rsp)
mov    %ecx,%r14d
shr    $0x1f,%ecx
add    %r14d,%ecx
sar    %ecx
lea    0x3(%r14),%edx
test   %r14d,%r14d
cmovns %r14d,%edx
lea    (%r14,%r14,1),%eax
mov    %eax,0x3c(%rsp)
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
sar    $0x2,%edx
lea    0x0(,%r14,4),%r9d
mov    %rdx,%r15
movslq %edx,%rax
mov    %ecx,0x14(%rsp)
movslq %ecx,%rbp
lea    (%rax,%rbp,1),%rcx
mov    0x58(%rsp),%rdi
lea    (%rdi,%rcx,4),%rcx
lea    (%rax,%rbp,2),%rdx
lea    (%rdi,%rdx,4),%r10
lea    (%rdi,%rbp,8),%rsi
mov    %rbp,%r12
lea    0x0(%rbp,%rbp,2),%r8
lea    (%r8,%rax,1),%rdx
lea    (%rdi,%rdx,4),%r11
lea    (%rdi,%r8,4),%rbp
lea    (%rdi,%rax,4),%rax
xor    %edx,%edx
mov    %r9d,0x44(%rsp)
mov    0x4(%rsp),%edi
jmp    13b8 <rfft+0x268>
nopw   0x0(%rax,%rax,1)
mov    %r9d,%edx
sub    %r14d,%edx
add    %edx,%edx
shl    $0x2,%r9d
mov    0x4(%rsp),%edi
cmp    %edi,%edx
jge    1480 <rfft+0x330>
cmp    %edi,%edx
jge    13a0 <rfft+0x250>
movslq %edx,%rdx
movslq %r9d,%rdi
jmp    13da <rfft+0x28a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    %rdi,%rdx
cmp    0x8(%rsp),%rdx
jge    13a0 <rfft+0x250>
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  0x4(%rbx,%rdx,4),%xmm1
subss  %xmm3,%xmm1
movss  %xmm1,(%rsi,%rdx,4)
addss  0x4(%rbx,%rdx,4),%xmm3
movss  %xmm3,0x4(%rbx,%rdx,4)
cmp    $0x2,%r14d
je     13d0 <rfft+0x280>
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    13d0 <rfft+0x280>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r14,0x70(%rsp)
cmp    $0x8,%r14d
jl     1300 <rfft+0x1b0>
movss  0xb74(%rip),%xmm8
divss  %xmm0,%xmm8
cmp    $0x3,%r15d
mov    $0x2,%eax
cmovl  %eax,%r15d
add    $0x1,%r15d
mov    %r15,0x68(%rsp)
mov    0x50(%rsp),%r13
mov    %r12,%rax
lea    0x0(,%r12,4),%r14
add    %r13,%r14
lea    0x0(%r13,%r12,8),%r15
lea    0x0(%r13,%r8,4),%r12
lea    0x0(,%rax,4),%ecx
mov    %rcx,0x28(%rsp)
lea    (%rax,%rax,2),%ecx
mov    %rcx,0x20(%rsp)
add    %eax,%eax
mov    %rax,0x30(%rsp)
mov    $0x2,%ebp
movss  %xmm8,0x40(%rsp)
jmp    155b <rfft+0x40b>
nopl   0x0(%rax)
mulss  0x40(%rsp),%xmm8
mov    0x18(%rsp),%rbp
add    $0x1,%rbp
add    $0x4,%r13
add    $0x4,%r14
add    $0x4,%r15
add    $0x4,%r12
mov    0x28(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x28(%rsp)
mov    0x20(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x20(%rsp)
mov    0x30(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x30(%rsp)
add    $0xffffffff,%r11d
mov    %r11d,0x14(%rsp)
cmp    0x68(%rsp),%rbp
je     1300 <rfft+0x1b0>
movss  %xmm8,(%rsp)
movaps %xmm8,%xmm0
mulss  0xaa3(%rip),%xmm0
movss  %xmm0,0x18(%rsp)
movaps %xmm8,%xmm0
call   1050 <cos@plt>
movss  %xmm0,0x4c(%rsp)
movss  (%rsp),%xmm0
call   1040 <sin@plt>
movss  %xmm0,(%rsp)
movss  0x18(%rsp),%xmm0
call   1050 <cos@plt>
movss  %xmm0,0x48(%rsp)
movss  0x18(%rsp),%xmm0
call   1040 <sin@plt>
movss  0x48(%rsp),%xmm11
movss  (%rsp),%xmm10
movss  0x4c(%rsp),%xmm9
movaps 0xa58(%rip),%xmm7
mov    %rbp,0x18(%rsp)
xorps  %xmm8,%xmm8
cvtsi2ss %ebp,%xmm8
xor    %ecx,%ecx
mov    0x44(%rsp),%eax
mov    0x4(%rsp),%r9d
mov    0x8(%rsp),%r10
mov    0x14(%rsp),%r11d
jmp    1604 <rfft+0x4b4>
nopl   (%rax)
mov    %eax,%ecx
sub    0x70(%rsp),%ecx
add    %ecx,%ecx
shl    $0x2,%eax
cmp    %r9d,%ecx
jge    1500 <rfft+0x3b0>
cmp    %r9d,%ecx
jge    15f0 <rfft+0x4a0>
movslq %ecx,%rdx
movslq %eax,%r8
mov    0x28(%rsp),%rsi
lea    (%rsi,%rcx,1),%edi
mov    0x20(%rsp),%rsi
lea    (%rsi,%rcx,1),%ebp
mov    0x30(%rsp),%rsi
add    %ecx,%esi
add    %r11d,%ecx
nopl   0x0(%rax)
movss  (%r15,%rdx,4),%xmm2
movslq %ebp,%rbp
movss  (%rbx,%rbp,4),%xmm1
movaps %xmm10,%xmm3
mulss  %xmm1,%xmm3
movaps %xmm10,%xmm4
mulss  %xmm2,%xmm4
mulss  %xmm9,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm9,%xmm1
subss  %xmm4,%xmm1
movss  (%r12,%rdx,4),%xmm3
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm4
movaps %xmm0,%xmm5
mulss  %xmm4,%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  (%rbx,%rsi,4),%xmm3
movaps %xmm3,%xmm4
addss  %xmm6,%xmm4
subss  %xmm3,%xmm6
movss  %xmm6,(%r15,%rdx,4)
movss  %xmm4,(%rbx,%rdi,4)
movss  (%r14,%rdx,4),%xmm3
movaps %xmm3,%xmm4
subss  %xmm2,%xmm4
xorps  %xmm7,%xmm3
subss  %xmm2,%xmm3
movss  %xmm3,(%rbx,%rbp,4)
movss  %xmm4,(%r12,%rdx,4)
movss  0x0(%r13,%rdx,4),%xmm2
movaps %xmm5,%xmm3
addss  %xmm2,%xmm3
subss  %xmm5,%xmm2
movss  %xmm2,(%rbx,%rsi,4)
movss  %xmm3,0x0(%r13,%rdx,4)
movslq %ecx,%rcx
movss  (%rbx,%rcx,4),%xmm2
movaps %xmm1,%xmm3
addss  %xmm2,%xmm3
subss  %xmm1,%xmm2
movss  %xmm2,(%rbx,%rcx,4)
movss  %xmm3,(%r14,%rdx,4)
add    %r8,%rdx
add    %eax,%edi
add    %eax,%ebp
add    %eax,%esi
add    %eax,%ecx
cmp    %r10,%rdx
jl     1630 <rfft+0x4e0>
jmp    15f0 <rfft+0x4a0>

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

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