#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 distance_periodic(double *, double *, double);
void calculate_force(double forces[][3], double ****neighbor,
                     double particles[][3], double region, int amount) {
  int i, j, k;
  double r = region / 2.;
  for (i = 0; i < amount; i++) {
    for (j = 0; j < 3; j++) {
      forces[i][j] = 0;
    }
  }
#pragma omp parallel for private(j, k)
  for (i = 0; i < amount; i++) {
    int neighbors = *neighbor[i][0][0];
    for (j = 1; j <= neighbors; j++) {
      double d = distance_periodic(particles[i], *neighbor[i][j], region);
      double di = 1. / d;
      double d3 = di * di * di;
      for (k = 0; k < 3; k++) {
        double dl = particles[i][k] - *neighbor[i][j][k];
        if (dl > r) {
          dl -= region;
        } else if (dl < -r) {
          dl += region;
        }
        forces[i][k] += 48. * d3 * (d3 - 0.5) * di * dl;
      }
    }
  }
#pragma omp barrier
}


x86 assembly (clang, -O0):
<calculate_force>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  0xec7(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11a2 <calculate_force+0x92>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    118f <calculate_force+0x7f>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    115c <calculate_force+0x4c>
jmp    1194 <calculate_force+0x84>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1149 <calculate_force+0x39>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1376 <calculate_force+0x266>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%rax
mov    (%rax),%rax
cvttsd2si (%rax),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1363 <calculate_force+0x253>
mov    -0x18(%rbp),%rdi
movslq -0x28(%rbp),%rax
imul   $0x18,%rax,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%rsi
movsd  -0x20(%rbp),%xmm0
call   1030 <distance_periodic@plt>
movsd  %xmm0,-0x48(%rbp)
movsd  0xdea(%rip),%xmm0
divsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    1350 <calculate_force+0x240>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
ucomisd -0x38(%rbp),%xmm0
jbe    12b2 <calculate_force+0x1a2>
movsd  -0x20(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    12f1 <calculate_force+0x1e1>
movsd  -0x60(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    12ec <calculate_force+0x1dc>
movsd  -0x20(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    12f1 <calculate_force+0x1e1>
movsd  0xd1f(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
movsd  0xd05(%rip),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1243 <calculate_force+0x133>
jmp    1355 <calculate_force+0x245>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11d5 <calculate_force+0xc5>
jmp    1368 <calculate_force+0x258>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11a9 <calculate_force+0x99>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calculate_force>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rdx,0x30(%rsp)
mov    %rsi,0x18(%rsp)
mov    %rdi,0x10(%rsp)
test   %ecx,%ecx
jle    1351 <calculate_force+0x231>
movsd  0xeb3(%rip),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm1,0x40(%rsp)
mov    %ecx,%eax
mov    %rax,0x38(%rsp)
lea    0x0(,%rax,8),%rax
lea    (%rax,%rax,2),%rdx
xor    %ebp,%ebp
mov    0x10(%rsp),%rdi
xor    %esi,%esi
movsd  %xmm0,(%rsp)
call   1030 <memset@plt>
movsd  (%rsp),%xmm0
movapd 0xe96(%rip),%xmm1
xorpd  0x40(%rsp),%xmm1
movapd %xmm1,0x20(%rsp)
jmp    11af <calculate_force+0x8f>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    0x38(%rsp),%rbp
je     1351 <calculate_force+0x231>
mov    0x18(%rsp),%rax
mov    (%rax,%rbp,8),%rax
mov    (%rax),%rcx
mov    (%rcx),%rcx
cvttsd2si (%rcx),%ecx
mov    %rcx,0x8(%rsp)
test   %ecx,%ecx
jle    11a0 <calculate_force+0x80>
lea    0x0(,%rbp,8),%rcx
lea    (%rcx,%rcx,2),%rcx
mov    0x30(%rsp),%rdx
lea    (%rdx,%rcx,1),%rbx
mov    0x8(%rsp),%rsi
add    $0x1,%esi
mov    %rsi,0x8(%rsp)
mov    0x10(%rsp),%rsi
lea    (%rsi,%rcx,1),%r14
lea    (%rdx,%rcx,1),%r15
add    $0x8,%r15
lea    (%rsi,%rcx,1),%r12
add    $0x8,%r12
mov    $0x1,%r13d
jmp    1235 <calculate_force+0x115>
xchg   %ax,%ax
subsd  %xmm0,%xmm2
mulsd  %xmm2,%xmm1
addsd  0x8(%r12),%xmm1
movsd  %xmm1,0x8(%r12)
add    $0x1,%r13
cmp    %r13,0x8(%rsp)
je     11a0 <calculate_force+0x80>
mov    (%rax,%r13,8),%rax
mov    (%rax),%rsi
mov    %rbx,%rdi
call   1040 <distance_periodic@plt>
movsd  0xdbc(%rip),%xmm1
divsd  %xmm0,%xmm1
movapd %xmm1,%xmm4
mulsd  %xmm1,%xmm4
mulsd  %xmm1,%xmm4
mov    0x18(%rsp),%rax
mov    (%rax,%rbp,8),%rax
mov    (%rax,%r13,8),%rcx
movapd %xmm4,%xmm3
mulsd  0xd9b(%rip),%xmm3
addsd  0xd9b(%rip),%xmm4
movsd  (%rbx),%xmm2
mov    (%rcx),%rdx
subsd  (%rdx),%xmm2
movapd 0x40(%rsp),%xmm5
ucomisd %xmm5,%xmm2
jbe    12a0 <calculate_force+0x180>
movsd  (%rsp),%xmm0
subsd  %xmm0,%xmm2
jmp    12c5 <calculate_force+0x1a5>
nop
movapd 0x20(%rsp),%xmm0
ucomisd %xmm2,%xmm0
jbe    12c0 <calculate_force+0x1a0>
movsd  (%rsp),%xmm0
addsd  %xmm0,%xmm2
jmp    12c5 <calculate_force+0x1a5>
nopw   0x0(%rax,%rax,1)
movsd  (%rsp),%xmm0
mulsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm1,%xmm2
addsd  (%r14),%xmm2
movsd  %xmm2,(%r14)
movsd  (%r15),%xmm2
mov    0x8(%rcx),%rdx
subsd  (%rdx),%xmm2
ucomisd %xmm5,%xmm2
jbe    1300 <calculate_force+0x1e0>
subsd  %xmm0,%xmm2
jmp    1310 <calculate_force+0x1f0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x20(%rsp),%xmm3
ucomisd %xmm2,%xmm3
jbe    1310 <calculate_force+0x1f0>
addsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
addsd  (%r12),%xmm2
movsd  %xmm2,(%r12)
movsd  0x8(%r15),%xmm2
mov    0x10(%rcx),%rcx
subsd  (%rcx),%xmm2
ucomisd %xmm5,%xmm2
ja     1210 <calculate_force+0xf0>
movapd 0x20(%rsp),%xmm3
ucomisd %xmm2,%xmm3
jbe    1214 <calculate_force+0xf4>
addsd  %xmm0,%xmm2
jmp    1214 <calculate_force+0xf4>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @calculate_force([3 x double]* nocapture %0, double**** nocapture %1, [3 x double]* %2, double %3, i32 %4) {
%6 = fmul double %3, 5.000000e-01
%7 = icmp sgt i32 %4, 0
br i1 %7, label %8, label %101
8: ; preds = %5
%9 = bitcast [3 x double]* %0 to i8*
%10 = zext i32 %4 to i64
%11 = mul nuw nsw i64 %10, 24
%12 = fneg double %6
%13 = zext i32 %4 to i64
br label %14
14: ; preds = %8, %98
%15 = phi i64 [ 0, %8 ], [ %99, %98 ]
%16 = getelementptr inbounds double***, double**** %1, i64 %15
%17 = load double***, double**** %16
%18 = load double**, double*** %17
%19 = load double*, double** %18
%20 = load double, double* %19
%21 = fptosi double %20 to i32
%22 = icmp slt i32 %21, 1
br i1 %22, label %98, label %23
23: ; preds = %14
%24 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 %15, i64 0
%25 = add nuw i32 %21, 1
%26 = zext i32 %25 to i64
%27 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %15, i64 0
%28 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 %15, i64 1
%29 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %15, i64 1
%30 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 %15, i64 2
%31 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %15, i64 2
br label %32
32: ; preds = %23, %92
%33 = phi double*** [ %17, %23 ], [ %42, %92 ]
%34 = phi i64 [ 1, %23 ], [ %96, %92 ]
%35 = getelementptr inbounds double**, double*** %33, i64 %34
%36 = load double**, double*** %35
%37 = load double*, double** %36
%38 = tail call double @distance_periodic(double* %24, double* %37, double %3)
%39 = fdiv double 1.000000e+00, %38
%40 = fmul double %39, %39
%41 = fmul double %39, %40
%42 = load double***, double**** %16
%43 = getelementptr inbounds double**, double*** %42, i64 %34
%44 = load double**, double*** %43
%45 = fmul double %41, 4.800000e+01
%46 = fadd double %41, -5.000000e-01
%47 = fmul double %45, %46
%48 = fmul double %39, %47
%49 = load double, double* %24
%50 = load double*, double** %44
%51 = load double, double* %50
%52 = fsub double %49, %51
%53 = fcmp ogt double %52, %6
br i1 %53, label %54, label %56
54: ; preds = %32
%55 = fsub double %52, %3
br label %60
56: ; preds = %32
%57 = fcmp olt double %52, %12
br i1 %57, label %58, label %60
58: ; preds = %56
%59 = fadd double %52, %3
br label %60
60: ; preds = %56, %58, %54
%61 = phi double [ %55, %54 ], [ %59, %58 ], [ %52, %56 ]
%62 = load double, double* %27
%63 = tail call double @llvm.fmuladd.f64(double %48, double %61, double %62)
store double %63, double* %27
%64 = load double, double* %28
%65 = getelementptr inbounds double*, double** %44, i64 1
%66 = load double*, double** %65
%67 = load double, double* %66
%68 = fsub double %64, %67
%69 = fcmp ogt double %68, %6
br i1 %69, label %74, label %70
70: ; preds = %60
%71 = fcmp olt double %68, %12
br i1 %71, label %72, label %76
72: ; preds = %70
%73 = fadd double %68, %3
br label %76
74: ; preds = %60
%75 = fsub double %68, %3
br label %76
76: ; preds = %74, %72, %70
%77 = phi double [ %75, %74 ], [ %73, %72 ], [ %68, %70 ]
%78 = load double, double* %29
%79 = tail call double @llvm.fmuladd.f64(double %48, double %77, double %78)
store double %79, double* %29
%80 = load double, double* %30
%81 = getelementptr inbounds double*, double** %44, i64 2
%82 = load double*, double** %81
%83 = load double, double* %82
%84 = fsub double %80, %83
%85 = fcmp ogt double %84, %6
br i1 %85, label %90, label %86
86: ; preds = %76
%87 = fcmp olt double %84, %12
br i1 %87, label %88, label %92
88: ; preds = %86
%89 = fadd double %84, %3
br label %92
90: ; preds = %76
%91 = fsub double %84, %3
br label %92
92: ; preds = %90, %88, %86
%93 = phi double [ %91, %90 ], [ %89, %88 ], [ %84, %86 ]
%94 = load double, double* %31
%95 = tail call double @llvm.fmuladd.f64(double %48, double %93, double %94)
store double %95, double* %31
%96 = add nuw nsw i64 %34, 1
%97 = icmp eq i64 %96, %26
br i1 %97, label %98, label %32
98: ; preds = %92, %14
%99 = add nuw nsw i64 %15, 1
%100 = icmp eq i64 %99, %13
br i1 %100, label %101, label %14
101: ; preds = %98, %5
ret void
}