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

/* Forward declarations */

/* Type definitions */
typedef int omp_sched_t;

/* Variables and functions */
int /*<<< orphan*/ check_offloading();
double omp_get_active_level();
double omp_get_ancestor_thread_num(int);
double omp_get_cancellation();
double omp_get_default_device();
double omp_get_dynamic();
double omp_get_level();
double omp_get_max_active_levels();
double omp_get_max_threads();
double omp_get_nested();
double omp_get_num_devices();
double omp_get_num_procs();
double omp_get_num_teams();
int omp_get_num_threads();
double omp_get_proc_bind();
int /*<<< orphan*/ omp_get_schedule(int *, int *);
scalar_t__ omp_get_team_num();
double omp_get_team_size(int);
double omp_get_thread_limit();
int omp_get_thread_num();
double omp_get_wtick();
double omp_get_wtime();
double omp_in_final();
double omp_in_parallel();
double omp_is_initial_device();
int omp_sched_dynamic;
int omp_sched_guided;
int omp_sched_static;
int /*<<< orphan*/ omp_set_default_device(int /*<<< orphan*/);
int /*<<< orphan*/ omp_set_dynamic(int);
int /*<<< orphan*/ omp_set_max_active_levels(int);
int /*<<< orphan*/ omp_set_nested(int /*<<< orphan*/);
int /*<<< orphan*/ omp_set_schedule(int, int);
int /*<<< orphan*/ printf(char *, ...);
int main(void) {
  check_offloading();
  int fail;
  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)
      {{A[0] = omp_get_num_threads();
      {
        if (omp_get_thread_num() == 3) {
          A[0] += omp_get_num_threads();
        }
      }
    }
  }
  {
    int i;
    int errorNum = 0;
    for (i = 0; i < 1; i++) {
      if (A[i] != 129) {
        printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 129,
               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
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {
      {
        A[0] = omp_get_max_threads();
        {
          if (omp_get_thread_num() == 0) {
            A[0] += omp_get_max_threads();
            A[1] = omp_get_num_threads();
          }
        }
      }
    }
    if (!omp_is_initial_device()) {
      int i;
      int errorNum = 0;
      for (i = 0; i < 1; i++) {
        if (A[i] != A[1] + 1) {
          printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]",
                 A[1] + 1, A[i]);
          fail = 1;
          if (errorNum++ > 10)
            break;
        }
      }
    }
  }
  if (fail) {
    printf("Failed\n");
  } else {
    printf("Succeeded\n");
  }
};
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};

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

#pragma omp parallel num_threads(19) if (A[0] == 1)

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

#pragma omp parallel num_threads(19)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{A[0] = omp_get_dynamic();
    omp_set_dynamic(1);
    A[0] += omp_get_dynamic();
    {
      if (omp_get_thread_num() == 18) {
        A[0] += omp_get_dynamic();
        omp_set_dynamic(0);
      }
    }
    A[0] += omp_get_dynamic();
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[i] != 3) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 3,
             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(19)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{A[0] = omp_get_cancellation();
    {
      if (omp_get_thread_num() == 18) {
        A[0] += omp_get_cancellation();
      }
    }
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; 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(19)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{A[0] = omp_get_nested();
    omp_set_nested(0);
    A[0] += omp_get_nested();
    {
      if (omp_get_thread_num() == 18) {
        A[0] += omp_get_nested();
        omp_set_nested(0);
      }
    }
    A[0] += omp_get_nested();
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[i] != 0) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 0,
             A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};
int result = 2 * (omp_sched_static + omp_sched_dynamic + omp_sched_guided) +
             omp_sched_static;
result += 2 * (1110) + 10;

#pragma omp parallel num_threads(19)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{omp_sched_t t;
    int chunk_size;
    t = omp_sched_static;
    chunk_size = 10;
    omp_set_schedule(t, chunk_size);
    t = 0;
    chunk_size = 0;
    omp_get_schedule(&t, &chunk_size);
    A[0] = t + chunk_size;
    t = omp_sched_dynamic;
    chunk_size = 100;
    omp_set_schedule(t, chunk_size);
    t = 0;
    chunk_size = 0;
    omp_get_schedule(&t, &chunk_size);
    A[0] += t + chunk_size;
    t = omp_sched_guided;
    chunk_size = 1000;
    omp_set_schedule(t, chunk_size);
    t = 0;
    chunk_size = 0;
    omp_get_schedule(&t, &chunk_size);
    A[0] += t + chunk_size;
    t = omp_sched_static;
    chunk_size = 10;
    omp_set_schedule(t, chunk_size);
    {
      if (omp_get_thread_num() == 18) {
        omp_sched_t t;
        int chunk_size;
        t = omp_sched_static;
        chunk_size = 10;
        omp_set_schedule(t, chunk_size);
        t = 0;
        chunk_size = 0;
        omp_get_schedule(&t, &chunk_size);
        A[0] += t + chunk_size;
        t = omp_sched_dynamic;
        chunk_size = 100;
        omp_set_schedule(t, chunk_size);
        t = 0;
        chunk_size = 0;
        omp_get_schedule(&t, &chunk_size);
        A[0] += t + chunk_size;
        t = omp_sched_guided;
        chunk_size = 1000;
        omp_set_schedule(t, chunk_size);
        t = 0;
        chunk_size = 0;
        omp_get_schedule(&t, &chunk_size);
        A[0] += t + chunk_size;
      }
    }
    t = 0;
    chunk_size = 0;
    omp_get_schedule(&t, &chunk_size);
    A[0] += t + chunk_size;
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[i] != result) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", result,
             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
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{A[0] = omp_get_thread_limit();
    {
      if (omp_get_thread_num() == 0) {
        A[0] += omp_get_thread_limit();
        A[1] = 2 * omp_get_num_threads();
      }
    }
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[i] != A[1]) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", A[1],
             A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};

#pragma omp parallel num_threads(19)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{omp_set_max_active_levels(1);
    A[0] = omp_get_max_active_levels();
    {
      if (omp_get_thread_num() == 18) {
        A[0] += omp_get_max_active_levels();
      }
    }
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[i] != 2) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 2,
             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(19)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{A[0] = omp_get_level();
    {
      if (omp_get_thread_num() == 18) {
        A[0] += omp_get_level();
      }
    }
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[i] != 1) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 1,
             A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};

#pragma omp parallel num_threads(19)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{A[0] = omp_get_ancestor_thread_num(0);
    {
      if (omp_get_thread_num() == 18) {
        A[0] += omp_get_ancestor_thread_num(0) + omp_get_ancestor_thread_num(1);
      }
    }
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[i] != 18) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 18,
             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(19)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {
      {
        A[0] = omp_get_team_size(0) + omp_get_team_size(1);
        {
          if (omp_get_thread_num() == 18) {
            A[0] += omp_get_team_size(0) + omp_get_team_size(1);
          }
        }
      }
    }
    if (!omp_is_initial_device()) {
      int i;
      int errorNum = 0;
      for (i = 0; i < 1; i++) {
        if (A[i] != 22) {
          printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 22,
                 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(19)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{A[0] = omp_get_active_level();
    {
      if (omp_get_thread_num() == 18) {
        A[0] += omp_get_active_level();
      }
    }
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[i] != 1) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 1,
             A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};

#pragma omp parallel num_threads(19)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{A[0] = omp_in_final();
    {
      if (omp_get_thread_num() == 18) {
        A[0] += omp_in_final();
      }
    }
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[i] != omp_is_initial_device() ? 0 : 2) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]",
             omp_is_initial_device() ? 0 : 2, 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(19)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{A[0] = omp_get_proc_bind();
    {
      if (omp_get_thread_num() == 18) {
        A[0] += omp_get_proc_bind();
      }
    }
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[i] != omp_is_initial_device() ? 0 : 2) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]",
             omp_is_initial_device() ? 0 : 2, 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(19)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{omp_set_default_device(0);
    A[0] = omp_get_default_device();
    {
      if (omp_get_thread_num() == 18) {
        A[0] += omp_get_default_device();
      }
    }
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; 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(19)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{A[0] = omp_get_num_devices();
    {
      if (omp_get_thread_num() == 18) {
        A[1] = omp_get_num_devices();
      }
    }
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[i] != A[i] - A[1]) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]",
             A[i] - A[1], A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};

#pragma omp parallel num_threads(19)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{A[0] = omp_get_num_teams();
    A[0] += omp_get_team_num();
    {
      if (omp_get_thread_num() == 18) {
        A[0] += omp_get_num_teams();
        A[0] += omp_get_team_num();
      }
    }
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[i] != 2) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", 2,
             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;
  }
};
A[1] = omp_is_initial_device();

