int main(void) {
  check_offloading();
  double A[(992)], B[(992)], C[(992)], D[(992)], E[(992)];
  {
    int i;
    for (i = 0; i < (992); i++) {
      {
        C[i] = 1;
        D[i] = i;
        E[i] = -i;
      }
    }
  };
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };

#pragma omp parallel num_threads(128)
  {
    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 tid = omp_get_thread_num();
      A[tid] += tid;
      {
        int tid = omp_get_thread_num();
        A[tid] += tid;
      }
    }
  }
  {
    int i;
    int errorNum = 0;
    for (i = 0; i < 128; i++) {
      if (A[i] != i * (trial + 1)) {
        printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]",
               i * (trial + 1), A[i]);
        fail = 1;
        if (errorNum++ > 10)
          break;
      }
    }
  }
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;

#pragma omp parallel num_threads(128)
{
  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 i = omp_get_thread_num() * 4;
    for (int j = i; j < i + 4; j++) {
      B[j] = D[j] + E[j];
    }
  }
}
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 512; i++) {
    if (B[i] != (double)0) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "B[i]",
             (double)0, B[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};

#pragma omp parallel num_threads(128) if (0)
{
  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 tid = omp_get_thread_num();
    A[tid] = tid;
  }
}
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 128; i++) {
    if (A[i] != 0) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 0,
             A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};

#pragma omp parallel num_threads(128) if (A[1] == 1)
{
  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 tid = omp_get_thread_num();
    A[tid] = tid;
  }
}
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 128; i++) {
    if (A[i] != 0) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 0,
             A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};

#pragma omp parallel num_threads(128) if (A[1] == 0)
{
  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 tid = omp_get_thread_num();
    A[tid] = tid;
  }
}
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 128; i++) {
    if (A[i] != i) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", i,
             A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;

#pragma omp parallel num_threads(128) proc_bind(master)

#pragma omp parallel num_threads(128) proc_bind(close)

#pragma omp parallel num_threads(128) proc_bind(spread)
{
  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 i = omp_get_thread_num() * 4;
    for (int j = i; j < i + 4; j++) {
      B[j] = 1 + D[j] + E[j];
    }
  }
  {
    int i = omp_get_thread_num() * 4;
    for (int j = i; j < i + 4; j++) {
      B[j] += 1 + D[j] + E[j];
    }
  }
  {
    int i = omp_get_thread_num() * 4;
    for (int j = i; j < i + 4; j++) {
      B[j] += 1 + D[j] + E[j];
    }
  }
}
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 512; i++) {
    if (B[i] != 3) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "B[i]", 3,
             B[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
for (int t = 1; t <= 128; t += t < 32 ? 1 : 32) {
  {
    int i;
    for (i = 0; i < (992); i++) {
      A[i] = 0;
    }
  };
  int threads[1];
  threads[0] = t;

#pragma omp parallel num_threads(threads[0]) if (1)
  {
    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 tid = omp_get_thread_num();
      A[tid] = 99;
    }
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 128; i++) {
    if (A[i] != 99 * (i < t)) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]",
             99 * (i < t), A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
}
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};

#pragma omp parallel if (0)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{double tmp = 1;
    A[0] = tmp;
    {
      tmp = 2;
      A[0] += tmp;
    }
    A[0] += tmp;
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[i] != 5) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 5,
             A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};

#pragma omp parallel private(tmp) if (0)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{double tmp = 1;
    A[0] = tmp;
    {
      tmp = 2;
      A[0] += tmp;
    }
    A[0] += tmp;
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[i] != 4) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 4,
             A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};

#pragma omp parallel firstprivate(tmp) if (0)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{double tmp = 1;
    A[0] = tmp;
    {
      tmp += 2;
      A[0] += tmp;
    }
    A[0] += tmp;
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[i] != 5) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 5,
             A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};

#pragma omp parallel firstprivate(tmp) shared(distance) if (0)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{double tmp = 1;
    A[0] = tmp;
    double distance = 21;
    {
      distance += 9;
      tmp += 2 + distance;
      A[0] += tmp;
    }
    A[0] += tmp + distance;
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[i] != 65) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 65,
             A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};
{
  int i;
  for (i = 0; i < (992); i++) {
    B[i] = 0;
  }
};

#pragma omp parallel num_threads(128)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{for (int i = 0; i < 128; i++){B[i] = 0;
    A[i] = 99 + B[i];
    B[i] = 1;
  }
  {
    int tid = omp_get_thread_num();
    A[tid] += 1;
    B[tid] += 2;
  }
  for (int i = 0; i < 128; i++) {
    A[i] += B[i];
  }
}
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 128; i++) {
    if (A[i] != 103) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 103,
             A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};
{
  int i;
  for (i = 0; i < (992); i++) {
    B[i] = 0;
  }
};

#pragma omp parallel num_threads(128) private(B) if (1)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{for (int i = 0; i < 128; i++){B[i] = 0;
    A[i] = 99 + B[i];
    B[i] = 1;
  }
  {
    int tid = omp_get_thread_num();
    A[tid] += 1;
    B[tid] = 2;
  }
  for (int i = 0; i < 128; i++) {
    A[i] += B[i];
  }
}
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 128; i++) {
    if (A[i] != 101) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 101,
             A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};
{
  int i;
  for (i = 0; i < (992); i++) {
    B[i] = 0;
  }
};

#pragma omp parallel num_threads(128) firstprivate(B)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{for (int i = 0; i < 128; i++){B[i] = 0;
    A[i] = 99 + B[i];
    B[i] = 2;
  }
  {
    int tid = omp_get_thread_num();
    B[tid] += 8;
    A[tid] += B[tid];
  }
  for (int i = 0; i < 128; i++) {
    A[i] += B[i];
  }
}
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 128; i++) {
    if (A[i] != 111) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 111,
             A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};
{
  int i;
  for (i = 0; i < (992); i++) {
    B[i] = 0;
  }
};

#pragma omp parallel firstprivate(B) shared(distance, A) if (0)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{B[0] = 0;
    A[0] = 99 + B[0];
    B[0] = 2;
    double distance[32];
    distance[30] = 21;
    {
      distance[30] += 9;
      B[0] += 8;
      A[0] += B[0] + distance[30];
    }
    A[0] += B[0] + distance[30];
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[i] != 171) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 171,
             A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
struct CITY {
  char name[128];
  int distance_to_nyc;
};
struct CONTEXT {
  struct CITY city;
  double A[(992)];
  double B[(992)];
};
struct CONTEXT data;
strcpy(data.city.name, "dobbs ferry");
data.city.distance_to_nyc = 21;
{
  int i;
  for (i = 0; i < (992); i++) {
    data.A[i] = 0;
  }
};

#pragma omp parallel num_threads(128)
{
  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 tid = omp_get_thread_num();
    data.A[tid] += tid + (int)data.city.name[1] + data.city.distance_to_nyc;
    {
      int tid = omp_get_thread_num();
      data.A[1 + tid] +=
          1 + tid + (int)data.city.name[1] + data.city.distance_to_nyc;
    }
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 128; i++) {
    if (data.A[i] != (132 + i) * (trial + 1)) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "data.A[i]",
             (132 + i) * (trial + 1), data.A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    data.A[i] = 0;
  }
};
{
  int i;
  for (i = 0; i < (992); i++) {
    data.B[i] = 0;
  }
};

#pragma omp parallel num_threads(128)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{for (int i = 0; i < 128; i++){data.B[i] = 0;
    data.A[i] = 99 + data.B[i];
    data.B[i] = 1;
  }
  {
    int tid = omp_get_thread_num();
    data.A[tid] += 1;
    data.B[tid] += 2;
  }
  for (int i = 0; i < 128; i++) {
    data.A[i] += data.B[i];
  }
}
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 128; i++) {
    if (data.A[i] != 103) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "data.A[i]",
             103, data.A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    data.A[i] = 0;
  }
};
{
  int i;
  for (i = 0; i < (992); i++) {
    data.B[i] = 0;
  }
};

#pragma omp parallel num_threads(128) private(data)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{for (int i = 0; i < 128; i++){data.B[i] = 0;
    data.A[i] = 99 + data.B[i];
    data.B[i] = 1;
  }
  {
    int tid = omp_get_thread_num();
    data.A[tid] += 1;
    data.B[tid] = 2;
  }
  for (int i = 0; i < 128; i++) {
    data.A[i] += data.B[i];
  }
}
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (data.A[i] != 100) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "data.A[i]",
             100, data.A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    data.A[i] = 0;
  }
};
{
  int i;
  for (i = 0; i < (992); i++) {
    data.B[i] = 0;
  }
};

#pragma omp parallel firstprivate(data) if (0)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{data.B[0] = 0;
    data.A[0] = 99 + data.B[0];
    data.B[0] = 2;
    double tmp;
    {
      data.B[0] += 8;
      data.A[0] += data.B[0];
      tmp = data.A[0];
    }
    data.A[0] += data.B[0] + tmp;
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (data.A[i] != 210) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "data.A[i]",
             210, data.A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};
{
  int i;
  for (i = 0; i < (992); i++) {
    B[i] = 0;
  }
};

#pragma omp parallel firstprivate(B) shared(city, A) if (0)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{B[0] = 0;
    A[0] = 99 + B[0];
    B[0] = 2;
    struct CITY city;
    city.distance_to_nyc = 21;
    {
      city.distance_to_nyc += 9;
      B[0] += 8;
      A[0] += B[0] + city.distance_to_nyc;
    }
    A[0] += B[0] + city.distance_to_nyc;
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[i] != 171) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 171,
             A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xddf0,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x0,%al
