void ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate(
    const int nPoints, const double boundaryPenaltyCoef,
    const double volumePenaltyCoef, 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 rho_s,
    const double nu_s, const double *g, const double *phi, const double *n,
    const double *kappa, const double *phi_s, const double *n_s,
    const double *p, const double *grad_p, const double *u, const double *v,
    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 *dmom_u_source_u, double *dmom_u_source_v, double *mom_v_source,
    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, H_rho_s, d_rho_s, H_mu_s,
      d_mu_s, norm_n, norm_n_s, volumeFlux, sp;
  int quadraticPenalty = 0, sipgPenalty = 1.0;
  sp = (double)(sipgPenalty);
  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;
    H_rho_s = smoothedHeaviside(eps_rho, phi_s[k]);
    d_rho_s = smoothedDirac(eps_rho, phi_s[k]);
    H_mu_s = smoothedHeaviside(eps_mu, phi_s[k]);
    d_mu_s = smoothedDirac(eps_mu, phi_s[k]);
    norm_n = sqrt(n[k * 2 + 0] * n[k * 2 + 0] + n[k * 2 + 1] * n[k * 2 + 1]);
    norm_n_s =
        sqrt(n_s[k * 2 + 0] * n_s[k * 2 + 0] + n_s[k * 2 + 1] * n_s[k * 2 + 1]);
    mom_u_acc[k] = H_mu_s * rho * u[k];
    dmom_u_acc_u[k] = H_mu_s * rho;
    mom_v_acc[k] = H_mu_s * rho * v[k];
    dmom_v_acc_v[k] = H_mu_s * rho;
    mass_adv[k * 2 + 0] = u[k];
    mass_adv[k * 2 + 1] = v[k];
    dmass_adv_u[k * 2 + 0] = 1.0;
    dmass_adv_v[k * 2 + 1] = 1.0;
    mom_u_adv[k * 2 + 0] =
        H_mu_s * rho * u[k] * u[k] -
        sp * (u[k] - 0.0) * d_mu_s * n_s[k * 2 + 0] / norm_n_s;
    mom_u_adv[k * 2 + 1] =
        H_mu_s * rho * u[k] * v[k] -
        sp * (u[k] - 0.0) * d_mu_s * n_s[k * 2 + 1] / norm_n_s;
    dmom_u_adv_u[k * 2 + 0] =
        2.0 * H_mu_s * rho * u[k] - sp * d_mu_s * n_s[k * 2 + 0] / norm_n_s;
    dmom_u_adv_u[k * 2 + 1] =
        H_mu_s * rho * v[k] - sp * d_mu_s * n_s[k * 2 + 1] / norm_n_s;
    dmom_u_adv_v[k * 2 + 1] = H_mu_s * rho * u[k];
    mom_v_adv[k * 2 + 0] =
        H_mu_s * rho * v[k] * u[k] -
        sp * (v[k] - 0.0) * d_mu_s * n_s[k * 2 + 0] / norm_n_s;
    mom_v_adv[k * 2 + 1] =
        H_mu_s * rho * v[k] * v[k] -
        sp * (v[k] - 0.0) * d_mu_s * n_s[k * 2 + 1] / norm_n_s;
    dmom_v_adv_u[k * 2 + 0] = H_mu_s * rho * v[k];
    dmom_v_adv_v[k * 2 + 0] =
        H_mu_s * rho * u[k] - sp * d_mu_s * n_s[k * 2 + 0] / norm_n_s;
    dmom_v_adv_v[k * 2 + 1] =
        2.0 * H_mu_s * rho * v[k] - sp * d_mu_s * n_s[k * 2 + 1] / norm_n_s;
    mom_u_diff_ten[k * 4 + 0] = 2.0 * H_mu_s * mu;
    mom_u_diff_ten[k * 4 + 3] = H_mu_s * mu;
    mom_uv_diff_ten[k * 4 + 2] = H_mu_s * mu;
    mom_v_diff_ten[k * 4 + 0] = H_mu_s * mu;
    mom_v_diff_ten[k * 4 + 3] = 2.0 * H_mu_s * mu;
    mom_vu_diff_ten[k * 4 + 1] = H_mu_s * mu;
    if (quadraticPenalty) {
      mom_u_source[k] =
          -H_mu_s * rho * g[0] -
          H_mu_s * d_mu * sigma * kappa[k] * n[k * 2 + 0] / norm_n +
          boundaryPenaltyCoef * rho * d_mu_s * (u[k] - 0.0) +
          volumePenaltyCoef * rho * (1.0 - H_mu_s) * (u[k] - 0.0) *
              (u[k] - 0.0);
      dmom_u_source_u[k] =
          boundaryPenaltyCoef * rho * d_mu_s +
          volumePenaltyCoef * rho * (1.0 - H_mu_s) * 2.0 * (u[k] - 0.0);
      dmom_u_source_v[k] = 0.0;
      mom_v_source[k] =
          -H_mu_s * rho * g[1] -
          H_mu_s * d_mu * sigma * kappa[k] * n[k * 2 + 1] / norm_n +
          boundaryPenaltyCoef * rho * d_mu_s * (v[k] - 0.0) +
          volumePenaltyCoef * rho * (1.0 - H_mu_s) * (v[k] - 0.0) *
              (v[k] - 0.0);
      dmom_v_source_u[k] = 0.0;
      dmom_v_source_v[k] =
          boundaryPenaltyCoef * rho * d_mu_s +
          volumePenaltyCoef * rho * (1.0 - H_mu_s) * 2.0 * (v[k] - 0.0);
    } else if (sipgPenalty) {
      mom_u_source[k] =
          -H_mu_s * rho * g[0] -
          H_mu_s * d_mu * sigma * kappa[k] * n[k * 2 + 0] / norm_n +
          volumePenaltyCoef * rho * (1.0 - H_mu_s) * (u[k] - 0.0);
      dmom_u_source_u[k] = volumePenaltyCoef * rho * (1.0 - H_mu_s);
      dmom_u_source_v[k] = 0.0;
      mom_v_source[k] =
          -H_mu_s * rho * g[1] -
          H_mu_s * d_mu * sigma * kappa[k] * n[k * 2 + 1] / norm_n +
          volumePenaltyCoef * rho * (1.0 - H_mu_s) * (v[k] - 0.0);
      dmom_v_source_u[k] = 0.0;
      dmom_v_source_v[k] = volumePenaltyCoef * rho * (1.0 - H_mu_s);
      volumeFlux = u[k] * n_s[k * 2 + 0] + v[k] * n_s[k * 2 + 1];
      if (volumeFlux < 0.0) {
        mom_u_source[k] += rho * d_mu_s * u[k] *
                           (u[k] * n_s[k * 2 + 0] + v[k] * n_s[k * 2 + 1]) /
                           norm_n_s;
        dmom_u_source_u[k] +=
            rho * d_mu_s *
            (2.0 * u[k] * n_s[k * 2 + 0] + v[k] * n_s[k * 2 + 1]) / norm_n_s;
        dmom_u_source_v[k] = rho * d_mu_s * u[k] * n_s[k * 2 + 1] / norm_n_s;
        mom_v_source[k] +=
            rho * d_mu_s *
            (v[k] * u[k] * n_s[k * 2 + 0] + v[k] * v[k] * n_s[k * 2 + 1]) /
            norm_n_s;
        dmom_v_source_u[k] += rho * d_mu_s * v[k] * n_s[k * 2 + 0] / norm_n_s;
        dmom_v_source_v[k] +=
            rho * d_mu_s *
            (u[k] * n_s[k * 2 + 0] + 2.0 * v[k] * n_s[k * 2 + 1]) / norm_n_s;
      }
    } else {
      mom_u_source[k] =
          -H_mu_s * rho * g[0] -
          H_mu_s * d_mu * sigma * kappa[k] * n[k * 2 + 0] / norm_n +
          boundaryPenaltyCoef * rho * d_mu_s * (u[k] - 0.0) +
          volumePenaltyCoef * rho * (1.0 - H_mu_s) * (u[k] - 0.0);
      dmom_u_source_u[k] = boundaryPenaltyCoef * rho * d_mu_s +
                           volumePenaltyCoef * rho * (1.0 - H_mu_s);
      dmom_u_source_v[k] = 0.0;
      mom_v_source[k] =
          -H_mu_s * rho * g[1] -
          H_mu_s * d_mu * sigma * kappa[k] * n[k * 2 + 1] / norm_n +
          boundaryPenaltyCoef * rho * d_mu_s * (v[k] - 0.0) +
          volumePenaltyCoef * rho * (1.0 - H_mu_s) * (v[k] - 0.0);
      dmom_v_source_u[k] = 0.0;
      dmom_v_source_v[k] = boundaryPenaltyCoef * rho * d_mu_s +
                           volumePenaltyCoef * rho * (1.0 - H_mu_s);
    }
    mom_u_ham[k] = grad_p[k * 2 + 0];
    dmom_u_ham_grad_p[k * 2 + 0] = 1.0;
    mom_v_ham[k] = grad_p[k * 2 + 1];
    dmom_v_ham_grad_p[k * 2 + 1] = 1.0;
  }
}


