void conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind(
    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, KW, DKW_DpsiC, rho2 = rho * rho, thetaS, rhom, drhom, m;
  int eN_upwind, ebN_global;
  register double drive, avgfI, avgdfI, avgaII, avgdaII, vol;
  for (i = 0; i < nSimplex; i++) {
    matID = materialTypes[i];
    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);
        KW = KWs[matID] * sqrt_sBar * vBar2;
        DKW_DpsiC = KWs[matID] * ((0.5 / sqrt_sBar) * DsBar_DpsiC * vBar2 +
                                  2.0 * sqrt_sBar * vBar * DvBar_DpsiC);
      } else {
        thetaW = thetaS;
        DthetaW_DpsiC = 0.0;
        KW = KWs[matID];
        DKW_DpsiC = 0.0;
      }
      rhom = rho * exp(beta * u[k]);
      drhom = beta * rhom;
      mass[k] = rhom * thetaW;
      dmass[k] = -rhom * DthetaW_DpsiC + drhom * thetaW;
      for (I = 0; I < nSpace; I++) {
        f[k * nSpace + I] = rho2 * KW * gravity[I];
        df[k * nSpace + I] = -rho2 * DKW_DpsiC * gravity[I];
        a[i * nPointsPerSimplex * nSpace2 + j * nSpace2 + I * nSpace + I] =
            rho * KW;
        da[i * nPointsPerSimplex * nSpace2 + j * nSpace2 + I * nSpace + I] =
            -rho * DKW_DpsiC;
      }
    }
  }
  if (upwindFlag == 1 || upwindFlag == 2) {
    if (computeAverages == 1) {
      for (i = 0; i < nSimplex; i++) {
        matID = materialTypes[i];
        vol = 0.0;
        for (j = 0; j < nPointsPerSimplex; j++)
          vol += dV[i * nPointsPerSimplex + j];
        for (I = 0; I < nSpace; I++) {
          avgaII = 0.0;
          avgfI = 0.0;
          avgdaII = 0.0;
          avgdfI = 0.0;
          for (j = 0; j < nPointsPerSimplex; j++) {
            k = i * nPointsPerSimplex + j;
            avgfI += f[k * nSpace + I] * dV[k];
            avgdfI += df[k * nSpace + I] * dV[k];
            avgaII += a[i * nPointsPerSimplex * nSpace2 + j * nSpace2 +
                        I * nSpace + I] *
                      dV[k];
            avgdaII += da[i * nPointsPerSimplex * nSpace2 + j * nSpace2 +
                          I * nSpace + I] *
                       dV[k];
          }
          avgfI /= vol;
          avgdfI /= vol;
          avgaII /= vol;
          avgdaII /= vol;
          f_avg[i * nSpace + I] = avgfI;
          df_avg[i * nSpace + I] = avgdfI;
          a_avg[i * nSpace2 + I * nSpace + I] = avgaII;
          da_avg[i * nSpace2 + I * nSpace + I] = avgdaII;
        }
      }
    }
    for (i = 0; i < nSimplex; i++) {
      matID = materialTypes[i];
      for (j = 0; j < nPointsPerSimplex; j++) {
        k = i * nPointsPerSimplex + j;
        ebN_global = quadraturePointToElementBoundary[k];
        drive = 0.0;
        for (I = 0; I < nSpace; I++) {
          drive +=
              (rho2 * KWs[matID] * gravity[I] -
               rho * KWs[matID] * 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];
        for (I = 0; I < nSpace; I++) {
          f[k * nSpace + I] = f_avg[eN_upwind * nSpace + I];
          a[i * nPointsPerSimplex * nSpace2 + j * nSpace2 + I * nSpace + I] =
              a_avg[eN_upwind * nSpace2 + I * nSpace + I];
        }
        if (upwindFlag == 2) {
          for (I = 0; I < nSpace; I++) {
            df[k * nSpace + I] = df_avg[eN_upwind * nSpace + I];
            da[i * nPointsPerSimplex * nSpace2 + j * nSpace2 + I * nSpace + I] =
                da_avg[eN_upwind * nSpace2 + I * nSpace + I];
          }
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind>:
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
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    178e <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x65e>
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    177b <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x64b>
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  0xd9a(%rip),%xmm1
divsd  (%rax,%rcx,8),%xmm1
movsd  0xd8d(%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    153e <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x40e>
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  0xd24(%rip),%xmm2
subsd  %xmm2,%xmm1
call   1040 <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  0xce8(%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   1040 <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  0xc93(%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  0xc42(%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  0xbe5(%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   1050 <sqrt@plt>
movsd  %xmm0,-0x80(%rbp)
mov    0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x80(%rbp),%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xb1d(%rip),%xmm1
divsd  -0x80(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm3
ff
movsd  0xaf8(%rip),%xmm2
mulsd  -0x80(%rbp),%xmm2
mulsd  -0xa0(%rbp),%xmm2
ff
mulsd  -0xb0(%rbp),%xmm2
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    1579 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x449>
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x128(%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)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1768 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x638>
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0xb8(%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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0xc0(%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  -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
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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0xc0(%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    163c <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x50c>
jmp    176d <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x63d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1214 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xe4>
jmp    1780 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x650>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11f3 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xc3>
cmpl   $0x1,-0x4(%rbp)
je     17a2 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x672>
cmpl   $0x2,-0x4(%rbp)
jne    1dfb <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xccb>
cmpl   $0x1,-0x8(%rbp)
jne    1adc <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x9ac>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1ad7 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x9a7>
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    181f <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x6ef>
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  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    17df <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x6af>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1ac4 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x994>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    19b0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x880>
mov    -0x2c(%rbp),%eax
imul   -0x10(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    0xa8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x100(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    0xb0(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x108(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
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
mov    -0x38(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x110(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%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
mov    -0x38(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x118(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1865 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x735>
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0x100(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0x108(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0x110(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0x118(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
mov    0x88(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x108(%rbp),%xmm0
ff
mov    0x90(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x110(%rbp),%xmm0
ff
mov    0x98(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x40(%rbp),%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  -0x118(%rbp),%xmm0
ff
mov    0xa0(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x40(%rbp),%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    1826 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x6f6>
jmp    1ac9 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x999>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    17b3 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x683>
jmp    1adc <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x9ac>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1df6 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xcc6>
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    1de3 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xcb3>
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)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1bfe <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xace>
movsd  -0xc8(%rbp),%xmm0
ff
mov    0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x20(%rbp),%xmm1
mov    0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
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    1b40 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xa10>
movsd  -0xf8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jae    1c30 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xb00>
mov    0x10(%rbp),%rax
mov    -0xf0(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jge    1c51 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xb21>
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    1c6d <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xb3d>
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)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1d17 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xbe7>
mov    0x88(%rbp),%rax
mov    -0xec(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%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)
mov    0x98(%rbp),%rax
mov    -0xec(%rbp),%ecx
imul   -0x40(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%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)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1c74 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xb44>
cmpl   $0x2,-0x4(%rbp)
jne    1dd0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xca0>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1dcb <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xc9b>
mov    0x90(%rbp),%rax
mov    -0xec(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%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)
mov    0xa0(%rbp),%rax
mov    -0xec(%rbp),%ecx
imul   -0x40(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%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
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    1d28 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xbf8>
jmp    1dd0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xca0>
jmp    1dd5 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xca5>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1b04 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x9d4>
jmp    1de8 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xcb8>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1ae3 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x9b3>
jmp    1dfb <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xccb>
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x178,%rsp
movsd  %xmm1,0x58(%rsp)
mov    %r9d,0x4c(%rsp)
mov    %esi,0xc8(%rsp)
mov    %rdi,0xe8(%rsp)
mov    0x260(%rsp),%rdi
mov    0x258(%rsp),%rsi
mov    0x250(%rsp),%rax
mov    %rax,0xf8(%rsp)
mov    0x248(%rsp),%rax
mov    %rax,0xf0(%rsp)
mov    0x1c8(%rsp),%r14
mov    %r8d,%r10d
imul   %r8d,%r10d
movapd %xmm0,0x110(%rsp)
mulsd  %xmm0,%xmm0
movapd %xmm0,0x130(%rsp)
movslq %r8d,%rax
mov    %rax,0xc0(%rsp)
movslq %ecx,%rax
mov    %rax,0x70(%rsp)
mov    %edx,%eax
mov    %rax,0xa8(%rsp)
mov    %ecx,0x8(%rsp)
mov    %ecx,%eax
mov    %rax,0xa0(%rsp)
mov    %r8,0x10(%rsp)
mov    %r8d,%r12d
mov    %edx,0x8c(%rsp)
test   %edx,%edx
mov    %r10d,0xc(%rsp)
jle    174c <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x61c>
movapd 0xe01(%rip),%xmm0
movapd 0x130(%rsp),%xmm1
xorpd  %xmm0,%xmm1
movapd %xmm1,0xd0(%rsp)
movapd 0x110(%rsp),%xmm1
xorpd  %xmm0,%xmm1
movapd %xmm1,0x120(%rsp)
mov    %r10d,%eax
imul   0x8(%rsp),%eax
mov    %eax,0xcc(%rsp)
mov    0xc0(%rsp),%rax
lea    0x1(%rax),%ebx
mov    %rax,%rcx
imul   0x70(%rsp),%rcx
shl    $0x3,%rcx
mov    %rcx,0x148(%rsp)
lea    0x0(,%rax,8),%rax
mov    %rax,0x30(%rsp)
xor    %eax,%eax
mov    %rax,0xb8(%rsp)
xorpd  %xmm0,%xmm0
mov    0x250(%rsp),%rax
mov    %rax,0x108(%rsp)
mov    0x248(%rsp),%rax
mov    %rax,0x100(%rsp)
xor    %eax,%eax
mov    %rax,0xb0(%rsp)
jmp    1304 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x1d4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0xb0(%rsp),%rcx
add    $0x1,%rcx
mov    0xb8(%rsp),%rax
add    0xcc(%rsp),%eax
mov    %rax,0xb8(%rsp)
mov    0x148(%rsp),%rax
add    %rax,0x100(%rsp)
add    %rax,0x108(%rsp)
mov    %rcx,%rax
mov    %rcx,0xb0(%rsp)
cmp    0xa8(%rsp),%rcx
je     174c <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x61c>
cmpl   $0x0,0x8(%rsp)
jle    12b0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x180>
mov    0x1c0(%rsp),%rax
mov    0xb0(%rsp),%rcx
movslq (%rax,%rcx,4),%rax
mov    %rax,0x20(%rsp)
imul   0x70(%rsp),%rcx
mov    %rcx,0x38(%rsp)
mov    0x108(%rsp),%r15
mov    0x100(%rsp),%rbp
mov    0xb8(%rsp),%rax
mov    %eax,%edx
xor    %ecx,%ecx
jmp    137e <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x24e>
nopl   (%rax)
mov    0x40(%rsp),%rcx
add    $0x1,%rcx
mov    0xc(%rsp),%r10d
add    %r10d,%edx
mov    0x30(%rsp),%rax
add    %rax,%rbp
add    %rax,%r15
cmp    0xa0(%rsp),%rcx
xorpd  %xmm0,%xmm0
je     12b0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x180>
mov    %edx,0x80(%rsp)
mov    0x38(%rsp),%rax
mov    %rcx,0x40(%rsp)
lea    (%rcx,%rax,1),%r13
mov    0x1f8(%rsp),%rax
movsd  (%rax,%r13,8),%xmm2
ucomisd %xmm2,%xmm0
jbe    14c0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x390>
mov    %r13,0x50(%rsp)
mov    0x1d8(%rsp),%r13
mov    0x20(%rsp),%r14
movsd  0x0(%r13,%r14,8),%xmm1
movapd 0xc34(%rip),%xmm0
xorpd  %xmm0,%xmm2
movsd  0xc38(%rip),%xmm3
divsd  %xmm1,%xmm3
movsd  0xc34(%rip),%xmm0
addsd  %xmm0,%xmm3
movapd %xmm3,0x60(%rsp)
mov    0x1d0(%rsp),%rax
mulsd  (%rax,%r14,8),%xmm2
movapd %xmm2,0x90(%rsp)
addsd  0xc13(%rip),%xmm1
movapd %xmm2,%xmm0
call   1040 <pow@plt>
movsd  %xmm0,0x18(%rsp)
movapd 0x90(%rsp),%xmm2
mulsd  %xmm2,%xmm0
movsd  %xmm0,0x78(%rsp)
mulsd  %xmm0,%xmm2
addsd  0xbdd(%rip),%xmm2
movaps 0x60(%rsp),%xmm1
xorps  0xbb9(%rip),%xmm1
movapd %xmm2,0x90(%rsp)
movapd %xmm2,%xmm0
call   1040 <pow@plt>
movapd %xmm0,%xmm7
mov    0x1d0(%rsp),%rax
movsd  (%rax,%r14,8),%xmm9
movsd  0x0(%r13,%r14,8),%xmm4
mov    0x1e8(%rsp),%rax
movsd  (%rax,%r14,8),%xmm5
movapd %xmm5,%xmm0
mulsd  %xmm7,%xmm0
mov    0x1e0(%rsp),%rax
addsd  (%rax,%r14,8),%xmm0
ucomisd 0xb92(%rip),%xmm7
movsd  %xmm0,0x28(%rsp)
jb     1520 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x3f0>
xorps  %xmm0,%xmm0
sqrtsd %xmm7,%xmm0
jmp    156d <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x43d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x1e0(%rsp),%rax
mov    0x20(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x1e8(%rsp),%rax
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x28(%rsp)
mov    0x1f0(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x60(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x90(%rsp)
jmp    1653 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x523>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd %xmm7,%xmm0
movsd  %xmm5,0x60(%rsp)
movsd  %xmm7,0x158(%rsp)
movapd %xmm9,0x160(%rsp)
movsd  %xmm4,0x150(%rsp)
call   1050 <sqrt@plt>
movsd  0x150(%rsp),%xmm4
movapd 0x160(%rsp),%xmm9
movsd  0x158(%rsp),%xmm7
movsd  0x60(%rsp),%xmm5
mov    0x1c8(%rsp),%r14
movsd  0xa9b(%rip),%xmm3
movapd %xmm3,%xmm2
subsd  %xmm4,%xmm2
mulsd  %xmm9,%xmm2
movapd %xmm7,%xmm1
divsd  0x90(%rsp),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x78(%rsp),%xmm6
mulsd  %xmm6,%xmm1
mulsd  %xmm1,%xmm5
movsd  %xmm5,0x60(%rsp)
movsd  0xa71(%rip),%xmm5
divsd  %xmm0,%xmm5
mulsd  %xmm1,%xmm5
mulsd  %xmm6,%xmm1
mulsd  %xmm7,%xmm6
movapd %xmm3,%xmm2
subsd  %xmm6,%xmm2
movapd %xmm0,%xmm6
addsd  %xmm0,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm2
xorpd  0xa18(%rip),%xmm9
addsd  0xa20(%rip),%xmm4
mulsd  %xmm9,%xmm4
movsd  0x18(%rsp),%xmm3
mulsd  %xmm4,%xmm3
mulsd  %xmm7,%xmm3
subsd  %xmm1,%xmm3
mov    0x1f0(%rsp),%rax
mov    0x20(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm6
mulsd  %xmm2,%xmm6
movsd  %xmm6,0x18(%rsp)
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm5
addsd  %xmm0,%xmm5
mulsd  %xmm1,%xmm5
movsd  %xmm5,0x90(%rsp)
mov    0x1f8(%rsp),%rax
mov    0x50(%rsp),%r13
movsd  (%rax,%r13,8),%xmm2
mulsd  0x58(%rsp),%xmm2
movapd %xmm2,%xmm0
call   1030 <exp@plt>
mulsd  0x110(%rsp),%xmm0
movapd %xmm0,%xmm1
mulsd  0x58(%rsp),%xmm1
movsd  0x28(%rsp),%xmm3
movapd %xmm3,%xmm2
mulsd  %xmm0,%xmm2
mov    0x218(%rsp),%rax
movsd  %xmm2,(%rax,%r13,8)
mulsd  %xmm3,%xmm1
mulsd  0x60(%rsp),%xmm0
subsd  %xmm0,%xmm1
mov    0x220(%rsp),%rax
movsd  %xmm1,(%rax,%r13,8)
cmpl   $0x0,0x10(%rsp)
mov    0x260(%rsp),%rdi
mov    0x258(%rsp),%rsi
mov    0x80(%rsp),%edx
movsd  0x90(%rsp),%xmm3
movsd  0x18(%rsp),%xmm4
jle    1350 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x220>
movapd 0x130(%rsp),%xmm0
mulsd  %xmm4,%xmm0
movapd %xmm3,%xmm1
mulsd  0xd0(%rsp),%xmm1
mulsd  0x110(%rsp),%xmm4
mulsd  0x120(%rsp),%xmm3
mov    %edx,%eax
xor    %ecx,%ecx
xchg   %ax,%ax
movsd  (%r14,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x0(%rbp,%rcx,8)
movsd  (%r14,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%r15,%rcx,8)
cltq
movsd  %xmm4,(%rsi,%rax,8)
movsd  %xmm3,(%rdi,%rax,8)
add    $0x1,%rcx
add    %ebx,%eax
cmp    %rcx,%r12
jne    1710 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x5e0>
jmp    1350 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x220>
mov    0xe8(%rsp),%rax
add    $0xffffffff,%eax
cmp    $0x1,%eax
mov    0xc0(%rsp),%r9
ja     1e7f <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xd4f>
mov    0x240(%rsp),%r13
mov    0x238(%rsp),%rbx
cmpl   $0x1,0xc8(%rsp)
01
jne    1ac1 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x991>
cmpl   $0x0,0x8c(%rsp)
jle    1ac1 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x991>
mov    0x210(%rsp),%rdx
mov    0xa0(%rsp),%rax
lea    -0x1(%rax),%rcx
mov    %rcx,0xd0(%rsp)
mov    %eax,%r8d
and    $0x3,%r8d
and    $0xfffffffc,%eax
mov    %rax,0x120(%rsp)
lea    0x18(%rdx),%rbp
mov    0x70(%rsp),%rcx
lea    0x0(,%rcx,8),%rax
mov    %rax,0x30(%rsp)
imul   0x8(%rsp),%r10d
mov    %r10d,0x50(%rsp)
mov    0x10(%rsp),%rax
add    $0x1,%eax
mov    %eax,0x80(%rsp)
mov    %r9,%rax
imul   %rcx,%rax
shl    $0x3,%rax
mov    %rax,0x78(%rsp)
xor    %eax,%eax
mov    %rax,0x40(%rsp)
mov    0x250(%rsp),%rax
mov    %rax,0x18(%rsp)
mov    0x248(%rsp),%rax
mov    %rax,0x20(%rsp)
xor    %eax,%eax
mov    %rax,0x28(%rsp)
mov    %r8,0x38(%rsp)
jmp    18ac <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x77c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r8,%r9
mov    0x28(%rsp),%rcx
add    $0x1,%rcx
mov    0x90(%rsp),%rbp
mov    0x30(%rsp),%rax
add    %rax,%rbp
add    %rax,%rdx
mov    0x40(%rsp),%rax
add    0x50(%rsp),%eax
mov    %rax,0x40(%rsp)
mov    0x78(%rsp),%rax
add    %rax,0x20(%rsp)
add    %rax,0x18(%rsp)
mov    %rcx,%rax
mov    %rcx,0x28(%rsp)
cmp    0xa8(%rsp),%rcx
mov    0x260(%rsp),%rdi
mov    0x258(%rsp),%rsi
mov    0xc(%rsp),%r10d
mov    0x38(%rsp),%r8
je     1ac1 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x991>
cmpl   $0x0,0x8(%rsp)
mov    %rbp,0x90(%rsp)
jle    18d0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x7a0>
cmpq   $0x3,0xd0(%rsp)
jae    18e0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x7b0>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
jmp    1911 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x7e1>
xchg   %ax,%ax
xorpd  %xmm0,%xmm0
jmp    192e <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x7fe>
cs nopw 0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    0x120(%rsp),%rcx
xchg   %ax,%ax
addsd  -0x18(%rbp,%rax,8),%xmm0
addsd  -0x10(%rbp,%rax,8),%xmm0
addsd  -0x8(%rbp,%rax,8),%xmm0
addsd  0x0(%rbp,%rax,8),%xmm0
add    $0x4,%rax
cmp    %rax,%rcx
jne    18f0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x7c0>
test   %r8,%r8
je     192e <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x7fe>
lea    (%rdx,%rax,8),%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
addsd  (%rax,%rcx,8),%xmm0
add    $0x1,%rcx
cmp    %rcx,%r8
jne    1920 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x7f0>
cmpl   $0x0,0x10(%rsp)
mov    %r9,%r8
jle    1840 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x710>
mov    0x28(%rsp),%rcx
mov    %rcx,%rax
imul   %r8,%rax
mov    %rax,0x60(%rsp)
mov    0xc(%rsp),%eax
imul   %ecx,%eax
mov    %rax,0x58(%rsp)
mov    0x18(%rsp),%r9
mov    0x20(%rsp),%r10
mov    0x40(%rsp),%rax
mov    %eax,%r11d
xor    %r15d,%r15d
jmp    1a08 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x8d8>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorpd  %xmm2,%xmm2
xorpd  %xmm1,%xmm1
movapd %xmm2,%xmm3
divsd  %xmm0,%xmm3
unpckhpd %xmm2,%xmm2
divsd  %xmm0,%xmm2
movapd %xmm1,%xmm4
divsd  %xmm0,%xmm4
unpckhpd %xmm1,%xmm1
divsd  %xmm0,%xmm1
mov    0x60(%rsp),%rax
add    %r15,%rax
mov    0x228(%rsp),%rcx
movsd  %xmm3,(%rcx,%rax,8)
mov    0x230(%rsp),%rcx
movsd  %xmm2,(%rcx,%rax,8)
mov    0x58(%rsp),%rax
add    %r15d,%eax
mov    %r15d,%ecx
imul   0x10(%rsp),%ecx
add    %eax,%ecx
movslq %ecx,%rax
movsd  %xmm4,(%rbx,%rax,8)
movsd  %xmm1,0x0(%r13,%rax,8)
add    $0x1,%r15
add    0x80(%rsp),%r11d
add    $0x8,%r10
add    $0x8,%r9
cmp    %r12,%r15
je     1840 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x710>
cmpl   $0x0,0x8(%rsp)
jle    1980 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x850>
xorpd  %xmm5,%xmm5
xor    %eax,%eax
mov    %r11d,%edi
xor    %ebp,%ebp
xorpd  %xmm6,%xmm6
mov    0x260(%rsp),%rcx
mov    0x258(%rsp),%rsi
mov    %r8,%rbx
mov    0xc(%rsp),%r13d
mov    0xa0(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd %xmm6,%xmm3
movapd %xmm5,%xmm4
movslq %edi,%rdi
movsd  (%rsi,%rdi,8),%xmm6
movhpd (%rcx,%rdi,8),%xmm6
movsd  (%r10,%rax,8),%xmm2
movhpd (%r9,%rax,8),%xmm2
movsd  (%rdx,%rbp,8),%xmm1
unpcklpd %xmm1,%xmm1
mulpd  %xmm1,%xmm2
movapd %xmm2,%xmm5
addpd  %xmm4,%xmm5
mulpd  %xmm6,%xmm1
movapd %xmm1,%xmm6
addpd  %xmm3,%xmm6
add    $0x1,%rbp
add    %r13d,%edi
add    %rbx,%rax
cmp    %rbp,%r8
jne    1a50 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x920>
addpd  %xmm4,%xmm2
addpd  %xmm3,%xmm1
mov    %rbx,%r8
mov    0x240(%rsp),%r13
mov    0x238(%rsp),%rbx
jmp    1988 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0x858>
cmpl   $0x0,0x8c(%rsp)
jle    1e7f <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xd4f>
mov    0x208(%rsp),%rbp
mov    0x200(%rsp),%rbx
cmpl   $0x2,0xe8(%rsp)
02
setne  %al
mov    0x4c(%rsp),%ecx
mov    0x10(%rsp),%rdx
imul   %edx,%ecx
mov    %ecx,0x4c(%rsp)
test   %edx,%edx
setle  %cl
or     %al,%cl
mov    %cl,0x40(%rsp)
mov    %r12d,%eax
and    $0xfffffffe,%eax
mov    %rax,0x18(%rsp)
lea    0x8(%rbx),%rax
mov    %rax,0x50(%rsp)
mov    %r9,%rax
imul   0x70(%rsp),%rax
shl    $0x3,%rax
mov    %rax,0x78(%rsp)
lea    0x0(,%r9,8),%rax
mov    %rax,0x28(%rsp)
lea    0x8(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    %r10d,%eax
imul   0x8(%rsp),%eax
mov    %eax,0xd0(%rsp)
lea    0x1(%rdx),%r9d
xor    %eax,%eax
mov    %rax,0x38(%rsp)
movapd 0x49d(%rip),%xmm0
xorpd  %xmm1,%xmm1
xor    %eax,%eax
mov    %rax,0x30(%rsp)
jmp    1bba <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xa8a>
mov    0x30(%rsp),%rdx
add    $0x1,%rdx
mov    0x78(%rsp),%rax
add    %rax,0x50(%rsp)
mov    0x38(%rsp),%rcx
add    0xd0(%rsp),%ecx
mov    %rcx,0x38(%rsp)
add    %rax,0xf0(%rsp)
add    %rax,0xf8(%rsp)
mov    %rdx,%rax
mov    %rdx,0x30(%rsp)
cmp    0xa8(%rsp),%rdx
je     1e7f <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xd4f>
cmpl   $0x0,0x8(%rsp)
jle    1b70 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xa40>
mov    0x1c0(%rsp),%rax
mov    0x30(%rsp),%rcx
movslq (%rax,%rcx,4),%rax
mov    %rax,0x90(%rsp)
imul   0x70(%rsp),%rcx
mov    %rcx,0x80(%rsp)
mov    0xf8(%rsp),%r15
mov    0xf0(%rsp),%r8
mov    0x38(%rsp),%rax
mov    %eax,0x60(%rsp)
mov    0x50(%rsp),%r11
xor    %ecx,%ecx
jmp    1c3a <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xb0a>
nopw   0x0(%rax,%rax,1)
mov    0x58(%rsp),%rcx
add    $0x1,%rcx
mov    0x28(%rsp),%rax
add    %rax,%r11
add    %r10d,0x60(%rsp)
add    %rax,%r8
add    %rax,%r15
cmp    0xa0(%rsp),%rcx
je     1b70 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xa40>
mov    0x80(%rsp),%rax
mov    %rcx,0x58(%rsp)
add    %rcx,%rax
mov    0x1b8(%rsp),%rcx
movslq (%rcx,%rax,4),%rbx
cmpl   $0x0,0x10(%rsp)
jle    1da0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xc70>
mov    0x4c(%rsp),%ecx
imul   %ebx,%ecx
mov    0x1f0(%rsp),%rdx
mov    0x90(%rsp),%rsi
movsd  (%rdx,%rsi,8),%xmm3
movapd 0x130(%rsp),%xmm2
mulsd  %xmm3,%xmm2
xorpd  %xmm0,%xmm3
mulsd  0x110(%rsp),%xmm3
movslq %ecx,%rcx
cmpl   $0x1,0x10(%rsp)
jne    1cb0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xb80>
xorpd  %xmm4,%xmm4
xor    %r10d,%r10d
jmp    1d21 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xbf1>
nopw   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%r13
xorpd  %xmm4,%xmm4
xor    %r10d,%r10d
mov    0x18(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%r11,%r10,8),%xmm5
mulsd  %xmm3,%xmm5
movsd  (%r14,%r10,8),%xmm6
mulsd  %xmm2,%xmm6
addsd  %xmm5,%xmm6
mulsd  -0x8(%r13,%r10,8),%xmm6
addsd  %xmm4,%xmm6
movsd  (%r11,%r10,8),%xmm5
mulsd  %xmm3,%xmm5
movsd  0x8(%r14,%r10,8),%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm5,%xmm4
mulsd  0x0(%r13,%r10,8),%xmm4
addsd  %xmm6,%xmm4
add    $0x2,%r10
cmp    %r10,%rdx
jne    1cd0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xba0>
test   $0x1,%r12b
mov    0xc0(%rsp),%rdx
je     1d61 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xc31>
imul   %rdx,%rax
add    %r10,%rax
mov    0x200(%rsp),%rdx
mulsd  (%rdx,%rax,8),%xmm3
mulsd  (%r14,%r10,8),%xmm2
addsd  %xmm3,%xmm2
add    %r10,%rcx
mov    0x208(%rsp),%rax
mulsd  (%rax,%rcx,8),%xmm2
addsd  %xmm2,%xmm4
ucomisd %xmm1,%xmm4
mov    0x260(%rsp),%rdi
mov    0x258(%rsp),%rsi
mov    0xc(%rsp),%r10d
jae    1da0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xc70>
mov    0x1b0(%rsp),%rax
mov    0x4(%rax,%rbx,8),%ecx
test   %ecx,%ecx
jns    1db0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xc80>
add    %rbx,%rbx
jmp    1da2 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xc72>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    %ebx,%ebx
movslq %ebx,%rax
mov    0x1b0(%rsp),%rcx
mov    (%rcx,%rax,4),%ecx
cmpl   $0x0,0x10(%rsp)
mov    0x238(%rsp),%r13
jle    1e1b <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xceb>
mov    %ecx,%edx
imul   0x10(%rsp),%edx
mov    %ecx,%eax
imul   %r10d,%eax
movslq %edx,%rdx
mov    0x228(%rsp),%rbx
lea    (%rbx,%rdx,8),%rbx
mov    0x60(%rsp),%edx
mov    %edx,%ebp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%rdx,8),%xmm2
movsd  %xmm2,(%r8,%rdx,8)
cltq
movsd  0x0(%r13,%rax,8),%xmm2
movslq %ebp,%rbp
movsd  %xmm2,(%rsi,%rbp,8)
add    $0x1,%rdx
add    %r9d,%ebp
add    %r9d,%eax
cmp    %rdx,%r12
jne    1df0 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xcc0>
cmpb   $0x0,0x40(%rsp)
mov    0x240(%rsp),%rbx
jne    1c10 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xae0>
mov    %ecx,%eax
imul   0x10(%rsp),%eax
imul   %r10d,%ecx
cltq
mov    0x230(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
mov    0x60(%rsp),%edx
mov    %edx,%ebp
xor    %edx,%edx
nop
movsd  (%rax,%rdx,8),%xmm2
movsd  %xmm2,(%r15,%rdx,8)
movslq %ecx,%rcx
movsd  (%rbx,%rcx,8),%xmm2
movslq %ebp,%rbp
movsd  %xmm2,(%rdi,%rbp,8)
add    $0x1,%rdx
add    %r9d,%ebp
add    %r9d,%ecx
cmp    %rdx,%r12
jne    1e50 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xd20>
jmp    1c10 <conservativeHeadRichardsMualemVanGenuchtenHetEvaluateV2withUpwind+0xae0>
add    $0x178,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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