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

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