#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 smoothedHeaviside(double, double);
void darcySharpInterfaceFlowImEvaluate(
    int nPoints, int nSpace, double Km, double rhoM, double Kp, double rhoP,
    double eps, double *gravity_u, double *u, double *gradu, double *u_levelSet,
    double *phi_pot, double *a, double *f, double *r, double *m,
    double *dphi_pot, double *da, double *df, double *dr, double *dm) {
  int k, I, J, nSpace2;
  double He, rhoHe;
  double rhoEps = 0.0;
  nSpace2 = nSpace * nSpace;
  for (k = 0; k < nPoints; k++) {
    m[k] = 0.0;
    dm[k] = 1.0;
    r[k] = 0.0;
    dr[k] = 0.0;
    phi_pot[k] = u[k];
    dphi_pot[k] = 1.0;
    He = smoothedHeaviside(eps, u_levelSet[k]);
    rhoHe = smoothedHeaviside(rhoEps, u_levelSet[k]);
    for (I = 0; I < nSpace; I++) {
      for (J = 0; J < nSpace; J++) {
        if (I == J)
          a[k * nSpace2 + I * nSpace + J] = Km + He * (Kp - Km);
        else
          a[k * nSpace2 + I * nSpace + J] = 0.0;
        da[k * nSpace2 + I * nSpace + J] = 0.0;
      }
      f[k * nSpace + I] =
          (Km * rhoM + He * (Kp * rhoP - Km * rhoM)) * gravity_u[I];
      df[k * nSpace + I] = 0.0;
    }
  }
}