#pragma omp parallel num_threads(19)
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{A[0] = omp_is_initial_device();
    {
      if (omp_get_thread_num() == 18) {
        A[0] += omp_is_initial_device();
      }
    }
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; i++) {
    if (A[i] != omp_is_initial_device() ? A[1] - A[1] : 2.0) {
      printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]",
             omp_is_initial_device() ? A[1] - A[1] : 2.0, A[i]);
      fail = 1;
      if (errorNum++ > 10)
        break;
    }
  }
}
}
if (fail) {
  printf("Failed\n");
} else {
  printf("Succeeded\n");
}
}
;
return 0;
{
  int i;
  for (i = 0; i < (992); i++) {
    A[i] = 0;
  }
};
{
  int fail = 0;
  int trial;
  for (int trial = 0; trial < (1) && fail == 0; trial++) {
#pragma omp target teams num_teams(1) thread_limit(1024)
    {{double precision;
    precision = omp_get_wtick();
    double start;
    double end;
    start = omp_get_wtime();
    end = omp_get_wtime();
  }
}
{
  int i;
  int errorNum = 0;
  for (i = 0; i < 1; 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");
}
}
;
return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x9d80,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x0,%al
call   1170 <check_offloading@plt>
movl   $0x0,-0x9b14(%rbp)
cmpl   $0x3e0,-0x9b14(%rbp)
jge    1363 <main+0x93>
movslq -0x9b14(%rbp),%rax
movsd  0x2cf6(%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    12f3 <main+0x23>
movl   $0x0,-0x9b18(%rbp)
cmpl   $0x3e0,-0x9b18(%rbp)
jge    13a4 <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    136d <main+0x9d>
movl   $0x0,-0x9b1c(%rbp)
movl   $0x0,-0x9b24(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9b24(%rbp)
mov    %al,-0x9d15(%rbp)
jge    13dd <main+0x10d>
cmpl   $0x0,-0x9b1c(%rbp)
sete   %al
mov    %al,-0x9d15(%rbp)
mov    -0x9d15(%rbp),%al
test   $0x1,%al
jne    13f0 <main+0x120>
jmp    150c <main+0x23c>
mov    $0x0,%al
call   10d0 <omp_get_num_threads@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   1070 <omp_get_thread_num@plt>
cmp    $0x3,%eax
jne    142e <main+0x15e>
mov    $0x0,%al
call   10d0 <omp_get_num_threads@plt>
cvtsi2sd %eax,%xmm0
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9b2c(%rbp)
movl   $0x0,-0x9b28(%rbp)
cmpl   $0x1,-0x9b28(%rbp)
jge    14f3 <main+0x223>
movslq -0x9b28(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x2bc1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    147c <main+0x1ac>
jp     147c <main+0x1ac>
jmp    14da <main+0x20a>
mov    -0x9b28(%rbp),%esi
movslq -0x9b28(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x2b97(%rip),%rdi
lea    0x2bbc(%rip),%rdx
mov    $0x81,%ecx
mov    $0x1,%al
call   10b0 <printf@plt>
movl   $0x1,-0x9b1c(%rbp)
mov    -0x9b2c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9b2c(%rbp)
cmp    $0xa,%eax
jle    14d5 <main+0x205>
jmp    14f3 <main+0x223>
jmp    14da <main+0x20a>
jmp    14df <main+0x20f>
mov    -0x9b28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b28(%rbp)
jmp    1442 <main+0x172>
jmp    14f8 <main+0x228>
mov    -0x9b24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b24(%rbp)
jmp    13b8 <main+0xe8>
cmpl   $0x0,-0x9b1c(%rbp)
je     152c <main+0x25c>
lea    0x2b41(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
jmp    153a <main+0x26a>
lea    0x2b36(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
movl   $0x0,-0x9b30(%rbp)
cmpl   $0x3e0,-0x9b30(%rbp)
jge    157b <main+0x2ab>
movslq -0x9b30(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b30(%rbp)
jmp    1544 <main+0x274>
movl   $0x0,-0x9b34(%rbp)
movl   $0x0,-0x9b3c(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9b3c(%rbp)
mov    %al,-0x9d16(%rbp)
jge    15b4 <main+0x2e4>
cmpl   $0x0,-0x9b34(%rbp)
sete   %al
mov    %al,-0x9d16(%rbp)
mov    -0x9d16(%rbp),%al
test   $0x1,%al
jne    15c7 <main+0x2f7>
jmp    1720 <main+0x450>
mov    $0x0,%al
call   1180 <omp_get_max_threads@plt>
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   1070 <omp_get_thread_num@plt>
cmp    $0x0,%eax
jne    1610 <main+0x340>
mov    $0x0,%al
call   1180 <omp_get_max_threads@plt>
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   10d0 <omp_get_num_threads@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x1f08(%rbp)
ff
mov    $0x0,%al
call   11f0 <omp_is_initial_device@plt>
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1707 <main+0x437>
jp     1707 <main+0x437>
movl   $0x0,-0x9b44(%rbp)
movl   $0x0,-0x9b40(%rbp)
cmpl   $0x1,-0x9b40(%rbp)
jge    1702 <main+0x432>
movslq -0x9b40(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x29a5(%rip),%xmm1
addsd  -0x1f08(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
jne    1680 <main+0x3b0>
jp     1680 <main+0x3b0>
jmp    16e9 <main+0x419>
mov    -0x9b40(%rbp),%esi
movsd  0x297a(%rip),%xmm0
addsd  -0x1f08(%rbp),%xmm0
ff
movslq -0x9b40(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x2983(%rip),%rdi
lea    0x29a8(%rip),%rdx
mov    $0x2,%al
call   10b0 <printf@plt>
movl   $0x1,-0x9b34(%rbp)
mov    -0x9b44(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9b44(%rbp)
cmp    $0xa,%eax
jle    16e4 <main+0x414>
jmp    1702 <main+0x432>
jmp    16e9 <main+0x419>
jmp    16ee <main+0x41e>
mov    -0x9b40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b40(%rbp)
jmp    163e <main+0x36e>
jmp    1707 <main+0x437>
jmp    170c <main+0x43c>
mov    -0x9b3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b3c(%rbp)
jmp    158f <main+0x2bf>
cmpl   $0x0,-0x9b34(%rbp)
je     1740 <main+0x470>
lea    0x292d(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
jmp    174e <main+0x47e>
lea    0x2922(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
movl   $0x0,-0x9b48(%rbp)
cmpl   $0x3e0,-0x9b48(%rbp)
jge    178f <main+0x4bf>
movslq -0x9b48(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b48(%rbp)
jmp    1758 <main+0x488>
movl   $0x0,-0x9b4c(%rbp)
movl   $0x0,-0x9b54(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9b54(%rbp)
mov    %al,-0x9d17(%rbp)
jge    17c8 <main+0x4f8>
cmpl   $0x0,-0x9b4c(%rbp)
sete   %al
mov    %al,-0x9d17(%rbp)
mov    -0x9d17(%rbp),%al
test   $0x1,%al
jne    17db <main+0x50b>
jmp    1904 <main+0x634>
mov    $0x0,%al
call   1120 <omp_get_num_procs@plt>
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   1070 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    1827 <main+0x557>
mov    $0x0,%al
call   1120 <omp_get_num_procs@plt>
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   10d0 <omp_get_num_threads@plt>
shl    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x1f08(%rbp)
ff
movl   $0x0,-0x9b5c(%rbp)
movl   $0x0,-0x9b58(%rbp)
cmpl   $0x1,-0x9b58(%rbp)
jge    18eb <main+0x61b>
movslq -0x9b58(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
ucomisd -0x1f08(%rbp),%xmm0
ff
jne    1871 <main+0x5a1>
jp     1871 <main+0x5a1>
jmp    18d2 <main+0x602>
mov    -0x9b58(%rbp),%esi
movsd  -0x1f08(%rbp),%xmm0
ff
movslq -0x9b58(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x279a(%rip),%rdi
lea    0x27bf(%rip),%rdx
mov    $0x2,%al
call   10b0 <printf@plt>
movl   $0x1,-0x9b4c(%rbp)
mov    -0x9b5c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9b5c(%rbp)
cmp    $0xa,%eax
jle    18cd <main+0x5fd>
jmp    18eb <main+0x61b>
jmp    18d2 <main+0x602>
jmp    18d7 <main+0x607>
mov    -0x9b58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b58(%rbp)
jmp    183b <main+0x56b>
jmp    18f0 <main+0x620>
mov    -0x9b54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b54(%rbp)
jmp    17a3 <main+0x4d3>
cmpl   $0x0,-0x9b4c(%rbp)
je     1924 <main+0x654>
lea    0x2749(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
jmp    1932 <main+0x662>
lea    0x273e(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
movl   $0x0,-0x9b60(%rbp)
cmpl   $0x3e0,-0x9b60(%rbp)
jge    1973 <main+0x6a3>
movslq -0x9b60(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b60(%rbp)
jmp    193c <main+0x66c>
movl   $0x0,-0x9b64(%rbp)
movl   $0x0,-0x9b6c(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9b6c(%rbp)
mov    %al,-0x9d18(%rbp)
jge    19ac <main+0x6dc>
cmpl   $0x0,-0x9b64(%rbp)
sete   %al
mov    %al,-0x9d18(%rbp)
mov    -0x9d18(%rbp),%al
test   $0x1,%al
jne    19bf <main+0x6ef>
jmp    1aea <main+0x81a>
mov    $0x0,%al
call   1030 <omp_in_parallel@plt>
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   1030 <omp_in_parallel@plt>
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   1070 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    1a0c <main+0x73c>
mov    $0x0,%al
call   1030 <omp_in_parallel@plt>
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9b74(%rbp)
movl   $0x0,-0x9b70(%rbp)
cmpl   $0x1,-0x9b70(%rbp)
jge    1ad1 <main+0x801>
movslq -0x9b70(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x25c3(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1a5a <main+0x78a>
jp     1a5a <main+0x78a>
jmp    1ab8 <main+0x7e8>
mov    -0x9b70(%rbp),%esi
movslq -0x9b70(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x25b9(%rip),%rdi
lea    0x25de(%rip),%rdx
mov    $0x1,%ecx
mov    $0x1,%al
call   10b0 <printf@plt>
movl   $0x1,-0x9b64(%rbp)
mov    -0x9b74(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9b74(%rbp)
cmp    $0xa,%eax
jle    1ab3 <main+0x7e3>
jmp    1ad1 <main+0x801>
jmp    1ab8 <main+0x7e8>
jmp    1abd <main+0x7ed>
mov    -0x9b70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b70(%rbp)
jmp    1a20 <main+0x750>
jmp    1ad6 <main+0x806>
mov    -0x9b6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b6c(%rbp)
jmp    1987 <main+0x6b7>
cmpl   $0x0,-0x9b64(%rbp)
je     1b0a <main+0x83a>
lea    0x2563(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
jmp    1b18 <main+0x848>
lea    0x2558(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
movl   $0x0,-0x9b78(%rbp)
cmpl   $0x3e0,-0x9b78(%rbp)
jge    1b59 <main+0x889>
movslq -0x9b78(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b78(%rbp)
jmp    1b22 <main+0x852>
movl   $0x0,-0x9b7c(%rbp)
movl   $0x0,-0x9b84(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9b84(%rbp)
mov    %al,-0x9d19(%rbp)
jge    1b92 <main+0x8c2>
cmpl   $0x0,-0x9b7c(%rbp)
sete   %al
mov    %al,-0x9d19(%rbp)
mov    -0x9d19(%rbp),%al
test   $0x1,%al
jne    1ba5 <main+0x8d5>
jmp    1cf8 <main+0xa28>
mov    $0x0,%al
call   11e0 <omp_get_dynamic@plt>
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x1,%edi
call   10f0 <omp_set_dynamic@plt>
mov    $0x0,%al
call   11e0 <omp_get_dynamic@plt>
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   1070 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    1c03 <main+0x933>
mov    $0x0,%al
call   11e0 <omp_get_dynamic@plt>
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
xor    %edi,%edi
call   10f0 <omp_set_dynamic@plt>
mov    $0x0,%al
call   11e0 <omp_get_dynamic@plt>
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9b8c(%rbp)
movl   $0x0,-0x9b88(%rbp)
cmpl   $0x1,-0x9b88(%rbp)
jge    1cdf <main+0xa0f>
movslq -0x9b88(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x23cd(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1c68 <main+0x998>
jp     1c68 <main+0x998>
jmp    1cc6 <main+0x9f6>
mov    -0x9b88(%rbp),%esi
movslq -0x9b88(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x23ab(%rip),%rdi
lea    0x23d0(%rip),%rdx
mov    $0x3,%ecx
mov    $0x1,%al
call   10b0 <printf@plt>
movl   $0x1,-0x9b7c(%rbp)
mov    -0x9b8c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9b8c(%rbp)
cmp    $0xa,%eax
jle    1cc1 <main+0x9f1>
jmp    1cdf <main+0xa0f>
jmp    1cc6 <main+0x9f6>
jmp    1ccb <main+0x9fb>
mov    -0x9b88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b88(%rbp)
jmp    1c2e <main+0x95e>
jmp    1ce4 <main+0xa14>
mov    -0x9b84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b84(%rbp)
jmp    1b6d <main+0x89d>
cmpl   $0x0,-0x9b7c(%rbp)
je     1d18 <main+0xa48>
lea    0x2355(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
jmp    1d26 <main+0xa56>
lea    0x234a(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
movl   $0x0,-0x9b90(%rbp)
cmpl   $0x3e0,-0x9b90(%rbp)
jge    1d67 <main+0xa97>
movslq -0x9b90(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9b90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b90(%rbp)
jmp    1d30 <main+0xa60>
movl   $0x0,-0x9b94(%rbp)
movl   $0x0,-0x9b9c(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9b9c(%rbp)
mov    %al,-0x9d1a(%rbp)
jge    1da0 <main+0xad0>
cmpl   $0x0,-0x9b94(%rbp)
sete   %al
mov    %al,-0x9d1a(%rbp)
mov    -0x9d1a(%rbp),%al
test   $0x1,%al
jne    1db3 <main+0xae3>
jmp    1ebf <main+0xbef>
mov    $0x0,%al
call   11b0 <omp_get_cancellation@plt>
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   1070 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    1de9 <main+0xb19>
mov    $0x0,%al
call   11b0 <omp_get_cancellation@plt>
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9ba4(%rbp)
movl   $0x0,-0x9ba0(%rbp)
cmpl   $0x1,-0x9ba0(%rbp)
jge    1ea6 <main+0xbd6>
movslq -0x9ba0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1e32 <main+0xb62>
jp     1e32 <main+0xb62>
jmp    1e8d <main+0xbbd>
mov    -0x9ba0(%rbp),%esi
movslq -0x9ba0(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x21e1(%rip),%rdi
lea    0x2206(%rip),%rdx
xor    %ecx,%ecx
mov    $0x1,%al
call   10b0 <printf@plt>
movl   $0x1,-0x9b94(%rbp)
mov    -0x9ba4(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9ba4(%rbp)
cmp    $0xa,%eax
jle    1e88 <main+0xbb8>
jmp    1ea6 <main+0xbd6>
jmp    1e8d <main+0xbbd>
jmp    1e92 <main+0xbc2>
mov    -0x9ba0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ba0(%rbp)
jmp    1dfd <main+0xb2d>
jmp    1eab <main+0xbdb>
mov    -0x9b9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9b9c(%rbp)
jmp    1d7b <main+0xaab>
cmpl   $0x0,-0x9b94(%rbp)
je     1edf <main+0xc0f>
lea    0x218e(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
jmp    1eed <main+0xc1d>
lea    0x2183(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
movl   $0x0,-0x9ba8(%rbp)
cmpl   $0x3e0,-0x9ba8(%rbp)
jge    1f2e <main+0xc5e>
movslq -0x9ba8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9ba8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ba8(%rbp)
jmp    1ef7 <main+0xc27>
movl   $0x0,-0x9bac(%rbp)
movl   $0x0,-0x9bb4(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9bb4(%rbp)
mov    %al,-0x9d1b(%rbp)
jge    1f67 <main+0xc97>
cmpl   $0x0,-0x9bac(%rbp)
sete   %al
mov    %al,-0x9d1b(%rbp)
mov    -0x9d1b(%rbp),%al
test   $0x1,%al
jne    1f7a <main+0xcaa>
jmp    20c2 <main+0xdf2>
mov    $0x0,%al
call   1100 <omp_get_nested@plt>
movsd  %xmm0,-0x1f10(%rbp)
ff
xor    %edi,%edi
call   1110 <omp_set_nested@plt>
mov    $0x0,%al
call   1100 <omp_get_nested@plt>
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   1070 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    1fd5 <main+0xd05>
mov    $0x0,%al
call   1100 <omp_get_nested@plt>
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
xor    %edi,%edi
call   1110 <omp_set_nested@plt>
mov    $0x0,%al
call   1100 <omp_get_nested@plt>
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9bbc(%rbp)
movl   $0x0,-0x9bb8(%rbp)
cmpl   $0x1,-0x9bb8(%rbp)
jge    20a9 <main+0xdd9>
movslq -0x9bb8(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2035 <main+0xd65>
jp     2035 <main+0xd65>
jmp    2090 <main+0xdc0>
mov    -0x9bb8(%rbp),%esi
movslq -0x9bb8(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x1fde(%rip),%rdi
lea    0x2003(%rip),%rdx
xor    %ecx,%ecx
mov    $0x1,%al
call   10b0 <printf@plt>
movl   $0x1,-0x9bac(%rbp)
mov    -0x9bbc(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9bbc(%rbp)
cmp    $0xa,%eax
jle    208b <main+0xdbb>
jmp    20a9 <main+0xdd9>
jmp    2090 <main+0xdc0>
jmp    2095 <main+0xdc5>
mov    -0x9bb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bb8(%rbp)
jmp    2000 <main+0xd30>
jmp    20ae <main+0xdde>
mov    -0x9bb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bb4(%rbp)
jmp    1f42 <main+0xc72>
cmpl   $0x0,-0x9bac(%rbp)
je     20e2 <main+0xe12>
lea    0x1f8b(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
jmp    20f0 <main+0xe20>
lea    0x1f80(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
movl   $0x0,-0x9bc0(%rbp)
cmpl   $0x3e0,-0x9bc0(%rbp)
jge    2131 <main+0xe61>
movslq -0x9bc0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bc0(%rbp)
jmp    20fa <main+0xe2a>
mov    0x3eb0(%rip),%rax
mov    (%rax),%eax
mov    0x3e8f(%rip),%rcx
add    (%rcx),%eax
mov    0x3e96(%rip),%rcx
add    (%rcx),%eax
shl    $0x1,%eax
mov    0x3e92(%rip),%rcx
add    (%rcx),%eax
mov    %eax,-0x9bc4(%rbp)
mov    -0x9bc4(%rbp),%eax
add    $0x8b6,%eax
mov    %eax,-0x9bc4(%rbp)
movl   $0x0,-0x9bc8(%rbp)
movl   $0x0,-0x9bd0(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9bd0(%rbp)
mov    %al,-0x9d1c(%rbp)
jge    21a8 <main+0xed8>
cmpl   $0x0,-0x9bc8(%rbp)
sete   %al
mov    %al,-0x9d1c(%rbp)
mov    -0x9d1c(%rbp),%al
test   $0x1,%al
jne    21bb <main+0xeeb>
jmp    25b9 <main+0x12e9>
mov    0x3e26(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x9bd4(%rbp)
movl   $0xa,-0x9bd8(%rbp)
mov    -0x9bd4(%rbp),%edi
mov    -0x9bd8(%rbp),%esi
call   1080 <omp_set_schedule@plt>
movl   $0x0,-0x9bd4(%rbp)
movl   $0x0,-0x9bd8(%rbp)
lea    -0x9bd4(%rbp),%rdi
lea    -0x9bd8(%rbp),%rsi
call   1150 <omp_get_schedule@plt>
mov    -0x9bd4(%rbp),%eax
add    -0x9bd8(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    0x3da5(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x9bd4(%rbp)
movl   $0x64,-0x9bd8(%rbp)
mov    -0x9bd4(%rbp),%edi
mov    -0x9bd8(%rbp),%esi
call   1080 <omp_set_schedule@plt>
movl   $0x0,-0x9bd4(%rbp)
movl   $0x0,-0x9bd8(%rbp)
lea    -0x9bd4(%rbp),%rdi
lea    -0x9bd8(%rbp),%rsi
call   1150 <omp_get_schedule@plt>
mov    -0x9bd4(%rbp),%eax
add    -0x9bd8(%rbp),%eax
cvtsi2sd %eax,%xmm0
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    0x3d44(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x9bd4(%rbp)
movl   $0x3e8,-0x9bd8(%rbp)
mov    -0x9bd4(%rbp),%edi
mov    -0x9bd8(%rbp),%esi
call   1080 <omp_set_schedule@plt>
movl   $0x0,-0x9bd4(%rbp)
movl   $0x0,-0x9bd8(%rbp)
lea    -0x9bd4(%rbp),%rdi
lea    -0x9bd8(%rbp),%rsi
call   1150 <omp_get_schedule@plt>
mov    -0x9bd4(%rbp),%eax
add    -0x9bd8(%rbp),%eax
cvtsi2sd %eax,%xmm0
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    0x3cdb(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x9bd4(%rbp)
movl   $0xa,-0x9bd8(%rbp)
mov    -0x9bd4(%rbp),%edi
mov    -0x9bd8(%rbp),%esi
call   1080 <omp_set_schedule@plt>
mov    $0x0,%al
call   1070 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    2493 <main+0x11c3>
mov    0x3ca1(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x9bdc(%rbp)
movl   $0xa,-0x9be0(%rbp)
mov    -0x9bdc(%rbp),%edi
mov    -0x9be0(%rbp),%esi
call   1080 <omp_set_schedule@plt>
movl   $0x0,-0x9bdc(%rbp)
movl   $0x0,-0x9be0(%rbp)
lea    -0x9bdc(%rbp),%rdi
lea    -0x9be0(%rbp),%rsi
call   1150 <omp_get_schedule@plt>
mov    -0x9bdc(%rbp),%eax
add    -0x9be0(%rbp),%eax
cvtsi2sd %eax,%xmm0
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    0x3c18(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x9bdc(%rbp)
movl   $0x64,-0x9be0(%rbp)
mov    -0x9bdc(%rbp),%edi
mov    -0x9be0(%rbp),%esi
call   1080 <omp_set_schedule@plt>
movl   $0x0,-0x9bdc(%rbp)
movl   $0x0,-0x9be0(%rbp)
lea    -0x9bdc(%rbp),%rdi
lea    -0x9be0(%rbp),%rsi
call   1150 <omp_get_schedule@plt>
mov    -0x9bdc(%rbp),%eax
add    -0x9be0(%rbp),%eax
cvtsi2sd %eax,%xmm0
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    0x3bb7(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x9bdc(%rbp)
movl   $0x3e8,-0x9be0(%rbp)
mov    -0x9bdc(%rbp),%edi
mov    -0x9be0(%rbp),%esi
call   1080 <omp_set_schedule@plt>
movl   $0x0,-0x9bdc(%rbp)
movl   $0x0,-0x9be0(%rbp)
lea    -0x9bdc(%rbp),%rdi
lea    -0x9be0(%rbp),%rsi
call   1150 <omp_get_schedule@plt>
mov    -0x9bdc(%rbp),%eax
add    -0x9be0(%rbp),%eax
cvtsi2sd %eax,%xmm0
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9bd4(%rbp)
movl   $0x0,-0x9bd8(%rbp)
lea    -0x9bd4(%rbp),%rdi
lea    -0x9bd8(%rbp),%rsi
call   1150 <omp_get_schedule@plt>
mov    -0x9bd4(%rbp),%eax
add    -0x9bd8(%rbp),%eax
cvtsi2sd %eax,%xmm0
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9be8(%rbp)
movl   $0x0,-0x9be4(%rbp)
cmpl   $0x1,-0x9be4(%rbp)
jge    25a0 <main+0x12d0>
movslq -0x9be4(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
cvtsi2sdl -0x9bc4(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
jne    2528 <main+0x1258>
jp     2528 <main+0x1258>
jmp    2587 <main+0x12b7>
mov    -0x9be4(%rbp),%esi
mov    -0x9bc4(%rbp),%ecx
movslq -0x9be4(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x1ae5(%rip),%rdi
lea    0x1b0a(%rip),%rdx
mov    $0x1,%al
call   10b0 <printf@plt>
movl   $0x1,-0x9bc8(%rbp)
mov    -0x9be8(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9be8(%rbp)
cmp    $0xa,%eax
jle    2582 <main+0x12b2>
jmp    25a0 <main+0x12d0>
jmp    2587 <main+0x12b7>
jmp    258c <main+0x12bc>
mov    -0x9be4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9be4(%rbp)
jmp    24ee <main+0x121e>
jmp    25a5 <main+0x12d5>
mov    -0x9bd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bd0(%rbp)
jmp    2183 <main+0xeb3>
cmpl   $0x0,-0x9bc8(%rbp)
je     25d9 <main+0x1309>
lea    0x1a94(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
jmp    25e7 <main+0x1317>
lea    0x1a89(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
movl   $0x0,-0x9bec(%rbp)
cmpl   $0x3e0,-0x9bec(%rbp)
jge    2628 <main+0x1358>
movslq -0x9bec(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9bec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bec(%rbp)
jmp    25f1 <main+0x1321>
movl   $0x0,-0x9bf0(%rbp)
movl   $0x0,-0x9bf8(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9bf8(%rbp)
mov    %al,-0x9d1d(%rbp)
jge    2661 <main+0x1391>
cmpl   $0x0,-0x9bf0(%rbp)
sete   %al
mov    %al,-0x9d1d(%rbp)
mov    -0x9d1d(%rbp),%al
test   $0x1,%al
jne    2674 <main+0x13a4>
jmp    279d <main+0x14cd>
mov    $0x0,%al
call   10e0 <omp_get_thread_limit@plt>
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   1070 <omp_get_thread_num@plt>
cmp    $0x0,%eax
jne    26c0 <main+0x13f0>
mov    $0x0,%al
call   10e0 <omp_get_thread_limit@plt>
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   10d0 <omp_get_num_threads@plt>
shl    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x1f08(%rbp)
ff
movl   $0x0,-0x9c00(%rbp)
movl   $0x0,-0x9bfc(%rbp)
cmpl   $0x1,-0x9bfc(%rbp)
jge    2784 <main+0x14b4>
movslq -0x9bfc(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
ucomisd -0x1f08(%rbp),%xmm0
ff
jne    270a <main+0x143a>
jp     270a <main+0x143a>
jmp    276b <main+0x149b>
mov    -0x9bfc(%rbp),%esi
movsd  -0x1f08(%rbp),%xmm0
ff
movslq -0x9bfc(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x1901(%rip),%rdi
lea    0x1926(%rip),%rdx
mov    $0x2,%al
call   10b0 <printf@plt>
movl   $0x1,-0x9bf0(%rbp)
mov    -0x9c00(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9c00(%rbp)
cmp    $0xa,%eax
jle    2766 <main+0x1496>
jmp    2784 <main+0x14b4>
jmp    276b <main+0x149b>
jmp    2770 <main+0x14a0>
mov    -0x9bfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bfc(%rbp)
jmp    26d4 <main+0x1404>
jmp    2789 <main+0x14b9>
mov    -0x9bf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9bf8(%rbp)
jmp    263c <main+0x136c>
cmpl   $0x0,-0x9bf0(%rbp)
je     27bd <main+0x14ed>
lea    0x18b0(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
jmp    27cb <main+0x14fb>
lea    0x18a5(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
movl   $0x0,-0x9c04(%rbp)
cmpl   $0x3e0,-0x9c04(%rbp)
jge    280c <main+0x153c>
movslq -0x9c04(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c04(%rbp)
jmp    27d5 <main+0x1505>
movl   $0x0,-0x9c08(%rbp)
movl   $0x0,-0x9c10(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9c10(%rbp)
mov    %al,-0x9d1e(%rbp)
jge    2845 <main+0x1575>
cmpl   $0x0,-0x9c08(%rbp)
sete   %al
mov    %al,-0x9d1e(%rbp)
mov    -0x9d1e(%rbp),%al
test   $0x1,%al
jne    2858 <main+0x1588>
jmp    2976 <main+0x16a6>
mov    $0x1,%edi
call   1050 <omp_set_max_active_levels@plt>
mov    $0x0,%al
call   1060 <omp_get_max_active_levels@plt>
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   1070 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    2898 <main+0x15c8>
mov    $0x0,%al
call   1060 <omp_get_max_active_levels@plt>
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9c18(%rbp)
movl   $0x0,-0x9c14(%rbp)
cmpl   $0x1,-0x9c14(%rbp)
jge    295d <main+0x168d>
movslq -0x9c14(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x172f(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    28e6 <main+0x1616>
jp     28e6 <main+0x1616>
jmp    2944 <main+0x1674>
mov    -0x9c14(%rbp),%esi
movslq -0x9c14(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x172d(%rip),%rdi
lea    0x1752(%rip),%rdx
mov    $0x2,%ecx
mov    $0x1,%al
call   10b0 <printf@plt>
movl   $0x1,-0x9c08(%rbp)
mov    -0x9c18(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9c18(%rbp)
cmp    $0xa,%eax
jle    293f <main+0x166f>
jmp    295d <main+0x168d>
jmp    2944 <main+0x1674>
jmp    2949 <main+0x1679>
mov    -0x9c14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c14(%rbp)
jmp    28ac <main+0x15dc>
jmp    2962 <main+0x1692>
mov    -0x9c10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c10(%rbp)
jmp    2820 <main+0x1550>
cmpl   $0x0,-0x9c08(%rbp)
je     2996 <main+0x16c6>
lea    0x16d7(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
jmp    29a4 <main+0x16d4>
lea    0x16cc(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
movl   $0x0,-0x9c1c(%rbp)
cmpl   $0x3e0,-0x9c1c(%rbp)
jge    29e5 <main+0x1715>
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    29ae <main+0x16de>
movl   $0x0,-0x9c20(%rbp)
movl   $0x0,-0x9c28(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9c28(%rbp)
mov    %al,-0x9d1f(%rbp)
jge    2a1e <main+0x174e>
cmpl   $0x0,-0x9c20(%rbp)
sete   %al
mov    %al,-0x9d1f(%rbp)
mov    -0x9d1f(%rbp),%al
test   $0x1,%al
jne    2a31 <main+0x1761>
jmp    2b45 <main+0x1875>
mov    $0x0,%al
call   1130 <omp_get_level@plt>
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   1070 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    2a67 <main+0x1797>
mov    $0x0,%al
call   1130 <omp_get_level@plt>
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9c30(%rbp)
movl   $0x0,-0x9c2c(%rbp)
cmpl   $0x1,-0x9c2c(%rbp)
jge    2b2c <main+0x185c>
movslq -0x9c2c(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1568(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2ab5 <main+0x17e5>
jp     2ab5 <main+0x17e5>
jmp    2b13 <main+0x1843>
mov    -0x9c2c(%rbp),%esi
movslq -0x9c2c(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x155e(%rip),%rdi
lea    0x1583(%rip),%rdx
mov    $0x1,%ecx
mov    $0x1,%al
call   10b0 <printf@plt>
movl   $0x1,-0x9c20(%rbp)
mov    -0x9c30(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9c30(%rbp)
cmp    $0xa,%eax
jle    2b0e <main+0x183e>
jmp    2b2c <main+0x185c>
jmp    2b13 <main+0x1843>
jmp    2b18 <main+0x1848>
mov    -0x9c2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c2c(%rbp)
jmp    2a7b <main+0x17ab>
jmp    2b31 <main+0x1861>
mov    -0x9c28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c28(%rbp)
jmp    29f9 <main+0x1729>
cmpl   $0x0,-0x9c20(%rbp)
je     2b65 <main+0x1895>
lea    0x1508(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
jmp    2b73 <main+0x18a3>
lea    0x14fd(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
movl   $0x0,-0x9c34(%rbp)
cmpl   $0x3e0,-0x9c34(%rbp)
jge    2bb4 <main+0x18e4>
movslq -0x9c34(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c34(%rbp)
jmp    2b7d <main+0x18ad>
movl   $0x0,-0x9c38(%rbp)
movl   $0x0,-0x9c40(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9c40(%rbp)
mov    %al,-0x9d20(%rbp)
jge    2bed <main+0x191d>
cmpl   $0x0,-0x9c38(%rbp)
sete   %al
mov    %al,-0x9d20(%rbp)
mov    -0x9d20(%rbp),%al
test   $0x1,%al
jne    2c00 <main+0x1930>
jmp    2d35 <main+0x1a65>
xor    %edi,%edi
call   1040 <omp_get_ancestor_thread_num@plt>
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   1070 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    2c57 <main+0x1987>
xor    %edi,%edi
call   1040 <omp_get_ancestor_thread_num@plt>
movsd  %xmm0,-0x9d28(%rbp)
ff
mov    $0x1,%edi
call   1040 <omp_get_ancestor_thread_num@plt>
movaps %xmm0,%xmm1
movsd  -0x9d28(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9c48(%rbp)
movl   $0x0,-0x9c44(%rbp)
cmpl   $0x1,-0x9c44(%rbp)
jge    2d1c <main+0x1a4c>
movslq -0x9c44(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1388(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2ca5 <main+0x19d5>
jp     2ca5 <main+0x19d5>
jmp    2d03 <main+0x1a33>
mov    -0x9c44(%rbp),%esi
movslq -0x9c44(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x136e(%rip),%rdi
lea    0x1393(%rip),%rdx
mov    $0x12,%ecx
mov    $0x1,%al
call   10b0 <printf@plt>
movl   $0x1,-0x9c38(%rbp)
mov    -0x9c48(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9c48(%rbp)
cmp    $0xa,%eax
jle    2cfe <main+0x1a2e>
jmp    2d1c <main+0x1a4c>
jmp    2d03 <main+0x1a33>
jmp    2d08 <main+0x1a38>
mov    -0x9c44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c44(%rbp)
jmp    2c6b <main+0x199b>
jmp    2d21 <main+0x1a51>
mov    -0x9c40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c40(%rbp)
jmp    2bc8 <main+0x18f8>
cmpl   $0x0,-0x9c38(%rbp)
je     2d55 <main+0x1a85>
lea    0x1318(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
jmp    2d63 <main+0x1a93>
lea    0x130d(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
movl   $0x0,-0x9c4c(%rbp)
cmpl   $0x3e0,-0x9c4c(%rbp)
jge    2da4 <main+0x1ad4>
movslq -0x9c4c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c4c(%rbp)
jmp    2d6d <main+0x1a9d>
movl   $0x0,-0x9c50(%rbp)
movl   $0x0,-0x9c58(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9c58(%rbp)
mov    %al,-0x9d29(%rbp)
jge    2ddd <main+0x1b0d>
cmpl   $0x0,-0x9c50(%rbp)
sete   %al
mov    %al,-0x9d29(%rbp)
mov    -0x9d29(%rbp),%al
test   $0x1,%al
jne    2df0 <main+0x1b20>
jmp    2f65 <main+0x1c95>
xor    %edi,%edi
call   1160 <omp_get_team_size@plt>
movsd  %xmm0,-0x9d38(%rbp)
ff
mov    $0x1,%edi
call   1160 <omp_get_team_size@plt>
movaps %xmm0,%xmm1
movsd  -0x9d38(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   1070 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    2e68 <main+0x1b98>
xor    %edi,%edi
call   1160 <omp_get_team_size@plt>
movsd  %xmm0,-0x9d40(%rbp)
ff
mov    $0x1,%edi
call   1160 <omp_get_team_size@plt>
movaps %xmm0,%xmm1
movsd  -0x9d40(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   11f0 <omp_is_initial_device@plt>
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2f4c <main+0x1c7c>
jp     2f4c <main+0x1c7c>
movl   $0x0,-0x9c60(%rbp)
movl   $0x0,-0x9c5c(%rbp)
cmpl   $0x1,-0x9c5c(%rbp)
jge    2f47 <main+0x1c77>
movslq -0x9c5c(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1155(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2ed0 <main+0x1c00>
jp     2ed0 <main+0x1c00>
jmp    2f2e <main+0x1c5e>
mov    -0x9c5c(%rbp),%esi
movslq -0x9c5c(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x1143(%rip),%rdi
lea    0x1168(%rip),%rdx
mov    $0x16,%ecx
mov    $0x1,%al
call   10b0 <printf@plt>
movl   $0x1,-0x9c50(%rbp)
mov    -0x9c60(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9c60(%rbp)
cmp    $0xa,%eax
jle    2f29 <main+0x1c59>
jmp    2f47 <main+0x1c77>
jmp    2f2e <main+0x1c5e>
jmp    2f33 <main+0x1c63>
mov    -0x9c5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c5c(%rbp)
jmp    2e96 <main+0x1bc6>
jmp    2f4c <main+0x1c7c>
jmp    2f51 <main+0x1c81>
mov    -0x9c58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c58(%rbp)
jmp    2db8 <main+0x1ae8>
cmpl   $0x0,-0x9c50(%rbp)
je     2f85 <main+0x1cb5>
lea    0x10e8(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
jmp    2f93 <main+0x1cc3>
lea    0x10dd(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
movl   $0x0,-0x9c64(%rbp)
cmpl   $0x3e0,-0x9c64(%rbp)
jge    2fd4 <main+0x1d04>
movslq -0x9c64(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c64(%rbp)
jmp    2f9d <main+0x1ccd>
movl   $0x0,-0x9c68(%rbp)
movl   $0x0,-0x9c70(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9c70(%rbp)
mov    %al,-0x9d41(%rbp)
jge    300d <main+0x1d3d>
cmpl   $0x0,-0x9c68(%rbp)
sete   %al
mov    %al,-0x9d41(%rbp)
mov    -0x9d41(%rbp),%al
test   $0x1,%al
jne    3020 <main+0x1d50>
jmp    3134 <main+0x1e64>
mov    $0x0,%al
call   1190 <omp_get_active_level@plt>
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   1070 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    3056 <main+0x1d86>
mov    $0x0,%al
call   1190 <omp_get_active_level@plt>
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9c78(%rbp)
movl   $0x0,-0x9c74(%rbp)
cmpl   $0x1,-0x9c74(%rbp)
jge    311b <main+0x1e4b>
movslq -0x9c74(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0xf79(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    30a4 <main+0x1dd4>
jp     30a4 <main+0x1dd4>
jmp    3102 <main+0x1e32>
mov    -0x9c74(%rbp),%esi
movslq -0x9c74(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0xf6f(%rip),%rdi
lea    0xf94(%rip),%rdx
mov    $0x1,%ecx
mov    $0x1,%al
call   10b0 <printf@plt>
movl   $0x1,-0x9c68(%rbp)
mov    -0x9c78(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9c78(%rbp)
cmp    $0xa,%eax
jle    30fd <main+0x1e2d>
jmp    311b <main+0x1e4b>
jmp    3102 <main+0x1e32>
jmp    3107 <main+0x1e37>
mov    -0x9c74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c74(%rbp)
jmp    306a <main+0x1d9a>
jmp    3120 <main+0x1e50>
mov    -0x9c70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c70(%rbp)
jmp    2fe8 <main+0x1d18>
cmpl   $0x0,-0x9c68(%rbp)
je     3154 <main+0x1e84>
lea    0xf19(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
jmp    3162 <main+0x1e92>
lea    0xf0e(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
movl   $0x0,-0x9c7c(%rbp)
cmpl   $0x3e0,-0x9c7c(%rbp)
jge    31a3 <main+0x1ed3>
movslq -0x9c7c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c7c(%rbp)
jmp    316c <main+0x1e9c>
movl   $0x0,-0x9c80(%rbp)
movl   $0x0,-0x9c88(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9c88(%rbp)
mov    %al,-0x9d42(%rbp)
jge    31dc <main+0x1f0c>
cmpl   $0x0,-0x9c80(%rbp)
sete   %al
mov    %al,-0x9d42(%rbp)
mov    -0x9d42(%rbp),%al
test   $0x1,%al
jne    31ef <main+0x1f1f>
jmp    335c <main+0x208c>
mov    $0x0,%al
call   10a0 <omp_in_final@plt>
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   1070 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    3225 <main+0x1f55>
mov    $0x0,%al
call   10a0 <omp_in_final@plt>
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9c90(%rbp)
movl   $0x0,-0x9c8c(%rbp)
cmpl   $0x1,-0x9c8c(%rbp)
jge    3343 <main+0x2073>
movslq -0x9c8c(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x9d50(%rbp)
ff
mov    $0x0,%al
call   11f0 <omp_is_initial_device@plt>
movaps %xmm0,%xmm1
movsd  -0x9d50(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jne    3285 <main+0x1fb5>
jp     3285 <main+0x1fb5>
jmp    3294 <main+0x1fc4>
xor    %eax,%eax
test   $0x1,%al
jne    32a3 <main+0x1fd3>
jmp    332a <main+0x205a>
mov    $0x1,%al
test   $0x1,%al
jne    32a3 <main+0x1fd3>
jmp    332a <main+0x205a>
mov    -0x9c8c(%rbp),%eax
mov    %eax,-0x9d54(%rbp)
mov    $0x0,%al
call   11f0 <omp_is_initial_device@plt>
mov    -0x9d54(%rbp),%esi
xorps  %xmm1,%xmm1
mov    $0x2,%ecx
xor    %eax,%eax
ucomisd %xmm1,%xmm0
setp   %dil
setne  %dl
or     %dil,%dl
cmovne %eax,%ecx
movslq -0x9c8c(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0xd42(%rip),%rdi
lea    0xd67(%rip),%rdx
mov    $0x1,%al
call   10b0 <printf@plt>
movl   $0x1,-0x9c80(%rbp)
mov    -0x9c90(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9c90(%rbp)
cmp    $0xa,%eax
jle    3325 <main+0x2055>
jmp    3343 <main+0x2073>
jmp    332a <main+0x205a>
jmp    332f <main+0x205f>
mov    -0x9c8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c8c(%rbp)
jmp    3239 <main+0x1f69>
jmp    3348 <main+0x2078>
mov    -0x9c88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c88(%rbp)
jmp    31b7 <main+0x1ee7>
cmpl   $0x0,-0x9c80(%rbp)
je     337c <main+0x20ac>
lea    0xcf1(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
jmp    338a <main+0x20ba>
lea    0xce6(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
movl   $0x0,-0x9c94(%rbp)
cmpl   $0x3e0,-0x9c94(%rbp)
jge    33cb <main+0x20fb>
movslq -0x9c94(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9c94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c94(%rbp)
jmp    3394 <main+0x20c4>
movl   $0x0,-0x9c98(%rbp)
movl   $0x0,-0x9ca0(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9ca0(%rbp)
mov    %al,-0x9d55(%rbp)
jge    3404 <main+0x2134>
cmpl   $0x0,-0x9c98(%rbp)
sete   %al
mov    %al,-0x9d55(%rbp)
mov    -0x9d55(%rbp),%al
test   $0x1,%al
jne    3417 <main+0x2147>
jmp    3584 <main+0x22b4>
mov    $0x0,%al
call   1090 <omp_get_proc_bind@plt>
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   1070 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    344d <main+0x217d>
mov    $0x0,%al
call   1090 <omp_get_proc_bind@plt>
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9ca8(%rbp)
movl   $0x0,-0x9ca4(%rbp)
cmpl   $0x1,-0x9ca4(%rbp)
jge    356b <main+0x229b>
movslq -0x9ca4(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x9d60(%rbp)
ff
mov    $0x0,%al
call   11f0 <omp_is_initial_device@plt>
movaps %xmm0,%xmm1
movsd  -0x9d60(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jne    34ad <main+0x21dd>
jp     34ad <main+0x21dd>
jmp    34bc <main+0x21ec>
xor    %eax,%eax
test   $0x1,%al
jne    34cb <main+0x21fb>
jmp    3552 <main+0x2282>
mov    $0x1,%al
test   $0x1,%al
jne    34cb <main+0x21fb>
jmp    3552 <main+0x2282>
mov    -0x9ca4(%rbp),%eax
mov    %eax,-0x9d64(%rbp)
mov    $0x0,%al
call   11f0 <omp_is_initial_device@plt>
mov    -0x9d64(%rbp),%esi
xorps  %xmm1,%xmm1
mov    $0x2,%ecx
xor    %eax,%eax
ucomisd %xmm1,%xmm0
setp   %dil
setne  %dl
or     %dil,%dl
cmovne %eax,%ecx
movslq -0x9ca4(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0xb1a(%rip),%rdi
lea    0xb3f(%rip),%rdx
mov    $0x1,%al
call   10b0 <printf@plt>
movl   $0x1,-0x9c98(%rbp)
mov    -0x9ca8(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9ca8(%rbp)
cmp    $0xa,%eax
jle    354d <main+0x227d>
jmp    356b <main+0x229b>
jmp    3552 <main+0x2282>
jmp    3557 <main+0x2287>
mov    -0x9ca4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ca4(%rbp)
jmp    3461 <main+0x2191>
jmp    3570 <main+0x22a0>
mov    -0x9ca0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ca0(%rbp)
jmp    33df <main+0x210f>
cmpl   $0x0,-0x9c98(%rbp)
je     35a4 <main+0x22d4>
lea    0xac9(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
jmp    35b2 <main+0x22e2>
lea    0xabe(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
movl   $0x0,-0x9cac(%rbp)
cmpl   $0x3e0,-0x9cac(%rbp)
jge    35f3 <main+0x2323>
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    35bc <main+0x22ec>
movl   $0x0,-0x9cb0(%rbp)
movl   $0x0,-0x9cb8(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9cb8(%rbp)
mov    %al,-0x9d65(%rbp)
jge    362c <main+0x235c>
cmpl   $0x0,-0x9cb0(%rbp)
sete   %al
mov    %al,-0x9d65(%rbp)
mov    -0x9d65(%rbp),%al
test   $0x1,%al
jne    363f <main+0x236f>
jmp    3752 <main+0x2482>
xor    %edi,%edi
call   1140 <omp_set_default_device@plt>
mov    $0x0,%al
call   10c0 <omp_get_default_device@plt>
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   1070 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    367c <main+0x23ac>
mov    $0x0,%al
call   10c0 <omp_get_default_device@plt>
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9cc0(%rbp)
movl   $0x0,-0x9cbc(%rbp)
cmpl   $0x1,-0x9cbc(%rbp)
jge    3739 <main+0x2469>
movslq -0x9cbc(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    36c5 <main+0x23f5>
jp     36c5 <main+0x23f5>
jmp    3720 <main+0x2450>
mov    -0x9cbc(%rbp),%esi
movslq -0x9cbc(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x94e(%rip),%rdi
lea    0x973(%rip),%rdx
xor    %ecx,%ecx
mov    $0x1,%al
call   10b0 <printf@plt>
movl   $0x1,-0x9cb0(%rbp)
mov    -0x9cc0(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9cc0(%rbp)
cmp    $0xa,%eax
jle    371b <main+0x244b>
jmp    3739 <main+0x2469>
jmp    3720 <main+0x2450>
jmp    3725 <main+0x2455>
mov    -0x9cbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cbc(%rbp)
jmp    3690 <main+0x23c0>
jmp    373e <main+0x246e>
mov    -0x9cb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cb8(%rbp)
jmp    3607 <main+0x2337>
cmpl   $0x0,-0x9cb0(%rbp)
je     3772 <main+0x24a2>
lea    0x8fb(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
jmp    3780 <main+0x24b0>
lea    0x8f0(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
movl   $0x0,-0x9cc4(%rbp)
cmpl   $0x3e0,-0x9cc4(%rbp)
jge    37c1 <main+0x24f1>
movslq -0x9cc4(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9cc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cc4(%rbp)
jmp    378a <main+0x24ba>
movl   $0x0,-0x9cc8(%rbp)
movl   $0x0,-0x9cd0(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9cd0(%rbp)
mov    %al,-0x9d66(%rbp)
jge    37fa <main+0x252a>
cmpl   $0x0,-0x9cc8(%rbp)
sete   %al
mov    %al,-0x9d66(%rbp)
mov    -0x9d66(%rbp),%al
test   $0x1,%al
jne    380d <main+0x253d>
jmp    393c <main+0x266c>
mov    $0x0,%al
call   11a0 <omp_get_num_devices@plt>
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   1070 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    383b <main+0x256b>
mov    $0x0,%al
call   11a0 <omp_get_num_devices@plt>
movsd  %xmm0,-0x1f08(%rbp)
ff
movl   $0x0,-0x9cd8(%rbp)
movl   $0x0,-0x9cd4(%rbp)
cmpl   $0x1,-0x9cd4(%rbp)
jge    3923 <main+0x2653>
movslq -0x9cd4(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movslq -0x9cd4(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
subsd  -0x1f08(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
jne    3899 <main+0x25c9>
jp     3899 <main+0x25c9>
jmp    390a <main+0x263a>
mov    -0x9cd4(%rbp),%esi
movslq -0x9cd4(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
subsd  -0x1f08(%rbp),%xmm0
ff
movslq -0x9cd4(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x762(%rip),%rdi
lea    0x787(%rip),%rdx
mov    $0x2,%al
call   10b0 <printf@plt>
movl   $0x1,-0x9cc8(%rbp)
mov    -0x9cd8(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9cd8(%rbp)
cmp    $0xa,%eax
jle    3905 <main+0x2635>
jmp    3923 <main+0x2653>
jmp    390a <main+0x263a>
jmp    390f <main+0x263f>
mov    -0x9cd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cd4(%rbp)
jmp    384f <main+0x257f>
jmp    3928 <main+0x2658>
mov    -0x9cd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cd0(%rbp)
jmp    37d5 <main+0x2505>
cmpl   $0x0,-0x9cc8(%rbp)
je     395c <main+0x268c>
lea    0x711(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
jmp    396a <main+0x269a>
lea    0x706(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
movl   $0x0,-0x9cdc(%rbp)
cmpl   $0x3e0,-0x9cdc(%rbp)
jge    39ab <main+0x26db>
movslq -0x9cdc(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9cdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cdc(%rbp)
jmp    3974 <main+0x26a4>
movl   $0x0,-0x9ce0(%rbp)
movl   $0x0,-0x9ce8(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9ce8(%rbp)
mov    %al,-0x9d67(%rbp)
jge    39e4 <main+0x2714>
cmpl   $0x0,-0x9ce0(%rbp)
sete   %al
mov    %al,-0x9d67(%rbp)
mov    -0x9d67(%rbp),%al
test   $0x1,%al
jne    39f7 <main+0x2727>
jmp    3b43 <main+0x2873>
mov    $0x0,%al
call   11d0 <omp_get_num_teams@plt>
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   11c0 <omp_get_team_num@plt>
cvtsi2sd %rax,%xmm0
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   1070 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    3a65 <main+0x2795>
mov    $0x0,%al
call   11d0 <omp_get_num_teams@plt>
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   11c0 <omp_get_team_num@plt>
cvtsi2sd %rax,%xmm0
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9cf0(%rbp)
movl   $0x0,-0x9cec(%rbp)
cmpl   $0x1,-0x9cec(%rbp)
jge    3b2a <main+0x285a>
movslq -0x9cec(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  0x562(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3ab3 <main+0x27e3>
jp     3ab3 <main+0x27e3>
jmp    3b11 <main+0x2841>
mov    -0x9cec(%rbp),%esi
movslq -0x9cec(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
lea    0x560(%rip),%rdi
lea    0x585(%rip),%rdx
mov    $0x2,%ecx
mov    $0x1,%al
call   10b0 <printf@plt>
movl   $0x1,-0x9ce0(%rbp)
mov    -0x9cf0(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9cf0(%rbp)
cmp    $0xa,%eax
jle    3b0c <main+0x283c>
jmp    3b2a <main+0x285a>
jmp    3b11 <main+0x2841>
jmp    3b16 <main+0x2846>
mov    -0x9cec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cec(%rbp)
jmp    3a79 <main+0x27a9>
jmp    3b2f <main+0x285f>
mov    -0x9ce8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9ce8(%rbp)
jmp    39bf <main+0x26ef>
cmpl   $0x0,-0x9ce0(%rbp)
je     3b63 <main+0x2893>
lea    0x50a(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
jmp    3b71 <main+0x28a1>
lea    0x4ff(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
movl   $0x0,-0x9cf4(%rbp)
cmpl   $0x3e0,-0x9cf4(%rbp)
jge    3bb2 <main+0x28e2>
movslq -0x9cf4(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x9cf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9cf4(%rbp)
jmp    3b7b <main+0x28ab>
mov    $0x0,%al
call   11f0 <omp_is_initial_device@plt>
movsd  %xmm0,-0x1f08(%rbp)
ff
movl   $0x0,-0x9cf8(%rbp)
movl   $0x0,-0x9d00(%rbp)
xor    %eax,%eax
cmpl   $0x1,-0x9d00(%rbp)
mov    %al,-0x9d68(%rbp)
jge    3bfa <main+0x292a>
cmpl   $0x0,-0x9cf8(%rbp)
sete   %al
mov    %al,-0x9d68(%rbp)
mov    -0x9d68(%rbp),%al
test   $0x1,%al
jne    3c0d <main+0x293d>
jmp    3dca <main+0x2afa>
mov    $0x0,%al
call   11f0 <omp_is_initial_device@plt>
movsd  %xmm0,-0x1f10(%rbp)
ff
mov    $0x0,%al
call   1070 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    3c43 <main+0x2973>
mov    $0x0,%al
call   11f0 <omp_is_initial_device@plt>
addsd  -0x1f10(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f10(%rbp)
ff
movl   $0x0,-0x9d08(%rbp)
movl   $0x0,-0x9d04(%rbp)
cmpl   $0x1,-0x9d04(%rbp)
jge    3db1 <main+0x2ae1>
movslq -0x9d04(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x9d70(%rbp)
ff
mov    $0x0,%al
call   11f0 <omp_is_initial_device@plt>
movaps %xmm0,%xmm1
movsd  -0x9d70(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jne    3ca3 <main+0x29d3>
jp     3ca3 <main+0x29d3>
jmp    3ccb <main+0x29fb>
movsd  -0x1f08(%rbp),%xmm0
ff
subsd  -0x1f08(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    3cda <main+0x2a0a>
jp     3cda <main+0x2a0a>
jmp    3d98 <main+0x2ac8>
mov    $0x1,%al
test   $0x1,%al
jne    3cda <main+0x2a0a>
jmp    3d98 <main+0x2ac8>
mov    -0x9d04(%rbp),%eax
mov    %eax,-0x9d74(%rbp)
mov    $0x0,%al
call   11f0 <omp_is_initial_device@plt>
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    3d05 <main+0x2a35>
jp     3d05 <main+0x2a35>
jmp    3d22 <main+0x2a52>
movsd  -0x1f08(%rbp),%xmm0
ff
subsd  -0x1f08(%rbp),%xmm0
ff
movsd  %xmm0,-0x9d80(%rbp)
ff
jmp    3d37 <main+0x2a67>
movsd  0x2d6(%rip),%xmm0
movsd  %xmm0,-0x9d80(%rbp)
ff
jmp    3d37 <main+0x2a67>
mov    -0x9d74(%rbp),%esi
movsd  -0x9d80(%rbp),%xmm0
ff
movslq -0x9d04(%rbp),%rax
movsd  -0x1f10(%rbp,%rax,8),%xmm1
ff ff
lea    0x2d4(%rip),%rdi
lea    0x2f9(%rip),%rdx
mov    $0x2,%al
call   10b0 <printf@plt>
movl   $0x1,-0x9cf8(%rbp)
mov    -0x9d08(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x9d08(%rbp)
cmp    $0xa,%eax
jle    3d93 <main+0x2ac3>
jmp    3db1 <main+0x2ae1>
jmp    3d98 <main+0x2ac8>
jmp    3d9d <main+0x2acd>
mov    -0x9d04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d04(%rbp)
jmp    3c57 <main+0x2987>
jmp    3db6 <main+0x2ae6>
mov    -0x9d00(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9d00(%rbp)
jmp    3bd5 <main+0x2905>
cmpl   $0x0,-0x9cf8(%rbp)
je     3dea <main+0x2b1a>
lea    0x283(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
jmp    3df8 <main+0x2b28>
lea    0x278(%rip),%rdi
mov    $0x0,%al
call   10b0 <printf@plt>
xor    %eax,%eax
add    $0x9d80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
xor    %eax,%eax
call   1180 <check_offloading@plt>
xor    %eax,%eax
call   10e0 <omp_get_num_threads@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1080 <omp_get_thread_num@plt>
cmp    $0x3,%eax
jne    1330 <main+0x50>
xor    %eax,%eax
call   10e0 <omp_get_num_threads@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
jmp    1336 <main+0x56>
movsd  0x8(%rsp),%xmm0
ucomisd 0x1cc2(%rip),%xmm0
jne    1342 <main+0x62>
jnp    1367 <main+0x87>
lea    0x1cef(%rip),%rdi
lea    0x1d14(%rip),%rdx
xor    %esi,%esi
mov    $0x81,%ecx
mov    $0x1,%al
call   10c0 <printf@plt>
lea    0x1d0e(%rip),%rdi
jmp    136e <main+0x8e>
lea    0x1cfb(%rip),%rdi
call   1070 <puts@plt>
xor    %eax,%eax
call   1190 <omp_get_max_threads@plt>
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1080 <omp_get_thread_num@plt>
xorpd  %xmm0,%xmm0
test   %eax,%eax
jne    13b4 <main+0xd4>
xor    %eax,%eax
call   1190 <omp_get_max_threads@plt>
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
xor    %eax,%eax
call   10e0 <omp_get_num_threads@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x20(%rsp)
xor    %eax,%eax
call   1200 <omp_is_initial_device@plt>
lea    0x1ca1(%rip),%rdi
ucomisd 0x1c60(%rip),%xmm0
jne    140e <main+0x12e>
jp     140e <main+0x12e>
movsd  0x20(%rsp),%xmm0
addsd  0x1c26(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jne    13f0 <main+0x110>
jnp    140e <main+0x12e>
lea    0x1c41(%rip),%rdi
lea    0x1c66(%rip),%rdx
xor    %esi,%esi
mov    $0x2,%al
call   10c0 <printf@plt>
lea    0x1c65(%rip),%rdi
call   1070 <puts@plt>
xor    %eax,%eax
call   1130 <omp_get_num_procs@plt>
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1080 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    1455 <main+0x175>
xor    %eax,%eax
call   1130 <omp_get_num_procs@plt>
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
xor    %eax,%eax
call   10e0 <omp_get_num_threads@plt>
add    %eax,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
jmp    1459 <main+0x179>
xorpd  %xmm0,%xmm0
movsd  0x8(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jne    1467 <main+0x187>
jnp    1487 <main+0x1a7>
lea    0x1bca(%rip),%rdi
lea    0x1bef(%rip),%rdx
xor    %esi,%esi
mov    $0x2,%al
call   10c0 <printf@plt>
lea    0x1bee(%rip),%rdi
jmp    148e <main+0x1ae>
lea    0x1bdb(%rip),%rdi
call   1070 <puts@plt>
xor    %eax,%eax
call   1030 <omp_in_parallel@plt>
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1030 <omp_in_parallel@plt>
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1080 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    14d6 <main+0x1f6>
xor    %eax,%eax
call   1030 <omp_in_parallel@plt>
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
jmp    14dc <main+0x1fc>
movsd  0x8(%rsp),%xmm0
ucomisd 0x1b24(%rip),%xmm0
jne    14e8 <main+0x208>
jnp    150d <main+0x22d>
lea    0x1b49(%rip),%rdi
lea    0x1b6e(%rip),%rdx
xor    %esi,%esi
mov    $0x1,%ecx
mov    $0x1,%al
call   10c0 <printf@plt>
lea    0x1b68(%rip),%rdi
jmp    1514 <main+0x234>
lea    0x1b55(%rip),%rdi
call   1070 <puts@plt>
xor    %eax,%eax
call   11f0 <omp_get_dynamic@plt>
movsd  %xmm0,0x8(%rsp)
mov    $0x1,%edi
call   1100 <omp_set_dynamic@plt>
xor    %eax,%eax
call   11f0 <omp_get_dynamic@plt>
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1080 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    156d <main+0x28d>
xor    %eax,%eax
call   11f0 <omp_get_dynamic@plt>
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
xor    %edi,%edi
call   1100 <omp_set_dynamic@plt>
xor    %eax,%eax
call   11f0 <omp_get_dynamic@plt>
addsd  0x8(%rsp),%xmm0
ucomisd 0x1a8e(%rip),%xmm0
jne    1586 <main+0x2a6>
jnp    15ab <main+0x2cb>
lea    0x1aab(%rip),%rdi
lea    0x1ad0(%rip),%rdx
xor    %esi,%esi
mov    $0x3,%ecx
mov    $0x1,%al
call   10c0 <printf@plt>
lea    0x1aca(%rip),%rdi
jmp    15b2 <main+0x2d2>
lea    0x1ab7(%rip),%rdi
call   1070 <puts@plt>
xor    %eax,%eax
call   11c0 <omp_get_cancellation@plt>
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1080 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    15e7 <main+0x307>
xor    %eax,%eax
call   11c0 <omp_get_cancellation@plt>
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
xorpd  %xmm0,%xmm0
movsd  0x8(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jne    15f9 <main+0x319>
jnp    161f <main+0x33f>
movapd %xmm1,%xmm0
lea    0x1a34(%rip),%rdi
lea    0x1a59(%rip),%rdx
xor    %esi,%esi
xor    %ecx,%ecx
mov    $0x1,%al
call   10c0 <printf@plt>
lea    0x1a56(%rip),%rdi
jmp    1626 <main+0x346>
lea    0x1a43(%rip),%rdi
call   1070 <puts@plt>
xor    %eax,%eax
call   1110 <omp_get_nested@plt>
movsd  %xmm0,0x8(%rsp)
xor    %edi,%edi
call   1120 <omp_set_nested@plt>
xor    %eax,%eax
call   1110 <omp_get_nested@plt>
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1080 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    167c <main+0x39c>
xor    %eax,%eax
call   1110 <omp_get_nested@plt>
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
xor    %edi,%edi
call   1120 <omp_set_nested@plt>
xor    %eax,%eax
call   1110 <omp_get_nested@plt>
addsd  0x8(%rsp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1695 <main+0x3b5>
jnp    16b7 <main+0x3d7>
lea    0x199c(%rip),%rdi
lea    0x19c1(%rip),%rdx
xor    %esi,%esi
xor    %ecx,%ecx
mov    $0x1,%al
call   10c0 <printf@plt>
lea    0x19be(%rip),%rdi
jmp    16be <main+0x3de>
lea    0x19ab(%rip),%rdi
call   1070 <puts@plt>
mov    0x391e(%rip),%r13
mov    0x0(%r13),%edi
mov    0x38fb(%rip),%r12
mov    (%r12),%eax
add    %edi,%eax
mov    0x38fe(%rip),%r15
add    (%r15),%eax
lea    (%rdi,%rax,2),%r14d
add    $0x8b6,%r14d
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
movsd  %xmm0,0x20(%rsp)
mov    %edi,0x14(%rsp)
movl   $0xa,0x10(%rsp)
mov    $0xa,%esi
call   1090 <omp_set_schedule@plt>
movl   $0x0,0x14(%rsp)
movl   $0x0,0x10(%rsp)
lea    0x14(%rsp),%rbx
lea    0x10(%rsp),%rbp
mov    %rbx,%rdi
mov    %rbp,%rsi
call   1160 <omp_get_schedule@plt>
mov    0x10(%rsp),%eax
add    0x14(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x8(%rsp)
mov    (%r12),%edi
mov    %edi,0x14(%rsp)
movl   $0x64,0x10(%rsp)
mov    $0x64,%esi
call   1090 <omp_set_schedule@plt>
movl   $0x0,0x14(%rsp)
movl   $0x0,0x10(%rsp)
mov    %rbx,%rdi
mov    %rbp,%rsi
call   1160 <omp_get_schedule@plt>
mov    0x10(%rsp),%eax
add    0x14(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    (%r15),%edi
mov    %edi,0x14(%rsp)
movl   $0x3e8,0x10(%rsp)
mov    $0x3e8,%esi
call   1090 <omp_set_schedule@plt>
movl   $0x0,0x14(%rsp)
movl   $0x0,0x10(%rsp)
mov    %rbx,%rdi
mov    %rbp,%rsi
call   1160 <omp_get_schedule@plt>
mov    0x10(%rsp),%eax
add    0x14(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    0x0(%r13),%edi
mov    %edi,0x14(%rsp)
movl   $0xa,0x10(%rsp)
mov    $0xa,%esi
call   1090 <omp_set_schedule@plt>
xor    %eax,%eax
call   1080 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    1914 <main+0x634>
mov    0x0(%r13),%edi
mov    %edi,0x1c(%rsp)
movl   $0xa,0x18(%rsp)
mov    $0xa,%esi
call   1090 <omp_set_schedule@plt>
movl   $0x0,0x1c(%rsp)
movl   $0x0,0x18(%rsp)
lea    0x1c(%rsp),%rbx
lea    0x18(%rsp),%rbp
mov    %rbx,%rdi
mov    %rbp,%rsi
call   1160 <omp_get_schedule@plt>
mov    0x18(%rsp),%eax
add    0x1c(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
mov    (%r12),%edi
mov    %edi,0x1c(%rsp)
movl   $0x64,0x18(%rsp)
mov    $0x64,%esi
call   1090 <omp_set_schedule@plt>
movl   $0x0,0x1c(%rsp)
movl   $0x0,0x18(%rsp)
mov    %rbx,%rdi
mov    %rbp,%rsi
call   1160 <omp_get_schedule@plt>
mov    0x18(%rsp),%eax
add    0x1c(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    (%r15),%edi
mov    %edi,0x1c(%rsp)
movl   $0x3e8,0x18(%rsp)
mov    $0x3e8,%esi
call   1090 <omp_set_schedule@plt>
movl   $0x0,0x1c(%rsp)
movl   $0x0,0x18(%rsp)
mov    %rbx,%rdi
mov    %rbp,%rsi
call   1160 <omp_get_schedule@plt>
mov    0x18(%rsp),%eax
add    0x1c(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movl   $0x0,0x14(%rsp)
movl   $0x0,0x10(%rsp)
lea    0x14(%rsp),%rdi
lea    0x10(%rsp),%rsi
call   1160 <omp_get_schedule@plt>
mov    0x10(%rsp),%eax
add    0x14(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x8(%rsp),%xmm0
ucomisd 0x20(%rsp),%xmm0
jne    1952 <main+0x672>
jnp    1975 <main+0x695>
lea    0x16df(%rip),%rdi
lea    0x1704(%rip),%rdx
xor    %esi,%esi
mov    %r14d,%ecx
mov    $0x1,%al
call   10c0 <printf@plt>
lea    0x1700(%rip),%rdi
jmp    197c <main+0x69c>
lea    0x16ed(%rip),%rdi
call   1070 <puts@plt>
xor    %eax,%eax
call   10f0 <omp_get_thread_limit@plt>
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1080 <omp_get_thread_num@plt>
test   %eax,%eax
je     199f <main+0x6bf>
xorpd  %xmm0,%xmm0
jmp    19c6 <main+0x6e6>
xor    %eax,%eax
call   10f0 <omp_get_thread_limit@plt>
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
xor    %eax,%eax
call   10e0 <omp_get_num_threads@plt>
add    %eax,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x8(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jne    19d4 <main+0x6f4>
jnp    19f4 <main+0x714>
lea    0x165d(%rip),%rdi
lea    0x1682(%rip),%rdx
xor    %esi,%esi
mov    $0x2,%al
call   10c0 <printf@plt>
lea    0x1681(%rip),%rdi
jmp    19fb <main+0x71b>
lea    0x166e(%rip),%rdi
call   1070 <puts@plt>
mov    $0x1,%edi
call   1050 <omp_set_max_active_levels@plt>
xor    %eax,%eax
call   1060 <omp_get_max_active_levels@plt>
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1080 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    1a3a <main+0x75a>
xor    %eax,%eax
call   1060 <omp_get_max_active_levels@plt>
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x8(%rsp),%xmm0
ucomisd 0x15d0(%rip),%xmm0
jne    1a4c <main+0x76c>
jnp    1a71 <main+0x791>
lea    0x15e5(%rip),%rdi
lea    0x160a(%rip),%rdx
xor    %esi,%esi
mov    $0x2,%ecx
mov    $0x1,%al
call   10c0 <printf@plt>
lea    0x1604(%rip),%rdi
jmp    1a78 <main+0x798>
lea    0x15f1(%rip),%rdi
call   1070 <puts@plt>
xor    %eax,%eax
call   1140 <omp_get_level@plt>
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1080 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    1aad <main+0x7cd>
xor    %eax,%eax
call   1140 <omp_get_level@plt>
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x8(%rsp),%xmm0
ucomisd 0x154d(%rip),%xmm0
jne    1abf <main+0x7df>
jnp    1ae4 <main+0x804>
lea    0x1572(%rip),%rdi
lea    0x1597(%rip),%rdx
xor    %esi,%esi
mov    $0x1,%ecx
mov    $0x1,%al
call   10c0 <printf@plt>
lea    0x1591(%rip),%rdi
jmp    1aeb <main+0x80b>
lea    0x157e(%rip),%rdi
call   1070 <puts@plt>
xor    %edi,%edi
call   1040 <omp_get_ancestor_thread_num@plt>
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1080 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    1b36 <main+0x856>
xor    %edi,%edi
call   1040 <omp_get_ancestor_thread_num@plt>
movsd  %xmm0,0x20(%rsp)
mov    $0x1,%edi
call   1040 <omp_get_ancestor_thread_num@plt>
addsd  0x20(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x8(%rsp),%xmm0
ucomisd 0x14dc(%rip),%xmm0
jne    1b48 <main+0x868>
jnp    1b6d <main+0x88d>
lea    0x14e9(%rip),%rdi
lea    0x150e(%rip),%rdx
xor    %esi,%esi
mov    $0x12,%ecx
mov    $0x1,%al
call   10c0 <printf@plt>
lea    0x1508(%rip),%rdi
jmp    1b74 <main+0x894>
lea    0x14f5(%rip),%rdi
call   1070 <puts@plt>
xor    %edi,%edi
call   1170 <omp_get_team_size@plt>
movsd  %xmm0,0x8(%rsp)
mov    $0x1,%edi
call   1170 <omp_get_team_size@plt>
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1080 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    1bd5 <main+0x8f5>
xor    %edi,%edi
call   1170 <omp_get_team_size@plt>
movsd  %xmm0,0x20(%rsp)
mov    $0x1,%edi
call   1170 <omp_get_team_size@plt>
addsd  0x20(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
xor    %eax,%eax
call   1200 <omp_is_initial_device@plt>
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
lea    0x147e(%rip),%rdi
jne    1c24 <main+0x944>
jp     1c24 <main+0x944>
movsd  0x8(%rsp),%xmm0
ucomisd 0x142b(%rip),%xmm0
jne    1c01 <main+0x921>
jnp    1c24 <main+0x944>
lea    0x1430(%rip),%rdi
lea    0x1455(%rip),%rdx
xor    %esi,%esi
mov    $0x16,%ecx
mov    $0x1,%al
call   10c0 <printf@plt>
lea    0x144f(%rip),%rdi
call   1070 <puts@plt>
xor    %eax,%eax
call   11a0 <omp_get_active_level@plt>
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1080 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    1c59 <main+0x979>
xor    %eax,%eax
call   11a0 <omp_get_active_level@plt>
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x8(%rsp),%xmm0
ucomisd 0x13a1(%rip),%xmm0
jne    1c6b <main+0x98b>
jnp    1c90 <main+0x9b0>
lea    0x13c6(%rip),%rdi
lea    0x13eb(%rip),%rdx
xor    %esi,%esi
mov    $0x1,%ecx
mov    $0x1,%al
call   10c0 <printf@plt>
lea    0x13e5(%rip),%rdi
jmp    1c97 <main+0x9b7>
lea    0x13d2(%rip),%rdi
call   1070 <puts@plt>
xor    %eax,%eax
call   10b0 <omp_in_final@plt>
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1080 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    1ccc <main+0x9ec>
xor    %eax,%eax
call   10b0 <omp_in_final@plt>
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
xor    %eax,%eax
call   1200 <omp_is_initial_device@plt>
movsd  0x8(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jne    1ce1 <main+0xa01>
jnp    1cea <main+0xa0a>
lea    0x1381(%rip),%rdi
jmp    1d28 <main+0xa48>
xor    %eax,%eax
call   1200 <omp_is_initial_device@plt>
xorpd  %xmm1,%xmm1
cmpeqsd %xmm0,%xmm1
movq   %xmm1,%rcx
and    $0x1,%ecx
add    %ecx,%ecx
lea    0x132d(%rip),%rdi
lea    0x1352(%rip),%rdx
xor    %esi,%esi
movsd  0x8(%rsp),%xmm0
mov    $0x1,%al
call   10c0 <printf@plt>
lea    0x134b(%rip),%rdi
call   1070 <puts@plt>
xor    %eax,%eax
call   10a0 <omp_get_proc_bind@plt>
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1080 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    1d5d <main+0xa7d>
xor    %eax,%eax
call   10a0 <omp_get_proc_bind@plt>
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
xor    %eax,%eax
call   1200 <omp_is_initial_device@plt>
movsd  0x8(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jne    1d72 <main+0xa92>
jnp    1d7b <main+0xa9b>
lea    0x12f0(%rip),%rdi
jmp    1db9 <main+0xad9>
xor    %eax,%eax
call   1200 <omp_is_initial_device@plt>
xorpd  %xmm1,%xmm1
cmpeqsd %xmm0,%xmm1
movq   %xmm1,%rcx
and    $0x1,%ecx
add    %ecx,%ecx
lea    0x129c(%rip),%rdi
lea    0x12c1(%rip),%rdx
xor    %esi,%esi
movsd  0x8(%rsp),%xmm0
mov    $0x1,%al
call   10c0 <printf@plt>
lea    0x12ba(%rip),%rdi
call   1070 <puts@plt>
xor    %edi,%edi
call   1150 <omp_set_default_device@plt>
xor    %eax,%eax
call   10d0 <omp_get_default_device@plt>
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1080 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    1df5 <main+0xb15>
xor    %eax,%eax
call   10d0 <omp_get_default_device@plt>
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
xorpd  %xmm0,%xmm0
movsd  0x8(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jne    1e07 <main+0xb27>
jnp    1e2d <main+0xb4d>
movapd %xmm1,%xmm0
lea    0x1226(%rip),%rdi
lea    0x124b(%rip),%rdx
xor    %esi,%esi
xor    %ecx,%ecx
mov    $0x1,%al
call   10c0 <printf@plt>
lea    0x1248(%rip),%rdi
jmp    1e34 <main+0xb54>
lea    0x1235(%rip),%rdi
call   1070 <puts@plt>
xor    %eax,%eax
call   11b0 <omp_get_num_devices@plt>
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1080 <omp_get_thread_num@plt>
cmp    $0x12,%eax
xorpd  %xmm2,%xmm2
jne    1e61 <main+0xb81>
xor    %eax,%eax
call   11b0 <omp_get_num_devices@plt>
movapd %xmm0,%xmm2
movsd  0x8(%rsp),%xmm1
movapd %xmm1,%xmm0
subsd  %xmm2,%xmm0
ucomisd %xmm0,%xmm1
jne    1e77 <main+0xb97>
jnp    1e97 <main+0xbb7>
lea    0x11ba(%rip),%rdi
lea    0x11df(%rip),%rdx
xor    %esi,%esi
mov    $0x2,%al
call   10c0 <printf@plt>
lea    0x11de(%rip),%rdi
jmp    1e9e <main+0xbbe>
lea    0x11cb(%rip),%rdi
call   1070 <puts@plt>
xor    %eax,%eax
call   11e0 <omp_get_num_teams@plt>
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   11d0 <omp_get_team_num@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1080 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    1f01 <main+0xc21>
xor    %eax,%eax
call   11e0 <omp_get_num_teams@plt>
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   11d0 <omp_get_team_num@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
jmp    1f07 <main+0xc27>
movsd  0x8(%rsp),%xmm0
ucomisd 0x1109(%rip),%xmm0
jne    1f13 <main+0xc33>
jnp    1f38 <main+0xc58>
lea    0x111e(%rip),%rdi
lea    0x1143(%rip),%rdx
xor    %esi,%esi
mov    $0x2,%ecx
mov    $0x1,%al
call   10c0 <printf@plt>
lea    0x113d(%rip),%rdi
jmp    1f3f <main+0xc5f>
lea    0x112a(%rip),%rdi
call   1070 <puts@plt>
xor    %eax,%eax
call   1200 <omp_is_initial_device@plt>
movapd %xmm0,0x20(%rsp)
xor    %eax,%eax
call   1200 <omp_is_initial_device@plt>
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1080 <omp_get_thread_num@plt>
cmp    $0x12,%eax
jne    1f81 <main+0xca1>
xor    %eax,%eax
call   1200 <omp_is_initial_device@plt>
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
xor    %eax,%eax
call   1200 <omp_is_initial_device@plt>
movsd  0x8(%rsp),%xmm1
ucomisd %xmm0,%xmm1
movapd 0x20(%rsp),%xmm2
subsd  %xmm2,%xmm2
jne    1fa0 <main+0xcc0>
jnp    1fb5 <main+0xcd5>
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm2
jne    1fb5 <main+0xcd5>
jp     1fb5 <main+0xcd5>
lea    0x10b6(%rip),%rdi
jmp    200f <main+0xd2f>
xor    %eax,%eax
movsd  %xmm1,0x8(%rsp)
movapd %xmm2,0x20(%rsp)
call   1200 <omp_is_initial_device@plt>
xorpd  %xmm1,%xmm1
cmpneqsd %xmm1,%xmm0
movapd 0x20(%rsp),%xmm2
andpd  %xmm0,%xmm2
movsd  0x1035(%rip),%xmm1
andnpd %xmm1,%xmm0
orpd   %xmm2,%xmm0
lea    0x1046(%rip),%rdi
lea    0x106b(%rip),%rdx
xor    %esi,%esi
movsd  0x8(%rsp),%xmm1
mov    $0x2,%al
call   10c0 <printf@plt>
lea    0x1064(%rip),%rdi
call   1070 <puts@plt>
xor    %eax,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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