#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
float cosf(float);
int floor(int);
float sinf(float);
float sqrtf(float);
void DoDFTQuick(float *outbins, float *frequencies, int bins,
                const float *databuffer, int place_in_data_buffer,
                int size_of_data_buffer, float q, float speedup) {
  int i, j;
  for (i = 0; i < bins; i++) {
    int flirts = 0;
    float freq = frequencies[i];
    float phi = 0;
    int ftq = freq * q;
    int sampleplace = place_in_data_buffer;
    float advance = 3.14159 * 2.0 / freq;
    float binqtys = 0;
    float binqtyc = 0;
    int skip = floor(ftq / speedup);
    if (skip == 0)
      skip = 1;
    advance *= skip;
    for (j = 0; j <= ftq; j += skip) {
      float sample = databuffer[sampleplace];
      sampleplace =
          (sampleplace - skip + size_of_data_buffer) % size_of_data_buffer;
      float sv = sinf(phi) * sample;
      float cv = cosf(phi) * sample;
      binqtys += sv;
      binqtyc += cv;
      phi += advance;
      flirts++;
    }
    float amp = sqrtf(binqtys * binqtys + binqtyc * binqtyc);
    outbins[i] = amp / freq / q * skip;
  }
}


x86 assembly (clang, -O0):
<DoDFTQuick>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
movss  %xmm0,-0x2c(%rbp)
movss  %xmm1,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1312 <DoDFTQuick+0x1d2>
movl   $0x0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x40(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x48(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe3b(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
cvtsi2ssl -0x48(%rbp),%xmm0
divss  -0x30(%rbp),%xmm0
cvttss2si %xmm0,%edi
call   1060 <floor@plt>
mov    %eax,-0x5c(%rbp)
cmpl   $0x0,-0x5c(%rbp)
jne    1209 <DoDFTQuick+0xc9>
movl   $0x1,-0x5c(%rbp)
cvtsi2ssl -0x5c(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     12b9 <DoDFTQuick+0x179>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x4c(%rbp),%eax
sub    -0x5c(%rbp),%eax
add    -0x28(%rbp),%eax
cltd
idivl  -0x28(%rbp)
mov    %edx,-0x4c(%rbp)
movss  -0x44(%rbp),%xmm0
call   1030 <sinf@plt>
mulss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x44(%rbp),%xmm0
call   1040 <cosf@plt>
mulss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x64(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x68(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x50(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    121f <DoDFTQuick+0xdf>
movss  -0x54(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1050 <sqrtf@plt>
movss  %xmm0,-0x6c(%rbp)
movss  -0x6c(%rbp),%xmm0
divss  -0x40(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtsi2ssl -0x5c(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1170 <DoDFTQuick+0x30>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<DoDFTQuick>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
movss  %xmm1,0x14(%rsp)
mov    %r8d,0x10(%rsp)
mov    %rsi,0x38(%rsp)
mov    %rdi,0x30(%rsp)
test   %edx,%edx
jle    1321 <DoDFTQuick+0x1e1>
movaps %xmm0,%xmm1
mov    %r9d,%r15d
mov    %rcx,%r14
mov    %edx,%eax
mov    %rax,0x28(%rsp)
xor    %ebx,%ebx
movss  %xmm0,0x8(%rsp)
jmp    11d6 <DoDFTQuick+0x96>
cs nopw 0x0(%rax,%rax,1)
nop
movaps %xmm1,%xmm0
call   1050 <sqrtf@plt>
movss  0x8(%rsp),%xmm1
mov    %rbx,%r14
mov    0x20(%rsp),%rbx
movss  (%rsp),%xmm2
movss  0xc(%rsp),%xmm3
divss  %xmm2,%xmm0
divss  %xmm1,%xmm0
mulss  %xmm3,%xmm0
mov    0x30(%rsp),%rax
movss  %xmm0,(%rax,%rbx,4)
add    $0x1,%rbx
cmp    0x28(%rsp),%rbx
je     1321 <DoDFTQuick+0x1e1>
mov    0x38(%rsp),%rax
movss  (%rax,%rbx,4),%xmm0
movss  %xmm0,(%rsp)
mulss  %xmm1,%xmm0
cvttss2si %xmm0,%r12d
cvttps2dq %xmm0,%xmm0
cvtdq2ps %xmm0,%xmm0
divss  0x14(%rsp),%xmm0
cvttss2si %xmm0,%edi
call   1060 <floor@plt>
mov    %eax,%ebp
test   %eax,%eax
mov    $0x1,%eax
cmove  %eax,%ebp
xorps  %xmm2,%xmm2
cvtsi2ss %ebp,%xmm2
test   %r12d,%r12d
mov    %rbx,0x20(%rsp)
movss  %xmm2,0xc(%rsp)
js     12f0 <DoDFTQuick+0x1b0>
movss  (%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdc4(%rip),%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
mulss  %xmm2,%xmm0
movss  %xmm0,0x1c(%rsp)
mov    %r12d,0x18(%rsp)
mov    %r15d,%r12d
sub    %ebp,%r12d
xorps  %xmm1,%xmm1
xorps  %xmm0,%xmm0
xor    %r13d,%r13d
mov    %r14,%rbx
mov    0x10(%rsp),%r14d
nopl   (%rax)
movss  %xmm0,0x4(%rsp)
movaps %xmm1,0x60(%rsp)
movslq %r14d,%rcx
lea    (%r12,%rcx,1),%eax
cltd
idiv   %r15d
movss  (%rbx,%rcx,4),%xmm0
movaps %xmm0,0x50(%rsp)
mov    %edx,%r14d
movss  0x4(%rsp),%xmm0
call   1030 <sinf@plt>
movaps %xmm0,0x40(%rsp)
movss  0x4(%rsp),%xmm0
call   1040 <cosf@plt>
movaps 0x60(%rsp),%xmm1
movaps 0x50(%rsp),%xmm2
shufps $0x0,%xmm2,%xmm2
movaps 0x40(%rsp),%xmm3
unpcklps %xmm0,%xmm3
movss  0x4(%rsp),%xmm0
mulps  %xmm2,%xmm3
addps  %xmm3,%xmm1
addss  0x1c(%rsp),%xmm0
add    %ebp,%r13d
cmp    0x18(%rsp),%r13d
jle    1270 <DoDFTQuick+0x130>
jmp    12f6 <DoDFTQuick+0x1b6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorps  %xmm1,%xmm1
mov    %r14,%rbx
movaps %xmm1,%xmm0
mulps  %xmm1,%xmm0
shufps $0x55,%xmm0,%xmm0
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
ucomiss 0xcf9(%rip),%xmm1
jb     1190 <DoDFTQuick+0x50>
xorps  %xmm0,%xmm0
sqrtss %xmm1,%xmm0
jmp    1198 <DoDFTQuick+0x58>
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @DoDFTQuick(float* %0, float* %1, i32 %2, float* %3, i32 %4, i32 %5, float %6, float %7) {
%9 = alloca float*
%10 = alloca float*
%11 = alloca i32
%12 = alloca float*
%13 = alloca i32
%14 = alloca i32
%15 = alloca float
%16 = alloca float
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca float
%21 = alloca float
%22 = alloca i32
%23 = alloca i32
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca i32
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float
store float* %0, float** %9
store float* %1, float** %10
store i32 %2, i32* %11
store float* %3, float** %12
store i32 %4, i32* %13
store i32 %5, i32* %14
store float %6, float* %15
store float %7, float* %16
store i32 0, i32* %17
br label %32
32: ; preds = %125, %8
%33 = load i32, i32* %17
%34 = load i32, i32* %11
%35 = icmp slt i32 %33, %34
br i1 %35, label %36, label %128
36: ; preds = %32
store i32 0, i32* %19
%37 = load float*, float** %10
%38 = load i32, i32* %17
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds float, float* %37, i64 %39
%41 = load float, float* %40
store float %41, float* %20
store float 0.000000e+00, float* %21
%42 = load float, float* %20
%43 = load float, float* %15
%44 = fmul float %42, %43
%45 = fptosi float %44 to i32
store i32 %45, i32* %22
%46 = load i32, i32* %13
store i32 %46, i32* %23
%47 = load float, float* %20
%48 = fpext float %47 to double
%49 = fdiv double 6.283180e+00, %48
%50 = fptrunc double %49 to float
store float %50, float* %24
store float 0.000000e+00, float* %25
store float 0.000000e+00, float* %26
%51 = load i32, i32* %22
%52 = sitofp i32 %51 to float
%53 = load float, float* %16
%54 = fdiv float %52, %53
%55 = fptosi float %54 to i32
%56 = call i32 @floor(i32 %55)
store i32 %56, i32* %27
%57 = load i32, i32* %27
%58 = icmp eq i32 %57, 0
br i1 %58, label %59, label %60
59: ; preds = %36
store i32 1, i32* %27
br label %60
60: ; preds = %59, %36
%61 = load i32, i32* %27
%62 = sitofp i32 %61 to float
%63 = load float, float* %24
%64 = fmul float %63, %62
store float %64, float* %24
store i32 0, i32* %18
br label %65
65: ; preds = %101, %60
%66 = load i32, i32* %18
%67 = load i32, i32* %22
%68 = icmp sle i32 %66, %67
br i1 %68, label %69, label %105
69: ; preds = %65
%70 = load float*, float** %12
%71 = load i32, i32* %23
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds float, float* %70, i64 %72
%74 = load float, float* %73
store float %74, float* %28
%75 = load i32, i32* %23
%76 = load i32, i32* %27
%77 = sub nsw i32 %75, %76
%78 = load i32, i32* %14
%79 = add nsw i32 %77, %78
%80 = load i32, i32* %14
%81 = srem i32 %79, %80
store i32 %81, i32* %23
%82 = load float, float* %21
%83 = call float @sinf(float %82)
%84 = load float, float* %28
%85 = fmul float %83, %84
store float %85, float* %29
%86 = load float, float* %21
%87 = call float @cosf(float %86)
%88 = load float, float* %28
%89 = fmul float %87, %88
store float %89, float* %30
%90 = load float, float* %29
%91 = load float, float* %25
%92 = fadd float %91, %90
store float %92, float* %25
%93 = load float, float* %30
%94 = load float, float* %26
%95 = fadd float %94, %93
store float %95, float* %26
%96 = load float, float* %24
%97 = load float, float* %21
%98 = fadd float %97, %96
store float %98, float* %21
%99 = load i32, i32* %19
%100 = add nsw i32 %99, 1
store i32 %100, i32* %19
br label %101
101: ; preds = %69
%102 = load i32, i32* %27
%103 = load i32, i32* %18
%104 = add nsw i32 %103, %102
store i32 %104, i32* %18
br label %65
105: ; preds = %65
%106 = load float, float* %25
%107 = load float, float* %25
%108 = load float, float* %26
%109 = load float, float* %26
%110 = fmul float %108, %109
%111 = call float @llvm.fmuladd.f32(float %106, float %107, float %110)
%112 = call float @sqrtf(float %111)
store float %112, float* %31
%113 = load float, float* %31
%114 = load float, float* %20
%115 = fdiv float %113, %114
%116 = load float, float* %15
%117 = fdiv float %115, %116
%118 = load i32, i32* %27
%119 = sitofp i32 %118 to float
%120 = fmul float %117, %119
%121 = load float*, float** %9
%122 = load i32, i32* %17
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds float, float* %121, i64 %123
store float %120, float* %124
br label %125
125: ; preds = %105
%126 = load i32, i32* %17
%127 = add nsw i32 %126, 1
store i32 %127, i32* %17
br label %32
128: ; preds = %32
ret void
}

LLVM IR (-O2):
define void @DoDFTQuick(float* nocapture writeonly %0, float* nocapture %1, i32 %2, float* nocapture %3, i32 %4, i32 %5, float %6, float %7) {
%9 = icmp sgt i32 %2, 0
br i1 %9, label %10, label %66
10: ; preds = %8
%11 = zext i32 %2 to i64
br label %12
12: ; preds = %10, %53
%13 = phi i64 [ 0, %10 ], [ %64, %53 ]
%14 = getelementptr inbounds float, float* %1, i64 %13
%15 = load float, float* %14
%16 = fmul float %15, %6
%17 = fptosi float %16 to i32
%18 = fpext float %15 to double
%19 = fdiv double 6.283180e+00, %18
%20 = fptrunc double %19 to float
%21 = sitofp i32 %17 to float
%22 = fdiv float %21, %7
%23 = fptosi float %22 to i32
%24 = tail call i32 @floor(i32 %23)
%25 = icmp eq i32 %24, 0
%26 = select i1 %25, i32 1, i32 %24
%27 = sitofp i32 %26 to float
%28 = fmul float %20, %27
%29 = icmp slt i32 %17, 0
br i1 %29, label %53, label %30
30: ; preds = %12
%31 = sub i32 %5, %26
br label %32
32: ; preds = %30, %32
%33 = phi i32 [ 0, %30 ], [ %51, %32 ]
%34 = phi float [ 0.000000e+00, %30 ], [ %50, %32 ]
%35 = phi i32 [ %4, %30 ], [ %41, %32 ]
%36 = phi <2 x float> [ zeroinitializer, %30 ], [ %49, %32 ]
%37 = sext i32 %35 to i64
%38 = getelementptr inbounds float, float* %3, i64 %37
%39 = load float, float* %38
%40 = add i32 %31, %35
%41 = srem i32 %40, %5
%42 = tail call float @sinf(float %34)
%43 = tail call float @cosf(float %34)
%44 = insertelement <2 x float> poison, float %39, i64 0
%45 = shufflevector <2 x float> %44, <2 x float> poison, <2 x i32> zeroinitializer
%46 = insertelement <2 x float> poison, float %42, i64 0
%47 = insertelement <2 x float> %46, float %43, i64 1
%48 = fmul <2 x float> %45, %47
%49 = fadd <2 x float> %36, %48
%50 = fadd float %28, %34
%51 = add nsw i32 %33, %26
%52 = icmp sgt i32 %51, %17
br i1 %52, label %53, label %32
53: ; preds = %32, %12
%54 = phi <2 x float> [ zeroinitializer, %12 ], [ %49, %32 ]
%55 = fmul <2 x float> %54, %54
%56 = extractelement <2 x float> %55, i64 1
%57 = extractelement <2 x float> %54, i64 0
%58 = tail call float @llvm.fmuladd.f32(float %57, float %57, float %56)
%59 = tail call float @sqrtf(float %58)
%60 = fdiv float %59, %15
%61 = fdiv float %60, %6
%62 = fmul float %61, %27
%63 = getelementptr inbounds float, float* %0, i64 %13
store float %62, float* %63
%64 = add nuw nsw i64 %13, 1
%65 = icmp eq i64 %64, %11
br i1 %65, label %66, label %12
66: ; preds = %53, %8
ret void
}