#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*/ mayer_fht(float *, int);
void mayer_ifft(int n, float *real, float *imag) {
  float a, b, c, d;
  float q, r, s, t;
  int i, j, k;
  mayer_fht(real, n);
  mayer_fht(imag, n);
  for (i = 1, j = n - 1, k = n / 2; i < k; i++, j--) {
    a = real[i];
    b = real[j];
    q = a + b;
    r = a - b;
    c = imag[i];
    d = imag[j];
    s = c + d;
    t = c - d;
    imag[i] = (s + r) * 0.5;
    imag[j] = (s - r) * 0.5;
    real[i] = (q - t) * 0.5;
    real[j] = (q + t) * 0.5;
  }
}


x86 assembly (clang, -O0):
<mayer_ifft>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x4(%rbp),%esi
call   1030 <mayer_fht@plt>
mov    -0x18(%rbp),%rdi
mov    -0x4(%rbp),%esi
call   1030 <mayer_fht@plt>
movl   $0x1,-0x3c(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    12ac <mayer_ifft+0x19c>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x1c(%rbp),%xmm0
addss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x1c(%rbp),%xmm0
subss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x24(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x24(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x34(%rbp),%xmm0
addss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe01(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x34(%rbp),%xmm0
subss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdd6(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x2c(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdab(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x2c(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd80(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1159 <mayer_ifft+0x49>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mayer_ifft>:
push   %r15
push   %r14
push   %rbx
mov    %rdx,%r14
mov    %rsi,%rbx
mov    %edi,%r15d
mov    %rsi,%rdi
mov    %r15d,%esi
call   1030 <mayer_fht@plt>
mov    %r14,%rdi
mov    %r15d,%esi
call   1030 <mayer_fht@plt>
cmp    $0x4,%r15d
jl     11d5 <mayer_ifft+0xc5>
mov    %r15d,%eax
shr    %r15d
add    $0xffffffffffffffff,%rax
mov    $0x1,%ecx
movss  0xeab(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rbx,%rcx,4),%xmm1
movss  (%rbx,%rax,4),%xmm2
movaps %xmm1,%xmm3
addss  %xmm2,%xmm3
subss  %xmm2,%xmm1
movss  (%r14,%rcx,4),%xmm2
movss  (%r14,%rax,4),%xmm4
movaps %xmm2,%xmm5
addss  %xmm4,%xmm5
subss  %xmm4,%xmm2
movaps %xmm1,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm0,%xmm4
movss  %xmm4,(%r14,%rcx,4)
subss  %xmm1,%xmm5
mulss  %xmm0,%xmm5
movss  %xmm5,(%r14,%rax,4)
movaps %xmm3,%xmm1
subss  %xmm2,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rbx,%rcx,4)
addss  %xmm3,%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%rbx,%rax,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
cmp    %rcx,%r15
jne    1160 <mayer_ifft+0x50>
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @mayer_ifft(i32 %0, float* %1, float* %2) {
%4 = alloca i32
%5 = alloca float*
%6 = alloca float*
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
store i32 %0, i32* %4
store float* %1, float** %5
store float* %2, float** %6
%18 = load float*, float** %5
%19 = load i32, i32* %4
%20 = call i32 @mayer_fht(float* %18, i32 %19)
%21 = load float*, float** %6
%22 = load i32, i32* %4
%23 = call i32 @mayer_fht(float* %21, i32 %22)
store i32 1, i32* %15
%24 = load i32, i32* %4
%25 = sub nsw i32 %24, 1
store i32 %25, i32* %16
%26 = load i32, i32* %4
%27 = sdiv i32 %26, 2
store i32 %27, i32* %17
br label %28
28: ; preds = %105, %3
%29 = load i32, i32* %15
%30 = load i32, i32* %17
%31 = icmp slt i32 %29, %30
br i1 %31, label %32, label %110
32: ; preds = %28
%33 = load float*, float** %5
%34 = load i32, i32* %15
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds float, float* %33, i64 %35
%37 = load float, float* %36
store float %37, float* %7
%38 = load float*, float** %5
%39 = load i32, i32* %16
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds float, float* %38, i64 %40
%42 = load float, float* %41
store float %42, float* %8
%43 = load float, float* %7
%44 = load float, float* %8
%45 = fadd float %43, %44
store float %45, float* %11
%46 = load float, float* %7
%47 = load float, float* %8
%48 = fsub float %46, %47
store float %48, float* %12
%49 = load float*, float** %6
%50 = load i32, i32* %15
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds float, float* %49, i64 %51
%53 = load float, float* %52
store float %53, float* %9
%54 = load float*, float** %6
%55 = load i32, i32* %16
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds float, float* %54, i64 %56
%58 = load float, float* %57
store float %58, float* %10
%59 = load float, float* %9
%60 = load float, float* %10
%61 = fadd float %59, %60
store float %61, float* %13
%62 = load float, float* %9
%63 = load float, float* %10
%64 = fsub float %62, %63
store float %64, float* %14
%65 = load float, float* %13
%66 = load float, float* %12
%67 = fadd float %65, %66
%68 = fpext float %67 to double
%69 = fmul double %68, 5.000000e-01
%70 = fptrunc double %69 to float
%71 = load float*, float** %6
%72 = load i32, i32* %15
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds float, float* %71, i64 %73
store float %70, float* %74
%75 = load float, float* %13
%76 = load float, float* %12
%77 = fsub float %75, %76
%78 = fpext float %77 to double
%79 = fmul double %78, 5.000000e-01
%80 = fptrunc double %79 to float
%81 = load float*, float** %6
%82 = load i32, i32* %16
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds float, float* %81, i64 %83
store float %80, float* %84
%85 = load float, float* %11
%86 = load float, float* %14
%87 = fsub float %85, %86
%88 = fpext float %87 to double
%89 = fmul double %88, 5.000000e-01
%90 = fptrunc double %89 to float
%91 = load float*, float** %5
%92 = load i32, i32* %15
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds float, float* %91, i64 %93
store float %90, float* %94
%95 = load float, float* %11
%96 = load float, float* %14
%97 = fadd float %95, %96
%98 = fpext float %97 to double
%99 = fmul double %98, 5.000000e-01
%100 = fptrunc double %99 to float
%101 = load float*, float** %5
%102 = load i32, i32* %16
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds float, float* %101, i64 %103
store float %100, float* %104
br label %105
105: ; preds = %32
%106 = load i32, i32* %15
%107 = add nsw i32 %106, 1
store i32 %107, i32* %15
%108 = load i32, i32* %16
%109 = add nsw i32 %108, -1
store i32 %109, i32* %16
br label %28
110: ; preds = %28
ret void
}

LLVM IR (-O2):
define void @mayer_ifft(i32 %0, float* %1, float* %2) {
%4 = tail call i32 @mayer_fht(float* %1, i32 %0)
%5 = tail call i32 @mayer_fht(float* %2, i32 %0)
%6 = icmp sgt i32 %0, 3
br i1 %6, label %7, label %37
7: ; preds = %3
%8 = lshr i32 %0, 1
%9 = zext i32 %0 to i64
%10 = zext i32 %8 to i64
br label %11
11: ; preds = %7, %11
%12 = phi i64 [ 1, %7 ], [ %35, %11 ]
%13 = phi i64 [ %9, %7 ], [ %14, %11 ]
%14 = add nsw i64 %13, -1
%15 = getelementptr inbounds float, float* %1, i64 %12
%16 = load float, float* %15
%17 = getelementptr inbounds float, float* %1, i64 %14
%18 = load float, float* %17
%19 = fadd float %16, %18
%20 = fsub float %16, %18
%21 = getelementptr inbounds float, float* %2, i64 %12
%22 = load float, float* %21
%23 = getelementptr inbounds float, float* %2, i64 %14
%24 = load float, float* %23
%25 = fadd float %22, %24
%26 = fsub float %22, %24
%27 = fadd float %20, %25
%28 = fmul float %27, 5.000000e-01
store float %28, float* %21
%29 = fsub float %25, %20
%30 = fmul float %29, 5.000000e-01
store float %30, float* %23
%31 = fsub float %19, %26
%32 = fmul float %31, 5.000000e-01
store float %32, float* %15
%33 = fadd float %19, %26
%34 = fmul float %33, 5.000000e-01
store float %34, float* %17
%35 = add nuw nsw i64 %12, 1
%36 = icmp eq i64 %35, %10
br i1 %36, label %37, label %11
37: ; preds = %11, %3
ret void
}