void groundwaterBryantDawsonIonExEvaluateFC(
    const int nPoints, const int nSpace, const double omega, const double d_m,
    const double d_h, const double alpha_L, const double alpha_T,
    const double K_m, const double K_h, const double K_w, const double Z_tot,
    const double *v, const double *c_m, const double *c_h, double *m_m,
    double *dm_m_m, double *dm_m_h, double *m_h, double *dm_h_m, double *dm_h_h,
    double *f_m, double *df_m, double *f_h, double *df_h, double *a_m,
    double *a_h, double *phi_h, double *dphi_h, double *r_m, double *dr_m_dm,
    double *dr_m_dh, double *r_h, double *dr_h_dm, double *dr_h_dh) {
  int k, I, J;
  const int nSpace2 = nSpace * nSpace;
  double norm_v;
  double C_m, C_h, C_oh, C_a, Z_m, Z_h, dC_a_dC_h, denomZ;
  const double eps = 1.0e-12;
  for (k = 0; k < nPoints; k++) {
    C_m = c_m[k];
    C_h = c_h[k];
    C_oh = K_w / (C_h + eps);
    C_a = C_h - C_oh;
    dC_a_dC_h = 1.0 + K_w / (C_h * C_h + eps);
    denomZ = 1.0 + K_m * C_m + K_h * C_h;
    Z_m = K_m * C_m * Z_tot / denomZ;
    Z_h = K_h * C_h * Z_tot / denomZ;
    m_m[k] = omega * (C_m + Z_m);
    dm_m_m[k] = omega * (1.0 + K_m * Z_tot / denomZ -
                         K_m * C_m * Z_tot / (denomZ * denomZ) * K_m * C_m);
    dm_m_h[k] = omega * (-K_m * C_m * Z_tot / (denomZ * denomZ) * K_h * C_h);
    m_h[k] = omega * (C_a + Z_h);
    dm_h_m[k] = omega * (-K_h * C_h * Z_tot / (denomZ * denomZ) * K_m * C_m);
    dm_h_h[k] = omega * (dC_a_dC_h + K_h * Z_tot / denomZ -
                         K_h * C_h * Z_tot / (denomZ * denomZ) * K_h * C_h);
    phi_h[k] = C_a;
    dphi_h[k] = dC_a_dC_h;
    norm_v = 0.0;
    for (I = 0; I < nSpace; I++) {
      f_m[k * nSpace + I] = v[k * nSpace + I] * C_m;
      df_m[k * nSpace + I] = v[k * nSpace + I];
      f_h[k * nSpace + I] = v[k * nSpace + I] * C_a;
      df_h[k * nSpace + I] = v[k * nSpace + I] * dC_a_dC_h;
      norm_v += v[k * nSpace + I] * v[k * nSpace + I];
    }
    norm_v = sqrt(norm_v);
    if (norm_v > 0.0) {
      for (I = 0; I < nSpace; I++) {
        a_m[k * nSpace2 + I * nSpace + I] = omega * d_m + alpha_T * norm_v +
                                            (alpha_L - alpha_T) *
                                                v[k * nSpace + I] *
                                                v[k * nSpace + I] / norm_v;
        for (J = I + 1; J < nSpace; J++) {
          a_m[k * nSpace2 + I * nSpace + J] = (alpha_L - alpha_T) *
                                              v[k * nSpace + I] *
                                              v[k * nSpace + J] / norm_v;
          a_m[k * nSpace2 + J * nSpace + I] = a_m[k * nSpace2 + I * nSpace + J];
        }
        a_h[k * nSpace2 + I * nSpace + I] = omega * d_h + alpha_T * norm_v +
                                            (alpha_L - alpha_T) *
                                                v[k * nSpace + I] *
                                                v[k * nSpace + I] / norm_v;
        for (J = I + 1; J < nSpace; J++) {
          a_h[k * nSpace2 + I * nSpace + J] = (alpha_L - alpha_T) *
                                              v[k * nSpace + I] *
                                              v[k * nSpace + J] / norm_v;
          a_h[k * nSpace2 + J * nSpace + I] = a_h[k * nSpace2 + I * nSpace + J];
        }
      }
    } else {
      for (I = 0; I < nSpace; I++) {
        a_m[k * nSpace2 + I * nSpace + I] = omega * d_m;
        a_h[k * nSpace2 + I * nSpace + I] = omega * d_h;
      }
    }
    r_m[k] = 0.0;
    r_h[k] = 0.0;
    dr_m_dm[k] = 0.0;
    dr_m_dh[k] = 0.0;
    dr_h_dm[k] = 0.0;
    dr_h_dh[k] = 0.0;
  }
}


