void VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate(
    const int nPoints, const int killNonlinearDrag, const double eps_rho,
    const double eps_mu, const double sigma, const double rho_0,
    const double nu_0, const double rho_1, const double nu_1,
    const double *meanGrainSize, const double *g, const double *phi,
    const double *n, const double *kappa, const double *p, const double *grad_p,
    const double *u, const double *v, const double *porosity, double *mom_u_acc,
    double *dmom_u_acc_u, double *mom_v_acc, double *dmom_v_acc_v,
    double *mass_adv, double *dmass_adv_u, double *dmass_adv_v,
    double *mom_u_adv, double *dmom_u_adv_u, double *dmom_u_adv_v,
    double *mom_v_adv, double *dmom_v_adv_u, double *dmom_v_adv_v,
    double *mom_u_diff_ten, double *mom_v_diff_ten, double *mom_uv_diff_ten,
    double *mom_vu_diff_ten, double *mom_u_source, double *mom_v_source,
    double *dmom_u_source_u, double *dmom_u_source_v, double *dmom_v_source_u,
    double *dmom_v_source_v, double *mom_u_ham, double *dmom_u_ham_grad_p,
    double *mom_v_ham, double *dmom_v_ham_grad_p) {
  int k;
  double rho, nu, mu, H_rho, d_rho, H_mu, d_mu, norm_n;
  double Ftilde, Kinv, uc;
  double nonlinearDragFactor = 1.0;
  if (killNonlinearDrag)
    nonlinearDragFactor = 0.0;
  for (k = 0; k < nPoints; k++) {
    H_rho = smoothedHeaviside(eps_rho, phi[k]);
    d_rho = smoothedDirac(eps_rho, phi[k]);
    H_mu = smoothedHeaviside(eps_mu, phi[k]);
    d_mu = smoothedDirac(eps_mu, phi[k]);
    rho = rho_0 * (1.0 - H_rho) + rho_1 * H_rho;
    nu = nu_0 * (1.0 - H_mu) + nu_1 * H_mu;
    mu = rho_0 * nu_0 * (1.0 - H_mu) + rho_1 * nu_1 * H_mu;
    mom_u_acc[k] = porosity[k] * u[k];
    dmom_u_acc_u[k] = porosity[k];
    mom_v_acc[k] = porosity[k] * v[k];
    dmom_v_acc_v[k] = porosity[k];
    mass_adv[k * 2 + 0] = porosity[k] * u[k];
    mass_adv[k * 2 + 1] = porosity[k] * v[k];
    dmass_adv_u[k * 2 + 0] = porosity[k];
    dmass_adv_v[k * 2 + 1] = porosity[k];
    mom_u_adv[k * 2 + 0] = porosity[k] * u[k] * u[k];
    mom_u_adv[k * 2 + 1] = porosity[k] * u[k] * v[k];
    dmom_u_adv_u[k * 2 + 0] = 2.0 * porosity[k] * u[k];
    dmom_u_adv_u[k * 2 + 1] = porosity[k] * v[k];
    dmom_u_adv_v[k * 2 + 1] = porosity[k] * u[k];
    mom_v_adv[k * 2 + 0] = porosity[k] * v[k] * u[k];
    mom_v_adv[k * 2 + 1] = porosity[k] * v[k] * v[k];
    dmom_v_adv_u[k * 2 + 0] = porosity[k] * v[k];
    dmom_v_adv_v[k * 2 + 0] = porosity[k] * u[k];
    dmom_v_adv_v[k * 2 + 1] = 2.0 * porosity[k] * v[k];
    mom_u_diff_ten[k * 4 + 0] = 2.0 * porosity[k] * nu;
    mom_u_diff_ten[k * 4 + 3] = porosity[k] * nu;
    mom_uv_diff_ten[k * 4 + 2] = porosity[k] * nu;
    mom_v_diff_ten[k * 4 + 0] = porosity[k] * nu;
    mom_v_diff_ten[k * 4 + 3] = 2.0 * porosity[k] * nu;
    mom_vu_diff_ten[k * 4 + 1] = porosity[k] * nu;
    norm_n = sqrt(n[k * 2 + 0] * n[k * 2 + 0] + n[k * 2 + 1] * n[k * 2 + 1]);
    uc = sqrt(u[k] * u[k] + v[k] * v[k]);
    if (fabs(1.0 - porosity[k]) < 1.0e-7)
      Ftilde = 0.0;
    else
      Ftilde =
          porosity[k] * meanGrainSize[k] * 1.0e-2 / (1.0 - porosity[k]) / nu;
    Ftilde *= nonlinearDragFactor;
    if (fabs(porosity[k]) < 1.0e-7)
      Kinv = 0.0;
    else
      Kinv = 180.0 * (1.0 - porosity[k]) * (1.0 - porosity[k]) /
             (meanGrainSize[k] * meanGrainSize[k] * porosity[k] * porosity[k] *
              porosity[k]);
    mom_u_source[k] =
        -porosity[k] * g[0] -
        porosity[k] * d_mu * sigma * kappa[k] * n[k * 2 + 0] / (norm_n) +
        porosity[k] * porosity[k] * nu * Kinv * (1.0 + Ftilde * uc) * u[k];
    mom_v_source[k] =
        -porosity[k] * rho * g[1] -
        porosity[k] * d_mu * sigma * kappa[k] * n[k * 2 + 1] / (norm_n) +
        porosity[k] * porosity[k] * nu * Kinv * (1.0 + Ftilde * uc) * v[k];
    dmom_u_source_u[k] = porosity[k] * porosity[k] * nu * Kinv *
                         (1.0 + Ftilde * (uc + u[k] * u[k] / (uc + 1.0e-12)));
    dmom_u_source_v[k] = porosity[k] * porosity[k] * nu * Kinv *
                         (0.0 + Ftilde * (u[k] * v[k] / (uc + 1.0e-12)));
    dmom_v_source_v[k] = porosity[k] * porosity[k] * nu * Kinv *
                         (1.0 + Ftilde * (uc + v[k] * v[k] / (uc + 1.0e-12)));
    dmom_v_source_u[k] = porosity[k] * porosity[k] * nu * Kinv *
                         (0.0 + Ftilde * (u[k] * v[k] / (uc + 1.0e-12)));
    mom_u_ham[k] = porosity[k] * grad_p[k * 2 + 0] / rho;
    dmom_u_ham_grad_p[k * 2 + 0] = porosity[k] / rho;
    mom_v_ham[k] = porosity[k] * grad_p[k * 2 + 1] / rho;
    dmom_v_ham_grad_p[k * 2 + 1] = porosity[k] / rho;
  }
}


