#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);
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 i;
  int j;
  double u_frd_sum_i;
  double u_bkd_sum_i;
  double v_frd_sum_i;
  double v_bkd_sum_i;
  double u_frd_sum_j;
  double u_bkd_sum_j;
  double v_frd_sum_j;
  double v_bkd_sum_j;
  double d2ux;
  double d2uy;
  double du2x;
  double duvy;
  double d2vx;
  double d2vy;
  double duvx;
  double dv2y;
  for (j = 1; j < jmax + 1; j++) {
    F[0][j] = U[0][j];
    F[imax][j] = U[imax][j];
  }
  for (i = 1; i < imax + 1; i++) {
    G[i][0] = V[i][0];
    G[i][jmax] = V[i][jmax];
  }
  for (i = 1; i < imax; i++) {
    for (j = 1; j < jmax; j++) {
      u_frd_sum_i = (U[i][j] + U[i + 1][j]) / 2;
      u_frd_sum_j = (U[i][j] + U[i][j + 1]) / 2;
      u_bkd_sum_i = (U[i][j] + U[i - 1][j]) / 2;
      u_bkd_sum_j = (U[i][j] + U[i][j - 1]) / 2;
      v_frd_sum_i = (V[i][j] + V[i + 1][j]) / 2;
      v_frd_sum_j = (V[i][j] + V[i][j + 1]) / 2;
      v_bkd_sum_i = (V[i][j] + V[i - 1][j]) / 2;
      v_bkd_sum_j = (V[i][j] + V[i][j - 1]) / 2;
      d2ux = (U[i - 1][j] - 2 * U[i][j] + U[i + 1][j]) / (dx * dx);
      d2uy = (U[i][j - 1] - 2 * U[i][j] + U[i][j + 1]) / (dy * dy);
      du2x = (u_frd_sum_i * u_frd_sum_i - u_bkd_sum_i * u_bkd_sum_i) / dx +
             alpha *
                 (fabs(u_frd_sum_i) * (U[i][j] - U[i + 1][j]) / 2 -
                  fabs(u_bkd_sum_i) * (U[i - 1][j] - U[i][j]) / 2) /
                 dx;
      duvy = (v_frd_sum_i * u_frd_sum_j -
              (V[i][j - 1] + V[i + 1][j - 1]) / 2 * u_bkd_sum_j) /
                 dy +
             alpha *
                 (fabs(v_frd_sum_i) * (U[i][j] - U[i][j - 1]) / 2 -
                  fabs(V[i][j - 1] + V[i + 1][j - 1]) *
                      (U[i][j - 1] - U[i][j]) / 4) /
                 dy;
      d2vx = (V[i - 1][j] - 2 * V[i][j] + V[i + 1][j]) / (dx * dx);
      d2vy = (V[i][j - 1] - 2 * V[i][j] + V[i][j + 1]) / (dy * dy);
      dv2y = (v_frd_sum_j * v_frd_sum_j - v_bkd_sum_j * v_bkd_sum_j) / dy +
             alpha *
                 (fabs(v_frd_sum_j) * (V[i][j] - V[i][j + 1]) / 2 -
                  fabs(v_bkd_sum_j) * (V[i][j - 1] - V[i][j]) / 2) /
                 dy;
      duvx = (u_frd_sum_j * v_frd_sum_i -
              (U[i - 1][j] + U[i - 1][j + 1]) / 2 * v_bkd_sum_i) /
                 dx +
             alpha *
                 (fabs(u_frd_sum_j) * (V[i][j] - V[i + 1][j]) / 2 -
                  fabs(U[i - 1][j] + U[i - 1][j + 1]) *
                      (V[i - 1][j] - V[i][j]) / 4) /
                 dx;
      F[i][j] = U[i][j] + dt * ((d2ux + d2uy) / Re - du2x - duvy + GX);
      G[i][j] = V[i][j] + dt * ((d2vx + d2vy) / Re - duvx - dv2y + GY);
    }
    j = jmax;
    u_frd_sum_i = (U[i][j] + U[i + 1][j]) / 2;
    u_frd_sum_j = (U[i][j] + U[i][j + 1]) / 2;
    u_bkd_sum_i = (U[i][j] + U[i - 1][j]) / 2;
    u_bkd_sum_j = (U[i][j] + U[i][j - 1]) / 2;
    v_frd_sum_i = (V[i][j] + V[i + 1][j]) / 2;
    d2ux = (U[i - 1][j] - 2 * U[i][j] + U[i + 1][j]) / (dx * dx);
    d2uy = (U[i][j - 1] - 2 * U[i][j] + U[i][j + 1]) / (dy * dy);
    du2x = (u_frd_sum_i * u_frd_sum_i - u_bkd_sum_i * u_bkd_sum_i) / dx +
           alpha *
               (fabs(u_frd_sum_i) * (U[i][j] - U[i + 1][j]) / 2 -
                fabs(u_bkd_sum_i) * (U[i - 1][j] - U[i][j]) / 2) /
               dx;
    duvy = (v_frd_sum_i * u_frd_sum_j -
            (V[i][j - 1] + V[i + 1][j - 1]) / 2 * u_bkd_sum_j) /
               dy +
           alpha *
               (fabs(v_frd_sum_i) * (U[i][j] - U[i][j - 1]) / 2 -
                fabs(V[i][j - 1] + V[i + 1][j - 1]) * (U[i][j - 1] - U[i][j]) /
                    4) /
               dy;
    F[i][j] = U[i][j] + dt * ((d2ux + d2uy) / Re - du2x - duvy + GX);
  }
  i = imax;
  for (j = 1; j < jmax; j++) {
    u_frd_sum_j = (U[i][j] + U[i][j + 1]) / 2;
    v_frd_sum_i = (V[i][j] + V[i + 1][j]) / 2;
    v_frd_sum_j = (V[i][j] + V[i][j + 1]) / 2;
    v_bkd_sum_i = (V[i][j] + V[i - 1][j]) / 2;
    v_bkd_sum_j = (V[i][j] + V[i][j - 1]) / 2;
    d2vx = (V[i - 1][j] - 2 * V[i][j] + V[i + 1][j]) / (dx * dx);
    d2vy = (V[i][j - 1] - 2 * V[i][j] + V[i][j + 1]) / (dy * dy);
    dv2y = (v_frd_sum_j * v_frd_sum_j - v_bkd_sum_j * v_bkd_sum_j) / dy +
           alpha *
               (fabs(v_frd_sum_j) * (V[i][j] - V[i][j + 1]) / 2 -
                fabs(v_bkd_sum_j) * (V[i][j - 1] - V[i][j]) / 2) /
               dy;
    duvx = (u_frd_sum_j * v_frd_sum_i -
            (U[i - 1][j] + U[i - 1][j + 1]) / 2 * v_bkd_sum_i) /
               dx +
           alpha *
               (fabs(u_frd_sum_j) * (V[i][j] - V[i + 1][j]) / 2 -
                fabs(U[i - 1][j] + U[i - 1][j + 1]) * (V[i - 1][j] - V[i][j]) /
                    4) /
               dx;
    G[i][j] = V[i][j] + dt * ((d2vx + d2vy) / Re - duvx - dv2y + GY);
  }
}


