#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*/ CheckPointer(float *, char *);
int /*<<< orphan*/ IsPowerOfTwo(unsigned int);
unsigned int NumberOfBitsNeeded(unsigned int);
unsigned int ReverseBits(unsigned int, unsigned int);
double cos(double);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, unsigned int);
double sin(double);
int /*<<< orphan*/ stderr;
void fft_float_StrictFP(unsigned NumSamples, int InverseTransform,
                        float *RealIn, float *ImagIn, float *RealOut,
                        float *ImagOut) {
#pragma STDC FP_CONTRACT OFF
  unsigned NumBits;
  unsigned i, j, k, n;
  unsigned BlockSize, BlockEnd;
  double angle_numerator = 2.0 * (3.14159265358979323846);
  double tr, ti;
  if (!IsPowerOfTwo(NumSamples)) {
    fprintf(stderr, "Error in fft():  NumSamples=%u is not power of two\n",
            NumSamples);
    exit(1);
  }
  if (InverseTransform)
    angle_numerator = -angle_numerator;
  CheckPointer(RealIn, "RealIn");
  CheckPointer(RealOut, "RealOut");
  CheckPointer(ImagOut, "ImagOut");
  NumBits = NumberOfBitsNeeded(NumSamples);
  for (i = 0; i < NumSamples; i++) {
    j = ReverseBits(i, NumBits);
    RealOut[j] = RealIn[i];
    ImagOut[j] = (ImagIn == NULL) ? 0.0 : ImagIn[i];
  }
  BlockEnd = 1;
  for (BlockSize = 2; BlockSize <= NumSamples; BlockSize <<= 1) {
    double delta_angle = angle_numerator / (double)BlockSize;
    double sm2 = sin(-2 * delta_angle);
    double sm1 = sin(-delta_angle);
    double cm2 = cos(-2 * delta_angle);
    double cm1 = cos(-delta_angle);
    double w = 2 * cm1;
    double ar[3], ai[3];
    double temp;
    for (i = 0; i < NumSamples; i += BlockSize) {
      ar[2] = cm2;
      ar[1] = cm1;
      ai[2] = sm2;
      ai[1] = sm1;
      for (j = i, n = 0; n < BlockEnd; j++, n++) {
        ar[0] = w * ar[1] - ar[2];
        ar[2] = ar[1];
        ar[1] = ar[0];
        ai[0] = w * ai[1] - ai[2];
        ai[2] = ai[1];
        ai[1] = ai[0];
        k = j + BlockEnd;
        tr = ar[0] * RealOut[k] - ai[0] * ImagOut[k];
        ti = ar[0] * ImagOut[k] + ai[0] * RealOut[k];
        RealOut[k] = RealOut[j] - tr;
        ImagOut[k] = ImagOut[j] - ti;
        RealOut[j] += tr;
        ImagOut[j] += ti;
      }
    }
    BlockEnd = BlockSize;
  }
  if (InverseTransform) {
    double denom = (double)NumSamples;
    for (i = 0; i < NumSamples; i++) {
      RealOut[i] /= denom;
      ImagOut[i] /= denom;
    }
  }
}


