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

/* Variables and functions */
int /*<<< orphan*/ HWLOC_OBJ_CORE;
int /*<<< orphan*/ assert(int);
unsigned int hwloc_get_nbobjs_by_depth(int /*<<< orphan*/, int);
int /*<<< orphan*/ hwloc_topology_destroy(int /*<<< orphan*/);
unsigned int hwloc_topology_get_depth(int /*<<< orphan*/);
int /*<<< orphan*/ hwloc_topology_init(int /*<<< orphan*/ *);
int /*<<< orphan*/ hwloc_topology_load(int /*<<< orphan*/);
scalar_t__ hwloc_topology_set_distance_matrix(int /*<<< orphan*/,
                                              int /*<<< orphan*/, int,
                                              unsigned int *, float *);
int /*<<< orphan*/ hwloc_topology_set_synthetic(int /*<<< orphan*/, char *);
int /*<<< orphan*/ putenv(char *);
int main(void) {
  hwloc_topology_t topology;
  unsigned indexes[16];
  float distances[16 * 16];
  unsigned i, j;
  unsigned depth;
  unsigned width;
  hwloc_topology_init(&topology);
  hwloc_topology_set_synthetic(topology, "node:2 core:8 pu:1");
  hwloc_topology_load(topology);
  depth = hwloc_topology_get_depth(topology);
  assert(depth == 4);
  width = hwloc_get_nbobjs_by_depth(topology, 0);
  assert(width == 1);
  width = hwloc_get_nbobjs_by_depth(topology, 1);
  assert(width == 2);
  width = hwloc_get_nbobjs_by_depth(topology, 2);
  assert(width == 16);
  width = hwloc_get_nbobjs_by_depth(topology, 3);
  assert(width == 16);
  hwloc_topology_destroy(topology);
  hwloc_topology_init(&topology);
  hwloc_topology_set_synthetic(topology, "node:2 core:8 pu:1");
  for (i = 0; i < 16; i++) {
    indexes[i] = i;
    for (j = 0; j < 16; j++)
      if (i == j)
        distances[i + 16 * j] = distances[j + 16 * i] = 3;
      else if (i / 2 == j / 2)
        distances[i + 16 * j] = distances[j + 16 * i] = 5;
      else if (i / 4 == j / 4)
        distances[i + 16 * j] = distances[j + 16 * i] = 7;
      else
        distances[i + 16 * j] = distances[j + 16 * i] = 9;
  }
  assert(!hwloc_topology_set_distance_matrix(topology, HWLOC_OBJ_CORE, 16,
                                             indexes, distances));
  hwloc_topology_load(topology);
  depth = hwloc_topology_get_depth(topology);
  assert(depth == 6);
  width = hwloc_get_nbobjs_by_depth(topology, 0);
  assert(width == 1);
  width = hwloc_get_nbobjs_by_depth(topology, 1);
  assert(width == 2);
  width = hwloc_get_nbobjs_by_depth(topology, 2);
  assert(width == 4);
  width = hwloc_get_nbobjs_by_depth(topology, 3);
  assert(width == 8);
  width = hwloc_get_nbobjs_by_depth(topology, 4);
  assert(width == 16);
  hwloc_topology_destroy(topology);
  distances[0] = 2.9;
  distances[1] = 5.1;
  distances[16] = 5.2;
  hwloc_topology_init(&topology);
  hwloc_topology_set_synthetic(topology, "node:2 core:8 pu:1");
  assert(!hwloc_topology_set_distance_matrix(topology, HWLOC_OBJ_CORE, 16,
                                             indexes, distances));
  putenv("HWLOC_GROUPING_ACCURACY=0.1");
  hwloc_topology_load(topology);
  depth = hwloc_topology_get_depth(topology);
  assert(depth == 6);
  hwloc_topology_destroy(topology);
  hwloc_topology_init(&topology);
  hwloc_topology_set_synthetic(topology, "node:2 core:8 pu:1");
  assert(!hwloc_topology_set_distance_matrix(topology, HWLOC_OBJ_CORE, 16,
                                             indexes, distances));
  putenv("HWLOC_GROUPING_ACCURACY=try");
  hwloc_topology_load(topology);
  depth = hwloc_topology_get_depth(topology);
  assert(depth == 6);
  hwloc_topology_destroy(topology);
  hwloc_topology_init(&topology);
  hwloc_topology_set_synthetic(topology, "node:2 core:8 pu:1");
  assert(!hwloc_topology_set_distance_matrix(topology, HWLOC_OBJ_CORE, 16,
                                             indexes, distances));
  putenv("HWLOC_GROUPING_ACCURACY=0.01");
  hwloc_topology_load(topology);
  depth = hwloc_topology_get_depth(topology);
  assert(depth == 4);
  hwloc_topology_destroy(topology);
  hwloc_topology_init(&topology);
  hwloc_topology_set_synthetic(topology, "node:2 core:8 pu:1");
  assert(!hwloc_topology_set_distance_matrix(topology, HWLOC_OBJ_CORE, 16,
                                             indexes, distances));
  putenv("HWLOC_GROUPING_ACCURACY=0");
  hwloc_topology_load(topology);
  depth = hwloc_topology_get_depth(topology);
  assert(depth == 4);
  hwloc_topology_destroy(topology);
  hwloc_topology_init(&topology);
  hwloc_topology_set_synthetic(topology, "node:2 core:8 pu:1");
  assert(!hwloc_topology_set_distance_matrix(topology, HWLOC_OBJ_CORE, 16,
                                             indexes, distances));
  assert(!hwloc_topology_set_distance_matrix(topology, HWLOC_OBJ_CORE, 0, NULL,
                                             NULL));
  hwloc_topology_load(topology);
  depth = hwloc_topology_get_depth(topology);
  assert(depth == 4);
  width = hwloc_get_nbobjs_by_depth(topology, 0);
  assert(width == 1);
  width = hwloc_get_nbobjs_by_depth(topology, 1);
  assert(width == 2);
  width = hwloc_get_nbobjs_by_depth(topology, 2);
  assert(width == 16);
  width = hwloc_get_nbobjs_by_depth(topology, 3);
  assert(width == 16);
  hwloc_topology_destroy(topology);
  hwloc_topology_init(&topology);
  hwloc_topology_set_synthetic(topology, "node:2 core:4 pu:4");
  hwloc_topology_load(topology);
  depth = hwloc_topology_get_depth(topology);
  assert(depth == 4);
  width = hwloc_get_nbobjs_by_depth(topology, 0);
  assert(width == 1);
  width = hwloc_get_nbobjs_by_depth(topology, 1);
  assert(width == 2);
  width = hwloc_get_nbobjs_by_depth(topology, 2);
  assert(width == 8);
  width = hwloc_get_nbobjs_by_depth(topology, 3);
  assert(width == 32);
  hwloc_topology_destroy(topology);
  hwloc_topology_init(&topology);
  hwloc_topology_set_synthetic(topology, "node:2 core:4 pu:4");
  putenv("HWLOC_Core_DISTANCES=0,1,2,3,4,5,6,7:4*2");
  hwloc_topology_load(topology);
  depth = hwloc_topology_get_depth(topology);
  assert(depth == 5);
  width = hwloc_get_nbobjs_by_depth(topology, 0);
  assert(width == 1);
  width = hwloc_get_nbobjs_by_depth(topology, 1);
  assert(width == 2);
  width = hwloc_get_nbobjs_by_depth(topology, 2);
  assert(width == 4);
  width = hwloc_get_nbobjs_by_depth(topology, 3);
  assert(width == 8);
  width = hwloc_get_nbobjs_by_depth(topology, 4);
  assert(width == 32);
  hwloc_topology_destroy(topology);
  hwloc_topology_init(&topology);
  hwloc_topology_set_synthetic(topology, "node:2 core:4 pu:4");
  putenv("HWLOC_PU_DISTANCES=0-31:16*2");
  hwloc_topology_load(topology);
  depth = hwloc_topology_get_depth(topology);
  assert(depth == 6);
  width = hwloc_get_nbobjs_by_depth(topology, 0);
  assert(width == 1);
  width = hwloc_get_nbobjs_by_depth(topology, 1);
  assert(width == 2);
  width = hwloc_get_nbobjs_by_depth(topology, 2);
  assert(width == 4);
  width = hwloc_get_nbobjs_by_depth(topology, 3);
  assert(width == 8);
  width = hwloc_get_nbobjs_by_depth(topology, 4);
  assert(width == 16);
  width = hwloc_get_nbobjs_by_depth(topology, 5);
  assert(width == 32);
  hwloc_topology_destroy(topology);
  hwloc_topology_init(&topology);
  hwloc_topology_set_synthetic(topology, "node:2 core:4 pu:4");
  putenv("HWLOC_Core_DISTANCES=0-7:2*4");
  hwloc_topology_load(topology);
  depth = hwloc_topology_get_depth(topology);
  assert(depth == 5);
  width = hwloc_get_nbobjs_by_depth(topology, 0);
  assert(width == 1);
  width = hwloc_get_nbobjs_by_depth(topology, 1);
  assert(width == 2);
  width = hwloc_get_nbobjs_by_depth(topology, 2);
  assert(width == 8);
  width = hwloc_get_nbobjs_by_depth(topology, 3);
  assert(width == 16);
  width = hwloc_get_nbobjs_by_depth(topology, 4);
  assert(width == 32);
  hwloc_topology_destroy(topology);
  hwloc_topology_init(&topology);
  hwloc_topology_set_synthetic(topology, "node:2 core:4 pu:4");
  putenv("HWLOC_Core_DISTANCES=none");
  putenv("HWLOC_PU_DISTANCES=none");
  hwloc_topology_load(topology);
  depth = hwloc_topology_get_depth(topology);
  assert(depth == 4);
  width = hwloc_get_nbobjs_by_depth(topology, 0);
  assert(width == 1);
  width = hwloc_get_nbobjs_by_depth(topology, 1);
  assert(width == 2);
  width = hwloc_get_nbobjs_by_depth(topology, 2);
  assert(width == 8);
  width = hwloc_get_nbobjs_by_depth(topology, 3);
  assert(width == 32);
  hwloc_topology_destroy(topology);
  hwloc_topology_init(&topology);
  hwloc_topology_set_synthetic(topology, "node:2 core:4 pu:4");
  assert(hwloc_topology_set_distance_matrix(topology, HWLOC_OBJ_CORE, 16, NULL,
                                            NULL) < 0);
  assert(hwloc_topology_set_distance_matrix(topology, HWLOC_OBJ_CORE, 0,
                                            indexes, NULL) < 0);
  indexes[1] = 0;
  assert(hwloc_topology_set_distance_matrix(topology, HWLOC_OBJ_CORE, 16,
                                            indexes, distances) < 0);
  hwloc_topology_destroy(topology);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x460,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x8(%rbp),%rdi
call   1030 <hwloc_topology_init@plt>
mov    -0x8(%rbp),%edi
lea    0xe67(%rip),%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
mov    -0x8(%rbp),%edi
call   1040 <hwloc_topology_load@plt>
mov    -0x8(%rbp),%edi
call   1050 <hwloc_topology_get_depth@plt>
mov    %eax,-0x45c(%rbp)
cmpl   $0x4,-0x45c(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x1,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x2,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x2,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x10,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x3,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x10,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
call   10b0 <hwloc_topology_destroy@plt>
lea    -0x8(%rbp),%rdi
call   1030 <hwloc_topology_init@plt>
mov    -0x8(%rbp),%edi
lea    0xd84(%rip),%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
movl   $0x0,-0x454(%rbp)
cmpl   $0x10,-0x454(%rbp)
jae    148c <main+0x2fc>
mov    -0x454(%rbp),%ecx
mov    -0x454(%rbp),%eax
mov    %ecx,-0x50(%rbp,%rax,4)
movl   $0x0,-0x458(%rbp)
cmpl   $0x10,-0x458(%rbp)
jae    1473 <main+0x2e3>
mov    -0x454(%rbp),%eax
cmp    -0x458(%rbp),%eax
jne    133a <main+0x1aa>
mov    -0x458(%rbp),%eax
mov    -0x454(%rbp),%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    %eax,%eax
movss  0xd10(%rip),%xmm0
movss  %xmm0,-0x450(%rbp,%rax,4)
ff ff
mov    -0x454(%rbp),%eax
mov    -0x458(%rbp),%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    %eax,%eax
movss  0xcec(%rip),%xmm0
movss  %xmm0,-0x450(%rbp,%rax,4)
ff ff
jmp    145a <main+0x2ca>
mov    -0x454(%rbp),%eax
shr    $0x1,%eax
mov    -0x458(%rbp),%ecx
shr    $0x1,%ecx
cmp    %ecx,%eax
jne    13a1 <main+0x211>
mov    -0x458(%rbp),%eax
mov    -0x454(%rbp),%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    %eax,%eax
movss  0xca5(%rip),%xmm0
movss  %xmm0,-0x450(%rbp,%rax,4)
ff ff
mov    -0x454(%rbp),%eax
mov    -0x458(%rbp),%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    %eax,%eax
movss  0xc81(%rip),%xmm0
movss  %xmm0,-0x450(%rbp,%rax,4)
ff ff
jmp    1455 <main+0x2c5>
mov    -0x454(%rbp),%eax
shr    $0x2,%eax
mov    -0x458(%rbp),%ecx
shr    $0x2,%ecx
cmp    %ecx,%eax
jne    1408 <main+0x278>
mov    -0x458(%rbp),%eax
mov    -0x454(%rbp),%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    %eax,%eax
movss  0xc3a(%rip),%xmm0
movss  %xmm0,-0x450(%rbp,%rax,4)
ff ff
mov    -0x454(%rbp),%eax
mov    -0x458(%rbp),%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    %eax,%eax
movss  0xc16(%rip),%xmm0
movss  %xmm0,-0x450(%rbp,%rax,4)
ff ff
jmp    1450 <main+0x2c0>
mov    -0x458(%rbp),%eax
mov    -0x454(%rbp),%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    %eax,%eax
movss  0xbe9(%rip),%xmm0
movss  %xmm0,-0x450(%rbp,%rax,4)
ff ff
mov    -0x454(%rbp),%eax
mov    -0x458(%rbp),%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    %eax,%eax
movss  0xbc5(%rip),%xmm0
movss  %xmm0,-0x450(%rbp,%rax,4)
ff ff
jmp    1455 <main+0x2c5>
jmp    145a <main+0x2ca>
jmp    145f <main+0x2cf>
mov    -0x458(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x458(%rbp)
jmp    12ce <main+0x13e>
jmp    1478 <main+0x2e8>
mov    -0x454(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x454(%rbp)
jmp    12a7 <main+0x117>
mov    -0x8(%rbp),%edi
mov    0x2b4a(%rip),%rax
mov    (%rax),%esi
lea    -0x50(%rbp),%rcx
lea    -0x450(%rbp),%r8
mov    $0x10,%edx
call   1060 <hwloc_topology_set_distance_matrix@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
call   1040 <hwloc_topology_load@plt>
mov    -0x8(%rbp),%edi
call   1050 <hwloc_topology_get_depth@plt>
mov    %eax,-0x45c(%rbp)
cmpl   $0x6,-0x45c(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x1,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x2,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x2,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x4,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x3,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x8,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x10,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
call   10b0 <hwloc_topology_destroy@plt>
movss  0xa4e(%rip),%xmm0
movss  %xmm0,-0x450(%rbp)
ff
movss  0xa3a(%rip),%xmm0
movss  %xmm0,-0x44c(%rbp)
ff
movss  0xa26(%rip),%xmm0
movss  %xmm0,-0x410(%rbp)
ff
lea    -0x8(%rbp),%rdi
call   1030 <hwloc_topology_init@plt>
mov    -0x8(%rbp),%edi
lea    0xa27(%rip),%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
mov    -0x8(%rbp),%edi
mov    0x29dc(%rip),%rax
mov    (%rax),%esi
lea    -0x50(%rbp),%rcx
lea    -0x450(%rbp),%r8
mov    $0x10,%edx
call   1060 <hwloc_topology_set_distance_matrix@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
lea    0x9fa(%rip),%rdi
call   1070 <putenv@plt>
mov    -0x8(%rbp),%edi
call   1040 <hwloc_topology_load@plt>
mov    -0x8(%rbp),%edi
call   1050 <hwloc_topology_get_depth@plt>
mov    %eax,-0x45c(%rbp)
cmpl   $0x6,-0x45c(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
call   10b0 <hwloc_topology_destroy@plt>
lea    -0x8(%rbp),%rdi
call   1030 <hwloc_topology_init@plt>
mov    -0x8(%rbp),%edi
lea    0x99d(%rip),%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
mov    -0x8(%rbp),%edi
mov    0x2952(%rip),%rax
mov    (%rax),%esi
lea    -0x50(%rbp),%rcx
lea    -0x450(%rbp),%r8
mov    $0x10,%edx
call   1060 <hwloc_topology_set_distance_matrix@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
lea    0x98c(%rip),%rdi
call   1070 <putenv@plt>
mov    -0x8(%rbp),%edi
call   1040 <hwloc_topology_load@plt>
mov    -0x8(%rbp),%edi
call   1050 <hwloc_topology_get_depth@plt>
mov    %eax,-0x45c(%rbp)
cmpl   $0x6,-0x45c(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
call   10b0 <hwloc_topology_destroy@plt>
lea    -0x8(%rbp),%rdi
call   1030 <hwloc_topology_init@plt>
mov    -0x8(%rbp),%edi
lea    0x913(%rip),%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
mov    -0x8(%rbp),%edi
mov    0x28c8(%rip),%rax
mov    (%rax),%esi
lea    -0x50(%rbp),%rcx
lea    -0x450(%rbp),%r8
mov    $0x10,%edx
call   1060 <hwloc_topology_set_distance_matrix@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
lea    0x91e(%rip),%rdi
call   1070 <putenv@plt>
mov    -0x8(%rbp),%edi
call   1040 <hwloc_topology_load@plt>
mov    -0x8(%rbp),%edi
call   1050 <hwloc_topology_get_depth@plt>
mov    %eax,-0x45c(%rbp)
cmpl   $0x4,-0x45c(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
call   10b0 <hwloc_topology_destroy@plt>
lea    -0x8(%rbp),%rdi
call   1030 <hwloc_topology_init@plt>
mov    -0x8(%rbp),%edi
lea    0x889(%rip),%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
mov    -0x8(%rbp),%edi
mov    0x283e(%rip),%rax
mov    (%rax),%esi
lea    -0x50(%rbp),%rcx
lea    -0x450(%rbp),%r8
mov    $0x10,%edx
call   1060 <hwloc_topology_set_distance_matrix@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
lea    0x8b1(%rip),%rdi
call   1070 <putenv@plt>
mov    -0x8(%rbp),%edi
call   1040 <hwloc_topology_load@plt>
mov    -0x8(%rbp),%edi
call   1050 <hwloc_topology_get_depth@plt>
mov    %eax,-0x45c(%rbp)
cmpl   $0x4,-0x45c(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
call   10b0 <hwloc_topology_destroy@plt>
lea    -0x8(%rbp),%rdi
call   1030 <hwloc_topology_init@plt>
mov    -0x8(%rbp),%edi
lea    0x7ff(%rip),%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
mov    -0x8(%rbp),%edi
mov    0x27b4(%rip),%rax
mov    (%rax),%esi
lea    -0x50(%rbp),%rcx
lea    -0x450(%rbp),%r8
mov    $0x10,%edx
call   1060 <hwloc_topology_set_distance_matrix@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    0x2780(%rip),%rax
mov    (%rax),%esi
xor    %edx,%edx
xor    %eax,%eax
mov    %eax,%r8d
mov    %r8,%rcx
call   1060 <hwloc_topology_set_distance_matrix@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
call   1040 <hwloc_topology_load@plt>
mov    -0x8(%rbp),%edi
call   1050 <hwloc_topology_get_depth@plt>
mov    %eax,-0x45c(%rbp)
cmpl   $0x4,-0x45c(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x1,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x2,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x2,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x10,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x3,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x10,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
call   10b0 <hwloc_topology_destroy@plt>
lea    -0x8(%rbp),%rdi
call   1030 <hwloc_topology_init@plt>
mov    -0x8(%rbp),%edi
lea    0x73c(%rip),%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
mov    -0x8(%rbp),%edi
call   1040 <hwloc_topology_load@plt>
mov    -0x8(%rbp),%edi
call   1050 <hwloc_topology_get_depth@plt>
mov    %eax,-0x45c(%rbp)
cmpl   $0x4,-0x45c(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x1,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x2,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x2,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x8,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x3,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x20,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
call   10b0 <hwloc_topology_destroy@plt>
lea    -0x8(%rbp),%rdi
call   1030 <hwloc_topology_init@plt>
mov    -0x8(%rbp),%edi
lea    0x659(%rip),%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
lea    0x660(%rip),%rdi
call   1070 <putenv@plt>
mov    -0x8(%rbp),%edi
call   1040 <hwloc_topology_load@plt>
mov    -0x8(%rbp),%edi
call   1050 <hwloc_topology_get_depth@plt>
mov    %eax,-0x45c(%rbp)
cmpl   $0x5,-0x45c(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x1,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x2,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x2,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x4,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x3,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x8,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x20,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
call   10b0 <hwloc_topology_destroy@plt>
lea    -0x8(%rbp),%rdi
call   1030 <hwloc_topology_init@plt>
mov    -0x8(%rbp),%edi
lea    0x543(%rip),%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
lea    0x573(%rip),%rdi
call   1070 <putenv@plt>
mov    -0x8(%rbp),%edi
call   1040 <hwloc_topology_load@plt>
mov    -0x8(%rbp),%edi
call   1050 <hwloc_topology_get_depth@plt>
mov    %eax,-0x45c(%rbp)
cmpl   $0x6,-0x45c(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x1,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x2,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x2,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x4,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x3,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x8,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x10,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x5,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x20,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
call   10b0 <hwloc_topology_destroy@plt>
lea    -0x8(%rbp),%rdi
call   1030 <hwloc_topology_init@plt>
mov    -0x8(%rbp),%edi
lea    0x406(%rip),%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
lea    0x453(%rip),%rdi
call   1070 <putenv@plt>
mov    -0x8(%rbp),%edi
call   1040 <hwloc_topology_load@plt>
mov    -0x8(%rbp),%edi
call   1050 <hwloc_topology_get_depth@plt>
mov    %eax,-0x45c(%rbp)
cmpl   $0x5,-0x45c(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x1,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x2,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x2,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x8,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x3,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x10,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x20,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
call   10b0 <hwloc_topology_destroy@plt>
lea    -0x8(%rbp),%rdi
call   1030 <hwloc_topology_init@plt>
mov    -0x8(%rbp),%edi
lea    0x2f0(%rip),%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
lea    0x35a(%rip),%rdi
call   1070 <putenv@plt>
lea    0x368(%rip),%rdi
call   1070 <putenv@plt>
mov    -0x8(%rbp),%edi
call   1040 <hwloc_topology_load@plt>
mov    -0x8(%rbp),%edi
call   1050 <hwloc_topology_get_depth@plt>
mov    %eax,-0x45c(%rbp)
cmpl   $0x4,-0x45c(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x1,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x2,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x2,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x8,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x3,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x20,-0x460(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
call   10b0 <hwloc_topology_destroy@plt>
lea    -0x8(%rbp),%rdi
call   1030 <hwloc_topology_init@plt>
mov    -0x8(%rbp),%edi
lea    0x1f5(%rip),%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
mov    -0x8(%rbp),%edi
mov    0x2128(%rip),%rax
mov    (%rax),%esi
mov    $0x10,%edx
xor    %eax,%eax
mov    %eax,%r8d
mov    %r8,%rcx
call   1060 <hwloc_topology_set_distance_matrix@plt>
cmp    $0x0,%rax
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
mov    0x20f9(%rip),%rax
mov    (%rax),%esi
lea    -0x50(%rbp),%rcx
xor    %edx,%edx
xor    %eax,%eax
mov    %eax,%r8d
call   1060 <hwloc_topology_set_distance_matrix@plt>
cmp    $0x0,%rax
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
movl   $0x0,-0x4c(%rbp)
mov    -0x8(%rbp),%edi
mov    0x20c5(%rip),%rax
mov    (%rax),%esi
lea    -0x50(%rbp),%rcx
lea    -0x450(%rbp),%r8
mov    $0x10,%edx
call   1060 <hwloc_topology_set_distance_matrix@plt>
cmp    $0x0,%rax
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1080 <assert@plt>
mov    -0x8(%rbp),%edi
call   10b0 <hwloc_topology_destroy@plt>
xor    %eax,%eax
add    $0x460,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x458,%rsp
lea    0xc(%rsp),%rbx
mov    %rbx,%rdi
call   1030 <hwloc_topology_init@plt>
mov    0xc(%rsp),%edi
lea    0xe47(%rip),%r14
mov    %r14,%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
mov    0xc(%rsp),%edi
call   1040 <hwloc_topology_load@plt>
mov    0xc(%rsp),%edi
call   1050 <hwloc_topology_get_depth@plt>
xor    %edi,%edi
cmp    $0x4,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
xor    %ebp,%ebp
xor    %esi,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x1,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x1,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x2,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x2,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x10,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x3,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x10,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
call   10b0 <hwloc_topology_destroy@plt>
mov    %rbx,%rdi
call   1030 <hwloc_topology_init@plt>
mov    0xc(%rsp),%edi
mov    %r14,%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
lea    0x50(%rsp),%rax
mov    %rax,%rcx
jmp    1296 <main+0x106>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
add    $0x4,%rcx
add    $0x40,%rax
cmp    $0x10,%rbp
je     1313 <main+0x183>
mov    %ebp,0x10(%rsp,%rbp,4)
mov    %rbp,%rdx
shl    $0x4,%rdx
add    %rbp,%rdx
mov    %rcx,%rsi
xor    %edi,%edi
jmp    12c6 <main+0x136>
nopl   0x0(%rax,%rax,1)
movl   $0x40400000,0x50(%rsp,%rdx,4)
40
add    $0x1,%rdi
add    $0x40,%rsi
cmp    $0x10,%rdi
je     1280 <main+0xf0>
cmp    %rdi,%rbp
je     12b0 <main+0x120>
mov    %edi,%ebx
xor    %ebp,%ebx
cmp    $0x1,%ebx
ja     12f0 <main+0x160>
movl   $0x40a00000,(%rax,%rdi,4)
movl   $0x40a00000,(%rsi)
jmp    12b8 <main+0x128>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    $0x3,%ebx
ja     1304 <main+0x174>
movl   $0x40e00000,(%rax,%rdi,4)
movl   $0x40e00000,(%rsi)
jmp    12b8 <main+0x128>
movl   $0x41100000,(%rax,%rdi,4)
movl   $0x41100000,(%rsi)
jmp    12b8 <main+0x128>
mov    0xc(%rsp),%edi
mov    0x2cc2(%rip),%rbp
mov    0x0(%rbp),%esi
lea    0x10(%rsp),%r15
lea    0x50(%rsp),%r14
mov    $0x10,%edx
mov    %r15,%rcx
mov    %r14,%r8
call   1060 <hwloc_topology_set_distance_matrix@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
call   1040 <hwloc_topology_load@plt>
mov    0xc(%rsp),%edi
call   1050 <hwloc_topology_get_depth@plt>
xor    %edi,%edi
cmp    $0x6,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
xor    %esi,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x1,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x1,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x2,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x2,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x4,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x3,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x8,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x4,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x10,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
call   10b0 <hwloc_topology_destroy@plt>
movabs $0x40a333334039999a,%rax
33 a3 40
mov    %rax,0x50(%rsp)
movl   $0x40a66666,0x90(%rsp)
66 66 a6 40
lea    0xc(%rsp),%r13
mov    %r13,%rdi
call   1030 <hwloc_topology_init@plt>
mov    0xc(%rsp),%edi
lea    0xbd3(%rip),%rbx
mov    %rbx,%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
mov    0xc(%rsp),%edi
mov    0x0(%rbp),%esi
mov    $0x10,%edx
mov    %r15,%rcx
mov    %r14,%r8
call   1060 <hwloc_topology_set_distance_matrix@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   1080 <assert@plt>
lea    0xbb2(%rip),%rdi
call   1070 <putenv@plt>
mov    0xc(%rsp),%edi
call   1040 <hwloc_topology_load@plt>
mov    0xc(%rsp),%edi
call   1050 <hwloc_topology_get_depth@plt>
xor    %edi,%edi
cmp    $0x6,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
call   10b0 <hwloc_topology_destroy@plt>
mov    %r13,%rdi
call   1030 <hwloc_topology_init@plt>
mov    0xc(%rsp),%edi
mov    %rbx,%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
mov    0xc(%rsp),%edi
mov    0x0(%rbp),%esi
mov    $0x10,%edx
mov    %r15,%rcx
mov    %r14,%r8
call   1060 <hwloc_topology_set_distance_matrix@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   1080 <assert@plt>
lea    0xb60(%rip),%rdi
call   1070 <putenv@plt>
mov    0xc(%rsp),%edi
call   1040 <hwloc_topology_load@plt>
mov    0xc(%rsp),%edi
call   1050 <hwloc_topology_get_depth@plt>
xor    %edi,%edi
cmp    $0x6,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
call   10b0 <hwloc_topology_destroy@plt>
mov    %r13,%rdi
call   1030 <hwloc_topology_init@plt>
mov    0xc(%rsp),%edi
mov    %rbx,%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
mov    0xc(%rsp),%edi
mov    0x0(%rbp),%esi
mov    $0x10,%edx
mov    %r15,%rcx
mov    %r14,%r8
call   1060 <hwloc_topology_set_distance_matrix@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   1080 <assert@plt>
lea    0xb0e(%rip),%rdi
call   1070 <putenv@plt>
mov    0xc(%rsp),%edi
call   1040 <hwloc_topology_load@plt>
mov    0xc(%rsp),%edi
call   1050 <hwloc_topology_get_depth@plt>
xor    %edi,%edi
cmp    $0x4,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
call   10b0 <hwloc_topology_destroy@plt>
mov    %r13,%rdi
call   1030 <hwloc_topology_init@plt>
mov    0xc(%rsp),%edi
mov    %rbx,%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
mov    0xc(%rsp),%edi
mov    0x0(%rbp),%esi
mov    $0x10,%edx
mov    %r15,%rcx
mov    %r14,%r8
call   1060 <hwloc_topology_set_distance_matrix@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   1080 <assert@plt>
lea    0xabd(%rip),%rdi
call   1070 <putenv@plt>
mov    0xc(%rsp),%edi
call   1040 <hwloc_topology_load@plt>
mov    0xc(%rsp),%edi
call   1050 <hwloc_topology_get_depth@plt>
xor    %edi,%edi
cmp    $0x4,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
call   10b0 <hwloc_topology_destroy@plt>
mov    %r13,%rdi
call   1030 <hwloc_topology_init@plt>
mov    0xc(%rsp),%edi
mov    %rbx,%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
mov    0xc(%rsp),%edi
mov    0x0(%rbp),%esi
mov    $0x10,%edx
mov    %r15,%rcx
mov    %r14,%r8
call   1060 <hwloc_topology_set_distance_matrix@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    0x0(%rbp),%esi
xor    %edx,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
call   1060 <hwloc_topology_set_distance_matrix@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
call   1040 <hwloc_topology_load@plt>
mov    0xc(%rsp),%edi
call   1050 <hwloc_topology_get_depth@plt>
xor    %edi,%edi
cmp    $0x4,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
xor    %esi,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x1,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x1,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x2,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x2,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x10,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x3,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x10,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
call   10b0 <hwloc_topology_destroy@plt>
mov    %r13,%rdi
call   1030 <hwloc_topology_init@plt>
mov    0xc(%rsp),%edi
lea    0x9a6(%rip),%r12
mov    %r12,%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
mov    0xc(%rsp),%edi
call   1040 <hwloc_topology_load@plt>
mov    0xc(%rsp),%edi
call   1050 <hwloc_topology_get_depth@plt>
xor    %edi,%edi
cmp    $0x4,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
xor    %esi,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x1,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x1,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x2,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x2,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x8,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x3,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x20,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
call   10b0 <hwloc_topology_destroy@plt>
mov    %r13,%rdi
call   1030 <hwloc_topology_init@plt>
mov    0xc(%rsp),%edi
mov    %r12,%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
lea    0x900(%rip),%rdi
call   1070 <putenv@plt>
mov    0xc(%rsp),%edi
call   1040 <hwloc_topology_load@plt>
mov    0xc(%rsp),%edi
call   1050 <hwloc_topology_get_depth@plt>
xor    %edi,%edi
cmp    $0x5,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
xor    %esi,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x1,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x1,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x2,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x2,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x4,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x3,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x8,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x4,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x20,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
call   10b0 <hwloc_topology_destroy@plt>
mov    %r13,%rdi
call   1030 <hwloc_topology_init@plt>
mov    0xc(%rsp),%edi
mov    %r12,%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
lea    0x857(%rip),%rdi
call   1070 <putenv@plt>
mov    0xc(%rsp),%edi
call   1040 <hwloc_topology_load@plt>
mov    0xc(%rsp),%edi
call   1050 <hwloc_topology_get_depth@plt>
xor    %edi,%edi
cmp    $0x6,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
xor    %esi,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x1,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x1,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x2,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x2,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x4,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x3,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x8,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x4,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x10,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x5,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x20,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
call   10b0 <hwloc_topology_destroy@plt>
mov    %r13,%rdi
call   1030 <hwloc_topology_init@plt>
mov    0xc(%rsp),%edi
mov    %r12,%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
lea    0x786(%rip),%rdi
call   1070 <putenv@plt>
mov    0xc(%rsp),%edi
call   1040 <hwloc_topology_load@plt>
mov    0xc(%rsp),%edi
call   1050 <hwloc_topology_get_depth@plt>
xor    %edi,%edi
cmp    $0x5,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
xor    %esi,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x1,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x1,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x2,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x2,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x8,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x3,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x10,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x4,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x20,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
call   10b0 <hwloc_topology_destroy@plt>
mov    %r13,%rdi
call   1030 <hwloc_topology_init@plt>
mov    0xc(%rsp),%edi
mov    %r12,%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
lea    0x6d1(%rip),%rdi
call   1070 <putenv@plt>
lea    0x6df(%rip),%rdi
call   1070 <putenv@plt>
mov    0xc(%rsp),%edi
call   1040 <hwloc_topology_load@plt>
mov    0xc(%rsp),%edi
call   1050 <hwloc_topology_get_depth@plt>
xor    %edi,%edi
cmp    $0x4,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
xor    %esi,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x1,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x1,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x2,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x2,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x8,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    $0x3,%esi
call   1090 <hwloc_get_nbobjs_by_depth@plt>
xor    %edi,%edi
cmp    $0x20,%eax
sete   %dil
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
call   10b0 <hwloc_topology_destroy@plt>
mov    %r13,%rdi
call   1030 <hwloc_topology_init@plt>
mov    0xc(%rsp),%edi
mov    %r12,%rsi
call   10a0 <hwloc_topology_set_synthetic@plt>
mov    0xc(%rsp),%edi
mov    0x0(%rbp),%esi
mov    $0x10,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
call   1060 <hwloc_topology_set_distance_matrix@plt>
shr    $0x3f,%rax
mov    %eax,%edi
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
mov    0x0(%rbp),%esi
xor    %edx,%edx
mov    %r15,%rcx
xor    %r8d,%r8d
call   1060 <hwloc_topology_set_distance_matrix@plt>
shr    $0x3f,%rax
mov    %eax,%edi
call   1080 <assert@plt>
movl   $0x0,0x14(%rsp)
mov    0xc(%rsp),%edi
mov    0x0(%rbp),%esi
mov    $0x10,%edx
mov    %r15,%rcx
mov    %r14,%r8
call   1060 <hwloc_topology_set_distance_matrix@plt>
shr    $0x3f,%rax
mov    %eax,%edi
call   1080 <assert@plt>
mov    0xc(%rsp),%edi
call   10b0 <hwloc_topology_destroy@plt>
xor    %eax,%eax
add    $0x458,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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