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++) {
        switch (Flag[i][j][k] & (3 * 4096)) {
        case 4096:
          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);
          }
          break;
        case 8192:
          break;
        default:
          fgg = getcelltype(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    $0x210,%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    29e9 <calculate_fgh+0x18b9>
movl   $0x1,-0x168(%rbp)
mov    -0x168(%rbp),%eax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    291c <calculate_fgh+0x17ec>
movl   $0x1,-0x16c(%rbp)
mov    -0x16c(%rbp),%eax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2886 <calculate_fgh+0x1756>
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),%eax
and    $0x3000,%eax
mov    %eax,-0x174(%rbp)
sub    $0x1000,%eax
je     1291 <calculate_fgh+0x161>
jmp    127b <calculate_fgh+0x14b>
mov    -0x174(%rbp),%eax
sub    $0x2000,%eax
je     258f <calculate_fgh+0x145f>
jmp    2594 <calculate_fgh+0x1464>
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     1c7e <calculate_fgh+0xb4e>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
movsd  %xmm0,-0x198(%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,-0x190(%rbp)
ff
movsd  0x1706(%rip),%xmm0
mulsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  0x16e9(%rip),%xmm1
call   1040 <pow@plt>
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0x70(%rbp),%xmm0
movsd  0x16c7(%rip),%xmm1
call   1040 <pow@plt>
movsd  -0x1a8(%rbp),%xmm6
ff
movsd  -0x1a0(%rbp),%xmm3
ff
movsd  -0x198(%rbp),%xmm2
ff
movsd  -0x190(%rbp),%xmm4
ff
movsd  -0x188(%rbp),%xmm1
ff
movaps %xmm0,%xmm5
movsd  -0x180(%rbp),%xmm0
ff
subsd  %xmm5,%xmm6
movsd  -0x28(%rbp),%xmm5
movsd  -0x70(%rbp),%xmm7
addsd  -0x88(%rbp),%xmm7
ff
movaps 0x1681(%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 0x1656(%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  0x15d1(%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 0x156e(%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 0x1543(%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  0x14c3(%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 0x1460(%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 0x1435(%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     2104 <calculate_fgh+0xfd4>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c8(%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,-0x1c0(%rbp)
ff
movsd  0x1280(%rip),%xmm0
mulsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
addsd  -0xb8(%rbp),%xmm0
ff
movsd  0x1263(%rip),%xmm1
call   1040 <pow@plt>
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
addsd  -0x78(%rbp),%xmm0
movsd  0x1241(%rip),%xmm1
call   1040 <pow@plt>
movsd  -0x1d8(%rbp),%xmm6
ff
movsd  -0x1d0(%rbp),%xmm3
ff
movsd  -0x1c8(%rbp),%xmm2
ff
movsd  -0x1c0(%rbp),%xmm4
ff
movsd  -0x1b8(%rbp),%xmm1
ff
movaps %xmm0,%xmm5
movsd  -0x1b0(%rbp),%xmm0
ff
subsd  %xmm5,%xmm6
movsd  -0x28(%rbp),%xmm5
movsd  -0x78(%rbp),%xmm7
addsd  -0xb8(%rbp),%xmm7
ff
movaps 0x11fb(%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 0x11d0(%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  0x114b(%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 0x10e8(%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 0x10bd(%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  0x103d(%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
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 0xfda(%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 0xfaf(%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     258a <calculate_fgh+0x145a>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f8(%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,-0x1f0(%rbp)
ff
movsd  0xdfa(%rip),%xmm0
mulsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x200(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
addsd  -0xe8(%rbp),%xmm0
ff
movsd  0xddd(%rip),%xmm1
call   1040 <pow@plt>
movsd  %xmm0,-0x208(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
addsd  -0x80(%rbp),%xmm0
movsd  0xdbb(%rip),%xmm1
call   1040 <pow@plt>
movsd  -0x208(%rbp),%xmm6
ff
movsd  -0x200(%rbp),%xmm3
ff
movsd  -0x1f8(%rbp),%xmm2
ff
movsd  -0x1f0(%rbp),%xmm4
ff
movsd  -0x1e8(%rbp),%xmm1
ff
movaps %xmm0,%xmm5
movsd  -0x1e0(%rbp),%xmm0
ff
subsd  %xmm5,%xmm6
movsd  -0x28(%rbp),%xmm5
movsd  -0x80(%rbp),%xmm7
addsd  -0xe8(%rbp),%xmm7
ff
movaps 0xd75(%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 0xd4a(%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  0xcc5(%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 0xc62(%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 0xc37(%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  0xbb7(%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 0xb54(%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 0xb29(%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    286d <calculate_fgh+0x173d>
jmp    286d <calculate_fgh+0x173d>
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   1050 <getcelltype@plt>
mov    %eax,-0x170(%rbp)
mov    -0x170(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cmp    $0x1,%edx
jne    262d <calculate_fgh+0x14fd>
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    286d <calculate_fgh+0x173d>
mov    -0x170(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cmp    $0x2,%edx
jne    269f <calculate_fgh+0x156f>
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    286d <calculate_fgh+0x173d>
jmp    26a4 <calculate_fgh+0x1574>
cmpl   $0x1f,-0x170(%rbp)
jle    2702 <calculate_fgh+0x15d2>
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    286d <calculate_fgh+0x173d>
cmpl   $0xf,-0x170(%rbp)
jle    276a <calculate_fgh+0x163a>
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    286d <calculate_fgh+0x173d>
jmp    276f <calculate_fgh+0x163f>
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    27e4 <calculate_fgh+0x16b4>
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    286d <calculate_fgh+0x173d>
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    2863 <calculate_fgh+0x1733>
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    286d <calculate_fgh+0x173d>
jmp    2868 <calculate_fgh+0x1738>
jmp    286d <calculate_fgh+0x173d>
jmp    2872 <calculate_fgh+0x1742>
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    29d0 <calculate_fgh+0x18a0>
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    2926 <calculate_fgh+0x17f6>
jmp    29d5 <calculate_fgh+0x18a5>
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    2ad4 <calculate_fgh+0x19a4>
movl   $0x1,-0x16c(%rbp)
mov    -0x16c(%rbp),%eax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2abb <calculate_fgh+0x198b>
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    2a11 <calculate_fgh+0x18e1>
jmp    2ac0 <calculate_fgh+0x1990>
mov    -0x168(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x168(%rbp)
jmp    29f3 <calculate_fgh+0x18c3>
add    $0x210,%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,0x60(%rsp)
mov    %r8,0x48(%rsp)
mov    %rcx,0x50(%rsp)
mov    %rdx,0x20(%rsp)
mov    %rsi,0x18(%rsp)
movsd  %xmm5,0x120(%rsp)
movsd  %xmm4,0x118(%rsp)
movsd  %xmm3,0x1c0(%rsp)
movsd  %xmm2,0x1b8(%rsp)
movsd  %xmm1,0x1b0(%rsp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x130(%rsp)
mov    %rdi,0x128(%rsp)
test   %edi,%edi
jle    20fa <calculate_fgh+0xfda>
mov    0x2d0(%rsp),%r13
movsd  0x1e57(%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  0x1e2d(%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 0x20(%rsp),%rax
movslq 0x18(%rsp),%rcx
mov    %rax,0x1a8(%rsp)
lea    0x1(%rax),%ebx
mov    %rcx,0x180(%rsp)
lea    0x1(%rcx),%eax
mov    %rax,0x1a0(%rsp)
mov    0x128(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x188(%rsp)
lea    -0x1(%rbx),%rax
lea    -0x5(%rbx),%rcx
mov    %rcx,0x170(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rax,0x138(%rsp)
and    $0xfffffffffffffffc,%rax
mov    %rax,0x160(%rsp)
add    $0x1,%rax
mov    %rax,0x158(%rsp)
mov    %rcx,%rax
mov    %rcx,0x168(%rsp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rcx
mov    %rcx,0x150(%rsp)
mov    %rbx,%rax
neg    %rax
mov    %rax,0x178(%rsp)
mov    $0x1,%r15d
mov    %rbx,0x28(%rsp)
jmp    12e2 <calculate_fgh+0x1c2>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15
cmp    0x188(%rsp),%r15
je     20fa <calculate_fgh+0xfda>
cmpl   $0x0,0x18(%rsp)
jle    1e70 <calculate_fgh+0xd50>
lea    0x1(%r15),%eax
mov    %rax,0x1d0(%rsp)
mov    0x2b8(%rsp),%rax
lea    (%rax,%r15,8),%rcx
mov    %rcx,0x148(%rsp)
mov    0x2c0(%rsp),%rcx
lea    (%rcx,%r15,8),%rcx
mov    %rcx,0xd8(%rsp)
mov    0x2c8(%rsp),%rcx
lea    (%rcx,%r15,8),%rcx
mov    %rcx,0x58(%rsp)
lea    -0x8(%rax,%r15,8),%rax
mov    %rax,0x190(%rsp)
mov    $0x1,%r12d
mov    %r15,0x1c8(%rsp)
jmp    139c <calculate_fgh+0x27c>
nop
mov    0x60(%rsp),%rax
mov    (%rax,%r15,8),%rax
mov    (%rax,%r12,8),%rax
movsd  (%rax),%xmm0
mov    0x58(%rsp),%rcx
mov    (%rcx),%rcx
mov    (%rcx,%r12,8),%rcx
movsd  %xmm0,(%rcx)
mov    0x1a8(%rsp),%rdx
movsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mov    0x140(%rsp),%rax
mov    %rax,%r12
cmp    0x1a0(%rsp),%rax
je     1e70 <calculate_fgh+0xd50>
lea    0x1(%r12),%rax
mov    %rax,0x140(%rsp)
cmpl   $0x0,0x20(%rsp)
jle    1350 <calculate_fgh+0x230>
mov    0x140(%rsp),%eax
mov    %rax,0x68(%rsp)
lea    -0x1(%r12),%rax
mov    %rax,0x198(%rsp)
mov    $0x1,%r14d
jmp    140a <calculate_fgh+0x2ea>
mov    0x60(%rsp),%rax
mov    (%rax,%r15,8),%rax
mov    (%rax,%r12,8),%rax
lea    -0x1(%r14),%rdx
movsd  -0x8(%rax,%r14,8),%xmm0
mov    0x58(%rsp),%rax
mov    %r12,%rcx
mov    (%rax),%rax
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax,%rdx,8)
add    $0x1,%r14
cmp    %r14,%rbx
je     1350 <calculate_fgh+0x230>
mov    0x0(%r13,%r15,8),%rax
mov    (%rax,%r12,8),%rax
mov    (%rax,%r14,4),%edi
mov    %edi,%eax
and    $0x3000,%eax
cmp    $0x2000,%eax
je     13fd <calculate_fgh+0x2dd>
cmp    $0x1000,%eax
jne    1d70 <calculate_fgh+0xc50>
mov    0x50(%rsp),%rcx
mov    -0x8(%rcx,%r15,8),%r11
mov    (%rcx,%r15,8),%rdi
mov    -0x8(%rdi,%r12,8),%r9
mov    (%rdi,%r12,8),%r8
mov    0x48(%rsp),%r13
mov    -0x8(%r13,%r15,8),%rax
mov    %rax,0x30(%rsp)
mov    0x0(%r13,%r15,8),%rbx
mov    -0x8(%rbx,%r12,8),%r10
mov    (%rbx,%r12,8),%rdx
movsd  -0x8(%rdx,%r14,8),%xmm0
movsd  %xmm0,0x200(%rsp)
movsd  (%rdx,%r14,8),%xmm0
movaps %xmm0,0xa0(%rsp)
mov    %r15,%rbp
mov    0x1d0(%rsp),%r15
mov    (%rcx,%r15,8),%rsi
mov    (%rsi,%r12,8),%rsi
movsd  (%rsi,%r14,8),%xmm0
movsd  %xmm0,0x1d8(%rsp)
mov    0x60(%rsp),%rcx
mov    (%rcx,%rbp,8),%rsi
mov    0x68(%rsp),%rax
mov    (%rbx,%rax,8),%rbx
movsd  (%rbx,%r14,8),%xmm0
movsd  %xmm0,0x1f0(%rsp)
mov    (%rsi,%r12,8),%rbx
movsd  -0x8(%rbx,%r14,8),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  (%rbx,%r14,8),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x8(%rbx,%r14,8),%xmm0
movsd  %xmm0,0x208(%rsp)
mov    (%r11,%r12,8),%rbx
movsd  (%rbx,%r14,8),%xmm0
movaps %xmm0,0xb0(%rsp)
movsd  0x8(%rbx,%r14,8),%xmm0
movsd  %xmm0,0x218(%rsp)
mov    -0x8(%rcx,%rbp,8),%rbx
movsd  (%r10,%r14,8),%xmm0
movaps %xmm0,0xc0(%rsp)
movsd  0x8(%r10,%r14,8),%xmm0
movsd  %xmm0,0x228(%rsp)
mov    -0x8(%rsi,%r12,8),%r10
mov    (%rdi,%rax,8),%rdi
movsd  (%rdi,%r14,8),%xmm0
movaps %xmm0,0x90(%rsp)
movsd  0x8(%rdx,%r14,8),%xmm0
movsd  %xmm0,0x80(%rsp)
mov    (%rcx,%r15,8),%rdx
mov    (%rdx,%r12,8),%rdx
movsd  -0x8(%rdx,%r14,8),%xmm0
movaps %xmm0,0x240(%rsp)
movsd  (%rdx,%r14,8),%xmm0
movsd  %xmm0,0x88(%rsp)
movsd  (%r9,%r14,8),%xmm0
movsd  %xmm0,0x1e0(%rsp)
mov    (%rbx,%r12,8),%rdx
mov    0x0(%r13,%r15,8),%rdi
mov    0x2d0(%rsp),%r13
mov    -0x8(%rdi,%r12,8),%r9
mov    (%rdi,%r12,8),%rbp
mov    (%rsi,%rax,8),%rsi
mov    0x30(%rsp),%rcx
mov    (%rcx,%r12,8),%rcx
mov    (%r11,%rax,8),%rbx
mov    0x0(%r13,%r15,8),%rdi
mov    (%rdi,%r12,8),%rdi
mov    (%rdi,%r14,4),%edi
movsd  (%rdx,%r14,8),%xmm0
movsd  %xmm0,0x210(%rsp)
movsd  -0x8(%r8,%r14,8),%xmm0
movsd  %xmm0,0x1e8(%rsp)
movsd  (%r8,%r14,8),%xmm0
movaps %xmm0,0x30(%rsp)
movsd  0x8(%r8,%r14,8),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x0(%rbp,%r14,8),%xmm0
movsd  %xmm0,0x70(%rsp)
movsd  -0x8(%rsi,%r14,8),%xmm0
movaps %xmm0,0x260(%rsp)
movsd  (%rsi,%r14,8),%xmm0
movsd  %xmm0,0x78(%rsp)
movsd  (%rcx,%r14,8),%xmm0
movsd  %xmm0,0x1f8(%rsp)
movsd  (%r10,%r14,8),%xmm0
movsd  %xmm0,0x220(%rsp)
movsd  (%rbx,%r14,8),%xmm0
movaps %xmm0,0x250(%rsp)
movsd  (%r9,%r14,8),%xmm0
movapd %xmm0,0x230(%rsp)
xor    %eax,%eax
call   1030 <isfluid@plt>
movsd  (%rsp),%xmm15
movapd 0x30(%rsp),%xmm7
movsd  0x88(%rsp),%xmm13
movapd 0x90(%rsp),%xmm14
movapd 0xc0(%rsp),%xmm11
movapd 0xb0(%rsp),%xmm12
movsd  0x10(%rsp),%xmm10
test   %eax,%eax
je     18bf <calculate_fgh+0x79f>
movapd %xmm7,%xmm0
mulsd  0x1956(%rip),%xmm0
movapd %xmm0,%xmm1
movsd  0x1d8(%rsp),%xmm5
addsd  %xmm5,%xmm1
addsd  %xmm12,%xmm1
movsd  0x108(%rsp),%xmm3
mulsd  %xmm3,%xmm1
movapd %xmm0,%xmm2
addsd  %xmm14,%xmm2
movsd  0x1e0(%rsp),%xmm8
addsd  %xmm8,%xmm2
movsd  0x100(%rsp),%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm15,%xmm0
movsd  0x1e8(%rsp),%xmm9
addsd  %xmm9,%xmm0
movsd  0xf8(%rsp),%xmm2
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm7,%xmm1
addsd  %xmm5,%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm7,%xmm3
addsd  %xmm12,%xmm3
movapd %xmm3,%xmm4
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm2
movapd %xmm7,%xmm4
subsd  %xmm5,%xmm4
movapd 0x18b4(%rip),%xmm6
andpd  %xmm6,%xmm3
movapd %xmm12,%xmm5
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 0xa0(%rsp),%xmm2
addsd  0x70(%rsp),%xmm2
movapd %xmm7,%xmm3
addsd  %xmm14,%xmm3
movapd 0x230(%rsp),%xmm4
addsd  %xmm11,%xmm4
movapd %xmm7,%xmm1
addsd  %xmm8,%xmm1
mulsd  %xmm4,%xmm1
mulsd  %xmm2,%xmm3
subsd  %xmm1,%xmm3
andpd  %xmm6,%xmm2
andpd  %xmm6,%xmm4
subsd  %xmm7,%xmm8
mulsd  %xmm4,%xmm8
movapd %xmm7,%xmm1
subsd  %xmm14,%xmm1
mulsd  %xmm2,%xmm1
subsd  %xmm8,%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm3,%xmm1
mulsd  0xe0(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  0x8(%rsp),%xmm0
addsd  %xmm13,%xmm0
movapd %xmm7,%xmm2
addsd  %xmm15,%xmm2
movapd 0x240(%rsp),%xmm4
addsd  %xmm10,%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  %xmm15,%xmm3
mulsd  %xmm0,%xmm3
subsd  %xmm9,%xmm3
mulsd  %xmm5,%xmm3
addsd  %xmm2,%xmm3
mulsd  0xf0(%rsp),%xmm3
addsd  %xmm1,%xmm3
addsd  0x1b0(%rsp),%xmm3
mulsd  0x120(%rsp),%xmm3
addsd  %xmm7,%xmm3
mov    0x148(%rsp),%rax
mov    (%rax),%rax
mov    (%rax,%r12,8),%rax
movsd  %xmm3,(%rax,%r14,8)
mov    0x1c8(%rsp),%r15
mov    0x0(%r13,%r15,8),%rax
mov    0x68(%rsp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax,%r14,4),%edi
xor    %eax,%eax
call   1030 <isfluid@plt>
test   %eax,%eax
mov    0x28(%rsp),%rbx
je     1b20 <calculate_fgh+0xa00>
movapd 0xa0(%rsp),%xmm7
movapd %xmm7,%xmm0
mulsd  0x170e(%rip),%xmm0
movapd %xmm0,%xmm1
movsd  0x70(%rsp),%xmm11
addsd  %xmm11,%xmm1
movsd  0x1f8(%rsp),%xmm10
addsd  %xmm10,%xmm1
movsd  0x108(%rsp),%xmm3
mulsd  %xmm3,%xmm1
movapd %xmm0,%xmm2
movsd  0x1f0(%rsp),%xmm6
addsd  %xmm6,%xmm2
movapd 0xc0(%rsp),%xmm5
addsd  %xmm5,%xmm2
movsd  0x100(%rsp),%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  0x80(%rsp),%xmm8
addsd  %xmm8,%xmm0
movsd  0x200(%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 0x1654(%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 0x90(%rsp),%xmm3
addsd  0x30(%rsp),%xmm3
movapd %xmm7,%xmm2
addsd  %xmm11,%xmm2
movapd 0x250(%rsp),%xmm4
addsd  0xb0(%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  0x8(%rsp),%xmm0
addsd  0x78(%rsp),%xmm0
movapd %xmm7,%xmm2
addsd  %xmm8,%xmm2
movapd 0x260(%rsp),%xmm4
addsd  0x10(%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  0x1b8(%rsp),%xmm3
mulsd  0x120(%rsp),%xmm3
addsd  %xmm7,%xmm3
mov    0xd8(%rsp),%rax
mov    (%rax),%rax
mov    (%rax,%r12,8),%rax
movsd  %xmm3,(%rax,%r14,8)
mov    0x0(%r13,%r15,8),%rax
mov    (%rax,%r12,8),%rax
mov    0x4(%rax,%r14,4),%edi
xor    %eax,%eax
call   1030 <isfluid@plt>
test   %eax,%eax
je     13fd <calculate_fgh+0x2dd>
movsd  0x8(%rsp),%xmm6
movapd %xmm6,%xmm0
mulsd  0x14c1(%rip),%xmm0
movapd %xmm0,%xmm1
movsd  0x88(%rsp),%xmm10
addsd  %xmm10,%xmm1
movsd  0x210(%rsp),%xmm12
addsd  %xmm12,%xmm1
movsd  0x108(%rsp),%xmm3
mulsd  %xmm3,%xmm1
movapd %xmm0,%xmm2
movsd  0x78(%rsp),%xmm9
addsd  %xmm9,%xmm2
movsd  0x220(%rsp),%xmm8
addsd  %xmm8,%xmm2
movsd  0x100(%rsp),%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  0x208(%rsp),%xmm5
addsd  %xmm5,%xmm0
movsd  0x10(%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 0x1409(%rip),%xmm11
andpd  %xmm11,%xmm3
subsd  %xmm6,%xmm7
mulsd  %xmm3,%xmm7
andpd  %xmm11,%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 0x30(%rsp),%xmm5
addsd  (%rsp),%xmm5
movapd %xmm6,%xmm2
addsd  %xmm10,%xmm2
movapd 0xb0(%rsp),%xmm4
addsd  0x218(%rsp),%xmm4
movapd %xmm6,%xmm1
addsd  %xmm12,%xmm1
mulsd  %xmm4,%xmm1
mulsd  %xmm5,%xmm2
subsd  %xmm1,%xmm2
movapd %xmm6,%xmm1
subsd  %xmm10,%xmm1
andpd  %xmm11,%xmm4
subsd  %xmm6,%xmm12
mulsd  %xmm4,%xmm12
andpd  %xmm11,%xmm5
mulsd  %xmm5,%xmm1
subsd  %xmm12,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  0xe8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movapd 0xa0(%rsp),%xmm4
addsd  0x80(%rsp),%xmm4
movapd %xmm6,%xmm2
addsd  %xmm9,%xmm2
movapd 0xc0(%rsp),%xmm7
addsd  0x228(%rsp),%xmm7
movapd %xmm6,%xmm0
addsd  %xmm8,%xmm0
mulsd  %xmm7,%xmm0
mulsd  %xmm4,%xmm2
subsd  %xmm0,%xmm2
movapd %xmm6,%xmm0
subsd  %xmm9,%xmm0
andpd  %xmm11,%xmm7
subsd  %xmm6,%xmm8
mulsd  %xmm7,%xmm8
andpd  %xmm11,%xmm4
mulsd  %xmm4,%xmm0
subsd  %xmm8,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
mulsd  0xe0(%rsp),%xmm0
addsd  %xmm1,%xmm0
addsd  0x1c0(%rsp),%xmm0
mulsd  0x120(%rsp),%xmm0
addsd  %xmm6,%xmm0
jmp    1da7 <calculate_fgh+0xc87>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %eax,%eax
call   1040 <getcelltype@plt>
lea    0x3(%rax),%edx
test   %eax,%eax
cmovns %eax,%edx
and    $0xfffffffc,%edx
mov    %eax,%ecx
sub    %edx,%ecx
cmp    $0x2,%ecx
je     13d1 <calculate_fgh+0x2b1>
cmp    $0x1,%ecx
jne    1db7 <calculate_fgh+0xc97>
mov    0x60(%rsp),%rax
mov    (%rax,%r15,8),%rax
mov    (%rax,%r12,8),%rax
movsd  (%rax,%r14,8),%xmm0
mov    0x58(%rsp),%rax
mov    %r12,%rcx
mov    %r14,%rdx
jmp    13f1 <calculate_fgh+0x2d1>
cmp    $0x20,%eax
jl     1dd9 <calculate_fgh+0xcb9>
mov    0x50(%rsp),%rax
mov    (%rax,%r15,8),%rax
mov    (%rax,%r12,8),%rax
movsd  (%rax,%r14,8),%xmm0
mov    0x148(%rsp),%rax
jmp    1dac <calculate_fgh+0xc8c>
cmp    $0x10,%eax
jl     1dfc <calculate_fgh+0xcdc>
mov    0x50(%rsp),%rax
mov    -0x8(%rax,%r15,8),%rax
mov    (%rax,%r12,8),%rax
movsd  (%rax,%r14,8),%xmm0
mov    0x190(%rsp),%rax
jmp    1dac <calculate_fgh+0xc8c>
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
ja     1e35 <calculate_fgh+0xd15>
mov    0x48(%rsp),%rax
mov    (%rax,%r15,8),%rax
mov    (%rax,%r12,8),%rax
movsd  (%rax,%r14,8),%xmm0
mov    0xd8(%rsp),%rax
jmp    1dac <calculate_fgh+0xc8c>
sub    %ecx,%eax
add    $0xfffffffc,%eax
cmp    $0x2,%eax
ja     13fd <calculate_fgh+0x2dd>
mov    0x48(%rsp),%rax
mov    (%rax,%r15,8),%rax
mov    -0x8(%rax,%r12,8),%rax
movsd  (%rax,%r14,8),%xmm0
mov    0xd8(%rsp),%rax
mov    0x198(%rsp),%rcx
jmp    1daf <calculate_fgh+0xc8f>
nopl   0x0(%rax)
cmpl   $0x0,0x20(%rsp)
jle    12d0 <calculate_fgh+0x1b0>
mov    0x48(%rsp),%rax
mov    (%rax,%r15,8),%rdx
mov    (%rdx),%rax
mov    0x2c0(%rsp),%rcx
mov    (%rcx,%r15,8),%rsi
mov    (%rsi),%rcx
mov    0x180(%rsp),%rdi
mov    (%rdx,%rdi,8),%rdx
mov    (%rsi,%rdi,8),%rsi
mov    $0x1,%r11d
cmpq   $0x4,0x138(%rsp)
jb     2080 <calculate_fgh+0xf60>
lea    0x8(%rcx),%rdi
mov    %rbx,%rbp
lea    (%rcx,%rbx,8),%r13
lea    0x8(%rsi),%r9
lea    (%rsi,%rbx,8),%r12
lea    0x8(%rax),%r14
lea    (%rax,%rbx,8),%r8
lea    0x8(%rdx),%rbx
mov    %rbx,0x30(%rsp)
lea    (%rdx,%rbp,8),%r10
cmp    %r12,%rdi
setb   0xc0(%rsp)
cmp    %r13,%r9
setb   0xb0(%rsp)
cmp    %r8,%rdi
setb   0x8(%rsp)
cmp    %r13,%r14
setb   0x10(%rsp)
cmp    %r10,%rdi
setb   %dil
mov    0x30(%rsp),%rbp
cmp    %r13,%rbp
setb   0xa0(%rsp)
cmp    %r8,%r9
setb   %r8b
cmp    %r12,%r14
setb   %r14b
cmp    %r10,%r9
setb   %r9b
cmp    %r12,%rbp
setb   %r12b
mov    0xb0(%rsp),%bl
test   %bl,0xc0(%rsp)
jne    2068 <calculate_fgh+0xf48>
mov    0x8(%rsp),%bl
and    0x10(%rsp),%bl
jne    2068 <calculate_fgh+0xf48>
and    0xa0(%rsp),%dil
mov    0x2d0(%rsp),%r13
jne    2070 <calculate_fgh+0xf50>
and    %r14b,%r8b
mov    0x28(%rsp),%rbx
jne    2080 <calculate_fgh+0xf60>
and    %r12b,%r9b
jne    2080 <calculate_fgh+0xf60>
cmpq   $0x4,0x170(%rsp)
jae    1f9a <calculate_fgh+0xe7a>
xor    %edi,%edi
jmp    200e <calculate_fgh+0xeee>
mov    0x150(%rsp),%rbp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups 0x8(%rax,%rdi,8),%xmm0
movups 0x18(%rax,%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(%rsi,%rdi,8)
movups %xmm1,0x18(%rsi,%rdi,8)
movups 0x28(%rax,%rdi,8),%xmm0
movups 0x38(%rax,%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(%rsi,%rdi,8)
movupd %xmm1,0x38(%rsi,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1fb0 <calculate_fgh+0xe90>
testb  $0x1,0x168(%rsp)
01
je     2048 <calculate_fgh+0xf28>
shl    $0x3,%rdi
or     $0x8,%rdi
movups (%rax,%rdi,1),%xmm0
movups 0x10(%rax,%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,(%rsi,%rdi,1)
movupd %xmm1,0x10(%rsi,%rdi,1)
mov    0x158(%rsp),%r11
mov    0x160(%rsp),%rdi
cmp    %rdi,0x138(%rsp)
je     12d0 <calculate_fgh+0x1b0>
jmp    2080 <calculate_fgh+0xf60>
mov    0x2d0(%rsp),%r13
mov    0x28(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r11,%rdi
test   $0x1,%bl
jne    20a4 <calculate_fgh+0xf84>
movsd  (%rax,%r11,8),%xmm0
movsd  %xmm0,(%rcx,%r11,8)
movsd  (%rdx,%r11,8),%xmm0
movsd  %xmm0,(%rsi,%r11,8)
lea    0x1(%r11),%rdi
not    %r11
cmp    0x178(%rsp),%r11
je     12d0 <calculate_fgh+0x1b0>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rax,%rdi,8),%xmm0
movsd  %xmm0,(%rcx,%rdi,8)
movsd  (%rdx,%rdi,8),%xmm0
movsd  %xmm0,(%rsi,%rdi,8)
movsd  0x8(%rax,%rdi,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rdi,8)
movsd  0x8(%rdx,%rdi,8),%xmm0
movsd  %xmm0,0x8(%rsi,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rbx
jne    20c0 <calculate_fgh+0xfa0>
jmp    12d0 <calculate_fgh+0x1b0>
cmpl   $0x0,0x18(%rsp)
jle    23fb <calculate_fgh+0x12db>
movslq 0x128(%rsp),%r8
mov    0x20(%rsp),%rax
lea    0x1(%rax),%ecx
mov    0x18(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x18(%rsp)
lea    -0x1(%rcx),%r9
lea    -0x5(%rcx),%rax
mov    %rax,0x80(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %r9,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0x70(%rsp)
add    $0x1,%rdx
mov    %rdx,0x68(%rsp)
mov    %rax,%rdx
mov    %rax,0x78(%rsp)
and    %rax,0x130(%rsp)
mov    %rcx,%rax
neg    %rax
mov    %rax,0x88(%rsp)
mov    $0x1,%r13d
mov    %r8,(%rsp)
mov    %r9,0x90(%rsp)
jmp    219f <calculate_fgh+0x107f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    0x18(%rsp),%r13
je     23fb <calculate_fgh+0x12db>
cmpl   $0x0,0x20(%rsp)
jle    2190 <calculate_fgh+0x1070>
mov    0x50(%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     2380 <calculate_fgh+0x1260>
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   0x30(%rsp)
cmp    %r9,%r14
setb   0x10(%rsp)
cmp    %r8,%rsi
setb   0x8(%rsp)
mov    %rax,%rsi
cmp    %r9,%rax
setb   0xa0(%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    22b0 <calculate_fgh+0x1190>
mov    0x10(%rsp),%al
and    %al,0x30(%rsp)
jne    22b0 <calculate_fgh+0x1190>
mov    0xa0(%rsp),%al
and    %al,0x8(%rsp)
jne    22b0 <calculate_fgh+0x1190>
and    %r14b,%r9b
jne    22b0 <calculate_fgh+0x1190>
and    %r15b,%r10b
mov    (%rsp),%r8
mov    0x90(%rsp),%r9
jne    2380 <calculate_fgh+0x1260>
cmpq   $0x4,0x80(%rsp)
jae    22c1 <calculate_fgh+0x11a1>
xor    %eax,%eax
jmp    232e <calculate_fgh+0x120e>
mov    (%rsp),%r8
mov    0x90(%rsp),%r9
jmp    2380 <calculate_fgh+0x1260>
mov    0x130(%rsp),%rsi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
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    22d0 <calculate_fgh+0x11b0>
testb  $0x1,0x78(%rsp)
je     2366 <calculate_fgh+0x1246>
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    0x68(%rsp),%r12
cmp    0x70(%rsp),%r9
je     2190 <calculate_fgh+0x1070>
cs nopw 0x0(%rax,%rax,1)
mov    %r12,%rsi
test   $0x1,%cl
jne    23a6 <calculate_fgh+0x1286>
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    0x88(%rsp),%r12
je     2190 <calculate_fgh+0x1070>
nopw   0x0(%rax,%rax,1)
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    23c0 <calculate_fgh+0x12a0>
jmp    2190 <calculate_fgh+0x1070>
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 = and i32 %112, 12288
switch i32 %113, label %1013 [
i32 4096, label %114
i32 8192, label %1012
]
114: ; preds = %99
%115 = load double***, double**** %32
%116 = load i32, i32* %70
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds double**, double*** %115, i64 %117
%119 = load double**, double*** %118
%120 = load i32, i32* %71
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds double*, double** %119, i64 %121
%123 = load double*, double** %122
%124 = load i32, i32* %72
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds double, double* %123, i64 %125
%127 = load double, double* %126
store double %127, double* %39
%128 = load double***, double**** %33
%129 = load i32, i32* %70
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds double**, double*** %128, i64 %130
%132 = load double**, double*** %131
%133 = load i32, i32* %71
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds double*, double** %132, i64 %134
%136 = load double*, double** %135
%137 = load i32, i32* %72
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds double, double* %136, i64 %138
%140 = load double, double* %139
store double %140, double* %40
%141 = load double***, double**** %34
%142 = load i32, i32* %70
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds double**, double*** %141, i64 %143
%145 = load double**, double*** %144
%146 = load i32, i32* %71
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds double*, double** %145, i64 %147
%149 = load double*, double** %148
%150 = load i32, i32* %72
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds double, double* %149, i64 %151
%153 = load double, double* %152
store double %153, double* %41
%154 = load double***, double**** %32
%155 = load i32, i32* %70
%156 = add nsw i32 %155, 1
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds double**, double*** %154, i64 %157
%159 = load double**, double*** %158
%160 = load i32, i32* %71
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds double*, double** %159, i64 %161
%163 = load double*, double** %162
%164 = load i32, i32* %72
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds double, double* %163, i64 %165
%167 = load double, double* %166
store double %167, double* %42
%168 = load double***, double**** %33
%169 = load i32, i32* %70
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds double**, double*** %168, i64 %170
%172 = load double**, double*** %171
%173 = load i32, i32* %71
%174 = add nsw i32 %173, 1
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds double*, double** %172, i64 %175
%177 = load double*, double** %176
%178 = load i32, i32* %72
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds double, double* %177, i64 %179
%181 = load double, double* %180
store double %181, double* %48
%182 = load double***, double**** %34
%183 = load i32, i32* %70
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds double**, double*** %182, i64 %184
%186 = load double**, double*** %185
%187 = load i32, i32* %71
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds double*, double** %186, i64 %188
%190 = load double*, double** %189
%191 = load i32, i32* %72
%192 = add nsw i32 %191, 1
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds double, double* %190, i64 %193
%195 = load double, double* %194
store double %195, double* %54
%196 = load double***, double**** %32
%197 = load i32, i32* %70
%198 = sub nsw i32 %197, 1
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds double**, double*** %196, i64 %199
%201 = load double**, double*** %200
%202 = load i32, i32* %71
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds double*, double** %201, i64 %203
%205 = load double*, double** %204
%206 = load i32, i32* %72
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds double, double* %205, i64 %207
%209 = load double, double* %208
store double %209, double* %43
%210 = load double***, double**** %33
%211 = load i32, i32* %70
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds double**, double*** %210, i64 %212
%214 = load double**, double*** %213
%215 = load i32, i32* %71
%216 = sub nsw i32 %215, 1
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds double*, double** %214, i64 %217
%219 = load double*, double** %218
%220 = load i32, i32* %72
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds double, double* %219, i64 %221
%223 = load double, double* %222
store double %223, double* %49
%224 = load double***, double**** %34
%225 = load i32, i32* %70
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds double**, double*** %224, i64 %226
%228 = load double**, double*** %227
%229 = load i32, i32* %71
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds double*, double** %228, i64 %230
%232 = load double*, double** %231
%233 = load i32, i32* %72
%234 = sub nsw i32 %233, 1
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds double, double* %232, i64 %235
%237 = load double, double* %236
store double %237, double* %55
%238 = load double***, double**** %32
%239 = load i32, i32* %70
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds double**, double*** %238, i64 %240
%242 = load double**, double*** %241
%243 = load i32, i32* %71
%244 = add nsw i32 %243, 1
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds double*, double** %242, i64 %245
%247 = load double*, double** %246
%248 = load i32, i32* %72
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds double, double* %247, i64 %249
%251 = load double, double* %250
store double %251, double* %44
%252 = load double***, double**** %33
%253 = load i32, i32* %70
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds double**, double*** %252, i64 %254
%256 = load double**, double*** %255
%257 = load i32, i32* %71
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds double*, double** %256, i64 %258
%260 = load double*, double** %259
%261 = load i32, i32* %72
%262 = add nsw i32 %261, 1
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds double, double* %260, i64 %263
%265 = load double, double* %264
store double %265, double* %50
%266 = load double***, double**** %34
%267 = load i32, i32* %70
%268 = add nsw i32 %267, 1
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds double**, double*** %266, i64 %269
%271 = load double**, double*** %270
%272 = load i32, i32* %71
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds double*, double** %271, i64 %273
%275 = load double*, double** %274
%276 = load i32, i32* %72
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds double, double* %275, i64 %277
%279 = load double, double* %278
store double %279, double* %56
%280 = load double***, double**** %32
%281 = load i32, i32* %70
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds double**, double*** %280, i64 %282
%284 = load double**, double*** %283
%285 = load i32, i32* %71
%286 = sub nsw i32 %285, 1
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds double*, double** %284, i64 %287
%289 = load double*, double** %288
%290 = load i32, i32* %72
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds double, double* %289, i64 %291
%293 = load double, double* %292
store double %293, double* %45
%294 = load double***, double**** %33
%295 = load i32, i32* %70
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds double**, double*** %294, i64 %296
%298 = load double**, double*** %297
%299 = load i32, i32* %71
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds double*, double** %298, i64 %300
%302 = load double*, double** %301
%303 = load i32, i32* %72
%304 = sub nsw i32 %303, 1
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds double, double* %302, i64 %305
%307 = load double, double* %306
store double %307, double* %51
%308 = load double***, double**** %34
%309 = load i32, i32* %70
%310 = sub nsw i32 %309, 1
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds double**, double*** %308, i64 %311
%313 = load double**, double*** %312
%314 = load i32, i32* %71
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds double*, double** %313, i64 %315
%317 = load double*, double** %316
%318 = load i32, i32* %72
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds double, double* %317, i64 %319
%321 = load double, double* %320
store double %321, double* %57
%322 = load double***, double**** %32
%323 = load i32, i32* %70
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds double**, double*** %322, i64 %324
%326 = load double**, double*** %325
%327 = load i32, i32* %71
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds double*, double** %326, i64 %328
%330 = load double*, double** %329
%331 = load i32, i32* %72
%332 = add nsw i32 %331, 1
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds double, double* %330, i64 %333
%335 = load double, double* %334
store double %335, double* %46
%336 = load double***, double**** %33
%337 = load i32, i32* %70
%338 = add nsw i32 %337, 1
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds double**, double*** %336, i64 %339
%341 = load double**, double*** %340
%342 = load i32, i32* %71
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds double*, double** %341, i64 %343
%345 = load double*, double** %344
%346 = load i32, i32* %72
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds double, double* %345, i64 %347
%349 = load double, double* %348
store double %349, double* %52
%350 = load double***, double**** %34
%351 = load i32, i32* %70
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds double**, double*** %350, i64 %352
%354 = load double**, double*** %353
%355 = load i32, i32* %71
%356 = add nsw i32 %355, 1
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds double*, double** %354, i64 %357
%359 = load double*, double** %358
%360 = load i32, i32* %72
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds double, double* %359, i64 %361
%363 = load double, double* %362
store double %363, double* %58
%364 = load double***, double**** %32
%365 = load i32, i32* %70
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds double**, double*** %364, i64 %366
%368 = load double**, double*** %367
%369 = load i32, i32* %71
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds double*, double** %368, i64 %370
%372 = load double*, double** %371
%373 = load i32, i32* %72
%374 = sub nsw i32 %373, 1
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds double, double* %372, i64 %375
%377 = load double, double* %376
store double %377, double* %47
%378 = load double***, double**** %33
%379 = load i32, i32* %70
%380 = sub nsw i32 %379, 1
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds double**, double*** %378, i64 %381
%383 = load double**, double*** %382
%384 = load i32, i32* %71
%385 = sext i32 %384 to i64
%386 = getelementptr inbounds double*, double** %383, i64 %385
%387 = load double*, double** %386
%388 = load i32, i32* %72
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds double, double* %387, i64 %389
%391 = load double, double* %390
store double %391, double* %53
%392 = load double***, double**** %34
%393 = load i32, i32* %70
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds double**, double*** %392, i64 %394
%396 = load double**, double*** %395
%397 = load i32, i32* %71
%398 = sub nsw i32 %397, 1
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds double*, double** %396, i64 %399
%401 = load double*, double** %400
%402 = load i32, i32* %72
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds double, double* %401, i64 %403
%405 = load double, double* %404
store double %405, double* %59
%406 = load double***, double**** %32
%407 = load i32, i32* %70
%408 = sub nsw i32 %407, 1
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds double**, double*** %406, i64 %409
%411 = load double**, double*** %410
%412 = load i32, i32* %71
%413 = add nsw i32 %412, 1
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds double*, double** %411, i64 %414
%416 = load double*, double** %415
%417 = load i32, i32* %72
%418 = sext i32 %417 to i64
%419 = getelementptr inbounds double, double* %416, i64 %418
%420 = load double, double* %419
store double %420, double* %60
%421 = load double***, double**** %32
%422 = load i32, i32* %70
%423 = sub nsw i32 %422, 1
%424 = sext i32 %423 to i64
%425 = getelementptr inbounds double**, double*** %421, i64 %424
%426 = load double**, double*** %425
%427 = load i32, i32* %71
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds double*, double** %426, i64 %428
%430 = load double*, double** %429
%431 = load i32, i32* %72
%432 = add nsw i32 %431, 1
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds double, double* %430, i64 %433
%435 = load double, double* %434
store double %435, double* %61
%436 = load double***, double**** %33
%437 = load i32, i32* %70
%438 = add nsw i32 %437, 1
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds double**, double*** %436, i64 %439
%441 = load double**, double*** %440
%442 = load i32, i32* %71
%443 = sub nsw i32 %442, 1
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds double*, double** %441, i64 %444
%446 = load double*, double** %445
%447 = load i32, i32* %72
%448 = sext i32 %447 to i64
%449 = getelementptr inbounds double, double* %446, i64 %448
%450 = load double, double* %449
store double %450, double* %62
%451 = load double***, double**** %33
%452 = load i32, i32* %70
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds double**, double*** %451, i64 %453
%455 = load double**, double*** %454
%456 = load i32, i32* %71
%457 = sub nsw i32 %456, 1
%458 = sext i32 %457 to i64
%459 = getelementptr inbounds double*, double** %455, i64 %458
%460 = load double*, double** %459
%461 = load i32, i32* %72
%462 = add nsw i32 %461, 1
%463 = sext i32 %462 to i64
%464 = getelementptr inbounds double, double* %460, i64 %463
%465 = load double, double* %464
store double %465, double* %63
%466 = load double***, double**** %34
%467 = load i32, i32* %70
%468 = sext i32 %467 to i64
%469 = getelementptr inbounds double**, double*** %466, i64 %468
%470 = load double**, double*** %469
%471 = load i32, i32* %71
%472 = add nsw i32 %471, 1
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds double*, double** %470, i64 %473
%475 = load double*, double** %474
%476 = load i32, i32* %72
%477 = sub nsw i32 %476, 1
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds double, double* %475, i64 %478
%480 = load double, double* %479
store double %480, double* %64
%481 = load double***, double**** %34
%482 = load i32, i32* %70
%483 = add nsw i32 %482, 1
%484 = sext i32 %483 to i64
%485 = getelementptr inbounds double**, double*** %481, i64 %484
%486 = load double**, double*** %485
%487 = load i32, i32* %71
%488 = sext i32 %487 to i64
%489 = getelementptr inbounds double*, double** %486, i64 %488
%490 = load double*, double** %489
%491 = load i32, i32* %72
%492 = sub nsw i32 %491, 1
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds double, double* %490, i64 %493
%495 = load double, double* %494
store double %495, double* %65
%496 = load i32***, i32**** %38
%497 = load i32, i32* %70
%498 = add nsw i32 %497, 1
%499 = sext i32 %498 to i64
%500 = getelementptr inbounds i32**, i32*** %496, i64 %499
%501 = load i32**, i32*** %500
%502 = load i32, i32* %71
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds i32*, i32** %501, i64 %503
%505 = load i32*, i32** %504
%506 = load i32, i32* %72
%507 = sext i32 %506 to i64
%508 = getelementptr inbounds i32, i32* %505, i64 %507
%509 = load i32, i32* %508
%510 = call i32 (i32, ...) bitcast (i32 (...)* @isfluid to i32 (i32, ...)*)(i32 %509)
%511 = icmp ne i32 %510, 0
br i1 %511, label %512, label %667
512: ; preds = %114
%513 = load double, double* %39
%514 = load double, double* %25
%515 = load double, double* %69
%516 = load double, double* %42
%517 = load double, double* %39
%518 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %517, double %516)
%519 = load double, double* %43
%520 = fadd double %518, %519
%521 = load double, double* %66
%522 = fmul double %520, %521
%523 = load double, double* %66
%524 = load double, double* %44
%525 = load double, double* %39
%526 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %525, double %524)
%527 = load double, double* %45
%528 = fadd double %526, %527
%529 = load double, double* %67
%530 = fmul double %528, %529
%531 = load double, double* %67
%532 = fmul double %530, %531
%533 = call double @llvm.fmuladd.f64(double %522, double %523, double %532)
%534 = load double, double* %46
%535 = load double, double* %39
%536 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %535, double %534)
%537 = load double, double* %47
%538 = fadd double %536, %537
%539 = load double, double* %68
%540 = fmul double %538, %539
%541 = load double, double* %68
%542 = call double @llvm.fmuladd.f64(double %540, double %541, double %533)
%543 = load double, double* %66
%544 = fmul double 2.500000e-01, %543
%545 = load double, double* %39
%546 = load double, double* %42
%547 = fadd double %545, %546
%548 = call double @pow(double %547, double 2.000000e+00)
%549 = load double, double* %43
%550 = load double, double* %39
%551 = fadd double %549, %550
%552 = call double @pow(double %551, double 2.000000e+00)
%553 = fsub double %548, %552
%554 = load double, double* %24
%555 = load double, double* %39
%556 = load double, double* %42
%557 = fadd double %555, %556
%558 = call double @llvm.fabs.f64(double %557)
%559 = load double, double* %39
%560 = load double, double* %42
%561 = fsub double %559, %560
%562 = load double, double* %43
%563 = load double, double* %39
%564 = fadd double %562, %563
%565 = call double @llvm.fabs.f64(double %564)
%566 = load double, double* %43
%567 = load double, double* %39
%568 = fsub double %566, %567
%569 = fmul double %565, %568
%570 = fneg double %569
%571 = call double @llvm.fmuladd.f64(double %558, double %561, double %570)
%572 = call double @llvm.fmuladd.f64(double %554, double %571, double %553)
%573 = fmul double %544, %572
%574 = fneg double %573
%575 = call double @llvm.fmuladd.f64(double %515, double %542, double %574)
%576 = load double, double* %67
%577 = fmul double 2.500000e-01, %576
%578 = load double, double* %40
%579 = load double, double* %52
%580 = fadd double %578, %579
%581 = load double, double* %39
%582 = load double, double* %44
%583 = fadd double %581, %582
%584 = load double, double* %49
%585 = load double, double* %62
%586 = fadd double %584, %585
%587 = load double, double* %45
%588 = load double, double* %39
%589 = fadd double %587, %588
%590 = fmul double %586, %589
%591 = fneg double %590
%592 = call double @llvm.fmuladd.f64(double %580, double %583, double %591)
%593 = load double, double* %24
%594 = load double, double* %40
%595 = load double, double* %52
%596 = fadd double %594, %595
%597 = call double @llvm.fabs.f64(double %596)
%598 = load double, double* %39
%599 = load double, double* %44
%600 = fsub double %598, %599
%601 = load double, double* %49
%602 = load double, double* %62
%603 = fadd double %601, %602
%604 = call double @llvm.fabs.f64(double %603)
%605 = load double, double* %45
%606 = load double, double* %39
%607 = fsub double %605, %606
%608 = fmul double %604, %607
%609 = fneg double %608
%610 = call double @llvm.fmuladd.f64(double %597, double %600, double %609)
%611 = call double @llvm.fmuladd.f64(double %593, double %610, double %592)
%612 = fneg double %577
%613 = call double @llvm.fmuladd.f64(double %612, double %611, double %575)
%614 = load double, double* %68
%615 = fmul double 2.500000e-01, %614
%616 = load double, double* %41
%617 = load double, double* %56
%618 = fadd double %616, %617
%619 = load double, double* %39
%620 = load double, double* %46
%621 = fadd double %619, %620
%622 = load double, double* %55
%623 = load double, double* %65
%624 = fadd double %622, %623
%625 = load double, double* %47
%626 = load double, double* %39
%627 = fadd double %625, %626
%628 = fmul double %624, %627
%629 = fneg double %628
%630 = call double @llvm.fmuladd.f64(double %618, double %621, double %629)
%631 = load double, double* %24
%632 = load double, double* %41
%633 = load double, double* %56
%634 = fadd double %632, %633
%635 = call double @llvm.fabs.f64(double %634)
%636 = load double, double* %39
%637 = load double, double* %46
%638 = fsub double %636, %637
%639 = load double, double* %55
%640 = load double, double* %65
%641 = fadd double %639, %640
%642 = call double @llvm.fabs.f64(double %641)
%643 = load double, double* %47
%644 = load double, double* %39
%645 = fsub double %643, %644
%646 = fmul double %642, %645
%647 = fneg double %646
%648 = call double @llvm.fmuladd.f64(double %635, double %638, double %647)
%649 = call double @llvm.fmuladd.f64(double %631, double %648, double %630)
%650 = fneg double %615
%651 = call double @llvm.fmuladd.f64(double %650, double %649, double %613)
%652 = load double, double* %21
%653 = fadd double %651, %652
%654 = call double @llvm.fmuladd.f64(double %514, double %653, double %513)
%655 = load double***, double**** %35
%656 = load i32, i32* %70
%657 = sext i32 %656 to i64
%658 = getelementptr inbounds double**, double*** %655, i64 %657
%659 = load double**, double*** %658
%660 = load i32, i32* %71
%661 = sext i32 %660 to i64
%662 = getelementptr inbounds double*, double** %659, i64 %661
%663 = load double*, double** %662
%664 = load i32, i32* %72
%665 = sext i32 %664 to i64
%666 = getelementptr inbounds double, double* %663, i64 %665
store double %654, double* %666
br label %667
667: ; preds = %512, %114
%668 = load i32***, i32**** %38
%669 = load i32, i32* %70
%670 = sext i32 %669 to i64
%671 = getelementptr inbounds i32**, i32*** %668, i64 %670
%672 = load i32**, i32*** %671
%673 = load i32, i32* %71
%674 = add nsw i32 %673, 1
%675 = sext i32 %674 to i64
%676 = getelementptr inbounds i32*, i32** %672, i64 %675
%677 = load i32*, i32** %676
%678 = load i32, i32* %72
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds i32, i32* %677, i64 %679
%681 = load i32, i32* %680
%682 = call i32 (i32, ...) bitcast (i32 (...)* @isfluid to i32 (i32, ...)*)(i32 %681)
%683 = icmp ne i32 %682, 0
br i1 %683, label %684, label %839
684: ; preds = %667
%685 = load double, double* %40
%686 = load double, double* %25
%687 = load double, double* %69
%688 = load double, double* %52
%689 = load double, double* %40
%690 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %689, double %688)
%691 = load double, double* %53
%692 = fadd double %690, %691
%693 = load double, double* %66
%694 = fmul double %692, %693
%695 = load double, double* %66
%696 = load double, double* %48
%697 = load double, double* %40
%698 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %697, double %696)
%699 = load double, double* %49
%700 = fadd double %698, %699
%701 = load double, double* %67
%702 = fmul double %700, %701
%703 = load double, double* %67
%704 = fmul double %702, %703
%705 = call double @llvm.fmuladd.f64(double %694, double %695, double %704)
%706 = load double, double* %50
%707 = load double, double* %40
%708 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %707, double %706)
%709 = load double, double* %51
%710 = fadd double %708, %709
%711 = load double, double* %68
%712 = fmul double %710, %711
%713 = load double, double* %68
%714 = call double @llvm.fmuladd.f64(double %712, double %713, double %705)
%715 = load double, double* %67
%716 = fmul double 2.500000e-01, %715
%717 = load double, double* %40
%718 = load double, double* %48
%719 = fadd double %717, %718
%720 = call double @pow(double %719, double 2.000000e+00)
%721 = load double, double* %49
%722 = load double, double* %40
%723 = fadd double %721, %722
%724 = call double @pow(double %723, double 2.000000e+00)
%725 = fsub double %720, %724
%726 = load double, double* %24
%727 = load double, double* %40
%728 = load double, double* %48
%729 = fadd double %727, %728
%730 = call double @llvm.fabs.f64(double %729)
%731 = load double, double* %40
%732 = load double, double* %48
%733 = fsub double %731, %732
%734 = load double, double* %49
%735 = load double, double* %40
%736 = fadd double %734, %735
%737 = call double @llvm.fabs.f64(double %736)
%738 = load double, double* %49
%739 = load double, double* %40
%740 = fsub double %738, %739
%741 = fmul double %737, %740
%742 = fneg double %741
%743 = call double @llvm.fmuladd.f64(double %730, double %733, double %742)
%744 = call double @llvm.fmuladd.f64(double %726, double %743, double %725)
%745 = fmul double %716, %744
%746 = fneg double %745
%747 = call double @llvm.fmuladd.f64(double %687, double %714, double %746)
%748 = load double, double* %66
%749 = fmul double 2.500000e-01, %748
%750 = load double, double* %39
%751 = load double, double* %44
%752 = fadd double %750, %751
%753 = load double, double* %40
%754 = load double, double* %52
%755 = fadd double %753, %754
%756 = load double, double* %43
%757 = load double, double* %60
%758 = fadd double %756, %757
%759 = load double, double* %53
%760 = load double, double* %40
%761 = fadd double %759, %760
%762 = fmul double %758, %761
%763 = fneg double %762
%764 = call double @llvm.fmuladd.f64(double %752, double %755, double %763)
%765 = load double, double* %24
%766 = load double, double* %39
%767 = load double, double* %44
%768 = fadd double %766, %767
%769 = call double @llvm.fabs.f64(double %768)
%770 = load double, double* %40
%771 = load double, double* %52
%772 = fsub double %770, %771
%773 = load double, double* %43
%774 = load double, double* %60
%775 = fadd double %773, %774
%776 = call double @llvm.fabs.f64(double %775)
%777 = load double, double* %53
%778 = load double, double* %40
%779 = fsub double %777, %778
%780 = fmul double %776, %779
%781 = fneg double %780
%782 = call double @llvm.fmuladd.f64(double %769, double %772, double %781)
%783 = call double @llvm.fmuladd.f64(double %765, double %782, double %764)
%784 = fneg double %749
%785 = call double @llvm.fmuladd.f64(double %784, double %783, double %747)
%786 = load double, double* %68
%787 = fmul double 2.500000e-01, %786
%788 = load double, double* %41
%789 = load double, double* %58
%790 = fadd double %788, %789
%791 = load double, double* %40
%792 = load double, double* %50
%793 = fadd double %791, %792
%794 = load double, double* %55
%795 = load double, double* %64
%796 = fadd double %794, %795
%797 = load double, double* %51
%798 = load double, double* %40
%799 = fadd double %797, %798
%800 = fmul double %796, %799
%801 = fneg double %800
%802 = call double @llvm.fmuladd.f64(double %790, double %793, double %801)
%803 = load double, double* %24
%804 = load double, double* %41
%805 = load double, double* %58
%806 = fadd double %804, %805
%807 = call double @llvm.fabs.f64(double %806)
%808 = load double, double* %40
%809 = load double, double* %50
%810 = fsub double %808, %809
%811 = load double, double* %55
%812 = load double, double* %64
%813 = fadd double %811, %812
%814 = call double @llvm.fabs.f64(double %813)
%815 = load double, double* %51
%816 = load double, double* %40
%817 = fsub double %815, %816
%818 = fmul double %814, %817
%819 = fneg double %818
%820 = call double @llvm.fmuladd.f64(double %807, double %810, double %819)
%821 = call double @llvm.fmuladd.f64(double %803, double %820, double %802)
%822 = fneg double %787
%823 = call double @llvm.fmuladd.f64(double %822, double %821, double %785)
%824 = load double, double* %22
%825 = fadd double %823, %824
%826 = call double @llvm.fmuladd.f64(double %686, double %825, double %685)
%827 = load double***, double**** %36
%828 = load i32, i32* %70
%829 = sext i32 %828 to i64
%830 = getelementptr inbounds double**, double*** %827, i64 %829
%831 = load double**, double*** %830
%832 = load i32, i32* %71
%833 = sext i32 %832 to i64
%834 = getelementptr inbounds double*, double** %831, i64 %833
%835 = load double*, double** %834
%836 = load i32, i32* %72
%837 = sext i32 %836 to i64
%838 = getelementptr inbounds double, double* %835, i64 %837
store double %826, double* %838
br label %839
839: ; preds = %684, %667
%840 = load i32***, i32**** %38
%841 = load i32, i32* %70
%842 = sext i32 %841 to i64
%843 = getelementptr inbounds i32**, i32*** %840, i64 %842
%844 = load i32**, i32*** %843
%845 = load i32, i32* %71
%846 = sext i32 %845 to i64
%847 = getelementptr inbounds i32*, i32** %844, i64 %846
%848 = load i32*, i32** %847
%849 = load i32, i32* %72
%850 = add nsw i32 %849, 1
%851 = sext i32 %850 to i64
%852 = getelementptr inbounds i32, i32* %848, i64 %851
%853 = load i32, i32* %852
%854 = call i32 (i32, ...) bitcast (i32 (...)* @isfluid to i32 (i32, ...)*)(i32 %853)
%855 = icmp ne i32 %854, 0
br i1 %855, label %856, label %1011
856: ; preds = %839
%857 = load double, double* %41
%858 = load double, double* %25
%859 = load double, double* %69
%860 = load double, double* %56
%861 = load double, double* %41
%862 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %861, double %860)
%863 = load double, double* %57
%864 = fadd double %862, %863
%865 = load double, double* %66
%866 = fmul double %864, %865
%867 = load double, double* %66
%868 = load double, double* %58
%869 = load double, double* %41
%870 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %869, double %868)
%871 = load double, double* %59
%872 = fadd double %870, %871
%873 = load double, double* %67
%874 = fmul double %872, %873
%875 = load double, double* %67
%876 = fmul double %874, %875
%877 = call double @llvm.fmuladd.f64(double %866, double %867, double %876)
%878 = load double, double* %54
%879 = load double, double* %41
%880 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %879, double %878)
%881 = load double, double* %55
%882 = fadd double %880, %881
%883 = load double, double* %68
%884 = fmul double %882, %883
%885 = load double, double* %68
%886 = call double @llvm.fmuladd.f64(double %884, double %885, double %877)
%887 = load double, double* %68
%888 = fmul double 2.500000e-01, %887
%889 = load double, double* %41
%890 = load double, double* %54
%891 = fadd double %889, %890
%892 = call double @pow(double %891, double 2.000000e+00)
%893 = load double, double* %55
%894 = load double, double* %41
%895 = fadd double %893, %894
%896 = call double @pow(double %895, double 2.000000e+00)
%897 = fsub double %892, %896
%898 = load double, double* %24
%899 = load double, double* %41
%900 = load double, double* %54
%901 = fadd double %899, %900
%902 = call double @llvm.fabs.f64(double %901)
%903 = load double, double* %41
%904 = load double, double* %54
%905 = fsub double %903, %904
%906 = load double, double* %55
%907 = load double, double* %41
%908 = fadd double %906, %907
%909 = call double @llvm.fabs.f64(double %908)
%910 = load double, double* %55
%911 = load double, double* %41
%912 = fsub double %910, %911
%913 = fmul double %909, %912
%914 = fneg double %913
%915 = call double @llvm.fmuladd.f64(double %902, double %905, double %914)
%916 = call double @llvm.fmuladd.f64(double %898, double %915, double %897)
%917 = fmul double %888, %916
%918 = fneg double %917
%919 = call double @llvm.fmuladd.f64(double %859, double %886, double %918)
%920 = load double, double* %66
%921 = fmul double 2.500000e-01, %920
%922 = load double, double* %39
%923 = load double, double* %46
%924 = fadd double %922, %923
%925 = load double, double* %41
%926 = load double, double* %56
%927 = fadd double %925, %926
%928 = load double, double* %43
%929 = load double, double* %61
%930 = fadd double %928, %929
%931 = load double, double* %57
%932 = load double, double* %41
%933 = fadd double %931, %932
%934 = fmul double %930, %933
%935 = fneg double %934
%936 = call double @llvm.fmuladd.f64(double %924, double %927, double %935)
%937 = load double, double* %24
%938 = load double, double* %39
%939 = load double, double* %46
%940 = fadd double %938, %939
%941 = call double @llvm.fabs.f64(double %940)
%942 = load double, double* %41
%943 = load double, double* %56
%944 = fsub double %942, %943
%945 = load double, double* %43
%946 = load double, double* %61
%947 = fadd double %945, %946
%948 = call double @llvm.fabs.f64(double %947)
%949 = load double, double* %57
%950 = load double, double* %41
%951 = fsub double %949, %950
%952 = fmul double %948, %951
%953 = fneg double %952
%954 = call double @llvm.fmuladd.f64(double %941, double %944, double %953)
%955 = call double @llvm.fmuladd.f64(double %937, double %954, double %936)
%956 = fneg double %921
%957 = call double @llvm.fmuladd.f64(double %956, double %955, double %919)
%958 = load double, double* %67
%959 = fmul double 2.500000e-01, %958
%960 = load double, double* %40
%961 = load double, double* %50
%962 = fadd double %960, %961
%963 = load double, double* %41
%964 = load double, double* %58
%965 = fadd double %963, %964
%966 = load double, double* %49
%967 = load double, double* %63
%968 = fadd double %966, %967
%969 = load double, double* %59
%970 = load double, double* %41
%971 = fadd double %969, %970
%972 = fmul double %968, %971
%973 = fneg double %972
%974 = call double @llvm.fmuladd.f64(double %962, double %965, double %973)
%975 = load double, double* %24
%976 = load double, double* %40
%977 = load double, double* %50
%978 = fadd double %976, %977
%979 = call double @llvm.fabs.f64(double %978)
%980 = load double, double* %41
%981 = load double, double* %58
%982 = fsub double %980, %981
%983 = load double, double* %49
%984 = load double, double* %63
%985 = fadd double %983, %984
%986 = call double @llvm.fabs.f64(double %985)
%987 = load double, double* %59
%988 = load double, double* %41
%989 = fsub double %987, %988
%990 = fmul double %986, %989
%991 = fneg double %990
%992 = call double @llvm.fmuladd.f64(double %979, double %982, double %991)
%993 = call double @llvm.fmuladd.f64(double %975, double %992, double %974)
%994 = fneg double %959
%995 = call double @llvm.fmuladd.f64(double %994, double %993, double %957)
%996 = load double, double* %23
%997 = fadd double %995, %996
%998 = call double @llvm.fmuladd.f64(double %858, double %997, double %857)
%999 = load double***, double**** %37
%1000 = load i32, i32* %70
%1001 = sext i32 %1000 to i64
%1002 = getelementptr inbounds double**, double*** %999, i64 %1001
%1003 = load double**, double*** %1002
%1004 = load i32, i32* %71
%1005 = sext i32 %1004 to i64
%1006 = getelementptr inbounds double*, double** %1003, i64 %1005
%1007 = load double*, double** %1006
%1008 = load i32, i32* %72
%1009 = sext i32 %1008 to i64
%1010 = getelementptr inbounds double, double* %1007, i64 %1009
store double %998, double* %1010
br label %1011
1011: ; preds = %856, %839
br label %1219
1012: ; preds = %99
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 (...)* @getcelltype 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 %1219
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 %1219
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 %1219
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 %1219
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 %1219
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 %1219
1217: ; preds = %1183
br label %1218
1218: ; preds = %1217
br label %1219
1219: ; preds = %1218, %1189, %1157, %1122, %1093, %1061, %1031, %1012, %1011
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 = %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, %654
%56 = phi i64 [ 1, %25 ], [ %655, %654 ]
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 = %654, %19
%77 = icmp slt i32 %10, 1
br i1 %77, label %808, 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 %657
102: ; preds = %625, %55
br i1 %27, label %654, 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 %654, 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 %654, label %637
230: ; preds = %57, %625
%231 = phi i64 [ 1, %57 ], [ %232, %625 ]
%232 = add nuw nsw i64 %231, 1
br i1 %27, label %625, label %233
233: ; preds = %230
%234 = and i64 %232, 4294967295
%235 = add nsw i64 %231, -1
br label %236
236: ; preds = %233, %622
%237 = phi i64 [ 1, %233 ], [ %623, %622 ]
%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 = and i32 %242, 12288
switch i32 %243, label %562 [
i32 4096, label %244
i32 8192, label %622
]
244: ; preds = %236
%245 = load double**, double*** %59
%246 = getelementptr inbounds double*, double** %245, i64 %231
%247 = load double*, double** %246
%248 = getelementptr inbounds double, double* %247, i64 %237
%249 = load double, double* %248
%250 = load double**, double*** %60
%251 = getelementptr inbounds double*, double** %250, i64 %231
%252 = load double*, double** %251
%253 = getelementptr inbounds double, double* %252, i64 %237
%254 = load double, double* %253
%255 = load double**, double*** %61
%256 = getelementptr inbounds double*, double** %255, i64 %231
%257 = load double*, double** %256
%258 = getelementptr inbounds double, double* %257, i64 %237
%259 = load double, double* %258
%260 = load double**, double*** %64
%261 = getelementptr inbounds double*, double** %260, i64 %231
%262 = load double*, double** %261
%263 = getelementptr inbounds double, double* %262, i64 %237
%264 = load double, double* %263
%265 = getelementptr inbounds double*, double** %250, i64 %234
%266 = load double*, double** %265
%267 = getelementptr inbounds double, double* %266, i64 %237
%268 = load double, double* %267
%269 = add nuw i64 %237, 1
%270 = and i64 %269, 4294967295
%271 = getelementptr inbounds double, double* %257, i64 %270
%272 = load double, double* %271
%273 = load double**, double*** %66
%274 = getelementptr inbounds double*, double** %273, i64 %231
%275 = load double*, double** %274
%276 = getelementptr inbounds double, double* %275, i64 %237
%277 = load double, double* %276
%278 = getelementptr inbounds double*, double** %250, i64 %235
%279 = load double*, double** %278
%280 = getelementptr inbounds double, double* %279, i64 %237
%281 = load double, double* %280
%282 = add nsw i64 %237, -1
%283 = getelementptr inbounds double, double* %257, i64 %282
%284 = load double, double* %283
%285 = getelementptr inbounds double*, double** %245, i64 %234
%286 = load double*, double** %285
%287 = getelementptr inbounds double, double* %286, i64 %237
%288 = load double, double* %287
%289 = getelementptr inbounds double, double* %252, i64 %270
%290 = load double, double* %289
%291 = load double**, double*** %67
%292 = getelementptr inbounds double*, double** %291, i64 %231
%293 = load double*, double** %292
%294 = getelementptr inbounds double, double* %293, i64 %237
%295 = load double, double* %294
%296 = getelementptr inbounds double*, double** %245, i64 %235
%297 = load double*, double** %296
%298 = getelementptr inbounds double, double* %297, i64 %237
%299 = load double, double* %298
%300 = getelementptr inbounds double, double* %252, i64 %282
%301 = load double, double* %300
%302 = load double**, double*** %68
%303 = getelementptr inbounds double*, double** %302, i64 %231
%304 = load double*, double** %303
%305 = getelementptr inbounds double, double* %304, i64 %237
%306 = load double, double* %305
%307 = getelementptr inbounds double, double* %247, i64 %270
%308 = load double, double* %307
%309 = load double**, double*** %69
%310 = getelementptr inbounds double*, double** %309, i64 %231
%311 = load double*, double** %310
%312 = getelementptr inbounds double, double* %311, i64 %237
%313 = load double, double* %312
%314 = getelementptr inbounds double*, double** %255, i64 %234
%315 = load double*, double** %314
%316 = getelementptr inbounds double, double* %315, i64 %237
%317 = load double, double* %316
%318 = getelementptr inbounds double, double* %247, i64 %282
%319 = load double, double* %318
%320 = load double**, double*** %70
%321 = getelementptr inbounds double*, double** %320, i64 %231
%322 = load double*, double** %321
%323 = getelementptr inbounds double, double* %322, i64 %237
%324 = load double, double* %323
%325 = getelementptr inbounds double*, double** %255, i64 %235
%326 = load double*, double** %325
%327 = getelementptr inbounds double, double* %326, i64 %237
%328 = load double, double* %327
%329 = getelementptr inbounds double*, double** %273, i64 %234
%330 = load double*, double** %329
%331 = getelementptr inbounds double, double* %330, i64 %237
%332 = load double, double* %331
%333 = getelementptr inbounds double, double* %275, i64 %270
%334 = load double, double* %333
%335 = getelementptr inbounds double*, double** %309, i64 %235
%336 = load double*, double** %335
%337 = getelementptr inbounds double, double* %336, i64 %237
%338 = load double, double* %337
%339 = getelementptr inbounds double, double* %279, i64 %270
%340 = load double, double* %339
%341 = getelementptr inbounds double, double* %315, i64 %282
%342 = load double, double* %341
%343 = getelementptr inbounds double, double* %293, i64 %282
%344 = load double, double* %343
%345 = load i32**, i32*** %71
%346 = getelementptr inbounds i32*, i32** %345, i64 %231
%347 = load i32*, i32** %346
%348 = getelementptr inbounds i32, i32* %347, i64 %237
%349 = load i32, i32* %348
%350 = tail call i32 (i32, ...) bitcast (i32 (...)* @isfluid to i32 (i32, ...)*)(i32 %349)
%351 = icmp eq i32 %350, 0
br i1 %351, label %418, label %352
352: ; preds = %244
%353 = tail call double @llvm.fmuladd.f64(double %249, double -2.000000e+00, double %264)
%354 = fadd double %353, %277
%355 = fmul double %20, %354
%356 = tail call double @llvm.fmuladd.f64(double %249, double -2.000000e+00, double %288)
%357 = fadd double %356, %299
%358 = fmul double %21, %357
%359 = fmul double %21, %358
%360 = tail call double @llvm.fmuladd.f64(double %355, double %20, double %359)
%361 = tail call double @llvm.fmuladd.f64(double %249, double -2.000000e+00, double %308)
%362 = fadd double %361, %319
%363 = fmul double %22, %362
%364 = tail call double @llvm.fmuladd.f64(double %363, double %22, double %360)
%365 = fadd double %249, %264
%366 = fmul double %365, %365
%367 = fadd double %249, %277
%368 = fmul double %367, %367
%369 = fsub double %366, %368
%370 = tail call double @llvm.fabs.f64(double %365)
%371 = fsub double %249, %264
%372 = tail call double @llvm.fabs.f64(double %367)
%373 = fsub double %277, %249
%374 = fneg double %372
%375 = fmul double %373, %374
%376 = tail call double @llvm.fmuladd.f64(double %370, double %371, double %375)
%377 = tail call double @llvm.fmuladd.f64(double %4, double %376, double %369)
%378 = fmul double %28, %377
%379 = tail call double @llvm.fmuladd.f64(double %23, double %364, double %378)
%380 = fadd double %254, %313
%381 = fadd double %249, %288
%382 = fadd double %281, %338
%383 = fadd double %249, %299
%384 = fneg double %382
%385 = fmul double %383, %384
%386 = tail call double @llvm.fmuladd.f64(double %380, double %381, double %385)
%387 = tail call double @llvm.fabs.f64(double %380)
%388 = fsub double %249, %288
%389 = tail call double @llvm.fabs.f64(double %382)
%390 = fsub double %299, %249
%391 = fneg double %389
%392 = fmul double %390, %391
%393 = tail call double @llvm.fmuladd.f64(double %387, double %388, double %392)
%394 = tail call double @llvm.fmuladd.f64(double %4, double %393, double %386)
%395 = tail call double @llvm.fmuladd.f64(double %29, double %394, double %379)
%396 = fadd double %259, %295
%397 = fadd double %249, %308
%398 = fadd double %284, %344
%399 = fadd double %249, %319
%400 = fneg double %398
%401 = fmul double %399, %400
%402 = tail call double @llvm.fmuladd.f64(double %396, double %397, double %401)
%403 = tail call double @llvm.fabs.f64(double %396)
%404 = fsub double %249, %308
%405 = tail call double @llvm.fabs.f64(double %398)
%406 = fsub double %319, %249
%407 = fneg double %405
%408 = fmul double %406, %407
%409 = tail call double @llvm.fmuladd.f64(double %403, double %404, double %408)
%410 = tail call double @llvm.fmuladd.f64(double %4, double %409, double %402)
%411 = tail call double @llvm.fmuladd.f64(double %30, double %410, double %395)
%412 = fadd double %411, %1
%413 = tail call double @llvm.fmuladd.f64(double %5, double %412, double %249)
%414 = load double**, double*** %72
%415 = getelementptr inbounds double*, double** %414, i64 %231
%416 = load double*, double** %415
%417 = getelementptr inbounds double, double* %416, i64 %237
store double %413, double* %417
br label %418
418: ; preds = %352, %244
%419 = load i32**, i32*** %58
%420 = getelementptr inbounds i32*, i32** %419, i64 %234
%421 = load i32*, i32** %420
%422 = getelementptr inbounds i32, i32* %421, i64 %237
%423 = load i32, i32* %422
%424 = tail call i32 (i32, ...) bitcast (i32 (...)* @isfluid to i32 (i32, ...)*)(i32 %423)
%425 = icmp eq i32 %424, 0
br i1 %425, label %492, label %426
426: ; preds = %418
%427 = tail call double @llvm.fmuladd.f64(double %254, double -2.000000e+00, double %313)
%428 = fadd double %427, %324
%429 = fmul double %20, %428
%430 = tail call double @llvm.fmuladd.f64(double %254, double -2.000000e+00, double %268)
%431 = fadd double %430, %281
%432 = fmul double %21, %431
%433 = fmul double %21, %432
%434 = tail call double @llvm.fmuladd.f64(double %429, double %20, double %433)
%435 = tail call double @llvm.fmuladd.f64(double %254, double -2.000000e+00, double %290)
%436 = fadd double %435, %301
%437 = fmul double %22, %436
%438 = tail call double @llvm.fmuladd.f64(double %437, double %22, double %434)
%439 = fadd double %254, %268
%440 = fmul double %439, %439
%441 = fadd double %254, %281
%442 = fmul double %441, %441
%443 = fsub double %440, %442
%444 = tail call double @llvm.fabs.f64(double %439)
%445 = fsub double %254, %268
%446 = tail call double @llvm.fabs.f64(double %441)
%447 = fsub double %281, %254
%448 = fneg double %446
%449 = fmul double %447, %448
%450 = tail call double @llvm.fmuladd.f64(double %444, double %445, double %449)
%451 = tail call double @llvm.fmuladd.f64(double %4, double %450, double %443)
%452 = fmul double %29, %451
%453 = tail call double @llvm.fmuladd.f64(double %23, double %438, double %452)
%454 = fadd double %249, %288
%455 = fadd double %254, %313
%456 = fadd double %277, %332
%457 = fadd double %254, %324
%458 = fneg double %456
%459 = fmul double %457, %458
%460 = tail call double @llvm.fmuladd.f64(double %454, double %455, double %459)
%461 = tail call double @llvm.fabs.f64(double %454)
%462 = fsub double %254, %313
%463 = tail call double @llvm.fabs.f64(double %456)
%464 = fsub double %324, %254
%465 = fneg double %463
%466 = fmul double %464, %465
%467 = tail call double @llvm.fmuladd.f64(double %461, double %462, double %466)
%468 = tail call double @llvm.fmuladd.f64(double %4, double %467, double %460)
%469 = tail call double @llvm.fmuladd.f64(double %28, double %468, double %453)
%470 = fadd double %259, %317
%471 = fadd double %254, %290
%472 = fadd double %284, %342
%473 = fadd double %254, %301
%474 = fneg double %472
%475 = fmul double %473, %474
%476 = tail call double @llvm.fmuladd.f64(double %470, double %471, double %475)
%477 = tail call double @llvm.fabs.f64(double %470)
%478 = fsub double %254, %290
%479 = tail call double @llvm.fabs.f64(double %472)
%480 = fsub double %301, %254
%481 = fneg double %479
%482 = fmul double %480, %481
%483 = tail call double @llvm.fmuladd.f64(double %477, double %478, double %482)
%484 = tail call double @llvm.fmuladd.f64(double %4, double %483, double %476)
%485 = tail call double @llvm.fmuladd.f64(double %30, double %484, double %469)
%486 = fadd double %485, %2
%487 = tail call double @llvm.fmuladd.f64(double %5, double %486, double %254)
%488 = load double**, double*** %73
%489 = getelementptr inbounds double*, double** %488, i64 %231
%490 = load double*, double** %489
%491 = getelementptr inbounds double, double* %490, i64 %237
store double %487, double* %491
br label %492
492: ; preds = %426, %418
%493 = load i32**, i32*** %58
%494 = getelementptr inbounds i32*, i32** %493, i64 %231
%495 = load i32*, i32** %494
%496 = getelementptr inbounds i32, i32* %495, i64 %270
%497 = load i32, i32* %496
%498 = tail call i32 (i32, ...) bitcast (i32 (...)* @isfluid to i32 (i32, ...)*)(i32 %497)
%499 = icmp eq i32 %498, 0
br i1 %499, label %622, label %500
500: ; preds = %492
%501 = tail call double @llvm.fmuladd.f64(double %259, double -2.000000e+00, double %295)
%502 = fadd double %501, %306
%503 = fmul double %20, %502
%504 = tail call double @llvm.fmuladd.f64(double %259, double -2.000000e+00, double %317)
%505 = fadd double %504, %328
%506 = fmul double %21, %505
%507 = fmul double %21, %506
%508 = tail call double @llvm.fmuladd.f64(double %503, double %20, double %507)
%509 = tail call double @llvm.fmuladd.f64(double %259, double -2.000000e+00, double %272)
%510 = fadd double %509, %284
%511 = fmul double %22, %510
%512 = tail call double @llvm.fmuladd.f64(double %511, double %22, double %508)
%513 = fadd double %259, %272
%514 = fmul double %513, %513
%515 = fadd double %259, %284
%516 = fmul double %515, %515
%517 = fsub double %514, %516
%518 = tail call double @llvm.fabs.f64(double %513)
%519 = fsub double %259, %272
%520 = tail call double @llvm.fabs.f64(double %515)
%521 = fsub double %284, %259
%522 = fneg double %520
%523 = fmul double %521, %522
%524 = tail call double @llvm.fmuladd.f64(double %518, double %519, double %523)
%525 = tail call double @llvm.fmuladd.f64(double %4, double %524, double %517)
%526 = fmul double %30, %525
%527 = tail call double @llvm.fmuladd.f64(double %23, double %512, double %526)
%528 = fadd double %249, %308
%529 = fadd double %259, %295
%530 = fadd double %277, %334
%531 = fadd double %259, %306
%532 = fneg double %530
%533 = fmul double %531, %532
%534 = tail call double @llvm.fmuladd.f64(double %528, double %529, double %533)
%535 = tail call double @llvm.fabs.f64(double %528)
%536 = fsub double %259, %295
%537 = tail call double @llvm.fabs.f64(double %530)
%538 = fsub double %306, %259
%539 = fneg double %537
%540 = fmul double %538, %539
%541 = tail call double @llvm.fmuladd.f64(double %535, double %536, double %540)
%542 = tail call double @llvm.fmuladd.f64(double %4, double %541, double %534)
%543 = tail call double @llvm.fmuladd.f64(double %28, double %542, double %527)
%544 = fadd double %254, %290
%545 = fadd double %259, %317
%546 = fadd double %281, %340
%547 = fadd double %259, %328
%548 = fneg double %546
%549 = fmul double %547, %548
%550 = tail call double @llvm.fmuladd.f64(double %544, double %545, double %549)
%551 = tail call double @llvm.fabs.f64(double %544)
%552 = fsub double %259, %317
%553 = tail call double @llvm.fabs.f64(double %546)
%554 = fsub double %328, %259
%555 = fneg double %553
%556 = fmul double %554, %555
%557 = tail call double @llvm.fmuladd.f64(double %551, double %552, double %556)
%558 = tail call double @llvm.fmuladd.f64(double %4, double %557, double %550)
%559 = tail call double @llvm.fmuladd.f64(double %29, double %558, double %543)
%560 = fadd double %559, %3
%561 = tail call double @llvm.fmuladd.f64(double %5, double %560, double %259)
br label %613
562: ; preds = %236
%563 = tail call i32 (i32, ...) bitcast (i32 (...)* @getcelltype to i32 (i32, ...)*)(i32 %242)
%564 = srem i32 %563, 4
switch i32 %564, label %578 [
i32 1, label %565
i32 2, label %571
]
565: ; preds = %562
%566 = load double**, double*** %61
%567 = getelementptr inbounds double*, double** %566, i64 %231
%568 = load double*, double** %567
%569 = getelementptr inbounds double, double* %568, i64 %237
%570 = load double, double* %569
br label %613
571: ; preds = %562
%572 = load double**, double*** %61
%573 = getelementptr inbounds double*, double** %572, i64 %231
%574 = load double*, double** %573
%575 = add nsw i64 %237, -1
%576 = getelementptr inbounds double, double* %574, i64 %575
%577 = load double, double* %576
br label %613
578: ; preds = %562
%579 = icmp sgt i32 %563, 31
br i1 %579, label %580, label %586
580: ; preds = %578
%581 = load double**, double*** %59
%582 = getelementptr inbounds double*, double** %581, i64 %231
%583 = load double*, double** %582
%584 = getelementptr inbounds double, double* %583, i64 %237
%585 = load double, double* %584
br label %613
586: ; preds = %578
%587 = icmp sgt i32 %563, 15
br i1 %587, label %588, label %594
588: ; preds = %586
%589 = load double**, double*** %66
%590 = getelementptr inbounds double*, double** %589, i64 %231
%591 = load double*, double** %590
%592 = getelementptr inbounds double, double* %591, i64 %237
%593 = load double, double* %592
br label %613
594: ; preds = %586
%595 = srem i32 %563, 16
%596 = add nsw i32 %595, -8
%597 = icmp ult i32 %596, 3
br i1 %597, label %598, label %604
598: ; preds = %594
%599 = load double**, double*** %60
%600 = getelementptr inbounds double*, double** %599, i64 %231
%601 = load double*, double** %600
%602 = getelementptr inbounds double, double* %601, i64 %237
%603 = load double, double* %602
br label %613
604: ; preds = %594
%605 = add nsw i32 %595, -4
%606 = icmp ult i32 %605, 3
br i1 %606, label %607, label %622
607: ; preds = %604
%608 = load double**, double*** %60
%609 = getelementptr inbounds double*, double** %608, i64 %235
%610 = load double*, double** %609
%611 = getelementptr inbounds double, double* %610, i64 %237
%612 = load double, double* %611
br label %613
613: ; preds = %500, %607, %598, %588, %580, %571, %565
%614 = phi double*** [ %74, %565 ], [ %74, %571 ], [ %72, %580 ], [ %75, %588 ], [ %73, %598 ], [ %73, %607 ], [ %74, %500 ]
%615 = phi i64 [ %231, %565 ], [ %231, %571 ], [ %231, %580 ], [ %231, %588 ], [ %231, %598 ], [ %235, %607 ], [ %231, %500 ]
%616 = phi i64 [ %237, %565 ], [ %575, %571 ], [ %237, %580 ], [ %237, %588 ], [ %237, %598 ], [ %237, %607 ], [ %237, %500 ]
%617 = phi double [ %570, %565 ], [ %577, %571 ], [ %585, %580 ], [ %593, %588 ], [ %603, %598 ], [ %612, %607 ], [ %561, %500 ]
%618 = load double**, double*** %614
%619 = getelementptr inbounds double*, double** %618, i64 %615
%620 = load double*, double** %619
%621 = getelementptr inbounds double, double* %620, i64 %616
store double %617, double* %621
br label %622
622: ; preds = %613, %236, %492, %604
%623 = add nuw nsw i64 %237, 1
%624 = icmp eq i64 %623, %38
br i1 %624, label %625, label %236
625: ; preds = %622, %230
%626 = load double**, double*** %61
%627 = getelementptr inbounds double*, double** %626, i64 %231
%628 = load double*, double** %627
%629 = load double, double* %628
%630 = load double**, double*** %74
%631 = getelementptr inbounds double*, double** %630, i64 %231
%632 = load double*, double** %631
store double %629, double* %632
%633 = getelementptr inbounds double, double* %628, i64 %31
%634 = load double, double* %633
%635 = getelementptr inbounds double, double* %632, i64 %31
store double %634, double* %635
%636 = icmp eq i64 %232, %37
br i1 %636, label %102, label %230
637: ; preds = %227, %637
%638 = phi i64 [ %652, %637 ], [ %228, %227 ]
%639 = getelementptr inbounds double, double* %106, i64 %638
%640 = load double, double* %639
%641 = getelementptr inbounds double, double* %109, i64 %638
store double %640, double* %641
%642 = getelementptr inbounds double, double* %111, i64 %638
%643 = load double, double* %642
%644 = getelementptr inbounds double, double* %113, i64 %638
store double %643, double* %644
%645 = add nuw nsw i64 %638, 1
%646 = getelementptr inbounds double, double* %106, i64 %645
%647 = load double, double* %646
%648 = getelementptr inbounds double, double* %109, i64 %645
store double %647, double* %648
%649 = getelementptr inbounds double, double* %111, i64 %645
%650 = load double, double* %649
%651 = getelementptr inbounds double, double* %113, i64 %645
store double %650, double* %651
%652 = add nuw nsw i64 %638, 2
%653 = icmp eq i64 %652, %39
br i1 %653, label %654, label %637
654: ; preds = %227, %637, %215, %102
%655 = add nuw nsw i64 %56, 1
%656 = icmp eq i64 %655, %36
br i1 %656, label %76, label %55
657: ; preds = %78, %805
%658 = phi i64 [ 1, %78 ], [ %806, %805 ]
br i1 %79, label %805, label %659
659: ; preds = %657
%660 = load double**, double*** %12
%661 = getelementptr inbounds double*, double** %660, i64 %658
%662 = load double*, double** %661
%663 = load double**, double*** %15
%664 = getelementptr inbounds double*, double** %663, i64 %658
%665 = load double*, double** %664
%666 = load double**, double*** %81
%667 = getelementptr inbounds double*, double** %666, i64 %658
%668 = load double*, double** %667
%669 = load double**, double*** %82
%670 = getelementptr inbounds double*, double** %669, i64 %658
%671 = load double*, double** %670
br i1 %91, label %774, label %672
672: ; preds = %659
%673 = getelementptr double, double* %665, i64 1
%674 = getelementptr double, double* %665, i64 %86
%675 = getelementptr double, double* %671, i64 1
%676 = getelementptr double, double* %671, i64 %86
%677 = getelementptr double, double* %662, i64 1
%678 = getelementptr double, double* %662, i64 %86
%679 = getelementptr double, double* %668, i64 1
%680 = getelementptr double, double* %668, i64 %86
%681 = icmp ult double* %673, %676
%682 = icmp ult double* %675, %674
%683 = and i1 %681, %682
%684 = icmp ult double* %673, %678
%685 = icmp ult double* %677, %674
%686 = and i1 %684, %685
%687 = or i1 %683, %686
%688 = icmp ult double* %673, %680
%689 = icmp ult double* %679, %674
%690 = and i1 %688, %689
%691 = or i1 %687, %690
%692 = icmp ult double* %675, %678
%693 = icmp ult double* %677, %676
%694 = and i1 %692, %693
%695 = or i1 %691, %694
%696 = icmp ult double* %675, %680
%697 = icmp ult double* %679, %676
%698 = and i1 %696, %697
%699 = or i1 %695, %698
br i1 %699, label %774, label %700
700: ; preds = %672
br i1 %95, label %749, label %701
701: ; preds = %700, %701
%702 = phi i64 [ %746, %701 ], [ 0, %700 ]
%703 = phi i64 [ %747, %701 ], [ 0, %700 ]
%704 = or i64 %702, 1
%705 = getelementptr inbounds double, double* %662, i64 %704
%706 = bitcast double* %705 to <2 x double>*
%707 = load <2 x double>, <2 x double>* %706
%708 = getelementptr inbounds double, double* %705, i64 2
%709 = bitcast double* %708 to <2 x double>*
%710 = load <2 x double>, <2 x double>* %709
%711 = getelementptr inbounds double, double* %665, i64 %704
%712 = bitcast double* %711 to <2 x double>*
store <2 x double> %707, <2 x double>* %712
%713 = getelementptr inbounds double, double* %711, i64 2
%714 = bitcast double* %713 to <2 x double>*
store <2 x double> %710, <2 x double>* %714
%715 = getelementptr inbounds double, double* %668, i64 %704
%716 = bitcast double* %715 to <2 x double>*
%717 = load <2 x double>, <2 x double>* %716
%718 = getelementptr inbounds double, double* %715, i64 2
%719 = bitcast double* %718 to <2 x double>*
%720 = load <2 x double>, <2 x double>* %719
%721 = getelementptr inbounds double, double* %671, i64 %704
%722 = bitcast double* %721 to <2 x double>*
store <2 x double> %717, <2 x double>* %722
%723 = getelementptr inbounds double, double* %721, i64 2
%724 = bitcast double* %723 to <2 x double>*
store <2 x double> %720, <2 x double>* %724
%725 = or i64 %702, 5
%726 = getelementptr inbounds double, double* %662, i64 %725
%727 = bitcast double* %726 to <2 x double>*
%728 = load <2 x double>, <2 x double>* %727
%729 = getelementptr inbounds double, double* %726, i64 2
%730 = bitcast double* %729 to <2 x double>*
%731 = load <2 x double>, <2 x double>* %730
%732 = getelementptr inbounds double, double* %665, i64 %725
%733 = bitcast double* %732 to <2 x double>*
store <2 x double> %728, <2 x double>* %733
%734 = getelementptr inbounds double, double* %732, i64 2
%735 = bitcast double* %734 to <2 x double>*
store <2 x double> %731, <2 x double>* %735
%736 = getelementptr inbounds double, double* %668, i64 %725
%737 = bitcast double* %736 to <2 x double>*
%738 = load <2 x double>, <2 x double>* %737
%739 = getelementptr inbounds double, double* %736, i64 2
%740 = bitcast double* %739 to <2 x double>*
%741 = load <2 x double>, <2 x double>* %740
%742 = getelementptr inbounds double, double* %671, i64 %725
%743 = bitcast double* %742 to <2 x double>*
store <2 x double> %738, <2 x double>* %743
%744 = getelementptr inbounds double, double* %742, i64 2
%745 = bitcast double* %744 to <2 x double>*
store <2 x double> %741, <2 x double>* %745
%746 = add nuw i64 %702, 8
%747 = add i64 %703, 2
%748 = icmp eq i64 %747, %96
br i1 %748, label %749, label %701
749: ; preds = %701, %700
%750 = phi i64 [ 0, %700 ], [ %746, %701 ]
br i1 %97, label %773, label %751
751: ; preds = %749
%752 = or i64 %750, 1
%753 = getelementptr inbounds double, double* %662, i64 %752
%754 = bitcast double* %753 to <2 x double>*
%755 = load <2 x double>, <2 x double>* %754
%756 = getelementptr inbounds double, double* %753, i64 2
%757 = bitcast double* %756 to <2 x double>*
%758 = load <2 x double>, <2 x double>* %757
%759 = getelementptr inbounds double, double* %665, i64 %752
%760 = bitcast double* %759 to <2 x double>*
store <2 x double> %755, <2 x double>* %760
%761 = getelementptr inbounds double, double* %759, i64 2
%762 = bitcast double* %761 to <2 x double>*
store <2 x double> %758, <2 x double>* %762
%763 = getelementptr inbounds double, double* %668, i64 %752
%764 = bitcast double* %763 to <2 x double>*
%765 = load <2 x double>, <2 x double>* %764
%766 = getelementptr inbounds double, double* %763, i64 2
%767 = bitcast double* %766 to <2 x double>*
%768 = load <2 x double>, <2 x double>* %767
%769 = getelementptr inbounds double, double* %671, i64 %752
%770 = bitcast double* %769 to <2 x double>*
store <2 x double> %765, <2 x double>* %770
%771 = getelementptr inbounds double, double* %769, i64 2
%772 = bitcast double* %771 to <2 x double>*
store <2 x double> %768, <2 x double>* %772
br label %773
773: ; preds = %749, %751
br i1 %98, label %805, label %774
774: ; preds = %672, %659, %773
%775 = phi i64 [ 1, %672 ], [ 1, %659 ], [ %93, %773 ]
%776 = xor i64 %775, -1
br i1 %100, label %777, label %785
777: ; preds = %774
%778 = getelementptr inbounds double, double* %662, i64 %775
%779 = load double, double* %778
%780 = getelementptr inbounds double, double* %665, i64 %775
store double %779, double* %780
%781 = getelementptr inbounds double, double* %668, i64 %775
%782 = load double, double* %781
%783 = getelementptr inbounds double, double* %671, i64 %775
store double %782, double* %783
%784 = add nuw nsw i64 %775, 1
br label %785
785: ; preds = %777, %774
%786 = phi i64 [ %775, %774 ], [ %784, %777 ]
%787 = icmp eq i64 %776, %101
br i1 %787, label %805, label %788
788: ; preds = %785, %788
%789 = phi i64 [ %803, %788 ], [ %786, %785 ]
%790 = getelementptr inbounds double, double* %662, i64 %789
%791 = load double, double* %790
%792 = getelementptr inbounds double, double* %665, i64 %789
store double %791, double* %792
%793 = getelementptr inbounds double, double* %668, i64 %789
%794 = load double, double* %793
%795 = getelementptr inbounds double, double* %671, i64 %789
store double %794, double* %795
%796 = add nuw nsw i64 %789, 1
%797 = getelementptr inbounds double, double* %662, i64 %796
%798 = load double, double* %797
%799 = getelementptr inbounds double, double* %665, i64 %796
store double %798, double* %799
%800 = getelementptr inbounds double, double* %668, i64 %796
%801 = load double, double* %800
%802 = getelementptr inbounds double, double* %671, i64 %796
store double %801, double* %802
%803 = add nuw nsw i64 %789, 2
%804 = icmp eq i64 %803, %86
br i1 %804, label %805, label %788
805: ; preds = %785, %788, %773, %657
%806 = add nuw nsw i64 %658, 1
%807 = icmp eq i64 %806, %85
br i1 %807, label %808, label %657
808: ; preds = %805, %76
ret void
}