void calculate_fgh(double Re, double GX, double GY, double GZ, double alpha,
                   double dt, double dx, double dy, double dz, int imax,
                   int jmax, int kmax, double ***U, double ***V, double ***W,
                   double ***F, double ***G, double ***H, int ***Flag) {
  double uijk, vijk, wijk, uujk, udjk, uiuk, uidk, uiju, uijd, viuk, vidk, viju,
      vijd, vujk, vdjk, wiju, wijd, wujk, wdjk, wiuk, widk, uduk, udju, vudk,
      vidu, wiud, wujd;
  double Dx = 1 / dx, Dy = 1 / dy, Dz = 1 / dz;
  double ReInv = 1.0 / Re;
  int i, j, k, fgg;
  for (i = 1; i < imax + 1; i++) {
    for (j = 1; j < jmax + 1; j++) {
      for (k = 1; k < kmax + 1; k++) {
        if (isfluid(Flag[i][j][k])) {
          uijk = U[i][j][k];
          vijk = V[i][j][k];
          wijk = W[i][j][k];
          uujk = U[i + 1][j][k];
          viuk = V[i][j + 1][k];
          wiju = W[i][j][k + 1];
          udjk = U[i - 1][j][k];
          vidk = V[i][j - 1][k];
          wijd = W[i][j][k - 1];
          uiuk = U[i][j + 1][k];
          viju = V[i][j][k + 1];
          wujk = W[i + 1][j][k];
          uidk = U[i][j - 1][k];
          vijd = V[i][j][k - 1];
          wdjk = W[i - 1][j][k];
          uiju = U[i][j][k + 1];
          vujk = V[i + 1][j][k];
          wiuk = W[i][j + 1][k];
          uijd = U[i][j][k - 1];
          vdjk = V[i - 1][j][k];
          widk = W[i][j - 1][k];
          uduk = U[i - 1][j + 1][k];
          udju = U[i - 1][j][k + 1];
          vudk = V[i + 1][j - 1][k];
          vidu = V[i][j - 1][k + 1];
          wiud = W[i][j + 1][k - 1];
          wujd = W[i + 1][j][k - 1];
          if (isfluid(Flag[i + 1][j][k])) {
            F[i][j][k] =
                uijk +
                dt * (ReInv * ((uujk - 2 * uijk + udjk) * Dx * Dx +
                               (uiuk - 2 * uijk + uidk) * Dy * Dy +
                               (uiju - 2 * uijk + uijd) * Dz * Dz) -
                      0.25 * Dx *
                          (pow((uijk + uujk), 2) - pow((udjk + uijk), 2) +
                           alpha * (fabs(uijk + uujk) * (uijk - uujk) -
                                    fabs(udjk + uijk) * (udjk - uijk))) -
                      0.25 * Dy *
                          ((vijk + vujk) * (uijk + uiuk) -
                           (vidk + vudk) * (uidk + uijk) +
                           alpha * (fabs(vijk + vujk) * (uijk - uiuk) -
                                    fabs(vidk + vudk) * (uidk - uijk))) -
                      0.25 * Dz *
                          ((wijk + wujk) * (uijk + uiju) -
                           (wijd + wujd) * (uijd + uijk) +
                           alpha * (fabs(wijk + wujk) * (uijk - uiju) -
                                    fabs(wijd + wujd) * (uijd - uijk))) +
                      GX);
          }
          if (isfluid(Flag[i][j + 1][k])) {
            G[i][j][k] =
                vijk +
                dt * (ReInv * ((vujk - 2 * vijk + vdjk) * Dx * Dx +
                               (viuk - 2 * vijk + vidk) * Dy * Dy +
                               (viju - 2 * vijk + vijd) * Dz * Dz) -
                      0.25 * Dy *
                          (pow((vijk + viuk), 2) - pow((vidk + vijk), 2) +
                           alpha * (fabs(vijk + viuk) * (vijk - viuk) -
                                    fabs(vidk + vijk) * (vidk - vijk))) -
                      0.25 * Dx *
                          ((uijk + uiuk) * (vijk + vujk) -
                           (udjk + uduk) * (vdjk + vijk) +
                           alpha * (fabs(uijk + uiuk) * (vijk - vujk) -
                                    fabs(udjk + uduk) * (vdjk - vijk))) -
                      0.25 * Dz *
                          ((wijk + wiuk) * (vijk + viju) -
                           (wijd + wiud) * (vijd + vijk) +
                           alpha * (fabs(wijk + wiuk) * (vijk - viju) -
                                    fabs(wijd + wiud) * (vijd - vijk))) +
                      GY);
          }
          if (isfluid(Flag[i][j][k + 1])) {
            H[i][j][k] =
                wijk +
                dt * (ReInv * ((wujk - 2 * wijk + wdjk) * Dx * Dx +
                               (wiuk - 2 * wijk + widk) * Dy * Dy +
                               (wiju - 2 * wijk + wijd) * Dz * Dz) -
                      0.25 * Dz *
                          (pow((wijk + wiju), 2) - pow((wijd + wijk), 2) +
                           alpha * (fabs(wijk + wiju) * (wijk - wiju) -
                                    fabs(wijd + wijk) * (wijd - wijk))) -
                      0.25 * Dx *
                          ((uijk + uiju) * (wijk + wujk) -
                           (udjk + udju) * (wdjk + wijk) +
                           alpha * (fabs(uijk + uiju) * (wijk - wujk) -
                                    fabs(udjk + udju) * (wdjk - wijk))) -
                      0.25 * Dy *
                          ((vijk + viju) * (wijk + wiuk) -
                           (vidk + vidu) * (widk + wijk) +
                           alpha * (fabs(vijk + viju) * (wijk - wiuk) -
                                    fabs(vidk + vidu) * (widk - wijk))) +
                      GZ);
          }
        } else {
          fgg = getboundarytype(Flag[i][j][k]);
          if (fgg % 4 == 1) {
            H[i][j][k] = W[i][j][k];
            break;
          } else if (fgg % 4 == 2) {
            H[i][j][k - 1] = W[i][j][k - 1];
            break;
          }
          if (fgg > 31) {
            F[i][j][k] = U[i][j][k];
            break;
          } else if (fgg > 15) {
            F[i - 1][j][k] = U[i - 1][j][k];
            break;
          }
          if ((fgg % 16 + 1) / 3 == 3) {
            G[i][j][k] = V[i][j][k];
            break;
          } else if ((fgg % 16 + 2) / 3 == 2) {
            G[i][j - 1][k] = V[i][j - 1][k];
            break;
          }
        }
      }
      H[i][j][0] = W[i][j][0];
      H[i][j][kmax] = W[i][j][kmax];
    }
    for (k = 1; k < kmax + 1; k++) {
      G[i][0][k] = V[i][0][k];
      G[i][jmax][k] = V[i][jmax][k];
    }
  }
  for (j = 1; j < jmax + 1; j++) {
    for (k = 1; k < kmax + 1; k++) {
      F[0][j][k] = U[0][j][k];
      F[imax][j][k] = U[imax][j][k];
    }
  }
}


