#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
scalar_t__ pow(double, int);
void calculate_fg(double Re, double GX, double GY, double alpha, double dt,
                  double dx, double dy, int imax, int jmax, double **U,
                  double **V, double **F, double **G, int **Flag) {
  double uij, vij, uuj, udj, uiu, uid, viu, vid, vuj, vdj, udu, vud;
  double Dx = 1 / dx, Dy = 1 / dy;
  int i, j;
  for (i = 1; i < imax + 1; i++) {
    for (j = 1; j < jmax + 1; j++) {
      switch (Flag[i][j]) {
      case (16):
        uij = U[i][j];
        uuj = U[i + 1][j];
        udj = U[i - 1][j];
        uiu = U[i][j + 1];
        uid = U[i][j - 1];
        udu = U[i - 1][j + 1];
        vij = V[i][j];
        viu = V[i][j + 1];
        vid = V[i][j - 1];
        vuj = V[i + 1][j];
        vdj = V[i - 1][j];
        vud = V[i + 1][j - 1];
        if (Flag[i + 1][j] == 16) {
          F[i][j] = uij + dt * (1 / Re *
                                    ((uuj - 2 * uij + udj) * Dx * Dx +
                                     (uiu - 2 * uij + uid) * Dy * Dy) -
                                0.25 * Dx *
                                    (pow((uij + uuj), 2) - pow((udj + uij), 2) +
                                     alpha * (fabs(uij + uuj) * (uij - uuj) -
                                              fabs(udj + uij) * (udj - uij))) -
                                0.25 * Dy *
                                    ((vij + vuj) * (uij + uiu) -
                                     (vid + vud) * (uid + uij) +
                                     alpha * (fabs(vij + vuj) * (uij - uiu) -
                                              fabs(vid + vud) * (uid - uij))) +
                                GX);
        }
        if (Flag[i][j + 1] == 16) {
          G[i][j] = vij + dt * (1 / Re *
                                    ((vuj - 2 * vij + vdj) * Dx * Dx +
                                     (viu - 2 * vij + vid) * Dy * Dy) -
                                0.25 * Dy *
                                    (pow((vij + viu), 2) - pow((vid + vij), 2) +
                                     alpha * (fabs(vij + viu) * (vij - viu) -
                                              fabs(vid + vij) * (vid - vij))) -
                                0.25 * Dx *
                                    ((uij + uiu) * (vij + vuj) -
                                     (udj + udu) * (vdj + vij) +
                                     alpha * (fabs(uij + uiu) * (vij - vuj) -
                                              fabs(udj + udu) * (vdj - vij))) +
                                GY);
          break;
        case (1):
          G[i][j] = V[i][j];
          break;
        case (4):
          F[i - 1][j] = U[i - 1][j];
          break;
        case (8):
          F[i][j] = U[i][j];
          break;
        case (2):
          G[i][j - 1] = V[i][j - 1];
          break;
        case (9):
          G[i][j] = V[i][j];
          F[i][j] = U[i][j];
          break;
        case (5):
          G[i][j] = V[i][j];
          F[i - 1][j] = U[i - 1][j];
          break;
        case (12):
          G[i][j - 1] = V[i][j - 1];
          F[i][j] = U[i][j];
          break;
        case (6):
          F[i - 1][j] = U[i - 1][j];
          G[i][j - 1] = V[i][j - 1];
          break;
        }
      }
    }
    G[i][0] = V[i][0];
    G[i][jmax] = V[i][jmax];
  }
  for (j = 1; j < jmax + 1; j++) {
    F[0][j] = U[0][j];
    F[imax][j] = U[imax][j];
  }
}


