#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);
int /*<<< orphan*/ omp_set_num_threads(int);
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;
    }
  }
  omp_set_num_threads(8);
#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  0xeb7(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11b2 <calculate_force+0x92>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    119f <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    116c <calculate_force+0x4c>
jmp    11a4 <calculate_force+0x84>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1159 <calculate_force+0x39>
mov    $0x8,%edi
call   1030 <omp_set_num_threads@plt>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1390 <calculate_force+0x270>
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     137d <calculate_force+0x25d>
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   1040 <distance_periodic@plt>
movsd  %xmm0,-0x48(%rbp)
movsd  0xdd0(%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    136a <calculate_force+0x24a>
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    12cc <calculate_force+0x1ac>
movsd  -0x20(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    130b <calculate_force+0x1eb>
movsd  -0x60(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    1306 <calculate_force+0x1e6>
movsd  -0x20(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    130b <calculate_force+0x1eb>
movsd  0xd05(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
movsd  0xceb(%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    125d <calculate_force+0x13d>
jmp    136f <calculate_force+0x24f>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11ef <calculate_force+0xcf>
jmp    1382 <calculate_force+0x262>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11c3 <calculate_force+0xa3>
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    $0x68,%rsp
mov    %rdx,0x40(%rsp)
mov    %rsi,0x18(%rsp)
test   %ecx,%ecx
jle    1370 <calculate_force+0x240>
movsd  0xea8(%rip),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm1,0x50(%rsp)
mov    %ecx,%eax
mov    %rax,0x48(%rsp)
lea    0x0(,%rax,8),%rax
lea    (%rax,%rax,2),%rdx
xor    %ebp,%ebp
mov    %rdi,0x38(%rsp)
xor    %esi,%esi
movsd  %xmm0,0x8(%rsp)
call   1030 <memset@plt>
mov    $0x8,%edi
call   1040 <omp_set_num_threads@plt>
movsd  0x8(%rsp),%xmm0
movapd 0xe7f(%rip),%xmm1
xorpd  0x50(%rsp),%xmm1
movapd %xmm1,0x20(%rsp)
jmp    11bf <calculate_force+0x8f>
nop
add    $0x1,%rbp
cmp    0x48(%rsp),%rbp
je     1361 <calculate_force+0x231>
mov    0x18(%rsp),%rax
mov    (%rax,%rbp,8),%rax
mov    (%rax),%rcx
mov    (%rcx),%rcx
cvttsd2si (%rcx),%ecx
mov    %rcx,0x10(%rsp)
test   %ecx,%ecx
jle    11b0 <calculate_force+0x80>
lea    0x0(,%rbp,8),%rcx
lea    (%rcx,%rcx,2),%rcx
mov    0x40(%rsp),%rdx
lea    (%rdx,%rcx,1),%rbx
mov    0x10(%rsp),%rsi
add    $0x1,%esi
mov    %rsi,0x10(%rsp)
mov    0x38(%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    1245 <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,0x10(%rsp)
je     11b0 <calculate_force+0x80>
mov    (%rax,%r13,8),%rax
mov    (%rax),%rsi
mov    %rbx,%rdi
call   1050 <distance_periodic@plt>
movsd  0xdac(%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  0xd8b(%rip),%xmm3
addsd  0xd8b(%rip),%xmm4
movsd  (%rbx),%xmm2
mov    (%rcx),%rdx
subsd  (%rdx),%xmm2
movapd 0x50(%rsp),%xmm5
ucomisd %xmm5,%xmm2
jbe    12b0 <calculate_force+0x180>
movsd  0x8(%rsp),%xmm0
subsd  %xmm0,%xmm2
jmp    12d6 <calculate_force+0x1a6>
movapd 0x20(%rsp),%xmm0
ucomisd %xmm2,%xmm0
jbe    12d0 <calculate_force+0x1a0>
movsd  0x8(%rsp),%xmm0
addsd  %xmm0,%xmm2
jmp    12d6 <calculate_force+0x1a6>
nopl   0x0(%rax,%rax,1)
movsd  0x8(%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    1310 <calculate_force+0x1e0>
subsd  %xmm0,%xmm2
jmp    1320 <calculate_force+0x1f0>
cs nopw 0x0(%rax,%rax,1)
nop
movapd 0x20(%rsp),%xmm3
ucomisd %xmm2,%xmm3
jbe    1320 <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     1220 <calculate_force+0xf0>
movapd 0x20(%rsp),%xmm3
ucomisd %xmm2,%xmm3
jbe    1224 <calculate_force+0xf4>
addsd  %xmm0,%xmm2
jmp    1224 <calculate_force+0xf4>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x8,%edi
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <omp_set_num_threads@plt>

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