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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ check_offloading();
scalar_t__ check_results(double *);
double *malloc(int);
int omp_get_num_teams();
int omp_get_team_num();
int /*<<< orphan*/ printf(char *, ...);
int main(void) {
  check_offloading();
  double A[(992)], B[(992)], C[(992)], D[(992)], E[(992)];
  int fail = 0;
  int expected = 1;
  int success = 0;
  int chunkSize;
  double p = 2.0, q = 4.0;
  int nte, tl, blockSize;
  {
    int i;
    for (i = 0; i < (992); i++) {
      {
        C[i] = 1;
        D[i] = i;
        E[i] = -i;
      }
    }
  };
  printf("iterations = teams\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("iterations > teams\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("iterations < teams\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("num_teams(512) dist_schedule(static,1)\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("num_teams(512) dist_schedule(static,512)\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("num_teams(512) dist_schedule(static, chunkSize)\n");
  chunkSize = (992) / 10;
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("num_teams(1024) dist_schedule(static, chunkSize)\n");
  chunkSize = (992) / 10;
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("num_teams(1024) dist_schedule(static, 1)\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("num_teams(3) dist_schedule(static, 1)\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("num_teams(3) dist_schedule(static, 3)\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("num_teams(10) dist_schedule(static, 99)\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("num_teams(256) dist_schedule(static, 992)\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  success = 0;
  for (int t = 0; t < (1); t++) {
#pragma omp target

#pragma omp teams distribute CLAUSES
    for (int i = 0; i < (992); i++) {
      A[i] += C[i];
    }
  }
  success += check_results(A);
  if (success == expected)
    printf("Succeeded\n");
  printf("num_teams(10) lastprivate(lastpriv)\n");
  success = 0;
  int lastpriv = -1;
#pragma omp target map(tofrom : lastpriv)
#pragma omp teams distribute num_teams(10) lastprivate(lastpriv)
  for (int i = 0; i < omp_get_num_teams(); i++)
    lastpriv = omp_get_team_num();
  if (lastpriv != 9) {
    printf("lastpriv value is %d and should have been %d\n", lastpriv, 9);
    fail = 1;
  }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  printf("num_teams(nte) thread_limit(tl) with parallel for innermost\n");
  success = 0;
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  {
    int i;
    for (i = 0; i < (992); i++) {
      B[i] = 0;
    }
  };
  nte = 32;
  tl = 64;
  blockSize = tl;
  for (int t = 0; t < (1); t++) {
#pragma omp target
#pragma omp teams distribute num_teams(nte) thread_limit(tl)
    for (int j = 0; j < 256; j += blockSize) {
#pragma omp parallel for
      for (int i = j; i < j + blockSize; i++) {
        A[i] += B[i] + C[i];
      }
    }
  }
  for (int i = 0; i < 256; i++) {
    if (A[i] != (1)) {
      printf("Error at A[%d], h = %lf, d = %lf\n", i, (double)(2.0 + 3.0) * (1),
             A[i]);
      fail = 1;
    }
  }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  printf("num_teams(nte) thread_limit(tl) with parallel for innermost\n");
  success = 0;
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  {
    int i;
    for (i = 0; i < (992); i++) {
      B[i] = 0;
    }
  };
  nte = 32;
  tl = 64;
  blockSize = tl;
  for (int t = 0; t < (1); t++) {
#pragma omp target
#pragma omp teams distribute num_teams(nte) thread_limit(tl)
    for (int j = 0; j < 510; j += blockSize) {
      int ub = (j + blockSize < 510) ? (j + blockSize) : 512;
#pragma omp parallel for
      for (int i = j; i < ub; i++) {
        A[i] += B[i] + C[i];
      }
    }
  }
  for (int i = 0; i < 256; i++) {
    if (A[i] != (1)) {
      printf("Error at A[%d], h = %lf, d = %lf\n", i, (double)(2.0 + 3.0) * (1),
             A[i]);
      fail = 1;
    }
  }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  printf("num_teams(512) collapse(2)\n");
  success = 0;
  double *S = malloc((992) * (992) * sizeof(double));
  double *T = malloc((992) * (992) * sizeof(double));
  double *U = malloc((992) * (992) * sizeof(double));
  for (int i = 0; i < (992); i++)
    for (int j = 0; j < (992); j++) {
      S[i * (992) + j] = 0.0;
      T[i * (992) + j] = 1.0;
      U[i * (992) + j] = 2.0;
    }
  for (int t = 0; t < (1); t++) {
#pragma omp target map(tofrom : S[:N * N]), map(to : T[:N * N], U[:N * N])
#pragma omp teams distribute num_teams(512) collapse(2)
    for (int i = 0; i < (992); i++)
      for (int j = 0; j < (992); j++)
        S[i * (992) + j] += T[i * (992) + j] + U[i * (992) + j];
  }
  for (int i = 0; i < (992); i++)
    for (int j = 0; j < (992); j++)
      if (S[i * (992) + j] != (1) * 3.0) {
        printf("Error at (%d,%d), h = %lf, d = %lf\n", i, j, (double)(1) * 3.0,
               S[i * (992) + j]);
        fail = 1;
      }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  printf("num_teams(512) collapse(3)\n");
  success = 0;
  int M = (992) / 8;
  double *V = malloc(M * M * M * sizeof(double));
  double *Z = malloc(M * M * M * sizeof(double));
  for (int i = 0; i < M; i++)
    for (int j = 0; j < M; j++)
      for (int k = 0; k < M; k++) {
        V[i * M * M + j * M + k] = 2.0;
        Z[i * M * M + j * M + k] = 3.0;
      }
  for (int t = 0; t < (1); t++) {
#pragma omp target map(tofrom : V[:M * M * M]), map(to : Z[:M * M * M])
#pragma omp teams distribute num_teams(512) collapse(3)
    for (int i = 0; i < M; i++)
      for (int j = 0; j < M; j++)
        for (int k = 0; k < M; k++)
          V[i * M * M + j * M + k] += Z[i * M * M + j * M + k];
  }
  for (int i = 0; i < M; i++)
    for (int j = 0; j < M; j++)
      for (int k = 0; k < M; k++)
        if (V[i * M * M + j * M + k] != 2.0 + (1) * 3.0) {
          printf("Error at (%d,%d), h = %lf, d = %lf\n", i, j,
                 (double)(1) * 3.0, V[i * M * M + j * M + k]);
          fail = 1;
        }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x9c90,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x0,%al
call   1050 <check_offloading@plt>
movl   $0x0,-0x9b14(%rbp)
movl   $0x1,-0x9b18(%rbp)
movl   $0x0,-0x9b1c(%rbp)
movsd  0x1e69(%rip),%xmm0
movsd  %xmm0,-0x9b28(%rbp)
ff
movsd  0x1e51(%rip),%xmm0
movsd  %xmm0,-0x9b30(%rbp)
ff
movl   $0x0,-0x9b40(%rbp)
cmpl   $0x3e0,-0x9b40(%rbp)
jge    1231 <main+0xd1>
movslq -0x9b40(%rbp),%rax
movsd  0x1e40(%rip),%xmm0
movsd  %xmm0,-0x5d10(%rbp,%rax,8)
ff ff
cvtsi2sdl -0x9b40(%rbp),%xmm0
ff
movslq -0x9b40(%rbp),%rax
movsd  %xmm0,-0x7c10(%rbp,%rax,8)
ff ff
xor    %eax,%eax
sub    -0x9b40(%rbp),%eax
cvtsi2sd %eax,%xmm0
movslq -0x9b40(%rbp),%rax
movsd  %xmm0,-0x9b10(%rbp,%rax,8)
ff ff
mov    -0x9b40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b40(%rbp)
jmp    11c1 <main+0x61>
lea    0x1df0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b44(%rbp)
cmpl   $0x3e0,-0x9b44(%rbp)
jge    1280 <main+0x120>
movslq -0x9b44(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b44(%rbp)
jmp    1249 <main+0xe9>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9b48(%rbp)
cmpl   $0x1,-0x9b48(%rbp)
jge    1311 <main+0x1b1>
movl   $0x0,-0x9b4c(%rbp)
cmpl   $0x3e0,-0x9b4c(%rbp)
jge    12f8 <main+0x198>
movslq -0x9b4c(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b4c(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b4c(%rbp)
jmp    12ab <main+0x14b>
jmp    12fd <main+0x19d>
mov    -0x9b48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b48(%rbp)
jmp    1294 <main+0x134>
lea    -0x1f10(%rbp),%rdi
call   1080 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    1350 <main+0x1f0>
lea    0x1cf3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1cf0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b50(%rbp)
cmpl   $0x3e0,-0x9b50(%rbp)
jge    139f <main+0x23f>
movslq -0x9b50(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b50(%rbp)
jmp    1368 <main+0x208>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9b54(%rbp)
cmpl   $0x1,-0x9b54(%rbp)
jge    1430 <main+0x2d0>
movl   $0x0,-0x9b58(%rbp)
cmpl   $0x3e0,-0x9b58(%rbp)
jge    1417 <main+0x2b7>
movslq -0x9b58(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b58(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b58(%rbp)
jmp    13ca <main+0x26a>
jmp    141c <main+0x2bc>
mov    -0x9b54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b54(%rbp)
jmp    13b3 <main+0x253>
lea    -0x1f10(%rbp),%rdi
call   1080 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    146f <main+0x30f>
lea    0x1bd4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1be5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b5c(%rbp)
cmpl   $0x3e0,-0x9b5c(%rbp)
jge    14be <main+0x35e>
movslq -0x9b5c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b5c(%rbp)
jmp    1487 <main+0x327>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9b60(%rbp)
cmpl   $0x1,-0x9b60(%rbp)
jge    154f <main+0x3ef>
movl   $0x0,-0x9b64(%rbp)
cmpl   $0x3e0,-0x9b64(%rbp)
jge    1536 <main+0x3d6>
movslq -0x9b64(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b64(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b64(%rbp)
jmp    14e9 <main+0x389>
jmp    153b <main+0x3db>
mov    -0x9b60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b60(%rbp)
jmp    14d2 <main+0x372>
lea    -0x1f10(%rbp),%rdi
call   1080 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    158e <main+0x42e>
lea    0x1ab5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1ada(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b68(%rbp)
cmpl   $0x3e0,-0x9b68(%rbp)
jge    15dd <main+0x47d>
movslq -0x9b68(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b68(%rbp)
jmp    15a6 <main+0x446>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9b6c(%rbp)
cmpl   $0x1,-0x9b6c(%rbp)
jge    166e <main+0x50e>
movl   $0x0,-0x9b70(%rbp)
cmpl   $0x3e0,-0x9b70(%rbp)
jge    1655 <main+0x4f5>
movslq -0x9b70(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b70(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b70(%rbp)
jmp    1608 <main+0x4a8>
jmp    165a <main+0x4fa>
mov    -0x9b6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b6c(%rbp)
jmp    15f1 <main+0x491>
lea    -0x1f10(%rbp),%rdi
call   1080 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    16ad <main+0x54d>
lea    0x1996(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x19e3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b74(%rbp)
cmpl   $0x3e0,-0x9b74(%rbp)
jge    16fc <main+0x59c>
movslq -0x9b74(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b74(%rbp)
jmp    16c5 <main+0x565>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9b78(%rbp)
cmpl   $0x1,-0x9b78(%rbp)
jge    178d <main+0x62d>
movl   $0x0,-0x9b7c(%rbp)
cmpl   $0x3e0,-0x9b7c(%rbp)
jge    1774 <main+0x614>
movslq -0x9b7c(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b7c(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b7c(%rbp)
jmp    1727 <main+0x5c7>
jmp    1779 <main+0x619>
mov    -0x9b78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b78(%rbp)
jmp    1710 <main+0x5b0>
lea    -0x1f10(%rbp),%rdi
call   1080 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    17cc <main+0x66c>
lea    0x1877(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x18ee(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x63,-0x9b20(%rbp)
movl   $0x0,-0x9b80(%rbp)
cmpl   $0x3e0,-0x9b80(%rbp)
jge    1825 <main+0x6c5>
movslq -0x9b80(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b80(%rbp)
jmp    17ee <main+0x68e>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9b84(%rbp)
cmpl   $0x1,-0x9b84(%rbp)
jge    18b6 <main+0x756>
movl   $0x0,-0x9b88(%rbp)
cmpl   $0x3e0,-0x9b88(%rbp)
jge    189d <main+0x73d>
movslq -0x9b88(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b88(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b88(%rbp)
jmp    1850 <main+0x6f0>
jmp    18a2 <main+0x742>
mov    -0x9b84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b84(%rbp)
jmp    1839 <main+0x6d9>
lea    -0x1f10(%rbp),%rdi
call   1080 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    18f5 <main+0x795>
lea    0x174e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x17f6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x63,-0x9b20(%rbp)
movl   $0x0,-0x9b8c(%rbp)
cmpl   $0x3e0,-0x9b8c(%rbp)
jge    194e <main+0x7ee>
movslq -0x9b8c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b8c(%rbp)
jmp    1917 <main+0x7b7>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9b90(%rbp)
cmpl   $0x1,-0x9b90(%rbp)
jge    19df <main+0x87f>
movl   $0x0,-0x9b94(%rbp)
cmpl   $0x3e0,-0x9b94(%rbp)
jge    19c6 <main+0x866>
movslq -0x9b94(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b94(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b94(%rbp)
jmp    1979 <main+0x819>
jmp    19cb <main+0x86b>
mov    -0x9b90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b90(%rbp)
jmp    1962 <main+0x802>
lea    -0x1f10(%rbp),%rdi
call   1080 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    1a1e <main+0x8be>
lea    0x1625(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x16ff(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b98(%rbp)
cmpl   $0x3e0,-0x9b98(%rbp)
jge    1a6d <main+0x90d>
movslq -0x9b98(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b98(%rbp)
jmp    1a36 <main+0x8d6>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9b9c(%rbp)
cmpl   $0x1,-0x9b9c(%rbp)
jge    1afe <main+0x99e>
movl   $0x0,-0x9ba0(%rbp)
cmpl   $0x3e0,-0x9ba0(%rbp)
jge    1ae5 <main+0x985>
movslq -0x9ba0(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9ba0(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9ba0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ba0(%rbp)
jmp    1a98 <main+0x938>
jmp    1aea <main+0x98a>
mov    -0x9b9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b9c(%rbp)
jmp    1a81 <main+0x921>
lea    -0x1f10(%rbp),%rdi
call   1080 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    1b3d <main+0x9dd>
lea    0x1506(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x160a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9ba4(%rbp)
cmpl   $0x3e0,-0x9ba4(%rbp)
jge    1b8c <main+0xa2c>
movslq -0x9ba4(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9ba4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ba4(%rbp)
jmp    1b55 <main+0x9f5>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9ba8(%rbp)
cmpl   $0x1,-0x9ba8(%rbp)
jge    1c1d <main+0xabd>
movl   $0x0,-0x9bac(%rbp)
cmpl   $0x3e0,-0x9bac(%rbp)
jge    1c04 <main+0xaa4>
movslq -0x9bac(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bac(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bac(%rbp)
jmp    1bb7 <main+0xa57>
jmp    1c09 <main+0xaa9>
mov    -0x9ba8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ba8(%rbp)
jmp    1ba0 <main+0xa40>
lea    -0x1f10(%rbp),%rdi
call   1080 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    1c5c <main+0xafc>
lea    0x13e7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1512(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9bb0(%rbp)
cmpl   $0x3e0,-0x9bb0(%rbp)
jge    1cab <main+0xb4b>
movslq -0x9bb0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bb0(%rbp)
jmp    1c74 <main+0xb14>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9bb4(%rbp)
cmpl   $0x1,-0x9bb4(%rbp)
jge    1d3c <main+0xbdc>
movl   $0x0,-0x9bb8(%rbp)
cmpl   $0x3e0,-0x9bb8(%rbp)
jge    1d23 <main+0xbc3>
movslq -0x9bb8(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bb8(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bb8(%rbp)
jmp    1cd6 <main+0xb76>
jmp    1d28 <main+0xbc8>
mov    -0x9bb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bb4(%rbp)
jmp    1cbf <main+0xb5f>
lea    -0x1f10(%rbp),%rdi
call   1080 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    1d7b <main+0xc1b>
lea    0x12c8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x141a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9bbc(%rbp)
cmpl   $0x3e0,-0x9bbc(%rbp)
jge    1dca <main+0xc6a>
movslq -0x9bbc(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bbc(%rbp)
jmp    1d93 <main+0xc33>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9bc0(%rbp)
cmpl   $0x1,-0x9bc0(%rbp)
jge    1e5b <main+0xcfb>
movl   $0x0,-0x9bc4(%rbp)
cmpl   $0x3e0,-0x9bc4(%rbp)
jge    1e42 <main+0xce2>
movslq -0x9bc4(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bc4(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bc4(%rbp)
jmp    1df5 <main+0xc95>
jmp    1e47 <main+0xce7>
mov    -0x9bc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bc0(%rbp)
jmp    1dde <main+0xc7e>
lea    -0x1f10(%rbp),%rdi
call   1080 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    1e9a <main+0xd3a>
lea    0x11a9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1324(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9bc8(%rbp)
cmpl   $0x3e0,-0x9bc8(%rbp)
jge    1ee9 <main+0xd89>
movslq -0x9bc8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bc8(%rbp)
jmp    1eb2 <main+0xd52>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9bcc(%rbp)
cmpl   $0x1,-0x9bcc(%rbp)
jge    1f7a <main+0xe1a>
movl   $0x0,-0x9bd0(%rbp)
cmpl   $0x3e0,-0x9bd0(%rbp)
jge    1f61 <main+0xe01>
movslq -0x9bd0(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bd0(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bd0(%rbp)
jmp    1f14 <main+0xdb4>
jmp    1f66 <main+0xe06>
mov    -0x9bcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bcc(%rbp)
jmp    1efd <main+0xd9d>
lea    -0x1f10(%rbp),%rdi
call   1080 <check_results@plt>
mov    %rax,%rcx
movslq -0x9b1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x9b1c(%rbp)
mov    -0x9b1c(%rbp),%eax
cmp    -0x9b18(%rbp),%eax
jne    1fb9 <main+0xe59>
lea    0x108a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1230(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b1c(%rbp)
movl   $0xffffffff,-0x9bd4(%rbp)
ff ff ff
movl   $0x0,-0x9bd8(%rbp)
mov    -0x9bd8(%rbp),%eax
mov    %eax,-0x9c84(%rbp)
mov    $0x0,%al
call   1070 <omp_get_num_teams@plt>
mov    %eax,%ecx
mov    -0x9c84(%rbp),%eax
cmp    %ecx,%eax
jge    2029 <main+0xec9>
mov    $0x0,%al
call   1060 <omp_get_team_num@plt>
mov    %eax,-0x9bd4(%rbp)
mov    -0x9bd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bd8(%rbp)
jmp    1fe5 <main+0xe85>
cmpl   $0x9,-0x9bd4(%rbp)
je     2059 <main+0xef9>
mov    -0x9bd4(%rbp),%esi
lea    0x11d2(%rip),%rdi
mov    $0x9,%edx
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
cmpl   $0x0,-0x9b14(%rbp)
je     2079 <main+0xf19>
lea    0x11d6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2087 <main+0xf27>
lea    0xfbc(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x11bd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9bdc(%rbp)
cmpl   $0x3e0,-0x9bdc(%rbp)
jge    20e0 <main+0xf80>
movslq -0x9bdc(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bdc(%rbp)
jmp    20a9 <main+0xf49>
movl   $0x0,-0x9be0(%rbp)
cmpl   $0x3e0,-0x9be0(%rbp)
jge    2121 <main+0xfc1>
movslq -0x9be0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9be0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9be0(%rbp)
jmp    20ea <main+0xf8a>
movl   $0x20,-0x9b34(%rbp)
movl   $0x40,-0x9b38(%rbp)
mov    -0x9b38(%rbp),%eax
mov    %eax,-0x9b3c(%rbp)
movl   $0x0,-0x9be4(%rbp)
cmpl   $0x1,-0x9be4(%rbp)
jge    221a <main+0x10ba>
movl   $0x0,-0x9be8(%rbp)
cmpl   $0x100,-0x9be8(%rbp)
jge    2201 <main+0x10a1>
mov    -0x9be8(%rbp),%eax
mov    %eax,-0x9bec(%rbp)
mov    -0x9bec(%rbp),%eax
mov    -0x9be8(%rbp),%ecx
add    -0x9b3c(%rbp),%ecx
cmp    %ecx,%eax
jge    21e5 <main+0x1085>
movslq -0x9bec(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bec(%rbp),%rax
addsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bec(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bec(%rbp)
jmp    217e <main+0x101e>
jmp    21ea <main+0x108a>
mov    -0x9b3c(%rbp),%eax
add    -0x9be8(%rbp),%eax
mov    %eax,-0x9be8(%rbp)
jmp    2162 <main+0x1002>
jmp    2206 <main+0x10a6>
mov    -0x9be4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9be4(%rbp)
jmp    214b <main+0xfeb>
movl   $0x0,-0x9bf0(%rbp)
cmpl   $0x100,-0x9bf0(%rbp)
jge    22b0 <main+0x1150>
movslq -0x9bf0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0xdd4(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2261 <main+0x1101>
jp     2261 <main+0x1101>
jmp    2297 <main+0x1137>
mov    -0x9bf0(%rbp),%esi
movslq -0x9bf0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x100a(%rip),%rdi
movsd  0xd8a(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    229c <main+0x113c>
mov    -0x9bf0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bf0(%rbp)
jmp    2224 <main+0x10c4>
cmpl   $0x0,-0x9b14(%rbp)
je     22d0 <main+0x1170>
lea    0xf7f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    22de <main+0x117e>
lea    0xd65(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf66(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9bf4(%rbp)
cmpl   $0x3e0,-0x9bf4(%rbp)
jge    2337 <main+0x11d7>
movslq -0x9bf4(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bf4(%rbp)
jmp    2300 <main+0x11a0>
movl   $0x0,-0x9bf8(%rbp)
cmpl   $0x3e0,-0x9bf8(%rbp)
jge    2378 <main+0x1218>
movslq -0x9bf8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9bf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bf8(%rbp)
jmp    2341 <main+0x11e1>
movl   $0x20,-0x9b34(%rbp)
movl   $0x40,-0x9b38(%rbp)
mov    -0x9b38(%rbp),%eax
mov    %eax,-0x9b3c(%rbp)
movl   $0x0,-0x9bfc(%rbp)
cmpl   $0x1,-0x9bfc(%rbp)
jge    24b3 <main+0x1353>
movl   $0x0,-0x9c00(%rbp)
cmpl   $0x1fe,-0x9c00(%rbp)
jge    249a <main+0x133a>
mov    -0x9c00(%rbp),%eax
add    -0x9b3c(%rbp),%eax
cmp    $0x1fe,%eax
jge    23f7 <main+0x1297>
mov    -0x9c00(%rbp),%eax
add    -0x9b3c(%rbp),%eax
mov    %eax,-0x9c88(%rbp)
jmp    2407 <main+0x12a7>
mov    $0x200,%eax
mov    %eax,-0x9c88(%rbp)
jmp    2407 <main+0x12a7>
mov    -0x9c88(%rbp),%eax
mov    %eax,-0x9c04(%rbp)
mov    -0x9c00(%rbp),%eax
mov    %eax,-0x9c08(%rbp)
mov    -0x9c08(%rbp),%eax
cmp    -0x9c04(%rbp),%eax
jge    247e <main+0x131e>
movslq -0x9c08(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c08(%rbp),%rax
addsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c08(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c08(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c08(%rbp)
jmp    241f <main+0x12bf>
jmp    2483 <main+0x1323>
mov    -0x9b3c(%rbp),%eax
add    -0x9c00(%rbp),%eax
mov    %eax,-0x9c00(%rbp)
jmp    23b9 <main+0x1259>
jmp    249f <main+0x133f>
mov    -0x9bfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bfc(%rbp)
jmp    23a2 <main+0x1242>
movl   $0x0,-0x9c0c(%rbp)
cmpl   $0x100,-0x9c0c(%rbp)
jge    2549 <main+0x13e9>
movslq -0x9c0c(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0xb3b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    24fa <main+0x139a>
jp     24fa <main+0x139a>
jmp    2530 <main+0x13d0>
mov    -0x9c0c(%rbp),%esi
movslq -0x9c0c(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0xd71(%rip),%rdi
movsd  0xaf1(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    2535 <main+0x13d5>
mov    -0x9c0c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c0c(%rbp)
jmp    24bd <main+0x135d>
cmpl   $0x0,-0x9b14(%rbp)
je     2569 <main+0x1409>
lea    0xce6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2577 <main+0x1417>
lea    0xacc(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xd2c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b1c(%rbp)
mov    $0x782000,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c18(%rbp)
mov    $0x782000,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c20(%rbp)
mov    $0x782000,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c28(%rbp)
movl   $0x0,-0x9c2c(%rbp)
cmpl   $0x3e0,-0x9c2c(%rbp)
jge    2693 <main+0x1533>
movl   $0x0,-0x9c30(%rbp)
cmpl   $0x3e0,-0x9c30(%rbp)
jge    267a <main+0x151a>
mov    -0x9c18(%rbp),%rax
imul   $0x3e0,-0x9c2c(%rbp),%ecx
add    -0x9c30(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c20(%rbp),%rax
imul   $0x3e0,-0x9c2c(%rbp),%ecx
add    -0x9c30(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x9e6(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c28(%rbp),%rax
imul   $0x3e0,-0x9c2c(%rbp),%ecx
add    -0x9c30(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x9a7(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c30(%rbp)
jmp    25e6 <main+0x1486>
jmp    267f <main+0x151f>
mov    -0x9c2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c2c(%rbp)
jmp    25cc <main+0x146c>
movl   $0x0,-0x9c34(%rbp)
cmpl   $0x1,-0x9c34(%rbp)
jge    2786 <main+0x1626>
movl   $0x0,-0x9c38(%rbp)
cmpl   $0x3e0,-0x9c38(%rbp)
jge    276d <main+0x160d>
movl   $0x0,-0x9c3c(%rbp)
cmpl   $0x3e0,-0x9c3c(%rbp)
jge    2754 <main+0x15f4>
mov    -0x9c20(%rbp),%rax
imul   $0x3e0,-0x9c38(%rbp),%ecx
add    -0x9c3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x9c28(%rbp),%rax
imul   $0x3e0,-0x9c38(%rbp),%ecx
add    -0x9c3c(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x9c18(%rbp),%rax
imul   $0x3e0,-0x9c38(%rbp),%ecx
add    -0x9c3c(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c3c(%rbp)
jmp    26ce <main+0x156e>
jmp    2759 <main+0x15f9>
mov    -0x9c38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c38(%rbp)
jmp    26b4 <main+0x1554>
jmp    2772 <main+0x1612>
mov    -0x9c34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c34(%rbp)
jmp    269d <main+0x153d>
movl   $0x0,-0x9c40(%rbp)
cmpl   $0x3e0,-0x9c40(%rbp)
jge    2873 <main+0x1713>
movl   $0x0,-0x9c44(%rbp)
cmpl   $0x3e0,-0x9c44(%rbp)
jge    285a <main+0x16fa>
mov    -0x9c18(%rbp),%rax
imul   $0x3e0,-0x9c40(%rbp),%ecx
add    -0x9c44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x837(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    27f6 <main+0x1696>
jp     27f6 <main+0x1696>
jmp    2841 <main+0x16e1>
mov    -0x9c40(%rbp),%esi
mov    -0x9c44(%rbp),%edx
mov    -0x9c18(%rbp),%rax
imul   $0x3e0,-0x9c40(%rbp),%ecx
add    -0x9c44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0xa9e(%rip),%rdi
movsd  0x7e8(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    2846 <main+0x16e6>
mov    -0x9c44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c44(%rbp)
jmp    27aa <main+0x164a>
jmp    285f <main+0x16ff>
mov    -0x9c40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c40(%rbp)
jmp    2790 <main+0x1630>
cmpl   $0x0,-0x9b14(%rbp)
je     2893 <main+0x1733>
lea    0x9bc(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    28a1 <main+0x1741>
lea    0x7a2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xa42(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x7c,-0x9c48(%rbp)
mov    -0x9c48(%rbp),%eax
imul   -0x9c48(%rbp),%eax
imul   -0x9c48(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c50(%rbp)
mov    -0x9c48(%rbp),%eax
imul   -0x9c48(%rbp),%eax
imul   -0x9c48(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c58(%rbp)
movl   $0x0,-0x9c5c(%rbp)
mov    -0x9c5c(%rbp),%eax
cmp    -0x9c48(%rbp),%eax
jge    2a2d <main+0x18cd>
movl   $0x0,-0x9c60(%rbp)
mov    -0x9c60(%rbp),%eax
cmp    -0x9c48(%rbp),%eax
jge    2a14 <main+0x18b4>
movl   $0x0,-0x9c64(%rbp)
mov    -0x9c64(%rbp),%eax
cmp    -0x9c48(%rbp),%eax
jge    29fb <main+0x189b>
mov    -0x9c50(%rbp),%rax
mov    -0x9c5c(%rbp),%ecx
imul   -0x9c48(%rbp),%ecx
imul   -0x9c48(%rbp),%ecx
mov    -0x9c60(%rbp),%edx
imul   -0x9c48(%rbp),%edx
add    %edx,%ecx
add    -0x9c64(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x666(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c58(%rbp),%rax
mov    -0x9c5c(%rbp),%ecx
imul   -0x9c48(%rbp),%ecx
imul   -0x9c48(%rbp),%ecx
mov    -0x9c60(%rbp),%edx
imul   -0x9c48(%rbp),%edx
add    %edx,%ecx
add    -0x9c64(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x636(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c64(%rbp)
jmp    2955 <main+0x17f5>
jmp    2a00 <main+0x18a0>
mov    -0x9c60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c60(%rbp)
jmp    2939 <main+0x17d9>
jmp    2a19 <main+0x18b9>
mov    -0x9c5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c5c(%rbp)
jmp    291d <main+0x17bd>
movl   $0x0,-0x9c68(%rbp)
cmpl   $0x1,-0x9c68(%rbp)
jge    2b6c <main+0x1a0c>
movl   $0x0,-0x9c6c(%rbp)
mov    -0x9c6c(%rbp),%eax
cmp    -0x9c48(%rbp),%eax
jge    2b53 <main+0x19f3>
movl   $0x0,-0x9c70(%rbp)
mov    -0x9c70(%rbp),%eax
cmp    -0x9c48(%rbp),%eax
jge    2b3a <main+0x19da>
movl   $0x0,-0x9c74(%rbp)
mov    -0x9c74(%rbp),%eax
cmp    -0x9c48(%rbp),%eax
jge    2b21 <main+0x19c1>
mov    -0x9c58(%rbp),%rax
mov    -0x9c6c(%rbp),%ecx
imul   -0x9c48(%rbp),%ecx
imul   -0x9c48(%rbp),%ecx
mov    -0x9c70(%rbp),%edx
imul   -0x9c48(%rbp),%edx
add    %edx,%ecx
add    -0x9c74(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x9c50(%rbp),%rax
mov    -0x9c6c(%rbp),%ecx
imul   -0x9c48(%rbp),%ecx
imul   -0x9c48(%rbp),%ecx
mov    -0x9c70(%rbp),%edx
imul   -0x9c48(%rbp),%edx
add    %edx,%ecx
add    -0x9c74(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c74(%rbp)
jmp    2a86 <main+0x1926>
jmp    2b26 <main+0x19c6>
mov    -0x9c70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c70(%rbp)
jmp    2a6a <main+0x190a>
jmp    2b3f <main+0x19df>
mov    -0x9c6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c6c(%rbp)
jmp    2a4e <main+0x18ee>
jmp    2b58 <main+0x19f8>
mov    -0x9c68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c68(%rbp)
jmp    2a37 <main+0x18d7>
movl   $0x0,-0x9c78(%rbp)
mov    -0x9c78(%rbp),%eax
cmp    -0x9c48(%rbp),%eax
jge    2cc4 <main+0x1b64>
movl   $0x0,-0x9c7c(%rbp)
mov    -0x9c7c(%rbp),%eax
cmp    -0x9c48(%rbp),%eax
jge    2cab <main+0x1b4b>
movl   $0x0,-0x9c80(%rbp)
mov    -0x9c80(%rbp),%eax
cmp    -0x9c48(%rbp),%eax
jge    2c92 <main+0x1b32>
mov    -0x9c50(%rbp),%rax
mov    -0x9c78(%rbp),%ecx
imul   -0x9c48(%rbp),%ecx
imul   -0x9c48(%rbp),%ecx
mov    -0x9c7c(%rbp),%edx
imul   -0x9c48(%rbp),%edx
add    %edx,%ecx
add    -0x9c80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x410(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2c15 <main+0x1ab5>
jp     2c15 <main+0x1ab5>
jmp    2c79 <main+0x1b19>
mov    -0x9c78(%rbp),%esi
mov    -0x9c7c(%rbp),%edx
mov    -0x9c50(%rbp),%rax
mov    -0x9c78(%rbp),%ecx
imul   -0x9c48(%rbp),%ecx
imul   -0x9c48(%rbp),%ecx
mov    -0x9c7c(%rbp),%edi
imul   -0x9c48(%rbp),%edi
add    %edi,%ecx
add    -0x9c80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0x666(%rip),%rdi
movsd  0x3b0(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    2c7e <main+0x1b1e>
mov    -0x9c80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c80(%rbp)
jmp    2bae <main+0x1a4e>
jmp    2c97 <main+0x1b37>
mov    -0x9c7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c7c(%rbp)
jmp    2b92 <main+0x1a32>
jmp    2cb0 <main+0x1b50>
mov    -0x9c78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c78(%rbp)
jmp    2b76 <main+0x1a16>
cmpl   $0x0,-0x9b14(%rbp)
je     2ce4 <main+0x1b84>
lea    0x56b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2cf2 <main+0x1b92>
lea    0x351(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x9c90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x5d18,%rsp
xor    %eax,%eax
call   1070 <check_offloading@plt>
mov    $0x1e,%eax
movapd 0x1e5b(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm0,0x1e20(%rsp,%rax,8)
movapd %xmm0,0x1e30(%rsp,%rax,8)
movapd %xmm0,0x1e40(%rsp,%rax,8)
movapd %xmm0,0x1e50(%rsp,%rax,8)
movapd %xmm0,0x1e60(%rsp,%rax,8)
movapd %xmm0,0x1e70(%rsp,%rax,8)
movapd %xmm0,0x1e80(%rsp,%rax,8)
movapd %xmm0,0x1e90(%rsp,%rax,8)
movapd %xmm0,0x1ea0(%rsp,%rax,8)
movapd %xmm0,0x1eb0(%rsp,%rax,8)
movapd %xmm0,0x1ec0(%rsp,%rax,8)
movapd %xmm0,0x1ed0(%rsp,%rax,8)
movapd %xmm0,0x1ee0(%rsp,%rax,8)
movapd %xmm0,0x1ef0(%rsp,%rax,8)
movapd %xmm0,0x1f00(%rsp,%rax,8)
movapd %xmm0,0x1f10(%rsp,%rax,8)
add    $0x20,%rax
cmp    $0x3fe,%rax
jne    11b0 <main+0x30>
lea    0x1e65(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     1300 <main+0x180>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1290 <main+0x110>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   10a0 <check_results@plt>
cmp    $0x1,%eax
jne    136c <main+0x1ec>
lea    0x1fa3(%rip),%rdi
call   1030 <puts@plt>
lea    0x1d5c(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     1420 <main+0x2a0>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    13b0 <main+0x230>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   10a0 <check_results@plt>
cmp    $0x1,%eax
jne    148c <main+0x30c>
lea    0x1e83(%rip),%rdi
call   1030 <puts@plt>
lea    0x1c4f(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     1540 <main+0x3c0>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    14d0 <main+0x350>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   10a0 <check_results@plt>
cmp    $0x1,%eax
jne    15ac <main+0x42c>
lea    0x1d63(%rip),%rdi
call   1030 <puts@plt>
lea    0x1b42(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     1660 <main+0x4e0>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    15f0 <main+0x470>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   10a0 <check_results@plt>
cmp    $0x1,%eax
jne    16cc <main+0x54c>
lea    0x1c43(%rip),%rdi
call   1030 <puts@plt>
lea    0x1a49(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     1780 <main+0x600>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1710 <main+0x590>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   10a0 <check_results@plt>
cmp    $0x1,%eax
jne    17ec <main+0x66c>
lea    0x1b23(%rip),%rdi
call   1030 <puts@plt>
lea    0x1952(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     18a0 <main+0x720>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1830 <main+0x6b0>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   10a0 <check_results@plt>
cmp    $0x1,%eax
jne    190c <main+0x78c>
lea    0x1a03(%rip),%rdi
call   1030 <puts@plt>
lea    0x1862(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     19c0 <main+0x840>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1950 <main+0x7d0>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   10a0 <check_results@plt>
cmp    $0x1,%eax
jne    1a2c <main+0x8ac>
lea    0x18e3(%rip),%rdi
call   1030 <puts@plt>
lea    0x1773(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     1ae0 <main+0x960>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1a70 <main+0x8f0>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   10a0 <check_results@plt>
cmp    $0x1,%eax
jne    1b4c <main+0x9cc>
lea    0x17c3(%rip),%rdi
call   1030 <puts@plt>
lea    0x167c(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     1c00 <main+0xa80>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1b90 <main+0xa10>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   10a0 <check_results@plt>
cmp    $0x1,%eax
jne    1c6c <main+0xaec>
lea    0x16a3(%rip),%rdi
call   1030 <puts@plt>
lea    0x1582(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     1d20 <main+0xba0>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1cb0 <main+0xb30>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   10a0 <check_results@plt>
cmp    $0x1,%eax
jne    1d8c <main+0xc0c>
lea    0x1583(%rip),%rdi
call   1030 <puts@plt>
lea    0x1488(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     1e40 <main+0xcc0>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1dd0 <main+0xc50>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   10a0 <check_results@plt>
cmp    $0x1,%eax
jne    1eac <main+0xd2c>
lea    0x1463(%rip),%rdi
call   1030 <puts@plt>
lea    0x1390(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xorpd  %xmm0,%xmm0
addsd  0x1f10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x7,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x20(%rsp,%rax,8),%xmm0
movupd -0x10(%rsp,%rax,8),%xmm1
movupd 0x1ee0(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1ef0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x20(%rsp,%rax,8)
movupd %xmm0,-0x10(%rsp,%rax,8)
cmp    $0x3df,%rax
je     1f60 <main+0xde0>
movupd (%rsp,%rax,8),%xmm0
movupd 0x10(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x1f10(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rsp,%rax,8)
movupd %xmm0,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1ef0 <main+0xd70>
movsd  0x3df8(%rsp),%xmm0
movsd  0x3e00(%rsp),%xmm1
addsd  0x1ef8(%rsp),%xmm0
movsd  %xmm0,0x1ef8(%rsp)
addsd  0x1f00(%rsp),%xmm1
movsd  %xmm1,0x1f00(%rsp)
movsd  0x3e08(%rsp),%xmm0
addsd  0x1f08(%rsp),%xmm0
movsd  %xmm0,0x1f08(%rsp)
lea    0x10(%rsp),%rdi
call   10a0 <check_results@plt>
cmp    $0x1,%eax
jne    1fcc <main+0xe4c>
lea    0x1343(%rip),%rdi
call   1030 <puts@plt>
lea    0x129a(%rip),%rdi
call   1030 <puts@plt>
xor    %eax,%eax
call   1090 <omp_get_num_teams@plt>
test   %eax,%eax
jle    2017 <main+0xe97>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
xor    %eax,%eax
call   1080 <omp_get_team_num@plt>
mov    %eax,%ebx
add    $0x1,%ebp
xor    %eax,%eax
call   1090 <omp_get_num_teams@plt>
cmp    %eax,%ebp
jl     1ff0 <main+0xe70>
cmp    $0x9,%ebx
jne    201c <main+0xe9c>
xor    %ebp,%ebp
lea    0x12f5(%rip),%rdi
jmp    203d <main+0xebd>
mov    $0xffffffff,%ebx
lea    0x1025(%rip),%rdi
mov    %ebx,%esi
mov    $0x9,%edx
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0x1,%ebp
lea    0x12c6(%rip),%rdi
call   1030 <puts@plt>
lea    0x1248(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x3e10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
movsd  0x3e10(%rsp),%xmm0
addsd  0x1f10(%rsp),%xmm0
xorpd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
mov    $0x3,%eax
nopl   0x0(%rax,%rax,1)
movupd (%rsp,%rax,8),%xmm0
movupd 0x3e00(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm1,%xmm2
addpd  %xmm0,%xmm2
movupd %xmm2,(%rsp,%rax,8)
cmp    $0x3f,%rax
je     20f6 <main+0xf76>
movupd 0x10(%rsp,%rax,8),%xmm0
movupd 0x3e10(%rsp,%rax,8),%xmm1
movupd 0x1f10(%rsp,%rax,8),%xmm2
addpd  %xmm1,%xmm2
addpd  %xmm0,%xmm2
movupd %xmm2,0x10(%rsp,%rax,8)
add    $0x4,%rax
jmp    20a0 <main+0xf20>
movsd  0x4008(%rsp),%xmm0
addsd  0x2108(%rsp),%xmm0
addsd  0x208(%rsp),%xmm0
movsd  %xmm0,0x208(%rsp)
xor    %eax,%eax
nopl   0x0(%rax)
movapd 0x4010(%rsp,%rax,8),%xmm0
addpd  0x2110(%rsp,%rax,8),%xmm0
movapd 0x4020(%rsp,%rax,8),%xmm1
addpd  0x210(%rsp,%rax,8),%xmm0
movapd %xmm0,0x210(%rsp,%rax,8)
addpd  0x2120(%rsp,%rax,8),%xmm1
addpd  0x220(%rsp,%rax,8),%xmm1
movapd %xmm1,0x220(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2120 <main+0xfa0>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4210(%rsp,%rax,8),%xmm0
addpd  0x2310(%rsp,%rax,8),%xmm0
movapd 0x4220(%rsp,%rax,8),%xmm1
addpd  0x410(%rsp,%rax,8),%xmm0
movapd %xmm0,0x410(%rsp,%rax,8)
addpd  0x2320(%rsp,%rax,8),%xmm1
addpd  0x420(%rsp,%rax,8),%xmm1
movapd %xmm1,0x420(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2180 <main+0x1000>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4410(%rsp,%rax,8),%xmm0
addpd  0x2510(%rsp,%rax,8),%xmm0
movapd 0x4420(%rsp,%rax,8),%xmm1
addpd  0x610(%rsp,%rax,8),%xmm0
movapd %xmm0,0x610(%rsp,%rax,8)
addpd  0x2520(%rsp,%rax,8),%xmm1
addpd  0x620(%rsp,%rax,8),%xmm1
movapd %xmm1,0x620(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    21e0 <main+0x1060>
xor    %ebx,%ebx
movsd  0xdf4(%rip),%xmm0
lea    0xe33(%rip),%r15
lea    0x10b9(%rip),%r14
nopw   0x0(%rax,%rax,1)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    226d <main+0x10ed>
jp     226d <main+0x10ed>
add    $0x1,%rbx
cmp    $0x100,%rbx
jne    2250 <main+0x10d0>
jmp    22a0 <main+0x1120>
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0xdbe(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0xda7(%rip),%xmm0
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0xff,%rbx
mov    %rax,%rbx
jne    2250 <main+0x10d0>
jmp    22b4 <main+0x1134>
test   %ebp,%ebp
lea    0x1061(%rip),%rax
lea    0x1053(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0xfce(%rip),%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x3e10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
movsd  0x3e10(%rsp),%xmm0
addsd  0x1f10(%rsp),%xmm0
xorpd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
mov    $0x3,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rsp,%rax,8),%xmm0
movupd 0x3e00(%rsp,%rax,8),%xmm1
movupd 0x1f00(%rsp,%rax,8),%xmm2
addpd  %xmm1,%xmm2
addpd  %xmm0,%xmm2
movupd %xmm2,(%rsp,%rax,8)
cmp    $0x3f,%rax
je     2376 <main+0x11f6>
movupd 0x10(%rsp,%rax,8),%xmm0
movupd 0x3e10(%rsp,%rax,8),%xmm1
movupd 0x1f10(%rsp,%rax,8),%xmm2
addpd  %xmm1,%xmm2
addpd  %xmm0,%xmm2
movupd %xmm2,0x10(%rsp,%rax,8)
add    $0x4,%rax
jmp    2320 <main+0x11a0>
movsd  0x4008(%rsp),%xmm0
addsd  0x2108(%rsp),%xmm0
addsd  0x208(%rsp),%xmm0
movsd  %xmm0,0x208(%rsp)
xor    %eax,%eax
nopl   0x0(%rax)
movapd 0x4010(%rsp,%rax,8),%xmm0
addpd  0x2110(%rsp,%rax,8),%xmm0
movapd 0x4020(%rsp,%rax,8),%xmm1
addpd  0x210(%rsp,%rax,8),%xmm0
movapd %xmm0,0x210(%rsp,%rax,8)
addpd  0x2120(%rsp,%rax,8),%xmm1
addpd  0x220(%rsp,%rax,8),%xmm1
movapd %xmm1,0x220(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    23a0 <main+0x1220>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4210(%rsp,%rax,8),%xmm0
addpd  0x2310(%rsp,%rax,8),%xmm0
movapd 0x4220(%rsp,%rax,8),%xmm1
addpd  0x410(%rsp,%rax,8),%xmm0
movapd %xmm0,0x410(%rsp,%rax,8)
addpd  0x2320(%rsp,%rax,8),%xmm1
addpd  0x420(%rsp,%rax,8),%xmm1
movapd %xmm1,0x420(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2400 <main+0x1280>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4410(%rsp,%rax,8),%xmm0
addpd  0x2510(%rsp,%rax,8),%xmm0
movapd 0x4420(%rsp,%rax,8),%xmm1
addpd  0x610(%rsp,%rax,8),%xmm0
movapd %xmm0,0x610(%rsp,%rax,8)
addpd  0x2520(%rsp,%rax,8),%xmm1
addpd  0x620(%rsp,%rax,8),%xmm1
movapd %xmm1,0x620(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2460 <main+0x12e0>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4610(%rsp,%rax,8),%xmm0
addpd  0x2710(%rsp,%rax,8),%xmm0
movapd 0x4620(%rsp,%rax,8),%xmm1
addpd  0x810(%rsp,%rax,8),%xmm0
movapd %xmm0,0x810(%rsp,%rax,8)
addpd  0x2720(%rsp,%rax,8),%xmm1
addpd  0x820(%rsp,%rax,8),%xmm1
movapd %xmm1,0x820(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    24c0 <main+0x1340>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4810(%rsp,%rax,8),%xmm0
addpd  0x2910(%rsp,%rax,8),%xmm0
movapd 0x4820(%rsp,%rax,8),%xmm1
addpd  0xa10(%rsp,%rax,8),%xmm0
movapd %xmm0,0xa10(%rsp,%rax,8)
addpd  0x2920(%rsp,%rax,8),%xmm1
addpd  0xa20(%rsp,%rax,8),%xmm1
movapd %xmm1,0xa20(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2520 <main+0x13a0>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4a10(%rsp,%rax,8),%xmm0
addpd  0x2b10(%rsp,%rax,8),%xmm0
movapd 0x4a20(%rsp,%rax,8),%xmm1
addpd  0xc10(%rsp,%rax,8),%xmm0
movapd %xmm0,0xc10(%rsp,%rax,8)
addpd  0x2b20(%rsp,%rax,8),%xmm1
addpd  0xc20(%rsp,%rax,8),%xmm1
movapd %xmm1,0xc20(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    2580 <main+0x1400>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x4c10(%rsp,%rax,8),%xmm0
addpd  0x2d10(%rsp,%rax,8),%xmm0
movapd 0x4c20(%rsp,%rax,8),%xmm1
addpd  0xe10(%rsp,%rax,8),%xmm0
movapd %xmm0,0xe10(%rsp,%rax,8)
addpd  0x2d20(%rsp,%rax,8),%xmm1
addpd  0xe20(%rsp,%rax,8),%xmm1
movapd %xmm1,0xe20(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    25e0 <main+0x1460>
xor    %ebx,%ebx
lea    0xa3b(%rip),%r15
lea    0xcc1(%rip),%r14
movsd  0x9e6(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    2670 <main+0x14f0>
jp     2670 <main+0x14f0>
add    $0x1,%rbx
cmp    $0x100,%rbx
jne    2650 <main+0x14d0>
jmp    269b <main+0x151b>
nopl   (%rax)
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0x9bb(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0xff,%rbx
mov    %rax,%rbx
jne    2642 <main+0x14c2>
jmp    26af <main+0x152f>
test   %ebp,%ebp
lea    0xc66(%rip),%rax
lea    0xc58(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0xc0f(%rip),%rdi
call   1030 <puts@plt>
mov    $0x782000,%edi
call   1060 <malloc@plt>
mov    %rax,%r14
mov    $0x782000,%edi
call   1060 <malloc@plt>
mov    %rax,%r15
mov    $0x782000,%edi
call   1060 <malloc@plt>
mov    %rax,%rbx
xor    %r12d,%r12d
mov    $0x782000,%edx
mov    %r14,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
mov    %rbx,%rax
add    $0x70,%rax
mov    %r15,%rcx
add    $0x70,%rcx
movapd 0x8fe(%rip),%xmm1
movapd 0x8e6(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd %xmm0,-0x70(%rcx,%rdx,8)
movupd %xmm0,-0x60(%rcx,%rdx,8)
movupd %xmm1,-0x70(%rax,%rdx,8)
movupd %xmm1,-0x60(%rax,%rdx,8)
movupd %xmm0,-0x50(%rcx,%rdx,8)
movupd %xmm0,-0x40(%rcx,%rdx,8)
movupd %xmm1,-0x50(%rax,%rdx,8)
movupd %xmm1,-0x40(%rax,%rdx,8)
movupd %xmm0,-0x30(%rcx,%rdx,8)
movupd %xmm0,-0x20(%rcx,%rdx,8)
movupd %xmm1,-0x30(%rax,%rdx,8)
movupd %xmm1,-0x20(%rax,%rdx,8)
movupd %xmm0,-0x10(%rcx,%rdx,8)
movupd %xmm0,(%rcx,%rdx,8)
movupd %xmm1,-0x10(%rax,%rdx,8)
movupd %xmm1,(%rax,%rdx,8)
add    $0x10,%rdx
cmp    $0x3e0,%rdx
jne    2730 <main+0x15b0>
add    $0x1,%r12
add    $0x1f00,%rax
add    $0x1f00,%rcx
cmp    $0x3e0,%r12
jne    2720 <main+0x15a0>
xor    %eax,%eax
mov    %r14,%rcx
xchg   %ax,%ax
mov    $0x2,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x10(%r15,%rdx,8),%xmm0
movupd (%r15,%rdx,8),%xmm1
movupd -0x10(%rbx,%rdx,8),%xmm2
addpd  %xmm0,%xmm2
movupd (%rbx,%rdx,8),%xmm0
addpd  %xmm1,%xmm0
movupd -0x10(%rcx,%rdx,8),%xmm1
addpd  %xmm2,%xmm1
movupd (%rcx,%rdx,8),%xmm2
addpd  %xmm0,%xmm2
movupd %xmm1,-0x10(%rcx,%rdx,8)
movupd %xmm2,(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    $0x3e2,%rdx
jne    27d0 <main+0x1650>
add    $0x1,%rax
add    $0x1f00,%rcx
add    $0x1f00,%rbx
add    $0x1f00,%r15
cmp    $0x3e0,%rax
jne    27c0 <main+0x1640>
xor    %r12d,%r12d
movsd  0x7f9(%rip),%xmm0
lea    0x84a(%rip),%r15
jmp    2864 <main+0x16e4>
add    $0x1,%r12
add    $0x1f00,%r14
cmp    $0x3e0,%r12
je     28b1 <main+0x1731>
xor    %ebx,%ebx
jmp    287d <main+0x16fd>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    $0x3e0,%rbx
je     2850 <main+0x16d0>
movsd  (%r14,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    288b <main+0x170b>
jnp    2870 <main+0x16f0>
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
movsd  0x7a5(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x796(%rip),%xmm0
mov    $0x1,%ebp
jmp    2870 <main+0x16f0>
test   %ebp,%ebp
lea    0xa50(%rip),%rax
lea    0xa42(%rip),%rdi
cmove  %rax,%rdi
call   1030 <puts@plt>
lea    0xa17(%rip),%rdi
call   1030 <puts@plt>
mov    $0xe8be00,%edi
call   1060 <malloc@plt>
mov    %rax,%r15
mov    $0xe8be00,%edi
call   1060 <malloc@plt>
lea    0x10(%rax),%r8
lea    0x10(%r15),%r9
xor    %esi,%esi
movapd 0x721(%rip),%xmm0
movapd 0x709(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
mov    %r9,%rdi
mov    %r8,%rcx
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd %xmm1,-0x10(%rdi,%rdx,8)
movupd %xmm0,-0x10(%rcx,%rdx,8)
movupd %xmm1,(%rdi,%rdx,8)
movupd %xmm0,(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    $0x7c,%rdx
jne    2930 <main+0x17b0>
add    $0x1,%rbx
add    $0x3e0,%rcx
add    $0x3e0,%rdi
cmp    $0x7c,%rbx
jne    2920 <main+0x17a0>
add    $0x1,%rsi
add    $0x1e080,%r8
add    $0x1e080,%r9
cmp    $0x7c,%rsi
jne    2910 <main+0x1790>
mov    %r15,%r8
add    $0x10,%r8
add    $0x10,%rax
xor    %edx,%edx
nopl   (%rax)
mov    %rax,%rsi
mov    %r8,%rdi
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd -0x10(%rsi,%rcx,8),%xmm0
movupd -0x10(%rdi,%rcx,8),%xmm1
addpd  %xmm0,%xmm1
movupd (%rdi,%rcx,8),%xmm0
movupd %xmm1,-0x10(%rdi,%rcx,8)
movupd (%rsi,%rcx,8),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%rdi,%rcx,8)
add    $0x4,%rcx
cmp    $0x7c,%rcx
jne    29b0 <main+0x1830>
add    $0x1,%rbx
add    $0x3e0,%rdi
add    $0x3e0,%rsi
cmp    $0x7c,%rbx
jne    29a0 <main+0x1820>
add    $0x1,%rdx
add    $0x1e080,%r8
add    $0x1e080,%rax
cmp    $0x7c,%rdx
jne    2990 <main+0x1810>
xor    %r13d,%r13d
lea    0x678(%rip),%r12
jmp    2a46 <main+0x18c6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r13
mov    0x8(%rsp),%r15
add    $0x1e080,%r15
cmp    $0x7c,%r13
je     2aaa <main+0x192a>
mov    %r15,0x8(%rsp)
xor    %ebx,%ebx
jmp    2a61 <main+0x18e1>
nop
add    $0x1,%rbx
add    $0x3e0,%r15
cmp    $0x7c,%rbx
je     2a30 <main+0x18b0>
xor    %r14d,%r14d
jmp    2a7a <main+0x18fa>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r14
cmp    $0x7c,%r14
je     2a50 <main+0x18d0>
movsd  (%r15,%r14,8),%xmm1
ucomisd 0x5b0(%rip),%xmm1
jne    2a8c <main+0x190c>
jnp    2a70 <main+0x18f0>
mov    %r12,%rdi
mov    %r13d,%esi
mov    %ebx,%edx
movsd  0x5a4(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
mov    $0x1,%ebp
jmp    2a70 <main+0x18f0>
test   %ebp,%ebp
lea    0x850(%rip),%rdi
lea    0x850(%rip),%rax
cmove  %rax,%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0x5d18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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