void VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate_sd(
    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, uc, Ftilde, Kinv;
  const double div_eps = 1.0e-6;
  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 * 2 + 0] = 2.0 * porosity[k] * nu;
    mom_u_diff_ten[k * 2 + 1] = porosity[k] * nu;
    mom_uv_diff_ten[k] = porosity[k] * nu;
    mom_v_diff_ten[k * 2 + 0] = porosity[k] * nu;
    mom_v_diff_ten[k * 2 + 1] = 2.0 * nu * porosity[k];
    mom_vu_diff_ten[k] = nu * porosity[k];
    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] * 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) +
        porosity[k] * porosity[k] * nu * Kinv * Ftilde * u[k] * u[k] /
            (uc + div_eps);
    dmom_u_source_v[k] = porosity[k] * porosity[k] * nu * Kinv * Ftilde * u[k] *
                         v[k] / (uc + div_eps);
    dmom_v_source_v[k] =
        porosity[k] * porosity[k] * nu * Kinv * (1.0 + Ftilde * uc) +
        porosity[k] * porosity[k] * nu * Kinv * Ftilde * v[k] * v[k] /
            (uc + div_eps);
    dmom_v_source_u[k] = porosity[k] * porosity[k] * nu * Kinv * Ftilde * u[k] *
                         v[k] / (uc + div_eps);
    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_sd>:
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  0xdcf(%rip),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  0xdb7(%rip),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
cmpl   $0x0,-0x8(%rbp)
je     1266 <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate_sd+0x136>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1f30 <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate_sd+0xe00>
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  0xce6(%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  0xcb7(%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  0xc83(%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  0xac8(%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  0x948(%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  0x90e(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    0xa8(%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
mulsd  -0x78(%rbp),%xmm0
mov    0xa8(%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
mulsd  -0x78(%rbp),%xmm0
mov    0xb8(%rbp),%rax
movslq -0x64(%rbp),%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    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x86e(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0xb0(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0xc0(%rbp),%rax
movslq -0x64(%rbp),%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,-0xb0(%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  0x740(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    18ea <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate_sd+0x7ba>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    1936 <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate_sd+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  0x714(%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,-0xb8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x6ce(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x6a2(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1988 <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate_sd+0x858>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    1a0f <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate_sd+0x8df>
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  0x668(%rip),%xmm1
subsd  (%rax,%rcx,8),%xmm1
movsd  0x683(%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,-0xc0(%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  -0xc0(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0xb0(%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
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  -0xc0(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm2
movsd  0x41f(%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  -0xc0(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm2
movsd  0x3af(%rip),%xmm1
addsd  %xmm1,%xmm2
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  -0xc0(%rbp),%xmm1
ff
mulsd  -0xb8(%rbp),%xmm1
ff
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x362(%rip),%xmm3
addsd  -0xb0(%rbp),%xmm3
ff
divsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %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  -0xc0(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
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
movsd  0x2ed(%rip),%xmm1
addsd  -0xb0(%rbp),%xmm1
ff
divsd  %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  -0xc0(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm2
movsd  0x286(%rip),%xmm1
addsd  %xmm1,%xmm2
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  -0xc0(%rbp),%xmm1
ff
mulsd  -0xb8(%rbp),%xmm1
ff
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x239(%rip),%xmm3
addsd  -0xb0(%rbp),%xmm3
ff
divsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %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  -0xc0(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
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
movsd  0x1c4(%rip),%xmm1
addsd  -0xb0(%rbp),%xmm1
ff
divsd  %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    126d <VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate_sd+0x13d>
add    $0xd0,%rsp
pop    %rbp
ret

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

LLVM IR (-O2):
define void @VolumeAveragedTwophaseNavierStokes_ST_LS_SO_2D_Evaluate_sd(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 %315
50: ; preds = %46
%51 = getelementptr inbounds double, double* %10, i64 1
%52 = zext i32 %0 to i64
br label %53
53: ; preds = %50, %211
%54 = phi i64 [ 0, %50 ], [ %313, %211 ]
%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 = getelementptr inbounds double, double* %32, i64 %91
store double %152, double* %153
%154 = load double, double* %73
%155 = fmul double %72, %154
%156 = getelementptr inbounds double, double* %32, i64 %96
store double %155, double* %156
%157 = load double, double* %73
%158 = fmul double %72, %157
%159 = getelementptr inbounds double, double* %34, i64 %54
store double %158, double* %159
%160 = load double, double* %73
%161 = fmul double %72, %160
%162 = getelementptr inbounds double, double* %33, i64 %91
store double %161, double* %162
%163 = fmul double %72, 2.000000e+00
%164 = load double, double* %73
%165 = fmul double %163, %164
%166 = getelementptr inbounds double, double* %33, i64 %96
store double %165, double* %166
%167 = load double, double* %73
%168 = fmul double %72, %167
%169 = getelementptr inbounds double, double* %35, i64 %54
store double %168, double* %169
%170 = getelementptr inbounds double, double* %12, i64 %91
%171 = load double, double* %170
%172 = getelementptr inbounds double, double* %12, i64 %96
%173 = load double, double* %172
%174 = fmul double %173, %173
%175 = tail call double @llvm.fmuladd.f64(double %171, double %171, double %174)
%176 = tail call double @sqrt(double %175)
%177 = load double, double* %75
%178 = load double, double* %82
%179 = fmul double %178, %178
%180 = tail call double @llvm.fmuladd.f64(double %177, double %177, double %179)
%181 = tail call double @sqrt(double %180)
%182 = load double, double* %73
%183 = fsub double 1.000000e+00, %182
%184 = tail call double @llvm.fabs.f64(double %183)
%185 = fcmp olt double %184, 0x3E7AD7F29ABCAF48
br i1 %185, label %193, label %186
186: ; preds = %53
%187 = getelementptr inbounds double, double* %9, i64 %54
%188 = load double, double* %187
%189 = fmul double %182, %188
%190 = fmul double %189, 1.000000e-02
%191 = fdiv double %190, %183
%192 = fdiv double %191, %72
br label %193
193: ; preds = %53, %186
%194 = phi double [ %192, %186 ], [ 0.000000e+00, %53 ]
%195 = fmul double %48, %194
%196 = tail call double @llvm.fabs.f64(double %182)
%197 = fcmp olt double %196, 0x3E7AD7F29ABCAF48
br i1 %197, label %211, label %198
198: ; preds = %193
%199 = getelementptr inbounds double, double* %9, i64 %54
%200 = load double, double* %199
%201 = fmul double %200, %200
%202 = fmul double %182, %201
%203 = insertelement <2 x double> poison, double %183, i64 0
%204 = insertelement <2 x double> %203, double %182, i64 1
%205 = insertelement <2 x double> <double 1.800000e+02, double poison>, double %202, i64 1
%206 = fmul <2 x double> %204, %205
%207 = fmul <2 x double> %204, %206
%208 = extractelement <2 x double> %207, i64 0
%209 = extractelement <2 x double> %207, i64 1
%210 = fdiv double %208, %209
br label %211
211: ; preds = %193, %198
%212 = phi double [ %210, %198 ], [ 0.000000e+00, %193 ]
%213 = fneg double %182
%214 = load double, double* %10
%215 = getelementptr inbounds double, double* %13, i64 %54
%216 = load double, double* %215
%217 = load double, double* %170
%218 = fmul double %66, %213
%219 = fmul double %218, %4
%220 = fmul double %219, %216
%221 = fmul double %220, %217
%222 = fdiv double %221, %176
%223 = tail call double @llvm.fmuladd.f64(double %213, double %214, double %222)
%224 = fmul double %182, %182
%225 = fmul double %72, %224
%226 = fmul double %225, %212
%227 = tail call double @llvm.fmuladd.f64(double %195, double %181, double 1.000000e+00)
%228 = fmul double %227, %226
%229 = load double, double* %75
%230 = tail call double @llvm.fmuladd.f64(double %228, double %229, double %223)
%231 = getelementptr inbounds double, double* %36, i64 %54
store double %230, double* %231
%232 = load double, double* %73
%233 = fneg double %232
%234 = load double, double* %51
%235 = load double, double* %215
%236 = load double, double* %172
%237 = fmul double %66, %233
%238 = fmul double %237, %4
%239 = fmul double %238, %235
%240 = fmul double %239, %236
%241 = fdiv double %240, %176
%242 = tail call double @llvm.fmuladd.f64(double %233, double %234, double %241)
%243 = fmul double %232, %232
%244 = fmul double %72, %243
%245 = fmul double %212, %244
%246 = fmul double %227, %245
%247 = load double, double* %82
%248 = tail call double @llvm.fmuladd.f64(double %246, double %247, double %242)
%249 = getelementptr inbounds double, double* %37, i64 %54
store double %248, double* %249
%250 = load double, double* %73
%251 = fmul double %250, %250
%252 = fmul double %72, %251
%253 = fmul double %212, %252
%254 = fmul double %195, %253
%255 = load double, double* %75
%256 = fmul double %255, %254
%257 = fmul double %255, %256
%258 = fadd double %181, 0x3EB0C6F7A0B5ED8D
%259 = fdiv double %257, %258
%260 = tail call double @llvm.fmuladd.f64(double %253, double %227, double %259)
%261 = getelementptr inbounds double, double* %38, i64 %54
store double %260, double* %261
%262 = load double, double* %73
%263 = fmul double %262, %262
%264 = fmul double %72, %263
%265 = fmul double %212, %264
%266 = fmul double %195, %265
%267 = load double, double* %75
%268 = fmul double %267, %266
%269 = load double, double* %82
%270 = fmul double %269, %268
%271 = fdiv double %270, %258
%272 = getelementptr inbounds double, double* %39, i64 %54
store double %271, double* %272
%273 = load double, double* %73
%274 = fmul double %273, %273
%275 = fmul double %72, %274
%276 = fmul double %212, %275
%277 = fmul double %195, %276
%278 = load double, double* %82
%279 = fmul double %278, %277
%280 = fmul double %278, %279
%281 = fdiv double %280, %258
%282 = tail call double @llvm.fmuladd.f64(double %276, double %227, double %281)
%283 = getelementptr inbounds double, double* %41, i64 %54
store double %282, double* %283
%284 = load double, double* %73
%285 = fmul double %284, %284
%286 = fmul double %72, %285
%287 = fmul double %212, %286
%288 = fmul double %195, %287
%289 = load double, double* %75
%290 = fmul double %289, %288
%291 = load double, double* %82
%292 = fmul double %291, %290
%293 = fdiv double %292, %258
%294 = getelementptr inbounds double, double* %40, i64 %54
store double %293, double* %294
%295 = load double, double* %73
%296 = getelementptr inbounds double, double* %15, i64 %91
%297 = load double, double* %296
%298 = fmul double %295, %297
%299 = fdiv double %298, %69
%300 = getelementptr inbounds double, double* %42, i64 %54
store double %299, double* %300
%301 = load double, double* %73
%302 = fdiv double %301, %69
%303 = getelementptr inbounds double, double* %43, i64 %91
store double %302, double* %303
%304 = load double, double* %73
%305 = getelementptr inbounds double, double* %15, i64 %96
%306 = load double, double* %305
%307 = fmul double %304, %306
%308 = fdiv double %307, %69
%309 = getelementptr inbounds double, double* %44, i64 %54
store double %308, double* %309
%310 = load double, double* %73
%311 = fdiv double %310, %69
%312 = getelementptr inbounds double, double* %45, i64 %96
store double %311, double* %312
%313 = add nuw nsw i64 %54, 1
%314 = icmp eq i64 %313, %52
br i1 %314, label %315, label %53
315: ; preds = %211, %46
ret void
}