void conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate(
    const int nSimplices, const int nPointsPerSimplex, const int nSpace,
    const double rho, const double *gravity, const double alpha, const double n,
    const double m, const double thetaR, const double thetaSR, const double KWs,
    double *dV, double *u, double *mass, double *dmass, double *f, double *df,
    double *a, double *da) {
  int k, I, J, eN;
  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 = thetaR + thetaSR;
  double mavg, dmavg, vol;
  double favg[3] = {0.0, 0.0, 0.0};
  double dfavg[3] = {0.0, 0.0, 0.0};
  double aavg[3][3] = {{0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}};
  double daavg[3][3] = {{0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}};
  for (eN = 0; eN < nSimplices; eN++) {
    mavg = 0.0;
    dmavg = 0.0;
    vol = 0.0;
    for (I = 0; I < nSpace; I++) {
      favg[I] = 0.0;
      dfavg[I] = 0.0;
      for (J = 0; J < nSpace; J++) {
        aavg[I][J] = 0.0;
        daavg[I][J] = 0.0;
      }
    }
    for (k = 0; k < nPointsPerSimplex; k++) {
      psiC = -u[eN * nPointsPerSimplex + k];
      if (psiC > 0.0) {
        pcBar = alpha * psiC;
        pcBar_nM2 = pow(pcBar, n - 2);
        pcBar_nM1 = pcBar_nM2 * pcBar;
        pcBar_n = pcBar_nM1 * pcBar;
        onePlus_pcBar_n = 1.0 + pcBar_n;
        sBar = pow(onePlus_pcBar_n, -m);
        DsBar_DpsiC = alpha * (1.0 - n) * (sBar / onePlus_pcBar_n) * pcBar_nM1;
        vBar = 1.0 - pcBar_nM1 * sBar;
        vBar2 = vBar * vBar;
        DvBar_DpsiC =
            -alpha * (n - 1.0) * pcBar_nM2 * sBar - pcBar_nM1 * DsBar_DpsiC;
        thetaW = thetaSR * sBar + thetaR;
        DthetaW_DpsiC = thetaSR * DsBar_DpsiC;
        sqrt_sBar = sqrt(sBar);
        KW = KWs * sqrt_sBar * vBar2;
        DKW_DpsiC = KWs * ((0.5 / sqrt_sBar) * DsBar_DpsiC * vBar2 +
                           2.0 * sqrt_sBar * vBar * DvBar_DpsiC);
      } else {
        thetaW = thetaS;
        DthetaW_DpsiC = 0.0;
        KW = KWs;
        DKW_DpsiC = 0.0;
      }
      vol += dV[eN * nPointsPerSimplex + k];
      mavg += rho * thetaW * dV[eN * nPointsPerSimplex + k];
      dmavg += -rho * DthetaW_DpsiC * dV[eN * nPointsPerSimplex + k];
      dmass[eN * nPointsPerSimplex + k] = -rho * DthetaW_DpsiC;
      for (I = 0; I < nSpace; I++) {
        favg[I] += rho2 * KW * gravity[I] * dV[eN * nPointsPerSimplex + k];
        dfavg[I] +=
            -rho2 * DKW_DpsiC * gravity[I] * dV[eN * nPointsPerSimplex + k];
        J = I;
        aavg[I][J] += rho * KW * dV[eN * nPointsPerSimplex + k];
        daavg[I][J] += -rho * DKW_DpsiC * dV[eN * nPointsPerSimplex + k];
        df[eN * nPointsPerSimplex * nSpace + k * nSpace + I] =
            -rho2 * DKW_DpsiC * gravity[I];
        da[eN * nPointsPerSimplex * nSpace2 + k * nSpace2 + I * nSpace + J] =
            -rho * DKW_DpsiC;
      }
    }
    assert(vol > 0.0);
    for (k = 0; k < nPointsPerSimplex; k++) {
      mass[eN * nPointsPerSimplex + k] = mavg / vol;
      for (I = 0; I < nSpace; I++) {
        f[eN * nPointsPerSimplex * nSpace + k * nSpace + I] = favg[I] / vol;
        for (J = 0; J < nSpace; J++) {
          if (J == I) {
            a[eN * nPointsPerSimplex * nSpace2 + k * nSpace2 + I * nSpace + J] =
                aavg[I][J] / vol;
          } else {
            a[eN * nPointsPerSimplex * nSpace2 + k * nSpace2 + I * nSpace + J] =
                0.0;
          }
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x200,%rsp
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)
movsd  %xmm0,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movsd  %xmm1,-0x28(%rbp)
movsd  %xmm2,-0x30(%rbp)
movsd  %xmm3,-0x38(%rbp)
movsd  %xmm4,-0x40(%rbp)
movsd  %xmm5,-0x48(%rbp)
movsd  %xmm6,-0x50(%rbp)
mov    %r8,-0x58(%rbp)
mov    %r9,-0x60(%rbp)
mov    -0xc(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x74(%rbp)
movsd  -0x18(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
lea    -0x140(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    -0x160(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    -0x1b0(%rbp),%rdi
xor    %esi,%esi
mov    $0x48,%edx
call   1030 <memset@plt>
lea    -0x200(%rbp),%rdi
xor    %esi,%esi
mov    $0x48,%edx
call   1030 <memset@plt>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1abb <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x97b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12ec <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x1ac>
movslq -0x68(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x140(%rbp,%rax,8)
ff ff
movslq -0x68(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x160(%rbp,%rax,8)
ff ff
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12d9 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x199>
movslq -0x68(%rbp),%rcx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x6c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x68(%rbp),%rcx
lea    -0x200(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x6c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1283 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x143>
jmp    12de <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x19e>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1250 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x110>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    192b <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x7eb>
mov    -0x60(%rbp),%rax
mov    -0x70(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    15c4 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x484>
movsd  -0x28(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x30(%rbp),%xmm1
movsd  0xc96(%rip),%xmm2
subsd  %xmm2,%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0xc5d(%rip),%xmm0
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x38(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
movsd  0xc0f(%rip),%xmm1
subsd  -0x30(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
divsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0xbaf(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
mulsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x30(%rbp),%xmm1
movsd  0xb62(%rip),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0xc0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
call   1060 <sqrt@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  0xa95(%rip),%xmm1
divsd  -0xb8(%rbp),%xmm1
ff
mulsd  -0xc0(%rbp),%xmm1
ff
movsd  -0xe0(%rbp),%xmm3
ff
movsd  0xa6d(%rip),%xmm2
mulsd  -0xb8(%rbp),%xmm2
ff
mulsd  -0xd8(%rbp),%xmm2
ff
mulsd  -0xe8(%rbp),%xmm2
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
jmp    15f7 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x4b7>
movsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x58(%rbp),%rax
mov    -0x70(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x18(%rbp),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
mov    -0x70(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x110(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x18(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
mov    -0x70(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x118(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x18(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
mov    -0x70(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1918 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x7d8>
movsd  -0x100(%rbp),%xmm0
ff
mulsd  -0xf0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x68(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x70(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x68(%rbp),%rax
movsd  -0x140(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp,%rax,8)
ff ff
movsd  -0x100(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0xf8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x68(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x70(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x68(%rbp),%rax
movsd  -0x160(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp,%rax,8)
ff ff
mov    -0x68(%rbp),%eax
mov    %eax,-0x6c(%rbp)
movsd  -0x18(%rbp),%xmm0
mulsd  -0xf0(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
mov    -0x70(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x68(%rbp),%rcx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x18(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0xf8(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
mov    -0x70(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x68(%rbp),%rcx
lea    -0x200(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x100(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0xf8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x68(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x70(%rbp),%ecx
imul   -0x8(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x64(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x18(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0xf8(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
mov    -0x70(%rbp),%ecx
imul   -0x8(%rbp),%ecx
imul   -0x74(%rbp),%ecx
mov    -0x64(%rbp),%edx
imul   -0x74(%rbp),%edx
add    %edx,%ecx
mov    -0x68(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    16eb <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x5ab>
jmp    191d <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x7dd>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    12f3 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x1b3>
movsd  -0x120(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%edi
mov    $0x0,%al
call   1040 <assert@plt>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1aa8 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x968>
movsd  -0x110(%rbp),%xmm0
ff
divsd  -0x120(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
mov    -0x70(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a95 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x955>
movslq -0x68(%rbp),%rax
movsd  -0x140(%rbp,%rax,8),%xmm0
ff ff
divsd  -0x120(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
mov    -0x70(%rbp),%ecx
imul   -0x8(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x64(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a82 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x942>
mov    -0x6c(%rbp),%eax
cmp    -0x68(%rbp),%eax
jne    1a40 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x900>
movslq -0x68(%rbp),%rcx
lea    -0x1b0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x120(%rbp),%xmm0
ff
mov    0x30(%rbp),%rax
mov    -0x70(%rbp),%ecx
imul   -0x8(%rbp),%ecx
imul   -0x74(%rbp),%ecx
mov    -0x64(%rbp),%edx
imul   -0x74(%rbp),%edx
add    %edx,%ecx
mov    -0x68(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1a6f <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x92f>
mov    0x30(%rbp),%rax
mov    -0x70(%rbp),%ecx
imul   -0x8(%rbp),%ecx
imul   -0x74(%rbp),%ecx
mov    -0x64(%rbp),%edx
imul   -0x74(%rbp),%edx
add    %edx,%ecx
mov    -0x68(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1a74 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x934>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    19d4 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x894>
jmp    1a87 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x947>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1989 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x849>
jmp    1a9a <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x95a>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1950 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x810>
jmp    1aad <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x96d>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    121c <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0xdc>
add    $0x200,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x268,%rsp
mov    %r9,0x148(%rsp)
mov    %r8,0x68(%rsp)
movsd  %xmm5,0x80(%rsp)
movsd  %xmm4,0x78(%rsp)
movapd %xmm3,0xa0(%rsp)
movaps %xmm1,0x180(%rsp)
mov    %rcx,0x60(%rsp)
movapd %xmm0,%xmm1
mov    %esi,0x10(%rsp)
xorpd  %xmm0,%xmm0
movapd %xmm0,0xd0(%rsp)
movq   $0x0,0xe0(%rsp)
movapd %xmm0,0x160(%rsp)
movq   $0x0,0x170(%rsp)
movapd %xmm0,0x1d0(%rsp)
movapd %xmm0,0x1c0(%rsp)
movapd %xmm0,0x1b0(%rsp)
movapd %xmm0,0x1a0(%rsp)
movq   $0x0,0x1e0(%rsp)
movapd %xmm0,0x220(%rsp)
movapd %xmm0,0x210(%rsp)
movapd %xmm0,0x200(%rsp)
movapd %xmm0,0x1f0(%rsp)
movq   $0x0,0x230(%rsp)
test   %edi,%edi
jle    1a77 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x937>
mov    0x2c0(%rsp),%r13
mov    %edx,%ecx
imul   %edx,%ecx
movapd %xmm1,%xmm3
mulsd  %xmm1,%xmm3
movsd  0x78(%rsp),%xmm0
addsd  0x80(%rsp),%xmm0
movsd  %xmm0,0x140(%rsp)
movsd  0xdaa(%rip),%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x128(%rsp)
movapd 0xdc5(%rip),%xmm4
movapd 0xa0(%rsp),%xmm0
xorpd  %xmm4,%xmm0
movapd %xmm0,0xa0(%rsp)
movsd  0xd7f(%rip),%xmm5
subsd  %xmm2,%xmm5
movapd 0x180(%rsp),%xmm0
mulsd  %xmm0,%xmm5
movsd  %xmm5,0x120(%rsp)
xorpd  %xmm4,%xmm0
addsd  0xd61(%rip),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x130(%rsp)
movapd %xmm1,%xmm2
xorpd  %xmm4,%xmm2
movapd %xmm3,0x250(%rsp)
xorpd  %xmm3,%xmm4
movapd %xmm4,0x240(%rsp)
mov    %edx,%r14d
lea    0x0(,%r14,8),%r15
mov    %edi,%eax
mov    %rax,0x110(%rsp)
mov    %r14d,%eax
and    $0x3,%eax
mov    %r14d,%ebp
and    $0xfffffffc,%ebp
mov    %rax,0x100(%rsp)
lea    0x0(,%rax,8),%rax
lea    (%rax,%rax,2),%rax
mov    %rax,0x138(%rsp)
mov    %ecx,0x1c(%rsp)
mov    0x10(%rsp),%eax
imul   %eax,%ecx
mov    %ecx,0x74(%rsp)
mov    %edx,%ecx
imul   %eax,%ecx
mov    %ecx,0x70(%rsp)
movslq %edx,%rcx
cltq
mov    %rax,0xf8(%rsp)
mov    %eax,%eax
mov    %rax,0x90(%rsp)
lea    -0x1(%r14),%rax
mov    %rax,0xf0(%rsp)
lea    0x1(%rcx),%eax
mov    %eax,0x18(%rsp)
mov    %rcx,0x158(%rsp)
lea    0x0(,%rcx,8),%rax
mov    %rax,0x150(%rsp)
movl   $0x0,0x14(%rsp)
movl   $0x0,0xc(%rsp)
xor    %eax,%eax
mov    %rax,0x50(%rsp)
mov    %rbp,0x108(%rsp)
movsd  %xmm6,0x58(%rsp)
movapd %xmm1,0xc0(%rsp)
mov    %edx,0x8(%rsp)
movapd %xmm2,0xb0(%rsp)
jmp    13fc <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x2bc>
xchg   %ax,%ax
xor    %edi,%edi
xor    %eax,%eax
call   1040 <assert@plt>
mov    0x8(%rsp),%edx
mov    0x50(%rsp),%rcx
add    $0x1,%rcx
mov    0xc(%rsp),%eax
add    0x74(%rsp),%eax
mov    %eax,0xc(%rsp)
mov    0x14(%rsp),%eax
add    0x70(%rsp),%eax
mov    %eax,0x14(%rsp)
mov    %rcx,%rax
mov    %rcx,0x50(%rsp)
cmp    0x110(%rsp),%rcx
mov    0x108(%rsp),%rbp
je     1a77 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x937>
test   %edx,%edx
jle    1592 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x452>
lea    0xd0(%rsp),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
lea    0x160(%rsp),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
cmpq   $0x3,0xf0(%rsp)
jae    1440 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x300>
xor    %ebx,%ebx
jmp    152d <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x3ed>
nopw   0x0(%rax,%rax,1)
xor    %r12d,%r12d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rsp,%r12,1),%rdi
add    $0x1a0,%rdi
lea    (%rsp,%r12,1),%rax
add    $0x1f0,%rax
mov    %rax,0x20(%rsp)
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
mov    0x20(%rsp),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
lea    (%rsp,%r12,1),%rdi
add    $0x1b8,%rdi
lea    (%rsp,%r12,1),%rax
add    $0x208,%rax
mov    %rax,0x20(%rsp)
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
mov    0x20(%rsp),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
lea    (%rsp,%r12,1),%rdi
add    $0x1d0,%rdi
lea    (%rsp,%r12,1),%rax
add    $0x220,%rax
mov    %rax,0x20(%rsp)
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
mov    0x20(%rsp),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
lea    (%rsp,%r12,1),%rdi
add    $0x1e8,%rdi
lea    (%rsp,%r12,1),%rax
add    $0x238,%rax
mov    %rax,0x20(%rsp)
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
mov    0x20(%rsp),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
add    $0x4,%rbx
add    $0x60,%r12
cmp    %rbx,%rbp
jne    1450 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x310>
cmpq   $0x0,0x100(%rsp)
je     1592 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x452>
shl    $0x3,%rbx
lea    (%rbx,%rbx,2),%rax
lea    (%rsp,%rax,1),%rbp
add    $0x1f0,%rbp
add    %rsp,%rax
add    $0x1a0,%rax
mov    %rax,0x20(%rsp)
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rax
lea    (%rax,%rbx,1),%rdi
lea    (%rbx,%rbp,1),%r12
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
mov    %r12,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
add    $0x18,%rbx
cmp    %rbx,0x138(%rsp)
jne    1560 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x420>
cmpl   $0x0,0x10(%rsp)
jle    13b0 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x270>
mov    0x50(%rsp),%rax
imul   0xf8(%rsp),%rax
mov    %rax,0x98(%rsp)
xorpd  %xmm14,%xmm14
mov    0x14(%rsp),%r10d
mov    0xc(%rsp),%r11d
xor    %r12d,%r12d
xorpd  %xmm12,%xmm12
xorpd  %xmm13,%xmm13
mov    0x68(%rsp),%rsi
movsd  0x58(%rsp),%xmm9
mov    0x60(%rsp),%r9
movapd 0xc0(%rsp),%xmm10
mov    0x8(%rsp),%r8d
mov    0x2c8(%rsp),%rbp
movapd 0xb0(%rsp),%xmm11
mov    0x18(%rsp),%edi
jmp    163e <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x4fe>
nopw   0x0(%rax,%rax,1)
addsd  %xmm8,%xmm12
mulsd  %xmm10,%xmm15
mulsd  %xmm8,%xmm15
addsd  %xmm15,%xmm13
add    $0x1,%r12
add    0x1c(%rsp),%r11d
add    %r8d,%r10d
cmp    0x90(%rsp),%r12
je     1940 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x800>
mov    0x98(%rsp),%rax
lea    (%r12,%rax,1),%rbx
mov    0x148(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
ucomisd %xmm0,%xmm14
xorpd  %xmm3,%xmm3
movsd  0x140(%rsp),%xmm15
movapd %xmm9,%xmm1
xorpd  %xmm2,%xmm2
jbe    183d <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x6fd>
mov    %r11d,0x38(%rsp)
mov    %r10d,0x3c(%rsp)
movsd  %xmm13,0x40(%rsp)
movsd  %xmm12,0x48(%rsp)
xorpd  0x997(%rip),%xmm0
mulsd  0x180(%rsp),%xmm0
movapd %xmm0,0x20(%rsp)
movsd  0x128(%rsp),%xmm1
call   1050 <pow@plt>
movapd 0x20(%rsp),%xmm2
movapd %xmm2,%xmm1
movsd  %xmm0,0x88(%rsp)
mulsd  %xmm0,%xmm1
movapd %xmm1,0x190(%rsp)
mulsd  %xmm1,%xmm2
addsd  0x926(%rip),%xmm2
movapd %xmm2,0x20(%rsp)
movapd %xmm2,%xmm0
movaps 0xa0(%rsp),%xmm1
call   1050 <pow@plt>
movapd %xmm0,%xmm15
ucomisd 0x91a(%rip),%xmm0
jb     1720 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x5e0>
xorps  %xmm0,%xmm0
sqrtsd %xmm15,%xmm0
jmp    173e <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x5fe>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd %xmm15,%xmm0
movsd  %xmm15,0x118(%rsp)
call   1060 <sqrt@plt>
movsd  0x118(%rsp),%xmm15
mov    0x68(%rsp),%rsi
movsd  0x58(%rsp),%xmm9
mov    0x60(%rsp),%r9
movapd 0xc0(%rsp),%xmm10
mov    0x8(%rsp),%r8d
mov    0x2c8(%rsp),%rbp
movapd 0xb0(%rsp),%xmm11
mov    0x18(%rsp),%edi
movsd  0x48(%rsp),%xmm12
movsd  0x40(%rsp),%xmm13
xorpd  %xmm14,%xmm14
mov    0x3c(%rsp),%r10d
mov    0x38(%rsp),%r11d
movsd  0x88(%rsp),%xmm6
movapd 0x20(%rsp),%xmm1
movapd 0x190(%rsp),%xmm2
movapd %xmm15,%xmm3
divsd  %xmm1,%xmm3
mulsd  0x120(%rsp),%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm3,%xmm4
mulsd  %xmm2,%xmm4
mulsd  %xmm15,%xmm2
movsd  0x834(%rip),%xmm5
subsd  %xmm2,%xmm5
movapd %xmm0,%xmm1
movsd  0x834(%rip),%xmm2
divsd  %xmm0,%xmm2
addsd  %xmm0,%xmm0
mulsd  %xmm5,%xmm0
mulsd  %xmm5,%xmm5
mulsd  0x130(%rsp),%xmm6
mulsd  %xmm15,%xmm6
subsd  %xmm4,%xmm6
movsd  0x80(%rsp),%xmm4
mulsd  %xmm4,%xmm15
addsd  0x78(%rsp),%xmm15
mulsd  %xmm9,%xmm1
mulsd  %xmm5,%xmm1
mulsd  %xmm3,%xmm2
mulsd  %xmm4,%xmm3
mulsd  %xmm6,%xmm0
mulsd  %xmm5,%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm9,%xmm2
movsd  (%rsi,%rbx,8),%xmm8
mulsd  %xmm11,%xmm3
mov    0x2a8(%rsp),%rax
movsd  %xmm3,(%rax,%rbx,8)
test   %r8d,%r8d
jle    1610 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x4d0>
movslq %r10d,%rax
mov    0x2b8(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
movapd 0x250(%rsp),%xmm3
mulsd  %xmm1,%xmm3
movapd %xmm2,%xmm4
mulsd  0x240(%rsp),%xmm4
mulsd  %xmm10,%xmm1
mulsd  %xmm11,%xmm2
xor    %ecx,%ecx
mov    %r11d,%edx
cs nopw 0x0(%rax,%rax,1)
movsd  (%r9,%rcx,1),%xmm0
movapd %xmm3,%xmm6
mulsd  %xmm0,%xmm6
movsd  (%rsi,%rbx,8),%xmm7
mulsd  %xmm7,%xmm6
addsd  0xd0(%rsp,%rcx,1),%xmm6
mulsd  %xmm4,%xmm0
movapd %xmm0,%xmm5
mulsd  %xmm7,%xmm5
addsd  0x160(%rsp,%rcx,1),%xmm5
movsd  %xmm6,0xd0(%rsp,%rcx,1)
movapd %xmm1,%xmm6
mulsd  %xmm7,%xmm6
addsd  0x1a0(%rsp,%rcx,4),%xmm6
movsd  %xmm5,0x160(%rsp,%rcx,1)
mulsd  %xmm2,%xmm7
addsd  0x1f0(%rsp,%rcx,4),%xmm7
movsd  %xmm6,0x1a0(%rsp,%rcx,4)
movsd  %xmm7,0x1f0(%rsp,%rcx,4)
movsd  %xmm0,(%rax,%rcx,1)
movslq %edx,%rdx
movsd  %xmm2,0x0(%rbp,%rdx,8)
add    %edi,%edx
add    $0x8,%rcx
cmp    %rcx,%r15
jne    18a0 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x760>
jmp    1610 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x4d0>
nopl   0x0(%rax)
xor    %edi,%edi
ucomisd 0x6d5(%rip),%xmm12
seta   %dil
xor    %eax,%eax
movsd  %xmm12,0x48(%rsp)
movsd  %xmm13,0x40(%rsp)
call   1040 <assert@plt>
movsd  0x40(%rsp),%xmm4
movsd  0x48(%rsp),%xmm3
mov    0x8(%rsp),%edx
cmpl   $0x0,0x10(%rsp)
mov    0x2b0(%rsp),%r11
mov    0x2a0(%rsp),%r12
jle    13bd <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x27d>
divsd  %xmm3,%xmm4
mov    0xc(%rsp),%r8d
xor    %r9d,%r9d
jmp    19b7 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x877>
nopl   (%rax)
add    $0x1,%r9
add    0x1c(%rsp),%r8d
cmp    0x90(%rsp),%r9
je     13bd <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x27d>
mov    0x98(%rsp),%rax
add    %r9,%rax
movsd  %xmm4,(%r12,%rax,8)
test   %edx,%edx
jle    19a0 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x860>
movslq %r8d,%rcx
lea    0x0(,%rcx,8),%rsi
add    %r13,%rsi
mov    0x1c(%rsp),%ecx
imul   %eax,%ecx
imul   %edx,%eax
movslq %ecx,%r10
movslq %eax,%rdi
xor    %ebx,%ebx
jmp    1a01 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x8c1>
xchg   %ax,%ax
add    $0x1,%rbx
add    0x150(%rsp),%rsi
cmp    %r14,%rbx
je     19a0 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x860>
movsd  0xd0(%rsp,%rbx,8),%xmm0
divsd  %xmm3,%xmm0
lea    (%rbx,%rdi,1),%rax
movsd  %xmm0,(%r11,%rax,8)
mov    %rbx,%rax
imul   0x158(%rsp),%rax
add    %r10,%rax
lea    (%rbx,%rbx,2),%rcx
lea    (%rsp,%rcx,8),%rcx
add    $0x1a0,%rcx
lea    (%rcx,%rbx,8),%rcx
add    %rbx,%rax
xor    %ebp,%ebp
jmp    1a61 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x921>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   $0x0,(%rsi,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r14
je     19f0 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x8b0>
cmp    %rbp,%rbx
jne    1a50 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x910>
movsd  (%rcx),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
jmp    1a58 <conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate+0x918>
add    $0x268,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @conservativeHeadRichardsL2projMualemVanGenuchtenHomEvaluate(i32 %0, i32 %1, i32 %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) {
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca double
%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 i32
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32
%44 = alloca double
%45 = alloca double
%46 = alloca double
%47 = alloca double
%48 = alloca double
%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 [3 x double]
%66 = alloca [3 x double]
%67 = alloca [3 x [3 x double]]
%68 = alloca [3 x [3 x double]]
store i32 %0, i32* %20
store i32 %1, i32* %21
store i32 %2, i32* %22
store double %3, double* %23
store double* %4, double** %24
store double %5, double* %25
store double %6, double* %26
store double %7, double* %27
store double %8, double* %28
store double %9, double* %29
store double %10, double* %30
store double* %11, double** %31
store double* %12, double** %32
store double* %13, double** %33
store double* %14, double** %34
store double* %15, double** %35
store double* %16, double** %36
store double* %17, double** %37
store double* %18, double** %38
%69 = load i32, i32* %22
%70 = load i32, i32* %22
%71 = mul nsw i32 %69, %70
store i32 %71, i32* %43
%72 = load double, double* %23
%73 = load double, double* %23
%74 = fmul double %72, %73
store double %74, double* %60
%75 = load double, double* %28
%76 = load double, double* %29
%77 = fadd double %75, %76
store double %77, double* %61
%78 = bitcast [3 x double]* %65 to i8*
%79 = bitcast [3 x double]* %66 to i8*
%80 = bitcast [3 x [3 x double]]* %67 to i8*
%81 = bitcast [3 x [3 x double]]* %68 to i8*
store i32 0, i32* %42
br label %82
82: ; preds = %535, %19
%83 = load i32, i32* %42
%84 = load i32, i32* %20
%85 = icmp slt i32 %83, %84
br i1 %85, label %86, label %538
86: ; preds = %82
store double 0.000000e+00, double* %62
store double 0.000000e+00, double* %63
store double 0.000000e+00, double* %64
store i32 0, i32* %40
br label %87
87: ; preds = %119, %86
%88 = load i32, i32* %40
%89 = load i32, i32* %22
%90 = icmp slt i32 %88, %89
br i1 %90, label %91, label %122
91: ; preds = %87
%92 = load i32, i32* %40
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds [3 x double], [3 x double]* %65, i64 0, i64 %93
store double 0.000000e+00, double* %94
%95 = load i32, i32* %40
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds [3 x double], [3 x double]* %66, i64 0, i64 %96
store double 0.000000e+00, double* %97
store i32 0, i32* %41
br label %98
98: ; preds = %115, %91
%99 = load i32, i32* %41
%100 = load i32, i32* %22
%101 = icmp slt i32 %99, %100
br i1 %101, label %102, label %118
102: ; preds = %98
%103 = load i32, i32* %40
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %67, i64 0, i64 %104
%106 = load i32, i32* %41
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds [3 x double], [3 x double]* %105, i64 0, i64 %107
store double 0.000000e+00, double* %108
%109 = load i32, i32* %40
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %68, i64 0, i64 %110
%112 = load i32, i32* %41
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds [3 x double], [3 x double]* %111, i64 0, i64 %113
store double 0.000000e+00, double* %114
br label %115
115: ; preds = %102
%116 = load i32, i32* %41
%117 = add nsw i32 %116, 1
store i32 %117, i32* %41
br label %98
118: ; preds = %98
br label %119
119: ; preds = %118
%120 = load i32, i32* %40
%121 = add nsw i32 %120, 1
store i32 %121, i32* %40
br label %87
122: ; preds = %87
store i32 0, i32* %39
br label %123
123: ; preds = %418, %122
%124 = load i32, i32* %39
%125 = load i32, i32* %21
%126 = icmp slt i32 %124, %125
br i1 %126, label %127, label %421
127: ; preds = %123
%128 = load double*, double** %32
%129 = load i32, i32* %42
%130 = load i32, i32* %21
%131 = mul nsw i32 %129, %130
%132 = load i32, i32* %39
%133 = add nsw i32 %131, %132
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds double, double* %128, i64 %134
%136 = load double, double* %135
%137 = fneg double %136
store double %137, double* %44
%138 = load double, double* %44
%139 = fcmp ogt double %138, 0.000000e+00
br i1 %139, label %140, label %218
140: ; preds = %127
%141 = load double, double* %25
%142 = load double, double* %44
%143 = fmul double %141, %142
store double %143, double* %45
%144 = load double, double* %45
%145 = load double, double* %26
%146 = fsub double %145, 2.000000e+00
%147 = call double @pow(double %144, double %146)
store double %147, double* %48
%148 = load double, double* %48
%149 = load double, double* %45
%150 = fmul double %148, %149
store double %150, double* %47
%151 = load double, double* %47
%152 = load double, double* %45
%153 = fmul double %151, %152
store double %153, double* %46
%154 = load double, double* %46
%155 = fadd double 1.000000e+00, %154
store double %155, double* %49
%156 = load double, double* %49
%157 = load double, double* %27
%158 = fneg double %157
%159 = call double @pow(double %156, double %158)
store double %159, double* %50
%160 = load double, double* %25
%161 = load double, double* %26
%162 = fsub double 1.000000e+00, %161
%163 = fmul double %160, %162
%164 = load double, double* %50
%165 = load double, double* %49
%166 = fdiv double %164, %165
%167 = fmul double %163, %166
%168 = load double, double* %47
%169 = fmul double %167, %168
store double %169, double* %52
%170 = load double, double* %47
%171 = load double, double* %50
%172 = fneg double %170
%173 = call double @llvm.fmuladd.f64(double %172, double %171, double 1.000000e+00)
store double %173, double* %55
%174 = load double, double* %55
%175 = load double, double* %55
%176 = fmul double %174, %175
store double %176, double* %56
%177 = load double, double* %25
%178 = fneg double %177
%179 = load double, double* %26
%180 = fsub double %179, 1.000000e+00
%181 = fmul double %178, %180
%182 = load double, double* %48
%183 = fmul double %181, %182
%184 = load double, double* %50
%185 = load double, double* %47
%186 = load double, double* %52
%187 = fmul double %185, %186
%188 = fneg double %187
%189 = call double @llvm.fmuladd.f64(double %183, double %184, double %188)
store double %189, double* %57
%190 = load double, double* %29
%191 = load double, double* %50
%192 = load double, double* %28
%193 = call double @llvm.fmuladd.f64(double %190, double %191, double %192)
store double %193, double* %53
%194 = load double, double* %29
%195 = load double, double* %52
%196 = fmul double %194, %195
store double %196, double* %54
%197 = load double, double* %50
%198 = call double @sqrt(double %197)
store double %198, double* %51
%199 = load double, double* %30
%200 = load double, double* %51
%201 = fmul double %199, %200
%202 = load double, double* %56
%203 = fmul double %201, %202
store double %203, double* %58
%204 = load double, double* %30
%205 = load double, double* %51
%206 = fdiv double 5.000000e-01, %205
%207 = load double, double* %52
%208 = fmul double %206, %207
%209 = load double, double* %56
%210 = load double, double* %51
%211 = fmul double 2.000000e+00, %210
%212 = load double, double* %55
%213 = fmul double %211, %212
%214 = load double, double* %57
%215 = fmul double %213, %214
%216 = call double @llvm.fmuladd.f64(double %208, double %209, double %215)
%217 = fmul double %204, %216
store double %217, double* %59
br label %221
218: ; preds = %127
%219 = load double, double* %61
store double %219, double* %53
store double 0.000000e+00, double* %54
%220 = load double, double* %30
store double %220, double* %58
store double 0.000000e+00, double* %59
br label %221
221: ; preds = %218, %140
%222 = load double*, double** %31
%223 = load i32, i32* %42
%224 = load i32, i32* %21
%225 = mul nsw i32 %223, %224
%226 = load i32, i32* %39
%227 = add nsw i32 %225, %226
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds double, double* %222, i64 %228
%230 = load double, double* %229
%231 = load double, double* %64
%232 = fadd double %231, %230
store double %232, double* %64
%233 = load double, double* %23
%234 = load double, double* %53
%235 = fmul double %233, %234
%236 = load double*, double** %31
%237 = load i32, i32* %42
%238 = load i32, i32* %21
%239 = mul nsw i32 %237, %238
%240 = load i32, i32* %39
%241 = add nsw i32 %239, %240
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds double, double* %236, i64 %242
%244 = load double, double* %243
%245 = load double, double* %62
%246 = call double @llvm.fmuladd.f64(double %235, double %244, double %245)
store double %246, double* %62
%247 = load double, double* %23
%248 = fneg double %247
%249 = load double, double* %54
%250 = fmul double %248, %249
%251 = load double*, double** %31
%252 = load i32, i32* %42
%253 = load i32, i32* %21
%254 = mul nsw i32 %252, %253
%255 = load i32, i32* %39
%256 = add nsw i32 %254, %255
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds double, double* %251, i64 %257
%259 = load double, double* %258
%260 = load double, double* %63
%261 = call double @llvm.fmuladd.f64(double %250, double %259, double %260)
store double %261, double* %63
%262 = load double, double* %23
%263 = fneg double %262
%264 = load double, double* %54
%265 = fmul double %263, %264
%266 = load double*, double** %34
%267 = load i32, i32* %42
%268 = load i32, i32* %21
%269 = mul nsw i32 %267, %268
%270 = load i32, i32* %39
%271 = add nsw i32 %269, %270
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds double, double* %266, i64 %272
store double %265, double* %273
store i32 0, i32* %40
br label %274
274: ; preds = %414, %221
%275 = load i32, i32* %40
%276 = load i32, i32* %22
%277 = icmp slt i32 %275, %276
br i1 %277, label %278, label %417
278: ; preds = %274
%279 = load double, double* %60
%280 = load double, double* %58
%281 = fmul double %279, %280
%282 = load double*, double** %24
%283 = load i32, i32* %40
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds double, double* %282, i64 %284
%286 = load double, double* %285
%287 = fmul double %281, %286
%288 = load double*, double** %31
%289 = load i32, i32* %42
%290 = load i32, i32* %21
%291 = mul nsw i32 %289, %290
%292 = load i32, i32* %39
%293 = add nsw i32 %291, %292
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds double, double* %288, i64 %294
%296 = load double, double* %295
%297 = load i32, i32* %40
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds [3 x double], [3 x double]* %65, i64 0, i64 %298
%300 = load double, double* %299
%301 = call double @llvm.fmuladd.f64(double %287, double %296, double %300)
store double %301, double* %299
%302 = load double, double* %60
%303 = fneg double %302
%304 = load double, double* %59
%305 = fmul double %303, %304
%306 = load double*, double** %24
%307 = load i32, i32* %40
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds double, double* %306, i64 %308
%310 = load double, double* %309
%311 = fmul double %305, %310
%312 = load double*, double** %31
%313 = load i32, i32* %42
%314 = load i32, i32* %21
%315 = mul nsw i32 %313, %314
%316 = load i32, i32* %39
%317 = add nsw i32 %315, %316
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds double, double* %312, i64 %318
%320 = load double, double* %319
%321 = load i32, i32* %40
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds [3 x double], [3 x double]* %66, i64 0, i64 %322
%324 = load double, double* %323
%325 = call double @llvm.fmuladd.f64(double %311, double %320, double %324)
store double %325, double* %323
%326 = load i32, i32* %40
store i32 %326, i32* %41
%327 = load double, double* %23
%328 = load double, double* %58
%329 = fmul double %327, %328
%330 = load double*, double** %31
%331 = load i32, i32* %42
%332 = load i32, i32* %21
%333 = mul nsw i32 %331, %332
%334 = load i32, i32* %39
%335 = add nsw i32 %333, %334
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds double, double* %330, i64 %336
%338 = load double, double* %337
%339 = load i32, i32* %40
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %67, i64 0, i64 %340
%342 = load i32, i32* %41
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds [3 x double], [3 x double]* %341, i64 0, i64 %343
%345 = load double, double* %344
%346 = call double @llvm.fmuladd.f64(double %329, double %338, double %345)
store double %346, double* %344
%347 = load double, double* %23
%348 = fneg double %347
%349 = load double, double* %59
%350 = fmul double %348, %349
%351 = load double*, double** %31
%352 = load i32, i32* %42
%353 = load i32, i32* %21
%354 = mul nsw i32 %352, %353
%355 = load i32, i32* %39
%356 = add nsw i32 %354, %355
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds double, double* %351, i64 %357
%359 = load double, double* %358
%360 = load i32, i32* %40
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %68, i64 0, i64 %361
%363 = load i32, i32* %41
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds [3 x double], [3 x double]* %362, i64 0, i64 %364
%366 = load double, double* %365
%367 = call double @llvm.fmuladd.f64(double %350, double %359, double %366)
store double %367, double* %365
%368 = load double, double* %60
%369 = fneg double %368
%370 = load double, double* %59
%371 = fmul double %369, %370
%372 = load double*, double** %24
%373 = load i32, i32* %40
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds double, double* %372, i64 %374
%376 = load double, double* %375
%377 = fmul double %371, %376
%378 = load double*, double** %36
%379 = load i32, i32* %42
%380 = load i32, i32* %21
%381 = mul nsw i32 %379, %380
%382 = load i32, i32* %22
%383 = mul nsw i32 %381, %382
%384 = load i32, i32* %39
%385 = load i32, i32* %22
%386 = mul nsw i32 %384, %385
%387 = add nsw i32 %383, %386
%388 = load i32, i32* %40
%389 = add nsw i32 %387, %388
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds double, double* %378, i64 %390
store double %377, double* %391
%392 = load double, double* %23
%393 = fneg double %392
%394 = load double, double* %59
%395 = fmul double %393, %394
%396 = load double*, double** %38
%397 = load i32, i32* %42
%398 = load i32, i32* %21
%399 = mul nsw i32 %397, %398
%400 = load i32, i32* %43
%401 = mul nsw i32 %399, %400
%402 = load i32, i32* %39
%403 = load i32, i32* %43
%404 = mul nsw i32 %402, %403
%405 = add nsw i32 %401, %404
%406 = load i32, i32* %40
%407 = load i32, i32* %22
%408 = mul nsw i32 %406, %407
%409 = add nsw i32 %405, %408
%410 = load i32, i32* %41
%411 = add nsw i32 %409, %410
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds double, double* %396, i64 %412
store double %395, double* %413
br label %414
414: ; preds = %278
%415 = load i32, i32* %40
%416 = add nsw i32 %415, 1
store i32 %416, i32* %40
br label %274
417: ; preds = %274
br label %418
418: ; preds = %417
%419 = load i32, i32* %39
%420 = add nsw i32 %419, 1
store i32 %420, i32* %39
br label %123
421: ; preds = %123
%422 = load double, double* %64
%423 = fcmp ogt double %422, 0.000000e+00
%424 = zext i1 %423 to i32
%425 = call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 %424)
store i32 0, i32* %39
br label %426
426: ; preds = %531, %421
%427 = load i32, i32* %39
%428 = load i32, i32* %21
%429 = icmp slt i32 %427, %428
br i1 %429, label %430, label %534
430: ; preds = %426
%431 = load double, double* %62
%432 = load double, double* %64
%433 = fdiv double %431, %432
%434 = load double*, double** %33
%435 = load i32, i32* %42
%436 = load i32, i32* %21
%437 = mul nsw i32 %435, %436
%438 = load i32, i32* %39
%439 = add nsw i32 %437, %438
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds double, double* %434, i64 %440
store double %433, double* %441
store i32 0, i32* %40
br label %442
442: ; preds = %527, %430
%443 = load i32, i32* %40
%444 = load i32, i32* %22
%445 = icmp slt i32 %443, %444
br i1 %445, label %446, label %530
446: ; preds = %442
%447 = load i32, i32* %40
%448 = sext i32 %447 to i64
%449 = getelementptr inbounds [3 x double], [3 x double]* %65, i64 0, i64 %448
%450 = load double, double* %449
%451 = load double, double* %64
%452 = fdiv double %450, %451
%453 = load double*, double** %35
%454 = load i32, i32* %42
%455 = load i32, i32* %21
%456 = mul nsw i32 %454, %455
%457 = load i32, i32* %22
%458 = mul nsw i32 %456, %457
%459 = load i32, i32* %39
%460 = load i32, i32* %22
%461 = mul nsw i32 %459, %460
%462 = add nsw i32 %458, %461
%463 = load i32, i32* %40
%464 = add nsw i32 %462, %463
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds double, double* %453, i64 %465
store double %452, double* %466
store i32 0, i32* %41
br label %467
467: ; preds = %523, %446
%468 = load i32, i32* %41
%469 = load i32, i32* %22
%470 = icmp slt i32 %468, %469
br i1 %470, label %471, label %526
471: ; preds = %467
%472 = load i32, i32* %41
%473 = load i32, i32* %40
%474 = icmp eq i32 %472, %473
br i1 %474, label %475, label %503
475: ; preds = %471
%476 = load i32, i32* %40
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %67, i64 0, i64 %477
%479 = load i32, i32* %41
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds [3 x double], [3 x double]* %478, i64 0, i64 %480
%482 = load double, double* %481
%483 = load double, double* %64
%484 = fdiv double %482, %483
%485 = load double*, double** %37
%486 = load i32, i32* %42
%487 = load i32, i32* %21
%488 = mul nsw i32 %486, %487
%489 = load i32, i32* %43
%490 = mul nsw i32 %488, %489
%491 = load i32, i32* %39
%492 = load i32, i32* %43
%493 = mul nsw i32 %491, %492
%494 = add nsw i32 %490, %493
%495 = load i32, i32* %40
%496 = load i32, i32* %22
%497 = mul nsw i32 %495, %496
%498 = add nsw i32 %494, %497
%499 = load i32, i32* %41
%500 = add nsw i32 %498, %499
%501 = sext i32 %500 to i64
%502 = getelementptr inbounds double, double* %485, i64 %501
store double %484, double* %502
br label %522
503: ; preds = %471
%504 = load double*, double** %37
%505 = load i32, i32* %42
%506 = load i32, i32* %21
%507 = mul nsw i32 %505, %506
%508 = load i32, i32* %43
%509 = mul nsw i32 %507, %508
%510 = load i32, i32* %39
%511 = load i32, i32* %43
%512 = mul nsw i32 %510, %511
%513 = add nsw i32 %509, %512
%514 = load i32, i32* %40
%515 = load i32, i32* %22
%516 = mul nsw i32 %514, %515
%517 = add nsw i32 %513, %516
%518 = load i32, i32* %41
%519 = add nsw i32 %517, %518
%520 = sext i32 %519 to i64
%521 = getelementptr inbounds double, double* %504, i64 %520
store double 0.000000e+00, double* %521
br label %522
522: ; preds = %503, %475
br label %523
523: ; preds = %522
%524 = load i32, i32* %41
%525 = add nsw i32 %524, 1
store i32 %525, i32* %41
br label %467
526: ; preds = %467
br label %527
527: ; preds = %526
%528 = load i32, i32* %40
%529 = add nsw i32 %528, 1
store i32 %529, i32* %40
br label %442
530: ; preds = %442
br label %531
531: ; preds = %530
%532 = load i32, i32* %39
%533 = add nsw i32 %532, 1
store i32 %533, i32* %39
br label %426
534: ; preds = %426
br label %535
535: ; preds = %534
%536 = load i32, i32* %42
%537 = add nsw i32 %536, 1
store i32 %537, i32* %42
br label %82
538: ; preds = %82
ret void
}

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