#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_bitmap_t;

/* Variables and functions */
int /*<<< orphan*/ assert(int);
int /*<<< orphan*/ hwloc_bitmap_allbut(int /*<<< orphan*/, int);
int /*<<< orphan*/ hwloc_bitmap_alloc();
int /*<<< orphan*/ hwloc_bitmap_alloc_full();
int /*<<< orphan*/ hwloc_bitmap_clr(int /*<<< orphan*/, int);
int /*<<< orphan*/ hwloc_bitmap_clr_range(int /*<<< orphan*/, int, int);
int /*<<< orphan*/ hwloc_bitmap_fill(int /*<<< orphan*/);
int hwloc_bitmap_first(int /*<<< orphan*/);
int /*<<< orphan*/ hwloc_bitmap_free(int /*<<< orphan*/);
int /*<<< orphan*/ hwloc_bitmap_from_ith_ulong(int /*<<< orphan*/, int, int);
int /*<<< orphan*/ hwloc_bitmap_from_ulong(int /*<<< orphan*/, int);
int hwloc_bitmap_isfull(int /*<<< orphan*/);
int hwloc_bitmap_last(int /*<<< orphan*/);
int hwloc_bitmap_next(int /*<<< orphan*/, int);
int /*<<< orphan*/ hwloc_bitmap_not(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ hwloc_bitmap_set_ith_ulong(int /*<<< orphan*/, int, int);
int /*<<< orphan*/ hwloc_bitmap_set_range(int /*<<< orphan*/, int, int);
int /*<<< orphan*/ hwloc_bitmap_singlify(int /*<<< orphan*/);
int hwloc_bitmap_to_ith_ulong(int /*<<< orphan*/, int);
unsigned long hwloc_bitmap_to_ulong(int /*<<< orphan*/);
int hwloc_bitmap_weight(int /*<<< orphan*/);
int /*<<< orphan*/ hwloc_bitmap_zero(int /*<<< orphan*/);
int main(void) {
  hwloc_bitmap_t set;
  set = hwloc_bitmap_alloc();
  assert(hwloc_bitmap_weight(set) == 0);
  assert(hwloc_bitmap_first(set) == -1);
  assert(hwloc_bitmap_last(set) == -1);
  assert(hwloc_bitmap_to_ulong(set) == 0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 0) == 0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 1) == 0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 23) == 0UL);
  hwloc_bitmap_from_ith_ulong(set, 4, 0xff);
  assert(hwloc_bitmap_to_ith_ulong(set, 4) == 0xff);
  assert(hwloc_bitmap_to_ulong(set) == 0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 0) == 0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 1) == 0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 23) == 0UL);
  hwloc_bitmap_from_ith_ulong(set, 4, 0xfe);
  hwloc_bitmap_set_ith_ulong(set, 6, 0xef);
  assert(hwloc_bitmap_to_ith_ulong(set, 4) == 0xfe);
  assert(hwloc_bitmap_to_ith_ulong(set, 6) == 0xef);
  assert(hwloc_bitmap_to_ulong(set) == 0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 0) == 0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 1) == 0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 23) == 0UL);
  hwloc_bitmap_zero(set);
  assert(hwloc_bitmap_weight(set) == 0);
  assert(hwloc_bitmap_first(set) == -1);
  assert(hwloc_bitmap_last(set) == -1);
  assert(hwloc_bitmap_to_ulong(set) == 0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 0) == 0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 1) == 0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 4) == 0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 23) == 0UL);
  hwloc_bitmap_free(set);
  set = hwloc_bitmap_alloc_full();
  assert(hwloc_bitmap_weight(set) == -1);
  assert(hwloc_bitmap_first(set) == 0);
  assert(hwloc_bitmap_last(set) == -1);
  assert(hwloc_bitmap_to_ulong(set) == ~0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 0) == ~0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 1) == ~0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 23) == ~0UL);
  hwloc_bitmap_set_ith_ulong(set, 4, 0xff);
  assert(hwloc_bitmap_to_ith_ulong(set, 4) == 0xff);
  assert(hwloc_bitmap_to_ulong(set) == ~0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 0) == ~0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 1) == ~0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 23) == ~0UL);
  hwloc_bitmap_from_ith_ulong(set, 4, 0xff);
  assert(hwloc_bitmap_to_ith_ulong(set, 4) == 0xff);
  assert(hwloc_bitmap_to_ulong(set) == 0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 0) == 0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 1) == 0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 23) == 0UL);
  hwloc_bitmap_fill(set);
  assert(hwloc_bitmap_weight(set) == -1);
  assert(hwloc_bitmap_first(set) == 0);
  assert(hwloc_bitmap_last(set) == -1);
  assert(hwloc_bitmap_to_ith_ulong(set, 4) == ~0UL);
  assert(hwloc_bitmap_to_ulong(set) == ~0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 0) == ~0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 1) == ~0UL);
  assert(hwloc_bitmap_to_ith_ulong(set, 23) == ~0UL);
  hwloc_bitmap_free(set);
  set = hwloc_bitmap_alloc();
  assert(hwloc_bitmap_weight(set) == 0);
  hwloc_bitmap_set_range(set, 23, 45);
  assert(hwloc_bitmap_weight(set) == 23);
  hwloc_bitmap_set_range(set, 78, -1);
  assert(hwloc_bitmap_weight(set) == -1);
  hwloc_bitmap_set_range(set, 44, 79);
  assert(hwloc_bitmap_weight(set) == -1);
  assert(hwloc_bitmap_first(set) == 23);
  assert(!hwloc_bitmap_isfull(set));
  hwloc_bitmap_set_range(set, 0, 22);
  assert(hwloc_bitmap_weight(set) == -1);
  assert(hwloc_bitmap_isfull(set));
  hwloc_bitmap_clr_range(set, 35, 56);
  assert(hwloc_bitmap_weight(set) == -1);
  assert(!hwloc_bitmap_isfull(set));
  hwloc_bitmap_clr_range(set, 58, -1);
  assert(hwloc_bitmap_weight(set) == 36);
  assert(hwloc_bitmap_last(set) == 57);
  assert(hwloc_bitmap_next(set, 34) == 57);
  hwloc_bitmap_clr(set, 57);
  assert(hwloc_bitmap_weight(set) == 35);
  assert(hwloc_bitmap_last(set) == 34);
  hwloc_bitmap_clr_range(set, 0, 34);
  assert(hwloc_bitmap_weight(set) == 0);
  assert(hwloc_bitmap_first(set) == -1);
  hwloc_bitmap_free(set);
  set = hwloc_bitmap_alloc();
  hwloc_bitmap_from_ulong(set, 0x0ff0);
  assert(hwloc_bitmap_first(set) == 4);
  assert(hwloc_bitmap_last(set) == 11);
  assert(hwloc_bitmap_weight(set) == 8);
  assert(hwloc_bitmap_to_ith_ulong(set, 0) == 0xff0);
  assert(hwloc_bitmap_to_ith_ulong(set, 1) == 0);
  hwloc_bitmap_zero(set);
  assert(hwloc_bitmap_weight(set) == 0);
  hwloc_bitmap_from_ith_ulong(set, 2, 0xff00);
  assert(hwloc_bitmap_weight(set) == 8);
  assert(hwloc_bitmap_to_ith_ulong(set, 0) == 0);
  assert(hwloc_bitmap_to_ith_ulong(set, 1) == 0);
  assert(hwloc_bitmap_to_ith_ulong(set, 2) == 0xff00);
  assert(hwloc_bitmap_to_ith_ulong(set, 3) == 0);
  hwloc_bitmap_allbut(set, 153);
  assert(hwloc_bitmap_weight(set) == -1);
  hwloc_bitmap_not(set, set);
  assert(hwloc_bitmap_weight(set) == 1);
  assert(hwloc_bitmap_first(set) == 153);
  assert(hwloc_bitmap_last(set) == 153);
  hwloc_bitmap_fill(set);
  hwloc_bitmap_clr_range(set, 178, 3589);
  hwloc_bitmap_not(set, set);
  assert(hwloc_bitmap_weight(set) == 3589 - 178 + 1);
  assert(hwloc_bitmap_first(set) == 178);
  assert(hwloc_bitmap_last(set) == 3589);
  hwloc_bitmap_zero(set);
  hwloc_bitmap_set_range(set, 0, 127);
  assert(hwloc_bitmap_weight(set) == 128);
  hwloc_bitmap_not(set, set);
  assert(hwloc_bitmap_weight(set) == -1);
  hwloc_bitmap_singlify(set);
  assert(hwloc_bitmap_weight(set) == 1);
  assert(hwloc_bitmap_first(set) == 128);
  assert(hwloc_bitmap_last(set) == 128);
  hwloc_bitmap_free(set);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x0,%al
