void conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm(
    const int upwindFlag, const int computeAverages, const int nSimplex,
    const int nPointsPerSimplex, const int nSpace,
    const int nQuadraturePoints_elementBoundary,
    const int *elementBoundaryElementsArray,
    const int *quadraturePointToElementBoundary, const int *materialTypes,
    const double rho, const double beta, const double *gravity,
    const double *alpha, const double *n_vg, const double *thetaR,
    const double *thetaSR, const double *KWs, const double *u,
    const double *gradu, const double *n_global, const double *dV, double *mass,
    double *dmass, double *f_avg, double *df_avg, double *a_avg, double *da_avg,
    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, KWr, DKWr_DpsiC, rho2 = rho * rho, thetaS, rhom, drhom, m;
  int eN_upwind, ebN_global;
  register double drive, KWs_harm, KWs_left, KWs_right, krw_val, dkrw_val, vol;
  if (upwindFlag > 0)
    assert(computeAverages);
  for (i = 0; i < nSimplex; i++) {
    matID = materialTypes[i];
    vol = 0.0;
    for (j = 0; j < nPointsPerSimplex; j++)
      vol += dV[i * nPointsPerSimplex + j];
    if (computeAverages) {
      a_avg[i * nSpace2 + 0 * nSpace + 0] = 0.0;
      da_avg[i * nSpace2 + 0 * nSpace + 0] = 0.0;
    }
    for (j = 0; j < nPointsPerSimplex; j++) {
      k = i * nPointsPerSimplex + j;
      psiC = -u[k];
      m = 1.0 - 1.0 / n_vg[matID];
      thetaS = thetaR[matID] + thetaSR[matID];
      if (psiC > 0.0) {
        pcBar = alpha[matID] * psiC;
        pcBar_nM2 = pow(pcBar, n_vg[matID] - 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[matID] * (1.0 - n_vg[matID]) *
                      (sBar / onePlus_pcBar_n) * pcBar_nM1;
        vBar = 1.0 - pcBar_nM1 * sBar;
        vBar2 = vBar * vBar;
        DvBar_DpsiC = -alpha[matID] * (n_vg[matID] - 1.0) * pcBar_nM2 * sBar -
                      pcBar_nM1 * DsBar_DpsiC;
        thetaW = thetaSR[matID] * sBar + thetaR[matID];
        DthetaW_DpsiC = thetaSR[matID] * DsBar_DpsiC;
        sqrt_sBar = sqrt(sBar);
        KWr = sqrt_sBar * vBar2;
        DKWr_DpsiC = ((0.5 / sqrt_sBar) * DsBar_DpsiC * vBar2 +
                      2.0 * sqrt_sBar * vBar * DvBar_DpsiC);
      } else {
        thetaW = thetaS;
        DthetaW_DpsiC = 0.0;
        KWr = 1.0;
        DKWr_DpsiC = 0.0;
      }
      rhom = rho * exp(beta * u[k]);
      drhom = beta * rhom;
      mass[k] = rhom * thetaW;
      dmass[k] = -rhom * DthetaW_DpsiC + drhom * thetaW;
      a[i * nPointsPerSimplex * nSpace2 + j * nSpace2 + 0 * nSpace + 0] = KWr;
      da[i * nPointsPerSimplex * nSpace2 + j * nSpace2 + 0 * nSpace + 0] =
          -DKWr_DpsiC;
      if (computeAverages) {
        a_avg[i * nSpace2 + 0 * nSpace + 0] += KWr * dV[k];
        da_avg[i * nSpace2 + 0 * nSpace + 0] += -DKWr_DpsiC * dV[k];
      }
    }
    if (computeAverages) {
      a_avg[i * nSpace2 + 0 * nSpace + 0] /= vol;
      da_avg[i * nSpace2 + 0 * nSpace + 0] /= vol;
    }
  }
  for (i = 0; i < nSimplex; i++) {
    matID = materialTypes[i];
    for (j = 0; j < nPointsPerSimplex; j++) {
      k = i * nPointsPerSimplex + j;
      ebN_global = quadraturePointToElementBoundary[k];
      KWs_left = KWs[matID];
      KWs_right = KWs_left;
      if (elementBoundaryElementsArray[ebN_global * 2 + 1] >= 0)
        KWs_right = KWs
            [materialTypes[elementBoundaryElementsArray[ebN_global * 2 + 1]]];
      KWs_harm = 2.0 * KWs_left * KWs_right / (KWs_left + KWs_right + 1.0e-24);
      drive = 0.0;
      for (I = 0; I < nSpace; I++) {
        drive +=
            (rho2 * KWs_harm * gravity[I] -
             rho * KWs_harm * gradu[k * nSpace + I]) *
            n_global[ebN_global * nQuadraturePoints_elementBoundary * nSpace +
                     0 * nSpace + I];
      }
      if (drive >= 0.0 || elementBoundaryElementsArray[ebN_global * 2 + 1] < 0)
        eN_upwind = elementBoundaryElementsArray[ebN_global * 2 + 0];
      else
        eN_upwind = elementBoundaryElementsArray[ebN_global * 2 + 1];
      krw_val =
          a[i * nPointsPerSimplex * nSpace2 + j * nSpace2 + 0 * nSpace + 0];
      dkrw_val =
          da[i * nPointsPerSimplex * nSpace2 + j * nSpace2 + 0 * nSpace + 0];
      if (upwindFlag > 0) {
        krw_val = a_avg[eN_upwind * nSpace2 + 0 * nSpace + 0];
      }
      for (I = 0; I < nSpace; I++) {
        f[k * nSpace + I] = rho2 * krw_val * KWs_harm * gravity[I];
        df[k * nSpace + I] = rho2 * dkrw_val * KWs_harm * gravity[I];
        a[i * nPointsPerSimplex * nSpace2 + j * nSpace2 + I * nSpace + I] =
            rho * krw_val * KWs_harm;
        da[i * nPointsPerSimplex * nSpace2 + j * nSpace2 + I * nSpace + I] =
            rho * dkrw_val * KWs_harm;
      }
    }
  }
}


x86 assembly (clang, -O0):
<conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    0xc0(%rbp),%rax
mov    0xb8(%rbp),%rax
mov    0xb0(%rbp),%rax
mov    0xa8(%rbp),%rax
mov    0xa0(%rbp),%rax
mov    0x98(%rbp),%rax
mov    0x90(%rbp),%rax
mov    0x88(%rbp),%rax
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
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    %ecx,-0x10(%rbp)
mov    %r8d,-0x14(%rbp)
mov    %r9d,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
movsd  %xmm1,-0x28(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x40(%rbp)
movsd  -0x20(%rbp),%xmm0
mulsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
cmpl   $0x0,-0x4(%rbp)
jle    1210 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0xd0>
mov    -0x8(%rbp),%edi
mov    $0x0,%al
call   1030 <assert@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1888 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x748>
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1283 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x143>
mov    0x70(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1243 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x103>
cmpl   $0x0,-0x8(%rbp)
je     12d1 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x191>
mov    0x98(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x40(%rbp),%ecx
imul   $0x0,-0x14(%rbp),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0xa0(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x40(%rbp),%ecx
imul   $0x0,-0x14(%rbp),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    180b <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x6cb>
mov    -0x2c(%rbp),%eax
imul   -0x10(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  0xce6(%rip),%xmm1
divsd  (%rax,%rcx,8),%xmm1
movsd  0xcd9(%rip),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    0x40(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    15e4 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x4a4>
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xc60(%rip),%xmm2
subsd  %xmm2,%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0xc34(%rip),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0xe8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0x78(%rbp)
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  0xbdf(%rip),%xmm1
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  -0x78(%rbp),%xmm1
divsd  -0x70(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0xb8e(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xb31(%rip),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    0x40(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  0xa7b(%rip),%xmm0
divsd  -0x80(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm2
ff
movsd  0xa4e(%rip),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    161a <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x4da>
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0xa09(%rip),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
call   1040 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x130(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
mulsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
mov    0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm1
ff
mulsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x80(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
mov    0xb8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
imul   -0x40(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
imul   $0x0,-0x14(%rbp),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0xc0(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
imul   -0x40(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
imul   $0x0,-0x14(%rbp),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x8(%rbp)
je     17f8 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x6b8>
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x98(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x40(%rbp),%ecx
imul   $0x0,-0x14(%rbp),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0xa0(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x40(%rbp),%ecx
imul   $0x0,-0x14(%rbp),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    17fd <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x6bd>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12d8 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x198>
cmpl   $0x0,-0x8(%rbp)
je     1875 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x735>
movsd  -0x128(%rbp),%xmm1
ff
mov    0x98(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x40(%rbp),%ecx
imul   $0x0,-0x14(%rbp),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x128(%rbp),%xmm1
ff
mov    0xa0(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x40(%rbp),%ecx
imul   $0x0,-0x14(%rbp),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    187a <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x73a>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1217 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0xd7>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1ca8 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0xb68>
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1c95 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0xb55>
mov    -0x2c(%rbp),%eax
imul   -0x10(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xf0(%rbp)
mov    0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
mov    0x10(%rbp),%rax
mov    -0xf0(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jl     194c <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x80c>
mov    0x50(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    0x10(%rbp),%rdx
mov    -0xf0(%rbp),%esi
shl    $0x1,%esi
add    $0x1,%esi
movslq %esi,%rsi
movslq (%rdx,%rsi,4),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  0x6b4(%rip),%xmm0
mulsd  -0x108(%rbp),%xmm0
ff
mulsd  -0x110(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm1
ff
addsd  -0x110(%rbp),%xmm1
ff
movsd  0x684(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1a52 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x912>
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x100(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x20(%rbp),%xmm1
mulsd  -0x100(%rbp),%xmm1
ff
mov    0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x68(%rbp),%rax
mov    -0xf0(%rbp),%ecx
imul   -0x18(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   $0x0,-0x14(%rbp),%edx
add    %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    199e <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x85e>
movsd  -0xf8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jae    1a84 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x944>
mov    0x10(%rbp),%rax
mov    -0xf0(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jge    1aa5 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x965>
mov    0x10(%rbp),%rax
mov    -0xf0(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xec(%rbp)
jmp    1ac1 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x981>
mov    0x10(%rbp),%rax
mov    -0xf0(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xec(%rbp)
mov    0xb8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
imul   -0x40(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
imul   $0x0,-0x14(%rbp),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    0xc0(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
imul   -0x40(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
imul   $0x0,-0x14(%rbp),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
cmpl   $0x0,-0x4(%rbp)
jle    1b5d <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0xa1d>
mov    0x98(%rbp),%rax
mov    -0xec(%rbp),%ecx
imul   -0x40(%rbp),%ecx
imul   $0x0,-0x14(%rbp),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1c82 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0xb42>
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x118(%rbp),%xmm0
ff
mulsd  -0x100(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0xa8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x120(%rbp),%xmm0
ff
mulsd  -0x100(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0xb0(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x20(%rbp),%xmm0
mulsd  -0x118(%rbp),%xmm0
ff
mulsd  -0x100(%rbp),%xmm0
mov    0xb8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
imul   -0x40(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
mov    -0x38(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x20(%rbp),%xmm0
mulsd  -0x120(%rbp),%xmm0
ff
mulsd  -0x100(%rbp),%xmm0
ff
mov    0xc0(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
imul   -0x40(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
mov    -0x38(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1b64 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0xa24>
jmp    1c87 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0xb47>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    18b0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x770>
jmp    1c9a <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0xb5a>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    188f <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x74f>
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
movsd  %xmm1,0x78(%rsp)
movsd  %xmm0,0x68(%rsp)
mov    %r9d,0x14(%rsp)
mov    %r8d,%r14d
mov    %ecx,0x4(%rsp)
mov    %edx,%r15d
mov    %edi,0xa4(%rsp)
test   %edi,%edi
mov    %esi,0x20(%rsp)
jle    1188 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x48>
mov    %esi,%edi
xor    %eax,%eax
call   1030 <assert@plt>
mov    0x20(%rsp),%esi
test   %r15d,%r15d
jle    1b70 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0xa30>
mov    0x210(%rsp),%rax
mov    %rax,0xb8(%rsp)
mov    0x208(%rsp),%rax
mov    %rax,0xb0(%rsp)
mov    0x1e0(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    0x1d8(%rsp),%rax
mov    %rax,0x18(%rsp)
mov    0x1d0(%rsp),%r8
mov    %r14d,%ecx
imul   %r14d,%ecx
movsd  0x68(%rsp),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0xd0(%rsp)
mov    0x4(%rsp),%eax
movslq %eax,%rdx
mov    %edx,%edi
mov    %edi,%ebp
and    $0x3,%ebp
mov    %edi,%ebx
and    $0xfffffffc,%ebx
mov    %rbx,0xe0(%rsp)
mov    %ecx,(%rsp)
imul   %eax,%ecx
mov    %ecx,0x3c(%rsp)
xorpd  %xmm1,%xmm1
mov    0x1b8(%rsp),%rax
mov    %rax,0x30(%rsp)
mov    0x188(%rsp),%r13
mov    %r15d,0xa0(%rsp)
mov    %r15d,%eax
mov    %rax,0xc0(%rsp)
mov    %rdi,0xd8(%rsp)
lea    -0x1(%rdi),%rax
mov    %rax,0xe8(%rsp)
mov    %r8,0x98(%rsp)
lea    0x18(%r8),%rbx
mov    %rdx,0xa8(%rsp)
lea    0x0(,%rdx,8),%rax
mov    %rax,0xf0(%rsp)
xor    %eax,%eax
mov    %rax,0x90(%rsp)
xor    %edx,%edx
mov    %rbp,0xf8(%rsp)
jmp    12f0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x1b0>
nopl   0x0(%rax)
add    $0x1,%rdx
mov    0x100(%rsp),%rbx
mov    0xf0(%rsp),%rax
add    %rax,%rbx
add    %rax,0x98(%rsp)
mov    0x90(%rsp),%rcx
add    0x3c(%rsp),%ecx
mov    %rcx,0x90(%rsp)
add    %rax,0x30(%rsp)
add    %rax,0x18(%rsp)
add    %rax,0x60(%rsp)
cmp    0xc0(%rsp),%rdx
mov    0x1b0(%rsp),%rdi
mov    0xf8(%rsp),%rbp
je     17c7 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x687>
xorpd  %xmm2,%xmm2
cmpl   $0x0,0x4(%rsp)
jle    136e <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x22e>
cmpq   $0x3,0xe8(%rsp)
jae    1310 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x1d0>
xorpd  %xmm2,%xmm2
xor    %eax,%eax
jmp    1340 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x200>
xchg   %ax,%ax
xorpd  %xmm2,%xmm2
xor    %eax,%eax
mov    0xe0(%rsp),%rcx
xchg   %ax,%ax
addsd  -0x18(%rbx,%rax,8),%xmm2
addsd  -0x10(%rbx,%rax,8),%xmm2
addsd  -0x8(%rbx,%rax,8),%xmm2
addsd  (%rbx,%rax,8),%xmm2
add    $0x4,%rax
cmp    %rax,%rcx
jne    1320 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x1e0>
test   %rbp,%rbp
je     136e <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x22e>
mov    0x98(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addsd  (%rax,%rcx,8),%xmm2
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    1360 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x220>
mov    %rbx,0x100(%rsp)
mov    0x180(%rsp),%rax
movslq (%rax,%rdx,4),%rbx
test   %esi,%esi
je     13ac <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x26c>
mov    (%rsp),%eax
imul   %edx,%eax
mov    0x1f8(%rsp),%rcx
movq   $0x0,(%rcx,%rax,8)
mov    0x200(%rsp),%rcx
movq   $0x0,(%rcx,%rax,8)
mov    %rdx,0xc8(%rsp)
cmpl   $0x0,0x4(%rsp)
jle    1780 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x640>
mov    (%rsp),%eax
imul   0xc8(%rsp),%eax
mov    %rax,0x118(%rsp)
mov    0x90(%rsp),%rax
mov    %eax,%r15d
xor    %r12d,%r12d
movsd  %xmm2,0x28(%rsp)
jmp    1410 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x2d0>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
add    (%rsp),%r15d
cmp    %r12,0xd8(%rsp)
xorpd  %xmm1,%xmm1
movsd  0x28(%rsp),%xmm2
je     1780 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x640>
mov    0x30(%rsp),%rax
movsd  (%rax,%r12,8),%xmm2
ucomisd %xmm2,%xmm1
jbe    1530 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x3f0>
mov    %r14,%rbp
mov    0x198(%rsp),%r14
movsd  (%r14,%rbx,8),%xmm1
movapd 0xbf2(%rip),%xmm0
xorpd  %xmm0,%xmm2
movsd  0xbbe(%rip),%xmm3
divsd  %xmm1,%xmm3
movsd  0xbaa(%rip),%xmm0
addsd  %xmm0,%xmm3
movapd %xmm3,0x80(%rsp)
mov    0x190(%rsp),%r14
mulsd  (%r14,%rbx,8),%xmm2
movapd %xmm2,0x40(%rsp)
addsd  0xb91(%rip),%xmm1
movapd %xmm2,%xmm0
call   1050 <pow@plt>
movsd  %xmm0,0x8(%rsp)
movapd 0x40(%rsp),%xmm2
mulsd  %xmm2,%xmm0
movsd  %xmm0,0x58(%rsp)
mulsd  %xmm0,%xmm2
addsd  0xb56(%rip),%xmm2
movapd 0x80(%rsp),%xmm1
xorpd  0xb75(%rip),%xmm1
movapd %xmm2,0x40(%rsp)
movapd %xmm2,%xmm0
call   1050 <pow@plt>
xorpd  %xmm1,%xmm1
movapd %xmm0,%xmm10
movsd  (%r14,%rbx,8),%xmm9
mov    0x198(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm4
mov    0x1a8(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm8
movapd %xmm8,%xmm0
mulsd  %xmm10,%xmm0
mov    0x1a0(%rsp),%rax
addsd  (%rax,%rbx,8),%xmm0
ucomisd %xmm1,%xmm10
movsd  %xmm0,0x70(%rsp)
jb     1580 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x440>
xorps  %xmm0,%xmm0
sqrtsd %xmm10,%xmm0
jmp    15d8 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x498>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x1a0(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    0x1a8(%rsp),%rax
addsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,0x70(%rsp)
xorpd  %xmm0,%xmm0
movapd %xmm0,0x40(%rsp)
movsd  0xa9e(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
xorpd  %xmm0,%xmm0
movapd %xmm0,0x80(%rsp)
jmp    169d <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x55d>
nopw   0x0(%rax,%rax,1)
movapd %xmm10,%xmm0
movapd %xmm8,0x80(%rsp)
movsd  %xmm10,0x110(%rsp)
movapd %xmm9,0x120(%rsp)
movsd  %xmm4,0x108(%rsp)
call   1060 <sqrt@plt>
movsd  0x108(%rsp),%xmm4
movapd 0x120(%rsp),%xmm9
movsd  0x110(%rsp),%xmm10
movapd 0x80(%rsp),%xmm8
mov    %rbp,%r14
movsd  0x8(%rsp),%xmm5
movapd 0x40(%rsp),%xmm6
movsd  0x58(%rsp),%xmm7
movsd  0xa0b(%rip),%xmm3
movapd %xmm3,%xmm2
subsd  %xmm4,%xmm2
mulsd  %xmm9,%xmm2
movapd %xmm10,%xmm1
divsd  %xmm6,%xmm1
mulsd  %xmm2,%xmm1
mulsd  %xmm7,%xmm1
mulsd  %xmm1,%xmm8
movapd %xmm8,0x80(%rsp)
movsd  0x9ee(%rip),%xmm6
divsd  %xmm0,%xmm6
mulsd  %xmm1,%xmm6
mulsd  %xmm7,%xmm1
mulsd  %xmm10,%xmm7
movapd %xmm3,%xmm2
subsd  %xmm7,%xmm2
movapd %xmm2,%xmm3
mulsd  %xmm2,%xmm3
xorpd  0x9dc(%rip),%xmm9
addsd  0x9ac(%rip),%xmm4
mulsd  %xmm9,%xmm4
mulsd  %xmm4,%xmm5
mulsd  %xmm10,%xmm5
subsd  %xmm1,%xmm5
mulsd  %xmm3,%xmm6
mulsd  %xmm0,%xmm3
movsd  %xmm3,0x8(%rsp)
addsd  %xmm0,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm0,%xmm6
movapd %xmm6,0x40(%rsp)
mov    0x30(%rsp),%rax
movsd  (%rax,%r12,8),%xmm2
mulsd  0x78(%rsp),%xmm2
movapd %xmm2,%xmm0
call   1040 <exp@plt>
mulsd  0x68(%rsp),%xmm0
movapd %xmm0,%xmm1
mulsd  0x78(%rsp),%xmm1
movsd  0x70(%rsp),%xmm3
movapd %xmm3,%xmm2
mulsd  %xmm0,%xmm2
mov    0x18(%rsp),%rax
movsd  %xmm2,(%rax,%r12,8)
mulsd  %xmm3,%xmm1
mulsd  0x80(%rsp),%xmm0
subsd  %xmm0,%xmm1
mov    0x60(%rsp),%rax
movsd  %xmm1,(%rax,%r12,8)
movslq %r15d,%rax
mov    0x218(%rsp),%rcx
movsd  0x8(%rsp),%xmm1
movsd  %xmm1,(%rcx,%rax,8)
movapd 0x40(%rsp),%xmm0
xorpd  0x91b(%rip),%xmm0
mov    0x220(%rsp),%rcx
movlpd %xmm0,(%rcx,%rax,8)
mov    0x20(%rsp),%esi
test   %esi,%esi
je     13f0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x2b0>
mov    0x98(%rsp),%rcx
mulsd  (%rcx,%r12,8),%xmm1
mov    0x1f8(%rsp),%rax
mov    0x118(%rsp),%rdx
addsd  (%rax,%rdx,8),%xmm1
movsd  %xmm1,(%rax,%rdx,8)
mulsd  (%rcx,%r12,8),%xmm0
mov    0x200(%rsp),%rax
addsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rax,%rdx,8)
jmp    13f0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x2b0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %esi,%esi
mov    0xc8(%rsp),%rdx
je     1290 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x150>
mov    (%rsp),%eax
imul   %edx,%eax
mov    0x1f8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mov    0x200(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx,%rax,8)
jmp    1290 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x150>
cmpl   $0x0,0xa0(%rsp)
jle    1b70 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0xa30>
mov    0x14(%rsp),%eax
imul   %r14d,%eax
mov    %eax,0x14(%rsp)
movslq %r14d,%rdx
mov    %r14d,%ecx
mov    %ecx,%r11d
and    $0xfffffffe,%r11d
mov    0x1c0(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x20(%rsp)
mov    %rdx,%rax
imul   0xa8(%rsp),%rax
shl    $0x3,%rax
mov    %rax,0x58(%rsp)
mov    %rdx,0x30(%rsp)
lea    0x0(,%rdx,8),%rax
mov    %rax,0x40(%rsp)
mov    0x1c8(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x60(%rsp)
lea    0x1(%r14),%eax
xor    %edx,%edx
mov    %rdx,0x18(%rsp)
movsd  0x7d6(%rip),%xmm0
xorpd  %xmm1,%xmm1
xor    %edx,%edx
mov    %rdx,0x28(%rsp)
mov    %r14,0x8(%rsp)
jmp    18a7 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x767>
nopl   0x0(%rax)
mov    0x28(%rsp),%rbp
add    $0x1,%rbp
mov    0x58(%rsp),%rdx
add    %rdx,0x20(%rsp)
mov    0x18(%rsp),%rsi
add    0x3c(%rsp),%esi
mov    %rsi,0x18(%rsp)
add    %rdx,0xb0(%rsp)
add    %rdx,0xb8(%rsp)
mov    %rbp,%rdx
mov    %rbp,0x28(%rsp)
cmp    0xc0(%rsp),%rbp
je     1b70 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0xa30>
cmpl   $0x0,0x4(%rsp)
jle    1860 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x720>
mov    0x180(%rsp),%rdx
mov    0x28(%rsp),%rsi
movslq (%rdx,%rsi,4),%rdx
mov    %rdx,0x78(%rsp)
imul   0xa8(%rsp),%rsi
mov    %rsi,0x70(%rsp)
mov    0xb8(%rsp),%r9
mov    0xb0(%rsp),%r10
mov    0x18(%rsp),%rdx
mov    %edx,%ebx
mov    0x20(%rsp),%r15
xor    %r8d,%r8d
jmp    192b <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x7eb>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r8
mov    0x40(%rsp),%rdx
add    %rdx,%r15
add    (%rsp),%ebx
add    %rdx,%r10
add    %rdx,%r9
cmp    0xd8(%rsp),%r8
mov    0x1b0(%rsp),%rdi
je     1860 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x720>
mov    %ebx,0x80(%rsp)
mov    0x70(%rsp),%rdx
lea    (%r8,%rdx,1),%r12
mov    0x178(%rsp),%rsi
movslq (%rsi,%r12,4),%rdx
mov    0x78(%rsp),%rsi
movsd  (%rdi,%rsi,8),%xmm3
mov    0x170(%rsp),%rsi
mov    0x4(%rsi,%rdx,8),%esi
movapd %xmm3,%xmm4
test   %esi,%esi
js     1976 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x836>
mov    0x180(%rsp),%rbx
movslq (%rbx,%rsi,4),%rbp
movsd  (%rdi,%rbp,8),%xmm4
movapd %xmm3,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm4,%xmm3
addsd  %xmm0,%xmm3
divsd  %xmm3,%xmm2
test   %r14d,%r14d
jle    1a86 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x946>
mov    0x14(%rsp),%ebp
imul   %edx,%ebp
movsd  0xd0(%rsp),%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm2,%xmm4
xorpd  0x679(%rip),%xmm4
mulsd  0x68(%rsp),%xmm4
movslq %ebp,%rbx
cmp    $0x1,%r14d
jne    19d0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x890>
xorpd  %xmm5,%xmm5
xor    %ebp,%ebp
jmp    1a31 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x8f1>
xchg   %ax,%ax
mov    0x60(%rsp),%rdi
lea    (%rdi,%rbx,8),%r14
xorpd  %xmm5,%xmm5
xor    %ebp,%ebp
nop
movsd  -0x8(%r15,%rbp,8),%xmm6
mulsd  %xmm4,%xmm6
movsd  0x0(%r13,%rbp,8),%xmm7
mulsd  %xmm3,%xmm7
addsd  %xmm6,%xmm7
mulsd  -0x8(%r14,%rbp,8),%xmm7
addsd  %xmm5,%xmm7
movsd  (%r15,%rbp,8),%xmm6
mulsd  %xmm4,%xmm6
movsd  0x8(%r13,%rbp,8),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm6,%xmm5
mulsd  (%r14,%rbp,8),%xmm5
addsd  %xmm7,%xmm5
add    $0x2,%rbp
cmp    %rbp,%r11
jne    19e0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x8a0>
test   $0x1,%cl
je     1a77 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x937>
mov    %r12,%rdi
imul   0x30(%rsp),%rdi
add    %rbp,%rdi
mov    %rdx,%r14
mov    %rbx,%rdx
mov    0x1c0(%rsp),%rbx
mulsd  (%rbx,%rdi,8),%xmm4
mulsd  0x0(%r13,%rbp,8),%xmm3
addsd  %xmm4,%xmm3
add    %rbp,%rdx
mov    0x1c8(%rsp),%rdi
mulsd  (%rdi,%rdx,8),%xmm3
mov    %r14,%rdx
addsd  %xmm3,%xmm5
ucomisd %xmm1,%xmm5
mov    0x8(%rsp),%r14
jae    1a86 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x946>
test   %esi,%esi
jns    1a97 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x957>
add    %rdx,%rdx
movslq %edx,%rsi
mov    0x170(%rsp),%rdi
mov    (%rdi,%rsi,4),%esi
mov    (%rsp),%edi
imul   %edi,%r12d
imul   %edi,%esi
cmpl   $0x0,0xa4(%rsp)
movslq %r12d,%rdi
mov    0x218(%rsp),%rdx
lea    (%rdx,%rdi,8),%rbp
movslq %esi,%rsi
mov    0x1f8(%rsp),%rbx
lea    (%rbx,%rsi,8),%rsi
cmovle %rbp,%rsi
test   %r14d,%r14d
mov    0x220(%rsp),%rbp
mov    0x80(%rsp),%ebx
jle    1900 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x7c0>
movsd  0x0(%rbp,%rdi,8),%xmm3
movsd  (%rsi),%xmm4
movsd  0xd0(%rsp),%xmm6
movapd %xmm6,%xmm5
mulsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
mulsd  %xmm3,%xmm6
mulsd  %xmm2,%xmm6
movsd  0x68(%rsp),%xmm7
mulsd  %xmm7,%xmm4
mulsd  %xmm2,%xmm4
mulsd  %xmm7,%xmm3
mulsd  %xmm2,%xmm3
mov    %ebx,%esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%r13,%rdi,8),%xmm2
mulsd  %xmm5,%xmm2
movsd  %xmm2,(%r10,%rdi,8)
movsd  0x0(%r13,%rdi,8),%xmm2
mulsd  %xmm6,%xmm2
movsd  %xmm2,(%r9,%rdi,8)
movslq %esi,%rsi
movsd  %xmm4,(%rdx,%rsi,8)
movsd  %xmm3,0x0(%rbp,%rsi,8)
add    $0x1,%rdi
add    %eax,%esi
cmp    %rdi,%rcx
jne    1b30 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x9f0>
jmp    1900 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm+0x7c0>
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, i32* %6, i32* %7, i32* %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, double* %21, double* %22, double* %23, double* %24, double* %25, double* %26, double* %27, double* %28, double* %29, double* %30) {
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32*
%39 = alloca i32*
%40 = alloca i32*
%41 = alloca double
%42 = alloca double
%43 = alloca double*
%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 i32
%64 = alloca i32
%65 = alloca i32
%66 = alloca i32
%67 = alloca i32
%68 = alloca i32
%69 = alloca double
%70 = alloca double
%71 = alloca double
%72 = alloca double
%73 = alloca double
%74 = alloca double
%75 = alloca double
%76 = alloca double
%77 = alloca double
%78 = alloca double
%79 = alloca double
%80 = alloca double
%81 = alloca double
%82 = alloca double
%83 = alloca double
%84 = alloca double
%85 = alloca double
%86 = alloca double
%87 = alloca double
%88 = alloca double
%89 = alloca double
%90 = alloca i32
%91 = alloca i32
%92 = alloca double
%93 = alloca double
%94 = alloca double
%95 = alloca double
%96 = alloca double
%97 = alloca double
%98 = alloca double
store i32 %0, i32* %32
store i32 %1, i32* %33
store i32 %2, i32* %34
store i32 %3, i32* %35
store i32 %4, i32* %36
store i32 %5, i32* %37
store i32* %6, i32** %38
store i32* %7, i32** %39
store i32* %8, i32** %40
store double %9, double* %41
store double %10, double* %42
store double* %11, double** %43
store double* %12, double** %44
store double* %13, double** %45
store double* %14, double** %46
store double* %15, double** %47
store double* %16, double** %48
store double* %17, double** %49
store double* %18, double** %50
store double* %19, double** %51
store double* %20, double** %52
store double* %21, double** %53
store double* %22, double** %54
store double* %23, double** %55
store double* %24, double** %56
store double* %25, double** %57
store double* %26, double** %58
store double* %27, double** %59
store double* %28, double** %60
store double* %29, double** %61
store double* %30, double** %62
%99 = load i32, i32* %36
%100 = load i32, i32* %36
%101 = mul nsw i32 %99, %100
store i32 %101, i32* %68
%102 = load double, double* %41
%103 = load double, double* %41
%104 = fmul double %102, %103
store double %104, double* %85
%105 = load i32, i32* %32
%106 = icmp sgt i32 %105, 0
br i1 %106, label %107, label %110
107: ; preds = %31
%108 = load i32, i32* %33
%109 = call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 %108)
br label %110
110: ; preds = %107, %31
store i32 0, i32* %63
br label %111
111: ; preds = %455, %110
%112 = load i32, i32* %63
%113 = load i32, i32* %34
%114 = icmp slt i32 %112, %113
br i1 %114, label %115, label %458
115: ; preds = %111
%116 = load i32*, i32** %40
%117 = load i32, i32* %63
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds i32, i32* %116, i64 %118
%120 = load i32, i32* %119
store i32 %120, i32* %67
store double 0.000000e+00, double* %98
store i32 0, i32* %64
br label %121
121: ; preds = %137, %115
%122 = load i32, i32* %64
%123 = load i32, i32* %35
%124 = icmp slt i32 %122, %123
br i1 %124, label %125, label %140
125: ; preds = %121
%126 = load double*, double** %52
%127 = load i32, i32* %63
%128 = load i32, i32* %35
%129 = mul nsw i32 %127, %128
%130 = load i32, i32* %64
%131 = add nsw i32 %129, %130
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds double, double* %126, i64 %132
%134 = load double, double* %133
%135 = load double, double* %98
%136 = fadd double %135, %134
store double %136, double* %98
br label %137
137: ; preds = %125
%138 = load i32, i32* %64
%139 = add nsw i32 %138, 1
store i32 %139, i32* %64
br label %121
140: ; preds = %121
%141 = load i32, i32* %33
%142 = icmp ne i32 %141, 0
br i1 %142, label %143, label %164
143: ; preds = %140
%144 = load double*, double** %57
%145 = load i32, i32* %63
%146 = load i32, i32* %68
%147 = mul nsw i32 %145, %146
%148 = load i32, i32* %36
%149 = mul nsw i32 0, %148
%150 = add nsw i32 %147, %149
%151 = add nsw i32 %150, 0
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds double, double* %144, i64 %152
store double 0.000000e+00, double* %153
%154 = load double*, double** %58
%155 = load i32, i32* %63
%156 = load i32, i32* %68
%157 = mul nsw i32 %155, %156
%158 = load i32, i32* %36
%159 = mul nsw i32 0, %158
%160 = add nsw i32 %157, %159
%161 = add nsw i32 %160, 0
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds double, double* %154, i64 %162
store double 0.000000e+00, double* %163
br label %164
164: ; preds = %143, %140
store i32 0, i32* %64
br label %165
165: ; preds = %421, %164
%166 = load i32, i32* %64
%167 = load i32, i32* %35
%168 = icmp slt i32 %166, %167
br i1 %168, label %169, label %424
169: ; preds = %165
%170 = load i32, i32* %63
%171 = load i32, i32* %35
%172 = mul nsw i32 %170, %171
%173 = load i32, i32* %64
%174 = add nsw i32 %172, %173
store i32 %174, i32* %65
%175 = load double*, double** %49
%176 = load i32, i32* %65
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds double, double* %175, i64 %177
%179 = load double, double* %178
%180 = fneg double %179
store double %180, double* %69
%181 = load double*, double** %45
%182 = load i32, i32* %67
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds double, double* %181, i64 %183
%185 = load double, double* %184
%186 = fdiv double 1.000000e+00, %185
%187 = fsub double 1.000000e+00, %186
store double %187, double* %89
%188 = load double*, double** %46
%189 = load i32, i32* %67
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds double, double* %188, i64 %190
%192 = load double, double* %191
%193 = load double*, double** %47
%194 = load i32, i32* %67
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds double, double* %193, i64 %195
%197 = load double, double* %196
%198 = fadd double %192, %197
store double %198, double* %86
%199 = load double, double* %69
%200 = fcmp ogt double %199, 0.000000e+00
br i1 %200, label %201, label %311
201: ; preds = %169
%202 = load double*, double** %44
%203 = load i32, i32* %67
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds double, double* %202, i64 %204
%206 = load double, double* %205
%207 = load double, double* %69
%208 = fmul double %206, %207
store double %208, double* %70
%209 = load double, double* %70
%210 = load double*, double** %45
%211 = load i32, i32* %67
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds double, double* %210, i64 %212
%214 = load double, double* %213
%215 = fsub double %214, 2.000000e+00
%216 = call double @pow(double %209, double %215)
store double %216, double* %73
%217 = load double, double* %73
%218 = load double, double* %70
%219 = fmul double %217, %218
store double %219, double* %72
%220 = load double, double* %72
%221 = load double, double* %70
%222 = fmul double %220, %221
store double %222, double* %71
%223 = load double, double* %71
%224 = fadd double 1.000000e+00, %223
store double %224, double* %74
%225 = load double, double* %74
%226 = load double, double* %89
%227 = fneg double %226
%228 = call double @pow(double %225, double %227)
store double %228, double* %75
%229 = load double*, double** %44
%230 = load i32, i32* %67
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds double, double* %229, i64 %231
%233 = load double, double* %232
%234 = load double*, double** %45
%235 = load i32, i32* %67
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds double, double* %234, i64 %236
%238 = load double, double* %237
%239 = fsub double 1.000000e+00, %238
%240 = fmul double %233, %239
%241 = load double, double* %75
%242 = load double, double* %74
%243 = fdiv double %241, %242
%244 = fmul double %240, %243
%245 = load double, double* %72
%246 = fmul double %244, %245
store double %246, double* %77
%247 = load double, double* %72
%248 = load double, double* %75
%249 = fneg double %247
%250 = call double @llvm.fmuladd.f64(double %249, double %248, double 1.000000e+00)
store double %250, double* %80
%251 = load double, double* %80
%252 = load double, double* %80
%253 = fmul double %251, %252
store double %253, double* %81
%254 = load double*, double** %44
%255 = load i32, i32* %67
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds double, double* %254, i64 %256
%258 = load double, double* %257
%259 = fneg double %258
%260 = load double*, double** %45
%261 = load i32, i32* %67
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds double, double* %260, i64 %262
%264 = load double, double* %263
%265 = fsub double %264, 1.000000e+00
%266 = fmul double %259, %265
%267 = load double, double* %73
%268 = fmul double %266, %267
%269 = load double, double* %75
%270 = load double, double* %72
%271 = load double, double* %77
%272 = fmul double %270, %271
%273 = fneg double %272
%274 = call double @llvm.fmuladd.f64(double %268, double %269, double %273)
store double %274, double* %82
%275 = load double*, double** %47
%276 = load i32, i32* %67
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds double, double* %275, i64 %277
%279 = load double, double* %278
%280 = load double, double* %75
%281 = load double*, double** %46
%282 = load i32, i32* %67
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds double, double* %281, i64 %283
%285 = load double, double* %284
%286 = call double @llvm.fmuladd.f64(double %279, double %280, double %285)
store double %286, double* %78
%287 = load double*, double** %47
%288 = load i32, i32* %67
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds double, double* %287, i64 %289
%291 = load double, double* %290
%292 = load double, double* %77
%293 = fmul double %291, %292
store double %293, double* %79
%294 = load double, double* %75
%295 = call double @sqrt(double %294)
store double %295, double* %76
%296 = load double, double* %76
%297 = load double, double* %81
%298 = fmul double %296, %297
store double %298, double* %83
%299 = load double, double* %76
%300 = fdiv double 5.000000e-01, %299
%301 = load double, double* %77
%302 = fmul double %300, %301
%303 = load double, double* %81
%304 = load double, double* %76
%305 = fmul double 2.000000e+00, %304
%306 = load double, double* %80
%307 = fmul double %305, %306
%308 = load double, double* %82
%309 = fmul double %307, %308
%310 = call double @llvm.fmuladd.f64(double %302, double %303, double %309)
store double %310, double* %84
br label %313
311: ; preds = %169
%312 = load double, double* %86
store double %312, double* %78
store double 0.000000e+00, double* %79
store double 1.000000e+00, double* %83
store double 0.000000e+00, double* %84
br label %313
313: ; preds = %311, %201
%314 = load double, double* %41
%315 = load double, double* %42
%316 = load double*, double** %49
%317 = load i32, i32* %65
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds double, double* %316, i64 %318
%320 = load double, double* %319
%321 = fmul double %315, %320
%322 = call double @exp(double %321)
%323 = fmul double %314, %322
store double %323, double* %87
%324 = load double, double* %42
%325 = load double, double* %87
%326 = fmul double %324, %325
store double %326, double* %88
%327 = load double, double* %87
%328 = load double, double* %78
%329 = fmul double %327, %328
%330 = load double*, double** %53
%331 = load i32, i32* %65
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds double, double* %330, i64 %332
store double %329, double* %333
%334 = load double, double* %87
%335 = fneg double %334
%336 = load double, double* %79
%337 = load double, double* %88
%338 = load double, double* %78
%339 = fmul double %337, %338
%340 = call double @llvm.fmuladd.f64(double %335, double %336, double %339)
%341 = load double*, double** %54
%342 = load i32, i32* %65
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds double, double* %341, i64 %343
store double %340, double* %344
%345 = load double, double* %83
%346 = load double*, double** %61
%347 = load i32, i32* %63
%348 = load i32, i32* %35
%349 = mul nsw i32 %347, %348
%350 = load i32, i32* %68
%351 = mul nsw i32 %349, %350
%352 = load i32, i32* %64
%353 = load i32, i32* %68
%354 = mul nsw i32 %352, %353
%355 = add nsw i32 %351, %354
%356 = load i32, i32* %36
%357 = mul nsw i32 0, %356
%358 = add nsw i32 %355, %357
%359 = add nsw i32 %358, 0
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds double, double* %346, i64 %360
store double %345, double* %361
%362 = load double, double* %84
%363 = fneg double %362
%364 = load double*, double** %62
%365 = load i32, i32* %63
%366 = load i32, i32* %35
%367 = mul nsw i32 %365, %366
%368 = load i32, i32* %68
%369 = mul nsw i32 %367, %368
%370 = load i32, i32* %64
%371 = load i32, i32* %68
%372 = mul nsw i32 %370, %371
%373 = add nsw i32 %369, %372
%374 = load i32, i32* %36
%375 = mul nsw i32 0, %374
%376 = add nsw i32 %373, %375
%377 = add nsw i32 %376, 0
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds double, double* %364, i64 %378
store double %363, double* %379
%380 = load i32, i32* %33
%381 = icmp ne i32 %380, 0
br i1 %381, label %382, label %420
382: ; preds = %313
%383 = load double, double* %83
%384 = load double*, double** %52
%385 = load i32, i32* %65
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds double, double* %384, i64 %386
%388 = load double, double* %387
%389 = load double*, double** %57
%390 = load i32, i32* %63
%391 = load i32, i32* %68
%392 = mul nsw i32 %390, %391
%393 = load i32, i32* %36
%394 = mul nsw i32 0, %393
%395 = add nsw i32 %392, %394
%396 = add nsw i32 %395, 0
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds double, double* %389, i64 %397
%399 = load double, double* %398
%400 = call double @llvm.fmuladd.f64(double %383, double %388, double %399)
store double %400, double* %398
%401 = load double, double* %84
%402 = fneg double %401
%403 = load double*, double** %52
%404 = load i32, i32* %65
%405 = sext i32 %404 to i64
%406 = getelementptr inbounds double, double* %403, i64 %405
%407 = load double, double* %406
%408 = load double*, double** %58
%409 = load i32, i32* %63
%410 = load i32, i32* %68
%411 = mul nsw i32 %409, %410
%412 = load i32, i32* %36
%413 = mul nsw i32 0, %412
%414 = add nsw i32 %411, %413
%415 = add nsw i32 %414, 0
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds double, double* %408, i64 %416
%418 = load double, double* %417
%419 = call double @llvm.fmuladd.f64(double %402, double %407, double %418)
store double %419, double* %417
br label %420
420: ; preds = %382, %313
br label %421
421: ; preds = %420
%422 = load i32, i32* %64
%423 = add nsw i32 %422, 1
store i32 %423, i32* %64
br label %165
424: ; preds = %165
%425 = load i32, i32* %33
%426 = icmp ne i32 %425, 0
br i1 %426, label %427, label %454
427: ; preds = %424
%428 = load double, double* %98
%429 = load double*, double** %57
%430 = load i32, i32* %63
%431 = load i32, i32* %68
%432 = mul nsw i32 %430, %431
%433 = load i32, i32* %36
%434 = mul nsw i32 0, %433
%435 = add nsw i32 %432, %434
%436 = add nsw i32 %435, 0
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds double, double* %429, i64 %437
%439 = load double, double* %438
%440 = fdiv double %439, %428
store double %440, double* %438
%441 = load double, double* %98
%442 = load double*, double** %58
%443 = load i32, i32* %63
%444 = load i32, i32* %68
%445 = mul nsw i32 %443, %444
%446 = load i32, i32* %36
%447 = mul nsw i32 0, %446
%448 = add nsw i32 %445, %447
%449 = add nsw i32 %448, 0
%450 = sext i32 %449 to i64
%451 = getelementptr inbounds double, double* %442, i64 %450
%452 = load double, double* %451
%453 = fdiv double %452, %441
store double %453, double* %451
br label %454
454: ; preds = %427, %424
br label %455
455: ; preds = %454
%456 = load i32, i32* %63
%457 = add nsw i32 %456, 1
store i32 %457, i32* %63
br label %111
458: ; preds = %111
store i32 0, i32* %63
br label %459
459: ; preds = %746, %458
%460 = load i32, i32* %63
%461 = load i32, i32* %34
%462 = icmp slt i32 %460, %461
br i1 %462, label %463, label %749
463: ; preds = %459
%464 = load i32*, i32** %40
%465 = load i32, i32* %63
%466 = sext i32 %465 to i64
%467 = getelementptr inbounds i32, i32* %464, i64 %466
%468 = load i32, i32* %467
store i32 %468, i32* %67
store i32 0, i32* %64
br label %469
469: ; preds = %742, %463
%470 = load i32, i32* %64
%471 = load i32, i32* %35
%472 = icmp slt i32 %470, %471
br i1 %472, label %473, label %745
473: ; preds = %469
%474 = load i32, i32* %63
%475 = load i32, i32* %35
%476 = mul nsw i32 %474, %475
%477 = load i32, i32* %64
%478 = add nsw i32 %476, %477
store i32 %478, i32* %65
%479 = load i32*, i32** %39
%480 = load i32, i32* %65
%481 = sext i32 %480 to i64
%482 = getelementptr inbounds i32, i32* %479, i64 %481
%483 = load i32, i32* %482
store i32 %483, i32* %91
%484 = load double*, double** %48
%485 = load i32, i32* %67
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds double, double* %484, i64 %486
%488 = load double, double* %487
store double %488, double* %94
%489 = load double, double* %94
store double %489, double* %95
%490 = load i32*, i32** %38
%491 = load i32, i32* %91
%492 = mul nsw i32 %491, 2
%493 = add nsw i32 %492, 1
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds i32, i32* %490, i64 %494
%496 = load i32, i32* %495
%497 = icmp sge i32 %496, 0
br i1 %497, label %498, label %514
498: ; preds = %473
%499 = load double*, double** %48
%500 = load i32*, i32** %40
%501 = load i32*, i32** %38
%502 = load i32, i32* %91
%503 = mul nsw i32 %502, 2
%504 = add nsw i32 %503, 1
%505 = sext i32 %504 to i64
%506 = getelementptr inbounds i32, i32* %501, i64 %505
%507 = load i32, i32* %506
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds i32, i32* %500, i64 %508
%510 = load i32, i32* %509
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds double, double* %499, i64 %511
%513 = load double, double* %512
store double %513, double* %95
br label %514
514: ; preds = %498, %473
%515 = load double, double* %94
%516 = fmul double 2.000000e+00, %515
%517 = load double, double* %95
%518 = fmul double %516, %517
%519 = load double, double* %94
%520 = load double, double* %95
%521 = fadd double %519, %520
%522 = fadd double %521, 0x3AF357C299A88EA7
%523 = fdiv double %518, %522
store double %523, double* %93
store double 0.000000e+00, double* %92
store i32 0, i32* %66
br label %524
524: ; preds = %568, %514
%525 = load i32, i32* %66
%526 = load i32, i32* %36
%527 = icmp slt i32 %525, %526
br i1 %527, label %528, label %571
528: ; preds = %524
%529 = load double, double* %85
%530 = load double, double* %93
%531 = fmul double %529, %530
%532 = load double*, double** %43
%533 = load i32, i32* %66
%534 = sext i32 %533 to i64
%535 = getelementptr inbounds double, double* %532, i64 %534
%536 = load double, double* %535
%537 = load double, double* %41
%538 = load double, double* %93
%539 = fmul double %537, %538
%540 = load double*, double** %50
%541 = load i32, i32* %65
%542 = load i32, i32* %36
%543 = mul nsw i32 %541, %542
%544 = load i32, i32* %66
%545 = add nsw i32 %543, %544
%546 = sext i32 %545 to i64
%547 = getelementptr inbounds double, double* %540, i64 %546
%548 = load double, double* %547
%549 = fmul double %539, %548
%550 = fneg double %549
%551 = call double @llvm.fmuladd.f64(double %531, double %536, double %550)
%552 = load double*, double** %51
%553 = load i32, i32* %91
%554 = load i32, i32* %37
%555 = mul nsw i32 %553, %554
%556 = load i32, i32* %36
%557 = mul nsw i32 %555, %556
%558 = load i32, i32* %36
%559 = mul nsw i32 0, %558
%560 = add nsw i32 %557, %559
%561 = load i32, i32* %66
%562 = add nsw i32 %560, %561
%563 = sext i32 %562 to i64
%564 = getelementptr inbounds double, double* %552, i64 %563
%565 = load double, double* %564
%566 = load double, double* %92
%567 = call double @llvm.fmuladd.f64(double %551, double %565, double %566)
store double %567, double* %92
br label %568
568: ; preds = %528
%569 = load i32, i32* %66
%570 = add nsw i32 %569, 1
store i32 %570, i32* %66
br label %524
571: ; preds = %524
%572 = load double, double* %92
%573 = fcmp oge double %572, 0.000000e+00
br i1 %573, label %583, label %574
574: ; preds = %571
%575 = load i32*, i32** %38
%576 = load i32, i32* %91
%577 = mul nsw i32 %576, 2
%578 = add nsw i32 %577, 1
%579 = sext i32 %578 to i64
%580 = getelementptr inbounds i32, i32* %575, i64 %579
%581 = load i32, i32* %580
%582 = icmp slt i32 %581, 0
br i1 %582, label %583, label %591
583: ; preds = %574, %571
%584 = load i32*, i32** %38
%585 = load i32, i32* %91
%586 = mul nsw i32 %585, 2
%587 = add nsw i32 %586, 0
%588 = sext i32 %587 to i64
%589 = getelementptr inbounds i32, i32* %584, i64 %588
%590 = load i32, i32* %589
store i32 %590, i32* %90
br label %599
591: ; preds = %574
%592 = load i32*, i32** %38
%593 = load i32, i32* %91
%594 = mul nsw i32 %593, 2
%595 = add nsw i32 %594, 1
%596 = sext i32 %595 to i64
%597 = getelementptr inbounds i32, i32* %592, i64 %596
%598 = load i32, i32* %597
store i32 %598, i32* %90
br label %599
599: ; preds = %591, %583
%600 = load double*, double** %61
%601 = load i32, i32* %63
%602 = load i32, i32* %35
%603 = mul nsw i32 %601, %602
%604 = load i32, i32* %68
%605 = mul nsw i32 %603, %604
%606 = load i32, i32* %64
%607 = load i32, i32* %68
%608 = mul nsw i32 %606, %607
%609 = add nsw i32 %605, %608
%610 = load i32, i32* %36
%611 = mul nsw i32 0, %610
%612 = add nsw i32 %609, %611
%613 = add nsw i32 %612, 0
%614 = sext i32 %613 to i64
%615 = getelementptr inbounds double, double* %600, i64 %614
%616 = load double, double* %615
store double %616, double* %96
%617 = load double*, double** %62
%618 = load i32, i32* %63
%619 = load i32, i32* %35
%620 = mul nsw i32 %618, %619
%621 = load i32, i32* %68
%622 = mul nsw i32 %620, %621
%623 = load i32, i32* %64
%624 = load i32, i32* %68
%625 = mul nsw i32 %623, %624
%626 = add nsw i32 %622, %625
%627 = load i32, i32* %36
%628 = mul nsw i32 0, %627
%629 = add nsw i32 %626, %628
%630 = add nsw i32 %629, 0
%631 = sext i32 %630 to i64
%632 = getelementptr inbounds double, double* %617, i64 %631
%633 = load double, double* %632
store double %633, double* %97
%634 = load i32, i32* %32
%635 = icmp sgt i32 %634, 0
br i1 %635, label %636, label %648
636: ; preds = %599
%637 = load double*, double** %57
%638 = load i32, i32* %90
%639 = load i32, i32* %68
%640 = mul nsw i32 %638, %639
%641 = load i32, i32* %36
%642 = mul nsw i32 0, %641
%643 = add nsw i32 %640, %642
%644 = add nsw i32 %643, 0
%645 = sext i32 %644 to i64
%646 = getelementptr inbounds double, double* %637, i64 %645
%647 = load double, double* %646
store double %647, double* %96
br label %648
648: ; preds = %636, %599
store i32 0, i32* %66
br label %649
649: ; preds = %738, %648
%650 = load i32, i32* %66
%651 = load i32, i32* %36
%652 = icmp slt i32 %650, %651
br i1 %652, label %653, label %741
653: ; preds = %649
%654 = load double, double* %85
%655 = load double, double* %96
%656 = fmul double %654, %655
%657 = load double, double* %93
%658 = fmul double %656, %657
%659 = load double*, double** %43
%660 = load i32, i32* %66
%661 = sext i32 %660 to i64
%662 = getelementptr inbounds double, double* %659, i64 %661
%663 = load double, double* %662
%664 = fmul double %658, %663
%665 = load double*, double** %59
%666 = load i32, i32* %65
%667 = load i32, i32* %36
%668 = mul nsw i32 %666, %667
%669 = load i32, i32* %66
%670 = add nsw i32 %668, %669
%671 = sext i32 %670 to i64
%672 = getelementptr inbounds double, double* %665, i64 %671
store double %664, double* %672
%673 = load double, double* %85
%674 = load double, double* %97
%675 = fmul double %673, %674
%676 = load double, double* %93
%677 = fmul double %675, %676
%678 = load double*, double** %43
%679 = load i32, i32* %66
%680 = sext i32 %679 to i64
%681 = getelementptr inbounds double, double* %678, i64 %680
%682 = load double, double* %681
%683 = fmul double %677, %682
%684 = load double*, double** %60
%685 = load i32, i32* %65
%686 = load i32, i32* %36
%687 = mul nsw i32 %685, %686
%688 = load i32, i32* %66
%689 = add nsw i32 %687, %688
%690 = sext i32 %689 to i64
%691 = getelementptr inbounds double, double* %684, i64 %690
store double %683, double* %691
%692 = load double, double* %41
%693 = load double, double* %96
%694 = fmul double %692, %693
%695 = load double, double* %93
%696 = fmul double %694, %695
%697 = load double*, double** %61
%698 = load i32, i32* %63
%699 = load i32, i32* %35
%700 = mul nsw i32 %698, %699
%701 = load i32, i32* %68
%702 = mul nsw i32 %700, %701
%703 = load i32, i32* %64
%704 = load i32, i32* %68
%705 = mul nsw i32 %703, %704
%706 = add nsw i32 %702, %705
%707 = load i32, i32* %66
%708 = load i32, i32* %36
%709 = mul nsw i32 %707, %708
%710 = add nsw i32 %706, %709
%711 = load i32, i32* %66
%712 = add nsw i32 %710, %711
%713 = sext i32 %712 to i64
%714 = getelementptr inbounds double, double* %697, i64 %713
store double %696, double* %714
%715 = load double, double* %41
%716 = load double, double* %97
%717 = fmul double %715, %716
%718 = load double, double* %93
%719 = fmul double %717, %718
%720 = load double*, double** %62
%721 = load i32, i32* %63
%722 = load i32, i32* %35
%723 = mul nsw i32 %721, %722
%724 = load i32, i32* %68
%725 = mul nsw i32 %723, %724
%726 = load i32, i32* %64
%727 = load i32, i32* %68
%728 = mul nsw i32 %726, %727
%729 = add nsw i32 %725, %728
%730 = load i32, i32* %66
%731 = load i32, i32* %36
%732 = mul nsw i32 %730, %731
%733 = add nsw i32 %729, %732
%734 = load i32, i32* %66
%735 = add nsw i32 %733, %734
%736 = sext i32 %735 to i64
%737 = getelementptr inbounds double, double* %720, i64 %736
store double %719, double* %737
br label %738
738: ; preds = %653
%739 = load i32, i32* %66
%740 = add nsw i32 %739, 1
store i32 %740, i32* %66
br label %649
741: ; preds = %649
br label %742
742: ; preds = %741
%743 = load i32, i32* %64
%744 = add nsw i32 %743, 1
store i32 %744, i32* %64
br label %469
745: ; preds = %469
br label %746
746: ; preds = %745
%747 = load i32, i32* %63
%748 = add nsw i32 %747, 1
store i32 %748, i32* %63
br label %459
749: ; preds = %459
ret void
}

LLVM IR (-O2):
define void @conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, i32* nocapture %6, i32* nocapture %7, i32* nocapture %8, double %9, double %10, double* nocapture %11, double* nocapture %12, double* nocapture %13, double* nocapture %14, double* nocapture %15, double* nocapture %16, double* nocapture %17, double* nocapture %18, double* nocapture %19, double* nocapture %20, double* nocapture writeonly %21, double* nocapture writeonly %22, double* nocapture readnone %23, double* nocapture readnone %24, double* nocapture %25, double* nocapture %26, double* nocapture writeonly %27, double* nocapture writeonly %28, double* nocapture %29, double* nocapture %30) {
%32 = mul nsw i32 %4, %4
%33 = fmul double %9, %9
%34 = icmp sgt i32 %0, 0
br i1 %34, label %35, label %37
35: ; preds = %31
%36 = tail call i32 (i32, ...) bitcast (i32 (...)* @assert to i32 (i32, ...)*)(i32 %1)
br label %37
37: ; preds = %35, %31
%38 = icmp sgt i32 %2, 0
br i1 %38, label %39, label %379
39: ; preds = %37
%40 = icmp sgt i32 %3, 0
%41 = icmp eq i32 %1, 0
%42 = sext i32 %3 to i64
%43 = zext i32 %2 to i64
%44 = zext i32 %3 to i64
%45 = zext i32 %3 to i64
%46 = add nsw i64 %44, -1
%47 = and i64 %44, 3
%48 = icmp ult i64 %46, 3
%49 = and i64 %44, 4294967292
%50 = icmp eq i64 %47, 0
br label %66
51: ; preds = %231
br i1 %38, label %52, label %379
52: ; preds = %51
%53 = icmp sgt i32 %3, 0
%54 = icmp sgt i32 %4, 0
%55 = mul i32 %5, %4
%56 = sext i32 %4 to i64
%57 = sext i32 %3 to i64
%58 = zext i32 %2 to i64
%59 = zext i32 %3 to i64
%60 = zext i32 %4 to i64
%61 = zext i32 %4 to i64
%62 = and i64 %60, 1
%63 = icmp eq i32 %4, 1
%64 = and i64 %60, 4294967294
%65 = icmp eq i64 %62, 0
br label %234
66: ; preds = %39, %231
%67 = phi i64 [ 0, %39 ], [ %232, %231 ]
%68 = getelementptr inbounds i32, i32* %8, i64 %67
%69 = load i32, i32* %68
br i1 %40, label %70, label %113
70: ; preds = %66
%71 = mul nsw i64 %67, %42
br i1 %48, label %98, label %72
72: ; preds = %70, %72
%73 = phi i64 [ %95, %72 ], [ 0, %70 ]
%74 = phi double [ %94, %72 ], [ 0.000000e+00, %70 ]
%75 = phi i64 [ %96, %72 ], [ 0, %70 ]
%76 = add nsw i64 %73, %71
%77 = getelementptr inbounds double, double* %20, i64 %76
%78 = load double, double* %77
%79 = fadd double %74, %78
%80 = or i64 %73, 1
%81 = add nsw i64 %80, %71
%82 = getelementptr inbounds double, double* %20, i64 %81
%83 = load double, double* %82
%84 = fadd double %79, %83
%85 = or i64 %73, 2
%86 = add nsw i64 %85, %71
%87 = getelementptr inbounds double, double* %20, i64 %86
%88 = load double, double* %87
%89 = fadd double %84, %88
%90 = or i64 %73, 3
%91 = add nsw i64 %90, %71
%92 = getelementptr inbounds double, double* %20, i64 %91
%93 = load double, double* %92
%94 = fadd double %89, %93
%95 = add nuw nsw i64 %73, 4
%96 = add i64 %75, 4
%97 = icmp eq i64 %96, %49
br i1 %97, label %98, label %72
98: ; preds = %72, %70
%99 = phi double [ undef, %70 ], [ %94, %72 ]
%100 = phi i64 [ 0, %70 ], [ %95, %72 ]
%101 = phi double [ 0.000000e+00, %70 ], [ %94, %72 ]
br i1 %50, label %113, label %102
102: ; preds = %98, %102
%103 = phi i64 [ %110, %102 ], [ %100, %98 ]
%104 = phi double [ %109, %102 ], [ %101, %98 ]
%105 = phi i64 [ %111, %102 ], [ 0, %98 ]
%106 = add nsw i64 %103, %71
%107 = getelementptr inbounds double, double* %20, i64 %106
%108 = load double, double* %107
%109 = fadd double %104, %108
%110 = add nuw nsw i64 %103, 1
%111 = add i64 %105, 1
%112 = icmp eq i64 %111, %47
br i1 %112, label %113, label %102
113: ; preds = %98, %102, %66
%114 = phi double [ 0.000000e+00, %66 ], [ %99, %98 ], [ %109, %102 ]
br i1 %41, label %121, label %115
115: ; preds = %113
%116 = trunc i64 %67 to i32
%117 = mul i32 %32, %116
%118 = zext i32 %117 to i64
%119 = getelementptr inbounds double, double* %25, i64 %118
store double 0.000000e+00, double* %119
%120 = getelementptr inbounds double, double* %26, i64 %118
store double 0.000000e+00, double* %120
br label %121
121: ; preds = %115, %113
br i1 %40, label %122, label %220
122: ; preds = %121
%123 = mul nsw i64 %67, %42
%124 = sext i32 %69 to i64
%125 = getelementptr inbounds double, double* %13, i64 %124
%126 = getelementptr inbounds double, double* %14, i64 %124
%127 = getelementptr inbounds double, double* %15, i64 %124
%128 = getelementptr inbounds double, double* %12, i64 %124
%129 = trunc i64 %67 to i32
%130 = mul i32 %32, %129
%131 = zext i32 %130 to i64
%132 = getelementptr inbounds double, double* %25, i64 %131
%133 = getelementptr inbounds double, double* %26, i64 %131
br label %134
134: ; preds = %122, %217
%135 = phi i64 [ 0, %122 ], [ %218, %217 ]
%136 = add nsw i64 %135, %123
%137 = getelementptr inbounds double, double* %17, i64 %136
%138 = load double, double* %137
%139 = load double, double* %125
%140 = fcmp olt double %138, 0.000000e+00
br i1 %140, label %141, label %183
141: ; preds = %134
%142 = fneg double %138
%143 = fdiv double 1.000000e+00, %139
%144 = fsub double 1.000000e+00, %143
%145 = load double, double* %128
%146 = fmul double %145, %142
%147 = fadd double %139, -2.000000e+00
%148 = tail call double @pow(double %146, double %147)
%149 = fmul double %148, %146
%150 = fmul double %146, %149
%151 = fadd double %150, 1.000000e+00
%152 = fneg double %144
%153 = tail call double @pow(double %151, double %152)
%154 = load double, double* %128
%155 = load double, double* %125
%156 = fsub double 1.000000e+00, %155
%157 = fmul double %154, %156
%158 = fdiv double %153, %151
%159 = fmul double %158, %157
%160 = fmul double %149, %159
%161 = fneg double %149
%162 = tail call double @llvm.fmuladd.f64(double %161, double %153, double 1.000000e+00)
%163 = fmul double %162, %162
%164 = fneg double %154
%165 = fadd double %155, -1.000000e+00
%166 = fmul double %165, %164
%167 = fmul double %148, %166
%168 = fmul double %160, %161
%169 = tail call double @llvm.fmuladd.f64(double %167, double %153, double %168)
%170 = load double, double* %127
%171 = load double, double* %126
%172 = tail call double @llvm.fmuladd.f64(double %170, double %153, double %171)
%173 = fmul double %170, %160
%174 = tail call double @sqrt(double %153)
%175 = fmul double %163, %174
%176 = fdiv double 5.000000e-01, %174
%177 = fmul double %176, %160
%178 = fmul double %174, 2.000000e+00
%179 = fmul double %162, %178
%180 = fmul double %179, %169
%181 = tail call double @llvm.fmuladd.f64(double %177, double %163, double %180)
%182 = load double, double* %137
br label %187
183: ; preds = %134
%184 = load double, double* %126
%185 = load double, double* %127
%186 = fadd double %184, %185
br label %187
187: ; preds = %183, %141
%188 = phi double [ %182, %141 ], [ %138, %183 ]
%189 = phi double [ %181, %141 ], [ 0.000000e+00, %183 ]
%190 = phi double [ %175, %141 ], [ 1.000000e+00, %183 ]
%191 = phi double [ %173, %141 ], [ 0.000000e+00, %183 ]
%192 = phi double [ %172, %141 ], [ %186, %183 ]
%193 = fmul double %188, %10
%194 = tail call double @exp(double %193)
%195 = fmul double %194, %9
%196 = fmul double %195, %10
%197 = fmul double %192, %195
%198 = getelementptr inbounds double, double* %21, i64 %136
store double %197, double* %198
%199 = fneg double %195
%200 = fmul double %192, %196
%201 = tail call double @llvm.fmuladd.f64(double %199, double %191, double %200)
%202 = getelementptr inbounds double, double* %22, i64 %136
store double %201, double* %202
%203 = trunc i64 %136 to i32
%204 = mul i32 %32, %203
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds double, double* %29, i64 %205
store double %190, double* %206
%207 = fneg double %189
%208 = getelementptr inbounds double, double* %30, i64 %205
store double %207, double* %208
br i1 %41, label %217, label %209
209: ; preds = %187
%210 = getelementptr inbounds double, double* %20, i64 %136
%211 = load double, double* %210
%212 = load double, double* %132
%213 = tail call double @llvm.fmuladd.f64(double %190, double %211, double %212)
store double %213, double* %132
%214 = load double, double* %210
%215 = load double, double* %133
%216 = tail call double @llvm.fmuladd.f64(double %207, double %214, double %215)
store double %216, double* %133
br label %217
217: ; preds = %187, %209
%218 = add nuw nsw i64 %135, 1
%219 = icmp eq i64 %218, %45
br i1 %219, label %220, label %134
220: ; preds = %217, %121
br i1 %41, label %231, label %221
221: ; preds = %220
%222 = trunc i64 %67 to i32
%223 = mul i32 %32, %222
%224 = zext i32 %223 to i64
%225 = getelementptr inbounds double, double* %25, i64 %224
%226 = load double, double* %225
%227 = fdiv double %226, %114
store double %227, double* %225
%228 = getelementptr inbounds double, double* %26, i64 %224
%229 = load double, double* %228
%230 = fdiv double %229, %114
store double %230, double* %228
br label %231
231: ; preds = %220, %221
%232 = add nuw nsw i64 %67, 1
%233 = icmp eq i64 %232, %43
br i1 %233, label %51, label %66
234: ; preds = %52, %376
%235 = phi i64 [ 0, %52 ], [ %377, %376 ]
br i1 %53, label %236, label %376
236: ; preds = %234
%237 = getelementptr inbounds i32, i32* %8, i64 %235
%238 = load i32, i32* %237
%239 = mul nsw i64 %235, %57
%240 = sext i32 %238 to i64
%241 = getelementptr inbounds double, double* %16, i64 %240
br label %242
242: ; preds = %236, %373
%243 = phi i64 [ 0, %236 ], [ %374, %373 ]
%244 = add nsw i64 %243, %239
%245 = getelementptr inbounds i32, i32* %7, i64 %244
%246 = load i32, i32* %245
%247 = load double, double* %241
%248 = shl nsw i32 %246, 1
%249 = or i32 %248, 1
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds i32, i32* %6, i64 %250
%252 = load i32, i32* %251
%253 = icmp sgt i32 %252, -1
br i1 %253, label %254, label %261
254: ; preds = %242
%255 = zext i32 %252 to i64
%256 = getelementptr inbounds i32, i32* %8, i64 %255
%257 = load i32, i32* %256
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds double, double* %16, i64 %258
%260 = load double, double* %259
br label %261
261: ; preds = %254, %242
%262 = phi double [ %260, %254 ], [ %247, %242 ]
%263 = fmul double %247, 2.000000e+00
%264 = fmul double %263, %262
%265 = fadd double %247, %262
%266 = fadd double %265, 0x3AF357C299A88EA7
%267 = fdiv double %264, %266
br i1 %54, label %268, label %326
268: ; preds = %261
%269 = fmul double %33, %267
%270 = mul nsw i64 %244, %56
%271 = fneg double %267
%272 = fmul double %271, %9
%273 = mul i32 %55, %246
%274 = sext i32 %273 to i64
br i1 %63, label %305, label %275
275: ; preds = %268, %275
%276 = phi i64 [ %302, %275 ], [ 0, %268 ]
%277 = phi double [ %301, %275 ], [ 0.000000e+00, %268 ]
%278 = phi i64 [ %303, %275 ], [ 0, %268 ]
%279 = getelementptr inbounds double, double* %11, i64 %276
%280 = load double, double* %279
%281 = add nsw i64 %276, %270
%282 = getelementptr inbounds double, double* %18, i64 %281
%283 = load double, double* %282
%284 = fmul double %272, %283
%285 = tail call double @llvm.fmuladd.f64(double %269, double %280, double %284)
%286 = add nsw i64 %276, %274
%287 = getelementptr inbounds double, double* %19, i64 %286
%288 = load double, double* %287
%289 = tail call double @llvm.fmuladd.f64(double %285, double %288, double %277)
%290 = or i64 %276, 1
%291 = getelementptr inbounds double, double* %11, i64 %290
%292 = load double, double* %291
%293 = add nsw i64 %290, %270
%294 = getelementptr inbounds double, double* %18, i64 %293
%295 = load double, double* %294
%296 = fmul double %272, %295
%297 = tail call double @llvm.fmuladd.f64(double %269, double %292, double %296)
%298 = add nsw i64 %290, %274
%299 = getelementptr inbounds double, double* %19, i64 %298
%300 = load double, double* %299
%301 = tail call double @llvm.fmuladd.f64(double %297, double %300, double %289)
%302 = add nuw nsw i64 %276, 2
%303 = add i64 %278, 2
%304 = icmp eq i64 %303, %64
br i1 %304, label %305, label %275
305: ; preds = %275, %268
%306 = phi double [ undef, %268 ], [ %301, %275 ]
%307 = phi i64 [ 0, %268 ], [ %302, %275 ]
%308 = phi double [ 0.000000e+00, %268 ], [ %301, %275 ]
br i1 %65, label %321, label %309
309: ; preds = %305
%310 = getelementptr inbounds double, double* %11, i64 %307
%311 = load double, double* %310
%312 = add nsw i64 %307, %270
%313 = getelementptr inbounds double, double* %18, i64 %312
%314 = load double, double* %313
%315 = fmul double %272, %314
%316 = tail call double @llvm.fmuladd.f64(double %269, double %311, double %315)
%317 = add nsw i64 %307, %274
%318 = getelementptr inbounds double, double* %19, i64 %317
%319 = load double, double* %318
%320 = tail call double @llvm.fmuladd.f64(double %316, double %319, double %308)
br label %321
321: ; preds = %305, %309
%322 = phi double [ %306, %305 ], [ %320, %309 ]
%323 = fcmp oge double %322, 0.000000e+00
%324 = icmp slt i32 %252, 0
%325 = select i1 %323, i1 true, i1 %324
br i1 %325, label %326, label %330
326: ; preds = %261, %321
%327 = sext i32 %248 to i64
%328 = getelementptr inbounds i32, i32* %6, i64 %327
%329 = load i32, i32* %328
br label %330
330: ; preds = %321, %326
%331 = phi i32 [ %329, %326 ], [ %252, %321 ]
%332 = trunc i64 %244 to i32
%333 = mul i32 %32, %332
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds double, double* %29, i64 %334
%336 = getelementptr inbounds double, double* %30, i64 %334
%337 = load double, double* %336
%338 = mul nsw i32 %331, %32
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds double, double* %25, i64 %339
%341 = select i1 %34, double* %340, double* %335
%342 = load double, double* %341
br i1 %54, label %343, label %373
343: ; preds = %330
%344 = fmul double %33, %342
%345 = fmul double %267, %344
%346 = mul nsw i64 %244, %56
%347 = fmul double %33, %337
%348 = fmul double %267, %347
%349 = fmul double %342, %9
%350 = fmul double %267, %349
%351 = fmul double %337, %9
%352 = fmul double %267, %351
br label %353
353: ; preds = %343, %353
%354 = phi i64 [ 0, %343 ], [ %371, %353 ]
%355 = getelementptr inbounds double, double* %11, i64 %354
%356 = load double, double* %355
%357 = fmul double %345, %356
%358 = add nsw i64 %354, %346
%359 = getelementptr inbounds double, double* %27, i64 %358
store double %357, double* %359
%360 = load double, double* %355
%361 = fmul double %348, %360
%362 = getelementptr inbounds double, double* %28, i64 %358
store double %361, double* %362
%363 = trunc i64 %354 to i32
%364 = add i32 %333, %363
%365 = trunc i64 %354 to i32
%366 = mul i32 %365, %4
%367 = add i32 %364, %366
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds double, double* %29, i64 %368
store double %350, double* %369
%370 = getelementptr inbounds double, double* %30, i64 %368
store double %352, double* %370
%371 = add nuw nsw i64 %354, 1
%372 = icmp eq i64 %371, %61
br i1 %372, label %373, label %353
373: ; preds = %353, %330
%374 = add nuw nsw i64 %243, 1
%375 = icmp eq i64 %374, %59
br i1 %375, label %376, label %242
376: ; preds = %373, %234
%377 = add nuw nsw i64 %235, 1
%378 = icmp eq i64 %377, %58
br i1 %378, label %379, label %234
379: ; preds = %376, %37, %51
ret void
}