int main() {
  int DX;
  int DY;
  int FSDX;
  int FSDY;
  int TDT;
  int TDTS8;
  int TDTSDX;
  int TDTSDY;
  int t, i, j;
  double CU[100 + 1][100 + 1];
  double CV[100 + 1][100 + 1];
  double Z[100 + 1][100 + 1];
  double H[100 + 1][100 + 1];
  double P[100 + 1][100 + 1];
  double U[100 + 1][100 + 1];
  double V[100 + 1][100 + 1];
  double UNEW[100 + 1][100 + 1];
  double UOLD[100 + 1][100 + 1];
  double PNEW[100 + 1][100 + 1];
  double POLD[100 + 1][100 + 1];
  double VNEW[100 + 1][100 + 1];
  double VOLD[100 + 1][100 + 1];
  double ALPHA;
  for (t = 0; t < 10; t++) {
    FSDX = 4 / DX;
    FSDY = 4 / DY;
    for (i = 0; i < 100; i++) {
      for (j = 0; j < 100; j++) {
        CU[i + 1][j] = (double)0.5 * (P[i + 1][j] + P[i][j]) * U[i + 1][j];
        CV[i][j + 1] = (double)0.5 * (P[i][j + 1] + P[i][j]) * V[i][j + 1];
        Z[i + 1][j + 1] =
            (FSDX * (V[i + 1][j + 1] - V[i][j + 1]) -
             FSDY * (U[i + 1][j + 1] - U[i + 1][j])) /
            (P[i][j] + P[i + 1][j] + P[i + 1][j + 1] + P[i][j + 1]);
        H[i][j] = P[i][j] + (double)0.25 *
                                (U[i + 1][j] * U[i + 1][j] + U[i][j] * U[i][j] +
                                 V[i][j + 1] * V[i][j + 1] + V[i][j] * V[i][j]);
      }
    }
    for (j = 0; j < 100; j++) {
      CU[0][j] = CU[100][j];
      CV[100][j + 1] = CV[0][j + 1];
      Z[0][j + 1] = Z[100][j + 1];
      H[100][j] = H[0][j];
    }
    for (i = 0; i < 100; i++) {
      CU[i + 1][100] = CU[i + 1][0];
      CV[i][0] = CV[i][100];
      Z[i + 1][0] = Z[i + 1][100];
      H[i][100] = H[i][0];
    }
    CU[0][100] = CU[100][0];
    CV[100][0] = CV[0][100];
    Z[0][0] = Z[100][100];
    H[100][100] = H[0][0];
    TDTS8 = TDT / 8;
    TDTSDX = TDT / DX;
    TDTSDY = TDT / DY;
    for (i = 0; i < 100; i++) {
      for (j = 0; j < 100; j++) {
        UNEW[i + 1][j] =
            UOLD[i + 1][j] +
            TDTS8 * (Z[i + 1][j + 1] + Z[i + 1][j]) *
                (CV[i + 1][j + 1] + CV[i][j + 1] + CV[i][j] + CV[i + 1][j]) -
            TDTSDX * (H[i + 1][j] - H[i][j]);
        VNEW[i][j + 1] =
            VOLD[i][j + 1] -
            TDTS8 * (Z[i + 1][j + 1] + Z[i][j + 1]) *
                (CU[i + 1][j + 1] + CU[i][j + 1] + CU[i][j] + CU[i + 1][j]) -
            TDTSDY * (H[i][j + 1] - H[i][j]);
        PNEW[i][j] = POLD[i][j] - TDTSDX * (CU[i + 1][j] - CU[i][j]) -
                     TDTSDY * (CV[i][j + 1] - CV[i][j]);
      }
    }
    for (j = 0; j < 100; j++) {
      UNEW[0][j] = UNEW[100][j];
      VNEW[100][j + 1] = VNEW[0][j + 1];
      PNEW[100][j] = PNEW[0][j];
    }
    for (i = 0; i < 100; i++) {
      UNEW[i + 1][100] = UNEW[i + 1][0];
      VNEW[i][0] = VNEW[i][100];
      PNEW[i][100] = PNEW[i][0];
    }
    UNEW[0][100] = UNEW[100][0];
    VNEW[100][0] = VNEW[0][100];
    PNEW[100][100] = PNEW[0][0];
    for (i = 0; i < 100; i++) {
      for (j = 0; j < 100; j++) {
        UOLD[i][j] =
            U[i][j] + ALPHA * (UNEW[i][j] - (double)2 * U[i][j] + UOLD[i][j]);
        VOLD[i][j] =
            V[i][j] + ALPHA * (VNEW[i][j] - (double)2 * V[i][j] + VOLD[i][j]);
        POLD[i][j] =
            P[i][j] + ALPHA * (PNEW[i][j] - (double)2 * P[i][j] + POLD[i][j]);
        U[i][j] = UNEW[i][j];
        V[i][j] = VNEW[i][j];
        P[i][j] = PNEW[i][j];
      }
    }
    for (j = 0; j < 100; j++) {
      UOLD[100][j] = UOLD[0][j];
      VOLD[100][j] = VOLD[0][j];
      POLD[100][j] = POLD[0][j];
      U[100][j] = U[0][j];
      V[100][j] = V[0][j];
      P[100][j] = P[0][j];
    }
    for (i = 0; i < 100; i++) {
      UOLD[i][100] = UOLD[i][0];
      VOLD[i][100] = VOLD[i][0];
      POLD[i][100] = POLD[i][0];
      U[i][100] = U[i][0];
      V[i][100] = V[i][0];
      P[i][100] = P[i][0];
    }
    UOLD[100][100] = UOLD[0][0];
    VOLD[100][100] = VOLD[0][0];
    POLD[100][100] = POLD[0][0];
    U[100][100] = U[0][0];
    V[100][100] = V[0][0];
    P[100][100] = P[0][0];
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x103050,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0xa,-0x28(%rbp)
jge    230e <main+0x120e>
mov    $0x4,%eax
cltd
idivl  -0x8(%rbp)
mov    %eax,-0x10(%rbp)
mov    $0x4,%eax
cltd
idivl  -0xc(%rbp)
mov    %eax,-0x14(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x64,-0x2c(%rbp)
jge    1587 <main+0x487>
movl   $0x0,-0x30(%rbp)
cmpl   $0x64,-0x30(%rbp)
jge    1574 <main+0x474>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x63a40(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x2c(%rbp),%rcx
lea    -0x63a40(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0x1e62(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x77910(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x13f00(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x2c(%rbp),%rcx
lea    -0x63a40(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x2c(%rbp),%rcx
lea    -0x63a40(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0x1dcf(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x8b7e0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x27dd0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cvtsi2sdl -0x10(%rbp),%xmm0
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x8b7e0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x2c(%rbp),%rcx
lea    -0x8b7e0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm2
cvtsi2sdl -0x14(%rbp),%xmm1
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x77910(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x77910(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x63a40(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x63a40(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x63a40(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movslq -0x2c(%rbp),%rcx
lea    -0x63a40(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x3bca0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x2c(%rbp),%rcx
lea    -0x63a40(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x77910(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x77910(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
movslq -0x2c(%rbp),%rcx
lea    -0x77910(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x2c(%rbp),%rcx
lea    -0x77910(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x8b7e0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x2c(%rbp),%rcx
lea    -0x8b7e0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movslq -0x2c(%rbp),%rcx
lea    -0x8b7e0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x8b7e0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
movsd  0x1ac0(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x4fb70(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1153 <main+0x53>
jmp    1579 <main+0x479>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1142 <main+0x42>
movl   $0x0,-0x30(%rbp)
cmpl   $0x64,-0x30(%rbp)
jge    161e <main+0x51e>
movslq -0x30(%rbp),%rax
movsd  -0x360(%rbp,%rax,8),%xmm0
ff ff
movslq -0x30(%rbp),%rax
movsd  %xmm0,-0x13f00(%rbp,%rax,8)
fe ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cltq
movsd  -0x27dd0(%rbp,%rax,8),%xmm0
fd ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cltq
movsd  %xmm0,-0x14230(%rbp,%rax,8)
fe ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cltq
movsd  -0x28100(%rbp,%rax,8),%xmm0
fd ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cltq
movsd  %xmm0,-0x3bca0(%rbp,%rax,8)
fc ff
movslq -0x30(%rbp),%rax
movsd  -0x4fb70(%rbp,%rax,8),%xmm0
fb ff
movslq -0x30(%rbp),%rax
movsd  %xmm0,-0x3bfd0(%rbp,%rax,8)
fc ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    158e <main+0x48e>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x64,-0x2c(%rbp)
jge    1729 <main+0x629>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x13f00(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x13f00(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x320(%rax)
movslq -0x2c(%rbp),%rcx
lea    -0x27dd0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  0x320(%rax),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x27dd0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,(%rax)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x3bca0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  0x320(%rax),%xmm0
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x3bca0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,(%rax)
movslq -0x2c(%rbp),%rcx
lea    -0x4fb70(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x4fb70(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x320(%rax)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1625 <main+0x525>
movsd  -0x360(%rbp),%xmm0
ff
movsd  %xmm0,-0x13be0(%rbp)
ff
movsd  -0x27ab0(%rbp),%xmm0
ff
movsd  %xmm0,-0x14230(%rbp)
ff
movsd  -0x27de0(%rbp),%xmm0
ff
movsd  %xmm0,-0x3bca0(%rbp)
ff
movsd  -0x4fb70(%rbp),%xmm0
ff
movsd  %xmm0,-0x3bcb0(%rbp)
ff
mov    -0x18(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
cltd
idivl  -0x8(%rbp)
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
cltd
idivl  -0xc(%rbp)
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x64,-0x2c(%rbp)
jge    1c11 <main+0xb11>
movl   $0x0,-0x30(%rbp)
cmpl   $0x64,-0x30(%rbp)
jge    1bfe <main+0xafe>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0xb3580(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsi2sdl -0x1c(%rbp),%xmm1
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x3bca0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x3bca0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x27dd0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x2c(%rbp),%rcx
lea    -0x27dd0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
movslq -0x2c(%rbp),%rcx
lea    -0x27dd0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x27dd0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
cvtsi2sdl -0x20(%rbp),%xmm0
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x4fb70(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x2c(%rbp),%rcx
lea    -0x4fb70(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x9f6b0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x2c(%rbp),%rcx
lea    -0x1030c0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsi2sdl -0x1c(%rbp),%xmm1
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x3bca0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x2c(%rbp),%rcx
lea    -0x3bca0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x13f00(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x2c(%rbp),%rcx
lea    -0x13f00(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
movslq -0x2c(%rbp),%rcx
lea    -0x13f00(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x13f00(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
cvtsi2sdl -0x24(%rbp),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x4fb70(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x2c(%rbp),%rcx
lea    -0x4fb70(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0xef1f0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x2c(%rbp),%rcx
lea    -0xdb320(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsi2sdl -0x20(%rbp),%xmm1
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x13f00(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x2c(%rbp),%rcx
lea    -0x13f00(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
cvtsi2sdl -0x24(%rbp),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x27dd0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x2c(%rbp),%rcx
lea    -0x27dd0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0xc7450(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    17a3 <main+0x6a3>
jmp    1c03 <main+0xb03>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1792 <main+0x692>
movl   $0x0,-0x30(%rbp)
cmpl   $0x64,-0x30(%rbp)
jge    1c86 <main+0xb86>
movslq -0x30(%rbp),%rax
movsd  -0x8bb10(%rbp,%rax,8),%xmm0
f7 ff
movslq -0x30(%rbp),%rax
movsd  %xmm0,-0x9f6b0(%rbp,%rax,8)
f6 ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cltq
movsd  -0xef1f0(%rbp,%rax,8),%xmm0
f1 ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cltq
movsd  %xmm0,-0xdb650(%rbp,%rax,8)
f2 ff
movslq -0x30(%rbp),%rax
movsd  -0xc7450(%rbp,%rax,8),%xmm0
f3 ff
movslq -0x30(%rbp),%rax
movsd  %xmm0,-0xb38b0(%rbp,%rax,8)
f4 ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1c18 <main+0xb18>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x64,-0x2c(%rbp)
jge    1d51 <main+0xc51>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x9f6b0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x9f6b0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x320(%rax)
movslq -0x2c(%rbp),%rcx
lea    -0xef1f0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  0x320(%rax),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0xef1f0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,(%rax)
movslq -0x2c(%rbp),%rcx
lea    -0xc7450(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0xc7450(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x320(%rax)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1c8d <main+0xb8d>
movsd  -0x8bb10(%rbp),%xmm0
ff
movsd  %xmm0,-0x9f390(%rbp)
ff
movsd  -0xeeed0(%rbp),%xmm0
ff
movsd  %xmm0,-0xdb650(%rbp)
ff
movsd  -0xc7450(%rbp),%xmm0
ff
movsd  %xmm0,-0xb3590(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
cmpl   $0x64,-0x2c(%rbp)
jge    2082 <main+0xf82>
movl   $0x0,-0x30(%rbp)
cmpl   $0x64,-0x30(%rbp)
jge    206f <main+0xf6f>
movslq -0x2c(%rbp),%rcx
lea    -0x77910(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x1030c8(%rbp),%xmm0
ff
movslq -0x2c(%rbp),%rcx
lea    -0x9f6b0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x2c(%rbp),%rcx
lea    -0x77910(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
addsd  %xmm3,%xmm3
subsd  %xmm3,%xmm2
movslq -0x2c(%rbp),%rcx
lea    -0xb3580(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0xb3580(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x2c(%rbp),%rcx
lea    -0x8b7e0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x1030c8(%rbp),%xmm0
ff
movslq -0x2c(%rbp),%rcx
lea    -0xef1f0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x2c(%rbp),%rcx
lea    -0x8b7e0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
addsd  %xmm3,%xmm3
subsd  %xmm3,%xmm2
movslq -0x2c(%rbp),%rcx
lea    -0x1030c0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x1030c0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x2c(%rbp),%rcx
lea    -0x63a40(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x1030c8(%rbp),%xmm0
ff
movslq -0x2c(%rbp),%rcx
lea    -0xc7450(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x2c(%rbp),%rcx
lea    -0x63a40(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
addsd  %xmm3,%xmm3
subsd  %xmm3,%xmm2
movslq -0x2c(%rbp),%rcx
lea    -0xdb320(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0xdb320(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x2c(%rbp),%rcx
lea    -0x9f6b0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x77910(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x2c(%rbp),%rcx
lea    -0xef1f0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x8b7e0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x2c(%rbp),%rcx
lea    -0xc7450(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x63a40(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1d99 <main+0xc99>
jmp    2074 <main+0xf74>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1d88 <main+0xc88>
movl   $0x0,-0x30(%rbp)
cmpl   $0x64,-0x30(%rbp)
jge    213d <main+0x103d>
movslq -0x30(%rbp),%rax
movsd  -0xb3580(%rbp,%rax,8),%xmm0
f4 ff
movslq -0x30(%rbp),%rax
movsd  %xmm0,-0x9f9e0(%rbp,%rax,8)
f6 ff
movslq -0x30(%rbp),%rax
movsd  -0x1030c0(%rbp,%rax,8),%xmm0
ef ff
movslq -0x30(%rbp),%rax
movsd  %xmm0,-0xef520(%rbp,%rax,8)
f1 ff
movslq -0x30(%rbp),%rax
movsd  -0xdb320(%rbp,%rax,8),%xmm0
f2 ff
movslq -0x30(%rbp),%rax
movsd  %xmm0,-0xc7780(%rbp,%rax,8)
f3 ff
movslq -0x30(%rbp),%rax
movsd  -0x77910(%rbp,%rax,8),%xmm0
f8 ff
movslq -0x30(%rbp),%rax
movsd  %xmm0,-0x63d70(%rbp,%rax,8)
f9 ff
movslq -0x30(%rbp),%rax
movsd  -0x8b7e0(%rbp,%rax,8),%xmm0
f7 ff
movslq -0x30(%rbp),%rax
movsd  %xmm0,-0x77c40(%rbp,%rax,8)
f8 ff
movslq -0x30(%rbp),%rax
movsd  -0x63a40(%rbp,%rax,8),%xmm0
f9 ff
movslq -0x30(%rbp),%rax
movsd  %xmm0,-0x4fea0(%rbp,%rax,8)
fb ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2089 <main+0xf89>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x64,-0x2c(%rbp)
jge    22a0 <main+0x11a0>
movslq -0x2c(%rbp),%rcx
lea    -0xb3580(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0xb3580(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x320(%rax)
movslq -0x2c(%rbp),%rcx
lea    -0x1030c0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x1030c0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x320(%rax)
movslq -0x2c(%rbp),%rcx
lea    -0xdb320(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0xdb320(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x320(%rax)
movslq -0x2c(%rbp),%rcx
lea    -0x77910(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x77910(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x320(%rax)
movslq -0x2c(%rbp),%rcx
lea    -0x8b7e0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x8b7e0(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x320(%rax)
movslq -0x2c(%rbp),%rcx
lea    -0x63a40(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x63a40(%rbp),%rax
imul   $0x328,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x320(%rax)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    2144 <main+0x1044>
movsd  -0xb3580(%rbp),%xmm0
ff
movsd  %xmm0,-0x9f6c0(%rbp)
ff
movsd  -0x1030c0(%rbp),%xmm0
ff
movsd  %xmm0,-0xef200(%rbp)
ff
movsd  -0xdb320(%rbp),%xmm0
ff
movsd  %xmm0,-0xc7460(%rbp)
ff
movsd  -0x77910(%rbp),%xmm0
ff
movsd  %xmm0,-0x63a50(%rbp)
ff
movsd  -0x8b7e0(%rbp),%xmm0
ff
movsd  %xmm0,-0x77920(%rbp)
ff
movsd  -0x63a40(%rbp),%xmm0
ff
movsd  %xmm0,-0x4fb80(%rbp)
ff
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1119 <main+0x19>
xor    %eax,%eax
add    $0x103050,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1030a8,%rsp
xor    %eax,%eax
movsd  0xed5(%rip),%xmm5
movsd  0xed5(%rip),%xmm6
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rax,0x8(%rsp)
lea    0x8b7d8(%rsp),%rax
lea    0x28(%rsp),%rcx
lea    0x77900(%rsp),%rdx
lea    0xdb638(%rsp),%rsi
lea    0x27dc0(%rsp),%rdi
lea    0x13ef8(%rsp),%rbp
xor    %r8d,%r8d
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r8
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movsd  0x320(%rbp,%rbx,1),%xmm2
addsd  %xmm1,%xmm2
mulsd  %xmm5,%xmm2
movsd  0x328(%rdi,%rbx,1),%xmm3
mulsd  %xmm3,%xmm2
movsd  %xmm2,(%rsi,%rbx,1)
movsd  (%rcx,%rbx,1),%xmm2
movsd  (%rdi,%rbx,1),%xmm4
mulsd  %xmm4,%xmm4
mulsd  %xmm3,%xmm3
addsd  %xmm4,%xmm3
movapd %xmm2,%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm3,%xmm4
mulsd  %xmm0,%xmm0
addsd  %xmm4,%xmm0
mulsd  %xmm6,%xmm0
addsd  %xmm1,%xmm0
movsd  0x0(%rbp,%rbx,1),%xmm3
addsd  %xmm3,%xmm1
mulsd  %xmm5,%xmm1
mulsd  %xmm2,%xmm1
movsd  %xmm1,(%rax,%rbx,1)
movsd  %xmm0,(%rdx,%rbx,1)
add    $0x8,%rbx
movapd %xmm2,%xmm0
movapd %xmm3,%xmm1
cmp    $0x320,%rbx
jne    1190 <main+0x80>
cmp    $0x64,%r8
je     1270 <main+0x160>
imul   $0x328,%r8,%rbx
movsd  0x13ef0(%rsp,%rbx,1),%xmm1
movsd  0x20(%rsp,%rbx,1),%xmm0
add    $0x328,%rbp
add    $0x328,%rdi
add    $0x328,%rsi
add    $0x328,%rdx
add    $0x328,%rcx
add    $0x328,%rax
jmp    1180 <main+0x70>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    $0x320,%edx
lea    0xdb310(%rsp),%rdi
lea    0xeeeb0(%rsp),%rsi
call   1030 <memcpy@plt>
mov    $0x320,%edx
lea    0xef1e8(%rsp),%rdi
lea    0x102d88(%rsp),%rsi
call   1030 <memcpy@plt>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movups 0x8b7d8(%rsp,%rax,8),%xmm0
movupd 0x8b7e8(%rsp,%rax,8),%xmm1
movups %xmm0,0x9f378(%rsp,%rax,8)
movapd 0x77900(%rsp,%rax,8),%xmm0
movapd 0x77910(%rsp,%rax,8),%xmm2
movapd %xmm0,0x8b4a0(%rsp,%rax,8)
movupd %xmm1,0x9f388(%rsp,%rax,8)
movapd %xmm2,0x8b4b0(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x64,%rax
jne    12b0 <main+0x1a0>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0xdb638(%rsp,%rax,1),%xmm0
movsd  %xmm0,0xdb958(%rsp,%rax,1)
movsd  0x8baf0(%rsp,%rax,1),%xmm0
movsd  %xmm0,0x8b7d0(%rsp,%rax,1)
movsd  0xef828(%rsp,%rax,1),%xmm0
movsd  %xmm0,0xef508(%rsp,%rax,1)
movsd  0x77900(%rsp,%rax,1),%xmm0
movsd  %xmm0,0x77c20(%rsp,%rax,1)
add    $0x328,%rax
cmp    $0x13ba0,%rax
jne    1310 <main+0x200>
movsd  0xeeeb0(%rsp),%xmm0
movsd  %xmm0,0xdb630(%rsp)
movsd  0x8baf0(%rsp),%xmm0
movsd  %xmm0,0x9f370(%rsp)
movsd  0x77900(%rsp),%xmm0
movsd  %xmm0,0x8b7c0(%rsp)
mov    $0x320,%edx
lea    0xc7440(%rsp),%rdi
lea    0xdafe0(%rsp),%rsi
call   1030 <memcpy@plt>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups 0x9f6a8(%rsp,%rax,8),%xmm0
movupd 0x9f6b8(%rsp,%rax,8),%xmm1
movups %xmm0,0xb3248(%rsp,%rax,8)
movapd 0xb3570(%rsp,%rax,8),%xmm0
movapd 0xb3580(%rsp,%rax,8),%xmm2
movapd %xmm0,0xc7110(%rsp,%rax,8)
movupd %xmm1,0xb3258(%rsp,%rax,8)
movapd %xmm2,0xc7120(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x64,%rax
jne    13c0 <main+0x2b0>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0xc7768(%rsp,%rax,1),%xmm0
movsd  %xmm0,0xc7a88(%rsp,%rax,1)
movsd  0x9f9c0(%rsp,%rax,1),%xmm0
movsd  %xmm0,0x9f6a0(%rsp,%rax,1)
movsd  0xb3570(%rsp,%rax,1),%xmm0
movsd  %xmm0,0xb3890(%rsp,%rax,1)
add    $0x328,%rax
cmp    $0x13ba0,%rax
jne    1420 <main+0x310>
movsd  0xdafe0(%rsp),%xmm0
movsd  %xmm0,0xc7760(%rsp)
lea    0x4fb60(%rsp),%rbx
lea    0x3bc90(%rsp),%rbp
lea    0x63a30(%rsp),%r14
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
imul   $0x328,%r15,%rax
lea    (%rsp,%rax,1),%rcx
add    $0x13ef0,%rcx
mov    %rcx,0x18(%rsp)
lea    0xb3570(%rsp,%rax,1),%rcx
mov    %rcx,0x10(%rsp)
lea    0x20(%rsp,%rax,1),%r12
lea    0x9f6a0(%rsp,%rax,1),%r13
lea    (%rsp,%rax,1),%rdi
add    $0x27dc0,%rdi
lea    (%rsp,%rax,1),%rsi
add    $0xc7440,%rsi
mov    $0x320,%edx
call   1030 <memcpy@plt>
mov    $0x320,%edx
mov    %r12,%rdi
mov    %r13,%rsi
call   1030 <memcpy@plt>
mov    $0x320,%edx
mov    0x18(%rsp),%rdi
mov    0x10(%rsp),%rsi
call   1030 <memcpy@plt>
mov    $0x2,%eax
movapd 0xaee(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd %xmm0,-0x10(%r14,%rax,8)
movupd %xmm0,-0x10(%rbp,%rax,8)
movupd %xmm0,-0x10(%rbx,%rax,8)
movupd %xmm0,(%r14,%rax,8)
movupd %xmm0,0x0(%rbp,%rax,8)
movupd %xmm0,(%rbx,%rax,8)
add    $0x4,%rax
cmp    $0x66,%rax
jne    1530 <main+0x420>
add    $0x1,%r15
add    $0x328,%r14
add    $0x328,%rbp
add    $0x328,%rbx
cmp    $0x64,%r15
jne    14a0 <main+0x390>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movaps 0x63a30(%rsp,%rax,1),%xmm0
movapd 0x63a40(%rsp,%rax,1),%xmm1
movaps %xmm0,0x775d0(%rsp,%rax,1)
movaps 0x3bc90(%rsp,%rax,1),%xmm0
movapd 0x3bca0(%rsp,%rax,1),%xmm2
movaps %xmm0,0x4f830(%rsp,%rax,1)
movaps 0x4fb60(%rsp,%rax,1),%xmm0
movapd 0x4fb70(%rsp,%rax,1),%xmm3
movaps %xmm0,0x63700(%rsp,%rax,1)
movaps 0x27dc0(%rsp,%rax,1),%xmm0
movapd 0x27dd0(%rsp,%rax,1),%xmm4
movaps %xmm0,0x3b960(%rsp,%rax,1)
movaps 0x20(%rsp,%rax,1),%xmm0
movaps %xmm0,0x13bc0(%rsp,%rax,1)
movaps 0x13ef0(%rsp,%rax,1),%xmm0
movaps %xmm0,0x27a90(%rsp,%rax,1)
movapd %xmm1,0x775e0(%rsp,%rax,1)
movapd %xmm2,0x4f840(%rsp,%rax,1)
movapd %xmm3,0x63710(%rsp,%rax,1)
movapd %xmm4,0x3b970(%rsp,%rax,1)
movaps 0x30(%rsp,%rax,1),%xmm0
movaps %xmm0,0x13bd0(%rsp,%rax,1)
movapd 0x13f00(%rsp,%rax,1),%xmm0
movapd %xmm0,0x27aa0(%rsp,%rax,1)
add    $0x20,%rax
cmp    $0x320,%rax
jne    1590 <main+0x480>
xor    %eax,%eax
movsd  0x992(%rip),%xmm5
movsd  0x992(%rip),%xmm6
cs nopw 0x0(%rax,%rax,1)
movsd  0x63a30(%rsp,%rax,1),%xmm0
movsd  %xmm0,0x63d50(%rsp,%rax,1)
movsd  0x3bc90(%rsp,%rax,1),%xmm0
movsd  %xmm0,0x3bfb0(%rsp,%rax,1)
movsd  0x4fb60(%rsp,%rax,1),%xmm0
movsd  %xmm0,0x4fe80(%rsp,%rax,1)
movsd  0x27dc0(%rsp,%rax,1),%xmm0
movsd  %xmm0,0x280e0(%rsp,%rax,1)
movsd  0x20(%rsp,%rax,1),%xmm0
movsd  %xmm0,0x340(%rsp,%rax,1)
movsd  0x13ef0(%rsp,%rax,1),%xmm0
movsd  %xmm0,0x14210(%rsp,%rax,1)
add    $0x328,%rax
cmp    $0x13ba0,%rax
jne    1680 <main+0x570>
movsd  0x63a30(%rsp),%xmm0
movsd  %xmm0,0x778f0(%rsp)
movsd  0x3bc90(%rsp),%xmm0
movsd  %xmm0,0x4fb50(%rsp)
movsd  0x4fb60(%rsp),%xmm0
movsd  %xmm0,0x63a20(%rsp)
movsd  0x27dc0(%rsp),%xmm0
movsd  %xmm0,0x3bc80(%rsp)
movsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x13ee0(%rsp)
movsd  0x13ef0(%rsp),%xmm1
movsd  %xmm1,0x27db0(%rsp)
mov    0x8(%rsp),%rax
add    $0x1,%eax
cmp    $0xa,%eax
jne    1140 <main+0x30>
xor    %eax,%eax
add    $0x1030a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca [101 x [101 x double]]
%14 = alloca [101 x [101 x double]]
%15 = alloca [101 x [101 x double]]
%16 = alloca [101 x [101 x double]]
%17 = alloca [101 x [101 x double]]
%18 = alloca [101 x [101 x double]]
%19 = alloca [101 x [101 x double]]
%20 = alloca [101 x [101 x double]]
%21 = alloca [101 x [101 x double]]
%22 = alloca [101 x [101 x double]]
%23 = alloca [101 x [101 x double]]
%24 = alloca [101 x [101 x double]]
%25 = alloca [101 x [101 x double]]
%26 = alloca double
store i32 0, i32* %1
store i32 0, i32* %10
br label %27
27: ; preds = %1072, %0
%28 = load i32, i32* %10
%29 = icmp slt i32 %28, 10
br i1 %29, label %30, label %1075
30: ; preds = %27
%31 = load i32, i32* %2
%32 = sdiv i32 4, %31
store i32 %32, i32* %4
%33 = load i32, i32* %3
%34 = sdiv i32 4, %33
store i32 %34, i32* %5
store i32 0, i32* %11
br label %35
35: ; preds = %278, %30
%36 = load i32, i32* %11
%37 = icmp slt i32 %36, 100
br i1 %37, label %38, label %281
38: ; preds = %35
store i32 0, i32* %12
br label %39
39: ; preds = %274, %38
%40 = load i32, i32* %12
%41 = icmp slt i32 %40, 100
br i1 %41, label %42, label %277
42: ; preds = %39
%43 = load i32, i32* %11
%44 = add nsw i32 %43, 1
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %17, i64 0, i64 %45
%47 = load i32, i32* %12
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds [101 x double], [101 x double]* %46, i64 0, i64 %48
%50 = load double, double* %49
%51 = load i32, i32* %11
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %17, i64 0, i64 %52
%54 = load i32, i32* %12
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds [101 x double], [101 x double]* %53, i64 0, i64 %55
%57 = load double, double* %56
%58 = fadd double %50, %57
%59 = fmul double 5.000000e-01, %58
%60 = load i32, i32* %11
%61 = add nsw i32 %60, 1
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %18, i64 0, i64 %62
%64 = load i32, i32* %12
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds [101 x double], [101 x double]* %63, i64 0, i64 %65
%67 = load double, double* %66
%68 = fmul double %59, %67
%69 = load i32, i32* %11
%70 = add nsw i32 %69, 1
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 %71
%73 = load i32, i32* %12
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [101 x double], [101 x double]* %72, i64 0, i64 %74
store double %68, double* %75
%76 = load i32, i32* %11
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %17, i64 0, i64 %77
%79 = load i32, i32* %12
%80 = add nsw i32 %79, 1
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds [101 x double], [101 x double]* %78, i64 0, i64 %81
%83 = load double, double* %82
%84 = load i32, i32* %11
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %17, i64 0, i64 %85
%87 = load i32, i32* %12
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds [101 x double], [101 x double]* %86, i64 0, i64 %88
%90 = load double, double* %89
%91 = fadd double %83, %90
%92 = fmul double 5.000000e-01, %91
%93 = load i32, i32* %11
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %19, i64 0, i64 %94
%96 = load i32, i32* %12
%97 = add nsw i32 %96, 1
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds [101 x double], [101 x double]* %95, i64 0, i64 %98
%100 = load double, double* %99
%101 = fmul double %92, %100
%102 = load i32, i32* %11
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %14, i64 0, i64 %103
%105 = load i32, i32* %12
%106 = add nsw i32 %105, 1
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds [101 x double], [101 x double]* %104, i64 0, i64 %107
store double %101, double* %108
%109 = load i32, i32* %4
%110 = sitofp i32 %109 to double
%111 = load i32, i32* %11
%112 = add nsw i32 %111, 1
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %19, i64 0, i64 %113
%115 = load i32, i32* %12
%116 = add nsw i32 %115, 1
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds [101 x double], [101 x double]* %114, i64 0, i64 %117
%119 = load double, double* %118
%120 = load i32, i32* %11
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %19, i64 0, i64 %121
%123 = load i32, i32* %12
%124 = add nsw i32 %123, 1
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds [101 x double], [101 x double]* %122, i64 0, i64 %125
%127 = load double, double* %126
%128 = fsub double %119, %127
%129 = load i32, i32* %5
%130 = sitofp i32 %129 to double
%131 = load i32, i32* %11
%132 = add nsw i32 %131, 1
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %18, i64 0, i64 %133
%135 = load i32, i32* %12
%136 = add nsw i32 %135, 1
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds [101 x double], [101 x double]* %134, i64 0, i64 %137
%139 = load double, double* %138
%140 = load i32, i32* %11
%141 = add nsw i32 %140, 1
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %18, i64 0, i64 %142
%144 = load i32, i32* %12
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds [101 x double], [101 x double]* %143, i64 0, i64 %145
%147 = load double, double* %146
%148 = fsub double %139, %147
%149 = fmul double %130, %148
%150 = fneg double %149
%151 = call double @llvm.fmuladd.f64(double %110, double %128, double %150)
%152 = load i32, i32* %11
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %17, i64 0, i64 %153
%155 = load i32, i32* %12
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds [101 x double], [101 x double]* %154, i64 0, i64 %156
%158 = load double, double* %157
%159 = load i32, i32* %11
%160 = add nsw i32 %159, 1
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %17, i64 0, i64 %161
%163 = load i32, i32* %12
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds [101 x double], [101 x double]* %162, i64 0, i64 %164
%166 = load double, double* %165
%167 = fadd double %158, %166
%168 = load i32, i32* %11
%169 = add nsw i32 %168, 1
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %17, i64 0, i64 %170
%172 = load i32, i32* %12
%173 = add nsw i32 %172, 1
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds [101 x double], [101 x double]* %171, i64 0, i64 %174
%176 = load double, double* %175
%177 = fadd double %167, %176
%178 = load i32, i32* %11
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %17, i64 0, i64 %179
%181 = load i32, i32* %12
%182 = add nsw i32 %181, 1
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds [101 x double], [101 x double]* %180, i64 0, i64 %183
%185 = load double, double* %184
%186 = fadd double %177, %185
%187 = fdiv double %151, %186
%188 = load i32, i32* %11
%189 = add nsw i32 %188, 1
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 %190
%192 = load i32, i32* %12
%193 = add nsw i32 %192, 1
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds [101 x double], [101 x double]* %191, i64 0, i64 %194
store double %187, double* %195
%196 = load i32, i32* %11
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %17, i64 0, i64 %197
%199 = load i32, i32* %12
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds [101 x double], [101 x double]* %198, i64 0, i64 %200
%202 = load double, double* %201
%203 = load i32, i32* %11
%204 = add nsw i32 %203, 1
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %18, i64 0, i64 %205
%207 = load i32, i32* %12
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds [101 x double], [101 x double]* %206, i64 0, i64 %208
%210 = load double, double* %209
%211 = load i32, i32* %11
%212 = add nsw i32 %211, 1
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %18, i64 0, i64 %213
%215 = load i32, i32* %12
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds [101 x double], [101 x double]* %214, i64 0, i64 %216
%218 = load double, double* %217
%219 = load i32, i32* %11
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %18, i64 0, i64 %220
%222 = load i32, i32* %12
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds [101 x double], [101 x double]* %221, i64 0, i64 %223
%225 = load double, double* %224
%226 = load i32, i32* %11
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %18, i64 0, i64 %227
%229 = load i32, i32* %12
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds [101 x double], [101 x double]* %228, i64 0, i64 %230
%232 = load double, double* %231
%233 = fmul double %225, %232
%234 = call double @llvm.fmuladd.f64(double %210, double %218, double %233)
%235 = load i32, i32* %11
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %19, i64 0, i64 %236
%238 = load i32, i32* %12
%239 = add nsw i32 %238, 1
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds [101 x double], [101 x double]* %237, i64 0, i64 %240
%242 = load double, double* %241
%243 = load i32, i32* %11
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %19, i64 0, i64 %244
%246 = load i32, i32* %12
%247 = add nsw i32 %246, 1
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds [101 x double], [101 x double]* %245, i64 0, i64 %248
%250 = load double, double* %249
%251 = call double @llvm.fmuladd.f64(double %242, double %250, double %234)
%252 = load i32, i32* %11
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %19, i64 0, i64 %253
%255 = load i32, i32* %12
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds [101 x double], [101 x double]* %254, i64 0, i64 %256
%258 = load double, double* %257
%259 = load i32, i32* %11
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %19, i64 0, i64 %260
%262 = load i32, i32* %12
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds [101 x double], [101 x double]* %261, i64 0, i64 %263
%265 = load double, double* %264
%266 = call double @llvm.fmuladd.f64(double %258, double %265, double %251)
%267 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %266, double %202)
%268 = load i32, i32* %11
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %16, i64 0, i64 %269
%271 = load i32, i32* %12
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds [101 x double], [101 x double]* %270, i64 0, i64 %272
store double %267, double* %273
br label %274
274: ; preds = %42
%275 = load i32, i32* %12
%276 = add nsw i32 %275, 1
store i32 %276, i32* %12
br label %39
277: ; preds = %39
br label %278
278: ; preds = %277
%279 = load i32, i32* %11
%280 = add nsw i32 %279, 1
store i32 %280, i32* %11
br label %35
281: ; preds = %35
store i32 0, i32* %12
br label %282
282: ; preds = %326, %281
%283 = load i32, i32* %12
%284 = icmp slt i32 %283, 100
br i1 %284, label %285, label %329
285: ; preds = %282
%286 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 100
%287 = load i32, i32* %12
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds [101 x double], [101 x double]* %286, i64 0, i64 %288
%290 = load double, double* %289
%291 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 0
%292 = load i32, i32* %12
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds [101 x double], [101 x double]* %291, i64 0, i64 %293
store double %290, double* %294
%295 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %14, i64 0, i64 0
%296 = load i32, i32* %12
%297 = add nsw i32 %296, 1
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds [101 x double], [101 x double]* %295, i64 0, i64 %298
%300 = load double, double* %299
%301 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %14, i64 0, i64 100
%302 = load i32, i32* %12
%303 = add nsw i32 %302, 1
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds [101 x double], [101 x double]* %301, i64 0, i64 %304
store double %300, double* %305
%306 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 100
%307 = load i32, i32* %12
%308 = add nsw i32 %307, 1
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds [101 x double], [101 x double]* %306, i64 0, i64 %309
%311 = load double, double* %310
%312 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 0
%313 = load i32, i32* %12
%314 = add nsw i32 %313, 1
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds [101 x double], [101 x double]* %312, i64 0, i64 %315
store double %311, double* %316
%317 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %16, i64 0, i64 0
%318 = load i32, i32* %12
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds [101 x double], [101 x double]* %317, i64 0, i64 %319
%321 = load double, double* %320
%322 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %16, i64 0, i64 100
%323 = load i32, i32* %12
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds [101 x double], [101 x double]* %322, i64 0, i64 %324
store double %321, double* %325
br label %326
326: ; preds = %285
%327 = load i32, i32* %12
%328 = add nsw i32 %327, 1
store i32 %328, i32* %12
br label %282
329: ; preds = %282
store i32 0, i32* %11
br label %330
330: ; preds = %374, %329
%331 = load i32, i32* %11
%332 = icmp slt i32 %331, 100
br i1 %332, label %333, label %377
333: ; preds = %330
%334 = load i32, i32* %11
%335 = add nsw i32 %334, 1
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 %336
%338 = getelementptr inbounds [101 x double], [101 x double]* %337, i64 0, i64 0
%339 = load double, double* %338
%340 = load i32, i32* %11
%341 = add nsw i32 %340, 1
%342 = sext i32 %341 to i64
%343 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 %342
%344 = getelementptr inbounds [101 x double], [101 x double]* %343, i64 0, i64 100
store double %339, double* %344
%345 = load i32, i32* %11
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %14, i64 0, i64 %346
%348 = getelementptr inbounds [101 x double], [101 x double]* %347, i64 0, i64 100
%349 = load double, double* %348
%350 = load i32, i32* %11
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %14, i64 0, i64 %351
%353 = getelementptr inbounds [101 x double], [101 x double]* %352, i64 0, i64 0
store double %349, double* %353
%354 = load i32, i32* %11
%355 = add nsw i32 %354, 1
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 %356
%358 = getelementptr inbounds [101 x double], [101 x double]* %357, i64 0, i64 100
%359 = load double, double* %358
%360 = load i32, i32* %11
%361 = add nsw i32 %360, 1
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 %362
%364 = getelementptr inbounds [101 x double], [101 x double]* %363, i64 0, i64 0
store double %359, double* %364
%365 = load i32, i32* %11
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %16, i64 0, i64 %366
%368 = getelementptr inbounds [101 x double], [101 x double]* %367, i64 0, i64 0
%369 = load double, double* %368
%370 = load i32, i32* %11
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %16, i64 0, i64 %371
%373 = getelementptr inbounds [101 x double], [101 x double]* %372, i64 0, i64 100
store double %369, double* %373
br label %374
374: ; preds = %333
%375 = load i32, i32* %11
%376 = add nsw i32 %375, 1
store i32 %376, i32* %11
br label %330
377: ; preds = %330
%378 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 100
%379 = getelementptr inbounds [101 x double], [101 x double]* %378, i64 0, i64 0
%380 = load double, double* %379
%381 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 0
%382 = getelementptr inbounds [101 x double], [101 x double]* %381, i64 0, i64 100
store double %380, double* %382
%383 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %14, i64 0, i64 0
%384 = getelementptr inbounds [101 x double], [101 x double]* %383, i64 0, i64 100
%385 = load double, double* %384
%386 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %14, i64 0, i64 100
%387 = getelementptr inbounds [101 x double], [101 x double]* %386, i64 0, i64 0
store double %385, double* %387
%388 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 100
%389 = getelementptr inbounds [101 x double], [101 x double]* %388, i64 0, i64 100
%390 = load double, double* %389
%391 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 0
%392 = getelementptr inbounds [101 x double], [101 x double]* %391, i64 0, i64 0
store double %390, double* %392
%393 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %16, i64 0, i64 0
%394 = getelementptr inbounds [101 x double], [101 x double]* %393, i64 0, i64 0
%395 = load double, double* %394
%396 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %16, i64 0, i64 100
%397 = getelementptr inbounds [101 x double], [101 x double]* %396, i64 0, i64 100
store double %395, double* %397
%398 = load i32, i32* %6
%399 = sdiv i32 %398, 8
store i32 %399, i32* %7
%400 = load i32, i32* %6
%401 = load i32, i32* %2
%402 = sdiv i32 %400, %401
store i32 %402, i32* %8
%403 = load i32, i32* %6
%404 = load i32, i32* %3
%405 = sdiv i32 %403, %404
store i32 %405, i32* %9
store i32 0, i32* %11
br label %406
406: ; preds = %656, %377
%407 = load i32, i32* %11
%408 = icmp slt i32 %407, 100
br i1 %408, label %409, label %659
409: ; preds = %406
store i32 0, i32* %12
br label %410
410: ; preds = %652, %409
%411 = load i32, i32* %12
%412 = icmp slt i32 %411, 100
br i1 %412, label %413, label %655
413: ; preds = %410
%414 = load i32, i32* %11
%415 = add nsw i32 %414, 1
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %21, i64 0, i64 %416
%418 = load i32, i32* %12
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds [101 x double], [101 x double]* %417, i64 0, i64 %419
%421 = load double, double* %420
%422 = load i32, i32* %7
%423 = sitofp i32 %422 to double
%424 = load i32, i32* %11
%425 = add nsw i32 %424, 1
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 %426
%428 = load i32, i32* %12
%429 = add nsw i32 %428, 1
%430 = sext i32 %429 to i64
%431 = getelementptr inbounds [101 x double], [101 x double]* %427, i64 0, i64 %430
%432 = load double, double* %431
%433 = load i32, i32* %11
%434 = add nsw i32 %433, 1
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 %435
%437 = load i32, i32* %12
%438 = sext i32 %437 to i64
%439 = getelementptr inbounds [101 x double], [101 x double]* %436, i64 0, i64 %438
%440 = load double, double* %439
%441 = fadd double %432, %440
%442 = fmul double %423, %441
%443 = load i32, i32* %11
%444 = add nsw i32 %443, 1
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %14, i64 0, i64 %445
%447 = load i32, i32* %12
%448 = add nsw i32 %447, 1
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds [101 x double], [101 x double]* %446, i64 0, i64 %449
%451 = load double, double* %450
%452 = load i32, i32* %11
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %14, i64 0, i64 %453
%455 = load i32, i32* %12
%456 = add nsw i32 %455, 1
%457 = sext i32 %456 to i64
%458 = getelementptr inbounds [101 x double], [101 x double]* %454, i64 0, i64 %457
%459 = load double, double* %458
%460 = fadd double %451, %459
%461 = load i32, i32* %11
%462 = sext i32 %461 to i64
%463 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %14, i64 0, i64 %462
%464 = load i32, i32* %12
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds [101 x double], [101 x double]* %463, i64 0, i64 %465
%467 = load double, double* %466
%468 = fadd double %460, %467
%469 = load i32, i32* %11
%470 = add nsw i32 %469, 1
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %14, i64 0, i64 %471
%473 = load i32, i32* %12
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds [101 x double], [101 x double]* %472, i64 0, i64 %474
%476 = load double, double* %475
%477 = fadd double %468, %476
%478 = call double @llvm.fmuladd.f64(double %442, double %477, double %421)
%479 = load i32, i32* %8
%480 = sitofp i32 %479 to double
%481 = load i32, i32* %11
%482 = add nsw i32 %481, 1
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %16, i64 0, i64 %483
%485 = load i32, i32* %12
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds [101 x double], [101 x double]* %484, i64 0, i64 %486
%488 = load double, double* %487
%489 = load i32, i32* %11
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %16, i64 0, i64 %490
%492 = load i32, i32* %12
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds [101 x double], [101 x double]* %491, i64 0, i64 %493
%495 = load double, double* %494
%496 = fsub double %488, %495
%497 = fneg double %480
%498 = call double @llvm.fmuladd.f64(double %497, double %496, double %478)
%499 = load i32, i32* %11
%500 = add nsw i32 %499, 1
%501 = sext i32 %500 to i64
%502 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %20, i64 0, i64 %501
%503 = load i32, i32* %12
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds [101 x double], [101 x double]* %502, i64 0, i64 %504
store double %498, double* %505
%506 = load i32, i32* %11
%507 = sext i32 %506 to i64
%508 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %25, i64 0, i64 %507
%509 = load i32, i32* %12
%510 = add nsw i32 %509, 1
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds [101 x double], [101 x double]* %508, i64 0, i64 %511
%513 = load double, double* %512
%514 = load i32, i32* %7
%515 = sitofp i32 %514 to double
%516 = load i32, i32* %11
%517 = add nsw i32 %516, 1
%518 = sext i32 %517 to i64
%519 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 %518
%520 = load i32, i32* %12
%521 = add nsw i32 %520, 1
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds [101 x double], [101 x double]* %519, i64 0, i64 %522
%524 = load double, double* %523
%525 = load i32, i32* %11
%526 = sext i32 %525 to i64
%527 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 %526
%528 = load i32, i32* %12
%529 = add nsw i32 %528, 1
%530 = sext i32 %529 to i64
%531 = getelementptr inbounds [101 x double], [101 x double]* %527, i64 0, i64 %530
%532 = load double, double* %531
%533 = fadd double %524, %532
%534 = fmul double %515, %533
%535 = load i32, i32* %11
%536 = add nsw i32 %535, 1
%537 = sext i32 %536 to i64
%538 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 %537
%539 = load i32, i32* %12
%540 = add nsw i32 %539, 1
%541 = sext i32 %540 to i64
%542 = getelementptr inbounds [101 x double], [101 x double]* %538, i64 0, i64 %541
%543 = load double, double* %542
%544 = load i32, i32* %11
%545 = sext i32 %544 to i64
%546 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 %545
%547 = load i32, i32* %12
%548 = add nsw i32 %547, 1
%549 = sext i32 %548 to i64
%550 = getelementptr inbounds [101 x double], [101 x double]* %546, i64 0, i64 %549
%551 = load double, double* %550
%552 = fadd double %543, %551
%553 = load i32, i32* %11
%554 = sext i32 %553 to i64
%555 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 %554
%556 = load i32, i32* %12
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds [101 x double], [101 x double]* %555, i64 0, i64 %557
%559 = load double, double* %558
%560 = fadd double %552, %559
%561 = load i32, i32* %11
%562 = add nsw i32 %561, 1
%563 = sext i32 %562 to i64
%564 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 %563
%565 = load i32, i32* %12
%566 = sext i32 %565 to i64
%567 = getelementptr inbounds [101 x double], [101 x double]* %564, i64 0, i64 %566
%568 = load double, double* %567
%569 = fadd double %560, %568
%570 = fneg double %534
%571 = call double @llvm.fmuladd.f64(double %570, double %569, double %513)
%572 = load i32, i32* %9
%573 = sitofp i32 %572 to double
%574 = load i32, i32* %11
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %16, i64 0, i64 %575
%577 = load i32, i32* %12
%578 = add nsw i32 %577, 1
%579 = sext i32 %578 to i64
%580 = getelementptr inbounds [101 x double], [101 x double]* %576, i64 0, i64 %579
%581 = load double, double* %580
%582 = load i32, i32* %11
%583 = sext i32 %582 to i64
%584 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %16, i64 0, i64 %583
%585 = load i32, i32* %12
%586 = sext i32 %585 to i64
%587 = getelementptr inbounds [101 x double], [101 x double]* %584, i64 0, i64 %586
%588 = load double, double* %587
%589 = fsub double %581, %588
%590 = fneg double %573
%591 = call double @llvm.fmuladd.f64(double %590, double %589, double %571)
%592 = load i32, i32* %11
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %24, i64 0, i64 %593
%595 = load i32, i32* %12
%596 = add nsw i32 %595, 1
%597 = sext i32 %596 to i64
%598 = getelementptr inbounds [101 x double], [101 x double]* %594, i64 0, i64 %597
store double %591, double* %598
%599 = load i32, i32* %11
%600 = sext i32 %599 to i64
%601 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %23, i64 0, i64 %600
%602 = load i32, i32* %12
%603 = sext i32 %602 to i64
%604 = getelementptr inbounds [101 x double], [101 x double]* %601, i64 0, i64 %603
%605 = load double, double* %604
%606 = load i32, i32* %8
%607 = sitofp i32 %606 to double
%608 = load i32, i32* %11
%609 = add nsw i32 %608, 1
%610 = sext i32 %609 to i64
%611 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 %610
%612 = load i32, i32* %12
%613 = sext i32 %612 to i64
%614 = getelementptr inbounds [101 x double], [101 x double]* %611, i64 0, i64 %613
%615 = load double, double* %614
%616 = load i32, i32* %11
%617 = sext i32 %616 to i64
%618 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 %617
%619 = load i32, i32* %12
%620 = sext i32 %619 to i64
%621 = getelementptr inbounds [101 x double], [101 x double]* %618, i64 0, i64 %620
%622 = load double, double* %621
%623 = fsub double %615, %622
%624 = fneg double %607
%625 = call double @llvm.fmuladd.f64(double %624, double %623, double %605)
%626 = load i32, i32* %9
%627 = sitofp i32 %626 to double
%628 = load i32, i32* %11
%629 = sext i32 %628 to i64
%630 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %14, i64 0, i64 %629
%631 = load i32, i32* %12
%632 = add nsw i32 %631, 1
%633 = sext i32 %632 to i64
%634 = getelementptr inbounds [101 x double], [101 x double]* %630, i64 0, i64 %633
%635 = load double, double* %634
%636 = load i32, i32* %11
%637 = sext i32 %636 to i64
%638 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %14, i64 0, i64 %637
%639 = load i32, i32* %12
%640 = sext i32 %639 to i64
%641 = getelementptr inbounds [101 x double], [101 x double]* %638, i64 0, i64 %640
%642 = load double, double* %641
%643 = fsub double %635, %642
%644 = fneg double %627
%645 = call double @llvm.fmuladd.f64(double %644, double %643, double %625)
%646 = load i32, i32* %11
%647 = sext i32 %646 to i64
%648 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %22, i64 0, i64 %647
%649 = load i32, i32* %12
%650 = sext i32 %649 to i64
%651 = getelementptr inbounds [101 x double], [101 x double]* %648, i64 0, i64 %650
store double %645, double* %651
br label %652
652: ; preds = %413
%653 = load i32, i32* %12
%654 = add nsw i32 %653, 1
store i32 %654, i32* %12
br label %410
655: ; preds = %410
br label %656
656: ; preds = %655
%657 = load i32, i32* %11
%658 = add nsw i32 %657, 1
store i32 %658, i32* %11
br label %406
659: ; preds = %406
store i32 0, i32* %12
br label %660
660: ; preds = %693, %659
%661 = load i32, i32* %12
%662 = icmp slt i32 %661, 100
br i1 %662, label %663, label %696
663: ; preds = %660
%664 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %20, i64 0, i64 100
%665 = load i32, i32* %12
%666 = sext i32 %665 to i64
%667 = getelementptr inbounds [101 x double], [101 x double]* %664, i64 0, i64 %666
%668 = load double, double* %667
%669 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %20, i64 0, i64 0
%670 = load i32, i32* %12
%671 = sext i32 %670 to i64
%672 = getelementptr inbounds [101 x double], [101 x double]* %669, i64 0, i64 %671
store double %668, double* %672
%673 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %24, i64 0, i64 0
%674 = load i32, i32* %12
%675 = add nsw i32 %674, 1
%676 = sext i32 %675 to i64
%677 = getelementptr inbounds [101 x double], [101 x double]* %673, i64 0, i64 %676
%678 = load double, double* %677
%679 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %24, i64 0, i64 100
%680 = load i32, i32* %12
%681 = add nsw i32 %680, 1
%682 = sext i32 %681 to i64
%683 = getelementptr inbounds [101 x double], [101 x double]* %679, i64 0, i64 %682
store double %678, double* %683
%684 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %22, i64 0, i64 0
%685 = load i32, i32* %12
%686 = sext i32 %685 to i64
%687 = getelementptr inbounds [101 x double], [101 x double]* %684, i64 0, i64 %686
%688 = load double, double* %687
%689 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %22, i64 0, i64 100
%690 = load i32, i32* %12
%691 = sext i32 %690 to i64
%692 = getelementptr inbounds [101 x double], [101 x double]* %689, i64 0, i64 %691
store double %688, double* %692
br label %693
693: ; preds = %663
%694 = load i32, i32* %12
%695 = add nsw i32 %694, 1
store i32 %695, i32* %12
br label %660
696: ; preds = %660
store i32 0, i32* %11
br label %697
697: ; preds = %730, %696
%698 = load i32, i32* %11
%699 = icmp slt i32 %698, 100
br i1 %699, label %700, label %733
700: ; preds = %697
%701 = load i32, i32* %11
%702 = add nsw i32 %701, 1
%703 = sext i32 %702 to i64
%704 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %20, i64 0, i64 %703
%705 = getelementptr inbounds [101 x double], [101 x double]* %704, i64 0, i64 0
%706 = load double, double* %705
%707 = load i32, i32* %11
%708 = add nsw i32 %707, 1
%709 = sext i32 %708 to i64
%710 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %20, i64 0, i64 %709
%711 = getelementptr inbounds [101 x double], [101 x double]* %710, i64 0, i64 100
store double %706, double* %711
%712 = load i32, i32* %11
%713 = sext i32 %712 to i64
%714 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %24, i64 0, i64 %713
%715 = getelementptr inbounds [101 x double], [101 x double]* %714, i64 0, i64 100
%716 = load double, double* %715
%717 = load i32, i32* %11
%718 = sext i32 %717 to i64
%719 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %24, i64 0, i64 %718
%720 = getelementptr inbounds [101 x double], [101 x double]* %719, i64 0, i64 0
store double %716, double* %720
%721 = load i32, i32* %11
%722 = sext i32 %721 to i64
%723 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %22, i64 0, i64 %722
%724 = getelementptr inbounds [101 x double], [101 x double]* %723, i64 0, i64 0
%725 = load double, double* %724
%726 = load i32, i32* %11
%727 = sext i32 %726 to i64
%728 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %22, i64 0, i64 %727
%729 = getelementptr inbounds [101 x double], [101 x double]* %728, i64 0, i64 100
store double %725, double* %729
br label %730
730: ; preds = %700
%731 = load i32, i32* %11
%732 = add nsw i32 %731, 1
store i32 %732, i32* %11
br label %697
733: ; preds = %697
%734 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %20, i64 0, i64 100
%735 = getelementptr inbounds [101 x double], [101 x double]* %734, i64 0, i64 0
%736 = load double, double* %735
%737 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %20, i64 0, i64 0
%738 = getelementptr inbounds [101 x double], [101 x double]* %737, i64 0, i64 100
store double %736, double* %738
%739 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %24, i64 0, i64 0
%740 = getelementptr inbounds [101 x double], [101 x double]* %739, i64 0, i64 100
%741 = load double, double* %740
%742 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %24, i64 0, i64 100
%743 = getelementptr inbounds [101 x double], [101 x double]* %742, i64 0, i64 0
store double %741, double* %743
%744 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %22, i64 0, i64 0
%745 = getelementptr inbounds [101 x double], [101 x double]* %744, i64 0, i64 0
%746 = load double, double* %745
%747 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %22, i64 0, i64 100
%748 = getelementptr inbounds [101 x double], [101 x double]* %747, i64 0, i64 100
store double %746, double* %748
store i32 0, i32* %11
br label %749
749: ; preds = %914, %733
%750 = load i32, i32* %11
%751 = icmp slt i32 %750, 100
br i1 %751, label %752, label %917
752: ; preds = %749
store i32 0, i32* %12
br label %753
753: ; preds = %910, %752
%754 = load i32, i32* %12
%755 = icmp slt i32 %754, 100
br i1 %755, label %756, label %913
756: ; preds = %753
%757 = load i32, i32* %11
%758 = sext i32 %757 to i64
%759 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %18, i64 0, i64 %758
%760 = load i32, i32* %12
%761 = sext i32 %760 to i64
%762 = getelementptr inbounds [101 x double], [101 x double]* %759, i64 0, i64 %761
%763 = load double, double* %762
%764 = load double, double* %26
%765 = load i32, i32* %11
%766 = sext i32 %765 to i64
%767 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %20, i64 0, i64 %766
%768 = load i32, i32* %12
%769 = sext i32 %768 to i64
%770 = getelementptr inbounds [101 x double], [101 x double]* %767, i64 0, i64 %769
%771 = load double, double* %770
%772 = load i32, i32* %11
%773 = sext i32 %772 to i64
%774 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %18, i64 0, i64 %773
%775 = load i32, i32* %12
%776 = sext i32 %775 to i64
%777 = getelementptr inbounds [101 x double], [101 x double]* %774, i64 0, i64 %776
%778 = load double, double* %777
%779 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %778, double %771)
%780 = load i32, i32* %11
%781 = sext i32 %780 to i64
%782 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %21, i64 0, i64 %781
%783 = load i32, i32* %12
%784 = sext i32 %783 to i64
%785 = getelementptr inbounds [101 x double], [101 x double]* %782, i64 0, i64 %784
%786 = load double, double* %785
%787 = fadd double %779, %786
%788 = call double @llvm.fmuladd.f64(double %764, double %787, double %763)
%789 = load i32, i32* %11
%790 = sext i32 %789 to i64
%791 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %21, i64 0, i64 %790
%792 = load i32, i32* %12
%793 = sext i32 %792 to i64
%794 = getelementptr inbounds [101 x double], [101 x double]* %791, i64 0, i64 %793
store double %788, double* %794
%795 = load i32, i32* %11
%796 = sext i32 %795 to i64
%797 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %19, i64 0, i64 %796
%798 = load i32, i32* %12
%799 = sext i32 %798 to i64
%800 = getelementptr inbounds [101 x double], [101 x double]* %797, i64 0, i64 %799
%801 = load double, double* %800
%802 = load double, double* %26
%803 = load i32, i32* %11
%804 = sext i32 %803 to i64
%805 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %24, i64 0, i64 %804
%806 = load i32, i32* %12
%807 = sext i32 %806 to i64
%808 = getelementptr inbounds [101 x double], [101 x double]* %805, i64 0, i64 %807
%809 = load double, double* %808
%810 = load i32, i32* %11
%811 = sext i32 %810 to i64
%812 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %19, i64 0, i64 %811
%813 = load i32, i32* %12
%814 = sext i32 %813 to i64
%815 = getelementptr inbounds [101 x double], [101 x double]* %812, i64 0, i64 %814
%816 = load double, double* %815
%817 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %816, double %809)
%818 = load i32, i32* %11
%819 = sext i32 %818 to i64
%820 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %25, i64 0, i64 %819
%821 = load i32, i32* %12
%822 = sext i32 %821 to i64
%823 = getelementptr inbounds [101 x double], [101 x double]* %820, i64 0, i64 %822
%824 = load double, double* %823
%825 = fadd double %817, %824
%826 = call double @llvm.fmuladd.f64(double %802, double %825, double %801)
%827 = load i32, i32* %11
%828 = sext i32 %827 to i64
%829 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %25, i64 0, i64 %828
%830 = load i32, i32* %12
%831 = sext i32 %830 to i64
%832 = getelementptr inbounds [101 x double], [101 x double]* %829, i64 0, i64 %831
store double %826, double* %832
%833 = load i32, i32* %11
%834 = sext i32 %833 to i64
%835 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %17, i64 0, i64 %834
%836 = load i32, i32* %12
%837 = sext i32 %836 to i64
%838 = getelementptr inbounds [101 x double], [101 x double]* %835, i64 0, i64 %837
%839 = load double, double* %838
%840 = load double, double* %26
%841 = load i32, i32* %11
%842 = sext i32 %841 to i64
%843 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %22, i64 0, i64 %842
%844 = load i32, i32* %12
%845 = sext i32 %844 to i64
%846 = getelementptr inbounds [101 x double], [101 x double]* %843, i64 0, i64 %845
%847 = load double, double* %846
%848 = load i32, i32* %11
%849 = sext i32 %848 to i64
%850 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %17, i64 0, i64 %849
%851 = load i32, i32* %12
%852 = sext i32 %851 to i64
%853 = getelementptr inbounds [101 x double], [101 x double]* %850, i64 0, i64 %852
%854 = load double, double* %853
%855 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %854, double %847)
%856 = load i32, i32* %11
%857 = sext i32 %856 to i64
%858 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %23, i64 0, i64 %857
%859 = load i32, i32* %12
%860 = sext i32 %859 to i64
%861 = getelementptr inbounds [101 x double], [101 x double]* %858, i64 0, i64 %860
%862 = load double, double* %861
%863 = fadd double %855, %862
%864 = call double @llvm.fmuladd.f64(double %840, double %863, double %839)
%865 = load i32, i32* %11
%866 = sext i32 %865 to i64
%867 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %23, i64 0, i64 %866
%868 = load i32, i32* %12
%869 = sext i32 %868 to i64
%870 = getelementptr inbounds [101 x double], [101 x double]* %867, i64 0, i64 %869
store double %864, double* %870
%871 = load i32, i32* %11
%872 = sext i32 %871 to i64
%873 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %20, i64 0, i64 %872
%874 = load i32, i32* %12
%875 = sext i32 %874 to i64
%876 = getelementptr inbounds [101 x double], [101 x double]* %873, i64 0, i64 %875
%877 = load double, double* %876
%878 = load i32, i32* %11
%879 = sext i32 %878 to i64
%880 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %18, i64 0, i64 %879
%881 = load i32, i32* %12
%882 = sext i32 %881 to i64
%883 = getelementptr inbounds [101 x double], [101 x double]* %880, i64 0, i64 %882
store double %877, double* %883
%884 = load i32, i32* %11
%885 = sext i32 %884 to i64
%886 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %24, i64 0, i64 %885
%887 = load i32, i32* %12
%888 = sext i32 %887 to i64
%889 = getelementptr inbounds [101 x double], [101 x double]* %886, i64 0, i64 %888
%890 = load double, double* %889
%891 = load i32, i32* %11
%892 = sext i32 %891 to i64
%893 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %19, i64 0, i64 %892
%894 = load i32, i32* %12
%895 = sext i32 %894 to i64
%896 = getelementptr inbounds [101 x double], [101 x double]* %893, i64 0, i64 %895
store double %890, double* %896
%897 = load i32, i32* %11
%898 = sext i32 %897 to i64
%899 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %22, i64 0, i64 %898
%900 = load i32, i32* %12
%901 = sext i32 %900 to i64
%902 = getelementptr inbounds [101 x double], [101 x double]* %899, i64 0, i64 %901
%903 = load double, double* %902
%904 = load i32, i32* %11
%905 = sext i32 %904 to i64
%906 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %17, i64 0, i64 %905
%907 = load i32, i32* %12
%908 = sext i32 %907 to i64
%909 = getelementptr inbounds [101 x double], [101 x double]* %906, i64 0, i64 %908
store double %903, double* %909
br label %910
910: ; preds = %756
%911 = load i32, i32* %12
%912 = add nsw i32 %911, 1
store i32 %912, i32* %12
br label %753
913: ; preds = %753
br label %914
914: ; preds = %913
%915 = load i32, i32* %11
%916 = add nsw i32 %915, 1
store i32 %916, i32* %11
br label %749
917: ; preds = %749
store i32 0, i32* %12
br label %918
918: ; preds = %976, %917
%919 = load i32, i32* %12
%920 = icmp slt i32 %919, 100
br i1 %920, label %921, label %979
921: ; preds = %918
%922 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %21, i64 0, i64 0
%923 = load i32, i32* %12
%924 = sext i32 %923 to i64
%925 = getelementptr inbounds [101 x double], [101 x double]* %922, i64 0, i64 %924
%926 = load double, double* %925
%927 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %21, i64 0, i64 100
%928 = load i32, i32* %12
%929 = sext i32 %928 to i64
%930 = getelementptr inbounds [101 x double], [101 x double]* %927, i64 0, i64 %929
store double %926, double* %930
%931 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %25, i64 0, i64 0
%932 = load i32, i32* %12
%933 = sext i32 %932 to i64
%934 = getelementptr inbounds [101 x double], [101 x double]* %931, i64 0, i64 %933
%935 = load double, double* %934
%936 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %25, i64 0, i64 100
%937 = load i32, i32* %12
%938 = sext i32 %937 to i64
%939 = getelementptr inbounds [101 x double], [101 x double]* %936, i64 0, i64 %938
store double %935, double* %939
%940 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %23, i64 0, i64 0
%941 = load i32, i32* %12
%942 = sext i32 %941 to i64
%943 = getelementptr inbounds [101 x double], [101 x double]* %940, i64 0, i64 %942
%944 = load double, double* %943
%945 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %23, i64 0, i64 100
%946 = load i32, i32* %12
%947 = sext i32 %946 to i64
%948 = getelementptr inbounds [101 x double], [101 x double]* %945, i64 0, i64 %947
store double %944, double* %948
%949 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %18, i64 0, i64 0
%950 = load i32, i32* %12
%951 = sext i32 %950 to i64
%952 = getelementptr inbounds [101 x double], [101 x double]* %949, i64 0, i64 %951
%953 = load double, double* %952
%954 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %18, i64 0, i64 100
%955 = load i32, i32* %12
%956 = sext i32 %955 to i64
%957 = getelementptr inbounds [101 x double], [101 x double]* %954, i64 0, i64 %956
store double %953, double* %957
%958 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %19, i64 0, i64 0
%959 = load i32, i32* %12
%960 = sext i32 %959 to i64
%961 = getelementptr inbounds [101 x double], [101 x double]* %958, i64 0, i64 %960
%962 = load double, double* %961
%963 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %19, i64 0, i64 100
%964 = load i32, i32* %12
%965 = sext i32 %964 to i64
%966 = getelementptr inbounds [101 x double], [101 x double]* %963, i64 0, i64 %965
store double %962, double* %966
%967 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %17, i64 0, i64 0
%968 = load i32, i32* %12
%969 = sext i32 %968 to i64
%970 = getelementptr inbounds [101 x double], [101 x double]* %967, i64 0, i64 %969
%971 = load double, double* %970
%972 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %17, i64 0, i64 100
%973 = load i32, i32* %12
%974 = sext i32 %973 to i64
%975 = getelementptr inbounds [101 x double], [101 x double]* %972, i64 0, i64 %974
store double %971, double* %975
br label %976
976: ; preds = %921
%977 = load i32, i32* %12
%978 = add nsw i32 %977, 1
store i32 %978, i32* %12
br label %918
979: ; preds = %918
store i32 0, i32* %11
br label %980
980: ; preds = %1038, %979
%981 = load i32, i32* %11
%982 = icmp slt i32 %981, 100
br i1 %982, label %983, label %1041
983: ; preds = %980
%984 = load i32, i32* %11
%985 = sext i32 %984 to i64
%986 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %21, i64 0, i64 %985
%987 = getelementptr inbounds [101 x double], [101 x double]* %986, i64 0, i64 0
%988 = load double, double* %987
%989 = load i32, i32* %11
%990 = sext i32 %989 to i64
%991 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %21, i64 0, i64 %990
%992 = getelementptr inbounds [101 x double], [101 x double]* %991, i64 0, i64 100
store double %988, double* %992
%993 = load i32, i32* %11
%994 = sext i32 %993 to i64
%995 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %25, i64 0, i64 %994
%996 = getelementptr inbounds [101 x double], [101 x double]* %995, i64 0, i64 0
%997 = load double, double* %996
%998 = load i32, i32* %11
%999 = sext i32 %998 to i64
%1000 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %25, i64 0, i64 %999
%1001 = getelementptr inbounds [101 x double], [101 x double]* %1000, i64 0, i64 100
store double %997, double* %1001
%1002 = load i32, i32* %11
%1003 = sext i32 %1002 to i64
%1004 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %23, i64 0, i64 %1003
%1005 = getelementptr inbounds [101 x double], [101 x double]* %1004, i64 0, i64 0
%1006 = load double, double* %1005
%1007 = load i32, i32* %11
%1008 = sext i32 %1007 to i64
%1009 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %23, i64 0, i64 %1008
%1010 = getelementptr inbounds [101 x double], [101 x double]* %1009, i64 0, i64 100
store double %1006, double* %1010
%1011 = load i32, i32* %11
%1012 = sext i32 %1011 to i64
%1013 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %18, i64 0, i64 %1012
%1014 = getelementptr inbounds [101 x double], [101 x double]* %1013, i64 0, i64 0
%1015 = load double, double* %1014
%1016 = load i32, i32* %11
%1017 = sext i32 %1016 to i64
%1018 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %18, i64 0, i64 %1017
%1019 = getelementptr inbounds [101 x double], [101 x double]* %1018, i64 0, i64 100
store double %1015, double* %1019
%1020 = load i32, i32* %11
%1021 = sext i32 %1020 to i64
%1022 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %19, i64 0, i64 %1021
%1023 = getelementptr inbounds [101 x double], [101 x double]* %1022, i64 0, i64 0
%1024 = load double, double* %1023
%1025 = load i32, i32* %11
%1026 = sext i32 %1025 to i64
%1027 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %19, i64 0, i64 %1026
%1028 = getelementptr inbounds [101 x double], [101 x double]* %1027, i64 0, i64 100
store double %1024, double* %1028
%1029 = load i32, i32* %11
%1030 = sext i32 %1029 to i64
%1031 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %17, i64 0, i64 %1030
%1032 = getelementptr inbounds [101 x double], [101 x double]* %1031, i64 0, i64 0
%1033 = load double, double* %1032
%1034 = load i32, i32* %11
%1035 = sext i32 %1034 to i64
%1036 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %17, i64 0, i64 %1035
%1037 = getelementptr inbounds [101 x double], [101 x double]* %1036, i64 0, i64 100
store double %1033, double* %1037
br label %1038
1038: ; preds = %983
%1039 = load i32, i32* %11
%1040 = add nsw i32 %1039, 1
store i32 %1040, i32* %11
br label %980
1041: ; preds = %980
%1042 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %21, i64 0, i64 0
%1043 = getelementptr inbounds [101 x double], [101 x double]* %1042, i64 0, i64 0
%1044 = load double, double* %1043
%1045 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %21, i64 0, i64 100
%1046 = getelementptr inbounds [101 x double], [101 x double]* %1045, i64 0, i64 100
store double %1044, double* %1046
%1047 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %25, i64 0, i64 0
%1048 = getelementptr inbounds [101 x double], [101 x double]* %1047, i64 0, i64 0
%1049 = load double, double* %1048
%1050 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %25, i64 0, i64 100
%1051 = getelementptr inbounds [101 x double], [101 x double]* %1050, i64 0, i64 100
store double %1049, double* %1051
%1052 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %23, i64 0, i64 0
%1053 = getelementptr inbounds [101 x double], [101 x double]* %1052, i64 0, i64 0
%1054 = load double, double* %1053
%1055 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %23, i64 0, i64 100
%1056 = getelementptr inbounds [101 x double], [101 x double]* %1055, i64 0, i64 100
store double %1054, double* %1056
%1057 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %18, i64 0, i64 0
%1058 = getelementptr inbounds [101 x double], [101 x double]* %1057, i64 0, i64 0
%1059 = load double, double* %1058
%1060 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %18, i64 0, i64 100
%1061 = getelementptr inbounds [101 x double], [101 x double]* %1060, i64 0, i64 100
store double %1059, double* %1061
%1062 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %19, i64 0, i64 0
%1063 = getelementptr inbounds [101 x double], [101 x double]* %1062, i64 0, i64 0
%1064 = load double, double* %1063
%1065 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %19, i64 0, i64 100
%1066 = getelementptr inbounds [101 x double], [101 x double]* %1065, i64 0, i64 100
store double %1064, double* %1066
%1067 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %17, i64 0, i64 0
%1068 = getelementptr inbounds [101 x double], [101 x double]* %1067, i64 0, i64 0
%1069 = load double, double* %1068
%1070 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %17, i64 0, i64 100
%1071 = getelementptr inbounds [101 x double], [101 x double]* %1070, i64 0, i64 100
store double %1069, double* %1071
br label %1072
1072: ; preds = %1041
%1073 = load i32, i32* %10
%1074 = add nsw i32 %1073, 1
store i32 %1074, i32* %10
br label %27
1075: ; preds = %27
ret i32 0
}

LLVM IR (-O2):
define i32 @main() {
%1 = alloca [101 x [101 x double]]
%2 = bitcast [101 x [101 x double]]* %1 to i8*
%3 = alloca [101 x [101 x double]]
%4 = alloca [101 x [101 x double]]
%5 = alloca [101 x [101 x double]]
%6 = alloca [101 x [101 x double]]
%7 = alloca [101 x [101 x double]]
%8 = alloca [101 x [101 x double]]
%9 = alloca [101 x [101 x double]]
%10 = bitcast [101 x [101 x double]]* %9 to i8*
%11 = alloca [101 x [101 x double]]
%12 = alloca [101 x [101 x double]]
%13 = alloca [101 x [101 x double]]
%14 = alloca [101 x [101 x double]]
%15 = alloca [101 x [101 x double]]
%16 = bitcast [101 x [101 x double]]* %3 to i8*
%17 = bitcast [101 x [101 x double]]* %4 to i8*
%18 = bitcast [101 x [101 x double]]* %5 to i8*
%19 = bitcast [101 x [101 x double]]* %6 to i8*
%20 = bitcast [101 x [101 x double]]* %7 to i8*
%21 = bitcast [101 x [101 x double]]* %8 to i8*
%22 = bitcast [101 x [101 x double]]* %11 to i8*
%23 = bitcast [101 x [101 x double]]* %12 to i8*
%24 = bitcast [101 x [101 x double]]* %13 to i8*
%25 = bitcast [101 x [101 x double]]* %14 to i8*
%26 = bitcast [101 x [101 x double]]* %15 to i8*
%27 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %1, i64 0, i64 100, i64 0
%28 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %1, i64 0, i64 0, i64 100
%29 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %3, i64 0, i64 0, i64 100
%30 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %3, i64 0, i64 100, i64 0
%31 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %5, i64 0, i64 0, i64 0
%32 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %5, i64 0, i64 100, i64 100
%33 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %9, i64 0, i64 100, i64 0
%34 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %9, i64 0, i64 0, i64 100
%35 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %11, i64 0, i64 0, i64 0
%36 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %11, i64 0, i64 100, i64 100
%37 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 0, i64 0
%38 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 100, i64 100
%39 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 0, i64 0
%40 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 100, i64 100
%41 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %7, i64 0, i64 0, i64 0
%42 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %7, i64 0, i64 100, i64 100
%43 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %8, i64 0, i64 0, i64 0
%44 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %8, i64 0, i64 100, i64 100
%45 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %6, i64 0, i64 0, i64 0
%46 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %6, i64 0, i64 100, i64 100
%47 = bitcast double* %27 to i8*
%48 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %4, i64 0, i64 0, i64 1
%49 = bitcast double* %48 to i8*
%50 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %4, i64 0, i64 100, i64 1
%51 = bitcast double* %50 to i8*
%52 = bitcast double* %33 to i8*
br label %53
53: ; preds = %0, %310
%54 = phi double [ undef, %0 ], [ %315, %310 ]
%55 = phi double [ undef, %0 ], [ %316, %310 ]
%56 = phi i32 [ 0, %0 ], [ %317, %310 ]
br label %57
57: ; preds = %94, %53
%58 = phi double [ %54, %53 ], [ %98, %94 ]
%59 = phi double [ %55, %53 ], [ %96, %94 ]
%60 = phi i64 [ 0, %53 ], [ %61, %94 ]
%61 = add nuw nsw i64 %60, 1
br label %62
62: ; preds = %57, %62
%63 = phi double [ %58, %57 ], [ %80, %62 ]
%64 = phi double [ %59, %57 ], [ %76, %62 ]
%65 = phi i64 [ 0, %57 ], [ %74, %62 ]
%66 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %6, i64 0, i64 %61, i64 %65
%67 = load double, double* %66
%68 = fadd double %67, %64
%69 = fmul double %68, 5.000000e-01
%70 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %7, i64 0, i64 %61, i64 %65
%71 = load double, double* %70
%72 = fmul double %71, %69
%73 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %1, i64 0, i64 %61, i64 %65
store double %72, double* %73
%74 = add nuw nsw i64 %65, 1
%75 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %6, i64 0, i64 %60, i64 %74
%76 = load double, double* %75
%77 = fadd double %64, %76
%78 = fmul double %77, 5.000000e-01
%79 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %8, i64 0, i64 %60, i64 %74
%80 = load double, double* %79
%81 = fmul double %80, %78
%82 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %3, i64 0, i64 %60, i64 %74
store double %81, double* %82
%83 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %7, i64 0, i64 %60, i64 %65
%84 = load double, double* %83
%85 = fmul double %84, %84
%86 = tail call double @llvm.fmuladd.f64(double %71, double %71, double %85)
%87 = tail call double @llvm.fmuladd.f64(double %80, double %80, double %86)
%88 = tail call double @llvm.fmuladd.f64(double %63, double %63, double %87)
%89 = tail call double @llvm.fmuladd.f64(double %88, double 2.500000e-01, double %64)
%90 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %5, i64 0, i64 %60, i64 %65
store double %89, double* %90
%91 = icmp eq i64 %74, 100
br i1 %91, label %92, label %62
92: ; preds = %62
%93 = icmp eq i64 %61, 100
br i1 %93, label %99, label %94
94: ; preds = %92
%95 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %6, i64 0, i64 %61, i64 0
%96 = load double, double* %95
%97 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %8, i64 0, i64 %61, i64 0
%98 = load double, double* %97
br label %57
99: ; preds = %92
br label %100
100: ; preds = %100, %99
%101 = phi i64 [ 0, %99 ], [ %125, %100 ]
%102 = or i64 %101, 1
%103 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %3, i64 0, i64 0, i64 %102
%104 = bitcast double* %103 to <2 x double>*
%105 = load <2 x double>, <2 x double>* %104
%106 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %3, i64 0, i64 100, i64 %102
%107 = bitcast double* %106 to <2 x double>*
store <2 x double> %105, <2 x double>* %107
%108 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %5, i64 0, i64 0, i64 %101
%109 = bitcast double* %108 to <2 x double>*
%110 = load <2 x double>, <2 x double>* %109
%111 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %5, i64 0, i64 100, i64 %101
%112 = bitcast double* %111 to <2 x double>*
store <2 x double> %110, <2 x double>* %112
%113 = or i64 %101, 2
%114 = or i64 %101, 3
%115 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %3, i64 0, i64 0, i64 %114
%116 = bitcast double* %115 to <2 x double>*
%117 = load <2 x double>, <2 x double>* %116
%118 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %3, i64 0, i64 100, i64 %114
%119 = bitcast double* %118 to <2 x double>*
store <2 x double> %117, <2 x double>* %119
%120 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %5, i64 0, i64 0, i64 %113
%121 = bitcast double* %120 to <2 x double>*
%122 = load <2 x double>, <2 x double>* %121
%123 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %5, i64 0, i64 100, i64 %113
%124 = bitcast double* %123 to <2 x double>*
store <2 x double> %122, <2 x double>* %124
%125 = add nuw nsw i64 %101, 4
%126 = icmp eq i64 %125, 100
br i1 %126, label %127, label %100
127: ; preds = %100, %127
%128 = phi i64 [ %129, %127 ], [ 0, %100 ]
%129 = add nuw nsw i64 %128, 1
%130 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %1, i64 0, i64 %129, i64 0
%131 = load double, double* %130
%132 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %1, i64 0, i64 %129, i64 100
store double %131, double* %132
%133 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %3, i64 0, i64 %128, i64 100
%134 = load double, double* %133
%135 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %3, i64 0, i64 %128, i64 0
store double %134, double* %135
%136 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %4, i64 0, i64 %129, i64 100
%137 = load double, double* %136
%138 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %4, i64 0, i64 %129, i64 0
store double %137, double* %138
%139 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %5, i64 0, i64 %128, i64 0
%140 = load double, double* %139
%141 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %5, i64 0, i64 %128, i64 100
store double %140, double* %141
%142 = icmp eq i64 %129, 100
br i1 %142, label %143, label %127
143: ; preds = %127
%144 = load double, double* %27
store double %144, double* %28
%145 = load double, double* %29
store double %145, double* %30
%146 = load double, double* %31
store double %146, double* %32
br label %147
147: ; preds = %147, %143
%148 = phi i64 [ 0, %143 ], [ %172, %147 ]
%149 = or i64 %148, 1
%150 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %14, i64 0, i64 0, i64 %149
%151 = bitcast double* %150 to <2 x double>*
%152 = load <2 x double>, <2 x double>* %151
%153 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %14, i64 0, i64 100, i64 %149
%154 = bitcast double* %153 to <2 x double>*
store <2 x double> %152, <2 x double>* %154
%155 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %12, i64 0, i64 0, i64 %148
%156 = bitcast double* %155 to <2 x double>*
%157 = load <2 x double>, <2 x double>* %156
%158 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %12, i64 0, i64 100, i64 %148
%159 = bitcast double* %158 to <2 x double>*
store <2 x double> %157, <2 x double>* %159
%160 = or i64 %148, 2
%161 = or i64 %148, 3
%162 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %14, i64 0, i64 0, i64 %161
%163 = bitcast double* %162 to <2 x double>*
%164 = load <2 x double>, <2 x double>* %163
%165 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %14, i64 0, i64 100, i64 %161
%166 = bitcast double* %165 to <2 x double>*
store <2 x double> %164, <2 x double>* %166
%167 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %12, i64 0, i64 0, i64 %160
%168 = bitcast double* %167 to <2 x double>*
%169 = load <2 x double>, <2 x double>* %168
%170 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %12, i64 0, i64 100, i64 %160
%171 = bitcast double* %170 to <2 x double>*
store <2 x double> %169, <2 x double>* %171
%172 = add nuw nsw i64 %148, 4
%173 = icmp eq i64 %172, 100
br i1 %173, label %174, label %147
174: ; preds = %147, %174
%175 = phi i64 [ %176, %174 ], [ 0, %147 ]
%176 = add nuw nsw i64 %175, 1
%177 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %9, i64 0, i64 %176, i64 0
%178 = load double, double* %177
%179 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %9, i64 0, i64 %176, i64 100
store double %178, double* %179
%180 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %14, i64 0, i64 %175, i64 100
%181 = load double, double* %180
%182 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %14, i64 0, i64 %175, i64 0
store double %181, double* %182
%183 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %12, i64 0, i64 %175, i64 0
%184 = load double, double* %183
%185 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %12, i64 0, i64 %175, i64 100
store double %184, double* %185
%186 = icmp eq i64 %176, 100
br i1 %186, label %187, label %174
187: ; preds = %174
%188 = load double, double* %33
store double %188, double* %34
br label %189
189: ; preds = %187, %220
%190 = phi i64 [ 0, %187 ], [ %221, %220 ]
%191 = getelementptr [101 x [101 x double]], [101 x [101 x double]]* %6, i64 0, i64 %190, i64 0
%192 = bitcast double* %191 to i8*
%193 = getelementptr [101 x [101 x double]], [101 x [101 x double]]* %12, i64 0, i64 %190, i64 0
%194 = bitcast double* %193 to i8*
%195 = getelementptr [101 x [101 x double]], [101 x [101 x double]]* %8, i64 0, i64 %190, i64 0
%196 = bitcast double* %195 to i8*
%197 = getelementptr [101 x [101 x double]], [101 x [101 x double]]* %14, i64 0, i64 %190, i64 0
%198 = bitcast double* %197 to i8*
%199 = getelementptr [101 x [101 x double]], [101 x [101 x double]]* %7, i64 0, i64 %190, i64 0
%200 = bitcast double* %199 to i8*
%201 = getelementptr [101 x [101 x double]], [101 x [101 x double]]* %9, i64 0, i64 %190, i64 0
%202 = bitcast double* %201 to i8*
br label %203
203: ; preds = %203, %189
%204 = phi i64 [ 0, %189 ], [ %218, %203 ]
%205 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %11, i64 0, i64 %190, i64 %204
%206 = bitcast double* %205 to <2 x double>*
store <2 x double> <double 0x7FF8000000000000, double 0x7FF8000000000000>, <2 x double>* %206
%207 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 %190, i64 %204
%208 = bitcast double* %207 to <2 x double>*
store <2 x double> <double 0x7FF8000000000000, double 0x7FF8000000000000>, <2 x double>* %208
%209 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 %190, i64 %204
%210 = bitcast double* %209 to <2 x double>*
store <2 x double> <double 0x7FF8000000000000, double 0x7FF8000000000000>, <2 x double>* %210
%211 = or i64 %204, 2
%212 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %11, i64 0, i64 %190, i64 %211
%213 = bitcast double* %212 to <2 x double>*
store <2 x double> <double 0x7FF8000000000000, double 0x7FF8000000000000>, <2 x double>* %213
%214 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 %190, i64 %211
%215 = bitcast double* %214 to <2 x double>*
store <2 x double> <double 0x7FF8000000000000, double 0x7FF8000000000000>, <2 x double>* %215
%216 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 %190, i64 %211
%217 = bitcast double* %216 to <2 x double>*
store <2 x double> <double 0x7FF8000000000000, double 0x7FF8000000000000>, <2 x double>* %217
%218 = add nuw nsw i64 %204, 4
%219 = icmp eq i64 %218, 100
br i1 %219, label %220, label %203
220: ; preds = %203
%221 = add nuw nsw i64 %190, 1
%222 = icmp eq i64 %221, 100
br i1 %222, label %223, label %189
223: ; preds = %220, %223
%224 = phi i64 [ %286, %223 ], [ 0, %220 ]
%225 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %11, i64 0, i64 0, i64 %224
%226 = bitcast double* %225 to <2 x double>*
%227 = load <2 x double>, <2 x double>* %226
%228 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %11, i64 0, i64 100, i64 %224
%229 = bitcast double* %228 to <2 x double>*
store <2 x double> %227, <2 x double>* %229
%230 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 0, i64 %224
%231 = bitcast double* %230 to <2 x double>*
%232 = load <2 x double>, <2 x double>* %231
%233 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 100, i64 %224
%234 = bitcast double* %233 to <2 x double>*
store <2 x double> %232, <2 x double>* %234
%235 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 0, i64 %224
%236 = bitcast double* %235 to <2 x double>*
%237 = load <2 x double>, <2 x double>* %236
%238 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 100, i64 %224
%239 = bitcast double* %238 to <2 x double>*
store <2 x double> %237, <2 x double>* %239
%240 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %7, i64 0, i64 0, i64 %224
%241 = bitcast double* %240 to <2 x double>*
%242 = load <2 x double>, <2 x double>* %241
%243 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %7, i64 0, i64 100, i64 %224
%244 = bitcast double* %243 to <2 x double>*
store <2 x double> %242, <2 x double>* %244
%245 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %8, i64 0, i64 0, i64 %224
%246 = bitcast double* %245 to <2 x double>*
%247 = load <2 x double>, <2 x double>* %246
%248 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %8, i64 0, i64 100, i64 %224
%249 = bitcast double* %248 to <2 x double>*
store <2 x double> %247, <2 x double>* %249
%250 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %6, i64 0, i64 0, i64 %224
%251 = bitcast double* %250 to <2 x double>*
%252 = load <2 x double>, <2 x double>* %251
%253 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %6, i64 0, i64 100, i64 %224
%254 = bitcast double* %253 to <2 x double>*
store <2 x double> %252, <2 x double>* %254
%255 = or i64 %224, 2
%256 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %11, i64 0, i64 0, i64 %255
%257 = bitcast double* %256 to <2 x double>*
%258 = load <2 x double>, <2 x double>* %257
%259 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %11, i64 0, i64 100, i64 %255
%260 = bitcast double* %259 to <2 x double>*
store <2 x double> %258, <2 x double>* %260
%261 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 0, i64 %255
%262 = bitcast double* %261 to <2 x double>*
%263 = load <2 x double>, <2 x double>* %262
%264 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 100, i64 %255
%265 = bitcast double* %264 to <2 x double>*
store <2 x double> %263, <2 x double>* %265
%266 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 0, i64 %255
%267 = bitcast double* %266 to <2 x double>*
%268 = load <2 x double>, <2 x double>* %267
%269 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 100, i64 %255
%270 = bitcast double* %269 to <2 x double>*
store <2 x double> %268, <2 x double>* %270
%271 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %7, i64 0, i64 0, i64 %255
%272 = bitcast double* %271 to <2 x double>*
%273 = load <2 x double>, <2 x double>* %272
%274 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %7, i64 0, i64 100, i64 %255
%275 = bitcast double* %274 to <2 x double>*
store <2 x double> %273, <2 x double>* %275
%276 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %8, i64 0, i64 0, i64 %255
%277 = bitcast double* %276 to <2 x double>*
%278 = load <2 x double>, <2 x double>* %277
%279 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %8, i64 0, i64 100, i64 %255
%280 = bitcast double* %279 to <2 x double>*
store <2 x double> %278, <2 x double>* %280
%281 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %6, i64 0, i64 0, i64 %255
%282 = bitcast double* %281 to <2 x double>*
%283 = load <2 x double>, <2 x double>* %282
%284 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %6, i64 0, i64 100, i64 %255
%285 = bitcast double* %284 to <2 x double>*
store <2 x double> %283, <2 x double>* %285
%286 = add nuw nsw i64 %224, 4
%287 = icmp eq i64 %286, 100
br i1 %287, label %288, label %223
288: ; preds = %223, %288
%289 = phi i64 [ %308, %288 ], [ 0, %223 ]
%290 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %11, i64 0, i64 %289, i64 0
%291 = load double, double* %290
%292 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %11, i64 0, i64 %289, i64 100
store double %291, double* %292
%293 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 %289, i64 0
%294 = load double, double* %293
%295 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %15, i64 0, i64 %289, i64 100
store double %294, double* %295
%296 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 %289, i64 0
%297 = load double, double* %296
%298 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %13, i64 0, i64 %289, i64 100
store double %297, double* %298
%299 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %7, i64 0, i64 %289, i64 0
%300 = load double, double* %299
%301 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %7, i64 0, i64 %289, i64 100
store double %300, double* %301
%302 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %8, i64 0, i64 %289, i64 0
%303 = load double, double* %302
%304 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %8, i64 0, i64 %289, i64 100
store double %303, double* %304
%305 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %6, i64 0, i64 %289, i64 0
%306 = load double, double* %305
%307 = getelementptr inbounds [101 x [101 x double]], [101 x [101 x double]]* %6, i64 0, i64 %289, i64 100
store double %306, double* %307
%308 = add nuw nsw i64 %289, 1
%309 = icmp eq i64 %308, 100
br i1 %309, label %310, label %288
310: ; preds = %288
%311 = load double, double* %35
store double %311, double* %36
%312 = load double, double* %37
store double %312, double* %38
%313 = load double, double* %39
store double %313, double* %40
%314 = load double, double* %41
store double %314, double* %42
%315 = load double, double* %43
store double %315, double* %44
%316 = load double, double* %45
store double %316, double* %46
%317 = add nuw nsw i32 %56, 1
%318 = icmp eq i32 %317, 10
br i1 %318, label %319, label %53
319: ; preds = %310
ret i32 0
}