#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*/ cfft(int, int, int /*<<< orphan*/, float *, int,
                        int /*<<< orphan*/, float *, int, int /*<<< orphan*/,
                        int /*<<< orphan*/);
void pd_fft(float *buf, int npoints, int inverse) {
  double renorm;
  float *fp, *fp2;
  int i;
  renorm = (inverse ? npoints : 1.);
  cfft((inverse ? 2 : 1), npoints, 0, buf, 8, 0, buf, 8, 0, 0);
  for (i = npoints << 1, fp = buf; i--; fp++)
    *fp *= renorm;
}


x86 assembly (clang, -O0):
<pd_fft>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
cmpl   $0x0,-0x10(%rbp)
je     113b <pd_fft+0x2b>
cvtsi2sdl -0xc(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    114d <pd_fft+0x3d>
movsd  0xebd(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    114d <pd_fft+0x3d>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x10(%rbp),%ecx
mov    $0x1,%edi
mov    $0x2,%eax
cmp    $0x0,%ecx
cmovne %eax,%edi
mov    -0xc(%rbp),%esi
mov    -0x8(%rbp),%rcx
mov    -0x8(%rbp),%rax
xor    %r9d,%r9d
mov    $0x8,%r8d
mov    %r9d,%edx
mov    %rax,(%rsp)
movl   $0x8,0x8(%rsp)
movl   $0x0,0x10(%rsp)
movl   $0x0,0x18(%rsp)
call   1030 <cfft@plt>
mov    -0xc(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x2c(%rbp)
cmp    $0x0,%eax
je     11f5 <pd_fft+0xe5>
movsd  -0x18(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
jmp    11b3 <pd_fft+0xa3>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<pd_fft>:
push   %r14
push   %rbx
sub    $0x18,%rsp
mov    %esi,%r14d
mov    %rdi,%rbx
xor    %eax,%eax
test   %edx,%edx
sete   %cl
je     112d <pd_fft+0x1d>
cvtsi2sd %r14d,%xmm0
jmp    1135 <pd_fft+0x25>
movsd  0xecb(%rip),%xmm0
movapd %xmm0,(%rsp)
mov    %cl,%al
mov    $0x2,%edi
sub    %eax,%edi
mov    %r14d,%esi
xor    %edx,%edx
mov    %rbx,%rcx
mov    $0x8,%r8d
xor    %r9d,%r9d
push   $0x0
push   $0x0
push   $0x8
push   %rbx
call   1030 <cfft@plt>
add    $0x20,%rsp
add    %r14d,%r14d
movapd (%rsp),%xmm5
je     12de <pd_fft+0x1ce>
lea    -0x2(%r14),%eax
cmp    $0x6,%eax
jb     12b4 <pd_fft+0x1a4>
add    $0x2,%rax
mov    %rax,%rcx
and    $0xfffffffffffffff8,%rcx
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     12e6 <pd_fft+0x1d6>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cvtps2pd 0x8(%rbx,%rdx,4),%xmm1
cvtps2pd (%rbx,%rdx,4),%xmm2
cvtps2pd 0x18(%rbx,%rdx,4),%xmm3
cvtps2pd 0x10(%rbx,%rdx,4),%xmm4
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm4
mulpd  %xmm0,%xmm3
cvtpd2ps %xmm1,%xmm1
cvtpd2ps %xmm2,%xmm2
cvtpd2ps %xmm3,%xmm3
unpcklpd %xmm1,%xmm2
cvtpd2ps %xmm4,%xmm1
unpcklpd %xmm3,%xmm1
movupd %xmm2,(%rbx,%rdx,4)
movupd %xmm1,0x10(%rbx,%rdx,4)
cvtps2pd 0x28(%rbx,%rdx,4),%xmm1
cvtps2pd 0x20(%rbx,%rdx,4),%xmm2
cvtps2pd 0x38(%rbx,%rdx,4),%xmm3
cvtps2pd 0x30(%rbx,%rdx,4),%xmm4
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm4
mulpd  %xmm0,%xmm3
cvtpd2ps %xmm1,%xmm1
cvtpd2ps %xmm2,%xmm2
cvtpd2ps %xmm3,%xmm3
unpcklpd %xmm1,%xmm2
cvtpd2ps %xmm4,%xmm1
unpcklpd %xmm3,%xmm1
movupd %xmm2,0x20(%rbx,%rdx,4)
movupd %xmm1,0x30(%rbx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    11c0 <pd_fft+0xb0>
test   $0x1,%sil
je     12a8 <pd_fft+0x198>
cvtps2pd 0x8(%rbx,%rdx,4),%xmm1
cvtps2pd (%rbx,%rdx,4),%xmm2
cvtps2pd 0x18(%rbx,%rdx,4),%xmm3
cvtps2pd 0x10(%rbx,%rdx,4),%xmm4
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm4
mulpd  %xmm0,%xmm3
cvtpd2ps %xmm1,%xmm0
cvtpd2ps %xmm2,%xmm1
cvtpd2ps %xmm3,%xmm2
cvtpd2ps %xmm4,%xmm3
unpcklpd %xmm0,%xmm1
unpcklpd %xmm2,%xmm3
movupd %xmm1,(%rbx,%rdx,4)
movupd %xmm3,0x10(%rbx,%rdx,4)
cmp    %rcx,%rax
je     12de <pd_fft+0x1ce>
sub    %ecx,%r14d
lea    (%rbx,%rcx,4),%rbx
mov    %r14d,%eax
xor    %ecx,%ecx
nopl   0x0(%rax)
movss  (%rbx,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm5,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %ecx,%eax
jne    12c0 <pd_fft+0x1b0>
add    $0x18,%rsp
pop    %rbx
pop    %r14
ret
xor    %edx,%edx
test   $0x1,%sil
jne    1262 <pd_fft+0x152>
jmp    12a8 <pd_fft+0x198>

LLVM IR (-O0):
define void @pd_fft(float* %0, i32 %1, i32 %2) {
%4 = alloca float*
%5 = alloca i32
%6 = alloca i32
%7 = alloca double
%8 = alloca float*
%9 = alloca float*
%10 = alloca i32
store float* %0, float** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%11 = load i32, i32* %6
%12 = icmp ne i32 %11, 0
br i1 %12, label %13, label %16
13: ; preds = %3
%14 = load i32, i32* %5
%15 = sitofp i32 %14 to double
br label %17
16: ; preds = %3
br label %17
17: ; preds = %16, %13
%18 = phi double [ %15, %13 ], [ 1.000000e+00, %16 ]
store double %18, double* %7
%19 = load i32, i32* %6
%20 = icmp ne i32 %19, 0
%21 = zext i1 %20 to i64
%22 = select i1 %20, i32 2, i32 1
%23 = load i32, i32* %5
%24 = load float*, float** %4
%25 = load float*, float** %4
%26 = call i32 @cfft(i32 %22, i32 %23, i32 0, float* %24, i32 8, i32 0, float* %25, i32 8, i32 0, i32 0)
%27 = load i32, i32* %5
%28 = shl i32 %27, 1
store i32 %28, i32* %10
%29 = load float*, float** %4
store float* %29, float** %8
br label %30
30: ; preds = %41, %17
%31 = load i32, i32* %10
%32 = add nsw i32 %31, -1
store i32 %32, i32* %10
%33 = icmp ne i32 %31, 0
br i1 %33, label %34, label %44
34: ; preds = %30
%35 = load double, double* %7
%36 = load float*, float** %8
%37 = load float, float* %36
%38 = fpext float %37 to double
%39 = fmul double %38, %35
%40 = fptrunc double %39 to float
store float %40, float* %36
br label %41
41: ; preds = %34
%42 = load float*, float** %8
%43 = getelementptr inbounds float, float* %42, i32 1
store float* %43, float** %8
br label %30
44: ; preds = %30
ret void
}

LLVM IR (-O2):
define void @pd_fft(float* %0, i32 %1, i32 %2) {
%4 = icmp eq i32 %2, 0
%5 = sitofp i32 %1 to double
%6 = select i1 %4, double 1.000000e+00, double %5
%7 = select i1 %4, i32 1, i32 2
%8 = tail call i32 @cfft(i32 %7, i32 %1, i32 0, float* %0, i32 8, i32 0, float* %0, i32 8, i32 0, i32 0)
%9 = shl i32 %1, 1
%10 = icmp eq i32 %9, 0
br i1 %10, label %100, label %11
11: ; preds = %3
%12 = add i32 %9, -2
%13 = zext i32 %12 to i64
%14 = add nuw nsw i64 %13, 2
%15 = icmp ult i32 %12, 6
br i1 %15, label %87, label %16
16: ; preds = %11
%17 = and i64 %14, 8589934584
%18 = trunc i64 %17 to i32
%19 = sub i32 %9, %18
%20 = getelementptr float, float* %0, i64 %17
%21 = insertelement <4 x double> poison, double %6, i64 0
%22 = shufflevector <4 x double> %21, <4 x double> poison, <4 x i32> zeroinitializer
%23 = insertelement <4 x double> poison, double %6, i64 0
%24 = shufflevector <4 x double> %23, <4 x double> poison, <4 x i32> zeroinitializer
%25 = add nsw i64 %17, -8
%26 = lshr exact i64 %25, 3
%27 = add nuw nsw i64 %26, 1
%28 = and i64 %27, 1
%29 = icmp eq i64 %25, 0
br i1 %29, label %67, label %30
30: ; preds = %16
%31 = and i64 %27, 4611686018427387902
br label %32
32: ; preds = %32, %30
%33 = phi i64 [ 0, %30 ], [ %64, %32 ]
%34 = phi i64 [ 0, %30 ], [ %65, %32 ]
%35 = getelementptr float, float* %0, i64 %33
%36 = bitcast float* %35 to <4 x float>*
%37 = load <4 x float>, <4 x float>* %36
%38 = getelementptr float, float* %35, i64 4
%39 = bitcast float* %38 to <4 x float>*
%40 = load <4 x float>, <4 x float>* %39
%41 = fpext <4 x float> %37 to <4 x double>
%42 = fpext <4 x float> %40 to <4 x double>
%43 = fmul <4 x double> %22, %41
%44 = fmul <4 x double> %24, %42
%45 = fptrunc <4 x double> %43 to <4 x float>
%46 = fptrunc <4 x double> %44 to <4 x float>
%47 = bitcast float* %35 to <4 x float>*
store <4 x float> %45, <4 x float>* %47
%48 = bitcast float* %38 to <4 x float>*
store <4 x float> %46, <4 x float>* %48
%49 = or i64 %33, 8
%50 = getelementptr float, float* %0, i64 %49
%51 = bitcast float* %50 to <4 x float>*
%52 = load <4 x float>, <4 x float>* %51
%53 = getelementptr float, float* %50, i64 4
%54 = bitcast float* %53 to <4 x float>*
%55 = load <4 x float>, <4 x float>* %54
%56 = fpext <4 x float> %52 to <4 x double>
%57 = fpext <4 x float> %55 to <4 x double>
%58 = fmul <4 x double> %22, %56
%59 = fmul <4 x double> %24, %57
%60 = fptrunc <4 x double> %58 to <4 x float>
%61 = fptrunc <4 x double> %59 to <4 x float>
%62 = bitcast float* %50 to <4 x float>*
store <4 x float> %60, <4 x float>* %62
%63 = bitcast float* %53 to <4 x float>*
store <4 x float> %61, <4 x float>* %63
%64 = add nuw i64 %33, 16
%65 = add i64 %34, 2
%66 = icmp eq i64 %65, %31
br i1 %66, label %67, label %32
67: ; preds = %32, %16
%68 = phi i64 [ 0, %16 ], [ %64, %32 ]
%69 = icmp eq i64 %28, 0
br i1 %69, label %85, label %70
70: ; preds = %67
%71 = getelementptr float, float* %0, i64 %68
%72 = bitcast float* %71 to <4 x float>*
%73 = load <4 x float>, <4 x float>* %72
%74 = getelementptr float, float* %71, i64 4
%75 = bitcast float* %74 to <4 x float>*
%76 = load <4 x float>, <4 x float>* %75
%77 = fpext <4 x float> %73 to <4 x double>
%78 = fpext <4 x float> %76 to <4 x double>
%79 = fmul <4 x double> %22, %77
%80 = fmul <4 x double> %24, %78
%81 = fptrunc <4 x double> %79 to <4 x float>
%82 = fptrunc <4 x double> %80 to <4 x float>
%83 = bitcast float* %71 to <4 x float>*
store <4 x float> %81, <4 x float>* %83
%84 = bitcast float* %74 to <4 x float>*
store <4 x float> %82, <4 x float>* %84
br label %85
85: ; preds = %67, %70
%86 = icmp eq i64 %14, %17
br i1 %86, label %100, label %87
87: ; preds = %11, %85
%88 = phi i32 [ %9, %11 ], [ %19, %85 ]
%89 = phi float* [ %0, %11 ], [ %20, %85 ]
br label %90
90: ; preds = %87, %90
%91 = phi i32 [ %93, %90 ], [ %88, %87 ]
%92 = phi float* [ %98, %90 ], [ %89, %87 ]
%93 = add nsw i32 %91, -1
%94 = load float, float* %92
%95 = fpext float %94 to double
%96 = fmul double %6, %95
%97 = fptrunc double %96 to float
store float %97, float* %92
%98 = getelementptr inbounds float, float* %92, i64 1
%99 = icmp eq i32 %93, 0
br i1 %99, label %100, label %90
100: ; preds = %90, %85, %3
ret void
}