x86 assembly (clang, -O0):
<ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    0x120(%rbp),%rax
mov    0x118(%rbp),%rax
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
movsd  0x20(%rbp),%xmm8
movsd  0x18(%rbp),%xmm8
movsd  0x10(%rbp),%xmm8
mov    %edi,-0x4(%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)
movsd  %xmm7,-0x48(%rbp)
mov    %rsi,-0x50(%rbp)
mov    %rdx,-0x58(%rbp)
mov    %rcx,-0x60(%rbp)
mov    %r8,-0x68(%rbp)
mov    %r9,-0x70(%rbp)
movl   $0x0,-0xf4(%rbp)
movl   $0x1,-0xf8(%rbp)
cvtsi2sdl -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    2805 <ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate+0x16d5>
movsd  -0x20(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    $0x2,%al
call   1050 <smoothedHeaviside@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x74(%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
mov    -0x58(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    $0x2,%al
call   1050 <smoothedHeaviside@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    $0x2,%al
call   1040 <smoothedDirac@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  0x1ce5(%rip),%xmm2
subsd  -0x98(%rbp),%xmm2
ff
movsd  -0x48(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  0x1cb6(%rip),%xmm2
subsd  -0xa8(%rbp),%xmm2
ff
movsd  0x10(%rbp),%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  0x1c7f(%rip),%xmm2
subsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x48(%rbp),%xmm1
mulsd  0x10(%rbp),%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    $0x2,%al
call   1050 <smoothedHeaviside@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    $0x2,%al
call   1040 <smoothedDirac@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    $0x2,%al
call   1050 <smoothedHeaviside@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    $0x2,%al
call   1040 <smoothedDirac@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x60(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x60(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
mov    -0x74(%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,-0xd8(%rbp)
ff
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x28(%rbp),%rax
mov    -0x74(%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,-0xe0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x60(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
mov    0x68(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x78(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  0x1a11(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x80(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x19f1(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xf0(%rbp),%xmm1
ff
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
xorps  %xmm4,%xmm4
subsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mulsd  -0xd0(%rbp),%xmm1
ff
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0xe0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x88(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xf0(%rbp),%xmm1
ff
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
xorps  %xmm4,%xmm4
subsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mulsd  -0xd0(%rbp),%xmm1
ff
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0xe0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x88(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x1896(%rip),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xf0(%rbp),%xmm1
ff
mulsd  -0xd0(%rbp),%xmm1
ff
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0xe0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x90(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xf0(%rbp),%xmm1
ff
mulsd  -0xd0(%rbp),%xmm1
ff
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0xe0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x90(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x98(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xf0(%rbp),%xmm1
ff
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
xorps  %xmm4,%xmm4
subsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mulsd  -0xd0(%rbp),%xmm1
ff
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0xe0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0xa0(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xf0(%rbp),%xmm1
ff
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
xorps  %xmm4,%xmm4
subsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mulsd  -0xd0(%rbp),%xmm1
ff
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0xe0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0xa0(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0xa8(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xf0(%rbp),%xmm1
ff
mulsd  -0xd0(%rbp),%xmm1
ff
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0xe0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0xb0(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x156a(%rip),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x80(%rbp),%xmm0
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xf0(%rbp),%xmm1
ff
mulsd  -0xd0(%rbp),%xmm1
ff
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0xe0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0xb0(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x14e4(%rip),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
mov    0xb8(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
mov    0xb8(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
mov    0xc8(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
mov    0xc0(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x143c(%rip),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
mov    0xc0(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
mov    0xd0(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0xf4(%rbp)
je     1f59 <ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate+0xe29>
movsd  -0xc8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x80(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
mulsd  -0x30(%rbp),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0xd8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x10(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  -0xd0(%rbp),%xmm1
ff
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
xorps  %xmm3,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x18(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  0x131d(%rip),%xmm2
subsd  -0xc8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
xorps  %xmm3,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
xorps  %xmm3,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0xd8(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0x18(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
movsd  0x12a9(%rip),%xmm3
subsd  -0xc8(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
movsd  0x128d(%rip),%xmm3
mulsd  %xmm3,%xmm1
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
xorps  %xmm4,%xmm4
subsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0xe0(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0xe8(%rbp),%rax
movslq -0x74(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x80(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
mulsd  -0x30(%rbp),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0xd8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x10(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  -0xd0(%rbp),%xmm1
ff
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
xorps  %xmm3,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x18(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  0x1183(%rip),%xmm2
subsd  -0xc8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
xorps  %xmm3,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
xorps  %xmm3,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0xf0(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0xf8(%rbp),%rax
movslq -0x74(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0x18(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
movsd  0x10fc(%rip),%xmm3
subsd  -0xc8(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
movsd  0x10e0(%rip),%xmm3
mulsd  %xmm3,%xmm1
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
xorps  %xmm4,%xmm4
subsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x100(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    276d <ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate+0x163d>
cmpl   $0x0,-0xf8(%rbp)
je     24ad <ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate+0x137d>
movsd  -0xc8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  -0x80(%rbp),%xmm1
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0x30(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0xd8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x18(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  0x1006(%rip),%xmm2
subsd  -0xc8(%rbp),%xmm2
mulsd  %xmm2,%xmm0
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
xorps  %xmm3,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0xd8(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x18(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  0xfbc(%rip),%xmm1
subsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    0xe0(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0xe8(%rbp),%rax
movslq -0x74(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  -0x80(%rbp),%xmm1
mov    -0x50(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0x30(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0xd8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x18(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  0xef0(%rip),%xmm2
subsd  -0xc8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
xorps  %xmm3,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0xf0(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0xf8(%rbp),%rax
movslq -0x74(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x18(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  0xe93(%rip),%xmm1
subsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    0x100(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0xe8(%rbp),%xmm0
ff
jbe    24a8 <ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate+0x1378>
movsd  -0x80(%rbp),%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0xe0(%rbp),%xmm0
ff
mov    0xd8(%rbp),%rax
movslq -0x74(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0xd66(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0xe0(%rbp),%xmm0
ff
mov    0xe0(%rbp),%rax
movslq -0x74(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0xe0(%rbp),%xmm0
ff
mov    0xe8(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0xe0(%rbp),%xmm0
ff
mov    0xf0(%rbp),%rax
movslq -0x74(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0xe0(%rbp),%xmm0
ff
mov    0xf8(%rbp),%rax
movslq -0x74(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0xb9b(%rip),%xmm2
mulsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0xe0(%rbp),%xmm0
ff
mov    0x100(%rbp),%rax
movslq -0x74(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    2768 <ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate+0x1638>
movsd  -0xc8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x80(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
mulsd  -0x30(%rbp),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0xd8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x10(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  -0xd0(%rbp),%xmm1
ff
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
xorps  %xmm3,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x18(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  0xa91(%rip),%xmm2
subsd  -0xc8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
xorps  %xmm3,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0xd8(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0x18(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
movsd  0xa35(%rip),%xmm3
subsd  -0xc8(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0xe0(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0xe8(%rbp),%rax
movslq -0x74(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x80(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
mulsd  -0x30(%rbp),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0xd8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x10(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  -0xd0(%rbp),%xmm1
ff
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
xorps  %xmm3,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x18(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  0x933(%rip),%xmm2
subsd  -0xc8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
xorps  %xmm3,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0xf0(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0xf8(%rbp),%rax
movslq -0x74(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0x18(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
movsd  0x8c4(%rip),%xmm3
subsd  -0xc8(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x100(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    276d <ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate+0x163d>
mov    0x38(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x108(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x110(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  0x85b(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x118(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x120(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x816(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1276 <ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate+0x146>
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r9,0x98(%rsp)
mov    %r8,0x90(%rsp)
mov    %rcx,0x38(%rsp)
mov    %rdx,0x88(%rsp)
mov    %rsi,0x80(%rsp)
movsd  %xmm7,0x30(%rsp)
movsd  %xmm6,0x20(%rsp)
movsd  %xmm5,0x28(%rsp)
movsd  %xmm4,0x78(%rsp)
movsd  %xmm3,0x18(%rsp)
movsd  %xmm2,0x10(%rsp)
movsd  %xmm1,0x70(%rsp)
test   %edi,%edi
jle    18f9 <ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate+0x7c9>
movsd  0x20(%rsp),%xmm0
mulsd  0x28(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0xf0(%rsp),%xmm0
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x68(%rsp)
mov    %edi,%eax
shl    $0x2,%rax
mov    %rax,0x60(%rsp)
xor    %ebx,%ebx
jmp    1225 <ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate+0xf5>
xchg   %ax,%ax
mov    0x118(%rsp),%rcx
movsd  (%rcx,%rbx,4),%xmm0
mov    0x1e8(%rsp),%rax
movsd  %xmm0,(%rax,%rbx,2)
mov    0x1f0(%rsp),%rax
mov    %r8,(%rax,%rbx,4)
movsd  0x8(%rcx,%rbx,4),%xmm0
mov    0x1f8(%rsp),%rax
movsd  %xmm0,(%rax,%rbx,2)
mov    0x200(%rsp),%rax
mov    %r8,0x8(%rax,%rbx,4)
add    $0x4,%rbx
cmp    %rbx,0x60(%rsp)
je     18f9 <ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate+0x7c9>
mov    0x88(%rsp),%rbp
movsd  0x0(%rbp,%rbx,2),%xmm1
movsd  0x10(%rsp),%xmm0
mov    $0x2,%al
call   1050 <smoothedHeaviside@plt>
mov    %eax,0x8(%rsp)
movsd  0x0(%rbp,%rbx,2),%xmm1
movsd  0x10(%rsp),%xmm0
mov    $0x2,%al
call   1040 <smoothedDirac@plt>
movsd  0x0(%rbp,%rbx,2),%xmm1
movsd  0x18(%rsp),%xmm0
mov    $0x2,%al
call   1050 <smoothedHeaviside@plt>
mov    %eax,%r14d
movsd  0x0(%rbp,%rbx,2),%xmm1
movsd  0x18(%rsp),%xmm0
mov    $0x2,%al
call   1040 <smoothedDirac@plt>
mov    %eax,%r13d
mov    0x98(%rsp),%rbp
movsd  0x0(%rbp,%rbx,2),%xmm1
movsd  0x10(%rsp),%xmm0
mov    $0x2,%al
call   1050 <smoothedHeaviside@plt>
movsd  0x0(%rbp,%rbx,2),%xmm1
movsd  0x10(%rsp),%xmm0
mov    $0x2,%al
call   1040 <smoothedDirac@plt>
movsd  0x0(%rbp,%rbx,2),%xmm1
movsd  0x18(%rsp),%xmm0
mov    $0x2,%al
call   1050 <smoothedHeaviside@plt>
mov    %eax,%r15d
movsd  0x0(%rbp,%rbx,2),%xmm1
movsd  0x18(%rsp),%xmm0
mov    $0x2,%al
call   1040 <smoothedDirac@plt>
mov    %eax,%r12d
mov    0x38(%rsp),%rax
movsd  (%rax,%rbx,4),%xmm0
movsd  0x8(%rax,%rbx,4),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd 0xd07(%rip),%xmm0
jb     1310 <ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate+0x1e0>
sqrtsd %xmm0,%xmm8
jmp    131a <ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate+0x1ea>
nopw   0x0(%rax,%rax,1)
call   1030 <sqrt@plt>
movapd %xmm0,%xmm8
mov    0x8(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
cvtsi2sd %r14d,%xmm7
cvtsi2sd %r13d,%xmm11
movsd  0xcc9(%rip),%xmm1
movapd %xmm1,%xmm10
subsd  %xmm0,%xmm10
mulsd  0x30(%rsp),%xmm0
mulsd  0x28(%rsp),%xmm10
addsd  %xmm0,%xmm10
movapd %xmm1,%xmm0
subsd  %xmm7,%xmm0
mulsd  0x20(%rsp),%xmm0
mulsd  0x68(%rsp),%xmm7
cvtsi2sd %r15d,%xmm12
cvtsi2sd %r12d,%xmm9
addsd  %xmm0,%xmm7
mov    0x108(%rsp),%r14
movsd  (%r14,%rbx,4),%xmm0
movsd  0x8(%r14,%rbx,4),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd 0xc6a(%rip),%xmm0
jb     13b0 <ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate+0x280>
sqrtsd %xmm0,%xmm0
jmp    140d <ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate+0x2dd>
cs nopw 0x0(%rax,%rax,1)
movsd  %xmm10,0x8(%rsp)
movsd  %xmm8,0x58(%rsp)
movsd  %xmm9,0x50(%rsp)
movsd  %xmm11,0x48(%rsp)
movsd  %xmm7,0x40(%rsp)
movapd %xmm12,0xa0(%rsp)
call   1030 <sqrt@plt>
movapd 0xa0(%rsp),%xmm12
movsd  0x40(%rsp),%xmm7
movsd  0x48(%rsp),%xmm11
movsd  0x50(%rsp),%xmm9
movsd  0x58(%rsp),%xmm8
movsd  0x8(%rsp),%xmm10
movabs $0x3ff0000000000000,%r8
movapd %xmm10,%xmm1
mulsd  %xmm12,%xmm1
mov    0x120(%rsp),%rbp
movsd  0x0(%rbp,%rbx,2),%xmm2
mulsd  %xmm1,%xmm2
mov    0x130(%rsp),%rax
movsd  %xmm2,(%rax,%rbx,2)
mov    0x138(%rsp),%rax
movsd  %xmm1,(%rax,%rbx,2)
mov    0x128(%rsp),%rdi
movsd  (%rdi,%rbx,2),%xmm2
mulsd  %xmm1,%xmm2
mov    0x140(%rsp),%rax
movsd  %xmm2,(%rax,%rbx,2)
mov    0x148(%rsp),%rax
movsd  %xmm1,(%rax,%rbx,2)
movsd  0x0(%rbp,%rbx,2),%xmm2
mov    0x150(%rsp),%rax
movsd  %xmm2,(%rax,%rbx,4)
movsd  (%rdi,%rbx,2),%xmm2
movsd  %xmm2,0x8(%rax,%rbx,4)
mov    0x158(%rsp),%rax
mov    %r8,(%rax,%rbx,4)
mov    0x160(%rsp),%rax
mov    %r8,0x8(%rax,%rbx,4)
movsd  0x0(%rbp,%rbx,2),%xmm2
movapd %xmm1,%xmm3
movapd %xmm9,%xmm4
mulsd  %xmm2,%xmm4
mulsd  (%r14,%rbx,4),%xmm4
mulsd  %xmm2,%xmm3
divsd  %xmm0,%xmm4
mulsd  %xmm2,%xmm3
subsd  %xmm4,%xmm3
mov    0x168(%rsp),%rax
movsd  %xmm3,(%rax,%rbx,4)
movsd  0x0(%rbp,%rbx,2),%xmm2
movapd %xmm1,%xmm3
mulsd  %xmm2,%xmm3
mulsd  %xmm9,%xmm2
mulsd  0x8(%r14,%rbx,4),%xmm2
mulsd  (%rdi,%rbx,2),%xmm3
divsd  %xmm0,%xmm2
subsd  %xmm2,%xmm3
movsd  %xmm3,0x8(%rax,%rbx,4)
movapd %xmm12,%xmm2
addsd  %xmm12,%xmm2
movapd %xmm10,%xmm3
mulsd  %xmm2,%xmm3
movsd  (%r14,%rbx,4),%xmm4
mulsd  %xmm9,%xmm4
divsd  %xmm0,%xmm4
movsd  0x0(%rbp,%rbx,2),%xmm5
mulsd  %xmm3,%xmm5
subsd  %xmm4,%xmm5
mov    0x170(%rsp),%rax
movsd  %xmm5,(%rax,%rbx,4)
movsd  0x8(%r14,%rbx,4),%xmm4
mulsd  %xmm9,%xmm4
divsd  %xmm0,%xmm4
movsd  (%rdi,%rbx,2),%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm4,%xmm5
movsd  %xmm5,0x8(%rax,%rbx,4)
movsd  0x0(%rbp,%rbx,2),%xmm4
mulsd  %xmm1,%xmm4
mov    0x178(%rsp),%rax
movsd  %xmm4,0x8(%rax,%rbx,4)
movsd  (%rdi,%rbx,2),%xmm4
movapd %xmm1,%xmm5
mulsd  %xmm4,%xmm5
mulsd  %xmm9,%xmm4
mulsd  (%r14,%rbx,4),%xmm4
divsd  %xmm0,%xmm4
mulsd  0x0(%rbp,%rbx,2),%xmm5
subsd  %xmm4,%xmm5
mov    0x180(%rsp),%rax
movsd  %xmm5,(%rax,%rbx,4)
movsd  (%rdi,%rbx,2),%xmm4
movapd %xmm1,%xmm5
mulsd  %xmm4,%xmm5
movapd %xmm9,%xmm6
mulsd  %xmm4,%xmm6
mulsd  %xmm4,%xmm5
mulsd  0x8(%r14,%rbx,4),%xmm6
divsd  %xmm0,%xmm6
subsd  %xmm6,%xmm5
movsd  %xmm5,0x8(%rax,%rbx,4)
movsd  (%rdi,%rbx,2),%xmm4
mulsd  %xmm1,%xmm4
mov    0x188(%rsp),%rax
movsd  %xmm4,(%rax,%rbx,4)
movsd  (%r14,%rbx,4),%xmm4
mulsd  %xmm9,%xmm4
mulsd  0x0(%rbp,%rbx,2),%xmm1
divsd  %xmm0,%xmm4
subsd  %xmm4,%xmm1
mov    0x190(%rsp),%rax
movsd  %xmm1,(%rax,%rbx,4)
movsd  0x8(%r14,%rbx,4),%xmm1
mulsd  %xmm9,%xmm1
divsd  %xmm0,%xmm1
mulsd  (%rdi,%rbx,2),%xmm3
subsd  %xmm1,%xmm3
movsd  %xmm3,0x8(%rax,%rbx,4)
mulsd  %xmm7,%xmm2
mov    %ebx,%eax
shl    $0x3,%rax
mov    0x198(%rsp),%rdx
movsd  %xmm2,(%rdx,%rax,1)
mulsd  %xmm12,%xmm7
lea    0x3(%rbx),%ecx
movsd  %xmm7,(%rdx,%rcx,8)
lea    0x2(%rbx),%edx
mov    0x1a8(%rsp),%rsi
movsd  %xmm7,(%rsi,%rdx,8)
mov    0x1a0(%rsp),%rdx
movsd  %xmm7,(%rdx,%rax,1)
movsd  %xmm2,(%rdx,%rcx,8)
lea    0x1(%rbx),%eax
mov    0x1b0(%rsp),%rcx
movsd  %xmm7,(%rcx,%rax,8)
movsd  0x95b(%rip),%xmm2
subsd  %xmm12,%xmm2
xorpd  0x95d(%rip),%xmm12
movapd %xmm10,%xmm1
mulsd  %xmm12,%xmm1
mulsd  %xmm12,%xmm11
mulsd  0x78(%rsp),%xmm11
mov    0x90(%rsp),%rax
movsd  (%rax,%rbx,2),%xmm3
mulsd  %xmm11,%xmm3
mov    0x38(%rsp),%rcx
mulsd  (%rcx,%rbx,4),%xmm3
divsd  %xmm8,%xmm3
mov    0x80(%rsp),%rdx
movsd  (%rdx),%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm3,%xmm4
movapd %xmm10,%xmm3
mulsd  0x70(%rsp),%xmm3
mulsd  %xmm2,%xmm3
movsd  0x0(%rbp,%rbx,2),%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm4,%xmm2
mov    0x1b8(%rsp),%rsi
movsd  %xmm2,(%rsi,%rbx,2)
mov    0x1c0(%rsp),%rsi
movsd  %xmm3,(%rsi,%rbx,2)
mov    0x1c8(%rsp),%rsi
movq   $0x0,(%rsi,%rbx,2)
mulsd  (%rax,%rbx,2),%xmm11
mulsd  0x8(%rcx,%rbx,4),%xmm11
divsd  %xmm8,%xmm11
mulsd  0x8(%rdx),%xmm1
addsd  %xmm11,%xmm1
movsd  (%rdi,%rbx,2),%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    0x1d0(%rsp),%rax
movsd  %xmm2,(%rax,%rbx,2)
mov    0x1d8(%rsp),%rax
movq   $0x0,(%rax,%rbx,2)
mov    0x1e0(%rsp),%rax
movsd  %xmm3,(%rax,%rbx,2)
movsd  0x0(%rbp,%rbx,2),%xmm1
movsd  (%rdi,%rbx,2),%xmm3
mulsd  0x8(%r14,%rbx,4),%xmm3
movsd  (%r14,%rbx,4),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm3,%xmm2
xorpd  %xmm3,%xmm3
ucomisd %xmm2,%xmm3
jbe    11d0 <ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate+0xa0>
mulsd  %xmm9,%xmm10
mulsd  %xmm10,%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm0,%xmm1
mov    0x1b8(%rsp),%rax
addsd  (%rax,%rbx,2),%xmm1
movsd  %xmm1,(%rax,%rbx,2)
mov    0x120(%rsp),%rdx
movsd  (%rdx,%rbx,2),%xmm1
mov    0x128(%rsp),%rcx
movsd  (%rcx,%rbx,2),%xmm2
mulsd  0x8(%r14,%rbx,4),%xmm2
addsd  %xmm1,%xmm1
mulsd  (%r14,%rbx,4),%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm10,%xmm1
divsd  %xmm0,%xmm1
mov    0x1c0(%rsp),%rax
addsd  (%rax,%rbx,2),%xmm1
movsd  %xmm1,(%rax,%rbx,2)
movsd  (%rdx,%rbx,2),%xmm1
mulsd  %xmm10,%xmm1
mulsd  0x8(%r14,%rbx,4),%xmm1
divsd  %xmm0,%xmm1
mov    0x1c8(%rsp),%rax
movsd  %xmm1,(%rax,%rbx,2)
movsd  (%rcx,%rbx,2),%xmm1
movsd  (%rdx,%rbx,2),%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm1,%xmm1
mulsd  0x8(%r14,%rbx,4),%xmm1
mulsd  (%r14,%rbx,4),%xmm2
addsd  %xmm1,%xmm2
mulsd  %xmm10,%xmm2
divsd  %xmm0,%xmm2
mov    0x1d0(%rsp),%rax
addsd  (%rax,%rbx,2),%xmm2
movsd  %xmm2,(%rax,%rbx,2)
movsd  (%rcx,%rbx,2),%xmm1
mulsd  %xmm10,%xmm1
mulsd  (%r14,%rbx,4),%xmm1
divsd  %xmm0,%xmm1
mov    0x1d8(%rsp),%rax
addsd  (%rax,%rbx,2),%xmm1
movsd  %xmm1,(%rax,%rbx,2)
movsd  (%rdx,%rbx,2),%xmm1
movsd  (%rcx,%rbx,2),%xmm2
addsd  %xmm2,%xmm2
mulsd  0x8(%r14,%rbx,4),%xmm2
mulsd  (%r14,%rbx,4),%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm10,%xmm1
divsd  %xmm0,%xmm1
mov    0x1e0(%rsp),%rax
addsd  (%rax,%rbx,2),%xmm1
movsd  %xmm1,(%rax,%rbx,2)
jmp    11d0 <ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate+0xa0>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @ThreephaseNavierStokes_ST_LS_SO_2D_Evaluate(i32 %0, double %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, double* %46, double* %47, double* %48) {
%50 = alloca i32
%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 double*
%94 = alloca double*
%95 = alloca double*
%96 = alloca double*
%97 = alloca double*
%98 = alloca double*
%99 = alloca i32
%100 = alloca double
%101 = alloca double
%102 = alloca double
%103 = alloca double
%104 = alloca double
%105 = alloca double
%106 = alloca double
%107 = alloca double
%108 = alloca double
%109 = alloca double
%110 = alloca double
%111 = alloca double
%112 = alloca double
%113 = alloca double
%114 = alloca double
%115 = alloca i32
%116 = alloca i32
store i32 %0, i32* %50
store double %1, double* %51
store double %2, double* %52
store double %3, double* %53
store double %4, double* %54
store double %5, double* %55
store double %6, double* %56
store double %7, double* %57
store double %8, double* %58
store double %9, double* %59
store double %10, double* %60
store double %11, double* %61
store double* %12, double** %62
store double* %13, double** %63
store double* %14, double** %64
store double* %15, double** %65
store double* %16, double** %66
store double* %17, double** %67
store double* %18, double** %68
store double* %19, double** %69
store double* %20, double** %70
store double* %21, double** %71
store double* %22, double** %72
store double* %23, double** %73
store double* %24, double** %74
store double* %25, double** %75
store double* %26, double** %76
store double* %27, double** %77
store double* %28, double** %78
store double* %29, double** %79
store double* %30, double** %80
store double* %31, double** %81
store double* %32, double** %82
store double* %33, double** %83
store double* %34, double** %84
store double* %35, double** %85
store double* %36, double** %86
store double* %37, double** %87
store double* %38, double** %88
store double* %39, double** %89
store double* %40, double** %90
store double* %41, double** %91
store double* %42, double** %92
store double* %43, double** %93
store double* %44, double** %94
store double* %45, double** %95
store double* %46, double** %96
store double* %47, double** %97
store double* %48, double** %98
store i32 0, i32* %115
store i32 1, i32* %116
%117 = load i32, i32* %116
%118 = sitofp i32 %117 to double
store double %118, double* %114
store i32 0, i32* %99
br label %119
119: ; preds = %1479, %49
%120 = load i32, i32* %99
%121 = load i32, i32* %50
%122 = icmp slt i32 %120, %121
br i1 %122, label %123, label %1482
123: ; preds = %119
%124 = load double, double* %53
%125 = load double*, double** %63
%126 = load i32, i32* %99
%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 (...)* @smoothedHeaviside to i32 (double, double, ...)*)(double %124, double %129)
%131 = sitofp i32 %130 to double
store double %131, double* %103
%132 = load double, double* %53
%133 = load double*, double** %63
%134 = load i32, i32* %99
%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 (...)* @smoothedDirac to i32 (double, double, ...)*)(double %132, double %137)
%139 = sitofp i32 %138 to double
store double %139, double* %104
%140 = load double, double* %54
%141 = load double*, double** %63
%142 = load i32, i32* %99
%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 (...)* @smoothedHeaviside to i32 (double, double, ...)*)(double %140, double %145)
%147 = sitofp i32 %146 to double
store double %147, double* %105
%148 = load double, double* %54
%149 = load double*, double** %63
%150 = load i32, i32* %99
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds double, double* %149, i64 %151
%153 = load double, double* %152
%154 = call i32 (double, double, ...) bitcast (i32 (...)* @smoothedDirac to i32 (double, double, ...)*)(double %148, double %153)
%155 = sitofp i32 %154 to double
store double %155, double* %106
%156 = load double, double* %56
%157 = load double, double* %103
%158 = fsub double 1.000000e+00, %157
%159 = load double, double* %58
%160 = load double, double* %103
%161 = fmul double %159, %160
%162 = call double @llvm.fmuladd.f64(double %156, double %158, double %161)
store double %162, double* %100
%163 = load double, double* %57
%164 = load double, double* %105
%165 = fsub double 1.000000e+00, %164
%166 = load double, double* %59
%167 = load double, double* %105
%168 = fmul double %166, %167
%169 = call double @llvm.fmuladd.f64(double %163, double %165, double %168)
store double %169, double* %101
%170 = load double, double* %56
%171 = load double, double* %57
%172 = fmul double %170, %171
%173 = load double, double* %105
%174 = fsub double 1.000000e+00, %173
%175 = load double, double* %58
%176 = load double, double* %59
%177 = fmul double %175, %176
%178 = load double, double* %105
%179 = fmul double %177, %178
%180 = call double @llvm.fmuladd.f64(double %172, double %174, double %179)
store double %180, double* %102
%181 = load double, double* %53
%182 = load double*, double** %66
%183 = load i32, i32* %99
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds double, double* %182, i64 %184
%186 = load double, double* %185
%187 = call i32 (double, double, ...) bitcast (i32 (...)* @smoothedHeaviside to i32 (double, double, ...)*)(double %181, double %186)
%188 = sitofp i32 %187 to double
store double %188, double* %107
%189 = load double, double* %53
%190 = load double*, double** %66
%191 = load i32, i32* %99
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds double, double* %190, i64 %192
%194 = load double, double* %193
%195 = call i32 (double, double, ...) bitcast (i32 (...)* @smoothedDirac to i32 (double, double, ...)*)(double %189, double %194)
%196 = sitofp i32 %195 to double
store double %196, double* %108
%197 = load double, double* %54
%198 = load double*, double** %66
%199 = load i32, i32* %99
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds double, double* %198, i64 %200
%202 = load double, double* %201
%203 = call i32 (double, double, ...) bitcast (i32 (...)* @smoothedHeaviside to i32 (double, double, ...)*)(double %197, double %202)
%204 = sitofp i32 %203 to double
store double %204, double* %109
%205 = load double, double* %54
%206 = load double*, double** %66
%207 = load i32, i32* %99
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds double, double* %206, i64 %208
%210 = load double, double* %209
%211 = call i32 (double, double, ...) bitcast (i32 (...)* @smoothedDirac to i32 (double, double, ...)*)(double %205, double %210)
%212 = sitofp i32 %211 to double
store double %212, double* %110
%213 = load double*, double** %64
%214 = load i32, i32* %99
%215 = mul nsw i32 %214, 2
%216 = add nsw i32 %215, 0
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds double, double* %213, i64 %217
%219 = load double, double* %218
%220 = load double*, double** %64
%221 = load i32, i32* %99
%222 = mul nsw i32 %221, 2
%223 = add nsw i32 %222, 0
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds double, double* %220, i64 %224
%226 = load double, double* %225
%227 = load double*, double** %64
%228 = load i32, i32* %99
%229 = mul nsw i32 %228, 2
%230 = add nsw i32 %229, 1
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds double, double* %227, i64 %231
%233 = load double, double* %232
%234 = load double*, double** %64
%235 = load i32, i32* %99
%236 = mul nsw i32 %235, 2
%237 = add nsw i32 %236, 1
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds double, double* %234, i64 %238
%240 = load double, double* %239
%241 = fmul double %233, %240
%242 = call double @llvm.fmuladd.f64(double %219, double %226, double %241)
%243 = call double @sqrt(double %242)
store double %243, double* %111
%244 = load double*, double** %67
%245 = load i32, i32* %99
%246 = mul nsw i32 %245, 2
%247 = add nsw i32 %246, 0
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds double, double* %244, i64 %248
%250 = load double, double* %249
%251 = load double*, double** %67
%252 = load i32, i32* %99
%253 = mul nsw i32 %252, 2
%254 = add nsw i32 %253, 0
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds double, double* %251, i64 %255
%257 = load double, double* %256
%258 = load double*, double** %67
%259 = load i32, i32* %99
%260 = mul nsw i32 %259, 2
%261 = add nsw i32 %260, 1
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds double, double* %258, i64 %262
%264 = load double, double* %263
%265 = load double*, double** %67
%266 = load i32, i32* %99
%267 = mul nsw i32 %266, 2
%268 = add nsw i32 %267, 1
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds double, double* %265, i64 %269
%271 = load double, double* %270
%272 = fmul double %264, %271
%273 = call double @llvm.fmuladd.f64(double %250, double %257, double %272)
%274 = call double @sqrt(double %273)
store double %274, double* %112
%275 = load double, double* %109
%276 = load double, double* %100
%277 = fmul double %275, %276
%278 = load double*, double** %70
%279 = load i32, i32* %99
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds double, double* %278, i64 %280
%282 = load double, double* %281
%283 = fmul double %277, %282
%284 = load double*, double** %72
%285 = load i32, i32* %99
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds double, double* %284, i64 %286
store double %283, double* %287
%288 = load double, double* %109
%289 = load double, double* %100
%290 = fmul double %288, %289
%291 = load double*, double** %73
%292 = load i32, i32* %99
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds double, double* %291, i64 %293
store double %290, double* %294
%295 = load double, double* %109
%296 = load double, double* %100
%297 = fmul double %295, %296
%298 = load double*, double** %71
%299 = load i32, i32* %99
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds double, double* %298, i64 %300
%302 = load double, double* %301
%303 = fmul double %297, %302
%304 = load double*, double** %74
%305 = load i32, i32* %99
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds double, double* %304, i64 %306
store double %303, double* %307
%308 = load double, double* %109
%309 = load double, double* %100
%310 = fmul double %308, %309
%311 = load double*, double** %75
%312 = load i32, i32* %99
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds double, double* %311, i64 %313
store double %310, double* %314
%315 = load double*, double** %70
%316 = load i32, i32* %99
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds double, double* %315, i64 %317
%319 = load double, double* %318
%320 = load double*, double** %76
%321 = load i32, i32* %99
%322 = mul nsw i32 %321, 2
%323 = add nsw i32 %322, 0
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds double, double* %320, i64 %324
store double %319, double* %325
%326 = load double*, double** %71
%327 = load i32, i32* %99
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds double, double* %326, i64 %328
%330 = load double, double* %329
%331 = load double*, double** %76
%332 = load i32, i32* %99
%333 = mul nsw i32 %332, 2
%334 = add nsw i32 %333, 1
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds double, double* %331, i64 %335
store double %330, double* %336
%337 = load double*, double** %77
%338 = load i32, i32* %99
%339 = mul nsw i32 %338, 2
%340 = add nsw i32 %339, 0
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds double, double* %337, i64 %341
store double 1.000000e+00, double* %342
%343 = load double*, double** %78
%344 = load i32, i32* %99
%345 = mul nsw i32 %344, 2
%346 = add nsw i32 %345, 1
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds double, double* %343, i64 %347
store double 1.000000e+00, double* %348
%349 = load double, double* %109
%350 = load double, double* %100
%351 = fmul double %349, %350
%352 = load double*, double** %70
%353 = load i32, i32* %99
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds double, double* %352, i64 %354
%356 = load double, double* %355
%357 = fmul double %351, %356
%358 = load double*, double** %70
%359 = load i32, i32* %99
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds double, double* %358, i64 %360
%362 = load double, double* %361
%363 = load double, double* %114
%364 = load double*, double** %70
%365 = load i32, i32* %99
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds double, double* %364, i64 %366
%368 = load double, double* %367
%369 = fsub double %368, 0.000000e+00
%370 = fmul double %363, %369
%371 = load double, double* %110
%372 = fmul double %370, %371
%373 = load double*, double** %67
%374 = load i32, i32* %99
%375 = mul nsw i32 %374, 2
%376 = add nsw i32 %375, 0
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds double, double* %373, i64 %377
%379 = load double, double* %378
%380 = fmul double %372, %379
%381 = load double, double* %112
%382 = fdiv double %380, %381
%383 = fneg double %382
%384 = call double @llvm.fmuladd.f64(double %357, double %362, double %383)
%385 = load double*, double** %79
%386 = load i32, i32* %99
%387 = mul nsw i32 %386, 2
%388 = add nsw i32 %387, 0
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds double, double* %385, i64 %389
store double %384, double* %390
%391 = load double, double* %109
%392 = load double, double* %100
%393 = fmul double %391, %392
%394 = load double*, double** %70
%395 = load i32, i32* %99
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds double, double* %394, i64 %396
%398 = load double, double* %397
%399 = fmul double %393, %398
%400 = load double*, double** %71
%401 = load i32, i32* %99
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds double, double* %400, i64 %402
%404 = load double, double* %403
%405 = load double, double* %114
%406 = load double*, double** %70
%407 = load i32, i32* %99
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds double, double* %406, i64 %408
%410 = load double, double* %409
%411 = fsub double %410, 0.000000e+00
%412 = fmul double %405, %411
%413 = load double, double* %110
%414 = fmul double %412, %413
%415 = load double*, double** %67
%416 = load i32, i32* %99
%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
%421 = load double, double* %420
%422 = fmul double %414, %421
%423 = load double, double* %112
%424 = fdiv double %422, %423
%425 = fneg double %424
%426 = call double @llvm.fmuladd.f64(double %399, double %404, double %425)
%427 = load double*, double** %79
%428 = load i32, i32* %99
%429 = mul nsw i32 %428, 2
%430 = add nsw i32 %429, 1
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds double, double* %427, i64 %431
store double %426, double* %432
%433 = load double, double* %109
%434 = fmul double 2.000000e+00, %433
%435 = load double, double* %100
%436 = fmul double %434, %435
%437 = load double*, double** %70
%438 = load i32, i32* %99
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds double, double* %437, i64 %439
%441 = load double, double* %440
%442 = load double, double* %114
%443 = load double, double* %110
%444 = fmul double %442, %443
%445 = load double*, double** %67
%446 = load i32, i32* %99
%447 = mul nsw i32 %446, 2
%448 = add nsw i32 %447, 0
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds double, double* %445, i64 %449
%451 = load double, double* %450
%452 = fmul double %444, %451
%453 = load double, double* %112
%454 = fdiv double %452, %453
%455 = fneg double %454
%456 = call double @llvm.fmuladd.f64(double %436, double %441, double %455)
%457 = load double*, double** %80
%458 = load i32, i32* %99
%459 = mul nsw i32 %458, 2
%460 = add nsw i32 %459, 0
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds double, double* %457, i64 %461
store double %456, double* %462
%463 = load double, double* %109
%464 = load double, double* %100
%465 = fmul double %463, %464
%466 = load double*, double** %71
%467 = load i32, i32* %99
%468 = sext i32 %467 to i64
%469 = getelementptr inbounds double, double* %466, i64 %468
%470 = load double, double* %469
%471 = load double, double* %114
%472 = load double, double* %110
%473 = fmul double %471, %472
%474 = load double*, double** %67
%475 = load i32, i32* %99
%476 = mul nsw i32 %475, 2
%477 = add nsw i32 %476, 1
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds double, double* %474, i64 %478
%480 = load double, double* %479
%481 = fmul double %473, %480
%482 = load double, double* %112
%483 = fdiv double %481, %482
%484 = fneg double %483
%485 = call double @llvm.fmuladd.f64(double %465, double %470, double %484)
%486 = load double*, double** %80
%487 = load i32, i32* %99
%488 = mul nsw i32 %487, 2
%489 = add nsw i32 %488, 1
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds double, double* %486, i64 %490
store double %485, double* %491
%492 = load double, double* %109
%493 = load double, double* %100
%494 = fmul double %492, %493
%495 = load double*, double** %70
%496 = load i32, i32* %99
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds double, double* %495, i64 %497
%499 = load double, double* %498
%500 = fmul double %494, %499
%501 = load double*, double** %81
%502 = load i32, i32* %99
%503 = mul nsw i32 %502, 2
%504 = add nsw i32 %503, 1
%505 = sext i32 %504 to i64
%506 = getelementptr inbounds double, double* %501, i64 %505
store double %500, double* %506
%507 = load double, double* %109
%508 = load double, double* %100
%509 = fmul double %507, %508
%510 = load double*, double** %71
%511 = load i32, i32* %99
%512 = sext i32 %511 to i64
%513 = getelementptr inbounds double, double* %510, i64 %512
%514 = load double, double* %513
%515 = fmul double %509, %514
%516 = load double*, double** %70
%517 = load i32, i32* %99
%518 = sext i32 %517 to i64
%519 = getelementptr inbounds double, double* %516, i64 %518
%520 = load double, double* %519
%521 = load double, double* %114
%522 = load double*, double** %71
%523 = load i32, i32* %99
%524 = sext i32 %523 to i64
%525 = getelementptr inbounds double, double* %522, i64 %524
%526 = load double, double* %525
%527 = fsub double %526, 0.000000e+00
%528 = fmul double %521, %527
%529 = load double, double* %110
%530 = fmul double %528, %529
%531 = load double*, double** %67
%532 = load i32, i32* %99
%533 = mul nsw i32 %532, 2
%534 = add nsw i32 %533, 0
%535 = sext i32 %534 to i64
%536 = getelementptr inbounds double, double* %531, i64 %535
%537 = load double, double* %536
%538 = fmul double %530, %537
%539 = load double, double* %112
%540 = fdiv double %538, %539
%541 = fneg double %540
%542 = call double @llvm.fmuladd.f64(double %515, double %520, double %541)
%543 = load double*, double** %82
%544 = load i32, i32* %99
%545 = mul nsw i32 %544, 2
%546 = add nsw i32 %545, 0
%547 = sext i32 %546 to i64
%548 = getelementptr inbounds double, double* %543, i64 %547
store double %542, double* %548
%549 = load double, double* %109
%550 = load double, double* %100
%551 = fmul double %549, %550
%552 = load double*, double** %71
%553 = load i32, i32* %99
%554 = sext i32 %553 to i64
%555 = getelementptr inbounds double, double* %552, i64 %554
%556 = load double, double* %555
%557 = fmul double %551, %556
%558 = load double*, double** %71
%559 = load i32, i32* %99
%560 = sext i32 %559 to i64
%561 = getelementptr inbounds double, double* %558, i64 %560
%562 = load double, double* %561
%563 = load double, double* %114
%564 = load double*, double** %71
%565 = load i32, i32* %99
%566 = sext i32 %565 to i64
%567 = getelementptr inbounds double, double* %564, i64 %566
%568 = load double, double* %567
%569 = fsub double %568, 0.000000e+00
%570 = fmul double %563, %569
%571 = load double, double* %110
%572 = fmul double %570, %571
%573 = load double*, double** %67
%574 = load i32, i32* %99
%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 = load double, double* %112
%582 = fdiv double %580, %581
%583 = fneg double %582
%584 = call double @llvm.fmuladd.f64(double %557, double %562, double %583)
%585 = load double*, double** %82
%586 = load i32, i32* %99
%587 = mul nsw i32 %586, 2
%588 = add nsw i32 %587, 1
%589 = sext i32 %588 to i64
%590 = getelementptr inbounds double, double* %585, i64 %589
store double %584, double* %590
%591 = load double, double* %109
%592 = load double, double* %100
%593 = fmul double %591, %592
%594 = load double*, double** %71
%595 = load i32, i32* %99
%596 = sext i32 %595 to i64
%597 = getelementptr inbounds double, double* %594, i64 %596
%598 = load double, double* %597
%599 = fmul double %593, %598
%600 = load double*, double** %83
%601 = load i32, i32* %99
%602 = mul nsw i32 %601, 2
%603 = add nsw i32 %602, 0
%604 = sext i32 %603 to i64
%605 = getelementptr inbounds double, double* %600, i64 %604
store double %599, double* %605
%606 = load double, double* %109
%607 = load double, double* %100
%608 = fmul double %606, %607
%609 = load double*, double** %70
%610 = load i32, i32* %99
%611 = sext i32 %610 to i64
%612 = getelementptr inbounds double, double* %609, i64 %611
%613 = load double, double* %612
%614 = load double, double* %114
%615 = load double, double* %110
%616 = fmul double %614, %615
%617 = load double*, double** %67
%618 = load i32, i32* %99
%619 = mul nsw i32 %618, 2
%620 = add nsw i32 %619, 0
%621 = sext i32 %620 to i64
%622 = getelementptr inbounds double, double* %617, i64 %621
%623 = load double, double* %622
%624 = fmul double %616, %623
%625 = load double, double* %112
%626 = fdiv double %624, %625
%627 = fneg double %626
%628 = call double @llvm.fmuladd.f64(double %608, double %613, double %627)
%629 = load double*, double** %84
%630 = load i32, i32* %99
%631 = mul nsw i32 %630, 2
%632 = add nsw i32 %631, 0
%633 = sext i32 %632 to i64
%634 = getelementptr inbounds double, double* %629, i64 %633
store double %628, double* %634
%635 = load double, double* %109
%636 = fmul double 2.000000e+00, %635
%637 = load double, double* %100
%638 = fmul double %636, %637
%639 = load double*, double** %71
%640 = load i32, i32* %99
%641 = sext i32 %640 to i64
%642 = getelementptr inbounds double, double* %639, i64 %641
%643 = load double, double* %642
%644 = load double, double* %114
%645 = load double, double* %110
%646 = fmul double %644, %645
%647 = load double*, double** %67
%648 = load i32, i32* %99
%649 = mul nsw i32 %648, 2
%650 = add nsw i32 %649, 1
%651 = sext i32 %650 to i64
%652 = getelementptr inbounds double, double* %647, i64 %651
%653 = load double, double* %652
%654 = fmul double %646, %653
%655 = load double, double* %112
%656 = fdiv double %654, %655
%657 = fneg double %656
%658 = call double @llvm.fmuladd.f64(double %638, double %643, double %657)
%659 = load double*, double** %84
%660 = load i32, i32* %99
%661 = mul nsw i32 %660, 2
%662 = add nsw i32 %661, 1
%663 = sext i32 %662 to i64
%664 = getelementptr inbounds double, double* %659, i64 %663
store double %658, double* %664
%665 = load double, double* %109
%666 = fmul double 2.000000e+00, %665
%667 = load double, double* %102
%668 = fmul double %666, %667
%669 = load double*, double** %85
%670 = load i32, i32* %99
%671 = mul nsw i32 %670, 4
%672 = add nsw i32 %671, 0
%673 = sext i32 %672 to i64
%674 = getelementptr inbounds double, double* %669, i64 %673
store double %668, double* %674
%675 = load double, double* %109
%676 = load double, double* %102
%677 = fmul double %675, %676
%678 = load double*, double** %85
%679 = load i32, i32* %99
%680 = mul nsw i32 %679, 4
%681 = add nsw i32 %680, 3
%682 = sext i32 %681 to i64
%683 = getelementptr inbounds double, double* %678, i64 %682
store double %677, double* %683
%684 = load double, double* %109
%685 = load double, double* %102
%686 = fmul double %684, %685
%687 = load double*, double** %87
%688 = load i32, i32* %99
%689 = mul nsw i32 %688, 4
%690 = add nsw i32 %689, 2
%691 = sext i32 %690 to i64
%692 = getelementptr inbounds double, double* %687, i64 %691
store double %686, double* %692
%693 = load double, double* %109
%694 = load double, double* %102
%695 = fmul double %693, %694
%696 = load double*, double** %86
%697 = load i32, i32* %99
%698 = mul nsw i32 %697, 4
%699 = add nsw i32 %698, 0
%700 = sext i32 %699 to i64
%701 = getelementptr inbounds double, double* %696, i64 %700
store double %695, double* %701
%702 = load double, double* %109
%703 = fmul double 2.000000e+00, %702
%704 = load double, double* %102
%705 = fmul double %703, %704
%706 = load double*, double** %86
%707 = load i32, i32* %99
%708 = mul nsw i32 %707, 4
%709 = add nsw i32 %708, 3
%710 = sext i32 %709 to i64
%711 = getelementptr inbounds double, double* %706, i64 %710
store double %705, double* %711
%712 = load double, double* %109
%713 = load double, double* %102
%714 = fmul double %712, %713
%715 = load double*, double** %88
%716 = load i32, i32* %99
%717 = mul nsw i32 %716, 4
%718 = add nsw i32 %717, 1
%719 = sext i32 %718 to i64
%720 = getelementptr inbounds double, double* %715, i64 %719
store double %714, double* %720
%721 = load i32, i32* %115
%722 = icmp ne i32 %721, 0
br i1 %722, label %723, label %910
723: ; preds = %123
%724 = load double, double* %109
%725 = fneg double %724
%726 = load double, double* %100
%727 = fmul double %725, %726
%728 = load double*, double** %62
%729 = getelementptr inbounds double, double* %728, i64 0
%730 = load double, double* %729
%731 = load double, double* %109
%732 = load double, double* %106
%733 = fmul double %731, %732
%734 = load double, double* %55
%735 = fmul double %733, %734
%736 = load double*, double** %65
%737 = load i32, i32* %99
%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** %64
%743 = load i32, i32* %99
%744 = mul nsw i32 %743, 2
%745 = add nsw i32 %744, 0
%746 = sext i32 %745 to i64
%747 = getelementptr inbounds double, double* %742, i64 %746
%748 = load double, double* %747
%749 = fmul double %741, %748
%750 = load double, double* %111
%751 = fdiv double %749, %750
%752 = fneg double %751
%753 = call double @llvm.fmuladd.f64(double %727, double %730, double %752)
%754 = load double, double* %51
%755 = load double, double* %100
%756 = fmul double %754, %755
%757 = load double, double* %110
%758 = fmul double %756, %757
%759 = load double*, double** %70
%760 = load i32, i32* %99
%761 = sext i32 %760 to i64
%762 = getelementptr inbounds double, double* %759, i64 %761
%763 = load double, double* %762
%764 = fsub double %763, 0.000000e+00
%765 = call double @llvm.fmuladd.f64(double %758, double %764, double %753)
%766 = load double, double* %52
%767 = load double, double* %100
%768 = fmul double %766, %767
%769 = load double, double* %109
%770 = fsub double 1.000000e+00, %769
%771 = fmul double %768, %770
%772 = load double*, double** %70
%773 = load i32, i32* %99
%774 = sext i32 %773 to i64
%775 = getelementptr inbounds double, double* %772, i64 %774
%776 = load double, double* %775
%777 = fsub double %776, 0.000000e+00
%778 = fmul double %771, %777
%779 = load double*, double** %70
%780 = load i32, i32* %99
%781 = sext i32 %780 to i64
%782 = getelementptr inbounds double, double* %779, i64 %781
%783 = load double, double* %782
%784 = fsub double %783, 0.000000e+00
%785 = call double @llvm.fmuladd.f64(double %778, double %784, double %765)
%786 = load double*, double** %89
%787 = load i32, i32* %99
%788 = sext i32 %787 to i64
%789 = getelementptr inbounds double, double* %786, i64 %788
store double %785, double* %789
%790 = load double, double* %51
%791 = load double, double* %100
%792 = fmul double %790, %791
%793 = load double, double* %110
%794 = load double, double* %52
%795 = load double, double* %100
%796 = fmul double %794, %795
%797 = load double, double* %109
%798 = fsub double 1.000000e+00, %797
%799 = fmul double %796, %798
%800 = fmul double %799, 2.000000e+00
%801 = load double*, double** %70
%802 = load i32, i32* %99
%803 = sext i32 %802 to i64
%804 = getelementptr inbounds double, double* %801, i64 %803
%805 = load double, double* %804
%806 = fsub double %805, 0.000000e+00
%807 = fmul double %800, %806
%808 = call double @llvm.fmuladd.f64(double %792, double %793, double %807)
%809 = load double*, double** %90
%810 = load i32, i32* %99
%811 = sext i32 %810 to i64
%812 = getelementptr inbounds double, double* %809, i64 %811
store double %808, double* %812
%813 = load double*, double** %91
%814 = load i32, i32* %99
%815 = sext i32 %814 to i64
%816 = getelementptr inbounds double, double* %813, i64 %815
store double 0.000000e+00, double* %816
%817 = load double, double* %109
%818 = fneg double %817
%819 = load double, double* %100
%820 = fmul double %818, %819
%821 = load double*, double** %62
%822 = getelementptr inbounds double, double* %821, i64 1
%823 = load double, double* %822
%824 = load double, double* %109
%825 = load double, double* %106
%826 = fmul double %824, %825
%827 = load double, double* %55
%828 = fmul double %826, %827
%829 = load double*, double** %65
%830 = load i32, i32* %99
%831 = sext i32 %830 to i64
%832 = getelementptr inbounds double, double* %829, i64 %831
%833 = load double, double* %832
%834 = fmul double %828, %833
%835 = load double*, double** %64
%836 = load i32, i32* %99
%837 = mul nsw i32 %836, 2
%838 = add nsw i32 %837, 1
%839 = sext i32 %838 to i64
%840 = getelementptr inbounds double, double* %835, i64 %839
%841 = load double, double* %840
%842 = fmul double %834, %841
%843 = load double, double* %111
%844 = fdiv double %842, %843
%845 = fneg double %844
%846 = call double @llvm.fmuladd.f64(double %820, double %823, double %845)
%847 = load double, double* %51
%848 = load double, double* %100
%849 = fmul double %847, %848
%850 = load double, double* %110
%851 = fmul double %849, %850
%852 = load double*, double** %71
%853 = load i32, i32* %99
%854 = sext i32 %853 to i64
%855 = getelementptr inbounds double, double* %852, i64 %854
%856 = load double, double* %855
%857 = fsub double %856, 0.000000e+00
%858 = call double @llvm.fmuladd.f64(double %851, double %857, double %846)
%859 = load double, double* %52
%860 = load double, double* %100
%861 = fmul double %859, %860
%862 = load double, double* %109
%863 = fsub double 1.000000e+00, %862
%864 = fmul double %861, %863
%865 = load double*, double** %71
%866 = load i32, i32* %99
%867 = sext i32 %866 to i64
%868 = getelementptr inbounds double, double* %865, i64 %867
%869 = load double, double* %868
%870 = fsub double %869, 0.000000e+00
%871 = fmul double %864, %870
%872 = load double*, double** %71
%873 = load i32, i32* %99
%874 = sext i32 %873 to i64
%875 = getelementptr inbounds double, double* %872, i64 %874
%876 = load double, double* %875
%877 = fsub double %876, 0.000000e+00
%878 = call double @llvm.fmuladd.f64(double %871, double %877, double %858)
%879 = load double*, double** %92
%880 = load i32, i32* %99
%881 = sext i32 %880 to i64
%882 = getelementptr inbounds double, double* %879, i64 %881
store double %878, double* %882
%883 = load double*, double** %93
%884 = load i32, i32* %99
%885 = sext i32 %884 to i64
%886 = getelementptr inbounds double, double* %883, i64 %885
store double 0.000000e+00, double* %886
%887 = load double, double* %51
%888 = load double, double* %100
%889 = fmul double %887, %888
%890 = load double, double* %110
%891 = load double, double* %52
%892 = load double, double* %100
%893 = fmul double %891, %892
%894 = load double, double* %109
%895 = fsub double 1.000000e+00, %894
%896 = fmul double %893, %895
%897 = fmul double %896, 2.000000e+00
%898 = load double*, double** %71
%899 = load i32, i32* %99
%900 = sext i32 %899 to i64
%901 = getelementptr inbounds double, double* %898, i64 %900
%902 = load double, double* %901
%903 = fsub double %902, 0.000000e+00
%904 = fmul double %897, %903
%905 = call double @llvm.fmuladd.f64(double %889, double %890, double %904)
%906 = load double*, double** %94
%907 = load i32, i32* %99
%908 = sext i32 %907 to i64
%909 = getelementptr inbounds double, double* %906, i64 %908
store double %905, double* %909
br label %1444
910: ; preds = %123
%911 = load i32, i32* %116
%912 = icmp ne i32 %911, 0
br i1 %912, label %913, label %1286
913: ; preds = %910
%914 = load double, double* %109
%915 = fneg double %914
%916 = load double, double* %100
%917 = fmul double %915, %916
%918 = load double*, double** %62
%919 = getelementptr inbounds double, double* %918, i64 0
%920 = load double, double* %919
%921 = load double, double* %109
%922 = load double, double* %106
%923 = fmul double %921, %922
%924 = load double, double* %55
%925 = fmul double %923, %924
%926 = load double*, double** %65
%927 = load i32, i32* %99
%928 = sext i32 %927 to i64
%929 = getelementptr inbounds double, double* %926, i64 %928
%930 = load double, double* %929
%931 = fmul double %925, %930
%932 = load double*, double** %64
%933 = load i32, i32* %99
%934 = mul nsw i32 %933, 2
%935 = add nsw i32 %934, 0
%936 = sext i32 %935 to i64
%937 = getelementptr inbounds double, double* %932, i64 %936
%938 = load double, double* %937
%939 = fmul double %931, %938
%940 = load double, double* %111
%941 = fdiv double %939, %940
%942 = fneg double %941
%943 = call double @llvm.fmuladd.f64(double %917, double %920, double %942)
%944 = load double, double* %52
%945 = load double, double* %100
%946 = fmul double %944, %945
%947 = load double, double* %109
%948 = fsub double 1.000000e+00, %947
%949 = fmul double %946, %948
%950 = load double*, double** %70
%951 = load i32, i32* %99
%952 = sext i32 %951 to i64
%953 = getelementptr inbounds double, double* %950, i64 %952
%954 = load double, double* %953
%955 = fsub double %954, 0.000000e+00
%956 = call double @llvm.fmuladd.f64(double %949, double %955, double %943)
%957 = load double*, double** %89
%958 = load i32, i32* %99
%959 = sext i32 %958 to i64
%960 = getelementptr inbounds double, double* %957, i64 %959
store double %956, double* %960
%961 = load double, double* %52
%962 = load double, double* %100
%963 = fmul double %961, %962
%964 = load double, double* %109
%965 = fsub double 1.000000e+00, %964
%966 = fmul double %963, %965
%967 = load double*, double** %90
%968 = load i32, i32* %99
%969 = sext i32 %968 to i64
%970 = getelementptr inbounds double, double* %967, i64 %969
store double %966, double* %970
%971 = load double*, double** %91
%972 = load i32, i32* %99
%973 = sext i32 %972 to i64
%974 = getelementptr inbounds double, double* %971, i64 %973
store double 0.000000e+00, double* %974
%975 = load double, double* %109
%976 = fneg double %975
%977 = load double, double* %100
%978 = fmul double %976, %977
%979 = load double*, double** %62
%980 = getelementptr inbounds double, double* %979, i64 1
%981 = load double, double* %980
%982 = load double, double* %109
%983 = load double, double* %106
%984 = fmul double %982, %983
%985 = load double, double* %55
%986 = fmul double %984, %985
%987 = load double*, double** %65
%988 = load i32, i32* %99
%989 = sext i32 %988 to i64
%990 = getelementptr inbounds double, double* %987, i64 %989
%991 = load double, double* %990
%992 = fmul double %986, %991
%993 = load double*, double** %64
%994 = load i32, i32* %99
%995 = mul nsw i32 %994, 2
%996 = add nsw i32 %995, 1
%997 = sext i32 %996 to i64
%998 = getelementptr inbounds double, double* %993, i64 %997
%999 = load double, double* %998
%1000 = fmul double %992, %999
%1001 = load double, double* %111
%1002 = fdiv double %1000, %1001
%1003 = fneg double %1002
%1004 = call double @llvm.fmuladd.f64(double %978, double %981, double %1003)
%1005 = load double, double* %52
%1006 = load double, double* %100
%1007 = fmul double %1005, %1006
%1008 = load double, double* %109
%1009 = fsub double 1.000000e+00, %1008
%1010 = fmul double %1007, %1009
%1011 = load double*, double** %71
%1012 = load i32, i32* %99
%1013 = sext i32 %1012 to i64
%1014 = getelementptr inbounds double, double* %1011, i64 %1013
%1015 = load double, double* %1014
%1016 = fsub double %1015, 0.000000e+00
%1017 = call double @llvm.fmuladd.f64(double %1010, double %1016, double %1004)
%1018 = load double*, double** %92
%1019 = load i32, i32* %99
%1020 = sext i32 %1019 to i64
%1021 = getelementptr inbounds double, double* %1018, i64 %1020
store double %1017, double* %1021
%1022 = load double*, double** %93
%1023 = load i32, i32* %99
%1024 = sext i32 %1023 to i64
%1025 = getelementptr inbounds double, double* %1022, i64 %1024
store double 0.000000e+00, double* %1025
%1026 = load double, double* %52
%1027 = load double, double* %100
%1028 = fmul double %1026, %1027
%1029 = load double, double* %109
%1030 = fsub double 1.000000e+00, %1029
%1031 = fmul double %1028, %1030
%1032 = load double*, double** %94
%1033 = load i32, i32* %99
%1034 = sext i32 %1033 to i64
%1035 = getelementptr inbounds double, double* %1032, i64 %1034
store double %1031, double* %1035
%1036 = load double*, double** %70
%1037 = load i32, i32* %99
%1038 = sext i32 %1037 to i64
%1039 = getelementptr inbounds double, double* %1036, i64 %1038
%1040 = load double, double* %1039
%1041 = load double*, double** %67
%1042 = load i32, i32* %99
%1043 = mul nsw i32 %1042, 2
%1044 = add nsw i32 %1043, 0
%1045 = sext i32 %1044 to i64
%1046 = getelementptr inbounds double, double* %1041, i64 %1045
%1047 = load double, double* %1046
%1048 = load double*, double** %71
%1049 = load i32, i32* %99
%1050 = sext i32 %1049 to i64
%1051 = getelementptr inbounds double, double* %1048, i64 %1050
%1052 = load double, double* %1051
%1053 = load double*, double** %67
%1054 = load i32, i32* %99
%1055 = mul nsw i32 %1054, 2
%1056 = add nsw i32 %1055, 1
%1057 = sext i32 %1056 to i64
%1058 = getelementptr inbounds double, double* %1053, i64 %1057
%1059 = load double, double* %1058
%1060 = fmul double %1052, %1059
%1061 = call double @llvm.fmuladd.f64(double %1040, double %1047, double %1060)
store double %1061, double* %113
%1062 = load double, double* %113
%1063 = fcmp olt double %1062, 0.000000e+00
br i1 %1063, label %1064, label %1285
1064: ; preds = %913
%1065 = load double, double* %100
%1066 = load double, double* %110
%1067 = fmul double %1065, %1066
%1068 = load double*, double** %70
%1069 = load i32, i32* %99
%1070 = sext i32 %1069 to i64
%1071 = getelementptr inbounds double, double* %1068, i64 %1070
%1072 = load double, double* %1071
%1073 = fmul double %1067, %1072
%1074 = load double*, double** %70
%1075 = load i32, i32* %99
%1076 = sext i32 %1075 to i64
%1077 = getelementptr inbounds double, double* %1074, i64 %1076
%1078 = load double, double* %1077
%1079 = load double*, double** %67
%1080 = load i32, i32* %99
%1081 = mul nsw i32 %1080, 2
%1082 = add nsw i32 %1081, 0
%1083 = sext i32 %1082 to i64
%1084 = getelementptr inbounds double, double* %1079, i64 %1083
%1085 = load double, double* %1084
%1086 = load double*, double** %71
%1087 = load i32, i32* %99
%1088 = sext i32 %1087 to i64
%1089 = getelementptr inbounds double, double* %1086, i64 %1088
%1090 = load double, double* %1089
%1091 = load double*, double** %67
%1092 = load i32, i32* %99
%1093 = mul nsw i32 %1092, 2
%1094 = add nsw i32 %1093, 1
%1095 = sext i32 %1094 to i64
%1096 = getelementptr inbounds double, double* %1091, i64 %1095
%1097 = load double, double* %1096
%1098 = fmul double %1090, %1097
%1099 = call double @llvm.fmuladd.f64(double %1078, double %1085, double %1098)
%1100 = fmul double %1073, %1099
%1101 = load double, double* %112
%1102 = fdiv double %1100, %1101
%1103 = load double*, double** %89
%1104 = load i32, i32* %99
%1105 = sext i32 %1104 to i64
%1106 = getelementptr inbounds double, double* %1103, i64 %1105
%1107 = load double, double* %1106
%1108 = fadd double %1107, %1102
store double %1108, double* %1106
%1109 = load double, double* %100
%1110 = load double, double* %110
%1111 = fmul double %1109, %1110
%1112 = load double*, double** %70
%1113 = load i32, i32* %99
%1114 = sext i32 %1113 to i64
%1115 = getelementptr inbounds double, double* %1112, i64 %1114
%1116 = load double, double* %1115
%1117 = fmul double 2.000000e+00, %1116
%1118 = load double*, double** %67
%1119 = load i32, i32* %99
%1120 = mul nsw i32 %1119, 2
%1121 = add nsw i32 %1120, 0
%1122 = sext i32 %1121 to i64
%1123 = getelementptr inbounds double, double* %1118, i64 %1122
%1124 = load double, double* %1123
%1125 = load double*, double** %71
%1126 = load i32, i32* %99
%1127 = sext i32 %1126 to i64
%1128 = getelementptr inbounds double, double* %1125, i64 %1127
%1129 = load double, double* %1128
%1130 = load double*, double** %67
%1131 = load i32, i32* %99
%1132 = mul nsw i32 %1131, 2
%1133 = add nsw i32 %1132, 1
%1134 = sext i32 %1133 to i64
%1135 = getelementptr inbounds double, double* %1130, i64 %1134
%1136 = load double, double* %1135
%1137 = fmul double %1129, %1136
%1138 = call double @llvm.fmuladd.f64(double %1117, double %1124, double %1137)
%1139 = fmul double %1111, %1138
%1140 = load double, double* %112
%1141 = fdiv double %1139, %1140
%1142 = load double*, double** %90
%1143 = load i32, i32* %99
%1144 = sext i32 %1143 to i64
%1145 = getelementptr inbounds double, double* %1142, i64 %1144
%1146 = load double, double* %1145
%1147 = fadd double %1146, %1141
store double %1147, double* %1145
%1148 = load double, double* %100
%1149 = load double, double* %110
%1150 = fmul double %1148, %1149
%1151 = load double*, double** %70
%1152 = load i32, i32* %99
%1153 = sext i32 %1152 to i64
%1154 = getelementptr inbounds double, double* %1151, i64 %1153
%1155 = load double, double* %1154
%1156 = fmul double %1150, %1155
%1157 = load double*, double** %67
%1158 = load i32, i32* %99
%1159 = mul nsw i32 %1158, 2
%1160 = add nsw i32 %1159, 1
%1161 = sext i32 %1160 to i64
%1162 = getelementptr inbounds double, double* %1157, i64 %1161
%1163 = load double, double* %1162
%1164 = fmul double %1156, %1163
%1165 = load double, double* %112
%1166 = fdiv double %1164, %1165
%1167 = load double*, double** %91
%1168 = load i32, i32* %99
%1169 = sext i32 %1168 to i64
%1170 = getelementptr inbounds double, double* %1167, i64 %1169
store double %1166, double* %1170
%1171 = load double, double* %100
%1172 = load double, double* %110
%1173 = fmul double %1171, %1172
%1174 = load double*, double** %71
%1175 = load i32, i32* %99
%1176 = sext i32 %1175 to i64
%1177 = getelementptr inbounds double, double* %1174, i64 %1176
%1178 = load double, double* %1177
%1179 = load double*, double** %70
%1180 = load i32, i32* %99
%1181 = sext i32 %1180 to i64
%1182 = getelementptr inbounds double, double* %1179, i64 %1181
%1183 = load double, double* %1182
%1184 = fmul double %1178, %1183
%1185 = load double*, double** %67
%1186 = load i32, i32* %99
%1187 = mul nsw i32 %1186, 2
%1188 = add nsw i32 %1187, 0
%1189 = sext i32 %1188 to i64
%1190 = getelementptr inbounds double, double* %1185, i64 %1189
%1191 = load double, double* %1190
%1192 = load double*, double** %71
%1193 = load i32, i32* %99
%1194 = sext i32 %1193 to i64
%1195 = getelementptr inbounds double, double* %1192, i64 %1194
%1196 = load double, double* %1195
%1197 = load double*, double** %71
%1198 = load i32, i32* %99
%1199 = sext i32 %1198 to i64
%1200 = getelementptr inbounds double, double* %1197, i64 %1199
%1201 = load double, double* %1200
%1202 = fmul double %1196, %1201
%1203 = load double*, double** %67
%1204 = load i32, i32* %99
%1205 = mul nsw i32 %1204, 2
%1206 = add nsw i32 %1205, 1
%1207 = sext i32 %1206 to i64
%1208 = getelementptr inbounds double, double* %1203, i64 %1207
%1209 = load double, double* %1208
%1210 = fmul double %1202, %1209
%1211 = call double @llvm.fmuladd.f64(double %1184, double %1191, double %1210)
%1212 = fmul double %1173, %1211
%1213 = load double, double* %112
%1214 = fdiv double %1212, %1213
%1215 = load double*, double** %92
%1216 = load i32, i32* %99
%1217 = sext i32 %1216 to i64
%1218 = getelementptr inbounds double, double* %1215, i64 %1217
%1219 = load double, double* %1218
%1220 = fadd double %1219, %1214
store double %1220, double* %1218
%1221 = load double, double* %100
%1222 = load double, double* %110
%1223 = fmul double %1221, %1222
%1224 = load double*, double** %71
%1225 = load i32, i32* %99
%1226 = sext i32 %1225 to i64
%1227 = getelementptr inbounds double, double* %1224, i64 %1226
%1228 = load double, double* %1227
%1229 = fmul double %1223, %1228
%1230 = load double*, double** %67
%1231 = load i32, i32* %99
%1232 = mul nsw i32 %1231, 2
%1233 = add nsw i32 %1232, 0
%1234 = sext i32 %1233 to i64
%1235 = getelementptr inbounds double, double* %1230, i64 %1234
%1236 = load double, double* %1235
%1237 = fmul double %1229, %1236
%1238 = load double, double* %112
%1239 = fdiv double %1237, %1238
%1240 = load double*, double** %93
%1241 = load i32, i32* %99
%1242 = sext i32 %1241 to i64
%1243 = getelementptr inbounds double, double* %1240, i64 %1242
%1244 = load double, double* %1243
%1245 = fadd double %1244, %1239
store double %1245, double* %1243
%1246 = load double, double* %100
%1247 = load double, double* %110
%1248 = fmul double %1246, %1247
%1249 = load double*, double** %70
%1250 = load i32, i32* %99
%1251 = sext i32 %1250 to i64
%1252 = getelementptr inbounds double, double* %1249, i64 %1251
%1253 = load double, double* %1252
%1254 = load double*, double** %67
%1255 = load i32, i32* %99
%1256 = mul nsw i32 %1255, 2
%1257 = add nsw i32 %1256, 0
%1258 = sext i32 %1257 to i64
%1259 = getelementptr inbounds double, double* %1254, i64 %1258
%1260 = load double, double* %1259
%1261 = load double*, double** %71
%1262 = load i32, i32* %99
%1263 = sext i32 %1262 to i64
%1264 = getelementptr inbounds double, double* %1261, i64 %1263
%1265 = load double, double* %1264
%1266 = fmul double 2.000000e+00, %1265
%1267 = load double*, double** %67
%1268 = load i32, i32* %99
%1269 = mul nsw i32 %1268, 2
%1270 = add nsw i32 %1269, 1
%1271 = sext i32 %1270 to i64
%1272 = getelementptr inbounds double, double* %1267, i64 %1271
%1273 = load double, double* %1272
%1274 = fmul double %1266, %1273
%1275 = call double @llvm.fmuladd.f64(double %1253, double %1260, double %1274)
%1276 = fmul double %1248, %1275
%1277 = load double, double* %112
%1278 = fdiv double %1276, %1277
%1279 = load double*, double** %94
%1280 = load i32, i32* %99
%1281 = sext i32 %1280 to i64
%1282 = getelementptr inbounds double, double* %1279, i64 %1281
%1283 = load double, double* %1282
%1284 = fadd double %1283, %1278
store double %1284, double* %1282
br label %1285
1285: ; preds = %1064, %913
br label %1443
1286: ; preds = %910
%1287 = load double, double* %109
%1288 = fneg double %1287
%1289 = load double, double* %100
%1290 = fmul double %1288, %1289
%1291 = load double*, double** %62
%1292 = getelementptr inbounds double, double* %1291, i64 0
%1293 = load double, double* %1292
%1294 = load double, double* %109
%1295 = load double, double* %106
%1296 = fmul double %1294, %1295
%1297 = load double, double* %55
%1298 = fmul double %1296, %1297
%1299 = load double*, double** %65
%1300 = load i32, i32* %99
%1301 = sext i32 %1300 to i64
%1302 = getelementptr inbounds double, double* %1299, i64 %1301
%1303 = load double, double* %1302
%1304 = fmul double %1298, %1303
%1305 = load double*, double** %64
%1306 = load i32, i32* %99
%1307 = mul nsw i32 %1306, 2
%1308 = add nsw i32 %1307, 0
%1309 = sext i32 %1308 to i64
%1310 = getelementptr inbounds double, double* %1305, i64 %1309
%1311 = load double, double* %1310
%1312 = fmul double %1304, %1311
%1313 = load double, double* %111
%1314 = fdiv double %1312, %1313
%1315 = fneg double %1314
%1316 = call double @llvm.fmuladd.f64(double %1290, double %1293, double %1315)
%1317 = load double, double* %51
%1318 = load double, double* %100
%1319 = fmul double %1317, %1318
%1320 = load double, double* %110
%1321 = fmul double %1319, %1320
%1322 = load double*, double** %70
%1323 = load i32, i32* %99
%1324 = sext i32 %1323 to i64
%1325 = getelementptr inbounds double, double* %1322, i64 %1324
%1326 = load double, double* %1325
%1327 = fsub double %1326, 0.000000e+00
%1328 = call double @llvm.fmuladd.f64(double %1321, double %1327, double %1316)
%1329 = load double, double* %52
%1330 = load double, double* %100
%1331 = fmul double %1329, %1330
%1332 = load double, double* %109
%1333 = fsub double 1.000000e+00, %1332
%1334 = fmul double %1331, %1333
%1335 = load double*, double** %70
%1336 = load i32, i32* %99
%1337 = sext i32 %1336 to i64
%1338 = getelementptr inbounds double, double* %1335, i64 %1337
%1339 = load double, double* %1338
%1340 = fsub double %1339, 0.000000e+00
%1341 = call double @llvm.fmuladd.f64(double %1334, double %1340, double %1328)
%1342 = load double*, double** %89
%1343 = load i32, i32* %99
%1344 = sext i32 %1343 to i64
%1345 = getelementptr inbounds double, double* %1342, i64 %1344
store double %1341, double* %1345
%1346 = load double, double* %51
%1347 = load double, double* %100
%1348 = fmul double %1346, %1347
%1349 = load double, double* %110
%1350 = load double, double* %52
%1351 = load double, double* %100
%1352 = fmul double %1350, %1351
%1353 = load double, double* %109
%1354 = fsub double 1.000000e+00, %1353
%1355 = fmul double %1352, %1354
%1356 = call double @llvm.fmuladd.f64(double %1348, double %1349, double %1355)
%1357 = load double*, double** %90
%1358 = load i32, i32* %99
%1359 = sext i32 %1358 to i64
%1360 = getelementptr inbounds double, double* %1357, i64 %1359
store double %1356, double* %1360
%1361 = load double*, double** %91
%1362 = load i32, i32* %99
%1363 = sext i32 %1362 to i64
%1364 = getelementptr inbounds double, double* %1361, i64 %1363
store double 0.000000e+00, double* %1364
%1365 = load double, double* %109
%1366 = fneg double %1365
%1367 = load double, double* %100
%1368 = fmul double %1366, %1367
%1369 = load double*, double** %62
%1370 = getelementptr inbounds double, double* %1369, i64 1
%1371 = load double, double* %1370
%1372 = load double, double* %109
%1373 = load double, double* %106
%1374 = fmul double %1372, %1373
%1375 = load double, double* %55
%1376 = fmul double %1374, %1375
%1377 = load double*, double** %65
%1378 = load i32, i32* %99
%1379 = sext i32 %1378 to i64
%1380 = getelementptr inbounds double, double* %1377, i64 %1379
%1381 = load double, double* %1380
%1382 = fmul double %1376, %1381
%1383 = load double*, double** %64
%1384 = load i32, i32* %99
%1385 = mul nsw i32 %1384, 2
%1386 = add nsw i32 %1385, 1
%1387 = sext i32 %1386 to i64
%1388 = getelementptr inbounds double, double* %1383, i64 %1387
%1389 = load double, double* %1388
%1390 = fmul double %1382, %1389
%1391 = load double, double* %111
%1392 = fdiv double %1390, %1391
%1393 = fneg double %1392
%1394 = call double @llvm.fmuladd.f64(double %1368, double %1371, double %1393)
%1395 = load double, double* %51
%1396 = load double, double* %100
%1397 = fmul double %1395, %1396
%1398 = load double, double* %110
%1399 = fmul double %1397, %1398
%1400 = load double*, double** %71
%1401 = load i32, i32* %99
%1402 = sext i32 %1401 to i64
%1403 = getelementptr inbounds double, double* %1400, i64 %1402
%1404 = load double, double* %1403
%1405 = fsub double %1404, 0.000000e+00
%1406 = call double @llvm.fmuladd.f64(double %1399, double %1405, double %1394)
%1407 = load double, double* %52
%1408 = load double, double* %100
%1409 = fmul double %1407, %1408
%1410 = load double, double* %109
%1411 = fsub double 1.000000e+00, %1410
%1412 = fmul double %1409, %1411
%1413 = load double*, double** %71
%1414 = load i32, i32* %99
%1415 = sext i32 %1414 to i64
%1416 = getelementptr inbounds double, double* %1413, i64 %1415
%1417 = load double, double* %1416
%1418 = fsub double %1417, 0.000000e+00
%1419 = call double @llvm.fmuladd.f64(double %1412, double %1418, double %1406)
%1420 = load double*, double** %92
%1421 = load i32, i32* %99
%1422 = sext i32 %1421 to i64
%1423 = getelementptr inbounds double, double* %1420, i64 %1422
store double %1419, double* %1423
%1424 = load double*, double** %93
%1425 = load i32, i32* %99
%1426 = sext i32 %1425 to i64
%1427 = getelementptr inbounds double, double* %1424, i64 %1426
store double 0.000000e+00, double* %1427
%1428 = load double, double* %51
%1429 = load double, double* %100
%1430 = fmul double %1428, %1429
%1431 = load double, double* %110
%1432 = load double, double* %52
%1433 = load double, double* %100
%1434 = fmul double %1432, %1433
%1435 = load double, double* %109
%1436 = fsub double 1.000000e+00, %1435
%1437 = fmul double %1434, %1436
%1438 = call double @llvm.fmuladd.f64(double %1430, double %1431, double %1437)
%1439 = load double*, double** %94
%1440 = load i32, i32* %99
%1441 = sext i32 %1440 to i64
%1442 = getelementptr inbounds double, double* %1439, i64 %1441
store double %1438, double* %1442
br label %1443
1443: ; preds = %1286, %1285
br label %1444
1444: ; preds = %1443, %723
%1445 = load double*, double** %69
%1446 = load i32, i32* %99
%1447 = mul nsw i32 %1446, 2
%1448 = add nsw i32 %1447, 0
%1449 = sext i32 %1448 to i64
%1450 = getelementptr inbounds double, double* %1445, i64 %1449
%1451 = load double, double* %1450
%1452 = load double*, double** %95
%1453 = load i32, i32* %99
%1454 = sext i32 %1453 to i64
%1455 = getelementptr inbounds double, double* %1452, i64 %1454
store double %1451, double* %1455
%1456 = load double*, double** %96
%1457 = load i32, i32* %99
%1458 = mul nsw i32 %1457, 2
%1459 = add nsw i32 %1458, 0
%1460 = sext i32 %1459 to i64
%1461 = getelementptr inbounds double, double* %1456, i64 %1460
store double 1.000000e+00, double* %1461
%1462 = load double*, double** %69
%1463 = load i32, i32* %99
%1464 = mul nsw i32 %1463, 2
%1465 = add nsw i32 %1464, 1
%1466 = sext i32 %1465 to i64
%1467 = getelementptr inbounds double, double* %1462, i64 %1466
%1468 = load double, double* %1467
%1469 = load double*, double** %97
%1470 = load i32, i32* %99
%1471 = sext i32 %1470 to i64
%1472 = getelementptr inbounds double, double* %1469, i64 %1471
store double %1468, double* %1472
%1473 = load double*, double** %98
%1474 = load i32, i32* %99
%1475 = mul nsw i32 %1474, 2
%1476 = add nsw i32 %1475, 1
%1477 = sext i32 %1476 to i64
%1478 = getelementptr inbounds double, double* %1473, i64 %1477
store double 1.000000e+00, double* %1478
br label %1479
1479: ; preds = %1444
%1480 = load i32, i32* %99
%1481 = add nsw i32 %1480, 1
store i32 %1481, i32* %99
br label %119
1482: ; preds = %119
ret void
}

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