#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 omp_get_num_threads();
int omp_get_thread_num();
int omp_is_initial_device();
int /*<<< orphan*/ printf(char *, ...);
int main(void) {
  check_offloading();
  double A[(992)], B[(992)], C[(992)], D[(992)], E[(992)];
  {
    int i;
    for (i = 0; i < (992); i++) {
      {
        C[i] = 1;
        D[i] = i;
        E[i] = -i;
      }
    }
  };
  int cpuExec = 0;
#pragma omp target map(tofrom : cpuExec)
  { cpuExec = omp_is_initial_device(); }
  int gpu_threads = 128;
  int cpu_threads = 32;
  int max_threads = cpuExec ? cpu_threads : gpu_threads;
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  {
    int fail = 0;
    int trial;
    for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target parallel num_threads(max_threads)
      {{int tid = omp_get_thread_num();
      A[tid] += tid;
    }
  }
  {
    int i;
    int errorNum = 0;
    for (i = 0; i < max_threads; i++) {
      if (A[i] != i * (trial + 1)) {
        printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]",
               i * (trial + 1), A[i]);
        fail = 1;
        if (errorNum++ > 10)
          break;
      }
    }
  }
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target parallel num_threads(max_threads)
    {{int i = omp_get_thread_num() * 4;
    for (int j = i; j < i + 4; j++) {
      B[j] = D[j] + E[j];
    }
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < max_threads * 4; i++) {
    if (B[i] != (double)0) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "B[i]",
             (double)0, B[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target parallel num_threads(max_threads) if (0)
    {{int tid = omp_get_thread_num();
    A[tid] = tid;
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < max_threads; i++) {
    if (A[i] != 0) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 0,
             A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target parallel num_threads(max_threads) if (A[0] == 0)
    {{int tid = omp_get_thread_num();
    A[tid] = tid + omp_is_initial_device();
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < max_threads; i++) {
    if (A[i] != i + cpuExec) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]",
             i + cpuExec, A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target parallel num_threads(max_threads) if (parallel : 0)
    {{int tid = omp_get_thread_num();
    A[tid] = !omp_is_initial_device();
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < max_threads; i++) {
    if (A[i] != i == 0 ? 1 - cpuExec : 0) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]",
             i == 0 ? 1 - cpuExec : 0, A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target parallel num_threads(                                       \
    max_threads) if (target : 0) if (parallel                                  \
                                     : A[0] == 0)
    {{int tid = omp_get_thread_num();
    A[tid] = tid + omp_is_initial_device();
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < cpu_threads; i++) {
    if (A[i] != i + 1) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", i + 1,
             A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target parallel if (parallel : A[0] > 0)
    {{int tid = omp_get_thread_num();
    A[tid] = omp_get_num_threads();
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[0] != 1) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[0]", 1,
             A[0]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};
#pragma omp target parallel
{ B[0] = omp_get_num_threads(); }
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target parallel if (parallel : A[0] == 0)
    {{int tid = omp_get_thread_num();
    A[tid] = omp_get_num_threads();
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[0] != B[0]) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[0]", B[0],
             A[0]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target parallel num_threads(2) if (parallel : A[0] == 0)
    {{int tid = omp_get_thread_num();
    A[tid] = omp_get_num_threads();
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[0] != 2) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[0]", 2,
             A[0]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target parallel num_threads(max_threads) proc_bind(master)
    {{int i = omp_get_thread_num() * 4;
    for (int j = i; j < i + 4; j++) {
      B[j] = 1 + D[j] + E[j];
    }
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < max_threads * 4; i++) {
    if (B[i] != 1) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "B[i]", 1,
             B[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target parallel num_threads(max_threads) proc_bind(close)
    {{int i = omp_get_thread_num() * 4;
    for (int j = i; j < i + 4; j++) {
      B[j] = 1 + D[j] + E[j];
    }
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < max_threads * 4; i++) {
    if (B[i] != 1) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "B[i]", 1,
             B[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target parallel num_threads(max_threads) proc_bind(spread)
    {{int i = omp_get_thread_num() * 4;
    for (int j = i; j < i + 4; j++) {
      B[j] = 1 + D[j] + E[j];
    }
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < max_threads * 4; i++) {
    if (B[i] != 1) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "B[i]", 1,
             B[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
for (int t = 1; t <= max_threads; t++) {
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  int threads[1];
  threads[0] = t;
  {
    int fail = 0;
    int trial;
    for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target parallel num_threads(threads[0])
      {{int tid = omp_get_thread_num();
      A[tid] = 99;
    }
  }
  {
    int i;
    int errorNum = 0;
    for (i = 0; i < 128; i++) {
      if (A[i] != 99 * (i < t)) {
        printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]",
               99 * (i < t), A[i]);
        fail = 1;
        if (errorNum++ > 10)
          break;
      }
    }
  }
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
}
{
  for (int i = 0; i < (gpu_threads - max_threads); i++)
    printf("Succeeded\n");
};
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};
{
  double tmp = 1;
  A[0] = tmp;
  {
    int fail = 0;
    int trial;
    for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target parallel map(tofrom : tmp) num_threads(1)
      {{tmp = 2;
      A[0] += tmp;
    }
  }
  {
    int i;
    int errorNum = 0;
    for (i = 0; i < 1; i++) {
      if (A[i] + tmp != (1 + trial) * 2 + 1 + 2) {
        printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]+tmp",
               (1 + trial) * 2 + 1 + 2, A[i] + tmp);
        fail = 1;
        if (errorNum++ > 10)
          break;
      }
    }
  }
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
}
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};
{
  double p[1], q = 99;
  p[0] = 1;
  A[0] = p[0];
  {
    int fail = 0;
    int trial;
    for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target parallel private(p, q) num_threads(1)
      {{p[0] = 2;
      q = 0;
      A[0] += p[0];
    }
  }
  {
    int i;
    int errorNum = 0;
    for (i = 0; i < 1; i++) {
      if (A[i] + p[0] + q != (1 + trial) * 2 + 2 + 99) {
        printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]+p[0]+q",
               (1 + trial) * 2 + 2 + 99, A[i] + p[0] + q);
        fail = 1;
        if (errorNum++ > 10)
          break;
      }
    }
  }
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
}
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};
{
  double p[1], q = 99;
  p[0] = 5;
  A[0] = p[0];
  {
    int fail = 0;
    int trial;
    for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target parallel firstprivate(p, q) num_threads(1)
      {{A[0] += p[0] + q;
      p[0] = 2;
      q = 0;
    }
  }
  {
    int i;
    int errorNum = 0;
    for (i = 0; i < 1; i++) {
      if (A[i] + p[0] + q != (1 + trial) * (99 + 5) + 5 + 5 + 99) {
        printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]+p[0]+q",
               (1 + trial) * (99 + 5) + 5 + 5 + 99, A[i] + p[0] + q);
        fail = 1;
        if (errorNum++ > 10)
          break;
      }
    }
  }
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
}
return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x9d40,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x0,%al
call   1060 <check_offloading@plt>
movl   $0x0,-0x9b14(%rbp)
cmpl   $0x3e0,-0x9b14(%rbp)
jge    11e3 <main+0x93>
movslq -0x9b14(%rbp),%rax
movsd  0x2e6e(%rip),%xmm0
movsd  %xmm0,-0x5d10(%rbp,%rax,8)
ff ff
cvtsi2sdl -0x9b14(%rbp),%xmm0
ff
movslq -0x9b14(%rbp),%rax
movsd  %xmm0,-0x7c10(%rbp,%rax,8)
ff ff
xor    %eax,%eax
sub    -0x9b14(%rbp),%eax
cvtsi2sd %eax,%xmm0
movslq -0x9b14(%rbp),%rax
movsd  %xmm0,-0x9b10(%rbp,%rax,8)
ff ff
mov    -0x9b14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b14(%rbp)
jmp    1173 <main+0x23>
movl   $0x0,-0x9b18(%rbp)
mov    $0x0,%al
call   1070 <omp_is_initial_device@plt>
mov    %eax,-0x9b18(%rbp)
movl   $0x80,-0x9b1c(%rbp)
movl   $0x20,-0x9b20(%rbp)
cmpl   $0x0,-0x9b18(%rbp)
je     122c <main+0xdc>
mov    -0x9b20(%rbp),%eax
mov    %eax,-0x9d10(%rbp)
jmp    1238 <main+0xe8>
mov    -0x9b1c(%rbp),%eax
mov    %eax,-0x9d10(%rbp)
mov    -0x9d10(%rbp),%eax
mov    %eax,-0x9b24(%rbp)
movl   $0x0,-0x9b28(%rbp)
cmpl   $0x3e0,-0x9b28(%rbp)
jge    1285 <main+0x135>
movslq -0x9b28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b28(%rbp)
jmp    124e <main+0xfe>
movl   $0x0,-0x9b2c(%rbp)
movl   $0x0,-0x9b34(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9b34(%rbp)
mov    %al,-0x9d11(%rbp)
jge    12be <main+0x16e>
cmpl   $0x0,-0x9b2c(%rbp)
sete   %al
mov    %al,-0x9d11(%rbp)
mov    -0x9d11(%rbp),%al
test   $0x1,%al
jne    12d1 <main+0x181>
jmp    13fd <main+0x2ad>
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x9b38(%rbp)
cvtsi2sdl -0x9b38(%rbp),%xmm0
ff
movslq -0x9b38(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9b40(%rbp)
movl   $0x0,-0x9b3c(%rbp)
mov    -0x9b3c(%rbp),%eax
cmp    -0x9b24(%rbp),%eax
jge    13e4 <main+0x294>
movslq -0x9b3c(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9b3c(%rbp),%eax
mov    -0x9b34(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jne    1360 <main+0x210>
jp     1360 <main+0x210>
jmp    13cb <main+0x27b>
mov    -0x9b3c(%rbp),%esi
mov    -0x9b3c(%rbp),%ecx
mov    -0x9b34(%rbp),%eax
add    $0x1,%eax
imul   %eax,%ecx
movslq -0x9b3c(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x2c91(%rip),%rdi
lea    0x2cb6(%rip),%rdx
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x9b2c(%rbp)
mov    -0x9b40(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9b40(%rbp)
cmp    $0xa,%eax
jle    13c6 <main+0x276>
jmp    13e4 <main+0x294>
jmp    13cb <main+0x27b>
jmp    13d0 <main+0x280>
mov    -0x9b3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b3c(%rbp)
jmp    1313 <main+0x1c3>
jmp    13e9 <main+0x299>
mov    -0x9b34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b34(%rbp)
jmp    1299 <main+0x149>
cmpl   $0x0,-0x9b2c(%rbp)
je     141d <main+0x2cd>
lea    0x2c40(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    142b <main+0x2db>
lea    0x2c35(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x9b44(%rbp)
movl   $0x0,-0x9b4c(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9b4c(%rbp)
mov    %al,-0x9d12(%rbp)
jge    1464 <main+0x314>
cmpl   $0x0,-0x9b44(%rbp)
sete   %al
mov    %al,-0x9d12(%rbp)
mov    -0x9d12(%rbp),%al
test   $0x1,%al
jne    1477 <main+0x327>
jmp    15cf <main+0x47f>
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
shl    $0x2,%eax
mov    %eax,-0x9b50(%rbp)
mov    -0x9b50(%rbp),%eax
mov    %eax,-0x9b54(%rbp)
mov    -0x9b54(%rbp),%eax
mov    -0x9b50(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    14ee <main+0x39e>
movslq -0x9b54(%rbp),%rax
movsd  -0x7c10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b54(%rbp),%rax
addsd  -0x9b10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b54(%rbp),%rax
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9b54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b54(%rbp)
jmp    1493 <main+0x343>
movl   $0x0,-0x9b5c(%rbp)
movl   $0x0,-0x9b58(%rbp)
mov    -0x9b58(%rbp),%eax
mov    -0x9b24(%rbp),%ecx
shl    $0x2,%ecx
cmp    %ecx,%eax
jge    15b6 <main+0x466>
movslq -0x9b58(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1541 <main+0x3f1>
jp     1541 <main+0x3f1>
jmp    159d <main+0x44d>
mov    -0x9b58(%rbp),%esi
movslq -0x9b58(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm1
ff ff
lea    0x2ac2(%rip),%rdi
lea    0x2aff(%rip),%rdx
xorps  %xmm0,%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movl   $0x1,-0x9b44(%rbp)
mov    -0x9b5c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9b5c(%rbp)
cmp    $0xa,%eax
jle    1598 <main+0x448>
jmp    15b6 <main+0x466>
jmp    159d <main+0x44d>
jmp    15a2 <main+0x452>
mov    -0x9b58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b58(%rbp)
jmp    1502 <main+0x3b2>
jmp    15bb <main+0x46b>
mov    -0x9b4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b4c(%rbp)
jmp    143f <main+0x2ef>
cmpl   $0x0,-0x9b44(%rbp)
je     15ef <main+0x49f>
lea    0x2a6e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    15fd <main+0x4ad>
lea    0x2a63(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x9b60(%rbp)
cmpl   $0x3e0,-0x9b60(%rbp)
jge    163e <main+0x4ee>
movslq -0x9b60(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b60(%rbp)
jmp    1607 <main+0x4b7>
movl   $0x0,-0x9b64(%rbp)
movl   $0x0,-0x9b6c(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9b6c(%rbp)
mov    %al,-0x9d13(%rbp)
jge    1677 <main+0x527>
cmpl   $0x0,-0x9b64(%rbp)
sete   %al
mov    %al,-0x9d13(%rbp)
mov    -0x9d13(%rbp),%al
test   $0x1,%al
jne    168a <main+0x53a>
jmp    178a <main+0x63a>
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x9b70(%rbp)
cvtsi2sdl -0x9b70(%rbp),%xmm0
ff
movslq -0x9b70(%rbp),%rax
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9b78(%rbp)
movl   $0x0,-0x9b74(%rbp)
mov    -0x9b74(%rbp),%eax
cmp    -0x9b24(%rbp),%eax
jge    1771 <main+0x621>
movslq -0x9b74(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    16fd <main+0x5ad>
jp     16fd <main+0x5ad>
jmp    1758 <main+0x608>
mov    -0x9b74(%rbp),%esi
movslq -0x9b74(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x2906(%rip),%rdi
lea    0x292b(%rip),%rdx
xor    %ecx,%ecx
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x9b64(%rbp)
mov    -0x9b78(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9b78(%rbp)
cmp    $0xa,%eax
jle    1753 <main+0x603>
jmp    1771 <main+0x621>
jmp    1758 <main+0x608>
jmp    175d <main+0x60d>
mov    -0x9b74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b74(%rbp)
jmp    16c3 <main+0x573>
jmp    1776 <main+0x626>
mov    -0x9b6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b6c(%rbp)
jmp    1652 <main+0x502>
cmpl   $0x0,-0x9b64(%rbp)
je     17aa <main+0x65a>
lea    0x28b3(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    17b8 <main+0x668>
lea    0x28a8(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x9b7c(%rbp)
cmpl   $0x3e0,-0x9b7c(%rbp)
jge    17f9 <main+0x6a9>
movslq -0x9b7c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b7c(%rbp)
jmp    17c2 <main+0x672>
movl   $0x0,-0x9b80(%rbp)
movl   $0x0,-0x9b88(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9b88(%rbp)
mov    %al,-0x9d14(%rbp)
jge    1832 <main+0x6e2>
cmpl   $0x0,-0x9b80(%rbp)
sete   %al
mov    %al,-0x9d14(%rbp)
mov    -0x9d14(%rbp),%al
test   $0x1,%al
jne    1845 <main+0x6f5>
jmp    1975 <main+0x825>
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x9b8c(%rbp)
mov    -0x9b8c(%rbp),%eax
mov    %eax,-0x9d18(%rbp)
mov    $0x0,%al
call   1070 <omp_is_initial_device@plt>
mov    %eax,%ecx
mov    -0x9d18(%rbp),%eax
add    %ecx,%eax
cvtsi2sd %eax,%xmm0
movslq -0x9b8c(%rbp),%rax
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9b94(%rbp)
movl   $0x0,-0x9b90(%rbp)
mov    -0x9b90(%rbp),%eax
cmp    -0x9b24(%rbp),%eax
jge    195c <main+0x80c>
movslq -0x9b90(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9b90(%rbp),%eax
add    -0x9b18(%rbp),%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jne    18de <main+0x78e>
jp     18de <main+0x78e>
jmp    1943 <main+0x7f3>
mov    -0x9b90(%rbp),%esi
mov    -0x9b90(%rbp),%ecx
add    -0x9b18(%rbp),%ecx
movslq -0x9b90(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x2719(%rip),%rdi
lea    0x273e(%rip),%rdx
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x9b80(%rbp)
mov    -0x9b94(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9b94(%rbp)
cmp    $0xa,%eax
jle    193e <main+0x7ee>
jmp    195c <main+0x80c>
jmp    1943 <main+0x7f3>
jmp    1948 <main+0x7f8>
mov    -0x9b90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b90(%rbp)
jmp    1897 <main+0x747>
jmp    1961 <main+0x811>
mov    -0x9b88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b88(%rbp)
jmp    180d <main+0x6bd>
cmpl   $0x0,-0x9b80(%rbp)
je     1995 <main+0x845>
lea    0x26c8(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    19a3 <main+0x853>
lea    0x26bd(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x9b98(%rbp)
cmpl   $0x3e0,-0x9b98(%rbp)
jge    19e4 <main+0x894>
movslq -0x9b98(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b98(%rbp)
jmp    19ad <main+0x85d>
movl   $0x0,-0x9b9c(%rbp)
movl   $0x0,-0x9ba4(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9ba4(%rbp)
mov    %al,-0x9d19(%rbp)
jge    1a1d <main+0x8cd>
cmpl   $0x0,-0x9b9c(%rbp)
sete   %al
mov    %al,-0x9d19(%rbp)
mov    -0x9d19(%rbp),%al
test   $0x1,%al
jne    1a30 <main+0x8e0>
jmp    1bb2 <main+0xa62>
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x9ba8(%rbp)
mov    $0x0,%al
call   1070 <omp_is_initial_device@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
cvtsi2sd %eax,%xmm0
movslq -0x9ba8(%rbp),%rax
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9bb0(%rbp)
movl   $0x0,-0x9bac(%rbp)
mov    -0x9bac(%rbp),%eax
cmp    -0x9b24(%rbp),%eax
jge    1b99 <main+0xa49>
movslq -0x9bac(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
cvtsi2sdl -0x9bac(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
setne  %al
setp   %cl
or     %cl,%al
and    $0x1,%al
movzbl %al,%eax
cmp    $0x0,%eax
jne    1ad6 <main+0x986>
mov    $0x1,%eax
sub    -0x9b18(%rbp),%eax
cmp    $0x0,%eax
jne    1ae5 <main+0x995>
jmp    1b80 <main+0xa30>
xor    %eax,%eax
test   $0x1,%al
jne    1ae5 <main+0x995>
jmp    1b80 <main+0xa30>
mov    -0x9bac(%rbp),%eax
mov    %eax,-0x9d20(%rbp)
cmpl   $0x0,-0x9bac(%rbp)
jne    1b14 <main+0x9c4>
mov    $0x1,%eax
sub    -0x9b18(%rbp),%eax
mov    %eax,-0x9d24(%rbp)
jmp    1b21 <main+0x9d1>
xor    %eax,%eax
mov    %eax,-0x9d24(%rbp)
jmp    1b21 <main+0x9d1>
mov    -0x9d20(%rbp),%esi
mov    -0x9d24(%rbp),%ecx
movslq -0x9bac(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x24dc(%rip),%rdi
lea    0x2501(%rip),%rdx
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x9b9c(%rbp)
mov    -0x9bb0(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9bb0(%rbp)
cmp    $0xa,%eax
jle    1b7b <main+0xa2b>
jmp    1b99 <main+0xa49>
jmp    1b80 <main+0xa30>
jmp    1b85 <main+0xa35>
mov    -0x9bac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bac(%rbp)
jmp    1a79 <main+0x929>
jmp    1b9e <main+0xa4e>
mov    -0x9ba4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ba4(%rbp)
jmp    19f8 <main+0x8a8>
cmpl   $0x0,-0x9b9c(%rbp)
je     1bd2 <main+0xa82>
lea    0x248b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1be0 <main+0xa90>
lea    0x2480(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x9bb4(%rbp)
cmpl   $0x3e0,-0x9bb4(%rbp)
jge    1c21 <main+0xad1>
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    1bea <main+0xa9a>
movl   $0x0,-0x9bb8(%rbp)
movl   $0x0,-0x9bc0(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9bc0(%rbp)
mov    %al,-0x9d25(%rbp)
jge    1c5a <main+0xb0a>
cmpl   $0x0,-0x9bb8(%rbp)
sete   %al
mov    %al,-0x9d25(%rbp)
mov    -0x9d25(%rbp),%al
test   $0x1,%al
jne    1c6d <main+0xb1d>
jmp    1d97 <main+0xc47>
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x9bc4(%rbp)
mov    -0x9bc4(%rbp),%eax
mov    %eax,-0x9d2c(%rbp)
mov    $0x0,%al
call   1070 <omp_is_initial_device@plt>
mov    %eax,%ecx
mov    -0x9d2c(%rbp),%eax
add    %ecx,%eax
cvtsi2sd %eax,%xmm0
movslq -0x9bc4(%rbp),%rax
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9bcc(%rbp)
movl   $0x0,-0x9bc8(%rbp)
mov    -0x9bc8(%rbp),%eax
cmp    -0x9b20(%rbp),%eax
jge    1d7e <main+0xc2e>
movslq -0x9bc8(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9bc8(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jne    1d03 <main+0xbb3>
jp     1d03 <main+0xbb3>
jmp    1d65 <main+0xc15>
mov    -0x9bc8(%rbp),%esi
mov    -0x9bc8(%rbp),%ecx
add    $0x1,%ecx
movslq -0x9bc8(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x22f7(%rip),%rdi
lea    0x231c(%rip),%rdx
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x9bb8(%rbp)
mov    -0x9bcc(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9bcc(%rbp)
cmp    $0xa,%eax
jle    1d60 <main+0xc10>
jmp    1d7e <main+0xc2e>
jmp    1d65 <main+0xc15>
jmp    1d6a <main+0xc1a>
mov    -0x9bc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bc8(%rbp)
jmp    1cbf <main+0xb6f>
jmp    1d83 <main+0xc33>
mov    -0x9bc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bc0(%rbp)
jmp    1c35 <main+0xae5>
cmpl   $0x0,-0x9bb8(%rbp)
je     1db7 <main+0xc67>
lea    0x22a6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1dc5 <main+0xc75>
lea    0x229b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x9bd0(%rbp)
cmpl   $0x3e0,-0x9bd0(%rbp)
jge    1e06 <main+0xcb6>
movslq -0x9bd0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bd0(%rbp)
jmp    1dcf <main+0xc7f>
movl   $0x0,-0x9bd4(%rbp)
movl   $0x0,-0x9bdc(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9bdc(%rbp)
mov    %al,-0x9d2d(%rbp)
jge    1e3f <main+0xcef>
cmpl   $0x0,-0x9bd4(%rbp)
sete   %al
mov    %al,-0x9d2d(%rbp)
mov    -0x9d2d(%rbp),%al
test   $0x1,%al
jne    1e52 <main+0xd02>
jmp    1f44 <main+0xdf4>
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x9be0(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
movslq -0x9be0(%rbp),%rax
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9be8(%rbp)
movl   $0x0,-0x9be4(%rbp)
cmpl   $0x1,-0x9be4(%rbp)
jge    1f2b <main+0xddb>
movsd  -0x1f10(%rbp),%xmm0
ff
movsd  0x2159(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1ebc <main+0xd6c>
jp     1ebc <main+0xd6c>
jmp    1f12 <main+0xdc2>
mov    -0x9be4(%rbp),%esi
movsd  -0x1f10(%rbp),%xmm0
ff
lea    0x214f(%rip),%rdi
lea    0x2191(%rip),%rdx
mov    $0x1,%ecx
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x9bd4(%rbp)
mov    -0x9be8(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9be8(%rbp)
cmp    $0xa,%eax
jle    1f0d <main+0xdbd>
jmp    1f2b <main+0xddb>
jmp    1f12 <main+0xdc2>
jmp    1f17 <main+0xdc7>
mov    -0x9be4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9be4(%rbp)
jmp    1e8a <main+0xd3a>
jmp    1f30 <main+0xde0>
mov    -0x9bdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bdc(%rbp)
jmp    1e1a <main+0xcca>
cmpl   $0x0,-0x9bd4(%rbp)
je     1f64 <main+0xe14>
lea    0x20f9(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1f72 <main+0xe22>
lea    0x20ee(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x9bec(%rbp)
cmpl   $0x3e0,-0x9bec(%rbp)
jge    1fb3 <main+0xe63>
movslq -0x9bec(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bec(%rbp)
jmp    1f7c <main+0xe2c>
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
movsd  %xmm0,-0x3e10(%rbp)
ff
movl   $0x0,-0x9bf0(%rbp)
movl   $0x0,-0x9bf8(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9bf8(%rbp)
mov    %al,-0x9d2e(%rbp)
jge    1ffb <main+0xeab>
cmpl   $0x0,-0x9bf0(%rbp)
sete   %al
mov    %al,-0x9d2e(%rbp)
mov    -0x9d2e(%rbp),%al
test   $0x1,%al
jne    200e <main+0xebe>
jmp    20ff <main+0xfaf>
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x9bfc(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
movslq -0x9bfc(%rbp),%rax
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9c04(%rbp)
movl   $0x0,-0x9c00(%rbp)
cmpl   $0x1,-0x9c00(%rbp)
jge    20e6 <main+0xf96>
movsd  -0x1f10(%rbp),%xmm0
ff
ucomisd -0x3e10(%rbp),%xmm0
ff
jne    2074 <main+0xf24>
jp     2074 <main+0xf24>
jmp    20cd <main+0xf7d>
mov    -0x9c00(%rbp),%esi
movsd  -0x3e10(%rbp),%xmm0
ff
movsd  -0x1f10(%rbp),%xmm1
ff
lea    0x1f8f(%rip),%rdi
lea    0x1fd1(%rip),%rdx
mov    $0x2,%al
call   1040 <printf@plt>
movl   $0x1,-0x9bf0(%rbp)
mov    -0x9c04(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9c04(%rbp)
cmp    $0xa,%eax
jle    20c8 <main+0xf78>
jmp    20e6 <main+0xf96>
jmp    20cd <main+0xf7d>
jmp    20d2 <main+0xf82>
mov    -0x9c00(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c00(%rbp)
jmp    2046 <main+0xef6>
jmp    20eb <main+0xf9b>
mov    -0x9bf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bf8(%rbp)
jmp    1fd6 <main+0xe86>
cmpl   $0x0,-0x9bf0(%rbp)
je     211f <main+0xfcf>
lea    0x1f3e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    212d <main+0xfdd>
lea    0x1f33(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x9c08(%rbp)
cmpl   $0x3e0,-0x9c08(%rbp)
jge    216e <main+0x101e>
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    2137 <main+0xfe7>
movl   $0x0,-0x9c0c(%rbp)
movl   $0x0,-0x9c14(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9c14(%rbp)
mov    %al,-0x9d2f(%rbp)
jge    21a7 <main+0x1057>
cmpl   $0x0,-0x9c0c(%rbp)
sete   %al
mov    %al,-0x9d2f(%rbp)
mov    -0x9d2f(%rbp),%al
test   $0x1,%al
jne    21ba <main+0x106a>
jmp    22ac <main+0x115c>
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x9c18(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
movslq -0x9c18(%rbp),%rax
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9c20(%rbp)
movl   $0x0,-0x9c1c(%rbp)
cmpl   $0x1,-0x9c1c(%rbp)
jge    2293 <main+0x1143>
movsd  -0x1f10(%rbp),%xmm0
ff
movsd  0x1e09(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2224 <main+0x10d4>
jp     2224 <main+0x10d4>
jmp    227a <main+0x112a>
mov    -0x9c1c(%rbp),%esi
movsd  -0x1f10(%rbp),%xmm0
ff
lea    0x1de7(%rip),%rdi
lea    0x1e29(%rip),%rdx
mov    $0x2,%ecx
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x9c0c(%rbp)
mov    -0x9c20(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9c20(%rbp)
cmp    $0xa,%eax
jle    2275 <main+0x1125>
jmp    2293 <main+0x1143>
jmp    227a <main+0x112a>
jmp    227f <main+0x112f>
mov    -0x9c1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c1c(%rbp)
jmp    21f2 <main+0x10a2>
jmp    2298 <main+0x1148>
mov    -0x9c14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c14(%rbp)
jmp    2182 <main+0x1032>
cmpl   $0x0,-0x9c0c(%rbp)
je     22cc <main+0x117c>
lea    0x1d91(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    22da <main+0x118a>
lea    0x1d86(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x9c24(%rbp)
movl   $0x0,-0x9c2c(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9c2c(%rbp)
mov    %al,-0x9d30(%rbp)
jge    2313 <main+0x11c3>
cmpl   $0x0,-0x9c24(%rbp)
sete   %al
mov    %al,-0x9d30(%rbp)
mov    -0x9d30(%rbp),%al
test   $0x1,%al
jne    2326 <main+0x11d6>
jmp    248d <main+0x133d>
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
shl    $0x2,%eax
mov    %eax,-0x9c30(%rbp)
mov    -0x9c30(%rbp),%eax
mov    %eax,-0x9c34(%rbp)
mov    -0x9c34(%rbp),%eax
mov    -0x9c30(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    23a5 <main+0x1255>
movslq -0x9c34(%rbp),%rax
movsd  0x1c98(%rip),%xmm0
addsd  -0x7c10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c34(%rbp),%rax
addsd  -0x9b10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c34(%rbp),%rax
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9c34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c34(%rbp)
jmp    2342 <main+0x11f2>
movl   $0x0,-0x9c3c(%rbp)
movl   $0x0,-0x9c38(%rbp)
mov    -0x9c38(%rbp),%eax
mov    -0x9b24(%rbp),%ecx
shl    $0x2,%ecx
cmp    %ecx,%eax
jge    2474 <main+0x1324>
movslq -0x9c38(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1c18(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    23fd <main+0x12ad>
jp     23fd <main+0x12ad>
jmp    245b <main+0x130b>
mov    -0x9c38(%rbp),%esi
movslq -0x9c38(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
lea    0x1c06(%rip),%rdi
lea    0x1c43(%rip),%rdx
mov    $0x1,%ecx
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x9c24(%rbp)
mov    -0x9c3c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9c3c(%rbp)
cmp    $0xa,%eax
jle    2456 <main+0x1306>
jmp    2474 <main+0x1324>
jmp    245b <main+0x130b>
jmp    2460 <main+0x1310>
mov    -0x9c38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c38(%rbp)
jmp    23b9 <main+0x1269>
jmp    2479 <main+0x1329>
mov    -0x9c2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c2c(%rbp)
jmp    22ee <main+0x119e>
cmpl   $0x0,-0x9c24(%rbp)
je     24ad <main+0x135d>
lea    0x1bb0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    24bb <main+0x136b>
lea    0x1ba5(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x9c40(%rbp)
movl   $0x0,-0x9c48(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9c48(%rbp)
mov    %al,-0x9d31(%rbp)
jge    24f4 <main+0x13a4>
cmpl   $0x0,-0x9c40(%rbp)
sete   %al
mov    %al,-0x9d31(%rbp)
mov    -0x9d31(%rbp),%al
test   $0x1,%al
jne    2507 <main+0x13b7>
jmp    266e <main+0x151e>
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
shl    $0x2,%eax
mov    %eax,-0x9c4c(%rbp)
mov    -0x9c4c(%rbp),%eax
mov    %eax,-0x9c50(%rbp)
mov    -0x9c50(%rbp),%eax
mov    -0x9c4c(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    2586 <main+0x1436>
movslq -0x9c50(%rbp),%rax
movsd  0x1ab7(%rip),%xmm0
addsd  -0x7c10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c50(%rbp),%rax
addsd  -0x9b10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c50(%rbp),%rax
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9c50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c50(%rbp)
jmp    2523 <main+0x13d3>
movl   $0x0,-0x9c58(%rbp)
movl   $0x0,-0x9c54(%rbp)
mov    -0x9c54(%rbp),%eax
mov    -0x9b24(%rbp),%ecx
shl    $0x2,%ecx
cmp    %ecx,%eax
jge    2655 <main+0x1505>
movslq -0x9c54(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1a37(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    25de <main+0x148e>
jp     25de <main+0x148e>
jmp    263c <main+0x14ec>
mov    -0x9c54(%rbp),%esi
movslq -0x9c54(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
lea    0x1a25(%rip),%rdi
lea    0x1a62(%rip),%rdx
mov    $0x1,%ecx
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x9c40(%rbp)
mov    -0x9c58(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9c58(%rbp)
cmp    $0xa,%eax
jle    2637 <main+0x14e7>
jmp    2655 <main+0x1505>
jmp    263c <main+0x14ec>
jmp    2641 <main+0x14f1>
mov    -0x9c54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c54(%rbp)
jmp    259a <main+0x144a>
jmp    265a <main+0x150a>
mov    -0x9c48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c48(%rbp)
jmp    24cf <main+0x137f>
cmpl   $0x0,-0x9c40(%rbp)
je     268e <main+0x153e>
lea    0x19cf(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    269c <main+0x154c>
lea    0x19c4(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x9c5c(%rbp)
movl   $0x0,-0x9c64(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9c64(%rbp)
mov    %al,-0x9d32(%rbp)
jge    26d5 <main+0x1585>
cmpl   $0x0,-0x9c5c(%rbp)
sete   %al
mov    %al,-0x9d32(%rbp)
mov    -0x9d32(%rbp),%al
test   $0x1,%al
jne    26e8 <main+0x1598>
jmp    284f <main+0x16ff>
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
shl    $0x2,%eax
mov    %eax,-0x9c68(%rbp)
mov    -0x9c68(%rbp),%eax
mov    %eax,-0x9c6c(%rbp)
mov    -0x9c6c(%rbp),%eax
mov    -0x9c68(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    2767 <main+0x1617>
movslq -0x9c6c(%rbp),%rax
movsd  0x18d6(%rip),%xmm0
addsd  -0x7c10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c6c(%rbp),%rax
addsd  -0x9b10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c6c(%rbp),%rax
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9c6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c6c(%rbp)
jmp    2704 <main+0x15b4>
movl   $0x0,-0x9c74(%rbp)
movl   $0x0,-0x9c70(%rbp)
mov    -0x9c70(%rbp),%eax
mov    -0x9b24(%rbp),%ecx
shl    $0x2,%ecx
cmp    %ecx,%eax
jge    2836 <main+0x16e6>
movslq -0x9c70(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1856(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    27bf <main+0x166f>
jp     27bf <main+0x166f>
jmp    281d <main+0x16cd>
mov    -0x9c70(%rbp),%esi
movslq -0x9c70(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
lea    0x1844(%rip),%rdi
lea    0x1881(%rip),%rdx
mov    $0x1,%ecx
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x9c5c(%rbp)
mov    -0x9c74(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9c74(%rbp)
cmp    $0xa,%eax
jle    2818 <main+0x16c8>
jmp    2836 <main+0x16e6>
jmp    281d <main+0x16cd>
jmp    2822 <main+0x16d2>
mov    -0x9c70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c70(%rbp)
jmp    277b <main+0x162b>
jmp    283b <main+0x16eb>
mov    -0x9c64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c64(%rbp)
jmp    26b0 <main+0x1560>
cmpl   $0x0,-0x9c5c(%rbp)
je     286f <main+0x171f>
lea    0x17ee(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    287d <main+0x172d>
lea    0x17e3(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x9c78(%rbp)
mov    -0x9c78(%rbp),%eax
cmp    -0x9b24(%rbp),%eax
jg     2aa4 <main+0x1954>
movl   $0x0,-0x9c7c(%rbp)
cmpl   $0x3e0,-0x9c7c(%rbp)
jge    28da <main+0x178a>
movslq -0x9c7c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c7c(%rbp)
jmp    28a3 <main+0x1753>
mov    -0x9c78(%rbp),%eax
mov    %eax,-0x9c80(%rbp)
movl   $0x0,-0x9c84(%rbp)
movl   $0x0,-0x9c8c(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9c8c(%rbp)
mov    %al,-0x9d33(%rbp)
jge    291f <main+0x17cf>
cmpl   $0x0,-0x9c84(%rbp)
sete   %al
mov    %al,-0x9d33(%rbp)
mov    -0x9d33(%rbp),%al
test   $0x1,%al
jne    2932 <main+0x17e2>
jmp    2a5d <main+0x190d>
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x9c90(%rbp)
movslq -0x9c90(%rbp),%rax
movsd  0x16ba(%rip),%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9c98(%rbp)
movl   $0x0,-0x9c94(%rbp)
cmpl   $0x80,-0x9c94(%rbp)
jge    2a44 <main+0x18f4>
movslq -0x9c94(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9c94(%rbp),%eax
cmp    -0x9c78(%rbp),%eax
setl   %al
and    $0x1,%al
movzbl %al,%eax
imul   $0x63,%eax,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jne    29bb <main+0x186b>
jp     29bb <main+0x186b>
jmp    2a2b <main+0x18db>
mov    -0x9c94(%rbp),%esi
mov    -0x9c94(%rbp),%eax
cmp    -0x9c78(%rbp),%eax
setl   %al
and    $0x1,%al
movzbl %al,%eax
imul   $0x63,%eax,%ecx
movslq -0x9c94(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x1631(%rip),%rdi
lea    0x1656(%rip),%rdx
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x9c84(%rbp)
mov    -0x9c98(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9c98(%rbp)
cmp    $0xa,%eax
jle    2a26 <main+0x18d6>
jmp    2a44 <main+0x18f4>
jmp    2a2b <main+0x18db>
jmp    2a30 <main+0x18e0>
mov    -0x9c94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c94(%rbp)
jmp    296b <main+0x181b>
jmp    2a49 <main+0x18f9>
mov    -0x9c8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c8c(%rbp)
jmp    28fa <main+0x17aa>
cmpl   $0x0,-0x9c84(%rbp)
je     2a7d <main+0x192d>
lea    0x15e0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    2a8b <main+0x193b>
lea    0x15d5(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    2a90 <main+0x1940>
mov    -0x9c78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c78(%rbp)
jmp    2887 <main+0x1737>
movl   $0x0,-0x9c9c(%rbp)
mov    -0x9c9c(%rbp),%eax
mov    -0x9b1c(%rbp),%ecx
sub    -0x9b24(%rbp),%ecx
cmp    %ecx,%eax
jge    2aea <main+0x199a>
lea    0x158a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x9c9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c9c(%rbp)
jmp    2aae <main+0x195e>
movl   $0x0,-0x9ca0(%rbp)
cmpl   $0x3e0,-0x9ca0(%rbp)
jge    2b2b <main+0x19db>
movslq -0x9ca0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9ca0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ca0(%rbp)
jmp    2af4 <main+0x19a4>
movsd  0x14cd(%rip),%xmm0
movsd  %xmm0,-0x9ca8(%rbp)
ff
movsd  -0x9ca8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9cac(%rbp)
movl   $0x0,-0x9cb4(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9cb4(%rbp)
mov    %al,-0x9d34(%rbp)
jge    2b84 <main+0x1a34>
cmpl   $0x0,-0x9cac(%rbp)
sete   %al
mov    %al,-0x9d34(%rbp)
mov    -0x9d34(%rbp),%al
test   $0x1,%al
jne    2b97 <main+0x1a47>
jmp    2cc8 <main+0x1b78>
movsd  0x1479(%rip),%xmm0
movsd  %xmm0,-0x9ca8(%rbp)
ff
movsd  -0x9ca8(%rbp),%xmm0
ff
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9cbc(%rbp)
movl   $0x0,-0x9cb8(%rbp)
cmpl   $0x1,-0x9cb8(%rbp)
jge    2caf <main+0x1b5f>
movslq -0x9cb8(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x9ca8(%rbp),%xmm0
ff
mov    -0x9cb4(%rbp),%eax
add    $0x1,%eax
shl    $0x1,%eax
add    $0x1,%eax
add    $0x2,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jne    2c23 <main+0x1ad3>
jp     2c23 <main+0x1ad3>
jmp    2c96 <main+0x1b46>
mov    -0x9cb8(%rbp),%esi
mov    -0x9cb4(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
add    $0x2,%ecx
movslq -0x9cb8(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x9ca8(%rbp),%xmm0
ff
lea    0x13c6(%rip),%rdi
lea    0x140d(%rip),%rdx
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x9cac(%rbp)
mov    -0x9cbc(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9cbc(%rbp)
cmp    $0xa,%eax
jle    2c91 <main+0x1b41>
jmp    2caf <main+0x1b5f>
jmp    2c96 <main+0x1b46>
jmp    2c9b <main+0x1b4b>
mov    -0x9cb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cb8(%rbp)
jmp    2bd3 <main+0x1a83>
jmp    2cb4 <main+0x1b64>
mov    -0x9cb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cb4(%rbp)
jmp    2b5f <main+0x1a0f>
cmpl   $0x0,-0x9cac(%rbp)
je     2ce8 <main+0x1b98>
lea    0x1375(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    2cf6 <main+0x1ba6>
lea    0x136a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x9cc0(%rbp)
cmpl   $0x3e0,-0x9cc0(%rbp)
jge    2d37 <main+0x1be7>
movslq -0x9cc0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9cc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cc0(%rbp)
jmp    2d00 <main+0x1bb0>
movsd  0x12c9(%rip),%xmm0
movsd  %xmm0,-0x9cd0(%rbp)
ff
movsd  0x12b1(%rip),%xmm0
movsd  %xmm0,-0x9cc8(%rbp)
ff
movsd  -0x9cc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9cd4(%rbp)
movl   $0x0,-0x9cdc(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9cdc(%rbp)
mov    %al,-0x9d35(%rbp)
jge    2da0 <main+0x1c50>
cmpl   $0x0,-0x9cd4(%rbp)
sete   %al
mov    %al,-0x9d35(%rbp)
mov    -0x9d35(%rbp),%al
test   $0x1,%al
jne    2db3 <main+0x1c63>
jmp    2eff <main+0x1daf>
movsd  0x125d(%rip),%xmm0
movsd  %xmm0,-0x9cc8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x9cd0(%rbp)
ff
movsd  -0x9cc8(%rbp),%xmm0
ff
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9ce4(%rbp)
movl   $0x0,-0x9ce0(%rbp)
cmpl   $0x1,-0x9ce0(%rbp)
jge    2ee6 <main+0x1d96>
movslq -0x9ce0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x9cc8(%rbp),%xmm0
ff
addsd  -0x9cd0(%rbp),%xmm0
ff
mov    -0x9cdc(%rbp),%eax
add    $0x1,%eax
shl    $0x1,%eax
add    $0x2,%eax
add    $0x63,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jne    2e52 <main+0x1d02>
jp     2e52 <main+0x1d02>
jmp    2ecd <main+0x1d7d>
mov    -0x9ce0(%rbp),%esi
mov    -0x9cdc(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
add    $0x63,%ecx
movslq -0x9ce0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x9cc8(%rbp),%xmm0
ff
addsd  -0x9cd0(%rbp),%xmm0
ff
lea    0x118f(%rip),%rdi
lea    0x11df(%rip),%rdx
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x9cd4(%rbp)
mov    -0x9ce4(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9ce4(%rbp)
cmp    $0xa,%eax
jle    2ec8 <main+0x1d78>
jmp    2ee6 <main+0x1d96>
jmp    2ecd <main+0x1d7d>
jmp    2ed2 <main+0x1d82>
mov    -0x9ce0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ce0(%rbp)
jmp    2dfa <main+0x1caa>
jmp    2eeb <main+0x1d9b>
mov    -0x9cdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cdc(%rbp)
jmp    2d7b <main+0x1c2b>
cmpl   $0x0,-0x9cd4(%rbp)
je     2f1f <main+0x1dcf>
lea    0x113e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    2f2d <main+0x1ddd>
lea    0x1133(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x9ce8(%rbp)
cmpl   $0x3e0,-0x9ce8(%rbp)
jge    2f6e <main+0x1e1e>
movslq -0x9ce8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9ce8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ce8(%rbp)
jmp    2f37 <main+0x1de7>
movsd  0x1092(%rip),%xmm0
movsd  %xmm0,-0x9cf8(%rbp)
ff
movsd  0x108a(%rip),%xmm0
movsd  %xmm0,-0x9cf0(%rbp)
ff
movsd  -0x9cf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9cfc(%rbp)
movl   $0x0,-0x9d04(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9d04(%rbp)
mov    %al,-0x9d36(%rbp)
jge    2fd7 <main+0x1e87>
cmpl   $0x0,-0x9cfc(%rbp)
sete   %al
mov    %al,-0x9d36(%rbp)
mov    -0x9d36(%rbp),%al
test   $0x1,%al
jne    2fea <main+0x1e9a>
jmp    3144 <main+0x1ff4>
movsd  -0x9cf0(%rbp),%xmm0
ff
addsd  -0x9cf8(%rbp),%xmm0
ff
addsd  -0x1f10(%rbp),%xmm0
movsd  %xmm0,-0x1f10(%rbp)
movsd  0x1006(%rip),%xmm0
movsd  %xmm0,-0x9cf0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x9cf8(%rbp)
ff
movl   $0x0,-0x9d0c(%rbp)
movl   $0x0,-0x9d08(%rbp)
cmpl   $0x1,-0x9d08(%rbp)
jge    312b <main+0x1fdb>
movslq -0x9d08(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x9cf0(%rbp),%xmm0
ff
addsd  -0x9cf8(%rbp),%xmm0
ff
mov    -0x9d04(%rbp),%eax
add    $0x1,%eax
imul   $0x68,%eax,%eax
add    $0x5,%eax
add    $0x5,%eax
add    $0x63,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jne    3094 <main+0x1f44>
jp     3094 <main+0x1f44>
jmp    3112 <main+0x1fc2>
mov    -0x9d08(%rbp),%esi
mov    -0x9d04(%rbp),%eax
add    $0x1,%eax
imul   $0x68,%eax,%ecx
add    $0x5,%ecx
add    $0x5,%ecx
add    $0x63,%ecx
movslq -0x9d08(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x9cf0(%rbp),%xmm0
ff
addsd  -0x9cf8(%rbp),%xmm0
ff
lea    0xf4a(%rip),%rdi
lea    0xf9a(%rip),%rdx
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x9cfc(%rbp)
mov    -0x9d0c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9d0c(%rbp)
cmp    $0xa,%eax
jle    310d <main+0x1fbd>
jmp    312b <main+0x1fdb>
jmp    3112 <main+0x1fc2>
jmp    3117 <main+0x1fc7>
mov    -0x9d08(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d08(%rbp)
jmp    3039 <main+0x1ee9>
jmp    3130 <main+0x1fe0>
mov    -0x9d04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d04(%rbp)
jmp    2fb2 <main+0x1e62>
cmpl   $0x0,-0x9cfc(%rbp)
je     3164 <main+0x2014>
lea    0xef9(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    3172 <main+0x2022>
lea    0xeee(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x9d40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x7c28,%rsp
xor    %eax,%eax
call   1080 <check_offloading@plt>
movdqa 0xe70(%rip),%xmm0
mov    $0x2,%eax
movdqa 0xe73(%rip),%xmm1
movdqa 0xe7b(%rip),%xmm2
movdqa 0xe83(%rip),%xmm3
movdqa %xmm0,%xmm4
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm5
paddd  %xmm1,%xmm5
cvtdq2pd %xmm0,%xmm6
cvtdq2pd %xmm5,%xmm5
movaps %xmm6,0x5d10(%rsp,%rax,8)
movdqa %xmm5,0x5d20(%rsp,%rax,8)
pxor   %xmm5,%xmm5
psubd  %xmm4,%xmm5
movdqa %xmm2,%xmm6
psubd  %xmm4,%xmm6
cvtdq2pd %xmm5,%xmm5
cvtdq2pd %xmm6,%xmm6
movaps %xmm5,0x3e10(%rsp,%rax,8)
movaps %xmm6,0x3e20(%rsp,%rax,8)
paddd  %xmm3,%xmm0
paddd  %xmm3,%xmm4
add    $0x4,%rax
cmp    $0x3e2,%rax
jne    11c0 <main+0x50>
xor    %ebx,%ebx
xor    %eax,%eax
call   1090 <omp_is_initial_device@plt>
mov    %eax,%ebp
mov    %eax,%r13d
lea    0x20(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
test   %ebp,%ebp
mov    $0x80,%eax
mov    $0x20,%ecx
cmove  %eax,%ecx
mov    %rcx,0x8(%rsp)
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
cltq
addsd  0x20(%rsp,%rax,8),%xmm0
movsd  %xmm0,0x20(%rsp,%rax,8)
lea    0xe05(%rip),%r15
lea    0xe2a(%rip),%r12
xor    %eax,%eax
xor    %ebp,%ebp
jmp    1293 <main+0x123>
add    $0x1,%ebp
mov    $0x1,%eax
add    $0x1,%rbx
cmp    %rbx,0x8(%rsp)
je     12c7 <main+0x157>
movsd  0x20(%rsp,%rbx,8),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
ucomisd %xmm1,%xmm0
jne    12a8 <main+0x138>
jnp    1288 <main+0x118>
mov    %r15,%rdi
mov    %ebx,%esi
mov    %r12,%rdx
mov    %ebx,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%ebp
jle    1280 <main+0x110>
lea    0xe04(%rip),%rdi
jmp    12db <main+0x16b>
test   %eax,%eax
lea    0xdef(%rip),%rax
lea    0xdf2(%rip),%rdi
cmove  %rax,%rdi
call   1030 <puts@plt>
mov    0x8(%rsp),%rax
lea    0x0(,%rax,4),%eax
cmp    $0x2,%eax
mov    $0x1,%r14d
cmovae %eax,%r14d
xor    %ebx,%ebx
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
shl    $0x2,%eax
cltq
movapd 0x5d20(%rsp,%rax,8),%xmm0
movapd 0x5d30(%rsp,%rax,8),%xmm1
addpd  0x3e20(%rsp,%rax,8),%xmm0
movapd %xmm0,0x1f20(%rsp,%rax,8)
addpd  0x3e30(%rsp,%rax,8),%xmm1
movapd %xmm1,0x1f30(%rsp,%rax,8)
lea    0xd34(%rip),%r15
lea    0xd5e(%rip),%r12
xor    %eax,%eax
xor    %ebp,%ebp
jmp    1371 <main+0x201>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%ebp
mov    $0x1,%eax
add    $0x1,%rbx
cmp    %rbx,%r14
je     13a7 <main+0x237>
movsd  0x1f20(%rsp,%rbx,8),%xmm1
ucomisd 0xcee(%rip),%xmm1
jne    1386 <main+0x216>
jnp    1368 <main+0x1f8>
xorpd  %xmm0,%xmm0
mov    %r15,%rdi
mov    %ebx,%esi
mov    %r12,%rdx
mov    $0x2,%al
call   1050 <printf@plt>
cmp    $0xa,%ebp
jle    1360 <main+0x1f0>
lea    0xd24(%rip),%rdi
jmp    13bb <main+0x24b>
test   %eax,%eax
lea    0xd0f(%rip),%rax
lea    0xd12(%rip),%rdi
cmove  %rax,%rdi
call   1030 <puts@plt>
lea    0x20(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
cltq
movsd  %xmm0,0x20(%rsp,%rax,8)
lea    0xc88(%rip),%r15
lea    0xcad(%rip),%r12
xor    %eax,%eax
xor    %ebp,%ebp
jmp    1413 <main+0x2a3>
nopl   (%rax)
add    $0x1,%ebp
mov    $0x1,%eax
add    $0x1,%rbx
cmp    %rbx,0x8(%rsp)
je     1444 <main+0x2d4>
movsd  0x20(%rsp,%rbx,8),%xmm0
ucomisd 0xc4f(%rip),%xmm0
jne    1425 <main+0x2b5>
jnp    1408 <main+0x298>
mov    %r15,%rdi
mov    %ebx,%esi
mov    %r12,%rdx
xor    %ecx,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%ebp
jle    1400 <main+0x290>
lea    0xc87(%rip),%rdi
jmp    1458 <main+0x2e8>
test   %eax,%eax
lea    0xc72(%rip),%rax
lea    0xc75(%rip),%rdi
cmove  %rax,%rdi
call   1030 <puts@plt>
lea    0x20(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
mov    %eax,%r15d
xor    %eax,%eax
call   1090 <omp_is_initial_device@plt>
add    %r15d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movslq %r15d,%rax
movsd  %xmm0,0x20(%rsp,%rax,8)
lea    0xbdd(%rip),%r15
lea    0xc02(%rip),%r12
xor    %eax,%eax
xor    %ebp,%ebp
mov    %r13,0x10(%rsp)
jmp    14c3 <main+0x353>
nopl   (%rax)
add    $0x1,%ebp
mov    $0x1,%eax
add    $0x1,%rbx
cmp    %rbx,0x8(%rsp)
je     14f9 <main+0x389>
movsd  0x20(%rsp,%rbx,8),%xmm0
lea    (%rbx,%r13,1),%rcx
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
ucomisd %xmm1,%xmm0
jne    14dc <main+0x36c>
jnp    14b8 <main+0x348>
mov    %r15,%rdi
mov    %ebx,%esi
mov    %r12,%rdx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%ebp
jle    14b0 <main+0x340>
lea    0xbd2(%rip),%rdi
jmp    150d <main+0x39d>
test   %eax,%eax
lea    0xbbd(%rip),%rax
lea    0xbc0(%rip),%rdi
cmove  %rax,%rdi
call   1030 <puts@plt>
lea    0x20(%rsp),%rdi
xor    %ebp,%ebp
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
mov    $0x1,%r13d
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1090 <omp_is_initial_device@plt>
test   %eax,%eax
je     1545 <main+0x3d5>
xorpd  %xmm0,%xmm0
jmp    154d <main+0x3dd>
movsd  0xb03(%rip),%xmm0
sub    0x10(%rsp),%r13d
movslq %ebx,%rax
movsd  %xmm0,0x20(%rsp,%rax,8)
lea    0xb16(%rip),%r15
lea    0xb3b(%rip),%r12
xor    %ebx,%ebx
xor    %eax,%eax
jmp    157b <main+0x40b>
nop
add    $0x1,%rbx
cmp    %rbx,0x8(%rsp)
je     15c1 <main+0x451>
movsd  0x20(%rsp,%rbx,8),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
ucomisd %xmm1,%xmm0
jne    1570 <main+0x400>
jp     1570 <main+0x400>
cmpl   $0x1,0x10(%rsp)
je     1570 <main+0x400>
test   %rbx,%rbx
mov    $0x0,%ecx
cmove  %r13d,%ecx
mov    %r15,%rdi
mov    %ebx,%esi
mov    %r12,%rdx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%ebp
jg     15d7 <main+0x467>
add    $0x1,%ebp
mov    $0x1,%eax
jmp    1570 <main+0x400>
test   %eax,%eax
lea    0xaf5(%rip),%rax
lea    0xaf8(%rip),%rdi
cmove  %rax,%rdi
jmp    15de <main+0x46e>
lea    0xaeb(%rip),%rdi
call   1030 <puts@plt>
lea    0x20(%rsp),%rdi
xor    %r13d,%r13d
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1090 <omp_is_initial_device@plt>
add    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movslq %ebx,%rax
movsd  %xmm0,0x20(%rsp,%rax,8)
lea    0xa58(%rip),%r15
lea    0xa7d(%rip),%r12
xor    %ebp,%ebp
xor    %eax,%eax
jmp    1641 <main+0x4d1>
nopl   (%rax)
add    $0x1,%ebp
mov    $0x1,%eax
mov    %rbx,%r13
cmp    $0x20,%rbx
je     167b <main+0x50b>
movsd  0x20(%rsp,%r13,8),%xmm0
lea    0x1(%r13),%rbx
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
ucomisd %xmm1,%xmm0
jne    165b <main+0x4eb>
jnp    1638 <main+0x4c8>
mov    %r15,%rdi
mov    %r13d,%esi
mov    %r12,%rdx
mov    %ebx,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%ebp
jle    1630 <main+0x4c0>
lea    0xa50(%rip),%rdi
jmp    168f <main+0x51f>
test   %eax,%eax
lea    0xa3b(%rip),%rax
lea    0xa3e(%rip),%rdi
cmove  %rax,%rdi
call   1030 <puts@plt>
lea    0x20(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
movslq %ebx,%rax
movsd  %xmm0,0x20(%rsp,%rax,8)
movsd  0x20(%rsp),%xmm0
lea    0x9f4(%rip),%rbp
ucomisd 0x97d(%rip),%xmm0
mov    %rbp,%rdi
mov    %r14,%r13
jne    16dd <main+0x56d>
jnp    1700 <main+0x590>
lea    0x994(%rip),%rdi
lea    0x9c3(%rip),%rdx
xor    %esi,%esi
mov    $0x1,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
lea    0x9c9(%rip),%rdi
call   1030 <puts@plt>
lea    0x20(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
movsd  %xmm0,0x18(%rsp)
movsd  %xmm0,0x1f20(%rsp)
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
movslq %ebx,%rax
movsd  %xmm0,0x20(%rsp,%rax,8)
movsd  0x18(%rsp),%xmm0
movsd  0x20(%rsp),%xmm1
ucomisd %xmm0,%xmm1
mov    %rbp,%rdi
jne    175c <main+0x5ec>
jnp    177a <main+0x60a>
lea    0x915(%rip),%rdi
lea    0x944(%rip),%rdx
xor    %esi,%esi
mov    $0x2,%al
call   1050 <printf@plt>
lea    0x94f(%rip),%rdi
call   1030 <puts@plt>
lea    0x20(%rsp),%rdi
xor    %r12d,%r12d
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
movslq %ebx,%rax
movsd  %xmm0,0x20(%rsp,%rax,8)
movsd  0x20(%rsp),%xmm0
ucomisd 0x89e(%rip),%xmm0
jne    17be <main+0x64e>
jnp    17e1 <main+0x671>
lea    0x8b3(%rip),%rdi
lea    0x8e2(%rip),%rdx
xor    %esi,%esi
mov    $0x2,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
lea    0x8e8(%rip),%rbp
mov    %rbp,%rdi
call   1030 <puts@plt>
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
shl    $0x2,%eax
cltq
movapd 0x843(%rip),%xmm2
movapd 0x5d20(%rsp,%rax,8),%xmm0
addpd  %xmm2,%xmm0
addpd  0x3e20(%rsp,%rax,8),%xmm0
movapd 0x5d30(%rsp,%rax,8),%xmm1
addpd  %xmm2,%xmm1
addpd  0x3e30(%rsp,%rax,8),%xmm1
movapd %xmm0,0x1f20(%rsp,%rax,8)
movapd %xmm1,0x1f30(%rsp,%rax,8)
lea    0x836(%rip),%r14
lea    0x860(%rip),%r15
xor    %ebx,%ebx
xor    %ebp,%ebp
jmp    185d <main+0x6ed>
nop
add    $0x1,%r12d
add    $0x1,%rbx
cmp    %rbx,%r13
je     189a <main+0x72a>
movsd  0x1f20(%rsp,%rbx,8),%xmm0
ucomisd 0x7e2(%rip),%xmm0
jne    1872 <main+0x702>
jnp    1854 <main+0x6e4>
mov    $0x1,%ebp
mov    %r14,%rdi
mov    %ebx,%esi
mov    %r15,%rdx
mov    $0x1,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%r12d
jle    1850 <main+0x6e0>
lea    0x831(%rip),%rdi
jmp    18ae <main+0x73e>
test   %ebp,%ebp
lea    0x81c(%rip),%rax
lea    0x81f(%rip),%rdi
cmove  %rax,%rdi
call   1030 <puts@plt>
xor    %ebx,%ebx
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
shl    $0x2,%eax
cltq
movapd 0x5d20(%rsp,%rax,8),%xmm0
movapd 0x76e(%rip),%xmm1
addpd  %xmm1,%xmm0
addpd  0x3e20(%rsp,%rax,8),%xmm0
movapd %xmm0,0x1f20(%rsp,%rax,8)
movapd 0x5d30(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
addpd  0x3e30(%rsp,%rax,8),%xmm0
movapd %xmm0,0x1f30(%rsp,%rax,8)
lea    0x76a(%rip),%r14
lea    0x794(%rip),%r15
xor    %r12d,%r12d
xor    %ebp,%ebp
jmp    192d <main+0x7bd>
nopl   0x0(%rax)
add    $0x1,%r12d
add    $0x1,%rbx
cmp    %rbx,%r13
je     196a <main+0x7fa>
movsd  0x1f20(%rsp,%rbx,8),%xmm0
ucomisd 0x712(%rip),%xmm0
jne    1942 <main+0x7d2>
jnp    1924 <main+0x7b4>
mov    $0x1,%ebp
mov    %r14,%rdi
mov    %ebx,%esi
mov    %r15,%rdx
mov    $0x1,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%r12d
jle    1920 <main+0x7b0>
lea    0x761(%rip),%rdi
jmp    197e <main+0x80e>
test   %ebp,%ebp
lea    0x74c(%rip),%rax
lea    0x74f(%rip),%rdi
cmove  %rax,%rdi
call   1030 <puts@plt>
xor    %ebx,%ebx
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
shl    $0x2,%eax
cltq
movapd 0x5d20(%rsp,%rax,8),%xmm0
movapd 0x69e(%rip),%xmm1
addpd  %xmm1,%xmm0
addpd  0x3e20(%rsp,%rax,8),%xmm0
addpd  0x5d30(%rsp,%rax,8),%xmm1
movapd %xmm0,0x1f20(%rsp,%rax,8)
addpd  0x3e30(%rsp,%rax,8),%xmm1
movapd %xmm1,0x1f30(%rsp,%rax,8)
lea    0x69e(%rip),%r14
lea    0x6c8(%rip),%r15
xor    %r12d,%r12d
xor    %ebp,%ebp
jmp    19fd <main+0x88d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12d
add    $0x1,%rbx
cmp    %rbx,%r13
je     1a3a <main+0x8ca>
movsd  0x1f20(%rsp,%rbx,8),%xmm0
ucomisd 0x642(%rip),%xmm0
jne    1a12 <main+0x8a2>
jnp    19f4 <main+0x884>
mov    $0x1,%ebp
mov    %r14,%rdi
mov    %ebx,%esi
mov    %r15,%rdx
mov    $0x1,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%r12d
jle    19f0 <main+0x880>
lea    0x691(%rip),%rdi
jmp    1a4e <main+0x8de>
test   %ebp,%ebp
lea    0x67c(%rip),%rax
lea    0x67f(%rip),%rdi
cmove  %rax,%rdi
call   1030 <puts@plt>
mov    0x8(%rsp),%rax
or     $0x1,%eax
mov    %rax,0x18(%rsp)
mov    $0x1,%r13d
mov    $0x63,%r14d
lea    0x605(%rip),%r15
lea    0x62a(%rip),%r12
jmp    1aa8 <main+0x938>
nopl   0x0(%rax)
test   %eax,%eax
lea    0x640(%rip),%rdi
lea    0x62f(%rip),%rax
cmove  %rax,%rdi
call   1030 <puts@plt>
add    $0x1,%r13
cmp    0x18(%rsp),%r13
je     1b3c <main+0x9cc>
mov    $0x1f00,%edx
lea    0x20(%rsp),%rdi
xor    %esi,%esi
call   1060 <memset@plt>
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
cltq
movabs $0x4058c00000000000,%rcx
c0 58 40
mov    %rcx,0x20(%rsp,%rax,8)
xor    %ebx,%ebx
xor    %ebp,%ebp
xor    %eax,%eax
jmp    1aed <main+0x97d>
nopl   0x0(%rax)
add    $0x1,%rbx
cmp    $0x80,%rbx
je     1a80 <main+0x910>
movsd  0x20(%rsp,%rbx,8),%xmm0
cmp    %r13,%rbx
mov    $0x0,%ecx
cmovb  %r14d,%ecx
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
ucomisd %xmm1,%xmm0
jne    1b0e <main+0x99e>
jnp    1ae0 <main+0x970>
mov    %r15,%rdi
mov    %ebx,%esi
mov    %r12,%rdx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%ebp
jg     1b30 <main+0x9c0>
add    $0x1,%ebp
mov    $0x1,%eax
jmp    1ae0 <main+0x970>
nopl   0x0(%rax)
lea    0x592(%rip),%rdi
jmp    1a94 <main+0x924>
cmpq   $0x0,0x10(%rsp)
je     1b6d <main+0x9fd>
mov    $0x80,%eax
sub    0x8(%rsp),%eax
cmp    $0x2,%eax
mov    $0x1,%ebp
cmovge %eax,%ebp
lea    0x560(%rip),%rbx
nop
mov    %rbx,%rdi
call   1030 <puts@plt>
add    $0xffffffff,%ebp
jne    1b60 <main+0x9f0>
lea    0x54b(%rip),%rdi
call   1030 <puts@plt>
lea    0x4f8(%rip),%rbx
lea    0x52c(%rip),%r14
movsd  0x4d1(%rip),%xmm0
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r14,%rdx
mov    $0x67,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
lea    0x51f(%rip),%rbp
mov    %rbp,%rdi
call   1030 <puts@plt>
movsd  0x4ae(%rip),%xmm0
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r14,%rdx
mov    $0xd5,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
mov    %rbp,%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0x7c28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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