#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();
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 i;
    for (i = 0; i < (992); i++) {
      {
        C[i] = 1;
        D[i] = i;
        E[i] = -i;
      }
    }
  };
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  for (int t = 0; t < (1); t++) {
#pragma omp target
#pragma omp teams num_teams(512)
#pragma omp distribute parallel for simd
    for (int i = 0; i < 512; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 512; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  for (int t = 0; t < (1); t++) {
#pragma omp target
#pragma omp teams num_teams(256)
#pragma omp distribute parallel for simd
    for (int i = 0; i < 500; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 500; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  for (int t = 0; t < (1); t++) {
#pragma omp target
#pragma omp teams num_teams(256)
#pragma omp distribute parallel for simd
    for (int i = 0; i < 123; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 123; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  for (int t = 0; t < (1); t++) {
#pragma omp target
#pragma omp teams num_teams(512)
#pragma omp distribute parallel for simd dist_schedule(static, 1)
    for (int i = 0; i < 512; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 512; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  for (int t = 0; t < (1); t++) {
#pragma omp target
#pragma omp teams num_teams(512)
#pragma omp distribute parallel for simd dist_schedule(static, 512)
    for (int i = 0; i < 512; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 512; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  int ten = 10;
  int chunkSize = 512 / ten;
  for (int t = 0; t < (1); t++) {
#pragma omp target
#pragma omp teams num_teams(512)
#pragma omp distribute parallel for simd dist_schedule(static, chunkSize)
    for (int i = 0; i < 512; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 512; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  for (int t = 0; t < (1); t++) {
#pragma omp target
#pragma omp teams num_teams(256)
#pragma omp distribute parallel for simd dist_schedule(static, 1)
    for (int i = 0; i < 500; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 500; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  for (int t = 0; t < (1); t++) {
#pragma omp target
#pragma omp teams num_teams(256)
#pragma omp distribute parallel for simd dist_schedule(static, 500)
    for (int i = 0; i < 500; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 500; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  ten = 10;
  chunkSize = 500 / ten;
  for (int t = 0; t < (1); t++) {
#pragma omp target
#pragma omp teams num_teams(256)
#pragma omp distribute parallel for simd dist_schedule(static, chunkSize)
    for (int i = 0; i < 500; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 500; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  for (int t = 0; t < (1); t++) {
#pragma omp target
#pragma omp teams num_teams(256)
#pragma omp distribute parallel for simd dist_schedule(static, 1)
    for (int i = 0; i < 123; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 123; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  for (int t = 0; t < (1); t++) {
#pragma omp target
#pragma omp teams num_teams(256)
#pragma omp distribute parallel for simd dist_schedule(static, 123)
    for (int i = 0; i < 123; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 123; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  ten = 10;
  chunkSize = 123 / ten;
  for (int t = 0; t < (1); t++) {
#pragma omp target
#pragma omp teams num_teams(256)
#pragma omp distribute parallel for simd dist_schedule(static, chunkSize)
    for (int i = 0; i < 123; i++) {
      A[i] += C[i];
    }
  }
  for (int i = 0; i < 123; i++)
    if (A[i] != (1)) {
      printf("Error at %d, h = %lf, d = %lf\n", i, (double)(1), A[i]);
      fail = 1;
    }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  {
    int i;
    for (i = 0; i < (992); i++) {
      B[i] = 0;
    }
  };
  double p = 2.0, q = 4.0;
  for (int t = 0; t < (1); t++) {
#pragma omp target
#pragma omp teams num_teams(256)
    {
#pragma omp distribute parallel for simd private(p, q)
      for (int i = 0; i < (992); i++) {
        p = 2;
        q = 3;
        A[i] += p;
        B[i] += q;
      }
    }
  }
  for (int i = 0; i < (992); i++) {
    if (A[i] != (1) * 2) {
      printf("Error at A[%d], h = %lf, d = %lf\n", i, (double)(1) * 2, A[i]);
      fail = 1;
    }
    if (B[i] != (1) * 3) {
      printf("Error at B[%d], h = %lf, d = %lf\n", i, (double)(1) * 3, B[i]);
      fail = 1;
    }
  }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  {
    int i;
    for (i = 0; i < (992); i++) {
      B[i] = 0;
    }
  };
  p = 2.0, q = 4.0;
  for (int t = 0; t < (1); t++) {
#pragma omp target
#pragma omp teams num_teams(64)
    {
#pragma omp distribute simd firstprivate(p, q)
      for (int i = 0; i < 128; i++) {
        p += 3.0;
        q += 7.0;
        A[i] += p;
        B[i] += q;
      }
    }
  }
  for (int i = 0; i < 128; i++) {
    if (i % 2 == 0) {
      if (A[i] != (2.0 + 3.0) * (1)) {
        printf("Error at A[%d], h = %lf, d = %lf\n", i,
               (double)(2.0 + 3.0) * (1), A[i]);
        fail = 1;
      }
      if (B[i] != (4.0 + 7.0) * (1)) {
        printf("Error at B[%d], h = %lf, d = %lf\n", i,
               (double)(4.0 + 7.0) * (1), B[i]);
        fail = 1;
      }
    } else {
      if (A[i] != (2.0 + 3.0 * 2) * (1)) {
        printf("Error at A[%d], h = %lf, d = %lf\n", i,
               (double)(2.0 + 3.0 * 2) * (1), A[i]);
        fail = 1;
      }
      if (B[i] != (4.0 + 7.0 * 2) * (1)) {
        printf("Error at B[%d], h = %lf, d = %lf\n", i,
               (double)(4.0 + 7.0 * 2) * (1), B[i]);
        fail = 1;
      }
    }
  }
  if (fail)
    printf("Failed\n");
  else
    printf("Succeeded\n");
  int lastpriv = -1;
#pragma omp target map(tofrom : lastpriv)
#pragma omp teams num_teams(10)
#pragma omp distribute parallel for simd 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");
  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 num_teams(512)
#pragma omp distribute parallel for simd 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");
  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 num_teams(512)
#pragma omp distribute parallel for simd 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    $0x9ca0,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x0,%al
call   1050 <check_offloading@plt>
movl   $0x0,-0x9b14(%rbp)
movl   $0x0,-0x9b18(%rbp)
cmpl   $0x3e0,-0x9b18(%rbp)
jge    11ed <main+0x9d>
movslq -0x9b18(%rbp),%rax
movsd  0x2e84(%rip),%xmm0
movsd  %xmm0,-0x5d10(%rbp,%rax,8)
ff ff
cvtsi2sdl -0x9b18(%rbp),%xmm0
ff
movslq -0x9b18(%rbp),%rax
movsd  %xmm0,-0x7c10(%rbp,%rax,8)
ff ff
xor    %eax,%eax
sub    -0x9b18(%rbp),%eax
cvtsi2sd %eax,%xmm0
movslq -0x9b18(%rbp),%rax
movsd  %xmm0,-0x9b10(%rbp,%rax,8)
ff ff
mov    -0x9b18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b18(%rbp)
jmp    117d <main+0x2d>
movl   $0x0,-0x9b1c(%rbp)
cmpl   $0x3e0,-0x9b1c(%rbp)
jge    122e <main+0xde>
movslq -0x9b1c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b1c(%rbp)
jmp    11f7 <main+0xa7>
movl   $0x0,-0x9b20(%rbp)
cmpl   $0x1,-0x9b20(%rbp)
jge    12b5 <main+0x165>
movl   $0x0,-0x9b24(%rbp)
cmpl   $0x200,-0x9b24(%rbp)
jge    129c <main+0x14c>
movslq -0x9b24(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b24(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b24(%rbp)
jmp    124f <main+0xff>
jmp    12a1 <main+0x151>
mov    -0x9b20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b20(%rbp)
jmp    1238 <main+0xe8>
movl   $0x0,-0x9b28(%rbp)
cmpl   $0x200,-0x9b28(%rbp)
jge    134b <main+0x1fb>
movslq -0x9b28(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x2d39(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    12fc <main+0x1ac>
jp     12fc <main+0x1ac>
jmp    1332 <main+0x1e2>
mov    -0x9b28(%rbp),%esi
movslq -0x9b28(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x2d2f(%rip),%rdi
movsd  0x2cff(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    1337 <main+0x1e7>
mov    -0x9b28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b28(%rbp)
jmp    12bf <main+0x16f>
cmpl   $0x0,-0x9b14(%rbp)
je     136b <main+0x21b>
lea    0x2d08(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1379 <main+0x229>
lea    0x2cfd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b2c(%rbp)
cmpl   $0x3e0,-0x9b2c(%rbp)
jge    13ba <main+0x26a>
movslq -0x9b2c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b2c(%rbp)
jmp    1383 <main+0x233>
movl   $0x0,-0x9b30(%rbp)
cmpl   $0x1,-0x9b30(%rbp)
jge    1441 <main+0x2f1>
movl   $0x0,-0x9b34(%rbp)
cmpl   $0x1f4,-0x9b34(%rbp)
jge    1428 <main+0x2d8>
movslq -0x9b34(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b34(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b34(%rbp)
jmp    13db <main+0x28b>
jmp    142d <main+0x2dd>
mov    -0x9b30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b30(%rbp)
jmp    13c4 <main+0x274>
movl   $0x0,-0x9b38(%rbp)
cmpl   $0x1f4,-0x9b38(%rbp)
jge    14d7 <main+0x387>
movslq -0x9b38(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x2bad(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1488 <main+0x338>
jp     1488 <main+0x338>
jmp    14be <main+0x36e>
mov    -0x9b38(%rbp),%esi
movslq -0x9b38(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x2ba3(%rip),%rdi
movsd  0x2b73(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    14c3 <main+0x373>
mov    -0x9b38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b38(%rbp)
jmp    144b <main+0x2fb>
cmpl   $0x0,-0x9b14(%rbp)
je     14f7 <main+0x3a7>
lea    0x2b7c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1505 <main+0x3b5>
lea    0x2b71(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b3c(%rbp)
cmpl   $0x3e0,-0x9b3c(%rbp)
jge    1546 <main+0x3f6>
movslq -0x9b3c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b3c(%rbp)
jmp    150f <main+0x3bf>
movl   $0x0,-0x9b40(%rbp)
cmpl   $0x1,-0x9b40(%rbp)
jge    15ca <main+0x47a>
movl   $0x0,-0x9b44(%rbp)
cmpl   $0x7b,-0x9b44(%rbp)
jge    15b1 <main+0x461>
movslq -0x9b44(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b44(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b44(%rbp)
jmp    1567 <main+0x417>
jmp    15b6 <main+0x466>
mov    -0x9b40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b40(%rbp)
jmp    1550 <main+0x400>
movl   $0x0,-0x9b48(%rbp)
cmpl   $0x7b,-0x9b48(%rbp)
jge    165d <main+0x50d>
movslq -0x9b48(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x2a27(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    160e <main+0x4be>
jp     160e <main+0x4be>
jmp    1644 <main+0x4f4>
mov    -0x9b48(%rbp),%esi
movslq -0x9b48(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x2a1d(%rip),%rdi
movsd  0x29ed(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    1649 <main+0x4f9>
mov    -0x9b48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b48(%rbp)
jmp    15d4 <main+0x484>
cmpl   $0x0,-0x9b14(%rbp)
je     167d <main+0x52d>
lea    0x29f6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    168b <main+0x53b>
lea    0x29eb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b4c(%rbp)
cmpl   $0x3e0,-0x9b4c(%rbp)
jge    16cc <main+0x57c>
movslq -0x9b4c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b4c(%rbp)
jmp    1695 <main+0x545>
movl   $0x0,-0x9b50(%rbp)
cmpl   $0x1,-0x9b50(%rbp)
jge    1753 <main+0x603>
movl   $0x0,-0x9b54(%rbp)
cmpl   $0x200,-0x9b54(%rbp)
jge    173a <main+0x5ea>
movslq -0x9b54(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b54(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b54(%rbp)
jmp    16ed <main+0x59d>
jmp    173f <main+0x5ef>
mov    -0x9b50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b50(%rbp)
jmp    16d6 <main+0x586>
movl   $0x0,-0x9b58(%rbp)
cmpl   $0x200,-0x9b58(%rbp)
jge    17e9 <main+0x699>
movslq -0x9b58(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x289b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    179a <main+0x64a>
jp     179a <main+0x64a>
jmp    17d0 <main+0x680>
mov    -0x9b58(%rbp),%esi
movslq -0x9b58(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x2891(%rip),%rdi
movsd  0x2861(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    17d5 <main+0x685>
mov    -0x9b58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b58(%rbp)
jmp    175d <main+0x60d>
cmpl   $0x0,-0x9b14(%rbp)
je     1809 <main+0x6b9>
lea    0x286a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1817 <main+0x6c7>
lea    0x285f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b5c(%rbp)
cmpl   $0x3e0,-0x9b5c(%rbp)
jge    1858 <main+0x708>
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    1821 <main+0x6d1>
movl   $0x0,-0x9b60(%rbp)
cmpl   $0x1,-0x9b60(%rbp)
jge    18df <main+0x78f>
movl   $0x0,-0x9b64(%rbp)
cmpl   $0x200,-0x9b64(%rbp)
jge    18c6 <main+0x776>
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    1879 <main+0x729>
jmp    18cb <main+0x77b>
mov    -0x9b60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b60(%rbp)
jmp    1862 <main+0x712>
movl   $0x0,-0x9b68(%rbp)
cmpl   $0x200,-0x9b68(%rbp)
jge    1975 <main+0x825>
movslq -0x9b68(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x270f(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1926 <main+0x7d6>
jp     1926 <main+0x7d6>
jmp    195c <main+0x80c>
mov    -0x9b68(%rbp),%esi
movslq -0x9b68(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x2705(%rip),%rdi
movsd  0x26d5(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    1961 <main+0x811>
mov    -0x9b68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b68(%rbp)
jmp    18e9 <main+0x799>
cmpl   $0x0,-0x9b14(%rbp)
je     1995 <main+0x845>
lea    0x26de(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    19a3 <main+0x853>
lea    0x26d3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b6c(%rbp)
cmpl   $0x3e0,-0x9b6c(%rbp)
jge    19e4 <main+0x894>
movslq -0x9b6c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b6c(%rbp)
jmp    19ad <main+0x85d>
movl   $0xa,-0x9b70(%rbp)
mov    $0x200,%eax
cltd
idivl  -0x9b70(%rbp)
mov    %eax,-0x9b74(%rbp)
movl   $0x0,-0x9b78(%rbp)
cmpl   $0x1,-0x9b78(%rbp)
jge    1a87 <main+0x937>
movl   $0x0,-0x9b7c(%rbp)
cmpl   $0x200,-0x9b7c(%rbp)
jge    1a6e <main+0x91e>
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    1a21 <main+0x8d1>
jmp    1a73 <main+0x923>
mov    -0x9b78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b78(%rbp)
jmp    1a0a <main+0x8ba>
movl   $0x0,-0x9b80(%rbp)
cmpl   $0x200,-0x9b80(%rbp)
jge    1b1d <main+0x9cd>
movslq -0x9b80(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x2567(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1ace <main+0x97e>
jp     1ace <main+0x97e>
jmp    1b04 <main+0x9b4>
mov    -0x9b80(%rbp),%esi
movslq -0x9b80(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x255d(%rip),%rdi
movsd  0x252d(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    1b09 <main+0x9b9>
mov    -0x9b80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b80(%rbp)
jmp    1a91 <main+0x941>
cmpl   $0x0,-0x9b14(%rbp)
je     1b3d <main+0x9ed>
lea    0x2536(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1b4b <main+0x9fb>
lea    0x252b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b84(%rbp)
cmpl   $0x3e0,-0x9b84(%rbp)
jge    1b8c <main+0xa3c>
movslq -0x9b84(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b84(%rbp)
jmp    1b55 <main+0xa05>
movl   $0x0,-0x9b88(%rbp)
cmpl   $0x1,-0x9b88(%rbp)
jge    1c13 <main+0xac3>
movl   $0x0,-0x9b8c(%rbp)
cmpl   $0x1f4,-0x9b8c(%rbp)
jge    1bfa <main+0xaaa>
movslq -0x9b8c(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b8c(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b8c(%rbp)
jmp    1bad <main+0xa5d>
jmp    1bff <main+0xaaf>
mov    -0x9b88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b88(%rbp)
jmp    1b96 <main+0xa46>
movl   $0x0,-0x9b90(%rbp)
cmpl   $0x1f4,-0x9b90(%rbp)
jge    1ca9 <main+0xb59>
movslq -0x9b90(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x23db(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1c5a <main+0xb0a>
jp     1c5a <main+0xb0a>
jmp    1c90 <main+0xb40>
mov    -0x9b90(%rbp),%esi
movslq -0x9b90(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x23d1(%rip),%rdi
movsd  0x23a1(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    1c95 <main+0xb45>
mov    -0x9b90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b90(%rbp)
jmp    1c1d <main+0xacd>
cmpl   $0x0,-0x9b14(%rbp)
je     1cc9 <main+0xb79>
lea    0x23aa(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1cd7 <main+0xb87>
lea    0x239f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9b94(%rbp)
cmpl   $0x3e0,-0x9b94(%rbp)
jge    1d18 <main+0xbc8>
movslq -0x9b94(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b94(%rbp)
jmp    1ce1 <main+0xb91>
movl   $0x0,-0x9b98(%rbp)
cmpl   $0x1,-0x9b98(%rbp)
jge    1d9f <main+0xc4f>
movl   $0x0,-0x9b9c(%rbp)
cmpl   $0x1f4,-0x9b9c(%rbp)
jge    1d86 <main+0xc36>
movslq -0x9b9c(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b9c(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b9c(%rbp)
jmp    1d39 <main+0xbe9>
jmp    1d8b <main+0xc3b>
mov    -0x9b98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b98(%rbp)
jmp    1d22 <main+0xbd2>
movl   $0x0,-0x9ba0(%rbp)
cmpl   $0x1f4,-0x9ba0(%rbp)
jge    1e35 <main+0xce5>
movslq -0x9ba0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x224f(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1de6 <main+0xc96>
jp     1de6 <main+0xc96>
jmp    1e1c <main+0xccc>
mov    -0x9ba0(%rbp),%esi
movslq -0x9ba0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x2245(%rip),%rdi
movsd  0x2215(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    1e21 <main+0xcd1>
mov    -0x9ba0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ba0(%rbp)
jmp    1da9 <main+0xc59>
cmpl   $0x0,-0x9b14(%rbp)
je     1e55 <main+0xd05>
lea    0x221e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1e63 <main+0xd13>
lea    0x2213(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9ba4(%rbp)
cmpl   $0x3e0,-0x9ba4(%rbp)
jge    1ea4 <main+0xd54>
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    1e6d <main+0xd1d>
movl   $0xa,-0x9b70(%rbp)
mov    $0x1f4,%eax
cltd
idivl  -0x9b70(%rbp)
mov    %eax,-0x9b74(%rbp)
movl   $0x0,-0x9ba8(%rbp)
cmpl   $0x1,-0x9ba8(%rbp)
jge    1f47 <main+0xdf7>
movl   $0x0,-0x9bac(%rbp)
cmpl   $0x1f4,-0x9bac(%rbp)
jge    1f2e <main+0xdde>
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    1ee1 <main+0xd91>
jmp    1f33 <main+0xde3>
mov    -0x9ba8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ba8(%rbp)
jmp    1eca <main+0xd7a>
movl   $0x0,-0x9bb0(%rbp)
cmpl   $0x1f4,-0x9bb0(%rbp)
jge    1fdd <main+0xe8d>
movslq -0x9bb0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x20a7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1f8e <main+0xe3e>
jp     1f8e <main+0xe3e>
jmp    1fc4 <main+0xe74>
mov    -0x9bb0(%rbp),%esi
movslq -0x9bb0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x209d(%rip),%rdi
movsd  0x206d(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    1fc9 <main+0xe79>
mov    -0x9bb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bb0(%rbp)
jmp    1f51 <main+0xe01>
cmpl   $0x0,-0x9b14(%rbp)
je     1ffd <main+0xead>
lea    0x2076(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    200b <main+0xebb>
lea    0x206b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9bb4(%rbp)
cmpl   $0x3e0,-0x9bb4(%rbp)
jge    204c <main+0xefc>
movslq -0x9bb4(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bb4(%rbp)
jmp    2015 <main+0xec5>
movl   $0x0,-0x9bb8(%rbp)
cmpl   $0x1,-0x9bb8(%rbp)
jge    20d0 <main+0xf80>
movl   $0x0,-0x9bbc(%rbp)
cmpl   $0x7b,-0x9bbc(%rbp)
jge    20b7 <main+0xf67>
movslq -0x9bbc(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bbc(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bbc(%rbp)
jmp    206d <main+0xf1d>
jmp    20bc <main+0xf6c>
mov    -0x9bb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bb8(%rbp)
jmp    2056 <main+0xf06>
movl   $0x0,-0x9bc0(%rbp)
cmpl   $0x7b,-0x9bc0(%rbp)
jge    2163 <main+0x1013>
movslq -0x9bc0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1f21(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2114 <main+0xfc4>
jp     2114 <main+0xfc4>
jmp    214a <main+0xffa>
mov    -0x9bc0(%rbp),%esi
movslq -0x9bc0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x1f17(%rip),%rdi
movsd  0x1ee7(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    214f <main+0xfff>
mov    -0x9bc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bc0(%rbp)
jmp    20da <main+0xf8a>
cmpl   $0x0,-0x9b14(%rbp)
je     2183 <main+0x1033>
lea    0x1ef0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2191 <main+0x1041>
lea    0x1ee5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9bc4(%rbp)
cmpl   $0x3e0,-0x9bc4(%rbp)
jge    21d2 <main+0x1082>
movslq -0x9bc4(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bc4(%rbp)
jmp    219b <main+0x104b>
movl   $0x0,-0x9bc8(%rbp)
cmpl   $0x1,-0x9bc8(%rbp)
jge    2256 <main+0x1106>
movl   $0x0,-0x9bcc(%rbp)
cmpl   $0x7b,-0x9bcc(%rbp)
jge    223d <main+0x10ed>
movslq -0x9bcc(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bcc(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bcc(%rbp)
jmp    21f3 <main+0x10a3>
jmp    2242 <main+0x10f2>
mov    -0x9bc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bc8(%rbp)
jmp    21dc <main+0x108c>
movl   $0x0,-0x9bd0(%rbp)
cmpl   $0x7b,-0x9bd0(%rbp)
jge    22e9 <main+0x1199>
movslq -0x9bd0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1d9b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    229a <main+0x114a>
jp     229a <main+0x114a>
jmp    22d0 <main+0x1180>
mov    -0x9bd0(%rbp),%esi
movslq -0x9bd0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x1d91(%rip),%rdi
movsd  0x1d61(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    22d5 <main+0x1185>
mov    -0x9bd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bd0(%rbp)
jmp    2260 <main+0x1110>
cmpl   $0x0,-0x9b14(%rbp)
je     2309 <main+0x11b9>
lea    0x1d6a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2317 <main+0x11c7>
lea    0x1d5f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9bd4(%rbp)
cmpl   $0x3e0,-0x9bd4(%rbp)
jge    2358 <main+0x1208>
movslq -0x9bd4(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bd4(%rbp)
jmp    2321 <main+0x11d1>
movl   $0xa,-0x9b70(%rbp)
mov    $0x7b,%eax
cltd
idivl  -0x9b70(%rbp)
mov    %eax,-0x9b74(%rbp)
movl   $0x0,-0x9bd8(%rbp)
cmpl   $0x1,-0x9bd8(%rbp)
jge    23f8 <main+0x12a8>
movl   $0x0,-0x9bdc(%rbp)
cmpl   $0x7b,-0x9bdc(%rbp)
jge    23df <main+0x128f>
movslq -0x9bdc(%rbp),%rax
movsd  -0x5d10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bdc(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bdc(%rbp)
jmp    2395 <main+0x1245>
jmp    23e4 <main+0x1294>
mov    -0x9bd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bd8(%rbp)
jmp    237e <main+0x122e>
movl   $0x0,-0x9be0(%rbp)
cmpl   $0x7b,-0x9be0(%rbp)
jge    248b <main+0x133b>
movslq -0x9be0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1bf9(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    243c <main+0x12ec>
jp     243c <main+0x12ec>
jmp    2472 <main+0x1322>
mov    -0x9be0(%rbp),%esi
movslq -0x9be0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x1bef(%rip),%rdi
movsd  0x1bbf(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    2477 <main+0x1327>
mov    -0x9be0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9be0(%rbp)
jmp    2402 <main+0x12b2>
cmpl   $0x0,-0x9b14(%rbp)
je     24ab <main+0x135b>
lea    0x1bc8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    24b9 <main+0x1369>
lea    0x1bbd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9be4(%rbp)
cmpl   $0x3e0,-0x9be4(%rbp)
jge    24fa <main+0x13aa>
movslq -0x9be4(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9be4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9be4(%rbp)
jmp    24c3 <main+0x1373>
movl   $0x0,-0x9be8(%rbp)
cmpl   $0x3e0,-0x9be8(%rbp)
jge    253b <main+0x13eb>
movslq -0x9be8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9be8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9be8(%rbp)
jmp    2504 <main+0x13b4>
movsd  0x1ac5(%rip),%xmm0
movsd  %xmm0,-0x9bf0(%rbp)
ff
movsd  0x1aad(%rip),%xmm0
movsd  %xmm0,-0x9bf8(%rbp)
ff
movl   $0x0,-0x9bfc(%rbp)
cmpl   $0x1,-0x9bfc(%rbp)
jge    261b <main+0x14cb>
movl   $0x0,-0x9c00(%rbp)
cmpl   $0x3e0,-0x9c00(%rbp)
jge    2602 <main+0x14b2>
movsd  0x1a74(%rip),%xmm0
movsd  %xmm0,-0x9bf0(%rbp)
ff
movsd  0x1a74(%rip),%xmm0
movsd  %xmm0,-0x9bf8(%rbp)
ff
movsd  -0x9bf0(%rbp),%xmm0
ff
movslq -0x9c00(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movsd  -0x9bf8(%rbp),%xmm0
ff
movslq -0x9c00(%rbp),%rax
addsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9c00(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c00(%rbp)
jmp    257c <main+0x142c>
jmp    2607 <main+0x14b7>
mov    -0x9bfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bfc(%rbp)
jmp    2565 <main+0x1415>
movl   $0x0,-0x9c04(%rbp)
cmpl   $0x3e0,-0x9c04(%rbp)
jge    2714 <main+0x15c4>
movslq -0x9c04(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x19bb(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2662 <main+0x1512>
jp     2662 <main+0x1512>
jmp    2698 <main+0x1548>
mov    -0x9c04(%rbp),%esi
movslq -0x9c04(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x19fb(%rip),%rdi
movsd  0x1981(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
movslq -0x9c04(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1968(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    26c5 <main+0x1575>
jp     26c5 <main+0x1575>
jmp    26fb <main+0x15ab>
mov    -0x9c04(%rbp),%esi
movslq -0x9c04(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm1
ff ff
lea    0x19ba(%rip),%rdi
movsd  0x192e(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    2700 <main+0x15b0>
mov    -0x9c04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c04(%rbp)
jmp    2625 <main+0x14d5>
cmpl   $0x0,-0x9b14(%rbp)
je     2734 <main+0x15e4>
lea    0x193f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2742 <main+0x15f2>
lea    0x1934(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x9c08(%rbp)
cmpl   $0x3e0,-0x9c08(%rbp)
jge    2783 <main+0x1633>
movslq -0x9c08(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c08(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c08(%rbp)
jmp    274c <main+0x15fc>
movl   $0x0,-0x9c0c(%rbp)
cmpl   $0x3e0,-0x9c0c(%rbp)
jge    27c4 <main+0x1674>
movslq -0x9c0c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9c0c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c0c(%rbp)
jmp    278d <main+0x163d>
movsd  0x183c(%rip),%xmm0
movsd  %xmm0,-0x9bf0(%rbp)
ff
movsd  0x1824(%rip),%xmm0
movsd  %xmm0,-0x9bf8(%rbp)
ff
movl   $0x0,-0x9c10(%rbp)
cmpl   $0x1,-0x9c10(%rbp)
jge    28b4 <main+0x1764>
movl   $0x0,-0x9c14(%rbp)
cmpl   $0x80,-0x9c14(%rbp)
jge    289b <main+0x174b>
movsd  0x17fb(%rip),%xmm0
addsd  -0x9bf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x9bf0(%rbp)
ff
movsd  0x180b(%rip),%xmm0
addsd  -0x9bf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x9bf8(%rbp)
ff
movsd  -0x9bf0(%rbp),%xmm0
ff
movslq -0x9c14(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movsd  -0x9bf8(%rbp),%xmm0
ff
movslq -0x9c14(%rbp),%rax
addsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9c14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c14(%rbp)
jmp    2805 <main+0x16b5>
jmp    28a0 <main+0x1750>
mov    -0x9c10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c10(%rbp)
jmp    27ee <main+0x169e>
movl   $0x0,-0x9c18(%rbp)
cmpl   $0x80,-0x9c18(%rbp)
jge    2a94 <main+0x1944>
mov    -0x9c18(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    29b0 <main+0x1860>
movslq -0x9c18(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1713(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2912 <main+0x17c2>
jp     2912 <main+0x17c2>
jmp    2948 <main+0x17f8>
mov    -0x9c18(%rbp),%esi
movslq -0x9c18(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x174b(%rip),%rdi
movsd  0x16d9(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
movslq -0x9c18(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x16d8(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2975 <main+0x1825>
jp     2975 <main+0x1825>
jmp    29ab <main+0x185b>
mov    -0x9c18(%rbp),%esi
movslq -0x9c18(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm1
ff ff
lea    0x170a(%rip),%rdi
movsd  0x169e(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    2a7b <main+0x192b>
movslq -0x9c18(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1660(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    29dd <main+0x188d>
jp     29dd <main+0x188d>
jmp    2a13 <main+0x18c3>
mov    -0x9c18(%rbp),%esi
movslq -0x9c18(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x1680(%rip),%rdi
movsd  0x1626(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
movslq -0x9c18(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1605(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2a40 <main+0x18f0>
jp     2a40 <main+0x18f0>
jmp    2a76 <main+0x1926>
mov    -0x9c18(%rbp),%esi
movslq -0x9c18(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm1
ff ff
lea    0x163f(%rip),%rdi
movsd  0x15cb(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    2a7b <main+0x192b>
jmp    2a80 <main+0x1930>
mov    -0x9c18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c18(%rbp)
jmp    28be <main+0x176e>
cmpl   $0x0,-0x9b14(%rbp)
je     2ab4 <main+0x1964>
lea    0x15bf(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2ac2 <main+0x1972>
lea    0x15b4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0xffffffff,-0x9c1c(%rbp)
ff ff ff
movl   $0x0,-0x9c20(%rbp)
mov    -0x9c20(%rbp),%eax
mov    %eax,-0x9c94(%rbp)
mov    $0x0,%al
call   1070 <omp_get_num_teams@plt>
mov    %eax,%ecx
mov    -0x9c94(%rbp),%eax
cmp    %ecx,%eax
jge    2b1a <main+0x19ca>
mov    $0x0,%al
call   1060 <omp_get_team_num@plt>
mov    %eax,-0x9c1c(%rbp)
mov    -0x9c20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c20(%rbp)
jmp    2ad6 <main+0x1986>
cmpl   $0x9,-0x9c1c(%rbp)
je     2b4a <main+0x19fa>
mov    -0x9c1c(%rbp),%esi
lea    0x158a(%rip),%rdi
mov    $0x9,%edx
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
cmpl   $0x0,-0x9b14(%rbp)
je     2b6a <main+0x1a1a>
lea    0x1509(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2b78 <main+0x1a28>
lea    0x14fe(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    $0x782000,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c28(%rbp)
mov    $0x782000,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c30(%rbp)
mov    $0x782000,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c38(%rbp)
movl   $0x0,-0x9c3c(%rbp)
cmpl   $0x3e0,-0x9c3c(%rbp)
jge    2c7c <main+0x1b2c>
movl   $0x0,-0x9c40(%rbp)
cmpl   $0x3e0,-0x9c40(%rbp)
jge    2c63 <main+0x1b13>
mov    -0x9c28(%rbp),%rax
imul   $0x3e0,-0x9c3c(%rbp),%ecx
add    -0x9c40(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c30(%rbp),%rax
imul   $0x3e0,-0x9c3c(%rbp),%ecx
add    -0x9c40(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x13fd(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c38(%rbp),%rax
imul   $0x3e0,-0x9c3c(%rbp),%ecx
add    -0x9c40(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x13be(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c40(%rbp)
jmp    2bcf <main+0x1a7f>
jmp    2c68 <main+0x1b18>
mov    -0x9c3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c3c(%rbp)
jmp    2bb5 <main+0x1a65>
movl   $0x0,-0x9c44(%rbp)
cmpl   $0x1,-0x9c44(%rbp)
jge    2d6f <main+0x1c1f>
movl   $0x0,-0x9c48(%rbp)
cmpl   $0x3e0,-0x9c48(%rbp)
jge    2d56 <main+0x1c06>
movl   $0x0,-0x9c4c(%rbp)
cmpl   $0x3e0,-0x9c4c(%rbp)
jge    2d3d <main+0x1bed>
mov    -0x9c30(%rbp),%rax
imul   $0x3e0,-0x9c48(%rbp),%ecx
add    -0x9c4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x9c38(%rbp),%rax
imul   $0x3e0,-0x9c48(%rbp),%ecx
add    -0x9c4c(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x9c28(%rbp),%rax
imul   $0x3e0,-0x9c48(%rbp),%ecx
add    -0x9c4c(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c4c(%rbp)
jmp    2cb7 <main+0x1b67>
jmp    2d42 <main+0x1bf2>
mov    -0x9c48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c48(%rbp)
jmp    2c9d <main+0x1b4d>
jmp    2d5b <main+0x1c0b>
mov    -0x9c44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c44(%rbp)
jmp    2c86 <main+0x1b36>
movl   $0x0,-0x9c50(%rbp)
cmpl   $0x3e0,-0x9c50(%rbp)
jge    2e5c <main+0x1d0c>
movl   $0x0,-0x9c54(%rbp)
cmpl   $0x3e0,-0x9c54(%rbp)
jge    2e43 <main+0x1cf3>
mov    -0x9c28(%rbp),%rax
imul   $0x3e0,-0x9c50(%rbp),%ecx
add    -0x9c54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x124e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2ddf <main+0x1c8f>
jp     2ddf <main+0x1c8f>
jmp    2e2a <main+0x1cda>
mov    -0x9c50(%rbp),%esi
mov    -0x9c54(%rbp),%edx
mov    -0x9c28(%rbp),%rax
imul   $0x3e0,-0x9c50(%rbp),%ecx
add    -0x9c54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0x12db(%rip),%rdi
movsd  0x11ff(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    2e2f <main+0x1cdf>
mov    -0x9c54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c54(%rbp)
jmp    2d93 <main+0x1c43>
jmp    2e48 <main+0x1cf8>
mov    -0x9c50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c50(%rbp)
jmp    2d79 <main+0x1c29>
cmpl   $0x0,-0x9b14(%rbp)
je     2e7c <main+0x1d2c>
lea    0x11f7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2e8a <main+0x1d3a>
lea    0x11ec(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x7c,-0x9c58(%rbp)
mov    -0x9c58(%rbp),%eax
imul   -0x9c58(%rbp),%eax
imul   -0x9c58(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c60(%rbp)
mov    -0x9c58(%rbp),%eax
imul   -0x9c58(%rbp),%eax
imul   -0x9c58(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x9c68(%rbp)
movl   $0x0,-0x9c6c(%rbp)
mov    -0x9c6c(%rbp),%eax
cmp    -0x9c58(%rbp),%eax
jge    2ffe <main+0x1eae>
movl   $0x0,-0x9c70(%rbp)
mov    -0x9c70(%rbp),%eax
cmp    -0x9c58(%rbp),%eax
jge    2fe5 <main+0x1e95>
movl   $0x0,-0x9c74(%rbp)
mov    -0x9c74(%rbp),%eax
cmp    -0x9c58(%rbp),%eax
jge    2fcc <main+0x1e7c>
mov    -0x9c60(%rbp),%rax
mov    -0x9c6c(%rbp),%ecx
imul   -0x9c58(%rbp),%ecx
imul   -0x9c58(%rbp),%ecx
mov    -0x9c70(%rbp),%edx
imul   -0x9c58(%rbp),%edx
add    %edx,%ecx
add    -0x9c74(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x1095(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c68(%rbp),%rax
mov    -0x9c6c(%rbp),%ecx
imul   -0x9c58(%rbp),%ecx
imul   -0x9c58(%rbp),%ecx
mov    -0x9c70(%rbp),%edx
imul   -0x9c58(%rbp),%edx
add    %edx,%ecx
add    -0x9c74(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x1065(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c74(%rbp)
jmp    2f26 <main+0x1dd6>
jmp    2fd1 <main+0x1e81>
mov    -0x9c70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c70(%rbp)
jmp    2f0a <main+0x1dba>
jmp    2fea <main+0x1e9a>
mov    -0x9c6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c6c(%rbp)
jmp    2eee <main+0x1d9e>
movl   $0x0,-0x9c78(%rbp)
cmpl   $0x1,-0x9c78(%rbp)
jge    313d <main+0x1fed>
movl   $0x0,-0x9c7c(%rbp)
mov    -0x9c7c(%rbp),%eax
cmp    -0x9c58(%rbp),%eax
jge    3124 <main+0x1fd4>
movl   $0x0,-0x9c80(%rbp)
mov    -0x9c80(%rbp),%eax
cmp    -0x9c58(%rbp),%eax
jge    310b <main+0x1fbb>
movl   $0x0,-0x9c84(%rbp)
mov    -0x9c84(%rbp),%eax
cmp    -0x9c58(%rbp),%eax
jge    30f2 <main+0x1fa2>
mov    -0x9c68(%rbp),%rax
mov    -0x9c7c(%rbp),%ecx
imul   -0x9c58(%rbp),%ecx
imul   -0x9c58(%rbp),%ecx
mov    -0x9c80(%rbp),%edx
imul   -0x9c58(%rbp),%edx
add    %edx,%ecx
add    -0x9c84(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x9c60(%rbp),%rax
mov    -0x9c7c(%rbp),%ecx
imul   -0x9c58(%rbp),%ecx
imul   -0x9c58(%rbp),%ecx
mov    -0x9c80(%rbp),%edx
imul   -0x9c58(%rbp),%edx
add    %edx,%ecx
add    -0x9c84(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c84(%rbp)
jmp    3057 <main+0x1f07>
jmp    30f7 <main+0x1fa7>
mov    -0x9c80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c80(%rbp)
jmp    303b <main+0x1eeb>
jmp    3110 <main+0x1fc0>
mov    -0x9c7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c7c(%rbp)
jmp    301f <main+0x1ecf>
jmp    3129 <main+0x1fd9>
mov    -0x9c78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c78(%rbp)
jmp    3008 <main+0x1eb8>
movl   $0x0,-0x9c88(%rbp)
mov    -0x9c88(%rbp),%eax
cmp    -0x9c58(%rbp),%eax
jge    3295 <main+0x2145>
movl   $0x0,-0x9c8c(%rbp)
mov    -0x9c8c(%rbp),%eax
cmp    -0x9c58(%rbp),%eax
jge    327c <main+0x212c>
movl   $0x0,-0x9c90(%rbp)
mov    -0x9c90(%rbp),%eax
cmp    -0x9c58(%rbp),%eax
jge    3263 <main+0x2113>
mov    -0x9c60(%rbp),%rax
mov    -0x9c88(%rbp),%ecx
imul   -0x9c58(%rbp),%ecx
imul   -0x9c58(%rbp),%ecx
mov    -0x9c8c(%rbp),%edx
imul   -0x9c58(%rbp),%edx
add    %edx,%ecx
add    -0x9c90(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xe3f(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    31e6 <main+0x2096>
jp     31e6 <main+0x2096>
jmp    324a <main+0x20fa>
mov    -0x9c88(%rbp),%esi
mov    -0x9c8c(%rbp),%edx
mov    -0x9c60(%rbp),%rax
mov    -0x9c88(%rbp),%ecx
imul   -0x9c58(%rbp),%ecx
imul   -0x9c58(%rbp),%ecx
mov    -0x9c8c(%rbp),%edi
imul   -0x9c58(%rbp),%edi
add    %edi,%ecx
add    -0x9c90(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0xebb(%rip),%rdi
movsd  0xddf(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movl   $0x1,-0x9b14(%rbp)
jmp    324f <main+0x20ff>
mov    -0x9c90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c90(%rbp)
jmp    317f <main+0x202f>
jmp    3268 <main+0x2118>
mov    -0x9c8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c8c(%rbp)
jmp    3163 <main+0x2013>
jmp    3281 <main+0x2131>
mov    -0x9c88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c88(%rbp)
jmp    3147 <main+0x1ff7>
cmpl   $0x0,-0x9b14(%rbp)
je     32b5 <main+0x2165>
lea    0xdbe(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    32c3 <main+0x2173>
lea    0xdb3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x9ca0,%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 0x1e6b(%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    11a0 <main+0x30>
lea    0x10(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd 0x1f10(%rsp,%rbx,8),%xmm0
movapd 0x1f20(%rsp,%rbx,8),%xmm1
movapd 0x1f30(%rsp,%rbx,8),%xmm2
movapd 0x1f40(%rsp,%rbx,8),%xmm3
addpd  0x10(%rsp,%rbx,8),%xmm0
addpd  0x20(%rsp,%rbx,8),%xmm1
movapd %xmm0,0x10(%rsp,%rbx,8)
movapd %xmm1,0x20(%rsp,%rbx,8)
addpd  0x30(%rsp,%rbx,8),%xmm2
addpd  0x40(%rsp,%rbx,8),%xmm3
movapd %xmm2,0x30(%rsp,%rbx,8)
movapd %xmm3,0x40(%rsp,%rbx,8)
add    $0x8,%rbx
cmp    $0x200,%rbx
jne    1260 <main+0xf0>
xor    %ebx,%ebx
mov    $0x1,%al
movsd  0x1d83(%rip),%xmm0
lea    0x1db4(%rip),%r15
lea    0x1e6c(%rip),%r14
xor    %ebp,%ebp
nopl   (%rax)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    12fd <main+0x18d>
jp     12fd <main+0x18d>
add    $0x1,%rbx
cmp    $0x200,%rbx
jne    12e0 <main+0x170>
jmp    1332 <main+0x1c2>
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0x1d46(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x1d37(%rip),%xmm0
lea    0x1(%rbx),%rcx
mov    $0x1,%ebp
xor    %eax,%eax
cmp    $0x1ff,%rbx
mov    %rcx,%rbx
jne    12e0 <main+0x170>
jmp    134b <main+0x1db>
lea    0x1e04(%rip),%rcx
lea    0x1e07(%rip),%r14
xor    %edx,%edx
test   $0x1,%al
cmovne %rcx,%r14
cmovne %edx,%ebp
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
nopl   0x0(%rax)
movapd 0x1ee0(%rsp,%rax,8),%xmm0
movapd 0x1ef0(%rsp,%rax,8),%xmm1
addpd  -0x20(%rsp,%rax,8),%xmm0
addpd  -0x10(%rsp,%rax,8),%xmm1
movapd %xmm0,-0x20(%rsp,%rax,8)
movapd %xmm1,-0x10(%rsp,%rax,8)
cmp    $0x1f6,%rax
je     13d0 <main+0x260>
movapd 0x1f00(%rsp,%rax,8),%xmm0
movapd 0x1f10(%rsp,%rax,8),%xmm1
addpd  (%rsp,%rax,8),%xmm0
addpd  0x10(%rsp,%rax,8),%xmm1
movapd %xmm0,(%rsp,%rax,8)
movapd %xmm1,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1370 <main+0x200>
xor    %ebx,%ebx
lea    0x1caf(%rip),%r15
lea    0x1d67(%rip),%r14
movsd  0x1c68(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1410 <main+0x2a0>
jp     1410 <main+0x2a0>
add    $0x1,%rbx
cmp    $0x1f4,%rbx
jne    13f0 <main+0x280>
jmp    1433 <main+0x2c3>
nopl   (%rax)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x1f3,%rbx
mov    %rax,%rbx
jne    13e0 <main+0x270>
jmp    1447 <main+0x2d7>
test   %ebp,%ebp
lea    0x1d01(%rip),%rax
lea    0x1d04(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movapd 0x1ee0(%rsp,%rax,8),%xmm0
addpd  -0x20(%rsp,%rax,8),%xmm0
movapd %xmm0,-0x20(%rsp,%rax,8)
cmp    $0x7e,%rax
je     14ce <main+0x35e>
movapd 0x1ef0(%rsp,%rax,8),%xmm0
movapd 0x1f00(%rsp,%rax,8),%xmm1
movapd 0x1f10(%rsp,%rax,8),%xmm2
addpd  -0x10(%rsp,%rax,8),%xmm0
movapd %xmm0,-0x10(%rsp,%rax,8)
addpd  (%rsp,%rax,8),%xmm1
movapd %xmm1,(%rsp,%rax,8)
addpd  0x10(%rsp,%rax,8),%xmm2
movapd %xmm2,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1470 <main+0x300>
movsd  0x22e0(%rsp),%xmm0
addsd  0x3e0(%rsp),%xmm0
movsd  %xmm0,0x3e0(%rsp)
xor    %ebx,%ebx
lea    0x1b96(%rip),%r15
lea    0x1c4e(%rip),%r14
movsd  0x1b4f(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1530 <main+0x3c0>
jp     1530 <main+0x3c0>
add    $0x1,%rbx
cmp    $0x7b,%rbx
jne    1510 <main+0x3a0>
jmp    1550 <main+0x3e0>
nopw   0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x7a,%rbx
mov    %rax,%rbx
jne    14f9 <main+0x389>
jmp    1564 <main+0x3f4>
test   %ebp,%ebp
lea    0x1be4(%rip),%rax
lea    0x1be7(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
nop
movapd 0x1f10(%rsp,%rbx,8),%xmm0
movapd 0x1f20(%rsp,%rbx,8),%xmm1
movapd 0x1f30(%rsp,%rbx,8),%xmm2
movapd 0x1f40(%rsp,%rbx,8),%xmm3
addpd  0x10(%rsp,%rbx,8),%xmm0
addpd  0x20(%rsp,%rbx,8),%xmm1
movapd %xmm0,0x10(%rsp,%rbx,8)
movapd %xmm1,0x20(%rsp,%rbx,8)
addpd  0x30(%rsp,%rbx,8),%xmm2
addpd  0x40(%rsp,%rbx,8),%xmm3
movapd %xmm2,0x30(%rsp,%rbx,8)
movapd %xmm3,0x40(%rsp,%rbx,8)
add    $0x8,%rbx
cmp    $0x200,%rbx
jne    1580 <main+0x410>
xor    %ebx,%ebx
lea    0x1a9e(%rip),%r15
lea    0x1b56(%rip),%r14
movsd  0x1a57(%rip),%xmm0
nopl   0x0(%rax)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    161d <main+0x4ad>
jp     161d <main+0x4ad>
add    $0x1,%rbx
cmp    $0x200,%rbx
jne    1600 <main+0x490>
jmp    1650 <main+0x4e0>
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0x1a26(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x1a17(%rip),%xmm0
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x1ff,%rbx
mov    %rax,%rbx
jne    1600 <main+0x490>
jmp    1664 <main+0x4f4>
test   %ebp,%ebp
lea    0x1ae4(%rip),%rax
lea    0x1ae7(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
nop
movapd 0x1f10(%rsp,%rbx,8),%xmm0
movapd 0x1f20(%rsp,%rbx,8),%xmm1
movapd 0x1f30(%rsp,%rbx,8),%xmm2
movapd 0x1f40(%rsp,%rbx,8),%xmm3
addpd  0x10(%rsp,%rbx,8),%xmm0
addpd  0x20(%rsp,%rbx,8),%xmm1
movapd %xmm0,0x10(%rsp,%rbx,8)
movapd %xmm1,0x20(%rsp,%rbx,8)
addpd  0x30(%rsp,%rbx,8),%xmm2
addpd  0x40(%rsp,%rbx,8),%xmm3
movapd %xmm2,0x30(%rsp,%rbx,8)
movapd %xmm3,0x40(%rsp,%rbx,8)
add    $0x8,%rbx
cmp    $0x200,%rbx
jne    1680 <main+0x510>
xor    %ebx,%ebx
lea    0x199e(%rip),%r15
lea    0x1a56(%rip),%r14
movsd  0x1957(%rip),%xmm0
nopl   0x0(%rax)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    171d <main+0x5ad>
jp     171d <main+0x5ad>
add    $0x1,%rbx
cmp    $0x200,%rbx
jne    1700 <main+0x590>
jmp    1750 <main+0x5e0>
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0x1926(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x1917(%rip),%xmm0
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x1ff,%rbx
mov    %rax,%rbx
jne    1700 <main+0x590>
jmp    1764 <main+0x5f4>
test   %ebp,%ebp
lea    0x19e4(%rip),%rax
lea    0x19e7(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
nop
movapd 0x1f10(%rsp,%rbx,8),%xmm0
movapd 0x1f20(%rsp,%rbx,8),%xmm1
movapd 0x1f30(%rsp,%rbx,8),%xmm2
movapd 0x1f40(%rsp,%rbx,8),%xmm3
addpd  0x10(%rsp,%rbx,8),%xmm0
addpd  0x20(%rsp,%rbx,8),%xmm1
movapd %xmm0,0x10(%rsp,%rbx,8)
movapd %xmm1,0x20(%rsp,%rbx,8)
addpd  0x30(%rsp,%rbx,8),%xmm2
addpd  0x40(%rsp,%rbx,8),%xmm3
movapd %xmm2,0x30(%rsp,%rbx,8)
movapd %xmm3,0x40(%rsp,%rbx,8)
add    $0x8,%rbx
cmp    $0x200,%rbx
jne    1780 <main+0x610>
xor    %ebx,%ebx
lea    0x189e(%rip),%r15
lea    0x1956(%rip),%r14
movsd  0x1857(%rip),%xmm0
nopl   0x0(%rax)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    181d <main+0x6ad>
jp     181d <main+0x6ad>
add    $0x1,%rbx
cmp    $0x200,%rbx
jne    1800 <main+0x690>
jmp    1850 <main+0x6e0>
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0x1826(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x1817(%rip),%xmm0
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x1ff,%rbx
mov    %rax,%rbx
jne    1800 <main+0x690>
jmp    1864 <main+0x6f4>
test   %ebp,%ebp
lea    0x18e4(%rip),%rax
lea    0x18e7(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd 0x1ee0(%rsp,%rax,8),%xmm0
movapd 0x1ef0(%rsp,%rax,8),%xmm1
addpd  -0x20(%rsp,%rax,8),%xmm0
addpd  -0x10(%rsp,%rax,8),%xmm1
movapd %xmm0,-0x20(%rsp,%rax,8)
movapd %xmm1,-0x10(%rsp,%rax,8)
cmp    $0x1f6,%rax
je     18f0 <main+0x780>
movapd 0x1f00(%rsp,%rax,8),%xmm0
movapd 0x1f10(%rsp,%rax,8),%xmm1
addpd  (%rsp,%rax,8),%xmm0
addpd  0x10(%rsp,%rax,8),%xmm1
movapd %xmm0,(%rsp,%rax,8)
movapd %xmm1,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1890 <main+0x720>
xor    %ebx,%ebx
lea    0x178f(%rip),%r15
lea    0x1847(%rip),%r14
movsd  0x1748(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1930 <main+0x7c0>
jp     1930 <main+0x7c0>
add    $0x1,%rbx
cmp    $0x1f4,%rbx
jne    1910 <main+0x7a0>
jmp    1953 <main+0x7e3>
nopl   (%rax)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x1f3,%rbx
mov    %rax,%rbx
jne    1900 <main+0x790>
jmp    1967 <main+0x7f7>
test   %ebp,%ebp
lea    0x17e1(%rip),%rax
lea    0x17e4(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movapd 0x1ee0(%rsp,%rax,8),%xmm0
movapd 0x1ef0(%rsp,%rax,8),%xmm1
addpd  -0x20(%rsp,%rax,8),%xmm0
addpd  -0x10(%rsp,%rax,8),%xmm1
movapd %xmm0,-0x20(%rsp,%rax,8)
movapd %xmm1,-0x10(%rsp,%rax,8)
cmp    $0x1f6,%rax
je     19f0 <main+0x880>
movapd 0x1f00(%rsp,%rax,8),%xmm0
movapd 0x1f10(%rsp,%rax,8),%xmm1
addpd  (%rsp,%rax,8),%xmm0
addpd  0x10(%rsp,%rax,8),%xmm1
movapd %xmm0,(%rsp,%rax,8)
movapd %xmm1,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1990 <main+0x820>
xor    %ebx,%ebx
lea    0x168f(%rip),%r15
lea    0x1747(%rip),%r14
movsd  0x1648(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1a30 <main+0x8c0>
jp     1a30 <main+0x8c0>
add    $0x1,%rbx
cmp    $0x1f4,%rbx
jne    1a10 <main+0x8a0>
jmp    1a53 <main+0x8e3>
nopl   (%rax)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x1f3,%rbx
mov    %rax,%rbx
jne    1a00 <main+0x890>
jmp    1a67 <main+0x8f7>
test   %ebp,%ebp
lea    0x16e1(%rip),%rax
lea    0x16e4(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movapd 0x1ee0(%rsp,%rax,8),%xmm0
movapd 0x1ef0(%rsp,%rax,8),%xmm1
addpd  -0x20(%rsp,%rax,8),%xmm0
addpd  -0x10(%rsp,%rax,8),%xmm1
movapd %xmm0,-0x20(%rsp,%rax,8)
movapd %xmm1,-0x10(%rsp,%rax,8)
cmp    $0x1f6,%rax
je     1af0 <main+0x980>
movapd 0x1f00(%rsp,%rax,8),%xmm0
movapd 0x1f10(%rsp,%rax,8),%xmm1
addpd  (%rsp,%rax,8),%xmm0
addpd  0x10(%rsp,%rax,8),%xmm1
movapd %xmm0,(%rsp,%rax,8)
movapd %xmm1,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1a90 <main+0x920>
xor    %ebx,%ebx
lea    0x158f(%rip),%r15
lea    0x1647(%rip),%r14
movsd  0x1548(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1b30 <main+0x9c0>
jp     1b30 <main+0x9c0>
add    $0x1,%rbx
cmp    $0x1f4,%rbx
jne    1b10 <main+0x9a0>
jmp    1b53 <main+0x9e3>
nopl   (%rax)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x1f3,%rbx
mov    %rax,%rbx
jne    1b00 <main+0x990>
jmp    1b67 <main+0x9f7>
test   %ebp,%ebp
lea    0x15e1(%rip),%rax
lea    0x15e4(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movapd 0x1ee0(%rsp,%rax,8),%xmm0
addpd  -0x20(%rsp,%rax,8),%xmm0
movapd %xmm0,-0x20(%rsp,%rax,8)
cmp    $0x7e,%rax
je     1bee <main+0xa7e>
movapd 0x1ef0(%rsp,%rax,8),%xmm0
movapd 0x1f00(%rsp,%rax,8),%xmm1
movapd 0x1f10(%rsp,%rax,8),%xmm2
addpd  -0x10(%rsp,%rax,8),%xmm0
movapd %xmm0,-0x10(%rsp,%rax,8)
addpd  (%rsp,%rax,8),%xmm1
movapd %xmm1,(%rsp,%rax,8)
addpd  0x10(%rsp,%rax,8),%xmm2
movapd %xmm2,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1b90 <main+0xa20>
movsd  0x22e0(%rsp),%xmm0
addsd  0x3e0(%rsp),%xmm0
movsd  %xmm0,0x3e0(%rsp)
xor    %ebx,%ebx
lea    0x1476(%rip),%r15
lea    0x152e(%rip),%r14
movsd  0x142f(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1c50 <main+0xae0>
jp     1c50 <main+0xae0>
add    $0x1,%rbx
cmp    $0x7b,%rbx
jne    1c30 <main+0xac0>
jmp    1c70 <main+0xb00>
nopw   0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x7a,%rbx
mov    %rax,%rbx
jne    1c19 <main+0xaa9>
jmp    1c84 <main+0xb14>
test   %ebp,%ebp
lea    0x14c4(%rip),%rax
lea    0x14c7(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd 0x1ee0(%rsp,%rax,8),%xmm0
addpd  -0x20(%rsp,%rax,8),%xmm0
movapd %xmm0,-0x20(%rsp,%rax,8)
cmp    $0x7e,%rax
je     1d0e <main+0xb9e>
movapd 0x1ef0(%rsp,%rax,8),%xmm0
movapd 0x1f00(%rsp,%rax,8),%xmm1
movapd 0x1f10(%rsp,%rax,8),%xmm2
addpd  -0x10(%rsp,%rax,8),%xmm0
movapd %xmm0,-0x10(%rsp,%rax,8)
addpd  (%rsp,%rax,8),%xmm1
movapd %xmm1,(%rsp,%rax,8)
addpd  0x10(%rsp,%rax,8),%xmm2
movapd %xmm2,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1cb0 <main+0xb40>
movsd  0x22e0(%rsp),%xmm0
addsd  0x3e0(%rsp),%xmm0
movsd  %xmm0,0x3e0(%rsp)
xor    %ebx,%ebx
lea    0x1356(%rip),%r15
lea    0x140e(%rip),%r14
movsd  0x130f(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1d70 <main+0xc00>
jp     1d70 <main+0xc00>
add    $0x1,%rbx
cmp    $0x7b,%rbx
jne    1d50 <main+0xbe0>
jmp    1d90 <main+0xc20>
nopw   0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x7a,%rbx
mov    %rax,%rbx
jne    1d39 <main+0xbc9>
jmp    1da4 <main+0xc34>
test   %ebp,%ebp
lea    0x13a4(%rip),%rax
lea    0x13a7(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x6,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd 0x1ee0(%rsp,%rax,8),%xmm0
addpd  -0x20(%rsp,%rax,8),%xmm0
movapd %xmm0,-0x20(%rsp,%rax,8)
cmp    $0x7e,%rax
je     1e2e <main+0xcbe>
movapd 0x1ef0(%rsp,%rax,8),%xmm0
movapd 0x1f00(%rsp,%rax,8),%xmm1
movapd 0x1f10(%rsp,%rax,8),%xmm2
addpd  -0x10(%rsp,%rax,8),%xmm0
movapd %xmm0,-0x10(%rsp,%rax,8)
addpd  (%rsp,%rax,8),%xmm1
movapd %xmm1,(%rsp,%rax,8)
addpd  0x10(%rsp,%rax,8),%xmm2
movapd %xmm2,0x10(%rsp,%rax,8)
add    $0x8,%rax
jmp    1dd0 <main+0xc60>
movsd  0x22e0(%rsp),%xmm0
addsd  0x3e0(%rsp),%xmm0
movsd  %xmm0,0x3e0(%rsp)
xor    %ebx,%ebx
lea    0x1236(%rip),%r15
lea    0x12ee(%rip),%r14
movsd  0x11ef(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1e90 <main+0xd20>
jp     1e90 <main+0xd20>
add    $0x1,%rbx
cmp    $0x7b,%rbx
jne    1e70 <main+0xd00>
jmp    1eb0 <main+0xd40>
nopw   0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0x1(%rbx),%rax
mov    $0x1,%ebp
cmp    $0x7a,%rbx
mov    %rax,%rbx
jne    1e59 <main+0xce9>
jmp    1ec4 <main+0xd54>
test   %ebp,%ebp
lea    0x1284(%rip),%rax
lea    0x1287(%rip),%r14
cmove  %rax,%r14
mov    %r14,%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>
mov    $0x6,%eax
movapd 0x1112(%rip),%xmm2
movapd 0x111a(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
movapd -0x20(%rsp,%rax,8),%xmm0
addpd  %xmm2,%xmm0
movapd -0x10(%rsp,%rax,8),%xmm1
addpd  %xmm2,%xmm1
movapd %xmm0,-0x20(%rsp,%rax,8)
movapd %xmm1,-0x10(%rsp,%rax,8)
movapd 0x3de0(%rsp,%rax,8),%xmm0
addpd  %xmm3,%xmm0
movapd 0x3df0(%rsp,%rax,8),%xmm1
addpd  %xmm3,%xmm1
movapd %xmm0,0x3de0(%rsp,%rax,8)
movapd %xmm1,0x3df0(%rsp,%rax,8)
movapd (%rsp,%rax,8),%xmm0
addpd  %xmm2,%xmm0
movapd 0x10(%rsp,%rax,8),%xmm1
addpd  %xmm2,%xmm1
movapd %xmm0,(%rsp,%rax,8)
movapd %xmm1,0x10(%rsp,%rax,8)
movapd 0x3e00(%rsp,%rax,8),%xmm0
addpd  %xmm3,%xmm0
movapd 0x3e10(%rsp,%rax,8),%xmm1
addpd  %xmm3,%xmm1
movapd %xmm0,0x3e00(%rsp,%rax,8)
movapd %xmm1,0x3e10(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x3e6,%rax
jne    1f10 <main+0xda0>
xor    %ebx,%ebx
movsd  0x1098(%rip),%xmm2
lea    0x10e0(%rip),%r15
lea    0x10fb(%rip),%r12
lea    0x1172(%rip),%r14
jmp    1fed <main+0xe7d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    $0x3e0,%rbx
je     2059 <main+0xee9>
movsd  0x10(%rsp,%rbx,8),%xmm1
ucomisd %xmm2,%xmm1
jne    1ffb <main+0xe8b>
jnp    2018 <main+0xea8>
mov    %r15,%rdi
mov    %ebx,%esi
movapd %xmm2,%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x1045(%rip),%xmm2
mov    $0x1,%ebp
movsd  0x3e10(%rsp,%rbx,8),%xmm1
movsd  0x1037(%rip),%xmm0
ucomisd %xmm0,%xmm1
jne    2031 <main+0xec1>
jnp    1fe0 <main+0xe70>
mov    %r12,%rdi
mov    %ebx,%esi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x1013(%rip),%xmm2
add    $0x1,%rbx
mov    $0x1,%ebp
cmp    $0x3e0,%rbx
jne    1fed <main+0xe7d>
jmp    206d <main+0xefd>
test   %ebp,%ebp
lea    0x10db(%rip),%rax
lea    0x10de(%rip),%r14
cmove  %rax,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
lea    0x10(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x3e10(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1050 <memset@plt>
movapd 0xf8c(%rip),%xmm0
movapd 0xf94(%rip),%xmm1
nopl   0x0(%rax)
addpd  %xmm1,%xmm0
movapd %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
addsd  0x10(%rsp,%rbx,8),%xmm2
movsd  %xmm2,0x10(%rsp,%rbx,8)
movsd  0x3e10(%rsp,%rbx,8),%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x3e10(%rsp,%rbx,8)
addpd  %xmm1,%xmm0
movapd %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
addsd  0x18(%rsp,%rbx,8),%xmm2
movsd  %xmm2,0x18(%rsp,%rbx,8)
movsd  0x3e18(%rsp,%rbx,8),%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x3e18(%rsp,%rbx,8)
add    $0x2,%rbx
cmp    $0x80,%rbx
jne    20b0 <main+0xf40>
xor    %ebx,%ebx
movsd  0xf55(%rip),%xmm0
lea    0xf7d(%rip),%r14
lea    0xf98(%rip),%r15
movsd  0xf2f(%rip),%xmm2
jmp    216d <main+0xffd>
nopl   0x0(%rax,%rax,1)
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0xf19(%rip),%xmm2
movsd  0xf21(%rip),%xmm0
mov    $0x1,%ebp
add    $0x1,%rbx
cmp    $0x80,%rbx
je     2228 <main+0x10b8>
movsd  0x10(%rsp,%rbx,8),%xmm1
test   $0x1,%bl
jne    21d0 <main+0x1060>
ucomisd %xmm0,%xmm1
jne    2180 <main+0x1010>
jnp    21a9 <main+0x1039>
mov    %r14,%rdi
mov    %ebx,%esi
movsd  0xeeb(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0xecc(%rip),%xmm2
movsd  0xed4(%rip),%xmm0
mov    $0x1,%ebp
movsd  0x3e10(%rsp,%rbx,8),%xmm1
ucomisd 0xec6(%rip),%xmm1
jne    21be <main+0x104e>
jnp    215c <main+0xfec>
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0xeb5(%rip),%xmm0
jmp    2140 <main+0xfd0>
ucomisd %xmm2,%xmm1
jne    21d8 <main+0x1068>
jnp    21fd <main+0x108d>
mov    %r14,%rdi
mov    %ebx,%esi
movapd %xmm2,%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0xe78(%rip),%xmm2
movsd  0xe80(%rip),%xmm0
mov    $0x1,%ebp
movsd  0x3e10(%rsp,%rbx,8),%xmm1
ucomisd 0xe62(%rip),%xmm1
jne    2216 <main+0x10a6>
jnp    215c <main+0xfec>
mov    %r15,%rdi
mov    %ebx,%esi
movsd  0xe4d(%rip),%xmm0
jmp    2140 <main+0xfd0>
test   %ebp,%ebp
lea    0xf0c(%rip),%r13
lea    0xf0f(%rip),%r14
mov    %r14,%rdi
cmove  %r13,%rdi
call   1030 <puts@plt>
xor    %eax,%eax
call   1090 <omp_get_num_teams@plt>
test   %eax,%eax
jle    228d <main+0x111d>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   1080 <omp_get_team_num@plt>
mov    %eax,%r15d
add    $0x1,%ebx
xor    %eax,%eax
call   1090 <omp_get_num_teams@plt>
cmp    %eax,%ebx
jl     2260 <main+0x10f0>
cmp    $0x9,%r15d
jne    2293 <main+0x1123>
test   %ebp,%ebp
lea    0xec0(%rip),%r14
cmove  %r13,%r14
jmp    22ae <main+0x113e>
mov    $0xffffffff,%r15d
lea    0xe51(%rip),%rdi
mov    %r15d,%esi
mov    $0x9,%edx
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0x1,%ebp
mov    %r14,%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 0xcfb(%rip),%xmm0
movapd 0xd03(%rip),%xmm1
nopl   (%rax)
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    2320 <main+0x11b0>
add    $0x1,%r12
add    $0x1f00,%rax
add    $0x1f00,%rcx
cmp    $0x3e0,%r12
jne    2310 <main+0x11a0>
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    23c0 <main+0x1250>
add    $0x1,%rax
add    $0x1f00,%rcx
add    $0x1f00,%rbx
add    $0x1f00,%r15
cmp    $0x3e0,%rax
jne    23b0 <main+0x1240>
xor    %r12d,%r12d
lea    0xce3(%rip),%r15
movsd  0xc22(%rip),%xmm0
jmp    2454 <main+0x12e4>
add    $0x1,%r12
add    $0x1f00,%r14
cmp    $0x3e0,%r12
je     24a1 <main+0x1331>
xor    %ebx,%ebx
jmp    246d <main+0x12fd>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    $0x3e0,%rbx
je     2440 <main+0x12d0>
movsd  (%r14,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jne    247b <main+0x130b>
jnp    2460 <main+0x12f0>
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
movsd  0xbd5(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0xbc6(%rip),%xmm0
mov    $0x1,%ebp
jmp    2460 <main+0x12f0>
test   %ebp,%ebp
lea    0xc9d(%rip),%rdi
cmove  %r13,%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 0xb34(%rip),%xmm0
movapd 0xb3c(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
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 %xmm0,-0x10(%rdi,%rdx,8)
movupd %xmm1,-0x10(%rcx,%rdx,8)
movupd %xmm0,(%rdi,%rdx,8)
movupd %xmm1,(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    $0x7c,%rdx
jne    2510 <main+0x13a0>
add    $0x1,%rbx
add    $0x3e0,%rcx
add    $0x3e0,%rdi
cmp    $0x7c,%rbx
jne    2500 <main+0x1390>
add    $0x1,%rsi
add    $0x1e080,%r8
add    $0x1e080,%r9
cmp    $0x7c,%rsi
jne    24f0 <main+0x1380>
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    2590 <main+0x1420>
add    $0x1,%rbx
add    $0x3e0,%rdi
add    $0x3e0,%rsi
cmp    $0x7c,%rbx
jne    2580 <main+0x1410>
add    $0x1,%rdx
add    $0x1e080,%r8
add    $0x1e080,%rax
cmp    $0x7c,%rdx
jne    2570 <main+0x1400>
xor    %r13d,%r13d
lea    0xb19(%rip),%r12
movsd  0xa70(%rip),%xmm0
jmp    2626 <main+0x14b6>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r13
mov    0x8(%rsp),%r15
add    $0x1e080,%r15
cmp    $0x7c,%r13
je     268e <main+0x151e>
mov    %r15,0x8(%rsp)
xor    %ebx,%ebx
jmp    2641 <main+0x14d1>
nop
add    $0x1,%rbx
add    $0x3e0,%r15
cmp    $0x7c,%rbx
je     2610 <main+0x14a0>
xor    %r14d,%r14d
jmp    265a <main+0x14ea>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r14
cmp    $0x7c,%r14
je     2630 <main+0x14c0>
movsd  (%r15,%r14,8),%xmm1
ucomisd %xmm0,%xmm1
jne    2668 <main+0x14f8>
jnp    2650 <main+0x14e0>
mov    %r12,%rdi
mov    %r13d,%esi
mov    %ebx,%edx
movsd  0x9e8(%rip),%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x9f1(%rip),%xmm0
mov    $0x1,%ebp
jmp    2650 <main+0x14e0>
test   %ebp,%ebp
lea    0xaa6(%rip),%rax
lea    0xaa9(%rip),%rdi
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 = [31 x i8] c"Error at %d, h = %lf, d = %lf\0A\00"
@.str.1 = [8 x i8] c"Failed\0A\00"
@.str.2 = [11 x i8] c"Succeeded\0A\00"
@.str.3 = [34 x i8] c"Error at A[%d], h = %lf, d = %lf\0A\00"
@.str.4 = [34 x i8] c"Error at B[%d], h = %lf, d = %lf\0A\00"
@.str.5 = [46 x i8] c"lastpriv value is %d and should have been %d\0A\00"
@.str.6 = [36 x i8] c"Error at (%d,%d), h = %lf, d = %lf\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 i32
%12 = alloca i32
%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 double
%62 = alloca double
%63 = alloca i32
%64 = alloca i32
%65 = alloca i32
%66 = alloca i32
%67 = alloca i32
%68 = alloca i32
%69 = alloca i32
%70 = alloca i32
%71 = alloca i32
%72 = alloca i32
%73 = alloca double*
%74 = alloca double*
%75 = alloca double*
%76 = alloca i32
%77 = alloca i32
%78 = alloca i32
%79 = alloca i32
%80 = alloca i32
%81 = alloca i32
%82 = alloca i32
%83 = alloca i32
%84 = alloca double*
%85 = alloca double*
%86 = alloca i32
%87 = alloca i32
%88 = alloca i32
%89 = alloca i32
%90 = alloca i32
%91 = alloca i32
%92 = alloca i32
%93 = alloca i32
%94 = alloca i32
%95 = alloca i32
store i32 0, i32* %1
%96 = call i32 (...) @check_offloading()
store i32 0, i32* %7
store i32 0, i32* %8
br label %97
97: ; preds = %115, %0
%98 = load i32, i32* %8
%99 = icmp slt i32 %98, 992
br i1 %99, label %100, label %118
100: ; preds = %97
%101 = load i32, i32* %8
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds [992 x double], [992 x double]* %4, i64 0, i64 %102
store double 1.000000e+00, double* %103
%104 = load i32, i32* %8
%105 = sitofp i32 %104 to double
%106 = load i32, i32* %8
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds [992 x double], [992 x double]* %5, i64 0, i64 %107
store double %105, double* %108
%109 = load i32, i32* %8
%110 = sub nsw i32 0, %109
%111 = sitofp i32 %110 to double
%112 = load i32, i32* %8
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds [992 x double], [992 x double]* %6, i64 0, i64 %113
store double %111, double* %114
br label %115
115: ; preds = %100
%116 = load i32, i32* %8
%117 = add nsw i32 %116, 1
store i32 %117, i32* %8
br label %97
118: ; preds = %97
store i32 0, i32* %9
br label %119
119: ; preds = %126, %118
%120 = load i32, i32* %9
%121 = icmp slt i32 %120, 992
br i1 %121, label %122, label %129
122: ; preds = %119
%123 = load i32, i32* %9
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %124
store double 0.000000e+00, double* %125
br label %126
126: ; preds = %122
%127 = load i32, i32* %9
%128 = add nsw i32 %127, 1
store i32 %128, i32* %9
br label %119
129: ; preds = %119
store i32 0, i32* %10
br label %130
130: ; preds = %151, %129
%131 = load i32, i32* %10
%132 = icmp slt i32 %131, 1
br i1 %132, label %133, label %154
133: ; preds = %130
store i32 0, i32* %11
br label %134
134: ; preds = %147, %133
%135 = load i32, i32* %11
%136 = icmp slt i32 %135, 512
br i1 %136, label %137, label %150
137: ; preds = %134
%138 = load i32, i32* %11
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds [992 x double], [992 x double]* %4, i64 0, i64 %139
%141 = load double, double* %140
%142 = load i32, i32* %11
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %143
%145 = load double, double* %144
%146 = fadd double %145, %141
store double %146, double* %144
br label %147
147: ; preds = %137
%148 = load i32, i32* %11
%149 = add nsw i32 %148, 1
store i32 %149, i32* %11
br label %134
150: ; preds = %134
br label %151
151: ; preds = %150
%152 = load i32, i32* %10
%153 = add nsw i32 %152, 1
store i32 %153, i32* %10
br label %130
154: ; preds = %130
store i32 0, i32* %12
br label %155
155: ; preds = %172, %154
%156 = load i32, i32* %12
%157 = icmp slt i32 %156, 512
br i1 %157, label %158, label %175
158: ; preds = %155
%159 = load i32, i32* %12
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %160
%162 = load double, double* %161
%163 = fcmp une double %162, 1.000000e+00
br i1 %163, label %164, label %171
164: ; preds = %158
%165 = load i32, i32* %12
%166 = load i32, i32* %12
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %167
%169 = load double, double* %168
%170 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0), i32 %165, double 1.000000e+00, double %169)
store i32 1, i32* %7
br label %171
171: ; preds = %164, %158
br label %172
172: ; preds = %171
%173 = load i32, i32* %12
%174 = add nsw i32 %173, 1
store i32 %174, i32* %12
br label %155
175: ; preds = %155
%176 = load i32, i32* %7
%177 = icmp ne i32 %176, 0
br i1 %177, label %178, label %180
178: ; preds = %175
%179 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %182
180: ; preds = %175
%181 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %182
182: ; preds = %180, %178
store i32 0, i32* %13
br label %183
183: ; preds = %190, %182
%184 = load i32, i32* %13
%185 = icmp slt i32 %184, 992
br i1 %185, label %186, label %193
186: ; preds = %183
%187 = load i32, i32* %13
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %188
store double 0.000000e+00, double* %189
br label %190
190: ; preds = %186
%191 = load i32, i32* %13
%192 = add nsw i32 %191, 1
store i32 %192, i32* %13
br label %183
193: ; preds = %183
store i32 0, i32* %14
br label %194
194: ; preds = %215, %193
%195 = load i32, i32* %14
%196 = icmp slt i32 %195, 1
br i1 %196, label %197, label %218
197: ; preds = %194
store i32 0, i32* %15
br label %198
198: ; preds = %211, %197
%199 = load i32, i32* %15
%200 = icmp slt i32 %199, 500
br i1 %200, label %201, label %214
201: ; preds = %198
%202 = load i32, i32* %15
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds [992 x double], [992 x double]* %4, i64 0, i64 %203
%205 = load double, double* %204
%206 = load i32, i32* %15
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %207
%209 = load double, double* %208
%210 = fadd double %209, %205
store double %210, double* %208
br label %211
211: ; preds = %201
%212 = load i32, i32* %15
%213 = add nsw i32 %212, 1
store i32 %213, i32* %15
br label %198
214: ; preds = %198
br label %215
215: ; preds = %214
%216 = load i32, i32* %14
%217 = add nsw i32 %216, 1
store i32 %217, i32* %14
br label %194
218: ; preds = %194
store i32 0, i32* %16
br label %219
219: ; preds = %236, %218
%220 = load i32, i32* %16
%221 = icmp slt i32 %220, 500
br i1 %221, label %222, label %239
222: ; preds = %219
%223 = load i32, i32* %16
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %224
%226 = load double, double* %225
%227 = fcmp une double %226, 1.000000e+00
br i1 %227, label %228, label %235
228: ; preds = %222
%229 = load i32, i32* %16
%230 = load i32, i32* %16
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %231
%233 = load double, double* %232
%234 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0), i32 %229, double 1.000000e+00, double %233)
store i32 1, i32* %7
br label %235
235: ; preds = %228, %222
br label %236
236: ; preds = %235
%237 = load i32, i32* %16
%238 = add nsw i32 %237, 1
store i32 %238, i32* %16
br label %219
239: ; preds = %219
%240 = load i32, i32* %7
%241 = icmp ne i32 %240, 0
br i1 %241, label %242, label %244
242: ; preds = %239
%243 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %246
244: ; preds = %239
%245 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %246
246: ; preds = %244, %242
store i32 0, i32* %17
br label %247
247: ; preds = %254, %246
%248 = load i32, i32* %17
%249 = icmp slt i32 %248, 992
br i1 %249, label %250, label %257
250: ; preds = %247
%251 = load i32, i32* %17
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %252
store double 0.000000e+00, double* %253
br label %254
254: ; preds = %250
%255 = load i32, i32* %17
%256 = add nsw i32 %255, 1
store i32 %256, i32* %17
br label %247
257: ; preds = %247
store i32 0, i32* %18
br label %258
258: ; preds = %279, %257
%259 = load i32, i32* %18
%260 = icmp slt i32 %259, 1
br i1 %260, label %261, label %282
261: ; preds = %258
store i32 0, i32* %19
br label %262
262: ; preds = %275, %261
%263 = load i32, i32* %19
%264 = icmp slt i32 %263, 123
br i1 %264, label %265, label %278
265: ; preds = %262
%266 = load i32, i32* %19
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds [992 x double], [992 x double]* %4, i64 0, i64 %267
%269 = load double, double* %268
%270 = load i32, i32* %19
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %271
%273 = load double, double* %272
%274 = fadd double %273, %269
store double %274, double* %272
br label %275
275: ; preds = %265
%276 = load i32, i32* %19
%277 = add nsw i32 %276, 1
store i32 %277, i32* %19
br label %262
278: ; preds = %262
br label %279
279: ; preds = %278
%280 = load i32, i32* %18
%281 = add nsw i32 %280, 1
store i32 %281, i32* %18
br label %258
282: ; preds = %258
store i32 0, i32* %20
br label %283
283: ; preds = %300, %282
%284 = load i32, i32* %20
%285 = icmp slt i32 %284, 123
br i1 %285, label %286, label %303
286: ; preds = %283
%287 = load i32, i32* %20
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %288
%290 = load double, double* %289
%291 = fcmp une double %290, 1.000000e+00
br i1 %291, label %292, label %299
292: ; preds = %286
%293 = load i32, i32* %20
%294 = load i32, i32* %20
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %295
%297 = load double, double* %296
%298 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0), i32 %293, double 1.000000e+00, double %297)
store i32 1, i32* %7
br label %299
299: ; preds = %292, %286
br label %300
300: ; preds = %299
%301 = load i32, i32* %20
%302 = add nsw i32 %301, 1
store i32 %302, i32* %20
br label %283
303: ; preds = %283
%304 = load i32, i32* %7
%305 = icmp ne i32 %304, 0
br i1 %305, label %306, label %308
306: ; preds = %303
%307 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %310
308: ; preds = %303
%309 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %310
310: ; preds = %308, %306
store i32 0, i32* %21
br label %311
311: ; preds = %318, %310
%312 = load i32, i32* %21
%313 = icmp slt i32 %312, 992
br i1 %313, label %314, label %321
314: ; preds = %311
%315 = load i32, i32* %21
%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* %21
%320 = add nsw i32 %319, 1
store i32 %320, i32* %21
br label %311
321: ; preds = %311
store i32 0, i32* %22
br label %322
322: ; preds = %343, %321
%323 = load i32, i32* %22
%324 = icmp slt i32 %323, 1
br i1 %324, label %325, label %346
325: ; preds = %322
store i32 0, i32* %23
br label %326
326: ; preds = %339, %325
%327 = load i32, i32* %23
%328 = icmp slt i32 %327, 512
br i1 %328, label %329, label %342
329: ; preds = %326
%330 = load i32, i32* %23
%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* %23
%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* %23
%341 = add nsw i32 %340, 1
store i32 %341, i32* %23
br label %326
342: ; preds = %326
br label %343
343: ; preds = %342
%344 = load i32, i32* %22
%345 = add nsw i32 %344, 1
store i32 %345, i32* %22
br label %322
346: ; preds = %322
store i32 0, i32* %24
br label %347
347: ; preds = %364, %346
%348 = load i32, i32* %24
%349 = icmp slt i32 %348, 512
br i1 %349, label %350, label %367
350: ; preds = %347
%351 = load i32, i32* %24
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %352
%354 = load double, double* %353
%355 = fcmp une double %354, 1.000000e+00
br i1 %355, label %356, label %363
356: ; preds = %350
%357 = load i32, i32* %24
%358 = load i32, i32* %24
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %359
%361 = load double, double* %360
%362 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0), i32 %357, double 1.000000e+00, double %361)
store i32 1, i32* %7
br label %363
363: ; preds = %356, %350
br label %364
364: ; preds = %363
%365 = load i32, i32* %24
%366 = add nsw i32 %365, 1
store i32 %366, i32* %24
br label %347
367: ; preds = %347
%368 = load i32, i32* %7
%369 = icmp ne i32 %368, 0
br i1 %369, label %370, label %372
370: ; preds = %367
%371 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %374
372: ; preds = %367
%373 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %374
374: ; preds = %372, %370
store i32 0, i32* %25
br label %375
375: ; preds = %382, %374
%376 = load i32, i32* %25
%377 = icmp slt i32 %376, 992
br i1 %377, label %378, label %385
378: ; preds = %375
%379 = load i32, i32* %25
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %380
store double 0.000000e+00, double* %381
br label %382
382: ; preds = %378
%383 = load i32, i32* %25
%384 = add nsw i32 %383, 1
store i32 %384, i32* %25
br label %375
385: ; preds = %375
store i32 0, i32* %26
br label %386
386: ; preds = %407, %385
%387 = load i32, i32* %26
%388 = icmp slt i32 %387, 1
br i1 %388, label %389, label %410
389: ; preds = %386
store i32 0, i32* %27
br label %390
390: ; preds = %403, %389
%391 = load i32, i32* %27
%392 = icmp slt i32 %391, 512
br i1 %392, label %393, label %406
393: ; preds = %390
%394 = load i32, i32* %27
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds [992 x double], [992 x double]* %4, i64 0, i64 %395
%397 = load double, double* %396
%398 = load i32, i32* %27
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %399
%401 = load double, double* %400
%402 = fadd double %401, %397
store double %402, double* %400
br label %403
403: ; preds = %393
%404 = load i32, i32* %27
%405 = add nsw i32 %404, 1
store i32 %405, i32* %27
br label %390
406: ; preds = %390
br label %407
407: ; preds = %406
%408 = load i32, i32* %26
%409 = add nsw i32 %408, 1
store i32 %409, i32* %26
br label %386
410: ; preds = %386
store i32 0, i32* %28
br label %411
411: ; preds = %428, %410
%412 = load i32, i32* %28
%413 = icmp slt i32 %412, 512
br i1 %413, label %414, label %431
414: ; preds = %411
%415 = load i32, i32* %28
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %416
%418 = load double, double* %417
%419 = fcmp une double %418, 1.000000e+00
br i1 %419, label %420, label %427
420: ; preds = %414
%421 = load i32, i32* %28
%422 = load i32, i32* %28
%423 = sext i32 %422 to i64
%424 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %423
%425 = load double, double* %424
%426 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0), i32 %421, double 1.000000e+00, double %425)
store i32 1, i32* %7
br label %427
427: ; preds = %420, %414
br label %428
428: ; preds = %427
%429 = load i32, i32* %28
%430 = add nsw i32 %429, 1
store i32 %430, i32* %28
br label %411
431: ; preds = %411
%432 = load i32, i32* %7
%433 = icmp ne i32 %432, 0
br i1 %433, label %434, label %436
434: ; preds = %431
%435 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %438
436: ; preds = %431
%437 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %438
438: ; preds = %436, %434
store i32 0, i32* %29
br label %439
439: ; preds = %446, %438
%440 = load i32, i32* %29
%441 = icmp slt i32 %440, 992
br i1 %441, label %442, label %449
442: ; preds = %439
%443 = load i32, i32* %29
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %444
store double 0.000000e+00, double* %445
br label %446
446: ; preds = %442
%447 = load i32, i32* %29
%448 = add nsw i32 %447, 1
store i32 %448, i32* %29
br label %439
449: ; preds = %439
store i32 10, i32* %30
%450 = load i32, i32* %30
%451 = sdiv i32 512, %450
store i32 %451, i32* %31
store i32 0, i32* %32
br label %452
452: ; preds = %473, %449
%453 = load i32, i32* %32
%454 = icmp slt i32 %453, 1
br i1 %454, label %455, label %476
455: ; preds = %452
store i32 0, i32* %33
br label %456
456: ; preds = %469, %455
%457 = load i32, i32* %33
%458 = icmp slt i32 %457, 512
br i1 %458, label %459, label %472
459: ; preds = %456
%460 = load i32, i32* %33
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds [992 x double], [992 x double]* %4, i64 0, i64 %461
%463 = load double, double* %462
%464 = load i32, i32* %33
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %465
%467 = load double, double* %466
%468 = fadd double %467, %463
store double %468, double* %466
br label %469
469: ; preds = %459
%470 = load i32, i32* %33
%471 = add nsw i32 %470, 1
store i32 %471, i32* %33
br label %456
472: ; preds = %456
br label %473
473: ; preds = %472
%474 = load i32, i32* %32
%475 = add nsw i32 %474, 1
store i32 %475, i32* %32
br label %452
476: ; preds = %452
store i32 0, i32* %34
br label %477
477: ; preds = %494, %476
%478 = load i32, i32* %34
%479 = icmp slt i32 %478, 512
br i1 %479, label %480, label %497
480: ; preds = %477
%481 = load i32, i32* %34
%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 = fcmp une double %484, 1.000000e+00
br i1 %485, label %486, label %493
486: ; preds = %480
%487 = load i32, i32* %34
%488 = load i32, i32* %34
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %489
%491 = load double, double* %490
%492 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0), i32 %487, double 1.000000e+00, double %491)
store i32 1, i32* %7
br label %493
493: ; preds = %486, %480
br label %494
494: ; preds = %493
%495 = load i32, i32* %34
%496 = add nsw i32 %495, 1
store i32 %496, i32* %34
br label %477
497: ; preds = %477
%498 = load i32, i32* %7
%499 = icmp ne i32 %498, 0
br i1 %499, label %500, label %502
500: ; preds = %497
%501 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %504
502: ; preds = %497
%503 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %504
504: ; preds = %502, %500
store i32 0, i32* %35
br label %505
505: ; preds = %512, %504
%506 = load i32, i32* %35
%507 = icmp slt i32 %506, 992
br i1 %507, label %508, label %515
508: ; preds = %505
%509 = load i32, i32* %35
%510 = sext i32 %509 to i64
%511 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %510
store double 0.000000e+00, double* %511
br label %512
512: ; preds = %508
%513 = load i32, i32* %35
%514 = add nsw i32 %513, 1
store i32 %514, i32* %35
br label %505
515: ; preds = %505
store i32 0, i32* %36
br label %516
516: ; preds = %537, %515
%517 = load i32, i32* %36
%518 = icmp slt i32 %517, 1
br i1 %518, label %519, label %540
519: ; preds = %516
store i32 0, i32* %37
br label %520
520: ; preds = %533, %519
%521 = load i32, i32* %37
%522 = icmp slt i32 %521, 500
br i1 %522, label %523, label %536
523: ; preds = %520
%524 = load i32, i32* %37
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds [992 x double], [992 x double]* %4, i64 0, i64 %525
%527 = load double, double* %526
%528 = load i32, i32* %37
%529 = sext i32 %528 to i64
%530 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %529
%531 = load double, double* %530
%532 = fadd double %531, %527
store double %532, double* %530
br label %533
533: ; preds = %523
%534 = load i32, i32* %37
%535 = add nsw i32 %534, 1
store i32 %535, i32* %37
br label %520
536: ; preds = %520
br label %537
537: ; preds = %536
%538 = load i32, i32* %36
%539 = add nsw i32 %538, 1
store i32 %539, i32* %36
br label %516
540: ; preds = %516
store i32 0, i32* %38
br label %541
541: ; preds = %558, %540
%542 = load i32, i32* %38
%543 = icmp slt i32 %542, 500
br i1 %543, label %544, label %561
544: ; preds = %541
%545 = load i32, i32* %38
%546 = sext i32 %545 to i64
%547 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %546
%548 = load double, double* %547
%549 = fcmp une double %548, 1.000000e+00
br i1 %549, label %550, label %557
550: ; preds = %544
%551 = load i32, i32* %38
%552 = load i32, i32* %38
%553 = sext i32 %552 to i64
%554 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %553
%555 = load double, double* %554
%556 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0), i32 %551, double 1.000000e+00, double %555)
store i32 1, i32* %7
br label %557
557: ; preds = %550, %544
br label %558
558: ; preds = %557
%559 = load i32, i32* %38
%560 = add nsw i32 %559, 1
store i32 %560, i32* %38
br label %541
561: ; preds = %541
%562 = load i32, i32* %7
%563 = icmp ne i32 %562, 0
br i1 %563, label %564, label %566
564: ; preds = %561
%565 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %568
566: ; preds = %561
%567 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %568
568: ; preds = %566, %564
store i32 0, i32* %39
br label %569
569: ; preds = %576, %568
%570 = load i32, i32* %39
%571 = icmp slt i32 %570, 992
br i1 %571, label %572, label %579
572: ; preds = %569
%573 = load i32, i32* %39
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %574
store double 0.000000e+00, double* %575
br label %576
576: ; preds = %572
%577 = load i32, i32* %39
%578 = add nsw i32 %577, 1
store i32 %578, i32* %39
br label %569
579: ; preds = %569
store i32 0, i32* %40
br label %580
580: ; preds = %601, %579
%581 = load i32, i32* %40
%582 = icmp slt i32 %581, 1
br i1 %582, label %583, label %604
583: ; preds = %580
store i32 0, i32* %41
br label %584
584: ; preds = %597, %583
%585 = load i32, i32* %41
%586 = icmp slt i32 %585, 500
br i1 %586, label %587, label %600
587: ; preds = %584
%588 = load i32, i32* %41
%589 = sext i32 %588 to i64
%590 = getelementptr inbounds [992 x double], [992 x double]* %4, i64 0, i64 %589
%591 = load double, double* %590
%592 = load i32, i32* %41
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %593
%595 = load double, double* %594
%596 = fadd double %595, %591
store double %596, double* %594
br label %597
597: ; preds = %587
%598 = load i32, i32* %41
%599 = add nsw i32 %598, 1
store i32 %599, i32* %41
br label %584
600: ; preds = %584
br label %601
601: ; preds = %600
%602 = load i32, i32* %40
%603 = add nsw i32 %602, 1
store i32 %603, i32* %40
br label %580
604: ; preds = %580
store i32 0, i32* %42
br label %605
605: ; preds = %622, %604
%606 = load i32, i32* %42
%607 = icmp slt i32 %606, 500
br i1 %607, label %608, label %625
608: ; preds = %605
%609 = load i32, i32* %42
%610 = sext i32 %609 to i64
%611 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %610
%612 = load double, double* %611
%613 = fcmp une double %612, 1.000000e+00
br i1 %613, label %614, label %621
614: ; preds = %608
%615 = load i32, i32* %42
%616 = load i32, i32* %42
%617 = sext i32 %616 to i64
%618 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %617
%619 = load double, double* %618
%620 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0), i32 %615, double 1.000000e+00, double %619)
store i32 1, i32* %7
br label %621
621: ; preds = %614, %608
br label %622
622: ; preds = %621
%623 = load i32, i32* %42
%624 = add nsw i32 %623, 1
store i32 %624, i32* %42
br label %605
625: ; preds = %605
%626 = load i32, i32* %7
%627 = icmp ne i32 %626, 0
br i1 %627, label %628, label %630
628: ; preds = %625
%629 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %632
630: ; preds = %625
%631 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %632
632: ; preds = %630, %628
store i32 0, i32* %43
br label %633
633: ; preds = %640, %632
%634 = load i32, i32* %43
%635 = icmp slt i32 %634, 992
br i1 %635, label %636, label %643
636: ; preds = %633
%637 = load i32, i32* %43
%638 = sext i32 %637 to i64
%639 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %638
store double 0.000000e+00, double* %639
br label %640
640: ; preds = %636
%641 = load i32, i32* %43
%642 = add nsw i32 %641, 1
store i32 %642, i32* %43
br label %633
643: ; preds = %633
store i32 10, i32* %30
%644 = load i32, i32* %30
%645 = sdiv i32 500, %644
store i32 %645, i32* %31
store i32 0, i32* %44
br label %646
646: ; preds = %667, %643
%647 = load i32, i32* %44
%648 = icmp slt i32 %647, 1
br i1 %648, label %649, label %670
649: ; preds = %646
store i32 0, i32* %45
br label %650
650: ; preds = %663, %649
%651 = load i32, i32* %45
%652 = icmp slt i32 %651, 500
br i1 %652, label %653, label %666
653: ; preds = %650
%654 = load i32, i32* %45
%655 = sext i32 %654 to i64
%656 = getelementptr inbounds [992 x double], [992 x double]* %4, i64 0, i64 %655
%657 = load double, double* %656
%658 = load i32, i32* %45
%659 = sext i32 %658 to i64
%660 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %659
%661 = load double, double* %660
%662 = fadd double %661, %657
store double %662, double* %660
br label %663
663: ; preds = %653
%664 = load i32, i32* %45
%665 = add nsw i32 %664, 1
store i32 %665, i32* %45
br label %650
666: ; preds = %650
br label %667
667: ; preds = %666
%668 = load i32, i32* %44
%669 = add nsw i32 %668, 1
store i32 %669, i32* %44
br label %646
670: ; preds = %646
store i32 0, i32* %46
br label %671
671: ; preds = %688, %670
%672 = load i32, i32* %46
%673 = icmp slt i32 %672, 500
br i1 %673, label %674, label %691
674: ; preds = %671
%675 = load i32, i32* %46
%676 = sext i32 %675 to i64
%677 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %676
%678 = load double, double* %677
%679 = fcmp une double %678, 1.000000e+00
br i1 %679, label %680, label %687
680: ; preds = %674
%681 = load i32, i32* %46
%682 = load i32, i32* %46
%683 = sext i32 %682 to i64
%684 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %683
%685 = load double, double* %684
%686 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0), i32 %681, double 1.000000e+00, double %685)
store i32 1, i32* %7
br label %687
687: ; preds = %680, %674
br label %688
688: ; preds = %687
%689 = load i32, i32* %46
%690 = add nsw i32 %689, 1
store i32 %690, i32* %46
br label %671
691: ; preds = %671
%692 = load i32, i32* %7
%693 = icmp ne i32 %692, 0
br i1 %693, label %694, label %696
694: ; preds = %691
%695 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %698
696: ; preds = %691
%697 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %698
698: ; preds = %696, %694
store i32 0, i32* %47
br label %699
699: ; preds = %706, %698
%700 = load i32, i32* %47
%701 = icmp slt i32 %700, 992
br i1 %701, label %702, label %709
702: ; preds = %699
%703 = load i32, i32* %47
%704 = sext i32 %703 to i64
%705 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %704
store double 0.000000e+00, double* %705
br label %706
706: ; preds = %702
%707 = load i32, i32* %47
%708 = add nsw i32 %707, 1
store i32 %708, i32* %47
br label %699
709: ; preds = %699
store i32 0, i32* %48
br label %710
710: ; preds = %731, %709
%711 = load i32, i32* %48
%712 = icmp slt i32 %711, 1
br i1 %712, label %713, label %734
713: ; preds = %710
store i32 0, i32* %49
br label %714
714: ; preds = %727, %713
%715 = load i32, i32* %49
%716 = icmp slt i32 %715, 123
br i1 %716, label %717, label %730
717: ; preds = %714
%718 = load i32, i32* %49
%719 = sext i32 %718 to i64
%720 = getelementptr inbounds [992 x double], [992 x double]* %4, i64 0, i64 %719
%721 = load double, double* %720
%722 = load i32, i32* %49
%723 = sext i32 %722 to i64
%724 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %723
%725 = load double, double* %724
%726 = fadd double %725, %721
store double %726, double* %724
br label %727
727: ; preds = %717
%728 = load i32, i32* %49
%729 = add nsw i32 %728, 1
store i32 %729, i32* %49
br label %714
730: ; preds = %714
br label %731
731: ; preds = %730
%732 = load i32, i32* %48
%733 = add nsw i32 %732, 1
store i32 %733, i32* %48
br label %710
734: ; preds = %710
store i32 0, i32* %50
br label %735
735: ; preds = %752, %734
%736 = load i32, i32* %50
%737 = icmp slt i32 %736, 123
br i1 %737, label %738, label %755
738: ; preds = %735
%739 = load i32, i32* %50
%740 = sext i32 %739 to i64
%741 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %740
%742 = load double, double* %741
%743 = fcmp une double %742, 1.000000e+00
br i1 %743, label %744, label %751
744: ; preds = %738
%745 = load i32, i32* %50
%746 = load i32, i32* %50
%747 = sext i32 %746 to i64
%748 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %747
%749 = load double, double* %748
%750 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0), i32 %745, double 1.000000e+00, double %749)
store i32 1, i32* %7
br label %751
751: ; preds = %744, %738
br label %752
752: ; preds = %751
%753 = load i32, i32* %50
%754 = add nsw i32 %753, 1
store i32 %754, i32* %50
br label %735
755: ; preds = %735
%756 = load i32, i32* %7
%757 = icmp ne i32 %756, 0
br i1 %757, label %758, label %760
758: ; preds = %755
%759 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %762
760: ; preds = %755
%761 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %762
762: ; preds = %760, %758
store i32 0, i32* %51
br label %763
763: ; preds = %770, %762
%764 = load i32, i32* %51
%765 = icmp slt i32 %764, 992
br i1 %765, label %766, label %773
766: ; preds = %763
%767 = load i32, i32* %51
%768 = sext i32 %767 to i64
%769 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %768
store double 0.000000e+00, double* %769
br label %770
770: ; preds = %766
%771 = load i32, i32* %51
%772 = add nsw i32 %771, 1
store i32 %772, i32* %51
br label %763
773: ; preds = %763
store i32 0, i32* %52
br label %774
774: ; preds = %795, %773
%775 = load i32, i32* %52
%776 = icmp slt i32 %775, 1
br i1 %776, label %777, label %798
777: ; preds = %774
store i32 0, i32* %53
br label %778
778: ; preds = %791, %777
%779 = load i32, i32* %53
%780 = icmp slt i32 %779, 123
br i1 %780, label %781, label %794
781: ; preds = %778
%782 = load i32, i32* %53
%783 = sext i32 %782 to i64
%784 = getelementptr inbounds [992 x double], [992 x double]* %4, i64 0, i64 %783
%785 = load double, double* %784
%786 = load i32, i32* %53
%787 = sext i32 %786 to i64
%788 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %787
%789 = load double, double* %788
%790 = fadd double %789, %785
store double %790, double* %788
br label %791
791: ; preds = %781
%792 = load i32, i32* %53
%793 = add nsw i32 %792, 1
store i32 %793, i32* %53
br label %778
794: ; preds = %778
br label %795
795: ; preds = %794
%796 = load i32, i32* %52
%797 = add nsw i32 %796, 1
store i32 %797, i32* %52
br label %774
798: ; preds = %774
store i32 0, i32* %54
br label %799
799: ; preds = %816, %798
%800 = load i32, i32* %54
%801 = icmp slt i32 %800, 123
br i1 %801, label %802, label %819
802: ; preds = %799
%803 = load i32, i32* %54
%804 = sext i32 %803 to i64
%805 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %804
%806 = load double, double* %805
%807 = fcmp une double %806, 1.000000e+00
br i1 %807, label %808, label %815
808: ; preds = %802
%809 = load i32, i32* %54
%810 = load i32, i32* %54
%811 = sext i32 %810 to i64
%812 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %811
%813 = load double, double* %812
%814 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0), i32 %809, double 1.000000e+00, double %813)
store i32 1, i32* %7
br label %815
815: ; preds = %808, %802
br label %816
816: ; preds = %815
%817 = load i32, i32* %54
%818 = add nsw i32 %817, 1
store i32 %818, i32* %54
br label %799
819: ; preds = %799
%820 = load i32, i32* %7
%821 = icmp ne i32 %820, 0
br i1 %821, label %822, label %824
822: ; preds = %819
%823 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %826
824: ; preds = %819
%825 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %826
826: ; preds = %824, %822
store i32 0, i32* %55
br label %827
827: ; preds = %834, %826
%828 = load i32, i32* %55
%829 = icmp slt i32 %828, 992
br i1 %829, label %830, label %837
830: ; preds = %827
%831 = load i32, i32* %55
%832 = sext i32 %831 to i64
%833 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %832
store double 0.000000e+00, double* %833
br label %834
834: ; preds = %830
%835 = load i32, i32* %55
%836 = add nsw i32 %835, 1
store i32 %836, i32* %55
br label %827
837: ; preds = %827
store i32 10, i32* %30
%838 = load i32, i32* %30
%839 = sdiv i32 123, %838
store i32 %839, i32* %31
store i32 0, i32* %56
br label %840
840: ; preds = %861, %837
%841 = load i32, i32* %56
%842 = icmp slt i32 %841, 1
br i1 %842, label %843, label %864
843: ; preds = %840
store i32 0, i32* %57
br label %844
844: ; preds = %857, %843
%845 = load i32, i32* %57
%846 = icmp slt i32 %845, 123
br i1 %846, label %847, label %860
847: ; preds = %844
%848 = load i32, i32* %57
%849 = sext i32 %848 to i64
%850 = getelementptr inbounds [992 x double], [992 x double]* %4, i64 0, i64 %849
%851 = load double, double* %850
%852 = load i32, i32* %57
%853 = sext i32 %852 to i64
%854 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %853
%855 = load double, double* %854
%856 = fadd double %855, %851
store double %856, double* %854
br label %857
857: ; preds = %847
%858 = load i32, i32* %57
%859 = add nsw i32 %858, 1
store i32 %859, i32* %57
br label %844
860: ; preds = %844
br label %861
861: ; preds = %860
%862 = load i32, i32* %56
%863 = add nsw i32 %862, 1
store i32 %863, i32* %56
br label %840
864: ; preds = %840
store i32 0, i32* %58
br label %865
865: ; preds = %882, %864
%866 = load i32, i32* %58
%867 = icmp slt i32 %866, 123
br i1 %867, label %868, label %885
868: ; preds = %865
%869 = load i32, i32* %58
%870 = sext i32 %869 to i64
%871 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %870
%872 = load double, double* %871
%873 = fcmp une double %872, 1.000000e+00
br i1 %873, label %874, label %881
874: ; preds = %868
%875 = load i32, i32* %58
%876 = load i32, i32* %58
%877 = sext i32 %876 to i64
%878 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %877
%879 = load double, double* %878
%880 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0), i32 %875, double 1.000000e+00, double %879)
store i32 1, i32* %7
br label %881
881: ; preds = %874, %868
br label %882
882: ; preds = %881
%883 = load i32, i32* %58
%884 = add nsw i32 %883, 1
store i32 %884, i32* %58
br label %865
885: ; preds = %865
%886 = load i32, i32* %7
%887 = icmp ne i32 %886, 0
br i1 %887, label %888, label %890
888: ; preds = %885
%889 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %892
890: ; preds = %885
%891 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %892
892: ; preds = %890, %888
store i32 0, i32* %59
br label %893
893: ; preds = %900, %892
%894 = load i32, i32* %59
%895 = icmp slt i32 %894, 992
br i1 %895, label %896, label %903
896: ; preds = %893
%897 = load i32, i32* %59
%898 = sext i32 %897 to i64
%899 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %898
store double 0.000000e+00, double* %899
br label %900
900: ; preds = %896
%901 = load i32, i32* %59
%902 = add nsw i32 %901, 1
store i32 %902, i32* %59
br label %893
903: ; preds = %893
store i32 0, i32* %60
br label %904
904: ; preds = %911, %903
%905 = load i32, i32* %60
%906 = icmp slt i32 %905, 992
br i1 %906, label %907, label %914
907: ; preds = %904
%908 = load i32, i32* %60
%909 = sext i32 %908 to i64
%910 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %909
store double 0.000000e+00, double* %910
br label %911
911: ; preds = %907
%912 = load i32, i32* %60
%913 = add nsw i32 %912, 1
store i32 %913, i32* %60
br label %904
914: ; preds = %904
store double 2.000000e+00, double* %61
store double 4.000000e+00, double* %62
store i32 0, i32* %63
br label %915
915: ; preds = %939, %914
%916 = load i32, i32* %63
%917 = icmp slt i32 %916, 1
br i1 %917, label %918, label %942
918: ; preds = %915
store i32 0, i32* %64
br label %919
919: ; preds = %935, %918
%920 = load i32, i32* %64
%921 = icmp slt i32 %920, 992
br i1 %921, label %922, label %938
922: ; preds = %919
store double 2.000000e+00, double* %61
store double 3.000000e+00, double* %62
%923 = load double, double* %61
%924 = load i32, i32* %64
%925 = sext i32 %924 to i64
%926 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %925
%927 = load double, double* %926
%928 = fadd double %927, %923
store double %928, double* %926
%929 = load double, double* %62
%930 = load i32, i32* %64
%931 = sext i32 %930 to i64
%932 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %931
%933 = load double, double* %932
%934 = fadd double %933, %929
store double %934, double* %932
br label %935
935: ; preds = %922
%936 = load i32, i32* %64
%937 = add nsw i32 %936, 1
store i32 %937, i32* %64
br label %919
938: ; preds = %919
br label %939
939: ; preds = %938
%940 = load i32, i32* %63
%941 = add nsw i32 %940, 1
store i32 %941, i32* %63
br label %915
942: ; preds = %915
store i32 0, i32* %65
br label %943
943: ; preds = %973, %942
%944 = load i32, i32* %65
%945 = icmp slt i32 %944, 992
br i1 %945, label %946, label %976
946: ; preds = %943
%947 = load i32, i32* %65
%948 = sext i32 %947 to i64
%949 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %948
%950 = load double, double* %949
%951 = fcmp une double %950, 2.000000e+00
br i1 %951, label %952, label %959
952: ; preds = %946
%953 = load i32, i32* %65
%954 = load i32, i32* %65
%955 = sext i32 %954 to i64
%956 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %955
%957 = load double, double* %956
%958 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.3, i64 0, i64 0), i32 %953, double 2.000000e+00, double %957)
store i32 1, i32* %7
br label %959
959: ; preds = %952, %946
%960 = load i32, i32* %65
%961 = sext i32 %960 to i64
%962 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %961
%963 = load double, double* %962
%964 = fcmp une double %963, 3.000000e+00
br i1 %964, label %965, label %972
965: ; preds = %959
%966 = load i32, i32* %65
%967 = load i32, i32* %65
%968 = sext i32 %967 to i64
%969 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %968
%970 = load double, double* %969
%971 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i32 %966, double 3.000000e+00, double %970)
store i32 1, i32* %7
br label %972
972: ; preds = %965, %959
br label %973
973: ; preds = %972
%974 = load i32, i32* %65
%975 = add nsw i32 %974, 1
store i32 %975, i32* %65
br label %943
976: ; preds = %943
%977 = load i32, i32* %7
%978 = icmp ne i32 %977, 0
br i1 %978, label %979, label %981
979: ; preds = %976
%980 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %983
981: ; preds = %976
%982 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %983
983: ; preds = %981, %979
store i32 0, i32* %66
br label %984
984: ; preds = %991, %983
%985 = load i32, i32* %66
%986 = icmp slt i32 %985, 992
br i1 %986, label %987, label %994
987: ; preds = %984
%988 = load i32, i32* %66
%989 = sext i32 %988 to i64
%990 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %989
store double 0.000000e+00, double* %990
br label %991
991: ; preds = %987
%992 = load i32, i32* %66
%993 = add nsw i32 %992, 1
store i32 %993, i32* %66
br label %984
994: ; preds = %984
store i32 0, i32* %67
br label %995
995: ; preds = %1002, %994
%996 = load i32, i32* %67
%997 = icmp slt i32 %996, 992
br i1 %997, label %998, label %1005
998: ; preds = %995
%999 = load i32, i32* %67
%1000 = sext i32 %999 to i64
%1001 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1000
store double 0.000000e+00, double* %1001
br label %1002
1002: ; preds = %998
%1003 = load i32, i32* %67
%1004 = add nsw i32 %1003, 1
store i32 %1004, i32* %67
br label %995
1005: ; preds = %995
store double 2.000000e+00, double* %61
store double 4.000000e+00, double* %62
store i32 0, i32* %68
br label %1006
1006: ; preds = %1034, %1005
%1007 = load i32, i32* %68
%1008 = icmp slt i32 %1007, 1
br i1 %1008, label %1009, label %1037
1009: ; preds = %1006
store i32 0, i32* %69
br label %1010
1010: ; preds = %1030, %1009
%1011 = load i32, i32* %69
%1012 = icmp slt i32 %1011, 128
br i1 %1012, label %1013, label %1033
1013: ; preds = %1010
%1014 = load double, double* %61
%1015 = fadd double %1014, 3.000000e+00
store double %1015, double* %61
%1016 = load double, double* %62
%1017 = fadd double %1016, 7.000000e+00
store double %1017, double* %62
%1018 = load double, double* %61
%1019 = load i32, i32* %69
%1020 = sext i32 %1019 to i64
%1021 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1020
%1022 = load double, double* %1021
%1023 = fadd double %1022, %1018
store double %1023, double* %1021
%1024 = load double, double* %62
%1025 = load i32, i32* %69
%1026 = sext i32 %1025 to i64
%1027 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1026
%1028 = load double, double* %1027
%1029 = fadd double %1028, %1024
store double %1029, double* %1027
br label %1030
1030: ; preds = %1013
%1031 = load i32, i32* %69
%1032 = add nsw i32 %1031, 1
store i32 %1032, i32* %69
br label %1010
1033: ; preds = %1010
br label %1034
1034: ; preds = %1033
%1035 = load i32, i32* %68
%1036 = add nsw i32 %1035, 1
store i32 %1036, i32* %68
br label %1006
1037: ; preds = %1006
store i32 0, i32* %70
br label %1038
1038: ; preds = %1100, %1037
%1039 = load i32, i32* %70
%1040 = icmp slt i32 %1039, 128
br i1 %1040, label %1041, label %1103
1041: ; preds = %1038
%1042 = load i32, i32* %70
%1043 = srem i32 %1042, 2
%1044 = icmp eq i32 %1043, 0
br i1 %1044, label %1045, label %1072
1045: ; preds = %1041
%1046 = load i32, i32* %70
%1047 = sext i32 %1046 to i64
%1048 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1047
%1049 = load double, double* %1048
%1050 = fcmp une double %1049, 5.000000e+00
br i1 %1050, label %1051, label %1058
1051: ; preds = %1045
%1052 = load i32, i32* %70
%1053 = load i32, i32* %70
%1054 = sext i32 %1053 to i64
%1055 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1054
%1056 = load double, double* %1055
%1057 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.3, i64 0, i64 0), i32 %1052, double 5.000000e+00, double %1056)
store i32 1, i32* %7
br label %1058
1058: ; preds = %1051, %1045
%1059 = load i32, i32* %70
%1060 = sext i32 %1059 to i64
%1061 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1060
%1062 = load double, double* %1061
%1063 = fcmp une double %1062, 1.100000e+01
br i1 %1063, label %1064, label %1071
1064: ; preds = %1058
%1065 = load i32, i32* %70
%1066 = load i32, i32* %70
%1067 = sext i32 %1066 to i64
%1068 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1067
%1069 = load double, double* %1068
%1070 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i32 %1065, double 1.100000e+01, double %1069)
store i32 1, i32* %7
br label %1071
1071: ; preds = %1064, %1058
br label %1099
1072: ; preds = %1041
%1073 = load i32, i32* %70
%1074 = sext i32 %1073 to i64
%1075 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1074
%1076 = load double, double* %1075
%1077 = fcmp une double %1076, 8.000000e+00
br i1 %1077, label %1078, label %1085
1078: ; preds = %1072
%1079 = load i32, i32* %70
%1080 = load i32, i32* %70
%1081 = sext i32 %1080 to i64
%1082 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1081
%1083 = load double, double* %1082
%1084 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.3, i64 0, i64 0), i32 %1079, double 8.000000e+00, double %1083)
store i32 1, i32* %7
br label %1085
1085: ; preds = %1078, %1072
%1086 = load i32, i32* %70
%1087 = sext i32 %1086 to i64
%1088 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1087
%1089 = load double, double* %1088
%1090 = fcmp une double %1089, 1.800000e+01
br i1 %1090, label %1091, label %1098
1091: ; preds = %1085
%1092 = load i32, i32* %70
%1093 = load i32, i32* %70
%1094 = sext i32 %1093 to i64
%1095 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1094
%1096 = load double, double* %1095
%1097 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i32 %1092, double 1.800000e+01, double %1096)
store i32 1, i32* %7
br label %1098
1098: ; preds = %1091, %1085
br label %1099
1099: ; preds = %1098, %1071
br label %1100
1100: ; preds = %1099
%1101 = load i32, i32* %70
%1102 = add nsw i32 %1101, 1
store i32 %1102, i32* %70
br label %1038
1103: ; preds = %1038
%1104 = load i32, i32* %7
%1105 = icmp ne i32 %1104, 0
br i1 %1105, label %1106, label %1108
1106: ; preds = %1103
%1107 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %1110
1108: ; preds = %1103
%1109 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %1110
1110: ; preds = %1108, %1106
store i32 -1, i32* %71
store i32 0, i32* %72
br label %1111
1111: ; preds = %1117, %1110
%1112 = load i32, i32* %72
%1113 = call i32 (...) @omp_get_num_teams()
%1114 = icmp slt i32 %1112, %1113
br i1 %1114, label %1115, label %1120
1115: ; preds = %1111
%1116 = call i32 (...) @omp_get_team_num()
store i32 %1116, i32* %71
br label %1117
1117: ; preds = %1115
%1118 = load i32, i32* %72
%1119 = add nsw i32 %1118, 1
store i32 %1119, i32* %72
br label %1111
1120: ; preds = %1111
%1121 = load i32, i32* %71
%1122 = icmp ne i32 %1121, 9
br i1 %1122, label %1123, label %1126
1123: ; preds = %1120
%1124 = load i32, i32* %71
%1125 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.5, i64 0, i64 0), i32 %1124, i32 9)
store i32 1, i32* %7
br label %1126
1126: ; preds = %1123, %1120
%1127 = load i32, i32* %7
%1128 = icmp ne i32 %1127, 0
br i1 %1128, label %1129, label %1131
1129: ; preds = %1126
%1130 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %1133
1131: ; preds = %1126
%1132 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %1133
1133: ; preds = %1131, %1129
%1134 = call double* @malloc(i32 7872512)
store double* %1134, double** %73
%1135 = call double* @malloc(i32 7872512)
store double* %1135, double** %74
%1136 = call double* @malloc(i32 7872512)
store double* %1136, double** %75
store i32 0, i32* %76
br label %1137
1137: ; preds = %1170, %1133
%1138 = load i32, i32* %76
%1139 = icmp slt i32 %1138, 992
br i1 %1139, label %1140, label %1173
1140: ; preds = %1137
store i32 0, i32* %77
br label %1141
1141: ; preds = %1166, %1140
%1142 = load i32, i32* %77
%1143 = icmp slt i32 %1142, 992
br i1 %1143, label %1144, label %1169
1144: ; preds = %1141
%1145 = load double*, double** %73
%1146 = load i32, i32* %76
%1147 = mul nsw i32 %1146, 992
%1148 = load i32, i32* %77
%1149 = add nsw i32 %1147, %1148
%1150 = sext i32 %1149 to i64
%1151 = getelementptr inbounds double, double* %1145, i64 %1150
store double 0.000000e+00, double* %1151
%1152 = load double*, double** %74
%1153 = load i32, i32* %76
%1154 = mul nsw i32 %1153, 992
%1155 = load i32, i32* %77
%1156 = add nsw i32 %1154, %1155
%1157 = sext i32 %1156 to i64
%1158 = getelementptr inbounds double, double* %1152, i64 %1157
store double 1.000000e+00, double* %1158
%1159 = load double*, double** %75
%1160 = load i32, i32* %76
%1161 = mul nsw i32 %1160, 992
%1162 = load i32, i32* %77
%1163 = add nsw i32 %1161, %1162
%1164 = sext i32 %1163 to i64
%1165 = getelementptr inbounds double, double* %1159, i64 %1164
store double 2.000000e+00, double* %1165
br label %1166
1166: ; preds = %1144
%1167 = load i32, i32* %77
%1168 = add nsw i32 %1167, 1
store i32 %1168, i32* %77
br label %1141
1169: ; preds = %1141
br label %1170
1170: ; preds = %1169
%1171 = load i32, i32* %76
%1172 = add nsw i32 %1171, 1
store i32 %1172, i32* %76
br label %1137
1173: ; preds = %1137
store i32 0, i32* %78
br label %1174
1174: ; preds = %1220, %1173
%1175 = load i32, i32* %78
%1176 = icmp slt i32 %1175, 1
br i1 %1176, label %1177, label %1223
1177: ; preds = %1174
store i32 0, i32* %79
br label %1178
1178: ; preds = %1216, %1177
%1179 = load i32, i32* %79
%1180 = icmp slt i32 %1179, 992
br i1 %1180, label %1181, label %1219
1181: ; preds = %1178
store i32 0, i32* %80
br label %1182
1182: ; preds = %1212, %1181
%1183 = load i32, i32* %80
%1184 = icmp slt i32 %1183, 992
br i1 %1184, label %1185, label %1215
1185: ; preds = %1182
%1186 = load double*, double** %74
%1187 = load i32, i32* %79
%1188 = mul nsw i32 %1187, 992
%1189 = load i32, i32* %80
%1190 = add nsw i32 %1188, %1189
%1191 = sext i32 %1190 to i64
%1192 = getelementptr inbounds double, double* %1186, i64 %1191
%1193 = load double, double* %1192
%1194 = load double*, double** %75
%1195 = load i32, i32* %79
%1196 = mul nsw i32 %1195, 992
%1197 = load i32, i32* %80
%1198 = add nsw i32 %1196, %1197
%1199 = sext i32 %1198 to i64
%1200 = getelementptr inbounds double, double* %1194, i64 %1199
%1201 = load double, double* %1200
%1202 = fadd double %1193, %1201
%1203 = load double*, double** %73
%1204 = load i32, i32* %79
%1205 = mul nsw i32 %1204, 992
%1206 = load i32, i32* %80
%1207 = add nsw i32 %1205, %1206
%1208 = sext i32 %1207 to i64
%1209 = getelementptr inbounds double, double* %1203, i64 %1208
%1210 = load double, double* %1209
%1211 = fadd double %1210, %1202
store double %1211, double* %1209
br label %1212
1212: ; preds = %1185
%1213 = load i32, i32* %80
%1214 = add nsw i32 %1213, 1
store i32 %1214, i32* %80
br label %1182
1215: ; preds = %1182
br label %1216
1216: ; preds = %1215
%1217 = load i32, i32* %79
%1218 = add nsw i32 %1217, 1
store i32 %1218, i32* %79
br label %1178
1219: ; preds = %1178
br label %1220
1220: ; preds = %1219
%1221 = load i32, i32* %78
%1222 = add nsw i32 %1221, 1
store i32 %1222, i32* %78
br label %1174
1223: ; preds = %1174
store i32 0, i32* %81
br label %1224
1224: ; preds = %1258, %1223
%1225 = load i32, i32* %81
%1226 = icmp slt i32 %1225, 992
br i1 %1226, label %1227, label %1261
1227: ; preds = %1224
store i32 0, i32* %82
br label %1228
1228: ; preds = %1254, %1227
%1229 = load i32, i32* %82
%1230 = icmp slt i32 %1229, 992
br i1 %1230, label %1231, label %1257
1231: ; preds = %1228
%1232 = load double*, double** %73
%1233 = load i32, i32* %81
%1234 = mul nsw i32 %1233, 992
%1235 = load i32, i32* %82
%1236 = add nsw i32 %1234, %1235
%1237 = sext i32 %1236 to i64
%1238 = getelementptr inbounds double, double* %1232, i64 %1237
%1239 = load double, double* %1238
%1240 = fcmp une double %1239, 3.000000e+00
br i1 %1240, label %1241, label %1253
1241: ; preds = %1231
%1242 = load i32, i32* %81
%1243 = load i32, i32* %82
%1244 = load double*, double** %73
%1245 = load i32, i32* %81
%1246 = mul nsw i32 %1245, 992
%1247 = load i32, i32* %82
%1248 = add nsw i32 %1246, %1247
%1249 = sext i32 %1248 to i64
%1250 = getelementptr inbounds double, double* %1244, i64 %1249
%1251 = load double, double* %1250
%1252 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.6, i64 0, i64 0), i32 %1242, i32 %1243, double 3.000000e+00, double %1251)
store i32 1, i32* %7
br label %1253
1253: ; preds = %1241, %1231
br label %1254
1254: ; preds = %1253
%1255 = load i32, i32* %82
%1256 = add nsw i32 %1255, 1
store i32 %1256, i32* %82
br label %1228
1257: ; preds = %1228
br label %1258
1258: ; preds = %1257
%1259 = load i32, i32* %81
%1260 = add nsw i32 %1259, 1
store i32 %1260, i32* %81
br label %1224
1261: ; preds = %1224
%1262 = load i32, i32* %7
%1263 = icmp ne i32 %1262, 0
br i1 %1263, label %1264, label %1266
1264: ; preds = %1261
%1265 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %1268
1266: ; preds = %1261
%1267 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %1268
1268: ; preds = %1266, %1264
store i32 124, i32* %83
%1269 = load i32, i32* %83
%1270 = load i32, i32* %83
%1271 = mul nsw i32 %1269, %1270
%1272 = load i32, i32* %83
%1273 = mul nsw i32 %1271, %1272
%1274 = sext i32 %1273 to i64
%1275 = mul i64 %1274, 8
%1276 = trunc i64 %1275 to i32
%1277 = call double* @malloc(i32 %1276)
store double* %1277, double** %84
%1278 = load i32, i32* %83
%1279 = load i32, i32* %83
%1280 = mul nsw i32 %1278, %1279
%1281 = load i32, i32* %83
%1282 = mul nsw i32 %1280, %1281
%1283 = sext i32 %1282 to i64
%1284 = mul i64 %1283, 8
%1285 = trunc i64 %1284 to i32
%1286 = call double* @malloc(i32 %1285)
store double* %1286, double** %85
store i32 0, i32* %86
br label %1287
1287: ; preds = %1338, %1268
%1288 = load i32, i32* %86
%1289 = load i32, i32* %83
%1290 = icmp slt i32 %1288, %1289
br i1 %1290, label %1291, label %1341
1291: ; preds = %1287
store i32 0, i32* %87
br label %1292
1292: ; preds = %1334, %1291
%1293 = load i32, i32* %87
%1294 = load i32, i32* %83
%1295 = icmp slt i32 %1293, %1294
br i1 %1295, label %1296, label %1337
1296: ; preds = %1292
store i32 0, i32* %88
br label %1297
1297: ; preds = %1330, %1296
%1298 = load i32, i32* %88
%1299 = load i32, i32* %83
%1300 = icmp slt i32 %1298, %1299
br i1 %1300, label %1301, label %1333
1301: ; preds = %1297
%1302 = load double*, double** %84
%1303 = load i32, i32* %86
%1304 = load i32, i32* %83
%1305 = mul nsw i32 %1303, %1304
%1306 = load i32, i32* %83
%1307 = mul nsw i32 %1305, %1306
%1308 = load i32, i32* %87
%1309 = load i32, i32* %83
%1310 = mul nsw i32 %1308, %1309
%1311 = add nsw i32 %1307, %1310
%1312 = load i32, i32* %88
%1313 = add nsw i32 %1311, %1312
%1314 = sext i32 %1313 to i64
%1315 = getelementptr inbounds double, double* %1302, i64 %1314
store double 2.000000e+00, double* %1315
%1316 = load double*, double** %85
%1317 = load i32, i32* %86
%1318 = load i32, i32* %83
%1319 = mul nsw i32 %1317, %1318
%1320 = load i32, i32* %83
%1321 = mul nsw i32 %1319, %1320
%1322 = load i32, i32* %87
%1323 = load i32, i32* %83
%1324 = mul nsw i32 %1322, %1323
%1325 = add nsw i32 %1321, %1324
%1326 = load i32, i32* %88
%1327 = add nsw i32 %1325, %1326
%1328 = sext i32 %1327 to i64
%1329 = getelementptr inbounds double, double* %1316, i64 %1328
store double 3.000000e+00, double* %1329
br label %1330
1330: ; preds = %1301
%1331 = load i32, i32* %88
%1332 = add nsw i32 %1331, 1
store i32 %1332, i32* %88
br label %1297
1333: ; preds = %1297
br label %1334
1334: ; preds = %1333
%1335 = load i32, i32* %87
%1336 = add nsw i32 %1335, 1
store i32 %1336, i32* %87
br label %1292
1337: ; preds = %1292
br label %1338
1338: ; preds = %1337
%1339 = load i32, i32* %86
%1340 = add nsw i32 %1339, 1
store i32 %1340, i32* %86
br label %1287
1341: ; preds = %1287
store i32 0, i32* %89
br label %1342
1342: ; preds = %1404, %1341
%1343 = load i32, i32* %89
%1344 = icmp slt i32 %1343, 1
br i1 %1344, label %1345, label %1407
1345: ; preds = %1342
store i32 0, i32* %90
br label %1346
1346: ; preds = %1400, %1345
%1347 = load i32, i32* %90
%1348 = load i32, i32* %83
%1349 = icmp slt i32 %1347, %1348
br i1 %1349, label %1350, label %1403
1350: ; preds = %1346
store i32 0, i32* %91
br label %1351
1351: ; preds = %1396, %1350
%1352 = load i32, i32* %91
%1353 = load i32, i32* %83
%1354 = icmp slt i32 %1352, %1353
br i1 %1354, label %1355, label %1399
1355: ; preds = %1351
store i32 0, i32* %92
br label %1356
1356: ; preds = %1392, %1355
%1357 = load i32, i32* %92
%1358 = load i32, i32* %83
%1359 = icmp slt i32 %1357, %1358
br i1 %1359, label %1360, label %1395
1360: ; preds = %1356
%1361 = load double*, double** %85
%1362 = load i32, i32* %90
%1363 = load i32, i32* %83
%1364 = mul nsw i32 %1362, %1363
%1365 = load i32, i32* %83
%1366 = mul nsw i32 %1364, %1365
%1367 = load i32, i32* %91
%1368 = load i32, i32* %83
%1369 = mul nsw i32 %1367, %1368
%1370 = add nsw i32 %1366, %1369
%1371 = load i32, i32* %92
%1372 = add nsw i32 %1370, %1371
%1373 = sext i32 %1372 to i64
%1374 = getelementptr inbounds double, double* %1361, i64 %1373
%1375 = load double, double* %1374
%1376 = load double*, double** %84
%1377 = load i32, i32* %90
%1378 = load i32, i32* %83
%1379 = mul nsw i32 %1377, %1378
%1380 = load i32, i32* %83
%1381 = mul nsw i32 %1379, %1380
%1382 = load i32, i32* %91
%1383 = load i32, i32* %83
%1384 = mul nsw i32 %1382, %1383
%1385 = add nsw i32 %1381, %1384
%1386 = load i32, i32* %92
%1387 = add nsw i32 %1385, %1386
%1388 = sext i32 %1387 to i64
%1389 = getelementptr inbounds double, double* %1376, i64 %1388
%1390 = load double, double* %1389
%1391 = fadd double %1390, %1375
store double %1391, double* %1389
br label %1392
1392: ; preds = %1360
%1393 = load i32, i32* %92
%1394 = add nsw i32 %1393, 1
store i32 %1394, i32* %92
br label %1356
1395: ; preds = %1356
br label %1396
1396: ; preds = %1395
%1397 = load i32, i32* %91
%1398 = add nsw i32 %1397, 1
store i32 %1398, i32* %91
br label %1351
1399: ; preds = %1351
br label %1400
1400: ; preds = %1399
%1401 = load i32, i32* %90
%1402 = add nsw i32 %1401, 1
store i32 %1402, i32* %90
br label %1346
1403: ; preds = %1346
br label %1404
1404: ; preds = %1403
%1405 = load i32, i32* %89
%1406 = add nsw i32 %1405, 1
store i32 %1406, i32* %89
br label %1342
1407: ; preds = %1342
store i32 0, i32* %93
br label %1408
1408: ; preds = %1467, %1407
%1409 = load i32, i32* %93
%1410 = load i32, i32* %83
%1411 = icmp slt i32 %1409, %1410
br i1 %1411, label %1412, label %1470
1412: ; preds = %1408
store i32 0, i32* %94
br label %1413
1413: ; preds = %1463, %1412
%1414 = load i32, i32* %94
%1415 = load i32, i32* %83
%1416 = icmp slt i32 %1414, %1415
br i1 %1416, label %1417, label %1466
1417: ; preds = %1413
store i32 0, i32* %95
br label %1418
1418: ; preds = %1459, %1417
%1419 = load i32, i32* %95
%1420 = load i32, i32* %83
%1421 = icmp slt i32 %1419, %1420
br i1 %1421, label %1422, label %1462
1422: ; preds = %1418
%1423 = load double*, double** %84
%1424 = load i32, i32* %93
%1425 = load i32, i32* %83
%1426 = mul nsw i32 %1424, %1425
%1427 = load i32, i32* %83
%1428 = mul nsw i32 %1426, %1427
%1429 = load i32, i32* %94
%1430 = load i32, i32* %83
%1431 = mul nsw i32 %1429, %1430
%1432 = add nsw i32 %1428, %1431
%1433 = load i32, i32* %95
%1434 = add nsw i32 %1432, %1433
%1435 = sext i32 %1434 to i64
%1436 = getelementptr inbounds double, double* %1423, i64 %1435
%1437 = load double, double* %1436
%1438 = fcmp une double %1437, 5.000000e+00
br i1 %1438, label %1439, label %1458
1439: ; preds = %1422
%1440 = load i32, i32* %93
%1441 = load i32, i32* %94
%1442 = load double*, double** %84
%1443 = load i32, i32* %93
%1444 = load i32, i32* %83
%1445 = mul nsw i32 %1443, %1444
%1446 = load i32, i32* %83
%1447 = mul nsw i32 %1445, %1446
%1448 = load i32, i32* %94
%1449 = load i32, i32* %83
%1450 = mul nsw i32 %1448, %1449
%1451 = add nsw i32 %1447, %1450
%1452 = load i32, i32* %95
%1453 = add nsw i32 %1451, %1452
%1454 = sext i32 %1453 to i64
%1455 = getelementptr inbounds double, double* %1442, i64 %1454
%1456 = load double, double* %1455
%1457 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.6, i64 0, i64 0), i32 %1440, i32 %1441, double 3.000000e+00, double %1456)
store i32 1, i32* %7
br label %1458
1458: ; preds = %1439, %1422
br label %1459
1459: ; preds = %1458
%1460 = load i32, i32* %95
%1461 = add nsw i32 %1460, 1
store i32 %1461, i32* %95
br label %1418
1462: ; preds = %1418
br label %1463
1463: ; preds = %1462
%1464 = load i32, i32* %94
%1465 = add nsw i32 %1464, 1
store i32 %1465, i32* %94
br label %1413
1466: ; preds = %1413
br label %1467
1467: ; preds = %1466
%1468 = load i32, i32* %93
%1469 = add nsw i32 %1468, 1
store i32 %1469, i32* %93
br label %1408
1470: ; preds = %1408
%1471 = load i32, i32* %7
%1472 = icmp ne i32 %1471, 0
br i1 %1472, label %1473, label %1475
1473: ; preds = %1470
%1474 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
br label %1477
1475: ; preds = %1470
%1476 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %1477
1477: ; preds = %1475, %1473
ret i32 0
}

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