x86 assembly (clang, -O0):
<darcySharpInterfaceFlowImEvaluate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
movsd  %xmm2,-0x20(%rbp)
movsd  %xmm3,-0x28(%rbp)
movsd  %xmm4,-0x30(%rbp)
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x40(%rbp)
mov    %r8,-0x48(%rbp)
mov    %r9,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13b2 <darcySharpInterfaceFlowImEvaluate+0x2a2>
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x58(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  0xe49(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  0xdfa(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
call   1030 <smoothedHeaviside@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x78(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
call   1030 <smoothedHeaviside@plt>
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    139f <darcySharpInterfaceFlowImEvaluate+0x28f>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1307 <darcySharpInterfaceFlowImEvaluate+0x1f7>
mov    -0x58(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jne    12b5 <darcySharpInterfaceFlowImEvaluate+0x1a5>
movsd  -0x10(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm2
subsd  -0x10(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x60(%rbp),%ecx
mov    -0x58(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    12d7 <darcySharpInterfaceFlowImEvaluate+0x1c7>
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x60(%rbp),%ecx
mov    -0x58(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x60(%rbp),%ecx
mov    -0x58(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    125d <darcySharpInterfaceFlowImEvaluate+0x14d>
movsd  -0x10(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm3
movsd  -0x28(%rbp),%xmm5
movsd  -0x10(%rbp),%xmm4
mulsd  -0x18(%rbp),%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x48(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    124a <darcySharpInterfaceFlowImEvaluate+0x13a>
jmp    13a4 <darcySharpInterfaceFlowImEvaluate+0x294>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    118b <darcySharpInterfaceFlowImEvaluate+0x7b>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<darcySharpInterfaceFlowImEvaluate>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9,0x68(%rsp)
mov    %rcx,0x60(%rsp)
movsd  %xmm4,0x58(%rsp)
movsd  %xmm0,0x10(%rsp)
mov    %esi,0x4(%rsp)
test   %edi,%edi
jle    13ec <darcySharpInterfaceFlowImEvaluate+0x2dc>
mov    0xe0(%rsp),%r13
mov    0xb8(%rsp),%r15
mov    0x4(%rsp),%eax
mov    %eax,%ecx
imul   %ecx,%ecx
mov    %rcx,0x18(%rsp)
movapd %xmm2,%xmm4
movsd  0x10(%rsp),%xmm0
subsd  %xmm0,%xmm4
movsd  %xmm4,0x30(%rsp)
mulsd  %xmm0,%xmm1
mulsd  %xmm2,%xmm3
movsd  %xmm1,0x38(%rsp)
subsd  %xmm1,%xmm3
movsd  %xmm3,0x40(%rsp)
movslq %eax,%rbp
mov    %edi,%eax
mov    %rax,0x50(%rsp)
mov    %ebp,%r12d
mov    %r12d,%r14d
and    $0xfffffffe,%r14d
mov    $0x1,%eax
mov    %rax,0x8(%rsp)
xor    %ecx,%ecx
mov    %rbp,0x28(%rsp)
mov    %rdx,0x48(%rsp)
jmp    11e3 <darcySharpInterfaceFlowImEvaluate+0xd3>
cs nopw 0x0(%rax,%rax,1)
mov    0x20(%rsp),%rcx
add    $0x1,%rcx
mov    0x8(%rsp),%rax
add    0x18(%rsp),%rax
mov    %rax,0x8(%rsp)
cmp    0x50(%rsp),%rcx
je     13ec <darcySharpInterfaceFlowImEvaluate+0x2dc>
mov    0xd0(%rsp),%rax
movq   $0x0,(%rax,%rcx,8)
mov    0xf8(%rsp),%rax
movabs $0x3ff0000000000000,%rdx
mov    %rdx,(%rax,%rcx,8)
mov    0xc8(%rsp),%rax
movq   $0x0,(%rax,%rcx,8)
mov    0xf0(%rsp),%rax
movq   $0x0,(%rax,%rcx,8)
mov    0x60(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm0
mov    0xb0(%rsp),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    0xd8(%rsp),%rax
mov    %rdx,(%rax,%rcx,8)
mov    0x68(%rsp),%rbx
movsd  (%rbx,%rcx,8),%xmm1
movsd  0x58(%rsp),%xmm0
mov    %rcx,%rbp
call   1030 <smoothedHeaviside@plt>
movsd  %xmm0,0x70(%rsp)
mov    %rbp,0x20(%rsp)
movsd  (%rbx,%rbp,8),%xmm1
xorpd  %xmm0,%xmm0
call   1030 <smoothedHeaviside@plt>
movsd  0x70(%rsp),%xmm2
mov    0x48(%rsp),%rdx
mov    0x28(%rsp),%rbp
cmpl   $0x0,0x4(%rsp)
jle    11c0 <darcySharpInterfaceFlowImEvaluate+0xb0>
mov    0x20(%rsp),%r9
mov    %r9,%r8
imul   0x18(%rsp),%r8
movsd  0x40(%rsp),%xmm0
mulsd  %xmm2,%xmm0
mulsd  0x30(%rsp),%xmm2
addsd  0x10(%rsp),%xmm2
addsd  0x38(%rsp),%xmm0
imul   %rbp,%r9
mov    0x8(%rsp),%r10
xor    %esi,%esi
jmp    131c <darcySharpInterfaceFlowImEvaluate+0x20c>
nop
movsd  %xmm2,(%r15,%r11,8)
add    %rbx,%rdi
movq   $0x0,0x0(%r13,%rdi,8)
movsd  (%rdx,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
lea    (%rsi,%r9,1),%rax
mov    0xc0(%rsp),%rcx
movsd  %xmm1,(%rcx,%rax,8)
mov    0xe8(%rsp),%rcx
movq   $0x0,(%rcx,%rax,8)
add    $0x1,%rsi
add    %rbp,%r10
cmp    %r12,%rsi
je     11c0 <darcySharpInterfaceFlowImEvaluate+0xb0>
mov    %rsi,%rdi
imul   %rbp,%rdi
add    %r8,%rdi
lea    (%rdi,%rsi,1),%r11
cmpl   $0x1,0x4(%rsp)
jne    1340 <darcySharpInterfaceFlowImEvaluate+0x230>
xor    %ebx,%ebx
test   $0x1,%r12b
je     12e2 <darcySharpInterfaceFlowImEvaluate+0x1d2>
jmp    13d3 <darcySharpInterfaceFlowImEvaluate+0x2c3>
xchg   %ax,%ax
mov    %r10,%rbp
xor    %eax,%eax
jmp    1376 <darcySharpInterfaceFlowImEvaluate+0x266>
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rcx
or     $0x1,%rcx
movsd  %xmm2,(%r15,%r11,8)
add    %rdi,%rcx
movq   $0x0,0x0(%r13,%rcx,8)
add    $0x2,%rbp
add    $0x1,%rax
cmp    %r14,%rax
je     13c0 <darcySharpInterfaceFlowImEvaluate+0x2b0>
mov    %rax,%rbx
cmp    %rax,%rsi
jne    1390 <darcySharpInterfaceFlowImEvaluate+0x280>
movsd  %xmm2,(%r15,%r11,8)
lea    -0x1(%rbp),%rax
jmp    139d <darcySharpInterfaceFlowImEvaluate+0x28d>
nopw   0x0(%rax,%rax,1)
lea    (%rdi,%rbx,1),%rax
movq   $0x0,-0x8(%r15,%rbp,8)
movq   $0x0,0x0(%r13,%rax,8)
lea    0x1(%rbx),%rax
cmp    %rax,%rsi
je     1350 <darcySharpInterfaceFlowImEvaluate+0x240>
movq   $0x0,(%r15,%rbp,8)
mov    %rbp,%rcx
jmp    1360 <darcySharpInterfaceFlowImEvaluate+0x250>
nopl   0x0(%rax)
add    $0x2,%rbx
mov    0x28(%rsp),%rbp
test   $0x1,%r12b
je     12e2 <darcySharpInterfaceFlowImEvaluate+0x1d2>
cmp    %rbx,%rsi
je     12d0 <darcySharpInterfaceFlowImEvaluate+0x1c0>
add    %rbx,%rdi
movq   $0x0,(%r15,%rdi,8)
jmp    12d9 <darcySharpInterfaceFlowImEvaluate+0x1c9>
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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