#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 log(double);
void Chi2FreqHomo(double f[], int ns, int nc, double X2G[2]) {
  int i, j;
  double mf[64] = {0}, small = 1e-50;
  X2G[0] = X2G[1] = 0;
  for (i = 0; i < ns; i++)
    for (j = 0; j < nc; j++)
      mf[j] += f[i * nc + j] / ns;
  for (i = 0; i < ns; i++) {
    for (j = 0; j < nc; j++) {
      if (mf[j] > small) {
        X2G[0] += ((f[i * nc + j] - mf[j]) * (f[i * nc + j] - mf[j])) / mf[j];
        if (f[i * nc + j])
          X2G[1] += 2 * f[i * nc + j] * log(f[i * nc + j] / mf[j]);
      }
    }
  }
}


x86 assembly (clang, -O0):
<Chi2FreqHomo>:
push   %rbp
mov    %rsp,%rbp
sub    $0x230,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
lea    -0x220(%rbp),%rdi
xor    %esi,%esi
mov    $0x200,%edx
call   1030 <memset@plt>
movsd  0xeac(%rip),%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11ef <Chi2FreqHomo+0xcf>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11dc <Chi2FreqHomo+0xbc>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsi2sdl -0xc(%rbp),%xmm1
divsd  %xmm1,%xmm0
movslq -0x20(%rbp),%rax
addsd  -0x220(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x220(%rbp,%rax,8)
ff ff
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    118d <Chi2FreqHomo+0x6d>
jmp    11e1 <Chi2FreqHomo+0xc1>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    117a <Chi2FreqHomo+0x5a>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    135c <Chi2FreqHomo+0x23c>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1349 <Chi2FreqHomo+0x229>
movslq -0x20(%rbp),%rax
movsd  -0x220(%rbp,%rax,8),%xmm0
ff ff
ucomisd -0x228(%rbp),%xmm0
ff
jbe    1336 <Chi2FreqHomo+0x216>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x20(%rbp),%rax
subsd  -0x220(%rbp,%rax,8),%xmm0
ff ff
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x20(%rbp),%rax
subsd  -0x220(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm1,%xmm0
movslq -0x20(%rbp),%rax
divsd  -0x220(%rbp,%rax,8),%xmm0
ff ff
mov    -0x18(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    12c1 <Chi2FreqHomo+0x1a1>
jp     12c1 <Chi2FreqHomo+0x1a1>
jmp    1331 <Chi2FreqHomo+0x211>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xd2e(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x20(%rbp),%rax
divsd  -0x220(%rbp,%rax,8),%xmm0
ff ff
call   1040 <log@plt>
movsd  -0x230(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm2
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax)
jmp    1336 <Chi2FreqHomo+0x216>
jmp    133b <Chi2FreqHomo+0x21b>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1209 <Chi2FreqHomo+0xe9>
jmp    134e <Chi2FreqHomo+0x22e>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11f6 <Chi2FreqHomo+0xd6>
add    $0x230,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Chi2FreqHomo>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x228,%rsp
mov    %rcx,%rbx
mov    %edx,0xc(%rsp)
mov    %esi,%ebp
mov    %rdi,%r13
lea    0x20(%rsp),%rdi
mov    $0x200,%edx
xor    %esi,%esi
call   1030 <memset@plt>
xorpd  %xmm0,%xmm0
movupd %xmm0,(%rbx)
test   %ebp,%ebp
jle    135c <Chi2FreqHomo+0x23c>
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
mov    0xc(%rsp),%r12d
movslq %r12d,%r8
mov    %ebp,0x10(%rsp)
mov    %ebp,%eax
mov    %rax,0x18(%rsp)
mov    %r8d,%ebp
mov    %ebp,%r14d
and    $0xfffffffe,%r14d
lea    -0x2(%r14),%r10
mov    %r10,%r11
shr    %r11
add    $0x1,%r11
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mov    %r11,%r9
and    $0xfffffffffffffffe,%r9
lea    0x10(%r13),%rax
lea    0x0(,%r8,8),%r15
xor    %edi,%edi
mov    %r13,%rdx
jmp    11d5 <Chi2FreqHomo+0xb5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rdi
add    %r15,%rax
add    %r15,%rdx
cmp    0x18(%rsp),%rdi
je     129d <Chi2FreqHomo+0x17d>
test   %r12d,%r12d
jle    11c0 <Chi2FreqHomo+0xa0>
cmp    $0x1,%r12d
jne    11f0 <Chi2FreqHomo+0xd0>
xor    %ecx,%ecx
jmp    1270 <Chi2FreqHomo+0x150>
nopw   0x0(%rax,%rax,1)
test   %r10,%r10
je     1293 <Chi2FreqHomo+0x173>
mov    %r9,%rcx
xor    %esi,%esi
xchg   %ax,%ax
movupd -0x10(%rax,%rsi,8),%xmm2
divpd  %xmm1,%xmm2
addpd  0x20(%rsp,%rsi,8),%xmm2
movapd %xmm2,0x20(%rsp,%rsi,8)
movupd (%rax,%rsi,8),%xmm2
divpd  %xmm1,%xmm2
addpd  0x30(%rsp,%rsi,8),%xmm2
movapd %xmm2,0x30(%rsp,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rcx
jne    1200 <Chi2FreqHomo+0xe0>
test   $0x1,%r11b
je     125c <Chi2FreqHomo+0x13c>
mov    %rdi,%rcx
imul   %r8,%rcx
add    %rsi,%rcx
movupd 0x0(%r13,%rcx,8),%xmm2
divpd  %xmm1,%xmm2
addpd  0x20(%rsp,%rsi,8),%xmm2
movapd %xmm2,0x20(%rsp,%rsi,8)
mov    %r14,%rcx
cmp    %rbp,%r14
je     11c0 <Chi2FreqHomo+0xa0>
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rcx,8),%xmm2
divsd  %xmm0,%xmm2
addsd  0x20(%rsp,%rcx,8),%xmm2
movsd  %xmm2,0x20(%rsp,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    1270 <Chi2FreqHomo+0x150>
jmp    11c0 <Chi2FreqHomo+0xa0>
xor    %esi,%esi
test   $0x1,%r11b
jne    123b <Chi2FreqHomo+0x11b>
jmp    125c <Chi2FreqHomo+0x13c>
cmpl   $0x0,0x10(%rsp)
jle    135c <Chi2FreqHomo+0x23c>
xor    %r12d,%r12d
movsd  0xd4d(%rip),%xmm2
jmp    12d2 <Chi2FreqHomo+0x1b2>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r12
add    %r15,%r13
cmp    0x18(%rsp),%r12
je     135c <Chi2FreqHomo+0x23c>
cmpl   $0x0,0xc(%rsp)
jle    12c0 <Chi2FreqHomo+0x1a0>
xor    %r14d,%r14d
jmp    12e9 <Chi2FreqHomo+0x1c9>
xchg   %ax,%ax
add    $0x1,%r14
cmp    %r14,%rbp
je     12c0 <Chi2FreqHomo+0x1a0>
movsd  0x20(%rsp,%r14,8),%xmm1
ucomisd %xmm2,%xmm1
jbe    12e0 <Chi2FreqHomo+0x1c0>
movsd  0x0(%r13,%r14,8),%xmm0
subsd  %xmm1,%xmm0
mulsd  %xmm0,%xmm0
divsd  %xmm1,%xmm0
addsd  (%rbx),%xmm0
movsd  %xmm0,(%rbx)
movsd  0x0(%r13,%r14,8),%xmm0
ucomisd 0xce8(%rip),%xmm0
jne    1324 <Chi2FreqHomo+0x204>
jnp    12e0 <Chi2FreqHomo+0x1c0>
movapd %xmm0,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x10(%rsp)
divsd  %xmm1,%xmm0
call   1040 <log@plt>
movsd  0xcbd(%rip),%xmm2
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x10(%rsp),%xmm0
addsd  0x8(%rbx),%xmm0
movsd  %xmm0,0x8(%rbx)
jmp    12e0 <Chi2FreqHomo+0x1c0>
add    $0x228,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @Chi2FreqHomo(double* %0, i32 %1, i32 %2, double* %3) {
%5 = alloca double*
%6 = alloca i32
%7 = alloca i32
%8 = alloca double*
%9 = alloca i32
%10 = alloca i32
%11 = alloca [64 x double]
%12 = alloca double
store double* %0, double** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store double* %3, double** %8
%13 = bitcast [64 x double]* %11 to i8*
store double 1.000000e-50, double* %12
%14 = load double*, double** %8
%15 = getelementptr inbounds double, double* %14, i64 1
store double 0.000000e+00, double* %15
%16 = load double*, double** %8
%17 = getelementptr inbounds double, double* %16, i64 0
store double 0.000000e+00, double* %17
store i32 0, i32* %9
br label %18
18: ; preds = %49, %4
%19 = load i32, i32* %9
%20 = load i32, i32* %6
%21 = icmp slt i32 %19, %20
br i1 %21, label %22, label %52
22: ; preds = %18
store i32 0, i32* %10
br label %23
23: ; preds = %45, %22
%24 = load i32, i32* %10
%25 = load i32, i32* %7
%26 = icmp slt i32 %24, %25
br i1 %26, label %27, label %48
27: ; preds = %23
%28 = load double*, double** %5
%29 = load i32, i32* %9
%30 = load i32, i32* %7
%31 = mul nsw i32 %29, %30
%32 = load i32, i32* %10
%33 = add nsw i32 %31, %32
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds double, double* %28, i64 %34
%36 = load double, double* %35
%37 = load i32, i32* %6
%38 = sitofp i32 %37 to double
%39 = fdiv double %36, %38
%40 = load i32, i32* %10
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds [64 x double], [64 x double]* %11, i64 0, i64 %41
%43 = load double, double* %42
%44 = fadd double %43, %39
store double %44, double* %42
br label %45
45: ; preds = %27
%46 = load i32, i32* %10
%47 = add nsw i32 %46, 1
store i32 %47, i32* %10
br label %23
48: ; preds = %23
br label %49
49: ; preds = %48
%50 = load i32, i32* %9
%51 = add nsw i32 %50, 1
store i32 %51, i32* %9
br label %18
52: ; preds = %18
store i32 0, i32* %9
br label %53
53: ; preds = %155, %52
%54 = load i32, i32* %9
%55 = load i32, i32* %6
%56 = icmp slt i32 %54, %55
br i1 %56, label %57, label %158
57: ; preds = %53
store i32 0, i32* %10
br label %58
58: ; preds = %151, %57
%59 = load i32, i32* %10
%60 = load i32, i32* %7
%61 = icmp slt i32 %59, %60
br i1 %61, label %62, label %154
62: ; preds = %58
%63 = load i32, i32* %10
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds [64 x double], [64 x double]* %11, i64 0, i64 %64
%66 = load double, double* %65
%67 = load double, double* %12
%68 = fcmp ogt double %66, %67
br i1 %68, label %69, label %150
69: ; preds = %62
%70 = load double*, double** %5
%71 = load i32, i32* %9
%72 = load i32, i32* %7
%73 = mul nsw i32 %71, %72
%74 = load i32, i32* %10
%75 = add nsw i32 %73, %74
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds double, double* %70, i64 %76
%78 = load double, double* %77
%79 = load i32, i32* %10
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [64 x double], [64 x double]* %11, i64 0, i64 %80
%82 = load double, double* %81
%83 = fsub double %78, %82
%84 = load double*, double** %5
%85 = load i32, i32* %9
%86 = load i32, i32* %7
%87 = mul nsw i32 %85, %86
%88 = load i32, i32* %10
%89 = add nsw i32 %87, %88
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds double, double* %84, i64 %90
%92 = load double, double* %91
%93 = load i32, i32* %10
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds [64 x double], [64 x double]* %11, i64 0, i64 %94
%96 = load double, double* %95
%97 = fsub double %92, %96
%98 = fmul double %83, %97
%99 = load i32, i32* %10
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [64 x double], [64 x double]* %11, i64 0, i64 %100
%102 = load double, double* %101
%103 = fdiv double %98, %102
%104 = load double*, double** %8
%105 = getelementptr inbounds double, double* %104, i64 0
%106 = load double, double* %105
%107 = fadd double %106, %103
store double %107, double* %105
%108 = load double*, double** %5
%109 = load i32, i32* %9
%110 = load i32, i32* %7
%111 = mul nsw i32 %109, %110
%112 = load i32, i32* %10
%113 = add nsw i32 %111, %112
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds double, double* %108, i64 %114
%116 = load double, double* %115
%117 = fcmp une double %116, 0.000000e+00
br i1 %117, label %118, label %149
118: ; preds = %69
%119 = load double*, double** %5
%120 = load i32, i32* %9
%121 = load i32, i32* %7
%122 = mul nsw i32 %120, %121
%123 = load i32, i32* %10
%124 = add nsw i32 %122, %123
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds double, double* %119, i64 %125
%127 = load double, double* %126
%128 = fmul double 2.000000e+00, %127
%129 = load double*, double** %5
%130 = load i32, i32* %9
%131 = load i32, i32* %7
%132 = mul nsw i32 %130, %131
%133 = load i32, i32* %10
%134 = add nsw i32 %132, %133
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds double, double* %129, i64 %135
%137 = load double, double* %136
%138 = load i32, i32* %10
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds [64 x double], [64 x double]* %11, i64 0, i64 %139
%141 = load double, double* %140
%142 = fdiv double %137, %141
%143 = call i32 @log(double %142)
%144 = sitofp i32 %143 to double
%145 = load double*, double** %8
%146 = getelementptr inbounds double, double* %145, i64 1
%147 = load double, double* %146
%148 = call double @llvm.fmuladd.f64(double %128, double %144, double %147)
store double %148, double* %146
br label %149
149: ; preds = %118, %69
br label %150
150: ; preds = %149, %62
br label %151
151: ; preds = %150
%152 = load i32, i32* %10
%153 = add nsw i32 %152, 1
store i32 %153, i32* %10
br label %58
154: ; preds = %58
br label %155
155: ; preds = %154
%156 = load i32, i32* %9
%157 = add nsw i32 %156, 1
store i32 %157, i32* %9
br label %53
158: ; preds = %53
ret void
}

LLVM IR (-O2):
define void @Chi2FreqHomo(double* nocapture %0, i32 %1, i32 %2, double* nocapture %3) {
%5 = alloca [64 x double]
%6 = bitcast [64 x double]* %5 to i8*
%7 = getelementptr inbounds double, double* %3, i64 1
%8 = icmp sgt i32 %1, 0
%9 = bitcast double* %3 to i8*
br i1 %8, label %10, label %130
10: ; preds = %4
%11 = icmp sgt i32 %2, 0
%12 = sitofp i32 %1 to double
%13 = sext i32 %2 to i64
%14 = zext i32 %1 to i64
%15 = zext i32 %2 to i64
%16 = and i64 %15, 4294967294
%17 = add nsw i64 %16, -2
%18 = lshr exact i64 %17, 1
%19 = add nuw i64 %18, 1
%20 = icmp eq i32 %2, 1
%21 = and i64 %15, 4294967294
%22 = insertelement <2 x double> poison, double %12, i64 0
%23 = shufflevector <2 x double> %22, <2 x double> poison, <2 x i32> zeroinitializer
%24 = and i64 %19, 1
%25 = icmp eq i64 %17, 0
%26 = and i64 %19, -2
%27 = icmp eq i64 %24, 0
%28 = icmp eq i64 %21, %15
br label %29
29: ; preds = %10, %94
%30 = phi i64 [ 0, %10 ], [ %95, %94 ]
br i1 %11, label %31, label %94
31: ; preds = %29
%32 = mul nsw i64 %30, %13
br i1 %20, label %75, label %33
33: ; preds = %31
br i1 %25, label %61, label %34
34: ; preds = %33, %34
%35 = phi i64 [ %58, %34 ], [ 0, %33 ]
%36 = phi i64 [ %59, %34 ], [ 0, %33 ]
%37 = add nsw i64 %35, %32
%38 = getelementptr inbounds double, double* %0, i64 %37
%39 = bitcast double* %38 to <2 x double>*
%40 = load <2 x double>, <2 x double>* %39
%41 = fdiv <2 x double> %40, %23
%42 = getelementptr inbounds [64 x double], [64 x double]* %5, i64 0, i64 %35
%43 = bitcast double* %42 to <2 x double>*
%44 = load <2 x double>, <2 x double>* %43
%45 = fadd <2 x double> %44, %41
%46 = bitcast double* %42 to <2 x double>*
store <2 x double> %45, <2 x double>* %46
%47 = or i64 %35, 2
%48 = add nsw i64 %47, %32
%49 = getelementptr inbounds double, double* %0, i64 %48
%50 = bitcast double* %49 to <2 x double>*
%51 = load <2 x double>, <2 x double>* %50
%52 = fdiv <2 x double> %51, %23
%53 = getelementptr inbounds [64 x double], [64 x double]* %5, i64 0, i64 %47
%54 = bitcast double* %53 to <2 x double>*
%55 = load <2 x double>, <2 x double>* %54
%56 = fadd <2 x double> %55, %52
%57 = bitcast double* %53 to <2 x double>*
store <2 x double> %56, <2 x double>* %57
%58 = add nuw i64 %35, 4
%59 = add nuw i64 %36, 2
%60 = icmp eq i64 %59, %26
br i1 %60, label %61, label %34
61: ; preds = %34, %33
%62 = phi i64 [ 0, %33 ], [ %58, %34 ]
br i1 %27, label %74, label %63
63: ; preds = %61
%64 = add nsw i64 %62, %32
%65 = getelementptr inbounds double, double* %0, i64 %64
%66 = bitcast double* %65 to <2 x double>*
%67 = load <2 x double>, <2 x double>* %66
%68 = fdiv <2 x double> %67, %23
%69 = getelementptr inbounds [64 x double], [64 x double]* %5, i64 0, i64 %62
%70 = bitcast double* %69 to <2 x double>*
%71 = load <2 x double>, <2 x double>* %70
%72 = fadd <2 x double> %71, %68
%73 = bitcast double* %69 to <2 x double>*
store <2 x double> %72, <2 x double>* %73
br label %74
74: ; preds = %61, %63
br i1 %28, label %94, label %75
75: ; preds = %31, %74
%76 = phi i64 [ 0, %31 ], [ %21, %74 ]
br label %83
77: ; preds = %94
br i1 %8, label %78, label %130
78: ; preds = %77
%79 = icmp sgt i32 %2, 0
%80 = sext i32 %2 to i64
%81 = zext i32 %1 to i64
%82 = zext i32 %2 to i64
br label %97
83: ; preds = %75, %83
%84 = phi i64 [ %92, %83 ], [ %76, %75 ]
%85 = add nsw i64 %84, %32
%86 = getelementptr inbounds double, double* %0, i64 %85
%87 = load double, double* %86
%88 = fdiv double %87, %12
%89 = getelementptr inbounds [64 x double], [64 x double]* %5, i64 0, i64 %84
%90 = load double, double* %89
%91 = fadd double %90, %88
store double %91, double* %89
%92 = add nuw nsw i64 %84, 1
%93 = icmp eq i64 %92, %15
br i1 %93, label %94, label %83
94: ; preds = %83, %74, %29
%95 = add nuw nsw i64 %30, 1
%96 = icmp eq i64 %95, %14
br i1 %96, label %77, label %29
97: ; preds = %78, %127
%98 = phi i64 [ 0, %78 ], [ %128, %127 ]
br i1 %79, label %99, label %127
99: ; preds = %97
%100 = mul nsw i64 %98, %80
br label %101
101: ; preds = %99, %124
%102 = phi i64 [ 0, %99 ], [ %125, %124 ]
%103 = getelementptr inbounds [64 x double], [64 x double]* %5, i64 0, i64 %102
%104 = load double, double* %103
%105 = fcmp ogt double %104, 1.000000e-50
br i1 %105, label %106, label %124
106: ; preds = %101
%107 = add nsw i64 %102, %100
%108 = getelementptr inbounds double, double* %0, i64 %107
%109 = load double, double* %108
%110 = fsub double %109, %104
%111 = fmul double %110, %110
%112 = fdiv double %111, %104
%113 = load double, double* %3
%114 = fadd double %113, %112
store double %114, double* %3
%115 = load double, double* %108
%116 = fcmp une double %115, 0.000000e+00
br i1 %116, label %117, label %124
117: ; preds = %106
%118 = fmul double %115, 2.000000e+00
%119 = fdiv double %115, %104
%120 = tail call i32 @log(double %119)
%121 = sitofp i32 %120 to double
%122 = load double, double* %7
%123 = tail call double @llvm.fmuladd.f64(double %118, double %121, double %122)
store double %123, double* %7
br label %124
124: ; preds = %101, %117, %106
%125 = add nuw nsw i64 %102, 1
%126 = icmp eq i64 %125, %82
br i1 %126, label %127, label %101
127: ; preds = %124, %97
%128 = add nuw nsw i64 %98, 1
%129 = icmp eq i64 %128, %81
br i1 %129, label %130, label %97
130: ; preds = %127, %4, %77
ret void
}