void conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd(
    const int upwindFlag, const int computeAverages, const int nSimplex,
    const int nPointsPerSimplex, const int nSpace,
    const int nQuadraturePoints_elementBoundary, const int *rowptr,
    const int *colind, 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, J, nnz;
  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;
  nnz = rowptr[nSpace];
  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;
      J = rowptr[0];
      a[i * nPointsPerSimplex * nnz + j * nnz + J] = KWr;
      da[i * nPointsPerSimplex * nnz + j * nnz + J] = -DKWr_DpsiC;
      if (computeAverages) {
        a_avg[i * nnz + J] += KWr * dV[k];
        da_avg[i * nnz + J] += -DKWr_DpsiC * dV[k];
      }
    }
    if (computeAverages) {
      a_avg[i * nnz + J] /= vol;
      da_avg[i * nnz + J] /= 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];
      J = rowptr[0];
      krw_val = a[i * nPointsPerSimplex * nnz + j * nnz + J];
      dkrw_val = da[i * nPointsPerSimplex * nnz + j * nnz + J];
      if (upwindFlag > 0) {
        krw_val = a_avg[eN_upwind * nnz + J];
      }
      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];
        for (J = rowptr[I]; J < rowptr[I + 1]; J++) {
          if (colind[J] == I) {
            a[i * nPointsPerSimplex * nnz + j * nnz + J] =
                rho * krw_val * KWs_harm;
            da[i * nPointsPerSimplex * nnz + j * nnz + J] =
                rho * dkrw_val * KWs_harm;
          } else {
            a[i * nPointsPerSimplex * nnz + j * nnz + J] = 0.0;
            da[i * nPointsPerSimplex * nnz + j * nnz + J] = 0.0;
          }
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%rsp
mov    0xd0(%rbp),%rax
mov    0xc8(%rbp),%rax
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,-0x48(%rbp)
movsd  -0x20(%rbp),%xmm0
mulsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x4(%rbp)
jle    122c <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xec>
mov    -0x8(%rbp),%edi
mov    $0x0,%al
call   1030 <assert@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    18a1 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x761>
mov    0x30(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12a2 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x162>
mov    0x80(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    125f <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x11f>
cmpl   $0x0,-0x8(%rbp)
je     12f0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x1b0>
mov    0xa8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x48(%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    0xb0(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x48(%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    1830 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x6f0>
mov    -0x2c(%rbp),%eax
imul   -0x10(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    0x68(%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,-0x50(%rbp)
mov    0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  0xcc7(%rip),%xmm1
divsd  (%rax,%rcx,8),%xmm1
movsd  0xcba(%rip),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    160f <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x4cf>
mov    0x40(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xc41(%rip),%xmm2
subsd  %xmm2,%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0xc15(%rip),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  -0xf0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0x80(%rbp)
mov    0x40(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  0xbc0(%rip),%xmm1
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  -0x80(%rbp),%xmm1
divsd  -0x78(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0xb6f(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    0x40(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xb12(%rip),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x80(%rbp),%xmm2
mov    0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0xa56(%rip),%xmm0
divsd  -0x88(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  0xa26(%rip),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
mulsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    1645 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x505>
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0x9de(%rip),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
mov    0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
call   1040 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x138(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
mulsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
mov    0x88(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm1
ff
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x90(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x40(%rbp)
movsd  -0xc0(%rbp),%xmm0
ff
mov    0xc8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
imul   -0x44(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0xd0(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
imul   -0x44(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x8(%rbp)
je     181d <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x6dd>
movsd  -0xc0(%rbp),%xmm0
ff
mov    0x80(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0xa8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x80(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0xb0(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1822 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x6e2>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12f7 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x1b7>
cmpl   $0x0,-0x8(%rbp)
je     188e <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x74e>
movsd  -0x130(%rbp),%xmm1
ff
mov    0xa8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm1
ff
mov    0xb0(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1893 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x753>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1233 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xf3>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1d50 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xc10>
mov    0x30(%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    1d3d <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xbfd>
mov    -0x2c(%rbp),%eax
imul   -0x10(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xf8(%rbp)
mov    0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
mov    0x20(%rbp),%rax
mov    -0xf8(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jl     1965 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x825>
mov    0x60(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    0x20(%rbp),%rdx
mov    -0xf8(%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,-0x118(%rbp)
ff
movsd  0x69b(%rip),%xmm0
mulsd  -0x110(%rbp),%xmm0
ff
mulsd  -0x118(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm1
ff
addsd  -0x118(%rbp),%xmm1
ff
movsd  0x66b(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1a6b <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x92b>
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0x108(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x20(%rbp),%xmm1
mulsd  -0x108(%rbp),%xmm1
ff
mov    0x70(%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    0x78(%rbp),%rax
mov    -0xf8(%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  -0x100(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    19b7 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x877>
movsd  -0x100(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jae    1a9d <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x95d>
mov    0x20(%rbp),%rax
mov    -0xf8(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jge    1abe <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x97e>
mov    0x20(%rbp),%rax
mov    -0xf8(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xf4(%rbp)
jmp    1ada <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x99a>
mov    0x20(%rbp),%rax
mov    -0xf8(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xf4(%rbp)
mov    0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x40(%rbp)
mov    0xc8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
imul   -0x44(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    0xd0(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
imul   -0x44(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
cmpl   $0x0,-0x4(%rbp)
jle    1b6d <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xa2d>
mov    0xa8(%rbp),%rax
mov    -0xf4(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1d2a <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xbea>
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0x120(%rbp),%xmm0
ff
mulsd  -0x108(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0xb8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0x128(%rbp),%xmm0
ff
mulsd  -0x108(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0xc0(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    0x10(%rbp),%rcx
mov    -0x38(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1d17 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xbd7>
mov    0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x38(%rbp),%eax
jne    1cb2 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xb72>
movsd  -0x20(%rbp),%xmm0
mulsd  -0x120(%rbp),%xmm0
ff
mulsd  -0x108(%rbp),%xmm0
ff
mov    0xc8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
imul   -0x44(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x20(%rbp),%xmm0
mulsd  -0x128(%rbp),%xmm0
ff
mulsd  -0x108(%rbp),%xmm0
ff
mov    0xd0(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
imul   -0x44(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1d04 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xbc4>
mov    0xc8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
imul   -0x44(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0xd0(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
imul   -0x44(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1d09 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xbc9>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1c0a <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xaca>
jmp    1d1c <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xbdc>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1b74 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xa34>
jmp    1d2f <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xbef>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    18c9 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x789>
jmp    1d42 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xc02>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    18a8 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x768>
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
movsd  %xmm1,0x98(%rsp)
movsd  %xmm0,0x90(%rsp)
mov    %r9d,0x1c(%rsp)
mov    %r8d,%r15d
mov    %ecx,0x4(%rsp)
mov    %edx,%ebx
mov    %esi,%r8d
mov    0x170(%rsp),%rax
movslq %r15d,%rcx
mov    %rcx,0xb0(%rsp)
movslq (%rax,%rcx,4),%r12
mov    %edi,0xd4(%rsp)
test   %edi,%edi
mov    %esi,0x78(%rsp)
jle    11a9 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x69>
mov    %r8d,%edi
xor    %eax,%eax
call   1030 <assert@plt>
mov    0x78(%rsp),%r8d
test   %ebx,%ebx
jle    1cfe <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xbbe>
mov    0x1f0(%rsp),%rax
mov    %rax,0x88(%rsp)
mov    0x1e8(%rsp),%rax
mov    %rax,0x80(%rsp)
mov    0x1e0(%rsp),%rsi
mov    %r15d,%eax
imul   %r15d,%eax
mov    %eax,0xcc(%rsp)
movsd  0x90(%rsp),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0xf0(%rsp)
mov    0x4(%rsp),%eax
movslq %eax,%rcx
mov    %ecx,%edx
mov    %edx,%edi
and    $0x3,%edi
mov    %edx,%ebp
and    $0xfffffffc,%ebp
mov    %rbp,0x110(%rsp)
mov    %r12d,%ebp
imul   %eax,%ebp
mov    %ebp,0xd0(%rsp)
xorpd  %xmm1,%xmm1
mov    0x1c8(%rsp),%rax
mov    %rax,0x28(%rsp)
mov    0x178(%rsp),%r13
mov    %ebx,0xc8(%rsp)
mov    %ebx,%eax
mov    %rax,0xe0(%rsp)
mov    %rdx,0xf8(%rsp)
lea    -0x1(%rdx),%rax
mov    %rax,0x118(%rsp)
mov    %rsi,0x8(%rsp)
lea    0x18(%rsi),%rbp
mov    %rcx,0xd8(%rsp)
lea    0x0(,%rcx,8),%rax
mov    %rax,0x120(%rsp)
xor    %eax,%eax
mov    %rax,0xa0(%rsp)
xor    %ebx,%ebx
mov    %r15d,0x3c(%rsp)
mov    %r12,0xc0(%rsp)
mov    %rdi,0x128(%rsp)
jmp    1323 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x1e3>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
mov    0x130(%rsp),%rbp
mov    0x120(%rsp),%rcx
add    %rcx,%rbp
add    %rcx,0x8(%rsp)
mov    0xa0(%rsp),%rdx
add    0xd0(%rsp),%edx
mov    %rdx,0xa0(%rsp)
add    %rcx,0x28(%rsp)
add    %rcx,0x80(%rsp)
add    %rcx,0x88(%rsp)
cmp    0xe0(%rsp),%rbx
mov    0x1c0(%rsp),%rsi
mov    0x198(%rsp),%rdx
mov    0x3c(%rsp),%r15d
mov    0x128(%rsp),%rdi
je     17ff <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x6bf>
xorpd  %xmm2,%xmm2
cmpl   $0x0,0x4(%rsp)
jle    13ae <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x26e>
cmpq   $0x3,0x118(%rsp)
jae    1350 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x210>
xorpd  %xmm2,%xmm2
xor    %ecx,%ecx
jmp    1381 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x241>
cs nopw 0x0(%rax,%rax,1)
nop
xorpd  %xmm2,%xmm2
xor    %ecx,%ecx
mov    0x110(%rsp),%rdx
xchg   %ax,%ax
addsd  -0x18(%rbp,%rcx,8),%xmm2
addsd  -0x10(%rbp,%rcx,8),%xmm2
addsd  -0x8(%rbp,%rcx,8),%xmm2
addsd  0x0(%rbp,%rcx,8),%xmm2
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1360 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x220>
test   %rdi,%rdi
je     13ae <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x26e>
mov    0x8(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addsd  (%rcx,%rdx,8),%xmm2
add    $0x1,%rdx
cmp    %rdx,%rdi
jne    13a0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x260>
mov    %rbp,0x130(%rsp)
mov    0x190(%rsp),%rcx
movslq (%rcx,%rbx,4),%r15
test   %r8d,%r8d
je     13f1 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x2b1>
mov    0xcc(%rsp),%ecx
imul   %ebx,%ecx
mov    0x208(%rsp),%rdx
movq   $0x0,(%rdx,%rcx,8)
mov    0x210(%rsp),%rdx
movq   $0x0,(%rdx,%rcx,8)
mov    %rbx,0xe8(%rsp)
cmpl   $0x0,0x4(%rsp)
jle    17b0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x670>
mov    0xe8(%rsp),%rax
imul   %r12,%rax
mov    %rax,0x20(%rsp)
mov    0xa0(%rsp),%rbp
xor    %ebx,%ebx
movsd  %xmm2,0xb8(%rsp)
jmp    1452 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x312>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
add    %r12d,%ebp
cmp    %rbx,0xf8(%rsp)
xorpd  %xmm1,%xmm1
movsd  0xb8(%rsp),%xmm2
je     17b0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x670>
mov    0x28(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm2
ucomisd %xmm2,%xmm1
jbe    1560 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x420>
mov    0x1a8(%rsp),%r14
movsd  (%r14,%r15,8),%xmm1
movapd 0xbb4(%rip),%xmm0
xorpd  %xmm0,%xmm2
movsd  0xb80(%rip),%xmm3
divsd  %xmm1,%xmm3
movsd  0xb6c(%rip),%xmm0
addsd  %xmm0,%xmm3
movapd %xmm3,0x50(%rsp)
mov    0x1a0(%rsp),%r12
mulsd  (%r12,%r15,8),%xmm2
movapd %xmm2,0x40(%rsp)
addsd  0xb56(%rip),%xmm1
movapd %xmm2,%xmm0
call   1050 <pow@plt>
movsd  %xmm0,0x10(%rsp)
movapd 0x40(%rsp),%xmm2
mulsd  %xmm2,%xmm0
movsd  %xmm0,0x70(%rsp)
mulsd  %xmm0,%xmm2
addsd  0xb1b(%rip),%xmm2
movapd 0x50(%rsp),%xmm1
xorpd  0xb3d(%rip),%xmm1
movapd %xmm2,0x40(%rsp)
movapd %xmm2,%xmm0
call   1050 <pow@plt>
xorpd  %xmm1,%xmm1
movapd %xmm0,%xmm10
movsd  (%r12,%r15,8),%xmm9
movsd  (%r14,%r15,8),%xmm4
mov    0x1b8(%rsp),%rax
movsd  (%rax,%r15,8),%xmm8
movapd %xmm8,%xmm0
mulsd  %xmm10,%xmm0
mov    0x1b0(%rsp),%rax
addsd  (%rax,%r15,8),%xmm0
ucomisd %xmm1,%xmm10
movsd  %xmm0,0x30(%rsp)
jb     15b0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x470>
xorps  %xmm0,%xmm0
sqrtsd %xmm10,%xmm0
jmp    15fc <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x4bc>
nopw   0x0(%rax,%rax,1)
mov    0x1b0(%rsp),%rax
movsd  (%rax,%r15,8),%xmm0
mov    0x1b8(%rsp),%rax
addsd  (%rax,%r15,8),%xmm0
movsd  %xmm0,0x30(%rsp)
xorpd  %xmm0,%xmm0
movapd %xmm0,0x40(%rsp)
movsd  0xa6c(%rip),%xmm0
movsd  %xmm0,0x10(%rsp)
xorpd  %xmm0,%xmm0
movapd %xmm0,0x50(%rsp)
jmp    16c2 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x582>
nopl   0x0(%rax)
movapd %xmm10,%xmm0
movapd %xmm8,0x50(%rsp)
movsd  %xmm10,0x68(%rsp)
movapd %xmm9,0x100(%rsp)
movsd  %xmm4,0xa8(%rsp)
call   1060 <sqrt@plt>
movsd  0xa8(%rsp),%xmm4
movapd 0x100(%rsp),%xmm9
movsd  0x68(%rsp),%xmm10
movapd 0x50(%rsp),%xmm8
mov    0xc0(%rsp),%r12
movsd  0x10(%rsp),%xmm5
movapd 0x40(%rsp),%xmm6
movsd  0x70(%rsp),%xmm7
movsd  0x9e2(%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,0x50(%rsp)
movsd  0x9c8(%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  0x9b6(%rip),%xmm9
addsd  0x986(%rip),%xmm4
mulsd  %xmm9,%xmm4
mulsd  %xmm4,%xmm5
mulsd  %xmm10,%xmm5
subsd  %xmm1,%xmm5
mulsd  %xmm3,%xmm6
mulsd  %xmm0,%xmm3
movsd  %xmm3,0x10(%rsp)
addsd  %xmm0,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm0,%xmm6
movapd %xmm6,0x40(%rsp)
mov    0x28(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm2
mulsd  0x98(%rsp),%xmm2
movapd %xmm2,%xmm0
call   1040 <exp@plt>
mulsd  0x90(%rsp),%xmm0
movapd %xmm0,%xmm1
mulsd  0x98(%rsp),%xmm1
movsd  0x30(%rsp),%xmm3
movapd %xmm3,%xmm2
mulsd  %xmm0,%xmm2
mov    0x80(%rsp),%rax
movsd  %xmm2,(%rax,%rbx,8)
mulsd  %xmm3,%xmm1
mulsd  0x50(%rsp),%xmm0
subsd  %xmm0,%xmm1
mov    0x88(%rsp),%rax
movsd  %xmm1,(%rax,%rbx,8)
mov    0x170(%rsp),%rax
mov    (%rax),%eax
lea    0x0(%rbp,%rax,1),%ecx
movslq %ecx,%rcx
mov    0x228(%rsp),%rdx
movsd  0x10(%rsp),%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
movapd 0x40(%rsp),%xmm0
xorpd  0x8de(%rip),%xmm0
mov    0x230(%rsp),%rdx
movlpd %xmm0,(%rdx,%rcx,8)
mov    0x78(%rsp),%r8d
test   %r8d,%r8d
je     1430 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x2f0>
movslq %eax,%rcx
add    0x20(%rsp),%rcx
mov    0x8(%rsp),%rsi
mulsd  (%rsi,%rbx,8),%xmm1
mov    0x208(%rsp),%rdx
addsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
mulsd  (%rsi,%rbx,8),%xmm0
mov    0x210(%rsp),%rdx
addsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
jmp    1430 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x2f0>
nopl   (%rax)
test   %r8d,%r8d
mov    0xe8(%rsp),%rbx
je     12b0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x170>
mov    %rbx,%rcx
imul   %r12,%rcx
movslq %eax,%rdx
add    %rcx,%rdx
mov    0x208(%rsp),%rcx
movsd  (%rcx,%rdx,8),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mov    0x210(%rsp),%rcx
movsd  (%rcx,%rdx,8),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
jmp    12b0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x170>
cmpl   $0x0,0xc8(%rsp)
jle    1cfe <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xbbe>
mov    0x1c(%rsp),%eax
imul   %r15d,%eax
mov    %eax,0x1c(%rsp)
mov    %r15d,%eax
mov    %rax,0x50(%rsp)
and    $0xfffffffe,%eax
mov    %rax,0x78(%rsp)
mov    0x1d0(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x68(%rsp)
mov    0xb0(%rsp),%rcx
mov    %rcx,%rax
imul   0xd8(%rsp),%rax
shl    $0x3,%rax
mov    %rax,0x100(%rsp)
lea    0x0(,%rcx,8),%rax
mov    %rax,0x88(%rsp)
mov    0x1d8(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x70(%rsp)
mov    0x230(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x80(%rsp)
mov    %r12d,%eax
imul   0x4(%rsp),%eax
mov    %eax,0xa8(%rsp)
mov    0x228(%rsp),%rax
add    $0x8,%rax
mov    %rax,0xb8(%rsp)
xor    %eax,%eax
mov    %rax,0x8(%rsp)
movsd  0x75f(%rip),%xmm0
xorpd  %xmm1,%xmm1
xor    %eax,%eax
mov    %rax,0x20(%rsp)
jmp    190d <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x7cd>
xchg   %ax,%ax
mov    0x20(%rsp),%rcx
add    $0x1,%rcx
mov    0x100(%rsp),%rax
add    %rax,0x68(%rsp)
mov    0x8(%rsp),%rax
add    0xa8(%rsp),%eax
mov    %rax,0x8(%rsp)
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
cmp    0xe0(%rsp),%rcx
je     1cfe <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xbbe>
cmpl   $0x0,0x4(%rsp)
jle    18d0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x790>
mov    0x190(%rsp),%rax
mov    0x20(%rsp),%rcx
movslq (%rax,%rcx,4),%rax
mov    %rax,0x10(%rsp)
imul   0xd8(%rsp),%rcx
mov    %rcx,0x28(%rsp)
mov    0x170(%rsp),%rcx
mov    (%rcx),%eax
mov    %rax,0x30(%rsp)
mov    0x8(%rsp),%rax
mov    %eax,0x40(%rsp)
mov    0x68(%rsp),%r9
xor    %ecx,%ecx
jmp    199c <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x85c>
nopl   0x0(%rax)
mov    0x98(%rsp),%rcx
add    $0x1,%rcx
add    0x88(%rsp),%r9
mov    0xc0(%rsp),%r12
add    %r12d,0x40(%rsp)
cmp    0xf8(%rsp),%rcx
mov    0x3c(%rsp),%r15d
mov    0x1c0(%rsp),%rsi
je     18d0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x790>
mov    0x28(%rsp),%rax
mov    %rcx,0x98(%rsp)
lea    (%rcx,%rax,1),%r14
mov    0x188(%rsp),%rax
movslq (%rax,%r14,4),%rbp
mov    0x10(%rsp),%rax
movsd  (%rsi,%rax,8),%xmm3
mov    0x180(%rsp),%rax
mov    0x4(%rax,%rbp,8),%ebx
movapd %xmm3,%xmm4
test   %ebx,%ebx
js     19e8 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x8a8>
mov    0x190(%rsp),%rax
movslq (%rax,%rbx,4),%rcx
movsd  (%rsi,%rcx,8),%xmm4
movapd %xmm3,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm4,%xmm3
addsd  %xmm0,%xmm3
divsd  %xmm3,%xmm2
test   %r15d,%r15d
jle    1b07 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x9c7>
mov    0x1c(%rsp),%ecx
imul   %ebp,%ecx
movsd  0xf0(%rsp),%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm2,%xmm4
xorpd  0x607(%rip),%xmm4
mulsd  0x90(%rsp),%xmm4
movslq %ecx,%r8
cmp    $0x1,%r15d
jne    1a50 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x910>
xorpd  %xmm5,%xmm5
xor    %edi,%edi
jmp    1abc <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x97c>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x70(%rsp),%rax
lea    (%rax,%r8,8),%rsi
xorpd  %xmm5,%xmm5
xor    %edi,%edi
mov    0x78(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%r9,%rdi,8),%xmm6
mulsd  %xmm4,%xmm6
movsd  (%rdx,%rdi,8),%xmm7
mulsd  %xmm3,%xmm7
addsd  %xmm6,%xmm7
mulsd  -0x8(%rsi,%rdi,8),%xmm7
addsd  %xmm5,%xmm7
movsd  (%r9,%rdi,8),%xmm6
mulsd  %xmm4,%xmm6
movsd  0x8(%rdx,%rdi,8),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm6,%xmm5
mulsd  (%rsi,%rdi,8),%xmm5
addsd  %xmm7,%xmm5
add    $0x2,%rdi
cmp    %rdi,%rax
jne    1a70 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x930>
testb  $0x1,0x50(%rsp)
je     1afd <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x9bd>
mov    %r14,%rcx
imul   0xb0(%rsp),%rcx
add    %rdi,%rcx
mov    0x1d0(%rsp),%rax
mulsd  (%rax,%rcx,8),%xmm4
mulsd  (%rdx,%rdi,8),%xmm3
addsd  %xmm4,%xmm3
add    %rdi,%r8
mov    0x1d8(%rsp),%rax
mulsd  (%rax,%r8,8),%xmm3
addsd  %xmm3,%xmm5
ucomisd %xmm1,%xmm5
jae    1b07 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x9c7>
test   %ebx,%ebx
jns    1b18 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x9d8>
add    %rbp,%rbp
movslq %ebp,%rcx
mov    0x180(%rsp),%rax
mov    (%rax,%rcx,4),%ebx
mov    %r14d,%edi
imul   %r12d,%edi
mov    0x30(%rsp),%rax
lea    (%rax,%rdi,1),%ecx
imul   %r12d,%ebx
add    %eax,%ebx
cmpl   $0x0,0xd4(%rsp)
movslq %ecx,%rcx
mov    0x228(%rsp),%rax
lea    (%rax,%rcx,8),%rbp
movslq %ebx,%rsi
mov    0x208(%rsp),%rax
lea    (%rax,%rsi,8),%rsi
cmovle %rbp,%rsi
test   %r15d,%r15d
jle    1960 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x820>
movslq 0x40(%rsp),%rbp
mov    0x80(%rsp),%rax
lea    (%rax,%rbp,8),%rbx
mov    0xb8(%rsp),%rax
lea    (%rax,%rbp,8),%rbp
mov    0x230(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm3
movsd  (%rsi),%xmm4
movsd  0xf0(%rsp),%xmm6
movapd %xmm6,%xmm5
mulsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
imul   0xb0(%rsp),%r14
mulsd  %xmm3,%xmm6
mulsd  %xmm2,%xmm6
movsd  0x90(%rsp),%xmm7
mulsd  %xmm7,%xmm4
mulsd  %xmm2,%xmm4
mulsd  %xmm7,%xmm3
mulsd  %xmm2,%xmm3
movslq %edi,%rax
mov    0x30(%rsp),%rcx
mov    %ecx,%r10d
xor    %r11d,%r11d
jmp    1bf3 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xab3>
nopl   (%rax)
cmp    0x50(%rsp),%r11
mov    0x198(%rsp),%rdx
je     1960 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0x820>
mov    %r11,%r8
mov    %r10d,%ecx
movsd  (%rdx,%r11,8),%xmm2
mulsd  %xmm5,%xmm2
lea    (%r11,%r14,1),%rsi
mov    0x218(%rsp),%rdi
movsd  %xmm2,(%rdi,%rsi,8)
movsd  (%rdx,%r11,8),%xmm2
mulsd  %xmm6,%xmm2
mov    0x220(%rsp),%rdi
movsd  %xmm2,(%rdi,%rsi,8)
add    $0x1,%r11
mov    0x170(%rsp),%rsi
mov    0x4(%rsi,%r8,4),%r10d
cmp    %r10d,%ecx
jge    1be0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xaa0>
movslq %ecx,%rsi
mov    %r10d,%edi
sub    %ecx,%edi
mov    %rsi,%r12
test   $0x1,%dil
je     1c8e <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xb4e>
mov    0x0(%r13,%rsi,4),%edi
lea    (%rsi,%rax,1),%rcx
movapd %xmm4,%xmm2
movapd %xmm3,%xmm7
cmp    %rdi,%r8
je     1c70 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xb30>
xorpd  %xmm2,%xmm2
xorpd  %xmm7,%xmm7
mov    0x228(%rsp),%rdi
movsd  %xmm2,(%rdi,%rcx,8)
mov    0x230(%rsp),%rdi
movsd  %xmm7,(%rdi,%rcx,8)
lea    0x1(%rsi),%r12
movslq %r10d,%r15
not    %rsi
add    %r15,%rsi
jne    1cba <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xb7a>
jmp    1be0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xaa0>
xchg   %ax,%ax
movsd  %xmm2,0x0(%rbp,%r12,8)
movsd  %xmm7,(%rbx,%r12,8)
add    $0x2,%r12
cmp    %r12,%r15
je     1be0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xaa0>
mov    0x0(%r13,%r12,4),%ecx
movapd %xmm4,%xmm2
movapd %xmm3,%xmm7
cmp    %rcx,%r8
je     1cd4 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xb94>
xorpd  %xmm2,%xmm2
xorpd  %xmm7,%xmm7
movsd  %xmm2,-0x8(%rbp,%r12,8)
movsd  %xmm7,-0x8(%rbx,%r12,8)
mov    0x4(%r13,%r12,4),%ecx
movapd %xmm4,%xmm2
movapd %xmm3,%xmm7
cmp    %rcx,%r8
je     1ca0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xb60>
xorpd  %xmm2,%xmm2
xorpd  %xmm7,%xmm7
jmp    1ca0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwindAndHarm_sd+0xb60>
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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