#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 /*<<< orphan*/ FILE;

/* Variables and functions */
int INT32_MAX;
int atoi(char *);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
scalar_t__ fgets(char *, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ free(int *);
int /*<<< orphan*/ get_ordered_corelist_error_message(char *, int);
int /*<<< orphan*/ *getenv(char *);
scalar_t__ malloc(int);
int /*<<< orphan*/ rewind(int /*<<< orphan*/ *);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ strncasecmp(char *, char *, int);
char *strtok(char *, char *);
void Get_Ordered_Corelist(int *list, int total_cores) {
  FILE *fp;
  char buf[256], *data;
  int proc_id, proc_done = 0, tmp_id, list_id;
  int core_id = -1, socket_id = -1;
  int siblings = 0, cores = 0;
  int min_socket_id = INT32_MAX, max_core_id = -1;
  int i, *thread_count;
  if (total_cores == 1) {
    list[0] = 0;
    goto done;
  }
  thread_count = (int *)malloc(sizeof(int) * total_cores);
  for (i = 0; i < total_cores; i++) {
    list[i] = -1;
    thread_count[i] = 0;
  }
  if ((fp = fopen("/proc/cpuinfo", "r")) == NULL) {
    get_ordered_corelist_error_message(
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/pumpkin83/OpenUH-OpenACC/refs/heads/master/"
        "osprey/libopenmp-pcl/omp_util.c",
        226);
    for (i = 0; i < total_cores; i++)
      list[i] = i;
    if (fp != NULL)
      fclose(fp);
    free(thread_count);
    return;
  };
  while (fgets(buf, 256, fp)) {
    int num;
    if (!strncasecmp(buf, "physical id", 11)) {
      strtok(buf, ":");
      data = strtok(NULL, "\n");
      num = atoi(data);
      if (num < min_socket_id)
        min_socket_id = num;
    } else if (!strncasecmp(buf, "siblings", 8)) {
      strtok(buf, ":");
      data = strtok(NULL, "\n");
      num = atoi(data);
      if (siblings == 0)
        siblings = num;
      if (siblings != num) {
        get_ordered_corelist_error_message(
            "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
            "2022-01-22/02-19-57/repos/pumpkin83/OpenUH-OpenACC/refs/heads/"
            "master/osprey/libopenmp-pcl/omp_util.c",
            246);
        for (i = 0; i < total_cores; i++)
          list[i] = i;
        if (fp != NULL)
          fclose(fp);
        free(thread_count);
        return;
      };
    } else if (!strncasecmp(buf, "core id", 7)) {
      strtok(buf, ":");
      data = strtok(NULL, "\n");
      num = atoi(data);
      if (max_core_id < num)
        max_core_id = num;
    } else if (!strncasecmp(buf, "cpu cores", 9)) {
      strtok(buf, ":");
      data = strtok(NULL, "\n");
      num = atoi(data);
      if (cores == 0)
        cores = num;
      if (cores != num) {
        get_ordered_corelist_error_message(
            "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
            "2022-01-22/02-19-57/repos/pumpkin83/OpenUH-OpenACC/refs/heads/"
            "master/osprey/libopenmp-pcl/omp_util.c",
            262);
        for (i = 0; i < total_cores; i++)
          list[i] = i;
        if (fp != NULL)
          fclose(fp);
        free(thread_count);
        return;
      };
    }
  }
  if (cores <= 0 || cores > total_cores || siblings <= 0 ||
      siblings > total_cores) {
    get_ordered_corelist_error_message(
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/pumpkin83/OpenUH-OpenACC/refs/heads/master/"
        "osprey/libopenmp-pcl/omp_util.c",
        269);
    for (i = 0; i < total_cores; i++)
      list[i] = i;
    if (fp != NULL)
      fclose(fp);
    free(thread_count);
    return;
  };
  if (max_core_id + 1 != cores) {
    int cores_per_die = max_core_id + 1;
    if (cores_per_die <= 0 || cores_per_die > cores) {
      get_ordered_corelist_error_message(
          "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
          "2022-01-22/02-19-57/repos/pumpkin83/OpenUH-OpenACC/refs/heads/"
          "master/osprey/libopenmp-pcl/omp_util.c",
          277);
      for (i = 0; i < total_cores; i++)
        list[i] = i;
      if (fp != NULL)
        fclose(fp);
      free(thread_count);
      return;
    };
    cores = cores_per_die;
  }
  rewind(fp);
  while (fgets(buf, 256, fp)) {
    if (!strncasecmp(buf, "processor", 9)) {
      strtok(buf, ":");
      data = strtok(NULL, "\n");
      proc_id = atoi(data);
      if (proc_id >= total_cores) {
        get_ordered_corelist_error_message(
            "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
            "2022-01-22/02-19-57/repos/pumpkin83/OpenUH-OpenACC/refs/heads/"
            "master/osprey/libopenmp-pcl/omp_util.c",
            290);
        for (i = 0; i < total_cores; i++)
          list[i] = i;
        if (fp != NULL)
          fclose(fp);
        free(thread_count);
        return;
      };
      while (fgets(buf, 256, fp)) {
        if (!strncasecmp(buf, "physical id", 11)) {
          strtok(buf, ":");
          data = strtok(NULL, "\n");
          socket_id = atoi(data) - min_socket_id;
        }
        if (!strncasecmp(buf, "core id", 7)) {
          strtok(buf, ":");
          data = strtok(NULL, "\n");
          core_id = atoi(data);
        }
        if ((socket_id >= 0) && (core_id >= 0)) {
          tmp_id = socket_id * siblings + core_id;
          list_id = tmp_id + thread_count[tmp_id] * cores;
          if (list_id >= total_cores) {
            get_ordered_corelist_error_message(
                "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/"
                "outputs/2022-01-22/02-19-57/repos/pumpkin83/OpenUH-OpenACC/"
                "refs/heads/master/osprey/libopenmp-pcl/omp_util.c",
                323);
            for (i = 0; i < total_cores; i++)
              list[i] = i;
            if (fp != NULL)
              fclose(fp);
            free(thread_count);
            return;
          };
          if (list[list_id] >= 0) {
            get_ordered_corelist_error_message(
                "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/"
                "outputs/2022-01-22/02-19-57/repos/pumpkin83/OpenUH-OpenACC/"
                "refs/heads/master/osprey/libopenmp-pcl/omp_util.c",
                325);
            for (i = 0; i < total_cores; i++)
              list[i] = i;
            if (fp != NULL)
              fclose(fp);
            free(thread_count);
            return;
          };
          list[list_id] = proc_id;
          thread_count[tmp_id] = thread_count[tmp_id] + 1;
          if (thread_count[tmp_id] > siblings / cores) {
            get_ordered_corelist_error_message(
                "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/"
                "outputs/2022-01-22/02-19-57/repos/pumpkin83/OpenUH-OpenACC/"
                "refs/heads/master/osprey/libopenmp-pcl/omp_util.c",
                337);
            for (i = 0; i < total_cores; i++)
              list[i] = i;
            if (fp != NULL)
              fclose(fp);
            free(thread_count);
            return;
          };
          socket_id = -1;
          core_id = -1;
          proc_done++;
          break;
        }
      }
    }
  }
  if (proc_done != total_cores) {
    get_ordered_corelist_error_message(
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/pumpkin83/OpenUH-OpenACC/refs/heads/master/"
        "osprey/libopenmp-pcl/omp_util.c",
        348);
    for (i = 0; i < total_cores; i++)
      list[i] = i;
    if (fp != NULL)
      fclose(fp);
    free(thread_count);
    return;
  };
  fclose(fp);
  free(thread_count);
done:
  if (getenv("O64_OMP_VERBOSE") != NULL) {
    fprintf(stderr, "Get_Ordered_Corelist: affinity map: ");
    for (i = 0; i < total_cores; i++) {
      fprintf(stderr, "%s%d", i > 0 ? "," : "", list[i]);
    }
    fprintf(stderr, "\n");
  }
}


x86 assembly (clang, -O0):
<Get_Ordered_Corelist>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x130(%rbp)
movl   $0xffffffff,-0x13c(%rbp)
ff ff ff
movl   $0xffffffff,-0x140(%rbp)
ff ff ff
movl   $0x0,-0x144(%rbp)
movl   $0x0,-0x148(%rbp)
mov    0x2dcd(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x14c(%rbp)
movl   $0xffffffff,-0x150(%rbp)
ff ff ff
cmpl   $0x1,-0xc(%rbp)
jne    1236 <Get_Ordered_Corelist+0x76>
mov    -0x8(%rbp),%rax
movl   $0x0,(%rax)
jmp    1cfd <Get_Ordered_Corelist+0xb3d>
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x160(%rbp)
movl   $0x0,-0x154(%rbp)
mov    -0x154(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12a0 <Get_Ordered_Corelist+0xe0>
mov    -0x8(%rbp),%rax
movslq -0x154(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x160(%rbp),%rax
movslq -0x154(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    1256 <Get_Ordered_Corelist+0x96>
lea    0xd59(%rip),%rdi
lea    0xe38(%rip),%rsi
call   10c0 <fopen@plt>
mov    %rax,-0x18(%rbp)
cmp    $0x0,%rax
jne    1338 <Get_Ordered_Corelist+0x178>
lea    0xd46(%rip),%rdi
mov    $0xe2,%esi
call   1050 <get_ordered_corelist_error_message@plt>
movl   $0x0,-0x154(%rbp)
mov    -0x154(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1313 <Get_Ordered_Corelist+0x153>
mov    -0x154(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x154(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    12dc <Get_Ordered_Corelist+0x11c>
cmpq   $0x0,-0x18(%rbp)
je     1327 <Get_Ordered_Corelist+0x167>
mov    -0x18(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0x160(%rbp),%rdi
call   1040 <free@plt>
jmp    1dae <Get_Ordered_Corelist+0xbee>
jmp    133d <Get_Ordered_Corelist+0x17d>
lea    -0x120(%rbp),%rdi
mov    -0x18(%rbp),%rdx
mov    $0x100,%esi
call   1080 <fgets@plt>
cmp    $0x0,%rax
je     1678 <Get_Ordered_Corelist+0x4b8>
lea    -0x120(%rbp),%rdi
lea    0xd49(%rip),%rsi
mov    $0xb,%edx
call   10b0 <strncasecmp@plt>
cmp    $0x0,%eax
jne    13dc <Get_Ordered_Corelist+0x21c>
lea    -0x120(%rbp),%rdi
lea    0xd34(%rip),%rsi
call   10d0 <strtok@plt>
xor    %eax,%eax
mov    %eax,%edi
lea    0xd26(%rip),%rsi
call   10d0 <strtok@plt>
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rdi
call   10e0 <atoi@plt>
mov    %eax,-0x164(%rbp)
mov    -0x164(%rbp),%eax
cmp    -0x14c(%rbp),%eax
jge    13d7 <Get_Ordered_Corelist+0x217>
mov    -0x164(%rbp),%eax
mov    %eax,-0x14c(%rbp)
jmp    1673 <Get_Ordered_Corelist+0x4b3>
lea    -0x120(%rbp),%rdi
lea    0xcd9(%rip),%rsi
mov    $0x8,%edx
call   10b0 <strncasecmp@plt>
cmp    $0x0,%eax
jne    14e0 <Get_Ordered_Corelist+0x320>
lea    -0x120(%rbp),%rdi
lea    0xcb4(%rip),%rsi
call   10d0 <strtok@plt>
xor    %eax,%eax
mov    %eax,%edi
lea    0xca6(%rip),%rsi
call   10d0 <strtok@plt>
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rdi
call   10e0 <atoi@plt>
mov    %eax,-0x164(%rbp)
cmpl   $0x0,-0x144(%rbp)
jne    1452 <Get_Ordered_Corelist+0x292>
mov    -0x164(%rbp),%eax
mov    %eax,-0x144(%rbp)
mov    -0x144(%rbp),%eax
cmp    -0x164(%rbp),%eax
je     14db <Get_Ordered_Corelist+0x31b>
lea    0xba3(%rip),%rdi
mov    $0xf6,%esi
call   1050 <get_ordered_corelist_error_message@plt>
movl   $0x0,-0x154(%rbp)
mov    -0x154(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14b6 <Get_Ordered_Corelist+0x2f6>
mov    -0x154(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x154(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    147f <Get_Ordered_Corelist+0x2bf>
cmpq   $0x0,-0x18(%rbp)
je     14ca <Get_Ordered_Corelist+0x30a>
mov    -0x18(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0x160(%rbp),%rdi
call   1040 <free@plt>
jmp    1dae <Get_Ordered_Corelist+0xbee>
jmp    166e <Get_Ordered_Corelist+0x4ae>
lea    -0x120(%rbp),%rdi
lea    0xbde(%rip),%rsi
mov    $0x7,%edx
call   10b0 <strncasecmp@plt>
cmp    $0x0,%eax
jne    1560 <Get_Ordered_Corelist+0x3a0>
lea    -0x120(%rbp),%rdi
lea    0xbb0(%rip),%rsi
call   10d0 <strtok@plt>
xor    %eax,%eax
mov    %eax,%edi
lea    0xba2(%rip),%rsi
call   10d0 <strtok@plt>
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rdi
call   10e0 <atoi@plt>
mov    %eax,-0x164(%rbp)
mov    -0x150(%rbp),%eax
cmp    -0x164(%rbp),%eax
jge    155b <Get_Ordered_Corelist+0x39b>
mov    -0x164(%rbp),%eax
mov    %eax,-0x150(%rbp)
jmp    1669 <Get_Ordered_Corelist+0x4a9>
lea    -0x120(%rbp),%rdi
lea    0xb66(%rip),%rsi
mov    $0x9,%edx
call   10b0 <strncasecmp@plt>
cmp    $0x0,%eax
jne    1664 <Get_Ordered_Corelist+0x4a4>
lea    -0x120(%rbp),%rdi
lea    0xb30(%rip),%rsi
call   10d0 <strtok@plt>
xor    %eax,%eax
mov    %eax,%edi
lea    0xb22(%rip),%rsi
call   10d0 <strtok@plt>
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rdi
call   10e0 <atoi@plt>
mov    %eax,-0x164(%rbp)
cmpl   $0x0,-0x148(%rbp)
jne    15d6 <Get_Ordered_Corelist+0x416>
mov    -0x164(%rbp),%eax
mov    %eax,-0x148(%rbp)
mov    -0x148(%rbp),%eax
cmp    -0x164(%rbp),%eax
je     165f <Get_Ordered_Corelist+0x49f>
lea    0xa1f(%rip),%rdi
mov    $0x106,%esi
call   1050 <get_ordered_corelist_error_message@plt>
movl   $0x0,-0x154(%rbp)
mov    -0x154(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    163a <Get_Ordered_Corelist+0x47a>
mov    -0x154(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x154(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    1603 <Get_Ordered_Corelist+0x443>
cmpq   $0x0,-0x18(%rbp)
je     164e <Get_Ordered_Corelist+0x48e>
mov    -0x18(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0x160(%rbp),%rdi
call   1040 <free@plt>
jmp    1dae <Get_Ordered_Corelist+0xbee>
jmp    1664 <Get_Ordered_Corelist+0x4a4>
jmp    1669 <Get_Ordered_Corelist+0x4a9>
jmp    166e <Get_Ordered_Corelist+0x4ae>
jmp    1673 <Get_Ordered_Corelist+0x4b3>
jmp    133d <Get_Ordered_Corelist+0x17d>
cmpl   $0x0,-0x148(%rbp)
jle    16b0 <Get_Ordered_Corelist+0x4f0>
mov    -0x148(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     16b0 <Get_Ordered_Corelist+0x4f0>
cmpl   $0x0,-0x144(%rbp)
jle    16b0 <Get_Ordered_Corelist+0x4f0>
mov    -0x144(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    1727 <Get_Ordered_Corelist+0x567>
lea    0x957(%rip),%rdi
mov    $0x10d,%esi
call   1050 <get_ordered_corelist_error_message@plt>
movl   $0x0,-0x154(%rbp)
mov    -0x154(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1702 <Get_Ordered_Corelist+0x542>
mov    -0x154(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x154(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    16cb <Get_Ordered_Corelist+0x50b>
cmpq   $0x0,-0x18(%rbp)
je     1716 <Get_Ordered_Corelist+0x556>
mov    -0x18(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0x160(%rbp),%rdi
call   1040 <free@plt>
jmp    1dae <Get_Ordered_Corelist+0xbee>
mov    -0x150(%rbp),%eax
add    $0x1,%eax
cmp    -0x148(%rbp),%eax
je     17ed <Get_Ordered_Corelist+0x62d>
mov    -0x150(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x168(%rbp)
cmpl   $0x0,-0x168(%rbp)
jle    176a <Get_Ordered_Corelist+0x5aa>
mov    -0x168(%rbp),%eax
cmp    -0x148(%rbp),%eax
jle    17e1 <Get_Ordered_Corelist+0x621>
lea    0x89d(%rip),%rdi
mov    $0x115,%esi
call   1050 <get_ordered_corelist_error_message@plt>
movl   $0x0,-0x154(%rbp)
mov    -0x154(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    17bc <Get_Ordered_Corelist+0x5fc>
mov    -0x154(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x154(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    1785 <Get_Ordered_Corelist+0x5c5>
cmpq   $0x0,-0x18(%rbp)
je     17d0 <Get_Ordered_Corelist+0x610>
mov    -0x18(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0x160(%rbp),%rdi
call   1040 <free@plt>
jmp    1dae <Get_Ordered_Corelist+0xbee>
mov    -0x168(%rbp),%eax
mov    %eax,-0x148(%rbp)
mov    -0x18(%rbp),%rdi
call   1070 <rewind@plt>
lea    -0x120(%rbp),%rdi
mov    -0x18(%rbp),%rdx
mov    $0x100,%esi
call   1080 <fgets@plt>
cmp    $0x0,%rax
je     1c62 <Get_Ordered_Corelist+0xaa2>
lea    -0x120(%rbp),%rdi
lea    0x8bb(%rip),%rsi
mov    $0x9,%edx
call   10b0 <strncasecmp@plt>
cmp    $0x0,%eax
jne    1c5d <Get_Ordered_Corelist+0xa9d>
lea    -0x120(%rbp),%rdi
lea    0x87b(%rip),%rsi
call   10d0 <strtok@plt>
xor    %eax,%eax
mov    %eax,%edi
lea    0x86d(%rip),%rsi
call   10d0 <strtok@plt>
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rdi
call   10e0 <atoi@plt>
mov    %eax,-0x12c(%rbp)
mov    -0x12c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     18f8 <Get_Ordered_Corelist+0x738>
lea    0x786(%rip),%rdi
mov    $0x122,%esi
call   1050 <get_ordered_corelist_error_message@plt>
movl   $0x0,-0x154(%rbp)
mov    -0x154(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    18d3 <Get_Ordered_Corelist+0x713>
mov    -0x154(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x154(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    189c <Get_Ordered_Corelist+0x6dc>
cmpq   $0x0,-0x18(%rbp)
je     18e7 <Get_Ordered_Corelist+0x727>
mov    -0x18(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0x160(%rbp),%rdi
call   1040 <free@plt>
jmp    1dae <Get_Ordered_Corelist+0xbee>
jmp    18fd <Get_Ordered_Corelist+0x73d>
lea    -0x120(%rbp),%rdi
mov    -0x18(%rbp),%rdx
mov    $0x100,%esi
call   1080 <fgets@plt>
cmp    $0x0,%rax
je     1c58 <Get_Ordered_Corelist+0xa98>
lea    -0x120(%rbp),%rdi
lea    0x789(%rip),%rsi
mov    $0xb,%edx
call   10b0 <strncasecmp@plt>
cmp    $0x0,%eax
jne    197f <Get_Ordered_Corelist+0x7bf>
lea    -0x120(%rbp),%rdi
lea    0x774(%rip),%rsi
call   10d0 <strtok@plt>
xor    %eax,%eax
mov    %eax,%edi
lea    0x766(%rip),%rsi
call   10d0 <strtok@plt>
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rdi
call   10e0 <atoi@plt>
sub    -0x14c(%rbp),%eax
mov    %eax,-0x140(%rbp)
lea    -0x120(%rbp),%rdi
lea    0x73f(%rip),%rsi
mov    $0x7,%edx
call   10b0 <strncasecmp@plt>
cmp    $0x0,%eax
jne    19dc <Get_Ordered_Corelist+0x81c>
lea    -0x120(%rbp),%rdi
lea    0x711(%rip),%rsi
call   10d0 <strtok@plt>
xor    %eax,%eax
mov    %eax,%edi
lea    0x703(%rip),%rsi
call   10d0 <strtok@plt>
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rdi
call   10e0 <atoi@plt>
mov    %eax,-0x13c(%rbp)
cmpl   $0x0,-0x140(%rbp)
jl     1c53 <Get_Ordered_Corelist+0xa93>
cmpl   $0x0,-0x13c(%rbp)
jl     1c53 <Get_Ordered_Corelist+0xa93>
mov    -0x140(%rbp),%eax
imul   -0x144(%rbp),%eax
add    -0x13c(%rbp),%eax
mov    %eax,-0x134(%rbp)
mov    -0x134(%rbp),%eax
mov    -0x160(%rbp),%rcx
movslq -0x134(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
imul   -0x148(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x138(%rbp)
mov    -0x138(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1abb <Get_Ordered_Corelist+0x8fb>
lea    0x5c3(%rip),%rdi
mov    $0x143,%esi
call   1050 <get_ordered_corelist_error_message@plt>
movl   $0x0,-0x154(%rbp)
mov    -0x154(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a96 <Get_Ordered_Corelist+0x8d6>
mov    -0x154(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x154(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    1a5f <Get_Ordered_Corelist+0x89f>
cmpq   $0x0,-0x18(%rbp)
je     1aaa <Get_Ordered_Corelist+0x8ea>
mov    -0x18(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0x160(%rbp),%rdi
call   1040 <free@plt>
jmp    1dae <Get_Ordered_Corelist+0xbee>
mov    -0x8(%rbp),%rax
movslq -0x138(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jl     1b47 <Get_Ordered_Corelist+0x987>
lea    0x537(%rip),%rdi
mov    $0x145,%esi
call   1050 <get_ordered_corelist_error_message@plt>
movl   $0x0,-0x154(%rbp)
mov    -0x154(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1b22 <Get_Ordered_Corelist+0x962>
mov    -0x154(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x154(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    1aeb <Get_Ordered_Corelist+0x92b>
cmpq   $0x0,-0x18(%rbp)
je     1b36 <Get_Ordered_Corelist+0x976>
mov    -0x18(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0x160(%rbp),%rdi
call   1040 <free@plt>
jmp    1dae <Get_Ordered_Corelist+0xbee>
mov    -0x12c(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x138(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x160(%rbp),%rax
movslq -0x134(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x160(%rbp),%rax
movslq -0x134(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x160(%rbp),%rax
movslq -0x134(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x16c(%rbp)
mov    -0x144(%rbp),%eax
cltd
idivl  -0x148(%rbp)
mov    %eax,%ecx
mov    -0x16c(%rbp),%eax
cmp    %ecx,%eax
jle    1c2b <Get_Ordered_Corelist+0xa6b>
lea    0x453(%rip),%rdi
mov    $0x151,%esi
call   1050 <get_ordered_corelist_error_message@plt>
movl   $0x0,-0x154(%rbp)
mov    -0x154(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1c06 <Get_Ordered_Corelist+0xa46>
mov    -0x154(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x154(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    1bcf <Get_Ordered_Corelist+0xa0f>
cmpq   $0x0,-0x18(%rbp)
je     1c1a <Get_Ordered_Corelist+0xa5a>
mov    -0x18(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0x160(%rbp),%rdi
call   1040 <free@plt>
jmp    1dae <Get_Ordered_Corelist+0xbee>
movl   $0xffffffff,-0x140(%rbp)
ff ff ff
movl   $0xffffffff,-0x13c(%rbp)
ff ff ff
mov    -0x130(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x130(%rbp)
jmp    1c58 <Get_Ordered_Corelist+0xa98>
jmp    18fd <Get_Ordered_Corelist+0x73d>
jmp    1c5d <Get_Ordered_Corelist+0xa9d>
jmp    17f6 <Get_Ordered_Corelist+0x636>
mov    -0x130(%rbp),%eax
cmp    -0xc(%rbp),%eax
je     1ce8 <Get_Ordered_Corelist+0xb28>
lea    0x396(%rip),%rdi
mov    $0x15c,%esi
call   1050 <get_ordered_corelist_error_message@plt>
movl   $0x0,-0x154(%rbp)
mov    -0x154(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1cc3 <Get_Ordered_Corelist+0xb03>
mov    -0x154(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x154(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    1c8c <Get_Ordered_Corelist+0xacc>
cmpq   $0x0,-0x18(%rbp)
je     1cd7 <Get_Ordered_Corelist+0xb17>
mov    -0x18(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0x160(%rbp),%rdi
call   1040 <free@plt>
jmp    1dae <Get_Ordered_Corelist+0xbee>
mov    -0x18(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0x160(%rbp),%rdi
call   1040 <free@plt>
lea    0x3e4(%rip),%rdi
call   1030 <getenv@plt>
cmp    $0x0,%rax
je     1dae <Get_Ordered_Corelist+0xbee>
mov    0x22c6(%rip),%rax
mov    (%rax),%edi
lea    0x3d5(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x0,-0x154(%rbp)
mov    -0x154(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1d97 <Get_Ordered_Corelist+0xbd7>
mov    0x2296(%rip),%rax
mov    (%rax),%edi
mov    -0x154(%rbp),%ecx
lea    0x369(%rip),%rdx
lea    0x3c2(%rip),%rax
cmp    $0x0,%ecx
cmovg  %rax,%rdx
mov    -0x8(%rbp),%rax
movslq -0x154(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
lea    0x3a1(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    1d34 <Get_Ordered_Corelist+0xb74>
mov    0x2242(%rip),%rax
mov    (%rax),%edi
lea    0x31a(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
add    $0x170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Get_Ordered_Corelist>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
mov    %esi,%r13d
mov    %rdi,%rbx
cmp    $0x1,%esi
jne    1286 <Get_Ordered_Corelist+0xc6>
movl   $0x0,(%rbx)
lea    0x1f8b(%rip),%rdi
call   1030 <getenv@plt>
test   %rax,%rax
je     189c <Get_Ordered_Corelist+0x6dc>
mov    0x3dde(%rip),%rax
mov    (%rax),%edi
lea    0x1f7d(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
test   %r13d,%r13d
jle    126a <Get_Ordered_Corelist+0xaa>
mov    %rbx,%r15
mov    %r13d,%ebx
lea    0x1f2e(%rip),%r12
lea    0x1f87(%rip),%r13
lea    0x1f7b(%rip),%rbp
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x3d99(%rip),%rax
mov    (%rax),%edi
test   %r14,%r14
mov    %r13,%rdx
cmove  %r12,%rdx
mov    (%r15,%r14,4),%ecx
mov    %rbp,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
add    $0x1,%r14
cmp    %r14,%rbx
jne    1240 <Get_Ordered_Corelist+0x80>
mov    0x3d6f(%rip),%rax
mov    (%rax),%edi
lea    0x1ed7(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
jmp    189c <Get_Ordered_Corelist+0x6dc>
mov    0x3d4b(%rip),%rax
mov    (%rax),%eax
mov    %eax,0x14(%rsp)
lea    0x0(,%r13,4),%edi
call   10a0 <malloc@plt>
mov    %rax,%r14
test   %r13d,%r13d
jle    1478 <Get_Ordered_Corelist+0x2b8>
mov    %r13d,%eax
cmp    $0x8,%r13d
jb     12cf <Get_Ordered_Corelist+0x10f>
lea    (%r14,%rax,4),%rcx
cmp    %rbx,%rcx
jbe    1370 <Get_Ordered_Corelist+0x1b0>
lea    (%rbx,%rax,4),%rcx
cmp    %rcx,%r14
jae    1370 <Get_Ordered_Corelist+0x1b0>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     1309 <Get_Ordered_Corelist+0x149>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movl   $0xffffffff,(%rbx,%rcx,4)
movl   $0x0,(%r14,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    12f0 <Get_Ordered_Corelist+0x130>
cmp    $0x3,%rdx
jb     1478 <Get_Ordered_Corelist+0x2b8>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movl   $0xffffffff,(%rbx,%rcx,4)
movl   $0x0,(%r14,%rcx,4)
movl   $0xffffffff,0x4(%rbx,%rcx,4)
ff
movl   $0x0,0x4(%r14,%rcx,4)
movl   $0xffffffff,0x8(%rbx,%rcx,4)
ff
movl   $0x0,0x8(%r14,%rcx,4)
movl   $0xffffffff,0xc(%rbx,%rcx,4)
ff
movl   $0x0,0xc(%r14,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1320 <Get_Ordered_Corelist+0x160>
jmp    1478 <Get_Ordered_Corelist+0x2b8>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    1396 <Get_Ordered_Corelist+0x1d6>
xor    %edi,%edi
jmp    1420 <Get_Ordered_Corelist+0x260>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
pcmpeqd %xmm0,%xmm0
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu %xmm0,(%rbx,%rdi,4)
movdqu %xmm0,0x10(%rbx,%rdi,4)
movdqu %xmm1,(%r14,%rdi,4)
movdqu %xmm1,0x10(%r14,%rdi,4)
movdqu %xmm0,0x20(%rbx,%rdi,4)
movdqu %xmm0,0x30(%rbx,%rdi,4)
movdqu %xmm1,0x20(%r14,%rdi,4)
movdqu %xmm1,0x30(%r14,%rdi,4)
movdqu %xmm0,0x40(%rbx,%rdi,4)
movdqu %xmm0,0x50(%rbx,%rdi,4)
movdqu %xmm1,0x40(%r14,%rdi,4)
movdqu %xmm1,0x50(%r14,%rdi,4)
movdqu %xmm0,0x60(%rbx,%rdi,4)
movdqu %xmm0,0x70(%rbx,%rdi,4)
movdqu %xmm1,0x60(%r14,%rdi,4)
movdqu %xmm1,0x70(%r14,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    13b0 <Get_Ordered_Corelist+0x1f0>
test   %rdx,%rdx
je     146f <Get_Ordered_Corelist+0x2af>
lea    (%r14,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%rbx,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
pcmpeqd %xmm0,%xmm0
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu %xmm0,-0x10(%rdi,%rbp,1)
movdqu %xmm0,(%rdi,%rbp,1)
movdqu %xmm1,-0x10(%rsi,%rbp,1)
movdqu %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1450 <Get_Ordered_Corelist+0x290>
cmp    %rax,%rcx
jne    12d1 <Get_Ordered_Corelist+0x111>
lea    0x1c11(%rip),%rdi
lea    0x1cf0(%rip),%rsi
call   10c0 <fopen@plt>
test   %rax,%rax
je     163c <Get_Ordered_Corelist+0x47c>
mov    %rax,%r15
lea    0x30(%rsp),%rdi
mov    $0x100,%esi
mov    %rax,%rdx
call   1080 <fgets@plt>
test   %rax,%rax
je     169f <Get_Ordered_Corelist+0x4df>
mov    %r13,0x8(%rsp)
mov    %r15,(%rsp)
xor    %r12d,%r12d
mov    $0xffffffff,%eax
mov    %rax,0x18(%rsp)
lea    0x1c74(%rip),%r13
lea    0x30(%rsp),%r15
xor    %ebp,%ebp
jmp    1529 <Get_Ordered_Corelist+0x369>
nopl   0x0(%rax,%rax,1)
lea    0x1c68(%rip),%rsi
call   10d0 <strtok@plt>
xor    %edi,%edi
lea    0x1c5c(%rip),%rsi
call   10d0 <strtok@plt>
mov    %rax,%rdi
call   10e0 <atoi@plt>
mov    0x14(%rsp),%ecx
cmp    %ecx,%eax
cmovl  %eax,%ecx
mov    %ecx,0x14(%rsp)
mov    %r15,%rdi
mov    $0x100,%esi
mov    (%rsp),%rdx
call   1080 <fgets@plt>
test   %rax,%rax
je     166a <Get_Ordered_Corelist+0x4aa>
mov    %r15,%rdi
mov    %r13,%rsi
mov    $0xb,%edx
call   10b0 <strncasecmp@plt>
mov    %r15,%rdi
test   %eax,%eax
je     14e0 <Get_Ordered_Corelist+0x320>
lea    0x1c0c(%rip),%rsi
mov    $0x8,%edx
call   10b0 <strncasecmp@plt>
mov    %r15,%rdi
test   %eax,%eax
je     15d0 <Get_Ordered_Corelist+0x410>
lea    0x1bfd(%rip),%rsi
mov    $0x7,%edx
call   10b0 <strncasecmp@plt>
mov    %r15,%rdi
test   %eax,%eax
je     1606 <Get_Ordered_Corelist+0x446>
lea    0x1be9(%rip),%rsi
mov    $0x9,%edx
call   10b0 <strncasecmp@plt>
test   %eax,%eax
jne    150f <Get_Ordered_Corelist+0x34f>
mov    %r15,%rdi
lea    0x1bbc(%rip),%rsi
call   10d0 <strtok@plt>
xor    %edi,%edi
lea    0x1bb0(%rip),%rsi
call   10d0 <strtok@plt>
mov    %rax,%rdi
call   10e0 <atoi@plt>
test   %r12d,%r12d
cmove  %eax,%r12d
cmp    %eax,%r12d
mov    %eax,%r12d
je     150f <Get_Ordered_Corelist+0x34f>
jmp    1c10 <Get_Ordered_Corelist+0xa50>
cs nopw 0x0(%rax,%rax,1)
lea    0x1b78(%rip),%rsi
call   10d0 <strtok@plt>
xor    %edi,%edi
lea    0x1b6c(%rip),%rsi
call   10d0 <strtok@plt>
mov    %rax,%rdi
call   10e0 <atoi@plt>
test   %ebp,%ebp
cmove  %eax,%ebp
cmp    %eax,%ebp
mov    %eax,%ebp
je     150f <Get_Ordered_Corelist+0x34f>
jmp    1729 <Get_Ordered_Corelist+0x569>
lea    0x1b42(%rip),%rsi
call   10d0 <strtok@plt>
xor    %edi,%edi
lea    0x1b36(%rip),%rsi
call   10d0 <strtok@plt>
mov    %rax,%rdi
call   10e0 <atoi@plt>
mov    0x18(%rsp),%rcx
cmp    %eax,%ecx
cmovl  %eax,%ecx
mov    %rcx,0x18(%rsp)
jmp    150f <Get_Ordered_Corelist+0x34f>
lea    0x1a5b(%rip),%rdi
mov    $0xe2,%esi
call   1050 <get_ordered_corelist_error_message@plt>
test   %r13d,%r13d
jle    19dc <Get_Ordered_Corelist+0x81c>
mov    %r13d,%eax
cmp    $0x8,%r13d
jae    16f7 <Get_Ordered_Corelist+0x537>
xor    %ecx,%ecx
jmp    19d0 <Get_Ordered_Corelist+0x810>
test   %r12d,%r12d
mov    (%rsp),%r15
mov    0x8(%rsp),%r13
jle    169f <Get_Ordered_Corelist+0x4df>
cmp    %r13d,%r12d
jg     169f <Get_Ordered_Corelist+0x4df>
test   %ebp,%ebp
jle    169f <Get_Ordered_Corelist+0x4df>
cmp    %r13d,%ebp
jg     169f <Get_Ordered_Corelist+0x4df>
mov    0x18(%rsp),%rcx
lea    0x1(%rcx),%eax
cmp    %r12d,%eax
jne    19f5 <Get_Ordered_Corelist+0x835>
mov    %r12d,%eax
jmp    1a06 <Get_Ordered_Corelist+0x846>
lea    0x19f8(%rip),%rdi
mov    $0x10d,%esi
call   1050 <get_ordered_corelist_error_message@plt>
test   %r13d,%r13d
jle    188c <Get_Ordered_Corelist+0x6cc>
mov    %r13d,%eax
cmp    $0x8,%r13d
jae    16c9 <Get_Ordered_Corelist+0x509>
xor    %ecx,%ecx
jmp    1880 <Get_Ordered_Corelist+0x6c0>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    175d <Get_Ordered_Corelist+0x59d>
movdqa 0x1910(%rip),%xmm0
xor    %edi,%edi
jmp    1828 <Get_Ordered_Corelist+0x668>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    18ae <Get_Ordered_Corelist+0x6ee>
movdqa 0x18de(%rip),%xmm0
xor    %edi,%edi
jmp    1978 <Get_Ordered_Corelist+0x7b8>
lea    0x196e(%rip),%rdi
mov    $0xf6,%esi
call   1050 <get_ordered_corelist_error_message@plt>
mov    0x8(%rsp),%rcx
test   %ecx,%ecx
mov    (%rsp),%rdi
jle    188f <Get_Ordered_Corelist+0x6cf>
mov    %ecx,%eax
cmp    $0x8,%ecx
jae    1ccd <Get_Ordered_Corelist+0xb0d>
xor    %ecx,%ecx
jmp    1e20 <Get_Ordered_Corelist+0xc60>
and    $0xfffffffffffffffc,%rsi
movdqa 0x1897(%rip),%xmm0
xor    %edi,%edi
movdqa 0x189c(%rip),%xmm8
movdqa 0x18a3(%rip),%xmm9
movdqa 0x18aa(%rip),%xmm10
movdqa 0x18b2(%rip),%xmm4
movdqa 0x18ba(%rip),%xmm5
movdqa 0x18c2(%rip),%xmm6
movdqa 0x18ca(%rip),%xmm7
movdqa 0x18d2(%rip),%xmm1
xchg   %ax,%ax
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rbx,%rdi,4)
movdqu %xmm2,0x10(%rbx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rbx,%rdi,4)
movdqu %xmm3,0x30(%rbx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rbx,%rdi,4)
movdqu %xmm3,0x50(%rbx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rbx,%rdi,4)
movdqu %xmm3,0x70(%rbx,%rdi,4)
add    $0x20,%rdi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    17b0 <Get_Ordered_Corelist+0x5f0>
test   %rdx,%rdx
je     1870 <Get_Ordered_Corelist+0x6b0>
lea    (%rbx,%rdi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movdqa 0x17cd(%rip),%xmm1
movdqa 0x17d5(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm3,(%rsi,%rdi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1850 <Get_Ordered_Corelist+0x690>
cmp    %rax,%rcx
je     188c <Get_Ordered_Corelist+0x6cc>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ecx,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1880 <Get_Ordered_Corelist+0x6c0>
mov    %r15,%rdi
call   1060 <fclose@plt>
mov    %r14,%rdi
call   1040 <free@plt>
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
and    $0xfffffffffffffffc,%rsi
movdqa 0x1746(%rip),%xmm0
xor    %edi,%edi
movdqa 0x174b(%rip),%xmm8
movdqa 0x1752(%rip),%xmm9
movdqa 0x1759(%rip),%xmm10
movdqa 0x1761(%rip),%xmm4
movdqa 0x1769(%rip),%xmm5
movdqa 0x1771(%rip),%xmm6
movdqa 0x1779(%rip),%xmm7
movdqa 0x1781(%rip),%xmm1
nop
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rbx,%rdi,4)
movdqu %xmm2,0x10(%rbx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rbx,%rdi,4)
movdqu %xmm3,0x30(%rbx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rbx,%rdi,4)
movdqu %xmm3,0x50(%rbx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rbx,%rdi,4)
movdqu %xmm3,0x70(%rbx,%rdi,4)
add    $0x20,%rdi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    1900 <Get_Ordered_Corelist+0x740>
test   %rdx,%rdx
je     19c0 <Get_Ordered_Corelist+0x800>
lea    (%rbx,%rdi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movdqa 0x167d(%rip),%xmm1
movdqa 0x1685(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm3,(%rsi,%rdi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    19a0 <Get_Ordered_Corelist+0x7e0>
cmp    %rax,%rcx
je     19dc <Get_Ordered_Corelist+0x81c>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ecx,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    19d0 <Get_Ordered_Corelist+0x810>
mov    %r14,%rdi
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free@plt>
test   %ecx,%ecx
js     1c9f <Get_Ordered_Corelist+0xadf>
cmp    %r12d,%ecx
jge    1c9f <Get_Ordered_Corelist+0xadf>
mov    %eax,0x2c(%rsp)
mov    %r15,%rdi
call   1070 <rewind@plt>
lea    0x30(%rsp),%rdi
mov    $0x100,%esi
mov    %r15,%rdx
call   1080 <fgets@plt>
test   %rax,%rax
je     1c44 <Get_Ordered_Corelist+0xa84>
mov    $0xffffffff,%r15d
xor    %eax,%eax
mov    %rax,0x20(%rsp)
lea    0x30(%rsp),%r13
mov    $0xffffffff,%r12d
jmp    1a7a <Get_Ordered_Corelist+0x8ba>
mov    0x20(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x20(%rsp)
mov    $0xffffffff,%r12d
mov    $0xffffffff,%r15d
mov    %r13,%rdi
mov    $0x100,%esi
mov    (%rsp),%rdx
call   1080 <fgets@plt>
test   %rax,%rax
je     1c4b <Get_Ordered_Corelist+0xa8b>
mov    %r13,%rdi
lea    0x16ea(%rip),%rsi
mov    $0x9,%edx
call   10b0 <strncasecmp@plt>
test   %eax,%eax
jne    1a60 <Get_Ordered_Corelist+0x8a0>
mov    %r13,%rdi
lea    0x16b3(%rip),%rsi
call   10d0 <strtok@plt>
xor    %edi,%edi
lea    0x16a7(%rip),%rsi
call   10d0 <strtok@plt>
mov    %rax,%rdi
call   10e0 <atoi@plt>
mov    %eax,0x18(%rsp)
cmp    0x8(%rsp),%eax
jl     1b06 <Get_Ordered_Corelist+0x946>
jmp    1e31 <Get_Ordered_Corelist+0xc71>
cs nopw 0x0(%rax,%rax,1)
mov    %r13,%rdi
lea    0x1675(%rip),%rsi
call   10d0 <strtok@plt>
xor    %edi,%edi
lea    0x1669(%rip),%rsi
call   10d0 <strtok@plt>
mov    %rax,%rdi
call   10e0 <atoi@plt>
mov    %eax,%r12d
test   %r15d,%r15d
js     1b06 <Get_Ordered_Corelist+0x946>
test   %r12d,%r12d
jns    1b8f <Get_Ordered_Corelist+0x9cf>
mov    %r13,%rdi
mov    $0x100,%esi
mov    (%rsp),%rdx
call   1080 <fgets@plt>
test   %rax,%rax
je     1a60 <Get_Ordered_Corelist+0x8a0>
mov    %r13,%rdi
lea    0x1619(%rip),%rsi
mov    $0xb,%edx
call   10b0 <strncasecmp@plt>
test   %eax,%eax
jne    1b65 <Get_Ordered_Corelist+0x9a5>
mov    %r13,%rdi
lea    0x160d(%rip),%rsi
call   10d0 <strtok@plt>
xor    %edi,%edi
lea    0x1601(%rip),%rsi
call   10d0 <strtok@plt>
mov    %rax,%rdi
call   10e0 <atoi@plt>
mov    %eax,%r15d
sub    0x14(%rsp),%r15d
mov    %r13,%rdi
lea    0x15ed(%rip),%rsi
mov    $0x7,%edx
call   10b0 <strncasecmp@plt>
test   %eax,%eax
je     1ad0 <Get_Ordered_Corelist+0x910>
test   %r15d,%r15d
jns    1afd <Get_Ordered_Corelist+0x93d>
jmp    1b06 <Get_Ordered_Corelist+0x946>
imul   %ebp,%r15d
add    %r15d,%r12d
movslq %r12d,%rax
mov    (%r14,%rax,4),%ecx
mov    0x2c(%rsp),%esi
imul   %esi,%ecx
add    %eax,%ecx
cmp    0x8(%rsp),%ecx
jge    2021 <Get_Ordered_Corelist+0xe61>
movslq %ecx,%rcx
cmpl   $0x0,(%rbx,%rcx,4)
jns    2055 <Get_Ordered_Corelist+0xe95>
mov    0x18(%rsp),%edx
mov    %edx,(%rbx,%rcx,4)
mov    (%r14,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%r14,%rax,4)
mov    %ebp,%eax
cltd
idiv   %esi
cmp    %eax,%ecx
jl     1a47 <Get_Ordered_Corelist+0x887>
lea    0x14bb(%rip),%rdi
mov    $0x151,%esi
call   1050 <get_ordered_corelist_error_message@plt>
mov    0x8(%rsp),%rcx
test   %ecx,%ecx
mov    (%rsp),%rdi
jle    188f <Get_Ordered_Corelist+0x6cf>
mov    %ecx,%eax
cmp    $0x8,%ecx
jae    245b <Get_Ordered_Corelist+0x129b>
xor    %ecx,%ecx
jmp    26fa <Get_Ordered_Corelist+0x153a>
lea    0x1487(%rip),%rdi
mov    $0x106,%esi
call   1050 <get_ordered_corelist_error_message@plt>
mov    0x8(%rsp),%rcx
test   %ecx,%ecx
mov    (%rsp),%rdi
jle    188f <Get_Ordered_Corelist+0x6cf>
mov    %ecx,%eax
cmp    $0x8,%ecx
jae    1e65 <Get_Ordered_Corelist+0xca5>
xor    %ecx,%ecx
jmp    2010 <Get_Ordered_Corelist+0xe50>
xor    %eax,%eax
mov    %rax,0x20(%rsp)
mov    0x8(%rsp),%r13
cmp    %r13d,0x20(%rsp)
jne    1c6d <Get_Ordered_Corelist+0xaad>
mov    (%rsp),%rdi
call   1060 <fclose@plt>
mov    %r14,%rdi
call   1040 <free@plt>
jmp    11e6 <Get_Ordered_Corelist+0x26>
lea    0x142a(%rip),%rdi
mov    $0x15c,%esi
call   1050 <get_ordered_corelist_error_message@plt>
test   %r13d,%r13d
mov    (%rsp),%rdi
jle    188f <Get_Ordered_Corelist+0x6cf>
mov    %r13d,%eax
cmp    $0x8,%r13d
jae    1e93 <Get_Ordered_Corelist+0xcd3>
xor    %ecx,%ecx
jmp    219e <Get_Ordered_Corelist+0xfde>
lea    0x13f8(%rip),%rdi
mov    $0x115,%esi
call   1050 <get_ordered_corelist_error_message@plt>
test   %r13d,%r13d
jle    188c <Get_Ordered_Corelist+0x6cc>
mov    %r13d,%eax
cmp    $0x8,%r13d
jae    1ec5 <Get_Ordered_Corelist+0xd05>
xor    %ecx,%ecx
jmp    22c4 <Get_Ordered_Corelist+0x1104>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rbp
mov    %rbp,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rbp
jae    1cfb <Get_Ordered_Corelist+0xb3b>
movdqa 0x130c(%rip),%xmm0
xor    %ebp,%ebp
jmp    1dc4 <Get_Ordered_Corelist+0xc04>
and    $0xfffffffffffffffc,%rsi
movdqa 0x12f9(%rip),%xmm0
xor    %ebp,%ebp
movdqa 0x12fe(%rip),%xmm8
movdqa 0x1305(%rip),%xmm9
movdqa 0x130c(%rip),%xmm10
movdqa 0x1314(%rip),%xmm4
movdqa 0x131c(%rip),%xmm5
movdqa 0x1324(%rip),%xmm6
movdqa 0x132c(%rip),%xmm7
movdqa 0x1334(%rip),%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rbx,%rbp,4)
movdqu %xmm2,0x10(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rbx,%rbp,4)
movdqu %xmm3,0x30(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rbx,%rbp,4)
movdqu %xmm3,0x50(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rbx,%rbp,4)
movdqu %xmm3,0x70(%rbx,%rbp,4)
add    $0x20,%rbp
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    1d4c <Get_Ordered_Corelist+0xb8c>
test   %rdx,%rdx
je     1e10 <Get_Ordered_Corelist+0xc50>
lea    (%rbx,%rbp,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %ebp,%ebp
movdqa 0x1231(%rip),%xmm1
movdqa 0x1239(%rip),%xmm2
nopw   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rbp,1)
movdqu %xmm3,(%rsi,%rbp,1)
paddd  %xmm2,%xmm0
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1df0 <Get_Ordered_Corelist+0xc30>
cmp    %rax,%rcx
je     188f <Get_Ordered_Corelist+0x6cf>
nopl   0x0(%rax)
mov    %ecx,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1e20 <Get_Ordered_Corelist+0xc60>
jmp    188f <Get_Ordered_Corelist+0x6cf>
lea    0x1266(%rip),%rdi
mov    $0x122,%esi
call   1050 <get_ordered_corelist_error_message@plt>
mov    0x8(%rsp),%rcx
test   %ecx,%ecx
mov    (%rsp),%rdi
jle    188f <Get_Ordered_Corelist+0x6cf>
mov    %ecx,%eax
cmp    $0x8,%ecx
jae    22d5 <Get_Ordered_Corelist+0x1115>
xor    %ecx,%ecx
jmp    244a <Get_Ordered_Corelist+0x128a>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rbp
mov    %rbp,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rbp
jae    1ef7 <Get_Ordered_Corelist+0xd37>
movdqa 0x1174(%rip),%xmm0
xor    %ebp,%ebp
jmp    1fc0 <Get_Ordered_Corelist+0xe00>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rbp
mov    %rbp,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rbp
jae    2089 <Get_Ordered_Corelist+0xec9>
movdqa 0x1142(%rip),%xmm0
xor    %ebp,%ebp
jmp    2152 <Get_Ordered_Corelist+0xf92>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    21af <Get_Ordered_Corelist+0xfef>
movdqa 0x1110(%rip),%xmm0
xor    %edi,%edi
jmp    2278 <Get_Ordered_Corelist+0x10b8>
and    $0xfffffffffffffffc,%rsi
movdqa 0x10fd(%rip),%xmm0
xor    %ebp,%ebp
movdqa 0x1102(%rip),%xmm8
movdqa 0x1109(%rip),%xmm9
movdqa 0x1110(%rip),%xmm10
movdqa 0x1118(%rip),%xmm4
movdqa 0x1120(%rip),%xmm5
movdqa 0x1128(%rip),%xmm6
movdqa 0x1130(%rip),%xmm7
movdqa 0x1138(%rip),%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rbx,%rbp,4)
movdqu %xmm2,0x10(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rbx,%rbp,4)
movdqu %xmm3,0x30(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rbx,%rbp,4)
movdqu %xmm3,0x50(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rbx,%rbp,4)
movdqu %xmm3,0x70(%rbx,%rbp,4)
add    $0x20,%rbp
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    1f48 <Get_Ordered_Corelist+0xd88>
test   %rdx,%rdx
je     2003 <Get_Ordered_Corelist+0xe43>
lea    (%rbx,%rbp,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %ebp,%ebp
movdqa 0x1035(%rip),%xmm1
movdqa 0x103d(%rip),%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rbp,1)
movdqu %xmm3,(%rsi,%rbp,1)
paddd  %xmm2,%xmm0
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1fe3 <Get_Ordered_Corelist+0xe23>
cmp    %rax,%rcx
je     188f <Get_Ordered_Corelist+0x6cf>
nopl   0x0(%rax)
mov    %ecx,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    2010 <Get_Ordered_Corelist+0xe50>
jmp    188f <Get_Ordered_Corelist+0x6cf>
lea    0x1076(%rip),%rdi
mov    $0x143,%esi
call   1050 <get_ordered_corelist_error_message@plt>
mov    0x8(%rsp),%rcx
test   %ecx,%ecx
mov    (%rsp),%rdi
jle    188f <Get_Ordered_Corelist+0x6cf>
mov    %ecx,%eax
cmp    $0x8,%ecx
jae    2303 <Get_Ordered_Corelist+0x1143>
xor    %ecx,%ecx
jmp    25d4 <Get_Ordered_Corelist+0x1414>
lea    0x1042(%rip),%rdi
mov    $0x145,%esi
call   1050 <get_ordered_corelist_error_message@plt>
mov    0x8(%rsp),%rcx
test   %ecx,%ecx
mov    (%rsp),%rdi
jle    188f <Get_Ordered_Corelist+0x6cf>
mov    %ecx,%eax
cmp    $0x8,%ecx
jae    248d <Get_Ordered_Corelist+0x12cd>
xor    %ecx,%ecx
jmp    2820 <Get_Ordered_Corelist+0x1660>
and    $0xfffffffffffffffc,%rsi
movdqa 0xf6b(%rip),%xmm0
xor    %ebp,%ebp
movdqa 0xf70(%rip),%xmm8
movdqa 0xf77(%rip),%xmm9
movdqa 0xf7e(%rip),%xmm10
movdqa 0xf86(%rip),%xmm4
movdqa 0xf8e(%rip),%xmm5
movdqa 0xf96(%rip),%xmm6
movdqa 0xf9e(%rip),%xmm7
movdqa 0xfa6(%rip),%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rbx,%rbp,4)
movdqu %xmm2,0x10(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rbx,%rbp,4)
movdqu %xmm3,0x30(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rbx,%rbp,4)
movdqu %xmm3,0x50(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rbx,%rbp,4)
movdqu %xmm3,0x70(%rbx,%rbp,4)
add    $0x20,%rbp
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    20da <Get_Ordered_Corelist+0xf1a>
test   %rdx,%rdx
je     2195 <Get_Ordered_Corelist+0xfd5>
lea    (%rbx,%rbp,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %ebp,%ebp
movdqa 0xea3(%rip),%xmm1
movdqa 0xeab(%rip),%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rbp,1)
movdqu %xmm3,(%rsi,%rbp,1)
paddd  %xmm2,%xmm0
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    2175 <Get_Ordered_Corelist+0xfb5>
cmp    %rax,%rcx
je     188f <Get_Ordered_Corelist+0x6cf>
mov    %ecx,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    219e <Get_Ordered_Corelist+0xfde>
jmp    188f <Get_Ordered_Corelist+0x6cf>
and    $0xfffffffffffffffc,%rsi
movdqa 0xe45(%rip),%xmm0
xor    %edi,%edi
movdqa 0xe4a(%rip),%xmm8
movdqa 0xe51(%rip),%xmm9
movdqa 0xe58(%rip),%xmm10
movdqa 0xe60(%rip),%xmm4
movdqa 0xe68(%rip),%xmm5
movdqa 0xe70(%rip),%xmm6
movdqa 0xe78(%rip),%xmm7
movdqa 0xe80(%rip),%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rbx,%rdi,4)
movdqu %xmm2,0x10(%rbx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rbx,%rdi,4)
movdqu %xmm3,0x30(%rbx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rbx,%rdi,4)
movdqu %xmm3,0x50(%rbx,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rbx,%rdi,4)
movdqu %xmm3,0x70(%rbx,%rdi,4)
add    $0x20,%rdi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    2200 <Get_Ordered_Corelist+0x1040>
test   %rdx,%rdx
je     22bb <Get_Ordered_Corelist+0x10fb>
lea    (%rbx,%rdi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movdqa 0xd7d(%rip),%xmm1
movdqa 0xd85(%rip),%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm3,(%rsi,%rdi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    229b <Get_Ordered_Corelist+0x10db>
cmp    %rax,%rcx
je     188c <Get_Ordered_Corelist+0x6cc>
mov    %ecx,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    22c4 <Get_Ordered_Corelist+0x1104>
jmp    188c <Get_Ordered_Corelist+0x6cc>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rbp
mov    %rbp,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rbp
jae    2335 <Get_Ordered_Corelist+0x1175>
movdqa 0xd04(%rip),%xmm0
xor    %ebp,%ebp
jmp    23fe <Get_Ordered_Corelist+0x123e>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rbp
mov    %rbp,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rbp
jae    24bf <Get_Ordered_Corelist+0x12ff>
movdqa 0xcd2(%rip),%xmm0
xor    %ebp,%ebp
jmp    2588 <Get_Ordered_Corelist+0x13c8>
and    $0xfffffffffffffffc,%rsi
movdqa 0xcbf(%rip),%xmm0
xor    %ebp,%ebp
movdqa 0xcc4(%rip),%xmm8
movdqa 0xccb(%rip),%xmm9
movdqa 0xcd2(%rip),%xmm10
movdqa 0xcda(%rip),%xmm4
movdqa 0xce2(%rip),%xmm5
movdqa 0xcea(%rip),%xmm6
movdqa 0xcf2(%rip),%xmm7
movdqa 0xcfa(%rip),%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rbx,%rbp,4)
movdqu %xmm2,0x10(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rbx,%rbp,4)
movdqu %xmm3,0x30(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rbx,%rbp,4)
movdqu %xmm3,0x50(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rbx,%rbp,4)
movdqu %xmm3,0x70(%rbx,%rbp,4)
add    $0x20,%rbp
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    2386 <Get_Ordered_Corelist+0x11c6>
test   %rdx,%rdx
je     2441 <Get_Ordered_Corelist+0x1281>
lea    (%rbx,%rbp,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %ebp,%ebp
movdqa 0xbf7(%rip),%xmm1
movdqa 0xbff(%rip),%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rbp,1)
movdqu %xmm3,(%rsi,%rbp,1)
paddd  %xmm2,%xmm0
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    2421 <Get_Ordered_Corelist+0x1261>
cmp    %rax,%rcx
je     188f <Get_Ordered_Corelist+0x6cf>
mov    %ecx,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    244a <Get_Ordered_Corelist+0x128a>
jmp    188f <Get_Ordered_Corelist+0x6cf>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rbp
mov    %rbp,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rbp
jae    25e5 <Get_Ordered_Corelist+0x1425>
movdqa 0xb7a(%rip),%xmm0
xor    %ebp,%ebp
jmp    26ae <Get_Ordered_Corelist+0x14ee>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rbp
mov    %rbp,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rbp
jae    270b <Get_Ordered_Corelist+0x154b>
movdqa 0xb48(%rip),%xmm0
xor    %ebp,%ebp
jmp    27d4 <Get_Ordered_Corelist+0x1614>
and    $0xfffffffffffffffc,%rsi
movdqa 0xb35(%rip),%xmm0
xor    %ebp,%ebp
movdqa 0xb3a(%rip),%xmm8
movdqa 0xb41(%rip),%xmm9
movdqa 0xb48(%rip),%xmm10
movdqa 0xb50(%rip),%xmm4
movdqa 0xb58(%rip),%xmm5
movdqa 0xb60(%rip),%xmm6
movdqa 0xb68(%rip),%xmm7
movdqa 0xb70(%rip),%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rbx,%rbp,4)
movdqu %xmm2,0x10(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rbx,%rbp,4)
movdqu %xmm3,0x30(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rbx,%rbp,4)
movdqu %xmm3,0x50(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rbx,%rbp,4)
movdqu %xmm3,0x70(%rbx,%rbp,4)
add    $0x20,%rbp
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    2510 <Get_Ordered_Corelist+0x1350>
test   %rdx,%rdx
je     25cb <Get_Ordered_Corelist+0x140b>
lea    (%rbx,%rbp,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %ebp,%ebp
movdqa 0xa6d(%rip),%xmm1
movdqa 0xa75(%rip),%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rbp,1)
movdqu %xmm3,(%rsi,%rbp,1)
paddd  %xmm2,%xmm0
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    25ab <Get_Ordered_Corelist+0x13eb>
cmp    %rax,%rcx
je     188f <Get_Ordered_Corelist+0x6cf>
mov    %ecx,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    25d4 <Get_Ordered_Corelist+0x1414>
jmp    188f <Get_Ordered_Corelist+0x6cf>
and    $0xfffffffffffffffc,%rsi
movdqa 0xa0f(%rip),%xmm0
xor    %ebp,%ebp
movdqa 0xa14(%rip),%xmm8
movdqa 0xa1b(%rip),%xmm9
movdqa 0xa22(%rip),%xmm10
movdqa 0xa2a(%rip),%xmm4
movdqa 0xa32(%rip),%xmm5
movdqa 0xa3a(%rip),%xmm6
movdqa 0xa42(%rip),%xmm7
movdqa 0xa4a(%rip),%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rbx,%rbp,4)
movdqu %xmm2,0x10(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rbx,%rbp,4)
movdqu %xmm3,0x30(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rbx,%rbp,4)
movdqu %xmm3,0x50(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rbx,%rbp,4)
movdqu %xmm3,0x70(%rbx,%rbp,4)
add    $0x20,%rbp
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    2636 <Get_Ordered_Corelist+0x1476>
test   %rdx,%rdx
je     26f1 <Get_Ordered_Corelist+0x1531>
lea    (%rbx,%rbp,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %ebp,%ebp
movdqa 0x947(%rip),%xmm1
movdqa 0x94f(%rip),%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rbp,1)
movdqu %xmm3,(%rsi,%rbp,1)
paddd  %xmm2,%xmm0
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    26d1 <Get_Ordered_Corelist+0x1511>
cmp    %rax,%rcx
je     188f <Get_Ordered_Corelist+0x6cf>
mov    %ecx,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    26fa <Get_Ordered_Corelist+0x153a>
jmp    188f <Get_Ordered_Corelist+0x6cf>
and    $0xfffffffffffffffc,%rsi
movdqa 0x8e9(%rip),%xmm0
xor    %ebp,%ebp
movdqa 0x8ee(%rip),%xmm8
movdqa 0x8f5(%rip),%xmm9
movdqa 0x8fc(%rip),%xmm10
movdqa 0x904(%rip),%xmm4
movdqa 0x90c(%rip),%xmm5
movdqa 0x914(%rip),%xmm6
movdqa 0x91c(%rip),%xmm7
movdqa 0x924(%rip),%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rbx,%rbp,4)
movdqu %xmm2,0x10(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rbx,%rbp,4)
movdqu %xmm3,0x30(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rbx,%rbp,4)
movdqu %xmm3,0x50(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rbx,%rbp,4)
movdqu %xmm3,0x70(%rbx,%rbp,4)
add    $0x20,%rbp
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    275c <Get_Ordered_Corelist+0x159c>
test   %rdx,%rdx
je     2817 <Get_Ordered_Corelist+0x1657>
lea    (%rbx,%rbp,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %ebp,%ebp
movdqa 0x821(%rip),%xmm1
movdqa 0x829(%rip),%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rbp,1)
movdqu %xmm3,(%rsi,%rbp,1)
paddd  %xmm2,%xmm0
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    27f7 <Get_Ordered_Corelist+0x1637>
cmp    %rax,%rcx
je     188f <Get_Ordered_Corelist+0x6cf>
mov    %ecx,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    2820 <Get_Ordered_Corelist+0x1660>
jmp    188f <Get_Ordered_Corelist+0x6cf>

LLVM IR (-O0):
@INT32_MAX = global i32 0
@.str = [14 x i8] c"/proc/cpuinfo\00"
@.str.1 = [2 x i8] c"r\00"
@.str.2 = [165 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/pumpkin83/OpenUH-OpenACC/refs/heads/master/osprey/libopenmp-pcl/omp_util.c\00"
@.str.3 = [12 x i8] c"physical id\00"
@.str.4 = [2 x i8] c":\00"
@.str.5 = [2 x i8] c"\0A\00"
@.str.6 = [9 x i8] c"siblings\00"
@.str.7 = [8 x i8] c"core id\00"
@.str.8 = [10 x i8] c"cpu cores\00"
@.str.9 = [10 x i8] c"processor\00"
@.str.10 = [16 x i8] c"O64_OMP_VERBOSE\00"
@stderr = global i32 0
@.str.11 = [37 x i8] c"Get_Ordered_Corelist: affinity map: \00"
@.str.12 = [5 x i8] c"%s%d\00"
@.str.13 = [2 x i8] c",\00"
@.str.14 = [1 x i8] zeroinitializer
define void @Get_Ordered_Corelist(i32* %0, i32 %1) {
%3 = alloca i32*
%4 = alloca i32
%5 = alloca i32*
%6 = alloca [256 x i8]
%7 = alloca i8*
%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
store i32* %0, i32** %3
store i32 %1, i32* %4
store i32 0, i32* %9
store i32 -1, i32* %12
store i32 -1, i32* %13
store i32 0, i32* %14
store i32 0, i32* %15
%22 = load i32, i32* @INT32_MAX
store i32 %22, i32* %16
store i32 -1, i32* %17
%23 = load i32, i32* %4
%24 = icmp eq i32 %23, 1
br i1 %24, label %25, label %28
25: ; preds = %2
%26 = load i32*, i32** %3
%27 = getelementptr inbounds i32, i32* %26, i64 0
store i32 0, i32* %27
br label %524
28: ; preds = %2
%29 = load i32, i32* %4
%30 = sext i32 %29 to i64
%31 = mul i64 4, %30
%32 = trunc i64 %31 to i32
%33 = call i64 @malloc(i32 %32)
%34 = inttoptr i64 %33 to i32*
store i32* %34, i32** %19
store i32 0, i32* %18
br label %35
35: ; preds = %48, %28
%36 = load i32, i32* %18
%37 = load i32, i32* %4
%38 = icmp slt i32 %36, %37
br i1 %38, label %39, label %51
39: ; preds = %35
%40 = load i32*, i32** %3
%41 = load i32, i32* %18
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds i32, i32* %40, i64 %42
store i32 -1, i32* %43
%44 = load i32*, i32** %19
%45 = load i32, i32* %18
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds i32, i32* %44, i64 %46
store i32 0, i32* %47
br label %48
48: ; preds = %39
%49 = load i32, i32* %18
%50 = add nsw i32 %49, 1
store i32 %50, i32* %18
br label %35
51: ; preds = %35
%52 = call i32* @fopen(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32* %52, i32** %5
%53 = icmp eq i32* %52, null
br i1 %53, label %54, label %78
54: ; preds = %51
%55 = call i32 @get_ordered_corelist_error_message(i8* getelementptr inbounds ([165 x i8], [165 x i8]* @.str.2, i64 0, i64 0), i32 226)
store i32 0, i32* %18
br label %56
56: ; preds = %66, %54
%57 = load i32, i32* %18
%58 = load i32, i32* %4
%59 = icmp slt i32 %57, %58
br i1 %59, label %60, label %69
60: ; preds = %56
%61 = load i32, i32* %18
%62 = load i32*, i32** %3
%63 = load i32, i32* %18
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i32, i32* %62, i64 %64
store i32 %61, i32* %65
br label %66
66: ; preds = %60
%67 = load i32, i32* %18
%68 = add nsw i32 %67, 1
store i32 %68, i32* %18
br label %56
69: ; preds = %56
%70 = load i32*, i32** %5
%71 = icmp ne i32* %70, null
br i1 %71, label %72, label %75
72: ; preds = %69
%73 = load i32*, i32** %5
%74 = call i32 @fclose(i32* %73)
br label %75
75: ; preds = %72, %69
%76 = load i32*, i32** %19
%77 = call i32 @free(i32* %76)
br label %552
78: ; preds = %51
br label %79
79: ; preds = %205, %78
%80 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%81 = load i32*, i32** %5
%82 = call i64 @fgets(i8* %80, i32 256, i32* %81)
%83 = icmp ne i64 %82, 0
br i1 %83, label %84, label %206
84: ; preds = %79
%85 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%86 = call i32 @strncasecmp(i8* %85, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i64 0, i64 0), i32 11)
%87 = icmp ne i32 %86, 0
br i1 %87, label %100, label %88
88: ; preds = %84
%89 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%90 = call i8* @strtok(i8* %89, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%91 = call i8* @strtok(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
store i8* %91, i8** %7
%92 = load i8*, i8** %7
%93 = call i32 @atoi(i8* %92)
store i32 %93, i32* %20
%94 = load i32, i32* %20
%95 = load i32, i32* %16
%96 = icmp slt i32 %94, %95
br i1 %96, label %97, label %99
97: ; preds = %88
%98 = load i32, i32* %20
store i32 %98, i32* %16
br label %99
99: ; preds = %97, %88
br label %205
100: ; preds = %84
%101 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%102 = call i32 @strncasecmp(i8* %101, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.6, i64 0, i64 0), i32 8)
%103 = icmp ne i32 %102, 0
br i1 %103, label %143, label %104
104: ; preds = %100
%105 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%106 = call i8* @strtok(i8* %105, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%107 = call i8* @strtok(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
store i8* %107, i8** %7
%108 = load i8*, i8** %7
%109 = call i32 @atoi(i8* %108)
store i32 %109, i32* %20
%110 = load i32, i32* %14
%111 = icmp eq i32 %110, 0
br i1 %111, label %112, label %114
112: ; preds = %104
%113 = load i32, i32* %20
store i32 %113, i32* %14
br label %114
114: ; preds = %112, %104
%115 = load i32, i32* %14
%116 = load i32, i32* %20
%117 = icmp ne i32 %115, %116
br i1 %117, label %118, label %142
118: ; preds = %114
%119 = call i32 @get_ordered_corelist_error_message(i8* getelementptr inbounds ([165 x i8], [165 x i8]* @.str.2, i64 0, i64 0), i32 246)
store i32 0, i32* %18
br label %120
120: ; preds = %130, %118
%121 = load i32, i32* %18
%122 = load i32, i32* %4
%123 = icmp slt i32 %121, %122
br i1 %123, label %124, label %133
124: ; preds = %120
%125 = load i32, i32* %18
%126 = load i32*, i32** %3
%127 = load i32, i32* %18
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i32, i32* %126, i64 %128
store i32 %125, i32* %129
br label %130
130: ; preds = %124
%131 = load i32, i32* %18
%132 = add nsw i32 %131, 1
store i32 %132, i32* %18
br label %120
133: ; preds = %120
%134 = load i32*, i32** %5
%135 = icmp ne i32* %134, null
br i1 %135, label %136, label %139
136: ; preds = %133
%137 = load i32*, i32** %5
%138 = call i32 @fclose(i32* %137)
br label %139
139: ; preds = %136, %133
%140 = load i32*, i32** %19
%141 = call i32 @free(i32* %140)
br label %552
142: ; preds = %114
br label %204
143: ; preds = %100
%144 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%145 = call i32 @strncasecmp(i8* %144, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.7, i64 0, i64 0), i32 7)
%146 = icmp ne i32 %145, 0
br i1 %146, label %159, label %147
147: ; preds = %143
%148 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%149 = call i8* @strtok(i8* %148, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%150 = call i8* @strtok(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
store i8* %150, i8** %7
%151 = load i8*, i8** %7
%152 = call i32 @atoi(i8* %151)
store i32 %152, i32* %20
%153 = load i32, i32* %17
%154 = load i32, i32* %20
%155 = icmp slt i32 %153, %154
br i1 %155, label %156, label %158
156: ; preds = %147
%157 = load i32, i32* %20
store i32 %157, i32* %17
br label %158
158: ; preds = %156, %147
br label %203
159: ; preds = %143
%160 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%161 = call i32 @strncasecmp(i8* %160, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.8, i64 0, i64 0), i32 9)
%162 = icmp ne i32 %161, 0
br i1 %162, label %202, label %163
163: ; preds = %159
%164 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%165 = call i8* @strtok(i8* %164, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%166 = call i8* @strtok(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
store i8* %166, i8** %7
%167 = load i8*, i8** %7
%168 = call i32 @atoi(i8* %167)
store i32 %168, i32* %20
%169 = load i32, i32* %15
%170 = icmp eq i32 %169, 0
br i1 %170, label %171, label %173
171: ; preds = %163
%172 = load i32, i32* %20
store i32 %172, i32* %15
br label %173
173: ; preds = %171, %163
%174 = load i32, i32* %15
%175 = load i32, i32* %20
%176 = icmp ne i32 %174, %175
br i1 %176, label %177, label %201
177: ; preds = %173
%178 = call i32 @get_ordered_corelist_error_message(i8* getelementptr inbounds ([165 x i8], [165 x i8]* @.str.2, i64 0, i64 0), i32 262)
store i32 0, i32* %18
br label %179
179: ; preds = %189, %177
%180 = load i32, i32* %18
%181 = load i32, i32* %4
%182 = icmp slt i32 %180, %181
br i1 %182, label %183, label %192
183: ; preds = %179
%184 = load i32, i32* %18
%185 = load i32*, i32** %3
%186 = load i32, i32* %18
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds i32, i32* %185, i64 %187
store i32 %184, i32* %188
br label %189
189: ; preds = %183
%190 = load i32, i32* %18
%191 = add nsw i32 %190, 1
store i32 %191, i32* %18
br label %179
192: ; preds = %179
%193 = load i32*, i32** %5
%194 = icmp ne i32* %193, null
br i1 %194, label %195, label %198
195: ; preds = %192
%196 = load i32*, i32** %5
%197 = call i32 @fclose(i32* %196)
br label %198
198: ; preds = %195, %192
%199 = load i32*, i32** %19
%200 = call i32 @free(i32* %199)
br label %552
201: ; preds = %173
br label %202
202: ; preds = %201, %159
br label %203
203: ; preds = %202, %158
br label %204
204: ; preds = %203, %142
br label %205
205: ; preds = %204, %99
br label %79
206: ; preds = %79
%207 = load i32, i32* %15
%208 = icmp sle i32 %207, 0
br i1 %208, label %220, label %209
209: ; preds = %206
%210 = load i32, i32* %15
%211 = load i32, i32* %4
%212 = icmp sgt i32 %210, %211
br i1 %212, label %220, label %213
213: ; preds = %209
%214 = load i32, i32* %14
%215 = icmp sle i32 %214, 0
br i1 %215, label %220, label %216
216: ; preds = %213
%217 = load i32, i32* %14
%218 = load i32, i32* %4
%219 = icmp sgt i32 %217, %218
br i1 %219, label %220, label %244
220: ; preds = %216, %213, %209, %206
%221 = call i32 @get_ordered_corelist_error_message(i8* getelementptr inbounds ([165 x i8], [165 x i8]* @.str.2, i64 0, i64 0), i32 269)
store i32 0, i32* %18
br label %222
222: ; preds = %232, %220
%223 = load i32, i32* %18
%224 = load i32, i32* %4
%225 = icmp slt i32 %223, %224
br i1 %225, label %226, label %235
226: ; preds = %222
%227 = load i32, i32* %18
%228 = load i32*, i32** %3
%229 = load i32, i32* %18
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds i32, i32* %228, i64 %230
store i32 %227, i32* %231
br label %232
232: ; preds = %226
%233 = load i32, i32* %18
%234 = add nsw i32 %233, 1
store i32 %234, i32* %18
br label %222
235: ; preds = %222
%236 = load i32*, i32** %5
%237 = icmp ne i32* %236, null
br i1 %237, label %238, label %241
238: ; preds = %235
%239 = load i32*, i32** %5
%240 = call i32 @fclose(i32* %239)
br label %241
241: ; preds = %238, %235
%242 = load i32*, i32** %19
%243 = call i32 @free(i32* %242)
br label %552
244: ; preds = %216
%245 = load i32, i32* %17
%246 = add nsw i32 %245, 1
%247 = load i32, i32* %15
%248 = icmp ne i32 %246, %247
br i1 %248, label %249, label %284
249: ; preds = %244
%250 = load i32, i32* %17
%251 = add nsw i32 %250, 1
store i32 %251, i32* %21
%252 = load i32, i32* %21
%253 = icmp sle i32 %252, 0
br i1 %253, label %258, label %254
254: ; preds = %249
%255 = load i32, i32* %21
%256 = load i32, i32* %15
%257 = icmp sgt i32 %255, %256
br i1 %257, label %258, label %282
258: ; preds = %254, %249
%259 = call i32 @get_ordered_corelist_error_message(i8* getelementptr inbounds ([165 x i8], [165 x i8]* @.str.2, i64 0, i64 0), i32 277)
store i32 0, i32* %18
br label %260
260: ; preds = %270, %258
%261 = load i32, i32* %18
%262 = load i32, i32* %4
%263 = icmp slt i32 %261, %262
br i1 %263, label %264, label %273
264: ; preds = %260
%265 = load i32, i32* %18
%266 = load i32*, i32** %3
%267 = load i32, i32* %18
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds i32, i32* %266, i64 %268
store i32 %265, i32* %269
br label %270
270: ; preds = %264
%271 = load i32, i32* %18
%272 = add nsw i32 %271, 1
store i32 %272, i32* %18
br label %260
273: ; preds = %260
%274 = load i32*, i32** %5
%275 = icmp ne i32* %274, null
br i1 %275, label %276, label %279
276: ; preds = %273
%277 = load i32*, i32** %5
%278 = call i32 @fclose(i32* %277)
br label %279
279: ; preds = %276, %273
%280 = load i32*, i32** %19
%281 = call i32 @free(i32* %280)
br label %552
282: ; preds = %254
%283 = load i32, i32* %21
store i32 %283, i32* %15
br label %284
284: ; preds = %282, %244
%285 = load i32*, i32** %5
%286 = call i32 @rewind(i32* %285)
br label %287
287: ; preds = %490, %284
%288 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%289 = load i32*, i32** %5
%290 = call i64 @fgets(i8* %288, i32 256, i32* %289)
%291 = icmp ne i64 %290, 0
br i1 %291, label %292, label %491
292: ; preds = %287
%293 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%294 = call i32 @strncasecmp(i8* %293, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.9, i64 0, i64 0), i32 9)
%295 = icmp ne i32 %294, 0
br i1 %295, label %490, label %296
296: ; preds = %292
%297 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%298 = call i8* @strtok(i8* %297, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%299 = call i8* @strtok(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
store i8* %299, i8** %7
%300 = load i8*, i8** %7
%301 = call i32 @atoi(i8* %300)
store i32 %301, i32* %8
%302 = load i32, i32* %8
%303 = load i32, i32* %4
%304 = icmp sge i32 %302, %303
br i1 %304, label %305, label %329
305: ; preds = %296
%306 = call i32 @get_ordered_corelist_error_message(i8* getelementptr inbounds ([165 x i8], [165 x i8]* @.str.2, i64 0, i64 0), i32 290)
store i32 0, i32* %18
br label %307
307: ; preds = %317, %305
%308 = load i32, i32* %18
%309 = load i32, i32* %4
%310 = icmp slt i32 %308, %309
br i1 %310, label %311, label %320
311: ; preds = %307
%312 = load i32, i32* %18
%313 = load i32*, i32** %3
%314 = load i32, i32* %18
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds i32, i32* %313, i64 %315
store i32 %312, i32* %316
br label %317
317: ; preds = %311
%318 = load i32, i32* %18
%319 = add nsw i32 %318, 1
store i32 %319, i32* %18
br label %307
320: ; preds = %307
%321 = load i32*, i32** %5
%322 = icmp ne i32* %321, null
br i1 %322, label %323, label %326
323: ; preds = %320
%324 = load i32*, i32** %5
%325 = call i32 @fclose(i32* %324)
br label %326
326: ; preds = %323, %320
%327 = load i32*, i32** %19
%328 = call i32 @free(i32* %327)
br label %552
329: ; preds = %296
br label %330
330: ; preds = %488, %329
%331 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%332 = load i32*, i32** %5
%333 = call i64 @fgets(i8* %331, i32 256, i32* %332)
%334 = icmp ne i64 %333, 0
br i1 %334, label %335, label %489
335: ; preds = %330
%336 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%337 = call i32 @strncasecmp(i8* %336, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i64 0, i64 0), i32 11)
%338 = icmp ne i32 %337, 0
br i1 %338, label %347, label %339
339: ; preds = %335
%340 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%341 = call i8* @strtok(i8* %340, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%342 = call i8* @strtok(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
store i8* %342, i8** %7
%343 = load i8*, i8** %7
%344 = call i32 @atoi(i8* %343)
%345 = load i32, i32* %16
%346 = sub nsw i32 %344, %345
store i32 %346, i32* %13
br label %347
347: ; preds = %339, %335
%348 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%349 = call i32 @strncasecmp(i8* %348, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.7, i64 0, i64 0), i32 7)
%350 = icmp ne i32 %349, 0
br i1 %350, label %357, label %351
351: ; preds = %347
%352 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%353 = call i8* @strtok(i8* %352, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%354 = call i8* @strtok(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
store i8* %354, i8** %7
%355 = load i8*, i8** %7
%356 = call i32 @atoi(i8* %355)
store i32 %356, i32* %12
br label %357
357: ; preds = %351, %347
%358 = load i32, i32* %13
%359 = icmp sge i32 %358, 0
br i1 %359, label %360, label %488
360: ; preds = %357
%361 = load i32, i32* %12
%362 = icmp sge i32 %361, 0
br i1 %362, label %363, label %488
363: ; preds = %360
%364 = load i32, i32* %13
%365 = load i32, i32* %14
%366 = mul nsw i32 %364, %365
%367 = load i32, i32* %12
%368 = add nsw i32 %366, %367
store i32 %368, i32* %10
%369 = load i32, i32* %10
%370 = load i32*, i32** %19
%371 = load i32, i32* %10
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds i32, i32* %370, i64 %372
%374 = load i32, i32* %373
%375 = load i32, i32* %15
%376 = mul nsw i32 %374, %375
%377 = add nsw i32 %369, %376
store i32 %377, i32* %11
%378 = load i32, i32* %11
%379 = load i32, i32* %4
%380 = icmp sge i32 %378, %379
br i1 %380, label %381, label %405
381: ; preds = %363
%382 = call i32 @get_ordered_corelist_error_message(i8* getelementptr inbounds ([165 x i8], [165 x i8]* @.str.2, i64 0, i64 0), i32 323)
store i32 0, i32* %18
br label %383
383: ; preds = %393, %381
%384 = load i32, i32* %18
%385 = load i32, i32* %4
%386 = icmp slt i32 %384, %385
br i1 %386, label %387, label %396
387: ; preds = %383
%388 = load i32, i32* %18
%389 = load i32*, i32** %3
%390 = load i32, i32* %18
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds i32, i32* %389, i64 %391
store i32 %388, i32* %392
br label %393
393: ; preds = %387
%394 = load i32, i32* %18
%395 = add nsw i32 %394, 1
store i32 %395, i32* %18
br label %383
396: ; preds = %383
%397 = load i32*, i32** %5
%398 = icmp ne i32* %397, null
br i1 %398, label %399, label %402
399: ; preds = %396
%400 = load i32*, i32** %5
%401 = call i32 @fclose(i32* %400)
br label %402
402: ; preds = %399, %396
%403 = load i32*, i32** %19
%404 = call i32 @free(i32* %403)
br label %552
405: ; preds = %363
%406 = load i32*, i32** %3
%407 = load i32, i32* %11
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds i32, i32* %406, i64 %408
%410 = load i32, i32* %409
%411 = icmp sge i32 %410, 0
br i1 %411, label %412, label %436
412: ; preds = %405
%413 = call i32 @get_ordered_corelist_error_message(i8* getelementptr inbounds ([165 x i8], [165 x i8]* @.str.2, i64 0, i64 0), i32 325)
store i32 0, i32* %18
br label %414
414: ; preds = %424, %412
%415 = load i32, i32* %18
%416 = load i32, i32* %4
%417 = icmp slt i32 %415, %416
br i1 %417, label %418, label %427
418: ; preds = %414
%419 = load i32, i32* %18
%420 = load i32*, i32** %3
%421 = load i32, i32* %18
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds i32, i32* %420, i64 %422
store i32 %419, i32* %423
br label %424
424: ; preds = %418
%425 = load i32, i32* %18
%426 = add nsw i32 %425, 1
store i32 %426, i32* %18
br label %414
427: ; preds = %414
%428 = load i32*, i32** %5
%429 = icmp ne i32* %428, null
br i1 %429, label %430, label %433
430: ; preds = %427
%431 = load i32*, i32** %5
%432 = call i32 @fclose(i32* %431)
br label %433
433: ; preds = %430, %427
%434 = load i32*, i32** %19
%435 = call i32 @free(i32* %434)
br label %552
436: ; preds = %405
%437 = load i32, i32* %8
%438 = load i32*, i32** %3
%439 = load i32, i32* %11
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds i32, i32* %438, i64 %440
store i32 %437, i32* %441
%442 = load i32*, i32** %19
%443 = load i32, i32* %10
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds i32, i32* %442, i64 %444
%446 = load i32, i32* %445
%447 = add nsw i32 %446, 1
%448 = load i32*, i32** %19
%449 = load i32, i32* %10
%450 = sext i32 %449 to i64
%451 = getelementptr inbounds i32, i32* %448, i64 %450
store i32 %447, i32* %451
%452 = load i32*, i32** %19
%453 = load i32, i32* %10
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds i32, i32* %452, i64 %454
%456 = load i32, i32* %455
%457 = load i32, i32* %14
%458 = load i32, i32* %15
%459 = sdiv i32 %457, %458
%460 = icmp sgt i32 %456, %459
br i1 %460, label %461, label %485
461: ; preds = %436
%462 = call i32 @get_ordered_corelist_error_message(i8* getelementptr inbounds ([165 x i8], [165 x i8]* @.str.2, i64 0, i64 0), i32 337)
store i32 0, i32* %18
br label %463
463: ; preds = %473, %461
%464 = load i32, i32* %18
%465 = load i32, i32* %4
%466 = icmp slt i32 %464, %465
br i1 %466, label %467, label %476
467: ; preds = %463
%468 = load i32, i32* %18
%469 = load i32*, i32** %3
%470 = load i32, i32* %18
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds i32, i32* %469, i64 %471
store i32 %468, i32* %472
br label %473
473: ; preds = %467
%474 = load i32, i32* %18
%475 = add nsw i32 %474, 1
store i32 %475, i32* %18
br label %463
476: ; preds = %463
%477 = load i32*, i32** %5
%478 = icmp ne i32* %477, null
br i1 %478, label %479, label %482
479: ; preds = %476
%480 = load i32*, i32** %5
%481 = call i32 @fclose(i32* %480)
br label %482
482: ; preds = %479, %476
%483 = load i32*, i32** %19
%484 = call i32 @free(i32* %483)
br label %552
485: ; preds = %436
store i32 -1, i32* %13
store i32 -1, i32* %12
%486 = load i32, i32* %9
%487 = add nsw i32 %486, 1
store i32 %487, i32* %9
br label %489
488: ; preds = %360, %357
br label %330
489: ; preds = %485, %330
br label %490
490: ; preds = %489, %292
br label %287
491: ; preds = %287
%492 = load i32, i32* %9
%493 = load i32, i32* %4
%494 = icmp ne i32 %492, %493
br i1 %494, label %495, label %519
495: ; preds = %491
%496 = call i32 @get_ordered_corelist_error_message(i8* getelementptr inbounds ([165 x i8], [165 x i8]* @.str.2, i64 0, i64 0), i32 348)
store i32 0, i32* %18
br label %497
497: ; preds = %507, %495
%498 = load i32, i32* %18
%499 = load i32, i32* %4
%500 = icmp slt i32 %498, %499
br i1 %500, label %501, label %510
501: ; preds = %497
%502 = load i32, i32* %18
%503 = load i32*, i32** %3
%504 = load i32, i32* %18
%505 = sext i32 %504 to i64
%506 = getelementptr inbounds i32, i32* %503, i64 %505
store i32 %502, i32* %506
br label %507
507: ; preds = %501
%508 = load i32, i32* %18
%509 = add nsw i32 %508, 1
store i32 %509, i32* %18
br label %497
510: ; preds = %497
%511 = load i32*, i32** %5
%512 = icmp ne i32* %511, null
br i1 %512, label %513, label %516
513: ; preds = %510
%514 = load i32*, i32** %5
%515 = call i32 @fclose(i32* %514)
br label %516
516: ; preds = %513, %510
%517 = load i32*, i32** %19
%518 = call i32 @free(i32* %517)
br label %552
519: ; preds = %491
%520 = load i32*, i32** %5
%521 = call i32 @fclose(i32* %520)
%522 = load i32*, i32** %19
%523 = call i32 @free(i32* %522)
br label %524
524: ; preds = %519, %25
%525 = call i32* @getenv(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.10, i64 0, i64 0))
%526 = icmp ne i32* %525, null
br i1 %526, label %527, label %552
527: ; preds = %524
%528 = load i32, i32* @stderr
%529 = call i32 (i32, i8*, ...) @fprintf(i32 %528, i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.11, i64 0, i64 0))
store i32 0, i32* %18
br label %530
530: ; preds = %546, %527
%531 = load i32, i32* %18
%532 = load i32, i32* %4
%533 = icmp slt i32 %531, %532
br i1 %533, label %534, label %549
534: ; preds = %530
%535 = load i32, i32* @stderr
%536 = load i32, i32* %18
%537 = icmp sgt i32 %536, 0
%538 = zext i1 %537 to i64
%539 = select i1 %537, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.13, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.14, i64 0, i64 0)
%540 = load i32*, i32** %3
%541 = load i32, i32* %18
%542 = sext i32 %541 to i64
%543 = getelementptr inbounds i32, i32* %540, i64 %542
%544 = load i32, i32* %543
%545 = call i32 (i32, i8*, ...) @fprintf(i32 %535, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.12, i64 0, i64 0), i8* %539, i32 %544)
br label %546
546: ; preds = %534
%547 = load i32, i32* %18
%548 = add nsw i32 %547, 1
store i32 %548, i32* %18
br label %530
549: ; preds = %530
%550 = load i32, i32* @stderr
%551 = call i32 (i32, i8*, ...) @fprintf(i32 %550, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
br label %552
552: ; preds = %75, %139, %198, %241, %279, %326, %402, %433, %482, %516, %549, %524
ret void
}

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