x86 assembly (clang, -O0):
<VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    0x110(%rbp),%rax
mov    0x108(%rbp),%rax
mov    0x100(%rbp),%rax
mov    0xf8(%rbp),%rax
mov    0xf0(%rbp),%rax
mov    0xe8(%rbp),%rax
mov    0xe0(%rbp),%rax
mov    0xd8(%rbp),%rax
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)
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
movsd  %xmm2,-0x20(%rbp)
movsd  %xmm3,-0x28(%rbp)
movsd  %xmm4,-0x30(%rbp)
movsd  %xmm5,-0x38(%rbp)
movsd  %xmm6,-0x40(%rbp)
mov    %rdx,-0x48(%rbp)
mov    %rcx,-0x50(%rbp)
mov    %r8,-0x58(%rbp)
mov    %r9,-0x60(%rbp)
movsd  0xdc7(%rip),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
cmpl   $0x0,-0x8(%rbp)
je     1256 <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate+0x126>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1ef5 <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate+0xdc5>
movsd  -0x10(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    $0x2,%al
call   1050 <smoothedHeaviside@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    $0x2,%al
call   1040 <smoothedDirac@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x18(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    $0x2,%al
call   1050 <smoothedHeaviside@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x18(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    $0x2,%al
call   1040 <smoothedDirac@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
movsd  0xcf6(%rip),%xmm2
subsd  -0x88(%rbp),%xmm2
ff
movsd  -0x38(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x30(%rbp),%xmm0
movsd  0xcc7(%rip),%xmm2
subsd  -0x98(%rbp),%xmm2
ff
movsd  -0x40(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x28(%rbp),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  0xc93(%rip),%xmm2
subsd  -0x98(%rbp),%xmm2
ff
movsd  -0x38(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x60(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x60(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x78(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x78(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  0xad0(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x88(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x90(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x90(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x98(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0xa0(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  0x950(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0xa0(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  0x916(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    0xa8(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    0xa8(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    0xb8(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    0xb0(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  0x866(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    0xb0(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    0xc0(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x60(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  0x748(%rip),%xmm1
subsd  (%rax,%rcx,8),%xmm1
movaps 0x76c(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x738(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    18ea <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate+0x7ba>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    1936 <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate+0x806>
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x70c(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  0x6e0(%rip),%xmm1
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x6ce(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x69a(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1988 <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate+0x858>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    1a0f <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate+0x8df>
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  0x668(%rip),%xmm1
subsd  (%rax,%rcx,8),%xmm1
movsd  0x67b(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  0x647(%rip),%xmm1
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm2
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x20(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xc0(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm2
movsd  0x51f(%rip),%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0xc8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  -0x70(%rbp),%xmm1
mov    -0x50(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x20(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xc0(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm2
movsd  0x41a(%rip),%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0xd0(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0xc0(%rbp),%xmm2
ff
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm3
movsd  0x3bc(%rip),%xmm4
addsd  -0xc0(%rbp),%xmm4
ff
divsd  %xmm4,%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
movsd  0x378(%rip),%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    0xd8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm1
ff
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
movsd  0x337(%rip),%xmm3
addsd  -0xc0(%rbp),%xmm3
ff
divsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
xorps  %xmm2,%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    0xe0(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0xc0(%rbp),%xmm2
ff
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm3
movsd  0x2b3(%rip),%xmm4
addsd  -0xc0(%rbp),%xmm4
ff
divsd  %xmm4,%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
movsd  0x26f(%rip),%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    0xf0(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm1
ff
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
movsd  0x22e(%rip),%xmm3
addsd  -0xc0(%rbp),%xmm3
ff
divsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
xorps  %xmm2,%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    0xe8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x70(%rbp),%xmm0
mov    0xf8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x70(%rbp),%xmm0
mov    0x100(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x70(%rbp),%xmm0
mov    0x108(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x70(%rbp),%xmm0
mov    0x110(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    125d <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate+0x12d>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9,%rbp
mov    %r8,0x70(%rsp)
mov    %rcx,0x68(%rsp)
mov    %rdx,0x10(%rsp)
movsd  %xmm6,0x60(%rsp)
movsd  %xmm5,0x58(%rsp)
movsd  %xmm4,0x50(%rsp)
movsd  %xmm3,0x48(%rsp)
movsd  %xmm2,0x40(%rsp)
movsd  %xmm1,0x28(%rsp)
movsd  %xmm0,0x20(%rsp)
test   %esi,%esi
je     1184 <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate+0x54>
xorpd  %xmm0,%xmm0
jmp    118c <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate+0x5c>
movsd  0xe74(%rip),%xmm0
movsd  %xmm0,0x18(%rsp)
test   %edi,%edi
jle    1891 <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate+0x761>
mov    %edi,%eax
shl    $0x2,%rax
mov    %rax,0x38(%rsp)
mov    0xd8(%rsp),%r12
mov    0xd0(%rsp),%r15
mov    0xc8(%rsp),%r14
xor    %r13d,%r13d
jmp    1433 <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate+0x303>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm4,%xmm7
movapd %xmm1,%xmm5
mulsd  %xmm4,%xmm5
movsd  0x40(%rsp),%xmm9
mulsd  %xmm9,%xmm5
mov    0xb0(%rsp),%rsi
mulsd  (%rsi,%r13,2),%xmm5
mulsd  0x0(%rbp,%r13,4),%xmm5
movapd 0xe3a(%rip),%xmm12
xorpd  %xmm12,%xmm7
divsd  %xmm14,%xmm5
mov    0x68(%rsp),%rcx
mulsd  (%rcx),%xmm7
mulsd  %xmm4,%xmm4
mulsd  %xmm13,%xmm4
mulsd  %xmm3,%xmm4
movapd %xmm2,%xmm6
mulsd  %xmm0,%xmm6
addsd  %xmm10,%xmm6
mulsd  %xmm6,%xmm4
mulsd  (%r14,%r13,2),%xmm4
subsd  %xmm5,%xmm7
addsd  %xmm7,%xmm4
mov    0x168(%rsp),%rdx
movsd  %xmm4,(%rdx,%r13,2)
movsd  (%rax),%xmm4
movapd %xmm4,%xmm5
xorpd  %xmm12,%xmm5
mulsd  %xmm8,%xmm5
mulsd  %xmm4,%xmm1
mulsd  %xmm9,%xmm1
mulsd  (%rsi,%r13,2),%xmm1
mulsd  0x8(%rbp,%r13,4),%xmm1
divsd  %xmm14,%xmm1
mulsd  0x8(%rcx),%xmm5
subsd  %xmm1,%xmm5
mulsd  %xmm4,%xmm4
mulsd  %xmm13,%xmm4
mulsd  %xmm3,%xmm4
mulsd  %xmm6,%xmm4
mulsd  (%r15,%r13,2),%xmm4
addsd  %xmm5,%xmm4
mov    0x170(%rsp),%rcx
movsd  %xmm4,(%rcx,%r13,2)
movsd  (%rax),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm13,%xmm1
mulsd  %xmm3,%xmm1
movsd  (%r14,%r13,2),%xmm5
mulsd  %xmm5,%xmm5
movapd %xmm0,%xmm4
addsd  0xd3f(%rip),%xmm4
divsd  %xmm4,%xmm5
addsd  %xmm0,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm10,%xmm5
mulsd  %xmm1,%xmm5
mov    0x178(%rsp),%rcx
movsd  %xmm5,(%rcx,%r13,2)
movsd  (%rax),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm13,%xmm1
mulsd  %xmm3,%xmm1
movsd  (%r14,%r13,2),%xmm5
mulsd  (%r15,%r13,2),%xmm5
divsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm11,%xmm5
mulsd  %xmm1,%xmm5
mov    0x180(%rsp),%rcx
movsd  %xmm5,(%rcx,%r13,2)
movsd  (%rax),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm13,%xmm1
mulsd  %xmm3,%xmm1
movsd  (%r15,%r13,2),%xmm5
mulsd  %xmm5,%xmm5
divsd  %xmm4,%xmm5
addsd  %xmm0,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm10,%xmm5
mulsd  %xmm1,%xmm5
mov    0x190(%rsp),%rcx
movsd  %xmm5,(%rcx,%r13,2)
movsd  (%rax),%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm13,%xmm0
mulsd  %xmm3,%xmm0
movsd  (%r14,%r13,2),%xmm1
mulsd  (%r15,%r13,2),%xmm1
divsd  %xmm4,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm11,%xmm1
mulsd  %xmm0,%xmm1
mov    0x188(%rsp),%rcx
movsd  %xmm1,(%rcx,%r13,2)
movsd  (%rax),%xmm0
mov    0xc0(%rsp),%rdx
mulsd  (%rdx,%r13,4),%xmm0
divsd  %xmm8,%xmm0
mov    0x198(%rsp),%rcx
movsd  %xmm0,(%rcx,%r13,2)
movsd  (%rax),%xmm0
divsd  %xmm8,%xmm0
mov    0x1a0(%rsp),%rcx
movsd  %xmm0,(%rcx,%r13,4)
movsd  (%rax),%xmm0
mulsd  0x8(%rdx,%r13,4),%xmm0
divsd  %xmm8,%xmm0
mov    0x1a8(%rsp),%rcx
movsd  %xmm0,(%rcx,%r13,2)
movsd  (%rax),%xmm0
divsd  %xmm8,%xmm0
mov    0x1b0(%rsp),%rax
movsd  %xmm0,0x8(%rax,%r13,4)
add    $0x4,%r13
cmp    %r13,0x38(%rsp)
je     1891 <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate+0x761>
mov    0x70(%rsp),%rbx
movsd  (%rbx,%r13,2),%xmm1
movsd  0x20(%rsp),%xmm0
mov    $0x2,%al
call   1050 <smoothedHeaviside@plt>
mov    %eax,0x4(%rsp)
movsd  (%rbx,%r13,2),%xmm1
movsd  0x20(%rsp),%xmm0
mov    $0x2,%al
call   1040 <smoothedDirac@plt>
movsd  (%rbx,%r13,2),%xmm1
movsd  0x28(%rsp),%xmm0
mov    $0x2,%al
call   1050 <smoothedHeaviside@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  (%rbx,%r13,2),%xmm1
movsd  0x28(%rsp),%xmm0
mov    $0x2,%al
call   1040 <smoothedDirac@plt>
xorpd  %xmm11,%xmm11
mov    %rbp,%rsi
movsd  (%r12,%r13,2),%xmm0
mulsd  (%r14,%r13,2),%xmm0
mov    0xe0(%rsp),%rcx
movsd  %xmm0,(%rcx,%r13,2)
movsd  (%r12,%r13,2),%xmm0
mov    0xe8(%rsp),%rcx
movsd  %xmm0,(%rcx,%r13,2)
movsd  (%r12,%r13,2),%xmm0
mulsd  (%r15,%r13,2),%xmm0
mov    %eax,%ebx
mov    0xf0(%rsp),%rax
movsd  %xmm0,(%rax,%r13,2)
movsd  (%r12,%r13,2),%xmm0
mov    0xf8(%rsp),%rax
movsd  %xmm0,(%rax,%r13,2)
movsd  (%r12,%r13,2),%xmm0
mulsd  (%r14,%r13,2),%xmm0
mov    0x100(%rsp),%rax
movsd  %xmm0,(%rax,%r13,4)
movsd  (%r12,%r13,2),%xmm0
mulsd  (%r15,%r13,2),%xmm0
movsd  %xmm0,0x8(%rax,%r13,4)
movsd  (%r12,%r13,2),%xmm0
mov    0x108(%rsp),%rax
movsd  %xmm0,(%rax,%r13,4)
movsd  (%r12,%r13,2),%xmm0
mov    0x110(%rsp),%rax
movsd  %xmm0,0x8(%rax,%r13,4)
movsd  (%r14,%r13,2),%xmm0
movsd  (%r12,%r13,2),%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  0xa93(%rip),%xmm2
movsd  0x8(%rsp),%xmm0
subsd  %xmm0,%xmm2
mulsd  0x60(%rsp),%xmm0
movapd %xmm0,%xmm3
mov    0x118(%rsp),%rax
movsd  %xmm1,(%rax,%r13,4)
movsd  (%r12,%r13,2),%xmm0
mulsd  (%r14,%r13,2),%xmm0
mulsd  (%r15,%r13,2),%xmm0
mulsd  0x50(%rsp),%xmm2
movsd  %xmm0,0x8(%rax,%r13,4)
movsd  (%r12,%r13,2),%xmm0
addsd  %xmm0,%xmm0
mulsd  (%r14,%r13,2),%xmm0
mov    0x120(%rsp),%rax
movsd  %xmm0,(%rax,%r13,4)
movsd  (%r12,%r13,2),%xmm0
mulsd  (%r15,%r13,2),%xmm0
movsd  %xmm0,0x8(%rax,%r13,4)
movsd  (%r12,%r13,2),%xmm0
mulsd  (%r14,%r13,2),%xmm0
mov    0x128(%rsp),%rax
movsd  %xmm0,0x8(%rax,%r13,4)
movsd  (%r12,%r13,2),%xmm0
mulsd  (%r15,%r13,2),%xmm0
mulsd  (%r14,%r13,2),%xmm0
addsd  %xmm3,%xmm2
mov    0x130(%rsp),%rax
movsd  %xmm0,(%rax,%r13,4)
movsd  (%r15,%r13,2),%xmm0
movsd  (%r12,%r13,2),%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rax,%r13,4)
movsd  (%r12,%r13,2),%xmm0
mulsd  (%r15,%r13,2),%xmm0
mov    0x138(%rsp),%rax
movsd  %xmm0,(%rax,%r13,4)
movsd  (%r12,%r13,2),%xmm0
mulsd  (%r14,%r13,2),%xmm0
mov    0x140(%rsp),%rax
movsd  %xmm0,(%rax,%r13,4)
movsd  (%r12,%r13,2),%xmm0
addsd  %xmm0,%xmm0
mulsd  (%r15,%r13,2),%xmm0
movsd  %xmm0,0x8(%rax,%r13,4)
movsd  (%r12,%r13,2),%xmm0
addsd  %xmm0,%xmm0
mulsd  %xmm2,%xmm0
mov    %r13d,%eax
shl    $0x3,%rax
mov    0x148(%rsp),%rdx
movsd  %xmm0,(%rdx,%rax,1)
movsd  (%r12,%r13,2),%xmm0
mulsd  %xmm2,%xmm0
lea    0x3(%r13),%ecx
movsd  %xmm0,(%rdx,%rcx,8)
movsd  (%r12,%r13,2),%xmm0
mulsd  %xmm2,%xmm0
lea    0x2(%r13),%edx
mov    0x158(%rsp),%rdi
movsd  %xmm0,(%rdi,%rdx,8)
movsd  (%r12,%r13,2),%xmm0
mulsd  %xmm2,%xmm0
mov    0x150(%rsp),%rdx
movsd  %xmm0,(%rdx,%rax,1)
movsd  (%r12,%r13,2),%xmm0
addsd  %xmm0,%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
movsd  (%r12,%r13,2),%xmm0
mulsd  %xmm2,%xmm0
lea    0x1(%r13),%eax
mov    0x160(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
movsd  0x0(%rbp,%r13,4),%xmm0
movsd  0x8(%rbp,%r13,4),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm11,%xmm0
movsd  %xmm2,0x8(%rsp)
jb     1750 <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate+0x620>
sqrtsd %xmm0,%xmm14
jmp    175f <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate+0x62f>
nopw   0x0(%rax,%rax,1)
call   1030 <sqrt@plt>
xorpd  %xmm11,%xmm11
movapd %xmm0,%xmm14
movsd  (%r14,%r13,2),%xmm0
movsd  (%r15,%r13,2),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm11,%xmm0
jb     1790 <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate+0x660>
sqrtsd %xmm0,%xmm0
jmp    17a8 <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate+0x678>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  %xmm14,0x30(%rsp)
call   1030 <sqrt@plt>
movsd  0x30(%rsp),%xmm14
xorpd  %xmm11,%xmm11
movsd  0x84f(%rip),%xmm10
movapd 0x867(%rip),%xmm5
movsd  0x846(%rip),%xmm9
movsd  0x8(%rsp),%xmm13
mov    0x4(%rsp),%edx
lea    (%r12,%r13,2),%rax
movsd  (%rax),%xmm4
movapd %xmm10,%xmm6
subsd  %xmm4,%xmm6
movapd %xmm6,%xmm1
andpd  %xmm5,%xmm1
xorpd  %xmm3,%xmm3
ucomisd %xmm1,%xmm9
xorpd  %xmm2,%xmm2
ja     1815 <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate+0x6e5>
mov    0x10(%rsp),%rcx
movsd  (%rcx,%r13,2),%xmm2
mulsd  %xmm4,%xmm2
mulsd  0x804(%rip),%xmm2
divsd  %xmm6,%xmm2
divsd  %xmm13,%xmm2
cvtsi2sd %edx,%xmm7
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
mulsd  0x18(%rsp),%xmm2
movapd %xmm10,%xmm8
subsd  %xmm7,%xmm8
mulsd  0x58(%rsp),%xmm7
mulsd  0x48(%rsp),%xmm8
addsd  %xmm7,%xmm8
movapd %xmm4,%xmm7
andpd  %xmm5,%xmm7
ucomisd %xmm7,%xmm9
ja     11d0 <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate+0xa0>
mov    0x10(%rsp),%rcx
movsd  (%rcx,%r13,2),%xmm7
mulsd  %xmm7,%xmm7
mulsd  %xmm4,%xmm7
movapd 0x7c0(%rip),%xmm3
unpcklpd %xmm7,%xmm3
unpcklpd %xmm4,%xmm6
mulpd  %xmm6,%xmm3
mulpd  %xmm6,%xmm3
movapd %xmm3,%xmm6
unpckhpd %xmm3,%xmm6
divsd  %xmm6,%xmm3
jmp    11d0 <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate+0xa0>
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate(i32 %0, i32 %1, double %2, double %3, double %4, double %5, double %6, double %7, double %8, double* %9, double* %10, double* %11, double* %12, double* %13, double* %14, double* %15, double* %16, double* %17, double* %18, 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, double* %33, double* %34, double* %35, double* %36, double* %37, double* %38, double* %39, double* %40, double* %41, double* %42, double* %43, double* %44, double* %45) {
%47 = alloca i32
%48 = alloca i32
%49 = alloca double
%50 = alloca double
%51 = alloca double
%52 = alloca double
%53 = alloca double
%54 = alloca double
%55 = alloca double
%56 = alloca double*
%57 = alloca double*
%58 = alloca double*
%59 = alloca double*
%60 = alloca double*
%61 = alloca double*
%62 = alloca double*
%63 = alloca double*
%64 = alloca double*
%65 = alloca double*
%66 = alloca double*
%67 = alloca double*
%68 = alloca double*
%69 = alloca double*
%70 = alloca double*
%71 = alloca double*
%72 = alloca double*
%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 double*
%91 = alloca double*
%92 = alloca double*
%93 = alloca i32
%94 = alloca double
%95 = alloca double
%96 = alloca double
%97 = alloca double
%98 = alloca double
%99 = alloca double
%100 = alloca double
%101 = alloca double
%102 = alloca double
%103 = alloca double
%104 = alloca double
%105 = alloca double
store i32 %0, i32* %47
store i32 %1, i32* %48
store double %2, double* %49
store double %3, double* %50
store double %4, double* %51
store double %5, double* %52
store double %6, double* %53
store double %7, double* %54
store double %8, double* %55
store double* %9, double** %56
store double* %10, double** %57
store double* %11, double** %58
store double* %12, double** %59
store double* %13, double** %60
store double* %14, double** %61
store double* %15, double** %62
store double* %16, double** %63
store double* %17, double** %64
store double* %18, double** %65
store double* %19, double** %66
store double* %20, double** %67
store double* %21, double** %68
store double* %22, double** %69
store double* %23, double** %70
store double* %24, double** %71
store double* %25, double** %72
store double* %26, double** %73
store double* %27, double** %74
store double* %28, double** %75
store double* %29, double** %76
store double* %30, double** %77
store double* %31, double** %78
store double* %32, double** %79
store double* %33, double** %80
store double* %34, double** %81
store double* %35, double** %82
store double* %36, double** %83
store double* %37, double** %84
store double* %38, double** %85
store double* %39, double** %86
store double* %40, double** %87
store double* %41, double** %88
store double* %42, double** %89
store double* %43, double** %90
store double* %44, double** %91
store double* %45, double** %92
store double 1.000000e+00, double* %105
%106 = load i32, i32* %48
%107 = icmp ne i32 %106, 0
br i1 %107, label %108, label %109
108: ; preds = %46
store double 0.000000e+00, double* %105
br label %109
109: ; preds = %108, %46
store i32 0, i32* %93
br label %110
110: ; preds = %1039, %109
%111 = load i32, i32* %93
%112 = load i32, i32* %47
%113 = icmp slt i32 %111, %112
br i1 %113, label %114, label %1042
114: ; preds = %110
%115 = load double, double* %49
%116 = load double*, double** %58
%117 = load i32, i32* %93
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds double, double* %116, i64 %118
%120 = load double, double* %119
%121 = call i32 (double, double, ...) bitcast (i32 (...)* @smoothedHeaviside to i32 (double, double, ...)*)(double %115, double %120)
%122 = sitofp i32 %121 to double
store double %122, double* %97
%123 = load double, double* %49
%124 = load double*, double** %58
%125 = load i32, i32* %93
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds double, double* %124, i64 %126
%128 = load double, double* %127
%129 = call i32 (double, double, ...) bitcast (i32 (...)* @smoothedDirac to i32 (double, double, ...)*)(double %123, double %128)
%130 = sitofp i32 %129 to double
store double %130, double* %98
%131 = load double, double* %50
%132 = load double*, double** %58
%133 = load i32, i32* %93
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds double, double* %132, i64 %134
%136 = load double, double* %135
%137 = call i32 (double, double, ...) bitcast (i32 (...)* @smoothedHeaviside to i32 (double, double, ...)*)(double %131, double %136)
%138 = sitofp i32 %137 to double
store double %138, double* %99
%139 = load double, double* %50
%140 = load double*, double** %58
%141 = load i32, i32* %93
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds double, double* %140, i64 %142
%144 = load double, double* %143
%145 = call i32 (double, double, ...) bitcast (i32 (...)* @smoothedDirac to i32 (double, double, ...)*)(double %139, double %144)
%146 = sitofp i32 %145 to double
store double %146, double* %100
%147 = load double, double* %52
%148 = load double, double* %97
%149 = fsub double 1.000000e+00, %148
%150 = load double, double* %54
%151 = load double, double* %97
%152 = fmul double %150, %151
%153 = call double @llvm.fmuladd.f64(double %147, double %149, double %152)
store double %153, double* %94
%154 = load double, double* %53
%155 = load double, double* %99
%156 = fsub double 1.000000e+00, %155
%157 = load double, double* %55
%158 = load double, double* %99
%159 = fmul double %157, %158
%160 = call double @llvm.fmuladd.f64(double %154, double %156, double %159)
store double %160, double* %95
%161 = load double, double* %52
%162 = load double, double* %53
%163 = fmul double %161, %162
%164 = load double, double* %99
%165 = fsub double 1.000000e+00, %164
%166 = load double, double* %54
%167 = load double, double* %55
%168 = fmul double %166, %167
%169 = load double, double* %99
%170 = fmul double %168, %169
%171 = call double @llvm.fmuladd.f64(double %163, double %165, double %170)
store double %171, double* %96
%172 = load double*, double** %65
%173 = load i32, i32* %93
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds double, double* %172, i64 %174
%176 = load double, double* %175
%177 = load double*, double** %63
%178 = load i32, i32* %93
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds double, double* %177, i64 %179
%181 = load double, double* %180
%182 = fmul double %176, %181
%183 = load double*, double** %66
%184 = load i32, i32* %93
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds double, double* %183, i64 %185
store double %182, double* %186
%187 = load double*, double** %65
%188 = load i32, i32* %93
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds double, double* %187, i64 %189
%191 = load double, double* %190
%192 = load double*, double** %67
%193 = load i32, i32* %93
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds double, double* %192, i64 %194
store double %191, double* %195
%196 = load double*, double** %65
%197 = load i32, i32* %93
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds double, double* %196, i64 %198
%200 = load double, double* %199
%201 = load double*, double** %64
%202 = load i32, i32* %93
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds double, double* %201, i64 %203
%205 = load double, double* %204
%206 = fmul double %200, %205
%207 = load double*, double** %68
%208 = load i32, i32* %93
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds double, double* %207, i64 %209
store double %206, double* %210
%211 = load double*, double** %65
%212 = load i32, i32* %93
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds double, double* %211, i64 %213
%215 = load double, double* %214
%216 = load double*, double** %69
%217 = load i32, i32* %93
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds double, double* %216, i64 %218
store double %215, double* %219
%220 = load double*, double** %65
%221 = load i32, i32* %93
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds double, double* %220, i64 %222
%224 = load double, double* %223
%225 = load double*, double** %63
%226 = load i32, i32* %93
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds double, double* %225, i64 %227
%229 = load double, double* %228
%230 = fmul double %224, %229
%231 = load double*, double** %70
%232 = load i32, i32* %93
%233 = mul nsw i32 %232, 2
%234 = add nsw i32 %233, 0
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds double, double* %231, i64 %235
store double %230, double* %236
%237 = load double*, double** %65
%238 = load i32, i32* %93
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds double, double* %237, i64 %239
%241 = load double, double* %240
%242 = load double*, double** %64
%243 = load i32, i32* %93
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds double, double* %242, i64 %244
%246 = load double, double* %245
%247 = fmul double %241, %246
%248 = load double*, double** %70
%249 = load i32, i32* %93
%250 = mul nsw i32 %249, 2
%251 = add nsw i32 %250, 1
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds double, double* %248, i64 %252
store double %247, double* %253
%254 = load double*, double** %65
%255 = load i32, i32* %93
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds double, double* %254, i64 %256
%258 = load double, double* %257
%259 = load double*, double** %71
%260 = load i32, i32* %93
%261 = mul nsw i32 %260, 2
%262 = add nsw i32 %261, 0
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds double, double* %259, i64 %263
store double %258, double* %264
%265 = load double*, double** %65
%266 = load i32, i32* %93
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds double, double* %265, i64 %267
%269 = load double, double* %268
%270 = load double*, double** %72
%271 = load i32, i32* %93
%272 = mul nsw i32 %271, 2
%273 = add nsw i32 %272, 1
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds double, double* %270, i64 %274
store double %269, double* %275
%276 = load double*, double** %65
%277 = load i32, i32* %93
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds double, double* %276, i64 %278
%280 = load double, double* %279
%281 = load double*, double** %63
%282 = load i32, i32* %93
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds double, double* %281, i64 %283
%285 = load double, double* %284
%286 = fmul double %280, %285
%287 = load double*, double** %63
%288 = load i32, i32* %93
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds double, double* %287, i64 %289
%291 = load double, double* %290
%292 = fmul double %286, %291
%293 = load double*, double** %73
%294 = load i32, i32* %93
%295 = mul nsw i32 %294, 2
%296 = add nsw i32 %295, 0
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds double, double* %293, i64 %297
store double %292, double* %298
%299 = load double*, double** %65
%300 = load i32, i32* %93
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds double, double* %299, i64 %301
%303 = load double, double* %302
%304 = load double*, double** %63
%305 = load i32, i32* %93
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds double, double* %304, i64 %306
%308 = load double, double* %307
%309 = fmul double %303, %308
%310 = load double*, double** %64
%311 = load i32, i32* %93
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds double, double* %310, i64 %312
%314 = load double, double* %313
%315 = fmul double %309, %314
%316 = load double*, double** %73
%317 = load i32, i32* %93
%318 = mul nsw i32 %317, 2
%319 = add nsw i32 %318, 1
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds double, double* %316, i64 %320
store double %315, double* %321
%322 = load double*, double** %65
%323 = load i32, i32* %93
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds double, double* %322, i64 %324
%326 = load double, double* %325
%327 = fmul double 2.000000e+00, %326
%328 = load double*, double** %63
%329 = load i32, i32* %93
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds double, double* %328, i64 %330
%332 = load double, double* %331
%333 = fmul double %327, %332
%334 = load double*, double** %74
%335 = load i32, i32* %93
%336 = mul nsw i32 %335, 2
%337 = add nsw i32 %336, 0
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds double, double* %334, i64 %338
store double %333, double* %339
%340 = load double*, double** %65
%341 = load i32, i32* %93
%342 = sext i32 %341 to i64
%343 = getelementptr inbounds double, double* %340, i64 %342
%344 = load double, double* %343
%345 = load double*, double** %64
%346 = load i32, i32* %93
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds double, double* %345, i64 %347
%349 = load double, double* %348
%350 = fmul double %344, %349
%351 = load double*, double** %74
%352 = load i32, i32* %93
%353 = mul nsw i32 %352, 2
%354 = add nsw i32 %353, 1
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds double, double* %351, i64 %355
store double %350, double* %356
%357 = load double*, double** %65
%358 = load i32, i32* %93
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds double, double* %357, i64 %359
%361 = load double, double* %360
%362 = load double*, double** %63
%363 = load i32, i32* %93
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds double, double* %362, i64 %364
%366 = load double, double* %365
%367 = fmul double %361, %366
%368 = load double*, double** %75
%369 = load i32, i32* %93
%370 = mul nsw i32 %369, 2
%371 = add nsw i32 %370, 1
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds double, double* %368, i64 %372
store double %367, double* %373
%374 = load double*, double** %65
%375 = load i32, i32* %93
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds double, double* %374, i64 %376
%378 = load double, double* %377
%379 = load double*, double** %64
%380 = load i32, i32* %93
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds double, double* %379, i64 %381
%383 = load double, double* %382
%384 = fmul double %378, %383
%385 = load double*, double** %63
%386 = load i32, i32* %93
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds double, double* %385, i64 %387
%389 = load double, double* %388
%390 = fmul double %384, %389
%391 = load double*, double** %76
%392 = load i32, i32* %93
%393 = mul nsw i32 %392, 2
%394 = add nsw i32 %393, 0
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds double, double* %391, i64 %395
store double %390, double* %396
%397 = load double*, double** %65
%398 = load i32, i32* %93
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds double, double* %397, i64 %399
%401 = load double, double* %400
%402 = load double*, double** %64
%403 = load i32, i32* %93
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds double, double* %402, i64 %404
%406 = load double, double* %405
%407 = fmul double %401, %406
%408 = load double*, double** %64
%409 = load i32, i32* %93
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds double, double* %408, i64 %410
%412 = load double, double* %411
%413 = fmul double %407, %412
%414 = load double*, double** %76
%415 = load i32, i32* %93
%416 = mul nsw i32 %415, 2
%417 = add nsw i32 %416, 1
%418 = sext i32 %417 to i64
%419 = getelementptr inbounds double, double* %414, i64 %418
store double %413, double* %419
%420 = load double*, double** %65
%421 = load i32, i32* %93
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds double, double* %420, i64 %422
%424 = load double, double* %423
%425 = load double*, double** %64
%426 = load i32, i32* %93
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds double, double* %425, i64 %427
%429 = load double, double* %428
%430 = fmul double %424, %429
%431 = load double*, double** %77
%432 = load i32, i32* %93
%433 = mul nsw i32 %432, 2
%434 = add nsw i32 %433, 0
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds double, double* %431, i64 %435
store double %430, double* %436
%437 = load double*, double** %65
%438 = load i32, i32* %93
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds double, double* %437, i64 %439
%441 = load double, double* %440
%442 = load double*, double** %63
%443 = load i32, i32* %93
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds double, double* %442, i64 %444
%446 = load double, double* %445
%447 = fmul double %441, %446
%448 = load double*, double** %78
%449 = load i32, i32* %93
%450 = mul nsw i32 %449, 2
%451 = add nsw i32 %450, 0
%452 = sext i32 %451 to i64
%453 = getelementptr inbounds double, double* %448, i64 %452
store double %447, double* %453
%454 = load double*, double** %65
%455 = load i32, i32* %93
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds double, double* %454, i64 %456
%458 = load double, double* %457
%459 = fmul double 2.000000e+00, %458
%460 = load double*, double** %64
%461 = load i32, i32* %93
%462 = sext i32 %461 to i64
%463 = getelementptr inbounds double, double* %460, i64 %462
%464 = load double, double* %463
%465 = fmul double %459, %464
%466 = load double*, double** %78
%467 = load i32, i32* %93
%468 = mul nsw i32 %467, 2
%469 = add nsw i32 %468, 1
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds double, double* %466, i64 %470
store double %465, double* %471
%472 = load double*, double** %65
%473 = load i32, i32* %93
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds double, double* %472, i64 %474
%476 = load double, double* %475
%477 = fmul double 2.000000e+00, %476
%478 = load double, double* %95
%479 = fmul double %477, %478
%480 = load double*, double** %79
%481 = load i32, i32* %93
%482 = mul nsw i32 %481, 4
%483 = add nsw i32 %482, 0
%484 = sext i32 %483 to i64
%485 = getelementptr inbounds double, double* %480, i64 %484
store double %479, double* %485
%486 = load double*, double** %65
%487 = load i32, i32* %93
%488 = sext i32 %487 to i64
%489 = getelementptr inbounds double, double* %486, i64 %488
%490 = load double, double* %489
%491 = load double, double* %95
%492 = fmul double %490, %491
%493 = load double*, double** %79
%494 = load i32, i32* %93
%495 = mul nsw i32 %494, 4
%496 = add nsw i32 %495, 3
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds double, double* %493, i64 %497
store double %492, double* %498
%499 = load double*, double** %65
%500 = load i32, i32* %93
%501 = sext i32 %500 to i64
%502 = getelementptr inbounds double, double* %499, i64 %501
%503 = load double, double* %502
%504 = load double, double* %95
%505 = fmul double %503, %504
%506 = load double*, double** %81
%507 = load i32, i32* %93
%508 = mul nsw i32 %507, 4
%509 = add nsw i32 %508, 2
%510 = sext i32 %509 to i64
%511 = getelementptr inbounds double, double* %506, i64 %510
store double %505, double* %511
%512 = load double*, double** %65
%513 = load i32, i32* %93
%514 = sext i32 %513 to i64
%515 = getelementptr inbounds double, double* %512, i64 %514
%516 = load double, double* %515
%517 = load double, double* %95
%518 = fmul double %516, %517
%519 = load double*, double** %80
%520 = load i32, i32* %93
%521 = mul nsw i32 %520, 4
%522 = add nsw i32 %521, 0
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds double, double* %519, i64 %523
store double %518, double* %524
%525 = load double*, double** %65
%526 = load i32, i32* %93
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds double, double* %525, i64 %527
%529 = load double, double* %528
%530 = fmul double 2.000000e+00, %529
%531 = load double, double* %95
%532 = fmul double %530, %531
%533 = load double*, double** %80
%534 = load i32, i32* %93
%535 = mul nsw i32 %534, 4
%536 = add nsw i32 %535, 3
%537 = sext i32 %536 to i64
%538 = getelementptr inbounds double, double* %533, i64 %537
store double %532, double* %538
%539 = load double*, double** %65
%540 = load i32, i32* %93
%541 = sext i32 %540 to i64
%542 = getelementptr inbounds double, double* %539, i64 %541
%543 = load double, double* %542
%544 = load double, double* %95
%545 = fmul double %543, %544
%546 = load double*, double** %82
%547 = load i32, i32* %93
%548 = mul nsw i32 %547, 4
%549 = add nsw i32 %548, 1
%550 = sext i32 %549 to i64
%551 = getelementptr inbounds double, double* %546, i64 %550
store double %545, double* %551
%552 = load double*, double** %59
%553 = load i32, i32* %93
%554 = mul nsw i32 %553, 2
%555 = add nsw i32 %554, 0
%556 = sext i32 %555 to i64
%557 = getelementptr inbounds double, double* %552, i64 %556
%558 = load double, double* %557
%559 = load double*, double** %59
%560 = load i32, i32* %93
%561 = mul nsw i32 %560, 2
%562 = add nsw i32 %561, 0
%563 = sext i32 %562 to i64
%564 = getelementptr inbounds double, double* %559, i64 %563
%565 = load double, double* %564
%566 = load double*, double** %59
%567 = load i32, i32* %93
%568 = mul nsw i32 %567, 2
%569 = add nsw i32 %568, 1
%570 = sext i32 %569 to i64
%571 = getelementptr inbounds double, double* %566, i64 %570
%572 = load double, double* %571
%573 = load double*, double** %59
%574 = load i32, i32* %93
%575 = mul nsw i32 %574, 2
%576 = add nsw i32 %575, 1
%577 = sext i32 %576 to i64
%578 = getelementptr inbounds double, double* %573, i64 %577
%579 = load double, double* %578
%580 = fmul double %572, %579
%581 = call double @llvm.fmuladd.f64(double %558, double %565, double %580)
%582 = call double @sqrt(double %581)
store double %582, double* %101
%583 = load double*, double** %63
%584 = load i32, i32* %93
%585 = sext i32 %584 to i64
%586 = getelementptr inbounds double, double* %583, i64 %585
%587 = load double, double* %586
%588 = load double*, double** %63
%589 = load i32, i32* %93
%590 = sext i32 %589 to i64
%591 = getelementptr inbounds double, double* %588, i64 %590
%592 = load double, double* %591
%593 = load double*, double** %64
%594 = load i32, i32* %93
%595 = sext i32 %594 to i64
%596 = getelementptr inbounds double, double* %593, i64 %595
%597 = load double, double* %596
%598 = load double*, double** %64
%599 = load i32, i32* %93
%600 = sext i32 %599 to i64
%601 = getelementptr inbounds double, double* %598, i64 %600
%602 = load double, double* %601
%603 = fmul double %597, %602
%604 = call double @llvm.fmuladd.f64(double %587, double %592, double %603)
%605 = call double @sqrt(double %604)
store double %605, double* %104
%606 = load double*, double** %65
%607 = load i32, i32* %93
%608 = sext i32 %607 to i64
%609 = getelementptr inbounds double, double* %606, i64 %608
%610 = load double, double* %609
%611 = fsub double 1.000000e+00, %610
%612 = call double @llvm.fabs.f64(double %611)
%613 = fcmp olt double %612, 0x3E7AD7F29ABCAF48
br i1 %613, label %614, label %615
614: ; preds = %114
store double 0.000000e+00, double* %102
br label %637
615: ; preds = %114
%616 = load double*, double** %65
%617 = load i32, i32* %93
%618 = sext i32 %617 to i64
%619 = getelementptr inbounds double, double* %616, i64 %618
%620 = load double, double* %619
%621 = load double*, double** %56
%622 = load i32, i32* %93
%623 = sext i32 %622 to i64
%624 = getelementptr inbounds double, double* %621, i64 %623
%625 = load double, double* %624
%626 = fmul double %620, %625
%627 = fmul double %626, 1.000000e-02
%628 = load double*, double** %65
%629 = load i32, i32* %93
%630 = sext i32 %629 to i64
%631 = getelementptr inbounds double, double* %628, i64 %630
%632 = load double, double* %631
%633 = fsub double 1.000000e+00, %632
%634 = fdiv double %627, %633
%635 = load double, double* %95
%636 = fdiv double %634, %635
store double %636, double* %102
br label %637
637: ; preds = %615, %614
%638 = load double, double* %105
%639 = load double, double* %102
%640 = fmul double %639, %638
store double %640, double* %102
%641 = load double*, double** %65
%642 = load i32, i32* %93
%643 = sext i32 %642 to i64
%644 = getelementptr inbounds double, double* %641, i64 %643
%645 = load double, double* %644
%646 = call double @llvm.fabs.f64(double %645)
%647 = fcmp olt double %646, 0x3E7AD7F29ABCAF48
br i1 %647, label %648, label %649
648: ; preds = %637
store double 0.000000e+00, double* %103
br label %694
649: ; preds = %637
%650 = load double*, double** %65
%651 = load i32, i32* %93
%652 = sext i32 %651 to i64
%653 = getelementptr inbounds double, double* %650, i64 %652
%654 = load double, double* %653
%655 = fsub double 1.000000e+00, %654
%656 = fmul double 1.800000e+02, %655
%657 = load double*, double** %65
%658 = load i32, i32* %93
%659 = sext i32 %658 to i64
%660 = getelementptr inbounds double, double* %657, i64 %659
%661 = load double, double* %660
%662 = fsub double 1.000000e+00, %661
%663 = fmul double %656, %662
%664 = load double*, double** %56
%665 = load i32, i32* %93
%666 = sext i32 %665 to i64
%667 = getelementptr inbounds double, double* %664, i64 %666
%668 = load double, double* %667
%669 = load double*, double** %56
%670 = load i32, i32* %93
%671 = sext i32 %670 to i64
%672 = getelementptr inbounds double, double* %669, i64 %671
%673 = load double, double* %672
%674 = fmul double %668, %673
%675 = load double*, double** %65
%676 = load i32, i32* %93
%677 = sext i32 %676 to i64
%678 = getelementptr inbounds double, double* %675, i64 %677
%679 = load double, double* %678
%680 = fmul double %674, %679
%681 = load double*, double** %65
%682 = load i32, i32* %93
%683 = sext i32 %682 to i64
%684 = getelementptr inbounds double, double* %681, i64 %683
%685 = load double, double* %684
%686 = fmul double %680, %685
%687 = load double*, double** %65
%688 = load i32, i32* %93
%689 = sext i32 %688 to i64
%690 = getelementptr inbounds double, double* %687, i64 %689
%691 = load double, double* %690
%692 = fmul double %686, %691
%693 = fdiv double %663, %692
store double %693, double* %103
br label %694
694: ; preds = %649, %648
%695 = load double*, double** %65
%696 = load i32, i32* %93
%697 = sext i32 %696 to i64
%698 = getelementptr inbounds double, double* %695, i64 %697
%699 = load double, double* %698
%700 = fneg double %699
%701 = load double*, double** %57
%702 = getelementptr inbounds double, double* %701, i64 0
%703 = load double, double* %702
%704 = load double*, double** %65
%705 = load i32, i32* %93
%706 = sext i32 %705 to i64
%707 = getelementptr inbounds double, double* %704, i64 %706
%708 = load double, double* %707
%709 = load double, double* %100
%710 = fmul double %708, %709
%711 = load double, double* %51
%712 = fmul double %710, %711
%713 = load double*, double** %60
%714 = load i32, i32* %93
%715 = sext i32 %714 to i64
%716 = getelementptr inbounds double, double* %713, i64 %715
%717 = load double, double* %716
%718 = fmul double %712, %717
%719 = load double*, double** %59
%720 = load i32, i32* %93
%721 = mul nsw i32 %720, 2
%722 = add nsw i32 %721, 0
%723 = sext i32 %722 to i64
%724 = getelementptr inbounds double, double* %719, i64 %723
%725 = load double, double* %724
%726 = fmul double %718, %725
%727 = load double, double* %101
%728 = fdiv double %726, %727
%729 = fneg double %728
%730 = call double @llvm.fmuladd.f64(double %700, double %703, double %729)
%731 = load double*, double** %65
%732 = load i32, i32* %93
%733 = sext i32 %732 to i64
%734 = getelementptr inbounds double, double* %731, i64 %733
%735 = load double, double* %734
%736 = load double*, double** %65
%737 = load i32, i32* %93
%738 = sext i32 %737 to i64
%739 = getelementptr inbounds double, double* %736, i64 %738
%740 = load double, double* %739
%741 = fmul double %735, %740
%742 = load double, double* %95
%743 = fmul double %741, %742
%744 = load double, double* %103
%745 = fmul double %743, %744
%746 = load double, double* %102
%747 = load double, double* %104
%748 = call double @llvm.fmuladd.f64(double %746, double %747, double 1.000000e+00)
%749 = fmul double %745, %748
%750 = load double*, double** %63
%751 = load i32, i32* %93
%752 = sext i32 %751 to i64
%753 = getelementptr inbounds double, double* %750, i64 %752
%754 = load double, double* %753
%755 = call double @llvm.fmuladd.f64(double %749, double %754, double %730)
%756 = load double*, double** %83
%757 = load i32, i32* %93
%758 = sext i32 %757 to i64
%759 = getelementptr inbounds double, double* %756, i64 %758
store double %755, double* %759
%760 = load double*, double** %65
%761 = load i32, i32* %93
%762 = sext i32 %761 to i64
%763 = getelementptr inbounds double, double* %760, i64 %762
%764 = load double, double* %763
%765 = fneg double %764
%766 = load double, double* %94
%767 = fmul double %765, %766
%768 = load double*, double** %57
%769 = getelementptr inbounds double, double* %768, i64 1
%770 = load double, double* %769
%771 = load double*, double** %65
%772 = load i32, i32* %93
%773 = sext i32 %772 to i64
%774 = getelementptr inbounds double, double* %771, i64 %773
%775 = load double, double* %774
%776 = load double, double* %100
%777 = fmul double %775, %776
%778 = load double, double* %51
%779 = fmul double %777, %778
%780 = load double*, double** %60
%781 = load i32, i32* %93
%782 = sext i32 %781 to i64
%783 = getelementptr inbounds double, double* %780, i64 %782
%784 = load double, double* %783
%785 = fmul double %779, %784
%786 = load double*, double** %59
%787 = load i32, i32* %93
%788 = mul nsw i32 %787, 2
%789 = add nsw i32 %788, 1
%790 = sext i32 %789 to i64
%791 = getelementptr inbounds double, double* %786, i64 %790
%792 = load double, double* %791
%793 = fmul double %785, %792
%794 = load double, double* %101
%795 = fdiv double %793, %794
%796 = fneg double %795
%797 = call double @llvm.fmuladd.f64(double %767, double %770, double %796)
%798 = load double*, double** %65
%799 = load i32, i32* %93
%800 = sext i32 %799 to i64
%801 = getelementptr inbounds double, double* %798, i64 %800
%802 = load double, double* %801
%803 = load double*, double** %65
%804 = load i32, i32* %93
%805 = sext i32 %804 to i64
%806 = getelementptr inbounds double, double* %803, i64 %805
%807 = load double, double* %806
%808 = fmul double %802, %807
%809 = load double, double* %95
%810 = fmul double %808, %809
%811 = load double, double* %103
%812 = fmul double %810, %811
%813 = load double, double* %102
%814 = load double, double* %104
%815 = call double @llvm.fmuladd.f64(double %813, double %814, double 1.000000e+00)
%816 = fmul double %812, %815
%817 = load double*, double** %64
%818 = load i32, i32* %93
%819 = sext i32 %818 to i64
%820 = getelementptr inbounds double, double* %817, i64 %819
%821 = load double, double* %820
%822 = call double @llvm.fmuladd.f64(double %816, double %821, double %797)
%823 = load double*, double** %84
%824 = load i32, i32* %93
%825 = sext i32 %824 to i64
%826 = getelementptr inbounds double, double* %823, i64 %825
store double %822, double* %826
%827 = load double*, double** %65
%828 = load i32, i32* %93
%829 = sext i32 %828 to i64
%830 = getelementptr inbounds double, double* %827, i64 %829
%831 = load double, double* %830
%832 = load double*, double** %65
%833 = load i32, i32* %93
%834 = sext i32 %833 to i64
%835 = getelementptr inbounds double, double* %832, i64 %834
%836 = load double, double* %835
%837 = fmul double %831, %836
%838 = load double, double* %95
%839 = fmul double %837, %838
%840 = load double, double* %103
%841 = fmul double %839, %840
%842 = load double, double* %102
%843 = load double, double* %104
%844 = load double*, double** %63
%845 = load i32, i32* %93
%846 = sext i32 %845 to i64
%847 = getelementptr inbounds double, double* %844, i64 %846
%848 = load double, double* %847
%849 = load double*, double** %63
%850 = load i32, i32* %93
%851 = sext i32 %850 to i64
%852 = getelementptr inbounds double, double* %849, i64 %851
%853 = load double, double* %852
%854 = fmul double %848, %853
%855 = load double, double* %104
%856 = fadd double %855, 0x3D719799812DEA11
%857 = fdiv double %854, %856
%858 = fadd double %843, %857
%859 = call double @llvm.fmuladd.f64(double %842, double %858, double 1.000000e+00)
%860 = fmul double %841, %859
%861 = load double*, double** %85
%862 = load i32, i32* %93
%863 = sext i32 %862 to i64
%864 = getelementptr inbounds double, double* %861, i64 %863
store double %860, double* %864
%865 = load double*, double** %65
%866 = load i32, i32* %93
%867 = sext i32 %866 to i64
%868 = getelementptr inbounds double, double* %865, i64 %867
%869 = load double, double* %868
%870 = load double*, double** %65
%871 = load i32, i32* %93
%872 = sext i32 %871 to i64
%873 = getelementptr inbounds double, double* %870, i64 %872
%874 = load double, double* %873
%875 = fmul double %869, %874
%876 = load double, double* %95
%877 = fmul double %875, %876
%878 = load double, double* %103
%879 = fmul double %877, %878
%880 = load double, double* %102
%881 = load double*, double** %63
%882 = load i32, i32* %93
%883 = sext i32 %882 to i64
%884 = getelementptr inbounds double, double* %881, i64 %883
%885 = load double, double* %884
%886 = load double*, double** %64
%887 = load i32, i32* %93
%888 = sext i32 %887 to i64
%889 = getelementptr inbounds double, double* %886, i64 %888
%890 = load double, double* %889
%891 = fmul double %885, %890
%892 = load double, double* %104
%893 = fadd double %892, 0x3D719799812DEA11
%894 = fdiv double %891, %893
%895 = call double @llvm.fmuladd.f64(double %880, double %894, double 0.000000e+00)
%896 = fmul double %879, %895
%897 = load double*, double** %86
%898 = load i32, i32* %93
%899 = sext i32 %898 to i64
%900 = getelementptr inbounds double, double* %897, i64 %899
store double %896, double* %900
%901 = load double*, double** %65
%902 = load i32, i32* %93
%903 = sext i32 %902 to i64
%904 = getelementptr inbounds double, double* %901, i64 %903
%905 = load double, double* %904
%906 = load double*, double** %65
%907 = load i32, i32* %93
%908 = sext i32 %907 to i64
%909 = getelementptr inbounds double, double* %906, i64 %908
%910 = load double, double* %909
%911 = fmul double %905, %910
%912 = load double, double* %95
%913 = fmul double %911, %912
%914 = load double, double* %103
%915 = fmul double %913, %914
%916 = load double, double* %102
%917 = load double, double* %104
%918 = load double*, double** %64
%919 = load i32, i32* %93
%920 = sext i32 %919 to i64
%921 = getelementptr inbounds double, double* %918, i64 %920
%922 = load double, double* %921
%923 = load double*, double** %64
%924 = load i32, i32* %93
%925 = sext i32 %924 to i64
%926 = getelementptr inbounds double, double* %923, i64 %925
%927 = load double, double* %926
%928 = fmul double %922, %927
%929 = load double, double* %104
%930 = fadd double %929, 0x3D719799812DEA11
%931 = fdiv double %928, %930
%932 = fadd double %917, %931
%933 = call double @llvm.fmuladd.f64(double %916, double %932, double 1.000000e+00)
%934 = fmul double %915, %933
%935 = load double*, double** %88
%936 = load i32, i32* %93
%937 = sext i32 %936 to i64
%938 = getelementptr inbounds double, double* %935, i64 %937
store double %934, double* %938
%939 = load double*, double** %65
%940 = load i32, i32* %93
%941 = sext i32 %940 to i64
%942 = getelementptr inbounds double, double* %939, i64 %941
%943 = load double, double* %942
%944 = load double*, double** %65
%945 = load i32, i32* %93
%946 = sext i32 %945 to i64
%947 = getelementptr inbounds double, double* %944, i64 %946
%948 = load double, double* %947
%949 = fmul double %943, %948
%950 = load double, double* %95
%951 = fmul double %949, %950
%952 = load double, double* %103
%953 = fmul double %951, %952
%954 = load double, double* %102
%955 = load double*, double** %63
%956 = load i32, i32* %93
%957 = sext i32 %956 to i64
%958 = getelementptr inbounds double, double* %955, i64 %957
%959 = load double, double* %958
%960 = load double*, double** %64
%961 = load i32, i32* %93
%962 = sext i32 %961 to i64
%963 = getelementptr inbounds double, double* %960, i64 %962
%964 = load double, double* %963
%965 = fmul double %959, %964
%966 = load double, double* %104
%967 = fadd double %966, 0x3D719799812DEA11
%968 = fdiv double %965, %967
%969 = call double @llvm.fmuladd.f64(double %954, double %968, double 0.000000e+00)
%970 = fmul double %953, %969
%971 = load double*, double** %87
%972 = load i32, i32* %93
%973 = sext i32 %972 to i64
%974 = getelementptr inbounds double, double* %971, i64 %973
store double %970, double* %974
%975 = load double*, double** %65
%976 = load i32, i32* %93
%977 = sext i32 %976 to i64
%978 = getelementptr inbounds double, double* %975, i64 %977
%979 = load double, double* %978
%980 = load double*, double** %62
%981 = load i32, i32* %93
%982 = mul nsw i32 %981, 2
%983 = add nsw i32 %982, 0
%984 = sext i32 %983 to i64
%985 = getelementptr inbounds double, double* %980, i64 %984
%986 = load double, double* %985
%987 = fmul double %979, %986
%988 = load double, double* %94
%989 = fdiv double %987, %988
%990 = load double*, double** %89
%991 = load i32, i32* %93
%992 = sext i32 %991 to i64
%993 = getelementptr inbounds double, double* %990, i64 %992
store double %989, double* %993
%994 = load double*, double** %65
%995 = load i32, i32* %93
%996 = sext i32 %995 to i64
%997 = getelementptr inbounds double, double* %994, i64 %996
%998 = load double, double* %997
%999 = load double, double* %94
%1000 = fdiv double %998, %999
%1001 = load double*, double** %90
%1002 = load i32, i32* %93
%1003 = mul nsw i32 %1002, 2
%1004 = add nsw i32 %1003, 0
%1005 = sext i32 %1004 to i64
%1006 = getelementptr inbounds double, double* %1001, i64 %1005
store double %1000, double* %1006
%1007 = load double*, double** %65
%1008 = load i32, i32* %93
%1009 = sext i32 %1008 to i64
%1010 = getelementptr inbounds double, double* %1007, i64 %1009
%1011 = load double, double* %1010
%1012 = load double*, double** %62
%1013 = load i32, i32* %93
%1014 = mul nsw i32 %1013, 2
%1015 = add nsw i32 %1014, 1
%1016 = sext i32 %1015 to i64
%1017 = getelementptr inbounds double, double* %1012, i64 %1016
%1018 = load double, double* %1017
%1019 = fmul double %1011, %1018
%1020 = load double, double* %94
%1021 = fdiv double %1019, %1020
%1022 = load double*, double** %91
%1023 = load i32, i32* %93
%1024 = sext i32 %1023 to i64
%1025 = getelementptr inbounds double, double* %1022, i64 %1024
store double %1021, double* %1025
%1026 = load double*, double** %65
%1027 = load i32, i32* %93
%1028 = sext i32 %1027 to i64
%1029 = getelementptr inbounds double, double* %1026, i64 %1028
%1030 = load double, double* %1029
%1031 = load double, double* %94
%1032 = fdiv double %1030, %1031
%1033 = load double*, double** %92
%1034 = load i32, i32* %93
%1035 = mul nsw i32 %1034, 2
%1036 = add nsw i32 %1035, 1
%1037 = sext i32 %1036 to i64
%1038 = getelementptr inbounds double, double* %1033, i64 %1037
store double %1032, double* %1038
br label %1039
1039: ; preds = %694
%1040 = load i32, i32* %93
%1041 = add nsw i32 %1040, 1
store i32 %1041, i32* %93
br label %110
1042: ; preds = %110
ret void
}

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