x86 assembly (clang, -O0):
<calculate_fg>:
push   %rbp
mov    %rsp,%rbp
sub    $0x68,%rsp
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)
movl   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    11b1 <calculate_fg+0xb1>
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    (%rax),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1148 <calculate_fg+0x48>
movl   $0x1,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1221 <calculate_fg+0x121>
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    11b8 <calculate_fg+0xb8>
movl   $0x1,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    2086 <calculate_fg+0xf86>
movl   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1b9b <calculate_fg+0xa9b>
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x1d8a(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x1d4a(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x1d07(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x1cc7(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x1c84(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x1c44(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x1c01(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x1bbe(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm1
mulsd  -0x30(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  -0x38(%rbp),%xmm1
mulsd  -0x38(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x30(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movaps 0x1aa3(%rip),%xmm3
pand   %xmm3,%xmm2
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x48(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
movsd  0x1a5c(%rip),%xmm3
divsd  %xmm3,%xmm2
movsd  -0x78(%rbp),%xmm3
movaps 0x1a54(%rip),%xmm4
pand   %xmm4,%xmm3
mov    -0x48(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm3
movsd  0x1a0d(%rip),%xmm4
divsd  %xmm4,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  -0x30(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0x19a2(%rip),%xmm3
divsd  %xmm3,%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm2
movaps 0x1969(%rip),%xmm3
pand   %xmm3,%xmm2
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
movsd  0x1922(%rip),%xmm3
divsd  %xmm3,%xmm2
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm3
movaps 0x18e6(%rip),%xmm4
pand   %xmm4,%xmm3
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm3
movsd  0x1897(%rip),%xmm4
divsd  %xmm4,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  -0x38(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm1
mulsd  -0x30(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  -0x38(%rbp),%xmm1
mulsd  -0x38(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
movsd  -0xa0(%rbp),%xmm2
ff
movaps 0x1764(%rip),%xmm3
pand   %xmm3,%xmm2
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
movsd  0x171d(%rip),%xmm3
divsd  %xmm3,%xmm2
movsd  -0xa8(%rbp),%xmm3
ff
movaps 0x1712(%rip),%xmm4
pand   %xmm4,%xmm3
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm3
movsd  0x16cb(%rip),%xmm4
divsd  %xmm4,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  -0x38(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x48(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0x1660(%rip),%xmm3
divsd  %xmm3,%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x30(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm2
ff
movaps 0x1624(%rip),%xmm3
pand   %xmm3,%xmm2
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
movsd  0x15dd(%rip),%xmm3
divsd  %xmm3,%xmm2
mov    -0x48(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x48(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm3
movaps 0x15a1(%rip),%xmm4
pand   %xmm4,%xmm3
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm3
movsd  0x1552(%rip),%xmm4
divsd  %xmm4,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  -0x30(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x28(%rbp),%xmm0
movsd  -0xb0(%rbp),%xmm2
ff
addsd  -0xb8(%rbp),%xmm2
ff
divsd  -0x8(%rbp),%xmm2
subsd  -0xc0(%rbp),%xmm2
ff
subsd  -0xc8(%rbp),%xmm2
ff
addsd  -0x10(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x28(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm2
ff
addsd  -0xd8(%rbp),%xmm2
ff
divsd  -0x8(%rbp),%xmm2
subsd  -0xe0(%rbp),%xmm2
ff
subsd  -0xe8(%rbp),%xmm2
ff
addsd  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    123b <calculate_fg+0x13b>
mov    -0x40(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x1430(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x13f0(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x13ad(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x136d(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x132a(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm1
mulsd  -0x30(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  -0x38(%rbp),%xmm1
mulsd  -0x38(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x30(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movaps 0x1212(%rip),%xmm3
pand   %xmm3,%xmm2
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x48(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
movsd  0x11cb(%rip),%xmm3
divsd  %xmm3,%xmm2
movsd  -0x78(%rbp),%xmm3
movaps 0x11c3(%rip),%xmm4
pand   %xmm4,%xmm3
mov    -0x48(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm3
movsd  0x117c(%rip),%xmm4
divsd  %xmm4,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  -0x30(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0x1111(%rip),%xmm3
divsd  %xmm3,%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm2
movaps 0x10d8(%rip),%xmm3
pand   %xmm3,%xmm2
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
movsd  0x1091(%rip),%xmm3
divsd  %xmm3,%xmm2
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm3
movaps 0x1055(%rip),%xmm4
pand   %xmm4,%xmm3
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm3
movsd  0x1006(%rip),%xmm4
divsd  %xmm4,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  -0x38(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x28(%rbp),%xmm0
movsd  -0xb0(%rbp),%xmm2
ff
addsd  -0xb8(%rbp),%xmm2
ff
divsd  -0x8(%rbp),%xmm2
subsd  -0xc0(%rbp),%xmm2
ff
subsd  -0xc8(%rbp),%xmm2
ff
addsd  -0x10(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1228 <calculate_fg+0x128>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x64(%rbp)
movl   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    259f <calculate_fg+0x149f>
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xf32(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xeef(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xeaf(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xe6c(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xe29(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm1
mulsd  -0x30(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  -0x38(%rbp),%xmm1
mulsd  -0x38(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
movsd  -0xa0(%rbp),%xmm2
ff
movaps 0xcff(%rip),%xmm3
pand   %xmm3,%xmm2
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
movsd  0xcb8(%rip),%xmm3
divsd  %xmm3,%xmm2
movsd  -0xa8(%rbp),%xmm3
ff
movaps 0xcad(%rip),%xmm4
pand   %xmm4,%xmm3
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm3
movsd  0xc66(%rip),%xmm4
divsd  %xmm4,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  -0x38(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x48(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0xbfb(%rip),%xmm3
divsd  %xmm3,%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x30(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm2
ff
movaps 0xbbf(%rip),%xmm3
pand   %xmm3,%xmm2
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
movsd  0xb78(%rip),%xmm3
divsd  %xmm3,%xmm2
mov    -0x48(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x48(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm3
movaps 0xb3c(%rip),%xmm4
pand   %xmm4,%xmm3
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm3
movsd  0xaed(%rip),%xmm4
divsd  %xmm4,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  -0x30(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x28(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm2
ff
addsd  -0xd8(%rbp),%xmm2
ff
divsd  -0x8(%rbp),%xmm2
subsd  -0xe0(%rbp),%xmm2
ff
subsd  -0xe8(%rbp),%xmm2
ff
addsd  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    2093 <calculate_fg+0xf93>
add    $0x68,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calculate_fg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %esi,%r15d
movapd %xmm6,%xmm9
movapd %xmm5,%xmm6
movapd %xmm0,%xmm15
movslq %edi,%r11
mov    %esi,%r12d
test   %esi,%esi
mov    %r15,-0x70(%rsp)
mov    %r8,0x68(%rsp)
mov    %r9,-0x68(%rsp)
jle    131f <calculate_fg+0x21f>
mov    %rdi,-0x20(%rsp)
mov    %rcx,-0x10(%rsp)
mov    (%rdx),%r10
mov    (%r8),%r14
mov    (%rdx,%r11,8),%rbp
mov    (%r8,%r11,8),%rbx
lea    0x1(%r15),%r13d
lea    0x1(%r12),%r9
mov    $0x1,%eax
cmp    $0x4,%r15d
jb     1332 <calculate_fg+0x232>
mov    %r13d,-0x60(%rsp)
mov    %r11,0x8(%rsp)
mov    %rdx,-0x78(%rsp)
mov    %r12,-0x80(%rsp)
lea    0x8(%r14),%rsi
lea    (%r14,%r9,8),%rdx
lea    0x8(%rbx),%r15
lea    (%rbx,%r9,8),%r13
lea    0x8(%r10),%r12
lea    (%r10,%r9,8),%r11
lea    0x8(%rbp),%rcx
lea    0x0(,%r9,8),%rdi
add    %rbp,%rdi
cmp    %r13,%rsi
setb   -0x30(%rsp)
cmp    %rdx,%r15
setb   -0x40(%rsp)
cmp    %r11,%rsi
setb   %r8b
cmp    %rdx,%r12
setb   0x30(%rsp)
cmp    %rdi,%rsi
setb   %sil
cmp    %rdx,%rcx
mov    %rcx,%rdx
setb   0x20(%rsp)
cmp    %r11,%r15
setb   %cl
cmp    %r13,%r12
setb   %r11b
cmp    %rdi,%r15
setb   %r15b
cmp    %r13,%rdx
setb   %dil
mov    -0x40(%rsp),%dl
test   %dl,-0x30(%rsp)
jne    216c <calculate_fg+0x106c>
mov    %r11d,%edx
and    0x30(%rsp),%r8b
mov    -0x80(%rsp),%r12
mov    0x8(%rsp),%r11
mov    -0x60(%rsp),%r13d
jne    1328 <calculate_fg+0x228>
and    0x20(%rsp),%sil
jne    1328 <calculate_fg+0x228>
and    %dl,%cl
jne    1328 <calculate_fg+0x228>
and    %dil,%r15b
mov    -0x78(%rsp),%rdx
mov    -0x70(%rsp),%r15
jne    1332 <calculate_fg+0x232>
mov    %r12d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rsi
mov    %rsi,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
test   %rsi,%rsi
je     215c <calculate_fg+0x105c>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edi,%edi
xchg   %ax,%ax
movups 0x8(%r10,%rdi,8),%xmm0
movups 0x18(%r10,%rdi,8),%xmm7
movups %xmm0,0x8(%r14,%rdi,8)
movups %xmm7,0x18(%r14,%rdi,8)
movups 0x8(%rbp,%rdi,8),%xmm0
movups 0x18(%rbp,%rdi,8),%xmm7
movups %xmm0,0x8(%rbx,%rdi,8)
movups %xmm7,0x18(%rbx,%rdi,8)
movups 0x28(%r10,%rdi,8),%xmm0
movups 0x38(%r10,%rdi,8),%xmm7
movups %xmm0,0x28(%r14,%rdi,8)
movups %xmm7,0x38(%r14,%rdi,8)
movupd 0x28(%rbp,%rdi,8),%xmm0
movupd 0x38(%rbp,%rdi,8),%xmm7
movupd %xmm0,0x28(%rbx,%rdi,8)
movupd %xmm7,0x38(%rbx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1270 <calculate_fg+0x170>
test   $0x1,%cl
je     1310 <calculate_fg+0x210>
shl    $0x3,%rdi
or     $0x8,%rdi
movups (%r10,%rdi,1),%xmm0
movups 0x10(%r10,%rdi,1),%xmm7
movups %xmm0,(%r14,%rdi,1)
movups %xmm7,0x10(%r14,%rdi,1)
movupd 0x0(%rbp,%rdi,1),%xmm0
movupd 0x10(%rbp,%rdi,1),%xmm7
movupd %xmm0,(%rbx,%rdi,1)
movupd %xmm7,0x10(%rbx,%rdi,1)
cmp    %rax,%r12
je     139a <calculate_fg+0x29a>
or     $0x1,%rax
jmp    1332 <calculate_fg+0x232>
lea    0x1(%r15),%r13d
jmp    13a9 <calculate_fg+0x2a9>
mov    -0x78(%rsp),%rdx
mov    -0x70(%rsp),%r15
mov    %rax,%rsi
not    %rsi
test   $0x1,%r9b
jne    1359 <calculate_fg+0x259>
movsd  (%r10,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
add    %r9,%rsi
je     139a <calculate_fg+0x29a>
xchg   %ax,%ax
movsd  (%r10,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x8(%r10,%rax,8),%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r9
jne    1360 <calculate_fg+0x260>
mov    -0x68(%rsp),%r9
mov    -0x10(%rsp),%rcx
mov    -0x20(%rsp),%rdi
test   %edi,%edi
movapd %xmm9,0x80(%rsp)
movapd %xmm6,0x50(%rsp)
movapd %xmm4,0xe0(%rsp)
movapd %xmm3,-0x50(%rsp)
movapd %xmm2,0x10(%rsp)
movapd %xmm15,0xc0(%rsp)
jle    1b5d <calculate_fg+0xa5d>
movslq %r15d,%rbp
lea    0x1(%rdi),%r8d
mov    %edi,%r10d
mov    $0x1,%eax
cmp    $0x2,%r8d
je     1458 <calculate_fg+0x358>
mov    %r10d,%r14d
and    $0xfffffffe,%r14d
neg    %r14
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rcx,%rax,8),%rsi
movsd  (%rsi),%xmm0
mov    (%r9,%rax,8),%rbx
movsd  %xmm0,(%rbx)
movsd  (%rsi,%rbp,8),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
mov    0x8(%rcx,%rax,8),%rsi
movsd  (%rsi),%xmm0
mov    0x8(%r9,%rax,8),%rbx
movsd  %xmm0,(%rbx)
movsd  (%rsi,%rbp,8),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
lea    (%r14,%rax,1),%rsi
add    $0x2,%rsi
add    $0x2,%rax
cmp    $0x1,%rsi
jne    1410 <calculate_fg+0x310>
test   $0x1,%r10b
je     1478 <calculate_fg+0x378>
mov    (%rcx,%rax,8),%rsi
movsd  (%rsi),%xmm0
mov    (%r9,%rax,8),%rax
movsd  %xmm0,(%rax)
movsd  (%rsi,%rbp,8),%xmm0
movsd  %xmm0,(%rax,%rbp,8)
cmp    $0x2,%edi
jl     1b74 <calculate_fg+0xa74>
mov    %rbp,0xb0(%rsp)
mov    %r8d,0x4c(%rsp)
mov    %r11,0x8(%rsp)
movapd %xmm6,%xmm0
mulsd  %xmm6,%xmm0
movapd %xmm0,-0x60(%rsp)
movapd %xmm9,%xmm0
mulsd  %xmm9,%xmm0
movapd %xmm0,-0x30(%rsp)
movslq %r13d,%r11
lea    -0x1(%r15),%eax
movslq %eax,%r14
mov    %r12,-0x80(%rsp)
lea    -0x8(,%r12,8),%rdi
ff
mov    $0x1,%r13d
movsd  0x1b29(%rip),%xmm8
mov    0x68(%rsp),%r8
mov    %rdx,-0x78(%rsp)
movsd  %xmm1,0x70(%rsp)
mov    %r11,0xd8(%rsp)
mov    %r14,0xd0(%rsp)
jmp    16fb <calculate_fg+0x5fb>
nopl   0x0(%rax)
lea    0x1(%r13),%r12
lea    -0x1(%r13),%rax
movapd %xmm6,%xmm5
mov    (%rdx,%r13,8),%rbp
mov    0xb0(%rsp),%rbx
movsd  0x0(%rbp,%rbx,8),%xmm10
mov    (%rdx,%r12,8),%rsi
movsd  (%rsi,%rbx,8),%xmm8
movapd %xmm10,%xmm12
addsd  %xmm8,%xmm12
movsd  0x1ac5(%rip),%xmm3
mulsd  %xmm3,%xmm12
movsd  0x0(%rbp,%r11,8),%xmm9
movapd %xmm10,%xmm11
addsd  %xmm9,%xmm11
mov    (%rdx,%rax,8),%rsi
movsd  (%rsi,%rbx,8),%xmm13
movapd %xmm10,%xmm14
addsd  %xmm13,%xmm14
mulsd  %xmm3,%xmm14
movsd  0x0(%rbp,%r14,8),%xmm2
movapd %xmm10,%xmm0
mulsd  0x1a8a(%rip),%xmm0
movapd %xmm0,%xmm7
addsd  %xmm13,%xmm7
addsd  %xmm8,%xmm7
divsd  -0x60(%rsp),%xmm7
addsd  %xmm2,%xmm0
addsd  %xmm9,%xmm0
divsd  -0x30(%rsp),%xmm0
addsd  %xmm7,%xmm0
movapd %xmm14,%xmm7
mulsd  %xmm14,%xmm7
movapd %xmm12,%xmm1
mulsd  %xmm12,%xmm1
subsd  %xmm7,%xmm1
movapd %xmm10,%xmm7
subsd  %xmm8,%xmm7
movapd 0x1a61(%rip),%xmm6
andpd  %xmm6,%xmm12
mulsd  %xmm12,%xmm7
mulsd  %xmm3,%xmm11
andpd  %xmm6,%xmm14
subsd  %xmm10,%xmm13
mulsd  %xmm14,%xmm13
movapd %xmm10,%xmm8
addsd  %xmm2,%xmm8
mulsd  %xmm3,%xmm8
mov    (%rcx,%r13,8),%rbp
mov    (%rcx,%r12,8),%rsi
divsd  %xmm5,%xmm1
mulsd  %xmm3,%xmm7
movapd %xmm5,%xmm12
movsd  0x19f7(%rip),%xmm5
mulsd  %xmm5,%xmm13
addsd  %xmm7,%xmm13
movapd -0x50(%rsp),%xmm14
mulsd  %xmm14,%xmm13
divsd  %xmm12,%xmm13
addsd  %xmm1,%xmm13
movsd  0x0(%rbp,%r14,8),%xmm9
addsd  (%rsi,%r14,8),%xmm9
movapd %xmm9,%xmm7
mulsd  %xmm5,%xmm7
mulsd  %xmm8,%xmm7
movapd %xmm3,%xmm8
movsd  0x0(%rbp,%rbx,8),%xmm1
addsd  (%rsi,%rbx,8),%xmm1
mulsd  %xmm3,%xmm1
mulsd  %xmm1,%xmm11
addsd  %xmm7,%xmm11
andpd  %xmm6,%xmm1
movapd %xmm10,%xmm7
subsd  %xmm2,%xmm7
mulsd  %xmm1,%xmm7
andpd  %xmm6,%xmm9
subsd  %xmm10,%xmm2
mulsd  %xmm9,%xmm2
mulsd  %xmm3,%xmm7
mulsd  0x1982(%rip),%xmm2
addsd  %xmm7,%xmm2
movapd 0x80(%rsp),%xmm9
divsd  %xmm9,%xmm11
mulsd  %xmm14,%xmm2
divsd  %xmm9,%xmm2
addsd  %xmm11,%xmm2
divsd  %xmm15,%xmm0
subsd  %xmm13,%xmm0
subsd  %xmm2,%xmm0
movsd  0x70(%rsp),%xmm1
addsd  %xmm1,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm10,%xmm0
mov    (%r8,%r13,8),%rax
movsd  %xmm0,(%rax,%rbx,8)
mov    %r12,%r13
cmp    %r10,%r12
movapd %xmm12,%xmm6
je     1b65 <calculate_fg+0xa65>
cmp    $0x1,%r15d
jle    1500 <calculate_fg+0x400>
mov    %r10,%rbp
mov    -0x8(%rdx,%r13,8),%r10
mov    %rcx,%rbx
mov    (%rdx,%r13,8),%r14
lea    0x1(%r13),%rcx
mov    %rcx,0xa0(%rsp)
mov    0x8(%rdx,%r13,8),%r15
lea    -0x1(%r13),%rax
mov    %rax,0x90(%rsp)
mov    -0x8(%rbx,%r13,8),%rsi
mov    (%rbx,%r13,8),%r12
mov    %rbx,%rcx
mov    0x8(%rbx,%r13,8),%r11
mov    (%r8,%r13,8),%r8
mov    (%r9,%r13,8),%r9
xor    %edx,%edx
nopl   0x0(%rax)
movsd  (%r14,%rdx,1),%xmm6
movsd  0x8(%r14,%rdx,1),%xmm0
movsd  0x8(%r15,%rdx,1),%xmm9
movapd %xmm0,%xmm15
addsd  %xmm9,%xmm15
mulsd  %xmm8,%xmm15
movsd  0x10(%r14,%rdx,1),%xmm11
movapd %xmm0,%xmm1
addsd  %xmm11,%xmm1
mulsd  %xmm8,%xmm1
movapd %xmm1,-0x10(%rsp)
movsd  0x8(%r10,%rdx,1),%xmm10
movapd %xmm0,%xmm1
addsd  %xmm10,%xmm1
mulsd  %xmm8,%xmm1
movapd %xmm0,%xmm12
movapd %xmm0,%xmm5
addsd  %xmm6,%xmm12
mulsd  %xmm8,%xmm12
movsd  (%r12,%rdx,1),%xmm14
movsd  0x8(%r12,%rdx,1),%xmm3
movsd  0x8(%r11,%rdx,1),%xmm0
movsd  %xmm0,-0x20(%rsp)
movapd %xmm3,%xmm13
addsd  %xmm0,%xmm13
mulsd  %xmm8,%xmm13
movsd  0x10(%r12,%rdx,1),%xmm8
movsd  %xmm8,0x30(%rsp)
movapd %xmm5,%xmm7
movsd  0x180f(%rip),%xmm0
mulsd  %xmm0,%xmm7
movapd %xmm7,%xmm2
addsd  %xmm10,%xmm2
addsd  %xmm9,%xmm2
divsd  -0x60(%rsp),%xmm2
addsd  %xmm6,%xmm7
addsd  %xmm11,%xmm7
divsd  -0x30(%rsp),%xmm7
addsd  %xmm2,%xmm7
movapd %xmm1,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm15,%xmm11
mulsd  %xmm15,%xmm11
subsd  %xmm2,%xmm11
movapd %xmm5,%xmm4
subsd  %xmm9,%xmm4
movapd %xmm3,%xmm0
addsd  %xmm8,%xmm0
mulsd  0x17ab(%rip),%xmm0
movapd 0x50(%rsp),%xmm2
divsd  %xmm2,%xmm11
movapd %xmm2,%xmm9
movapd 0x17c3(%rip),%xmm2
andpd  %xmm2,%xmm15
mulsd  %xmm15,%xmm4
mulsd  0x1781(%rip),%xmm4
andpd  %xmm2,%xmm1
movapd %xmm10,%xmm2
subsd  %xmm5,%xmm2
mulsd  %xmm1,%xmm2
movsd  0x1778(%rip),%xmm1
mulsd  %xmm1,%xmm2
addsd  %xmm4,%xmm2
movapd -0x50(%rsp),%xmm8
mulsd  %xmm8,%xmm2
divsd  %xmm9,%xmm2
addsd  %xmm11,%xmm2
movsd  (%r11,%rdx,1),%xmm4
addsd  %xmm14,%xmm4
movapd %xmm4,%xmm15
mulsd  0x1741(%rip),%xmm15
mulsd  %xmm12,%xmm15
movapd %xmm13,%xmm9
movapd 0x174e(%rip),%xmm11
andpd  %xmm11,%xmm13
movsd  %xmm5,-0x40(%rsp)
movapd %xmm5,%xmm1
subsd  %xmm6,%xmm1
mulsd  %xmm13,%xmm1
movsd  0x8(%rsi,%rdx,1),%xmm12
andpd  %xmm11,%xmm4
subsd  %xmm5,%xmm6
mulsd  %xmm4,%xmm6
movapd %xmm3,%xmm13
addsd  %xmm14,%xmm13
mulsd  0x16df(%rip),%xmm13
mulsd  -0x10(%rsp),%xmm9
movapd %xmm9,0x20(%rsp)
addsd  %xmm9,%xmm15
movapd 0x80(%rsp),%xmm11
divsd  %xmm11,%xmm15
mulsd  0x16b5(%rip),%xmm1
mulsd  0x16c5(%rip),%xmm6
subsd  %xmm6,%xmm1
mulsd  %xmm8,%xmm1
divsd  %xmm11,%xmm1
addsd  %xmm15,%xmm1
movapd %xmm3,%xmm6
mulsd  0x1696(%rip),%xmm6
movapd %xmm6,%xmm4
addsd  %xmm12,%xmm4
addsd  -0x20(%rsp),%xmm4
divsd  -0x60(%rsp),%xmm4
addsd  %xmm14,%xmm6
movsd  0x30(%rsp),%xmm5
addsd  %xmm5,%xmm6
divsd  -0x30(%rsp),%xmm6
addsd  %xmm4,%xmm6
movapd %xmm13,%xmm15
mulsd  %xmm13,%xmm15
movapd %xmm0,%xmm9
mulsd  %xmm0,%xmm9
subsd  %xmm15,%xmm9
movapd %xmm3,%xmm15
subsd  %xmm5,%xmm15
movapd 0x1665(%rip),%xmm4
andpd  %xmm4,%xmm0
mulsd  %xmm0,%xmm15
andpd  %xmm4,%xmm13
subsd  %xmm3,%xmm14
mulsd  %xmm13,%xmm14
movapd 0xe0(%rsp),%xmm13
mulsd  0x160a(%rip),%xmm15
movsd  0x1612(%rip),%xmm5
mulsd  %xmm5,%xmm14
addsd  %xmm15,%xmm14
movapd 0xc0(%rsp),%xmm4
movapd %xmm3,%xmm8
addsd  %xmm12,%xmm8
mulsd  0x15dc(%rip),%xmm8
divsd  %xmm11,%xmm9
movapd -0x50(%rsp),%xmm15
mulsd  %xmm15,%xmm14
divsd  %xmm11,%xmm14
addsd  %xmm9,%xmm14
addsd  0x10(%r10,%rdx,1),%xmm10
movapd %xmm10,%xmm0
mulsd  %xmm5,%xmm0
mulsd  %xmm8,%xmm0
movsd  0x15a3(%rip),%xmm8
addsd  0x20(%rsp),%xmm0
subsd  %xmm3,%xmm12
subsd  -0x20(%rsp),%xmm3
movapd -0x10(%rsp),%xmm5
movapd 0x15b3(%rip),%xmm9
andpd  %xmm9,%xmm5
mulsd  %xmm5,%xmm3
andpd  %xmm9,%xmm10
mulsd  %xmm12,%xmm10
mulsd  %xmm8,%xmm3
mulsd  0x157a(%rip),%xmm10
subsd  %xmm10,%xmm3
movapd 0x50(%rsp),%xmm5
divsd  %xmm5,%xmm0
mulsd  %xmm15,%xmm3
divsd  %xmm5,%xmm3
addsd  %xmm0,%xmm3
divsd  %xmm4,%xmm7
subsd  %xmm2,%xmm7
subsd  %xmm1,%xmm7
addsd  0x70(%rsp),%xmm7
mulsd  %xmm13,%xmm7
addsd  -0x40(%rsp),%xmm7
movsd  %xmm7,0x8(%r8,%rdx,1)
divsd  %xmm4,%xmm6
subsd  %xmm3,%xmm6
subsd  %xmm14,%xmm6
addsd  0x10(%rsp),%xmm6
mulsd  %xmm13,%xmm6
addsd  0x8(%r12,%rdx,1),%xmm6
movsd  %xmm6,0x8(%r9,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rdi
jne    1750 <calculate_fg+0x650>
movapd %xmm4,%xmm15
movapd %xmm13,%xmm4
movapd 0x50(%rsp),%xmm5
mov    -0x68(%rsp),%r9
mov    -0x78(%rsp),%rdx
mov    -0x70(%rsp),%r15
mov    0x68(%rsp),%r8
mov    %rbp,%r10
mov    0xd8(%rsp),%r11
mov    0xd0(%rsp),%r14
mov    0xa0(%rsp),%r12
mov    0x90(%rsp),%rax
jmp    150c <calculate_fg+0x40c>
add    $0x1,%edi
mov    %edi,%r8d
jmp    1b74 <calculate_fg+0xa74>
mov    -0x80(%rsp),%r12
mov    0x8(%rsp),%r11
mov    0x4c(%rsp),%r8d
cmp    $0x2,%r15d
movapd 0x80(%rsp),%xmm15
movapd 0x50(%rsp),%xmm8
jl     1dd1 <calculate_fg+0xcd1>
mov    -0x8(%rdx,%r11,8),%rsi
mov    (%rdx,%r11,8),%rax
mov    -0x8(%rcx,%r11,8),%r10
mov    (%rcx,%r11,8),%rdx
movslq %r8d,%rdi
mov    (%rcx,%rdi,8),%r14
movapd %xmm8,%xmm5
mulsd  %xmm8,%xmm5
movapd %xmm15,%xmm0
mulsd  %xmm15,%xmm0
mov    (%r9,%r11,8),%rbx
lea    -0x1(%r12),%rdi
mov    $0x1,%r9d
cmp    $0x2,%rdi
movapd %xmm5,-0x10(%rsp)
movapd %xmm0,-0x20(%rsp)
jae    1de3 <calculate_fg+0xce3>
movapd %xmm8,%xmm2
movapd -0x50(%rsp),%xmm11
movapd 0x10(%rsp),%xmm10
lea    (%rbx,%r9,8),%rbp
lea    (%rsi,%r9,8),%rsi
add    $0x8,%rsi
lea    (%r10,%r9,8),%rdi
lea    (%r14,%r9,8),%rcx
lea    (%rdx,%r9,8),%rdx
lea    (%rax,%r9,8),%rax
add    $0x8,%rax
sub    %r9,%r12
xor    %ebx,%ebx
movsd  0x13de(%rip),%xmm12
movapd 0x1405(%rip),%xmm8
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rdx,%rbx,8),%xmm6
movsd  (%rdx,%rbx,8),%xmm14
movsd  (%rcx,%rbx,8),%xmm13
movapd %xmm2,%xmm9
movsd  0x8(%rdx,%rbx,8),%xmm2
movapd %xmm14,%xmm7
addsd  %xmm2,%xmm7
mulsd  %xmm12,%xmm7
movsd  (%rdi,%rbx,8),%xmm1
movapd %xmm14,%xmm4
addsd  %xmm6,%xmm4
mulsd  %xmm12,%xmm4
movapd %xmm14,%xmm0
mulsd  0x138d(%rip),%xmm0
movapd %xmm0,%xmm3
addsd  %xmm1,%xmm3
addsd  %xmm13,%xmm3
divsd  %xmm5,%xmm3
addsd  %xmm6,%xmm0
addsd  %xmm2,%xmm0
divsd  -0x20(%rsp),%xmm0
addsd  %xmm3,%xmm0
movapd %xmm4,%xmm3
mulsd  %xmm4,%xmm3
movapd %xmm7,%xmm5
mulsd  %xmm7,%xmm5
subsd  %xmm3,%xmm5
movapd %xmm14,%xmm3
subsd  %xmm2,%xmm3
andpd  %xmm8,%xmm7
mulsd  %xmm7,%xmm3
movsd  -0x8(%rax,%rbx,8),%xmm2
addsd  (%rax,%rbx,8),%xmm2
mulsd  %xmm12,%xmm2
andpd  %xmm8,%xmm4
subsd  %xmm14,%xmm6
mulsd  %xmm4,%xmm6
movapd %xmm14,%xmm4
addsd  %xmm1,%xmm4
mulsd  %xmm12,%xmm4
divsd  %xmm15,%xmm5
mulsd  %xmm12,%xmm3
movsd  0x130e(%rip),%xmm7
mulsd  %xmm7,%xmm6
addsd  %xmm3,%xmm6
mulsd  %xmm11,%xmm6
divsd  %xmm15,%xmm6
addsd  %xmm5,%xmm6
movsd  -0x8(%rsi,%rbx,8),%xmm3
addsd  (%rsi,%rbx,8),%xmm3
movapd %xmm3,%xmm5
mulsd  %xmm7,%xmm5
mulsd  %xmm4,%xmm5
movapd %xmm14,%xmm4
addsd  %xmm13,%xmm4
mulsd  %xmm12,%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm5,%xmm4
movapd %xmm14,%xmm5
subsd  %xmm13,%xmm5
andpd  %xmm8,%xmm2
mulsd  %xmm2,%xmm5
movapd %xmm9,%xmm2
movapd 0xc0(%rsp),%xmm9
andpd  %xmm8,%xmm3
subsd  %xmm14,%xmm1
mulsd  %xmm3,%xmm1
mulsd  %xmm12,%xmm5
mulsd  0x129d(%rip),%xmm1
addsd  %xmm5,%xmm1
movapd -0x10(%rsp),%xmm5
divsd  %xmm2,%xmm4
mulsd  %xmm11,%xmm1
divsd  %xmm2,%xmm1
addsd  %xmm4,%xmm1
divsd  %xmm9,%xmm0
subsd  %xmm1,%xmm0
subsd  %xmm6,%xmm0
addsd  %xmm10,%xmm0
mulsd  0xe0(%rsp),%xmm0
addsd  %xmm14,%xmm0
movsd  %xmm0,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r12
jne    1c30 <calculate_fg+0xb30>
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rdi,-0x68(%rsp)
lea    0x8(%rbx),%rbp
lea    (%rbx,%r12,8),%r13
lea    0x8(%rax),%r8
lea    (%rax,%r12,8),%rdi
add    $0x8,%rdi
lea    0x8(%rdx,%r12,8),%r11
lea    0x8(%r14),%rcx
mov    %rcx,-0x40(%rsp)
lea    (%r14,%r12,8),%rcx
mov    %rcx,0x30(%rsp)
cmp    %rdi,%rbp
setb   -0x60(%rsp)
cmp    %r13,%r8
lea    0x8(%r10),%rcx
setb   -0x30(%rsp)
cmp    %r11,%rbp
setb   %r15b
cmp    %r13,%rdx
setb   0x20(%rsp)
cmp    0x30(%rsp),%rbp
setb   %r11b
cmp    %r13,-0x40(%rsp)
lea    (%r10,%r12,8),%rdi
setb   -0x40(%rsp)
cmp    %rdi,%rbp
setb   %r8b
cmp    %r13,%rcx
mov    %r12,-0x80(%rsp)
lea    0x8(%rsi,%r12,8),%rdi
setb   %r12b
cmp    %rdi,%rbp
lea    0x8(%rsi),%rdi
setb   %bpl
cmp    %r13,%rdi
setb   %dil
mov    -0x30(%rsp),%cl
test   %cl,-0x60(%rsp)
jne    218a <calculate_fg+0x108a>
mov    %r12d,%ecx
and    0x20(%rsp),%r15b
mov    -0x80(%rsp),%r12
jne    1be1 <calculate_fg+0xae1>
and    -0x40(%rsp),%r11b
jne    1be1 <calculate_fg+0xae1>
and    %cl,%r8b
jne    1be1 <calculate_fg+0xae1>
and    %dil,%bpl
movapd %xmm8,%xmm2
movapd -0x50(%rsp),%xmm11
movapd 0x10(%rsp),%xmm10
movapd 0xc0(%rsp),%xmm9
jne    1bf4 <calculate_fg+0xaf4>
mov    -0x68(%rsp),%r8
mov    %r8,%rbp
and    $0xfffffffffffffffe,%rbp
mov    %r8,%r9
or     $0x1,%r9
unpcklpd %xmm5,%xmm5
movapd %xmm5,-0x30(%rsp)
movapd -0x20(%rsp),%xmm0
unpcklpd %xmm0,%xmm0
movapd %xmm0,-0x40(%rsp)
unpcklpd %xmm15,%xmm15
movapd %xmm15,0x30(%rsp)
unpcklpd %xmm11,%xmm11
movapd %xmm11,0x20(%rsp)
unpcklpd %xmm2,%xmm2
movapd %xmm2,0x70(%rsp)
unpcklpd %xmm9,%xmm9
movapd %xmm9,0xb0(%rsp)
unpcklpd %xmm10,%xmm10
movapd %xmm10,0xa0(%rsp)
unpcklpd %xmm4,%xmm4
movapd %xmm4,0x90(%rsp)
xor    %edi,%edi
movapd 0x10e9(%rip),%xmm8
movapd 0x20(%rsp),%xmm7
nopl   (%rax)
movupd 0x8(%rax,%rdi,8),%xmm3
movupd 0x10(%rax,%rdi,8),%xmm14
addpd  %xmm3,%xmm14
movupd 0x8(%r14,%rdi,8),%xmm0
movapd %xmm0,-0x60(%rsp)
movupd (%rdx,%rdi,8),%xmm9
movupd 0x8(%rdx,%rdi,8),%xmm15
movupd 0x10(%rdx,%rdi,8),%xmm11
movapd %xmm15,%xmm13
addpd  %xmm11,%xmm13
mulpd  %xmm8,%xmm13
movupd 0x8(%r10,%rdi,8),%xmm6
movapd %xmm15,%xmm12
addpd  %xmm9,%xmm12
mulpd  %xmm8,%xmm12
movapd %xmm15,%xmm3
mulpd  0x108b(%rip),%xmm3
movapd %xmm3,%xmm5
addpd  %xmm6,%xmm5
addpd  %xmm0,%xmm5
divpd  -0x30(%rsp),%xmm5
addpd  %xmm9,%xmm3
addpd  %xmm11,%xmm3
divpd  -0x40(%rsp),%xmm3
addpd  %xmm5,%xmm3
movapd %xmm12,%xmm5
mulpd  %xmm12,%xmm5
movapd %xmm13,%xmm10
mulpd  %xmm13,%xmm10
subpd  %xmm5,%xmm10
movapd %xmm15,%xmm5
subpd  %xmm11,%xmm5
movapd 0x1019(%rip),%xmm11
andpd  %xmm11,%xmm13
mulpd  %xmm13,%xmm5
mulpd  %xmm8,%xmm14
andpd  %xmm11,%xmm12
subpd  %xmm15,%xmm9
mulpd  %xmm12,%xmm9
movapd %xmm15,%xmm4
addpd  %xmm6,%xmm4
mulpd  %xmm8,%xmm4
movapd 0x30(%rsp),%xmm0
divpd  %xmm0,%xmm10
mulpd  %xmm8,%xmm5
mulpd  %xmm8,%xmm9
subpd  %xmm9,%xmm5
mulpd  %xmm7,%xmm5
divpd  %xmm0,%xmm5
addpd  %xmm10,%xmm5
movupd 0x8(%rsi,%rdi,8),%xmm0
movupd 0x10(%rsi,%rdi,8),%xmm2
addpd  %xmm0,%xmm2
movapd %xmm2,%xmm0
mulpd  0xfda(%rip),%xmm0
mulpd  %xmm4,%xmm0
movapd %xmm15,%xmm4
movapd -0x60(%rsp),%xmm1
addpd  %xmm1,%xmm4
mulpd  %xmm8,%xmm4
mulpd  %xmm14,%xmm4
addpd  %xmm0,%xmm4
movapd %xmm15,%xmm0
subpd  %xmm1,%xmm0
andpd  %xmm11,%xmm14
mulpd  %xmm14,%xmm0
andpd  %xmm11,%xmm2
subpd  %xmm15,%xmm6
mulpd  %xmm2,%xmm6
mulpd  %xmm8,%xmm0
mulpd  0xf9b(%rip),%xmm6
addpd  %xmm0,%xmm6
movapd 0x70(%rsp),%xmm0
divpd  %xmm0,%xmm4
mulpd  %xmm7,%xmm6
divpd  %xmm0,%xmm6
addpd  %xmm4,%xmm6
divpd  0xb0(%rsp),%xmm3
subpd  %xmm6,%xmm3
subpd  %xmm5,%xmm3
addpd  0xa0(%rsp),%xmm3
mulpd  0x90(%rsp),%xmm3
addpd  %xmm15,%xmm3
movupd %xmm3,0x8(%rbx,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rbp
jne    1f60 <calculate_fg+0xe60>
cmp    %rbp,%r8
movapd 0x80(%rsp),%xmm15
movapd 0x50(%rsp),%xmm2
movapd -0x50(%rsp),%xmm11
movapd 0x10(%rsp),%xmm10
movapd -0x10(%rsp),%xmm5
jne    1bf4 <calculate_fg+0xaf4>
jmp    1dd1 <calculate_fg+0xcd1>
xor    %edi,%edi
test   $0x1,%cl
jne    12db <calculate_fg+0x1db>
jmp    1310 <calculate_fg+0x210>
mov    -0x80(%rsp),%r12
mov    -0x78(%rsp),%rdx
mov    0x8(%rsp),%r11
mov    -0x70(%rsp),%r15
mov    -0x60(%rsp),%r13d
jmp    1332 <calculate_fg+0x232>
movapd %xmm8,%xmm2
movapd -0x50(%rsp),%xmm11
movapd 0x10(%rsp),%xmm10
mov    -0x80(%rsp),%r12
jmp    1bf4 <calculate_fg+0xaf4>

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