#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_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 hwloc_bitmap_first(int /*<<< orphan*/);
int /*<<< orphan*/ hwloc_bitmap_free(int /*<<< orphan*/);
int /*<<< orphan*/ hwloc_bitmap_from_ith_ulong(int /*<<< orphan*/, int, int);
int hwloc_bitmap_isfull(int /*<<< orphan*/);
int hwloc_bitmap_last(int /*<<< orphan*/);
int hwloc_bitmap_next(int /*<<< orphan*/, int);
int /*<<< orphan*/ hwloc_bitmap_set_ith_ulong(int /*<<< orphan*/, int, int);
int /*<<< orphan*/ hwloc_bitmap_set_range(int /*<<< orphan*/, int, int);
unsigned long 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_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);
  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   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
mov    $0xff,%edx
call   1120 <hwloc_bitmap_from_ith_ulong@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0xff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <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   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1110 <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   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1060 <hwloc_bitmap_free@plt>
mov    $0x0,%al
call   10d0 <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   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0xffffffffffffffff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0xffffffffffffffff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0xffffffffffffffff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
mov    $0xff,%edx
call   10c0 <hwloc_bitmap_set_ith_ulong@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0xff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <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   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0xffffffffffffffff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0xffffffffffffffff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0xffffffffffffffff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
mov    $0xff,%edx
call   1120 <hwloc_bitmap_from_ith_ulong@plt>
mov    -0x8(%rbp),%edi
mov    $0x4,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0xff,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <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   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <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   1130 <hwloc_bitmap_weight@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x17,%esi
mov    $0x2d,%edx
call   10a0 <hwloc_bitmap_set_range@plt>
mov    -0x8(%rbp),%edi
call   1130 <hwloc_bitmap_weight@plt>
cmp    $0x17,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x4e,%esi
mov    $0xffffffff,%edx
call   10a0 <hwloc_bitmap_set_range@plt>
mov    -0x8(%rbp),%edi
call   1130 <hwloc_bitmap_weight@plt>
cmp    $0xffffffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x2c,%esi
mov    $0x4f,%edx
call   10a0 <hwloc_bitmap_set_range@plt>
mov    -0x8(%rbp),%edi
call   1130 <hwloc_bitmap_weight@plt>
cmp    $0xffffffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1090 <hwloc_bitmap_first@plt>
cmp    $0x17,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1100 <hwloc_bitmap_isfull@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
mov    $0x16,%edx
call   10a0 <hwloc_bitmap_set_range@plt>
mov    -0x8(%rbp),%edi
call   1130 <hwloc_bitmap_weight@plt>
cmp    $0xffffffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1100 <hwloc_bitmap_isfull@plt>
mov    %eax,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x23,%esi
mov    $0x38,%edx
call   10e0 <hwloc_bitmap_clr_range@plt>
mov    -0x8(%rbp),%edi
call   1130 <hwloc_bitmap_weight@plt>
cmp    $0xffffffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1100 <hwloc_bitmap_isfull@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x3a,%esi
mov    $0xffffffff,%edx
call   10e0 <hwloc_bitmap_clr_range@plt>
mov    -0x8(%rbp),%edi
call   1130 <hwloc_bitmap_weight@plt>
cmp    $0x24,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
call   10f0 <hwloc_bitmap_last@plt>
cmp    $0x39,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <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   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
mov    $0x39,%esi
call   1070 <hwloc_bitmap_clr@plt>
mov    -0x8(%rbp),%edi
call   1130 <hwloc_bitmap_weight@plt>
cmp    $0x23,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
call   10f0 <hwloc_bitmap_last@plt>
cmp    $0x22,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
mov    $0x22,%edx
call   10e0 <hwloc_bitmap_clr_range@plt>
mov    -0x8(%rbp),%edi
call   1130 <hwloc_bitmap_weight@plt>
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <assert@plt>
mov    -0x8(%rbp),%edi
call   1090 <hwloc_bitmap_first@plt>
cmp    $0xffffffff,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   10b0 <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   10b0 <assert@plt>
mov    %ebx,%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x4,%esi
mov    $0xff,%edx
call   1120 <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,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
call   1050 <hwloc_bitmap_to_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
call   1110 <hwloc_bitmap_zero@plt>
mov    %ebx,%edi
call   1050 <hwloc_bitmap_to_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x4,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
call   1060 <hwloc_bitmap_free@plt>
xor    %eax,%eax
call   10d0 <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   10b0 <assert@plt>
mov    %ebx,%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xffffffffffffffff,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xffffffffffffffff,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xffffffffffffffff,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x4,%esi
mov    $0xff,%edx
call   10c0 <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,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
call   1050 <hwloc_bitmap_to_ulong@plt>
xor    %edi,%edi
cmp    $0xffffffffffffffff,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xffffffffffffffff,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xffffffffffffffff,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
cmp    $0xffffffffffffffff,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x4,%esi
mov    $0xff,%edx
call   1120 <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,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
call   1050 <hwloc_bitmap_to_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
xor    %esi,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x1,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x17,%esi
call   1080 <hwloc_bitmap_to_ith_ulong@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   10b0 <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   1130 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x17,%esi
mov    $0x2d,%edx
call   10a0 <hwloc_bitmap_set_range@plt>
mov    %ebx,%edi
call   1130 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0x17,%eax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x4e,%esi
mov    $0xffffffff,%edx
call   10a0 <hwloc_bitmap_set_range@plt>
mov    %ebx,%edi
call   1130 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x2c,%esi
mov    $0x4f,%edx
call   10a0 <hwloc_bitmap_set_range@plt>
mov    %ebx,%edi
call   1130 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
call   1090 <hwloc_bitmap_first@plt>
xor    %edi,%edi
cmp    $0x17,%eax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
call   1100 <hwloc_bitmap_isfull@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x16,%edx
call   10a0 <hwloc_bitmap_set_range@plt>
mov    %ebx,%edi
call   1130 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
call   1100 <hwloc_bitmap_isfull@plt>
mov    %eax,%edi
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x23,%esi
mov    $0x38,%edx
call   10e0 <hwloc_bitmap_clr_range@plt>
mov    %ebx,%edi
call   1130 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
call   1100 <hwloc_bitmap_isfull@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x3a,%esi
mov    $0xffffffff,%edx
call   10e0 <hwloc_bitmap_clr_range@plt>
mov    %ebx,%edi
call   1130 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0x24,%eax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
call   10f0 <hwloc_bitmap_last@plt>
xor    %edi,%edi
cmp    $0x39,%eax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x22,%esi
call   1030 <hwloc_bitmap_next@plt>
xor    %edi,%edi
cmp    $0x39,%eax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
mov    $0x39,%esi
call   1070 <hwloc_bitmap_clr@plt>
mov    %ebx,%edi
call   1130 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
cmp    $0x23,%eax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
call   10f0 <hwloc_bitmap_last@plt>
xor    %edi,%edi
cmp    $0x22,%eax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x22,%edx
call   10e0 <hwloc_bitmap_clr_range@plt>
mov    %ebx,%edi
call   1130 <hwloc_bitmap_weight@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   10b0 <assert@plt>
mov    %ebx,%edi
call   1090 <hwloc_bitmap_first@plt>
xor    %edi,%edi
cmp    $0xffffffff,%eax
sete   %dil
call   10b0 <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 i64 @hwloc_bitmap_to_ith_ulong(i32 %9, i32 0)
%11 = icmp eq i64 %10, 0
%12 = zext i1 %11 to i32
%13 = call i32 @assert(i32 %12)
%14 = load i32, i32* %2
%15 = call i64 @hwloc_bitmap_to_ith_ulong(i32 %14, i32 1)
%16 = icmp eq i64 %15, 0
%17 = zext i1 %16 to i32
%18 = call i32 @assert(i32 %17)
%19 = load i32, i32* %2
%20 = call i64 @hwloc_bitmap_to_ith_ulong(i32 %19, i32 23)
%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_from_ith_ulong(i32 %24, i32 4, i32 255)
%26 = load i32, i32* %2
%27 = call i64 @hwloc_bitmap_to_ith_ulong(i32 %26, i32 4)
%28 = icmp eq i64 %27, 255
%29 = zext i1 %28 to i32
%30 = call i32 @assert(i32 %29)
%31 = load i32, i32* %2
%32 = call i64 @hwloc_bitmap_to_ulong(i32 %31)
%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 i64 @hwloc_bitmap_to_ith_ulong(i32 %36, i32 0)
%38 = icmp eq i64 %37, 0
%39 = zext i1 %38 to i32
%40 = call i32 @assert(i32 %39)
%41 = load i32, i32* %2
%42 = call i64 @hwloc_bitmap_to_ith_ulong(i32 %41, i32 1)
%43 = icmp eq i64 %42, 0
%44 = zext i1 %43 to i32
%45 = call i32 @assert(i32 %44)
%46 = load i32, i32* %2
%47 = call i64 @hwloc_bitmap_to_ith_ulong(i32 %46, i32 23)
%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_zero(i32 %51)
%53 = load i32, i32* %2
%54 = call i64 @hwloc_bitmap_to_ulong(i32 %53)
%55 = icmp eq i64 %54, 0
%56 = zext i1 %55 to i32
%57 = call i32 @assert(i32 %56)
%58 = load i32, i32* %2
%59 = call i64 @hwloc_bitmap_to_ith_ulong(i32 %58, i32 0)
%60 = icmp eq i64 %59, 0
%61 = zext i1 %60 to i32
%62 = call i32 @assert(i32 %61)
%63 = load i32, i32* %2
%64 = call i64 @hwloc_bitmap_to_ith_ulong(i32 %63, i32 1)
%65 = icmp eq i64 %64, 0
%66 = zext i1 %65 to i32
%67 = call i32 @assert(i32 %66)
%68 = load i32, i32* %2
%69 = call i64 @hwloc_bitmap_to_ith_ulong(i32 %68, i32 4)
%70 = icmp eq i64 %69, 0
%71 = zext i1 %70 to i32
%72 = call i32 @assert(i32 %71)
%73 = load i32, i32* %2
%74 = call i64 @hwloc_bitmap_to_ith_ulong(i32 %73, i32 23)
%75 = icmp eq i64 %74, 0
%76 = zext i1 %75 to i32
%77 = call i32 @assert(i32 %76)
%78 = load i32, i32* %2
%79 = call i32 @hwloc_bitmap_free(i32 %78)
%80 = call i32 (...) @hwloc_bitmap_alloc_full()
store i32 %80, i32* %2
%81 = load i32, i32* %2
%82 = call i64 @hwloc_bitmap_to_ulong(i32 %81)
%83 = icmp eq i64 %82, -1
%84 = zext i1 %83 to i32
%85 = call i32 @assert(i32 %84)
%86 = load i32, i32* %2
%87 = call i64 @hwloc_bitmap_to_ith_ulong(i32 %86, i32 0)
%88 = icmp eq i64 %87, -1
%89 = zext i1 %88 to i32
%90 = call i32 @assert(i32 %89)
%91 = load i32, i32* %2
%92 = call i64 @hwloc_bitmap_to_ith_ulong(i32 %91, i32 1)
%93 = icmp eq i64 %92, -1
%94 = zext i1 %93 to i32
%95 = call i32 @assert(i32 %94)
%96 = load i32, i32* %2
%97 = call i64 @hwloc_bitmap_to_ith_ulong(i32 %96, i32 23)
%98 = icmp eq i64 %97, -1
%99 = zext i1 %98 to i32
%100 = call i32 @assert(i32 %99)
%101 = load i32, i32* %2
%102 = call i32 @hwloc_bitmap_set_ith_ulong(i32 %101, i32 4, i32 255)
%103 = load i32, i32* %2
%104 = call i64 @hwloc_bitmap_to_ith_ulong(i32 %103, i32 4)
%105 = icmp eq i64 %104, 255
%106 = zext i1 %105 to i32
%107 = call i32 @assert(i32 %106)
%108 = load i32, i32* %2
%109 = call i64 @hwloc_bitmap_to_ulong(i32 %108)
%110 = icmp eq i64 %109, -1
%111 = zext i1 %110 to i32
%112 = call i32 @assert(i32 %111)
%113 = load i32, i32* %2
%114 = call i64 @hwloc_bitmap_to_ith_ulong(i32 %113, i32 0)
%115 = icmp eq i64 %114, -1
%116 = zext i1 %115 to i32
%117 = call i32 @assert(i32 %116)
%118 = load i32, i32* %2
%119 = call i64 @hwloc_bitmap_to_ith_ulong(i32 %118, i32 1)
%120 = icmp eq i64 %119, -1
%121 = zext i1 %120 to i32
%122 = call i32 @assert(i32 %121)
%123 = load i32, i32* %2
%124 = call i64 @hwloc_bitmap_to_ith_ulong(i32 %123, i32 23)
%125 = icmp eq i64 %124, -1
%126 = zext i1 %125 to i32
%127 = call i32 @assert(i32 %126)
%128 = load i32, i32* %2
%129 = call i32 @hwloc_bitmap_from_ith_ulong(i32 %128, i32 4, i32 255)
%130 = load i32, i32* %2
%131 = call i64 @hwloc_bitmap_to_ith_ulong(i32 %130, i32 4)
%132 = icmp eq i64 %131, 255
%133 = zext i1 %132 to i32
%134 = call i32 @assert(i32 %133)
%135 = load i32, i32* %2
%136 = call i64 @hwloc_bitmap_to_ulong(i32 %135)
%137 = icmp eq i64 %136, 0
%138 = zext i1 %137 to i32
%139 = call i32 @assert(i32 %138)
%140 = load i32, i32* %2
%141 = call i64 @hwloc_bitmap_to_ith_ulong(i32 %140, i32 0)
%142 = icmp eq i64 %141, 0
%143 = zext i1 %142 to i32
%144 = call i32 @assert(i32 %143)
%145 = load i32, i32* %2
%146 = call i64 @hwloc_bitmap_to_ith_ulong(i32 %145, i32 1)
%147 = icmp eq i64 %146, 0
%148 = zext i1 %147 to i32
%149 = call i32 @assert(i32 %148)
%150 = load i32, i32* %2
%151 = call i64 @hwloc_bitmap_to_ith_ulong(i32 %150, i32 23)
%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()
store i32 %157, i32* %2
%158 = load i32, i32* %2
%159 = call i32 @hwloc_bitmap_weight(i32 %158)
%160 = icmp eq i32 %159, 0
%161 = zext i1 %160 to i32
%162 = call i32 @assert(i32 %161)
%163 = load i32, i32* %2
%164 = call i32 @hwloc_bitmap_set_range(i32 %163, i32 23, i32 45)
%165 = load i32, i32* %2
%166 = call i32 @hwloc_bitmap_weight(i32 %165)
%167 = icmp eq i32 %166, 23
%168 = zext i1 %167 to i32
%169 = call i32 @assert(i32 %168)
%170 = load i32, i32* %2
%171 = call i32 @hwloc_bitmap_set_range(i32 %170, i32 78, i32 -1)
%172 = load i32, i32* %2
%173 = call i32 @hwloc_bitmap_weight(i32 %172)
%174 = icmp eq i32 %173, -1
%175 = zext i1 %174 to i32
%176 = call i32 @assert(i32 %175)
%177 = load i32, i32* %2
%178 = call i32 @hwloc_bitmap_set_range(i32 %177, i32 44, i32 79)
%179 = load i32, i32* %2
%180 = call i32 @hwloc_bitmap_weight(i32 %179)
%181 = icmp eq i32 %180, -1
%182 = zext i1 %181 to i32
%183 = call i32 @assert(i32 %182)
%184 = load i32, i32* %2
%185 = call i32 @hwloc_bitmap_first(i32 %184)
%186 = icmp eq i32 %185, 23
%187 = zext i1 %186 to i32
%188 = call i32 @assert(i32 %187)
%189 = load i32, i32* %2
%190 = call i32 @hwloc_bitmap_isfull(i32 %189)
%191 = icmp ne i32 %190, 0
%192 = xor i1 %191, true
%193 = zext i1 %192 to i32
%194 = call i32 @assert(i32 %193)
%195 = load i32, i32* %2
%196 = call i32 @hwloc_bitmap_set_range(i32 %195, i32 0, i32 22)
%197 = load i32, i32* %2
%198 = call i32 @hwloc_bitmap_weight(i32 %197)
%199 = icmp eq i32 %198, -1
%200 = zext i1 %199 to i32
%201 = call i32 @assert(i32 %200)
%202 = load i32, i32* %2
%203 = call i32 @hwloc_bitmap_isfull(i32 %202)
%204 = call i32 @assert(i32 %203)
%205 = load i32, i32* %2
%206 = call i32 @hwloc_bitmap_clr_range(i32 %205, i32 35, i32 56)
%207 = load i32, i32* %2
%208 = call i32 @hwloc_bitmap_weight(i32 %207)
%209 = icmp eq i32 %208, -1
%210 = zext i1 %209 to i32
%211 = call i32 @assert(i32 %210)
%212 = load i32, i32* %2
%213 = call i32 @hwloc_bitmap_isfull(i32 %212)
%214 = icmp ne i32 %213, 0
%215 = xor i1 %214, true
%216 = zext i1 %215 to i32
%217 = call i32 @assert(i32 %216)
%218 = load i32, i32* %2
%219 = call i32 @hwloc_bitmap_clr_range(i32 %218, i32 58, i32 -1)
%220 = load i32, i32* %2
%221 = call i32 @hwloc_bitmap_weight(i32 %220)
%222 = icmp eq i32 %221, 36
%223 = zext i1 %222 to i32
%224 = call i32 @assert(i32 %223)
%225 = load i32, i32* %2
%226 = call i32 @hwloc_bitmap_last(i32 %225)
%227 = icmp eq i32 %226, 57
%228 = zext i1 %227 to i32
%229 = call i32 @assert(i32 %228)
%230 = load i32, i32* %2
%231 = call i32 @hwloc_bitmap_next(i32 %230, i32 34)
%232 = icmp eq i32 %231, 57
%233 = zext i1 %232 to i32
%234 = call i32 @assert(i32 %233)
%235 = load i32, i32* %2
%236 = call i32 @hwloc_bitmap_clr(i32 %235, i32 57)
%237 = load i32, i32* %2
%238 = call i32 @hwloc_bitmap_weight(i32 %237)
%239 = icmp eq i32 %238, 35
%240 = zext i1 %239 to i32
%241 = call i32 @assert(i32 %240)
%242 = load i32, i32* %2
%243 = call i32 @hwloc_bitmap_last(i32 %242)
%244 = icmp eq i32 %243, 34
%245 = zext i1 %244 to i32
%246 = call i32 @assert(i32 %245)
%247 = load i32, i32* %2
%248 = call i32 @hwloc_bitmap_clr_range(i32 %247, i32 0, i32 34)
%249 = load i32, i32* %2
%250 = call i32 @hwloc_bitmap_weight(i32 %249)
%251 = icmp eq i32 %250, 0
%252 = zext i1 %251 to i32
%253 = call i32 @assert(i32 %252)
%254 = load i32, i32* %2
%255 = call i32 @hwloc_bitmap_first(i32 %254)
%256 = icmp eq i32 %255, -1
%257 = zext i1 %256 to i32
%258 = call i32 @assert(i32 %257)
%259 = load i32, i32* %2
%260 = call i32 @hwloc_bitmap_free(i32 %259)
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 i64 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 0)
%7 = icmp eq i64 %6, 0
%8 = zext i1 %7 to i32
%9 = tail call i32 @assert(i32 %8)
%10 = tail call i64 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 1)
%11 = icmp eq i64 %10, 0
%12 = zext i1 %11 to i32
%13 = tail call i32 @assert(i32 %12)
%14 = tail call i64 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 23)
%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_from_ith_ulong(i32 %1, i32 4, i32 255)
%19 = tail call i64 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 4)
%20 = icmp eq i64 %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 i64 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 0)
%28 = icmp eq i64 %27, 0
%29 = zext i1 %28 to i32
%30 = tail call i32 @assert(i32 %29)
%31 = tail call i64 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 1)
%32 = icmp eq i64 %31, 0
%33 = zext i1 %32 to i32
%34 = tail call i32 @assert(i32 %33)
%35 = tail call i64 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 23)
%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_zero(i32 %1)
%40 = tail call i64 @hwloc_bitmap_to_ulong(i32 %1)
%41 = icmp eq i64 %40, 0
%42 = zext i1 %41 to i32
%43 = tail call i32 @assert(i32 %42)
%44 = tail call i64 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 0)
%45 = icmp eq i64 %44, 0
%46 = zext i1 %45 to i32
%47 = tail call i32 @assert(i32 %46)
%48 = tail call i64 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 1)
%49 = icmp eq i64 %48, 0
%50 = zext i1 %49 to i32
%51 = tail call i32 @assert(i32 %50)
%52 = tail call i64 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 4)
%53 = icmp eq i64 %52, 0
%54 = zext i1 %53 to i32
%55 = tail call i32 @assert(i32 %54)
%56 = tail call i64 @hwloc_bitmap_to_ith_ulong(i32 %1, i32 23)
%57 = icmp eq i64 %56, 0
%58 = zext i1 %57 to i32
%59 = tail call i32 @assert(i32 %58)
%60 = tail call i32 @hwloc_bitmap_free(i32 %1)
%61 = tail call i32 (...) @hwloc_bitmap_alloc_full()
%62 = tail call i64 @hwloc_bitmap_to_ulong(i32 %61)
%63 = icmp eq i64 %62, -1
%64 = zext i1 %63 to i32
%65 = tail call i32 @assert(i32 %64)
%66 = tail call i64 @hwloc_bitmap_to_ith_ulong(i32 %61, i32 0)
%67 = icmp eq i64 %66, -1
%68 = zext i1 %67 to i32
%69 = tail call i32 @assert(i32 %68)
%70 = tail call i64 @hwloc_bitmap_to_ith_ulong(i32 %61, i32 1)
%71 = icmp eq i64 %70, -1
%72 = zext i1 %71 to i32
%73 = tail call i32 @assert(i32 %72)
%74 = tail call i64 @hwloc_bitmap_to_ith_ulong(i32 %61, i32 23)
%75 = icmp eq i64 %74, -1
%76 = zext i1 %75 to i32
%77 = tail call i32 @assert(i32 %76)
%78 = tail call i32 @hwloc_bitmap_set_ith_ulong(i32 %61, i32 4, i32 255)
%79 = tail call i64 @hwloc_bitmap_to_ith_ulong(i32 %61, i32 4)
%80 = icmp eq i64 %79, 255
%81 = zext i1 %80 to i32
%82 = tail call i32 @assert(i32 %81)
%83 = tail call i64 @hwloc_bitmap_to_ulong(i32 %61)
%84 = icmp eq i64 %83, -1
%85 = zext i1 %84 to i32
%86 = tail call i32 @assert(i32 %85)
%87 = tail call i64 @hwloc_bitmap_to_ith_ulong(i32 %61, i32 0)
%88 = icmp eq i64 %87, -1
%89 = zext i1 %88 to i32
%90 = tail call i32 @assert(i32 %89)
%91 = tail call i64 @hwloc_bitmap_to_ith_ulong(i32 %61, i32 1)
%92 = icmp eq i64 %91, -1
%93 = zext i1 %92 to i32
%94 = tail call i32 @assert(i32 %93)
%95 = tail call i64 @hwloc_bitmap_to_ith_ulong(i32 %61, i32 23)
%96 = icmp eq i64 %95, -1
%97 = zext i1 %96 to i32
%98 = tail call i32 @assert(i32 %97)
%99 = tail call i32 @hwloc_bitmap_from_ith_ulong(i32 %61, i32 4, i32 255)
%100 = tail call i64 @hwloc_bitmap_to_ith_ulong(i32 %61, i32 4)
%101 = icmp eq i64 %100, 255
%102 = zext i1 %101 to i32
%103 = tail call i32 @assert(i32 %102)
%104 = tail call i64 @hwloc_bitmap_to_ulong(i32 %61)
%105 = icmp eq i64 %104, 0
%106 = zext i1 %105 to i32
%107 = tail call i32 @assert(i32 %106)
%108 = tail call i64 @hwloc_bitmap_to_ith_ulong(i32 %61, i32 0)
%109 = icmp eq i64 %108, 0
%110 = zext i1 %109 to i32
%111 = tail call i32 @assert(i32 %110)
%112 = tail call i64 @hwloc_bitmap_to_ith_ulong(i32 %61, i32 1)
%113 = icmp eq i64 %112, 0
%114 = zext i1 %113 to i32
%115 = tail call i32 @assert(i32 %114)
%116 = tail call i64 @hwloc_bitmap_to_ith_ulong(i32 %61, i32 23)
%117 = icmp eq i64 %116, 0
%118 = zext i1 %117 to i32
%119 = tail call i32 @assert(i32 %118)
%120 = tail call i32 @hwloc_bitmap_free(i32 %61)
%121 = tail call i32 (...) @hwloc_bitmap_alloc()
%122 = tail call i32 @hwloc_bitmap_weight(i32 %121)
%123 = icmp eq i32 %122, 0
%124 = zext i1 %123 to i32
%125 = tail call i32 @assert(i32 %124)
%126 = tail call i32 @hwloc_bitmap_set_range(i32 %121, i32 23, i32 45)
%127 = tail call i32 @hwloc_bitmap_weight(i32 %121)
%128 = icmp eq i32 %127, 23
%129 = zext i1 %128 to i32
%130 = tail call i32 @assert(i32 %129)
%131 = tail call i32 @hwloc_bitmap_set_range(i32 %121, i32 78, i32 -1)
%132 = tail call i32 @hwloc_bitmap_weight(i32 %121)
%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_set_range(i32 %121, i32 44, i32 79)
%137 = tail call i32 @hwloc_bitmap_weight(i32 %121)
%138 = icmp eq i32 %137, -1
%139 = zext i1 %138 to i32
%140 = tail call i32 @assert(i32 %139)
%141 = tail call i32 @hwloc_bitmap_first(i32 %121)
%142 = icmp eq i32 %141, 23
%143 = zext i1 %142 to i32
%144 = tail call i32 @assert(i32 %143)
%145 = tail call i32 @hwloc_bitmap_isfull(i32 %121)
%146 = icmp eq i32 %145, 0
%147 = zext i1 %146 to i32
%148 = tail call i32 @assert(i32 %147)
%149 = tail call i32 @hwloc_bitmap_set_range(i32 %121, i32 0, i32 22)
%150 = tail call i32 @hwloc_bitmap_weight(i32 %121)
%151 = icmp eq i32 %150, -1
%152 = zext i1 %151 to i32
%153 = tail call i32 @assert(i32 %152)
%154 = tail call i32 @hwloc_bitmap_isfull(i32 %121)
%155 = tail call i32 @assert(i32 %154)
%156 = tail call i32 @hwloc_bitmap_clr_range(i32 %121, i32 35, i32 56)
%157 = tail call i32 @hwloc_bitmap_weight(i32 %121)
%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_isfull(i32 %121)
%162 = icmp eq i32 %161, 0
%163 = zext i1 %162 to i32
%164 = tail call i32 @assert(i32 %163)
%165 = tail call i32 @hwloc_bitmap_clr_range(i32 %121, i32 58, i32 -1)
%166 = tail call i32 @hwloc_bitmap_weight(i32 %121)
%167 = icmp eq i32 %166, 36
%168 = zext i1 %167 to i32
%169 = tail call i32 @assert(i32 %168)
%170 = tail call i32 @hwloc_bitmap_last(i32 %121)
%171 = icmp eq i32 %170, 57
%172 = zext i1 %171 to i32
%173 = tail call i32 @assert(i32 %172)
%174 = tail call i32 @hwloc_bitmap_next(i32 %121, i32 34)
%175 = icmp eq i32 %174, 57
%176 = zext i1 %175 to i32
%177 = tail call i32 @assert(i32 %176)
%178 = tail call i32 @hwloc_bitmap_clr(i32 %121, i32 57)
%179 = tail call i32 @hwloc_bitmap_weight(i32 %121)
%180 = icmp eq i32 %179, 35
%181 = zext i1 %180 to i32
%182 = tail call i32 @assert(i32 %181)
%183 = tail call i32 @hwloc_bitmap_last(i32 %121)
%184 = icmp eq i32 %183, 34
%185 = zext i1 %184 to i32
%186 = tail call i32 @assert(i32 %185)
%187 = tail call i32 @hwloc_bitmap_clr_range(i32 %121, i32 0, i32 34)
%188 = tail call i32 @hwloc_bitmap_weight(i32 %121)
%189 = icmp eq i32 %188, 0
%190 = zext i1 %189 to i32
%191 = tail call i32 @assert(i32 %190)
%192 = tail call i32 @hwloc_bitmap_first(i32 %121)
%193 = icmp eq i32 %192, -1
%194 = zext i1 %193 to i32
%195 = tail call i32 @assert(i32 %194)
%196 = tail call i32 @hwloc_bitmap_free(i32 %121)
ret i32 0
}