call   1060 <check_offloading@plt>
movl   $0x0,-0x9b14(%rbp)
cmpl   $0x3e0,-0x9b14(%rbp)
jge    11d3 <main+0x93>
movslq -0x9b14(%rbp),%rax
movsd  0x3ea6(%rip),%xmm0
movsd  %xmm0,-0x5d10(%rbp,%rax,8)
ff ff
cvtsi2sdl -0x9b14(%rbp),%xmm0
ff
movslq -0x9b14(%rbp),%rax
movsd  %xmm0,-0x7c10(%rbp,%rax,8)
ff ff
xor    %eax,%eax
sub    -0x9b14(%rbp),%eax
cvtsi2sd %eax,%xmm0
movslq -0x9b14(%rbp),%rax
movsd  %xmm0,-0x9b10(%rbp,%rax,8)
ff ff
mov    -0x9b14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b14(%rbp)
jmp    1163 <main+0x23>
movl   $0x0,-0x9b18(%rbp)
cmpl   $0x3e0,-0x9b18(%rbp)
jge    1214 <main+0xd4>
movslq -0x9b18(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b18(%rbp)
jmp    11dd <main+0x9d>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9b24(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9b24(%rbp)
mov    %al,-0xddd9(%rbp)
jge    124d <main+0x10d>
cmpl   $0x0,-0x9b1c(%rbp)
sete   %al
mov    %al,-0xddd9(%rbp)
mov    -0xddd9(%rbp),%al
test   $0x1,%al
jne    1260 <main+0x120>
jmp    13b8 <main+0x278>
mov    $0x0,%al
call   1040 <omp_get_thread_num@plt>
mov    %eax,-0x9b28(%rbp)
cvtsi2sdl -0x9b28(%rbp),%xmm0
ff
movslq -0x9b28(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    $0x0,%al
call   1040 <omp_get_thread_num@plt>
mov    %eax,-0x9b2c(%rbp)
cvtsi2sdl -0x9b2c(%rbp),%xmm0
ff
movslq -0x9b2c(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9b34(%rbp)
movl   $0x0,-0x9b30(%rbp)
cmpl   $0x80,-0x9b30(%rbp)
jge    139f <main+0x25f>
movslq -0x9b30(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9b30(%rbp),%eax
mov    -0x9b24(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jne    131b <main+0x1db>
jp     131b <main+0x1db>
jmp    1386 <main+0x246>
mov    -0x9b30(%rbp),%esi
mov    -0x9b30(%rbp),%ecx
mov    -0x9b24(%rbp),%eax
add    $0x1,%eax
imul   %eax,%ecx
movslq -0x9b30(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x3d36(%rip),%rdi
lea    0x3d84(%rip),%rdx
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x1,-0x9b1c(%rbp)
mov    -0x9b34(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9b34(%rbp)
cmp    $0xa,%eax
jle    1381 <main+0x241>
jmp    139f <main+0x25f>
jmp    1386 <main+0x246>
jmp    138b <main+0x24b>
mov    -0x9b30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b30(%rbp)
jmp    12d0 <main+0x190>
jmp    13a4 <main+0x264>
mov    -0x9b24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b24(%rbp)
jmp    1228 <main+0xe8>
cmpl   $0x0,-0x9b1c(%rbp)
je     13d8 <main+0x298>
lea    0x3ce0(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    13e6 <main+0x2a6>
lea    0x3cd5(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x9b38(%rbp)
movl   $0x0,-0x9b40(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9b40(%rbp)
mov    %al,-0xddda(%rbp)
jge    141f <main+0x2df>
cmpl   $0x0,-0x9b38(%rbp)
sete   %al
mov    %al,-0xddda(%rbp)
mov    -0xddda(%rbp),%al
test   $0x1,%al
jne    1432 <main+0x2f2>
jmp    1583 <main+0x443>
mov    $0x0,%al
call   1040 <omp_get_thread_num@plt>
shl    $0x2,%eax
mov    %eax,-0x9b44(%rbp)
mov    -0x9b44(%rbp),%eax
mov    %eax,-0x9b48(%rbp)
mov    -0x9b48(%rbp),%eax
mov    -0x9b44(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    14a9 <main+0x369>
movslq -0x9b48(%rbp),%rax
movsd  -0x7c10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b48(%rbp),%rax
addsd  -0x9b10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9b48(%rbp),%rax
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9b48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b48(%rbp)
jmp    144e <main+0x30e>
movl   $0x0,-0x9b50(%rbp)
movl   $0x0,-0x9b4c(%rbp)
cmpl   $0x200,-0x9b4c(%rbp)
jge    156a <main+0x42a>
movslq -0x9b4c(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14f5 <main+0x3b5>
jp     14f5 <main+0x3b5>
jmp    1551 <main+0x411>
mov    -0x9b4c(%rbp),%esi
movslq -0x9b4c(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm1
ff ff
lea    0x3b6e(%rip),%rdi
lea    0x3ba6(%rip),%rdx
xorps  %xmm0,%xmm0
mov    $0x2,%al
call   1050 <printf@plt>
movl   $0x1,-0x9b38(%rbp)
mov    -0x9b50(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9b50(%rbp)
cmp    $0xa,%eax
jle    154c <main+0x40c>
jmp    156a <main+0x42a>
jmp    1551 <main+0x411>
jmp    1556 <main+0x416>
mov    -0x9b4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b4c(%rbp)
jmp    14bd <main+0x37d>
jmp    156f <main+0x42f>
mov    -0x9b40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b40(%rbp)
jmp    13fa <main+0x2ba>
cmpl   $0x0,-0x9b38(%rbp)
je     15a3 <main+0x463>
lea    0x3b15(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    15b1 <main+0x471>
lea    0x3b0a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x9b54(%rbp)
cmpl   $0x3e0,-0x9b54(%rbp)
jge    15f2 <main+0x4b2>
movslq -0x9b54(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b54(%rbp)
jmp    15bb <main+0x47b>
movl   $0x0,-0x9b58(%rbp)
movl   $0x0,-0x9b60(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9b60(%rbp)
mov    %al,-0xdddb(%rbp)
jge    162b <main+0x4eb>
cmpl   $0x0,-0x9b58(%rbp)
sete   %al
mov    %al,-0xdddb(%rbp)
mov    -0xdddb(%rbp),%al
test   $0x1,%al
jne    163e <main+0x4fe>
jmp    173c <main+0x5fc>
mov    $0x0,%al
call   1040 <omp_get_thread_num@plt>
mov    %eax,-0x9b64(%rbp)
cvtsi2sdl -0x9b64(%rbp),%xmm0
ff
movslq -0x9b64(%rbp),%rax
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9b6c(%rbp)
movl   $0x0,-0x9b68(%rbp)
cmpl   $0x80,-0x9b68(%rbp)
jge    1723 <main+0x5e3>
movslq -0x9b68(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    16af <main+0x56f>
jp     16af <main+0x56f>
jmp    170a <main+0x5ca>
mov    -0x9b68(%rbp),%esi
movslq -0x9b68(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x39b4(%rip),%rdi
lea    0x3a02(%rip),%rdx
xor    %ecx,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x1,-0x9b58(%rbp)
mov    -0x9b6c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9b6c(%rbp)
cmp    $0xa,%eax
jle    1705 <main+0x5c5>
jmp    1723 <main+0x5e3>
jmp    170a <main+0x5ca>
jmp    170f <main+0x5cf>
mov    -0x9b68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b68(%rbp)
jmp    1677 <main+0x537>
jmp    1728 <main+0x5e8>
mov    -0x9b60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b60(%rbp)
jmp    1606 <main+0x4c6>
cmpl   $0x0,-0x9b58(%rbp)
je     175c <main+0x61c>
lea    0x395c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    176a <main+0x62a>
lea    0x3951(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x9b70(%rbp)
cmpl   $0x3e0,-0x9b70(%rbp)
jge    17ab <main+0x66b>
movslq -0x9b70(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b70(%rbp)
jmp    1774 <main+0x634>
movl   $0x0,-0x9b74(%rbp)
movl   $0x0,-0x9b7c(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9b7c(%rbp)
mov    %al,-0xdddc(%rbp)
jge    17e4 <main+0x6a4>
cmpl   $0x0,-0x9b74(%rbp)
sete   %al
mov    %al,-0xdddc(%rbp)
mov    -0xdddc(%rbp),%al
test   $0x1,%al
jne    17f7 <main+0x6b7>
jmp    18f5 <main+0x7b5>
mov    $0x0,%al
call   1040 <omp_get_thread_num@plt>
mov    %eax,-0x9b80(%rbp)
cvtsi2sdl -0x9b80(%rbp),%xmm0
ff
movslq -0x9b80(%rbp),%rax
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9b88(%rbp)
movl   $0x0,-0x9b84(%rbp)
cmpl   $0x80,-0x9b84(%rbp)
jge    18dc <main+0x79c>
movslq -0x9b84(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1868 <main+0x728>
jp     1868 <main+0x728>
jmp    18c3 <main+0x783>
mov    -0x9b84(%rbp),%esi
movslq -0x9b84(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x37fb(%rip),%rdi
lea    0x3849(%rip),%rdx
xor    %ecx,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x1,-0x9b74(%rbp)
mov    -0x9b88(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9b88(%rbp)
cmp    $0xa,%eax
jle    18be <main+0x77e>
jmp    18dc <main+0x79c>
jmp    18c3 <main+0x783>
jmp    18c8 <main+0x788>
mov    -0x9b84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b84(%rbp)
jmp    1830 <main+0x6f0>
jmp    18e1 <main+0x7a1>
mov    -0x9b7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b7c(%rbp)
jmp    17bf <main+0x67f>
cmpl   $0x0,-0x9b74(%rbp)
je     1915 <main+0x7d5>
lea    0x37a3(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1923 <main+0x7e3>
lea    0x3798(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x9b8c(%rbp)
cmpl   $0x3e0,-0x9b8c(%rbp)
jge    1964 <main+0x824>
movslq -0x9b8c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b8c(%rbp)
jmp    192d <main+0x7ed>
movl   $0x0,-0x9b90(%rbp)
movl   $0x0,-0x9b98(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9b98(%rbp)
mov    %al,-0xdddd(%rbp)
jge    199d <main+0x85d>
cmpl   $0x0,-0x9b90(%rbp)
sete   %al
mov    %al,-0xdddd(%rbp)
mov    -0xdddd(%rbp),%al
test   $0x1,%al
jne    19b0 <main+0x870>
jmp    1ab7 <main+0x977>
mov    $0x0,%al
call   1040 <omp_get_thread_num@plt>
mov    %eax,-0x9b9c(%rbp)
cvtsi2sdl -0x9b9c(%rbp),%xmm0
ff
movslq -0x9b9c(%rbp),%rax
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9ba4(%rbp)
movl   $0x0,-0x9ba0(%rbp)
cmpl   $0x80,-0x9ba0(%rbp)
jge    1a9e <main+0x95e>
movslq -0x9ba0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
cvtsi2sdl -0x9ba0(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
jne    1a26 <main+0x8e6>
jp     1a26 <main+0x8e6>
jmp    1a85 <main+0x945>
mov    -0x9ba0(%rbp),%esi
mov    -0x9ba0(%rbp),%ecx
movslq -0x9ba0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x3637(%rip),%rdi
lea    0x3685(%rip),%rdx
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x1,-0x9b90(%rbp)
mov    -0x9ba4(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9ba4(%rbp)
cmp    $0xa,%eax
jle    1a80 <main+0x940>
jmp    1a9e <main+0x95e>
jmp    1a85 <main+0x945>
jmp    1a8a <main+0x94a>
mov    -0x9ba0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ba0(%rbp)
jmp    19e9 <main+0x8a9>
jmp    1aa3 <main+0x963>
mov    -0x9b98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b98(%rbp)
jmp    1978 <main+0x838>
cmpl   $0x0,-0x9b90(%rbp)
je     1ad7 <main+0x997>
lea    0x35e1(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1ae5 <main+0x9a5>
lea    0x35d6(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x9ba8(%rbp)
movl   $0x0,-0x9bb0(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9bb0(%rbp)
mov    %al,-0xddde(%rbp)
jge    1b1e <main+0x9de>
cmpl   $0x0,-0x9ba8(%rbp)
sete   %al
mov    %al,-0xddde(%rbp)
mov    -0xddde(%rbp),%al
test   $0x1,%al
jne    1b31 <main+0x9f1>
jmp    1da1 <main+0xc61>
mov    $0x0,%al
call   1040 <omp_get_thread_num@plt>
shl    $0x2,%eax
mov    %eax,-0x9bb4(%rbp)
mov    -0x9bb4(%rbp),%eax
mov    %eax,-0x9bb8(%rbp)
mov    -0x9bb8(%rbp),%eax
mov    -0x9bb4(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    1bb0 <main+0xa70>
movslq -0x9bb8(%rbp),%rax
movsd  0x34b5(%rip),%xmm0
addsd  -0x7c10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bb8(%rbp),%rax
addsd  -0x9b10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bb8(%rbp),%rax
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9bb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bb8(%rbp)
jmp    1b4d <main+0xa0d>
mov    $0x0,%al
call   1040 <omp_get_thread_num@plt>
shl    $0x2,%eax
mov    %eax,-0x9bbc(%rbp)
mov    -0x9bbc(%rbp),%eax
mov    %eax,-0x9bc0(%rbp)
mov    -0x9bc0(%rbp),%eax
mov    -0x9bbc(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    1c38 <main+0xaf8>
movslq -0x9bc0(%rbp),%rax
movsd  0x3436(%rip),%xmm0
addsd  -0x7c10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bc0(%rbp),%rax
addsd  -0x9b10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bc0(%rbp),%rax
addsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9bc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bc0(%rbp)
jmp    1bcc <main+0xa8c>
mov    $0x0,%al
call   1040 <omp_get_thread_num@plt>
shl    $0x2,%eax
mov    %eax,-0x9bc4(%rbp)
mov    -0x9bc4(%rbp),%eax
mov    %eax,-0x9bc8(%rbp)
mov    -0x9bc8(%rbp),%eax
mov    -0x9bc4(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    1cc0 <main+0xb80>
movslq -0x9bc8(%rbp),%rax
movsd  0x33ae(%rip),%xmm0
addsd  -0x7c10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bc8(%rbp),%rax
addsd  -0x9b10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9bc8(%rbp),%rax
addsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9bc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bc8(%rbp)
jmp    1c54 <main+0xb14>
movl   $0x0,-0x9bd0(%rbp)
movl   $0x0,-0x9bcc(%rbp)
cmpl   $0x200,-0x9bcc(%rbp)
jge    1d88 <main+0xc48>
movslq -0x9bcc(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x337c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1d11 <main+0xbd1>
jp     1d11 <main+0xbd1>
jmp    1d6f <main+0xc2f>
mov    -0x9bcc(%rbp),%esi
movslq -0x9bcc(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
lea    0x3352(%rip),%rdi
lea    0x338a(%rip),%rdx
mov    $0x3,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x1,-0x9ba8(%rbp)
mov    -0x9bd0(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9bd0(%rbp)
cmp    $0xa,%eax
jle    1d6a <main+0xc2a>
jmp    1d88 <main+0xc48>
jmp    1d6f <main+0xc2f>
jmp    1d74 <main+0xc34>
mov    -0x9bcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bcc(%rbp)
jmp    1cd4 <main+0xb94>
jmp    1d8d <main+0xc4d>
mov    -0x9bb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bb0(%rbp)
jmp    1af9 <main+0x9b9>
cmpl   $0x0,-0x9ba8(%rbp)
je     1dc1 <main+0xc81>
lea    0x32f7(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1dcf <main+0xc8f>
lea    0x32ec(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x1,-0x9bd4(%rbp)
cmpl   $0x80,-0x9bd4(%rbp)
jg     2007 <main+0xec7>
movl   $0x0,-0x9bd8(%rbp)
cmpl   $0x3e0,-0x9bd8(%rbp)
jge    1e2a <main+0xcea>
movslq -0x9bd8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bd8(%rbp)
jmp    1df3 <main+0xcb3>
mov    -0x9bd4(%rbp),%eax
mov    %eax,-0x9bdc(%rbp)
movl   $0x0,-0x9be0(%rbp)
movl   $0x0,-0x9be8(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9be8(%rbp)
mov    %al,-0xdddf(%rbp)
jge    1e6f <main+0xd2f>
cmpl   $0x0,-0x9be0(%rbp)
sete   %al
mov    %al,-0xdddf(%rbp)
mov    -0xdddf(%rbp),%al
test   $0x1,%al
jne    1e82 <main+0xd42>
jmp    1fad <main+0xe6d>
mov    $0x0,%al
call   1040 <omp_get_thread_num@plt>
mov    %eax,-0x9bec(%rbp)
movslq -0x9bec(%rbp),%rax
movsd  0x3172(%rip),%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9bf4(%rbp)
movl   $0x0,-0x9bf0(%rbp)
cmpl   $0x80,-0x9bf0(%rbp)
jge    1f94 <main+0xe54>
movslq -0x9bf0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
mov    -0x9bf0(%rbp),%eax
cmp    -0x9bd4(%rbp),%eax
setl   %al
and    $0x1,%al
movzbl %al,%eax
imul   $0x63,%eax,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jne    1f0b <main+0xdcb>
jp     1f0b <main+0xdcb>
jmp    1f7b <main+0xe3b>
mov    -0x9bf0(%rbp),%esi
mov    -0x9bf0(%rbp),%eax
cmp    -0x9bd4(%rbp),%eax
setl   %al
and    $0x1,%al
movzbl %al,%eax
imul   $0x63,%eax,%ecx
movslq -0x9bf0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x3141(%rip),%rdi
lea    0x318f(%rip),%rdx
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x1,-0x9be0(%rbp)
mov    -0x9bf4(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9bf4(%rbp)
cmp    $0xa,%eax
jle    1f76 <main+0xe36>
jmp    1f94 <main+0xe54>
jmp    1f7b <main+0xe3b>
jmp    1f80 <main+0xe40>
mov    -0x9bf0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bf0(%rbp)
jmp    1ebb <main+0xd7b>
jmp    1f99 <main+0xe59>
mov    -0x9be8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9be8(%rbp)
jmp    1e4a <main+0xd0a>
cmpl   $0x0,-0x9be0(%rbp)
je     1fcd <main+0xe8d>
lea    0x30eb(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1fdb <main+0xe9b>
lea    0x30e0(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1fe0 <main+0xea0>
mov    -0x9bd4(%rbp),%edx
mov    $0x20,%eax
mov    $0x1,%ecx
cmp    $0x20,%edx
cmovl  %ecx,%eax
add    -0x9bd4(%rbp),%eax
mov    %eax,-0x9bd4(%rbp)
jmp    1dd9 <main+0xc99>
movl   $0x0,-0x9bf8(%rbp)
cmpl   $0x3e0,-0x9bf8(%rbp)
jge    2048 <main+0xf08>
movslq -0x9bf8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bf8(%rbp)
jmp    2011 <main+0xed1>
movl   $0x0,-0x9bfc(%rbp)
movl   $0x0,-0x9c04(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9c04(%rbp)
mov    %al,-0xdde0(%rbp)
jge    2081 <main+0xf41>
cmpl   $0x0,-0x9bfc(%rbp)
sete   %al
mov    %al,-0xdde0(%rbp)
mov    -0xdde0(%rbp),%al
test   $0x1,%al
jne    2094 <main+0xf54>
jmp    21d2 <main+0x1092>
movsd  0x2f8c(%rip),%xmm0
movsd  %xmm0,-0x9c10(%rbp)
ff
movsd  -0x9c10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movsd  0x2f4c(%rip),%xmm0
movsd  %xmm0,-0x9c10(%rbp)
ff
movsd  -0x9c10(%rbp),%xmm0
ff
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movsd  -0x9c10(%rbp),%xmm0
ff
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9c18(%rbp)
movl   $0x0,-0x9c14(%rbp)
cmpl   $0x1,-0x9c14(%rbp)
jge    21b9 <main+0x1079>
movslq -0x9c14(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x2f3b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2142 <main+0x1002>
jp     2142 <main+0x1002>
jmp    21a0 <main+0x1060>
mov    -0x9c14(%rbp),%esi
movslq -0x9c14(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x2f21(%rip),%rdi
lea    0x2f6f(%rip),%rdx
mov    $0x5,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x1,-0x9bfc(%rbp)
mov    -0x9c18(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9c18(%rbp)
cmp    $0xa,%eax
jle    219b <main+0x105b>
jmp    21b9 <main+0x1079>
jmp    21a0 <main+0x1060>
jmp    21a5 <main+0x1065>
mov    -0x9c14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c14(%rbp)
jmp    2108 <main+0xfc8>
jmp    21be <main+0x107e>
mov    -0x9c04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c04(%rbp)
jmp    205c <main+0xf1c>
cmpl   $0x0,-0x9bfc(%rbp)
je     21f2 <main+0x10b2>
lea    0x2ec6(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    2200 <main+0x10c0>
lea    0x2ebb(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x9c1c(%rbp)
cmpl   $0x3e0,-0x9c1c(%rbp)
jge    2241 <main+0x1101>
movslq -0x9c1c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c1c(%rbp)
jmp    220a <main+0x10ca>
movl   $0x0,-0x9c20(%rbp)
movl   $0x0,-0x9c28(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9c28(%rbp)
mov    %al,-0xdde1(%rbp)
jge    227a <main+0x113a>
cmpl   $0x0,-0x9c20(%rbp)
sete   %al
mov    %al,-0xdde1(%rbp)
mov    -0xdde1(%rbp),%al
test   $0x1,%al
jne    228d <main+0x114d>
jmp    23cb <main+0x128b>
movsd  0x2d93(%rip),%xmm0
movsd  %xmm0,-0x9c30(%rbp)
ff
movsd  -0x9c30(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movsd  0x2d53(%rip),%xmm0
movsd  %xmm0,-0x9c30(%rbp)
ff
movsd  -0x9c30(%rbp),%xmm0
ff
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movsd  -0x9c30(%rbp),%xmm0
ff
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9c38(%rbp)
movl   $0x0,-0x9c34(%rbp)
cmpl   $0x1,-0x9c34(%rbp)
jge    23b2 <main+0x1272>
movslq -0x9c34(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x2d4a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    233b <main+0x11fb>
jp     233b <main+0x11fb>
jmp    2399 <main+0x1259>
mov    -0x9c34(%rbp),%esi
movslq -0x9c34(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x2d28(%rip),%rdi
lea    0x2d76(%rip),%rdx
mov    $0x4,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x1,-0x9c20(%rbp)
mov    -0x9c38(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9c38(%rbp)
cmp    $0xa,%eax
jle    2394 <main+0x1254>
jmp    23b2 <main+0x1272>
jmp    2399 <main+0x1259>
jmp    239e <main+0x125e>
mov    -0x9c34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c34(%rbp)
jmp    2301 <main+0x11c1>
jmp    23b7 <main+0x1277>
mov    -0x9c28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c28(%rbp)
jmp    2255 <main+0x1115>
cmpl   $0x0,-0x9c20(%rbp)
je     23eb <main+0x12ab>
lea    0x2ccd(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    23f9 <main+0x12b9>
lea    0x2cc2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x9c3c(%rbp)
cmpl   $0x3e0,-0x9c3c(%rbp)
jge    243a <main+0x12fa>
movslq -0x9c3c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c3c(%rbp)
jmp    2403 <main+0x12c3>
movl   $0x0,-0x9c40(%rbp)
movl   $0x0,-0x9c48(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9c48(%rbp)
mov    %al,-0xdde2(%rbp)
jge    2473 <main+0x1333>
cmpl   $0x0,-0x9c40(%rbp)
sete   %al
mov    %al,-0xdde2(%rbp)
mov    -0xdde2(%rbp),%al
test   $0x1,%al
jne    2486 <main+0x1346>
jmp    25cc <main+0x148c>
movsd  0x2b9a(%rip),%xmm0
movsd  %xmm0,-0x9c50(%rbp)
ff
movsd  -0x9c50(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movsd  0x2b5a(%rip),%xmm0
addsd  -0x9c50(%rbp),%xmm0
ff
movsd  %xmm0,-0x9c50(%rbp)
ff
movsd  -0x9c50(%rbp),%xmm0
ff
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movsd  -0x9c50(%rbp),%xmm0
ff
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9c58(%rbp)
movl   $0x0,-0x9c54(%rbp)
cmpl   $0x1,-0x9c54(%rbp)
jge    25b3 <main+0x1473>
movslq -0x9c54(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x2b41(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    253c <main+0x13fc>
jp     253c <main+0x13fc>
jmp    259a <main+0x145a>
mov    -0x9c54(%rbp),%esi
movslq -0x9c54(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x2b27(%rip),%rdi
lea    0x2b75(%rip),%rdx
mov    $0x5,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x1,-0x9c40(%rbp)
mov    -0x9c58(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9c58(%rbp)
cmp    $0xa,%eax
jle    2595 <main+0x1455>
jmp    25b3 <main+0x1473>
jmp    259a <main+0x145a>
jmp    259f <main+0x145f>
mov    -0x9c54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c54(%rbp)
jmp    2502 <main+0x13c2>
jmp    25b8 <main+0x1478>
mov    -0x9c48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c48(%rbp)
jmp    244e <main+0x130e>
cmpl   $0x0,-0x9c40(%rbp)
je     25ec <main+0x14ac>
lea    0x2acc(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    25fa <main+0x14ba>
lea    0x2ac1(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x9c5c(%rbp)
cmpl   $0x3e0,-0x9c5c(%rbp)
jge    263b <main+0x14fb>
movslq -0x9c5c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c5c(%rbp)
jmp    2604 <main+0x14c4>
movl   $0x0,-0x9c60(%rbp)
movl   $0x0,-0x9c68(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9c68(%rbp)
mov    %al,-0xdde3(%rbp)
jge    2674 <main+0x1534>
cmpl   $0x0,-0x9c60(%rbp)
sete   %al
mov    %al,-0xdde3(%rbp)
mov    -0xdde3(%rbp),%al
test   $0x1,%al
jne    2687 <main+0x1547>
jmp    2805 <main+0x16c5>
movsd  0x2999(%rip),%xmm0
movsd  %xmm0,-0x9c70(%rbp)
ff
movsd  -0x9c70(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movsd  0x2999(%rip),%xmm0
movsd  %xmm0,-0x9c78(%rbp)
ff
movsd  0x2981(%rip),%xmm0
addsd  -0x9c78(%rbp),%xmm0
ff
movsd  %xmm0,-0x9c78(%rbp)
ff
movsd  0x2931(%rip),%xmm0
addsd  -0x9c78(%rbp),%xmm0
ff
addsd  -0x9c70(%rbp),%xmm0
ff
movsd  %xmm0,-0x9c70(%rbp)
ff
movsd  -0x9c70(%rbp),%xmm0
ff
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movsd  -0x9c70(%rbp),%xmm0
ff
addsd  -0x9c78(%rbp),%xmm0
ff
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9c80(%rbp)
movl   $0x0,-0x9c7c(%rbp)
cmpl   $0x1,-0x9c7c(%rbp)
jge    27ec <main+0x16ac>
movslq -0x9c7c(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x2900(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2775 <main+0x1635>
jp     2775 <main+0x1635>
jmp    27d3 <main+0x1693>
mov    -0x9c7c(%rbp),%esi
movslq -0x9c7c(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x28ee(%rip),%rdi
lea    0x293c(%rip),%rdx
mov    $0x41,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x1,-0x9c60(%rbp)
mov    -0x9c80(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9c80(%rbp)
cmp    $0xa,%eax
jle    27ce <main+0x168e>
jmp    27ec <main+0x16ac>
jmp    27d3 <main+0x1693>
jmp    27d8 <main+0x1698>
mov    -0x9c7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c7c(%rbp)
jmp    273b <main+0x15fb>
jmp    27f1 <main+0x16b1>
mov    -0x9c68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c68(%rbp)
jmp    264f <main+0x150f>
cmpl   $0x0,-0x9c60(%rbp)
je     2825 <main+0x16e5>
lea    0x2893(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    2833 <main+0x16f3>
lea    0x2888(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x9c84(%rbp)
cmpl   $0x3e0,-0x9c84(%rbp)
jge    2874 <main+0x1734>
movslq -0x9c84(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c84(%rbp)
jmp    283d <main+0x16fd>
movl   $0x0,-0x9c88(%rbp)
cmpl   $0x3e0,-0x9c88(%rbp)
jge    28b5 <main+0x1775>
movslq -0x9c88(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9c88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c88(%rbp)
jmp    287e <main+0x173e>
movl   $0x0,-0x9c8c(%rbp)
movl   $0x0,-0x9c94(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9c94(%rbp)
mov    %al,-0xdde4(%rbp)
jge    28ee <main+0x17ae>
cmpl   $0x0,-0x9c8c(%rbp)
sete   %al
mov    %al,-0xdde4(%rbp)
mov    -0xdde4(%rbp),%al
test   $0x1,%al
jne    2901 <main+0x17c1>
jmp    2b09 <main+0x19c9>
movl   $0x0,-0x9c98(%rbp)
cmpl   $0x80,-0x9c98(%rbp)
jge    2982 <main+0x1842>
movslq -0x9c98(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
movslq -0x9c98(%rbp),%rax
movsd  0x26d3(%rip),%xmm0
addsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9c98(%rbp),%rax
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movslq -0x9c98(%rbp),%rax
movsd  0x26c3(%rip),%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9c98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c98(%rbp)
jmp    290b <main+0x17cb>
mov    $0x0,%al
call   1040 <omp_get_thread_num@plt>
mov    %eax,-0x9c9c(%rbp)
movslq -0x9c9c(%rbp),%rax
movsd  0x268a(%rip),%xmm0
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movslq -0x9c9c(%rbp),%rax
movsd  0x2649(%rip),%xmm0
addsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9ca0(%rbp)
cmpl   $0x80,-0x9ca0(%rbp)
jge    2a28 <main+0x18e8>
movslq -0x9ca0(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9ca0(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9ca0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ca0(%rbp)
jmp    29db <main+0x189b>
movl   $0x0,-0x9ca8(%rbp)
movl   $0x0,-0x9ca4(%rbp)
cmpl   $0x80,-0x9ca4(%rbp)
jge    2af0 <main+0x19b0>
movslq -0x9ca4(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x25d4(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2a79 <main+0x1939>
jp     2a79 <main+0x1939>
jmp    2ad7 <main+0x1997>
mov    -0x9ca4(%rbp),%esi
movslq -0x9ca4(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x25ea(%rip),%rdi
lea    0x2638(%rip),%rdx
mov    $0x67,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x1,-0x9c8c(%rbp)
mov    -0x9ca8(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9ca8(%rbp)
cmp    $0xa,%eax
jle    2ad2 <main+0x1992>
jmp    2af0 <main+0x19b0>
jmp    2ad7 <main+0x1997>
jmp    2adc <main+0x199c>
mov    -0x9ca4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ca4(%rbp)
jmp    2a3c <main+0x18fc>
jmp    2af5 <main+0x19b5>
mov    -0x9c94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c94(%rbp)
jmp    28c9 <main+0x1789>
cmpl   $0x0,-0x9c8c(%rbp)
je     2b29 <main+0x19e9>
lea    0x258f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    2b37 <main+0x19f7>
lea    0x2584(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x9cac(%rbp)
cmpl   $0x3e0,-0x9cac(%rbp)
jge    2b78 <main+0x1a38>
movslq -0x9cac(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9cac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cac(%rbp)
jmp    2b41 <main+0x1a01>
movl   $0x0,-0x9cb0(%rbp)
cmpl   $0x3e0,-0x9cb0(%rbp)
jge    2bb9 <main+0x1a79>
movslq -0x9cb0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9cb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cb0(%rbp)
jmp    2b82 <main+0x1a42>
movl   $0x0,-0x9cb4(%rbp)
movl   $0x0,-0x9cbc(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9cbc(%rbp)
mov    %al,-0xdde5(%rbp)
jge    2bf2 <main+0x1ab2>
cmpl   $0x0,-0x9cb4(%rbp)
sete   %al
mov    %al,-0xdde5(%rbp)
mov    -0xdde5(%rbp),%al
test   $0x1,%al
jne    2c05 <main+0x1ac5>
jmp    2e04 <main+0x1cc4>
movl   $0x0,-0x9cc0(%rbp)
cmpl   $0x80,-0x9cc0(%rbp)
jge    2c86 <main+0x1b46>
movslq -0x9cc0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
movslq -0x9cc0(%rbp),%rax
movsd  0x23cf(%rip),%xmm0
addsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9cc0(%rbp),%rax
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movslq -0x9cc0(%rbp),%rax
movsd  0x23bf(%rip),%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9cc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cc0(%rbp)
jmp    2c0f <main+0x1acf>
mov    $0x0,%al
call   1040 <omp_get_thread_num@plt>
mov    %eax,-0x9cc4(%rbp)
movslq -0x9cc4(%rbp),%rax
movsd  0x2386(%rip),%xmm0
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movslq -0x9cc4(%rbp),%rax
movsd  0x2345(%rip),%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9cc8(%rbp)
cmpl   $0x80,-0x9cc8(%rbp)
jge    2d23 <main+0x1be3>
movslq -0x9cc8(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9cc8(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9cc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cc8(%rbp)
jmp    2cd6 <main+0x1b96>
movl   $0x0,-0x9cd0(%rbp)
movl   $0x0,-0x9ccc(%rbp)
cmpl   $0x80,-0x9ccc(%rbp)
jge    2deb <main+0x1cab>
movslq -0x9ccc(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x22f9(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2d74 <main+0x1c34>
jp     2d74 <main+0x1c34>
jmp    2dd2 <main+0x1c92>
mov    -0x9ccc(%rbp),%esi
movslq -0x9ccc(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x22ef(%rip),%rdi
lea    0x233d(%rip),%rdx
mov    $0x65,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x1,-0x9cb4(%rbp)
mov    -0x9cd0(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9cd0(%rbp)
cmp    $0xa,%eax
jle    2dcd <main+0x1c8d>
jmp    2deb <main+0x1cab>
jmp    2dd2 <main+0x1c92>
jmp    2dd7 <main+0x1c97>
mov    -0x9ccc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ccc(%rbp)
jmp    2d37 <main+0x1bf7>
jmp    2df0 <main+0x1cb0>
mov    -0x9cbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cbc(%rbp)
jmp    2bcd <main+0x1a8d>
cmpl   $0x0,-0x9cb4(%rbp)
je     2e24 <main+0x1ce4>
lea    0x2294(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    2e32 <main+0x1cf2>
lea    0x2289(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x9cd4(%rbp)
cmpl   $0x3e0,-0x9cd4(%rbp)
jge    2e73 <main+0x1d33>
movslq -0x9cd4(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9cd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cd4(%rbp)
jmp    2e3c <main+0x1cfc>
movl   $0x0,-0x9cd8(%rbp)
cmpl   $0x3e0,-0x9cd8(%rbp)
jge    2eb4 <main+0x1d74>
movslq -0x9cd8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9cd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cd8(%rbp)
jmp    2e7d <main+0x1d3d>
movl   $0x0,-0x9cdc(%rbp)
movl   $0x0,-0x9ce4(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9ce4(%rbp)
mov    %al,-0xdde6(%rbp)
jge    2eed <main+0x1dad>
cmpl   $0x0,-0x9cdc(%rbp)
sete   %al
mov    %al,-0xdde6(%rbp)
mov    -0xdde6(%rbp),%al
test   $0x1,%al
jne    2f00 <main+0x1dc0>
jmp    3110 <main+0x1fd0>
movl   $0x0,-0x9ce8(%rbp)
cmpl   $0x80,-0x9ce8(%rbp)
jge    2f81 <main+0x1e41>
movslq -0x9ce8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
movslq -0x9ce8(%rbp),%rax
movsd  0x20d4(%rip),%xmm0
addsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9ce8(%rbp),%rax
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movslq -0x9ce8(%rbp),%rax
movsd  0x20a4(%rip),%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9ce8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ce8(%rbp)
jmp    2f0a <main+0x1dca>
mov    $0x0,%al
call   1040 <omp_get_thread_num@plt>
mov    %eax,-0x9cec(%rbp)
movslq -0x9cec(%rbp),%rax
movsd  0x2063(%rip),%xmm0
addsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
movslq -0x9cec(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9cec(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
movl   $0x0,-0x9cf0(%rbp)
cmpl   $0x80,-0x9cf0(%rbp)
jge    302f <main+0x1eef>
movslq -0x9cf0(%rbp),%rax
movsd  -0x3e10(%rbp,%rax,8),%xmm0
movslq -0x9cf0(%rbp),%rax
addsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9cf0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cf0(%rbp)
jmp    2fe2 <main+0x1ea2>
movl   $0x0,-0x9cf8(%rbp)
movl   $0x0,-0x9cf4(%rbp)
cmpl   $0x80,-0x9cf4(%rbp)
jge    30f7 <main+0x1fb7>
movslq -0x9cf4(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1fe5(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3080 <main+0x1f40>
jp     3080 <main+0x1f40>
jmp    30de <main+0x1f9e>
mov    -0x9cf4(%rbp),%esi
movslq -0x9cf4(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x1fe3(%rip),%rdi
lea    0x2031(%rip),%rdx
mov    $0x6f,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x1,-0x9cdc(%rbp)
mov    -0x9cf8(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9cf8(%rbp)
cmp    $0xa,%eax
jle    30d9 <main+0x1f99>
jmp    30f7 <main+0x1fb7>
jmp    30de <main+0x1f9e>
jmp    30e3 <main+0x1fa3>
mov    -0x9cf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cf4(%rbp)
jmp    3043 <main+0x1f03>
jmp    30fc <main+0x1fbc>
mov    -0x9ce4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ce4(%rbp)
jmp    2ec8 <main+0x1d88>
cmpl   $0x0,-0x9cdc(%rbp)
je     3130 <main+0x1ff0>
lea    0x1f88(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    313e <main+0x1ffe>
lea    0x1f7d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x9cfc(%rbp)
cmpl   $0x3e0,-0x9cfc(%rbp)
jge    317f <main+0x203f>
movslq -0x9cfc(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9cfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cfc(%rbp)
jmp    3148 <main+0x2008>
movl   $0x0,-0x9d00(%rbp)
cmpl   $0x3e0,-0x9d00(%rbp)
jge    31c0 <main+0x2080>
movslq -0x9d00(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0x9d00(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d00(%rbp)
jmp    3189 <main+0x2049>
movl   $0x0,-0x9d04(%rbp)
movl   $0x0,-0x9d0c(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9d0c(%rbp)
mov    %al,-0xdde7(%rbp)
jge    31f9 <main+0x20b9>
cmpl   $0x0,-0x9d04(%rbp)
sete   %al
mov    %al,-0xdde7(%rbp)
mov    -0xdde7(%rbp),%al
test   $0x1,%al
jne    320c <main+0x20cc>
jmp    339d <main+0x225d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp)
ff
movsd  0x1df1(%rip),%xmm0
addsd  -0x3e10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movsd  0x1dd1(%rip),%xmm0
movsd  %xmm0,-0x3e10(%rbp)
ff
movsd  0x1e01(%rip),%xmm0
movsd  %xmm0,-0x9d20(%rbp)
ff
movsd  0x1de9(%rip),%xmm0
addsd  -0x9d20(%rbp),%xmm0
ff
movsd  %xmm0,-0x9d20(%rbp)
ff
movsd  0x1d91(%rip),%xmm0
addsd  -0x3e10(%rbp),%xmm0
ff
movsd  %xmm0,-0x3e10(%rbp)
ff
movsd  -0x3e10(%rbp),%xmm0
ff
addsd  -0x9d20(%rbp),%xmm0
ff
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movsd  -0x3e10(%rbp),%xmm0
ff
addsd  -0x9d20(%rbp),%xmm0
ff
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9e18(%rbp)
movl   $0x0,-0x9e14(%rbp)
cmpl   $0x1,-0x9e14(%rbp)
jge    3384 <main+0x2244>
movslq -0x9e14(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1d20(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    330d <main+0x21cd>
jp     330d <main+0x21cd>
jmp    336b <main+0x222b>
mov    -0x9e14(%rbp),%esi
movslq -0x9e14(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x1d56(%rip),%rdi
lea    0x1da4(%rip),%rdx
mov    $0xab,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x1,-0x9d04(%rbp)
mov    -0x9e18(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9e18(%rbp)
cmp    $0xa,%eax
jle    3366 <main+0x2226>
jmp    3384 <main+0x2244>
jmp    336b <main+0x222b>
jmp    3370 <main+0x2230>
mov    -0x9e14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9e14(%rbp)
jmp    32d3 <main+0x2193>
jmp    3389 <main+0x2249>
mov    -0x9d0c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d0c(%rbp)
jmp    31d4 <main+0x2094>
cmpl   $0x0,-0x9d04(%rbp)
je     33bd <main+0x227d>
lea    0x1cfb(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    33cb <main+0x228b>
lea    0x1cf0(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xdca0(%rbp),%rdi
lea    0x1ceb(%rip),%rsi
call   1030 <strcpy@plt>
movl   $0x15,-0xdc20(%rbp)
movl   $0x0,-0xdca4(%rbp)
cmpl   $0x3e0,-0xdca4(%rbp)
jge    3429 <main+0x22e9>
movslq -0xdca4(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xdc18(%rbp,%rax,8)
ff ff
mov    -0xdca4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdca4(%rbp)
jmp    33f2 <main+0x22b2>
movl   $0x0,-0xdca8(%rbp)
movl   $0x0,-0xdcb0(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0xdcb0(%rbp)
mov    %al,-0xdde8(%rbp)
jge    3462 <main+0x2322>
cmpl   $0x0,-0xdca8(%rbp)
sete   %al
mov    %al,-0xdde8(%rbp)
mov    -0xdde8(%rbp),%al
test   $0x1,%al
jne    3475 <main+0x2335>
jmp    3601 <main+0x24c1>
mov    $0x0,%al
call   1040 <omp_get_thread_num@plt>
mov    %eax,-0xdcb4(%rbp)
mov    -0xdcb4(%rbp),%eax
movsbl -0xdc9f(%rbp),%ecx
add    %ecx,%eax
add    -0xdc20(%rbp),%eax
cvtsi2sd %eax,%xmm0
movslq -0xdcb4(%rbp),%rax
addsd  -0xdc18(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xdc18(%rbp,%rax,8)
ff ff
mov    $0x0,%al
call   1040 <omp_get_thread_num@plt>
mov    %eax,-0xdcb8(%rbp)
mov    -0xdcb8(%rbp),%eax
add    $0x1,%eax
movsbl -0xdc9f(%rbp),%ecx
add    %ecx,%eax
add    -0xdc20(%rbp),%eax
cvtsi2sd %eax,%xmm0
mov    -0xdcb8(%rbp),%eax
add    $0x1,%eax
cltq
addsd  -0xdc18(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xdc18(%rbp,%rax,8)
ff ff
movl   $0x0,-0xdcc0(%rbp)
movl   $0x0,-0xdcbc(%rbp)
cmpl   $0x80,-0xdcbc(%rbp)
jge    35e8 <main+0x24a8>
movslq -0xdcbc(%rbp),%rax
movsd  -0xdc18(%rbp,%rax,8),%xmm0
ff ff
mov    -0xdcbc(%rbp),%eax
add    $0x84,%eax
mov    -0xdcb0(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jne    355e <main+0x241e>
jp     355e <main+0x241e>
jmp    35cf <main+0x248f>
mov    -0xdcbc(%rbp),%esi
mov    -0xdcbc(%rbp),%ecx
add    $0x84,%ecx
mov    -0xdcb0(%rbp),%eax
add    $0x1,%eax
imul   %eax,%ecx
movslq -0xdcbc(%rbp),%rax
movsd  -0xdc18(%rbp,%rax,8),%xmm0
ff ff
lea    0x1aed(%rip),%rdi
lea    0x1b36(%rip),%rdx
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x1,-0xdca8(%rbp)
mov    -0xdcc0(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0xdcc0(%rbp)
cmp    $0xa,%eax
jle    35ca <main+0x248a>
jmp    35e8 <main+0x24a8>
jmp    35cf <main+0x248f>
jmp    35d4 <main+0x2494>
mov    -0xdcbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdcbc(%rbp)
jmp    350e <main+0x23ce>
jmp    35ed <main+0x24ad>
mov    -0xdcb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdcb0(%rbp)
jmp    343d <main+0x22fd>
cmpl   $0x0,-0xdca8(%rbp)
je     3621 <main+0x24e1>
lea    0x1a97(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    362f <main+0x24ef>
lea    0x1a8c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0xdcc4(%rbp)
cmpl   $0x3e0,-0xdcc4(%rbp)
jge    3670 <main+0x2530>
movslq -0xdcc4(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xdc18(%rbp,%rax,8)
ff ff
mov    -0xdcc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdcc4(%rbp)
jmp    3639 <main+0x24f9>
movl   $0x0,-0xdcc8(%rbp)
cmpl   $0x3e0,-0xdcc8(%rbp)
jge    36b1 <main+0x2571>
movslq -0xdcc8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xbd18(%rbp,%rax,8)
ff ff
mov    -0xdcc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdcc8(%rbp)
jmp    367a <main+0x253a>
movl   $0x0,-0xdccc(%rbp)
movl   $0x0,-0xdcd4(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0xdcd4(%rbp)
mov    %al,-0xdde9(%rbp)
jge    36ea <main+0x25aa>
cmpl   $0x0,-0xdccc(%rbp)
sete   %al
mov    %al,-0xdde9(%rbp)
mov    -0xdde9(%rbp),%al
test   $0x1,%al
jne    36fd <main+0x25bd>
jmp    3905 <main+0x27c5>
movl   $0x0,-0xdcd8(%rbp)
cmpl   $0x80,-0xdcd8(%rbp)
jge    377e <main+0x263e>
movslq -0xdcd8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xbd18(%rbp,%rax,8)
ff ff
movslq -0xdcd8(%rbp),%rax
movsd  0x18d7(%rip),%xmm0
addsd  -0xbd18(%rbp,%rax,8),%xmm0
ff ff
movslq -0xdcd8(%rbp),%rax
movsd  %xmm0,-0xdc18(%rbp,%rax,8)
ff ff
movslq -0xdcd8(%rbp),%rax
movsd  0x18c7(%rip),%xmm0
movsd  %xmm0,-0xbd18(%rbp,%rax,8)
ff ff
mov    -0xdcd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdcd8(%rbp)
jmp    3707 <main+0x25c7>
mov    $0x0,%al
call   1040 <omp_get_thread_num@plt>
mov    %eax,-0xdcdc(%rbp)
movslq -0xdcdc(%rbp),%rax
movsd  0x188e(%rip),%xmm0
addsd  -0xdc18(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xdc18(%rbp,%rax,8)
ff ff
movslq -0xdcdc(%rbp),%rax
movsd  0x184d(%rip),%xmm0
addsd  -0xbd18(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xbd18(%rbp,%rax,8)
ff ff
movl   $0x0,-0xdce0(%rbp)
cmpl   $0x80,-0xdce0(%rbp)
jge    3824 <main+0x26e4>
movslq -0xdce0(%rbp),%rax
movsd  -0xbd18(%rbp,%rax,8),%xmm0
ff ff
movslq -0xdce0(%rbp),%rax
addsd  -0xdc18(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xdc18(%rbp,%rax,8)
ff ff
mov    -0xdce0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdce0(%rbp)
jmp    37d7 <main+0x2697>
movl   $0x0,-0xdce8(%rbp)
movl   $0x0,-0xdce4(%rbp)
cmpl   $0x80,-0xdce4(%rbp)
jge    38ec <main+0x27ac>
movslq -0xdce4(%rbp),%rax
movsd  -0xdc18(%rbp,%rax,8),%xmm0
ff ff
movsd  0x17d8(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3875 <main+0x2735>
jp     3875 <main+0x2735>
jmp    38d3 <main+0x2793>
mov    -0xdce4(%rbp),%esi
movslq -0xdce4(%rbp),%rax
movsd  -0xdc18(%rbp,%rax,8),%xmm0
ff ff
lea    0x17ee(%rip),%rdi
lea    0x1837(%rip),%rdx
mov    $0x67,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x1,-0xdccc(%rbp)
mov    -0xdce8(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0xdce8(%rbp)
cmp    $0xa,%eax
jle    38ce <main+0x278e>
jmp    38ec <main+0x27ac>
jmp    38d3 <main+0x2793>
jmp    38d8 <main+0x2798>
mov    -0xdce4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdce4(%rbp)
jmp    3838 <main+0x26f8>
jmp    38f1 <main+0x27b1>
mov    -0xdcd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdcd4(%rbp)
jmp    36c5 <main+0x2585>
cmpl   $0x0,-0xdccc(%rbp)
je     3925 <main+0x27e5>
lea    0x1793(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3933 <main+0x27f3>
lea    0x1788(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0xdcec(%rbp)
cmpl   $0x3e0,-0xdcec(%rbp)
jge    3974 <main+0x2834>
movslq -0xdcec(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xdc18(%rbp,%rax,8)
ff ff
mov    -0xdcec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdcec(%rbp)
jmp    393d <main+0x27fd>
movl   $0x0,-0xdcf0(%rbp)
cmpl   $0x3e0,-0xdcf0(%rbp)
jge    39b5 <main+0x2875>
movslq -0xdcf0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xbd18(%rbp,%rax,8)
ff ff
mov    -0xdcf0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdcf0(%rbp)
jmp    397e <main+0x283e>
movl   $0x0,-0xdcf4(%rbp)
movl   $0x0,-0xdcfc(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0xdcfc(%rbp)
mov    %al,-0xddea(%rbp)
jge    39ee <main+0x28ae>
cmpl   $0x0,-0xdcf4(%rbp)
sete   %al
mov    %al,-0xddea(%rbp)
mov    -0xddea(%rbp),%al
test   $0x1,%al
jne    3a01 <main+0x28c1>
jmp    3bfd <main+0x2abd>
movl   $0x0,-0xdd00(%rbp)
cmpl   $0x80,-0xdd00(%rbp)
jge    3a82 <main+0x2942>
movslq -0xdd00(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xbd18(%rbp,%rax,8)
ff ff
movslq -0xdd00(%rbp),%rax
movsd  0x15d3(%rip),%xmm0
addsd  -0xbd18(%rbp,%rax,8),%xmm0
ff ff
movslq -0xdd00(%rbp),%rax
movsd  %xmm0,-0xdc18(%rbp,%rax,8)
ff ff
movslq -0xdd00(%rbp),%rax
movsd  0x15c3(%rip),%xmm0
movsd  %xmm0,-0xbd18(%rbp,%rax,8)
ff ff
mov    -0xdd00(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdd00(%rbp)
jmp    3a0b <main+0x28cb>
mov    $0x0,%al
call   1040 <omp_get_thread_num@plt>
mov    %eax,-0xdd04(%rbp)
movslq -0xdd04(%rbp),%rax
movsd  0x158a(%rip),%xmm0
addsd  -0xdc18(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xdc18(%rbp,%rax,8)
ff ff
movslq -0xdd04(%rbp),%rax
movsd  0x1549(%rip),%xmm0
movsd  %xmm0,-0xbd18(%rbp,%rax,8)
ff ff
movl   $0x0,-0xdd08(%rbp)
cmpl   $0x80,-0xdd08(%rbp)
jge    3b1f <main+0x29df>
movslq -0xdd08(%rbp),%rax
movsd  -0xbd18(%rbp,%rax,8),%xmm0
ff ff
movslq -0xdd08(%rbp),%rax
addsd  -0xdc18(%rbp,%rax,8),%xmm0
movsd  %xmm0,-0xdc18(%rbp,%rax,8)
ff ff
mov    -0xdd08(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdd08(%rbp)
jmp    3ad2 <main+0x2992>
movl   $0x0,-0xdd10(%rbp)
movl   $0x0,-0xdd0c(%rbp)
cmpl   $0x1,-0xdd0c(%rbp)
jge    3be4 <main+0x2aa4>
movslq -0xdd0c(%rbp),%rax
movsd  -0xdc18(%rbp,%rax,8),%xmm0
ff ff
movsd  0x14d8(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3b6d <main+0x2a2d>
jp     3b6d <main+0x2a2d>
jmp    3bcb <main+0x2a8b>
mov    -0xdd0c(%rbp),%esi
movslq -0xdd0c(%rbp),%rax
movsd  -0xdc18(%rbp,%rax,8),%xmm0
ff ff
lea    0x14f6(%rip),%rdi
lea    0x153f(%rip),%rdx
mov    $0x64,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x1,-0xdcf4(%rbp)
mov    -0xdd10(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0xdd10(%rbp)
cmp    $0xa,%eax
jle    3bc6 <main+0x2a86>
jmp    3be4 <main+0x2aa4>
jmp    3bcb <main+0x2a8b>
jmp    3bd0 <main+0x2a90>
mov    -0xdd0c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdd0c(%rbp)
jmp    3b33 <main+0x29f3>
jmp    3be9 <main+0x2aa9>
mov    -0xdcfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdcfc(%rbp)
jmp    39c9 <main+0x2889>
cmpl   $0x0,-0xdcf4(%rbp)
je     3c1d <main+0x2add>
lea    0x149b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3c2b <main+0x2aeb>
lea    0x1490(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0xdd14(%rbp)
cmpl   $0x3e0,-0xdd14(%rbp)
jge    3c6c <main+0x2b2c>
movslq -0xdd14(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xdc18(%rbp,%rax,8)
ff ff
mov    -0xdd14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdd14(%rbp)
jmp    3c35 <main+0x2af5>
movl   $0x0,-0xdd18(%rbp)
cmpl   $0x3e0,-0xdd18(%rbp)
jge    3cad <main+0x2b6d>
movslq -0xdd18(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xbd18(%rbp,%rax,8)
ff ff
mov    -0xdd18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdd18(%rbp)
jmp    3c76 <main+0x2b36>
movl   $0x0,-0xdd1c(%rbp)
movl   $0x0,-0xdd24(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0xdd24(%rbp)
mov    %al,-0xddeb(%rbp)
jge    3ce6 <main+0x2ba6>
cmpl   $0x0,-0xdd1c(%rbp)
sete   %al
mov    %al,-0xddeb(%rbp)
mov    -0xddeb(%rbp),%al
test   $0x1,%al
jne    3cf9 <main+0x2bb9>
jmp    3e6a <main+0x2d2a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xbd18(%rbp)
ff
movsd  0x1304(%rip),%xmm0
addsd  -0xbd18(%rbp),%xmm0
ff
movsd  %xmm0,-0xdc18(%rbp)
ff
movsd  0x12e4(%rip),%xmm0
movsd  %xmm0,-0xbd18(%rbp)
ff
movsd  0x12cc(%rip),%xmm0
addsd  -0xbd18(%rbp),%xmm0
ff
movsd  %xmm0,-0xbd18(%rbp)
ff
movsd  -0xbd18(%rbp),%xmm0
ff
addsd  -0xdc18(%rbp),%xmm0
ff
movsd  %xmm0,-0xdc18(%rbp)
ff
movsd  -0xdc18(%rbp),%xmm0
ff
movsd  %xmm0,-0xdd30(%rbp)
ff
movsd  -0xbd18(%rbp),%xmm0
ff
addsd  -0xdd30(%rbp),%xmm0
ff
addsd  -0xdc18(%rbp),%xmm0
ff
movsd  %xmm0,-0xdc18(%rbp)
ff
movl   $0x0,-0xdd38(%rbp)
movl   $0x0,-0xdd34(%rbp)
cmpl   $0x1,-0xdd34(%rbp)
jge    3e51 <main+0x2d11>
movslq -0xdd34(%rbp),%rax
movsd  -0xdc18(%rbp,%rax,8),%xmm0
ff ff
movsd  0x125b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3dda <main+0x2c9a>
jp     3dda <main+0x2c9a>
jmp    3e38 <main+0x2cf8>
mov    -0xdd34(%rbp),%esi
movslq -0xdd34(%rbp),%rax
movsd  -0xdc18(%rbp,%rax,8),%xmm0
ff ff
lea    0x1289(%rip),%rdi
lea    0x12d2(%rip),%rdx
mov    $0xd2,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x1,-0xdd1c(%rbp)
mov    -0xdd38(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0xdd38(%rbp)
cmp    $0xa,%eax
jle    3e33 <main+0x2cf3>
jmp    3e51 <main+0x2d11>
jmp    3e38 <main+0x2cf8>
jmp    3e3d <main+0x2cfd>
mov    -0xdd34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdd34(%rbp)
jmp    3da0 <main+0x2c60>
jmp    3e56 <main+0x2d16>
mov    -0xdd24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdd24(%rbp)
jmp    3cc1 <main+0x2b81>
cmpl   $0x0,-0xdd1c(%rbp)
je     3e8a <main+0x2d4a>
lea    0x122e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    3e98 <main+0x2d58>
lea    0x1223(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0xdd3c(%rbp)
cmpl   $0x3e0,-0xdd3c(%rbp)
jge    3ed9 <main+0x2d99>
movslq -0xdd3c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0xdd3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdd3c(%rbp)
jmp    3ea2 <main+0x2d62>
movl   $0x0,-0xdd40(%rbp)
cmpl   $0x3e0,-0xdd40(%rbp)
jge    3f1a <main+0x2dda>
movslq -0xdd40(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp,%rax,8)
ff ff
mov    -0xdd40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdd40(%rbp)
jmp    3ee3 <main+0x2da3>
movl   $0x0,-0xdd44(%rbp)
movl   $0x0,-0xdd4c(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0xdd4c(%rbp)
mov    %al,-0xddec(%rbp)
jge    3f53 <main+0x2e13>
cmpl   $0x0,-0xdd44(%rbp)
sete   %al
mov    %al,-0xddec(%rbp)
mov    -0xddec(%rbp),%al
test   $0x1,%al
jne    3f66 <main+0x2e26>
jmp    40f0 <main+0x2fb0>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e10(%rbp)
ff
movsd  0x1097(%rip),%xmm0
addsd  -0x3e10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movsd  0x1077(%rip),%xmm0
movsd  %xmm0,-0x3e10(%rbp)
ff
movl   $0x15,-0xdd50(%rbp)
mov    -0xdd50(%rbp),%eax
add    $0x9,%eax
mov    %eax,-0xdd50(%rbp)
movsd  0x1046(%rip),%xmm0
addsd  -0x3e10(%rbp),%xmm0
ff
movsd  %xmm0,-0x3e10(%rbp)
ff
movsd  -0x3e10(%rbp),%xmm0
ff
cvtsi2sdl -0xdd50(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movsd  -0x3e10(%rbp),%xmm0
ff
cvtsi2sdl -0xdd50(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
addsd  -0x1f10(%rbp),%xmm0
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0xddd8(%rbp)
movl   $0x0,-0xddd4(%rbp)
cmpl   $0x1,-0xddd4(%rbp)
jge    40d7 <main+0x2f97>
movslq -0xddd4(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0xfcd(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    4060 <main+0x2f20>
jp     4060 <main+0x2f20>
jmp    40be <main+0x2f7e>
mov    -0xddd4(%rbp),%esi
movslq -0xddd4(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x1003(%rip),%rdi
lea    0x1051(%rip),%rdx
mov    $0xab,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x1,-0xdd44(%rbp)
mov    -0xddd8(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0xddd8(%rbp)
cmp    $0xa,%eax
jle    40b9 <main+0x2f79>
jmp    40d7 <main+0x2f97>
jmp    40be <main+0x2f7e>
jmp    40c3 <main+0x2f83>
mov    -0xddd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xddd4(%rbp)
jmp    4026 <main+0x2ee6>
jmp    40dc <main+0x2f9c>
mov    -0xdd4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdd4c(%rbp)
jmp    3f2e <main+0x2dee>
cmpl   $0x0,-0xdd44(%rbp)
je     4110 <main+0x2fd0>
lea    0xfa8(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    411e <main+0x2fde>
lea    0xf9d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
xor    %eax,%eax
add    $0xddf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xba98,%rsp
xor    %eax,%eax
call   1070 <check_offloading@plt>
movdqa 0x1e90(%rip),%xmm0
mov    $0x2,%eax
movdqa 0x1e93(%rip),%xmm1
movdqa 0x1e9b(%rip),%xmm2
movdqa 0x1ea3(%rip),%xmm3
movdqa %xmm0,%xmm4
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm5
paddd  %xmm1,%xmm5
cvtdq2pd %xmm0,%xmm6
cvtdq2pd %xmm5,%xmm5
movaps %xmm6,0x9b80(%rsp,%rax,8)
movdqa %xmm5,0x9b90(%rsp,%rax,8)
pxor   %xmm5,%xmm5
psubd  %xmm4,%xmm5
movdqa %xmm2,%xmm6
psubd  %xmm4,%xmm6
cvtdq2pd %xmm5,%xmm5
cvtdq2pd %xmm6,%xmm6
movaps %xmm5,0x7c80(%rsp,%rax,8)
movaps %xmm6,0x7c90(%rsp,%rax,8)
paddd  %xmm3,%xmm0
paddd  %xmm3,%xmm4
add    $0x4,%rax
cmp    $0x3e2,%rax
jne    11a0 <main+0x50>
mov    %rsp,%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
cltq
addsd  (%rsp,%rax,8),%xmm0
movsd  %xmm0,(%rsp,%rax,8)
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
cltq
addsd  (%rsp,%rax,8),%xmm0
movsd  %xmm0,(%rsp,%rax,8)
lea    0x1e97(%rip),%r14
lea    0x1ed2(%rip),%r15
xor    %eax,%eax
xor    %ebp,%ebp
jmp    126d <main+0x11d>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    $0x80,%rbx
je     12a1 <main+0x151>
movsd  (%rsp,%rbx,8),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
ucomisd %xmm1,%xmm0
jne    1281 <main+0x131>
jnp    1260 <main+0x110>
mov    %r14,%rdi
mov    %ebx,%esi
mov    %r15,%rdx
mov    %ebx,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%ebp
jg     12b7 <main+0x167>
add    $0x1,%ebp
mov    $0x1,%eax
jmp    1260 <main+0x110>
test   %eax,%eax
lea    0x1e7d(%rip),%rax
lea    0x1e80(%rip),%rdi
cmove  %rax,%rdi
jmp    12be <main+0x16e>
lea    0x1e73(%rip),%rdi
call   1030 <puts@plt>
xor    %ebx,%ebx
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
shl    $0x2,%eax
cltq
movapd 0x9b90(%rsp,%rax,8),%xmm0
movapd 0x9ba0(%rsp,%rax,8),%xmm1
addpd  0x7c90(%rsp,%rax,8),%xmm0
movapd %xmm0,0x1f00(%rsp,%rax,8)
addpd  0x7ca0(%rsp,%rax,8),%xmm1
movapd %xmm1,0x1f10(%rsp,%rax,8)
lea    0x1dd2(%rip),%r14
lea    0x1df7(%rip),%r15
xor    %eax,%eax
xor    %ebp,%ebp
jmp    132d <main+0x1dd>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    $0x200,%rbx
je     1364 <main+0x214>
movsd  0x1f00(%rsp,%rbx,8),%xmm1
ucomisd 0x1d9a(%rip),%xmm1
jne    1342 <main+0x1f2>
jnp    1320 <main+0x1d0>
xorpd  %xmm0,%xmm0
mov    %r14,%rdi
mov    %ebx,%esi
mov    %r15,%rdx
mov    $0x2,%al
call   1050 <printf@plt>
cmp    $0xa,%ebp
jg     137a <main+0x22a>
add    $0x1,%ebp
mov    $0x1,%eax
jmp    1320 <main+0x1d0>
test   %eax,%eax
lea    0x1dba(%rip),%rax
lea    0x1dbd(%rip),%rdi
cmove  %rax,%rdi
jmp    1381 <main+0x231>
lea    0x1db0(%rip),%rdi
call   1030 <puts@plt>
mov    %rsp,%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
cltq
movsd  %xmm0,(%rsp,%rax,8)
lea    0x1d2d(%rip),%r14
lea    0x1d68(%rip),%r15
xor    %eax,%eax
xor    %ebp,%ebp
jmp    13cd <main+0x27d>
add    $0x1,%rbx
cmp    $0x80,%rbx
je     13fe <main+0x2ae>
movsd  (%rsp,%rbx,8),%xmm0
ucomisd 0x1cfe(%rip),%xmm0
jne    13de <main+0x28e>
jnp    13c0 <main+0x270>
mov    %r14,%rdi
mov    %ebx,%esi
mov    %r15,%rdx
xor    %ecx,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%ebp
jg     1414 <main+0x2c4>
add    $0x1,%ebp
mov    $0x1,%eax
jmp    13c0 <main+0x270>
test   %eax,%eax
lea    0x1d20(%rip),%rax
lea    0x1d23(%rip),%rdi
cmove  %rax,%rdi
jmp    141b <main+0x2cb>
lea    0x1d16(%rip),%rdi
call   1030 <puts@plt>
mov    %rsp,%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
cltq
movsd  %xmm0,(%rsp,%rax,8)
lea    0x1c93(%rip),%r14
lea    0x1cce(%rip),%r15
xor    %eax,%eax
xor    %ebp,%ebp
jmp    146d <main+0x31d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    $0x80,%rbx
je     149e <main+0x34e>
movsd  (%rsp,%rbx,8),%xmm0
ucomisd 0x1c5e(%rip),%xmm0
jne    147e <main+0x32e>
jnp    1460 <main+0x310>
mov    %r14,%rdi
mov    %ebx,%esi
mov    %r15,%rdx
xor    %ecx,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%ebp
jg     14b4 <main+0x364>
add    $0x1,%ebp
mov    $0x1,%eax
jmp    1460 <main+0x310>
test   %eax,%eax
lea    0x1c80(%rip),%rax
lea    0x1c83(%rip),%rdi
cmove  %rax,%rdi
jmp    14bb <main+0x36b>
lea    0x1c76(%rip),%rdi
call   1030 <puts@plt>
mov    %rsp,%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
cltq
movsd  %xmm0,(%rsp,%rax,8)
lea    0x1bf3(%rip),%r14
lea    0x1c2e(%rip),%r15
xor    %eax,%eax
xor    %ebp,%ebp
jmp    150d <main+0x3bd>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    $0x80,%rbx
je     1541 <main+0x3f1>
movsd  (%rsp,%rbx,8),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
ucomisd %xmm1,%xmm0
jne    1521 <main+0x3d1>
jnp    1500 <main+0x3b0>
mov    %r14,%rdi
mov    %ebx,%esi
mov    %r15,%rdx
mov    %ebx,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%ebp
jg     1557 <main+0x407>
add    $0x1,%ebp
mov    $0x1,%eax
jmp    1500 <main+0x3b0>
test   %eax,%eax
lea    0x1bdd(%rip),%rax
lea    0x1be0(%rip),%rdi
cmove  %rax,%rdi
jmp    155e <main+0x40e>
lea    0x1bd3(%rip),%rdi
call   1030 <puts@plt>
xor    %ebx,%ebx
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
shl    $0x2,%eax
cltq
movapd 0x1ac7(%rip),%xmm1
movapd 0x9b90(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
addpd  0x7c90(%rsp,%rax,8),%xmm0
movapd %xmm0,0x1f00(%rsp,%rax,8)
movapd 0x9ba0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
addpd  0x7ca0(%rsp,%rax,8),%xmm0
movapd %xmm0,0x1f10(%rsp,%rax,8)
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
shl    $0x2,%eax
cltq
movapd 0x9b90(%rsp,%rax,8),%xmm0
movapd 0x1a6c(%rip),%xmm2
addpd  %xmm2,%xmm0
addpd  0x7c90(%rsp,%rax,8),%xmm0
addpd  0x1f00(%rsp,%rax,8),%xmm0
movapd 0x9ba0(%rsp,%rax,8),%xmm1
addpd  %xmm2,%xmm1
addpd  0x7ca0(%rsp,%rax,8),%xmm1
movapd %xmm0,0x1f00(%rsp,%rax,8)
addpd  0x1f10(%rsp,%rax,8),%xmm1
movapd %xmm1,0x1f10(%rsp,%rax,8)
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
shl    $0x2,%eax
cltq
movapd 0x9b90(%rsp,%rax,8),%xmm0
movapd 0x1a08(%rip),%xmm1
addpd  %xmm1,%xmm0
addpd  0x7c90(%rsp,%rax,8),%xmm0
addpd  0x1f00(%rsp,%rax,8),%xmm0
movapd %xmm0,0x1f00(%rsp,%rax,8)
movapd 0x9ba0(%rsp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
addpd  0x7ca0(%rsp,%rax,8),%xmm0
addpd  0x1f10(%rsp,%rax,8),%xmm0
movapd %xmm0,0x1f10(%rsp,%rax,8)
lea    0x1a5a(%rip),%r14
lea    0x1a7f(%rip),%r15
xor    %eax,%eax
xor    %ebp,%ebp
jmp    16ad <main+0x55d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rbx
cmp    $0x200,%rbx
je     16e5 <main+0x595>
movsd  0x1f00(%rsp,%rbx,8),%xmm0
ucomisd 0x19b2(%rip),%xmm0
jne    16c2 <main+0x572>
jnp    16a0 <main+0x550>
mov    %r14,%rdi
mov    %ebx,%esi
mov    %r15,%rdx
mov    $0x3,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%ebp
jg     16fb <main+0x5ab>
add    $0x1,%ebp
mov    $0x1,%eax
jmp    16a0 <main+0x550>
test   %eax,%eax
lea    0x1a39(%rip),%rax
lea    0x1a3c(%rip),%rdi
cmove  %rax,%rdi
jmp    1702 <main+0x5b2>
lea    0x1a2f(%rip),%rdi
call   1030 <puts@plt>
mov    $0x1,%ebp
mov    $0x63,%r12d
lea    0x19c7(%rip),%r15
lea    0x1a02(%rip),%rbx
jmp    1764 <main+0x614>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   %eax,%eax
lea    0x19f8(%rip),%rdi
lea    0x19e7(%rip),%rax
cmove  %rax,%rdi
call   1030 <puts@plt>
lea    0x20(%r14),%eax
lea    0x1(%r14),%ebp
cmp    $0x20,%r14d
cmovae %eax,%ebp
cmp    $0x81,%ebp
jae    17fc <main+0x6ac>
mov    $0x1f00,%edx
mov    %rsp,%rdi
xor    %esi,%esi
call   1060 <memset@plt>
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
cltq
movabs $0x4058c00000000000,%rcx
c0 58 40
mov    %rcx,(%rsp,%rax,8)
mov    %ebp,%r14d
xor    %ebp,%ebp
xor    %r13d,%r13d
xor    %eax,%eax
jmp    17ad <main+0x65d>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    $0x80,%rbp
je     1730 <main+0x5e0>
movsd  (%rsp,%rbp,8),%xmm0
cmp    %r14,%rbp
mov    $0x0,%ecx
cmovb  %r12d,%ecx
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
ucomisd %xmm1,%xmm0
jne    17cd <main+0x67d>
jnp    17a0 <main+0x650>
mov    %r15,%rdi
mov    %ebp,%esi
mov    %rbx,%rdx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%r13d
jg     17f0 <main+0x6a0>
add    $0x1,%r13d
mov    $0x1,%eax
jmp    17a0 <main+0x650>
nopl   (%rax)
lea    0x193a(%rip),%rdi
jmp    1744 <main+0x5f4>
lea    0x1924(%rip),%r15
mov    %r15,%rdi
call   1030 <puts@plt>
lea    0x18ce(%rip),%rbp
lea    0x1909(%rip),%r12
xor    %ebx,%ebx
movsd  0x1855(%rip),%xmm0
mov    %rbp,%rdi
xor    %esi,%esi
mov    %r12,%rdx
mov    $0x4,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
lea    0x18f3(%rip),%r14
mov    %r14,%rdi
call   1030 <puts@plt>
movsd  0x1832(%rip),%xmm0
mov    %rbp,%rdi
xor    %esi,%esi
mov    %r12,%rdx
mov    $0x5,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
mov    %r14,%rdi
call   1030 <puts@plt>
movsd  0x1816(%rip),%xmm0
mov    %rbp,%rdi
xor    %esi,%esi
mov    %r12,%rdx
mov    $0x41,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
mov    %r14,%rdi
call   1030 <puts@plt>
mov    %rsp,%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
lea    0x1f00(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
movapd 0x1797(%rip),%xmm1
movaps 0x1780(%rip),%xmm0
movapd %xmm1,(%rsp,%rbx,8)
movapd %xmm1,0x10(%rsp,%rbx,8)
movaps %xmm0,0x1f00(%rsp,%rbx,8)
movaps %xmm0,0x1f10(%rsp,%rbx,8)
movapd %xmm1,0x20(%rsp,%rbx,8)
movapd %xmm1,0x30(%rsp,%rbx,8)
movaps %xmm0,0x1f20(%rsp,%rbx,8)
movaps %xmm0,0x1f30(%rsp,%rbx,8)
movapd %xmm1,0x40(%rsp,%rbx,8)
movapd %xmm1,0x50(%rsp,%rbx,8)
movaps %xmm0,0x1f40(%rsp,%rbx,8)
movaps %xmm0,0x1f50(%rsp,%rbx,8)
movapd %xmm1,0x60(%rsp,%rbx,8)
movapd %xmm1,0x70(%rsp,%rbx,8)
movaps %xmm0,0x1f60(%rsp,%rbx,8)
movaps %xmm0,0x1f70(%rsp,%rbx,8)
add    $0x10,%rbx
cmp    $0x80,%rbx
jne    18c0 <main+0x770>
xor    %ebx,%ebx
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
cltq
movsd  (%rsp,%rax,8),%xmm0
addsd  0x173c(%rip),%xmm0
movsd  %xmm0,(%rsp,%rax,8)
movsd  0x1f00(%rsp,%rax,8),%xmm0
addsd  0x172e(%rip),%xmm0
movsd  %xmm0,0x1f00(%rsp,%rax,8)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd 0x1f00(%rsp,%rbx,8),%xmm0
movapd 0x1f10(%rsp,%rbx,8),%xmm1
movapd 0x1f20(%rsp,%rbx,8),%xmm2
movapd 0x1f30(%rsp,%rbx,8),%xmm3
addpd  (%rsp,%rbx,8),%xmm0
addpd  0x10(%rsp,%rbx,8),%xmm1
movapd %xmm0,(%rsp,%rbx,8)
movapd %xmm1,0x10(%rsp,%rbx,8)
addpd  0x20(%rsp,%rbx,8),%xmm2
addpd  0x30(%rsp,%rbx,8),%xmm3
movapd %xmm2,0x20(%rsp,%rbx,8)
movapd %xmm3,0x30(%rsp,%rbx,8)
add    $0x8,%rbx
cmp    $0x80,%rbx
jne    1980 <main+0x830>
xor    %ebp,%ebp
lea    0x16f8(%rip),%r12
lea    0x1733(%rip),%r13
xor    %ebx,%ebx
xor    %eax,%eax
jmp    1a0d <main+0x8bd>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbp
cmp    $0x80,%rbp
je     1a41 <main+0x8f1>
movsd  (%rsp,%rbp,8),%xmm0
ucomisd 0x1686(%rip),%xmm0
jne    1a1e <main+0x8ce>
jnp    1a00 <main+0x8b0>
mov    %r12,%rdi
mov    %ebp,%esi
mov    %r13,%rdx
mov    $0x67,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%ebx
jg     1a4e <main+0x8fe>
add    $0x1,%ebx
mov    $0x1,%eax
jmp    1a00 <main+0x8b0>
test   %eax,%eax
lea    0x16e7(%rip),%r14
cmove  %r15,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
mov    %rsp,%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
lea    0x1f00(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
movaps 0x15be(%rip),%xmm0
movapd 0x15c6(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
movapd %xmm1,(%rsp,%rbx,8)
movapd %xmm1,0x10(%rsp,%rbx,8)
movaps %xmm0,0x1f00(%rsp,%rbx,8)
movaps %xmm0,0x1f10(%rsp,%rbx,8)
movapd %xmm1,0x20(%rsp,%rbx,8)
movapd %xmm1,0x30(%rsp,%rbx,8)
movaps %xmm0,0x1f20(%rsp,%rbx,8)
movaps %xmm0,0x1f30(%rsp,%rbx,8)
movapd %xmm1,0x40(%rsp,%rbx,8)
movapd %xmm1,0x50(%rsp,%rbx,8)
movaps %xmm0,0x1f40(%rsp,%rbx,8)
movaps %xmm0,0x1f50(%rsp,%rbx,8)
movapd %xmm1,0x60(%rsp,%rbx,8)
movapd %xmm1,0x70(%rsp,%rbx,8)
movaps %xmm0,0x1f60(%rsp,%rbx,8)
movaps %xmm0,0x1f70(%rsp,%rbx,8)
add    $0x10,%rbx
cmp    $0x80,%rbx
jne    1a90 <main+0x940>
xor    %ebx,%ebx
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
cltq
movsd  (%rsp,%rax,8),%xmm0
addsd  0x156c(%rip),%xmm0
movsd  %xmm0,(%rsp,%rax,8)
movabs $0x4000000000000000,%rcx
mov    %rcx,0x1f00(%rsp,%rax,8)
nopl   0x0(%rax,%rax,1)
movapd 0x1f00(%rsp,%rbx,8),%xmm0
movapd 0x1f10(%rsp,%rbx,8),%xmm1
movapd 0x1f20(%rsp,%rbx,8),%xmm2
movapd 0x1f30(%rsp,%rbx,8),%xmm3
addpd  (%rsp,%rbx,8),%xmm0
addpd  0x10(%rsp,%rbx,8),%xmm1
movapd %xmm0,(%rsp,%rbx,8)
movapd %xmm1,0x10(%rsp,%rbx,8)
addpd  0x20(%rsp,%rbx,8),%xmm2
addpd  0x30(%rsp,%rbx,8),%xmm3
movapd %xmm2,0x20(%rsp,%rbx,8)
movapd %xmm3,0x30(%rsp,%rbx,8)
add    $0x8,%rbx
cmp    $0x80,%rbx
jne    1b40 <main+0x9f0>
xor    %ebx,%ebx
lea    0x1538(%rip),%r12
lea    0x1573(%rip),%r13
lea    0x157b(%rip),%r14
xor    %ebp,%ebp
xor    %eax,%eax
jmp    1bcd <main+0xa7d>
nopl   0x0(%rax)
add    $0x1,%rbx
cmp    $0x80,%rbx
je     1c01 <main+0xab1>
movsd  (%rsp,%rbx,8),%xmm0
ucomisd 0x14ce(%rip),%xmm0
jne    1bde <main+0xa8e>
jnp    1bc0 <main+0xa70>
mov    %r12,%rdi
mov    %ebx,%esi
mov    %r13,%rdx
mov    $0x65,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%ebp
jg     1c0e <main+0xabe>
add    $0x1,%ebp
mov    $0x1,%eax
jmp    1bc0 <main+0xa70>
test   %eax,%eax
lea    0x1527(%rip),%r14
cmove  %r15,%r14
mov    %r14,%rdi
call   1030 <puts@plt>
mov    %rsp,%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
lea    0x1f00(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
movaps 0x141e(%rip),%xmm0
movapd 0x1406(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
movapd %xmm1,(%rsp,%rbx,8)
movapd %xmm1,0x10(%rsp,%rbx,8)
movaps %xmm0,0x1f00(%rsp,%rbx,8)
movaps %xmm0,0x1f10(%rsp,%rbx,8)
movapd %xmm1,0x20(%rsp,%rbx,8)
movapd %xmm1,0x30(%rsp,%rbx,8)
movaps %xmm0,0x1f20(%rsp,%rbx,8)
movaps %xmm0,0x1f30(%rsp,%rbx,8)
movapd %xmm1,0x40(%rsp,%rbx,8)
movapd %xmm1,0x50(%rsp,%rbx,8)
movaps %xmm0,0x1f40(%rsp,%rbx,8)
movaps %xmm0,0x1f50(%rsp,%rbx,8)
movapd %xmm1,0x60(%rsp,%rbx,8)
movapd %xmm1,0x70(%rsp,%rbx,8)
movaps %xmm0,0x1f60(%rsp,%rbx,8)
movaps %xmm0,0x1f70(%rsp,%rbx,8)
add    $0x10,%rbx
cmp    $0x80,%rbx
jne    1c50 <main+0xb00>
xor    %ebx,%ebx
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
cltq
movsd  0x1f00(%rsp,%rax,8),%xmm0
addsd  0x13c8(%rip),%xmm0
movsd  %xmm0,0x1f00(%rsp,%rax,8)
addsd  (%rsp,%rax,8),%xmm0
movsd  %xmm0,(%rsp,%rax,8)
nopl   0x0(%rax,%rax,1)
movapd 0x1f00(%rsp,%rbx,8),%xmm0
movapd 0x1f10(%rsp,%rbx,8),%xmm1
movapd 0x1f20(%rsp,%rbx,8),%xmm2
movapd 0x1f30(%rsp,%rbx,8),%xmm3
addpd  (%rsp,%rbx,8),%xmm0
addpd  0x10(%rsp,%rbx,8),%xmm1
movapd %xmm0,(%rsp,%rbx,8)
movapd %xmm1,0x10(%rsp,%rbx,8)
addpd  0x20(%rsp,%rbx,8),%xmm2
addpd  0x30(%rsp,%rbx,8),%xmm3
movapd %xmm2,0x20(%rsp,%rbx,8)
movapd %xmm3,0x30(%rsp,%rbx,8)
add    $0x8,%rbx
cmp    $0x80,%rbx
jne    1d00 <main+0xbb0>
xor    %ebx,%ebx
lea    0x1378(%rip),%r14
lea    0x13b3(%rip),%r13
lea    0x13bb(%rip),%r12
xor    %ebp,%ebp
xor    %eax,%eax
jmp    1d8d <main+0xc3d>
nopl   0x0(%rax)
add    $0x1,%rbx
cmp    $0x80,%rbx
je     1dc1 <main+0xc71>
movsd  (%rsp,%rbx,8),%xmm0
ucomisd 0x131e(%rip),%xmm0
jne    1d9e <main+0xc4e>
jnp    1d80 <main+0xc30>
mov    %r14,%rdi
mov    %ebx,%esi
mov    %r13,%rdx
mov    $0x6f,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%ebp
jg     1dd0 <main+0xc80>
add    $0x1,%ebp
mov    $0x1,%eax
jmp    1d80 <main+0xc30>
test   %eax,%eax
lea    0x1367(%rip),%rdi
cmove  %r15,%rdi
jmp    1dd3 <main+0xc83>
mov    %r12,%rdi
call   1030 <puts@plt>
mov    %rsp,%rdi
xor    %ebx,%ebx
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
lea    0x1f00(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
lea    0x12dc(%rip),%r13
lea    0x1317(%rip),%rdx
movsd  0x12ad(%rip),%xmm0
mov    %r13,%rdi
xor    %esi,%esi
mov    $0xab,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
movabs $0x4024000000000000,%rax
mov    %rax,0x1f00(%rsp)
movabs $0x4066600000000000,%rax
60 66 40
mov    %rax,(%rsp)
mov    %r12,%rdi
call   1030 <puts@plt>
movabs $0x6566207362626f64,%rax
20 66 65
mov    %rax,0x3e08(%rsp)
movl   $0x797272,0x3e10(%rsp)
movl   $0x15,0x3e88(%rsp)
lea    0x3e90(%rsp),%rdi
mov    $0x1f00,%edx
xor    %esi,%esi
call   1060 <memset@plt>
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
lea    0x84(%rax),%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
cltq
addsd  0x3e90(%rsp,%rax,8),%xmm0
movsd  %xmm0,0x3e90(%rsp,%rax,8)
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
movsbl 0x3e09(%rsp),%ecx
add    %eax,%ecx
add    $0x16,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
cltq
addsd  0x3e98(%rsp,%rax,8),%xmm0
movsd  %xmm0,0x3e98(%rsp,%rax,8)
lea    0x1237(%rip),%rbp
xor    %r14d,%r14d
xor    %eax,%eax
jmp    1efd <main+0xdad>
nopl   (%rax)
add    $0x1,%rbx
cmp    $0x80,%rbx
je     1f41 <main+0xdf1>
movsd  0x3e90(%rsp,%rbx,8),%xmm0
lea    0x84(%rbx),%ecx
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
ucomisd %xmm1,%xmm0
jne    1f1b <main+0xdcb>
jnp    1ef0 <main+0xda0>
lea    0x84(%rbx),%ecx
mov    %r13,%rdi
mov    %ebx,%esi
mov    %rbp,%rdx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%r14d
jg     1f4e <main+0xdfe>
add    $0x1,%r14d
mov    $0x1,%eax
jmp    1ef0 <main+0xda0>
test   %eax,%eax
lea    0x11e7(%rip),%r12
cmove  %r15,%r12
mov    %r12,%rdi
call   1030 <puts@plt>
xor    %ebx,%ebx
mov    $0x3e00,%edx
lea    0x3e90(%rsp),%rdi
xor    %esi,%esi
call   1060 <memset@plt>
movaps 0x10cd(%rip),%xmm0
movapd 0x10d5(%rip),%xmm1
nopl   0x0(%rax,%rax,1)
movupd %xmm1,0x3e90(%rsp,%rbx,8)
movups %xmm0,0x5d90(%rsp,%rbx,8)
movupd %xmm1,0x3ea0(%rsp,%rbx,8)
movups %xmm0,0x5da0(%rsp,%rbx,8)
movupd %xmm1,0x3eb0(%rsp,%rbx,8)
movups %xmm0,0x5db0(%rsp,%rbx,8)
movupd %xmm1,0x3ec0(%rsp,%rbx,8)
movups %xmm0,0x5dc0(%rsp,%rbx,8)
movupd %xmm1,0x3ed0(%rsp,%rbx,8)
movups %xmm0,0x5dd0(%rsp,%rbx,8)
movupd %xmm1,0x3ee0(%rsp,%rbx,8)
movups %xmm0,0x5de0(%rsp,%rbx,8)
movupd %xmm1,0x3ef0(%rsp,%rbx,8)
movups %xmm0,0x5df0(%rsp,%rbx,8)
movupd %xmm1,0x3f00(%rsp,%rbx,8)
movups %xmm0,0x5e00(%rsp,%rbx,8)
add    $0x10,%rbx
cmp    $0x80,%rbx
jne    1f80 <main+0xe30>
xor    %ebx,%ebx
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
cltq
movsd  0x3e90(%rsp,%rax,8),%xmm0
addsd  0x105b(%rip),%xmm0
movsd  %xmm0,0x3e90(%rsp,%rax,8)
movsd  0x5d90(%rsp,%rax,8),%xmm0
addsd  0x1049(%rip),%xmm0
movsd  %xmm0,0x5d90(%rsp,%rax,8)
nopl   0x0(%rax,%rax,1)
movupd 0x5d90(%rsp,%rbx,8),%xmm0
movupd 0x5da0(%rsp,%rbx,8),%xmm1
movupd 0x3e90(%rsp,%rbx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x3ea0(%rsp,%rbx,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x3eb0(%rsp,%rbx,8),%xmm1
movupd 0x3ec0(%rsp,%rbx,8),%xmm3
movupd %xmm2,0x3e90(%rsp,%rbx,8)
movupd %xmm0,0x3ea0(%rsp,%rbx,8)
movupd 0x5db0(%rsp,%rbx,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x5dc0(%rsp,%rbx,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,0x3eb0(%rsp,%rbx,8)
movupd %xmm1,0x3ec0(%rsp,%rbx,8)
add    $0x8,%rbx
cmp    $0x80,%rbx
jne    2060 <main+0xf10>
xor    %ebp,%ebp
lea    0xfea(%rip),%r13
lea    0x1020(%rip),%r14
lea    0x102d(%rip),%r12
xor    %ebx,%ebx
xor    %eax,%eax
jmp    211d <main+0xfcd>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    $0x80,%rbp
je     2155 <main+0x1005>
movsd  0x3e90(%rsp,%rbp,8),%xmm0
ucomisd 0xf72(%rip),%xmm0
jne    2132 <main+0xfe2>
jnp    2110 <main+0xfc0>
mov    %r13,%rdi
mov    %ebp,%esi
mov    %r14,%rdx
mov    $0x67,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
cmp    $0xa,%ebx
jg     2162 <main+0x1012>
add    $0x1,%ebx
mov    $0x1,%eax
jmp    2110 <main+0xfc0>
test   %eax,%eax
lea    0xfd3(%rip),%r12
cmove  %r15,%r12
mov    %r12,%rdi
call   1030 <puts@plt>
xor    %ebx,%ebx
mov    $0x3e00,%edx
lea    0x3e90(%rsp),%rdi
xor    %esi,%esi
call   1060 <memset@plt>
movaps 0xeb9(%rip),%xmm0
movapd 0xec1(%rip),%xmm1
nop
movupd %xmm1,0x3e90(%rsp,%rbx,8)
movups %xmm0,0x5d90(%rsp,%rbx,8)
movupd %xmm1,0x3ea0(%rsp,%rbx,8)
movups %xmm0,0x5da0(%rsp,%rbx,8)
movupd %xmm1,0x3eb0(%rsp,%rbx,8)
movups %xmm0,0x5db0(%rsp,%rbx,8)
movupd %xmm1,0x3ec0(%rsp,%rbx,8)
movups %xmm0,0x5dc0(%rsp,%rbx,8)
movupd %xmm1,0x3ed0(%rsp,%rbx,8)
movups %xmm0,0x5dd0(%rsp,%rbx,8)
movupd %xmm1,0x3ee0(%rsp,%rbx,8)
movups %xmm0,0x5de0(%rsp,%rbx,8)
movupd %xmm1,0x3ef0(%rsp,%rbx,8)
movups %xmm0,0x5df0(%rsp,%rbx,8)
movupd %xmm1,0x3f00(%rsp,%rbx,8)
movups %xmm0,0x5e00(%rsp,%rbx,8)
add    $0x10,%rbx
cmp    $0x80,%rbx
jne    2190 <main+0x1040>
xor    %ebx,%ebx
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
cltq
movsd  0x3e90(%rsp,%rax,8),%xmm0
addsd  0xe4b(%rip),%xmm0
movsd  %xmm0,0x3e90(%rsp,%rax,8)
movabs $0x4000000000000000,%rcx
mov    %rcx,0x5d90(%rsp,%rax,8)
movupd 0x5d90(%rsp,%rbx,8),%xmm0
movupd 0x5da0(%rsp,%rbx,8),%xmm1
movupd 0x3e90(%rsp,%rbx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x3ea0(%rsp,%rbx,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x3eb0(%rsp,%rbx,8),%xmm1
movupd 0x3ec0(%rsp,%rbx,8),%xmm3
movupd %xmm2,0x3e90(%rsp,%rbx,8)
movupd %xmm0,0x3ea0(%rsp,%rbx,8)
movupd 0x5db0(%rsp,%rbx,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x5dc0(%rsp,%rbx,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,0x3eb0(%rsp,%rbx,8)
movupd %xmm1,0x3ec0(%rsp,%rbx,8)
add    $0x8,%rbx
cmp    $0x80,%rbx
jne    2260 <main+0x1110>
movsd  0x3e90(%rsp),%xmm0
ucomisd 0xdca(%rip),%xmm0
jne    2302 <main+0x11b2>
jnp    2325 <main+0x11d5>
lea    0xdd7(%rip),%rdi
lea    0xe0d(%rip),%rdx
xor    %esi,%esi
mov    $0x64,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
lea    0xe0c(%rip),%r15
mov    %r15,%rdi
call   1030 <puts@plt>
lea    0xdac(%rip),%rbx
lea    0xde2(%rip),%rdx
movsd  0xd8d(%rip),%xmm0
mov    %rbx,%rdi
xor    %esi,%esi
mov    $0xd2,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
lea    0xdd6(%rip),%rbp
mov    %rbp,%rdi
call   1030 <puts@plt>
lea    0xdb8(%rip),%rdx
movsd  0xd4e(%rip),%xmm0
mov    %rbx,%rdi
xor    %esi,%esi
mov    $0xab,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
mov    %rbp,%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0xba98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.CONTEXT = type { %struct.CITY, [992 x double], [992 x double] }
%struct.CITY = type { [128 x i8], i32 }
@.str = [44 x i8] c"Failed at %3d with %s, expected %f, got %f\0A\00"
@.str.1 = [5 x i8] c"A[i]\00"
@.str.2 = [8 x i8] c"Failed\0A\00"
@.str.3 = [11 x i8] c"Succeeded\0A\00"
@.str.4 = [5 x i8] c"B[i]\00"
@.str.5 = [12 x i8] c"dobbs ferry\00"
@.str.6 = [10 x i8] c"data.A[i]\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [992 x double]
%3 = alloca [992 x double]
%4 = alloca [992 x double]
%5 = alloca [992 x double]
%6 = alloca [992 x double]
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
%47 = alloca i32
%48 = alloca i32
%49 = alloca i32
%50 = alloca i32
%51 = alloca i32
%52 = alloca i32
%53 = alloca i32
%54 = alloca i32
%55 = alloca i32
%56 = alloca i32
%57 = alloca [1 x i32]
%58 = alloca i32
%59 = alloca i32
%60 = alloca i32
%61 = alloca i32
%62 = alloca i32
%63 = alloca i32
%64 = alloca i32
%65 = alloca i32
%66 = alloca i32
%67 = alloca i32
%68 = alloca double
%69 = alloca i32
%70 = alloca i32
%71 = alloca i32
%72 = alloca i32
%73 = alloca i32
%74 = alloca i32
%75 = alloca double
%76 = alloca i32
%77 = alloca i32
%78 = alloca i32
%79 = alloca i32
%80 = alloca i32
%81 = alloca i32
%82 = alloca double
%83 = alloca i32
%84 = alloca i32
%85 = alloca i32
%86 = alloca i32
%87 = alloca i32
%88 = alloca i32
%89 = alloca double
%90 = alloca double
%91 = alloca i32
%92 = alloca i32
%93 = alloca i32
%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 i32
%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 i32
%124 = alloca i32
%125 = alloca i32
%126 = alloca i32
%127 = alloca i32
%128 = alloca [32 x double]
%129 = alloca i32
%130 = alloca i32
%131 = alloca %struct.CONTEXT
%132 = alloca i32
%133 = alloca i32
%134 = alloca i32
%135 = alloca i32
%136 = alloca i32
%137 = alloca i32
%138 = alloca i32
%139 = alloca i32
%140 = alloca i32
%141 = alloca i32
%142 = alloca i32
%143 = alloca i32
%144 = alloca i32
%145 = alloca i32
%146 = alloca i32
%147 = alloca i32
%148 = alloca i32
%149 = alloca i32
%150 = alloca i32
%151 = alloca i32
%152 = alloca i32
%153 = alloca i32
%154 = alloca i32
%155 = alloca i32
%156 = alloca i32
%157 = alloca i32
%158 = alloca i32
%159 = alloca i32
%160 = alloca i32
%161 = alloca i32
%162 = alloca i32
%163 = alloca i32
%164 = alloca i32
%165 = alloca double
%166 = alloca i32
%167 = alloca i32
%168 = alloca i32
%169 = alloca i32
%170 = alloca i32
%171 = alloca i32
%172 = alloca i32
%173 = alloca %struct.CITY
%174 = alloca i32
%175 = alloca i32
store i32 0, i32* %1
%176 = call i32 (...) @check_offloading()
store i32 0, i32* %7
br label %177
177: ; preds = %195, %0
%178 = load i32, i32* %7
%179 = icmp slt i32 %178, 992
br i1 %179, label %180, label %198
180: ; preds = %177
%181 = load i32, i32* %7
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds [992 x double], [992 x double]* %4, i64 0, i64 %182
store double 1.000000e+00, double* %183
%184 = load i32, i32* %7
%185 = sitofp i32 %184 to double
%186 = load i32, i32* %7
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds [992 x double], [992 x double]* %5, i64 0, i64 %187
store double %185, double* %188
%189 = load i32, i32* %7
%190 = sub nsw i32 0, %189
%191 = sitofp i32 %190 to double
%192 = load i32, i32* %7
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds [992 x double], [992 x double]* %6, i64 0, i64 %193
store double %191, double* %194
br label %195
195: ; preds = %180
%196 = load i32, i32* %7
%197 = add nsw i32 %196, 1
store i32 %197, i32* %7
br label %177
198: ; preds = %177
store i32 0, i32* %8
br label %199
199: ; preds = %206, %198
%200 = load i32, i32* %8
%201 = icmp slt i32 %200, 992
br i1 %201, label %202, label %209
202: ; preds = %199
%203 = load i32, i32* %8
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %204
store double 0.000000e+00, double* %205
br label %206
206: ; preds = %202
%207 = load i32, i32* %8
%208 = add nsw i32 %207, 1
store i32 %208, i32* %8
br label %199
209: ; preds = %199
store i32 0, i32* %9
store i32 0, i32* %11
br label %210
210: ; preds = %270, %209
%211 = load i32, i32* %11
%212 = icmp slt i32 %211, 1
br i1 %212, label %213, label %216
213: ; preds = %210
%214 = load i32, i32* %9
%215 = icmp eq i32 %214, 0
br label %216
216: ; preds = %213, %210
%217 = phi i1 [ false, %210 ], [ %215, %213 ]
br i1 %217, label %218, label %273
218: ; preds = %216
%219 = call i32 (...) @omp_get_thread_num()
store i32 %219, i32* %12
%220 = load i32, i32* %12
%221 = sitofp i32 %220 to double
%222 = load i32, i32* %12
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %223
%225 = load double, double* %224
%226 = fadd double %225, %221
store double %226, double* %224
%227 = call i32 (...) @omp_get_thread_num()
store i32 %227, i32* %13
%228 = load i32, i32* %13
%229 = sitofp i32 %228 to double
%230 = load i32, i32* %13
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %231
%233 = load double, double* %232
%234 = fadd double %233, %229
store double %234, double* %232
store i32 0, i32* %15
store i32 0, i32* %14
br label %235
235: ; preds = %266, %218
%236 = load i32, i32* %14
%237 = icmp slt i32 %236, 128
br i1 %237, label %238, label %269
238: ; preds = %235
%239 = load i32, i32* %14
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %240
%242 = load double, double* %241
%243 = load i32, i32* %14
%244 = load i32, i32* %11
%245 = add nsw i32 %244, 1
%246 = mul nsw i32 %243, %245
%247 = sitofp i32 %246 to double
%248 = fcmp une double %242, %247
br i1 %248, label %249, label %265
249: ; preds = %238
%250 = load i32, i32* %14
%251 = load i32, i32* %14
%252 = load i32, i32* %11
%253 = add nsw i32 %252, 1
%254 = mul nsw i32 %251, %253
%255 = load i32, i32* %14
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %256
%258 = load double, double* %257
%259 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %250, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 %254, double %258)
store i32 1, i32* %9
%260 = load i32, i32* %15
%261 = add nsw i32 %260, 1
store i32 %261, i32* %15
%262 = icmp sgt i32 %260, 10
br i1 %262, label %263, label %264
263: ; preds = %249
br label %269
264: ; preds = %249
br label %265
265: ; preds = %264, %238
br label %266
266: ; preds = %265
%267 = load i32, i32* %14
%268 = add nsw i32 %267, 1
store i32 %268, i32* %14
br label %235
269: ; preds = %263, %235
br label %270
270: ; preds = %269
%271 = load i32, i32* %11
%272 = add nsw i32 %271, 1
store i32 %272, i32* %11
br label %210
273: ; preds = %216
%274 = load i32, i32* %9
%275 = icmp ne i32 %274, 0
br i1 %275, label %276, label %278
276: ; preds = %273
%277 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %280
278: ; preds = %273
%279 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %280
280: ; preds = %278, %276
store i32 0, i32* %16
store i32 0, i32* %18
br label %281
281: ; preds = %341, %280
%282 = load i32, i32* %18
%283 = icmp slt i32 %282, 1
br i1 %283, label %284, label %287
284: ; preds = %281
%285 = load i32, i32* %16
%286 = icmp eq i32 %285, 0
br label %287
287: ; preds = %284, %281
%288 = phi i1 [ false, %281 ], [ %286, %284 ]
br i1 %288, label %289, label %344
289: ; preds = %287
%290 = call i32 (...) @omp_get_thread_num()
%291 = mul nsw i32 %290, 4
store i32 %291, i32* %19
%292 = load i32, i32* %19
store i32 %292, i32* %20
br label %293
293: ; preds = %311, %289
%294 = load i32, i32* %20
%295 = load i32, i32* %19
%296 = add nsw i32 %295, 4
%297 = icmp slt i32 %294, %296
br i1 %297, label %298, label %314
298: ; preds = %293
%299 = load i32, i32* %20
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds [992 x double], [992 x double]* %5, i64 0, i64 %300
%302 = load double, double* %301
%303 = load i32, i32* %20
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds [992 x double], [992 x double]* %6, i64 0, i64 %304
%306 = load double, double* %305
%307 = fadd double %302, %306
%308 = load i32, i32* %20
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %309
store double %307, double* %310
br label %311
311: ; preds = %298
%312 = load i32, i32* %20
%313 = add nsw i32 %312, 1
store i32 %313, i32* %20
br label %293
314: ; preds = %293
store i32 0, i32* %22
store i32 0, i32* %21
br label %315
315: ; preds = %337, %314
%316 = load i32, i32* %21
%317 = icmp slt i32 %316, 512
br i1 %317, label %318, label %340
318: ; preds = %315
%319 = load i32, i32* %21
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %320
%322 = load double, double* %321
%323 = fcmp une double %322, 0.000000e+00
br i1 %323, label %324, label %336
324: ; preds = %318
%325 = load i32, i32* %21
%326 = load i32, i32* %21
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %327
%329 = load double, double* %328
%330 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %325, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), double 0.000000e+00, double %329)
store i32 1, i32* %16
%331 = load i32, i32* %22
%332 = add nsw i32 %331, 1
store i32 %332, i32* %22
%333 = icmp sgt i32 %331, 10
br i1 %333, label %334, label %335
334: ; preds = %324
br label %340
335: ; preds = %324
br label %336
336: ; preds = %335, %318
br label %337
337: ; preds = %336
%338 = load i32, i32* %21
%339 = add nsw i32 %338, 1
store i32 %339, i32* %21
br label %315
340: ; preds = %334, %315
br label %341
341: ; preds = %340
%342 = load i32, i32* %18
%343 = add nsw i32 %342, 1
store i32 %343, i32* %18
br label %281
344: ; preds = %287
%345 = load i32, i32* %16
%346 = icmp ne i32 %345, 0
br i1 %346, label %347, label %349
347: ; preds = %344
%348 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %351
349: ; preds = %344
%350 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %351
351: ; preds = %349, %347
store i32 0, i32* %23
br label %352
352: ; preds = %359, %351
%353 = load i32, i32* %23
%354 = icmp slt i32 %353, 992
br i1 %354, label %355, label %362
355: ; preds = %352
%356 = load i32, i32* %23
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %357
store double 0.000000e+00, double* %358
br label %359
359: ; preds = %355
%360 = load i32, i32* %23
%361 = add nsw i32 %360, 1
store i32 %361, i32* %23
br label %352
362: ; preds = %352
store i32 0, i32* %24
store i32 0, i32* %26
br label %363
363: ; preds = %404, %362
%364 = load i32, i32* %26
%365 = icmp slt i32 %364, 1
br i1 %365, label %366, label %369
366: ; preds = %363
%367 = load i32, i32* %24
%368 = icmp eq i32 %367, 0
br label %369
369: ; preds = %366, %363
%370 = phi i1 [ false, %363 ], [ %368, %366 ]
br i1 %370, label %371, label %407
371: ; preds = %369
%372 = call i32 (...) @omp_get_thread_num()
store i32 %372, i32* %27
%373 = load i32, i32* %27
%374 = sitofp i32 %373 to double
%375 = load i32, i32* %27
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %376
store double %374, double* %377
store i32 0, i32* %29
store i32 0, i32* %28
br label %378
378: ; preds = %400, %371
%379 = load i32, i32* %28
%380 = icmp slt i32 %379, 128
br i1 %380, label %381, label %403
381: ; preds = %378
%382 = load i32, i32* %28
%383 = sext i32 %382 to i64
%384 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %383
%385 = load double, double* %384
%386 = fcmp une double %385, 0.000000e+00
br i1 %386, label %387, label %399
387: ; preds = %381
%388 = load i32, i32* %28
%389 = load i32, i32* %28
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %390
%392 = load double, double* %391
%393 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %388, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 0, double %392)
store i32 1, i32* %24
%394 = load i32, i32* %29
%395 = add nsw i32 %394, 1
store i32 %395, i32* %29
%396 = icmp sgt i32 %394, 10
br i1 %396, label %397, label %398
397: ; preds = %387
br label %403
398: ; preds = %387
br label %399
399: ; preds = %398, %381
br label %400
400: ; preds = %399
%401 = load i32, i32* %28
%402 = add nsw i32 %401, 1
store i32 %402, i32* %28
br label %378
403: ; preds = %397, %378
br label %404
404: ; preds = %403
%405 = load i32, i32* %26
%406 = add nsw i32 %405, 1
store i32 %406, i32* %26
br label %363
407: ; preds = %369
%408 = load i32, i32* %24
%409 = icmp ne i32 %408, 0
br i1 %409, label %410, label %412
410: ; preds = %407
%411 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %414
412: ; preds = %407
%413 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %414
414: ; preds = %412, %410
store i32 0, i32* %30
br label %415
415: ; preds = %422, %414
%416 = load i32, i32* %30
%417 = icmp slt i32 %416, 992
br i1 %417, label %418, label %425
418: ; preds = %415
%419 = load i32, i32* %30
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %420
store double 0.000000e+00, double* %421
br label %422
422: ; preds = %418
%423 = load i32, i32* %30
%424 = add nsw i32 %423, 1
store i32 %424, i32* %30
br label %415
425: ; preds = %415
store i32 0, i32* %31
store i32 0, i32* %33
br label %426
426: ; preds = %467, %425
%427 = load i32, i32* %33
%428 = icmp slt i32 %427, 1
br i1 %428, label %429, label %432
429: ; preds = %426
%430 = load i32, i32* %31
%431 = icmp eq i32 %430, 0
br label %432
432: ; preds = %429, %426
%433 = phi i1 [ false, %426 ], [ %431, %429 ]
br i1 %433, label %434, label %470
434: ; preds = %432
%435 = call i32 (...) @omp_get_thread_num()
store i32 %435, i32* %34
%436 = load i32, i32* %34
%437 = sitofp i32 %436 to double
%438 = load i32, i32* %34
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %439
store double %437, double* %440
store i32 0, i32* %36
store i32 0, i32* %35
br label %441
441: ; preds = %463, %434
%442 = load i32, i32* %35
%443 = icmp slt i32 %442, 128
br i1 %443, label %444, label %466
444: ; preds = %441
%445 = load i32, i32* %35
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %446
%448 = load double, double* %447
%449 = fcmp une double %448, 0.000000e+00
br i1 %449, label %450, label %462
450: ; preds = %444
%451 = load i32, i32* %35
%452 = load i32, i32* %35
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %453
%455 = load double, double* %454
%456 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %451, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 0, double %455)
store i32 1, i32* %31
%457 = load i32, i32* %36
%458 = add nsw i32 %457, 1
store i32 %458, i32* %36
%459 = icmp sgt i32 %457, 10
br i1 %459, label %460, label %461
460: ; preds = %450
br label %466
461: ; preds = %450
br label %462
462: ; preds = %461, %444
br label %463
463: ; preds = %462
%464 = load i32, i32* %35
%465 = add nsw i32 %464, 1
store i32 %465, i32* %35
br label %441
466: ; preds = %460, %441
br label %467
467: ; preds = %466
%468 = load i32, i32* %33
%469 = add nsw i32 %468, 1
store i32 %469, i32* %33
br label %426
470: ; preds = %432
%471 = load i32, i32* %31
%472 = icmp ne i32 %471, 0
br i1 %472, label %473, label %475
473: ; preds = %470
%474 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %477
475: ; preds = %470
%476 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %477
477: ; preds = %475, %473
store i32 0, i32* %37
br label %478
478: ; preds = %485, %477
%479 = load i32, i32* %37
%480 = icmp slt i32 %479, 992
br i1 %480, label %481, label %488
481: ; preds = %478
%482 = load i32, i32* %37
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %483
store double 0.000000e+00, double* %484
br label %485
485: ; preds = %481
%486 = load i32, i32* %37
%487 = add nsw i32 %486, 1
store i32 %487, i32* %37
br label %478
488: ; preds = %478
store i32 0, i32* %38
store i32 0, i32* %40
br label %489
489: ; preds = %533, %488
%490 = load i32, i32* %40
%491 = icmp slt i32 %490, 1
br i1 %491, label %492, label %495
492: ; preds = %489
%493 = load i32, i32* %38
%494 = icmp eq i32 %493, 0
br label %495
495: ; preds = %492, %489
%496 = phi i1 [ false, %489 ], [ %494, %492 ]
br i1 %496, label %497, label %536
497: ; preds = %495
%498 = call i32 (...) @omp_get_thread_num()
store i32 %498, i32* %41
%499 = load i32, i32* %41
%500 = sitofp i32 %499 to double
%501 = load i32, i32* %41
%502 = sext i32 %501 to i64
%503 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %502
store double %500, double* %503
store i32 0, i32* %43
store i32 0, i32* %42
br label %504
504: ; preds = %529, %497
%505 = load i32, i32* %42
%506 = icmp slt i32 %505, 128
br i1 %506, label %507, label %532
507: ; preds = %504
%508 = load i32, i32* %42
%509 = sext i32 %508 to i64
%510 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %509
%511 = load double, double* %510
%512 = load i32, i32* %42
%513 = sitofp i32 %512 to double
%514 = fcmp une double %511, %513
br i1 %514, label %515, label %528
515: ; preds = %507
%516 = load i32, i32* %42
%517 = load i32, i32* %42
%518 = load i32, i32* %42
%519 = sext i32 %518 to i64
%520 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %519
%521 = load double, double* %520
%522 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %516, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 %517, double %521)
store i32 1, i32* %38
%523 = load i32, i32* %43
%524 = add nsw i32 %523, 1
store i32 %524, i32* %43
%525 = icmp sgt i32 %523, 10
br i1 %525, label %526, label %527
526: ; preds = %515
br label %532
527: ; preds = %515
br label %528
528: ; preds = %527, %507
br label %529
529: ; preds = %528
%530 = load i32, i32* %42
%531 = add nsw i32 %530, 1
store i32 %531, i32* %42
br label %504
532: ; preds = %526, %504
br label %533
533: ; preds = %532
%534 = load i32, i32* %40
%535 = add nsw i32 %534, 1
store i32 %535, i32* %40
br label %489
536: ; preds = %495
%537 = load i32, i32* %38
%538 = icmp ne i32 %537, 0
br i1 %538, label %539, label %541
539: ; preds = %536
%540 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %543
541: ; preds = %536
%542 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %543
543: ; preds = %541, %539
store i32 0, i32* %44
store i32 0, i32* %46
br label %544
544: ; preds = %661, %543
%545 = load i32, i32* %46
%546 = icmp slt i32 %545, 1
br i1 %546, label %547, label %550
547: ; preds = %544
%548 = load i32, i32* %44
%549 = icmp eq i32 %548, 0
br label %550
550: ; preds = %547, %544
%551 = phi i1 [ false, %544 ], [ %549, %547 ]
br i1 %551, label %552, label %664
552: ; preds = %550
%553 = call i32 (...) @omp_get_thread_num()
%554 = mul nsw i32 %553, 4
store i32 %554, i32* %47
%555 = load i32, i32* %47
store i32 %555, i32* %48
br label %556
556: ; preds = %575, %552
%557 = load i32, i32* %48
%558 = load i32, i32* %47
%559 = add nsw i32 %558, 4
%560 = icmp slt i32 %557, %559
br i1 %560, label %561, label %578
561: ; preds = %556
%562 = load i32, i32* %48
%563 = sext i32 %562 to i64
%564 = getelementptr inbounds [992 x double], [992 x double]* %5, i64 0, i64 %563
%565 = load double, double* %564
%566 = fadd double 1.000000e+00, %565
%567 = load i32, i32* %48
%568 = sext i32 %567 to i64
%569 = getelementptr inbounds [992 x double], [992 x double]* %6, i64 0, i64 %568
%570 = load double, double* %569
%571 = fadd double %566, %570
%572 = load i32, i32* %48
%573 = sext i32 %572 to i64
%574 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %573
store double %571, double* %574
br label %575
575: ; preds = %561
%576 = load i32, i32* %48
%577 = add nsw i32 %576, 1
store i32 %577, i32* %48
br label %556
578: ; preds = %556
%579 = call i32 (...) @omp_get_thread_num()
%580 = mul nsw i32 %579, 4
store i32 %580, i32* %49
%581 = load i32, i32* %49
store i32 %581, i32* %50
br label %582
582: ; preds = %603, %578
%583 = load i32, i32* %50
%584 = load i32, i32* %49
%585 = add nsw i32 %584, 4
%586 = icmp slt i32 %583, %585
br i1 %586, label %587, label %606
587: ; preds = %582
%588 = load i32, i32* %50
%589 = sext i32 %588 to i64
%590 = getelementptr inbounds [992 x double], [992 x double]* %5, i64 0, i64 %589
%591 = load double, double* %590
%592 = fadd double 1.000000e+00, %591
%593 = load i32, i32* %50
%594 = sext i32 %593 to i64
%595 = getelementptr inbounds [992 x double], [992 x double]* %6, i64 0, i64 %594
%596 = load double, double* %595
%597 = fadd double %592, %596
%598 = load i32, i32* %50
%599 = sext i32 %598 to i64
%600 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %599
%601 = load double, double* %600
%602 = fadd double %601, %597
store double %602, double* %600
br label %603
603: ; preds = %587
%604 = load i32, i32* %50
%605 = add nsw i32 %604, 1
store i32 %605, i32* %50
br label %582
606: ; preds = %582
%607 = call i32 (...) @omp_get_thread_num()
%608 = mul nsw i32 %607, 4
store i32 %608, i32* %51
%609 = load i32, i32* %51
store i32 %609, i32* %52
br label %610
610: ; preds = %631, %606
%611 = load i32, i32* %52
%612 = load i32, i32* %51
%613 = add nsw i32 %612, 4
%614 = icmp slt i32 %611, %613
br i1 %614, label %615, label %634
615: ; preds = %610
%616 = load i32, i32* %52
%617 = sext i32 %616 to i64
%618 = getelementptr inbounds [992 x double], [992 x double]* %5, i64 0, i64 %617
%619 = load double, double* %618
%620 = fadd double 1.000000e+00, %619
%621 = load i32, i32* %52
%622 = sext i32 %621 to i64
%623 = getelementptr inbounds [992 x double], [992 x double]* %6, i64 0, i64 %622
%624 = load double, double* %623
%625 = fadd double %620, %624
%626 = load i32, i32* %52
%627 = sext i32 %626 to i64
%628 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %627
%629 = load double, double* %628
%630 = fadd double %629, %625
store double %630, double* %628
br label %631
631: ; preds = %615
%632 = load i32, i32* %52
%633 = add nsw i32 %632, 1
store i32 %633, i32* %52
br label %610
634: ; preds = %610
store i32 0, i32* %54
store i32 0, i32* %53
br label %635
635: ; preds = %657, %634
%636 = load i32, i32* %53
%637 = icmp slt i32 %636, 512
br i1 %637, label %638, label %660
638: ; preds = %635
%639 = load i32, i32* %53
%640 = sext i32 %639 to i64
%641 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %640
%642 = load double, double* %641
%643 = fcmp une double %642, 3.000000e+00
br i1 %643, label %644, label %656
644: ; preds = %638
%645 = load i32, i32* %53
%646 = load i32, i32* %53
%647 = sext i32 %646 to i64
%648 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %647
%649 = load double, double* %648
%650 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %645, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), i32 3, double %649)
store i32 1, i32* %44
%651 = load i32, i32* %54
%652 = add nsw i32 %651, 1
store i32 %652, i32* %54
%653 = icmp sgt i32 %651, 10
br i1 %653, label %654, label %655
654: ; preds = %644
br label %660
655: ; preds = %644
br label %656
656: ; preds = %655, %638
br label %657
657: ; preds = %656
%658 = load i32, i32* %53
%659 = add nsw i32 %658, 1
store i32 %659, i32* %53
br label %635
660: ; preds = %654, %635
br label %661
661: ; preds = %660
%662 = load i32, i32* %46
%663 = add nsw i32 %662, 1
store i32 %663, i32* %46
br label %544
664: ; preds = %550
%665 = load i32, i32* %44
%666 = icmp ne i32 %665, 0
br i1 %666, label %667, label %669
667: ; preds = %664
%668 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %671
669: ; preds = %664
%670 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %671
671: ; preds = %669, %667
store i32 1, i32* %55
br label %672
672: ; preds = %750, %671
%673 = load i32, i32* %55
%674 = icmp sle i32 %673, 128
br i1 %674, label %675, label %757
675: ; preds = %672
store i32 0, i32* %56
br label %676
676: ; preds = %683, %675
%677 = load i32, i32* %56
%678 = icmp slt i32 %677, 992
br i1 %678, label %679, label %686
679: ; preds = %676
%680 = load i32, i32* %56
%681 = sext i32 %680 to i64
%682 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %681
store double 0.000000e+00, double* %682
br label %683
683: ; preds = %679
%684 = load i32, i32* %56
%685 = add nsw i32 %684, 1
store i32 %685, i32* %56
br label %676
686: ; preds = %676
%687 = load i32, i32* %55
%688 = getelementptr inbounds [1 x i32], [1 x i32]* %57, i64 0, i64 0
store i32 %687, i32* %688
store i32 0, i32* %58
store i32 0, i32* %60
br label %689
689: ; preds = %739, %686
%690 = load i32, i32* %60
%691 = icmp slt i32 %690, 1
br i1 %691, label %692, label %695
692: ; preds = %689
%693 = load i32, i32* %58
%694 = icmp eq i32 %693, 0
br label %695
695: ; preds = %692, %689
%696 = phi i1 [ false, %689 ], [ %694, %692 ]
br i1 %696, label %697, label %742
697: ; preds = %695
%698 = call i32 (...) @omp_get_thread_num()
store i32 %698, i32* %61
%699 = load i32, i32* %61
%700 = sext i32 %699 to i64
%701 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %700
store double 9.900000e+01, double* %701
store i32 0, i32* %63
store i32 0, i32* %62
br label %702
702: ; preds = %735, %697
%703 = load i32, i32* %62
%704 = icmp slt i32 %703, 128
br i1 %704, label %705, label %738
705: ; preds = %702
%706 = load i32, i32* %62
%707 = sext i32 %706 to i64
%708 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %707
%709 = load double, double* %708
%710 = load i32, i32* %62
%711 = load i32, i32* %55
%712 = icmp slt i32 %710, %711
%713 = zext i1 %712 to i32
%714 = mul nsw i32 99, %713
%715 = sitofp i32 %714 to double
%716 = fcmp une double %709, %715
br i1 %716, label %717, label %734
717: ; preds = %705
%718 = load i32, i32* %62
%719 = load i32, i32* %62
%720 = load i32, i32* %55
%721 = icmp slt i32 %719, %720
%722 = zext i1 %721 to i32
%723 = mul nsw i32 99, %722
%724 = load i32, i32* %62
%725 = sext i32 %724 to i64
%726 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %725
%727 = load double, double* %726
%728 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %718, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 %723, double %727)
store i32 1, i32* %58
%729 = load i32, i32* %63
%730 = add nsw i32 %729, 1
store i32 %730, i32* %63
%731 = icmp sgt i32 %729, 10
br i1 %731, label %732, label %733
732: ; preds = %717
br label %738
733: ; preds = %717
br label %734
734: ; preds = %733, %705
br label %735
735: ; preds = %734
%736 = load i32, i32* %62
%737 = add nsw i32 %736, 1
store i32 %737, i32* %62
br label %702
738: ; preds = %732, %702
br label %739
739: ; preds = %738
%740 = load i32, i32* %60
%741 = add nsw i32 %740, 1
store i32 %741, i32* %60
br label %689
742: ; preds = %695
%743 = load i32, i32* %58
%744 = icmp ne i32 %743, 0
br i1 %744, label %745, label %747
745: ; preds = %742
%746 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %749
747: ; preds = %742
%748 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %749
749: ; preds = %747, %745
br label %750
750: ; preds = %749
%751 = load i32, i32* %55
%752 = icmp slt i32 %751, 32
%753 = zext i1 %752 to i64
%754 = select i1 %752, i32 1, i32 32
%755 = load i32, i32* %55
%756 = add nsw i32 %755, %754
store i32 %756, i32* %55
br label %672
757: ; preds = %672
store i32 0, i32* %64
br label %758
758: ; preds = %765, %757
%759 = load i32, i32* %64
%760 = icmp slt i32 %759, 992
br i1 %760, label %761, label %768
761: ; preds = %758
%762 = load i32, i32* %64
%763 = sext i32 %762 to i64
%764 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %763
store double 0.000000e+00, double* %764
br label %765
765: ; preds = %761
%766 = load i32, i32* %64
%767 = add nsw i32 %766, 1
store i32 %767, i32* %64
br label %758
768: ; preds = %758
store i32 0, i32* %65
store i32 0, i32* %67
br label %769
769: ; preds = %814, %768
%770 = load i32, i32* %67
%771 = icmp slt i32 %770, 1
br i1 %771, label %772, label %775
772: ; preds = %769
%773 = load i32, i32* %65
%774 = icmp eq i32 %773, 0
br label %775
775: ; preds = %772, %769
%776 = phi i1 [ false, %769 ], [ %774, %772 ]
br i1 %776, label %777, label %817
777: ; preds = %775
store double 1.000000e+00, double* %68
%778 = load double, double* %68
%779 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 0
store double %778, double* %779
store double 2.000000e+00, double* %68
%780 = load double, double* %68
%781 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 0
%782 = load double, double* %781
%783 = fadd double %782, %780
store double %783, double* %781
%784 = load double, double* %68
%785 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 0
%786 = load double, double* %785
%787 = fadd double %786, %784
store double %787, double* %785
store i32 0, i32* %70
store i32 0, i32* %69
br label %788
788: ; preds = %810, %777
%789 = load i32, i32* %69
%790 = icmp slt i32 %789, 1
br i1 %790, label %791, label %813
791: ; preds = %788
%792 = load i32, i32* %69
%793 = sext i32 %792 to i64
%794 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %793
%795 = load double, double* %794
%796 = fcmp une double %795, 5.000000e+00
br i1 %796, label %797, label %809
797: ; preds = %791
%798 = load i32, i32* %69
%799 = load i32, i32* %69
%800 = sext i32 %799 to i64
%801 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %800
%802 = load double, double* %801
%803 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %798, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 5, double %802)
store i32 1, i32* %65
%804 = load i32, i32* %70
%805 = add nsw i32 %804, 1
store i32 %805, i32* %70
%806 = icmp sgt i32 %804, 10
br i1 %806, label %807, label %808
807: ; preds = %797
br label %813
808: ; preds = %797
br label %809
809: ; preds = %808, %791
br label %810
810: ; preds = %809
%811 = load i32, i32* %69
%812 = add nsw i32 %811, 1
store i32 %812, i32* %69
br label %788
813: ; preds = %807, %788
br label %814
814: ; preds = %813
%815 = load i32, i32* %67
%816 = add nsw i32 %815, 1
store i32 %816, i32* %67
br label %769
817: ; preds = %775
%818 = load i32, i32* %65
%819 = icmp ne i32 %818, 0
br i1 %819, label %820, label %822
820: ; preds = %817
%821 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %824
822: ; preds = %817
%823 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %824
824: ; preds = %822, %820
store i32 0, i32* %71
br label %825
825: ; preds = %832, %824
%826 = load i32, i32* %71
%827 = icmp slt i32 %826, 992
br i1 %827, label %828, label %835
828: ; preds = %825
%829 = load i32, i32* %71
%830 = sext i32 %829 to i64
%831 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %830
store double 0.000000e+00, double* %831
br label %832
832: ; preds = %828
%833 = load i32, i32* %71
%834 = add nsw i32 %833, 1
store i32 %834, i32* %71
br label %825
835: ; preds = %825
store i32 0, i32* %72
store i32 0, i32* %74
br label %836
836: ; preds = %881, %835
%837 = load i32, i32* %74
%838 = icmp slt i32 %837, 1
br i1 %838, label %839, label %842
839: ; preds = %836
%840 = load i32, i32* %72
%841 = icmp eq i32 %840, 0
br label %842
842: ; preds = %839, %836
%843 = phi i1 [ false, %836 ], [ %841, %839 ]
br i1 %843, label %844, label %884
844: ; preds = %842
store double 1.000000e+00, double* %75
%845 = load double, double* %75
%846 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 0
store double %845, double* %846
store double 2.000000e+00, double* %75
%847 = load double, double* %75
%848 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 0
%849 = load double, double* %848
%850 = fadd double %849, %847
store double %850, double* %848
%851 = load double, double* %75
%852 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 0
%853 = load double, double* %852
%854 = fadd double %853, %851
store double %854, double* %852
store i32 0, i32* %77
store i32 0, i32* %76
br label %855
855: ; preds = %877, %844
%856 = load i32, i32* %76
%857 = icmp slt i32 %856, 1
br i1 %857, label %858, label %880
858: ; preds = %855
%859 = load i32, i32* %76
%860 = sext i32 %859 to i64
%861 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %860
%862 = load double, double* %861
%863 = fcmp une double %862, 4.000000e+00
br i1 %863, label %864, label %876
864: ; preds = %858
%865 = load i32, i32* %76
%866 = load i32, i32* %76
%867 = sext i32 %866 to i64
%868 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %867
%869 = load double, double* %868
%870 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %865, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 4, double %869)
store i32 1, i32* %72
%871 = load i32, i32* %77
%872 = add nsw i32 %871, 1
store i32 %872, i32* %77
%873 = icmp sgt i32 %871, 10
br i1 %873, label %874, label %875
874: ; preds = %864
br label %880
875: ; preds = %864
br label %876
876: ; preds = %875, %858
br label %877
877: ; preds = %876
%878 = load i32, i32* %76
%879 = add nsw i32 %878, 1
store i32 %879, i32* %76
br label %855
880: ; preds = %874, %855
br label %881
881: ; preds = %880
%882 = load i32, i32* %74
%883 = add nsw i32 %882, 1
store i32 %883, i32* %74
br label %836
884: ; preds = %842
%885 = load i32, i32* %72
%886 = icmp ne i32 %885, 0
br i1 %886, label %887, label %889
887: ; preds = %884
%888 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %891
889: ; preds = %884
%890 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %891
891: ; preds = %889, %887
store i32 0, i32* %78
br label %892
892: ; preds = %899, %891
%893 = load i32, i32* %78
%894 = icmp slt i32 %893, 992
br i1 %894, label %895, label %902
895: ; preds = %892
%896 = load i32, i32* %78
%897 = sext i32 %896 to i64
%898 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %897
store double 0.000000e+00, double* %898
br label %899
899: ; preds = %895
%900 = load i32, i32* %78
%901 = add nsw i32 %900, 1
store i32 %901, i32* %78
br label %892
902: ; preds = %892
store i32 0, i32* %79
store i32 0, i32* %81
br label %903
903: ; preds = %950, %902
%904 = load i32, i32* %81
%905 = icmp slt i32 %904, 1
br i1 %905, label %906, label %909
906: ; preds = %903
%907 = load i32, i32* %79
%908 = icmp eq i32 %907, 0
br label %909
909: ; preds = %906, %903
%910 = phi i1 [ false, %903 ], [ %908, %906 ]
br i1 %910, label %911, label %953
911: ; preds = %909
store double 1.000000e+00, double* %82
%912 = load double, double* %82
%913 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 0
store double %912, double* %913
%914 = load double, double* %82
%915 = fadd double %914, 2.000000e+00
store double %915, double* %82
%916 = load double, double* %82
%917 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 0
%918 = load double, double* %917
%919 = fadd double %918, %916
store double %919, double* %917
%920 = load double, double* %82
%921 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 0
%922 = load double, double* %921
%923 = fadd double %922, %920
store double %923, double* %921
store i32 0, i32* %84
store i32 0, i32* %83
br label %924
924: ; preds = %946, %911
%925 = load i32, i32* %83
%926 = icmp slt i32 %925, 1
br i1 %926, label %927, label %949
927: ; preds = %924
%928 = load i32, i32* %83
%929 = sext i32 %928 to i64
%930 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %929
%931 = load double, double* %930
%932 = fcmp une double %931, 5.000000e+00
br i1 %932, label %933, label %945
933: ; preds = %927
%934 = load i32, i32* %83
%935 = load i32, i32* %83
%936 = sext i32 %935 to i64
%937 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %936
%938 = load double, double* %937
%939 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %934, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 5, double %938)
store i32 1, i32* %79
%940 = load i32, i32* %84
%941 = add nsw i32 %940, 1
store i32 %941, i32* %84
%942 = icmp sgt i32 %940, 10
br i1 %942, label %943, label %944
943: ; preds = %933
br label %949
944: ; preds = %933
br label %945
945: ; preds = %944, %927
br label %946
946: ; preds = %945
%947 = load i32, i32* %83
%948 = add nsw i32 %947, 1
store i32 %948, i32* %83
br label %924
949: ; preds = %943, %924
br label %950
950: ; preds = %949
%951 = load i32, i32* %81
%952 = add nsw i32 %951, 1
store i32 %952, i32* %81
br label %903
953: ; preds = %909
%954 = load i32, i32* %79
%955 = icmp ne i32 %954, 0
br i1 %955, label %956, label %958
956: ; preds = %953
%957 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %960
958: ; preds = %953
%959 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %960
960: ; preds = %958, %956
store i32 0, i32* %85
br label %961
961: ; preds = %968, %960
%962 = load i32, i32* %85
%963 = icmp slt i32 %962, 992
br i1 %963, label %964, label %971
964: ; preds = %961
%965 = load i32, i32* %85
%966 = sext i32 %965 to i64
%967 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %966
store double 0.000000e+00, double* %967
br label %968
968: ; preds = %964
%969 = load i32, i32* %85
%970 = add nsw i32 %969, 1
store i32 %970, i32* %85
br label %961
971: ; preds = %961
store i32 0, i32* %86
store i32 0, i32* %88
br label %972
972: ; preds = %1025, %971
%973 = load i32, i32* %88
%974 = icmp slt i32 %973, 1
br i1 %974, label %975, label %978
975: ; preds = %972
%976 = load i32, i32* %86
%977 = icmp eq i32 %976, 0
br label %978
978: ; preds = %975, %972
%979 = phi i1 [ false, %972 ], [ %977, %975 ]
br i1 %979, label %980, label %1028
980: ; preds = %978
store double 1.000000e+00, double* %89
%981 = load double, double* %89
%982 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 0
store double %981, double* %982
store double 2.100000e+01, double* %90
%983 = load double, double* %90
%984 = fadd double %983, 9.000000e+00
store double %984, double* %90
%985 = load double, double* %90
%986 = fadd double 2.000000e+00, %985
%987 = load double, double* %89
%988 = fadd double %987, %986
store double %988, double* %89
%989 = load double, double* %89
%990 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 0
%991 = load double, double* %990
%992 = fadd double %991, %989
store double %992, double* %990
%993 = load double, double* %89
%994 = load double, double* %90
%995 = fadd double %993, %994
%996 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 0
%997 = load double, double* %996
%998 = fadd double %997, %995
store double %998, double* %996
store i32 0, i32* %92
store i32 0, i32* %91
br label %999
999: ; preds = %1021, %980
%1000 = load i32, i32* %91
%1001 = icmp slt i32 %1000, 1
br i1 %1001, label %1002, label %1024
1002: ; preds = %999
%1003 = load i32, i32* %91
%1004 = sext i32 %1003 to i64
%1005 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1004
%1006 = load double, double* %1005
%1007 = fcmp une double %1006, 6.500000e+01
br i1 %1007, label %1008, label %1020
1008: ; preds = %1002
%1009 = load i32, i32* %91
%1010 = load i32, i32* %91
%1011 = sext i32 %1010 to i64
%1012 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1011
%1013 = load double, double* %1012
%1014 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %1009, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 65, double %1013)
store i32 1, i32* %86
%1015 = load i32, i32* %92
%1016 = add nsw i32 %1015, 1
store i32 %1016, i32* %92
%1017 = icmp sgt i32 %1015, 10
br i1 %1017, label %1018, label %1019
1018: ; preds = %1008
br label %1024
1019: ; preds = %1008
br label %1020
1020: ; preds = %1019, %1002
br label %1021
1021: ; preds = %1020
%1022 = load i32, i32* %91
%1023 = add nsw i32 %1022, 1
store i32 %1023, i32* %91
br label %999
1024: ; preds = %1018, %999
br label %1025
1025: ; preds = %1024
%1026 = load i32, i32* %88
%1027 = add nsw i32 %1026, 1
store i32 %1027, i32* %88
br label %972
1028: ; preds = %978
%1029 = load i32, i32* %86
%1030 = icmp ne i32 %1029, 0
br i1 %1030, label %1031, label %1033
1031: ; preds = %1028
%1032 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %1035
1033: ; preds = %1028
%1034 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %1035
1035: ; preds = %1033, %1031
store i32 0, i32* %93
br label %1036
1036: ; preds = %1043, %1035
%1037 = load i32, i32* %93
%1038 = icmp slt i32 %1037, 992
br i1 %1038, label %1039, label %1046
1039: ; preds = %1036
%1040 = load i32, i32* %93
%1041 = sext i32 %1040 to i64
%1042 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1041
store double 0.000000e+00, double* %1042
br label %1043
1043: ; preds = %1039
%1044 = load i32, i32* %93
%1045 = add nsw i32 %1044, 1
store i32 %1045, i32* %93
br label %1036
1046: ; preds = %1036
store i32 0, i32* %94
br label %1047
1047: ; preds = %1054, %1046
%1048 = load i32, i32* %94
%1049 = icmp slt i32 %1048, 992
br i1 %1049, label %1050, label %1057
1050: ; preds = %1047
%1051 = load i32, i32* %94
%1052 = sext i32 %1051 to i64
%1053 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1052
store double 0.000000e+00, double* %1053
br label %1054
1054: ; preds = %1050
%1055 = load i32, i32* %94
%1056 = add nsw i32 %1055, 1
store i32 %1056, i32* %94
br label %1047
1057: ; preds = %1047
store i32 0, i32* %95
store i32 0, i32* %97
br label %1058
1058: ; preds = %1143, %1057
%1059 = load i32, i32* %97
%1060 = icmp slt i32 %1059, 1
br i1 %1060, label %1061, label %1064
1061: ; preds = %1058
%1062 = load i32, i32* %95
%1063 = icmp eq i32 %1062, 0
br label %1064
1064: ; preds = %1061, %1058
%1065 = phi i1 [ false, %1058 ], [ %1063, %1061 ]
br i1 %1065, label %1066, label %1146
1066: ; preds = %1064
store i32 0, i32* %98
br label %1067
1067: ; preds = %1085, %1066
%1068 = load i32, i32* %98
%1069 = icmp slt i32 %1068, 128
br i1 %1069, label %1070, label %1088
1070: ; preds = %1067
%1071 = load i32, i32* %98
%1072 = sext i32 %1071 to i64
%1073 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1072
store double 0.000000e+00, double* %1073
%1074 = load i32, i32* %98
%1075 = sext i32 %1074 to i64
%1076 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1075
%1077 = load double, double* %1076
%1078 = fadd double 9.900000e+01, %1077
%1079 = load i32, i32* %98
%1080 = sext i32 %1079 to i64
%1081 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1080
store double %1078, double* %1081
%1082 = load i32, i32* %98
%1083 = sext i32 %1082 to i64
%1084 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1083
store double 1.000000e+00, double* %1084
br label %1085
1085: ; preds = %1070
%1086 = load i32, i32* %98
%1087 = add nsw i32 %1086, 1
store i32 %1087, i32* %98
br label %1067
1088: ; preds = %1067
%1089 = call i32 (...) @omp_get_thread_num()
store i32 %1089, i32* %99
%1090 = load i32, i32* %99
%1091 = sext i32 %1090 to i64
%1092 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1091
%1093 = load double, double* %1092
%1094 = fadd double %1093, 1.000000e+00
store double %1094, double* %1092
%1095 = load i32, i32* %99
%1096 = sext i32 %1095 to i64
%1097 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1096
%1098 = load double, double* %1097
%1099 = fadd double %1098, 2.000000e+00
store double %1099, double* %1097
store i32 0, i32* %100
br label %1100
1100: ; preds = %1113, %1088
%1101 = load i32, i32* %100
%1102 = icmp slt i32 %1101, 128
br i1 %1102, label %1103, label %1116
1103: ; preds = %1100
%1104 = load i32, i32* %100
%1105 = sext i32 %1104 to i64
%1106 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1105
%1107 = load double, double* %1106
%1108 = load i32, i32* %100
%1109 = sext i32 %1108 to i64
%1110 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1109
%1111 = load double, double* %1110
%1112 = fadd double %1111, %1107
store double %1112, double* %1110
br label %1113
1113: ; preds = %1103
%1114 = load i32, i32* %100
%1115 = add nsw i32 %1114, 1
store i32 %1115, i32* %100
br label %1100
1116: ; preds = %1100
store i32 0, i32* %102
store i32 0, i32* %101
br label %1117
1117: ; preds = %1139, %1116
%1118 = load i32, i32* %101
%1119 = icmp slt i32 %1118, 128
br i1 %1119, label %1120, label %1142
1120: ; preds = %1117
%1121 = load i32, i32* %101
%1122 = sext i32 %1121 to i64
%1123 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1122
%1124 = load double, double* %1123
%1125 = fcmp une double %1124, 1.030000e+02
br i1 %1125, label %1126, label %1138
1126: ; preds = %1120
%1127 = load i32, i32* %101
%1128 = load i32, i32* %101
%1129 = sext i32 %1128 to i64
%1130 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1129
%1131 = load double, double* %1130
%1132 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %1127, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 103, double %1131)
store i32 1, i32* %95
%1133 = load i32, i32* %102
%1134 = add nsw i32 %1133, 1
store i32 %1134, i32* %102
%1135 = icmp sgt i32 %1133, 10
br i1 %1135, label %1136, label %1137
1136: ; preds = %1126
br label %1142
1137: ; preds = %1126
br label %1138
1138: ; preds = %1137, %1120
br label %1139
1139: ; preds = %1138
%1140 = load i32, i32* %101
%1141 = add nsw i32 %1140, 1
store i32 %1141, i32* %101
br label %1117
1142: ; preds = %1136, %1117
br label %1143
1143: ; preds = %1142
%1144 = load i32, i32* %97
%1145 = add nsw i32 %1144, 1
store i32 %1145, i32* %97
br label %1058
1146: ; preds = %1064
%1147 = load i32, i32* %95
%1148 = icmp ne i32 %1147, 0
br i1 %1148, label %1149, label %1151
1149: ; preds = %1146
%1150 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %1153
1151: ; preds = %1146
%1152 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %1153
1153: ; preds = %1151, %1149
store i32 0, i32* %103
br label %1154
1154: ; preds = %1161, %1153
%1155 = load i32, i32* %103
%1156 = icmp slt i32 %1155, 992
br i1 %1156, label %1157, label %1164
1157: ; preds = %1154
%1158 = load i32, i32* %103
%1159 = sext i32 %1158 to i64
%1160 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1159
store double 0.000000e+00, double* %1160
br label %1161
1161: ; preds = %1157
%1162 = load i32, i32* %103
%1163 = add nsw i32 %1162, 1
store i32 %1163, i32* %103
br label %1154
1164: ; preds = %1154
store i32 0, i32* %104
br label %1165
1165: ; preds = %1172, %1164
%1166 = load i32, i32* %104
%1167 = icmp slt i32 %1166, 992
br i1 %1167, label %1168, label %1175
1168: ; preds = %1165
%1169 = load i32, i32* %104
%1170 = sext i32 %1169 to i64
%1171 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1170
store double 0.000000e+00, double* %1171
br label %1172
1172: ; preds = %1168
%1173 = load i32, i32* %104
%1174 = add nsw i32 %1173, 1
store i32 %1174, i32* %104
br label %1165
1175: ; preds = %1165
store i32 0, i32* %105
store i32 0, i32* %107
br label %1176
1176: ; preds = %1259, %1175
%1177 = load i32, i32* %107
%1178 = icmp slt i32 %1177, 1
br i1 %1178, label %1179, label %1182
1179: ; preds = %1176
%1180 = load i32, i32* %105
%1181 = icmp eq i32 %1180, 0
br label %1182
1182: ; preds = %1179, %1176
%1183 = phi i1 [ false, %1176 ], [ %1181, %1179 ]
br i1 %1183, label %1184, label %1262
1184: ; preds = %1182
store i32 0, i32* %108
br label %1185
1185: ; preds = %1203, %1184
%1186 = load i32, i32* %108
%1187 = icmp slt i32 %1186, 128
br i1 %1187, label %1188, label %1206
1188: ; preds = %1185
%1189 = load i32, i32* %108
%1190 = sext i32 %1189 to i64
%1191 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1190
store double 0.000000e+00, double* %1191
%1192 = load i32, i32* %108
%1193 = sext i32 %1192 to i64
%1194 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1193
%1195 = load double, double* %1194
%1196 = fadd double 9.900000e+01, %1195
%1197 = load i32, i32* %108
%1198 = sext i32 %1197 to i64
%1199 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1198
store double %1196, double* %1199
%1200 = load i32, i32* %108
%1201 = sext i32 %1200 to i64
%1202 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1201
store double 1.000000e+00, double* %1202
br label %1203
1203: ; preds = %1188
%1204 = load i32, i32* %108
%1205 = add nsw i32 %1204, 1
store i32 %1205, i32* %108
br label %1185
1206: ; preds = %1185
%1207 = call i32 (...) @omp_get_thread_num()
store i32 %1207, i32* %109
%1208 = load i32, i32* %109
%1209 = sext i32 %1208 to i64
%1210 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1209
%1211 = load double, double* %1210
%1212 = fadd double %1211, 1.000000e+00
store double %1212, double* %1210
%1213 = load i32, i32* %109
%1214 = sext i32 %1213 to i64
%1215 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1214
store double 2.000000e+00, double* %1215
store i32 0, i32* %110
br label %1216
1216: ; preds = %1229, %1206
%1217 = load i32, i32* %110
%1218 = icmp slt i32 %1217, 128
br i1 %1218, label %1219, label %1232
1219: ; preds = %1216
%1220 = load i32, i32* %110
%1221 = sext i32 %1220 to i64
%1222 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1221
%1223 = load double, double* %1222
%1224 = load i32, i32* %110
%1225 = sext i32 %1224 to i64
%1226 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1225
%1227 = load double, double* %1226
%1228 = fadd double %1227, %1223
store double %1228, double* %1226
br label %1229
1229: ; preds = %1219
%1230 = load i32, i32* %110
%1231 = add nsw i32 %1230, 1
store i32 %1231, i32* %110
br label %1216
1232: ; preds = %1216
store i32 0, i32* %112
store i32 0, i32* %111
br label %1233
1233: ; preds = %1255, %1232
%1234 = load i32, i32* %111
%1235 = icmp slt i32 %1234, 128
br i1 %1235, label %1236, label %1258
1236: ; preds = %1233
%1237 = load i32, i32* %111
%1238 = sext i32 %1237 to i64
%1239 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1238
%1240 = load double, double* %1239
%1241 = fcmp une double %1240, 1.010000e+02
br i1 %1241, label %1242, label %1254
1242: ; preds = %1236
%1243 = load i32, i32* %111
%1244 = load i32, i32* %111
%1245 = sext i32 %1244 to i64
%1246 = getelementptr inbounds [992 x double], [992 x double]* %2, 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 %1243, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 101, double %1247)
store i32 1, i32* %105
%1249 = load i32, i32* %112
%1250 = add nsw i32 %1249, 1
store i32 %1250, i32* %112
%1251 = icmp sgt i32 %1249, 10
br i1 %1251, label %1252, label %1253
1252: ; preds = %1242
br label %1258
1253: ; preds = %1242
br label %1254
1254: ; preds = %1253, %1236
br label %1255
1255: ; preds = %1254
%1256 = load i32, i32* %111
%1257 = add nsw i32 %1256, 1
store i32 %1257, i32* %111
br label %1233
1258: ; preds = %1252, %1233
br label %1259
1259: ; preds = %1258
%1260 = load i32, i32* %107
%1261 = add nsw i32 %1260, 1
store i32 %1261, i32* %107
br label %1176
1262: ; preds = %1182
%1263 = load i32, i32* %105
%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
store i32 0, i32* %113
br label %1270
1270: ; preds = %1277, %1269
%1271 = load i32, i32* %113
%1272 = icmp slt i32 %1271, 992
br i1 %1272, label %1273, label %1280
1273: ; preds = %1270
%1274 = load i32, i32* %113
%1275 = sext i32 %1274 to i64
%1276 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1275
store double 0.000000e+00, double* %1276
br label %1277
1277: ; preds = %1273
%1278 = load i32, i32* %113
%1279 = add nsw i32 %1278, 1
store i32 %1279, i32* %113
br label %1270
1280: ; preds = %1270
store i32 0, i32* %114
br label %1281
1281: ; preds = %1288, %1280
%1282 = load i32, i32* %114
%1283 = icmp slt i32 %1282, 992
br i1 %1283, label %1284, label %1291
1284: ; preds = %1281
%1285 = load i32, i32* %114
%1286 = sext i32 %1285 to i64
%1287 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1286
store double 0.000000e+00, double* %1287
br label %1288
1288: ; preds = %1284
%1289 = load i32, i32* %114
%1290 = add nsw i32 %1289, 1
store i32 %1290, i32* %114
br label %1281
1291: ; preds = %1281
store i32 0, i32* %115
store i32 0, i32* %117
br label %1292
1292: ; preds = %1381, %1291
%1293 = load i32, i32* %117
%1294 = icmp slt i32 %1293, 1
br i1 %1294, label %1295, label %1298
1295: ; preds = %1292
%1296 = load i32, i32* %115
%1297 = icmp eq i32 %1296, 0
br label %1298
1298: ; preds = %1295, %1292
%1299 = phi i1 [ false, %1292 ], [ %1297, %1295 ]
br i1 %1299, label %1300, label %1384
1300: ; preds = %1298
store i32 0, i32* %118
br label %1301
1301: ; preds = %1319, %1300
%1302 = load i32, i32* %118
%1303 = icmp slt i32 %1302, 128
br i1 %1303, label %1304, label %1322
1304: ; preds = %1301
%1305 = load i32, i32* %118
%1306 = sext i32 %1305 to i64
%1307 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1306
store double 0.000000e+00, double* %1307
%1308 = load i32, i32* %118
%1309 = sext i32 %1308 to i64
%1310 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1309
%1311 = load double, double* %1310
%1312 = fadd double 9.900000e+01, %1311
%1313 = load i32, i32* %118
%1314 = sext i32 %1313 to i64
%1315 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1314
store double %1312, double* %1315
%1316 = load i32, i32* %118
%1317 = sext i32 %1316 to i64
%1318 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1317
store double 2.000000e+00, double* %1318
br label %1319
1319: ; preds = %1304
%1320 = load i32, i32* %118
%1321 = add nsw i32 %1320, 1
store i32 %1321, i32* %118
br label %1301
1322: ; preds = %1301
%1323 = call i32 (...) @omp_get_thread_num()
store i32 %1323, i32* %119
%1324 = load i32, i32* %119
%1325 = sext i32 %1324 to i64
%1326 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1325
%1327 = load double, double* %1326
%1328 = fadd double %1327, 8.000000e+00
store double %1328, double* %1326
%1329 = load i32, i32* %119
%1330 = sext i32 %1329 to i64
%1331 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1330
%1332 = load double, double* %1331
%1333 = load i32, i32* %119
%1334 = sext i32 %1333 to i64
%1335 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1334
%1336 = load double, double* %1335
%1337 = fadd double %1336, %1332
store double %1337, double* %1335
store i32 0, i32* %120
br label %1338
1338: ; preds = %1351, %1322
%1339 = load i32, i32* %120
%1340 = icmp slt i32 %1339, 128
br i1 %1340, label %1341, label %1354
1341: ; preds = %1338
%1342 = load i32, i32* %120
%1343 = sext i32 %1342 to i64
%1344 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1343
%1345 = load double, double* %1344
%1346 = load i32, i32* %120
%1347 = sext i32 %1346 to i64
%1348 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1347
%1349 = load double, double* %1348
%1350 = fadd double %1349, %1345
store double %1350, double* %1348
br label %1351
1351: ; preds = %1341
%1352 = load i32, i32* %120
%1353 = add nsw i32 %1352, 1
store i32 %1353, i32* %120
br label %1338
1354: ; preds = %1338
store i32 0, i32* %122
store i32 0, i32* %121
br label %1355
1355: ; preds = %1377, %1354
%1356 = load i32, i32* %121
%1357 = icmp slt i32 %1356, 128
br i1 %1357, label %1358, label %1380
1358: ; preds = %1355
%1359 = load i32, i32* %121
%1360 = sext i32 %1359 to i64
%1361 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1360
%1362 = load double, double* %1361
%1363 = fcmp une double %1362, 1.110000e+02
br i1 %1363, label %1364, label %1376
1364: ; preds = %1358
%1365 = load i32, i32* %121
%1366 = load i32, i32* %121
%1367 = sext i32 %1366 to i64
%1368 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1367
%1369 = load double, double* %1368
%1370 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %1365, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 111, double %1369)
store i32 1, i32* %115
%1371 = load i32, i32* %122
%1372 = add nsw i32 %1371, 1
store i32 %1372, i32* %122
%1373 = icmp sgt i32 %1371, 10
br i1 %1373, label %1374, label %1375
1374: ; preds = %1364
br label %1380
1375: ; preds = %1364
br label %1376
1376: ; preds = %1375, %1358
br label %1377
1377: ; preds = %1376
%1378 = load i32, i32* %121
%1379 = add nsw i32 %1378, 1
store i32 %1379, i32* %121
br label %1355
1380: ; preds = %1374, %1355
br label %1381
1381: ; preds = %1380
%1382 = load i32, i32* %117
%1383 = add nsw i32 %1382, 1
store i32 %1383, i32* %117
br label %1292
1384: ; preds = %1298
%1385 = load i32, i32* %115
%1386 = icmp ne i32 %1385, 0
br i1 %1386, label %1387, label %1389
1387: ; preds = %1384
%1388 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %1391
1389: ; preds = %1384
%1390 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %1391
1391: ; preds = %1389, %1387
store i32 0, i32* %123
br label %1392
1392: ; preds = %1399, %1391
%1393 = load i32, i32* %123
%1394 = icmp slt i32 %1393, 992
br i1 %1394, label %1395, label %1402
1395: ; preds = %1392
%1396 = load i32, i32* %123
%1397 = sext i32 %1396 to i64
%1398 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1397
store double 0.000000e+00, double* %1398
br label %1399
1399: ; preds = %1395
%1400 = load i32, i32* %123
%1401 = add nsw i32 %1400, 1
store i32 %1401, i32* %123
br label %1392
1402: ; preds = %1392
store i32 0, i32* %124
br label %1403
1403: ; preds = %1410, %1402
%1404 = load i32, i32* %124
%1405 = icmp slt i32 %1404, 992
br i1 %1405, label %1406, label %1413
1406: ; preds = %1403
%1407 = load i32, i32* %124
%1408 = sext i32 %1407 to i64
%1409 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1408
store double 0.000000e+00, double* %1409
br label %1410
1410: ; preds = %1406
%1411 = load i32, i32* %124
%1412 = add nsw i32 %1411, 1
store i32 %1412, i32* %124
br label %1403
1413: ; preds = %1403
store i32 0, i32* %125
store i32 0, i32* %127
br label %1414
1414: ; preds = %1478, %1413
%1415 = load i32, i32* %127
%1416 = icmp slt i32 %1415, 1
br i1 %1416, label %1417, label %1420
1417: ; preds = %1414
%1418 = load i32, i32* %125
%1419 = icmp eq i32 %1418, 0
br label %1420
1420: ; preds = %1417, %1414
%1421 = phi i1 [ false, %1414 ], [ %1419, %1417 ]
br i1 %1421, label %1422, label %1481
1422: ; preds = %1420
%1423 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 0
store double 0.000000e+00, double* %1423
%1424 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 0
%1425 = load double, double* %1424
%1426 = fadd double 9.900000e+01, %1425
%1427 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 0
store double %1426, double* %1427
%1428 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 0
store double 2.000000e+00, double* %1428
%1429 = getelementptr inbounds [32 x double], [32 x double]* %128, i64 0, i64 30
store double 2.100000e+01, double* %1429
%1430 = getelementptr inbounds [32 x double], [32 x double]* %128, i64 0, i64 30
%1431 = load double, double* %1430
%1432 = fadd double %1431, 9.000000e+00
store double %1432, double* %1430
%1433 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 0
%1434 = load double, double* %1433
%1435 = fadd double %1434, 8.000000e+00
store double %1435, double* %1433
%1436 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 0
%1437 = load double, double* %1436
%1438 = getelementptr inbounds [32 x double], [32 x double]* %128, i64 0, i64 30
%1439 = load double, double* %1438
%1440 = fadd double %1437, %1439
%1441 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 0
%1442 = load double, double* %1441
%1443 = fadd double %1442, %1440
store double %1443, double* %1441
%1444 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 0
%1445 = load double, double* %1444
%1446 = getelementptr inbounds [32 x double], [32 x double]* %128, i64 0, i64 30
%1447 = load double, double* %1446
%1448 = fadd double %1445, %1447
%1449 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 0
%1450 = load double, double* %1449
%1451 = fadd double %1450, %1448
store double %1451, double* %1449
store i32 0, i32* %130
store i32 0, i32* %129
br label %1452
1452: ; preds = %1474, %1422
%1453 = load i32, i32* %129
%1454 = icmp slt i32 %1453, 1
br i1 %1454, label %1455, label %1477
1455: ; preds = %1452
%1456 = load i32, i32* %129
%1457 = sext i32 %1456 to i64
%1458 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1457
%1459 = load double, double* %1458
%1460 = fcmp une double %1459, 1.710000e+02
br i1 %1460, label %1461, label %1473
1461: ; preds = %1455
%1462 = load i32, i32* %129
%1463 = load i32, i32* %129
%1464 = sext i32 %1463 to i64
%1465 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1464
%1466 = load double, double* %1465
%1467 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %1462, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 171, double %1466)
store i32 1, i32* %125
%1468 = load i32, i32* %130
%1469 = add nsw i32 %1468, 1
store i32 %1469, i32* %130
%1470 = icmp sgt i32 %1468, 10
br i1 %1470, label %1471, label %1472
1471: ; preds = %1461
br label %1477
1472: ; preds = %1461
br label %1473
1473: ; preds = %1472, %1455
br label %1474
1474: ; preds = %1473
%1475 = load i32, i32* %129
%1476 = add nsw i32 %1475, 1
store i32 %1476, i32* %129
br label %1452
1477: ; preds = %1471, %1452
br label %1478
1478: ; preds = %1477
%1479 = load i32, i32* %127
%1480 = add nsw i32 %1479, 1
store i32 %1480, i32* %127
br label %1414
1481: ; preds = %1420
%1482 = load i32, i32* %125
%1483 = icmp ne i32 %1482, 0
br i1 %1483, label %1484, label %1486
1484: ; preds = %1481
%1485 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %1488
1486: ; preds = %1481
%1487 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %1488
1488: ; preds = %1486, %1484
%1489 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 0
%1490 = getelementptr inbounds %struct.CITY, %struct.CITY* %1489, i32 0, i32 0
%1491 = getelementptr inbounds [128 x i8], [128 x i8]* %1490, i64 0, i64 0
%1492 = call i8* @strcpy(i8* %1491, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.5, i64 0, i64 0))
%1493 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 0
%1494 = getelementptr inbounds %struct.CITY, %struct.CITY* %1493, i32 0, i32 1
store i32 21, i32* %1494
store i32 0, i32* %132
br label %1495
1495: ; preds = %1503, %1488
%1496 = load i32, i32* %132
%1497 = icmp slt i32 %1496, 992
br i1 %1497, label %1498, label %1506
1498: ; preds = %1495
%1499 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1500 = load i32, i32* %132
%1501 = sext i32 %1500 to i64
%1502 = getelementptr inbounds [992 x double], [992 x double]* %1499, i64 0, i64 %1501
store double 0.000000e+00, double* %1502
br label %1503
1503: ; preds = %1498
%1504 = load i32, i32* %132
%1505 = add nsw i32 %1504, 1
store i32 %1505, i32* %132
br label %1495
1506: ; preds = %1495
store i32 0, i32* %133
store i32 0, i32* %135
br label %1507
1507: ; preds = %1595, %1506
%1508 = load i32, i32* %135
%1509 = icmp slt i32 %1508, 1
br i1 %1509, label %1510, label %1513
1510: ; preds = %1507
%1511 = load i32, i32* %133
%1512 = icmp eq i32 %1511, 0
br label %1513
1513: ; preds = %1510, %1507
%1514 = phi i1 [ false, %1507 ], [ %1512, %1510 ]
br i1 %1514, label %1515, label %1598
1515: ; preds = %1513
%1516 = call i32 (...) @omp_get_thread_num()
store i32 %1516, i32* %136
%1517 = load i32, i32* %136
%1518 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 0
%1519 = getelementptr inbounds %struct.CITY, %struct.CITY* %1518, i32 0, i32 0
%1520 = getelementptr inbounds [128 x i8], [128 x i8]* %1519, i64 0, i64 1
%1521 = load i8, i8* %1520
%1522 = sext i8 %1521 to i32
%1523 = add nsw i32 %1517, %1522
%1524 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 0
%1525 = getelementptr inbounds %struct.CITY, %struct.CITY* %1524, i32 0, i32 1
%1526 = load i32, i32* %1525
%1527 = add nsw i32 %1523, %1526
%1528 = sitofp i32 %1527 to double
%1529 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1530 = load i32, i32* %136
%1531 = sext i32 %1530 to i64
%1532 = getelementptr inbounds [992 x double], [992 x double]* %1529, i64 0, i64 %1531
%1533 = load double, double* %1532
%1534 = fadd double %1533, %1528
store double %1534, double* %1532
%1535 = call i32 (...) @omp_get_thread_num()
store i32 %1535, i32* %137
%1536 = load i32, i32* %137
%1537 = add nsw i32 1, %1536
%1538 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 0
%1539 = getelementptr inbounds %struct.CITY, %struct.CITY* %1538, i32 0, i32 0
%1540 = getelementptr inbounds [128 x i8], [128 x i8]* %1539, i64 0, i64 1
%1541 = load i8, i8* %1540
%1542 = sext i8 %1541 to i32
%1543 = add nsw i32 %1537, %1542
%1544 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 0
%1545 = getelementptr inbounds %struct.CITY, %struct.CITY* %1544, i32 0, i32 1
%1546 = load i32, i32* %1545
%1547 = add nsw i32 %1543, %1546
%1548 = sitofp i32 %1547 to double
%1549 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1550 = load i32, i32* %137
%1551 = add nsw i32 1, %1550
%1552 = sext i32 %1551 to i64
%1553 = getelementptr inbounds [992 x double], [992 x double]* %1549, i64 0, i64 %1552
%1554 = load double, double* %1553
%1555 = fadd double %1554, %1548
store double %1555, double* %1553
store i32 0, i32* %139
store i32 0, i32* %138
br label %1556
1556: ; preds = %1591, %1515
%1557 = load i32, i32* %138
%1558 = icmp slt i32 %1557, 128
br i1 %1558, label %1559, label %1594
1559: ; preds = %1556
%1560 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1561 = load i32, i32* %138
%1562 = sext i32 %1561 to i64
%1563 = getelementptr inbounds [992 x double], [992 x double]* %1560, i64 0, i64 %1562
%1564 = load double, double* %1563
%1565 = load i32, i32* %138
%1566 = add nsw i32 132, %1565
%1567 = load i32, i32* %135
%1568 = add nsw i32 %1567, 1
%1569 = mul nsw i32 %1566, %1568
%1570 = sitofp i32 %1569 to double
%1571 = fcmp une double %1564, %1570
br i1 %1571, label %1572, label %1590
1572: ; preds = %1559
%1573 = load i32, i32* %138
%1574 = load i32, i32* %138
%1575 = add nsw i32 132, %1574
%1576 = load i32, i32* %135
%1577 = add nsw i32 %1576, 1
%1578 = mul nsw i32 %1575, %1577
%1579 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1580 = load i32, i32* %138
%1581 = sext i32 %1580 to i64
%1582 = getelementptr inbounds [992 x double], [992 x double]* %1579, i64 0, i64 %1581
%1583 = load double, double* %1582
%1584 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %1573, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0), i32 %1578, double %1583)
store i32 1, i32* %133
%1585 = load i32, i32* %139
%1586 = add nsw i32 %1585, 1
store i32 %1586, i32* %139
%1587 = icmp sgt i32 %1585, 10
br i1 %1587, label %1588, label %1589
1588: ; preds = %1572
br label %1594
1589: ; preds = %1572
br label %1590
1590: ; preds = %1589, %1559
br label %1591
1591: ; preds = %1590
%1592 = load i32, i32* %138
%1593 = add nsw i32 %1592, 1
store i32 %1593, i32* %138
br label %1556
1594: ; preds = %1588, %1556
br label %1595
1595: ; preds = %1594
%1596 = load i32, i32* %135
%1597 = add nsw i32 %1596, 1
store i32 %1597, i32* %135
br label %1507
1598: ; preds = %1513
%1599 = load i32, i32* %133
%1600 = icmp ne i32 %1599, 0
br i1 %1600, label %1601, label %1603
1601: ; preds = %1598
%1602 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %1605
1603: ; preds = %1598
%1604 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %1605
1605: ; preds = %1603, %1601
store i32 0, i32* %140
br label %1606
1606: ; preds = %1614, %1605
%1607 = load i32, i32* %140
%1608 = icmp slt i32 %1607, 992
br i1 %1608, label %1609, label %1617
1609: ; preds = %1606
%1610 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1611 = load i32, i32* %140
%1612 = sext i32 %1611 to i64
%1613 = getelementptr inbounds [992 x double], [992 x double]* %1610, i64 0, i64 %1612
store double 0.000000e+00, double* %1613
br label %1614
1614: ; preds = %1609
%1615 = load i32, i32* %140
%1616 = add nsw i32 %1615, 1
store i32 %1616, i32* %140
br label %1606
1617: ; preds = %1606
store i32 0, i32* %141
br label %1618
1618: ; preds = %1626, %1617
%1619 = load i32, i32* %141
%1620 = icmp slt i32 %1619, 992
br i1 %1620, label %1621, label %1629
1621: ; preds = %1618
%1622 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 2
%1623 = load i32, i32* %141
%1624 = sext i32 %1623 to i64
%1625 = getelementptr inbounds [992 x double], [992 x double]* %1622, i64 0, i64 %1624
store double 0.000000e+00, double* %1625
br label %1626
1626: ; preds = %1621
%1627 = load i32, i32* %141
%1628 = add nsw i32 %1627, 1
store i32 %1628, i32* %141
br label %1618
1629: ; preds = %1618
store i32 0, i32* %142
store i32 0, i32* %144
br label %1630
1630: ; preds = %1725, %1629
%1631 = load i32, i32* %144
%1632 = icmp slt i32 %1631, 1
br i1 %1632, label %1633, label %1636
1633: ; preds = %1630
%1634 = load i32, i32* %142
%1635 = icmp eq i32 %1634, 0
br label %1636
1636: ; preds = %1633, %1630
%1637 = phi i1 [ false, %1630 ], [ %1635, %1633 ]
br i1 %1637, label %1638, label %1728
1638: ; preds = %1636
store i32 0, i32* %145
br label %1639
1639: ; preds = %1661, %1638
%1640 = load i32, i32* %145
%1641 = icmp slt i32 %1640, 128
br i1 %1641, label %1642, label %1664
1642: ; preds = %1639
%1643 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 2
%1644 = load i32, i32* %145
%1645 = sext i32 %1644 to i64
%1646 = getelementptr inbounds [992 x double], [992 x double]* %1643, i64 0, i64 %1645
store double 0.000000e+00, double* %1646
%1647 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 2
%1648 = load i32, i32* %145
%1649 = sext i32 %1648 to i64
%1650 = getelementptr inbounds [992 x double], [992 x double]* %1647, i64 0, i64 %1649
%1651 = load double, double* %1650
%1652 = fadd double 9.900000e+01, %1651
%1653 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1654 = load i32, i32* %145
%1655 = sext i32 %1654 to i64
%1656 = getelementptr inbounds [992 x double], [992 x double]* %1653, i64 0, i64 %1655
store double %1652, double* %1656
%1657 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 2
%1658 = load i32, i32* %145
%1659 = sext i32 %1658 to i64
%1660 = getelementptr inbounds [992 x double], [992 x double]* %1657, i64 0, i64 %1659
store double 1.000000e+00, double* %1660
br label %1661
1661: ; preds = %1642
%1662 = load i32, i32* %145
%1663 = add nsw i32 %1662, 1
store i32 %1663, i32* %145
br label %1639
1664: ; preds = %1639
%1665 = call i32 (...) @omp_get_thread_num()
store i32 %1665, i32* %146
%1666 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1667 = load i32, i32* %146
%1668 = sext i32 %1667 to i64
%1669 = getelementptr inbounds [992 x double], [992 x double]* %1666, i64 0, i64 %1668
%1670 = load double, double* %1669
%1671 = fadd double %1670, 1.000000e+00
store double %1671, double* %1669
%1672 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 2
%1673 = load i32, i32* %146
%1674 = sext i32 %1673 to i64
%1675 = getelementptr inbounds [992 x double], [992 x double]* %1672, i64 0, i64 %1674
%1676 = load double, double* %1675
%1677 = fadd double %1676, 2.000000e+00
store double %1677, double* %1675
store i32 0, i32* %147
br label %1678
1678: ; preds = %1693, %1664
%1679 = load i32, i32* %147
%1680 = icmp slt i32 %1679, 128
br i1 %1680, label %1681, label %1696
1681: ; preds = %1678
%1682 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 2
%1683 = load i32, i32* %147
%1684 = sext i32 %1683 to i64
%1685 = getelementptr inbounds [992 x double], [992 x double]* %1682, i64 0, i64 %1684
%1686 = load double, double* %1685
%1687 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1688 = load i32, i32* %147
%1689 = sext i32 %1688 to i64
%1690 = getelementptr inbounds [992 x double], [992 x double]* %1687, i64 0, i64 %1689
%1691 = load double, double* %1690
%1692 = fadd double %1691, %1686
store double %1692, double* %1690
br label %1693
1693: ; preds = %1681
%1694 = load i32, i32* %147
%1695 = add nsw i32 %1694, 1
store i32 %1695, i32* %147
br label %1678
1696: ; preds = %1678
store i32 0, i32* %149
store i32 0, i32* %148
br label %1697
1697: ; preds = %1721, %1696
%1698 = load i32, i32* %148
%1699 = icmp slt i32 %1698, 128
br i1 %1699, label %1700, label %1724
1700: ; preds = %1697
%1701 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1702 = load i32, i32* %148
%1703 = sext i32 %1702 to i64
%1704 = getelementptr inbounds [992 x double], [992 x double]* %1701, i64 0, i64 %1703
%1705 = load double, double* %1704
%1706 = fcmp une double %1705, 1.030000e+02
br i1 %1706, label %1707, label %1720
1707: ; preds = %1700
%1708 = load i32, i32* %148
%1709 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1710 = load i32, i32* %148
%1711 = sext i32 %1710 to i64
%1712 = getelementptr inbounds [992 x double], [992 x double]* %1709, i64 0, i64 %1711
%1713 = load double, double* %1712
%1714 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %1708, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0), i32 103, double %1713)
store i32 1, i32* %142
%1715 = load i32, i32* %149
%1716 = add nsw i32 %1715, 1
store i32 %1716, i32* %149
%1717 = icmp sgt i32 %1715, 10
br i1 %1717, label %1718, label %1719
1718: ; preds = %1707
br label %1724
1719: ; preds = %1707
br label %1720
1720: ; preds = %1719, %1700
br label %1721
1721: ; preds = %1720
%1722 = load i32, i32* %148
%1723 = add nsw i32 %1722, 1
store i32 %1723, i32* %148
br label %1697
1724: ; preds = %1718, %1697
br label %1725
1725: ; preds = %1724
%1726 = load i32, i32* %144
%1727 = add nsw i32 %1726, 1
store i32 %1727, i32* %144
br label %1630
1728: ; preds = %1636
%1729 = load i32, i32* %142
%1730 = icmp ne i32 %1729, 0
br i1 %1730, label %1731, label %1733
1731: ; preds = %1728
%1732 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %1735
1733: ; preds = %1728
%1734 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %1735
1735: ; preds = %1733, %1731
store i32 0, i32* %150
br label %1736
1736: ; preds = %1744, %1735
%1737 = load i32, i32* %150
%1738 = icmp slt i32 %1737, 992
br i1 %1738, label %1739, label %1747
1739: ; preds = %1736
%1740 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1741 = load i32, i32* %150
%1742 = sext i32 %1741 to i64
%1743 = getelementptr inbounds [992 x double], [992 x double]* %1740, i64 0, i64 %1742
store double 0.000000e+00, double* %1743
br label %1744
1744: ; preds = %1739
%1745 = load i32, i32* %150
%1746 = add nsw i32 %1745, 1
store i32 %1746, i32* %150
br label %1736
1747: ; preds = %1736
store i32 0, i32* %151
br label %1748
1748: ; preds = %1756, %1747
%1749 = load i32, i32* %151
%1750 = icmp slt i32 %1749, 992
br i1 %1750, label %1751, label %1759
1751: ; preds = %1748
%1752 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 2
%1753 = load i32, i32* %151
%1754 = sext i32 %1753 to i64
%1755 = getelementptr inbounds [992 x double], [992 x double]* %1752, i64 0, i64 %1754
store double 0.000000e+00, double* %1755
br label %1756
1756: ; preds = %1751
%1757 = load i32, i32* %151
%1758 = add nsw i32 %1757, 1
store i32 %1758, i32* %151
br label %1748
1759: ; preds = %1748
store i32 0, i32* %152
store i32 0, i32* %154
br label %1760
1760: ; preds = %1853, %1759
%1761 = load i32, i32* %154
%1762 = icmp slt i32 %1761, 1
br i1 %1762, label %1763, label %1766
1763: ; preds = %1760
%1764 = load i32, i32* %152
%1765 = icmp eq i32 %1764, 0
br label %1766
1766: ; preds = %1763, %1760
%1767 = phi i1 [ false, %1760 ], [ %1765, %1763 ]
br i1 %1767, label %1768, label %1856
1768: ; preds = %1766
store i32 0, i32* %155
br label %1769
1769: ; preds = %1791, %1768
%1770 = load i32, i32* %155
%1771 = icmp slt i32 %1770, 128
br i1 %1771, label %1772, label %1794
1772: ; preds = %1769
%1773 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 2
%1774 = load i32, i32* %155
%1775 = sext i32 %1774 to i64
%1776 = getelementptr inbounds [992 x double], [992 x double]* %1773, i64 0, i64 %1775
store double 0.000000e+00, double* %1776
%1777 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 2
%1778 = load i32, i32* %155
%1779 = sext i32 %1778 to i64
%1780 = getelementptr inbounds [992 x double], [992 x double]* %1777, i64 0, i64 %1779
%1781 = load double, double* %1780
%1782 = fadd double 9.900000e+01, %1781
%1783 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1784 = load i32, i32* %155
%1785 = sext i32 %1784 to i64
%1786 = getelementptr inbounds [992 x double], [992 x double]* %1783, i64 0, i64 %1785
store double %1782, double* %1786
%1787 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 2
%1788 = load i32, i32* %155
%1789 = sext i32 %1788 to i64
%1790 = getelementptr inbounds [992 x double], [992 x double]* %1787, i64 0, i64 %1789
store double 1.000000e+00, double* %1790
br label %1791
1791: ; preds = %1772
%1792 = load i32, i32* %155
%1793 = add nsw i32 %1792, 1
store i32 %1793, i32* %155
br label %1769
1794: ; preds = %1769
%1795 = call i32 (...) @omp_get_thread_num()
store i32 %1795, i32* %156
%1796 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1797 = load i32, i32* %156
%1798 = sext i32 %1797 to i64
%1799 = getelementptr inbounds [992 x double], [992 x double]* %1796, i64 0, i64 %1798
%1800 = load double, double* %1799
%1801 = fadd double %1800, 1.000000e+00
store double %1801, double* %1799
%1802 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 2
%1803 = load i32, i32* %156
%1804 = sext i32 %1803 to i64
%1805 = getelementptr inbounds [992 x double], [992 x double]* %1802, i64 0, i64 %1804
store double 2.000000e+00, double* %1805
store i32 0, i32* %157
br label %1806
1806: ; preds = %1821, %1794
%1807 = load i32, i32* %157
%1808 = icmp slt i32 %1807, 128
br i1 %1808, label %1809, label %1824
1809: ; preds = %1806
%1810 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 2
%1811 = load i32, i32* %157
%1812 = sext i32 %1811 to i64
%1813 = getelementptr inbounds [992 x double], [992 x double]* %1810, i64 0, i64 %1812
%1814 = load double, double* %1813
%1815 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1816 = load i32, i32* %157
%1817 = sext i32 %1816 to i64
%1818 = getelementptr inbounds [992 x double], [992 x double]* %1815, i64 0, i64 %1817
%1819 = load double, double* %1818
%1820 = fadd double %1819, %1814
store double %1820, double* %1818
br label %1821
1821: ; preds = %1809
%1822 = load i32, i32* %157
%1823 = add nsw i32 %1822, 1
store i32 %1823, i32* %157
br label %1806
1824: ; preds = %1806
store i32 0, i32* %159
store i32 0, i32* %158
br label %1825
1825: ; preds = %1849, %1824
%1826 = load i32, i32* %158
%1827 = icmp slt i32 %1826, 1
br i1 %1827, label %1828, label %1852
1828: ; preds = %1825
%1829 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1830 = load i32, i32* %158
%1831 = sext i32 %1830 to i64
%1832 = getelementptr inbounds [992 x double], [992 x double]* %1829, i64 0, i64 %1831
%1833 = load double, double* %1832
%1834 = fcmp une double %1833, 1.000000e+02
br i1 %1834, label %1835, label %1848
1835: ; preds = %1828
%1836 = load i32, i32* %158
%1837 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1838 = load i32, i32* %158
%1839 = sext i32 %1838 to i64
%1840 = getelementptr inbounds [992 x double], [992 x double]* %1837, i64 0, i64 %1839
%1841 = load double, double* %1840
%1842 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %1836, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0), i32 100, double %1841)
store i32 1, i32* %152
%1843 = load i32, i32* %159
%1844 = add nsw i32 %1843, 1
store i32 %1844, i32* %159
%1845 = icmp sgt i32 %1843, 10
br i1 %1845, label %1846, label %1847
1846: ; preds = %1835
br label %1852
1847: ; preds = %1835
br label %1848
1848: ; preds = %1847, %1828
br label %1849
1849: ; preds = %1848
%1850 = load i32, i32* %158
%1851 = add nsw i32 %1850, 1
store i32 %1851, i32* %158
br label %1825
1852: ; preds = %1846, %1825
br label %1853
1853: ; preds = %1852
%1854 = load i32, i32* %154
%1855 = add nsw i32 %1854, 1
store i32 %1855, i32* %154
br label %1760
1856: ; preds = %1766
%1857 = load i32, i32* %152
%1858 = icmp ne i32 %1857, 0
br i1 %1858, label %1859, label %1861
1859: ; preds = %1856
%1860 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %1863
1861: ; preds = %1856
%1862 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %1863
1863: ; preds = %1861, %1859
store i32 0, i32* %160
br label %1864
1864: ; preds = %1872, %1863
%1865 = load i32, i32* %160
%1866 = icmp slt i32 %1865, 992
br i1 %1866, label %1867, label %1875
1867: ; preds = %1864
%1868 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1869 = load i32, i32* %160
%1870 = sext i32 %1869 to i64
%1871 = getelementptr inbounds [992 x double], [992 x double]* %1868, i64 0, i64 %1870
store double 0.000000e+00, double* %1871
br label %1872
1872: ; preds = %1867
%1873 = load i32, i32* %160
%1874 = add nsw i32 %1873, 1
store i32 %1874, i32* %160
br label %1864
1875: ; preds = %1864
store i32 0, i32* %161
br label %1876
1876: ; preds = %1884, %1875
%1877 = load i32, i32* %161
%1878 = icmp slt i32 %1877, 992
br i1 %1878, label %1879, label %1887
1879: ; preds = %1876
%1880 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 2
%1881 = load i32, i32* %161
%1882 = sext i32 %1881 to i64
%1883 = getelementptr inbounds [992 x double], [992 x double]* %1880, i64 0, i64 %1882
store double 0.000000e+00, double* %1883
br label %1884
1884: ; preds = %1879
%1885 = load i32, i32* %161
%1886 = add nsw i32 %1885, 1
store i32 %1886, i32* %161
br label %1876
1887: ; preds = %1876
store i32 0, i32* %162
store i32 0, i32* %164
br label %1888
1888: ; preds = %1958, %1887
%1889 = load i32, i32* %164
%1890 = icmp slt i32 %1889, 1
br i1 %1890, label %1891, label %1894
1891: ; preds = %1888
%1892 = load i32, i32* %162
%1893 = icmp eq i32 %1892, 0
br label %1894
1894: ; preds = %1891, %1888
%1895 = phi i1 [ false, %1888 ], [ %1893, %1891 ]
br i1 %1895, label %1896, label %1961
1896: ; preds = %1894
%1897 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 2
%1898 = getelementptr inbounds [992 x double], [992 x double]* %1897, i64 0, i64 0
store double 0.000000e+00, double* %1898
%1899 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 2
%1900 = getelementptr inbounds [992 x double], [992 x double]* %1899, i64 0, i64 0
%1901 = load double, double* %1900
%1902 = fadd double 9.900000e+01, %1901
%1903 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1904 = getelementptr inbounds [992 x double], [992 x double]* %1903, i64 0, i64 0
store double %1902, double* %1904
%1905 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 2
%1906 = getelementptr inbounds [992 x double], [992 x double]* %1905, i64 0, i64 0
store double 2.000000e+00, double* %1906
%1907 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 2
%1908 = getelementptr inbounds [992 x double], [992 x double]* %1907, i64 0, i64 0
%1909 = load double, double* %1908
%1910 = fadd double %1909, 8.000000e+00
store double %1910, double* %1908
%1911 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 2
%1912 = getelementptr inbounds [992 x double], [992 x double]* %1911, i64 0, i64 0
%1913 = load double, double* %1912
%1914 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1915 = getelementptr inbounds [992 x double], [992 x double]* %1914, i64 0, i64 0
%1916 = load double, double* %1915
%1917 = fadd double %1916, %1913
store double %1917, double* %1915
%1918 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1919 = getelementptr inbounds [992 x double], [992 x double]* %1918, i64 0, i64 0
%1920 = load double, double* %1919
store double %1920, double* %165
%1921 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 2
%1922 = getelementptr inbounds [992 x double], [992 x double]* %1921, i64 0, i64 0
%1923 = load double, double* %1922
%1924 = load double, double* %165
%1925 = fadd double %1923, %1924
%1926 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1927 = getelementptr inbounds [992 x double], [992 x double]* %1926, i64 0, i64 0
%1928 = load double, double* %1927
%1929 = fadd double %1928, %1925
store double %1929, double* %1927
store i32 0, i32* %167
store i32 0, i32* %166
br label %1930
1930: ; preds = %1954, %1896
%1931 = load i32, i32* %166
%1932 = icmp slt i32 %1931, 1
br i1 %1932, label %1933, label %1957
1933: ; preds = %1930
%1934 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1935 = load i32, i32* %166
%1936 = sext i32 %1935 to i64
%1937 = getelementptr inbounds [992 x double], [992 x double]* %1934, i64 0, i64 %1936
%1938 = load double, double* %1937
%1939 = fcmp une double %1938, 2.100000e+02
br i1 %1939, label %1940, label %1953
1940: ; preds = %1933
%1941 = load i32, i32* %166
%1942 = getelementptr inbounds %struct.CONTEXT, %struct.CONTEXT* %131, i32 0, i32 1
%1943 = load i32, i32* %166
%1944 = sext i32 %1943 to i64
%1945 = getelementptr inbounds [992 x double], [992 x double]* %1942, i64 0, i64 %1944
%1946 = load double, double* %1945
%1947 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %1941, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0), i32 210, double %1946)
store i32 1, i32* %162
%1948 = load i32, i32* %167
%1949 = add nsw i32 %1948, 1
store i32 %1949, i32* %167
%1950 = icmp sgt i32 %1948, 10
br i1 %1950, label %1951, label %1952
1951: ; preds = %1940
br label %1957
1952: ; preds = %1940
br label %1953
1953: ; preds = %1952, %1933
br label %1954
1954: ; preds = %1953
%1955 = load i32, i32* %166
%1956 = add nsw i32 %1955, 1
store i32 %1956, i32* %166
br label %1930
1957: ; preds = %1951, %1930
br label %1958
1958: ; preds = %1957
%1959 = load i32, i32* %164
%1960 = add nsw i32 %1959, 1
store i32 %1960, i32* %164
br label %1888
1961: ; preds = %1894
%1962 = load i32, i32* %162
%1963 = icmp ne i32 %1962, 0
br i1 %1963, label %1964, label %1966
1964: ; preds = %1961
%1965 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %1968
1966: ; preds = %1961
%1967 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %1968
1968: ; preds = %1966, %1964
store i32 0, i32* %168
br label %1969
1969: ; preds = %1976, %1968
%1970 = load i32, i32* %168
%1971 = icmp slt i32 %1970, 992
br i1 %1971, label %1972, label %1979
1972: ; preds = %1969
%1973 = load i32, i32* %168
%1974 = sext i32 %1973 to i64
%1975 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %1974
store double 0.000000e+00, double* %1975
br label %1976
1976: ; preds = %1972
%1977 = load i32, i32* %168
%1978 = add nsw i32 %1977, 1
store i32 %1978, i32* %168
br label %1969
1979: ; preds = %1969
store i32 0, i32* %169
br label %1980
1980: ; preds = %1987, %1979
%1981 = load i32, i32* %169
%1982 = icmp slt i32 %1981, 992
br i1 %1982, label %1983, label %1990
1983: ; preds = %1980
%1984 = load i32, i32* %169
%1985 = sext i32 %1984 to i64
%1986 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 %1985
store double 0.000000e+00, double* %1986
br label %1987
1987: ; preds = %1983
%1988 = load i32, i32* %169
%1989 = add nsw i32 %1988, 1
store i32 %1989, i32* %169
br label %1980
1990: ; preds = %1980
store i32 0, i32* %170
store i32 0, i32* %172
br label %1991
1991: ; preds = %2057, %1990
%1992 = load i32, i32* %172
%1993 = icmp slt i32 %1992, 1
br i1 %1993, label %1994, label %1997
1994: ; preds = %1991
%1995 = load i32, i32* %170
%1996 = icmp eq i32 %1995, 0
br label %1997
1997: ; preds = %1994, %1991
%1998 = phi i1 [ false, %1991 ], [ %1996, %1994 ]
br i1 %1998, label %1999, label %2060
1999: ; preds = %1997
%2000 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 0
store double 0.000000e+00, double* %2000
%2001 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 0
%2002 = load double, double* %2001
%2003 = fadd double 9.900000e+01, %2002
%2004 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 0
store double %2003, double* %2004
%2005 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 0
store double 2.000000e+00, double* %2005
%2006 = getelementptr inbounds %struct.CITY, %struct.CITY* %173, i32 0, i32 1
store i32 21, i32* %2006
%2007 = getelementptr inbounds %struct.CITY, %struct.CITY* %173, i32 0, i32 1
%2008 = load i32, i32* %2007
%2009 = add nsw i32 %2008, 9
store i32 %2009, i32* %2007
%2010 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 0
%2011 = load double, double* %2010
%2012 = fadd double %2011, 8.000000e+00
store double %2012, double* %2010
%2013 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 0
%2014 = load double, double* %2013
%2015 = getelementptr inbounds %struct.CITY, %struct.CITY* %173, i32 0, i32 1
%2016 = load i32, i32* %2015
%2017 = sitofp i32 %2016 to double
%2018 = fadd double %2014, %2017
%2019 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 0
%2020 = load double, double* %2019
%2021 = fadd double %2020, %2018
store double %2021, double* %2019
%2022 = getelementptr inbounds [992 x double], [992 x double]* %3, i64 0, i64 0
%2023 = load double, double* %2022
%2024 = getelementptr inbounds %struct.CITY, %struct.CITY* %173, i32 0, i32 1
%2025 = load i32, i32* %2024
%2026 = sitofp i32 %2025 to double
%2027 = fadd double %2023, %2026
%2028 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 0
%2029 = load double, double* %2028
%2030 = fadd double %2029, %2027
store double %2030, double* %2028
store i32 0, i32* %175
store i32 0, i32* %174
br label %2031
2031: ; preds = %2053, %1999
%2032 = load i32, i32* %174
%2033 = icmp slt i32 %2032, 1
br i1 %2033, label %2034, label %2056
2034: ; preds = %2031
%2035 = load i32, i32* %174
%2036 = sext i32 %2035 to i64
%2037 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %2036
%2038 = load double, double* %2037
%2039 = fcmp une double %2038, 1.710000e+02
br i1 %2039, label %2040, label %2052
2040: ; preds = %2034
%2041 = load i32, i32* %174
%2042 = load i32, i32* %174
%2043 = sext i32 %2042 to i64
%2044 = getelementptr inbounds [992 x double], [992 x double]* %2, i64 0, i64 %2043
%2045 = load double, double* %2044
%2046 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %2041, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 171, double %2045)
store i32 1, i32* %170
%2047 = load i32, i32* %175
%2048 = add nsw i32 %2047, 1
store i32 %2048, i32* %175
%2049 = icmp sgt i32 %2047, 10
br i1 %2049, label %2050, label %2051
2050: ; preds = %2040
br label %2056
2051: ; preds = %2040
br label %2052
2052: ; preds = %2051, %2034
br label %2053
2053: ; preds = %2052
%2054 = load i32, i32* %174
%2055 = add nsw i32 %2054, 1
store i32 %2055, i32* %174
br label %2031
2056: ; preds = %2050, %2031
br label %2057
2057: ; preds = %2056
%2058 = load i32, i32* %172
%2059 = add nsw i32 %2058, 1
store i32 %2059, i32* %172
br label %1991
2060: ; preds = %1997
%2061 = load i32, i32* %170
%2062 = icmp ne i32 %2061, 0
br i1 %2062, label %2063, label %2065
2063: ; preds = %2060
%2064 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i64 0, i64 0))
br label %2067
2065: ; preds = %2060
%2066 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
br label %2067
2067: ; preds = %2065, %2063
ret i32 0
}

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