#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*/ free(double *);
scalar_t__ malloc(int);
double dCombinations(int n, int r) {
  if (r < 0)
    return 0;
  if (n < 0)
    return dCombinations(r - n - 1, r) * ((r % 2 == 0) ? 1 : -1);
  if (n < r)
    return 0;
  if ((n == 0) && (r == 0))
    return 1.0;
  int i, j;
  double *nn, *no, *h;
  nn = (double *)malloc(sizeof(double) * ((size_t)(r + 1)));
  no = (double *)malloc(sizeof(double) * ((size_t)(r + 1)));
  for (i = 0; i <= r; i++) {
    nn[i] = no[i] = 0;
  }
  nn[0] = no[0] = 1;
  for (i = 1; i <= n; i++) {
    h = no;
    no = nn;
    nn = h;
    for (j = 1; j <= r; j++) {
      nn[j] = no[j] + no[j - 1];
    }
  }
  double res = nn[r];
  free(nn);
  free(no);
  return res;
}


x86 assembly (clang, -O0):
<dCombinations>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0xc(%rbp)
mov    %esi,-0x10(%rbp)
cmpl   $0x0,-0x10(%rbp)
jge    1155 <dCombinations+0x25>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1324 <dCombinations+0x1f4>
cmpl   $0x0,-0xc(%rbp)
jge    119d <dCombinations+0x6d>
mov    -0x10(%rbp),%edi
sub    -0xc(%rbp),%edi
sub    $0x1,%edi
mov    -0x10(%rbp),%esi
call   1050 <dCombinations@plt>
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    $0xffffffff,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmove  %ecx,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1324 <dCombinations+0x1f4>
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11b6 <dCombinations+0x86>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1324 <dCombinations+0x1f4>
cmpl   $0x0,-0xc(%rbp)
jne    11dc <dCombinations+0xac>
cmpl   $0x0,-0x10(%rbp)
jne    11dc <dCombinations+0xac>
movsd  0xe2e(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1324 <dCombinations+0x1f4>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     124b <dCombinations+0x11b>
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1211 <dCombinations+0xe1>
mov    -0x28(%rbp),%rax
movsd  0xda9(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movsd  0xd99(%rip),%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     12f6 <dCombinations+0x1c6>
mov    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x20(%rbp)
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     12e3 <dCombinations+0x1b3>
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    129d <dCombinations+0x16d>
jmp    12e8 <dCombinations+0x1b8>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1272 <dCombinations+0x142>
mov    -0x20(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dCombinations>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
xorpd  %xmm1,%xmm1
test   %esi,%esi
js     15b3 <dCombinations+0x483>
mov    %esi,%r15d
mov    %edi,%r14d
test   %edi,%edi
js     1255 <dCombinations+0x125>
cmp    %r14d,%r15d
ja     15b3 <dCombinations+0x483>
mov    %r15d,%eax
or     %r14d,%eax
je     1282 <dCombinations+0x152>
lea    0x8(,%r15,8),%ebp
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    %rax,%rbx
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    %rax,%rbp
lea    0x1(%r15),%eax
cmp    $0x3,%r15d
jb     11b4 <dCombinations+0x84>
lea    (%rbx,%rax,8),%rcx
cmp    %rcx,%rbp
jae    128f <dCombinations+0x15f>
lea    0x0(,%rax,8),%rcx
add    %rbp,%rcx
cmp    %rcx,%rbx
jae    128f <dCombinations+0x15f>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     11eb <dCombinations+0xbb>
nopl   0x0(%rax,%rax,1)
movq   $0x0,0x0(%rbp,%rcx,8)
movq   $0x0,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    11d0 <dCombinations+0xa0>
cmp    $0x3,%rdx
jb     1378 <dCombinations+0x248>
cs nopw 0x0(%rax,%rax,1)
nop
movq   $0x0,0x0(%rbp,%rcx,8)
movq   $0x0,(%rbx,%rcx,8)
movq   $0x0,0x8(%rbp,%rcx,8)
movq   $0x0,0x8(%rbx,%rcx,8)
movq   $0x0,0x10(%rbp,%rcx,8)
movq   $0x0,0x10(%rbx,%rcx,8)
movq   $0x0,0x18(%rbp,%rcx,8)
movq   $0x0,0x18(%rbx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1200 <dCombinations+0xd0>
jmp    1378 <dCombinations+0x248>
not    %r14d
add    %r15d,%r14d
mov    %r14d,%edi
mov    %r15d,%esi
call   1050 <dCombinations@plt>
and    $0x1,%r15d
neg    %r15d
sbb    %eax,%eax
or     $0x1,%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
mulsd  %xmm0,%xmm1
jmp    15b3 <dCombinations+0x483>
movsd  0xd76(%rip),%xmm1
jmp    15b3 <dCombinations+0x483>
mov    %eax,%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    12b4 <dCombinations+0x184>
xor    %edi,%edi
jmp    1329 <dCombinations+0x1f9>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
xorpd  %xmm0,%xmm0
xchg   %ax,%ax
movupd %xmm0,0x0(%rbp,%rdi,8)
movupd %xmm0,0x10(%rbp,%rdi,8)
movupd %xmm0,(%rbx,%rdi,8)
movupd %xmm0,0x10(%rbx,%rdi,8)
movupd %xmm0,0x20(%rbp,%rdi,8)
movupd %xmm0,0x30(%rbp,%rdi,8)
movupd %xmm0,0x20(%rbx,%rdi,8)
movupd %xmm0,0x30(%rbx,%rdi,8)
movupd %xmm0,0x40(%rbp,%rdi,8)
movupd %xmm0,0x50(%rbp,%rdi,8)
movupd %xmm0,0x40(%rbx,%rdi,8)
movupd %xmm0,0x50(%rbx,%rdi,8)
movupd %xmm0,0x60(%rbp,%rdi,8)
movupd %xmm0,0x70(%rbp,%rdi,8)
movupd %xmm0,0x60(%rbx,%rdi,8)
movupd %xmm0,0x70(%rbx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    12c0 <dCombinations+0x190>
test   %r8,%r8
je     136f <dCombinations+0x23f>
lea    (%rbx,%rdi,8),%rsi
add    $0x10,%rsi
lea    0x10(,%rdi,8),%rdi
add    %rbp,%rdi
shl    $0x5,%r8
xor    %edx,%edx
xorpd  %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movupd %xmm0,-0x10(%rdi,%rdx,1)
movupd %xmm0,(%rdi,%rdx,1)
movupd %xmm0,-0x10(%rsi,%rdx,1)
movupd %xmm0,(%rsi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    1350 <dCombinations+0x220>
cmp    %rax,%rcx
jne    11b6 <dCombinations+0x86>
movabs $0x3ff0000000000000,%rcx
mov    %rcx,0x0(%rbp)
mov    %rcx,(%rbx)
test   %r14d,%r14d
jle    1591 <dCombinations+0x461>
lea    -0x1(%rax),%r11
lea    -0x5(%rax),%rcx
mov    %rcx,(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %r11,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0x18(%rsp)
add    $0x1,%rdx
mov    %rdx,0x10(%rsp)
movabs $0x7ffffffffffffffc,%rsi
ff ff 7f
or     $0x2,%rsi
mov    %rcx,%rdx
mov    %rcx,0x20(%rsp)
and    %rcx,%rsi
mov    %rsi,0x8(%rsp)
mov    %rax,%r13
neg    %r13
mov    $0x1,%edi
mov    %rbp,%rdx
jmp    1401 <dCombinations+0x2d1>
nopl   0x0(%rax)
lea    0x1(%rdi),%ecx
mov    %rbp,%rdx
cmp    %r14d,%edi
mov    %ecx,%edi
je     1591 <dCombinations+0x461>
mov    %rbx,%rbp
mov    %rdx,%rbx
test   %r15d,%r15d
jle    13f0 <dCombinations+0x2c0>
mov    $0x1,%esi
cmp    $0x4,%r11
jb     1530 <dCombinations+0x400>
lea    0x8(%rbx),%rdx
lea    (%rbx,%rax,8),%rcx
lea    0x8(%rbp),%r8
lea    0x0(,%rax,8),%r10
add    %rbp,%r10
lea    0x0(,%r11,8),%r9
add    %rbp,%r9
cmp    %r10,%rdx
setb   %r10b
cmp    %rcx,%r8
setb   %r12b
cmp    %r9,%rdx
setb   %dl
cmp    %rcx,%rbp
setb   %r8b
test   %r12b,%r10b
jne    1530 <dCombinations+0x400>
and    %r8b,%dl
jne    1530 <dCombinations+0x400>
cmpq   $0x4,(%rsp)
jae    1475 <dCombinations+0x345>
xor    %esi,%esi
jmp    14e2 <dCombinations+0x3b2>
mov    0x8(%rsp),%rdx
xor    %esi,%esi
nopl   0x0(%rax)
movupd 0x0(%rbp,%rsi,8),%xmm0
movupd 0x8(%rbp,%rsi,8),%xmm1
addpd  %xmm0,%xmm1
movupd 0x10(%rbp,%rsi,8),%xmm0
movupd 0x18(%rbp,%rsi,8),%xmm2
addpd  %xmm0,%xmm2
movupd %xmm1,0x8(%rbx,%rsi,8)
movupd %xmm2,0x18(%rbx,%rsi,8)
movupd 0x20(%rbp,%rsi,8),%xmm0
movupd 0x28(%rbp,%rsi,8),%xmm1
addpd  %xmm0,%xmm1
movupd 0x30(%rbp,%rsi,8),%xmm0
movupd 0x38(%rbp,%rsi,8),%xmm2
addpd  %xmm0,%xmm2
movupd %xmm1,0x28(%rbx,%rsi,8)
movupd %xmm2,0x38(%rbx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdx
jne    1480 <dCombinations+0x350>
testb  $0x1,0x20(%rsp)
je     1520 <dCombinations+0x3f0>
lea    0x0(,%rsi,8),%rcx
or     $0x8,%rcx
movupd 0x0(%rbp,%rcx,1),%xmm0
movupd 0x10(%rbp,%rcx,1),%xmm1
movupd 0x0(%rbp,%rsi,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rbp,%rsi,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rcx,1)
movupd %xmm0,0x10(%rbx,%rcx,1)
mov    0x10(%rsp),%rsi
cmp    0x18(%rsp),%r11
je     13f0 <dCombinations+0x2c0>
mov    %rsi,%rdx
test   $0x1,%al
jne    154c <dCombinations+0x41c>
movsd  0x0(%rbp,%rsi,8),%xmm0
addsd  -0x8(%rbp,%rsi,8),%xmm0
movsd  %xmm0,(%rbx,%rsi,8)
lea    0x1(%rsi),%rdx
not    %rsi
cmp    %r13,%rsi
je     13f0 <dCombinations+0x2c0>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdx,8),%xmm0
addsd  -0x8(%rbp,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  0x8(%rbp,%rdx,8),%xmm0
addsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    1560 <dCombinations+0x430>
jmp    13f0 <dCombinations+0x2c0>
movslq %r15d,%rax
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rsp)
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
movsd  (%rsp),%xmm1
movapd %xmm1,%xmm0
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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