x86 assembly (clang, -O0):
<fft_float_StrictFP>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movsd  0xe57(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x4(%rbp),%edi
call   1040 <IsPowerOfTwo@plt>
cmp    $0x0,%eax
jne    11e1 <fft_float_StrictFP+0x61>
mov    0x2e1a(%rip),%rax
mov    (%rax),%edi
mov    -0x4(%rbp),%edx
lea    0xe46(%rip),%rsi
call   1050 <fprintf@plt>
mov    $0x1,%edi
call   1090 <exit@plt>
cmpl   $0x0,-0x8(%rbp)
je     120c <fft_float_StrictFP+0x8c>
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rdi
lea    0xe35(%rip),%rsi
call   10a0 <CheckPointer@plt>
mov    -0x20(%rbp),%rdi
lea    0xe2c(%rip),%rsi
call   10a0 <CheckPointer@plt>
mov    -0x28(%rbp),%rdi
lea    0xe24(%rip),%rsi
call   10a0 <CheckPointer@plt>
mov    -0x4(%rbp),%edi
call   1030 <NumberOfBitsNeeded@plt>
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    12d9 <fft_float_StrictFP+0x159>
mov    -0x30(%rbp),%edi
mov    -0x2c(%rbp),%esi
call   1080 <ReverseBits@plt>
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
cmpq   $0x0,-0x18(%rbp)
jne    129b <fft_float_StrictFP+0x11b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    12b3 <fft_float_StrictFP+0x133>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    124e <fft_float_StrictFP+0xce>
movl   $0x1,-0x44(%rbp)
movl   $0x2,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
ja     15d8 <fft_float_StrictFP+0x458>
movsd  -0x50(%rbp),%xmm0
mov    -0x40(%rbp),%eax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0xcff(%rip),%xmm0
mulsd  -0x68(%rbp),%xmm0
call   1060 <sin@plt>
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
call   1060 <sin@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  0xcc2(%rip),%xmm0
mulsd  -0x68(%rbp),%xmm0
call   1070 <cos@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
call   1070 <cos@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0xc7a(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    15c4 <fft_float_StrictFP+0x444>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jae    15b1 <fft_float_StrictFP+0x431>
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0xc8(%rbp),%xmm0
ff
subsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x34(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  -0xd0(%rbp),%xmm1
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  -0xd0(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  -0x58(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  -0x60(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0x58(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movsd  -0x60(%rbp),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13f5 <fft_float_StrictFP+0x275>
jmp    15b6 <fft_float_StrictFP+0x436>
mov    -0x40(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    13a5 <fft_float_StrictFP+0x225>
mov    -0x40(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    12e7 <fft_float_StrictFP+0x167>
cmpl   $0x0,-0x8(%rbp)
je     1662 <fft_float_StrictFP+0x4e2>
mov    -0x4(%rbp),%eax
cvtsi2sd %rax,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    165d <fft_float_StrictFP+0x4dd>
movsd  -0xe0(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movsd  -0xe0(%rbp),%xmm1
ff
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15f9 <fft_float_StrictFP+0x479>
jmp    1662 <fft_float_StrictFP+0x4e2>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fft_float_StrictFP>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9,%r14
mov    %r8,%rbx
mov    %rcx,%r12
mov    %rdx,%r13
mov    %esi,%ebp
mov    %edi,%r15d
call   1040 <IsPowerOfTwo@plt>
test   %eax,%eax
je     1536 <fft_float_StrictFP+0x3b6>
mov    %ebp,0x24(%rsp)
test   %ebp,%ebp
sete   0x30(%rsp)
lea    0xe9e(%rip),%rsi
mov    %r13,0x18(%rsp)
mov    %r13,%rdi
call   10a0 <CheckPointer@plt>
lea    0xe91(%rip),%rsi
mov    %rbx,%rdi
call   10a0 <CheckPointer@plt>
lea    0xe8a(%rip),%rsi
mov    %r14,%rdi
call   10a0 <CheckPointer@plt>
mov    %r15d,%edi
call   1030 <NumberOfBitsNeeded@plt>
test   %r15d,%r15d
je     1527 <fft_float_StrictFP+0x3a7>
mov    %eax,%ebp
mov    %r15d,%eax
mov    %rax,0x8(%rsp)
xor    %ecx,%ecx
mov    0x30(%rsp),%al
mov    %al,%cl
lea    0xded(%rip),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x40(%rsp)
xor    %r13d,%r13d
jmp    1252 <fft_float_StrictFP+0xd2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%r12,%r13,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x8(%rsp),%rcx
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%r14,%rax,4)
add    $0x1,%r13
cmp    %r13,%rcx
je     1278 <fft_float_StrictFP+0xf8>
mov    %r13d,%edi
mov    %ebp,%esi
call   1080 <ReverseBits@plt>
mov    0x18(%rsp),%rcx
movss  (%rcx,%r13,4),%xmm0
mov    %eax,%eax
movss  %xmm0,(%rbx,%rax,4)
test   %r12,%r12
jne    1230 <fft_float_StrictFP+0xb0>
xorps  %xmm0,%xmm0
jmp    123a <fft_float_StrictFP+0xba>
cmp    $0x2,%r15d
jae    12af <fft_float_StrictFP+0x12f>
cmpl   $0x0,0x24(%rsp)
mov    0x8(%rsp),%rsi
je     1527 <fft_float_StrictFP+0x3a7>
test   %r15d,%r15d
je     1527 <fft_float_StrictFP+0x3a7>
xorps  %xmm0,%xmm0
cvtsi2sd %rsi,%xmm0
cmp    $0x4,%esi
jae    1458 <fft_float_StrictFP+0x2d8>
xor    %eax,%eax
jmp    14f0 <fft_float_StrictFP+0x370>
mov    $0x1,%ebp
mov    $0x2,%eax
jmp    12cc <fft_float_StrictFP+0x14c>
nopl   0x0(%rax,%rax,1)
lea    (%r12,%r12,1),%eax
mov    %r12d,%ebp
cmp    %r15d,%eax
ja     127e <fft_float_StrictFP+0xfe>
mov    %eax,%r12d
mov    %eax,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
movsd  0x40(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x28(%rsp)
movapd %xmm1,%xmm0
mulsd  0xd2b(%rip),%xmm0
movsd  %xmm0,0x10(%rsp)
call   1060 <sin@plt>
movsd  %xmm0,0x18(%rsp)
movsd  0x28(%rsp),%xmm0
call   1060 <sin@plt>
xorps  0xcf8(%rip),%xmm0
movaps %xmm0,0x30(%rsp)
movsd  0x10(%rsp),%xmm0
call   1070 <cos@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x28(%rsp),%xmm0
call   1070 <cos@plt>
movapd %xmm0,%xmm8
addsd  %xmm0,%xmm8
xor    %eax,%eax
mov    %ebp,%ecx
jmp    135f <fft_float_StrictFP+0x1df>
nopl   0x0(%rax)
add    %r12d,%eax
add    %r12d,%ecx
cmp    %r15d,%eax
jae    12c0 <fft_float_StrictFP+0x140>
test   %ebp,%ebp
je     1350 <fft_float_StrictFP+0x1d0>
xor    %edx,%edx
movapd 0x30(%rsp),%xmm5
movsd  0x18(%rsp),%xmm6
movapd %xmm0,%xmm4
movsd  0x10(%rsp),%xmm7
nopl   0x0(%rax,%rax,1)
movapd %xmm4,%xmm9
movapd %xmm5,%xmm2
lea    (%rax,%rdx,1),%esi
movapd %xmm8,%xmm4
mulsd  %xmm9,%xmm4
movapd %xmm8,%xmm5
subsd  %xmm7,%xmm4
mulsd  %xmm2,%xmm5
lea    (%rcx,%rdx,1),%edi
movss  (%rbx,%rdi,4),%xmm7
subsd  %xmm6,%xmm5
xorps  %xmm6,%xmm6
cvtss2sd %xmm7,%xmm6
movapd %xmm4,%xmm7
movss  (%r14,%rdi,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm6,%xmm7
movapd %xmm5,%xmm3
mulsd  %xmm1,%xmm3
subsd  %xmm3,%xmm7
movss  (%rbx,%rsi,4),%xmm3
cvtss2sd %xmm3,%xmm3
subsd  %xmm7,%xmm3
cvtsd2ss %xmm3,%xmm3
mulsd  %xmm4,%xmm1
mulsd  %xmm5,%xmm6
movss  %xmm3,(%rbx,%rdi,4)
movss  (%r14,%rsi,4),%xmm3
addsd  %xmm1,%xmm6
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
subsd  %xmm6,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%r14,%rdi,4)
movss  (%rbx,%rsi,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm7,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%rbx,%rsi,4)
movss  (%r14,%rsi,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm6,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%r14,%rsi,4)
add    $0x1,%edx
movapd %xmm2,%xmm6
movapd %xmm9,%xmm7
cmp    %edx,%ebp
jne    1380 <fft_float_StrictFP+0x200>
jmp    1350 <fft_float_StrictFP+0x1d0>
lea    (%r14,%rsi,4),%rax
cmp    %rbx,%rax
jbe    1471 <fft_float_StrictFP+0x2f1>
lea    (%rbx,%rsi,4),%rax
cmp    %r14,%rax
jbe    1471 <fft_float_StrictFP+0x2f1>
xor    %eax,%eax
jmp    14f0 <fft_float_StrictFP+0x370>
mov    %esi,%eax
and    $0xfffffffc,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    0x0(,%rsi,4),%rcx
and    $0xfffffffffffffff0,%rcx
xor    %edx,%edx
nopl   0x0(%rax)
cvtps2pd 0x8(%rbx,%rdx,1),%xmm2
cvtps2pd (%rbx,%rdx,1),%xmm3
divpd  %xmm1,%xmm3
divpd  %xmm1,%xmm2
cvtpd2ps %xmm2,%xmm2
cvtpd2ps %xmm3,%xmm3
unpcklpd %xmm2,%xmm3
movupd %xmm3,(%rbx,%rdx,1)
cvtps2pd 0x8(%r14,%rdx,1),%xmm2
cvtps2pd (%r14,%rdx,1),%xmm3
divpd  %xmm1,%xmm3
divpd  %xmm1,%xmm2
cvtpd2ps %xmm2,%xmm2
cvtpd2ps %xmm3,%xmm3
unpcklpd %xmm2,%xmm3
movupd %xmm3,(%r14,%rdx,1)
add    $0x10,%rdx
cmp    %rdx,%rcx
jne    1490 <fft_float_StrictFP+0x310>
cmp    %rsi,%rax
je     1527 <fft_float_StrictFP+0x3a7>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rbx,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%rbx,%rax,4)
movss  (%r14,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%r14,%rax,4)
add    $0x1,%rax
cmp    %rax,%rsi
jne    14f0 <fft_float_StrictFP+0x370>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x2aa3(%rip),%rax
mov    (%rax),%edi
lea    0xae2(%rip),%rsi
mov    %r15d,%edx
call   1050 <fprintf@plt>
mov    $0x1,%edi
call   1090 <exit@plt>

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

LLVM IR (-O2):
@stderr = global i32 0
@.str = [52 x i8] c"Error in fft(): NumSamples=%u is not power of two\0A\00"
@.str.1 = [7 x i8] c"RealIn\00"
@.str.2 = [8 x i8] c"RealOut\00"
@.str.3 = [8 x i8] c"ImagOut\00"
define void @fft_float_StrictFP(i32 %0, i32 %1, float* %2, float* %3, float* %4, float* %5) {
%7 = tail call i32 @IsPowerOfTwo(i32 %0)
%8 = icmp eq i32 %7, 0
br i1 %8, label %9, label %13
9: ; preds = %6
%10 = load i32, i32* @stderr
%11 = tail call i32 @fprintf(i32 %10, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str, i64 0, i64 0), i32 %0)
%12 = tail call i32 @exit(i32 1)
unreachable
13: ; preds = %6
%14 = icmp eq i32 %1, 0
%15 = select i1 %14, double 0x401921FB54442D18, double 0xC01921FB54442D18
%16 = tail call i32 @CheckPointer(float* %2, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0))
%17 = tail call i32 @CheckPointer(float* %4, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
%18 = tail call i32 @CheckPointer(float* %5, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0))
%19 = tail call i32 @NumberOfBitsNeeded(i32 %0)
%20 = icmp eq i32 %0, 0
br i1 %20, label %164, label %21
21: ; preds = %13
%22 = icmp eq float* %3, null
%23 = zext i32 %0 to i64
br label %26
24: ; preds = %38
%25 = icmp ult i32 %0, 2
br i1 %25, label %112, label %44
26: ; preds = %21, %38
%27 = phi i64 [ 0, %21 ], [ %42, %38 ]
%28 = trunc i64 %27 to i32
%29 = tail call i32 @ReverseBits(i32 %28, i32 %19)
%30 = getelementptr inbounds float, float* %2, i64 %27
%31 = load float, float* %30
%32 = zext i32 %29 to i64
%33 = getelementptr inbounds float, float* %4, i64 %32
store float %31, float* %33
br i1 %22, label %38, label %34
34: ; preds = %26
%35 = getelementptr inbounds float, float* %3, i64 %27
%36 = load float, float* %35
%37 = fpext float %36 to double
br label %38
38: ; preds = %26, %34
%39 = phi double [ %37, %34 ], [ 0.000000e+00, %26 ]
%40 = fptrunc double %39 to float
%41 = getelementptr inbounds float, float* %5, i64 %32
store float %40, float* %41
%42 = add nuw nsw i64 %27, 1
%43 = icmp eq i64 %42, %23
br i1 %43, label %24, label %26
44: ; preds = %24, %109
%45 = phi i32 [ %110, %109 ], [ 2, %24 ]
%46 = phi i32 [ %45, %109 ], [ 1, %24 ]
%47 = uitofp i32 %45 to double
%48 = fdiv double %15, %47
%49 = fmul double %48, -2.000000e+00
%50 = tail call double @sin(double %49)
%51 = tail call double @sin(double %48)
%52 = fneg double %51
%53 = tail call double @cos(double %49)
%54 = tail call double @cos(double %48)
%55 = fmul double %54, 2.000000e+00
%56 = icmp eq i32 %46, 0
br label %57
57: ; preds = %44, %105
%58 = phi i32 [ %46, %44 ], [ %108, %105 ]
%59 = phi i32 [ 0, %44 ], [ %106, %105 ]
br i1 %56, label %105, label %60
60: ; preds = %57, %60
%61 = phi i32 [ %103, %60 ], [ %59, %57 ]
%62 = phi double [ %69, %60 ], [ %52, %57 ]
%63 = phi double [ %62, %60 ], [ %50, %57 ]
%64 = phi double [ %67, %60 ], [ %54, %57 ]
%65 = phi double [ %64, %60 ], [ %53, %57 ]
%66 = fmul double %55, %64
%67 = fsub double %66, %65
%68 = fmul double %55, %62
%69 = fsub double %68, %63
%70 = add i32 %61, %46
%71 = zext i32 %70 to i64
%72 = getelementptr inbounds float, float* %4, i64 %71
%73 = load float, float* %72
%74 = fpext float %73 to double
%75 = fmul double %67, %74
%76 = getelementptr inbounds float, float* %5, i64 %71
%77 = load float, float* %76
%78 = fpext float %77 to double
%79 = fmul double %69, %78
%80 = fsub double %75, %79
%81 = fmul double %67, %78
%82 = fmul double %69, %74
%83 = fadd double %82, %81
%84 = zext i32 %61 to i64
%85 = getelementptr inbounds float, float* %4, i64 %84
%86 = load float, float* %85
%87 = fpext float %86 to double
%88 = fsub double %87, %80
%89 = fptrunc double %88 to float
store float %89, float* %72
%90 = getelementptr inbounds float, float* %5, i64 %84
%91 = load float, float* %90
%92 = fpext float %91 to double
%93 = fsub double %92, %83
%94 = fptrunc double %93 to float
store float %94, float* %76
%95 = load float, float* %85
%96 = fpext float %95 to double
%97 = fadd double %80, %96
%98 = fptrunc double %97 to float
store float %98, float* %85
%99 = load float, float* %90
%100 = fpext float %99 to double
%101 = fadd double %83, %100
%102 = fptrunc double %101 to float
store float %102, float* %90
%103 = add i32 %61, 1
%104 = icmp eq i32 %103, %58
br i1 %104, label %105, label %60
105: ; preds = %60, %57
%106 = add i32 %59, %45
%107 = icmp ult i32 %106, %0
%108 = add i32 %58, %45
br i1 %107, label %57, label %109
109: ; preds = %105
%110 = shl i32 %45, 1
%111 = icmp ugt i32 %110, %0
br i1 %111, label %112, label %44
112: ; preds = %109, %24
br i1 %14, label %164, label %113
113: ; preds = %112
%114 = uitofp i32 %0 to double
br i1 %20, label %164, label %115
115: ; preds = %113
%116 = zext i32 %0 to i64
%117 = icmp ult i32 %0, 4
br i1 %117, label %148, label %118
118: ; preds = %115
%119 = getelementptr float, float* %4, i64 %23
%120 = getelementptr float, float* %5, i64 %23
%121 = icmp ugt float* %120, %4
%122 = icmp ugt float* %119, %5
%123 = and i1 %121, %122
br i1 %123, label %148, label %124
124: ; preds = %118
%125 = and i64 %23, 4294967292
%126 = insertelement <4 x double> poison, double %114, i64 0
%127 = shufflevector <4 x double> %126, <4 x double> poison, <4 x i32> zeroinitializer
br label %128
128: ; preds = %128, %124
%129 = phi i64 [ 0, %124 ], [ %144, %128 ]
%130 = getelementptr inbounds float, float* %4, i64 %129
%131 = bitcast float* %130 to <4 x float>*
%132 = load <4 x float>, <4 x float>* %131
%133 = fpext <4 x float> %132 to <4 x double>
%134 = fdiv <4 x double> %133, %127
%135 = fptrunc <4 x double> %134 to <4 x float>
%136 = bitcast float* %130 to <4 x float>*
store <4 x float> %135, <4 x float>* %136
%137 = getelementptr inbounds float, float* %5, i64 %129
%138 = bitcast float* %137 to <4 x float>*
%139 = load <4 x float>, <4 x float>* %138
%140 = fpext <4 x float> %139 to <4 x double>
%141 = fdiv <4 x double> %140, %127
%142 = fptrunc <4 x double> %141 to <4 x float>
%143 = bitcast float* %137 to <4 x float>*
store <4 x float> %142, <4 x float>* %143
%144 = add nuw i64 %129, 4
%145 = icmp eq i64 %144, %125
br i1 %145, label %146, label %128
146: ; preds = %128
%147 = icmp eq i64 %125, %23
br i1 %147, label %164, label %148
148: ; preds = %118, %115, %146
%149 = phi i64 [ 0, %118 ], [ 0, %115 ], [ %125, %146 ]
br label %150
150: ; preds = %148, %150
%151 = phi i64 [ %162, %150 ], [ %149, %148 ]
%152 = getelementptr inbounds float, float* %4, i64 %151
%153 = load float, float* %152
%154 = fpext float %153 to double
%155 = fdiv double %154, %114
%156 = fptrunc double %155 to float
store float %156, float* %152
%157 = getelementptr inbounds float, float* %5, i64 %151
%158 = load float, float* %157
%159 = fpext float %158 to double
%160 = fdiv double %159, %114
%161 = fptrunc double %160 to float
store float %161, float* %157
%162 = add nuw nsw i64 %151, 1
%163 = icmp eq i64 %162, %116
br i1 %163, label %164, label %150
164: ; preds = %150, %146, %13, %113, %112
ret void
}