LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_chunk_alloc_internal_hard
static arena_chunk_t *
arena_chunk_alloc_internal_hard(arena_t *arena, chunk_hooks_t *chunk_hooks,
    bool *zero, bool *commit)
{
	arena_chunk_t *chunk;

	malloc_mutex_unlock(&arena->lock);

	chunk = (arena_chunk_t *)chunk_alloc_wrapper(arena, chunk_hooks, NULL,
	    chunksize, chunksize, zero, commit);
	if (chunk != NULL && !*commit) {
		/* Commit header. */
		if (chunk_hooks->commit(chunk, chunksize, 0, map_bias <<
		    LG_PAGE, arena->ind)) {
			chunk_dalloc_wrapper(arena, chunk_hooks,
			    (void *)chunk, chunksize, *commit);
			chunk = NULL;
		}
	}
	if (chunk != NULL && arena_chunk_register(arena, chunk, *zero)) {
		if (!*commit) {
			/* Undo commit of header. */
			chunk_hooks->decommit(chunk, chunksize, 0, map_bias <<
			    LG_PAGE, arena->ind);
		}
		chunk_dalloc_wrapper(arena, chunk_hooks, (void *)chunk,
		    chunksize, *commit);
		chunk = NULL;
	}

	malloc_mutex_lock(&arena->lock);
	return (chunk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x5c304(%rip), %rax     # 0xa2728
movq (%rax), %rcx
leaq 0x5c2fa(%rip), %rax     # 0xa2728
movq (%rax), %r8
movq -0x18(%rbp), %r9
movq -0x20(%rbp), %rax
xorl %edx, %edx
movq %rax, (%rsp)
callq 0x50db0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x464bb
movq -0x20(%rbp), %rax
testb $0x1, (%rax)
jne 0x464bb
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rdi
leaq 0x5c2bd(%rip), %rcx     # 0xa2728
movq (%rcx), %rsi
movq 0x5c163(%rip), %rcx     # 0xa25d8
shlq $0xc, %rcx
movq -0x8(%rbp), %rdx
movl (%rdx), %r8d
xorl %edx, %edx
callq *%rax
testb $0x1, %al
jne 0x4648a
jmp 0x464b9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq 0x5c28b(%rip), %rax     # 0xa2728
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x515c0
movq $0x0, -0x28(%rbp)
jmp 0x464bb
cmpq $0x0, -0x28(%rbp)
je 0x46548
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x46380
testb $0x1, %al
jne 0x464e4
jmp 0x46548
movq -0x20(%rbp), %rax
testb $0x1, (%rax)
jne 0x46519
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rdi
leaq 0x5c228(%rip), %rcx     # 0xa2728
movq (%rcx), %rsi
movq 0x5c0ce(%rip), %rcx     # 0xa25d8
shlq $0xc, %rcx
movq -0x8(%rbp), %rdx
movl (%rdx), %r8d
xorl %edx, %edx
callq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq 0x5c1fc(%rip), %rax     # 0xa2728
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x515c0
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3a0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/extent.h
// Function: je_extent_node_init
JEMALLOC_INLINE void
extent_node_init(extent_node_t *node, arena_t *arena, void *addr, size_t size,
    bool zeroed, bool committed)
{

	extent_node_arena_set(node, arena);
	extent_node_addr_set(node, addr);
	extent_node_size_set(node, size);
	extent_node_zeroed_set(node, zeroed);
	extent_node_committed_set(node, committed);
	extent_node_achunk_set(node, false);
	if (config_prof)
		extent_node_prof_tctx_set(node, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %r8d, -0x44(%rbp)
movq %rcx, %rax
movl -0x44(%rbp), %ecx
movq %rax, -0x40(%rbp)
movq %rdx, %rax
movq -0x40(%rbp), %rdx
movq %rax, -0x38(%rbp)
movq %rsi, %rax
movq -0x38(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq %rdi, %r8
movq -0x30(%rbp), %rdi
movb %r9b, %al
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %cl
movb %cl, -0x21(%rbp)
andb $0x1, %al
movb %al, -0x22(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x46630
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x46650
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x46670
movq -0x8(%rbp), %rdi
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x46690
movq -0x8(%rbp), %rdi
movb -0x22(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x466b0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x46610
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_avail_comp
JEMALLOC_INLINE_C int
arena_avail_comp(arena_chunk_map_misc_t *a, arena_chunk_map_misc_t *b)
{
	int ret;
	uintptr_t a_miscelm = (uintptr_t)a;
	size_t a_qsize = run_quantize(arena_miscelm_is_key(a) ?
	    arena_miscelm_key_size_get(a) : arena_miscelm_size_get(a));
	size_t b_qsize = run_quantize(arena_miscelm_size_get(b));

	/*
	 * Compare based on quantized size rather than size, in order to sort
	 * equally useful runs only by address.
	 */
	ret = (a_qsize > b_qsize) - (a_qsize < b_qsize);
	if (ret == 0) {
		if (!arena_miscelm_is_key(a)) {
			uintptr_t b_miscelm = (uintptr_t)b;

			ret = (a_miscelm > b_miscelm) - (a_miscelm < b_miscelm);
		} else {
			/*
			 * Treat keys as if they are lower than anything else.
			 */
			ret = -1;
		}
	}

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x46d10
testb $0x1, %al
jne 0x46b47
jmp 0x46b56
movq -0x8(%rbp), %rdi
callq 0x46d30
movq %rax, -0x40(%rbp)
jmp 0x46b63
movq -0x8(%rbp), %rdi
callq 0x46d60
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x46c00
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x46d60
movq %rax, %rdi
callq 0x46c00
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x28(%rbp), %rcx
cmpq -0x30(%rbp), %rcx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x46bf7
movq -0x8(%rbp), %rdi
callq 0x46d10
testb $0x1, %al
jne 0x46bee
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x38(%rbp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x20(%rbp), %rcx
cmpq -0x38(%rbp), %rcx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x46bf5
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x46bf7
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_miscelm_size_get
JEMALLOC_INLINE_C size_t
arena_miscelm_size_get(arena_chunk_map_misc_t *miscelm)
{
	arena_chunk_t *chunk;
	size_t pageind, mapbits;

	assert(!arena_miscelm_is_key(miscelm));

	chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(miscelm);
	pageind = arena_miscelm_to_pageind(miscelm);
	mapbits = arena_mapbits_get(chunk, pageind);
	return (arena_mapbits_size_decode(mapbits));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x68(%rbp)
jmp 0x46d6a
movq -0x68(%rbp), %rax
leaq 0x5b9bb(%rip), %rcx     # 0xa2730
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
leaq 0x5b99a(%rip), %rcx     # 0xa2730
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
addq 0x5b82d(%rip), %rcx     # 0xa25e0
subq %rcx, %rax
movl $0x60, %ecx
xorl %edx, %edx
divq %rcx
addq 0x5b811(%rip), %rax     # 0xa25d8
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rcx
movq -0x78(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x68, %rax
movq -0x10(%rbp), %rcx
subq 0x5b7c2(%rip), %rcx     # 0xa25d8
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
andq $-0x2000, %rax          # imm = 0xE000
shrq %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_run_zero
JEMALLOC_INLINE_C void
arena_run_zero(arena_chunk_t *chunk, size_t run_ind, size_t npages)
{

	JEMALLOC_VALGRIND_MAKE_MEM_UNDEFINED((void *)((uintptr_t)chunk +
	    (run_ind << LG_PAGE)), (npages << LG_PAGE));
	memset((void *)((uintptr_t)chunk + (run_ind << LG_PAGE)), 0,
	    (npages << LG_PAGE));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x59aa9(%rip), %rax     # 0xa1704
movb (%rax), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x47c8a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
shlq $0xc, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
shlq $0xc, %rsi
callq 0x7faa0
jmp 0x47c8c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
shlq $0xc, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rdx
shlq $0xc, %rdx
xorl %esi, %esi
callq 0x10250
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_avail_remove
static void
arena_avail_remove(arena_t *arena, arena_chunk_t *chunk, size_t pageind,
    size_t npages)
{

	assert(npages == (arena_mapbits_unallocated_size_get(chunk, pageind) >>
	    LG_PAGE));
	arena_avail_tree_remove(&arena->runs_avail, arena_miscelm_get(chunk,
	    pageind));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
jmp 0x47d1a
movq -0x18(%rbp), %rdi
addq $0xf0, %rdi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
addq 0x5a8a0(%rip), %rsi     # 0xa25e0
imulq $0x60, -0x10(%rbp), %rax
addq %rax, %rsi
xorl %eax, %eax
subq 0x5a887(%rip), %rax     # 0xa25d8
imulq $0x60, %rax, %rax
addq %rax, %rsi
callq 0x47fb0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_run_dirty_remove
static void
arena_run_dirty_remove(arena_t *arena, arena_chunk_t *chunk, size_t pageind,
    size_t npages)
{
	arena_chunk_map_misc_t *miscelm = arena_miscelm_get(chunk, pageind);

	assert(npages == (arena_mapbits_unallocated_size_get(chunk, pageind) >>
	    LG_PAGE));
	assert(arena_mapbits_dirty_get(chunk, pageind) == CHUNK_MAP_DIRTY);
	assert(arena_mapbits_dirty_get(chunk, pageind+npages-1) ==
	    CHUNK_MAP_DIRTY);

	qr_remove(&miscelm->rd, rd_link);
	assert(arena->ndirty >= npages);
	arena->ndirty -= npages;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq 0x5a841(%rip), %rax     # 0xa25e0
imulq $0x60, -0x10(%rbp), %rcx
addq %rcx, %rax
xorl %ecx, %ecx
subq 0x5a828(%rip), %rcx     # 0xa25d8
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x47dbd
jmp 0x47dbf
jmp 0x47dc1
jmp 0x47dc3
jmp 0x47dc5
jmp 0x47dc7
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
addq $0x10, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
addq $0x10, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x47e10
jmp 0x47e12
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0xe8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0xe8(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_cactive_update
static void
arena_cactive_update(arena_t *arena, size_t add_pages, size_t sub_pages)
{

	if (config_stats) {
		ssize_t cactive_diff = CHUNK_CEILING((arena->nactive + add_pages
		    - sub_pages) << LG_PAGE) - CHUNK_CEILING(arena->nactive <<
		    LG_PAGE);
		if (cactive_diff != 0)
			stats_cactive_add(cactive_diff);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rax
addq -0x10(%rbp), %rax
subq -0x18(%rbp), %rax
shlq $0xc, %rax
leaq 0x5a8ce(%rip), %rcx     # 0xa2730
addq (%rcx), %rax
leaq 0x5a8c4(%rip), %rcx     # 0xa2730
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0xe0(%rcx), %rcx
shlq $0xc, %rcx
leaq 0x5a8a4(%rip), %rdx     # 0xa2730
addq (%rdx), %rcx
leaq 0x5a89a(%rip), %rdx     # 0xa2730
movq (%rdx), %rdx
xorq $-0x1, %rdx
andq %rdx, %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x47eb7
movq -0x20(%rbp), %rdi
callq 0x3c770
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_run_dirty_insert
static void
arena_run_dirty_insert(arena_t *arena, arena_chunk_t *chunk, size_t pageind,
    size_t npages)
{
	arena_chunk_map_misc_t *miscelm = arena_miscelm_get(chunk, pageind);

	assert(npages == (arena_mapbits_unallocated_size_get(chunk, pageind) >>
	    LG_PAGE));
	assert(arena_mapbits_dirty_get(chunk, pageind) == CHUNK_MAP_DIRTY);
	assert(arena_mapbits_dirty_get(chunk, pageind+npages-1) ==
	    CHUNK_MAP_DIRTY);

	qr_new(&miscelm->rd, rd_link);
	qr_meld(&arena->runs_dirty, &miscelm->rd, rd_link);
	arena->ndirty += npages;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq 0x5a6f1(%rip), %rax     # 0xa25e0
imulq $0x60, -0x10(%rbp), %rcx
addq %rcx, %rax
xorl %ecx, %ecx
subq 0x5a6d8(%rip), %rcx     # 0xa25d8
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x47f0d
jmp 0x47f0f
jmp 0x47f11
jmp 0x47f13
jmp 0x47f15
jmp 0x47f17
movq -0x38(%rbp), %rcx
addq $0x10, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
addq $0x10, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x47f39
movq -0x38(%rbp), %rcx
addq $0x10, %rcx
movq -0x18(%rbp), %rax
movq 0x160(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
addq $0x158, %rcx            # imm = 0x158
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x160(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x160(%rax)
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0xe8(%rax), %rcx
movq %rcx, 0xe8(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_run_size_get
static size_t
arena_run_size_get(arena_t *arena, arena_chunk_t *chunk, arena_run_t *run,
    size_t run_ind)
{
	size_t size;

	assert(run_ind >= map_bias);
	assert(run_ind < chunk_npages);

	if (arena_mapbits_large_get(chunk, run_ind) != 0) {
		size = arena_mapbits_large_size_get(chunk, run_ind);
		assert(size == PAGE || arena_mapbits_large_size_get(chunk,
		    run_ind+(size>>LG_PAGE)-1) == 0);
	} else {
		arena_bin_info_t *bin_info = &arena_bin_info[run->binind];
		size = bin_info->run_size;
	}

	return (size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0xb8(%rbp)
movq %rsi, -0xc0(%rbp)
movq %rdx, -0xc8(%rbp)
movq %rcx, -0xd0(%rbp)
jmp 0x49626
jmp 0x49628
jmp 0x4962a
movq -0xc0(%rbp), %rcx
movq -0xd0(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x68, %rax
movq -0x10(%rbp), %rcx
subq 0x58f55(%rip), %rcx     # 0xa25d8
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0x49766
movq -0xc0(%rbp), %rcx
movq -0xd0(%rbp), %rax
movq %rcx, -0xa0(%rbp)
movq %rax, -0xa8(%rbp)
movq -0xa0(%rbp), %rcx
movq -0xa8(%rbp), %rax
movq %rcx, -0x90(%rbp)
movq %rax, -0x98(%rbp)
movq -0x90(%rbp), %rcx
movq -0x98(%rbp), %rax
movq %rcx, -0x68(%rbp)
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
addq $0x68, %rax
movq -0x60(%rbp), %rcx
subq 0x58ebc(%rip), %rcx     # 0xa25d8
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
andq $-0x2000, %rax          # imm = 0xE000
shrq %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0xd8(%rbp)
jmp 0x49764
jmp 0x49798
movq -0xc8(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x57fa8(%rip), %rax     # 0xa1720
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0xe0(%rbp)
movq -0xe0(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0xd8(%rbp)
movq -0xd8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/bitmap.h
// Function: je_bitmap_sfu
JEMALLOC_INLINE size_t
bitmap_sfu(bitmap_t *bitmap, const bitmap_info_t *binfo)
{
	size_t bit;
	bitmap_t g;
	unsigned i;

	assert(!bitmap_full(bitmap, binfo));

	i = binfo->nlevels - 1;
	g = bitmap[binfo->levels[i].group_offset];
	bit = jemalloc_ffsl(g) - 1;
	while (i > 0) {
		i--;
		g = bitmap[binfo->levels[i].group_offset + bit];
		bit = (bit << LG_BITMAP_GROUP_NBITS) + (jemalloc_ffsl(g) - 1);
	}

	bitmap_set(bitmap, binfo, bit);
	return (bit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
jmp 0x4a712
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movl -0x34(%rbp), %edx
movq 0x10(%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdx
tzcntq %rdx, %rax
addq $0x1, %rax
xorl %ecx, %ecx
cmpq $0x0, %rdx
cmoveq %rcx, %rax
subl $0x1, %eax
cltq
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x34(%rbp)
jbe 0x4a7c0
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movl -0x34(%rbp), %edx
movq 0x10(%rcx,%rdx,8), %rcx
addq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
shlq $0x6, %rax
movq -0x30(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rsi
tzcntq %rsi, %rcx
addq $0x1, %rcx
xorl %edx, %edx
cmpq $0x0, %rsi
cmoveq %rdx, %rcx
subl $0x1, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x4a75f
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x4a7e0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/bitmap.h
// Function: je_bitmap_set
JEMALLOC_INLINE void
bitmap_set(bitmap_t *bitmap, const bitmap_info_t *binfo, size_t bit)
{
	size_t goff;
	bitmap_t *gp;
	bitmap_t g;

	assert(bit < binfo->nbits);
	assert(!bitmap_get(bitmap, binfo, bit));
	goff = bit >> LG_BITMAP_GROUP_NBITS;
	gp = &bitmap[goff];
	g = *gp;
	assert(g & (1LU << (bit & BITMAP_GROUP_NBITS_MASK)));
	g ^= 1LU << (bit & BITMAP_GROUP_NBITS_MASK);
	*gp = g;
	assert(bitmap_get(bitmap, binfo, bit));
	/* Propagate group state transitions up the tree. */
	if (g == 0) {
		unsigned i;
		for (i = 1; i < binfo->nlevels; i++) {
			bit = goff;
			goff = bit >> LG_BITMAP_GROUP_NBITS;
			gp = &bitmap[binfo->levels[i].group_offset + goff];
			g = *gp;
			assert(g & (1LU << (bit & BITMAP_GROUP_NBITS_MASK)));
			g ^= 1LU << (bit & BITMAP_GROUP_NBITS_MASK);
			*gp = g;
			if (g != 0)
				break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x4a7f2
jmp 0x4a7f4
jmp 0x4a7f6
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x4a822
movq -0x18(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %eax
shlq %cl, %rax
xorq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4a847
cmpq $0x0, -0x30(%rbp)
jne 0x4a8e3
movl $0x1, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x4a8e1
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x34(%rbp), %edx
movq 0x10(%rcx,%rdx,8), %rcx
addq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x4a8a5
movq -0x18(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %eax
shlq %cl, %rax
xorq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x4a8d1
jmp 0x4a8e1
jmp 0x4a8d3
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4a859
jmp 0x4a8e3
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_bin_nonfull_run_get
static arena_run_t *
arena_bin_nonfull_run_get(arena_t *arena, arena_bin_t *bin)
{
	arena_run_t *run;
	szind_t binind;
	arena_bin_info_t *bin_info;

	/* Look for a usable run. */
	run = arena_bin_nonfull_run_tryget(bin);
	if (run != NULL)
		return (run);
	/* No existing runs have any space available. */

	binind = arena_bin_index(arena, bin);
	bin_info = &arena_bin_info[binind];

	/* Allocate a new run. */
	malloc_mutex_unlock(&bin->lock);
	/******************************/
	malloc_mutex_lock(&arena->lock);
	run = arena_run_alloc_small(arena, bin_info->run_size, binind);
	if (run != NULL) {
		/* Initialize run internals. */
		run->binind = binind;
		run->nfree = bin_info->nregs;
		bitmap_init(run->bitmap, &bin_info->bitmap_info);
	}
	malloc_mutex_unlock(&arena->lock);
	/********************************/
	malloc_mutex_lock(&bin->lock);
	if (run != NULL) {
		if (config_stats) {
			bin->stats.nruns++;
			bin->stats.curruns++;
		}
		return (run);
	}

	/*
	 * arena_run_alloc_small() failed, but another thread may have made
	 * sufficient memory available while this one dropped bin->lock above,
	 * so search one more time.
	 */
	run = arena_bin_nonfull_run_tryget(bin);
	if (run != NULL)
		return (run);

	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4ab70
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4a961
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4aa62
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4a8f0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
leaq 0x56da3(%rip), %rax     # 0xa1720
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3c3c0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3a0
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rsi
movl -0x24(%rbp), %edx
callq 0x4abc0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4a9e9
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x30(%rbp), %rsi
addq $0x28, %rsi
callq 0x4fc90
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3c0
movq -0x18(%rbp), %rdi
callq 0x3c3a0
cmpq $0x0, -0x20(%rbp)
je 0x4aa3c
movq -0x18(%rbp), %rax
movq 0xc8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xc8(%rax)
movq -0x18(%rbp), %rax
movq 0xd8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xd8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4aa62
movq -0x18(%rbp), %rdi
callq 0x4ab70
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4aa5a
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4aa62
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_dalloc_bin_run
static void
arena_dalloc_bin_run(arena_t *arena, arena_chunk_t *chunk, arena_run_t *run,
    arena_bin_t *bin)
{

	assert(run != bin->runcur);
	assert(arena_run_tree_search(&bin->runs, arena_run_to_miscelm(run)) ==
	    NULL);

	malloc_mutex_unlock(&bin->lock);
	/******************************/
	malloc_mutex_lock(&arena->lock);
	arena_run_dalloc_decommit(arena, chunk, run);
	malloc_mutex_unlock(&arena->lock);
	/****************************/
	malloc_mutex_lock(&bin->lock);
	if (config_stats)
		bin->stats.curruns--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x4aa8a
jmp 0x4aa8c
jmp 0x4aa8e
movq -0x20(%rbp), %rdi
callq 0x3c3c0
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4c3c0
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3c0
movq -0x20(%rbp), %rdi
callq 0x3c3a0
movq -0x20(%rbp), %rax
movq 0xd8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xd8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_bin_lower_run
static void
arena_bin_lower_run(arena_t *arena, arena_chunk_t *chunk, arena_run_t *run,
    arena_bin_t *bin)
{

	/*
	 * Make sure that if bin->runcur is non-NULL, it refers to the lowest
	 * non-full run.  It is okay to NULL runcur out rather than proactively
	 * keeping it pointing at the lowest non-full run.
	 */
	if ((uintptr_t)run < (uintptr_t)bin->runcur) {
		/* Switch runcur. */
		if (bin->runcur->nfree > 0)
			arena_bin_runs_insert(bin, bin->runcur);
		bin->runcur = run;
		if (config_stats)
			bin->stats.reruns++;
	} else
		arena_bin_runs_insert(bin, run);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x28(%rcx), %rcx
cmpq %rcx, %rax
jae 0x4ab5c
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $0x0, 0x4(%rax)
jbe 0x4ab38
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x4c500
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
movq 0xd0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xd0(%rax)
jmp 0x4ab69
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4c500
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_bin_nonfull_run_tryget
static arena_run_t *
arena_bin_nonfull_run_tryget(arena_bin_t *bin)
{
	arena_run_t *run = arena_bin_runs_first(bin);
	if (run != NULL) {
		arena_bin_runs_remove(bin, run);
		if (config_stats)
			bin->stats.reruns++;
	}
	return (run);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4acb0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4abb3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4ad00
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xd0(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_run_alloc_small
static arena_run_t *
arena_run_alloc_small(arena_t *arena, size_t size, szind_t binind)
{
	arena_chunk_t *chunk;
	arena_run_t *run;

	assert(size <= arena_maxrun);
	assert(size == PAGE_CEILING(size));
	assert(binind != BININD_INVALID);

	/* Search the arena's chunks for the lowest best fit. */
	run = arena_run_alloc_small_helper(arena, size, binind);
	if (run != NULL)
		return (run);

	/*
	 * No usable runs.  Create a new chunk from which to allocate the run.
	 */
	chunk = arena_chunk_alloc(arena);
	if (chunk != NULL) {
		run = &arena_miscelm_get(chunk, map_bias)->run;
		if (arena_run_split_small(arena, run, size, binind))
			run = NULL;
		return (run);
	}

	/*
	 * arena_chunk_alloc() failed, but another thread may have made
	 * sufficient memory available while this one dropped arena->lock in
	 * arena_chunk_alloc(), so search one more time.
	 */
	return (arena_run_alloc_small_helper(arena, size, binind));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movl %edx, -0x2c(%rbp)
jmp 0x4abd5
jmp 0x4abd7
jmp 0x4abd9
jmp 0x4abdb
jmp 0x4abdd
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x4bbc0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x4ac05
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x4ac97
movq -0x20(%rbp), %rdi
callq 0x45b90
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x4ac83
movq -0x38(%rbp), %rcx
movq 0x579b4(%rip), %rax     # 0xa25d8
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq 0x579a9(%rip), %rax     # 0xa25e0
imulq $0x60, -0x10(%rbp), %rcx
addq %rcx, %rax
xorl %ecx, %ecx
subq 0x57990(%rip), %rcx     # 0xa25d8
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x4bc20
testb $0x1, %al
jne 0x4ac71
jmp 0x4ac79
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x4ac97
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x4bbc0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_bin_runs_first
static arena_run_t *
arena_bin_runs_first(arena_bin_t *bin)
{
	arena_chunk_map_misc_t *miscelm = arena_run_tree_first(&bin->runs);
	if (miscelm != NULL)
		return (&miscelm->run);

	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x4ad50
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4ace2
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x4acea
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_run_comp
JEMALLOC_INLINE_C int
arena_run_comp(arena_chunk_map_misc_t *a, arena_chunk_map_misc_t *b)
{
	uintptr_t a_miscelm = (uintptr_t)a;
	uintptr_t b_miscelm = (uintptr_t)b;

	assert(a != NULL);
	assert(b != NULL);

	return ((a_miscelm > b_miscelm) - (a_miscelm < b_miscelm));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x4bb8e
jmp 0x4bb90
jmp 0x4bb92
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x18(%rbp), %rcx
cmpq -0x20(%rbp), %rcx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_run_alloc_small_helper
static arena_run_t *
arena_run_alloc_small_helper(arena_t *arena, size_t size, szind_t binind)
{
	arena_run_t *run = arena_run_first_best_fit(arena, size);
	if (run != NULL) {
		if (arena_run_split_small(arena, run, size, binind))
			run = NULL;
	}
	return (run);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4c100
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4bc0f
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq 0x4bc20
testb $0x1, %al
jne 0x4bc05
jmp 0x4bc0d
movq $0x0, -0x20(%rbp)
jmp 0x4bc0f
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_run_first_best_fit
static arena_run_t *
arena_run_first_best_fit(arena_t *arena, size_t size)
{
	size_t search_size = run_quantize_first(size);
	arena_chunk_map_misc_t *key = arena_miscelm_key_create(search_size);
	arena_chunk_map_misc_t *miscelm =
	    arena_avail_tree_nsearch(&arena->runs_avail, key);
	if (miscelm == NULL)
		return (NULL);
	return (&miscelm->run);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4c170
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4c1b0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0xf0, %rdi
movq -0x28(%rbp), %rsi
callq 0x4c1e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x4c153
movq $0x0, -0x8(%rbp)
jmp 0x4c15f
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: run_quantize_first
static size_t
run_quantize_first(size_t size)
{
	size_t qsize = run_quantize(size);

	if (qsize < size) {
		/*
		 * Skip a quantization that may have an adequately large run,
		 * because under-sized runs may be mixed in.  This only happens
		 * when an unusual size is requested, i.e. for aligned
		 * allocation, and is just one of several places where linear
		 * search would potentially find sufficiently aligned available
		 * memory somewhere lower.
		 */
		qsize = run_quantize_next(size);
	}
	return (qsize);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x46c00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x4c1a0
movq -0x8(%rbp), %rdi
callq 0x4c290
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: run_quantize_next
static size_t
run_quantize_next(size_t size)
{
	size_t large_run_size_next;

	assert(size != 0);
	assert(size == PAGE_CEILING(size));

	/*
	 * Return the next quantized size greater than the input size.
	 * Quantized sizes comprise the union of run sizes that back small
	 * region runs, and run sizes that back large regions with no explicit
	 * alignment constraints.
	 */

	if (size > SMALL_MAXCLASS) {
		large_run_size_next = PAGE_CEILING(index2size(size2index(size -
		    large_pad) + 1) + large_pad);
	} else
		large_run_size_next = SIZE_T_MAX;
	if (size >= small_maxrun)
		return (large_run_size_next);

	while (true) {
		size += PAGE;
		assert(size <= small_maxrun);
		if (small_run_tab[size >> LG_PAGE]) {
			if (large_run_size_next < size)
				return (large_run_size_next);
			return (size);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
jmp 0x4c29e
jmp 0x4c2a0
jmp 0x4c2a2
cmpq $0x3800, -0x40(%rbp)    # imm = 0x3800
jbe 0x4c346
movq -0x40(%rbp), %rax
subq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x30(%rbp)
cmpq $0x1000, -0x30(%rbp)    # imm = 0x1000
setbe %al
testb $0x1, %al
jne 0x4c2cf
jmp 0x4c2fb
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
shrq $0x3, %rcx
leaq 0x42996(%rip), %rax     # 0x8ec80
movzbl (%rax,%rcx), %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl %eax, -0x28(%rbp)
jmp 0x4c307
movq -0x30(%rbp), %rdi
callq 0x4ca20
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x421de(%rip), %rax     # 0x8e500
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x1000, %rax           # imm = 0x1000
addq $0xfff, %rax            # imm = 0xFFF
andq $-0x1000, %rax          # imm = 0xF000
movq %rax, -0x48(%rbp)
jmp 0x4c34e
movq $-0x1, -0x48(%rbp)
movq -0x40(%rbp), %rax
cmpq 0x56297(%rip), %rax     # 0xa25f0
jb 0x4c365
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x4c3ac
jmp 0x4c367
movq -0x40(%rbp), %rax
addq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x40(%rbp)
jmp 0x4c377
movq 0x5627a(%rip), %rax     # 0xa25f8
movq -0x40(%rbp), %rcx
shrq $0xc, %rcx
testb $0x1, (%rax,%rcx)
je 0x4c3aa
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x4c3a0
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x4c3ac
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x4c3ac
jmp 0x4c367
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_run_decommit
static bool
arena_run_decommit(arena_t *arena, arena_chunk_t *chunk, arena_run_t *run)
{
	arena_chunk_map_misc_t *miscelm = arena_run_to_miscelm(run);
	size_t run_ind = arena_miscelm_to_pageind(miscelm);
	size_t offset = run_ind << LG_PAGE;
	size_t length = arena_run_size_get(arena, chunk, run, run_ind);

	return (arena->chunk_hooks.decommit(chunk, chunksize, offset, length,
	    arena->ind));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
subq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x562cd(%rip), %rcx     # 0xa2730
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
addq 0x56160(%rip), %rcx     # 0xa25e0
subq %rcx, %rax
movl $0x60, %ecx
xorl %edx, %edx
divq %rcx
addq 0x56144(%rip), %rax     # 0xa25d8
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
shlq $0xc, %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x49600
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rax
movq 0x430(%rax), %rax
movq -0x38(%rbp), %rdi
leaq 0x5624d(%rip), %rcx     # 0xa2728
movq (%rcx), %rsi
movq -0x58(%rbp), %rdx
movq -0x60(%rbp), %rcx
movq -0x30(%rbp), %r8
movl (%r8), %r8d
callq *%rax
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_run_alloc_large_helper
static arena_run_t *
arena_run_alloc_large_helper(arena_t *arena, size_t size, bool zero)
{
	arena_run_t *run = arena_run_first_best_fit(arena, s2u(size));
	if (run != NULL) {
		if (arena_run_split_large(arena, run, size, zero))
			run = NULL;
	}
	return (run);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %dl, %al
movq %rdi, -0x78(%rbp)
movq %rsi, -0x80(%rbp)
andb $0x1, %al
movb %al, -0x81(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x1000, -0x70(%rbp)    # imm = 0x1000
setbe %al
testb $0x1, %al
jne 0x4cb81
jmp 0x4cbdc
movq -0x70(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
subq $0x1, %rcx
shrq $0x3, %rcx
leaq 0x420dc(%rip), %rax     # 0x8ec80
movzbl (%rax,%rcx), %eax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, %ecx
leaq 0x41941(%rip), %rax     # 0x8e500
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x4cca4
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
setl %al
testb $0x1, %al
jne 0x4cbf2
jmp 0x4cc14
movq -0x8(%rbp), %rdx
shlq %rdx
movl $0x3f, %eax
movl $0x40, %ecx
cmpq $0x0, %rdx
cmovneq %rcx, %rax
movq %rax, -0xa0(%rbp)
jmp 0x4cc2b
movq -0x8(%rbp), %rdi
shlq %rdi
subq $0x1, %rdi
callq 0x4cb20
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x6, -0x10(%rbp)
jae 0x4cc4b
movl $0x3, %eax
movq %rax, -0xa8(%rbp)
jmp 0x4cc5e
movq -0x10(%rbp), %rax
subq $0x2, %rax
subq $0x1, %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq -0x28(%rbp), %rax
movq -0x28(%rbp), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x98(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x4c100
movq %rax, -0x90(%rbp)
cmpq $0x0, -0x90(%rbp)
je 0x4ccf7
movq -0x78(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x80(%rbp), %rdx
movb -0x81(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x45c10
testb $0x1, %al
jne 0x4ccea
jmp 0x4ccf5
movq $0x0, -0x90(%rbp)
jmp 0x4ccf7
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_run_reg_dalloc
JEMALLOC_INLINE_C void
arena_run_reg_dalloc(arena_run_t *run, void *ptr)
{
	arena_chunk_t *chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(run);
	size_t pageind = ((uintptr_t)ptr - (uintptr_t)chunk) >> LG_PAGE;
	size_t mapbits = arena_mapbits_get(chunk, pageind);
	szind_t binind = arena_ptr_small_binind_get(ptr, mapbits);
	arena_bin_info_t *bin_info = &arena_bin_info[binind];
	unsigned regind = arena_run_regind(run, bin_info, ptr);

	assert(run->nfree < bin_info->nregs);
	/* Freeing an interior pointer can cause assertion failure. */
	assert(((uintptr_t)ptr -
	    ((uintptr_t)arena_miscelm_to_rpages(arena_run_to_miscelm(run)) +
	    (uintptr_t)bin_info->reg0_offset)) %
	    (uintptr_t)bin_info->reg_interval == 0);
	assert((uintptr_t)ptr >=
	    (uintptr_t)arena_miscelm_to_rpages(arena_run_to_miscelm(run)) +
	    (uintptr_t)bin_info->reg0_offset);
	/* Freeing an unallocated pointer can cause assertion failure. */
	assert(bitmap_get(run->bitmap, &bin_info->bitmap_info, regind));

	bitmap_unset(run->bitmap, &bin_info->bitmap_info, regind);
	run->nfree++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x58(%rbp)
movq %rsi, -0x60(%rbp)
movq -0x58(%rbp), %rax
leaq 0x54972(%rip), %rcx     # 0xa2730
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rax
movq -0x68(%rbp), %rcx
subq %rcx, %rax
shrq $0xc, %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x68, %rax
movq -0x28(%rbp), %rcx
subq 0x547b6(%rip), %rcx     # 0xa25d8
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x60(%rbp), %rcx
movq -0x78(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $0x1fe0, %rax           # imm = 0x1FE0
shrq $0x5, %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %eax
movl %eax, %ecx
leaq 0x538b5(%rip), %rax     # 0xa1720
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x58(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x4df60
movl %eax, -0x8c(%rbp)
jmp 0x4de95
jmp 0x4de97
jmp 0x4de99
jmp 0x4de9b
jmp 0x4de9d
jmp 0x4de9f
jmp 0x4dea1
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
movq -0x88(%rbp), %rsi
addq $0x28, %rsi
movl -0x8c(%rbp), %eax
movl %eax, %edx
callq 0x4e0e0
movq -0x58(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_dissociate_bin_run
static void
arena_dissociate_bin_run(arena_chunk_t *chunk, arena_run_t *run,
    arena_bin_t *bin)
{

	/* Dissociate run from bin. */
	if (run == bin->runcur)
		bin->runcur = NULL;
	else {
		szind_t binind = arena_bin_index(extent_node_arena_get(
		    &chunk->node), bin);
		arena_bin_info_t *bin_info = &arena_bin_info[binind];

		if (bin_info->nregs != 1) {
			/*
			 * This block's conditional is necessary because if the
			 * run only contains one region, then it never gets
			 * inserted into the non-full runs tree.
			 */
			arena_bin_runs_remove(bin, run);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jne 0x4df10
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
jmp 0x4df58
movq -0x8(%rbp), %rdi
callq 0x4e210
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x4a8f0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x537ec(%rip), %rax     # 0xa1720
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x1, 0x20(%rax)
je 0x4df56
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4ad00
jmp 0x4df58
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/bitmap.h
// Function: je_bitmap_unset
JEMALLOC_INLINE void
bitmap_unset(bitmap_t *bitmap, const bitmap_info_t *binfo, size_t bit)
{
	size_t goff;
	bitmap_t *gp;
	bitmap_t g;
	bool propagate;

	assert(bit < binfo->nbits);
	assert(bitmap_get(bitmap, binfo, bit));
	goff = bit >> LG_BITMAP_GROUP_NBITS;
	gp = &bitmap[goff];
	g = *gp;
	propagate = (g == 0);
	assert((g & (1LU << (bit & BITMAP_GROUP_NBITS_MASK))) == 0);
	g ^= 1LU << (bit & BITMAP_GROUP_NBITS_MASK);
	*gp = g;
	assert(!bitmap_get(bitmap, binfo, bit));
	/* Propagate group state transitions up the tree. */
	if (propagate) {
		unsigned i;
		for (i = 1; i < binfo->nlevels; i++) {
			bit = goff;
			goff = bit >> LG_BITMAP_GROUP_NBITS;
			gp = &bitmap[binfo->levels[i].group_offset + goff];
			g = *gp;
			propagate = (g == 0);
			assert((g & (1LU << (bit & BITMAP_GROUP_NBITS_MASK)))
			    == 0);
			g ^= 1LU << (bit & BITMAP_GROUP_NBITS_MASK);
			*gp = g;
			if (!propagate)
				break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x4e0f2
jmp 0x4e0f4
jmp 0x4e0f6
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x4e12f
movq -0x18(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %eax
shlq %cl, %rax
xorq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4e154
testb $0x1, -0x31(%rbp)
je 0x4e1ff
movl $0x1, -0x38(%rbp)
movl -0x38(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x4e1fd
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x38(%rbp), %edx
movq 0x10(%rcx,%rdx,8), %rcx
addq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x4e1c2
movq -0x18(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %eax
shlq %cl, %rax
xorq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
testb $0x1, -0x31(%rbp)
jne 0x4e1ed
jmp 0x4e1fd
jmp 0x4e1ef
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x4e165
jmp 0x4e1ff
popq %rbp
retq
nopw %cs:(%rax,%rax)