call   1040 <hwloc_bitmap_alloc@plt>
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1090 <hwloc_bitmap_first@plt>
cmp    $0xffffffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1120 <hwloc_bitmap_last@plt>
cmp    $0xffffffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1050 <hwloc_bitmap_to_ulong@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
mov    $0xff,%edx
call   1170 <hwloc_bitmap_from_ith_ulong@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0xff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1050 <hwloc_bitmap_to_ulong@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
mov    $0xfe,%edx
call   1170 <hwloc_bitmap_from_ith_ulong@plt>
mov    -0x8(%rbp),%edi
mov    $0x6,%esi
mov    $0xef,%edx
call   10d0 <hwloc_bitmap_set_ith_ulong@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0xfe,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x6,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0xef,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1050 <hwloc_bitmap_to_ulong@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1140 <hwloc_bitmap_zero@plt>
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1090 <hwloc_bitmap_first@plt>
cmp    $0xffffffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1120 <hwloc_bitmap_last@plt>
cmp    $0xffffffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1050 <hwloc_bitmap_to_ulong@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1060 <hwloc_bitmap_free@plt>
mov    $0x0,%al
call   10e0 <hwloc_bitmap_alloc_full@plt>
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0xffffffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1090 <hwloc_bitmap_first@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1120 <hwloc_bitmap_last@plt>
cmp    $0xffffffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1050 <hwloc_bitmap_to_ulong@plt>
cmp    $0xffffffffffffffff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0xffffffffffffffff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0xffffffffffffffff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0xffffffffffffffff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
mov    $0xff,%edx
call   10d0 <hwloc_bitmap_set_ith_ulong@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0xff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1050 <hwloc_bitmap_to_ulong@plt>
cmp    $0xffffffffffffffff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0xffffffffffffffff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0xffffffffffffffff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0xffffffffffffffff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
mov    $0xff,%edx
call   1170 <hwloc_bitmap_from_ith_ulong@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0xff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1050 <hwloc_bitmap_to_ulong@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1160 <hwloc_bitmap_fill@plt>
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0xffffffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1090 <hwloc_bitmap_first@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1120 <hwloc_bitmap_last@plt>
cmp    $0xffffffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0xffffffffffffffff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1050 <hwloc_bitmap_to_ulong@plt>
cmp    $0xffffffffffffffff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0xffffffffffffffff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0xffffffffffffffff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cltq
cmp    $0xffffffffffffffff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1060 <hwloc_bitmap_free@plt>
mov    $0x0,%al
call   1040 <hwloc_bitmap_alloc@plt>
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x17,%esi
mov    $0x2d,%edx
call   10a0 <hwloc_bitmap_set_range@plt>
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0x17,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x4e,%esi
mov    $0xffffffff,%edx
call   10a0 <hwloc_bitmap_set_range@plt>
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0xffffffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x2c,%esi
mov    $0x4f,%edx
call   10a0 <hwloc_bitmap_set_range@plt>
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0xffffffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1090 <hwloc_bitmap_first@plt>
cmp    $0x17,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1130 <hwloc_bitmap_isfull@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
mov    $0x16,%edx
call   10a0 <hwloc_bitmap_set_range@plt>
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0xffffffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1130 <hwloc_bitmap_isfull@plt>
mov    %eax,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x23,%esi
mov    $0x38,%edx
call   1110 <hwloc_bitmap_clr_range@plt>
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0xffffffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1130 <hwloc_bitmap_isfull@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x3a,%esi
mov    $0xffffffff,%edx
call   1110 <hwloc_bitmap_clr_range@plt>
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0x24,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1120 <hwloc_bitmap_last@plt>
cmp    $0x39,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x22,%esi
call   1030 <hwloc_bitmap_next@plt>
cmp    $0x39,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x39,%esi
call   1070 <hwloc_bitmap_clr@plt>
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0x23,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1120 <hwloc_bitmap_last@plt>
cmp    $0x22,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
mov    $0x22,%edx
call   1110 <hwloc_bitmap_clr_range@plt>
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1090 <hwloc_bitmap_first@plt>
cmp    $0xffffffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1060 <hwloc_bitmap_free@plt>
mov    $0x0,%al
call   1040 <hwloc_bitmap_alloc@plt>
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%edi
mov    $0xff0,%esi
call   10f0 <hwloc_bitmap_from_ulong@plt>
mov    -0x8(%rbp),%edi
call   1090 <hwloc_bitmap_first@plt>
cmp    $0x4,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1120 <hwloc_bitmap_last@plt>
cmp    $0xb,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0x8,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0xff0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1140 <hwloc_bitmap_zero@plt>
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x2,%esi
mov    $0xff00,%edx
call   1170 <hwloc_bitmap_from_ith_ulong@plt>
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0x8,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x2,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0xff00,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x3,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x99,%esi
call   10b0 <hwloc_bitmap_allbut@plt>
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0xffffffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    -0x8(%rbp),%esi
call   1100 <hwloc_bitmap_not@plt>
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0x1,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1090 <hwloc_bitmap_first@plt>
cmp    $0x99,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1120 <hwloc_bitmap_last@plt>
cmp    $0x99,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1160 <hwloc_bitmap_fill@plt>
mov    -0x8(%rbp),%edi
mov    $0xb2,%esi
mov    $0xe05,%edx
call   1110 <hwloc_bitmap_clr_range@plt>
mov    -0x8(%rbp),%edi
mov    -0x8(%rbp),%esi
call   1100 <hwloc_bitmap_not@plt>
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0xd54,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1090 <hwloc_bitmap_first@plt>
cmp    $0xb2,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1120 <hwloc_bitmap_last@plt>
cmp    $0xe05,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1140 <hwloc_bitmap_zero@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
mov    $0x7f,%edx
call   10a0 <hwloc_bitmap_set_range@plt>
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0x80,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    -0x8(%rbp),%esi
call   1100 <hwloc_bitmap_not@plt>
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0xffffffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1150 <hwloc_bitmap_singlify@plt>
mov    -0x8(%rbp),%edi
call   1180 <hwloc_bitmap_weight@plt>
cmp    $0x1,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1090 <hwloc_bitmap_first@plt>
cmp    $0x80,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1120 <hwloc_bitmap_last@plt>
cmp    $0x80,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10c0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1060 <hwloc_bitmap_free@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
xor    %eax,%eax
call   1040 <hwloc_bitmap_alloc@plt>
mov    %eax,%ebx
mov    %eax,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1090 <hwloc_bitmap_first@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1120 <hwloc_bitmap_last@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1050 <hwloc_bitmap_to_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x4,%esi
mov    $0xff,%edx
call   1170 <hwloc_bitmap_from_ith_ulong@plt>
mov    %ebx,%edi
mov    $0x4,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1050 <hwloc_bitmap_to_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x4,%esi
mov    $0xfe,%edx
call   1170 <hwloc_bitmap_from_ith_ulong@plt>
mov    %ebx,%edi
mov    $0x6,%esi
mov    $0xef,%edx
call   10d0 <hwloc_bitmap_set_ith_ulong@plt>
mov    %ebx,%edi
mov    $0x4,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xfe,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x6,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xef,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1050 <hwloc_bitmap_to_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1140 <hwloc_bitmap_zero@plt>
mov    %ebx,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1090 <hwloc_bitmap_first@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1120 <hwloc_bitmap_last@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1050 <hwloc_bitmap_to_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x4,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1060 <hwloc_bitmap_free@plt>
xor    %eax,%eax
call   10e0 <hwloc_bitmap_alloc_full@plt>
mov    %eax,%ebx
mov    %eax,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1090 <hwloc_bitmap_first@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1120 <hwloc_bitmap_last@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1050 <hwloc_bitmap_to_ulong@plt>
xor    %edi,%edi
cmp    $0xffffffffffffffff,%rax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x4,%esi
mov    $0xff,%edx
call   10d0 <hwloc_bitmap_set_ith_ulong@plt>
mov    %ebx,%edi
mov    $0x4,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1050 <hwloc_bitmap_to_ulong@plt>
xor    %edi,%edi
cmp    $0xffffffffffffffff,%rax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x4,%esi
mov    $0xff,%edx
call   1170 <hwloc_bitmap_from_ith_ulong@plt>
mov    %ebx,%edi
mov    $0x4,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1050 <hwloc_bitmap_to_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1160 <hwloc_bitmap_fill@plt>
mov    %ebx,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1090 <hwloc_bitmap_first@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1120 <hwloc_bitmap_last@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x4,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1050 <hwloc_bitmap_to_ulong@plt>
xor    %edi,%edi
cmp    $0xffffffffffffffff,%rax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1060 <hwloc_bitmap_free@plt>
xor    %eax,%eax
call   1040 <hwloc_bitmap_alloc@plt>
mov    %eax,%ebx
mov    %eax,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x17,%esi
mov    $0x2d,%edx
call   10a0 <hwloc_bitmap_set_range@plt>
mov    %ebx,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0x17,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x4e,%esi
mov    $0xffffffff,%edx
call   10a0 <hwloc_bitmap_set_range@plt>
mov    %ebx,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x2c,%esi
mov    $0x4f,%edx
call   10a0 <hwloc_bitmap_set_range@plt>
mov    %ebx,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1090 <hwloc_bitmap_first@plt>
xor    %edi,%edi
cmp    $0x17,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1130 <hwloc_bitmap_isfull@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x16,%edx
call   10a0 <hwloc_bitmap_set_range@plt>
mov    %ebx,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1130 <hwloc_bitmap_isfull@plt>
mov    %eax,%edi
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x23,%esi
mov    $0x38,%edx
call   1110 <hwloc_bitmap_clr_range@plt>
mov    %ebx,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1130 <hwloc_bitmap_isfull@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x3a,%esi
mov    $0xffffffff,%edx
call   1110 <hwloc_bitmap_clr_range@plt>
mov    %ebx,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0x24,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1120 <hwloc_bitmap_last@plt>
xor    %edi,%edi
cmp    $0x39,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x22,%esi
call   1030 <hwloc_bitmap_next@plt>
xor    %edi,%edi
cmp    $0x39,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x39,%esi
call   1070 <hwloc_bitmap_clr@plt>
mov    %ebx,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0x23,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1120 <hwloc_bitmap_last@plt>
xor    %edi,%edi
cmp    $0x22,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x22,%edx
call   1110 <hwloc_bitmap_clr_range@plt>
mov    %ebx,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1090 <hwloc_bitmap_first@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1060 <hwloc_bitmap_free@plt>
xor    %eax,%eax
call   1040 <hwloc_bitmap_alloc@plt>
mov    %eax,%ebx
mov    %eax,%edi
mov    $0xff0,%esi
call   10f0 <hwloc_bitmap_from_ulong@plt>
mov    %ebx,%edi
call   1090 <hwloc_bitmap_first@plt>
xor    %edi,%edi
cmp    $0x4,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1120 <hwloc_bitmap_last@plt>
xor    %edi,%edi
cmp    $0xb,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0x8,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xff0,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1140 <hwloc_bitmap_zero@plt>
mov    %ebx,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x2,%esi
mov    $0xff00,%edx
call   1170 <hwloc_bitmap_from_ith_ulong@plt>
mov    %ebx,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0x8,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x2,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xff00,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x3,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    $0x99,%esi
call   10b0 <hwloc_bitmap_allbut@plt>
mov    %ebx,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    %ebx,%esi
call   1100 <hwloc_bitmap_not@plt>
mov    %ebx,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0x1,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1090 <hwloc_bitmap_first@plt>
xor    %edi,%edi
cmp    $0x99,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1120 <hwloc_bitmap_last@plt>
xor    %edi,%edi
cmp    $0x99,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1160 <hwloc_bitmap_fill@plt>
mov    %ebx,%edi
mov    $0xb2,%esi
mov    $0xe05,%edx
call   1110 <hwloc_bitmap_clr_range@plt>
mov    %ebx,%edi
mov    %ebx,%esi
call   1100 <hwloc_bitmap_not@plt>
mov    %ebx,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0xd54,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1090 <hwloc_bitmap_first@plt>
xor    %edi,%edi
cmp    $0xb2,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1120 <hwloc_bitmap_last@plt>
xor    %edi,%edi
cmp    $0xe05,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1140 <hwloc_bitmap_zero@plt>
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x7f,%edx
call   10a0 <hwloc_bitmap_set_range@plt>
mov    %ebx,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0x80,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
mov    %ebx,%esi
call   1100 <hwloc_bitmap_not@plt>
mov    %ebx,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1150 <hwloc_bitmap_singlify@plt>
mov    %ebx,%edi
call   1180 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0x1,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1090 <hwloc_bitmap_first@plt>
xor    %edi,%edi
cmp    $0x80,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1120 <hwloc_bitmap_last@plt>
xor    %edi,%edi
cmp    $0x80,%eax
sete   %dil
call   10c0 <assert@plt>
mov    %ebx,%edi
call   1060 <hwloc_bitmap_free@plt>
xor    %eax,%eax
pop    %rbx
ret

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

