#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 */
double *dgetmem(int const);
int /*<<< orphan*/ fftr(double *, double *, int const);
int /*<<< orphan*/ free(double *);
void ndps2c(double *n, const int l, double *c, const int m) {
  int i, no;
  double *nx, *ny;
  no = l / 2;
  nx = dgetmem(l);
  ny = dgetmem(l);
  for (i = 0; i <= no; i++) {
    nx[i] = n[i];
  }
  for (i = 1; i < no; i++) {
    nx[l - i] = nx[i];
  }
  fftr(nx, ny, l);
  c[0] = 0.0;
  for (i = 1; i <= m; i++)
    c[i] = nx[i] / (i * l / 2.0);
  if (m == l / 2)
    c[m] = nx[m] / 2.0;
  free(nx);
  free(ny);
}


x86 assembly (clang, -O0):
<ndps2c>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x24(%rbp)
mov    -0xc(%rbp),%edi
call   1050 <dgetmem@plt>
mov    %rax,-0x30(%rbp)
mov    -0xc(%rbp),%edi
call   1050 <dgetmem@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     11a7 <ndps2c+0x77>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1173 <ndps2c+0x43>
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11e7 <ndps2c+0xb7>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11ae <ndps2c+0x7e>
mov    -0x30(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0xc(%rbp),%edx
call   1040 <fftr@plt>
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1258 <ndps2c+0x128>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%eax
imul   -0xc(%rbp),%eax
cvtsi2sd %eax,%xmm1
movsd  0xdcb(%rip),%xmm2
divsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1209 <ndps2c+0xd9>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x3c(%rbp),%eax
cmp    %ecx,%eax
jne    129c <ndps2c+0x16c>
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xd75(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ndps2c>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %ecx,%r14d
mov    %rdx,%r13
mov    %esi,%r12d
mov    %rdi,%rbx
mov    %esi,%r15d
shr    $0x1f,%r15d
add    %esi,%r15d
sar    %r15d
mov    %esi,%edi
call   1050 <dgetmem@plt>
mov    %rax,%rbp
mov    %r12d,%edi
call   1050 <dgetmem@plt>
cmp    $0xffffffff,%r12d
jl     13c6 <ndps2c+0x296>
lea    0x1(%r15),%r9d
cmp    $0x4,%r9d
jb     1197 <ndps2c+0x67>
lea    (%rbx,%r9,8),%rcx
cmp    %rcx,%rbp
jae    120d <ndps2c+0xdd>
lea    0x0(,%r9,8),%rcx
add    %rbp,%rcx
cmp    %rbx,%rcx
jbe    120d <ndps2c+0xdd>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r9,%rdx
mov    %r9,%rsi
and    $0x3,%rsi
je     11c5 <ndps2c+0x95>
nopl   0x0(%rax,%rax,1)
movq   (%rbx,%rcx,8),%xmm0
movq   %xmm0,0x0(%rbp,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    11b0 <ndps2c+0x80>
cmp    $0x3,%rdx
jb     12e8 <ndps2c+0x1b8>
nop
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rcx,8)
movsd  0x10(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rbp,%rcx,8)
movq   0x18(%rbx,%rcx,8),%xmm0
movq   %xmm0,0x18(%rbp,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    11d0 <ndps2c+0xa0>
jmp    12e8 <ndps2c+0x1b8>
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%r8d
and    $0x3,%r8d
cmp    $0xc,%rdx
jae    1233 <ndps2c+0x103>
xor    %edi,%edi
jmp    129d <ndps2c+0x16d>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movups (%rbx,%rdi,8),%xmm0
movups 0x10(%rbx,%rdi,8),%xmm1
movups %xmm0,0x0(%rbp,%rdi,8)
movups %xmm1,0x10(%rbp,%rdi,8)
movups 0x20(%rbx,%rdi,8),%xmm0
movups 0x30(%rbx,%rdi,8),%xmm1
movups %xmm0,0x20(%rbp,%rdi,8)
movups %xmm1,0x30(%rbp,%rdi,8)
movups 0x40(%rbx,%rdi,8),%xmm0
movups 0x50(%rbx,%rdi,8),%xmm1
movups %xmm0,0x40(%rbp,%rdi,8)
movups %xmm1,0x50(%rbp,%rdi,8)
movdqu 0x60(%rbx,%rdi,8),%xmm0
movdqu 0x70(%rbx,%rdi,8),%xmm1
movdqu %xmm0,0x60(%rbp,%rdi,8)
movdqu %xmm1,0x70(%rbp,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1240 <ndps2c+0x110>
test   %r8,%r8
je     12df <ndps2c+0x1af>
lea    0x10(,%rdi,8),%rsi
add    %rbp,%rsi
lea    (%rbx,%rdi,8),%rdi
add    $0x10,%rdi
shl    $0x5,%r8
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rdi,%rdx,1),%xmm0
movdqu (%rdi,%rdx,1),%xmm1
movdqu %xmm0,-0x10(%rsi,%rdx,1)
movdqu %xmm1,(%rsi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    12c0 <ndps2c+0x190>
cmp    %r9,%rcx
jne    1199 <ndps2c+0x69>
cmp    $0x4,%r12d
jl     13c6 <ndps2c+0x296>
mov    %r12d,%r8d
cmp    $0x3,%r15d
mov    $0x2,%edi
cmovge %r15d,%edi
lea    -0x1(%rdi),%rsi
add    $0xfffffffffffffffe,%rdi
mov    %esi,%r9d
and    $0x3,%r9d
mov    $0x1,%edx
cmp    $0x3,%rdi
jb     1383 <ndps2c+0x253>
and    $0xfffffffffffffffc,%rsi
lea    -0x8(,%r8,8),%rdi
ff
add    %rbp,%rdi
lea    0x20(%rbp),%rbx
mov    $0xffffffffffffffff,%rdx
cs nopw 0x0(%rax,%rax,1)
movsd  -0x18(%rbx),%xmm0
movsd  %xmm0,0x8(%rdi,%rdx,8)
movsd  -0x10(%rbx),%xmm0
movsd  %xmm0,(%rdi,%rdx,8)
movsd  -0x8(%rbx),%xmm0
movsd  %xmm0,-0x8(%rdi,%rdx,8)
movq   (%rbx),%xmm0
movq   %xmm0,-0x10(%rdi,%rdx,8)
add    $0x20,%rbx
lea    (%rsi,%rdx,1),%rcx
add    $0xfffffffffffffffc,%rcx
add    $0xfffffffffffffffc,%rdx
cmp    $0xffffffffffffffff,%rcx
jne    1340 <ndps2c+0x210>
neg    %rdx
test   %r9,%r9
je     13c6 <ndps2c+0x296>
sub    %rdx,%r8
lea    0x0(,%r8,8),%rcx
add    %rbp,%rcx
lea    0x0(,%rdx,8),%rdx
add    %rbp,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movq   (%rdx,%rsi,8),%xmm0
movq   %xmm0,(%rcx)
add    $0x1,%rsi
add    $0xfffffffffffffff8,%rcx
cmp    %rsi,%r9
jne    13b0 <ndps2c+0x280>
mov    %rbp,%rdi
mov    %rax,(%rsp)
mov    %rax,%rsi
mov    %r12d,%edx
call   1040 <fftr@plt>
movq   $0x0,0x0(%r13)
test   %r14d,%r14d
jle    15e5 <ndps2c+0x4b5>
mov    %r14d,%ecx
lea    0x1(%rcx),%rax
mov    $0x1,%edx
cmp    $0x2,%r14d
jb     1542 <ndps2c+0x412>
lea    0x8(%r13),%rsi
lea    0x0(,%rax,8),%rdi
add    %rbp,%rdi
cmp    %rdi,%rsi
jae    142e <ndps2c+0x2fe>
lea    0x0(,%rax,8),%rsi
add    %r13,%rsi
mov    %rbp,%rdi
add    $0x8,%rdi
cmp    %rsi,%rdi
jb     1542 <ndps2c+0x412>
mov    %ecx,%edx
and    $0xfffffffe,%edx
movd   %r12d,%xmm0
pshufd $0x50,%xmm0,%xmm0
lea    -0x2(%rdx),%rsi
mov    %rsi,%rbx
shr    %rbx
add    $0x1,%rbx
pshufd $0xf5,%xmm0,%xmm1
test   %rsi,%rsi
je     1621 <ndps2c+0x4f1>
mov    %rbx,%rdi
and    $0xfffffffffffffffe,%rdi
movdqa 0xb98(%rip),%xmm2
mov    $0x1,%esi
movapd 0xb9b(%rip),%xmm3
movdqa 0xba2(%rip),%xmm8
movdqa 0xbaa(%rip),%xmm5
cs nopw 0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rsi,8),%xmm6
movdqa %xmm2,%xmm7
pmuludq %xmm0,%xmm7
pshufd $0xf5,%xmm2,%xmm4
pmuludq %xmm1,%xmm4
punpckldq %xmm4,%xmm7
cvtdq2pd %xmm7,%xmm4
mulpd  %xmm3,%xmm4
divpd  %xmm4,%xmm6
movupd %xmm6,0x0(%r13,%rsi,8)
movdqa %xmm2,%xmm4
paddd  %xmm8,%xmm4
movupd 0x10(%rbp,%rsi,8),%xmm6
pshufd $0xf5,%xmm4,%xmm7
pmuludq %xmm0,%xmm4
pmuludq %xmm1,%xmm7
punpckldq %xmm7,%xmm4
cvtdq2pd %xmm4,%xmm4
mulpd  %xmm3,%xmm4
divpd  %xmm4,%xmm6
movupd %xmm6,0x10(%r13,%rsi,8)
paddd  %xmm5,%xmm2
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1490 <ndps2c+0x360>
test   $0x1,%bl
je     1532 <ndps2c+0x402>
movupd 0x0(%rbp,%rsi,8),%xmm3
pmuludq %xmm2,%xmm0
pshufd $0xf5,%xmm2,%xmm2
pmuludq %xmm1,%xmm2
punpckldq %xmm2,%xmm0
cvtdq2pd %xmm0,%xmm0
mulpd  0xae9(%rip),%xmm0
divpd  %xmm0,%xmm3
movupd %xmm3,0x0(%r13,%rsi,8)
cmp    %rdx,%rcx
je     15e5 <ndps2c+0x4b5>
or     $0x1,%rcx
mov    %rcx,%rdx
mov    %rdx,%rcx
not    %rcx
test   $0x1,%al
jne    1576 <ndps2c+0x446>
mov    %edx,%esi
imul   %r12d,%esi
xorps  %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
mulsd  0xadf(%rip),%xmm0
movsd  0x0(%rbp,%rdx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rdx,8)
add    $0x1,%rdx
add    %rax,%rcx
je     15e5 <ndps2c+0x4b5>
mov    %r12d,%ecx
imul   %edx,%ecx
lea    (%r12,%r12,1),%esi
lea    0x1(%rdx),%edi
imul   %r12d,%edi
movsd  0xaac(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%rbp,%rdx,8),%xmm1
xorps  %xmm2,%xmm2
cvtsi2sd %ecx,%xmm2
mulsd  %xmm0,%xmm2
divsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%r13,%rdx,8)
xorps  %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
movsd  0x8(%rbp,%rdx,8),%xmm2
mulsd  %xmm0,%xmm1
divsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%r13,%rdx,8)
add    $0x2,%rdx
add    %esi,%ecx
add    %esi,%edi
cmp    %rdx,%rax
jne    15a0 <ndps2c+0x470>
cmp    %r14d,%r15d
jne    1602 <ndps2c+0x4d2>
movslq %r14d,%rax
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  0xa45(%rip),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
mov    %rbp,%rdi
call   1030 <free@plt>
mov    (%rsp),%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
movdqa 0x9d7(%rip),%xmm2
mov    $0x1,%esi
test   $0x1,%bl
jne    1504 <ndps2c+0x3d4>
jmp    1532 <ndps2c+0x402>

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

LLVM IR (-O2):
define void @ndps2c(double* nocapture %0, i32 %1, double* nocapture writeonly %2, i32 %3) {
%5 = sdiv i32 %1, 2
%6 = tail call double* @dgetmem(i32 %1)
%7 = tail call double* @dgetmem(i32 %1)
%8 = icmp slt i32 %1, -1
br i1 %8, label %185, label %9
9: ; preds = %4
%10 = add nsw i32 %5, 1
%11 = zext i32 %10 to i64
%12 = icmp ult i32 %10, 4
br i1 %12, label %98, label %13
13: ; preds = %9
%14 = getelementptr double, double* %6, i64 %11
%15 = getelementptr double, double* %0, i64 %11
%16 = icmp ult double* %6, %15
%17 = icmp ugt double* %14, %0
%18 = and i1 %16, %17
br i1 %18, label %98, label %19
19: ; preds = %13
%20 = and i64 %11, 4294967292
%21 = add nsw i64 %20, -4
%22 = lshr exact i64 %21, 2
%23 = add nuw nsw i64 %22, 1
%24 = and i64 %23, 3
%25 = icmp ult i64 %21, 12
br i1 %25, label %77, label %26
26: ; preds = %19
%27 = and i64 %23, 9223372036854775804
br label %28
28: ; preds = %28, %26
%29 = phi i64 [ 0, %26 ], [ %74, %28 ]
%30 = phi i64 [ 0, %26 ], [ %75, %28 ]
%31 = getelementptr inbounds double, double* %0, i64 %29
%32 = bitcast double* %31 to <2 x double>*
%33 = load <2 x double>, <2 x double>* %32
%34 = getelementptr inbounds double, double* %31, i64 2
%35 = bitcast double* %34 to <2 x double>*
%36 = load <2 x double>, <2 x double>* %35
%37 = getelementptr inbounds double, double* %6, i64 %29
%38 = bitcast double* %37 to <2 x double>*
store <2 x double> %33, <2 x double>* %38
%39 = getelementptr inbounds double, double* %37, i64 2
%40 = bitcast double* %39 to <2 x double>*
store <2 x double> %36, <2 x double>* %40
%41 = or i64 %29, 4
%42 = getelementptr inbounds double, double* %0, i64 %41
%43 = bitcast double* %42 to <2 x double>*
%44 = load <2 x double>, <2 x double>* %43
%45 = getelementptr inbounds double, double* %42, i64 2
%46 = bitcast double* %45 to <2 x double>*
%47 = load <2 x double>, <2 x double>* %46
%48 = getelementptr inbounds double, double* %6, i64 %41
%49 = bitcast double* %48 to <2 x double>*
store <2 x double> %44, <2 x double>* %49
%50 = getelementptr inbounds double, double* %48, i64 2
%51 = bitcast double* %50 to <2 x double>*
store <2 x double> %47, <2 x double>* %51
%52 = or i64 %29, 8
%53 = getelementptr inbounds double, double* %0, i64 %52
%54 = bitcast double* %53 to <2 x double>*
%55 = load <2 x double>, <2 x double>* %54
%56 = getelementptr inbounds double, double* %53, i64 2
%57 = bitcast double* %56 to <2 x double>*
%58 = load <2 x double>, <2 x double>* %57
%59 = getelementptr inbounds double, double* %6, i64 %52
%60 = bitcast double* %59 to <2 x double>*
store <2 x double> %55, <2 x double>* %60
%61 = getelementptr inbounds double, double* %59, i64 2
%62 = bitcast double* %61 to <2 x double>*
store <2 x double> %58, <2 x double>* %62
%63 = or i64 %29, 12
%64 = getelementptr inbounds double, double* %0, i64 %63
%65 = bitcast double* %64 to <2 x double>*
%66 = load <2 x double>, <2 x double>* %65
%67 = getelementptr inbounds double, double* %64, i64 2
%68 = bitcast double* %67 to <2 x double>*
%69 = load <2 x double>, <2 x double>* %68
%70 = getelementptr inbounds double, double* %6, i64 %63
%71 = bitcast double* %70 to <2 x double>*
store <2 x double> %66, <2 x double>* %71
%72 = getelementptr inbounds double, double* %70, i64 2
%73 = bitcast double* %72 to <2 x double>*
store <2 x double> %69, <2 x double>* %73
%74 = add nuw i64 %29, 16
%75 = add nuw i64 %30, 4
%76 = icmp eq i64 %75, %27
br i1 %76, label %77, label %28
77: ; preds = %28, %19
%78 = phi i64 [ 0, %19 ], [ %74, %28 ]
%79 = icmp eq i64 %24, 0
br i1 %79, label %96, label %80
80: ; preds = %77, %80
%81 = phi i64 [ %93, %80 ], [ %78, %77 ]
%82 = phi i64 [ %94, %80 ], [ 0, %77 ]
%83 = getelementptr inbounds double, double* %0, i64 %81
%84 = bitcast double* %83 to <2 x double>*
%85 = load <2 x double>, <2 x double>* %84
%86 = getelementptr inbounds double, double* %83, i64 2
%87 = bitcast double* %86 to <2 x double>*
%88 = load <2 x double>, <2 x double>* %87
%89 = getelementptr inbounds double, double* %6, i64 %81
%90 = bitcast double* %89 to <2 x double>*
store <2 x double> %85, <2 x double>* %90
%91 = getelementptr inbounds double, double* %89, i64 2
%92 = bitcast double* %91 to <2 x double>*
store <2 x double> %88, <2 x double>* %92
%93 = add nuw i64 %81, 4
%94 = add i64 %82, 1
%95 = icmp eq i64 %94, %24
br i1 %95, label %96, label %80
96: ; preds = %80, %77
%97 = icmp eq i64 %20, %11
br i1 %97, label %116, label %98
98: ; preds = %13, %9, %96
%99 = phi i64 [ 0, %13 ], [ 0, %9 ], [ %20, %96 ]
%100 = xor i64 %99, -1
%101 = add nsw i64 %100, %11
%102 = and i64 %11, 3
%103 = icmp eq i64 %102, 0
br i1 %103, label %113, label %104
104: ; preds = %98, %104
%105 = phi i64 [ %110, %104 ], [ %99, %98 ]
%106 = phi i64 [ %111, %104 ], [ 0, %98 ]
%107 = getelementptr inbounds double, double* %0, i64 %105
%108 = load double, double* %107
%109 = getelementptr inbounds double, double* %6, i64 %105
store double %108, double* %109
%110 = add nuw nsw i64 %105, 1
%111 = add i64 %106, 1
%112 = icmp eq i64 %111, %102
br i1 %112, label %113, label %104
113: ; preds = %104, %98
%114 = phi i64 [ %99, %98 ], [ %110, %104 ]
%115 = icmp ult i64 %101, 3
br i1 %115, label %116, label %128
116: ; preds = %113, %128, %96
%117 = icmp sgt i32 %1, 3
br i1 %117, label %118, label %185
118: ; preds = %116
%119 = zext i32 %1 to i64
%120 = call i32 @llvm.smax.i32(i32 %5, i32 2)
%121 = zext i32 %120 to i64
%122 = add nsw i64 %121, -1
%123 = add nsw i64 %121, -2
%124 = and i64 %122, 3
%125 = icmp ult i64 %123, 3
br i1 %125, label %172, label %126
126: ; preds = %118
%127 = and i64 %122, -4
br label %147
128: ; preds = %113, %128
%129 = phi i64 [ %145, %128 ], [ %114, %113 ]
%130 = getelementptr inbounds double, double* %0, i64 %129
%131 = load double, double* %130
%132 = getelementptr inbounds double, double* %6, i64 %129
store double %131, double* %132
%133 = add nuw nsw i64 %129, 1
%134 = getelementptr inbounds double, double* %0, i64 %133
%135 = load double, double* %134
%136 = getelementptr inbounds double, double* %6, i64 %133
store double %135, double* %136
%137 = add nuw nsw i64 %129, 2
%138 = getelementptr inbounds double, double* %0, i64 %137
%139 = load double, double* %138
%140 = getelementptr inbounds double, double* %6, i64 %137
store double %139, double* %140
%141 = add nuw nsw i64 %129, 3
%142 = getelementptr inbounds double, double* %0, i64 %141
%143 = load double, double* %142
%144 = getelementptr inbounds double, double* %6, i64 %141
store double %143, double* %144
%145 = add nuw nsw i64 %129, 4
%146 = icmp eq i64 %145, %11
br i1 %146, label %116, label %128
147: ; preds = %147, %126
%148 = phi i64 [ 1, %126 ], [ %169, %147 ]
%149 = phi i64 [ 0, %126 ], [ %170, %147 ]
%150 = getelementptr inbounds double, double* %6, i64 %148
%151 = load double, double* %150
%152 = sub nsw i64 %119, %148
%153 = getelementptr inbounds double, double* %6, i64 %152
store double %151, double* %153
%154 = add nuw nsw i64 %148, 1
%155 = getelementptr inbounds double, double* %6, i64 %154
%156 = load double, double* %155
%157 = sub nsw i64 %119, %154
%158 = getelementptr inbounds double, double* %6, i64 %157
store double %156, double* %158
%159 = add nuw nsw i64 %148, 2
%160 = getelementptr inbounds double, double* %6, i64 %159
%161 = load double, double* %160
%162 = sub nsw i64 %119, %159
%163 = getelementptr inbounds double, double* %6, i64 %162
store double %161, double* %163
%164 = add nuw nsw i64 %148, 3
%165 = getelementptr inbounds double, double* %6, i64 %164
%166 = load double, double* %165
%167 = sub nsw i64 %119, %164
%168 = getelementptr inbounds double, double* %6, i64 %167
store double %166, double* %168
%169 = add nuw nsw i64 %148, 4
%170 = add nuw i64 %149, 4
%171 = icmp eq i64 %170, %127
br i1 %171, label %172, label %147
172: ; preds = %147, %118
%173 = phi i64 [ 1, %118 ], [ %169, %147 ]
%174 = icmp eq i64 %124, 0
br i1 %174, label %185, label %175
175: ; preds = %172, %175
%176 = phi i64 [ %182, %175 ], [ %173, %172 ]
%177 = phi i64 [ %183, %175 ], [ 0, %172 ]
%178 = getelementptr inbounds double, double* %6, i64 %176
%179 = load double, double* %178
%180 = sub nsw i64 %119, %176
%181 = getelementptr inbounds double, double* %6, i64 %180
store double %179, double* %181
%182 = add nuw nsw i64 %176, 1
%183 = add i64 %177, 1
%184 = icmp eq i64 %183, %124
br i1 %184, label %185, label %175
185: ; preds = %172, %175, %4, %116
%186 = tail call i32 @fftr(double* %6, double* %7, i32 %1)
store double 0.000000e+00, double* %2
%187 = icmp slt i32 %3, 1
br i1 %187, label %300, label %188
188: ; preds = %185
%189 = add nuw i32 %3, 1
%190 = zext i32 %189 to i64
%191 = add nsw i64 %190, -1
%192 = icmp ult i64 %191, 2
br i1 %192, label %260, label %193
193: ; preds = %188
%194 = getelementptr double, double* %2, i64 1
%195 = getelementptr double, double* %2, i64 %190
%196 = getelementptr double, double* %6, i64 1
%197 = getelementptr double, double* %6, i64 %190
%198 = icmp ult double* %194, %197
%199 = icmp ult double* %196, %195
%200 = and i1 %198, %199
br i1 %200, label %260, label %201
201: ; preds = %193
%202 = and i64 %191, -2
%203 = or i64 %191, 1
%204 = insertelement <2 x i32> poison, i32 %1, i64 0
%205 = shufflevector <2 x i32> %204, <2 x i32> poison, <2 x i32> zeroinitializer
%206 = add nsw i64 %202, -2
%207 = lshr exact i64 %206, 1
%208 = add nuw i64 %207, 1
%209 = and i64 %208, 1
%210 = icmp eq i64 %206, 0
br i1 %210, label %244, label %211
211: ; preds = %201
%212 = and i64 %208, -2
br label %213
213: ; preds = %213, %211
%214 = phi i64 [ 0, %211 ], [ %238, %213 ]
%215 = phi <2 x i32> [ <i32 1, i32 2>, %211 ], [ %239, %213 ]
%216 = phi i64 [ 0, %211 ], [ %240, %213 ]
%217 = or i64 %214, 1
%218 = getelementptr inbounds double, double* %6, i64 %217
%219 = bitcast double* %218 to <2 x double>*
%220 = load <2 x double>, <2 x double>* %219
%221 = mul nsw <2 x i32> %215, %205
%222 = sitofp <2 x i32> %221 to <2 x double>
%223 = fmul <2 x double> %222, <double 5.000000e-01, double 5.000000e-01>
%224 = fdiv <2 x double> %220, %223
%225 = getelementptr inbounds double, double* %2, i64 %217
%226 = bitcast double* %225 to <2 x double>*
store <2 x double> %224, <2 x double>* %226
%227 = add <2 x i32> %215, <i32 2, i32 2>
%228 = or i64 %214, 3
%229 = getelementptr inbounds double, double* %6, i64 %228
%230 = bitcast double* %229 to <2 x double>*
%231 = load <2 x double>, <2 x double>* %230
%232 = mul nsw <2 x i32> %227, %205
%233 = sitofp <2 x i32> %232 to <2 x double>
%234 = fmul <2 x double> %233, <double 5.000000e-01, double 5.000000e-01>
%235 = fdiv <2 x double> %231, %234
%236 = getelementptr inbounds double, double* %2, i64 %228
%237 = bitcast double* %236 to <2 x double>*
store <2 x double> %235, <2 x double>* %237
%238 = add nuw i64 %214, 4
%239 = add <2 x i32> %215, <i32 4, i32 4>
%240 = add nuw i64 %216, 2
%241 = icmp eq i64 %240, %212
br i1 %241, label %242, label %213
242: ; preds = %213
%243 = or i64 %238, 1
br label %244
244: ; preds = %242, %201
%245 = phi i64 [ 1, %201 ], [ %243, %242 ]
%246 = phi <2 x i32> [ <i32 1, i32 2>, %201 ], [ %239, %242 ]
%247 = icmp eq i64 %209, 0
br i1 %247, label %258, label %248
248: ; preds = %244
%249 = getelementptr inbounds double, double* %6, i64 %245
%250 = bitcast double* %249 to <2 x double>*
%251 = load <2 x double>, <2 x double>* %250
%252 = mul nsw <2 x i32> %246, %205
%253 = sitofp <2 x i32> %252 to <2 x double>
%254 = fmul <2 x double> %253, <double 5.000000e-01, double 5.000000e-01>
%255 = fdiv <2 x double> %251, %254
%256 = getelementptr inbounds double, double* %2, i64 %245
%257 = bitcast double* %256 to <2 x double>*
store <2 x double> %255, <2 x double>* %257
br label %258
258: ; preds = %244, %248
%259 = icmp eq i64 %191, %202
br i1 %259, label %300, label %260
260: ; preds = %193, %188, %258
%261 = phi i64 [ 1, %193 ], [ 1, %188 ], [ %203, %258 ]
%262 = xor i64 %261, -1
%263 = and i64 %190, 1
%264 = icmp eq i64 %263, 0
br i1 %264, label %265, label %275
265: ; preds = %260
%266 = getelementptr inbounds double, double* %6, i64 %261
%267 = load double, double* %266
%268 = trunc i64 %261 to i32
%269 = mul nsw i32 %268, %1
%270 = sitofp i32 %269 to double
%271 = fmul double %270, 5.000000e-01
%272 = fdiv double %267, %271
%273 = getelementptr inbounds double, double* %2, i64 %261
store double %272, double* %273
%274 = add nuw nsw i64 %261, 1
br label %275
275: ; preds = %265, %260
%276 = phi i64 [ %261, %260 ], [ %274, %265 ]
%277 = sub nsw i64 0, %190
%278 = icmp eq i64 %262, %277
br i1 %278, label %300, label %279
279: ; preds = %275, %279
%280 = phi i64 [ %298, %279 ], [ %276, %275 ]
%281 = getelementptr inbounds double, double* %6, i64 %280
%282 = load double, double* %281
%283 = trunc i64 %280 to i32
%284 = mul nsw i32 %283, %1
%285 = sitofp i32 %284 to double
%286 = fmul double %285, 5.000000e-01
%287 = fdiv double %282, %286
%288 = getelementptr inbounds double, double* %2, i64 %280
store double %287, double* %288
%289 = add nuw nsw i64 %280, 1
%290 = getelementptr inbounds double, double* %6, i64 %289
%291 = load double, double* %290
%292 = trunc i64 %289 to i32
%293 = mul nsw i32 %292, %1
%294 = sitofp i32 %293 to double
%295 = fmul double %294, 5.000000e-01
%296 = fdiv double %291, %295
%297 = getelementptr inbounds double, double* %2, i64 %289
store double %296, double* %297
%298 = add nuw nsw i64 %280, 2
%299 = icmp eq i64 %298, %190
br i1 %299, label %300, label %279
300: ; preds = %275, %279, %258, %185
%301 = icmp eq i32 %5, %3
br i1 %301, label %302, label %308
302: ; preds = %300
%303 = sext i32 %3 to i64
%304 = getelementptr inbounds double, double* %6, i64 %303
%305 = load double, double* %304
%306 = fmul double %305, 5.000000e-01
%307 = getelementptr inbounds double, double* %2, i64 %303
store double %306, double* %307
br label %308
308: ; preds = %302, %300
%309 = tail call i32 @free(double* %6)
%310 = tail call i32 @free(double* %7)
ret void
}