#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 sqrt(double);
double equilibrium_error(double *dF, double *F, double **K, double *D, int DoF,
                         int *q, int *r) {
  double ss_dF = 0.0, ss_F = 0.0, errF = 0.0;
  int i, j;
  for (i = 1; i <= DoF; i++) {
    errF = 0.0;
    if (q[i]) {
      errF = F[i];
      for (j = 1; j <= DoF; j++) {
        if (q[j]) {
          if (i <= j)
            errF -= K[i][j] * D[j];
          else
            errF -= K[j][i] * D[j];
        }
      }
      for (j = 1; j <= DoF; j++)
        if (r[j])
          errF -= K[i][j] * D[j];
    }
    dF[i] = errF;
  }
  for (i = 1; i <= DoF; i++)
    if (q[i])
      ss_dF += (dF[i] * dF[i]);
  for (i = 1; i <= DoF; i++)
    if (q[i])
      ss_F += (F[i] * F[i]);
  return (sqrt(ss_dF) / sqrt(ss_F));
}


x86 assembly (clang, -O0):
<equilibrium_error>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1317 <equilibrium_error+0x207>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     12f7 <equilibrium_error+0x1e7>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     126f <equilibrium_error+0x15f>
mov    -0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     125c <equilibrium_error+0x14c>
mov    -0x4c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     120c <equilibrium_error+0xfc>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    1257 <equilibrium_error+0x147>
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    125c <equilibrium_error+0x14c>
jmp    1261 <equilibrium_error+0x151>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1192 <equilibrium_error+0x82>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     12f2 <equilibrium_error+0x1e2>
mov    0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     12df <equilibrium_error+0x1cf>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    12e4 <equilibrium_error+0x1d4>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1276 <equilibrium_error+0x166>
jmp    12f7 <equilibrium_error+0x1e7>
movsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1153 <equilibrium_error+0x43>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     137b <equilibrium_error+0x26b>
mov    -0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1368 <equilibrium_error+0x258>
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    136d <equilibrium_error+0x25d>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    131e <equilibrium_error+0x20e>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     13df <equilibrium_error+0x2cf>
mov    -0x30(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     13cc <equilibrium_error+0x2bc>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    13d1 <equilibrium_error+0x2c1>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1382 <equilibrium_error+0x272>
movsd  -0x38(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x40(%rbp),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x58(%rbp),%xmm0
divsd  %xmm1,%xmm0
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<equilibrium_error>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
xorpd  %xmm1,%xmm1
xorpd  %xmm0,%xmm0
xorpd  %xmm3,%xmm3
test   %r8d,%r8d
jle    1377 <equilibrium_error+0x267>
mov    0x40(%rsp),%r14
mov    %r8d,%r10d
lea    0x1(%r10),%r12
lea    -0x1(%r10),%r11
mov    %r10d,%r15d
and    $0xfffffffe,%r15d
neg    %r15
mov    $0x1,%r13d
jmp    1177 <equilibrium_error+0x67>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
movsd  %xmm0,(%rdi,%r13,8)
add    $0x1,%r13
cmp    %r12,%r13
je     1259 <equilibrium_error+0x149>
cmpl   $0x0,(%r9,%r13,4)
je     1160 <equilibrium_error+0x50>
movsd  (%rsi,%r13,8),%xmm0
mov    $0x1,%ebx
jmp    1199 <equilibrium_error+0x89>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    %rbx,%r12
je     11d0 <equilibrium_error+0xc0>
cmpl   $0x0,(%r9,%rbx,4)
je     1190 <equilibrium_error+0x80>
cmp    %rbx,%r13
mov    %r13,%rax
cmova  %rbx,%rax
mov    %rbx,%rbp
cmova  %r13,%rbp
mov    (%rdx,%rax,8),%rax
movsd  (%rax,%rbp,8),%xmm2
mulsd  (%rcx,%rbx,8),%xmm2
subsd  %xmm2,%xmm0
jmp    1190 <equilibrium_error+0x80>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x1,%ebx
test   %r11,%r11
jne    1222 <equilibrium_error+0x112>
test   $0x1,%r10b
je     1164 <equilibrium_error+0x54>
cmpl   $0x0,(%r14,%rbx,4)
je     1164 <equilibrium_error+0x54>
mov    (%rdx,%r13,8),%rax
movsd  (%rax,%rbx,8),%xmm2
mulsd  (%rcx,%rbx,8),%xmm2
subsd  %xmm2,%xmm0
jmp    1164 <equilibrium_error+0x54>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r15,%rbx,1),%rax
add    $0x2,%rax
add    $0x2,%rbx
cmp    $0x1,%rax
je     11da <equilibrium_error+0xca>
cmpl   $0x0,(%r14,%rbx,4)
je     123b <equilibrium_error+0x12b>
mov    (%rdx,%r13,8),%rax
movsd  (%rax,%rbx,8),%xmm2
mulsd  (%rcx,%rbx,8),%xmm2
subsd  %xmm2,%xmm0
cmpl   $0x0,0x4(%r14,%rbx,4)
je     1210 <equilibrium_error+0x100>
mov    (%rdx,%r13,8),%rax
movsd  0x8(%rax,%rbx,8),%xmm2
mulsd  0x8(%rcx,%rbx,8),%xmm2
subsd  %xmm2,%xmm0
jmp    1210 <equilibrium_error+0x100>
test   %r8d,%r8d
jle    12be <equilibrium_error+0x1ae>
test   %r11,%r11
je     12cb <equilibrium_error+0x1bb>
mov    %r10d,%ecx
and    $0xfffffffe,%ecx
neg    %rcx
xorpd  %xmm0,%xmm0
mov    $0x1,%eax
jmp    1292 <equilibrium_error+0x182>
nopw   0x0(%rax,%rax,1)
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
je     12d4 <equilibrium_error+0x1c4>
cmpl   $0x0,(%r9,%rax,4)
je     12a6 <equilibrium_error+0x196>
movsd  (%rdi,%rax,8),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm2,%xmm0
cmpl   $0x0,0x4(%r9,%rax,4)
je     1280 <equilibrium_error+0x170>
movsd  0x8(%rdi,%rax,8),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm2,%xmm0
jmp    1280 <equilibrium_error+0x170>
xorpd  %xmm0,%xmm0
xorpd  %xmm3,%xmm3
jmp    1377 <equilibrium_error+0x267>
xorpd  %xmm0,%xmm0
mov    $0x1,%eax
test   $0x1,%r10b
je     12ee <equilibrium_error+0x1de>
cmpl   $0x0,(%r9,%rax,4)
je     12ee <equilibrium_error+0x1de>
movsd  (%rdi,%rax,8),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm2,%xmm0
test   %r8d,%r8d
jle    134e <equilibrium_error+0x23e>
test   %r11,%r11
je     1354 <equilibrium_error+0x244>
mov    %r10d,%ecx
and    $0xfffffffe,%ecx
neg    %rcx
xorpd  %xmm3,%xmm3
mov    $0x1,%eax
jmp    1322 <equilibrium_error+0x212>
nopl   0x0(%rax)
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
je     135d <equilibrium_error+0x24d>
cmpl   $0x0,(%r9,%rax,4)
je     1336 <equilibrium_error+0x226>
movsd  (%rsi,%rax,8),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm2,%xmm3
cmpl   $0x0,0x4(%r9,%rax,4)
je     1310 <equilibrium_error+0x200>
movsd  0x8(%rsi,%rax,8),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm2,%xmm3
jmp    1310 <equilibrium_error+0x200>
xorpd  %xmm3,%xmm3
jmp    1377 <equilibrium_error+0x267>
xorpd  %xmm3,%xmm3
mov    $0x1,%eax
test   $0x1,%r10b
je     1377 <equilibrium_error+0x267>
cmpl   $0x0,(%r9,%rax,4)
je     1377 <equilibrium_error+0x267>
movsd  (%rsi,%rax,8),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm2,%xmm3
ucomisd %xmm1,%xmm0
jb     1386 <equilibrium_error+0x276>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
jmp    1399 <equilibrium_error+0x289>
movsd  %xmm3,(%rsp)
call   1030 <sqrt@plt>
movsd  (%rsp),%xmm3
movapd %xmm0,%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm3
jb     13ac <equilibrium_error+0x29c>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    13bf <equilibrium_error+0x2af>
movapd %xmm3,%xmm0
movsd  %xmm1,(%rsp)
call   1030 <sqrt@plt>
movsd  (%rsp),%xmm1
divsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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