x86 assembly (clang, -O0):
<calculate_fgh>:
push   %rbp
mov    %rsp,%rbp
sub    $0x200,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
movsd  0x10(%rbp),%xmm8
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
movsd  %xmm2,-0x18(%rbp)
movsd  %xmm3,-0x20(%rbp)
movsd  %xmm4,-0x28(%rbp)
movsd  %xmm5,-0x30(%rbp)
movsd  %xmm6,-0x38(%rbp)
movsd  %xmm7,-0x40(%rbp)
mov    %edi,-0x44(%rbp)
mov    %esi,-0x48(%rbp)
mov    %edx,-0x4c(%rbp)
mov    %rcx,-0x58(%rbp)
mov    %r8,-0x60(%rbp)
mov    %r9,-0x68(%rbp)
movsd  0x1e6a(%rip),%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  0x1e55(%rip),%xmm0
divsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  0x1e40(%rip),%xmm0
divsd  0x10(%rbp),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  0x1e2b(%rip),%xmm0
divsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movl   $0x1,-0x164(%rbp)
mov    -0x164(%rbp),%eax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    29c3 <calculate_fgh+0x1893>
movl   $0x1,-0x168(%rbp)
mov    -0x168(%rbp),%eax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    28f6 <calculate_fgh+0x17c6>
movl   $0x1,-0x16c(%rbp)
mov    -0x16c(%rbp),%eax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2860 <calculate_fgh+0x1730>
mov    0x30(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    $0x0,%al
call   1030 <isfluid@plt>
cmp    $0x0,%eax
je     256e <calculate_fgh+0x143e>
mov    -0x58(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x164(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x60(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x168(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x68(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x16c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x58(%rbp),%rax
mov    -0x164(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x60(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x168(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x68(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x16c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x58(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x168(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x60(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x16c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x68(%rbp),%rax
mov    -0x164(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x58(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x168(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x60(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x16c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x68(%rbp),%rax
mov    -0x164(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x58(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x16c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x60(%rbp),%rax
mov    -0x164(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x68(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x168(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x58(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x16c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x60(%rbp),%rax
mov    -0x164(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x68(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x168(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x58(%rbp),%rax
mov    -0x164(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x168(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x58(%rbp),%rax
mov    -0x164(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x16c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x60(%rbp),%rax
mov    -0x164(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x168(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x60(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x168(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x16c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x68(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x168(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x16c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x68(%rbp),%rax
mov    -0x164(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x16c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    0x30(%rbp),%rax
mov    -0x164(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    $0x0,%al
call   1030 <isfluid@plt>
cmp    $0x0,%eax
je     1c5d <calculate_fgh+0xb2d>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x70(%rbp),%xmm0
addsd  %xmm0,%xmm0
subsd  %xmm0,%xmm1
addsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x148(%rbp),%xmm1
ff
movsd  -0x148(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm3
addsd  %xmm3,%xmm3
subsd  %xmm3,%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x150(%rbp),%xmm0
ff
mulsd  -0x150(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
addsd  %xmm2,%xmm2
subsd  %xmm2,%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0x158(%rbp),%xmm0
ff
movsd  -0x158(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movsd  0x1727(%rip),%xmm0
mulsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  0x170a(%rip),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0x70(%rbp),%xmm0
movsd  0x16e8(%rip),%xmm1
call   1050 <pow@plt>
movsd  -0x1a0(%rbp),%xmm6
ff
movsd  -0x198(%rbp),%xmm3
ff
movsd  -0x190(%rbp),%xmm2
ff
movsd  -0x188(%rbp),%xmm4
ff
movsd  -0x180(%rbp),%xmm1
ff
movaps %xmm0,%xmm5
movsd  -0x178(%rbp),%xmm0
ff
subsd  %xmm5,%xmm6
movsd  -0x28(%rbp),%xmm5
movsd  -0x70(%rbp),%xmm7
addsd  -0x88(%rbp),%xmm7
ff
movaps 0x16a2(%rip),%xmm8
pand   %xmm8,%xmm7
movsd  -0x70(%rbp),%xmm9
subsd  -0x88(%rbp),%xmm9
ff ff
movsd  -0x90(%rbp),%xmm8
ff ff
addsd  -0x70(%rbp),%xmm8
movaps 0x1677(%rip),%xmm10
pand   %xmm10,%xmm8
movsd  -0x90(%rbp),%xmm10
ff ff
subsd  -0x70(%rbp),%xmm10
mulsd  %xmm10,%xmm8
movq   %xmm8,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm8
mulsd  %xmm9,%xmm7
addsd  %xmm8,%xmm7
mulsd  %xmm7,%xmm5
addsd  %xmm6,%xmm5
mulsd  %xmm5,%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movsd  0x15f2(%rip),%xmm3
mulsd  -0x150(%rbp),%xmm3
ff
movsd  -0x78(%rbp),%xmm5
addsd  -0xd8(%rbp),%xmm5
ff
movsd  -0x70(%rbp),%xmm6
addsd  -0x98(%rbp),%xmm6
ff
movsd  -0xc0(%rbp),%xmm4
ff
addsd  -0x128(%rbp),%xmm4
ff
movsd  -0xa0(%rbp),%xmm7
ff
addsd  -0x70(%rbp),%xmm7
mulsd  %xmm7,%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm6,%xmm5
addsd  %xmm4,%xmm5
movsd  -0x28(%rbp),%xmm4
movsd  -0x78(%rbp),%xmm6
addsd  -0xd8(%rbp),%xmm6
ff
movaps 0x158f(%rip),%xmm7
pand   %xmm7,%xmm6
movsd  -0x70(%rbp),%xmm8
subsd  -0x98(%rbp),%xmm8
ff ff
movsd  -0xc0(%rbp),%xmm7
ff
addsd  -0x128(%rbp),%xmm7
ff
movaps 0x1564(%rip),%xmm9
pand   %xmm9,%xmm7
movsd  -0xa0(%rbp),%xmm9
ff ff
subsd  -0x70(%rbp),%xmm9
mulsd  %xmm9,%xmm7
movq   %xmm7,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm7
mulsd  %xmm8,%xmm6
addsd  %xmm7,%xmm6
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movsd  0x14e4(%rip),%xmm2
mulsd  -0x158(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm5
addsd  -0xf8(%rbp),%xmm5
ff
movsd  -0x70(%rbp),%xmm6
addsd  -0xa8(%rbp),%xmm6
ff
movsd  -0xf0(%rbp),%xmm4
ff
addsd  -0x140(%rbp),%xmm4
ff
movsd  -0xb0(%rbp),%xmm7
ff
addsd  -0x70(%rbp),%xmm7
mulsd  %xmm7,%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm6,%xmm5
addsd  %xmm4,%xmm5
movsd  -0x28(%rbp),%xmm4
movsd  -0x80(%rbp),%xmm6
addsd  -0xf8(%rbp),%xmm6
ff
movaps 0x1481(%rip),%xmm7
pand   %xmm7,%xmm6
movsd  -0x70(%rbp),%xmm8
subsd  -0xa8(%rbp),%xmm8
ff ff
movsd  -0xf0(%rbp),%xmm7
ff
addsd  -0x140(%rbp),%xmm7
ff
movaps 0x1456(%rip),%xmm9
pand   %xmm9,%xmm7
movsd  -0xb0(%rbp),%xmm9
ff ff
subsd  -0x70(%rbp),%xmm9
mulsd  %xmm9,%xmm7
movq   %xmm7,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm7
mulsd  %xmm8,%xmm6
addsd  %xmm7,%xmm6
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
addsd  -0x10(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x168(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    $0x0,%al
call   1030 <isfluid@plt>
cmp    $0x0,%eax
je     20e3 <calculate_fgh+0xfb3>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0xd8(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm0
addsd  %xmm0,%xmm0
subsd  %xmm0,%xmm1
addsd  -0xe0(%rbp),%xmm1
ff
mulsd  -0x148(%rbp),%xmm1
ff
movsd  -0x148(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm3
addsd  %xmm3,%xmm3
subsd  %xmm3,%xmm0
addsd  -0xc0(%rbp),%xmm0
ff
mulsd  -0x150(%rbp),%xmm0
ff
mulsd  -0x150(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm2
addsd  %xmm2,%xmm2
subsd  %xmm2,%xmm0
addsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0x158(%rbp),%xmm0
ff
movsd  -0x158(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  0x12a1(%rip),%xmm0
mulsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
addsd  -0xb8(%rbp),%xmm0
ff
movsd  0x1284(%rip),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
addsd  -0x78(%rbp),%xmm0
movsd  0x1262(%rip),%xmm1
call   1050 <pow@plt>
movsd  -0x1d0(%rbp),%xmm6
ff
movsd  -0x1c8(%rbp),%xmm3
ff
movsd  -0x1c0(%rbp),%xmm2
ff
movsd  -0x1b8(%rbp),%xmm4
ff
movsd  -0x1b0(%rbp),%xmm1
ff
movaps %xmm0,%xmm5
movsd  -0x1a8(%rbp),%xmm0
ff
subsd  %xmm5,%xmm6
movsd  -0x28(%rbp),%xmm5
movsd  -0x78(%rbp),%xmm7
addsd  -0xb8(%rbp),%xmm7
ff
movaps 0x121c(%rip),%xmm8
pand   %xmm8,%xmm7
movsd  -0x78(%rbp),%xmm9
subsd  -0xb8(%rbp),%xmm9
ff ff
movsd  -0xc0(%rbp),%xmm8
ff ff
addsd  -0x78(%rbp),%xmm8
movaps 0x11f1(%rip),%xmm10
pand   %xmm10,%xmm8
movsd  -0xc0(%rbp),%xmm10
ff ff
subsd  -0x78(%rbp),%xmm10
mulsd  %xmm10,%xmm8
movq   %xmm8,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm8
mulsd  %xmm9,%xmm7
addsd  %xmm8,%xmm7
mulsd  %xmm7,%xmm5
addsd  %xmm6,%xmm5
mulsd  %xmm5,%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movsd  0x116c(%rip),%xmm3
mulsd  -0x148(%rbp),%xmm3
ff
movsd  -0x70(%rbp),%xmm5
addsd  -0x98(%rbp),%xmm5
ff
movsd  -0x78(%rbp),%xmm6
addsd  -0xd8(%rbp),%xmm6
ff
movsd  -0x90(%rbp),%xmm4
ff
addsd  -0x118(%rbp),%xmm4
ff
movsd  -0xe0(%rbp),%xmm7
ff
addsd  -0x78(%rbp),%xmm7
mulsd  %xmm7,%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm6,%xmm5
addsd  %xmm4,%xmm5
movsd  -0x28(%rbp),%xmm4
movsd  -0x70(%rbp),%xmm6
addsd  -0x98(%rbp),%xmm6
ff
movaps 0x1109(%rip),%xmm7
pand   %xmm7,%xmm6
movsd  -0x78(%rbp),%xmm8
subsd  -0xd8(%rbp),%xmm8
ff ff
movsd  -0x90(%rbp),%xmm7
ff
addsd  -0x118(%rbp),%xmm7
ff
movaps 0x10de(%rip),%xmm9
pand   %xmm9,%xmm7
movsd  -0xe0(%rbp),%xmm9
ff ff
subsd  -0x78(%rbp),%xmm9
mulsd  %xmm9,%xmm7
movq   %xmm7,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm7
mulsd  %xmm8,%xmm6
addsd  %xmm7,%xmm6
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movsd  0x105e(%rip),%xmm2
mulsd  -0x158(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm5
addsd  -0x108(%rbp),%xmm5
ff
movsd  -0x78(%rbp),%xmm6
addsd  -0xc8(%rbp),%xmm6
ff
movsd  -0xf0(%rbp),%xmm4
ff
addsd  -0x138(%rbp),%xmm4
ff
movsd  -0xd0(%rbp),%xmm7
ff
addsd  -0x78(%rbp),%xmm7
mulsd  %xmm7,%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm6,%xmm5
addsd  %xmm4,%xmm5
movsd  -0x28(%rbp),%xmm4
movsd  -0x80(%rbp),%xmm6
addsd  -0x108(%rbp),%xmm6
ff
movaps 0xffb(%rip),%xmm7
pand   %xmm7,%xmm6
movsd  -0x78(%rbp),%xmm8
subsd  -0xc8(%rbp),%xmm8
ff ff
movsd  -0xf0(%rbp),%xmm7
ff
addsd  -0x138(%rbp),%xmm7
ff
movaps 0xfd0(%rip),%xmm9
pand   %xmm9,%xmm7
movsd  -0xd0(%rbp),%xmm9
ff ff
subsd  -0x78(%rbp),%xmm9
mulsd  %xmm9,%xmm7
movq   %xmm7,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm7
mulsd  %xmm8,%xmm6
addsd  %xmm7,%xmm6
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
addsd  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x16c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edi
mov    $0x0,%al
call   1030 <isfluid@plt>
cmp    $0x0,%eax
je     2569 <calculate_fgh+0x1439>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0xf8(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm0
addsd  %xmm0,%xmm0
subsd  %xmm0,%xmm1
addsd  -0x100(%rbp),%xmm1
ff
mulsd  -0x148(%rbp),%xmm1
ff
movsd  -0x148(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm3
addsd  %xmm3,%xmm3
subsd  %xmm3,%xmm0
addsd  -0x110(%rbp),%xmm0
ff
mulsd  -0x150(%rbp),%xmm0
ff
mulsd  -0x150(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
addsd  %xmm2,%xmm2
subsd  %xmm2,%xmm0
addsd  -0xf0(%rbp),%xmm0
ff
mulsd  -0x158(%rbp),%xmm0
ff
movsd  -0x158(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
movsd  0xe1b(%rip),%xmm0
mulsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
addsd  -0xe8(%rbp),%xmm0
ff
movsd  0xdfe(%rip),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0x200(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
addsd  -0x80(%rbp),%xmm0
movsd  0xddc(%rip),%xmm1
call   1050 <pow@plt>
movsd  -0x200(%rbp),%xmm6
ff
movsd  -0x1f8(%rbp),%xmm3
ff
movsd  -0x1f0(%rbp),%xmm2
ff
movsd  -0x1e8(%rbp),%xmm4
ff
movsd  -0x1e0(%rbp),%xmm1
ff
movaps %xmm0,%xmm5
movsd  -0x1d8(%rbp),%xmm0
ff
subsd  %xmm5,%xmm6
movsd  -0x28(%rbp),%xmm5
movsd  -0x80(%rbp),%xmm7
addsd  -0xe8(%rbp),%xmm7
ff
movaps 0xd96(%rip),%xmm8
pand   %xmm8,%xmm7
movsd  -0x80(%rbp),%xmm9
subsd  -0xe8(%rbp),%xmm9
ff ff
movsd  -0xf0(%rbp),%xmm8
ff ff
addsd  -0x80(%rbp),%xmm8
movaps 0xd6b(%rip),%xmm10
pand   %xmm10,%xmm8
movsd  -0xf0(%rbp),%xmm10
ff ff
subsd  -0x80(%rbp),%xmm10
mulsd  %xmm10,%xmm8
movq   %xmm8,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm8
mulsd  %xmm9,%xmm7
addsd  %xmm8,%xmm7
mulsd  %xmm7,%xmm5
addsd  %xmm6,%xmm5
mulsd  %xmm5,%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movsd  0xce6(%rip),%xmm3
mulsd  -0x148(%rbp),%xmm3
ff
movsd  -0x70(%rbp),%xmm5
addsd  -0xa8(%rbp),%xmm5
ff
movsd  -0x80(%rbp),%xmm6
addsd  -0xf8(%rbp),%xmm6
ff
movsd  -0x90(%rbp),%xmm4
ff
addsd  -0x120(%rbp),%xmm4
ff
movsd  -0x100(%rbp),%xmm7
ff
addsd  -0x80(%rbp),%xmm7
mulsd  %xmm7,%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm6,%xmm5
addsd  %xmm4,%xmm5
movsd  -0x28(%rbp),%xmm4
movsd  -0x70(%rbp),%xmm6
addsd  -0xa8(%rbp),%xmm6
ff
movaps 0xc83(%rip),%xmm7
pand   %xmm7,%xmm6
movsd  -0x80(%rbp),%xmm8
subsd  -0xf8(%rbp),%xmm8
ff ff
movsd  -0x90(%rbp),%xmm7
ff
addsd  -0x120(%rbp),%xmm7
ff
movaps 0xc58(%rip),%xmm9
pand   %xmm9,%xmm7
movsd  -0x100(%rbp),%xmm9
ff ff
subsd  -0x80(%rbp),%xmm9
mulsd  %xmm9,%xmm7
movq   %xmm7,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm7
mulsd  %xmm8,%xmm6
addsd  %xmm7,%xmm6
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movsd  0xbd8(%rip),%xmm2
mulsd  -0x150(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm5
addsd  -0xc8(%rbp),%xmm5
ff
movsd  -0x80(%rbp),%xmm6
addsd  -0x108(%rbp),%xmm6
ff
movsd  -0xc0(%rbp),%xmm4
ff
addsd  -0x130(%rbp),%xmm4
ff
movsd  -0x110(%rbp),%xmm7
ff
addsd  -0x80(%rbp),%xmm7
mulsd  %xmm7,%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm6,%xmm5
addsd  %xmm4,%xmm5
movsd  -0x28(%rbp),%xmm4
movsd  -0x78(%rbp),%xmm6
addsd  -0xc8(%rbp),%xmm6
ff
movaps 0xb75(%rip),%xmm7
pand   %xmm7,%xmm6
movsd  -0x80(%rbp),%xmm8
subsd  -0x108(%rbp),%xmm8
ff ff
movsd  -0xc0(%rbp),%xmm7
ff
addsd  -0x130(%rbp),%xmm7
ff
movaps 0xb4a(%rip),%xmm9
pand   %xmm9,%xmm7
movsd  -0x110(%rbp),%xmm9
ff ff
subsd  -0x80(%rbp),%xmm9
mulsd  %xmm9,%xmm7
movq   %xmm7,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm7
mulsd  %xmm8,%xmm6
addsd  %xmm7,%xmm6
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
addsd  -0x20(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2847 <calculate_fgh+0x1717>
mov    0x30(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    $0x0,%al
call   1040 <getboundarytype@plt>
mov    %eax,-0x170(%rbp)
mov    -0x170(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cmp    $0x1,%edx
jne    2607 <calculate_fgh+0x14d7>
mov    -0x68(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2860 <calculate_fgh+0x1730>
mov    -0x170(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cmp    $0x2,%edx
jne    2679 <calculate_fgh+0x1549>
mov    -0x68(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x16c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x16c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2860 <calculate_fgh+0x1730>
jmp    267e <calculate_fgh+0x154e>
cmpl   $0x1f,-0x170(%rbp)
jle    26dc <calculate_fgh+0x15ac>
mov    -0x58(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2860 <calculate_fgh+0x1730>
cmpl   $0xf,-0x170(%rbp)
jle    2744 <calculate_fgh+0x1614>
mov    -0x58(%rbp),%rax
mov    -0x164(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x164(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2860 <calculate_fgh+0x1730>
jmp    2749 <calculate_fgh+0x1619>
mov    -0x170(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %edx,%eax
add    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x3,%eax
jne    27be <calculate_fgh+0x168e>
mov    -0x60(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2860 <calculate_fgh+0x1730>
mov    -0x170(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %edx,%eax
add    $0x2,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x2,%eax
jne    283d <calculate_fgh+0x170d>
mov    -0x60(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x168(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x168(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2860 <calculate_fgh+0x1730>
jmp    2842 <calculate_fgh+0x1712>
jmp    2847 <calculate_fgh+0x1717>
jmp    284c <calculate_fgh+0x171c>
mov    -0x16c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x16c(%rbp)
jmp    1228 <calculate_fgh+0xf8>
mov    -0x68(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    0x28(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
mov    -0x68(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x168(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x168(%rbp)
jmp    120a <calculate_fgh+0xda>
movl   $0x1,-0x16c(%rbp)
mov    -0x16c(%rbp),%eax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    29aa <calculate_fgh+0x187a>
mov    -0x60(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%rax
movslq -0x16c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x164(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x16c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x16c(%rbp)
jmp    2900 <calculate_fgh+0x17d0>
jmp    29af <calculate_fgh+0x187f>
mov    -0x164(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x164(%rbp)
jmp    11ec <calculate_fgh+0xbc>
movl   $0x1,-0x168(%rbp)
mov    -0x168(%rbp),%eax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2aae <calculate_fgh+0x197e>
movl   $0x1,-0x16c(%rbp)
mov    -0x16c(%rbp),%eax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2a95 <calculate_fgh+0x1965>
mov    -0x58(%rbp),%rax
mov    (%rax),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x16c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x16c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x16c(%rbp)
jmp    29eb <calculate_fgh+0x18bb>
jmp    2a9a <calculate_fgh+0x196a>
mov    -0x168(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x168(%rbp)
jmp    29cd <calculate_fgh+0x189d>
add    $0x200,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calculate_fgh>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x278,%rsp
mov    %r9,0x50(%rsp)
mov    %r8,0x40(%rsp)
mov    %rcx,0x48(%rsp)
mov    %rdx,0x18(%rsp)
mov    %rsi,0x8(%rsp)
movsd  %xmm5,0x120(%rsp)
movsd  %xmm4,0x118(%rsp)
movsd  %xmm3,0x1c8(%rsp)
movsd  %xmm2,0x1c0(%rsp)
movsd  %xmm1,0x1b8(%rsp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x138(%rsp)
mov    %rdi,0x130(%rsp)
test   %edi,%edi
jle    215e <calculate_fgh+0x103e>
movsd  0x1e5f(%rip),%xmm1
movapd %xmm1,%xmm2
divsd  %xmm6,%xmm2
movapd %xmm1,%xmm3
divsd  %xmm7,%xmm3
movapd %xmm1,%xmm4
divsd  0x2b0(%rsp),%xmm4
divsd  %xmm0,%xmm1
movsd  %xmm1,0x110(%rsp)
movsd  0x1e35(%rip),%xmm0
movsd  %xmm2,0x108(%rsp)
mulsd  %xmm0,%xmm2
movsd  %xmm2,0xe8(%rsp)
movsd  %xmm3,0x100(%rsp)
mulsd  %xmm0,%xmm3
movsd  %xmm3,0xe0(%rsp)
movsd  %xmm4,0xf8(%rsp)
mulsd  %xmm4,%xmm0
movsd  %xmm0,0xf0(%rsp)
movslq 0x18(%rsp),%rax
movslq 0x8(%rsp),%rcx
mov    %rax,0x1b0(%rsp)
lea    0x1(%rax),%r15d
mov    %rcx,0x190(%rsp)
lea    0x1(%rcx),%eax
mov    %rax,0x1a8(%rsp)
mov    0x130(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x198(%rsp)
lea    -0x1(%r15),%rax
lea    -0x5(%r15),%rcx
mov    %rcx,0x180(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rax,0x140(%rsp)
and    $0xfffffffffffffffc,%rax
mov    %rax,0x170(%rsp)
add    $0x1,%rax
mov    %rax,0x168(%rsp)
mov    %rcx,%rax
mov    %rcx,0x178(%rsp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rcx
mov    %rcx,0x160(%rsp)
mov    %r15,%rax
neg    %rax
mov    %rax,0x188(%rsp)
mov    $0x1,%ebp
mov    %r15,0x38(%rsp)
jmp    12e2 <calculate_fgh+0x1c2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rbp
cmp    0x198(%rsp),%rbp
je     215e <calculate_fgh+0x103e>
cmpl   $0x0,0x8(%rsp)
mov    %rbp,0x10(%rsp)
jle    1ef0 <calculate_fgh+0xdd0>
lea    0x1(%rbp),%eax
mov    %rax,0x1d0(%rsp)
mov    0x2b8(%rsp),%rax
lea    (%rax,%rbp,8),%rcx
mov    %rcx,0x148(%rsp)
mov    0x2c0(%rsp),%rcx
lea    (%rcx,%rbp,8),%rcx
mov    %rcx,0xd8(%rsp)
mov    0x2c8(%rsp),%rcx
lea    (%rcx,%rbp,8),%rcx
mov    %rcx,0x30(%rsp)
lea    (%rax,%rbp,8),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x1a0(%rsp)
mov    $0x1,%r12d
jmp    13be <calculate_fgh+0x29e>
mov    %ebx,%eax
mov    0x50(%rsp),%rcx
mov    (%rcx,%rbp,8),%rcx
lea    0x0(,%rax,8),%rbx
add    (%rcx,%r14,8),%rbx
mov    0x30(%rsp),%rcx
mov    %r14,%r13
movsd  (%rbx),%xmm0
mov    (%rcx),%rcx
mov    (%rcx,%r13,8),%rcx
movsd  %xmm0,(%rcx,%rax,8)
mov    0x50(%rsp),%rax
mov    (%rax,%rbp,8),%rax
mov    (%rax,%r14,8),%rax
movsd  (%rax),%xmm0
mov    0x30(%rsp),%rcx
mov    (%rcx),%rcx
mov    (%rcx,%r14,8),%rcx
movsd  %xmm0,(%rcx)
mov    0x1b0(%rsp),%rdx
movsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
cmp    0x1a8(%rsp),%r12
je     1ef0 <calculate_fgh+0xdd0>
mov    %r12,%r14
add    $0x1,%r12
cmpl   $0x0,0x18(%rsp)
jle    137d <calculate_fgh+0x25d>
mov    %r12d,%eax
mov    %rax,0x58(%rsp)
lea    -0x1(%r14),%r13
mov    $0x1,%ebx
mov    %r12,0x1d8(%rsp)
mov    %r13,0x150(%rsp)
jmp    140c <calculate_fgh+0x2ec>
nop
mov    0x150(%rsp),%r13
mov    0x158(%rsp),%rax
mov    %rax,%rbx
cmp    %r15,%rax
je     137d <calculate_fgh+0x25d>
mov    0x2d0(%rsp),%rax
mov    (%rax,%rbp,8),%rax
mov    (%rax,%r14,8),%rax
mov    (%rax,%rbx,4),%edi
xor    %eax,%eax
call   1030 <isfluid@plt>
test   %eax,%eax
je     1db0 <calculate_fgh+0xc90>
mov    0x48(%rsp),%rcx
mov    -0x8(%rcx,%rbp,8),%rax
mov    %rax,0x90(%rsp)
mov    (%rcx,%rbp,8),%r8
mov    -0x8(%r8,%r14,8),%rax
mov    %rax,(%rsp)
mov    (%r8,%r14,8),%r10
movsd  -0x8(%r10,%rbx,8),%xmm0
movsd  %xmm0,0x1f0(%rsp)
movsd  (%r10,%rbx,8),%xmm0
movaps %xmm0,0xb0(%rsp)
mov    0x40(%rsp),%r9
mov    -0x8(%r9,%rbp,8),%rax
mov    %rax,0xa0(%rsp)
mov    (%r9,%rbp,8),%rdx
mov    -0x8(%rdx,%r14,8),%rax
mov    %rax,0x128(%rsp)
mov    (%rdx,%r14,8),%rdi
movsd  -0x8(%rdi,%rbx,8),%xmm0
movsd  %xmm0,0x208(%rsp)
movsd  (%rdi,%rbx,8),%xmm0
movaps %xmm0,0xc0(%rsp)
mov    0x50(%rsp),%r15
mov    (%r15,%rbp,8),%r12
mov    (%r12,%r14,8),%rax
movsd  -0x8(%rax,%rbx,8),%xmm0
movsd  %xmm0,0x28(%rsp)
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,0x20(%rsp)
mov    0x1d0(%rsp),%r13
mov    (%rcx,%r13,8),%rcx
mov    (%rcx,%r14,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,0x1e0(%rsp)
mov    0x58(%rsp),%rsi
mov    (%rdx,%rsi,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,0x1f8(%rsp)
lea    0x1(%rbx),%rcx
mov    %rcx,0x158(%rsp)
mov    %ecx,%r11d
movsd  (%rax,%r11,8),%xmm0
movsd  %xmm0,0x218(%rsp)
mov    -0x8(%r15,%rbp,8),%rax
mov    (%r8,%rsi,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
movaps %xmm0,0x80(%rsp)
mov    -0x8(%r12,%r14,8),%rcx
movsd  (%rdi,%r11,8),%xmm0
movsd  %xmm0,0x68(%rsp)
mov    (%r15,%r13,8),%rdx
mov    0x2d0(%rsp),%rdi
mov    (%rdx,%r14,8),%rdx
movsd  -0x8(%rdx,%rbx,8),%xmm0
movaps %xmm0,0x240(%rsp)
movsd  (%rdx,%rbx,8),%xmm0
movsd  %xmm0,0x78(%rsp)
mov    0x90(%rsp),%rdx
mov    (%rdx,%r14,8),%r15
mov    (%rsp),%rbp
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,0x1e8(%rsp)
mov    (%rax,%r14,8),%rax
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,0x220(%rsp)
movsd  (%r10,%r11,8),%xmm0
movsd  %xmm0,(%rsp)
mov    (%r9,%r13,8),%rax
mov    -0x8(%rax,%r14,8),%r9
mov    (%rax,%r14,8),%r8
mov    (%r12,%rsi,8),%rbp
mov    0xa0(%rsp),%rax
mov    (%rax,%r14,8),%rax
mov    (%rdx,%rsi,8),%rsi
mov    (%rdi,%r13,8),%rdi
mov    %rbx,%r13
mov    %r11,%rbx
mov    (%rdi,%r14,8),%rdi
mov    (%rdi,%r13,4),%edi
movsd  (%r8,%r13,8),%xmm0
movsd  %xmm0,0x70(%rsp)
movsd  -0x8(%rbp,%r13,8),%xmm0
movaps %xmm0,0x260(%rsp)
movsd  0x0(%rbp,%r13,8),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  (%rax,%r13,8),%xmm0
movsd  %xmm0,0x200(%rsp)
movsd  (%rcx,%r13,8),%xmm0
movsd  %xmm0,0x228(%rsp)
movsd  (%rsi,%r13,8),%xmm0
movaps %xmm0,0x250(%rsp)
movsd  (%r15,%r13,8),%xmm0
movaps %xmm0,0x90(%rsp)
movsd  (%r15,%r11,8),%xmm0
movsd  %xmm0,0x210(%rsp)
movsd  (%r9,%r13,8),%xmm0
movaps %xmm0,0x230(%rsp)
mov    0x128(%rsp),%rax
movsd  (%rax,%r13,8),%xmm0
movaps %xmm0,0xa0(%rsp)
movsd  (%rax,%r11,8),%xmm0
movsd  %xmm0,0x128(%rsp)
xor    %eax,%eax
call   1030 <isfluid@plt>
movsd  0x70(%rsp),%xmm15
movsd  (%rsp),%xmm14
movsd  0x78(%rsp),%xmm13
movapd 0x80(%rsp),%xmm12
movsd  0x28(%rsp),%xmm9
movapd 0xc0(%rsp),%xmm8
movapd 0xb0(%rsp),%xmm7
test   %eax,%eax
je     18e5 <calculate_fgh+0x7c5>
movapd %xmm7,%xmm0
mulsd  0x1931(%rip),%xmm0
movapd %xmm0,%xmm1
movsd  0x1e0(%rsp),%xmm6
addsd  %xmm6,%xmm1
movapd 0x90(%rsp),%xmm5
addsd  %xmm5,%xmm1
movsd  0x108(%rsp),%xmm3
mulsd  %xmm3,%xmm1
movapd %xmm0,%xmm2
addsd  %xmm12,%xmm2
movsd  0x1e8(%rsp),%xmm10
addsd  %xmm10,%xmm2
movsd  0x100(%rsp),%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm14,%xmm0
movsd  0x1f0(%rsp),%xmm11
addsd  %xmm11,%xmm0
movsd  0xf8(%rsp),%xmm2
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm7,%xmm1
addsd  %xmm6,%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm7,%xmm3
addsd  %xmm5,%xmm3
movapd %xmm3,%xmm4
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm2
movapd %xmm7,%xmm4
subsd  %xmm6,%xmm4
movapd 0x1888(%rip),%xmm6
andpd  %xmm6,%xmm3
subsd  %xmm7,%xmm5
mulsd  %xmm3,%xmm5
andpd  %xmm6,%xmm1
mulsd  %xmm1,%xmm4
subsd  %xmm5,%xmm4
movsd  0x118(%rsp),%xmm5
mulsd  %xmm5,%xmm4
addsd  %xmm2,%xmm4
mulsd  0xe8(%rsp),%xmm4
mulsd  0x110(%rsp),%xmm0
addsd  %xmm4,%xmm0
movapd %xmm8,%xmm2
addsd  %xmm15,%xmm2
movapd %xmm7,%xmm3
addsd  %xmm12,%xmm3
movapd 0x230(%rsp),%xmm4
addsd  0xa0(%rsp),%xmm4
movapd %xmm7,%xmm1
addsd  %xmm10,%xmm1
mulsd  %xmm4,%xmm1
mulsd  %xmm2,%xmm3
subsd  %xmm1,%xmm3
andpd  %xmm6,%xmm2
andpd  %xmm6,%xmm4
subsd  %xmm7,%xmm10
mulsd  %xmm4,%xmm10
movapd %xmm7,%xmm1
subsd  %xmm12,%xmm1
mulsd  %xmm2,%xmm1
subsd  %xmm10,%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm3,%xmm1
mulsd  0xe0(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  0x20(%rsp),%xmm0
addsd  %xmm13,%xmm0
movapd %xmm7,%xmm2
addsd  %xmm14,%xmm2
movapd 0x240(%rsp),%xmm4
addsd  %xmm9,%xmm4
movapd %xmm7,%xmm3
addsd  %xmm11,%xmm3
mulsd  %xmm4,%xmm3
mulsd  %xmm0,%xmm2
subsd  %xmm3,%xmm2
andpd  %xmm6,%xmm0
andpd  %xmm6,%xmm4
subsd  %xmm7,%xmm11
mulsd  %xmm4,%xmm11
movapd %xmm7,%xmm3
subsd  %xmm14,%xmm3
mulsd  %xmm0,%xmm3
subsd  %xmm11,%xmm3
mulsd  %xmm5,%xmm3
addsd  %xmm2,%xmm3
mulsd  0xf0(%rsp),%xmm3
addsd  %xmm1,%xmm3
addsd  0x1b8(%rsp),%xmm3
mulsd  0x120(%rsp),%xmm3
addsd  %xmm7,%xmm3
mov    0x148(%rsp),%rax
mov    (%rax),%rax
mov    (%rax,%r14,8),%rax
movsd  %xmm3,(%rax,%r13,8)
mov    0x10(%rsp),%rbp
mov    0x2d0(%rsp),%rax
mov    (%rax,%rbp,8),%rax
mov    0x58(%rsp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax,%r13,4),%edi
xor    %eax,%eax
call   1030 <isfluid@plt>
test   %eax,%eax
je     1b45 <calculate_fgh+0xa25>
movapd 0xc0(%rsp),%xmm7
movapd %xmm7,%xmm0
mulsd  0x16e9(%rip),%xmm0
movapd %xmm0,%xmm1
movsd  0x70(%rsp),%xmm11
addsd  %xmm11,%xmm1
movsd  0x200(%rsp),%xmm10
addsd  %xmm10,%xmm1
movsd  0x108(%rsp),%xmm3
mulsd  %xmm3,%xmm1
movapd %xmm0,%xmm2
movsd  0x1f8(%rsp),%xmm6
addsd  %xmm6,%xmm2
movapd 0xa0(%rsp),%xmm5
addsd  %xmm5,%xmm2
movsd  0x100(%rsp),%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  0x68(%rsp),%xmm8
addsd  %xmm8,%xmm0
movsd  0x208(%rsp),%xmm9
addsd  %xmm9,%xmm0
movsd  0xf8(%rsp),%xmm2
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm7,%xmm1
addsd  %xmm6,%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm7,%xmm3
addsd  %xmm5,%xmm3
movapd %xmm3,%xmm4
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm2
movapd %xmm7,%xmm4
subsd  %xmm6,%xmm4
movapd 0x1632(%rip),%xmm6
andpd  %xmm6,%xmm3
subsd  %xmm7,%xmm5
mulsd  %xmm3,%xmm5
andpd  %xmm6,%xmm1
mulsd  %xmm1,%xmm4
subsd  %xmm5,%xmm4
movsd  0x118(%rsp),%xmm5
mulsd  %xmm5,%xmm4
addsd  %xmm2,%xmm4
mulsd  0xe0(%rsp),%xmm4
mulsd  0x110(%rsp),%xmm0
addsd  %xmm4,%xmm0
movapd 0x80(%rsp),%xmm3
addsd  0xb0(%rsp),%xmm3
movapd %xmm7,%xmm2
addsd  %xmm11,%xmm2
movapd 0x250(%rsp),%xmm4
addsd  0x90(%rsp),%xmm4
movapd %xmm7,%xmm1
addsd  %xmm10,%xmm1
mulsd  %xmm4,%xmm1
mulsd  %xmm3,%xmm2
subsd  %xmm1,%xmm2
movapd %xmm7,%xmm1
subsd  %xmm11,%xmm1
andpd  %xmm6,%xmm4
subsd  %xmm7,%xmm10
mulsd  %xmm4,%xmm10
andpd  %xmm6,%xmm3
mulsd  %xmm3,%xmm1
subsd  %xmm10,%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm2,%xmm1
mulsd  0xe8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  0x20(%rsp),%xmm0
addsd  0x60(%rsp),%xmm0
movapd %xmm7,%xmm2
addsd  %xmm8,%xmm2
movapd 0x260(%rsp),%xmm4
addsd  0x28(%rsp),%xmm4
movapd %xmm7,%xmm3
addsd  %xmm9,%xmm3
mulsd  %xmm4,%xmm3
mulsd  %xmm0,%xmm2
subsd  %xmm3,%xmm2
andpd  %xmm6,%xmm0
andpd  %xmm6,%xmm4
subsd  %xmm7,%xmm9
mulsd  %xmm4,%xmm9
movapd %xmm7,%xmm3
subsd  %xmm8,%xmm3
mulsd  %xmm0,%xmm3
subsd  %xmm9,%xmm3
mulsd  %xmm5,%xmm3
addsd  %xmm2,%xmm3
mulsd  0xf0(%rsp),%xmm3
addsd  %xmm1,%xmm3
addsd  0x1c0(%rsp),%xmm3
mulsd  0x120(%rsp),%xmm3
addsd  %xmm7,%xmm3
mov    0xd8(%rsp),%rax
mov    (%rax),%rax
mov    (%rax,%r14,8),%rax
movsd  %xmm3,(%rax,%r13,8)
mov    0x2d0(%rsp),%rax
mov    (%rax,%rbp,8),%rax
mov    (%rax,%r14,8),%rax
mov    (%rax,%rbx,4),%edi
xor    %eax,%eax
call   1030 <isfluid@plt>
test   %eax,%eax
mov    0x38(%rsp),%r15
mov    0x1d8(%rsp),%r12
je     13f0 <calculate_fgh+0x2d0>
movsd  0x20(%rsp),%xmm6
movapd %xmm6,%xmm0
mulsd  0x148a(%rip),%xmm0
movapd %xmm0,%xmm1
movsd  0x78(%rsp),%xmm11
addsd  %xmm11,%xmm1
movsd  0x220(%rsp),%xmm12
addsd  %xmm12,%xmm1
movsd  0x108(%rsp),%xmm3
mulsd  %xmm3,%xmm1
movapd %xmm0,%xmm2
movsd  0x60(%rsp),%xmm9
addsd  %xmm9,%xmm2
movsd  0x228(%rsp),%xmm10
addsd  %xmm10,%xmm2
movsd  0x100(%rsp),%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  0x218(%rsp),%xmm5
addsd  %xmm5,%xmm0
movsd  0x28(%rsp),%xmm7
addsd  %xmm7,%xmm0
movsd  0xf8(%rsp),%xmm2
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm6,%xmm1
addsd  %xmm5,%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm6,%xmm3
addsd  %xmm7,%xmm3
movapd %xmm3,%xmm4
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm2
movapd %xmm6,%xmm4
subsd  %xmm5,%xmm4
movapd 0x13d5(%rip),%xmm8
andpd  %xmm8,%xmm3
subsd  %xmm6,%xmm7
mulsd  %xmm3,%xmm7
andpd  %xmm8,%xmm1
mulsd  %xmm1,%xmm4
subsd  %xmm7,%xmm4
movsd  0x118(%rsp),%xmm3
mulsd  %xmm3,%xmm4
addsd  %xmm2,%xmm4
mulsd  0xf0(%rsp),%xmm4
mulsd  0x110(%rsp),%xmm0
addsd  %xmm4,%xmm0
movapd 0xb0(%rsp),%xmm4
addsd  (%rsp),%xmm4
movapd %xmm6,%xmm2
addsd  %xmm11,%xmm2
movapd 0x90(%rsp),%xmm5
addsd  0x210(%rsp),%xmm5
movapd %xmm6,%xmm1
addsd  %xmm12,%xmm1
mulsd  %xmm5,%xmm1
mulsd  %xmm4,%xmm2
subsd  %xmm1,%xmm2
movapd %xmm6,%xmm1
subsd  %xmm11,%xmm1
andpd  %xmm8,%xmm5
subsd  %xmm6,%xmm12
mulsd  %xmm5,%xmm12
andpd  %xmm8,%xmm4
mulsd  %xmm4,%xmm1
subsd  %xmm12,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  0xe8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movapd 0xc0(%rsp),%xmm4
addsd  0x68(%rsp),%xmm4
movapd %xmm6,%xmm0
addsd  %xmm9,%xmm0
movapd 0xa0(%rsp),%xmm5
addsd  0x128(%rsp),%xmm5
movapd %xmm6,%xmm2
addsd  %xmm10,%xmm2
mulsd  %xmm5,%xmm2
mulsd  %xmm4,%xmm0
subsd  %xmm2,%xmm0
movapd %xmm6,%xmm2
subsd  %xmm9,%xmm2
andpd  %xmm8,%xmm5
subsd  %xmm6,%xmm10
mulsd  %xmm5,%xmm10
andpd  %xmm8,%xmm4
mulsd  %xmm4,%xmm2
subsd  %xmm10,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
mulsd  0xe0(%rsp),%xmm2
addsd  %xmm1,%xmm2
addsd  0x1c8(%rsp),%xmm2
mulsd  0x120(%rsp),%xmm2
addsd  %xmm6,%xmm2
mov    0x30(%rsp),%rax
mov    (%rax),%rax
mov    (%rax,%r14,8),%rax
movsd  %xmm2,(%rax,%r13,8)
jmp    13f0 <calculate_fgh+0x2d0>
nopl   0x0(%rax)
mov    0x2d0(%rsp),%rax
mov    (%rax,%rbp,8),%rax
mov    (%rax,%r14,8),%rax
mov    (%rax,%rbx,4),%edi
xor    %eax,%eax
call   1040 <getboundarytype@plt>
lea    0x3(%rax),%edx
test   %eax,%eax
cmovns %eax,%edx
and    $0xfffffffc,%edx
mov    %eax,%ecx
sub    %edx,%ecx
cmp    $0x2,%ecx
je     1e2c <calculate_fgh+0xd0c>
cmp    $0x1,%ecx
je     134e <calculate_fgh+0x22e>
cmp    $0x20,%eax
jge    1e56 <calculate_fgh+0xd36>
cmp    $0x10,%eax
jge    1e7a <calculate_fgh+0xd5a>
lea    0xf(%rax),%ecx
test   %eax,%eax
cmovns %eax,%ecx
and    $0xfffffff0,%ecx
mov    %ecx,%edx
neg    %edx
add    %eax,%edx
add    $0xfffffff8,%edx
cmp    $0x2,%edx
jbe    1e9f <calculate_fgh+0xd7f>
sub    %ecx,%eax
add    $0xfffffffc,%eax
cmp    $0x3,%eax
jb     1ec3 <calculate_fgh+0xda3>
add    $0x1,%rbx
mov    %rbx,%rax
jmp    1400 <calculate_fgh+0x2e0>
mov    0x50(%rsp),%rax
mov    (%rax,%rbp,8),%rcx
shl    $0x20,%rbx
movabs $0xffffffff00000000,%rax
ff ff ff
add    %rax,%rbx
mov    %rbx,%rax
sar    $0x20,%rax
sar    $0x1d,%rbx
jmp    1361 <calculate_fgh+0x241>
mov    %ebx,%eax
mov    0x48(%rsp),%rcx
mov    (%rcx,%rbp,8),%rcx
lea    0x0(,%rax,8),%rbx
add    (%rcx,%r14,8),%rbx
mov    0x148(%rsp),%rcx
jmp    136a <calculate_fgh+0x24a>
mov    %ebx,%eax
mov    0x48(%rsp),%rcx
mov    -0x8(%rcx,%rbp,8),%rcx
lea    0x0(,%rax,8),%rbx
add    (%rcx,%r14,8),%rbx
mov    0x1a0(%rsp),%rcx
jmp    136a <calculate_fgh+0x24a>
mov    %ebx,%eax
mov    0x40(%rsp),%rcx
mov    (%rcx,%rbp,8),%rcx
lea    0x0(,%rax,8),%rbx
add    (%rcx,%r14,8),%rbx
mov    0xd8(%rsp),%rcx
jmp    136a <calculate_fgh+0x24a>
mov    %ebx,%eax
mov    0x40(%rsp),%rcx
mov    (%rcx,%rbp,8),%rcx
lea    0x0(,%rax,8),%rbx
add    -0x8(%rcx,%r14,8),%rbx
mov    0xd8(%rsp),%rcx
jmp    136d <calculate_fgh+0x24d>
nopl   0x0(%rax,%rax,1)
cmpl   $0x0,0x18(%rsp)
jle    12d0 <calculate_fgh+0x1b0>
mov    0x40(%rsp),%rax
mov    (%rax,%rbp,8),%rdx
mov    (%rdx),%r14
mov    0x2c0(%rsp),%rcx
mov    (%rcx,%rbp,8),%rax
mov    (%rax),%rcx
mov    0x190(%rsp),%rdi
mov    (%rdx,%rdi,8),%rdx
mov    (%rax,%rdi,8),%r12
mov    $0x1,%r11d
cmpq   $0x4,0x140(%rsp)
jb     20e0 <calculate_fgh+0xfc0>
lea    0x8(%rcx),%rdi
lea    (%rcx,%r15,8),%r13
lea    0x8(%r12),%r9
lea    (%r12,%r15,8),%rbx
lea    0x8(%r14),%rax
lea    (%r14,%r15,8),%r8
lea    0x8(%rdx),%rbp
lea    (%rdx,%r15,8),%r10
cmp    %rbx,%rdi
setb   %r15b
cmp    %r13,%r9
setb   0xc0(%rsp)
cmp    %r8,%rdi
setb   %sil
cmp    %r13,%rax
setb   0xb0(%rsp)
cmp    %r10,%rdi
setb   %dil
cmp    %r13,%rbp
setb   %r13b
cmp    %r8,%r9
setb   %r8b
cmp    %rbx,%rax
setb   %al
cmp    %r10,%r9
setb   %r9b
cmp    %rbx,%rbp
setb   %r10b
test   %r15b,0xc0(%rsp)
jne    20d4 <calculate_fgh+0xfb4>
and    0xb0(%rsp),%sil
jne    20d4 <calculate_fgh+0xfb4>
and    %r13b,%dil
mov    0x38(%rsp),%r15
jne    20d9 <calculate_fgh+0xfb9>
and    %al,%r8b
jne    20d9 <calculate_fgh+0xfb9>
and    %r10b,%r9b
mov    0x10(%rsp),%rbp
jne    20e0 <calculate_fgh+0xfc0>
cmpq   $0x4,0x180(%rsp)
jae    1ff9 <calculate_fgh+0xed9>
xor    %edi,%edi
jmp    2076 <calculate_fgh+0xf56>
mov    0x160(%rsp),%rax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups 0x8(%r14,%rdi,8),%xmm0
movups 0x18(%r14,%rdi,8),%xmm1
movups %xmm0,0x8(%rcx,%rdi,8)
movups %xmm1,0x18(%rcx,%rdi,8)
movups 0x8(%rdx,%rdi,8),%xmm0
movups 0x18(%rdx,%rdi,8),%xmm1
movups %xmm0,0x8(%r12,%rdi,8)
movups %xmm1,0x18(%r12,%rdi,8)
movups 0x28(%r14,%rdi,8),%xmm0
movups 0x38(%r14,%rdi,8),%xmm1
movups %xmm0,0x28(%rcx,%rdi,8)
movups %xmm1,0x38(%rcx,%rdi,8)
movupd 0x28(%rdx,%rdi,8),%xmm0
movupd 0x38(%rdx,%rdi,8),%xmm1
movupd %xmm0,0x28(%r12,%rdi,8)
movupd %xmm1,0x38(%r12,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rax
jne    2010 <calculate_fgh+0xef0>
testb  $0x1,0x178(%rsp)
01
je     20b4 <calculate_fgh+0xf94>
shl    $0x3,%rdi
or     $0x8,%rdi
movups (%r14,%rdi,1),%xmm0
movups 0x10(%r14,%rdi,1),%xmm1
movups %xmm0,(%rcx,%rdi,1)
movups %xmm1,0x10(%rcx,%rdi,1)
movupd (%rdx,%rdi,1),%xmm0
movupd 0x10(%rdx,%rdi,1),%xmm1
movupd %xmm0,(%r12,%rdi,1)
movupd %xmm1,0x10(%r12,%rdi,1)
mov    0x168(%rsp),%r11
mov    0x170(%rsp),%rdi
cmp    %rdi,0x140(%rsp)
je     12d0 <calculate_fgh+0x1b0>
jmp    20e0 <calculate_fgh+0xfc0>
mov    0x38(%rsp),%r15
mov    0x10(%rsp),%rbp
xchg   %ax,%ax
mov    %r11,%rdi
test   $0x1,%r15b
jne    2105 <calculate_fgh+0xfe5>
movsd  (%r14,%r11,8),%xmm0
movsd  %xmm0,(%rcx,%r11,8)
movsd  (%rdx,%r11,8),%xmm0
movsd  %xmm0,(%r12,%r11,8)
lea    0x1(%r11),%rdi
not    %r11
cmp    0x188(%rsp),%r11
je     12d0 <calculate_fgh+0x1b0>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r14,%rdi,8),%xmm0
movsd  %xmm0,(%rcx,%rdi,8)
movsd  (%rdx,%rdi,8),%xmm0
movsd  %xmm0,(%r12,%rdi,8)
movsd  0x8(%r14,%rdi,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rdi,8)
movsd  0x8(%rdx,%rdi,8),%xmm0
movsd  %xmm0,0x8(%r12,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r15
jne    2120 <calculate_fgh+0x1000>
jmp    12d0 <calculate_fgh+0x1b0>
cmpl   $0x0,0x8(%rsp)
jle    244b <calculate_fgh+0x132b>
movslq 0x130(%rsp),%r8
mov    0x18(%rsp),%rax
lea    0x1(%rax),%ecx
mov    0x8(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x8(%rsp)
lea    -0x1(%rcx),%r9
lea    -0x5(%rcx),%rax
mov    %rax,0x70(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %r9,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0x60(%rsp)
add    $0x1,%rdx
mov    %rdx,0x58(%rsp)
mov    %rax,%rdx
mov    %rax,0x68(%rsp)
and    %rax,0x138(%rsp)
mov    %rcx,%rax
neg    %rax
mov    %rax,0x78(%rsp)
mov    $0x1,%r13d
mov    %r8,(%rsp)
mov    %r9,0x80(%rsp)
jmp    21ef <calculate_fgh+0x10cf>
nop
add    $0x1,%r13
cmp    0x8(%rsp),%r13
je     244b <calculate_fgh+0x132b>
cmpl   $0x0,0x18(%rsp)
jle    21e0 <calculate_fgh+0x10c0>
mov    0x48(%rsp),%rdx
mov    (%rdx),%rax
mov    (%rax,%r13,8),%rbp
mov    0x2b8(%rsp),%rsi
mov    (%rsi),%rax
mov    (%rax,%r13,8),%rdi
mov    (%rdx,%r8,8),%rax
mov    (%rax,%r13,8),%rbx
mov    (%rsi,%r8,8),%rax
mov    (%rax,%r13,8),%rdx
mov    $0x1,%r12d
cmp    $0x4,%r9
jb     23d0 <calculate_fgh+0x12b0>
lea    0x8(%rdi),%rsi
lea    (%rdi,%rcx,8),%r9
lea    0x8(%rdx),%r10
lea    (%rdx,%rcx,8),%r15
lea    0x8(%rbp),%r14
lea    0x0(,%rcx,8),%r11
add    %rbp,%r11
lea    0x8(%rbx),%rax
lea    (%rbx,%rcx,8),%r8
cmp    %r15,%rsi
setb   0xc0(%rsp)
cmp    %r9,%r10
setb   0xb0(%rsp)
cmp    %r11,%rsi
setb   0x28(%rsp)
cmp    %r9,%r14
setb   0x20(%rsp)
cmp    %r8,%rsi
setb   0xa0(%rsp)
mov    %rax,%rsi
cmp    %r9,%rax
setb   0x90(%rsp)
cmp    %r11,%r10
setb   %r9b
cmp    %r15,%r14
setb   %r14b
cmp    %r8,%r10
setb   %r10b
cmp    %r15,%rax
setb   %r15b
mov    0xb0(%rsp),%al
test   %al,0xc0(%rsp)
jne    2303 <calculate_fgh+0x11e3>
mov    0x20(%rsp),%al
and    %al,0x28(%rsp)
jne    2303 <calculate_fgh+0x11e3>
mov    0x90(%rsp),%al
and    %al,0xa0(%rsp)
jne    2303 <calculate_fgh+0x11e3>
and    %r14b,%r9b
jne    2303 <calculate_fgh+0x11e3>
and    %r15b,%r10b
mov    (%rsp),%r8
mov    0x80(%rsp),%r9
jne    23d0 <calculate_fgh+0x12b0>
cmpq   $0x4,0x70(%rsp)
jae    2314 <calculate_fgh+0x11f4>
xor    %eax,%eax
jmp    237e <calculate_fgh+0x125e>
mov    (%rsp),%r8
mov    0x80(%rsp),%r9
jmp    23d0 <calculate_fgh+0x12b0>
mov    0x138(%rsp),%rsi
xor    %eax,%eax
xchg   %ax,%ax
movups 0x8(%rbp,%rax,8),%xmm0
movups 0x18(%rbp,%rax,8),%xmm1
movups %xmm0,0x8(%rdi,%rax,8)
movups %xmm1,0x18(%rdi,%rax,8)
movups 0x8(%rbx,%rax,8),%xmm0
movups 0x18(%rbx,%rax,8),%xmm1
movups %xmm0,0x8(%rdx,%rax,8)
movups %xmm1,0x18(%rdx,%rax,8)
movups 0x28(%rbp,%rax,8),%xmm0
movups 0x38(%rbp,%rax,8),%xmm1
movups %xmm0,0x28(%rdi,%rax,8)
movups %xmm1,0x38(%rdi,%rax,8)
movupd 0x28(%rbx,%rax,8),%xmm0
movupd 0x38(%rbx,%rax,8),%xmm1
movupd %xmm0,0x28(%rdx,%rax,8)
movupd %xmm1,0x38(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rsi
jne    2320 <calculate_fgh+0x1200>
testb  $0x1,0x68(%rsp)
je     23b6 <calculate_fgh+0x1296>
shl    $0x3,%rax
or     $0x8,%rax
movups 0x0(%rbp,%rax,1),%xmm0
movups 0x10(%rbp,%rax,1),%xmm1
movups %xmm0,(%rdi,%rax,1)
movups %xmm1,0x10(%rdi,%rax,1)
movupd (%rbx,%rax,1),%xmm0
movupd 0x10(%rbx,%rax,1),%xmm1
movupd %xmm0,(%rdx,%rax,1)
movupd %xmm1,0x10(%rdx,%rax,1)
mov    0x58(%rsp),%r12
cmp    0x60(%rsp),%r9
je     21e0 <calculate_fgh+0x10c0>
cs nopw 0x0(%rax,%rax,1)
mov    %r12,%rsi
test   $0x1,%cl
jne    23f6 <calculate_fgh+0x12d6>
movsd  0x0(%rbp,%r12,8),%xmm0
movsd  %xmm0,(%rdi,%r12,8)
movsd  (%rbx,%r12,8),%xmm0
movsd  %xmm0,(%rdx,%r12,8)
lea    0x1(%r12),%rsi
not    %r12
cmp    0x78(%rsp),%r12
je     21e0 <calculate_fgh+0x10c0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%rbp,%rsi,8),%xmm0
movsd  %xmm0,(%rdi,%rsi,8)
movsd  (%rbx,%rsi,8),%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
movsd  0x8(%rbp,%rsi,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rsi,8)
movsd  0x8(%rbx,%rsi,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rcx
jne    2410 <calculate_fgh+0x12f0>
jmp    21e0 <calculate_fgh+0x10c0>
add    $0x278,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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