#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 smoothedDirac(double, double);
double smoothedHeaviside(double, double);
void seepageBrezis(const int nSimplex, const int nPointsPerSimplex,
                   const int nSpace, const int *materialTypes,
                   const double epsFact, const double rho, const double beta,
                   const double *elementDiameter, const double *gravity,
                   const double *alpha, const double *n, const double *thetaR,
                   const double *thetaSR, const double *KWs, double *u,
                   double *mass, double *dmass, double *f, double *df,
                   double *a, double *da) {
  int i, j, k, I, matID;
  const int nSpace2 = nSpace * nSpace;
  register double psiC, pcBar, pcBar_n, pcBar_nM1, pcBar_nM2, onePlus_pcBar_n,
      sBar, sqrt_sBar, DsBar_DpsiC, thetaW, DthetaW_DpsiC, vBar, vBar2,
      DvBar_DpsiC, KW, DKW_DpsiC, rho2 = rho * rho, thetaS, rhom, drhom, m, eps,
                                  hStar, dhStar;
  for (i = 0; i < nSimplex; i++) {
    matID = materialTypes[i];
    eps = epsFact * elementDiameter[i];
    for (j = 0; j < nPointsPerSimplex; j++) {
      k = i * nPointsPerSimplex + j;
      thetaS = thetaR[matID] + thetaSR[matID];
      hStar = smoothedHeaviside(eps, u[k] + eps) * (1.0 - 1.0e-5) + 1.0e-5;
      dhStar = smoothedDirac(eps, u[k] + eps) * (1.0 - 1.0e-5);
      mass[k] = thetaS * hStar;
      dmass[k] = thetaS * dhStar;
      for (I = 0; I < nSpace; I++) {
        f[k * nSpace + I] = KWs[matID] * gravity[I] * hStar;
        df[k * nSpace + I] = KWs[matID] * gravity[I] * dhStar;
        a[k * nSpace2 + I * nSpace + I] = KWs[matID] * hStar;
        da[k * nSpace2 + I * nSpace + I] = KWs[matID] * dhStar;
      }
    }
  }
}


