#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();
int omp_get_num_threads();
int omp_get_thread_num();
long omp_is_initial_device();
int /*<<< orphan*/ printf(char *, ...);
int main(void) {
  check_offloading();
  double A[(992) + 2], B[(992) + 2], C[(992) + 2], D[(992) + 2], E[(992) + 2];
  {
    int i;
    for (i = 0; i < (992); i++) {
      {
        C[i] = 0;
        D[i] = i;
        E[i] = -i;
      }
    }
  };
  long cpuExec = 0;
#pragma omp target map(tofrom : cpuExec)
  { cpuExec = omp_is_initial_device(); }
  int gpu_threads = 768;
  int cpu_threads = 32;
  int max_threads = cpuExec ? cpu_threads : gpu_threads;

#pragma omp parallel num_threads(33) if (0)

#pragma omp barrier

#pragma omp barrier

#pragma omp barrier

#pragma omp barrier
  {
    int fail = 0;
    int trial;
    for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(33)
      {{{{int tid = omp_get_thread_num();
      int cs = (992) / omp_get_num_threads();
      int lb = tid * cs;
      int ub = (tid + 1) * cs;
      ub = ub > (992) ? (992) : ub;
      for (int i = lb; i < ub; i++) {
        A[i] = D[i];
      }
      double sum = 0;
      for (int i = 1 + tid; i < (992); i++) {
        sum += A[i];
      }
      A[tid] = sum;
      sum = 0;
      for (int i = 2 + tid; i < (992); i++) {
        sum += A[i];
      }
      A[tid + 1] = sum;
      B[tid] = A[tid] - A[tid + 1];
    }
  }
}
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (B[i] != i + 1) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "B[i]", 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 threads[1];
  threads[0] = t;

#pragma omp parallel num_threads(threads[0])

#pragma omp barrier

#pragma omp barrier

#pragma omp barrier

#pragma omp parallel num_threads(threads[0])

#pragma omp barrier

#pragma omp barrier

#pragma omp barrier

#pragma omp parallel num_threads(threads[0])

#pragma omp barrier

#pragma omp barrier

#pragma omp barrier

#pragma omp parallel num_threads(threads[0])

#pragma omp barrier

#pragma omp barrier

#pragma omp barrier

#pragma omp parallel num_threads(threads[0])

#pragma omp barrier

#pragma omp barrier

#pragma omp barrier
  {
    int fail = 0;
    int trial;
    for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(max_threads)
      {{{int i;
      for (i = 0; i < (992); i++) {
        B[i] = 0;
      }
    };
    {
      {{{int tid = omp_get_thread_num();
      int cs = (992) / omp_get_num_threads();
      int lb = tid * cs;
      int ub = (tid + 1) * cs;
      ub = ub > (992) ? (992) : ub;
      for (int i = lb; i < ub; i++) {
        A[i] = D[i];
      }
      double sum = 0;
      for (int i = 1 + tid; i < (992); i++) {
        sum += A[i];
      }
      A[tid] = sum;
      C[tid] = A[tid] - A[tid + 1] - tid;
      if (tid < omp_get_num_threads() - 1)
        B[tid] += C[tid];
    };
  }
}
{{{int tid = omp_get_thread_num();
int cs = (992) / omp_get_num_threads();
int lb = tid * cs;
int ub = (tid + 1) * cs;
ub = ub > (992) ? (992) : ub;
for (int i = lb; i < ub; i++) {
  A[i] = D[i];
}
double sum = 0;
for (int i = 1 + tid; i < (992); i++) {
  sum += A[i];
}
A[tid] = sum;
C[tid] = A[tid] - A[tid + 1] - tid;
if (tid < omp_get_num_threads() - 1)
  B[tid] += C[tid];
}
;
}
}
{{{int tid = omp_get_thread_num();
int cs = (992) / omp_get_num_threads();
int lb = tid * cs;
int ub = (tid + 1) * cs;
ub = ub > (992) ? (992) : ub;
for (int i = lb; i < ub; i++) {
  A[i] = D[i];
}
double sum = 0;
for (int i = 1 + tid; i < (992); i++) {
  sum += A[i];
}
A[tid] = sum;
C[tid] = A[tid] - A[tid + 1] - tid;
if (tid < omp_get_num_threads() - 1)
  B[tid] += C[tid];
}
;
}
}
{{{int tid = omp_get_thread_num();
int cs = (992) / omp_get_num_threads();
int lb = tid * cs;
int ub = (tid + 1) * cs;
ub = ub > (992) ? (992) : ub;
for (int i = lb; i < ub; i++) {
  A[i] = D[i];
}
double sum = 0;
for (int i = 1 + tid; i < (992); i++) {
  sum += A[i];
}
A[tid] = sum;
C[tid] = A[tid] - A[tid + 1] - tid;
if (tid < omp_get_num_threads() - 1)
  B[tid] += C[tid];
}
;
}
}
{
  {
    {
      int tid = omp_get_thread_num();
      int cs = (992) / omp_get_num_threads();
      int lb = tid * cs;
      int ub = (tid + 1) * cs;
      ub = ub > (992) ? (992) : ub;
      for (int i = lb; i < ub; i++) {
        A[i] = D[i];
      }
      double sum = 0;
      for (int i = 1 + tid; i < (992); i++) {
        sum += A[i];
      }
      A[tid] = sum;
      C[tid] = A[tid] - A[tid + 1] - tid;
      if (tid < omp_get_num_threads() - 1)
        B[tid] += C[tid];
    };
  }
}
}
}
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < threads[0] - 1; i++) {
    if (B[i] != 5) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "B[i]", 5,
             B[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");
};

#pragma omp parallel num_threads(threads[0])

#pragma omp barrier

#pragma omp barrier

#pragma omp barrier
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(max_threads)
    {{{int i;
    for (i = 0; i < (992); i++) {
      B[i] = 0;
    }
  };
  for (int t = 2; t <= max_threads; t++) {
    int threads[1];
    threads[0] = t;
    {
      {
        {
          int tid = omp_get_thread_num();
          int cs = (992) / omp_get_num_threads();
          int lb = tid * cs;
          int ub = (tid + 1) * cs;
          ub = ub > (992) ? (992) : ub;
          for (int i = lb; i < ub; i++) {
            A[i] = D[i];
          }
          double sum = 0;
          for (int i = 1 + tid; i < (992); i++) {
            sum += A[i];
          }
          A[tid] = sum;
          C[tid] = A[tid] - A[tid + 1] - tid;
          if (tid < omp_get_num_threads() - 1)
            B[tid] += C[tid];
        };
      }
    }
  }
}
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < max_threads - 1; i++) {
    if (B[i] != max_threads - i - 1) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "B[i]",
             max_threads - i - 1, B[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;

#pragma omp barrier

#pragma omp barrier

#pragma omp barrier
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma #pragma omp target
    {{{int i;
    for (i = 0; i < (992); i++) {
      B[i] = 0;
    }
  };
  {
    int tid = omp_get_thread_num();
    int cs = (992) / omp_get_num_threads();
    int lb = tid * cs;
    int ub = (tid + 1) * cs;
    ub = ub > (992) ? (992) : ub;
    for (int i = lb; i < ub; i++) {
      A[i] = D[i];
    }
    double sum = 0;
    for (int i = 1 + tid; i < (992); i++) {
      sum += A[i];
    }
    A[tid] = sum;
    C[tid] = A[tid] - A[tid + 1] - tid;
    if (tid < omp_get_num_threads() - 1)
      B[tid] += C[tid];
  }
}
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (C[i] != 491535) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "C[i]", 491535,
             C[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
for (int t = 2; t <= max_threads; t++) {
  {
    int i;
    for (i = 0; i < (992); i++) {
      B[i] = 0;
    }
  };
  int threads;
  threads = t;

#pragma omp barrier

#pragma omp barrier

#pragma omp barrier
  {
    int fail = 0;
    int trial;
    for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target parallel num_threads(threads)
      {{{int tid = omp_get_thread_num();
      int cs = (992) / omp_get_num_threads();
      int lb = tid * cs;
      int ub = (tid + 1) * cs;
      ub = ub > (992) ? (992) : ub;
      for (int i = lb; i < ub; i++) {
        A[i] = D[i];
      }
      double sum = 0;
      for (int i = 1 + tid; i < (992); i++) {
        sum += A[i];
      }
      A[tid] = sum;
      C[tid] = A[tid] - A[tid + 1] - tid;
      if (tid < omp_get_num_threads() - 1)
        B[tid] += C[tid];
    };
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < t - 1; i++) {
    if (B[i] != (trial + 1) * 1) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "B[i]",
             (trial + 1) * 1, B[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");
};
if (!cpuExec) {
  {
    int i;
    for (i = 0; i < (992); i++) {
      B[i] = 0;
    }
  };

#pragma omp parallel num_threads(16)

#pragma omp parallel num_threads(16)

#pragma omp barrier

#pragma omp barrier

#pragma omp barrier
  {
    int fail = 0;
    int trial;
    for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
      {{{{int b = omp_get_thread_num() * 16;
      {
        int tid = omp_get_thread_num();
        int cs = (992) / omp_get_num_threads();
        int lb = tid * cs;
        int ub = (tid + 1) * cs;
        ub = ub > (992) ? (992) : ub;
        for (int i = lb; i < ub; i++) {
          A[i] = D[i];
        }
        double sum = 0;
        for (int i = 1 + tid; i < (992); i++) {
          sum += A[i];
        }
        A[tid] = sum;
        C[tid] = A[tid] - A[tid + 1] - tid;
        if (tid < omp_get_num_threads() - 1)
          B[b + tid] += C[tid];
        else
          B[b + tid] = 0;
      }
    }
  };
}
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 16 * 16; i++) {
    if (B[i] != (i > 0 && (i + 1) % 16 == 0 ? 0 : (trial + 1) * 1)) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "B[i]",
             (i > 0 && (i + 1) % 16 == 0 ? 0 : (trial + 1) * 1), B[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
}
else {
  {
    for (int i = 0; i < (1); i++)
      printf("Succeeded\n");
  };
}
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x9e00,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x0,%al
call   1060 <check_offloading@plt>
movl   $0x0,-0x9b64(%rbp)
cmpl   $0x3e0,-0x9b64(%rbp)
jge    11de <main+0x8e>
movslq -0x9b64(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x5d40(%rbp,%rax,8)
ff ff
cvtsi2sdl -0x9b64(%rbp),%xmm0
ff
movslq -0x9b64(%rbp),%rax
movsd  %xmm0,-0x7c50(%rbp,%rax,8)
ff ff
xor    %eax,%eax
sub    -0x9b64(%rbp),%eax
cvtsi2sd %eax,%xmm0
movslq -0x9b64(%rbp),%rax
movsd  %xmm0,-0x9b60(%rbp,%rax,8)
ff ff
mov    -0x9b64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b64(%rbp)
jmp    1173 <main+0x23>
movq   $0x0,-0x9b70(%rbp)
mov    $0x0,%al
call   1070 <omp_is_initial_device@plt>
mov    %rax,-0x9b70(%rbp)
movl   $0x300,-0x9b74(%rbp)
movl   $0x20,-0x9b78(%rbp)
cmpq   $0x0,-0x9b70(%rbp)
je     122a <main+0xda>
mov    -0x9b78(%rbp),%eax
mov    %eax,-0x9d84(%rbp)
jmp    1236 <main+0xe6>
mov    -0x9b74(%rbp),%eax
mov    %eax,-0x9d84(%rbp)
mov    -0x9d84(%rbp),%eax
mov    %eax,-0x9b7c(%rbp)
movl   $0x0,-0x9b80(%rbp)
movl   $0x0,-0x9b88(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9b88(%rbp)
mov    %al,-0x9d85(%rbp)
jge    127b <main+0x12b>
cmpl   $0x0,-0x9b80(%rbp)
sete   %al
mov    %al,-0x9d85(%rbp)
mov    -0x9d85(%rbp),%al
test   $0x1,%al
jne    128e <main+0x13e>
jmp    1570 <main+0x420>
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x9b8c(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    $0x3e0,%eax
cltd
idiv   %ecx
mov    %eax,-0x9b90(%rbp)
mov    -0x9b8c(%rbp),%eax
imul   -0x9b90(%rbp),%eax
mov    %eax,-0x9b94(%rbp)
mov    -0x9b8c(%rbp),%eax
add    $0x1,%eax
imul   -0x9b90(%rbp),%eax
mov    %eax,-0x9b98(%rbp)
cmpl   $0x3e0,-0x9b98(%rbp)
jle    12fb <main+0x1ab>
mov    $0x3e0,%eax
mov    %eax,-0x9d8c(%rbp)
jmp    1307 <main+0x1b7>
mov    -0x9b98(%rbp),%eax
mov    %eax,-0x9d8c(%rbp)
mov    -0x9d8c(%rbp),%eax
mov    %eax,-0x9b98(%rbp)
mov    -0x9b94(%rbp),%eax
mov    %eax,-0x9b9c(%rbp)
mov    -0x9b9c(%rbp),%eax
cmp    -0x9b98(%rbp),%eax
jge    1365 <main+0x215>
movslq -0x9b9c(%rbp),%rax
movsd  -0x7c50(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b9c(%rbp),%rax
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
mov    -0x9b9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b9c(%rbp)
jmp    131f <main+0x1cf>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x9ba8(%rbp)
ff
mov    -0x9b8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bac(%rbp)
cmpl   $0x3e0,-0x9bac(%rbp)
jge    13c3 <main+0x273>
movslq -0x9bac(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x9ba8(%rbp),%xmm0
ff
movsd  %xmm0,-0x9ba8(%rbp)
ff
mov    -0x9bac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bac(%rbp)
jmp    137f <main+0x22f>
movsd  -0x9ba8(%rbp),%xmm0
ff
movslq -0x9b8c(%rbp),%rax
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x9ba8(%rbp)
ff
mov    -0x9b8c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x9bb0(%rbp)
cmpl   $0x3e0,-0x9bb0(%rbp)
jge    1439 <main+0x2e9>
movslq -0x9bb0(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x9ba8(%rbp),%xmm0
ff
movsd  %xmm0,-0x9ba8(%rbp)
ff
mov    -0x9bb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bb0(%rbp)
jmp    13f5 <main+0x2a5>
movsd  -0x9ba8(%rbp),%xmm0
ff
mov    -0x9b8c(%rbp),%eax
add    $0x1,%eax
cltq
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
movslq -0x9b8c(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9b8c(%rbp),%eax
add    $0x1,%eax
cltq
subsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b8c(%rbp),%rax
movsd  %xmm0,-0x3e30(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9bb8(%rbp)
movl   $0x0,-0x9bb4(%rbp)
cmpl   $0x1,-0x9bb4(%rbp)
jge    1557 <main+0x407>
movslq -0x9bb4(%rbp),%rax
movsd  -0x3e30(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9bb4(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jne    14dc <main+0x38c>
jp     14dc <main+0x38c>
jmp    153e <main+0x3ee>
mov    -0x9bb4(%rbp),%esi
mov    -0x9bb4(%rbp),%ecx
add    $0x1,%ecx
movslq -0x9bb4(%rbp),%rax
movsd  -0x3e30(%rbp,%rax,8),%xmm0
ff ff
lea    0x2b0e(%rip),%rdi
lea    0x2b33(%rip),%rdx
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x9b80(%rbp)
mov    -0x9bb8(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9bb8(%rbp)
cmp    $0xa,%eax
jle    1539 <main+0x3e9>
jmp    1557 <main+0x407>
jmp    153e <main+0x3ee>
jmp    1543 <main+0x3f3>
mov    -0x9bb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bb4(%rbp)
jmp    149d <main+0x34d>
jmp    155c <main+0x40c>
mov    -0x9b88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b88(%rbp)
jmp    1256 <main+0x106>
cmpl   $0x0,-0x9b80(%rbp)
je     1590 <main+0x440>
lea    0x2abd(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    159e <main+0x44e>
lea    0x2ab2(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x9bbc(%rbp)
mov    -0x9bbc(%rbp),%eax
cmp    -0x9b7c(%rbp),%eax
jg     20ce <main+0xf7e>
mov    -0x9bbc(%rbp),%eax
mov    %eax,-0x9bc0(%rbp)
movl   $0x0,-0x9bc4(%rbp)
movl   $0x0,-0x9bcc(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9bcc(%rbp)
mov    %al,-0x9d8d(%rbp)
jge    15ff <main+0x4af>
cmpl   $0x0,-0x9bc4(%rbp)
sete   %al
mov    %al,-0x9d8d(%rbp)
mov    -0x9d8d(%rbp),%al
test   $0x1,%al
jne    1612 <main+0x4c2>
jmp    2087 <main+0xf37>
movl   $0x0,-0x9bd0(%rbp)
cmpl   $0x3e0,-0x9bd0(%rbp)
jge    1653 <main+0x503>
movslq -0x9bd0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e30(%rbp,%rax,8)
ff ff
mov    -0x9bd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bd0(%rbp)
jmp    161c <main+0x4cc>
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x9bd4(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    $0x3e0,%eax
cltd
idiv   %ecx
mov    %eax,-0x9bd8(%rbp)
mov    -0x9bd4(%rbp),%eax
imul   -0x9bd8(%rbp),%eax
mov    %eax,-0x9bdc(%rbp)
mov    -0x9bd4(%rbp),%eax
add    $0x1,%eax
imul   -0x9bd8(%rbp),%eax
mov    %eax,-0x9be0(%rbp)
cmpl   $0x3e0,-0x9be0(%rbp)
jle    16c0 <main+0x570>
mov    $0x3e0,%eax
mov    %eax,-0x9d94(%rbp)
jmp    16cc <main+0x57c>
mov    -0x9be0(%rbp),%eax
mov    %eax,-0x9d94(%rbp)
mov    -0x9d94(%rbp),%eax
mov    %eax,-0x9be0(%rbp)
mov    -0x9bdc(%rbp),%eax
mov    %eax,-0x9be4(%rbp)
mov    -0x9be4(%rbp),%eax
cmp    -0x9be0(%rbp),%eax
jge    172a <main+0x5da>
movslq -0x9be4(%rbp),%rax
movsd  -0x7c50(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9be4(%rbp),%rax
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
mov    -0x9be4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9be4(%rbp)
jmp    16e4 <main+0x594>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x9bf0(%rbp)
ff
mov    -0x9bd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bf4(%rbp)
cmpl   $0x3e0,-0x9bf4(%rbp)
jge    1788 <main+0x638>
movslq -0x9bf4(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x9bf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x9bf0(%rbp)
ff
mov    -0x9bf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bf4(%rbp)
jmp    1744 <main+0x5f4>
movsd  -0x9bf0(%rbp),%xmm0
ff
movslq -0x9bd4(%rbp),%rax
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
movslq -0x9bd4(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9bd4(%rbp),%eax
add    $0x1,%eax
cltq
subsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
cvtsi2sdl -0x9bd4(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movslq -0x9bd4(%rbp),%rax
movsd  %xmm0,-0x5d40(%rbp,%rax,8)
ff ff
mov    -0x9bd4(%rbp),%eax
mov    %eax,-0x9d98(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    -0x9d98(%rbp),%eax
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    182f <main+0x6df>
movslq -0x9bd4(%rbp),%rax
movsd  -0x5d40(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bd4(%rbp),%rax
addsd  -0x3e30(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3e30(%rbp,%rax,8)
ff ff
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x9bf8(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    $0x3e0,%eax
cltd
idiv   %ecx
mov    %eax,-0x9bfc(%rbp)
mov    -0x9bf8(%rbp),%eax
imul   -0x9bfc(%rbp),%eax
mov    %eax,-0x9c00(%rbp)
mov    -0x9bf8(%rbp),%eax
add    $0x1,%eax
imul   -0x9bfc(%rbp),%eax
mov    %eax,-0x9c04(%rbp)
cmpl   $0x3e0,-0x9c04(%rbp)
jle    189c <main+0x74c>
mov    $0x3e0,%eax
mov    %eax,-0x9d9c(%rbp)
jmp    18a8 <main+0x758>
mov    -0x9c04(%rbp),%eax
mov    %eax,-0x9d9c(%rbp)
mov    -0x9d9c(%rbp),%eax
mov    %eax,-0x9c04(%rbp)
mov    -0x9c00(%rbp),%eax
mov    %eax,-0x9c08(%rbp)
mov    -0x9c08(%rbp),%eax
cmp    -0x9c04(%rbp),%eax
jge    1906 <main+0x7b6>
movslq -0x9c08(%rbp),%rax
movsd  -0x7c50(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c08(%rbp),%rax
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
mov    -0x9c08(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c08(%rbp)
jmp    18c0 <main+0x770>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x9c10(%rbp)
ff
mov    -0x9bf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c14(%rbp)
cmpl   $0x3e0,-0x9c14(%rbp)
jge    1964 <main+0x814>
movslq -0x9c14(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x9c10(%rbp),%xmm0
ff
movsd  %xmm0,-0x9c10(%rbp)
ff
mov    -0x9c14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c14(%rbp)
jmp    1920 <main+0x7d0>
movsd  -0x9c10(%rbp),%xmm0
ff
movslq -0x9bf8(%rbp),%rax
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
movslq -0x9bf8(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9bf8(%rbp),%eax
add    $0x1,%eax
cltq
subsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
cvtsi2sdl -0x9bf8(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movslq -0x9bf8(%rbp),%rax
movsd  %xmm0,-0x5d40(%rbp,%rax,8)
ff ff
mov    -0x9bf8(%rbp),%eax
mov    %eax,-0x9da0(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    -0x9da0(%rbp),%eax
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1a0b <main+0x8bb>
movslq -0x9bf8(%rbp),%rax
movsd  -0x5d40(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bf8(%rbp),%rax
addsd  -0x3e30(%rbp,%rax,8),%xmm0
movsd  %xmm0,-0x3e30(%rbp,%rax,8)
ff ff
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x9c18(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    $0x3e0,%eax
cltd
idiv   %ecx
mov    %eax,-0x9c1c(%rbp)
mov    -0x9c18(%rbp),%eax
imul   -0x9c1c(%rbp),%eax
mov    %eax,-0x9c20(%rbp)
mov    -0x9c18(%rbp),%eax
add    $0x1,%eax
imul   -0x9c1c(%rbp),%eax
mov    %eax,-0x9c24(%rbp)
cmpl   $0x3e0,-0x9c24(%rbp)
jle    1a78 <main+0x928>
mov    $0x3e0,%eax
mov    %eax,-0x9da4(%rbp)
jmp    1a84 <main+0x934>
mov    -0x9c24(%rbp),%eax
mov    %eax,-0x9da4(%rbp)
mov    -0x9da4(%rbp),%eax
mov    %eax,-0x9c24(%rbp)
mov    -0x9c20(%rbp),%eax
mov    %eax,-0x9c28(%rbp)
mov    -0x9c28(%rbp),%eax
cmp    -0x9c24(%rbp),%eax
jge    1ae2 <main+0x992>
movslq -0x9c28(%rbp),%rax
movsd  -0x7c50(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c28(%rbp),%rax
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
mov    -0x9c28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c28(%rbp)
jmp    1a9c <main+0x94c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x9c30(%rbp)
ff
mov    -0x9c18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c34(%rbp)
cmpl   $0x3e0,-0x9c34(%rbp)
jge    1b40 <main+0x9f0>
movslq -0x9c34(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x9c30(%rbp),%xmm0
ff
movsd  %xmm0,-0x9c30(%rbp)
ff
mov    -0x9c34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c34(%rbp)
jmp    1afc <main+0x9ac>
movsd  -0x9c30(%rbp),%xmm0
ff
movslq -0x9c18(%rbp),%rax
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
movslq -0x9c18(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9c18(%rbp),%eax
add    $0x1,%eax
cltq
subsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
cvtsi2sdl -0x9c18(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movslq -0x9c18(%rbp),%rax
movsd  %xmm0,-0x5d40(%rbp,%rax,8)
ff ff
mov    -0x9c18(%rbp),%eax
mov    %eax,-0x9da8(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    -0x9da8(%rbp),%eax
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1be7 <main+0xa97>
movslq -0x9c18(%rbp),%rax
movsd  -0x5d40(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c18(%rbp),%rax
addsd  -0x3e30(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3e30(%rbp,%rax,8)
ff ff
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x9c38(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    $0x3e0,%eax
cltd
idiv   %ecx
mov    %eax,-0x9c3c(%rbp)
mov    -0x9c38(%rbp),%eax
imul   -0x9c3c(%rbp),%eax
mov    %eax,-0x9c40(%rbp)
mov    -0x9c38(%rbp),%eax
add    $0x1,%eax
imul   -0x9c3c(%rbp),%eax
mov    %eax,-0x9c44(%rbp)
cmpl   $0x3e0,-0x9c44(%rbp)
jle    1c54 <main+0xb04>
mov    $0x3e0,%eax
mov    %eax,-0x9dac(%rbp)
jmp    1c60 <main+0xb10>
mov    -0x9c44(%rbp),%eax
mov    %eax,-0x9dac(%rbp)
mov    -0x9dac(%rbp),%eax
mov    %eax,-0x9c44(%rbp)
mov    -0x9c40(%rbp),%eax
mov    %eax,-0x9c48(%rbp)
mov    -0x9c48(%rbp),%eax
cmp    -0x9c44(%rbp),%eax
jge    1cbe <main+0xb6e>
movslq -0x9c48(%rbp),%rax
movsd  -0x7c50(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c48(%rbp),%rax
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
mov    -0x9c48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c48(%rbp)
jmp    1c78 <main+0xb28>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x9c50(%rbp)
ff
mov    -0x9c38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c54(%rbp)
cmpl   $0x3e0,-0x9c54(%rbp)
jge    1d1c <main+0xbcc>
movslq -0x9c54(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x9c50(%rbp),%xmm0
ff
movsd  %xmm0,-0x9c50(%rbp)
ff
mov    -0x9c54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c54(%rbp)
jmp    1cd8 <main+0xb88>
movsd  -0x9c50(%rbp),%xmm0
ff
movslq -0x9c38(%rbp),%rax
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
movslq -0x9c38(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9c38(%rbp),%eax
add    $0x1,%eax
cltq
subsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
cvtsi2sdl -0x9c38(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movslq -0x9c38(%rbp),%rax
movsd  %xmm0,-0x5d40(%rbp,%rax,8)
ff ff
mov    -0x9c38(%rbp),%eax
mov    %eax,-0x9db0(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    -0x9db0(%rbp),%eax
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1dc3 <main+0xc73>
movslq -0x9c38(%rbp),%rax
movsd  -0x5d40(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c38(%rbp),%rax
addsd  -0x3e30(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3e30(%rbp,%rax,8)
ff ff
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x9c58(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    $0x3e0,%eax
cltd
idiv   %ecx
mov    %eax,-0x9c5c(%rbp)
mov    -0x9c58(%rbp),%eax
imul   -0x9c5c(%rbp),%eax
mov    %eax,-0x9c60(%rbp)
mov    -0x9c58(%rbp),%eax
add    $0x1,%eax
imul   -0x9c5c(%rbp),%eax
mov    %eax,-0x9c64(%rbp)
cmpl   $0x3e0,-0x9c64(%rbp)
jle    1e30 <main+0xce0>
mov    $0x3e0,%eax
mov    %eax,-0x9db4(%rbp)
jmp    1e3c <main+0xcec>
mov    -0x9c64(%rbp),%eax
mov    %eax,-0x9db4(%rbp)
mov    -0x9db4(%rbp),%eax
mov    %eax,-0x9c64(%rbp)
mov    -0x9c60(%rbp),%eax
mov    %eax,-0x9c68(%rbp)
mov    -0x9c68(%rbp),%eax
cmp    -0x9c64(%rbp),%eax
jge    1e9a <main+0xd4a>
movslq -0x9c68(%rbp),%rax
movsd  -0x7c50(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c68(%rbp),%rax
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
mov    -0x9c68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c68(%rbp)
jmp    1e54 <main+0xd04>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x9c70(%rbp)
ff
mov    -0x9c58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c74(%rbp)
cmpl   $0x3e0,-0x9c74(%rbp)
jge    1ef8 <main+0xda8>
movslq -0x9c74(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x9c70(%rbp),%xmm0
ff
movsd  %xmm0,-0x9c70(%rbp)
ff
mov    -0x9c74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c74(%rbp)
jmp    1eb4 <main+0xd64>
movsd  -0x9c70(%rbp),%xmm0
ff
movslq -0x9c58(%rbp),%rax
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
movslq -0x9c58(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9c58(%rbp),%eax
add    $0x1,%eax
cltq
subsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
cvtsi2sdl -0x9c58(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movslq -0x9c58(%rbp),%rax
movsd  %xmm0,-0x5d40(%rbp,%rax,8)
ff ff
mov    -0x9c58(%rbp),%eax
mov    %eax,-0x9db8(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    -0x9db8(%rbp),%eax
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1f9f <main+0xe4f>
movslq -0x9c58(%rbp),%rax
movsd  -0x5d40(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c58(%rbp),%rax
addsd  -0x3e30(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3e30(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9c7c(%rbp)
movl   $0x0,-0x9c78(%rbp)
mov    -0x9c78(%rbp),%eax
mov    -0x9bc0(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    206e <main+0xf1e>
movslq -0x9c78(%rbp),%rax
movsd  -0x3e30(%rbp,%rax,8),%xmm0
ff ff
movsd  0x2026(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1ff7 <main+0xea7>
jp     1ff7 <main+0xea7>
jmp    2055 <main+0xf05>
mov    -0x9c78(%rbp),%esi
movslq -0x9c78(%rbp),%rax
movsd  -0x3e30(%rbp,%rax,8),%xmm0
lea    0x1ffc(%rip),%rdi
lea    0x2021(%rip),%rdx
mov    $0x5,%ecx
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x9bc4(%rbp)
mov    -0x9c7c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9c7c(%rbp)
cmp    $0xa,%eax
jle    2050 <main+0xf00>
jmp    206e <main+0xf1e>
jmp    2055 <main+0xf05>
jmp    205a <main+0xf0a>
mov    -0x9c78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c78(%rbp)
jmp    1fb3 <main+0xe63>
jmp    2073 <main+0xf23>
mov    -0x9bcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bcc(%rbp)
jmp    15da <main+0x48a>
cmpl   $0x0,-0x9bc4(%rbp)
je     20a7 <main+0xf57>
lea    0x1fa6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    20b5 <main+0xf65>
lea    0x1f9b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    20ba <main+0xf6a>
mov    -0x9bbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bbc(%rbp)
jmp    15a8 <main+0x458>
movl   $0x0,-0x9c80(%rbp)
mov    -0x9c80(%rbp),%eax
mov    -0x9b74(%rbp),%ecx
sub    -0x9b7c(%rbp),%ecx
cmp    %ecx,%eax
jge    2114 <main+0xfc4>
lea    0x1f50(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x9c80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c80(%rbp)
jmp    20d8 <main+0xf88>
movl   $0x0,-0x9c84(%rbp)
movl   $0x0,-0x9c8c(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9c8c(%rbp)
mov    %al,-0x9db9(%rbp)
jge    214d <main+0xffd>
cmpl   $0x0,-0x9c84(%rbp)
sete   %al
mov    %al,-0x9db9(%rbp)
mov    -0x9db9(%rbp),%al
test   $0x1,%al
jne    2160 <main+0x1010>
jmp    24bb <main+0x136b>
movl   $0x0,-0x9c90(%rbp)
cmpl   $0x3e0,-0x9c90(%rbp)
jge    21a1 <main+0x1051>
movslq -0x9c90(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e30(%rbp,%rax,8)
ff ff
mov    -0x9c90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c90(%rbp)
jmp    216a <main+0x101a>
movl   $0x2,-0x9c94(%rbp)
mov    -0x9c94(%rbp),%eax
cmp    -0x9b7c(%rbp),%eax
jg     23be <main+0x126e>
mov    -0x9c94(%rbp),%eax
mov    %eax,-0x9c98(%rbp)
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x9c9c(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    $0x3e0,%eax
cltd
idiv   %ecx
mov    %eax,-0x9ca0(%rbp)
mov    -0x9c9c(%rbp),%eax
imul   -0x9ca0(%rbp),%eax
mov    %eax,-0x9ca4(%rbp)
mov    -0x9c9c(%rbp),%eax
add    $0x1,%eax
imul   -0x9ca0(%rbp),%eax
mov    %eax,-0x9ca8(%rbp)
cmpl   $0x3e0,-0x9ca8(%rbp)
jle    2236 <main+0x10e6>
mov    $0x3e0,%eax
mov    %eax,-0x9dc0(%rbp)
jmp    2242 <main+0x10f2>
mov    -0x9ca8(%rbp),%eax
mov    %eax,-0x9dc0(%rbp)
mov    -0x9dc0(%rbp),%eax
mov    %eax,-0x9ca8(%rbp)
mov    -0x9ca4(%rbp),%eax
mov    %eax,-0x9cac(%rbp)
mov    -0x9cac(%rbp),%eax
cmp    -0x9ca8(%rbp),%eax
jge    22a0 <main+0x1150>
movslq -0x9cac(%rbp),%rax
movsd  -0x7c50(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9cac(%rbp),%rax
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
mov    -0x9cac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cac(%rbp)
jmp    225a <main+0x110a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x9cb8(%rbp)
ff
mov    -0x9c9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cbc(%rbp)
cmpl   $0x3e0,-0x9cbc(%rbp)
jge    22fe <main+0x11ae>
movslq -0x9cbc(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x9cb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x9cb8(%rbp)
ff
mov    -0x9cbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cbc(%rbp)
jmp    22ba <main+0x116a>
movsd  -0x9cb8(%rbp),%xmm0
ff
movslq -0x9c9c(%rbp),%rax
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
movslq -0x9c9c(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9c9c(%rbp),%eax
add    $0x1,%eax
cltq
subsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
cvtsi2sdl -0x9c9c(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movslq -0x9c9c(%rbp),%rax
movsd  %xmm0,-0x5d40(%rbp,%rax,8)
ff ff
mov    -0x9c9c(%rbp),%eax
mov    %eax,-0x9dc4(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    -0x9dc4(%rbp),%eax
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    23a5 <main+0x1255>
movslq -0x9c9c(%rbp),%rax
movsd  -0x5d40(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c9c(%rbp),%rax
addsd  -0x3e30(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3e30(%rbp,%rax,8)
ff ff
jmp    23aa <main+0x125a>
mov    -0x9c94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c94(%rbp)
jmp    21ab <main+0x105b>
movl   $0x0,-0x9cc4(%rbp)
movl   $0x0,-0x9cc0(%rbp)
mov    -0x9cc0(%rbp),%eax
mov    -0x9b7c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    24a2 <main+0x1352>
movslq -0x9cc0(%rbp),%rax
movsd  -0x3e30(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9b7c(%rbp),%eax
sub    -0x9cc0(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jne    2421 <main+0x12d1>
jp     2421 <main+0x12d1>
jmp    2489 <main+0x1339>
mov    -0x9cc0(%rbp),%esi
mov    -0x9b7c(%rbp),%ecx
sub    -0x9cc0(%rbp),%ecx
sub    $0x1,%ecx
movslq -0x9cc0(%rbp),%rax
movsd  -0x3e30(%rbp,%rax,8),%xmm0
ff ff
lea    0x1bc3(%rip),%rdi
lea    0x1be8(%rip),%rdx
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x9c84(%rbp)
mov    -0x9cc4(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9cc4(%rbp)
cmp    $0xa,%eax
jle    2484 <main+0x1334>
jmp    24a2 <main+0x1352>
jmp    2489 <main+0x1339>
jmp    248e <main+0x133e>
mov    -0x9cc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cc0(%rbp)
jmp    23d2 <main+0x1282>
jmp    24a7 <main+0x1357>
mov    -0x9c8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c8c(%rbp)
jmp    2128 <main+0xfd8>
cmpl   $0x0,-0x9c84(%rbp)
je     24db <main+0x138b>
lea    0x1b72(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    24e9 <main+0x1399>
lea    0x1b67(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x9cc8(%rbp)
movl   $0x0,-0x9cd0(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9cd0(%rbp)
mov    %al,-0x9dc5(%rbp)
jge    2522 <main+0x13d2>
cmpl   $0x0,-0x9cc8(%rbp)
sete   %al
mov    %al,-0x9dc5(%rbp)
mov    -0x9dc5(%rbp),%al
test   $0x1,%al
jne    2535 <main+0x13e5>
jmp    2830 <main+0x16e0>
movl   $0x0,-0x9cd4(%rbp)
cmpl   $0x3e0,-0x9cd4(%rbp)
jge    2576 <main+0x1426>
movslq -0x9cd4(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e30(%rbp,%rax,8)
ff ff
mov    -0x9cd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cd4(%rbp)
jmp    253f <main+0x13ef>
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x9cd8(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    $0x3e0,%eax
cltd
idiv   %ecx
mov    %eax,-0x9cdc(%rbp)
mov    -0x9cd8(%rbp),%eax
imul   -0x9cdc(%rbp),%eax
mov    %eax,-0x9ce0(%rbp)
mov    -0x9cd8(%rbp),%eax
add    $0x1,%eax
imul   -0x9cdc(%rbp),%eax
mov    %eax,-0x9ce4(%rbp)
cmpl   $0x3e0,-0x9ce4(%rbp)
jle    25e3 <main+0x1493>
mov    $0x3e0,%eax
mov    %eax,-0x9dcc(%rbp)
jmp    25ef <main+0x149f>
mov    -0x9ce4(%rbp),%eax
mov    %eax,-0x9dcc(%rbp)
mov    -0x9dcc(%rbp),%eax
mov    %eax,-0x9ce4(%rbp)
mov    -0x9ce0(%rbp),%eax
mov    %eax,-0x9ce8(%rbp)
mov    -0x9ce8(%rbp),%eax
cmp    -0x9ce4(%rbp),%eax
jge    264d <main+0x14fd>
movslq -0x9ce8(%rbp),%rax
movsd  -0x7c50(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9ce8(%rbp),%rax
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
mov    -0x9ce8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ce8(%rbp)
jmp    2607 <main+0x14b7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x9cf0(%rbp)
ff
mov    -0x9cd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cf4(%rbp)
cmpl   $0x3e0,-0x9cf4(%rbp)
jge    26ab <main+0x155b>
movslq -0x9cf4(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x9cf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x9cf0(%rbp)
ff
mov    -0x9cf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cf4(%rbp)
jmp    2667 <main+0x1517>
movsd  -0x9cf0(%rbp),%xmm0
ff
movslq -0x9cd8(%rbp),%rax
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
movslq -0x9cd8(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9cd8(%rbp),%eax
add    $0x1,%eax
cltq
subsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
cvtsi2sdl -0x9cd8(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movslq -0x9cd8(%rbp),%rax
movsd  %xmm0,-0x5d40(%rbp,%rax,8)
ff ff
mov    -0x9cd8(%rbp),%eax
mov    %eax,-0x9dd0(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    -0x9dd0(%rbp),%eax
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    2752 <main+0x1602>
movslq -0x9cd8(%rbp),%rax
movsd  -0x5d40(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9cd8(%rbp),%rax
addsd  -0x3e30(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3e30(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9cfc(%rbp)
movl   $0x0,-0x9cf8(%rbp)
cmpl   $0x1,-0x9cf8(%rbp)
jge    2817 <main+0x16c7>
movslq -0x9cf8(%rbp),%rax
movsd  -0x5d40(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1875(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    27a0 <main+0x1650>
jp     27a0 <main+0x1650>
jmp    27fe <main+0x16ae>
mov    -0x9cf8(%rbp),%esi
movslq -0x9cf8(%rbp),%rax
movsd  -0x5d40(%rbp,%rax,8),%xmm0
ff ff
lea    0x1853(%rip),%rdi
lea    0x1890(%rip),%rdx
mov    $0x7800f,%ecx
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x9cc8(%rbp)
mov    -0x9cfc(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9cfc(%rbp)
cmp    $0xa,%eax
jle    27f9 <main+0x16a9>
jmp    2817 <main+0x16c7>
jmp    27fe <main+0x16ae>
jmp    2803 <main+0x16b3>
mov    -0x9cf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cf8(%rbp)
jmp    2766 <main+0x1616>
jmp    281c <main+0x16cc>
mov    -0x9cd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cd0(%rbp)
jmp    24fd <main+0x13ad>
cmpl   $0x0,-0x9cc8(%rbp)
je     2850 <main+0x1700>
lea    0x17fd(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    285e <main+0x170e>
lea    0x17f2(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x2,-0x9d00(%rbp)
mov    -0x9d00(%rbp),%eax
cmp    -0x9b7c(%rbp),%eax
jg     2c2d <main+0x1add>
movl   $0x0,-0x9d04(%rbp)
cmpl   $0x3e0,-0x9d04(%rbp)
jge    28bb <main+0x176b>
movslq -0x9d04(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e30(%rbp,%rax,8)
ff ff
mov    -0x9d04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d04(%rbp)
jmp    2884 <main+0x1734>
mov    -0x9d00(%rbp),%eax
mov    %eax,-0x9d08(%rbp)
movl   $0x0,-0x9d0c(%rbp)
movl   $0x0,-0x9d14(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9d14(%rbp)
mov    %al,-0x9dd1(%rbp)
jge    2900 <main+0x17b0>
cmpl   $0x0,-0x9d0c(%rbp)
sete   %al
mov    %al,-0x9dd1(%rbp)
mov    -0x9dd1(%rbp),%al
test   $0x1,%al
jne    2913 <main+0x17c3>
jmp    2be6 <main+0x1a96>
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x9d18(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    $0x3e0,%eax
cltd
idiv   %ecx
mov    %eax,-0x9d1c(%rbp)
mov    -0x9d18(%rbp),%eax
imul   -0x9d1c(%rbp),%eax
mov    %eax,-0x9d20(%rbp)
mov    -0x9d18(%rbp),%eax
add    $0x1,%eax
imul   -0x9d1c(%rbp),%eax
mov    %eax,-0x9d24(%rbp)
cmpl   $0x3e0,-0x9d24(%rbp)
jle    2980 <main+0x1830>
mov    $0x3e0,%eax
mov    %eax,-0x9dd8(%rbp)
jmp    298c <main+0x183c>
mov    -0x9d24(%rbp),%eax
mov    %eax,-0x9dd8(%rbp)
mov    -0x9dd8(%rbp),%eax
mov    %eax,-0x9d24(%rbp)
mov    -0x9d20(%rbp),%eax
mov    %eax,-0x9d28(%rbp)
mov    -0x9d28(%rbp),%eax
cmp    -0x9d24(%rbp),%eax
jge    29ea <main+0x189a>
movslq -0x9d28(%rbp),%rax
movsd  -0x7c50(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9d28(%rbp),%rax
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
mov    -0x9d28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d28(%rbp)
jmp    29a4 <main+0x1854>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x9d30(%rbp)
ff
mov    -0x9d18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d34(%rbp)
cmpl   $0x3e0,-0x9d34(%rbp)
jge    2a48 <main+0x18f8>
movslq -0x9d34(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x9d30(%rbp),%xmm0
ff
movsd  %xmm0,-0x9d30(%rbp)
ff
mov    -0x9d34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d34(%rbp)
jmp    2a04 <main+0x18b4>
movsd  -0x9d30(%rbp),%xmm0
ff
movslq -0x9d18(%rbp),%rax
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
movslq -0x9d18(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9d18(%rbp),%eax
add    $0x1,%eax
cltq
subsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
cvtsi2sdl -0x9d18(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movslq -0x9d18(%rbp),%rax
movsd  %xmm0,-0x5d40(%rbp,%rax,8)
ff ff
mov    -0x9d18(%rbp),%eax
mov    %eax,-0x9ddc(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    -0x9ddc(%rbp),%eax
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    2aef <main+0x199f>
movslq -0x9d18(%rbp),%rax
movsd  -0x5d40(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9d18(%rbp),%rax
addsd  -0x3e30(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3e30(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9d3c(%rbp)
movl   $0x0,-0x9d38(%rbp)
mov    -0x9d38(%rbp),%eax
mov    -0x9d00(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    2bcd <main+0x1a7d>
movslq -0x9d38(%rbp),%rax
movsd  -0x3e30(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9d14(%rbp),%eax
add    $0x1,%eax
shl    $0x0,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jne    2b4f <main+0x19ff>
jp     2b4f <main+0x19ff>
jmp    2bb4 <main+0x1a64>
mov    -0x9d38(%rbp),%esi
mov    -0x9d14(%rbp),%ecx
add    $0x1,%ecx
shl    $0x0,%ecx
movslq -0x9d38(%rbp),%rax
movsd  -0x3e30(%rbp,%rax,8),%xmm0
ff ff
lea    0x1498(%rip),%rdi
lea    0x14bd(%rip),%rdx
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x9d0c(%rbp)
mov    -0x9d3c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9d3c(%rbp)
cmp    $0xa,%eax
jle    2baf <main+0x1a5f>
jmp    2bcd <main+0x1a7d>
jmp    2bb4 <main+0x1a64>
jmp    2bb9 <main+0x1a69>
mov    -0x9d38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d38(%rbp)
jmp    2b03 <main+0x19b3>
jmp    2bd2 <main+0x1a82>
mov    -0x9d14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d14(%rbp)
jmp    28db <main+0x178b>
cmpl   $0x0,-0x9d0c(%rbp)
je     2c06 <main+0x1ab6>
lea    0x1447(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    2c14 <main+0x1ac4>
lea    0x143c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    2c19 <main+0x1ac9>
mov    -0x9d00(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d00(%rbp)
jmp    2868 <main+0x1718>
movl   $0x0,-0x9d40(%rbp)
mov    -0x9d40(%rbp),%eax
mov    -0x9b74(%rbp),%ecx
sub    -0x9b7c(%rbp),%ecx
cmp    %ecx,%eax
jge    2c73 <main+0x1b23>
lea    0x13f1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x9d40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d40(%rbp)
jmp    2c37 <main+0x1ae7>
cmpq   $0x0,-0x9b70(%rbp)
jne    30df <main+0x1f8f>
movl   $0x0,-0x9d44(%rbp)
cmpl   $0x3e0,-0x9d44(%rbp)
jge    2cc2 <main+0x1b72>
movslq -0x9d44(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e30(%rbp,%rax,8)
ff ff
mov    -0x9d44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d44(%rbp)
jmp    2c8b <main+0x1b3b>
movl   $0x0,-0x9d48(%rbp)
movl   $0x0,-0x9d50(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9d50(%rbp)
mov    %al,-0x9ddd(%rbp)
jge    2cfb <main+0x1bab>
cmpl   $0x0,-0x9d48(%rbp)
sete   %al
mov    %al,-0x9ddd(%rbp)
mov    -0x9ddd(%rbp),%al
test   $0x1,%al
jne    2d0e <main+0x1bbe>
jmp    30ac <main+0x1f5c>
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
shl    $0x4,%eax
mov    %eax,-0x9d54(%rbp)
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x9d58(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    $0x3e0,%eax
cltd
idiv   %ecx
mov    %eax,-0x9d5c(%rbp)
mov    -0x9d58(%rbp),%eax
imul   -0x9d5c(%rbp),%eax
mov    %eax,-0x9d60(%rbp)
mov    -0x9d58(%rbp),%eax
add    $0x1,%eax
imul   -0x9d5c(%rbp),%eax
mov    %eax,-0x9d64(%rbp)
cmpl   $0x3e0,-0x9d64(%rbp)
jle    2d8b <main+0x1c3b>
mov    $0x3e0,%eax
mov    %eax,-0x9de4(%rbp)
jmp    2d97 <main+0x1c47>
mov    -0x9d64(%rbp),%eax
mov    %eax,-0x9de4(%rbp)
mov    -0x9de4(%rbp),%eax
mov    %eax,-0x9d64(%rbp)
mov    -0x9d60(%rbp),%eax
mov    %eax,-0x9d68(%rbp)
mov    -0x9d68(%rbp),%eax
cmp    -0x9d64(%rbp),%eax
jge    2df5 <main+0x1ca5>
movslq -0x9d68(%rbp),%rax
movsd  -0x7c50(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9d68(%rbp),%rax
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
mov    -0x9d68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d68(%rbp)
jmp    2daf <main+0x1c5f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x9d70(%rbp)
ff
mov    -0x9d58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d74(%rbp)
cmpl   $0x3e0,-0x9d74(%rbp)
jge    2e53 <main+0x1d03>
movslq -0x9d74(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x9d70(%rbp),%xmm0
ff
movsd  %xmm0,-0x9d70(%rbp)
ff
mov    -0x9d74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d74(%rbp)
jmp    2e0f <main+0x1cbf>
movsd  -0x9d70(%rbp),%xmm0
ff
movslq -0x9d58(%rbp),%rax
movsd  %xmm0,-0x1f20(%rbp,%rax,8)
ff ff
movslq -0x9d58(%rbp),%rax
movsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9d58(%rbp),%eax
add    $0x1,%eax
cltq
subsd  -0x1f20(%rbp,%rax,8),%xmm0
ff ff
cvtsi2sdl -0x9d58(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movslq -0x9d58(%rbp),%rax
movsd  %xmm0,-0x5d40(%rbp,%rax,8)
ff ff
mov    -0x9d58(%rbp),%eax
mov    %eax,-0x9de8(%rbp)
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    -0x9de8(%rbp),%eax
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    2f06 <main+0x1db6>
movslq -0x9d58(%rbp),%rax
movsd  -0x5d40(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9d54(%rbp),%eax
add    -0x9d58(%rbp),%eax
cltq
addsd  -0x3e30(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3e30(%rbp,%rax,8)
ff ff
jmp    2f20 <main+0x1dd0>
mov    -0x9d54(%rbp),%eax
add    -0x9d58(%rbp),%eax
cltq
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e30(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9d7c(%rbp)
movl   $0x0,-0x9d78(%rbp)
cmpl   $0x100,-0x9d78(%rbp)
jge    3093 <main+0x1f43>
movslq -0x9d78(%rbp),%rax
movsd  -0x3e30(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x9df0(%rbp)
ff
cmpl   $0x0,-0x9d78(%rbp)
jle    2f90 <main+0x1e40>
mov    -0x9d78(%rbp),%eax
add    $0x1,%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    2f90 <main+0x1e40>
xor    %eax,%eax
mov    %eax,-0x9df4(%rbp)
jmp    2fa2 <main+0x1e52>
mov    -0x9d50(%rbp),%eax
add    $0x1,%eax
shl    $0x0,%eax
mov    %eax,-0x9df4(%rbp)
movsd  -0x9df0(%rbp),%xmm0
ff
mov    -0x9df4(%rbp),%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jne    2fc9 <main+0x1e79>
jp     2fc9 <main+0x1e79>
jmp    307a <main+0x1f2a>
mov    -0x9d78(%rbp),%eax
mov    %eax,-0x9df8(%rbp)
cmpl   $0x0,-0x9d78(%rbp)
jle    3009 <main+0x1eb9>
mov    -0x9d78(%rbp),%eax
add    $0x1,%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    3009 <main+0x1eb9>
xor    %eax,%eax
mov    %eax,-0x9dfc(%rbp)
jmp    301b <main+0x1ecb>
mov    -0x9d50(%rbp),%eax
add    $0x1,%eax
shl    $0x0,%eax
mov    %eax,-0x9dfc(%rbp)
mov    -0x9df8(%rbp),%esi
mov    -0x9dfc(%rbp),%ecx
movslq -0x9d78(%rbp),%rax
movsd  -0x3e30(%rbp,%rax,8),%xmm0
ff ff
lea    0xfd2(%rip),%rdi
lea    0xff7(%rip),%rdx
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x1,-0x9d48(%rbp)
mov    -0x9d7c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9d7c(%rbp)
cmp    $0xa,%eax
jle    3075 <main+0x1f25>
jmp    3093 <main+0x1f43>
jmp    307a <main+0x1f2a>
jmp    307f <main+0x1f2f>
mov    -0x9d78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d78(%rbp)
jmp    2f34 <main+0x1de4>
jmp    3098 <main+0x1f48>
mov    -0x9d50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d50(%rbp)
jmp    2cd6 <main+0x1b86>
cmpl   $0x0,-0x9d48(%rbp)
je     30cc <main+0x1f7c>
lea    0xf81(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    30da <main+0x1f8a>
lea    0xf76(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    311d <main+0x1fcd>
movl   $0x0,-0x9d80(%rbp)
cmpl   $0x1,-0x9d80(%rbp)
jge    3118 <main+0x1fc8>
lea    0xf4c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x9d80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d80(%rbp)
jmp    30e9 <main+0x1f99>
jmp    311d <main+0x1fcd>
mov    -0x4(%rbp),%eax
add    $0x9e00,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x7c68,%rsp
xor    %eax,%eax
call   1090 <check_offloading@plt>
lea    0x5d50(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
movdqa 0x1e4c(%rip),%xmm0
mov    $0x6,%eax
movdqa 0x1e4f(%rip),%xmm1
movdqa 0x1e57(%rip),%xmm2
movdqa 0x1e5f(%rip),%xmm3
movdqa 0x1e67(%rip),%xmm4
nopl   0x0(%rax)
movdqa %xmm0,%xmm5
cvtdq2pd %xmm0,%xmm6
paddd  %xmm1,%xmm5
cvtdq2pd %xmm5,%xmm5
movaps %xmm6,0x3e10(%rsp,%rax,8)
movaps %xmm5,0x3e20(%rsp,%rax,8)
movdqa %xmm0,%xmm5
paddd  %xmm2,%xmm5
movdqa %xmm0,%xmm6
cvtdq2pd %xmm5,%xmm5
paddd  %xmm3,%xmm6
cvtdq2pd %xmm6,%xmm6
movaps %xmm5,0x3e30(%rsp,%rax,8)
movaps %xmm6,0x3e40(%rsp,%rax,8)
paddd  %xmm4,%xmm0
add    $0x8,%rax
cmp    $0x3e6,%rax
jne    11e0 <main+0x60>
xor    %eax,%eax
call   10a0 <omp_is_initial_device@plt>
mov    %rax,%r14
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    $0x3e0,%esi
mov    $0x3e0,%eax
xor    %edx,%edx
idiv   %ecx
mov    %eax,%ecx
imul   %ebx,%ecx
lea    0x1(%rbx),%ebp
imul   %ebp,%eax
cmp    $0x3e0,%eax
cmovge %esi,%eax
cmp    %eax,%ecx
jge    12a0 <main+0x120>
movslq %ecx,%rdx
lea    (%rsp,%rdx,8),%rdi
add    $0x20,%rdi
lea    (%rsp,%rdx,8),%rsi
add    $0x3e40,%rsi
not    %ecx
add    %ecx,%eax
lea    0x8(,%rax,8),%rdx
call   1080 <memcpy@plt>
cmp    $0x3df,%ebx
jge    13be <main+0x23e>
movslq %ebx,%rax
lea    0x1(%rax),%rdx
mov    $0x7,%esi
sub    %ebx,%esi
mov    $0x3de,%ecx
sub    %ebx,%ecx
pxor   %xmm0,%xmm0
and    $0x7,%esi
je     12df <main+0x15f>
nopw   0x0(%rax,%rax,1)
addsd  0x20(%rsp,%rdx,8),%xmm0
add    $0x1,%rdx
add    $0xffffffff,%esi
jne    12d0 <main+0x150>
cmp    $0x7,%ecx
jb     132c <main+0x1ac>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
addsd  0x20(%rsp,%rdx,8),%xmm0
addsd  0x28(%rsp,%rdx,8),%xmm0
addsd  0x30(%rsp,%rdx,8),%xmm0
addsd  0x38(%rsp,%rdx,8),%xmm0
addsd  0x40(%rsp,%rdx,8),%xmm0
addsd  0x48(%rsp,%rdx,8),%xmm0
addsd  0x50(%rsp,%rdx,8),%xmm0
addsd  0x58(%rsp,%rdx,8),%xmm0
add    $0x8,%rdx
cmp    $0x3e0,%edx
jne    12f0 <main+0x170>
movsd  %xmm0,0x20(%rsp,%rax,8)
pxor   %xmm1,%xmm1
cmp    $0x3dd,%ebx
jg     13d1 <main+0x251>
lea    0x2(%rbx),%edx
movslq %edx,%rdx
pxor   %xmm1,%xmm1
and    $0x7,%ecx
je     136f <main+0x1ef>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addsd  0x20(%rsp,%rdx,8),%xmm1
add    $0x1,%rdx
add    $0xffffffff,%ecx
jne    1360 <main+0x1e0>
add    $0xfffffc29,%ebx
cmp    $0x7,%ebx
jb     13d1 <main+0x251>
nopw   0x0(%rax,%rax,1)
addsd  0x20(%rsp,%rdx,8),%xmm1
addsd  0x28(%rsp,%rdx,8),%xmm1
addsd  0x30(%rsp,%rdx,8),%xmm1
addsd  0x38(%rsp,%rdx,8),%xmm1
addsd  0x40(%rsp,%rdx,8),%xmm1
addsd  0x48(%rsp,%rdx,8),%xmm1
addsd  0x50(%rsp,%rdx,8),%xmm1
addsd  0x58(%rsp,%rdx,8),%xmm1
add    $0x8,%rdx
cmp    $0x3e0,%edx
jne    1380 <main+0x200>
jmp    13d1 <main+0x251>
mov    %ebx,%eax
movq   $0x0,0x20(%rsp,%rax,8)
pxor   %xmm0,%xmm0
pxor   %xmm1,%xmm1
movslq %ebp,%rcx
movq   %xmm1,0x20(%rsp,%rcx,8)
subsd  %xmm1,%xmm0
movsd  %xmm0,0x1f30(%rsp,%rax,8)
movsd  0x1f30(%rsp),%xmm0
lea    0x1caf(%rip),%rdi
ucomisd 0x1c51(%rip),%xmm0
jne    1403 <main+0x283>
jnp    1426 <main+0x2a6>
lea    0x1c66(%rip),%rdi
lea    0x1c8b(%rip),%rdx
xor    %esi,%esi
mov    $0x1,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
lea    0x1c8a(%rip),%rdi
mov    %r14,0x18(%rsp)
test   %r14,%r14
mov    $0x300,%eax
mov    $0x20,%ecx
cmove  %eax,%ecx
mov    %rcx,0x8(%rsp)
call   1030 <puts@plt>
mov    $0x1,%r13d
lea    0x1c4a(%rip),%r12
xor    %r14d,%r14d
jmp    147f <main+0x2ff>
nopw   0x0(%rax,%rax,1)
lea    0x1c3f(%rip),%rdi
call   1030 <puts@plt>
add    $0x1,%r13d
add    $0x1,%r14
cmp    0x8(%rsp),%r14
je     1b60 <main+0x9e0>
mov    $0x1f00,%edx
lea    0x1f30(%rsp),%rdi
xor    %esi,%esi
call   1060 <memset@plt>
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    $0x3e0,%eax
xor    %edx,%edx
idiv   %ecx
mov    %eax,%ecx
imul   %ebp,%ecx
lea    0x1(%rbp),%r15d
imul   %r15d,%eax
cmp    $0x3e0,%eax
mov    $0x3e0,%edx
cmovge %edx,%eax
cmp    %eax,%ecx
jge    14f3 <main+0x373>
movslq %ecx,%rdx
lea    (%rsp,%rdx,8),%rdi
add    $0x20,%rdi
lea    (%rsp,%rdx,8),%rsi
add    $0x3e40,%rsi
not    %ecx
add    %ecx,%eax
lea    0x8(,%rax,8),%rdx
call   1080 <memcpy@plt>
cmp    $0x3df,%ebp
jge    1580 <main+0x400>
movslq %ebp,%rbx
lea    0x1(%rbx),%rax
mov    $0x7,%ecx
sub    %ebp,%ecx
xorpd  %xmm1,%xmm1
and    $0x7,%ecx
je     152f <main+0x3af>
cs nopw 0x0(%rax,%rax,1)
addsd  0x20(%rsp,%rax,8),%xmm1
add    $0x1,%rax
add    $0xffffffff,%ecx
jne    1520 <main+0x3a0>
lea    -0x3d8(%rbp),%ecx
cmp    $0x7,%ecx
jb     1586 <main+0x406>
nopw   0x0(%rax,%rax,1)
addsd  0x20(%rsp,%rax,8),%xmm1
addsd  0x28(%rsp,%rax,8),%xmm1
addsd  0x30(%rsp,%rax,8),%xmm1
addsd  0x38(%rsp,%rax,8),%xmm1
addsd  0x40(%rsp,%rax,8),%xmm1
addsd  0x48(%rsp,%rax,8),%xmm1
addsd  0x50(%rsp,%rax,8),%xmm1
addsd  0x58(%rsp,%rax,8),%xmm1
add    $0x8,%rax
cmp    $0x3e0,%eax
jne    1540 <main+0x3c0>
jmp    1586 <main+0x406>
nopl   (%rax)
mov    %ebp,%ebx
xorpd  %xmm1,%xmm1
movsd  %xmm1,0x20(%rsp,%rbx,8)
movslq %r15d,%rax
subsd  0x20(%rsp,%rax,8),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
movsd  %xmm1,0x5d50(%rsp,%rbx,8)
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
add    $0xffffffff,%eax
cmp    %eax,%ebp
jge    15d3 <main+0x453>
movsd  (%rsp),%xmm0
addsd  0x1f30(%rsp,%rbx,8),%xmm0
movsd  %xmm0,0x1f30(%rsp,%rbx,8)
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    $0x3e0,%eax
xor    %edx,%edx
idiv   %ecx
mov    %eax,%ecx
imul   %ebp,%ecx
lea    0x1(%rbp),%r15d
imul   %r15d,%eax
cmp    $0x3e0,%eax
mov    $0x3e0,%edx
cmovge %edx,%eax
cmp    %eax,%ecx
jge    1633 <main+0x4b3>
movslq %ecx,%rdx
lea    (%rsp,%rdx,8),%rdi
add    $0x20,%rdi
lea    (%rsp,%rdx,8),%rsi
add    $0x3e40,%rsi
not    %ecx
add    %ecx,%eax
lea    0x8(,%rax,8),%rdx
call   1080 <memcpy@plt>
cmp    $0x3df,%ebp
jge    16c0 <main+0x540>
movslq %ebp,%rbx
lea    0x1(%rbx),%rax
mov    $0x7,%ecx
sub    %ebp,%ecx
xorpd  %xmm1,%xmm1
and    $0x7,%ecx
je     166f <main+0x4ef>
cs nopw 0x0(%rax,%rax,1)
addsd  0x20(%rsp,%rax,8),%xmm1
add    $0x1,%rax
add    $0xffffffff,%ecx
jne    1660 <main+0x4e0>
lea    -0x3d8(%rbp),%ecx
cmp    $0x7,%ecx
jb     16c6 <main+0x546>
nopw   0x0(%rax,%rax,1)
addsd  0x20(%rsp,%rax,8),%xmm1
addsd  0x28(%rsp,%rax,8),%xmm1
addsd  0x30(%rsp,%rax,8),%xmm1
addsd  0x38(%rsp,%rax,8),%xmm1
addsd  0x40(%rsp,%rax,8),%xmm1
addsd  0x48(%rsp,%rax,8),%xmm1
addsd  0x50(%rsp,%rax,8),%xmm1
addsd  0x58(%rsp,%rax,8),%xmm1
add    $0x8,%rax
cmp    $0x3e0,%eax
jne    1680 <main+0x500>
jmp    16c6 <main+0x546>
nopl   (%rax)
mov    %ebp,%ebx
xorpd  %xmm1,%xmm1
movsd  %xmm1,0x20(%rsp,%rbx,8)
movslq %r15d,%rax
subsd  0x20(%rsp,%rax,8),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
movsd  %xmm1,0x5d50(%rsp,%rbx,8)
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
add    $0xffffffff,%eax
cmp    %eax,%ebp
jge    1713 <main+0x593>
movsd  (%rsp),%xmm0
addsd  0x1f30(%rsp,%rbx,8),%xmm0
movsd  %xmm0,0x1f30(%rsp,%rbx,8)
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    $0x3e0,%eax
xor    %edx,%edx
idiv   %ecx
mov    %eax,%ecx
imul   %ebp,%ecx
lea    0x1(%rbp),%r15d
imul   %r15d,%eax
cmp    $0x3e0,%eax
mov    $0x3e0,%edx
cmovge %edx,%eax
cmp    %eax,%ecx
jge    1773 <main+0x5f3>
movslq %ecx,%rdx
lea    (%rsp,%rdx,8),%rdi
add    $0x20,%rdi
lea    (%rsp,%rdx,8),%rsi
add    $0x3e40,%rsi
not    %ecx
add    %ecx,%eax
lea    0x8(,%rax,8),%rdx
call   1080 <memcpy@plt>
cmp    $0x3df,%ebp
jge    1800 <main+0x680>
movslq %ebp,%rbx
lea    0x1(%rbx),%rax
mov    $0x7,%ecx
sub    %ebp,%ecx
xorpd  %xmm1,%xmm1
and    $0x7,%ecx
je     17af <main+0x62f>
cs nopw 0x0(%rax,%rax,1)
addsd  0x20(%rsp,%rax,8),%xmm1
add    $0x1,%rax
add    $0xffffffff,%ecx
jne    17a0 <main+0x620>
lea    -0x3d8(%rbp),%ecx
cmp    $0x7,%ecx
jb     1806 <main+0x686>
nopw   0x0(%rax,%rax,1)
addsd  0x20(%rsp,%rax,8),%xmm1
addsd  0x28(%rsp,%rax,8),%xmm1
addsd  0x30(%rsp,%rax,8),%xmm1
addsd  0x38(%rsp,%rax,8),%xmm1
addsd  0x40(%rsp,%rax,8),%xmm1
addsd  0x48(%rsp,%rax,8),%xmm1
addsd  0x50(%rsp,%rax,8),%xmm1
addsd  0x58(%rsp,%rax,8),%xmm1
add    $0x8,%rax
cmp    $0x3e0,%eax
jne    17c0 <main+0x640>
jmp    1806 <main+0x686>
nopl   (%rax)
mov    %ebp,%ebx
xorpd  %xmm1,%xmm1
movsd  %xmm1,0x20(%rsp,%rbx,8)
movslq %r15d,%rax
subsd  0x20(%rsp,%rax,8),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
movsd  %xmm1,0x5d50(%rsp,%rbx,8)
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
add    $0xffffffff,%eax
cmp    %eax,%ebp
jge    1853 <main+0x6d3>
movsd  (%rsp),%xmm0
addsd  0x1f30(%rsp,%rbx,8),%xmm0
movsd  %xmm0,0x1f30(%rsp,%rbx,8)
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    $0x3e0,%eax
xor    %edx,%edx
idiv   %ecx
mov    %eax,%ecx
imul   %ebp,%ecx
lea    0x1(%rbp),%r15d
imul   %r15d,%eax
cmp    $0x3e0,%eax
mov    $0x3e0,%edx
cmovge %edx,%eax
cmp    %eax,%ecx
jge    18b3 <main+0x733>
movslq %ecx,%rdx
lea    (%rsp,%rdx,8),%rdi
add    $0x20,%rdi
lea    (%rsp,%rdx,8),%rsi
add    $0x3e40,%rsi
not    %ecx
add    %ecx,%eax
lea    0x8(,%rax,8),%rdx
call   1080 <memcpy@plt>
cmp    $0x3df,%ebp
jge    1940 <main+0x7c0>
movslq %ebp,%rbx
lea    0x1(%rbx),%rax
mov    $0x7,%ecx
sub    %ebp,%ecx
xorpd  %xmm1,%xmm1
and    $0x7,%ecx
je     18ef <main+0x76f>
cs nopw 0x0(%rax,%rax,1)
addsd  0x20(%rsp,%rax,8),%xmm1
add    $0x1,%rax
add    $0xffffffff,%ecx
jne    18e0 <main+0x760>
lea    -0x3d8(%rbp),%ecx
cmp    $0x7,%ecx
jb     1946 <main+0x7c6>
nopw   0x0(%rax,%rax,1)
addsd  0x20(%rsp,%rax,8),%xmm1
addsd  0x28(%rsp,%rax,8),%xmm1
addsd  0x30(%rsp,%rax,8),%xmm1
addsd  0x38(%rsp,%rax,8),%xmm1
addsd  0x40(%rsp,%rax,8),%xmm1
addsd  0x48(%rsp,%rax,8),%xmm1
addsd  0x50(%rsp,%rax,8),%xmm1
addsd  0x58(%rsp,%rax,8),%xmm1
add    $0x8,%rax
cmp    $0x3e0,%eax
jne    1900 <main+0x780>
jmp    1946 <main+0x7c6>
nopl   (%rax)
mov    %ebp,%ebx
xorpd  %xmm1,%xmm1
movsd  %xmm1,0x20(%rsp,%rbx,8)
movslq %r15d,%rax
subsd  0x20(%rsp,%rax,8),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
movsd  %xmm1,0x5d50(%rsp,%rbx,8)
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
add    $0xffffffff,%eax
cmp    %eax,%ebp
jge    1993 <main+0x813>
movsd  (%rsp),%xmm0
addsd  0x1f30(%rsp,%rbx,8),%xmm0
movsd  %xmm0,0x1f30(%rsp,%rbx,8)
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    $0x3e0,%eax
xor    %edx,%edx
idiv   %ecx
mov    %eax,%ecx
imul   %ebp,%ecx
lea    0x1(%rbp),%r15d
imul   %r15d,%eax
cmp    $0x3e0,%eax
mov    $0x3e0,%edx
cmovge %edx,%eax
cmp    %eax,%ecx
jge    19f3 <main+0x873>
movslq %ecx,%rdx
lea    (%rsp,%rdx,8),%rdi
add    $0x20,%rdi
lea    (%rsp,%rdx,8),%rsi
add    $0x3e40,%rsi
not    %ecx
add    %ecx,%eax
lea    0x8(,%rax,8),%rdx
call   1080 <memcpy@plt>
cmp    $0x3df,%ebp
jge    1a80 <main+0x900>
movslq %ebp,%rbx
lea    0x1(%rbx),%rax
mov    $0x7,%ecx
sub    %ebp,%ecx
xorpd  %xmm1,%xmm1
and    $0x7,%ecx
je     1a2f <main+0x8af>
cs nopw 0x0(%rax,%rax,1)
addsd  0x20(%rsp,%rax,8),%xmm1
add    $0x1,%rax
add    $0xffffffff,%ecx
jne    1a20 <main+0x8a0>
lea    -0x3d8(%rbp),%ecx
cmp    $0x7,%ecx
jb     1a86 <main+0x906>
nopw   0x0(%rax,%rax,1)
addsd  0x20(%rsp,%rax,8),%xmm1
addsd  0x28(%rsp,%rax,8),%xmm1
addsd  0x30(%rsp,%rax,8),%xmm1
addsd  0x38(%rsp,%rax,8),%xmm1
addsd  0x40(%rsp,%rax,8),%xmm1
addsd  0x48(%rsp,%rax,8),%xmm1
addsd  0x50(%rsp,%rax,8),%xmm1
addsd  0x58(%rsp,%rax,8),%xmm1
add    $0x8,%rax
cmp    $0x3e0,%eax
jne    1a40 <main+0x8c0>
jmp    1a86 <main+0x906>
nopl   (%rax)
mov    %ebp,%ebx
xorpd  %xmm1,%xmm1
movsd  %xmm1,0x20(%rsp,%rbx,8)
movslq %r15d,%rax
subsd  0x20(%rsp,%rax,8),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
movsd  %xmm1,0x5d50(%rsp,%rbx,8)
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
add    $0xffffffff,%eax
cmp    %eax,%ebp
jge    1ad3 <main+0x953>
movsd  (%rsp),%xmm0
addsd  0x1f30(%rsp,%rbx,8),%xmm0
movsd  %xmm0,0x1f30(%rsp,%rbx,8)
cmp    $0x2,%r13d
lea    0x1592(%rip),%r15
jb     1460 <main+0x2e0>
xor    %ebp,%ebp
xor    %eax,%eax
xor    %ebx,%ebx
jmp    1af9 <main+0x979>
nopl   0x0(%rax)
add    $0x1,%rbp
cmp    %rbp,%r14
je     1b40 <main+0x9c0>
movsd  0x1f30(%rsp,%rbp,8),%xmm0
ucomisd 0x154e(%rip),%xmm0
jne    1b0e <main+0x98e>
jnp    1af0 <main+0x970>
mov    %r15,%rdi
mov    %ebp,%esi
mov    %r12,%rdx
mov    $0x5,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%ebx
jg     1b54 <main+0x9d4>
add    $0x1,%ebx
mov    $0x1,%eax
jmp    1af0 <main+0x970>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x1569(%rip),%rdi
test   %eax,%eax
jne    1467 <main+0x2e7>
jmp    1460 <main+0x2e0>
lea    0x1555(%rip),%rdi
jmp    1467 <main+0x2e7>
mov    $0x300,%r14d
sub    0x8(%rsp),%r14d
cmpq   $0x0,0x18(%rsp)
je     1b9d <main+0xa1d>
cmp    $0x2,%r14d
mov    $0x1,%ebp
cmovge %r14d,%ebp
lea    0x151f(%rip),%rbx
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rdi
call   1030 <puts@plt>
add    $0xffffffff,%ebp
jne    1b90 <main+0xa10>
mov    %r14d,0x10(%rsp)
mov    0x8(%rsp),%rax
mov    %eax,%r15d
or     $0x1,%r15d
add    $0xffffffff,%eax
mov    %eax,0x14(%rsp)
lea    0x1f30(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
mov    $0x2,%ebp
mov    $0x3e0,%r12d
jmp    1bec <main+0xa6c>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%ebp
cmp    %r15d,%ebp
je     1d31 <main+0xbb1>
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    $0x3e0,%eax
xor    %edx,%edx
idiv   %ecx
mov    %eax,%ecx
imul   %ebx,%ecx
lea    0x1(%rbx),%r13d
imul   %r13d,%eax
cmp    $0x3e0,%eax
cmovge %r12d,%eax
cmp    %eax,%ecx
jge    1c48 <main+0xac8>
movslq %ecx,%rdx
lea    (%rsp,%rdx,8),%rdi
add    $0x20,%rdi
lea    (%rsp,%rdx,8),%rsi
add    $0x3e40,%rsi
not    %ecx
add    %ecx,%eax
lea    0x8(,%rax,8),%rdx
call   1080 <memcpy@plt>
cmp    $0x3df,%ebx
jge    1cd0 <main+0xb50>
movslq %ebx,%r14
lea    0x1(%r14),%rax
mov    $0x7,%ecx
sub    %ebx,%ecx
xorpd  %xmm1,%xmm1
and    $0x7,%ecx
je     1c7f <main+0xaff>
nopl   0x0(%rax,%rax,1)
addsd  0x20(%rsp,%rax,8),%xmm1
add    $0x1,%rax
add    $0xffffffff,%ecx
jne    1c70 <main+0xaf0>
lea    -0x3d8(%rbx),%ecx
cmp    $0x7,%ecx
jb     1cd7 <main+0xb57>
nopw   0x0(%rax,%rax,1)
addsd  0x20(%rsp,%rax,8),%xmm1
addsd  0x28(%rsp,%rax,8),%xmm1
addsd  0x30(%rsp,%rax,8),%xmm1
addsd  0x38(%rsp,%rax,8),%xmm1
addsd  0x40(%rsp,%rax,8),%xmm1
addsd  0x48(%rsp,%rax,8),%xmm1
addsd  0x50(%rsp,%rax,8),%xmm1
addsd  0x58(%rsp,%rax,8),%xmm1
add    $0x8,%rax
cmp    $0x3e0,%eax
jne    1c90 <main+0xb10>
jmp    1cd7 <main+0xb57>
nopl   (%rax)
mov    %ebx,%r14d
xorpd  %xmm1,%xmm1
movsd  %xmm1,0x20(%rsp,%r14,8)
movslq %r13d,%rax
subsd  0x20(%rsp,%rax,8),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
movsd  %xmm1,0x5d50(%rsp,%r14,8)
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
add    $0xffffffff,%eax
cmp    %eax,%ebx
jge    1be0 <main+0xa60>
movsd  (%rsp),%xmm0
addsd  0x1f30(%rsp,%r14,8),%xmm0
movsd  %xmm0,0x1f30(%rsp,%r14,8)
jmp    1be0 <main+0xa60>
mov    0x14(%rsp),%ebp
xor    %ebx,%ebx
lea    0x1332(%rip),%r12
lea    0x1357(%rip),%r13
lea    0x1364(%rip),%r15
xor    %r14d,%r14d
xor    %eax,%eax
jmp    1d73 <main+0xbf3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r14d
mov    $0x1,%eax
add    $0x1,%rbx
add    $0xffffffffffffffff,%rbp
je     1da4 <main+0xc24>
movsd  0x1f30(%rsp,%rbx,8),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
ucomisd %xmm1,%xmm0
jne    1d8b <main+0xc0b>
jnp    1d69 <main+0xbe9>
mov    %r12,%rdi
mov    %ebx,%esi
mov    %r13,%rdx
mov    %ebp,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%r14d
jle    1d60 <main+0xbe0>
jmp    1db8 <main+0xc38>
test   %eax,%eax
lea    0x12f9(%rip),%rax
lea    0x12fc(%rip),%r15
cmove  %rax,%r15
mov    %r15,%rdi
call   1030 <puts@plt>
lea    0x1f30(%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>
mov    %eax,%ecx
mov    $0x3e0,%esi
mov    $0x3e0,%eax
xor    %edx,%edx
idiv   %ecx
mov    %eax,%ecx
imul   %ebx,%ecx
lea    0x1(%rbx),%r14d
imul   %r14d,%eax
cmp    $0x3e0,%eax
cmovge %esi,%eax
cmp    %eax,%ecx
jge    1e34 <main+0xcb4>
movslq %ecx,%rdx
lea    (%rsp,%rdx,8),%rdi
add    $0x20,%rdi
lea    (%rsp,%rdx,8),%rsi
add    $0x3e40,%rsi
not    %ecx
add    %ecx,%eax
lea    0x8(,%rax,8),%rdx
call   1080 <memcpy@plt>
cmp    $0x3df,%ebx
jge    1ebd <main+0xd3d>
movslq %ebx,%rbp
lea    0x1(%rbp),%rax
mov    $0x7,%ecx
sub    %ebx,%ecx
xorpd  %xmm1,%xmm1
and    $0x7,%ecx
je     1e6f <main+0xcef>
nopw   0x0(%rax,%rax,1)
addsd  0x20(%rsp,%rax,8),%xmm1
add    $0x1,%rax
add    $0xffffffff,%ecx
jne    1e60 <main+0xce0>
lea    -0x3d8(%rbx),%ecx
cmp    $0x7,%ecx
jb     1ec3 <main+0xd43>
nopw   0x0(%rax,%rax,1)
addsd  0x20(%rsp,%rax,8),%xmm1
addsd  0x28(%rsp,%rax,8),%xmm1
addsd  0x30(%rsp,%rax,8),%xmm1
addsd  0x38(%rsp,%rax,8),%xmm1
addsd  0x40(%rsp,%rax,8),%xmm1
addsd  0x48(%rsp,%rax,8),%xmm1
addsd  0x50(%rsp,%rax,8),%xmm1
addsd  0x58(%rsp,%rax,8),%xmm1
add    $0x8,%rax
cmp    $0x3e0,%eax
jne    1e80 <main+0xd00>
jmp    1ec3 <main+0xd43>
mov    %ebx,%ebp
xorpd  %xmm1,%xmm1
movsd  %xmm1,0x20(%rsp,%rbp,8)
movslq %r14d,%rax
subsd  0x20(%rsp,%rax,8),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
movsd  %xmm1,0x5d50(%rsp,%rbp,8)
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
add    $0xffffffff,%eax
cmp    %eax,%ebx
jge    1f10 <main+0xd90>
movsd  (%rsp),%xmm0
addsd  0x1f30(%rsp,%rbp,8),%xmm0
movsd  %xmm0,0x1f30(%rsp,%rbp,8)
movsd  0x5d50(%rsp),%xmm0
lea    0x1186(%rip),%rdi
ucomisd 0x1138(%rip),%xmm0
jne    1f2c <main+0xdac>
jnp    1f4f <main+0xdcf>
lea    0x113d(%rip),%rdi
lea    0x1167(%rip),%rdx
xor    %esi,%esi
mov    $0x7800f,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
lea    0x1161(%rip),%rdi
call   1030 <puts@plt>
mov    $0x1,%r14d
lea    0x110f(%rip),%r12
lea    0x1134(%rip),%r13
jmp    1f98 <main+0xe18>
nopw   0x0(%rax,%rax,1)
test   %ebx,%ebx
lea    0x1137(%rip),%rdi
lea    0x1126(%rip),%rax
cmove  %rax,%rdi
call   1030 <puts@plt>
add    $0x1,%r14
cmp    0x8(%rsp),%r14
je     215c <main+0xfdc>
mov    $0x1f00,%edx
lea    0x1f30(%rsp),%rdi
xor    %esi,%esi
call   1060 <memset@plt>
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    $0x3e0,%eax
xor    %edx,%edx
idiv   %ecx
mov    %eax,%ecx
imul   %ebp,%ecx
lea    0x1(%rbp),%ebx
imul   %ebx,%eax
cmp    $0x3e0,%eax
mov    $0x3e0,%edx
cmovge %edx,%eax
cmp    %eax,%ecx
jge    200a <main+0xe8a>
movslq %ecx,%rdx
lea    (%rsp,%rdx,8),%rdi
add    $0x20,%rdi
lea    (%rsp,%rdx,8),%rsi
add    $0x3e40,%rsi
not    %ecx
add    %ecx,%eax
lea    0x8(,%rax,8),%rdx
call   1080 <memcpy@plt>
cmp    $0x3df,%ebp
jge    2090 <main+0xf10>
movslq %ebp,%r15
lea    0x1(%r15),%rax
mov    $0x7,%ecx
sub    %ebp,%ecx
xorpd  %xmm1,%xmm1
and    $0x7,%ecx
je     203f <main+0xebf>
nopl   (%rax)
addsd  0x20(%rsp,%rax,8),%xmm1
add    $0x1,%rax
add    $0xffffffff,%ecx
jne    2030 <main+0xeb0>
lea    -0x3d8(%rbp),%ecx
cmp    $0x7,%ecx
jb     2097 <main+0xf17>
nopw   0x0(%rax,%rax,1)
addsd  0x20(%rsp,%rax,8),%xmm1
addsd  0x28(%rsp,%rax,8),%xmm1
addsd  0x30(%rsp,%rax,8),%xmm1
addsd  0x38(%rsp,%rax,8),%xmm1
addsd  0x40(%rsp,%rax,8),%xmm1
addsd  0x48(%rsp,%rax,8),%xmm1
addsd  0x50(%rsp,%rax,8),%xmm1
addsd  0x58(%rsp,%rax,8),%xmm1
add    $0x8,%rax
cmp    $0x3e0,%eax
jne    2050 <main+0xed0>
jmp    2097 <main+0xf17>
nopl   (%rax)
mov    %ebp,%r15d
xorpd  %xmm1,%xmm1
movsd  %xmm1,0x20(%rsp,%r15,8)
movslq %ebx,%rax
subsd  0x20(%rsp,%rax,8),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
movsd  %xmm1,0x5d50(%rsp,%r15,8)
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
add    $0xffffffff,%eax
cmp    %eax,%ebp
jge    20e8 <main+0xf68>
movsd  (%rsp),%xmm0
addsd  0x1f30(%rsp,%r15,8),%xmm0
movsd  %xmm0,0x1f30(%rsp,%r15,8)
xor    %ebp,%ebp
xor    %r15d,%r15d
xor    %ebx,%ebx
jmp    210d <main+0xf8d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    %rbp,%r14
je     1f70 <main+0xdf0>
movsd  0x1f30(%rsp,%rbp,8),%xmm0
ucomisd 0xf32(%rip),%xmm0
jne    2122 <main+0xfa2>
jnp    2100 <main+0xf80>
mov    $0x1,%ebx
mov    %r12,%rdi
mov    %ebp,%esi
mov    %r13,%rdx
mov    $0x1,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%r15d
jg     2150 <main+0xfd0>
add    $0x1,%r15d
jmp    2100 <main+0xf80>
nopw   0x0(%rax,%rax,1)
lea    0xf59(%rip),%rdi
jmp    1f84 <main+0xe04>
mov    0x18(%rsp),%r14
test   %r14,%r14
je     2196 <main+0x1016>
mov    0x10(%rsp),%eax
cmp    $0x2,%eax
mov    $0x1,%ebp
cmovge %eax,%ebp
lea    0xf2a(%rip),%rbx
nopl   0x0(%rax)
mov    %rbx,%rdi
call   1030 <puts@plt>
add    $0xffffffff,%ebp
jne    2180 <main+0x1000>
test   %r14,%r14
jne    23a2 <main+0x1222>
lea    0x1f30(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
mov    %eax,%ebp
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
mov    %eax,%ecx
mov    $0x3e0,%esi
mov    $0x3e0,%eax
xor    %edx,%edx
idiv   %ecx
mov    %eax,%ecx
imul   %ebx,%ecx
lea    0x1(%rbx),%r14d
imul   %r14d,%eax
cmp    $0x3e0,%eax
cmovge %esi,%eax
cmp    %eax,%ecx
jge    2213 <main+0x1093>
movslq %ecx,%rdx
lea    (%rsp,%rdx,8),%rdi
add    $0x20,%rdi
lea    (%rsp,%rdx,8),%rsi
add    $0x3e40,%rsi
not    %ecx
add    %ecx,%eax
lea    0x8(,%rax,8),%rdx
call   1080 <memcpy@plt>
shl    $0x4,%ebp
cmp    $0x3df,%ebx
jge    229e <main+0x111e>
movslq %ebx,%rax
lea    0x1(%rax),%rcx
mov    $0x7,%edx
sub    %ebx,%edx
xorpd  %xmm1,%xmm1
and    $0x7,%edx
je     224f <main+0x10cf>
nopl   0x0(%rax)
addsd  0x20(%rsp,%rcx,8),%xmm1
add    $0x1,%rcx
add    $0xffffffff,%edx
jne    2240 <main+0x10c0>
lea    -0x3d8(%rbx),%edx
cmp    $0x7,%edx
jb     22a4 <main+0x1124>
nopw   0x0(%rax,%rax,1)
addsd  0x20(%rsp,%rcx,8),%xmm1
addsd  0x28(%rsp,%rcx,8),%xmm1
addsd  0x30(%rsp,%rcx,8),%xmm1
addsd  0x38(%rsp,%rcx,8),%xmm1
addsd  0x40(%rsp,%rcx,8),%xmm1
addsd  0x48(%rsp,%rcx,8),%xmm1
addsd  0x50(%rsp,%rcx,8),%xmm1
addsd  0x58(%rsp,%rcx,8),%xmm1
add    $0x8,%rcx
cmp    $0x3e0,%ecx
jne    2260 <main+0x10e0>
jmp    22a4 <main+0x1124>
mov    %ebx,%eax
xorpd  %xmm1,%xmm1
movsd  %xmm1,0x20(%rsp,%rax,8)
movslq %r14d,%rcx
subsd  0x20(%rsp,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  %xmm1,0x5d50(%rsp,%rax,8)
xor    %r12d,%r12d
xor    %eax,%eax
call   1070 <omp_get_num_threads@plt>
add    $0xffffffff,%eax
add    %ebx,%ebp
movslq %ebp,%rcx
xorpd  %xmm0,%xmm0
cmp    %eax,%ebx
jge    22f6 <main+0x1176>
movsd  0x8(%rsp),%xmm0
addsd  0x1f30(%rsp,%rcx,8),%xmm0
movsd  %xmm0,0x1f30(%rsp,%rcx,8)
lea    0xd6a(%rip),%r14
lea    0xd8f(%rip),%r15
lea    0xd9c(%rip),%rbx
xor    %ebp,%ebp
xor    %eax,%eax
jmp    232d <main+0x11ad>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    $0x100,%rbp
je     238e <main+0x120e>
movsd  0x1f30(%rsp,%rbp,8),%xmm0
test   %rbp,%rbp
je     2343 <main+0x11c3>
lea    0x1(%rbp),%ecx
test   $0xf,%cl
je     2360 <main+0x11e0>
mov    $0x1,%ecx
ucomisd 0xd00(%rip),%xmm0
jne    236e <main+0x11ee>
jp     236e <main+0x11ee>
jmp    2320 <main+0x11a0>
cs nopw 0x0(%rax,%rax,1)
xor    %ecx,%ecx
ucomisd 0xcfe(%rip),%xmm0
jne    236e <main+0x11ee>
jnp    2320 <main+0x11a0>
mov    %r14,%rdi
mov    %ebp,%esi
mov    %r15,%rdx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%r12d
jg     23a2 <main+0x1222>
add    $0x1,%r12d
mov    $0x1,%eax
jmp    2320 <main+0x11a0>
test   %eax,%eax
lea    0xd0f(%rip),%rax
lea    0xd12(%rip),%rbx
cmove  %rax,%rbx
mov    %rbx,%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0x7c68,%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"B[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"C[i]\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [994 x double]
%3 = alloca [994 x double]
%4 = alloca [994 x double]
%5 = alloca [994 x double]
%6 = alloca [994 x double]
%7 = alloca i32
%8 = alloca i64
%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 double
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca [1 x 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 double
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca double
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
%47 = alloca i32
%48 = alloca i32
%49 = alloca i32
%50 = alloca double
%51 = alloca i32
%52 = alloca i32
%53 = alloca i32
%54 = alloca i32
%55 = alloca i32
%56 = alloca i32
%57 = alloca double
%58 = alloca i32
%59 = alloca i32
%60 = alloca i32
%61 = alloca i32
%62 = alloca i32
%63 = alloca i32
%64 = alloca double
%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 [1 x i32]
%75 = alloca i32
%76 = alloca i32
%77 = alloca i32
%78 = alloca i32
%79 = alloca i32
%80 = alloca double
%81 = alloca i32
%82 = alloca i32
%83 = alloca i32
%84 = alloca i32
%85 = alloca i32
%86 = alloca i32
%87 = alloca i32
%88 = alloca i32
%89 = alloca i32
%90 = alloca i32
%91 = alloca i32
%92 = alloca i32
%93 = alloca double
%94 = alloca i32
%95 = alloca i32
%96 = alloca i32
%97 = alloca i32
%98 = alloca 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 i32
%108 = alloca double
%109 = alloca i32
%110 = alloca i32
%111 = alloca i32
%112 = alloca i32
%113 = alloca i32
%114 = alloca i32
%115 = alloca i32
%116 = alloca i32
%117 = alloca i32
%118 = alloca i32
%119 = alloca i32
%120 = alloca i32
%121 = alloca i32
%122 = alloca i32
%123 = alloca double
%124 = alloca i32
%125 = alloca i32
%126 = alloca i32
%127 = alloca i32
store i32 0, i32* %1
%128 = call i32 (...) @check_offloading()
store i32 0, i32* %7
br label %129
129: ; preds = %147, %0
%130 = load i32, i32* %7
%131 = icmp slt i32 %130, 992
br i1 %131, label %132, label %150
132: ; preds = %129
%133 = load i32, i32* %7
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %134
store double 0.000000e+00, double* %135
%136 = load i32, i32* %7
%137 = sitofp i32 %136 to double
%138 = load i32, i32* %7
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds [994 x double], [994 x double]* %5, i64 0, i64 %139
store double %137, double* %140
%141 = load i32, i32* %7
%142 = sub nsw i32 0, %141
%143 = sitofp i32 %142 to double
%144 = load i32, i32* %7
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds [994 x double], [994 x double]* %6, i64 0, i64 %145
store double %143, double* %146
br label %147
147: ; preds = %132
%148 = load i32, i32* %7
%149 = add nsw i32 %148, 1
store i32 %149, i32* %7
br label %129
150: ; preds = %129
store i64 0, i64* %8
%151 = call i64 (...) @omp_is_initial_device()
store i64 %151, i64* %8
store i32 768, i32* %9
store i32 32, i32* %10
%152 = load i64, i64* %8
%153 = icmp ne i64 %152, 0
br i1 %153, label %154, label %156
154: ; preds = %150
%155 = load i32, i32* %10
br label %158
156: ; preds = %150
%157 = load i32, i32* %9
br label %158
158: ; preds = %156, %154
%159 = phi i32 [ %155, %154 ], [ %157, %156 ]
store i32 %159, i32* %11
store i32 0, i32* %12
store i32 0, i32* %14
br label %160
160: ; preds = %288, %158
%161 = load i32, i32* %14
%162 = icmp slt i32 %161, 1
br i1 %162, label %163, label %166
163: ; preds = %160
%164 = load i32, i32* %12
%165 = icmp eq i32 %164, 0
br label %166
166: ; preds = %163, %160
%167 = phi i1 [ false, %160 ], [ %165, %163 ]
br i1 %167, label %168, label %291
168: ; preds = %166
%169 = call i32 (...) @omp_get_thread_num()
store i32 %169, i32* %15
%170 = call i32 (...) @omp_get_num_threads()
%171 = sdiv i32 992, %170
store i32 %171, i32* %16
%172 = load i32, i32* %15
%173 = load i32, i32* %16
%174 = mul nsw i32 %172, %173
store i32 %174, i32* %17
%175 = load i32, i32* %15
%176 = add nsw i32 %175, 1
%177 = load i32, i32* %16
%178 = mul nsw i32 %176, %177
store i32 %178, i32* %18
%179 = load i32, i32* %18
%180 = icmp sgt i32 %179, 992
br i1 %180, label %181, label %182
181: ; preds = %168
br label %184
182: ; preds = %168
%183 = load i32, i32* %18
br label %184
184: ; preds = %182, %181
%185 = phi i32 [ 992, %181 ], [ %183, %182 ]
store i32 %185, i32* %18
%186 = load i32, i32* %17
store i32 %186, i32* %19
br label %187
187: ; preds = %199, %184
%188 = load i32, i32* %19
%189 = load i32, i32* %18
%190 = icmp slt i32 %188, %189
br i1 %190, label %191, label %202
191: ; preds = %187
%192 = load i32, i32* %19
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds [994 x double], [994 x double]* %5, i64 0, i64 %193
%195 = load double, double* %194
%196 = load i32, i32* %19
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %197
store double %195, double* %198
br label %199
199: ; preds = %191
%200 = load i32, i32* %19
%201 = add nsw i32 %200, 1
store i32 %201, i32* %19
br label %187
202: ; preds = %187
store double 0.000000e+00, double* %20
%203 = load i32, i32* %15
%204 = add nsw i32 1, %203
store i32 %204, i32* %21
br label %205
205: ; preds = %215, %202
%206 = load i32, i32* %21
%207 = icmp slt i32 %206, 992
br i1 %207, label %208, label %218
208: ; preds = %205
%209 = load i32, i32* %21
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %210
%212 = load double, double* %211
%213 = load double, double* %20
%214 = fadd double %213, %212
store double %214, double* %20
br label %215
215: ; preds = %208
%216 = load i32, i32* %21
%217 = add nsw i32 %216, 1
store i32 %217, i32* %21
br label %205
218: ; preds = %205
%219 = load double, double* %20
%220 = load i32, i32* %15
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %221
store double %219, double* %222
store double 0.000000e+00, double* %20
%223 = load i32, i32* %15
%224 = add nsw i32 2, %223
store i32 %224, i32* %22
br label %225
225: ; preds = %235, %218
%226 = load i32, i32* %22
%227 = icmp slt i32 %226, 992
br i1 %227, label %228, label %238
228: ; preds = %225
%229 = load i32, i32* %22
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %230
%232 = load double, double* %231
%233 = load double, double* %20
%234 = fadd double %233, %232
store double %234, double* %20
br label %235
235: ; preds = %228
%236 = load i32, i32* %22
%237 = add nsw i32 %236, 1
store i32 %237, i32* %22
br label %225
238: ; preds = %225
%239 = load double, double* %20
%240 = load i32, i32* %15
%241 = add nsw i32 %240, 1
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %242
store double %239, double* %243
%244 = load i32, i32* %15
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %245
%247 = load double, double* %246
%248 = load i32, i32* %15
%249 = add nsw i32 %248, 1
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %250
%252 = load double, double* %251
%253 = fsub double %247, %252
%254 = load i32, i32* %15
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %255
store double %253, double* %256
store i32 0, i32* %24
store i32 0, i32* %23
br label %257
257: ; preds = %284, %238
%258 = load i32, i32* %23
%259 = icmp slt i32 %258, 1
br i1 %259, label %260, label %287
260: ; preds = %257
%261 = load i32, i32* %23
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %262
%264 = load double, double* %263
%265 = load i32, i32* %23
%266 = add nsw i32 %265, 1
%267 = sitofp i32 %266 to double
%268 = fcmp une double %264, %267
br i1 %268, label %269, label %283
269: ; preds = %260
%270 = load i32, i32* %23
%271 = load i32, i32* %23
%272 = add nsw i32 %271, 1
%273 = load i32, i32* %23
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %274
%276 = load double, double* %275
%277 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %270, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 %272, double %276)
store i32 1, i32* %12
%278 = load i32, i32* %24
%279 = add nsw i32 %278, 1
store i32 %279, i32* %24
%280 = icmp sgt i32 %278, 10
br i1 %280, label %281, label %282
281: ; preds = %269
br label %287
282: ; preds = %269
br label %283
283: ; preds = %282, %260
br label %284
284: ; preds = %283
%285 = load i32, i32* %23
%286 = add nsw i32 %285, 1
store i32 %286, i32* %23
br label %257
287: ; preds = %281, %257
br label %288
288: ; preds = %287
%289 = load i32, i32* %14
%290 = add nsw i32 %289, 1
store i32 %290, i32* %14
br label %160
291: ; preds = %166
%292 = load i32, i32* %12
%293 = icmp ne i32 %292, 0
br i1 %293, label %294, label %296
294: ; preds = %291
%295 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %298
296: ; preds = %291
%297 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %298
298: ; preds = %296, %294
store i32 1, i32* %25
br label %299
299: ; preds = %791, %298
%300 = load i32, i32* %25
%301 = load i32, i32* %11
%302 = icmp sle i32 %300, %301
br i1 %302, label %303, label %794
303: ; preds = %299
%304 = load i32, i32* %25
%305 = getelementptr inbounds [1 x i32], [1 x i32]* %26, i64 0, i64 0
store i32 %304, i32* %305
store i32 0, i32* %27
store i32 0, i32* %29
br label %306
306: ; preds = %780, %303
%307 = load i32, i32* %29
%308 = icmp slt i32 %307, 1
br i1 %308, label %309, label %312
309: ; preds = %306
%310 = load i32, i32* %27
%311 = icmp eq i32 %310, 0
br label %312
312: ; preds = %309, %306
%313 = phi i1 [ false, %306 ], [ %311, %309 ]
br i1 %313, label %314, label %783
314: ; preds = %312
store i32 0, i32* %30
br label %315
315: ; preds = %322, %314
%316 = load i32, i32* %30
%317 = icmp slt i32 %316, 992
br i1 %317, label %318, label %325
318: ; preds = %315
%319 = load i32, i32* %30
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %320
store double 0.000000e+00, double* %321
br label %322
322: ; preds = %318
%323 = load i32, i32* %30
%324 = add nsw i32 %323, 1
store i32 %324, i32* %30
br label %315
325: ; preds = %315
%326 = call i32 (...) @omp_get_thread_num()
store i32 %326, i32* %31
%327 = call i32 (...) @omp_get_num_threads()
%328 = sdiv i32 992, %327
store i32 %328, i32* %32
%329 = load i32, i32* %31
%330 = load i32, i32* %32
%331 = mul nsw i32 %329, %330
store i32 %331, i32* %33
%332 = load i32, i32* %31
%333 = add nsw i32 %332, 1
%334 = load i32, i32* %32
%335 = mul nsw i32 %333, %334
store i32 %335, i32* %34
%336 = load i32, i32* %34
%337 = icmp sgt i32 %336, 992
br i1 %337, label %338, label %339
338: ; preds = %325
br label %341
339: ; preds = %325
%340 = load i32, i32* %34
br label %341
341: ; preds = %339, %338
%342 = phi i32 [ 992, %338 ], [ %340, %339 ]
store i32 %342, i32* %34
%343 = load i32, i32* %33
store i32 %343, i32* %35
br label %344
344: ; preds = %356, %341
%345 = load i32, i32* %35
%346 = load i32, i32* %34
%347 = icmp slt i32 %345, %346
br i1 %347, label %348, label %359
348: ; preds = %344
%349 = load i32, i32* %35
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds [994 x double], [994 x double]* %5, i64 0, i64 %350
%352 = load double, double* %351
%353 = load i32, i32* %35
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %354
store double %352, double* %355
br label %356
356: ; preds = %348
%357 = load i32, i32* %35
%358 = add nsw i32 %357, 1
store i32 %358, i32* %35
br label %344
359: ; preds = %344
store double 0.000000e+00, double* %36
%360 = load i32, i32* %31
%361 = add nsw i32 1, %360
store i32 %361, i32* %37
br label %362
362: ; preds = %372, %359
%363 = load i32, i32* %37
%364 = icmp slt i32 %363, 992
br i1 %364, label %365, label %375
365: ; preds = %362
%366 = load i32, i32* %37
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %367
%369 = load double, double* %368
%370 = load double, double* %36
%371 = fadd double %370, %369
store double %371, double* %36
br label %372
372: ; preds = %365
%373 = load i32, i32* %37
%374 = add nsw i32 %373, 1
store i32 %374, i32* %37
br label %362
375: ; preds = %362
%376 = load double, double* %36
%377 = load i32, i32* %31
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %378
store double %376, double* %379
%380 = load i32, i32* %31
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %381
%383 = load double, double* %382
%384 = load i32, i32* %31
%385 = add nsw i32 %384, 1
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %386
%388 = load double, double* %387
%389 = fsub double %383, %388
%390 = load i32, i32* %31
%391 = sitofp i32 %390 to double
%392 = fsub double %389, %391
%393 = load i32, i32* %31
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %394
store double %392, double* %395
%396 = load i32, i32* %31
%397 = call i32 (...) @omp_get_num_threads()
%398 = sub nsw i32 %397, 1
%399 = icmp slt i32 %396, %398
br i1 %399, label %400, label %410
400: ; preds = %375
%401 = load i32, i32* %31
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %402
%404 = load double, double* %403
%405 = load i32, i32* %31
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %406
%408 = load double, double* %407
%409 = fadd double %408, %404
store double %409, double* %407
br label %410
410: ; preds = %400, %375
%411 = call i32 (...) @omp_get_thread_num()
store i32 %411, i32* %38
%412 = call i32 (...) @omp_get_num_threads()
%413 = sdiv i32 992, %412
store i32 %413, i32* %39
%414 = load i32, i32* %38
%415 = load i32, i32* %39
%416 = mul nsw i32 %414, %415
store i32 %416, i32* %40
%417 = load i32, i32* %38
%418 = add nsw i32 %417, 1
%419 = load i32, i32* %39
%420 = mul nsw i32 %418, %419
store i32 %420, i32* %41
%421 = load i32, i32* %41
%422 = icmp sgt i32 %421, 992
br i1 %422, label %423, label %424
423: ; preds = %410
br label %426
424: ; preds = %410
%425 = load i32, i32* %41
br label %426
426: ; preds = %424, %423
%427 = phi i32 [ 992, %423 ], [ %425, %424 ]
store i32 %427, i32* %41
%428 = load i32, i32* %40
store i32 %428, i32* %42
br label %429
429: ; preds = %441, %426
%430 = load i32, i32* %42
%431 = load i32, i32* %41
%432 = icmp slt i32 %430, %431
br i1 %432, label %433, label %444
433: ; preds = %429
%434 = load i32, i32* %42
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds [994 x double], [994 x double]* %5, i64 0, i64 %435
%437 = load double, double* %436
%438 = load i32, i32* %42
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %439
store double %437, double* %440
br label %441
441: ; preds = %433
%442 = load i32, i32* %42
%443 = add nsw i32 %442, 1
store i32 %443, i32* %42
br label %429
444: ; preds = %429
store double 0.000000e+00, double* %43
%445 = load i32, i32* %38
%446 = add nsw i32 1, %445
store i32 %446, i32* %44
br label %447
447: ; preds = %457, %444
%448 = load i32, i32* %44
%449 = icmp slt i32 %448, 992
br i1 %449, label %450, label %460
450: ; preds = %447
%451 = load i32, i32* %44
%452 = sext i32 %451 to i64
%453 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %452
%454 = load double, double* %453
%455 = load double, double* %43
%456 = fadd double %455, %454
store double %456, double* %43
br label %457
457: ; preds = %450
%458 = load i32, i32* %44
%459 = add nsw i32 %458, 1
store i32 %459, i32* %44
br label %447
460: ; preds = %447
%461 = load double, double* %43
%462 = load i32, i32* %38
%463 = sext i32 %462 to i64
%464 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %463
store double %461, double* %464
%465 = load i32, i32* %38
%466 = sext i32 %465 to i64
%467 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %466
%468 = load double, double* %467
%469 = load i32, i32* %38
%470 = add nsw i32 %469, 1
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %471
%473 = load double, double* %472
%474 = fsub double %468, %473
%475 = load i32, i32* %38
%476 = sitofp i32 %475 to double
%477 = fsub double %474, %476
%478 = load i32, i32* %38
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %479
store double %477, double* %480
%481 = load i32, i32* %38
%482 = call i32 (...) @omp_get_num_threads()
%483 = sub nsw i32 %482, 1
%484 = icmp slt i32 %481, %483
br i1 %484, label %485, label %495
485: ; preds = %460
%486 = load i32, i32* %38
%487 = sext i32 %486 to i64
%488 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %487
%489 = load double, double* %488
%490 = load i32, i32* %38
%491 = sext i32 %490 to i64
%492 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %491
%493 = load double, double* %492
%494 = fadd double %493, %489
store double %494, double* %492
br label %495
495: ; preds = %485, %460
%496 = call i32 (...) @omp_get_thread_num()
store i32 %496, i32* %45
%497 = call i32 (...) @omp_get_num_threads()
%498 = sdiv i32 992, %497
store i32 %498, i32* %46
%499 = load i32, i32* %45
%500 = load i32, i32* %46
%501 = mul nsw i32 %499, %500
store i32 %501, i32* %47
%502 = load i32, i32* %45
%503 = add nsw i32 %502, 1
%504 = load i32, i32* %46
%505 = mul nsw i32 %503, %504
store i32 %505, i32* %48
%506 = load i32, i32* %48
%507 = icmp sgt i32 %506, 992
br i1 %507, label %508, label %509
508: ; preds = %495
br label %511
509: ; preds = %495
%510 = load i32, i32* %48
br label %511
511: ; preds = %509, %508
%512 = phi i32 [ 992, %508 ], [ %510, %509 ]
store i32 %512, i32* %48
%513 = load i32, i32* %47
store i32 %513, i32* %49
br label %514
514: ; preds = %526, %511
%515 = load i32, i32* %49
%516 = load i32, i32* %48
%517 = icmp slt i32 %515, %516
br i1 %517, label %518, label %529
518: ; preds = %514
%519 = load i32, i32* %49
%520 = sext i32 %519 to i64
%521 = getelementptr inbounds [994 x double], [994 x double]* %5, i64 0, i64 %520
%522 = load double, double* %521
%523 = load i32, i32* %49
%524 = sext i32 %523 to i64
%525 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %524
store double %522, double* %525
br label %526
526: ; preds = %518
%527 = load i32, i32* %49
%528 = add nsw i32 %527, 1
store i32 %528, i32* %49
br label %514
529: ; preds = %514
store double 0.000000e+00, double* %50
%530 = load i32, i32* %45
%531 = add nsw i32 1, %530
store i32 %531, i32* %51
br label %532
532: ; preds = %542, %529
%533 = load i32, i32* %51
%534 = icmp slt i32 %533, 992
br i1 %534, label %535, label %545
535: ; preds = %532
%536 = load i32, i32* %51
%537 = sext i32 %536 to i64
%538 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %537
%539 = load double, double* %538
%540 = load double, double* %50
%541 = fadd double %540, %539
store double %541, double* %50
br label %542
542: ; preds = %535
%543 = load i32, i32* %51
%544 = add nsw i32 %543, 1
store i32 %544, i32* %51
br label %532
545: ; preds = %532
%546 = load double, double* %50
%547 = load i32, i32* %45
%548 = sext i32 %547 to i64
%549 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %548
store double %546, double* %549
%550 = load i32, i32* %45
%551 = sext i32 %550 to i64
%552 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %551
%553 = load double, double* %552
%554 = load i32, i32* %45
%555 = add nsw i32 %554, 1
%556 = sext i32 %555 to i64
%557 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %556
%558 = load double, double* %557
%559 = fsub double %553, %558
%560 = load i32, i32* %45
%561 = sitofp i32 %560 to double
%562 = fsub double %559, %561
%563 = load i32, i32* %45
%564 = sext i32 %563 to i64
%565 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %564
store double %562, double* %565
%566 = load i32, i32* %45
%567 = call i32 (...) @omp_get_num_threads()
%568 = sub nsw i32 %567, 1
%569 = icmp slt i32 %566, %568
br i1 %569, label %570, label %580
570: ; preds = %545
%571 = load i32, i32* %45
%572 = sext i32 %571 to i64
%573 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %572
%574 = load double, double* %573
%575 = load i32, i32* %45
%576 = sext i32 %575 to i64
%577 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %576
%578 = load double, double* %577
%579 = fadd double %578, %574
store double %579, double* %577
br label %580
580: ; preds = %570, %545
%581 = call i32 (...) @omp_get_thread_num()
store i32 %581, i32* %52
%582 = call i32 (...) @omp_get_num_threads()
%583 = sdiv i32 992, %582
store i32 %583, i32* %53
%584 = load i32, i32* %52
%585 = load i32, i32* %53
%586 = mul nsw i32 %584, %585
store i32 %586, i32* %54
%587 = load i32, i32* %52
%588 = add nsw i32 %587, 1
%589 = load i32, i32* %53
%590 = mul nsw i32 %588, %589
store i32 %590, i32* %55
%591 = load i32, i32* %55
%592 = icmp sgt i32 %591, 992
br i1 %592, label %593, label %594
593: ; preds = %580
br label %596
594: ; preds = %580
%595 = load i32, i32* %55
br label %596
596: ; preds = %594, %593
%597 = phi i32 [ 992, %593 ], [ %595, %594 ]
store i32 %597, i32* %55
%598 = load i32, i32* %54
store i32 %598, i32* %56
br label %599
599: ; preds = %611, %596
%600 = load i32, i32* %56
%601 = load i32, i32* %55
%602 = icmp slt i32 %600, %601
br i1 %602, label %603, label %614
603: ; preds = %599
%604 = load i32, i32* %56
%605 = sext i32 %604 to i64
%606 = getelementptr inbounds [994 x double], [994 x double]* %5, i64 0, i64 %605
%607 = load double, double* %606
%608 = load i32, i32* %56
%609 = sext i32 %608 to i64
%610 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %609
store double %607, double* %610
br label %611
611: ; preds = %603
%612 = load i32, i32* %56
%613 = add nsw i32 %612, 1
store i32 %613, i32* %56
br label %599
614: ; preds = %599
store double 0.000000e+00, double* %57
%615 = load i32, i32* %52
%616 = add nsw i32 1, %615
store i32 %616, i32* %58
br label %617
617: ; preds = %627, %614
%618 = load i32, i32* %58
%619 = icmp slt i32 %618, 992
br i1 %619, label %620, label %630
620: ; preds = %617
%621 = load i32, i32* %58
%622 = sext i32 %621 to i64
%623 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %622
%624 = load double, double* %623
%625 = load double, double* %57
%626 = fadd double %625, %624
store double %626, double* %57
br label %627
627: ; preds = %620
%628 = load i32, i32* %58
%629 = add nsw i32 %628, 1
store i32 %629, i32* %58
br label %617
630: ; preds = %617
%631 = load double, double* %57
%632 = load i32, i32* %52
%633 = sext i32 %632 to i64
%634 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %633
store double %631, double* %634
%635 = load i32, i32* %52
%636 = sext i32 %635 to i64
%637 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %636
%638 = load double, double* %637
%639 = load i32, i32* %52
%640 = add nsw i32 %639, 1
%641 = sext i32 %640 to i64
%642 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %641
%643 = load double, double* %642
%644 = fsub double %638, %643
%645 = load i32, i32* %52
%646 = sitofp i32 %645 to double
%647 = fsub double %644, %646
%648 = load i32, i32* %52
%649 = sext i32 %648 to i64
%650 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %649
store double %647, double* %650
%651 = load i32, i32* %52
%652 = call i32 (...) @omp_get_num_threads()
%653 = sub nsw i32 %652, 1
%654 = icmp slt i32 %651, %653
br i1 %654, label %655, label %665
655: ; preds = %630
%656 = load i32, i32* %52
%657 = sext i32 %656 to i64
%658 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %657
%659 = load double, double* %658
%660 = load i32, i32* %52
%661 = sext i32 %660 to i64
%662 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %661
%663 = load double, double* %662
%664 = fadd double %663, %659
store double %664, double* %662
br label %665
665: ; preds = %655, %630
%666 = call i32 (...) @omp_get_thread_num()
store i32 %666, i32* %59
%667 = call i32 (...) @omp_get_num_threads()
%668 = sdiv i32 992, %667
store i32 %668, i32* %60
%669 = load i32, i32* %59
%670 = load i32, i32* %60
%671 = mul nsw i32 %669, %670
store i32 %671, i32* %61
%672 = load i32, i32* %59
%673 = add nsw i32 %672, 1
%674 = load i32, i32* %60
%675 = mul nsw i32 %673, %674
store i32 %675, i32* %62
%676 = load i32, i32* %62
%677 = icmp sgt i32 %676, 992
br i1 %677, label %678, label %679
678: ; preds = %665
br label %681
679: ; preds = %665
%680 = load i32, i32* %62
br label %681
681: ; preds = %679, %678
%682 = phi i32 [ 992, %678 ], [ %680, %679 ]
store i32 %682, i32* %62
%683 = load i32, i32* %61
store i32 %683, i32* %63
br label %684
684: ; preds = %696, %681
%685 = load i32, i32* %63
%686 = load i32, i32* %62
%687 = icmp slt i32 %685, %686
br i1 %687, label %688, label %699
688: ; preds = %684
%689 = load i32, i32* %63
%690 = sext i32 %689 to i64
%691 = getelementptr inbounds [994 x double], [994 x double]* %5, i64 0, i64 %690
%692 = load double, double* %691
%693 = load i32, i32* %63
%694 = sext i32 %693 to i64
%695 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %694
store double %692, double* %695
br label %696
696: ; preds = %688
%697 = load i32, i32* %63
%698 = add nsw i32 %697, 1
store i32 %698, i32* %63
br label %684
699: ; preds = %684
store double 0.000000e+00, double* %64
%700 = load i32, i32* %59
%701 = add nsw i32 1, %700
store i32 %701, i32* %65
br label %702
702: ; preds = %712, %699
%703 = load i32, i32* %65
%704 = icmp slt i32 %703, 992
br i1 %704, label %705, label %715
705: ; preds = %702
%706 = load i32, i32* %65
%707 = sext i32 %706 to i64
%708 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %707
%709 = load double, double* %708
%710 = load double, double* %64
%711 = fadd double %710, %709
store double %711, double* %64
br label %712
712: ; preds = %705
%713 = load i32, i32* %65
%714 = add nsw i32 %713, 1
store i32 %714, i32* %65
br label %702
715: ; preds = %702
%716 = load double, double* %64
%717 = load i32, i32* %59
%718 = sext i32 %717 to i64
%719 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %718
store double %716, double* %719
%720 = load i32, i32* %59
%721 = sext i32 %720 to i64
%722 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %721
%723 = load double, double* %722
%724 = load i32, i32* %59
%725 = add nsw i32 %724, 1
%726 = sext i32 %725 to i64
%727 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %726
%728 = load double, double* %727
%729 = fsub double %723, %728
%730 = load i32, i32* %59
%731 = sitofp i32 %730 to double
%732 = fsub double %729, %731
%733 = load i32, i32* %59
%734 = sext i32 %733 to i64
%735 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %734
store double %732, double* %735
%736 = load i32, i32* %59
%737 = call i32 (...) @omp_get_num_threads()
%738 = sub nsw i32 %737, 1
%739 = icmp slt i32 %736, %738
br i1 %739, label %740, label %750
740: ; preds = %715
%741 = load i32, i32* %59
%742 = sext i32 %741 to i64
%743 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %742
%744 = load double, double* %743
%745 = load i32, i32* %59
%746 = sext i32 %745 to i64
%747 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %746
%748 = load double, double* %747
%749 = fadd double %748, %744
store double %749, double* %747
br label %750
750: ; preds = %740, %715
store i32 0, i32* %67
store i32 0, i32* %66
br label %751
751: ; preds = %776, %750
%752 = load i32, i32* %66
%753 = getelementptr inbounds [1 x i32], [1 x i32]* %26, i64 0, i64 0
%754 = load i32, i32* %753
%755 = sub nsw i32 %754, 1
%756 = icmp slt i32 %752, %755
br i1 %756, label %757, label %779
757: ; preds = %751
%758 = load i32, i32* %66
%759 = sext i32 %758 to i64
%760 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %759
%761 = load double, double* %760
%762 = fcmp une double %761, 5.000000e+00
br i1 %762, label %763, label %775
763: ; preds = %757
%764 = load i32, i32* %66
%765 = load i32, i32* %66
%766 = sext i32 %765 to i64
%767 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %766
%768 = load double, double* %767
%769 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %764, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 5, double %768)
store i32 1, i32* %27
%770 = load i32, i32* %67
%771 = add nsw i32 %770, 1
store i32 %771, i32* %67
%772 = icmp sgt i32 %770, 10
br i1 %772, label %773, label %774
773: ; preds = %763
br label %779
774: ; preds = %763
br label %775
775: ; preds = %774, %757
br label %776
776: ; preds = %775
%777 = load i32, i32* %66
%778 = add nsw i32 %777, 1
store i32 %778, i32* %66
br label %751
779: ; preds = %773, %751
br label %780
780: ; preds = %779
%781 = load i32, i32* %29
%782 = add nsw i32 %781, 1
store i32 %782, i32* %29
br label %306
783: ; preds = %312
%784 = load i32, i32* %27
%785 = icmp ne i32 %784, 0
br i1 %785, label %786, label %788
786: ; preds = %783
%787 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %790
788: ; preds = %783
%789 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %790
790: ; preds = %788, %786
br label %791
791: ; preds = %790
%792 = load i32, i32* %25
%793 = add nsw i32 %792, 1
store i32 %793, i32* %25
br label %299
794: ; preds = %299
store i32 0, i32* %68
br label %795
795: ; preds = %803, %794
%796 = load i32, i32* %68
%797 = load i32, i32* %9
%798 = load i32, i32* %11
%799 = sub nsw i32 %797, %798
%800 = icmp slt i32 %796, %799
br i1 %800, label %801, label %806
801: ; preds = %795
%802 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %803
803: ; preds = %801
%804 = load i32, i32* %68
%805 = add nsw i32 %804, 1
store i32 %805, i32* %68
br label %795
806: ; preds = %795
store i32 0, i32* %69
store i32 0, i32* %71
br label %807
807: ; preds = %960, %806
%808 = load i32, i32* %71
%809 = icmp slt i32 %808, 1
br i1 %809, label %810, label %813
810: ; preds = %807
%811 = load i32, i32* %69
%812 = icmp eq i32 %811, 0
br label %813
813: ; preds = %810, %807
%814 = phi i1 [ false, %807 ], [ %812, %810 ]
br i1 %814, label %815, label %963
815: ; preds = %813
store i32 0, i32* %72
br label %816
816: ; preds = %823, %815
%817 = load i32, i32* %72
%818 = icmp slt i32 %817, 992
br i1 %818, label %819, label %826
819: ; preds = %816
%820 = load i32, i32* %72
%821 = sext i32 %820 to i64
%822 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %821
store double 0.000000e+00, double* %822
br label %823
823: ; preds = %819
%824 = load i32, i32* %72
%825 = add nsw i32 %824, 1
store i32 %825, i32* %72
br label %816
826: ; preds = %816
store i32 2, i32* %73
br label %827
827: ; preds = %919, %826
%828 = load i32, i32* %73
%829 = load i32, i32* %11
%830 = icmp sle i32 %828, %829
br i1 %830, label %831, label %922
831: ; preds = %827
%832 = load i32, i32* %73
%833 = getelementptr inbounds [1 x i32], [1 x i32]* %74, i64 0, i64 0
store i32 %832, i32* %833
%834 = call i32 (...) @omp_get_thread_num()
store i32 %834, i32* %75
%835 = call i32 (...) @omp_get_num_threads()
%836 = sdiv i32 992, %835
store i32 %836, i32* %76
%837 = load i32, i32* %75
%838 = load i32, i32* %76
%839 = mul nsw i32 %837, %838
store i32 %839, i32* %77
%840 = load i32, i32* %75
%841 = add nsw i32 %840, 1
%842 = load i32, i32* %76
%843 = mul nsw i32 %841, %842
store i32 %843, i32* %78
%844 = load i32, i32* %78
%845 = icmp sgt i32 %844, 992
br i1 %845, label %846, label %847
846: ; preds = %831
br label %849
847: ; preds = %831
%848 = load i32, i32* %78
br label %849
849: ; preds = %847, %846
%850 = phi i32 [ 992, %846 ], [ %848, %847 ]
store i32 %850, i32* %78
%851 = load i32, i32* %77
store i32 %851, i32* %79
br label %852
852: ; preds = %864, %849
%853 = load i32, i32* %79
%854 = load i32, i32* %78
%855 = icmp slt i32 %853, %854
br i1 %855, label %856, label %867
856: ; preds = %852
%857 = load i32, i32* %79
%858 = sext i32 %857 to i64
%859 = getelementptr inbounds [994 x double], [994 x double]* %5, i64 0, i64 %858
%860 = load double, double* %859
%861 = load i32, i32* %79
%862 = sext i32 %861 to i64
%863 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %862
store double %860, double* %863
br label %864
864: ; preds = %856
%865 = load i32, i32* %79
%866 = add nsw i32 %865, 1
store i32 %866, i32* %79
br label %852
867: ; preds = %852
store double 0.000000e+00, double* %80
%868 = load i32, i32* %75
%869 = add nsw i32 1, %868
store i32 %869, i32* %81
br label %870
870: ; preds = %880, %867
%871 = load i32, i32* %81
%872 = icmp slt i32 %871, 992
br i1 %872, label %873, label %883
873: ; preds = %870
%874 = load i32, i32* %81
%875 = sext i32 %874 to i64
%876 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %875
%877 = load double, double* %876
%878 = load double, double* %80
%879 = fadd double %878, %877
store double %879, double* %80
br label %880
880: ; preds = %873
%881 = load i32, i32* %81
%882 = add nsw i32 %881, 1
store i32 %882, i32* %81
br label %870
883: ; preds = %870
%884 = load double, double* %80
%885 = load i32, i32* %75
%886 = sext i32 %885 to i64
%887 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %886
store double %884, double* %887
%888 = load i32, i32* %75
%889 = sext i32 %888 to i64
%890 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %889
%891 = load double, double* %890
%892 = load i32, i32* %75
%893 = add nsw i32 %892, 1
%894 = sext i32 %893 to i64
%895 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %894
%896 = load double, double* %895
%897 = fsub double %891, %896
%898 = load i32, i32* %75
%899 = sitofp i32 %898 to double
%900 = fsub double %897, %899
%901 = load i32, i32* %75
%902 = sext i32 %901 to i64
%903 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %902
store double %900, double* %903
%904 = load i32, i32* %75
%905 = call i32 (...) @omp_get_num_threads()
%906 = sub nsw i32 %905, 1
%907 = icmp slt i32 %904, %906
br i1 %907, label %908, label %918
908: ; preds = %883
%909 = load i32, i32* %75
%910 = sext i32 %909 to i64
%911 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %910
%912 = load double, double* %911
%913 = load i32, i32* %75
%914 = sext i32 %913 to i64
%915 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %914
%916 = load double, double* %915
%917 = fadd double %916, %912
store double %917, double* %915
br label %918
918: ; preds = %908, %883
br label %919
919: ; preds = %918
%920 = load i32, i32* %73
%921 = add nsw i32 %920, 1
store i32 %921, i32* %73
br label %827
922: ; preds = %827
store i32 0, i32* %83
store i32 0, i32* %82
br label %923
923: ; preds = %956, %922
%924 = load i32, i32* %82
%925 = load i32, i32* %11
%926 = sub nsw i32 %925, 1
%927 = icmp slt i32 %924, %926
br i1 %927, label %928, label %959
928: ; preds = %923
%929 = load i32, i32* %82
%930 = sext i32 %929 to i64
%931 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %930
%932 = load double, double* %931
%933 = load i32, i32* %11
%934 = load i32, i32* %82
%935 = sub nsw i32 %933, %934
%936 = sub nsw i32 %935, 1
%937 = sitofp i32 %936 to double
%938 = fcmp une double %932, %937
br i1 %938, label %939, label %955
939: ; preds = %928
%940 = load i32, i32* %82
%941 = load i32, i32* %11
%942 = load i32, i32* %82
%943 = sub nsw i32 %941, %942
%944 = sub nsw i32 %943, 1
%945 = load i32, i32* %82
%946 = sext i32 %945 to i64
%947 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %946
%948 = load double, double* %947
%949 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %940, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 %944, double %948)
store i32 1, i32* %69
%950 = load i32, i32* %83
%951 = add nsw i32 %950, 1
store i32 %951, i32* %83
%952 = icmp sgt i32 %950, 10
br i1 %952, label %953, label %954
953: ; preds = %939
br label %959
954: ; preds = %939
br label %955
955: ; preds = %954, %928
br label %956
956: ; preds = %955
%957 = load i32, i32* %82
%958 = add nsw i32 %957, 1
store i32 %958, i32* %82
br label %923
959: ; preds = %953, %923
br label %960
960: ; preds = %959
%961 = load i32, i32* %71
%962 = add nsw i32 %961, 1
store i32 %962, i32* %71
br label %807
963: ; preds = %813
%964 = load i32, i32* %69
%965 = icmp ne i32 %964, 0
br i1 %965, label %966, label %968
966: ; preds = %963
%967 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %970
968: ; preds = %963
%969 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %970
970: ; preds = %968, %966
store i32 0, i32* %84
store i32 0, i32* %86
br label %971
971: ; preds = %1102, %970
%972 = load i32, i32* %86
%973 = icmp slt i32 %972, 1
br i1 %973, label %974, label %977
974: ; preds = %971
%975 = load i32, i32* %84
%976 = icmp eq i32 %975, 0
br label %977
977: ; preds = %974, %971
%978 = phi i1 [ false, %971 ], [ %976, %974 ]
br i1 %978, label %979, label %1105
979: ; preds = %977
store i32 0, i32* %87
br label %980
980: ; preds = %987, %979
%981 = load i32, i32* %87
%982 = icmp slt i32 %981, 992
br i1 %982, label %983, label %990
983: ; preds = %980
%984 = load i32, i32* %87
%985 = sext i32 %984 to i64
%986 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %985
store double 0.000000e+00, double* %986
br label %987
987: ; preds = %983
%988 = load i32, i32* %87
%989 = add nsw i32 %988, 1
store i32 %989, i32* %87
br label %980
990: ; preds = %980
%991 = call i32 (...) @omp_get_thread_num()
store i32 %991, i32* %88
%992 = call i32 (...) @omp_get_num_threads()
%993 = sdiv i32 992, %992
store i32 %993, i32* %89
%994 = load i32, i32* %88
%995 = load i32, i32* %89
%996 = mul nsw i32 %994, %995
store i32 %996, i32* %90
%997 = load i32, i32* %88
%998 = add nsw i32 %997, 1
%999 = load i32, i32* %89
%1000 = mul nsw i32 %998, %999
store i32 %1000, i32* %91
%1001 = load i32, i32* %91
%1002 = icmp sgt i32 %1001, 992
br i1 %1002, label %1003, label %1004
1003: ; preds = %990
br label %1006
1004: ; preds = %990
%1005 = load i32, i32* %91
br label %1006
1006: ; preds = %1004, %1003
%1007 = phi i32 [ 992, %1003 ], [ %1005, %1004 ]
store i32 %1007, i32* %91
%1008 = load i32, i32* %90
store i32 %1008, i32* %92
br label %1009
1009: ; preds = %1021, %1006
%1010 = load i32, i32* %92
%1011 = load i32, i32* %91
%1012 = icmp slt i32 %1010, %1011
br i1 %1012, label %1013, label %1024
1013: ; preds = %1009
%1014 = load i32, i32* %92
%1015 = sext i32 %1014 to i64
%1016 = getelementptr inbounds [994 x double], [994 x double]* %5, i64 0, i64 %1015
%1017 = load double, double* %1016
%1018 = load i32, i32* %92
%1019 = sext i32 %1018 to i64
%1020 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %1019
store double %1017, double* %1020
br label %1021
1021: ; preds = %1013
%1022 = load i32, i32* %92
%1023 = add nsw i32 %1022, 1
store i32 %1023, i32* %92
br label %1009
1024: ; preds = %1009
store double 0.000000e+00, double* %93
%1025 = load i32, i32* %88
%1026 = add nsw i32 1, %1025
store i32 %1026, i32* %94
br label %1027
1027: ; preds = %1037, %1024
%1028 = load i32, i32* %94
%1029 = icmp slt i32 %1028, 992
br i1 %1029, label %1030, label %1040
1030: ; preds = %1027
%1031 = load i32, i32* %94
%1032 = sext i32 %1031 to i64
%1033 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %1032
%1034 = load double, double* %1033
%1035 = load double, double* %93
%1036 = fadd double %1035, %1034
store double %1036, double* %93
br label %1037
1037: ; preds = %1030
%1038 = load i32, i32* %94
%1039 = add nsw i32 %1038, 1
store i32 %1039, i32* %94
br label %1027
1040: ; preds = %1027
%1041 = load double, double* %93
%1042 = load i32, i32* %88
%1043 = sext i32 %1042 to i64
%1044 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %1043
store double %1041, double* %1044
%1045 = load i32, i32* %88
%1046 = sext i32 %1045 to i64
%1047 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %1046
%1048 = load double, double* %1047
%1049 = load i32, i32* %88
%1050 = add nsw i32 %1049, 1
%1051 = sext i32 %1050 to i64
%1052 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %1051
%1053 = load double, double* %1052
%1054 = fsub double %1048, %1053
%1055 = load i32, i32* %88
%1056 = sitofp i32 %1055 to double
%1057 = fsub double %1054, %1056
%1058 = load i32, i32* %88
%1059 = sext i32 %1058 to i64
%1060 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %1059
store double %1057, double* %1060
%1061 = load i32, i32* %88
%1062 = call i32 (...) @omp_get_num_threads()
%1063 = sub nsw i32 %1062, 1
%1064 = icmp slt i32 %1061, %1063
br i1 %1064, label %1065, label %1075
1065: ; preds = %1040
%1066 = load i32, i32* %88
%1067 = sext i32 %1066 to i64
%1068 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %1067
%1069 = load double, double* %1068
%1070 = load i32, i32* %88
%1071 = sext i32 %1070 to i64
%1072 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %1071
%1073 = load double, double* %1072
%1074 = fadd double %1073, %1069
store double %1074, double* %1072
br label %1075
1075: ; preds = %1065, %1040
store i32 0, i32* %96
store i32 0, i32* %95
br label %1076
1076: ; preds = %1098, %1075
%1077 = load i32, i32* %95
%1078 = icmp slt i32 %1077, 1
br i1 %1078, label %1079, label %1101
1079: ; preds = %1076
%1080 = load i32, i32* %95
%1081 = sext i32 %1080 to i64
%1082 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %1081
%1083 = load double, double* %1082
%1084 = fcmp une double %1083, 4.915350e+05
br i1 %1084, label %1085, label %1097
1085: ; preds = %1079
%1086 = load i32, i32* %95
%1087 = load i32, i32* %95
%1088 = sext i32 %1087 to i64
%1089 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %1088
%1090 = load double, double* %1089
%1091 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %1086, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), i32 491535, double %1090)
store i32 1, i32* %84
%1092 = load i32, i32* %96
%1093 = add nsw i32 %1092, 1
store i32 %1093, i32* %96
%1094 = icmp sgt i32 %1092, 10
br i1 %1094, label %1095, label %1096
1095: ; preds = %1085
br label %1101
1096: ; preds = %1085
br label %1097
1097: ; preds = %1096, %1079
br label %1098
1098: ; preds = %1097
%1099 = load i32, i32* %95
%1100 = add nsw i32 %1099, 1
store i32 %1100, i32* %95
br label %1076
1101: ; preds = %1095, %1076
br label %1102
1102: ; preds = %1101
%1103 = load i32, i32* %86
%1104 = add nsw i32 %1103, 1
store i32 %1104, i32* %86
br label %971
1105: ; preds = %977
%1106 = load i32, i32* %84
%1107 = icmp ne i32 %1106, 0
br i1 %1107, label %1108, label %1110
1108: ; preds = %1105
%1109 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %1112
1110: ; preds = %1105
%1111 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %1112
1112: ; preds = %1110, %1108
store i32 2, i32* %97
br label %1113
1113: ; preds = %1270, %1112
%1114 = load i32, i32* %97
%1115 = load i32, i32* %11
%1116 = icmp sle i32 %1114, %1115
br i1 %1116, label %1117, label %1273
1117: ; preds = %1113
store i32 0, i32* %98
br label %1118
1118: ; preds = %1125, %1117
%1119 = load i32, i32* %98
%1120 = icmp slt i32 %1119, 992
br i1 %1120, label %1121, label %1128
1121: ; preds = %1118
%1122 = load i32, i32* %98
%1123 = sext i32 %1122 to i64
%1124 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %1123
store double 0.000000e+00, double* %1124
br label %1125
1125: ; preds = %1121
%1126 = load i32, i32* %98
%1127 = add nsw i32 %1126, 1
store i32 %1127, i32* %98
br label %1118
1128: ; preds = %1118
%1129 = load i32, i32* %97
store i32 %1129, i32* %99
store i32 0, i32* %100
store i32 0, i32* %102
br label %1130
1130: ; preds = %1259, %1128
%1131 = load i32, i32* %102
%1132 = icmp slt i32 %1131, 1
br i1 %1132, label %1133, label %1136
1133: ; preds = %1130
%1134 = load i32, i32* %100
%1135 = icmp eq i32 %1134, 0
br label %1136
1136: ; preds = %1133, %1130
%1137 = phi i1 [ false, %1130 ], [ %1135, %1133 ]
br i1 %1137, label %1138, label %1262
1138: ; preds = %1136
%1139 = call i32 (...) @omp_get_thread_num()
store i32 %1139, i32* %103
%1140 = call i32 (...) @omp_get_num_threads()
%1141 = sdiv i32 992, %1140
store i32 %1141, i32* %104
%1142 = load i32, i32* %103
%1143 = load i32, i32* %104
%1144 = mul nsw i32 %1142, %1143
store i32 %1144, i32* %105
%1145 = load i32, i32* %103
%1146 = add nsw i32 %1145, 1
%1147 = load i32, i32* %104
%1148 = mul nsw i32 %1146, %1147
store i32 %1148, i32* %106
%1149 = load i32, i32* %106
%1150 = icmp sgt i32 %1149, 992
br i1 %1150, label %1151, label %1152
1151: ; preds = %1138
br label %1154
1152: ; preds = %1138
%1153 = load i32, i32* %106
br label %1154
1154: ; preds = %1152, %1151
%1155 = phi i32 [ 992, %1151 ], [ %1153, %1152 ]
store i32 %1155, i32* %106
%1156 = load i32, i32* %105
store i32 %1156, i32* %107
br label %1157
1157: ; preds = %1169, %1154
%1158 = load i32, i32* %107
%1159 = load i32, i32* %106
%1160 = icmp slt i32 %1158, %1159
br i1 %1160, label %1161, label %1172
1161: ; preds = %1157
%1162 = load i32, i32* %107
%1163 = sext i32 %1162 to i64
%1164 = getelementptr inbounds [994 x double], [994 x double]* %5, i64 0, i64 %1163
%1165 = load double, double* %1164
%1166 = load i32, i32* %107
%1167 = sext i32 %1166 to i64
%1168 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %1167
store double %1165, double* %1168
br label %1169
1169: ; preds = %1161
%1170 = load i32, i32* %107
%1171 = add nsw i32 %1170, 1
store i32 %1171, i32* %107
br label %1157
1172: ; preds = %1157
store double 0.000000e+00, double* %108
%1173 = load i32, i32* %103
%1174 = add nsw i32 1, %1173
store i32 %1174, i32* %109
br label %1175
1175: ; preds = %1185, %1172
%1176 = load i32, i32* %109
%1177 = icmp slt i32 %1176, 992
br i1 %1177, label %1178, label %1188
1178: ; preds = %1175
%1179 = load i32, i32* %109
%1180 = sext i32 %1179 to i64
%1181 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %1180
%1182 = load double, double* %1181
%1183 = load double, double* %108
%1184 = fadd double %1183, %1182
store double %1184, double* %108
br label %1185
1185: ; preds = %1178
%1186 = load i32, i32* %109
%1187 = add nsw i32 %1186, 1
store i32 %1187, i32* %109
br label %1175
1188: ; preds = %1175
%1189 = load double, double* %108
%1190 = load i32, i32* %103
%1191 = sext i32 %1190 to i64
%1192 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %1191
store double %1189, double* %1192
%1193 = load i32, i32* %103
%1194 = sext i32 %1193 to i64
%1195 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %1194
%1196 = load double, double* %1195
%1197 = load i32, i32* %103
%1198 = add nsw i32 %1197, 1
%1199 = sext i32 %1198 to i64
%1200 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %1199
%1201 = load double, double* %1200
%1202 = fsub double %1196, %1201
%1203 = load i32, i32* %103
%1204 = sitofp i32 %1203 to double
%1205 = fsub double %1202, %1204
%1206 = load i32, i32* %103
%1207 = sext i32 %1206 to i64
%1208 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %1207
store double %1205, double* %1208
%1209 = load i32, i32* %103
%1210 = call i32 (...) @omp_get_num_threads()
%1211 = sub nsw i32 %1210, 1
%1212 = icmp slt i32 %1209, %1211
br i1 %1212, label %1213, label %1223
1213: ; preds = %1188
%1214 = load i32, i32* %103
%1215 = sext i32 %1214 to i64
%1216 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %1215
%1217 = load double, double* %1216
%1218 = load i32, i32* %103
%1219 = sext i32 %1218 to i64
%1220 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %1219
%1221 = load double, double* %1220
%1222 = fadd double %1221, %1217
store double %1222, double* %1220
br label %1223
1223: ; preds = %1213, %1188
store i32 0, i32* %111
store i32 0, i32* %110
br label %1224
1224: ; preds = %1255, %1223
%1225 = load i32, i32* %110
%1226 = load i32, i32* %97
%1227 = sub nsw i32 %1226, 1
%1228 = icmp slt i32 %1225, %1227
br i1 %1228, label %1229, label %1258
1229: ; preds = %1224
%1230 = load i32, i32* %110
%1231 = sext i32 %1230 to i64
%1232 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %1231
%1233 = load double, double* %1232
%1234 = load i32, i32* %102
%1235 = add nsw i32 %1234, 1
%1236 = mul nsw i32 %1235, 1
%1237 = sitofp i32 %1236 to double
%1238 = fcmp une double %1233, %1237
br i1 %1238, label %1239, label %1254
1239: ; preds = %1229
%1240 = load i32, i32* %110
%1241 = load i32, i32* %102
%1242 = add nsw i32 %1241, 1
%1243 = mul nsw i32 %1242, 1
%1244 = load i32, i32* %110
%1245 = sext i32 %1244 to i64
%1246 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %1245
%1247 = load double, double* %1246
%1248 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %1240, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 %1243, double %1247)
store i32 1, i32* %100
%1249 = load i32, i32* %111
%1250 = add nsw i32 %1249, 1
store i32 %1250, i32* %111
%1251 = icmp sgt i32 %1249, 10
br i1 %1251, label %1252, label %1253
1252: ; preds = %1239
br label %1258
1253: ; preds = %1239
br label %1254
1254: ; preds = %1253, %1229
br label %1255
1255: ; preds = %1254
%1256 = load i32, i32* %110
%1257 = add nsw i32 %1256, 1
store i32 %1257, i32* %110
br label %1224
1258: ; preds = %1252, %1224
br label %1259
1259: ; preds = %1258
%1260 = load i32, i32* %102
%1261 = add nsw i32 %1260, 1
store i32 %1261, i32* %102
br label %1130
1262: ; preds = %1136
%1263 = load i32, i32* %100
%1264 = icmp ne i32 %1263, 0
br i1 %1264, label %1265, label %1267
1265: ; preds = %1262
%1266 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %1269
1267: ; preds = %1262
%1268 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %1269
1269: ; preds = %1267, %1265
br label %1270
1270: ; preds = %1269
%1271 = load i32, i32* %97
%1272 = add nsw i32 %1271, 1
store i32 %1272, i32* %97
br label %1113
1273: ; preds = %1113
store i32 0, i32* %112
br label %1274
1274: ; preds = %1282, %1273
%1275 = load i32, i32* %112
%1276 = load i32, i32* %9
%1277 = load i32, i32* %11
%1278 = sub nsw i32 %1276, %1277
%1279 = icmp slt i32 %1275, %1278
br i1 %1279, label %1280, label %1285
1280: ; preds = %1274
%1281 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %1282
1282: ; preds = %1280
%1283 = load i32, i32* %112
%1284 = add nsw i32 %1283, 1
store i32 %1284, i32* %112
br label %1274
1285: ; preds = %1274
%1286 = load i64, i64* %8
%1287 = icmp ne i64 %1286, 0
br i1 %1287, label %1470, label %1288
1288: ; preds = %1285
store i32 0, i32* %113
br label %1289
1289: ; preds = %1296, %1288
%1290 = load i32, i32* %113
%1291 = icmp slt i32 %1290, 992
br i1 %1291, label %1292, label %1299
1292: ; preds = %1289
%1293 = load i32, i32* %113
%1294 = sext i32 %1293 to i64
%1295 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %1294
store double 0.000000e+00, double* %1295
br label %1296
1296: ; preds = %1292
%1297 = load i32, i32* %113
%1298 = add nsw i32 %1297, 1
store i32 %1298, i32* %113
br label %1289
1299: ; preds = %1289
store i32 0, i32* %114
store i32 0, i32* %116
br label %1300
1300: ; preds = %1459, %1299
%1301 = load i32, i32* %116
%1302 = icmp slt i32 %1301, 1
br i1 %1302, label %1303, label %1306
1303: ; preds = %1300
%1304 = load i32, i32* %114
%1305 = icmp eq i32 %1304, 0
br label %1306
1306: ; preds = %1303, %1300
%1307 = phi i1 [ false, %1300 ], [ %1305, %1303 ]
br i1 %1307, label %1308, label %1462
1308: ; preds = %1306
%1309 = call i32 (...) @omp_get_thread_num()
%1310 = mul nsw i32 %1309, 16
store i32 %1310, i32* %117
%1311 = call i32 (...) @omp_get_thread_num()
store i32 %1311, i32* %118
%1312 = call i32 (...) @omp_get_num_threads()
%1313 = sdiv i32 992, %1312
store i32 %1313, i32* %119
%1314 = load i32, i32* %118
%1315 = load i32, i32* %119
%1316 = mul nsw i32 %1314, %1315
store i32 %1316, i32* %120
%1317 = load i32, i32* %118
%1318 = add nsw i32 %1317, 1
%1319 = load i32, i32* %119
%1320 = mul nsw i32 %1318, %1319
store i32 %1320, i32* %121
%1321 = load i32, i32* %121
%1322 = icmp sgt i32 %1321, 992
br i1 %1322, label %1323, label %1324
1323: ; preds = %1308
br label %1326
1324: ; preds = %1308
%1325 = load i32, i32* %121
br label %1326
1326: ; preds = %1324, %1323
%1327 = phi i32 [ 992, %1323 ], [ %1325, %1324 ]
store i32 %1327, i32* %121
%1328 = load i32, i32* %120
store i32 %1328, i32* %122
br label %1329
1329: ; preds = %1341, %1326
%1330 = load i32, i32* %122
%1331 = load i32, i32* %121
%1332 = icmp slt i32 %1330, %1331
br i1 %1332, label %1333, label %1344
1333: ; preds = %1329
%1334 = load i32, i32* %122
%1335 = sext i32 %1334 to i64
%1336 = getelementptr inbounds [994 x double], [994 x double]* %5, i64 0, i64 %1335
%1337 = load double, double* %1336
%1338 = load i32, i32* %122
%1339 = sext i32 %1338 to i64
%1340 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %1339
store double %1337, double* %1340
br label %1341
1341: ; preds = %1333
%1342 = load i32, i32* %122
%1343 = add nsw i32 %1342, 1
store i32 %1343, i32* %122
br label %1329
1344: ; preds = %1329
store double 0.000000e+00, double* %123
%1345 = load i32, i32* %118
%1346 = add nsw i32 1, %1345
store i32 %1346, i32* %124
br label %1347
1347: ; preds = %1357, %1344
%1348 = load i32, i32* %124
%1349 = icmp slt i32 %1348, 992
br i1 %1349, label %1350, label %1360
1350: ; preds = %1347
%1351 = load i32, i32* %124
%1352 = sext i32 %1351 to i64
%1353 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %1352
%1354 = load double, double* %1353
%1355 = load double, double* %123
%1356 = fadd double %1355, %1354
store double %1356, double* %123
br label %1357
1357: ; preds = %1350
%1358 = load i32, i32* %124
%1359 = add nsw i32 %1358, 1
store i32 %1359, i32* %124
br label %1347
1360: ; preds = %1347
%1361 = load double, double* %123
%1362 = load i32, i32* %118
%1363 = sext i32 %1362 to i64
%1364 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %1363
store double %1361, double* %1364
%1365 = load i32, i32* %118
%1366 = sext i32 %1365 to i64
%1367 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %1366
%1368 = load double, double* %1367
%1369 = load i32, i32* %118
%1370 = add nsw i32 %1369, 1
%1371 = sext i32 %1370 to i64
%1372 = getelementptr inbounds [994 x double], [994 x double]* %2, i64 0, i64 %1371
%1373 = load double, double* %1372
%1374 = fsub double %1368, %1373
%1375 = load i32, i32* %118
%1376 = sitofp i32 %1375 to double
%1377 = fsub double %1374, %1376
%1378 = load i32, i32* %118
%1379 = sext i32 %1378 to i64
%1380 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %1379
store double %1377, double* %1380
%1381 = load i32, i32* %118
%1382 = call i32 (...) @omp_get_num_threads()
%1383 = sub nsw i32 %1382, 1
%1384 = icmp slt i32 %1381, %1383
br i1 %1384, label %1385, label %1397
1385: ; preds = %1360
%1386 = load i32, i32* %118
%1387 = sext i32 %1386 to i64
%1388 = getelementptr inbounds [994 x double], [994 x double]* %4, i64 0, i64 %1387
%1389 = load double, double* %1388
%1390 = load i32, i32* %117
%1391 = load i32, i32* %118
%1392 = add nsw i32 %1390, %1391
%1393 = sext i32 %1392 to i64
%1394 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %1393
%1395 = load double, double* %1394
%1396 = fadd double %1395, %1389
store double %1396, double* %1394
br label %1403
1397: ; preds = %1360
%1398 = load i32, i32* %117
%1399 = load i32, i32* %118
%1400 = add nsw i32 %1398, %1399
%1401 = sext i32 %1400 to i64
%1402 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %1401
store double 0.000000e+00, double* %1402
br label %1403
1403: ; preds = %1397, %1385
store i32 0, i32* %126
store i32 0, i32* %125
br label %1404
1404: ; preds = %1455, %1403
%1405 = load i32, i32* %125
%1406 = icmp slt i32 %1405, 256
br i1 %1406, label %1407, label %1458
1407: ; preds = %1404
%1408 = load i32, i32* %125
%1409 = sext i32 %1408 to i64
%1410 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %1409
%1411 = load double, double* %1410
%1412 = load i32, i32* %125
%1413 = icmp sgt i32 %1412, 0
br i1 %1413, label %1414, label %1420
1414: ; preds = %1407
%1415 = load i32, i32* %125
%1416 = add nsw i32 %1415, 1
%1417 = srem i32 %1416, 16
%1418 = icmp eq i32 %1417, 0
br i1 %1418, label %1419, label %1420
1419: ; preds = %1414
br label %1424
1420: ; preds = %1414, %1407
%1421 = load i32, i32* %116
%1422 = add nsw i32 %1421, 1
%1423 = mul nsw i32 %1422, 1
br label %1424
1424: ; preds = %1420, %1419
%1425 = phi i32 [ 0, %1419 ], [ %1423, %1420 ]
%1426 = sitofp i32 %1425 to double
%1427 = fcmp une double %1411, %1426
br i1 %1427, label %1428, label %1454
1428: ; preds = %1424
%1429 = load i32, i32* %125
%1430 = load i32, i32* %125
%1431 = icmp sgt i32 %1430, 0
br i1 %1431, label %1432, label %1438
1432: ; preds = %1428
%1433 = load i32, i32* %125
%1434 = add nsw i32 %1433, 1
%1435 = srem i32 %1434, 16
%1436 = icmp eq i32 %1435, 0
br i1 %1436, label %1437, label %1438
1437: ; preds = %1432
br label %1442
1438: ; preds = %1432, %1428
%1439 = load i32, i32* %116
%1440 = add nsw i32 %1439, 1
%1441 = mul nsw i32 %1440, 1
br label %1442
1442: ; preds = %1438, %1437
%1443 = phi i32 [ 0, %1437 ], [ %1441, %1438 ]
%1444 = load i32, i32* %125
%1445 = sext i32 %1444 to i64
%1446 = getelementptr inbounds [994 x double], [994 x double]* %3, i64 0, i64 %1445
%1447 = load double, double* %1446
%1448 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %1429, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 %1443, double %1447)
store i32 1, i32* %114
%1449 = load i32, i32* %126
%1450 = add nsw i32 %1449, 1
store i32 %1450, i32* %126
%1451 = icmp sgt i32 %1449, 10
br i1 %1451, label %1452, label %1453
1452: ; preds = %1442
br label %1458
1453: ; preds = %1442
br label %1454
1454: ; preds = %1453, %1424
br label %1455
1455: ; preds = %1454
%1456 = load i32, i32* %125
%1457 = add nsw i32 %1456, 1
store i32 %1457, i32* %125
br label %1404
1458: ; preds = %1452, %1404
br label %1459
1459: ; preds = %1458
%1460 = load i32, i32* %116
%1461 = add nsw i32 %1460, 1
store i32 %1461, i32* %116
br label %1300
1462: ; preds = %1306
%1463 = load i32, i32* %114
%1464 = icmp ne i32 %1463, 0
br i1 %1464, label %1465, label %1467
1465: ; preds = %1462
%1466 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %1469
1467: ; preds = %1462
%1468 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %1469
1469: ; preds = %1467, %1465
br label %1480
1470: ; preds = %1285
store i32 0, i32* %127
br label %1471
1471: ; preds = %1476, %1470
%1472 = load i32, i32* %127
%1473 = icmp slt i32 %1472, 1
br i1 %1473, label %1474, label %1479
1474: ; preds = %1471
%1475 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %1476
1476: ; preds = %1474
%1477 = load i32, i32* %127
%1478 = add nsw i32 %1477, 1
store i32 %1478, i32* %127
br label %1471
1479: ; preds = %1471
br label %1480
1480: ; preds = %1479, %1469
%1481 = load i32, i32* %1
ret i32 %1481
}

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