#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 rbernoulli(double);
double rgamma(double, double);
void sample_H(int D, int p, double *par_0, double *par_1, double *par_2,
              double par_p_t, int ***L, double ***Lambda) {
  for (int d = 0; d < D; d++) {
    for (int i = 0; i < p; i++) {
      for (int j = i; j < p; j++) {
        if (j == i) {
          Lambda[d][i][j] = rgamma(par_2[0], par_2[1]);
          L[d][i][i] = -1;
        } else {
          L[d][i][j] = rbernoulli(par_p_t);
          if (L[d][i][j] == 1) {
            Lambda[d][i][j] = rgamma(par_1[0], par_1[1]);
          } else {
            Lambda[d][i][j] = rgamma(par_0[0], par_0[1]);
          }
          L[d][j][i] = L[d][i][j];
          Lambda[d][j][i] = Lambda[d][i][j];
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<sample_H>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    133f <sample_H+0x21f>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    132c <sample_H+0x20c>
mov    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1319 <sample_H+0x1f9>
mov    -0x3c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jne    11e2 <sample_H+0xc2>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm1
call   1030 <rgamma@plt>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
jmp    1306 <sample_H+0x1e6>
movsd  -0x28(%rbp),%xmm0
call   1040 <rbernoulli@plt>
mov    %eax,%edx
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    1263 <sample_H+0x143>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm1
call   1030 <rgamma@plt>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1296 <sample_H+0x176>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
call   1030 <rgamma@plt>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    130b <sample_H+0x1eb>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1173 <sample_H+0x53>
jmp    131e <sample_H+0x1fe>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1161 <sample_H+0x41>
jmp    1331 <sample_H+0x211>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    114e <sample_H+0x2e>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sample_H>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
movsd  %xmm0,0x50(%rsp)
mov    %r8,0x10(%rsp)
mov    %rcx,0x48(%rsp)
mov    %rdx,0x40(%rsp)
mov    %esi,0x4(%rsp)
test   %edi,%edi
jle    1303 <sample_H+0x1e3>
mov    %r9,%r15
mov    %edi,%eax
mov    %rax,0x28(%rsp)
mov    0x4(%rsp),%ebx
lea    -0x1(%rbx),%rax
mov    %rax,0x20(%rsp)
xor    %r13d,%r13d
mov    %r9,0x8(%rsp)
mov    %rbx,0x30(%rsp)
jmp    118f <sample_H+0x6f>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r13
cmp    0x28(%rsp),%r13
je     1303 <sample_H+0x1e3>
cmpl   $0x0,0x4(%rsp)
jle    1180 <sample_H+0x60>
mov    $0x8,%r12d
mov    $0x4,%ebp
mov    0x20(%rsp),%rax
mov    %rax,0x18(%rsp)
xor    %r14d,%r14d
jmp    11d0 <sample_H+0xb0>
add    $0x8,%r12
add    $0x4,%rbp
addq   $0xffffffffffffffff,0x18(%rsp)
mov    0x38(%rsp),%rax
mov    %rax,%r14
mov    0x30(%rsp),%rbx
cmp    %rbx,%rax
je     1180 <sample_H+0x60>
mov    0x10(%rsp),%rax
movsd  (%rax),%xmm0
movsd  0x8(%rax),%xmm1
call   1030 <rgamma@plt>
mov    0x8(%rsp),%r15
mov    0x90(%rsp),%rax
mov    (%rax,%r13,8),%rax
mov    (%rax,%r14,8),%rax
movsd  %xmm0,(%rax,%r14,8)
mov    (%r15,%r13,8),%rax
mov    (%rax,%r14,8),%rax
movl   $0xffffffff,(%rax,%r14,4)
ff
lea    0x1(%r14),%rax
mov    %rax,0x38(%rsp)
cmp    %rbx,%rax
je     11b0 <sample_H+0x90>
xor    %ebx,%ebx
jmp    127b <sample_H+0x15b>
movsd  (%rcx),%xmm0
movsd  0x8(%rcx),%xmm1
call   1030 <rgamma@plt>
mov    0x90(%rsp),%rax
mov    (%rax,%r13,8),%rax
mov    (%rax,%r14,8),%rcx
add    %r12,%rcx
movsd  %xmm0,(%rcx,%rbx,8)
mov    (%r15,%r13,8),%rcx
mov    (%rcx,%r14,8),%rdx
add    %rbp,%rdx
mov    (%rdx,%rbx,4),%edx
add    %r12,%rcx
mov    (%rcx,%rbx,8),%rcx
mov    %edx,(%rcx,%r14,4)
add    %r12,%rax
mov    (%rax,%rbx,8),%rax
movsd  %xmm0,(%rax,%r14,8)
add    $0x1,%rbx
cmp    %rbx,0x18(%rsp)
je     11b0 <sample_H+0x90>
cmp    $0xffffffffffffffff,%rbx
je     12c0 <sample_H+0x1a0>
movsd  0x50(%rsp),%xmm0
call   1040 <rbernoulli@plt>
mov    (%r15,%r13,8),%rcx
mov    (%rcx,%r14,8),%rcx
add    %rbp,%rcx
mov    %eax,(%rcx,%rbx,4)
mov    0x48(%rsp),%rcx
cmp    $0x1,%eax
je     1220 <sample_H+0x100>
mov    0x40(%rsp),%rcx
jmp    1220 <sample_H+0x100>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x10(%rsp),%rax
movsd  (%rax),%xmm0
movsd  0x8(%rax),%xmm1
call   1030 <rgamma@plt>
mov    0x8(%rsp),%r15
mov    0x90(%rsp),%rax
mov    (%rax,%r13,8),%rax
mov    (%rax,%r14,8),%rax
movsd  %xmm0,(%rax,%r14,8)
mov    (%r15,%r13,8),%rax
mov    (%rax,%r14,8),%rax
movl   $0xffffffff,(%rax,%r14,4)
ff
jmp    126c <sample_H+0x14c>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @sample_H(i32 %0, i32 %1, double* %2, double* %3, double* %4, double %5, i32*** %6, double*** %7) {
%9 = alloca i32
%10 = alloca i32
%11 = alloca double*
%12 = alloca double*
%13 = alloca double*
%14 = alloca double
%15 = alloca i32***
%16 = alloca double***
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
store i32 %0, i32* %9
store i32 %1, i32* %10
store double* %2, double** %11
store double* %3, double** %12
store double* %4, double** %13
store double %5, double* %14
store i32*** %6, i32**** %15
store double*** %7, double**** %16
store i32 0, i32* %17
br label %20
20: ; preds = %200, %8
%21 = load i32, i32* %17
%22 = load i32, i32* %9
%23 = icmp slt i32 %21, %22
br i1 %23, label %24, label %203
24: ; preds = %20
store i32 0, i32* %18
br label %25
25: ; preds = %196, %24
%26 = load i32, i32* %18
%27 = load i32, i32* %10
%28 = icmp slt i32 %26, %27
br i1 %28, label %29, label %199
29: ; preds = %25
%30 = load i32, i32* %18
store i32 %30, i32* %19
br label %31
31: ; preds = %192, %29
%32 = load i32, i32* %19
%33 = load i32, i32* %10
%34 = icmp slt i32 %32, %33
br i1 %34, label %35, label %195
35: ; preds = %31
%36 = load i32, i32* %19
%37 = load i32, i32* %18
%38 = icmp eq i32 %36, %37
br i1 %38, label %39, label %71
39: ; preds = %35
%40 = load double*, double** %13
%41 = getelementptr inbounds double, double* %40, i64 0
%42 = load double, double* %41
%43 = load double*, double** %13
%44 = getelementptr inbounds double, double* %43, i64 1
%45 = load double, double* %44
%46 = call double @rgamma(double %42, double %45)
%47 = load double***, double**** %16
%48 = load i32, i32* %17
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds double**, double*** %47, i64 %49
%51 = load double**, double*** %50
%52 = load i32, i32* %18
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds double*, double** %51, i64 %53
%55 = load double*, double** %54
%56 = load i32, i32* %19
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds double, double* %55, i64 %57
store double %46, double* %58
%59 = load i32***, i32**** %15
%60 = load i32, i32* %17
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds i32**, i32*** %59, i64 %61
%63 = load i32**, i32*** %62
%64 = load i32, i32* %18
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds i32*, i32** %63, i64 %65
%67 = load i32*, i32** %66
%68 = load i32, i32* %18
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i32, i32* %67, i64 %69
store i32 -1, i32* %70
br label %191
71: ; preds = %35
%72 = load double, double* %14
%73 = call i32 @rbernoulli(double %72)
%74 = load i32***, i32**** %15
%75 = load i32, i32* %17
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds i32**, i32*** %74, i64 %76
%78 = load i32**, i32*** %77
%79 = load i32, i32* %18
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i32*, i32** %78, i64 %80
%82 = load i32*, i32** %81
%83 = load i32, i32* %19
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds i32, i32* %82, i64 %84
store i32 %73, i32* %85
%86 = load i32***, i32**** %15
%87 = load i32, i32* %17
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds i32**, i32*** %86, i64 %88
%90 = load i32**, i32*** %89
%91 = load i32, i32* %18
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds i32*, i32** %90, i64 %92
%94 = load i32*, i32** %93
%95 = load i32, i32* %19
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds i32, i32* %94, i64 %96
%98 = load i32, i32* %97
%99 = icmp eq i32 %98, 1
br i1 %99, label %100, label %120
100: ; preds = %71
%101 = load double*, double** %12
%102 = getelementptr inbounds double, double* %101, i64 0
%103 = load double, double* %102
%104 = load double*, double** %12
%105 = getelementptr inbounds double, double* %104, i64 1
%106 = load double, double* %105
%107 = call double @rgamma(double %103, double %106)
%108 = load double***, double**** %16
%109 = load i32, i32* %17
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds double**, double*** %108, i64 %110
%112 = load double**, double*** %111
%113 = load i32, i32* %18
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds double*, double** %112, i64 %114
%116 = load double*, double** %115
%117 = load i32, i32* %19
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds double, double* %116, i64 %118
store double %107, double* %119
br label %140
120: ; preds = %71
%121 = load double*, double** %11
%122 = getelementptr inbounds double, double* %121, i64 0
%123 = load double, double* %122
%124 = load double*, double** %11
%125 = getelementptr inbounds double, double* %124, i64 1
%126 = load double, double* %125
%127 = call double @rgamma(double %123, double %126)
%128 = load double***, double**** %16
%129 = load i32, i32* %17
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds double**, double*** %128, i64 %130
%132 = load double**, double*** %131
%133 = load i32, i32* %18
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds double*, double** %132, i64 %134
%136 = load double*, double** %135
%137 = load i32, i32* %19
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds double, double* %136, i64 %138
store double %127, double* %139
br label %140
140: ; preds = %120, %100
%141 = load i32***, i32**** %15
%142 = load i32, i32* %17
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds i32**, i32*** %141, i64 %143
%145 = load i32**, i32*** %144
%146 = load i32, i32* %18
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds i32*, i32** %145, i64 %147
%149 = load i32*, i32** %148
%150 = load i32, i32* %19
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds i32, i32* %149, i64 %151
%153 = load i32, i32* %152
%154 = load i32***, i32**** %15
%155 = load i32, i32* %17
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds i32**, i32*** %154, i64 %156
%158 = load i32**, i32*** %157
%159 = load i32, i32* %19
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds i32*, i32** %158, i64 %160
%162 = load i32*, i32** %161
%163 = load i32, i32* %18
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds i32, i32* %162, i64 %164
store i32 %153, i32* %165
%166 = load double***, double**** %16
%167 = load i32, i32* %17
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds double**, double*** %166, i64 %168
%170 = load double**, double*** %169
%171 = load i32, i32* %18
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds double*, double** %170, i64 %172
%174 = load double*, double** %173
%175 = load i32, i32* %19
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds double, double* %174, i64 %176
%178 = load double, double* %177
%179 = load double***, double**** %16
%180 = load i32, i32* %17
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds double**, double*** %179, i64 %181
%183 = load double**, double*** %182
%184 = load i32, i32* %19
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds double*, double** %183, i64 %185
%187 = load double*, double** %186
%188 = load i32, i32* %18
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds double, double* %187, i64 %189
store double %178, double* %190
br label %191
191: ; preds = %140, %39
br label %192
192: ; preds = %191
%193 = load i32, i32* %19
%194 = add nsw i32 %193, 1
store i32 %194, i32* %19
br label %31
195: ; preds = %31
br label %196
196: ; preds = %195
%197 = load i32, i32* %18
%198 = add nsw i32 %197, 1
store i32 %198, i32* %18
br label %25
199: ; preds = %25
br label %200
200: ; preds = %199
%201 = load i32, i32* %17
%202 = add nsw i32 %201, 1
store i32 %202, i32* %17
br label %20
203: ; preds = %20
ret void
}

LLVM IR (-O2):
define void @sample_H(i32 %0, i32 %1, double* nocapture %2, double* nocapture %3, double* nocapture %4, double %5, i32*** nocapture %6, double*** nocapture %7) {
%9 = icmp sgt i32 %0, 0
br i1 %9, label %10, label %20
10: ; preds = %8
%11 = icmp sgt i32 %1, 0
%12 = getelementptr inbounds double, double* %4, i64 1
%13 = zext i32 %0 to i64
%14 = zext i32 %1 to i64
br label %15
15: ; preds = %10, %36
%16 = phi i64 [ 0, %10 ], [ %37, %36 ]
br i1 %11, label %17, label %36
17: ; preds = %15
%18 = getelementptr inbounds i32**, i32*** %6, i64 %16
%19 = getelementptr inbounds double**, double*** %7, i64 %16
br label %21
20: ; preds = %36, %8
ret void
21: ; preds = %39, %17
%22 = phi i64 [ 0, %17 ], [ %34, %39 ]
%23 = load double, double* %4
%24 = load double, double* %12
%25 = tail call double @rgamma(double %23, double %24)
%26 = load double**, double*** %19
%27 = getelementptr inbounds double*, double** %26, i64 %22
%28 = load double*, double** %27
%29 = getelementptr inbounds double, double* %28, i64 %22
store double %25, double* %29
%30 = load i32**, i32*** %18
%31 = getelementptr inbounds i32*, i32** %30, i64 %22
%32 = load i32*, i32** %31
%33 = getelementptr inbounds i32, i32* %32, i64 %22
store i32 -1, i32* %33
%34 = add nuw nsw i64 %22, 1
%35 = icmp eq i64 %34, %14
br i1 %35, label %39, label %41
36: ; preds = %39, %15
%37 = add nuw nsw i64 %16, 1
%38 = icmp eq i64 %37, %13
br i1 %38, label %20, label %15
39: ; preds = %84, %21
%40 = icmp eq i64 %34, %14
br i1 %40, label %36, label %21
41: ; preds = %21, %84
%42 = phi i64 [ %85, %84 ], [ %34, %21 ]
%43 = icmp eq i64 %42, %22
br i1 %43, label %44, label %56
44: ; preds = %41
%45 = load double, double* %4
%46 = load double, double* %12
%47 = tail call double @rgamma(double %45, double %46)
%48 = load double**, double*** %19
%49 = getelementptr inbounds double*, double** %48, i64 %22
%50 = load double*, double** %49
%51 = getelementptr inbounds double, double* %50, i64 %22
store double %47, double* %51
%52 = load i32**, i32*** %18
%53 = getelementptr inbounds i32*, i32** %52, i64 %22
%54 = load i32*, i32** %53
%55 = getelementptr inbounds i32, i32* %54, i64 %22
store i32 -1, i32* %55
br label %84
56: ; preds = %41
%57 = tail call i32 @rbernoulli(double %5)
%58 = load i32**, i32*** %18
%59 = getelementptr inbounds i32*, i32** %58, i64 %22
%60 = load i32*, i32** %59
%61 = getelementptr inbounds i32, i32* %60, i64 %42
store i32 %57, i32* %61
%62 = icmp eq i32 %57, 1
%63 = select i1 %62, double* %3, double* %2
%64 = select i1 %62, double* %3, double* %2
%65 = getelementptr inbounds double, double* %64, i64 1
%66 = load double, double* %63
%67 = load double, double* %65
%68 = tail call double @rgamma(double %66, double %67)
%69 = load double**, double*** %19
%70 = getelementptr inbounds double*, double** %69, i64 %22
%71 = load double*, double** %70
%72 = getelementptr inbounds double, double* %71, i64 %42
store double %68, double* %72
%73 = load i32**, i32*** %18
%74 = getelementptr inbounds i32*, i32** %73, i64 %22
%75 = load i32*, i32** %74
%76 = getelementptr inbounds i32, i32* %75, i64 %42
%77 = load i32, i32* %76
%78 = getelementptr inbounds i32*, i32** %73, i64 %42
%79 = load i32*, i32** %78
%80 = getelementptr inbounds i32, i32* %79, i64 %22
store i32 %77, i32* %80
%81 = getelementptr inbounds double*, double** %69, i64 %42
%82 = load double*, double** %81
%83 = getelementptr inbounds double, double* %82, i64 %22
store double %68, double* %83
br label %84
84: ; preds = %44, %56
%85 = add nuw nsw i64 %42, 1
%86 = icmp eq i64 %85, %14
br i1 %86, label %39, label %41
}