LLVM IR (-O2):
define i32 @main() {
%1 = tail call i32 (...) @hwloc_bitmap_alloc()
%2 = tail call i32 @hwloc_bitmap_weight(i32 %1)
%3 = icmp eq i32 %2, 0
%4 = zext i1 %3 to i32
%5 = tail call i32 @assert(i32 %4)
%6 = tail call i32 @hwloc_bitmap_first(i32 %1)
%7 = icmp eq i32 %6, -1
%8 = zext i1 %7 to i32
%9 = tail call i32 @assert(i32 %8)
%10 = tail call i32 @hwloc_bitmap_last(i32 %1)
%11 = icmp eq i32 %10, -1
%12 = zext i1 %11 to i32
%13 = tail call i32 @assert(i32 %12)
%14 = tail call i64 @hwloc_bitmap_to_ulong(i32 %1)
%15 = icmp eq i64 %14, 0
%16 = zext i1 %15 to i32
%17 = tail call i32 @assert(i32 %16)
%18 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 0)
%19 = icmp eq i32 %18, 0
%20 = zext i1 %19 to i32
%21 = tail call i32 @assert(i32 %20)
%22 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 1)
%23 = icmp eq i32 %22, 0
%24 = zext i1 %23 to i32
%25 = tail call i32 @assert(i32 %24)
%26 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 23)
%27 = icmp eq i32 %26, 0
%28 = zext i1 %27 to i32
%29 = tail call i32 @assert(i32 %28)
%30 = tail call i32 @hwloc_bitmap_from_ith_ulong(i32 %1, i32 4, i32 255)
%31 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 4)
%32 = icmp eq i32 %31, 255
%33 = zext i1 %32 to i32
%34 = tail call i32 @assert(i32 %33)
%35 = tail call i64 @hwloc_bitmap_to_ulong(i32 %1)
%36 = icmp eq i64 %35, 0
%37 = zext i1 %36 to i32
%38 = tail call i32 @assert(i32 %37)
%39 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 0)
%40 = icmp eq i32 %39, 0
%41 = zext i1 %40 to i32
%42 = tail call i32 @assert(i32 %41)
%43 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 1)
%44 = icmp eq i32 %43, 0
%45 = zext i1 %44 to i32
%46 = tail call i32 @assert(i32 %45)
%47 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 23)
%48 = icmp eq i32 %47, 0
%49 = zext i1 %48 to i32
%50 = tail call i32 @assert(i32 %49)
%51 = tail call i32 @hwloc_bitmap_from_ith_ulong(i32 %1, i32 4, i32 254)
%52 = tail call i32 @hwloc_bitmap_set_ith_ulong(i32 %1, i32 6, i32 239)
%53 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 4)
%54 = icmp eq i32 %53, 254
%55 = zext i1 %54 to i32
%56 = tail call i32 @assert(i32 %55)
%57 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 6)
%58 = icmp eq i32 %57, 239
%59 = zext i1 %58 to i32
%60 = tail call i32 @assert(i32 %59)
%61 = tail call i64 @hwloc_bitmap_to_ulong(i32 %1)
%62 = icmp eq i64 %61, 0
%63 = zext i1 %62 to i32
%64 = tail call i32 @assert(i32 %63)
%65 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 0)
%66 = icmp eq i32 %65, 0
%67 = zext i1 %66 to i32
%68 = tail call i32 @assert(i32 %67)
%69 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 1)
%70 = icmp eq i32 %69, 0
%71 = zext i1 %70 to i32
%72 = tail call i32 @assert(i32 %71)
%73 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 23)
%74 = icmp eq i32 %73, 0
%75 = zext i1 %74 to i32
%76 = tail call i32 @assert(i32 %75)
%77 = tail call i32 @hwloc_bitmap_zero(i32 %1)
%78 = tail call i32 @hwloc_bitmap_weight(i32 %1)
%79 = icmp eq i32 %78, 0
%80 = zext i1 %79 to i32
%81 = tail call i32 @assert(i32 %80)
%82 = tail call i32 @hwloc_bitmap_first(i32 %1)
%83 = icmp eq i32 %82, -1
%84 = zext i1 %83 to i32
%85 = tail call i32 @assert(i32 %84)
%86 = tail call i32 @hwloc_bitmap_last(i32 %1)
%87 = icmp eq i32 %86, -1
%88 = zext i1 %87 to i32
%89 = tail call i32 @assert(i32 %88)
%90 = tail call i64 @hwloc_bitmap_to_ulong(i32 %1)
%91 = icmp eq i64 %90, 0
%92 = zext i1 %91 to i32
%93 = tail call i32 @assert(i32 %92)
%94 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 0)
%95 = icmp eq i32 %94, 0
%96 = zext i1 %95 to i32
%97 = tail call i32 @assert(i32 %96)
%98 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 1)
%99 = icmp eq i32 %98, 0
%100 = zext i1 %99 to i32
%101 = tail call i32 @assert(i32 %100)
%102 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 4)
%103 = icmp eq i32 %102, 0
%104 = zext i1 %103 to i32
%105 = tail call i32 @assert(i32 %104)
%106 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 23)
%107 = icmp eq i32 %106, 0
%108 = zext i1 %107 to i32
%109 = tail call i32 @assert(i32 %108)
%110 = tail call i32 @hwloc_bitmap_free(i32 %1)
%111 = tail call i32 (...) @hwloc_bitmap_alloc_full()
%112 = tail call i32 @hwloc_bitmap_weight(i32 %111)
%113 = icmp eq i32 %112, -1
%114 = zext i1 %113 to i32
%115 = tail call i32 @assert(i32 %114)
%116 = tail call i32 @hwloc_bitmap_first(i32 %111)
%117 = icmp eq i32 %116, 0
%118 = zext i1 %117 to i32
%119 = tail call i32 @assert(i32 %118)
%120 = tail call i32 @hwloc_bitmap_last(i32 %111)
%121 = icmp eq i32 %120, -1
%122 = zext i1 %121 to i32
%123 = tail call i32 @assert(i32 %122)
%124 = tail call i64 @hwloc_bitmap_to_ulong(i32 %111)
%125 = icmp eq i64 %124, -1
%126 = zext i1 %125 to i32
%127 = tail call i32 @assert(i32 %126)
%128 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %111, i32 0)
%129 = icmp eq i32 %128, -1
%130 = zext i1 %129 to i32
%131 = tail call i32 @assert(i32 %130)
%132 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %111, i32 1)
%133 = icmp eq i32 %132, -1
%134 = zext i1 %133 to i32
%135 = tail call i32 @assert(i32 %134)
%136 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %111, i32 23)
%137 = icmp eq i32 %136, -1
%138 = zext i1 %137 to i32
%139 = tail call i32 @assert(i32 %138)
%140 = tail call i32 @hwloc_bitmap_set_ith_ulong(i32 %111, i32 4, i32 255)
%141 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %111, i32 4)
%142 = icmp eq i32 %141, 255
%143 = zext i1 %142 to i32
%144 = tail call i32 @assert(i32 %143)
%145 = tail call i64 @hwloc_bitmap_to_ulong(i32 %111)
%146 = icmp eq i64 %145, -1
%147 = zext i1 %146 to i32
%148 = tail call i32 @assert(i32 %147)
%149 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %111, i32 0)
%150 = icmp eq i32 %149, -1
%151 = zext i1 %150 to i32
%152 = tail call i32 @assert(i32 %151)
%153 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %111, i32 1)
%154 = icmp eq i32 %153, -1
%155 = zext i1 %154 to i32
%156 = tail call i32 @assert(i32 %155)
%157 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %111, i32 23)
%158 = icmp eq i32 %157, -1
%159 = zext i1 %158 to i32
%160 = tail call i32 @assert(i32 %159)
%161 = tail call i32 @hwloc_bitmap_from_ith_ulong(i32 %111, i32 4, i32 255)
%162 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %111, i32 4)
%163 = icmp eq i32 %162, 255
%164 = zext i1 %163 to i32
%165 = tail call i32 @assert(i32 %164)
%166 = tail call i64 @hwloc_bitmap_to_ulong(i32 %111)
%167 = icmp eq i64 %166, 0
%168 = zext i1 %167 to i32
%169 = tail call i32 @assert(i32 %168)
%170 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %111, i32 0)
%171 = icmp eq i32 %170, 0
%172 = zext i1 %171 to i32
%173 = tail call i32 @assert(i32 %172)
%174 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %111, i32 1)
%175 = icmp eq i32 %174, 0
%176 = zext i1 %175 to i32
%177 = tail call i32 @assert(i32 %176)
%178 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %111, i32 23)
%179 = icmp eq i32 %178, 0
%180 = zext i1 %179 to i32
%181 = tail call i32 @assert(i32 %180)
%182 = tail call i32 @hwloc_bitmap_fill(i32 %111)
%183 = tail call i32 @hwloc_bitmap_weight(i32 %111)
%184 = icmp eq i32 %183, -1
%185 = zext i1 %184 to i32
%186 = tail call i32 @assert(i32 %185)
%187 = tail call i32 @hwloc_bitmap_first(i32 %111)
%188 = icmp eq i32 %187, 0
%189 = zext i1 %188 to i32
%190 = tail call i32 @assert(i32 %189)
%191 = tail call i32 @hwloc_bitmap_last(i32 %111)
%192 = icmp eq i32 %191, -1
%193 = zext i1 %192 to i32
%194 = tail call i32 @assert(i32 %193)
%195 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %111, i32 4)
%196 = icmp eq i32 %195, -1
%197 = zext i1 %196 to i32
%198 = tail call i32 @assert(i32 %197)
%199 = tail call i64 @hwloc_bitmap_to_ulong(i32 %111)
%200 = icmp eq i64 %199, -1
%201 = zext i1 %200 to i32
%202 = tail call i32 @assert(i32 %201)
%203 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %111, i32 0)
%204 = icmp eq i32 %203, -1
%205 = zext i1 %204 to i32
%206 = tail call i32 @assert(i32 %205)
%207 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %111, i32 1)
%208 = icmp eq i32 %207, -1
%209 = zext i1 %208 to i32
%210 = tail call i32 @assert(i32 %209)
%211 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %111, i32 23)
%212 = icmp eq i32 %211, -1
%213 = zext i1 %212 to i32
%214 = tail call i32 @assert(i32 %213)
%215 = tail call i32 @hwloc_bitmap_free(i32 %111)
%216 = tail call i32 (...) @hwloc_bitmap_alloc()
%217 = tail call i32 @hwloc_bitmap_weight(i32 %216)
%218 = icmp eq i32 %217, 0
%219 = zext i1 %218 to i32
%220 = tail call i32 @assert(i32 %219)
%221 = tail call i32 @hwloc_bitmap_set_range(i32 %216, i32 23, i32 45)
%222 = tail call i32 @hwloc_bitmap_weight(i32 %216)
%223 = icmp eq i32 %222, 23
%224 = zext i1 %223 to i32
%225 = tail call i32 @assert(i32 %224)
%226 = tail call i32 @hwloc_bitmap_set_range(i32 %216, i32 78, i32 -1)
%227 = tail call i32 @hwloc_bitmap_weight(i32 %216)
%228 = icmp eq i32 %227, -1
%229 = zext i1 %228 to i32
%230 = tail call i32 @assert(i32 %229)
%231 = tail call i32 @hwloc_bitmap_set_range(i32 %216, i32 44, i32 79)
%232 = tail call i32 @hwloc_bitmap_weight(i32 %216)
%233 = icmp eq i32 %232, -1
%234 = zext i1 %233 to i32
%235 = tail call i32 @assert(i32 %234)
%236 = tail call i32 @hwloc_bitmap_first(i32 %216)
%237 = icmp eq i32 %236, 23
%238 = zext i1 %237 to i32
%239 = tail call i32 @assert(i32 %238)
%240 = tail call i32 @hwloc_bitmap_isfull(i32 %216)
%241 = icmp eq i32 %240, 0
%242 = zext i1 %241 to i32
%243 = tail call i32 @assert(i32 %242)
%244 = tail call i32 @hwloc_bitmap_set_range(i32 %216, i32 0, i32 22)
%245 = tail call i32 @hwloc_bitmap_weight(i32 %216)
%246 = icmp eq i32 %245, -1
%247 = zext i1 %246 to i32
%248 = tail call i32 @assert(i32 %247)
%249 = tail call i32 @hwloc_bitmap_isfull(i32 %216)
%250 = tail call i32 @assert(i32 %249)
%251 = tail call i32 @hwloc_bitmap_clr_range(i32 %216, i32 35, i32 56)
%252 = tail call i32 @hwloc_bitmap_weight(i32 %216)
%253 = icmp eq i32 %252, -1
%254 = zext i1 %253 to i32
%255 = tail call i32 @assert(i32 %254)
%256 = tail call i32 @hwloc_bitmap_isfull(i32 %216)
%257 = icmp eq i32 %256, 0
%258 = zext i1 %257 to i32
%259 = tail call i32 @assert(i32 %258)
%260 = tail call i32 @hwloc_bitmap_clr_range(i32 %216, i32 58, i32 -1)
%261 = tail call i32 @hwloc_bitmap_weight(i32 %216)
%262 = icmp eq i32 %261, 36
%263 = zext i1 %262 to i32
%264 = tail call i32 @assert(i32 %263)
%265 = tail call i32 @hwloc_bitmap_last(i32 %216)
%266 = icmp eq i32 %265, 57
%267 = zext i1 %266 to i32
%268 = tail call i32 @assert(i32 %267)
%269 = tail call i32 @hwloc_bitmap_next(i32 %216, i32 34)
%270 = icmp eq i32 %269, 57
%271 = zext i1 %270 to i32
%272 = tail call i32 @assert(i32 %271)
%273 = tail call i32 @hwloc_bitmap_clr(i32 %216, i32 57)
%274 = tail call i32 @hwloc_bitmap_weight(i32 %216)
%275 = icmp eq i32 %274, 35
%276 = zext i1 %275 to i32
%277 = tail call i32 @assert(i32 %276)
%278 = tail call i32 @hwloc_bitmap_last(i32 %216)
%279 = icmp eq i32 %278, 34
%280 = zext i1 %279 to i32
%281 = tail call i32 @assert(i32 %280)
%282 = tail call i32 @hwloc_bitmap_clr_range(i32 %216, i32 0, i32 34)
%283 = tail call i32 @hwloc_bitmap_weight(i32 %216)
%284 = icmp eq i32 %283, 0
%285 = zext i1 %284 to i32
%286 = tail call i32 @assert(i32 %285)
%287 = tail call i32 @hwloc_bitmap_first(i32 %216)
%288 = icmp eq i32 %287, -1
%289 = zext i1 %288 to i32
%290 = tail call i32 @assert(i32 %289)
%291 = tail call i32 @hwloc_bitmap_free(i32 %216)
%292 = tail call i32 (...) @hwloc_bitmap_alloc()
%293 = tail call i32 @hwloc_bitmap_from_ulong(i32 %292, i32 4080)
%294 = tail call i32 @hwloc_bitmap_first(i32 %292)
%295 = icmp eq i32 %294, 4
%296 = zext i1 %295 to i32
%297 = tail call i32 @assert(i32 %296)
%298 = tail call i32 @hwloc_bitmap_last(i32 %292)
%299 = icmp eq i32 %298, 11
%300 = zext i1 %299 to i32
%301 = tail call i32 @assert(i32 %300)
%302 = tail call i32 @hwloc_bitmap_weight(i32 %292)
%303 = icmp eq i32 %302, 8
%304 = zext i1 %303 to i32
%305 = tail call i32 @assert(i32 %304)
%306 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %292, i32 0)
%307 = icmp eq i32 %306, 4080
%308 = zext i1 %307 to i32
%309 = tail call i32 @assert(i32 %308)
%310 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %292, i32 1)
%311 = icmp eq i32 %310, 0
%312 = zext i1 %311 to i32
%313 = tail call i32 @assert(i32 %312)
%314 = tail call i32 @hwloc_bitmap_zero(i32 %292)
%315 = tail call i32 @hwloc_bitmap_weight(i32 %292)
%316 = icmp eq i32 %315, 0
%317 = zext i1 %316 to i32
%318 = tail call i32 @assert(i32 %317)
%319 = tail call i32 @hwloc_bitmap_from_ith_ulong(i32 %292, i32 2, i32 65280)
%320 = tail call i32 @hwloc_bitmap_weight(i32 %292)
%321 = icmp eq i32 %320, 8
%322 = zext i1 %321 to i32
%323 = tail call i32 @assert(i32 %322)
%324 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %292, i32 0)
%325 = icmp eq i32 %324, 0
%326 = zext i1 %325 to i32
%327 = tail call i32 @assert(i32 %326)
%328 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %292, i32 1)
%329 = icmp eq i32 %328, 0
%330 = zext i1 %329 to i32
%331 = tail call i32 @assert(i32 %330)
%332 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %292, i32 2)
%333 = icmp eq i32 %332, 65280
%334 = zext i1 %333 to i32
%335 = tail call i32 @assert(i32 %334)
%336 = tail call i32 @hwloc_bitmap_to_ith_ulong(i32 %292, i32 3)
%337 = icmp eq i32 %336, 0
%338 = zext i1 %337 to i32
%339 = tail call i32 @assert(i32 %338)
%340 = tail call i32 @hwloc_bitmap_allbut(i32 %292, i32 153)
%341 = tail call i32 @hwloc_bitmap_weight(i32 %292)
%342 = icmp eq i32 %341, -1
%343 = zext i1 %342 to i32
%344 = tail call i32 @assert(i32 %343)
%345 = tail call i32 @hwloc_bitmap_not(i32 %292, i32 %292)
%346 = tail call i32 @hwloc_bitmap_weight(i32 %292)
%347 = icmp eq i32 %346, 1
%348 = zext i1 %347 to i32
%349 = tail call i32 @assert(i32 %348)
%350 = tail call i32 @hwloc_bitmap_first(i32 %292)
%351 = icmp eq i32 %350, 153
%352 = zext i1 %351 to i32
%353 = tail call i32 @assert(i32 %352)
%354 = tail call i32 @hwloc_bitmap_last(i32 %292)
%355 = icmp eq i32 %354, 153
%356 = zext i1 %355 to i32
%357 = tail call i32 @assert(i32 %356)
%358 = tail call i32 @hwloc_bitmap_fill(i32 %292)
%359 = tail call i32 @hwloc_bitmap_clr_range(i32 %292, i32 178, i32 3589)
%360 = tail call i32 @hwloc_bitmap_not(i32 %292, i32 %292)
%361 = tail call i32 @hwloc_bitmap_weight(i32 %292)
%362 = icmp eq i32 %361, 3412
%363 = zext i1 %362 to i32
%364 = tail call i32 @assert(i32 %363)
%365 = tail call i32 @hwloc_bitmap_first(i32 %292)
%366 = icmp eq i32 %365, 178
%367 = zext i1 %366 to i32
%368 = tail call i32 @assert(i32 %367)
%369 = tail call i32 @hwloc_bitmap_last(i32 %292)
%370 = icmp eq i32 %369, 3589
%371 = zext i1 %370 to i32
%372 = tail call i32 @assert(i32 %371)
%373 = tail call i32 @hwloc_bitmap_zero(i32 %292)
%374 = tail call i32 @hwloc_bitmap_set_range(i32 %292, i32 0, i32 127)
%375 = tail call i32 @hwloc_bitmap_weight(i32 %292)
%376 = icmp eq i32 %375, 128
%377 = zext i1 %376 to i32
%378 = tail call i32 @assert(i32 %377)
%379 = tail call i32 @hwloc_bitmap_not(i32 %292, i32 %292)
%380 = tail call i32 @hwloc_bitmap_weight(i32 %292)
%381 = icmp eq i32 %380, -1
%382 = zext i1 %381 to i32
%383 = tail call i32 @assert(i32 %382)
%384 = tail call i32 @hwloc_bitmap_singlify(i32 %292)
%385 = tail call i32 @hwloc_bitmap_weight(i32 %292)
%386 = icmp eq i32 %385, 1
%387 = zext i1 %386 to i32
%388 = tail call i32 @assert(i32 %387)
%389 = tail call i32 @hwloc_bitmap_first(i32 %292)
%390 = icmp eq i32 %389, 128
%391 = zext i1 %390 to i32
%392 = tail call i32 @assert(i32 %391)
%393 = tail call i32 @hwloc_bitmap_last(i32 %292)
%394 = icmp eq i32 %393, 128
%395 = zext i1 %394 to i32
%396 = tail call i32 @assert(i32 %395)
%397 = tail call i32 @hwloc_bitmap_free(i32 %292)
ret i32 0
}