x86 assembly (clang, -O0):
<seepageBrezis>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
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)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
movsd  %xmm1,-0x28(%rbp)
movsd  %xmm2,-0x30(%rbp)
mov    %r8,-0x38(%rbp)
mov    %r9,-0x40(%rbp)
mov    -0xc(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x58(%rbp)
movsd  -0x28(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13e9 <seepageBrezis+0x2c9>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
movsd  -0x20(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13d6 <seepageBrezis+0x2b6>
mov    -0x44(%rbp),%eax
imul   -0x8(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  -0x108(%rbp),%xmm1
ff
call   1040 <smoothedHeaviside@plt>
movsd  0xdbe(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xdba(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  -0x108(%rbp),%xmm1
ff
call   1030 <smoothedDirac@plt>
movsd  0xd7c(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0x110(%rbp),%xmm0
ff
mov    0x40(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0x118(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13c3 <seepageBrezis+0x2a3>
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x110(%rbp),%xmm0
ff
mov    0x50(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x118(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x110(%rbp),%xmm0
ff
mov    0x60(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
mov    -0x50(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x118(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
mov    -0x50(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    12d1 <seepageBrezis+0x1b1>
jmp    13c8 <seepageBrezis+0x2a8>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    11dd <seepageBrezis+0xbd>
jmp    13db <seepageBrezis+0x2bb>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11a2 <seepageBrezis+0x82>
add    $0x120,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<seepageBrezis>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r8,0x68(%rsp)
movsd  %xmm0,0x60(%rsp)
mov    %rcx,0x58(%rsp)
mov    %edx,0xc(%rsp)
mov    %esi,0x8(%rsp)
test   %edi,%edi
jle    141c <seepageBrezis+0x2fc>
mov    %r9,%rbx
mov    0x138(%rsp),%rax
mov    %rax,0x38(%rsp)
mov    0x130(%rsp),%rax
mov    %rax,0x30(%rsp)
movslq 0xc(%rsp),%rcx
mov    0x8(%rsp),%eax
movslq %eax,%rdx
mov    %edi,%esi
mov    %rsi,0x78(%rsp)
mov    %ecx,%edi
mov    %ecx,%esi
imul   %ecx,%esi
mov    %esi,0x28(%rsp)
imul   %eax,%esi
mov    %esi,0x24(%rsp)
lea    0x1(%rcx),%r15d
mov    %rcx,%rax
imul   %rdx,%rax
shl    $0x3,%rax
mov    %rax,0x70(%rsp)
shl    $0x3,%rcx
mov    %rcx,0x90(%rsp)
mov    0x110(%rsp),%r12
mov    %rdx,0x50(%rsp)
mov    %edx,%eax
mov    %rax,0x80(%rsp)
xor    %eax,%eax
mov    %rax,0x18(%rsp)
xor    %eax,%eax
mov    %rax,0x10(%rsp)
mov    %rdi,0x88(%rsp)
jmp    1229 <seepageBrezis+0x109>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x10(%rsp),%rcx
add    $0x1,%rcx
mov    0x18(%rsp),%rax
add    0x24(%rsp),%eax
mov    %rax,0x18(%rsp)
mov    0x70(%rsp),%rax
add    %rax,0x30(%rsp)
add    %rax,0x38(%rsp)
mov    %rcx,%rax
mov    %rcx,0x10(%rsp)
cmp    0x78(%rsp),%rcx
je     141c <seepageBrezis+0x2fc>
cmpl   $0x0,0x8(%rsp)
jle    11f0 <seepageBrezis+0xd0>
mov    0x68(%rsp),%rax
mov    0x10(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x40(%rsp)
mov    0x58(%rsp),%rax
movslq (%rax,%rcx,4),%rbp
imul   0x50(%rsp),%rcx
mov    %rcx,0x98(%rsp)
mov    0x38(%rsp),%r14
mov    0x30(%rsp),%r13
mov    0x18(%rsp),%rax
mov    %eax,%r8d
xor    %ecx,%ecx
jmp    12ad <seepageBrezis+0x18d>
nopl   0x0(%rax,%rax,1)
mov    0xb0(%rsp),%rcx
add    $0x1,%rcx
add    0x28(%rsp),%r8d
mov    0x90(%rsp),%rax
add    %rax,%r13
add    %rax,%r14
cmp    0x80(%rsp),%rcx
je     11f0 <seepageBrezis+0xd0>
mov    %r8d,0x2c(%rsp)
mov    0x98(%rsp),%rax
mov    %rcx,0xb0(%rsp)
add    %rax,%rcx
mov    %rcx,0x48(%rsp)
mov    0x100(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
mov    0x108(%rsp),%rax
addsd  (%rax,%rbp,8),%xmm0
movsd  %xmm0,0xa8(%rsp)
mov    0x118(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm1
movsd  0x40(%rsp),%xmm0
addsd  %xmm0,%xmm1
call   1040 <smoothedHeaviside@plt>
movsd  %xmm0,0xa0(%rsp)
mov    0x48(%rsp),%rax
mov    0x118(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm1
movsd  0x40(%rsp),%xmm0
addsd  %xmm0,%xmm1
call   1030 <smoothedDirac@plt>
movsd  0xa0(%rsp),%xmm2
mov    0x2c(%rsp),%r8d
mov    0x88(%rsp),%rdi
mov    0x140(%rsp),%rsi
mov    0x148(%rsp),%rdx
movsd  0xc9f(%rip),%xmm1
mulsd  %xmm1,%xmm2
addsd  0xc9b(%rip),%xmm2
mulsd  %xmm1,%xmm0
movsd  0xa8(%rsp),%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm2,%xmm1
mov    0x120(%rsp),%rax
mov    0x48(%rsp),%rcx
movsd  %xmm1,(%rax,%rcx,8)
mulsd  %xmm0,%xmm3
mov    0x128(%rsp),%rax
movsd  %xmm3,(%rax,%rcx,8)
cmpl   $0x0,0xc(%rsp)
jle    1280 <seepageBrezis+0x160>
mov    %r8d,%eax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r12,%rbp,8),%xmm1
mulsd  (%rbx,%rcx,8),%xmm1
mulsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%r13,%rcx,8)
movsd  (%r12,%rbp,8),%xmm1
mulsd  (%rbx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rcx,8)
movsd  (%r12,%rbp,8),%xmm1
mulsd  %xmm2,%xmm1
cltq
movsd  %xmm1,(%rsi,%rax,8)
movsd  (%r12,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rax,8)
add    $0x1,%rcx
add    %r15d,%eax
cmp    %rcx,%rdi
jne    13c0 <seepageBrezis+0x2a0>
jmp    1280 <seepageBrezis+0x160>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @seepageBrezis(i32 %0, i32 %1, i32 %2, i32* %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 i32
%25 = alloca i32*
%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 i32
%48 = alloca i32
%49 = alloca double
%50 = alloca double
%51 = alloca double
%52 = alloca double
%53 = alloca double
%54 = alloca double
%55 = alloca double
%56 = alloca double
%57 = alloca double
%58 = alloca double
%59 = alloca double
%60 = alloca double
%61 = alloca double
%62 = alloca double
%63 = alloca double
%64 = alloca double
%65 = alloca double
%66 = alloca double
%67 = alloca double
%68 = alloca double
%69 = alloca double
%70 = alloca double
%71 = alloca double
%72 = alloca double
store i32 %0, i32* %22
store i32 %1, i32* %23
store i32 %2, i32* %24
store i32* %3, i32** %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
%73 = load i32, i32* %24
%74 = load i32, i32* %24
%75 = mul nsw i32 %73, %74
store i32 %75, i32* %48
%76 = load double, double* %27
%77 = load double, double* %27
%78 = fmul double %76, %77
store double %78, double* %65
store i32 0, i32* %43
br label %79
79: ; preds = %244, %21
%80 = load i32, i32* %43
%81 = load i32, i32* %22
%82 = icmp slt i32 %80, %81
br i1 %82, label %83, label %247
83: ; preds = %79
%84 = load i32*, i32** %25
%85 = load i32, i32* %43
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i32, i32* %84, i64 %86
%88 = load i32, i32* %87
store i32 %88, i32* %47
%89 = load double, double* %26
%90 = load double*, double** %29
%91 = load i32, i32* %43
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds double, double* %90, i64 %92
%94 = load double, double* %93
%95 = fmul double %89, %94
store double %95, double* %70
store i32 0, i32* %44
br label %96
96: ; preds = %240, %83
%97 = load i32, i32* %44
%98 = load i32, i32* %23
%99 = icmp slt i32 %97, %98
br i1 %99, label %100, label %243
100: ; preds = %96
%101 = load i32, i32* %43
%102 = load i32, i32* %23
%103 = mul nsw i32 %101, %102
%104 = load i32, i32* %44
%105 = add nsw i32 %103, %104
store i32 %105, i32* %45
%106 = load double*, double** %33
%107 = load i32, i32* %47
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds double, double* %106, i64 %108
%110 = load double, double* %109
%111 = load double*, double** %34
%112 = load i32, i32* %47
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds double, double* %111, i64 %113
%115 = load double, double* %114
%116 = fadd double %110, %115
store double %116, double* %66
%117 = load double, double* %70
%118 = load double*, double** %36
%119 = load i32, i32* %45
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds double, double* %118, i64 %120
%122 = load double, double* %121
%123 = load double, double* %70
%124 = fadd double %122, %123
%125 = call double @smoothedHeaviside(double %117, double %124)
%126 = call double @llvm.fmuladd.f64(double %125, double 9.999900e-01, double 1.000000e-05)
store double %126, double* %71
%127 = load double, double* %70
%128 = load double*, double** %36
%129 = load i32, i32* %45
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds double, double* %128, i64 %130
%132 = load double, double* %131
%133 = load double, double* %70
%134 = fadd double %132, %133
%135 = call double @smoothedDirac(double %127, double %134)
%136 = fmul double %135, 9.999900e-01
store double %136, double* %72
%137 = load double, double* %66
%138 = load double, double* %71
%139 = fmul double %137, %138
%140 = load double*, double** %37
%141 = load i32, i32* %45
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds double, double* %140, i64 %142
store double %139, double* %143
%144 = load double, double* %66
%145 = load double, double* %72
%146 = fmul double %144, %145
%147 = load double*, double** %38
%148 = load i32, i32* %45
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds double, double* %147, i64 %149
store double %146, double* %150
store i32 0, i32* %46
br label %151
151: ; preds = %236, %100
%152 = load i32, i32* %46
%153 = load i32, i32* %24
%154 = icmp slt i32 %152, %153
br i1 %154, label %155, label %239
155: ; preds = %151
%156 = load double*, double** %35
%157 = load i32, i32* %47
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds double, double* %156, i64 %158
%160 = load double, double* %159
%161 = load double*, double** %30
%162 = load i32, i32* %46
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds double, double* %161, i64 %163
%165 = load double, double* %164
%166 = fmul double %160, %165
%167 = load double, double* %71
%168 = fmul double %166, %167
%169 = load double*, double** %39
%170 = load i32, i32* %45
%171 = load i32, i32* %24
%172 = mul nsw i32 %170, %171
%173 = load i32, i32* %46
%174 = add nsw i32 %172, %173
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds double, double* %169, i64 %175
store double %168, double* %176
%177 = load double*, double** %35
%178 = load i32, i32* %47
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds double, double* %177, i64 %179
%181 = load double, double* %180
%182 = load double*, double** %30
%183 = load i32, i32* %46
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds double, double* %182, i64 %184
%186 = load double, double* %185
%187 = fmul double %181, %186
%188 = load double, double* %72
%189 = fmul double %187, %188
%190 = load double*, double** %40
%191 = load i32, i32* %45
%192 = load i32, i32* %24
%193 = mul nsw i32 %191, %192
%194 = load i32, i32* %46
%195 = add nsw i32 %193, %194
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds double, double* %190, i64 %196
store double %189, double* %197
%198 = load double*, double** %35
%199 = load i32, i32* %47
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds double, double* %198, i64 %200
%202 = load double, double* %201
%203 = load double, double* %71
%204 = fmul double %202, %203
%205 = load double*, double** %41
%206 = load i32, i32* %45
%207 = load i32, i32* %48
%208 = mul nsw i32 %206, %207
%209 = load i32, i32* %46
%210 = load i32, i32* %24
%211 = mul nsw i32 %209, %210
%212 = add nsw i32 %208, %211
%213 = load i32, i32* %46
%214 = add nsw i32 %212, %213
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds double, double* %205, i64 %215
store double %204, double* %216
%217 = load double*, double** %35
%218 = load i32, i32* %47
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds double, double* %217, i64 %219
%221 = load double, double* %220
%222 = load double, double* %72
%223 = fmul double %221, %222
%224 = load double*, double** %42
%225 = load i32, i32* %45
%226 = load i32, i32* %48
%227 = mul nsw i32 %225, %226
%228 = load i32, i32* %46
%229 = load i32, i32* %24
%230 = mul nsw i32 %228, %229
%231 = add nsw i32 %227, %230
%232 = load i32, i32* %46
%233 = add nsw i32 %231, %232
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds double, double* %224, i64 %234
store double %223, double* %235
br label %236
236: ; preds = %155
%237 = load i32, i32* %46
%238 = add nsw i32 %237, 1
store i32 %238, i32* %46
br label %151
239: ; preds = %151
br label %240
240: ; preds = %239
%241 = load i32, i32* %44
%242 = add nsw i32 %241, 1
store i32 %242, i32* %44
br label %96
243: ; preds = %96
br label %244
244: ; preds = %243
%245 = load i32, i32* %43
%246 = add nsw i32 %245, 1
store i32 %246, i32* %43
br label %79
247: ; preds = %79
ret void
}

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