x86 assembly (clang, -O0):
<calculate_fg>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%rsp
mov    0x10(%rbp),%rax
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)
mov    %edi,-0x3c(%rbp)
mov    %esi,-0x40(%rbp)
mov    %rdx,-0x48(%rbp)
mov    %rcx,-0x50(%rbp)
mov    %r8,-0x58(%rbp)
mov    %r9,-0x60(%rbp)
movsd  0xea0(%rip),%xmm0
divsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  0xe8b(%rip),%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movl   $0x1,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1d7c <calculate_fg+0xc6c>
movl   $0x1,-0xd8(%rbp)
mov    -0xd8(%rbp),%eax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1d12 <calculate_fg+0xc02>
mov    0x10(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0xe0(%rbp)
sub    $0xf,%eax
ja     1cf9 <calculate_fg+0xbe9>
mov    -0xe0(%rbp),%rax
lea    0xe26(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x48(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x48(%rbp),%rax
mov    -0xd4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x48(%rbp),%rax
mov    -0xd4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x48(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xd8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x48(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xd8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    -0xd4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xd8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x50(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x50(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xd8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x50(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xd8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    -0xd4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    -0xd4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    -0xd4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xd8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x10(%rbp),%rax
mov    -0xd4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
cmpl   $0x10,(%rax,%rcx,4)
jne    16e4 <calculate_fg+0x5d4>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  0xbe2(%rip),%xmm0
divsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
addsd  -0x80(%rbp),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x68(%rbp),%xmm3
addsd  %xmm3,%xmm3
subsd  %xmm3,%xmm1
addsd  -0x90(%rbp),%xmm1
ff
mulsd  -0xd0(%rbp),%xmm1
ff
mulsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  0xb71(%rip),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
addsd  -0x78(%rbp),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
mov    %rax,-0xe8(%rbp)
movsd  -0x80(%rbp),%xmm0
addsd  -0x68(%rbp),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  -0x110(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm3
ff
movsd  -0x100(%rbp),%xmm4
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm1
ff
mov    %rax,%rcx
mov    -0xe8(%rbp),%rax
sub    %rcx,%rax
cvtsi2sd %rax,%xmm6
movsd  -0x20(%rbp),%xmm5
movsd  -0x68(%rbp),%xmm7
addsd  -0x78(%rbp),%xmm7
movaps 0xae9(%rip),%xmm8
pand   %xmm8,%xmm7
movsd  -0x68(%rbp),%xmm9
subsd  -0x78(%rbp),%xmm9
movsd  -0x80(%rbp),%xmm8
addsd  -0x68(%rbp),%xmm8
movaps 0xac4(%rip),%xmm10
pand   %xmm10,%xmm8
movsd  -0x80(%rbp),%xmm10
subsd  -0x68(%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,%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movsd  0xa52(%rip),%xmm2
mulsd  -0xd0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm5
addsd  -0xa8(%rbp),%xmm5
ff
movsd  -0x68(%rbp),%xmm6
addsd  -0x88(%rbp),%xmm6
ff
movsd  -0xa0(%rbp),%xmm4
ff
addsd  -0xc0(%rbp),%xmm4
ff
movsd  -0x90(%rbp),%xmm7
ff
addsd  -0x68(%rbp),%xmm7
mulsd  %xmm7,%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm6,%xmm5
addsd  %xmm4,%xmm5
movsd  -0x20(%rbp),%xmm4
movsd  -0x70(%rbp),%xmm6
addsd  -0xa8(%rbp),%xmm6
ff
movaps 0x9df(%rip),%xmm7
pand   %xmm7,%xmm6
movsd  -0x68(%rbp),%xmm8
subsd  -0x88(%rbp),%xmm8
ff ff
movsd  -0xa0(%rbp),%xmm7
ff
addsd  -0xc0(%rbp),%xmm7
ff
movaps 0x9b4(%rip),%xmm9
pand   %xmm9,%xmm7
movsd  -0x90(%rbp),%xmm9
ff ff
subsd  -0x68(%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    -0x58(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xd8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x10,(%rax,%rcx,4)
jne    1cf4 <calculate_fg+0xbe4>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  0x8d5(%rip),%xmm0
divsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x70(%rbp),%xmm3
addsd  %xmm3,%xmm3
subsd  %xmm3,%xmm1
addsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0xd0(%rbp),%xmm1
ff
mulsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  0x85e(%rip),%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
mov    $0x2,%edi
call   1030 <pow@plt>
mov    %rax,-0x118(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0x70(%rbp),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  -0x140(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm3
ff
movsd  -0x130(%rbp),%xmm4
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm1
ff
mov    %rax,%rcx
mov    -0x118(%rbp),%rax
sub    %rcx,%rax
cvtsi2sd %rax,%xmm6
movsd  -0x20(%rbp),%xmm5
movsd  -0x70(%rbp),%xmm7
addsd  -0x98(%rbp),%xmm7
ff
movaps 0x7cd(%rip),%xmm8
pand   %xmm8,%xmm7
movsd  -0x70(%rbp),%xmm9
subsd  -0x98(%rbp),%xmm9
ff ff
movsd  -0xa0(%rbp),%xmm8
ff ff
addsd  -0x70(%rbp),%xmm8
movaps 0x7a2(%rip),%xmm10
pand   %xmm10,%xmm8
movsd  -0xa0(%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,%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movsd  0x72d(%rip),%xmm2
mulsd  -0xc8(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm5
addsd  -0x88(%rbp),%xmm5
ff
movsd  -0x70(%rbp),%xmm6
addsd  -0xa8(%rbp),%xmm6
ff
movsd  -0x80(%rbp),%xmm4
addsd  -0xb8(%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  -0x20(%rbp),%xmm4
movsd  -0x68(%rbp),%xmm6
addsd  -0x88(%rbp),%xmm6
ff
movaps 0x6bd(%rip),%xmm7
pand   %xmm7,%xmm6
movsd  -0x70(%rbp),%xmm8
subsd  -0xa8(%rbp),%xmm8
ff ff
movsd  -0x80(%rbp),%xmm7
addsd  -0xb8(%rbp),%xmm7
ff
movaps 0x695(%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  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1cf9 <calculate_fg+0xbe9>
mov    -0x50(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1cf9 <calculate_fg+0xbe9>
mov    -0x48(%rbp),%rax
mov    -0xd4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    -0xd4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1cf9 <calculate_fg+0xbe9>
mov    -0x48(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1cf9 <calculate_fg+0xbe9>
mov    -0x50(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xd8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xd8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1cf9 <calculate_fg+0xbe9>
mov    -0x50(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1cf9 <calculate_fg+0xbe9>
mov    -0x50(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
mov    -0xd4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    -0xd4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1cf9 <calculate_fg+0xbe9>
mov    -0x50(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xd8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xd8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1cf9 <calculate_fg+0xbe9>
mov    -0x48(%rbp),%rax
mov    -0xd4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    -0xd4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xd8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xd8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1cf9 <calculate_fg+0xbe9>
jmp    1cf9 <calculate_fg+0xbe9>
jmp    1cfe <calculate_fg+0xbee>
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    11aa <calculate_fg+0x9a>
mov    -0x50(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    -0x60(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
mov    -0x50(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    118c <calculate_fg+0x7c>
movl   $0x1,-0xd8(%rbp)
mov    -0xd8(%rbp),%eax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1e04 <calculate_fg+0xcf4>
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    (%rax),%rax
movslq -0xd8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xd8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    1d86 <calculate_fg+0xc76>
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calculate_fg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %r8,0x60(%rsp)
mov    %rdx,%r15
movsd  %xmm4,0xa0(%rsp)
movsd  %xmm3,0x98(%rsp)
movsd  %xmm2,0x120(%rsp)
movsd  %xmm1,0x118(%rsp)
mov    %rdi,0x58(%rsp)
test   %edi,%edi
jle    1839 <calculate_fg+0x729>
mov    0x1a0(%rsp),%r8
movsd  0xe96(%rip),%xmm1
movapd %xmm1,%xmm2
divsd  %xmm5,%xmm2
movapd %xmm1,%xmm3
divsd  %xmm6,%xmm3
divsd  %xmm0,%xmm1
movsd  %xmm1,0x88(%rsp)
movsd  0xe79(%rip),%xmm0
movsd  %xmm2,0x80(%rsp)
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x68(%rsp)
movsd  %xmm3,0x78(%rsp)
mulsd  %xmm3,%xmm0
movsd  %xmm0,0x70(%rsp)
movslq %esi,%rax
mov    %rax,0x110(%rsp)
lea    0x1(%rax),%r13d
mov    0x58(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x108(%rsp)
mov    $0x1,%r14d
lea    0xe52(%rip),%r12
mov    %rcx,0x90(%rsp)
mov    %esi,0x2c(%rsp)
mov    %r9,0x100(%rsp)
jmp    1247 <calculate_fg+0x137>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x2c(%rsp),%esi
mov    0x100(%rsp),%r9
mov    0x128(%rsp),%rbp
mov    (%rcx,%r14,8),%rax
movsd  (%rax),%xmm0
mov    (%r9,%r14,8),%rdx
movsd  %xmm0,(%rdx)
mov    0x110(%rsp),%rdi
movsd  (%rax,%rdi,8),%xmm0
movsd  %xmm0,(%rdx,%rdi,8)
mov    %rbp,%r14
cmp    0x108(%rsp),%rbp
je     1839 <calculate_fg+0x729>
test   %esi,%esi
jle    1830 <calculate_fg+0x720>
mov    0x60(%rsp),%rax
lea    (%rax,%r14,8),%r10
add    $0xfffffffffffffff8,%r10
lea    (%r9,%r14,8),%r9
lea    (%rax,%r14,8),%r11
lea    0x1(%r14),%rax
mov    %rax,0x128(%rsp)
mov    %eax,%eax
mov    %rax,0xc0(%rsp)
mov    $0x1,%ebx
mov    %r10,0xb8(%rsp)
mov    %r9,0xb0(%rsp)
mov    %r11,0xa8(%rsp)
jmp    12d0 <calculate_fg+0x1c0>
mov    (%rcx,%r14,8),%rax
movsd  -0x8(%rax,%rbx,8),%xmm0
mov    (%r9),%rax
movsd  %xmm0,-0x8(%rax,%rbx,8)
mov    (%r15,%r14,8),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    %r11,%rax
mov    %rbx,%rdx
mov    (%rax),%rax
movsd  %xmm0,(%rax,%rdx,8)
add    $0x1,%rbx
cmp    %rbx,%r13
je     1200 <calculate_fg+0xf0>
mov    (%r8,%r14,8),%rax
mov    (%rax,%rbx,4),%edx
add    $0xffffffff,%edx
cmp    $0xf,%edx
ja     12c3 <calculate_fg+0x1b3>
movslq (%r12,%rdx,4),%rdx
add    %r12,%rdx
jmp    *%rdx
mov    (%rcx,%r14,8),%rax
movsd  (%rax,%rbx,8),%xmm0
jmp    1819 <calculate_fg+0x709>
mov    (%rcx,%r14,8),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    (%r9),%rax
movsd  %xmm0,(%rax,%rbx,8)
mov    -0x8(%r15,%r14,8),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    %r10,%rax
jmp    12b8 <calculate_fg+0x1a8>
mov    -0x8(%r15,%r14,8),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    (%r10),%rax
movsd  %xmm0,(%rax,%rbx,8)
mov    (%rcx,%r14,8),%rax
lea    -0x1(%rbx),%rdx
movsd  -0x8(%rax,%rbx,8),%xmm0
mov    %r9,%rax
jmp    12bb <calculate_fg+0x1ab>
mov    (%rcx,%r14,8),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    (%r9),%rax
movsd  %xmm0,(%rax,%rbx,8)
jmp    12ac <calculate_fg+0x19c>
mov    -0x8(%r15,%r14,8),%rsi
mov    (%r15,%r14,8),%rdx
movsd  (%rdx,%rbx,8),%xmm0
movaps %xmm0,0x40(%rsp)
movsd  (%rsi,%rbx,8),%xmm0
movaps %xmm0,0x30(%rsp)
movsd  0x8(%rsi,%rbx,8),%xmm0
movsd  %xmm0,0x138(%rsp)
movsd  0x8(%rdx,%rbx,8),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    -0x8(%rcx,%r14,8),%rsi
mov    (%rcx,%r14,8),%rdi
movsd  -0x8(%rdi,%rbx,8),%xmm3
movsd  (%rdi,%rbx,8),%xmm11
movsd  0x8(%rdi,%rbx,8),%xmm0
movsd  %xmm0,0xc8(%rsp)
mov    0xc0(%rsp),%rbp
mov    (%rcx,%rbp,8),%rdi
movsd  (%rdi,%rbx,8),%xmm10
movsd  (%rsi,%rbx,8),%xmm0
movsd  %xmm0,0xd8(%rsp)
mov    (%r8,%rbp,8),%rsi
cmpl   $0x10,(%rsi,%rbx,4)
movsd  %xmm11,0x18(%rsp)
movsd  %xmm10,0xd0(%rsp)
movsd  %xmm3,0x8(%rsp)
jne    162e <calculate_fg+0x51e>
movsd  -0x8(%rdx,%rbx,8),%xmm2
movsd  %xmm2,0x20(%rsp)
mov    0xc0(%rsp),%rax
mov    (%r15,%rax,8),%rax
movsd  (%rax,%rbx,8),%xmm1
movapd 0x40(%rsp),%xmm4
movapd %xmm4,%xmm0
movapd %xmm4,%xmm5
mulsd  0xbeb(%rip),%xmm0
movapd %xmm0,%xmm4
addsd  %xmm1,%xmm4
movapd %xmm1,%xmm6
movsd  %xmm1,0x130(%rsp)
addsd  0x30(%rsp),%xmm4
movsd  0x80(%rsp),%xmm1
mulsd  %xmm1,%xmm4
addsd  0x10(%rsp),%xmm0
addsd  %xmm2,%xmm0
movsd  0x78(%rsp),%xmm2
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm1,%xmm4
addsd  %xmm0,%xmm4
movsd  %xmm4,0xe0(%rsp)
movapd %xmm5,%xmm0
addsd  %xmm6,%xmm0
movapd %xmm0,0x150(%rsp)
movsd  -0x8(%rdi,%rbx,8),%xmm1
addsd  %xmm3,%xmm1
movapd %xmm1,0xf0(%rsp)
mov    $0x2,%edi
call   1030 <pow@plt>
mov    %r15,%rbp
mov    %rax,%r15
movapd 0x40(%rsp),%xmm0
addsd  0x30(%rsp),%xmm0
movapd %xmm0,0x140(%rsp)
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  0xd0(%rsp),%xmm10
movsd  0x18(%rsp),%xmm11
mov    0xa8(%rsp),%r11
mov    0xb0(%rsp),%r9
mov    0xb8(%rsp),%r10
mov    0x1a0(%rsp),%r8
mov    0x90(%rsp),%rcx
movapd 0x40(%rsp),%xmm7
movapd %xmm7,%xmm0
subsd  0x130(%rsp),%xmm0
movapd 0xb02(%rip),%xmm8
movapd 0x140(%rsp),%xmm2
andpd  %xmm8,%xmm2
movapd 0x30(%rsp),%xmm1
subsd  %xmm7,%xmm1
mulsd  %xmm2,%xmm1
sub    %rax,%r15
movapd 0x150(%rsp),%xmm2
andpd  %xmm8,%xmm2
mulsd  %xmm2,%xmm0
xorps  %xmm2,%xmm2
cvtsi2sd %r15,%xmm2
mov    %rbp,%r15
subsd  %xmm1,%xmm0
movsd  0x98(%rsp),%xmm3
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
mulsd  0x68(%rsp),%xmm0
movsd  0xe0(%rsp),%xmm9
mulsd  0x88(%rsp),%xmm9
addsd  %xmm0,%xmm9
movapd %xmm11,%xmm0
addsd  %xmm10,%xmm0
movapd %xmm7,%xmm1
movsd  0x10(%rsp),%xmm6
addsd  %xmm6,%xmm1
movapd %xmm7,%xmm2
movsd  0x20(%rsp),%xmm4
addsd  %xmm4,%xmm2
movapd 0xf0(%rsp),%xmm5
mulsd  %xmm5,%xmm2
mulsd  %xmm0,%xmm1
subsd  %xmm2,%xmm1
andpd  %xmm8,%xmm0
andpd  %xmm8,%xmm5
movapd %xmm4,%xmm2
subsd  %xmm7,%xmm2
mulsd  %xmm5,%xmm2
movapd %xmm2,%xmm4
movapd %xmm7,%xmm2
subsd  %xmm6,%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm2
movsd  0x8(%rsp),%xmm3
addsd  %xmm1,%xmm2
mulsd  0x70(%rsp),%xmm2
addsd  %xmm9,%xmm2
addsd  0x118(%rsp),%xmm2
mulsd  0xa0(%rsp),%xmm2
addsd  %xmm7,%xmm2
mov    (%r11),%rax
movsd  %xmm2,(%rax,%rbx,8)
mov    (%r8,%r14,8),%rax
cmpl   $0x10,0x4(%rax,%rbx,4)
jne    12c3 <calculate_fg+0x1b3>
movapd %xmm11,%xmm0
mulsd  0x9ca(%rip),%xmm0
movapd %xmm0,%xmm4
addsd  %xmm10,%xmm4
addsd  0xd8(%rsp),%xmm4
movsd  0x80(%rsp),%xmm1
mulsd  %xmm1,%xmm4
movsd  0xc8(%rsp),%xmm2
addsd  %xmm2,%xmm0
movapd %xmm2,%xmm5
addsd  %xmm3,%xmm0
movsd  0x78(%rsp),%xmm2
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm1,%xmm4
addsd  %xmm0,%xmm4
movsd  %xmm4,0x20(%rsp)
movapd %xmm11,%xmm0
addsd  %xmm5,%xmm0
movapd %xmm0,0xf0(%rsp)
mov    $0x2,%edi
call   1030 <pow@plt>
mov    %rax,%rbp
movsd  0x18(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
movapd %xmm0,0xe0(%rsp)
mov    $0x2,%edi
call   1030 <pow@plt>
mov    0xa8(%rsp),%r11
mov    0xb0(%rsp),%r9
mov    0xb8(%rsp),%r10
mov    0x1a0(%rsp),%r8
mov    0x90(%rsp),%rcx
movsd  0x18(%rsp),%xmm1
movapd %xmm1,%xmm0
subsd  0xc8(%rsp),%xmm0
movapd 0x908(%rip),%xmm8
movapd 0xe0(%rsp),%xmm4
andpd  %xmm8,%xmm4
movsd  0x8(%rsp),%xmm2
subsd  %xmm1,%xmm2
movapd %xmm1,%xmm3
mulsd  %xmm4,%xmm2
movapd 0xf0(%rsp),%xmm1
andpd  %xmm8,%xmm1
mulsd  %xmm1,%xmm0
sub    %rax,%rbp
subsd  %xmm2,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %rbp,%xmm1
movsd  0x98(%rsp),%xmm9
mulsd  %xmm9,%xmm0
addsd  %xmm1,%xmm0
mulsd  0x70(%rsp),%xmm0
movsd  0x20(%rsp),%xmm7
mulsd  0x88(%rsp),%xmm7
addsd  %xmm0,%xmm7
movapd 0x40(%rsp),%xmm4
addsd  0x10(%rsp),%xmm4
movapd %xmm3,%xmm1
movsd  0xd0(%rsp),%xmm2
addsd  %xmm2,%xmm1
movapd 0x30(%rsp),%xmm5
addsd  0x138(%rsp),%xmm5
movapd %xmm3,%xmm0
movsd  0xd8(%rsp),%xmm6
addsd  %xmm6,%xmm0
mulsd  %xmm5,%xmm0
mulsd  %xmm4,%xmm1
subsd  %xmm0,%xmm1
movapd %xmm3,%xmm0
subsd  %xmm2,%xmm0
andpd  %xmm8,%xmm5
subsd  %xmm3,%xmm6
mulsd  %xmm5,%xmm6
andpd  %xmm8,%xmm4
mulsd  %xmm4,%xmm0
subsd  %xmm6,%xmm0
mulsd  %xmm9,%xmm0
addsd  %xmm1,%xmm0
mulsd  0x68(%rsp),%xmm0
addsd  %xmm7,%xmm0
addsd  0x120(%rsp),%xmm0
mulsd  0xa0(%rsp),%xmm0
addsd  %xmm3,%xmm0
mov    %r9,%rax
jmp    12b8 <calculate_fg+0x1a8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x1(%r14),%rbp
jmp    1214 <calculate_fg+0x104>
test   %esi,%esi
jle    1a43 <calculate_fg+0x933>
mov    (%r15),%rax
mov    0x60(%rsp),%rbp
mov    0x0(%rbp),%rcx
movslq 0x58(%rsp),%rdi
mov    (%r15,%rdi,8),%rdx
mov    0x0(%rbp,%rdi,8),%r8
mov    %esi,%edi
lea    0x1(%rdi),%r10
mov    $0x1,%ebp
cmp    $0x4,%esi
jae    18dc <calculate_fg+0x7cc>
mov    %rbp,%rdi
not    %rdi
test   $0x1,%r10b
jne    1890 <calculate_fg+0x780>
movsd  (%rax,%rbp,8),%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
movsd  (%rdx,%rbp,8),%xmm0
movsd  %xmm0,(%r8,%rbp,8)
add    $0x1,%rbp
add    %r10,%rdi
je     1a43 <calculate_fg+0x933>
nopl   0x0(%rax)
movsd  (%rax,%rbp,8),%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
movsd  (%rdx,%rbp,8),%xmm0
movsd  %xmm0,(%r8,%rbp,8)
movsd  0x8(%rax,%rbp,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rbp,8)
movsd  0x8(%rdx,%rbp,8),%xmm0
movsd  %xmm0,0x8(%r8,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r10
jne    18a0 <calculate_fg+0x790>
jmp    1a43 <calculate_fg+0x933>
mov    %rdi,0x8(%rsp)
lea    0x8(%rcx),%rdi
lea    (%rcx,%r10,8),%rbx
lea    0x8(%r8),%r11
lea    (%r8,%r10,8),%r13
lea    0x8(%rax),%r12
lea    (%rax,%r10,8),%r9
lea    0x8(%rdx),%r15
lea    (%rdx,%r10,8),%r14
cmp    %r13,%rdi
setb   0x40(%rsp)
cmp    %rbx,%r11
setb   0x30(%rsp)
cmp    %r9,%rdi
setb   %sil
cmp    %rbx,%r12
setb   0x18(%rsp)
cmp    %r14,%rdi
setb   %dil
cmp    %rbx,%r15
setb   0x10(%rsp)
cmp    %r9,%r11
setb   %r9b
cmp    %r13,%r12
setb   %r12b
cmp    %r14,%r11
setb   %r11b
cmp    %r13,%r15
setb   %r13b
mov    0x30(%rsp),%bl
test   %bl,0x40(%rsp)
jne    186b <calculate_fg+0x75b>
and    0x18(%rsp),%sil
jne    186b <calculate_fg+0x75b>
and    0x10(%rsp),%dil
jne    186b <calculate_fg+0x75b>
and    %r12b,%r9b
jne    186b <calculate_fg+0x75b>
and    %r13b,%r11b
jne    186b <calculate_fg+0x75b>
mov    0x8(%rsp),%rsi
mov    %esi,%ebp
and    $0xfffffffc,%ebp
lea    -0x4(%rbp),%rdi
mov    %rdi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rdi,%rdi
je     1a5e <calculate_fg+0x94e>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
mov    $0x1,%ebx
nop
movups (%rax,%rbx,8),%xmm0
movups 0x10(%rax,%rbx,8),%xmm1
movups %xmm0,(%rcx,%rbx,8)
movups %xmm1,0x10(%rcx,%rbx,8)
movups (%rdx,%rbx,8),%xmm0
movups 0x10(%rdx,%rbx,8),%xmm1
movups %xmm0,(%r8,%rbx,8)
movups %xmm1,0x10(%r8,%rbx,8)
movups 0x20(%rax,%rbx,8),%xmm0
movups 0x30(%rax,%rbx,8),%xmm1
movups %xmm0,0x20(%rcx,%rbx,8)
movups %xmm1,0x30(%rcx,%rbx,8)
movupd 0x20(%rdx,%rbx,8),%xmm0
movupd 0x30(%rdx,%rbx,8),%xmm1
movupd %xmm0,0x20(%r8,%rbx,8)
movupd %xmm1,0x30(%r8,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rdi
jne    19b0 <calculate_fg+0x8a0>
test   $0x1,%r9b
je     1a3e <calculate_fg+0x92e>
movups (%rax,%rbx,8),%xmm0
movups 0x10(%rax,%rbx,8),%xmm1
movups %xmm0,(%rcx,%rbx,8)
movups %xmm1,0x10(%rcx,%rbx,8)
movupd (%rdx,%rbx,8),%xmm0
movupd 0x10(%rdx,%rbx,8),%xmm1
movupd %xmm0,(%r8,%rbx,8)
movupd %xmm1,0x10(%r8,%rbx,8)
cmp    %rbp,%rsi
jne    1a55 <calculate_fg+0x945>
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
or     $0x1,%rbp
jmp    186b <calculate_fg+0x75b>
mov    $0x1,%ebx
test   $0x1,%r9b
jne    1a14 <calculate_fg+0x904>
jmp    1a3e <calculate_fg+0x92e>

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

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