x86 assembly (clang, -O0):
<groundwaterBryantDawsonIonExEvaluateFC>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    0xa8(%rbp),%rax
mov    0xa0(%rbp),%rax
mov    0x98(%rbp),%rax
mov    0x90(%rbp),%rax
mov    0x88(%rbp),%rax
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
movsd  0x10(%rbp),%xmm8
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
movsd  %xmm2,-0x20(%rbp)
movsd  %xmm3,-0x28(%rbp)
movsd  %xmm4,-0x30(%rbp)
movsd  %xmm5,-0x38(%rbp)
movsd  %xmm6,-0x40(%rbp)
movsd  %xmm7,-0x48(%rbp)
mov    %rdx,-0x50(%rbp)
mov    %rcx,-0x58(%rbp)
mov    %r8,-0x60(%rbp)
mov    %r9,-0x68(%rbp)
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
mov    %eax,-0x78(%rbp)
movsd  0xe31(%rip),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1a27 <groundwaterBryantDawsonIonExEvaluateFC+0x917>
mov    -0x58(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x60(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  0xddf(%rip),%xmm1
addsd  -0x90(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x48(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
movsd  0xd92(%rip),%xmm2
addsd  %xmm2,%xmm0
divsd  %xmm0,%xmm1
movsd  0xd8a(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x38(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
mulsd  %xmm0,%xmm1
movsd  0xd65(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
mulsd  0x10(%rbp),%xmm0
divsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mulsd  0x10(%rbp),%xmm0
divsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
addsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
mulsd  0x10(%rbp),%xmm1
divsd  -0xc0(%rbp),%xmm1
ff
movsd  0xcbb(%rip),%xmm2
addsd  %xmm1,%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
mulsd  0x10(%rbp),%xmm1
movsd  -0xc0(%rbp),%xmm3
ff
mulsd  -0xc0(%rbp),%xmm3
ff
divsd  %xmm3,%xmm1
mulsd  -0x38(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
mulsd  0x10(%rbp),%xmm1
movsd  -0xc0(%rbp),%xmm2
ff
mulsd  -0xc0(%rbp),%xmm2
ff
divsd  %xmm2,%xmm1
mulsd  -0x40(%rbp),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm1
ff
addsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
mulsd  0x10(%rbp),%xmm1
movsd  -0xc0(%rbp),%xmm2
ff
mulsd  -0xc0(%rbp),%xmm2
ff
divsd  %xmm2,%xmm1
mulsd  -0x38(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0x40(%rbp),%xmm1
mulsd  0x10(%rbp),%xmm1
divsd  -0xc0(%rbp),%xmm1
ff
addsd  %xmm1,%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
mulsd  0x10(%rbp),%xmm1
movsd  -0xc0(%rbp),%xmm3
ff
mulsd  -0xc0(%rbp),%xmm3
ff
divsd  %xmm3,%xmm1
mulsd  -0x40(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    0x38(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
mov    0x70(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x78(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1679 <groundwaterBryantDawsonIonExEvaluateFC+0x569>
mov    -0x50(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
mov    0x40(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
mov    0x50(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1559 <groundwaterBryantDawsonIonExEvaluateFC+0x449>
movsd  -0x80(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    192f <groundwaterBryantDawsonIonExEvaluateFC+0x81f>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    192a <groundwaterBryantDawsonIonExEvaluateFC+0x81a>
movsd  -0x10(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x28(%rbp),%xmm1
subsd  -0x30(%rbp),%xmm1
mov    -0x50(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x50(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0x80(%rbp),%xmm1
addsd  %xmm1,%xmm0
mov    0x60(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x78(%rbp),%ecx
mov    -0x70(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    17e2 <groundwaterBryantDawsonIonExEvaluateFC+0x6d2>
movsd  -0x28(%rbp),%xmm0
subsd  -0x30(%rbp),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x74(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x80(%rbp),%xmm0
mov    0x60(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x78(%rbp),%ecx
mov    -0x70(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x74(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x60(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x78(%rbp),%ecx
mov    -0x70(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x74(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x60(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x78(%rbp),%ecx
mov    -0x74(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1730 <groundwaterBryantDawsonIonExEvaluateFC+0x620>
movsd  -0x10(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x28(%rbp),%xmm1
subsd  -0x30(%rbp),%xmm1
mov    -0x50(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x50(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0x80(%rbp),%xmm1
addsd  %xmm1,%xmm0
mov    0x68(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x78(%rbp),%ecx
mov    -0x70(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1917 <groundwaterBryantDawsonIonExEvaluateFC+0x807>
movsd  -0x28(%rbp),%xmm0
subsd  -0x30(%rbp),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x74(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x80(%rbp),%xmm0
mov    0x68(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x78(%rbp),%ecx
mov    -0x70(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x74(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x68(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x78(%rbp),%ecx
mov    -0x70(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x74(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x78(%rbp),%ecx
mov    -0x74(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1865 <groundwaterBryantDawsonIonExEvaluateFC+0x755>
jmp    191c <groundwaterBryantDawsonIonExEvaluateFC+0x80c>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    16a1 <groundwaterBryantDawsonIonExEvaluateFC+0x591>
jmp    19a7 <groundwaterBryantDawsonIonExEvaluateFC+0x897>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    19a2 <groundwaterBryantDawsonIonExEvaluateFC+0x892>
movsd  -0x10(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
mov    0x60(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x78(%rbp),%ecx
mov    -0x70(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mulsd  -0x20(%rbp),%xmm0
mov    0x68(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x78(%rbp),%ecx
mov    -0x70(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1936 <groundwaterBryantDawsonIonExEvaluateFC+0x826>
jmp    19a7 <groundwaterBryantDawsonIonExEvaluateFC+0x897>
mov    0x80(%rbp),%rax
movslq -0x6c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x98(%rbp),%rax
movslq -0x6c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x88(%rbp),%rax
movslq -0x6c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x90(%rbp),%rax
movslq -0x6c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0xa0(%rbp),%rax
movslq -0x6c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0xa8(%rbp),%rax
movslq -0x6c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    11de <groundwaterBryantDawsonIonExEvaluateFC+0xce>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<groundwaterBryantDawsonIonExEvaluateFC>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x238,%rsp
mov    %r9,0x198(%rsp)
mov    %r8,0x190(%rsp)
mov    %rcx,0x188(%rsp)
movsd  %xmm7,0x180(%rsp)
movapd %xmm6,0x1e0(%rsp)
movapd %xmm5,0x1d0(%rsp)
movsd  %xmm4,0xc8(%rsp)
movsd  %xmm2,0x48(%rsp)
movsd  %xmm1,0x40(%rsp)
movsd  %xmm0,0xd0(%rsp)
mov    %esi,0xc(%rsp)
test   %edi,%edi
jle    1f08 <groundwaterBryantDawsonIonExEvaluateFC+0xdf8>
mov    %rdx,%r12
mov    0x2c8(%rsp),%r9
mov    0x2c0(%rsp),%rax
movsd  0x270(%rsp),%xmm0
mov    0xc(%rsp),%r10d
mov    %r10d,%r8d
imul   %r8d,%r8d
movapd 0x1d0(%rsp),%xmm2
movapd %xmm2,%xmm4
mulsd  %xmm0,%xmm4
movapd %xmm4,0x220(%rsp)
movapd 0xe38(%rip),%xmm4
xorpd  %xmm4,%xmm2
movapd %xmm2,0x200(%rsp)
movapd 0x1e0(%rsp),%xmm2
xorpd  %xmm2,%xmm4
movapd %xmm4,0x210(%rsp)
mulsd  %xmm0,%xmm2
movapd %xmm2,0x1f0(%rsp)
movsd  0xd0(%rsp),%xmm0
movsd  0x40(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x40(%rsp)
movsd  0x48(%rsp),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x48(%rsp)
subsd  0xc8(%rsp),%xmm3
movslq %r10d,%rbx
mov    %edi,%esi
mov    %rsi,0x178(%rsp)
mov    %rax,%rdi
mov    %ebx,%r15d
mov    %r15d,%eax
and    $0xfffffffe,%eax
mov    %rax,0x158(%rsp)
mov    0x2b8(%rsp),%rsi
mov    0x2b0(%rsp),%rcx
mov    0x2a8(%rsp),%rdx
mov    0x2a0(%rsp),%r11
lea    -0x2(%r15),%rbp
mov    %rbp,0x1a0(%rsp)
lea    0x0(,%rbx,8),%rbp
mov    %rbp,0x138(%rsp)
lea    0x1(%rbx),%r13d
lea    (%rbx,%rbx,1),%ebp
mov    %ebp,0x60(%rsp)
lea    0x2(%rbx,%rbx,1),%ebp
mov    %ebp,0xc4(%rsp)
lea    -0x1(%r15),%rbp
mov    %rbp,0x160(%rsp)
lea    0x8(%r12),%rax
mov    %rax,0xd8(%rsp)
lea    0x8(%rdi),%rbp
mov    %rbp,0xf8(%rsp)
mov    %r8,0xa0(%rsp)
lea    0x0(,%r8,8),%rbp
mov    %rbp,0x170(%rsp)
mov    %rbx,0xb8(%rsp)
lea    0x8(,%rbx,8),%rbp
mov    %rbp,0x1b0(%rsp)
lea    0x8(%r9),%rbp
mov    %rbp,0xf0(%rsp)
xor    %eax,%eax
mov    %rax,0x70(%rsp)
mov    %r9,0xe8(%rsp)
mov    %rdi,0xe0(%rsp)
mov    %r10d,0x64(%rsp)
mov    %r12,%rbx
xor    %eax,%eax
movsd  %xmm3,0x168(%rsp)
mov    %r13,0x1b8(%rsp)
jmp    143c <groundwaterBryantDawsonIonExEvaluateFC+0x32c>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x2e0(%rsp),%rax
mov    0x50(%rsp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    0x2f8(%rsp),%rax
movq   $0x0,(%rax,%rcx,8)
mov    0x2e8(%rsp),%rax
movq   $0x0,(%rax,%rcx,8)
mov    0x2f0(%rsp),%rax
movq   $0x0,(%rax,%rcx,8)
mov    0x300(%rsp),%rax
movq   $0x0,(%rax,%rcx,8)
mov    0x308(%rsp),%rax
movq   $0x0,(%rax,%rcx,8)
mov    0x138(%rsp),%rbp
add    %rbp,%rbx
mov    0x108(%rsp),%r11
add    %rbp,%r11
mov    0x110(%rsp),%rdx
add    %rbp,%rdx
mov    0x118(%rsp),%rcx
add    %rbp,%rcx
mov    0x120(%rsp),%rsi
add    %rbp,%rsi
mov    0xa0(%rsp),%r8
mov    0x70(%rsp),%rax
add    %r8d,%eax
mov    %rax,0x70(%rsp)
add    %r8d,0x64(%rsp)
add    %rbp,0xd8(%rsp)
mov    0x170(%rsp),%rbp
add    %rbp,0xf8(%rsp)
add    %rbp,0xe0(%rsp)
add    %rbp,0xf0(%rsp)
add    %rbp,0xe8(%rsp)
mov    0x98(%rsp),%rax
cmp    0x178(%rsp),%rax
je     1f08 <groundwaterBryantDawsonIonExEvaluateFC+0xdf8>
mov    %r11,0x108(%rsp)
mov    %rdx,0x110(%rsp)
mov    %rcx,0x118(%rsp)
mov    %rsi,0x120(%rsp)
mov    %rax,%rcx
mov    0x188(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm13
mov    0x190(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm8
movapd %xmm8,%xmm12
movapd %xmm8,%xmm0
movapd 0x1e0(%rsp),%xmm5
movapd %xmm5,%xmm11
mulsd  %xmm8,%xmm11
movapd %xmm8,%xmm7
movsd  0xb6b(%rip),%xmm2
addsd  %xmm2,%xmm7
movsd  0x180(%rsp),%xmm15
movapd %xmm15,%xmm4
divsd  %xmm7,%xmm4
subsd  %xmm4,%xmm12
mulsd  %xmm8,%xmm0
addsd  %xmm2,%xmm0
divsd  %xmm0,%xmm15
movapd 0x1d0(%rsp),%xmm2
movapd %xmm2,%xmm14
mulsd  %xmm13,%xmm14
movapd %xmm14,%xmm7
movsd  0xb29(%rip),%xmm1
addsd  %xmm1,%xmm7
addsd  %xmm11,%xmm7
movsd  0x270(%rsp),%xmm6
mulsd  %xmm6,%xmm14
movapd %xmm14,%xmm0
divsd  %xmm7,%xmm0
mulsd  %xmm6,%xmm11
movapd %xmm11,%xmm9
divsd  %xmm7,%xmm9
addsd  %xmm13,%xmm0
movsd  0xd0(%rsp),%xmm10
mulsd  %xmm10,%xmm0
mov    0x198(%rsp),%rax
movsd  %xmm0,(%rax,%rcx,8)
movapd 0x220(%rsp),%xmm0
divsd  %xmm7,%xmm0
addsd  %xmm1,%xmm0
movapd 0x1f0(%rsp),%xmm4
divsd  %xmm7,%xmm4
mulsd  %xmm7,%xmm7
divsd  %xmm7,%xmm14
mulsd  %xmm2,%xmm14
mulsd  %xmm13,%xmm14
subsd  %xmm14,%xmm0
mulsd  %xmm10,%xmm0
mov    0x278(%rsp),%rax
movsd  %xmm0,(%rax,%rcx,8)
movapd %xmm13,%xmm0
mulsd  0x200(%rsp),%xmm0
mulsd  %xmm6,%xmm0
divsd  %xmm7,%xmm0
mulsd  %xmm5,%xmm0
mulsd  %xmm8,%xmm0
mulsd  %xmm10,%xmm0
mov    0x280(%rsp),%rax
movsd  %xmm0,(%rax,%rcx,8)
addsd  %xmm12,%xmm9
mulsd  %xmm10,%xmm9
mov    0x288(%rsp),%rax
movsd  %xmm9,(%rax,%rcx,8)
divsd  %xmm7,%xmm11
mulsd  %xmm5,%xmm11
mulsd  %xmm8,%xmm11
mulsd  0x210(%rsp),%xmm8
mulsd  %xmm6,%xmm8
divsd  %xmm7,%xmm8
mulsd  %xmm2,%xmm8
mulsd  %xmm13,%xmm8
mulsd  %xmm10,%xmm8
mov    0x290(%rsp),%rax
movsd  %xmm8,(%rax,%rcx,8)
addsd  %xmm1,%xmm15
addsd  %xmm15,%xmm4
subsd  %xmm11,%xmm4
mulsd  %xmm10,%xmm4
mov    0x298(%rsp),%rax
movsd  %xmm4,(%rax,%rcx,8)
lea    0x1(%rcx),%rax
mov    %rax,0x98(%rsp)
mov    0x2d0(%rsp),%rax
movsd  %xmm12,(%rax,%rcx,8)
mov    0x2d8(%rsp),%rax
mov    %rcx,0x50(%rsp)
movsd  %xmm15,(%rax,%rcx,8)
cmpl   $0x0,0xc(%rsp)
jle    1340 <groundwaterBryantDawsonIonExEvaluateFC+0x230>
mov    0x50(%rsp),%rax
add    %r15,%rax
mov    %rax,0x1a8(%rsp)
lea    (%r12,%rax,8),%rax
mov    %rax,0x100(%rsp)
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    0x120(%rsp),%rcx
mov    0x118(%rsp),%rdx
mov    0x110(%rsp),%rsi
mov    0x108(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm4
mulsd  %xmm13,%xmm4
movsd  %xmm4,0x0(%rbp,%rax,8)
movsd  (%rbx,%rax,8),%xmm4
movsd  %xmm4,(%rsi,%rax,8)
movsd  (%rbx,%rax,8),%xmm4
mulsd  %xmm12,%xmm4
movsd  %xmm4,(%rdx,%rax,8)
movsd  (%rbx,%rax,8),%xmm4
mulsd  %xmm15,%xmm4
movsd  %xmm4,(%rcx,%rax,8)
movsd  (%rbx,%rax,8),%xmm4
mulsd  %xmm4,%xmm4
addsd  %xmm4,%xmm0
add    $0x1,%rax
cmp    %rax,%r15
jne    16b0 <groundwaterBryantDawsonIonExEvaluateFC+0x5a0>
ucomisd 0x91a(%rip),%xmm0
jb     1710 <groundwaterBryantDawsonIonExEvaluateFC+0x600>
sqrtsd %xmm0,%xmm0
jmp    172e <groundwaterBryantDawsonIonExEvaluateFC+0x61e>
xchg   %ax,%ax
call   1030 <sqrt@plt>
mov    0x2c0(%rsp),%rdi
mov    0x2c8(%rsp),%r9
movsd  0x168(%rsp),%xmm3
mov    0xc(%rsp),%esi
ucomisd 0x8e6(%rip),%xmm0
jbe    1e60 <groundwaterBryantDawsonIonExEvaluateFC+0xd50>
test   %esi,%esi
jle    1340 <groundwaterBryantDawsonIonExEvaluateFC+0x230>
movapd %xmm0,%xmm9
mulsd  0xc8(%rsp),%xmm9
movsd  0x40(%rsp),%xmm8
addsd  %xmm9,%xmm8
mov    0x50(%rsp),%rax
mov    %rax,%rcx
imul   0xb8(%rsp),%rcx
mov    %rcx,0x1c8(%rsp)
imul   0xa0(%rsp),%rax
mov    %rax,0x1c0(%rsp)
addsd  0x48(%rsp),%xmm9
movapd %xmm0,%xmm11
unpcklpd %xmm0,%xmm11
mov    $0x1,%ebp
mov    0xe8(%rsp),%r14
mov    0xf0(%rsp),%rax
mov    %rax,0x130(%rsp)
mov    0xe0(%rsp),%rax
mov    0x70(%rsp),%rcx
mov    %ecx,0x2c(%rsp)
mov    0xf8(%rsp),%rdx
mov    0xd8(%rsp),%r11
mov    0x64(%rsp),%ecx
mov    %ecx,0x28(%rsp)
mov    0x160(%rsp),%rcx
mov    %rcx,0x140(%rsp)
xor    %ecx,%ecx
jmp    1886 <groundwaterBryantDawsonIonExEvaluateFC+0x776>
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%r13,8),%xmm4
movapd %xmm3,%xmm7
mulsd  %xmm4,%xmm7
mulsd  %xmm4,%xmm7
divsd  %xmm0,%xmm7
addsd  %xmm9,%xmm7
movsd  %xmm7,(%r9,%r8,8)
add    $0x1,%rbp
addq   $0xffffffffffffffff,0x140(%rsp)
mov    0x1b8(%rsp),%r13
add    %r13d,0x28(%rsp)
add    $0x8,%r11
mov    0x148(%rsp),%rdx
mov    0x1b0(%rsp),%rdi
add    %rdi,%rdx
addl   $0x1,0x2c(%rsp)
mov    0x138(%rsp),%rcx
add    %rcx,%rax
add    %rdi,0x130(%rsp)
add    %rcx,%r14
mov    0x150(%rsp),%rcx
cmp    %r15,%rcx
mov    0x2c0(%rsp),%rdi
je     1340 <groundwaterBryantDawsonIonExEvaluateFC+0x230>
mov    %rdx,0x148(%rsp)
mov    %rcx,%rdx
mov    0x1c8(%rsp),%rcx
lea    (%rdx,%rcx,1),%r13
movsd  (%r12,%r13,8),%xmm4
movapd %xmm3,%xmm7
mulsd  %xmm4,%xmm7
mulsd  %xmm4,%xmm7
divsd  %xmm0,%xmm7
addsd  %xmm8,%xmm7
mov    %edx,%ecx
imul   %esi,%ecx
movslq %ecx,%r8
add    0x1c0(%rsp),%r8
add    %rdx,%r8
movsd  %xmm7,(%rdi,%r8,8)
lea    0x1(%rdx),%rcx
cmp    0xb8(%rsp),%rcx
mov    %rcx,0x150(%rsp)
jge    1800 <groundwaterBryantDawsonIonExEvaluateFC+0x6f0>
mov    0x140(%rsp),%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x128(%rsp)
mov    %rdx,%rsi
not    %rsi
add    %r15,%rsi
lea    (%rdx,%rdx,1),%rcx
mov    %rcx,0x90(%rsp)
mov    0x98(%rsp),%rcx
mov    %rbp,0x58(%rsp)
mov    %rcx,%rbp
lea    (%rcx,%rdx,2),%r10
mov    0x1a8(%rsp),%rcx
add    %rdx,%rcx
mov    %rcx,0x78(%rsp)
mov    0x50(%rsp),%rcx
add    %rdx,%rcx
lea    (%r12,%rcx,8),%rcx
mov    %rcx,0x80(%rsp)
lea    0x0(%rbp,%rdx,1),%rcx
mov    0x58(%rsp),%rbp
lea    (%r12,%rcx,8),%rcx
mov    %rcx,0x88(%rsp)
mov    0x1a0(%rsp),%rcx
sub    %rdx,%rcx
mov    %rcx,0x18(%rsp)
mov    %rbp,%rdx
mov    %rsi,%rcx
mov    %rsi,0x20(%rsp)
cmp    $0x2,%rsi
mov    0xc(%rsp),%esi
jb     1bc0 <groundwaterBryantDawsonIonExEvaluateFC+0xab0>
mov    %rbp,%rdx
cmp    $0x1,%esi
jne    1bc0 <groundwaterBryantDawsonIonExEvaluateFC+0xab0>
mov    0x98(%rsp),%rcx
mov    0x90(%rsp),%rdx
add    %edx,%ecx
mov    0x18(%rsp),%rdx
lea    (%rdx,%rcx,1),%edi
mov    %rbp,%rdx
cmp    %ecx,%edi
mov    0x2c0(%rsp),%rdi
jl     1bc0 <groundwaterBryantDawsonIonExEvaluateFC+0xab0>
mov    0x18(%rsp),%rcx
shr    $0x20,%rcx
mov    %rbp,%rdx
jne    1bc0 <groundwaterBryantDawsonIonExEvaluateFC+0xab0>
lea    (%rdi,%r10,8),%rdx
mov    0x2c0(%rsp),%rcx
mov    0x78(%rsp),%rsi
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,0xa8(%rsp)
movslq %r10d,%rcx
mov    0x2c0(%rsp),%rdi
mov    %r10,%rbp
lea    (%rdi,%rcx,8),%r10
mov    %r10,0xb0(%rsp)
mov    0x2c0(%rsp),%rdi
mov    0x20(%rsp),%rsi
lea    (%rdi,%rsi,8),%r9
mov    0xc(%rsp),%esi
lea    (%r9,%rcx,8),%rcx
cmp    %rcx,%rdx
setb   0x38(%rsp)
mov    0xa8(%rsp),%rdi
cmp    %rdi,%r10
setb   0x30(%rsp)
mov    %rbp,0x68(%rsp)
mov    0x88(%rsp),%r10
cmp    %r10,%rdx
setb   0x17(%rsp)
mov    0x80(%rsp),%r9
cmp    %rdi,%r9
setb   0x16(%rsp)
mov    0x100(%rsp),%rbp
cmp    %rbp,%rdx
setb   0x15(%rsp)
cmp    %rdi,%r10
mov    0x2c0(%rsp),%rdi
setb   0xa8(%rsp)
mov    0xb0(%rsp),%rdx
cmp    %r10,%rdx
setb   0x14(%rsp)
cmp    %rcx,%r9
setb   0x13(%rsp)
cmp    %rbp,%rdx
mov    0x58(%rsp),%rbp
setb   %r9b
cmp    %rcx,%r10
mov    0x68(%rsp),%r10
setb   0xb0(%rsp)
mov    %rbp,%rdx
mov    0x30(%rsp),%cl
test   %cl,0x38(%rsp)
jne    1bc0 <groundwaterBryantDawsonIonExEvaluateFC+0xab0>
mov    %rbp,%rdx
mov    0x16(%rsp),%cl
and    %cl,0x17(%rsp)
jne    1bc0 <groundwaterBryantDawsonIonExEvaluateFC+0xab0>
mov    %rbp,%rdx
mov    0xa8(%rsp),%cl
and    %cl,0x15(%rsp)
jne    1bc0 <groundwaterBryantDawsonIonExEvaluateFC+0xab0>
mov    %rbp,%rdx
mov    0x13(%rsp),%cl
and    %cl,0x14(%rsp)
jne    1bc0 <groundwaterBryantDawsonIonExEvaluateFC+0xab0>
mov    %rbp,%rdx
and    0xb0(%rsp),%r9b
jne    1bc0 <groundwaterBryantDawsonIonExEvaluateFC+0xab0>
mov    %r14,0x30(%rsp)
mov    0x20(%rsp),%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x38(%rsp)
lea    (%rcx,%rbp,1),%rdx
movsd  (%r12,%r13,8),%xmm4
mulsd  %xmm3,%xmm4
unpcklpd %xmm4,%xmm4
mov    0x28(%rsp),%ecx
xor    %edi,%edi
mov    0x60(%rsp),%r10d
mov    %r11,%r9
mov    0x148(%rsp),%r11
mov    0x128(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nop
movupd (%r9,%rdi,8),%xmm7
mulpd  %xmm4,%xmm7
divpd  %xmm11,%xmm7
movupd %xmm7,(%r11,%rdi,8)
movslq %ecx,%rcx
mov    0x2c0(%rsp),%r14
movupd %xmm7,(%r14,%rcx,8)
add    $0x2,%rdi
add    %r10d,%ecx
cmp    %rdi,%rbp
jne    1b60 <groundwaterBryantDawsonIonExEvaluateFC+0xa50>
mov    0x38(%rsp),%rcx
cmp    %rcx,0x20(%rsp)
mov    0x2c0(%rsp),%rdi
mov    %r9,%r11
mov    0x58(%rsp),%rbp
mov    0x68(%rsp),%r10
mov    0x30(%rsp),%r14
je     1bfd <groundwaterBryantDawsonIonExEvaluateFC+0xaed>
nopl   0x0(%rax,%rax,1)
mov    %esi,%r9d
imul   %edx,%r9d
add    0x2c(%rsp),%r9d
nopl   0x0(%rax)
movsd  (%r12,%r13,8),%xmm4
mulsd  %xmm3,%xmm4
mulsd  (%rbx,%rdx,8),%xmm4
divsd  %xmm0,%xmm4
movsd  %xmm4,(%rax,%rdx,8)
movslq %r9d,%r9
movsd  %xmm4,(%rdi,%r9,8)
add    $0x1,%rdx
add    %esi,%r9d
cmp    %rdx,%r15
jne    1bd0 <groundwaterBryantDawsonIonExEvaluateFC+0xac0>
movsd  (%r12,%r13,8),%xmm4
movapd %xmm3,%xmm7
mulsd  %xmm4,%xmm7
mulsd  %xmm4,%xmm7
divsd  %xmm0,%xmm7
addsd  %xmm9,%xmm7
mov    0x2c8(%rsp),%r9
movsd  %xmm7,(%r9,%r8,8)
mov    0x150(%rsp),%rcx
cmp    0xb8(%rsp),%rcx
jge    1821 <groundwaterBryantDawsonIonExEvaluateFC+0x711>
mov    %rbp,%rdx
cmpq   $0x2,0x20(%rsp)
jb     1e10 <groundwaterBryantDawsonIonExEvaluateFC+0xd00>
mov    %rbp,%rdx
cmp    $0x1,%esi
jne    1e10 <groundwaterBryantDawsonIonExEvaluateFC+0xd00>
mov    0x90(%rsp),%rdi
add    0x98(%rsp),%edi
mov    0x18(%rsp),%rcx
add    %edi,%ecx
mov    %rbp,%rdx
cmp    %edi,%ecx
jl     1e10 <groundwaterBryantDawsonIonExEvaluateFC+0xd00>
shrq   $0x20,0x18(%rsp)
mov    %rbp,%rdx
jne    1e10 <groundwaterBryantDawsonIonExEvaluateFC+0xd00>
lea    (%r9,%r10,8),%rcx
mov    0x78(%rsp),%rdx
lea    (%r9,%rdx,8),%r8
movslq %r10d,%rdi
mov    0x2c8(%rsp),%rdx
lea    (%rdx,%rdi,8),%r9
mov    0x2c8(%rsp),%rdx
mov    0x20(%rsp),%rsi
lea    (%rdx,%rsi,8),%rdx
mov    0xc(%rsp),%esi
lea    (%rdx,%rdi,8),%rdx
cmp    %rdx,%rcx
setb   0x18(%rsp)
cmp    %r8,%r9
setb   0x90(%rsp)
mov    0x88(%rsp),%rdi
cmp    %rdi,%rcx
setb   0x78(%rsp)
mov    0x80(%rsp),%r10
cmp    %r8,%r10
setb   0x68(%rsp)
mov    0x100(%rsp),%rbp
cmp    %rbp,%rcx
setb   0x30(%rsp)
cmp    %r8,%rdi
setb   0x38(%rsp)
cmp    %rdi,%r9
setb   %r8b
cmp    %rdx,%r10
setb   0x80(%rsp)
cmp    %rbp,%r9
mov    0x58(%rsp),%rbp
mov    0x2c8(%rsp),%r9
setb   %r10b
cmp    %rdx,%rdi
setb   0x88(%rsp)
mov    %rbp,%rdx
mov    0x90(%rsp),%cl
test   %cl,0x18(%rsp)
jne    1e10 <groundwaterBryantDawsonIonExEvaluateFC+0xd00>
mov    %rbp,%rdx
mov    0x68(%rsp),%dil
and    %dil,0x78(%rsp)
jne    1e10 <groundwaterBryantDawsonIonExEvaluateFC+0xd00>
mov    %rbp,%rdx
mov    0x30(%rsp),%cl
and    0x38(%rsp),%cl
jne    1e10 <groundwaterBryantDawsonIonExEvaluateFC+0xd00>
mov    %rbp,%rdx
and    0x80(%rsp),%r8b
jne    1e10 <groundwaterBryantDawsonIonExEvaluateFC+0xd00>
mov    %rbp,%rdx
and    0x88(%rsp),%r10b
jne    1e10 <groundwaterBryantDawsonIonExEvaluateFC+0xd00>
mov    0x20(%rsp),%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x18(%rsp)
lea    (%rcx,%rbp,1),%rdx
movsd  (%r12,%r13,8),%xmm4
mulsd  %xmm3,%xmm4
unpcklpd %xmm4,%xmm4
mov    0x28(%rsp),%ecx
xor    %edi,%edi
mov    0x60(%rsp),%r10d
mov    0x130(%rsp),%rbp
mov    0x128(%rsp),%r8
nopl   (%rax)
movupd (%r11,%rdi,8),%xmm7
mulpd  %xmm4,%xmm7
divpd  %xmm11,%xmm7
movupd %xmm7,0x0(%rbp,%rdi,8)
movslq %ecx,%rcx
movupd %xmm7,(%r9,%rcx,8)
add    $0x2,%rdi
add    %r10d,%ecx
cmp    %rdi,%r8
jne    1dd0 <groundwaterBryantDawsonIonExEvaluateFC+0xcc0>
mov    0x18(%rsp),%rcx
cmp    %rcx,0x20(%rsp)
mov    0x58(%rsp),%rbp
je     1821 <groundwaterBryantDawsonIonExEvaluateFC+0x711>
nop
mov    %esi,%ecx
imul   %edx,%ecx
add    0x2c(%rsp),%ecx
nopl   0x0(%rax)
movsd  (%r12,%r13,8),%xmm4
mulsd  %xmm3,%xmm4
mulsd  (%rbx,%rdx,8),%xmm4
divsd  %xmm0,%xmm4
movsd  %xmm4,(%r14,%rdx,8)
movslq %ecx,%rcx
movsd  %xmm4,(%r9,%rcx,8)
add    $0x1,%rdx
add    %esi,%ecx
cmp    %rdx,%r15
jne    1e20 <groundwaterBryantDawsonIonExEvaluateFC+0xd10>
jmp    1821 <groundwaterBryantDawsonIonExEvaluateFC+0x711>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   %esi,%esi
jle    1340 <groundwaterBryantDawsonIonExEvaluateFC+0x230>
cmp    $0x1,%esi
jne    1e71 <groundwaterBryantDawsonIonExEvaluateFC+0xd61>
xor    %eax,%eax
jmp    1ec8 <groundwaterBryantDawsonIonExEvaluateFC+0xdb8>
mov    0x70(%rsp),%rcx
xor    %eax,%eax
mov    0x158(%rsp),%rsi
mov    0xc4(%rsp),%ebp
nopw   0x0(%rax,%rax,1)
movslq %ecx,%rcx
movsd  0x40(%rsp),%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
movsd  0x48(%rsp),%xmm0
movsd  %xmm0,(%r9,%rcx,8)
lea    0x0(%r13,%rcx,1),%edx
movslq %edx,%rdx
movsd  %xmm1,(%rdi,%rdx,8)
movsd  %xmm0,(%r9,%rdx,8)
add    $0x2,%rax
add    %ebp,%ecx
cmp    %rax,%rsi
jne    1e90 <groundwaterBryantDawsonIonExEvaluateFC+0xd80>
test   $0x1,%r15b
mov    0xc(%rsp),%edx
je     1340 <groundwaterBryantDawsonIonExEvaluateFC+0x230>
mov    0x50(%rsp),%rcx
imul   0xa0(%rsp),%ecx
add    %eax,%ecx
imul   %edx,%eax
add    %ecx,%eax
cltq
movsd  0x40(%rsp),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
movsd  0x48(%rsp),%xmm0
movsd  %xmm0,(%r9,%rax,8)
jmp    1340 <groundwaterBryantDawsonIonExEvaluateFC+0x230>
add    $0x238,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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