LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_dalloc_large_locked
void
arena_dalloc_large_locked(arena_t *arena, arena_chunk_t *chunk, void *ptr)
{

	if (config_fill || config_stats) {
		size_t pageind = ((uintptr_t)ptr - (uintptr_t)chunk) >> LG_PAGE;
		size_t size = arena_mapbits_large_size_get(chunk, pageind);

		if (config_fill && config_stats && opt_junk)
			memset(ptr, 0x5a, size);
		if (config_stats) {
			arena->stats.ndalloc_large++;
			arena->stats.allocated_large -= size;
			arena->stats.lstats[(size >> LG_PAGE) - 1].ndalloc++;
			arena->stats.lstats[(size >> LG_PAGE) - 1].curruns--;
		}
	}

	arena_run_dalloc(arena, (arena_run_t *)ptr, true, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
shrq $0xc, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb7500
movq %rax, -0x28(%rbp)
leaq 0x7105c(%rip), %rax     # 0x1284ab
testb $0x1, (%rax)
je 0xb7466
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x5a, %esi
callq 0x1f110
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x60(%rax)
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x28(%rbp), %rcx
shrq $0xc, %rcx
subq $0x1, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x28(%rbp), %rcx
shrq $0xc, %rcx
subq $0x1, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0xb7540
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_ralloc_no_move
void *
arena_ralloc_no_move(void *ptr, size_t oldsize, size_t size, size_t extra,
    bool zero)
{

	/*
	 * Avoid moving the allocation if the size class can be left the same.
	 */
	if (oldsize <= arena_maxclass) {
		if (oldsize <= SMALL_MAXCLASS) {
			assert(arena_bin_info[SMALL_SIZE2BIN(oldsize)].reg_size
			    == oldsize);
			if ((size + extra <= SMALL_MAXCLASS &&
			    SMALL_SIZE2BIN(size + extra) ==
			    SMALL_SIZE2BIN(oldsize)) || (size <= oldsize &&
			    size + extra >= oldsize)) {
				if (config_fill && opt_junk && size < oldsize) {
					memset((void *)((uintptr_t)ptr + size),
					    0x5a, oldsize - size);
				}
				return (ptr);
			}
		} else {
			assert(size <= arena_maxclass);
			if (size + extra > SMALL_MAXCLASS) {
				if (arena_ralloc_large(ptr, oldsize, size,
				    extra, zero) == false)
					return (ptr);
			}
		}
	}

	/* Reallocation would require a move. */
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x18(%rbp), %rax
leaq 0x71845(%rip), %rcx     # 0x129280
cmpq (%rcx), %rax
ja 0xb7b3c
cmpq $0xe00, -0x18(%rbp)     # imm = 0xE00
ja 0xb7af0
jmp 0xb7a54
jmp 0xb7a56
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
cmpq $0xe00, %rax            # imm = 0xE00
ja 0xb7a9c
movq -0x20(%rbp), %rcx
addq -0x28(%rbp), %rcx
subq $0x1, %rcx
shrq $0x3, %rcx
leaq 0x35c03(%rip), %rax     # 0xed680
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
shrq $0x3, %rdx
leaq 0x35bec(%rip), %rcx     # 0xed680
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xb7ab4
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xb7aee
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0xb7aee
leaq 0x709f0(%rip), %rax     # 0x1284ab
testb $0x1, (%rax)
je 0xb7ae4
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xb7ae4
movq -0x10(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
subq -0x20(%rbp), %rdx
movl $0x5a, %esi
callq 0x1f110
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb7b44
jmp 0xb7b3a
jmp 0xb7af2
jmp 0xb7af4
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
cmpq $0xe00, %rax            # imm = 0xE00
jbe 0xb7b38
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0xb7b50
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xb7b36
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb7b44
jmp 0xb7b38
jmp 0xb7b3a
jmp 0xb7b3c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_boot
void
arena_boot(void)
{
	size_t header_size;
	unsigned i;

	/*
	 * Compute the header size such that it is large enough to contain the
	 * page map.  The page map is biased to omit entries for the header
	 * itself, so some iteration is necessary to compute the map bias.
	 *
	 * 1) Compute safe header_size and map_bias values that include enough
	 *    space for an unbiased page map.
	 * 2) Refine map_bias based on (1) to omit the header pages in the page
	 *    map.  The resulting map_bias may be one too small.
	 * 3) Refine map_bias based on (2).  The result will be >= the result
	 *    from (2), and will always be correct.
	 */
	map_bias = 0;
	for (i = 0; i < 3; i++) {
		header_size = offsetof(arena_chunk_t, map) +
		    (sizeof(arena_chunk_map_t) * (chunk_npages-map_bias));
		map_bias = (header_size >> LG_PAGE) + ((header_size & PAGE_MASK)
		    != 0);
	}
	assert(map_bias > 0);

	arena_maxclass = chunksize - (map_bias << LG_PAGE);

	bin_info_init();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x70829(%rip), %rax     # 0x129278
movq $0x0, (%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jae 0xb8abb
leaq 0x7076e(%rip), %rax     # 0x1291d8
movq (%rax), %rax
leaq 0x70804(%rip), %rcx     # 0x129278
subq (%rcx), %rax
imulq $0x18, %rax, %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
shrq $0xc, %rcx
movq -0x8(%rbp), %rax
andq $0xfff, %rax            # imm = 0xFFF
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
addq %rax, %rcx
leaq 0x707cb(%rip), %rax     # 0x129278
movq %rcx, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb8a5d
jmp 0xb8abd
jmp 0xb8abf
leaq 0x706ea(%rip), %rax     # 0x1291b0
movq (%rax), %rcx
leaq 0x707a8(%rip), %rax     # 0x129278
movq (%rax), %rax
shlq $0xc, %rax
subq %rax, %rcx
leaq 0x7079f(%rip), %rax     # 0x129280
movq %rcx, (%rax)
callq 0xb8af0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_prefork
void
arena_prefork(arena_t *arena)
{
	unsigned i;

	malloc_mutex_prefork(&arena->lock);
	for (i = 0; i < NBINS; i++)
		malloc_mutex_prefork(&arena->bins[i].lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0xcded0
movl $0x0, -0xc(%rbp)
cmpl $0x1c, -0xc(%rbp)
jae 0xb92ae
movq -0x8(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
movl -0xc(%rbp), %eax
imulq $0x98, %rax, %rax
addq %rax, %rdi
callq 0xcded0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb9280
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_postfork_parent
void
arena_postfork_parent(arena_t *arena)
{
	unsigned i;

	for (i = 0; i < NBINS; i++)
		malloc_mutex_postfork_parent(&arena->bins[i].lock);
	malloc_mutex_postfork_parent(&arena->lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x1c, -0xc(%rbp)
jae 0xb9301
movq -0x8(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
movl -0xc(%rbp), %eax
imulq $0x98, %rax, %rax
addq %rax, %rdi
callq 0xcdf10
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb92d3
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0xcdf10
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_postfork_child
void
arena_postfork_child(arena_t *arena)
{
	unsigned i;

	for (i = 0; i < NBINS; i++)
		malloc_mutex_postfork_child(&arena->bins[i].lock);
	malloc_mutex_postfork_child(&arena->lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x1c, -0xc(%rbp)
jae 0xb9361
movq -0x8(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
movl -0xc(%rbp), %eax
imulq $0x98, %rax, %rax
addq %rax, %rdi
callq 0xcdf50
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb9333
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0xcdf50
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/include/jemalloc/internal/arena.h
// Function: arena_mapbits_unallocated_set
JEMALLOC_INLINE void
arena_mapbits_unallocated_set(arena_chunk_t *chunk, size_t pageind, size_t size,
    size_t flags)
{
	size_t *mapbitsp;

	mapbitsp = arena_mapbitsp_get(chunk, pageind);
	assert((size & PAGE_MASK) == 0);
	assert((flags & ~CHUNK_MAP_FLAGS_MASK) == 0);
	assert((flags & (CHUNK_MAP_DIRTY|CHUNK_MAP_UNZEROED)) == flags);
	*mapbitsp = size | CHUNK_MAP_BININD_INVALID | flags;
}

// 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
movq -0x10(%rbp), %rsi
callq 0xba2b0
movq %rax, -0x28(%rbp)
jmp 0xba12b
jmp 0xba12d
jmp 0xba12f
jmp 0xba131
jmp 0xba133
movq -0x18(%rbp), %rcx
orq $0xff0, %rcx            # imm = 0xFF0
orq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_avail_insert
static void
arena_avail_insert(arena_t *arena, arena_chunk_t *chunk, size_t pageind,
    size_t npages, bool maybe_adjac_pred, bool maybe_adjac_succ)
{

	assert(npages == (arena_mapbits_unallocated_size_get(chunk, pageind) >>
	    LG_PAGE));

	/*
	 * chunks_dirty is keyed by nruns_{avail,adjac}, so the chunk must be
	 * removed and reinserted even if the run to be inserted is clean.
	 */
	if (chunk->ndirty != 0)
		arena_chunk_dirty_remove(&arena->chunks_dirty, chunk);

	if (maybe_adjac_pred && arena_avail_adjac_pred(chunk, pageind))
		chunk->nruns_adjac++;
	if (maybe_adjac_succ && arena_avail_adjac_succ(chunk, pageind, npages))
		chunk->nruns_adjac++;
	chunk->nruns_avail++;
	assert(chunk->nruns_avail > chunk->nruns_adjac);

	if (arena_mapbits_dirty_get(chunk, pageind) != 0) {
		arena->ndirty += npages;
		chunk->ndirty += npages;
	}
	if (chunk->ndirty != 0)
		arena_chunk_dirty_insert(&arena->chunks_dirty, chunk);

	arena_avail_tree_insert(&arena->runs_avail, arena_mapp_get(chunk,
	    pageind));
}

// 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)
jmp 0xba1a3
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xba1c2
movq -0x8(%rbp), %rdi
addq $0x90, %rdi
movq -0x10(%rbp), %rsi
callq 0xba2e0
testb $0x1, -0x21(%rbp)
je 0xba1eb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xbb0c0
testb $0x1, %al
jne 0xba1db
jmp 0xba1eb
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
testb $0x1, -0x22(%rbp)
je 0xba218
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xbb120
testb $0x1, %al
jne 0xba208
jmp 0xba218
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
jmp 0xba22a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb9ad0
cmpq $0x0, %rax
je 0xba263
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0xf0(%rax), %rcx
movq %rcx, 0xf0(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xba282
movq -0x8(%rbp), %rdi
addq $0x90, %rdi
movq -0x10(%rbp), %rsi
callq 0xbb180
movq -0x8(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb73d0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xbb5e0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_avail_adjac_succ
static inline bool
arena_avail_adjac_succ(arena_chunk_t *chunk, size_t pageind, size_t npages)
{
	bool ret;

	if (pageind+npages == chunk_npages)
		ret = false;
	else {
		assert(pageind+npages < chunk_npages);
		ret = (arena_mapbits_allocated_get(chunk, pageind+npages) == 0);
		assert(ret == false || arena_mapbits_dirty_get(chunk, pageind)
		    != arena_mapbits_dirty_get(chunk, pageind+npages));
	}
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
leaq 0x6e095(%rip), %rcx     # 0x1291d8
cmpq (%rcx), %rax
jne 0xbb14e
movb $0x0, -0x19(%rbp)
jmp 0xbb173
jmp 0xbb150
jmp 0xbb152
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x18(%rbp), %rsi
callq 0xb9a60
cmpq $0x0, %rax
sete %al
andb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0xbb171
jmp 0xbb173
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/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, bool maybe_adjac_pred, bool maybe_adjac_succ)
{

	assert(npages == (arena_mapbits_unallocated_size_get(chunk, pageind) >>
	    LG_PAGE));

	/*
	 * chunks_dirty is keyed by nruns_{avail,adjac}, so the chunk must be
	 * removed and reinserted even if the run to be removed is clean.
	 */
	if (chunk->ndirty != 0)
		arena_chunk_dirty_remove(&arena->chunks_dirty, chunk);

	if (maybe_adjac_pred && arena_avail_adjac_pred(chunk, pageind))
		chunk->nruns_adjac--;
	if (maybe_adjac_succ && arena_avail_adjac_succ(chunk, pageind, npages))
		chunk->nruns_adjac--;
	chunk->nruns_avail--;
	assert(chunk->nruns_avail > chunk->nruns_adjac || (chunk->nruns_avail
	    == 0 && chunk->nruns_adjac == 0));

	if (arena_mapbits_dirty_get(chunk, pageind) != 0) {
		arena->ndirty -= npages;
		chunk->ndirty -= npages;
	}
	if (chunk->ndirty != 0)
		arena_chunk_dirty_insert(&arena->chunks_dirty, chunk);

	arena_avail_tree_remove(&arena->runs_avail, arena_mapp_get(chunk,
	    pageind));
}

// 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)
jmp 0xbbc53
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xbbc72
movq -0x8(%rbp), %rdi
addq $0x90, %rdi
movq -0x10(%rbp), %rsi
callq 0xba2e0
testb $0x1, -0x21(%rbp)
je 0xbbc9b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xbb0c0
testb $0x1, %al
jne 0xbbc8b
jmp 0xbbc9b
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x28(%rax)
testb $0x1, -0x22(%rbp)
je 0xbbcc8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xbb120
testb $0x1, %al
jne 0xbbcb8
jmp 0xbbcc8
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
jmp 0xbbcda
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb9ad0
cmpq $0x0, %rax
je 0xbbd19
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0xf0(%rax)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xbbd38
movq -0x8(%rbp), %rdi
addq $0x90, %rdi
movq -0x10(%rbp), %rsi
callq 0xbb180
movq -0x8(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb73d0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xbbeb0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/include/jemalloc/internal/arena.h
// Function: arena_mapbits_large_set
JEMALLOC_INLINE void
arena_mapbits_large_set(arena_chunk_t *chunk, size_t pageind, size_t size,
    size_t flags)
{
	size_t *mapbitsp;
	size_t unzeroed;

	mapbitsp = arena_mapbitsp_get(chunk, pageind);
	assert((size & PAGE_MASK) == 0);
	assert((flags & CHUNK_MAP_DIRTY) == flags);
	unzeroed = *mapbitsp & CHUNK_MAP_UNZEROED; /* Preserve unzeroed. */
	*mapbitsp = size | CHUNK_MAP_BININD_INVALID | flags | unzeroed |
	    CHUNK_MAP_LARGE | CHUNK_MAP_ALLOCATED;
}

// 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
movq -0x10(%rbp), %rsi
callq 0xba2b0
movq %rax, -0x28(%rbp)
jmp 0xbbdfb
jmp 0xbbdfd
jmp 0xbbdff
movq -0x28(%rbp), %rax
movq (%rax), %rax
andq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
orq $0xff0, %rcx            # imm = 0xFF0
orq -0x20(%rbp), %rcx
orq -0x30(%rbp), %rcx
orq $0x2, %rcx
orq $0x1, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/include/jemalloc/internal/arena.h
// Function: arena_mapbits_small_set
JEMALLOC_INLINE void
arena_mapbits_small_set(arena_chunk_t *chunk, size_t pageind, size_t runind,
    size_t binind, size_t flags)
{
	size_t *mapbitsp;
	size_t unzeroed;

	assert(binind < BININD_INVALID);
	mapbitsp = arena_mapbitsp_get(chunk, pageind);
	assert(pageind - runind >= map_bias);
	assert((flags & CHUNK_MAP_DIRTY) == flags);
	unzeroed = *mapbitsp & CHUNK_MAP_UNZEROED; /* Preserve unzeroed. */
	*mapbitsp = (runind << LG_PAGE) | (binind << CHUNK_MAP_BININD_SHIFT) |
	    flags | unzeroed | CHUNK_MAP_ALLOCATED;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
jmp 0xbbe5e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xba2b0
movq %rax, -0x30(%rbp)
jmp 0xbbe71
jmp 0xbbe73
jmp 0xbbe75
movq -0x30(%rbp), %rax
movq (%rax), %rax
andq $0x4, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rcx
shlq $0xc, %rcx
movq -0x20(%rbp), %rax
shlq $0x4, %rax
orq %rax, %rcx
orq -0x28(%rbp), %rcx
orq -0x38(%rbp), %rcx
orq $0x1, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/include/jemalloc/internal/bitmap.h
// Function: 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) == false);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xbccd2
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x24(%rbp), %edx
movq 0x10(%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1f7a0
subl $0x1, %eax
cltq
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x24(%rbp)
jbe 0xbcd5e
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x24(%rbp), %edx
movq 0x10(%rcx,%rdx,8), %rcx
addq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
shlq $0x6, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1f7a0
movl %eax, %ecx
movq -0x30(%rbp), %rax
subl $0x1, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0xbcd09
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xbcd80
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/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_t *mapelm = arena_run_tree_first(&bin->runs);
	if (mapelm != NULL) {
		arena_chunk_t *chunk;
		size_t pageind;
		arena_run_t *run;

		chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(mapelm);
		pageind = ((((uintptr_t)mapelm - (uintptr_t)chunk->map) /
		    sizeof(arena_chunk_map_t))) + map_bias;
		run = (arena_run_t *)((uintptr_t)chunk + (uintptr_t)((pageind -
		    arena_mapbits_small_runind_get(chunk, pageind)) <<
		    LG_PAGE));
		return (run);
	}

	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0xbd1e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xbd158
movq -0x18(%rbp), %rax
leaq 0x6c0ed(%rip), %rcx     # 0x1291d0
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $0x30, %rcx
subq %rcx, %rax
movl $0x18, %ecx
xorl %edx, %edx
divq %rcx
leaq 0x6c167(%rip), %rcx     # 0x129278
addq (%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xb6f20
movq -0x40(%rbp), %rcx
movq %rax, %rdx
movq -0x38(%rbp), %rax
subq %rdx, %rcx
shlq $0xc, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xbd160
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_bin_runs_remove
static void
arena_bin_runs_remove(arena_bin_t *bin, arena_run_t *run)
{
	arena_chunk_t *chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(run);
	size_t pageind = ((uintptr_t)run - (uintptr_t)chunk) >> LG_PAGE;
	arena_chunk_map_t *mapelm = arena_mapp_get(chunk, pageind);

	assert(arena_run_tree_search(&bin->runs, mapelm) != NULL);

	arena_run_tree_remove(&bin->runs, mapelm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x6c045(%rip), %rcx     # 0x1291d0
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
shrq $0xc, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb73d0
movq %rax, -0x28(%rbp)
jmp 0xbd1bf
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movq -0x28(%rbp), %rsi
callq 0xbd250
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_run_comp
static inline int
arena_run_comp(arena_chunk_map_t *a, arena_chunk_map_t *b)
{
	uintptr_t a_mapelm = (uintptr_t)a;
	uintptr_t b_mapelm = (uintptr_t)b;

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

	return ((a_mapelm > b_mapelm) - (a_mapelm < b_mapelm));
}

// 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 0xbe01e
jmp 0xbe020
jmp 0xbe022
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/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_run_alloc_helper
static arena_run_t *
arena_run_alloc_helper(arena_t *arena, size_t size, bool large, size_t binind,
    bool zero)
{
	arena_run_t *run;
	arena_chunk_map_t *mapelm, key;

	key.bits = size | CHUNK_MAP_KEY;
	mapelm = arena_avail_tree_nsearch(&arena->runs_avail, &key);
	if (mapelm != NULL) {
		arena_chunk_t *run_chunk = CHUNK_ADDR2BASE(mapelm);
		size_t pageind = (((uintptr_t)mapelm -
		    (uintptr_t)run_chunk->map) / sizeof(arena_chunk_map_t))
		    + map_bias;

		run = (arena_run_t *)((uintptr_t)run_chunk + (pageind <<
		    LG_PAGE));
		arena_run_split(arena, run, size, large, binind, zero);
		return (run);
	}

	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %dl
movb %dl, -0x19(%rbp)
movq %rcx, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x18(%rbp), %rax
orq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
leaq -0x58(%rbp), %rsi
callq 0xbe140
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xbe125
movq -0x40(%rbp), %rax
leaq 0x6b124(%rip), %rcx     # 0x1291d0
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rcx
addq $0x30, %rcx
subq %rcx, %rax
movl $0x18, %ecx
xorl %edx, %edx
divq %rcx
leaq 0x6b19e(%rip), %rcx     # 0x129278
addq (%rcx), %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rax
movq -0x68(%rbp), %rcx
shlq $0xc, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
movb -0x19(%rbp), %cl
movq -0x28(%rbp), %r8
movb -0x29(%rbp), %al
andb $0x1, %cl
andb $0x1, %al
movzbl %cl, %ecx
movzbl %al, %r9d
callq 0xb9b50
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xbe12d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_bin_runs_insert
static void
arena_bin_runs_insert(arena_bin_t *bin, arena_run_t *run)
{
	arena_chunk_t *chunk = CHUNK_ADDR2BASE(run);
	size_t pageind = ((uintptr_t)run - (uintptr_t)chunk) >> LG_PAGE;
	arena_chunk_map_t *mapelm = arena_mapp_get(chunk, pageind);

	assert(arena_run_tree_search(&bin->runs, mapelm) == NULL);

	arena_run_tree_insert(&bin->runs, mapelm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x6add5(%rip), %rcx     # 0x1291d0
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
shrq $0xc, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb73d0
movq %rax, -0x28(%rbp)
jmp 0xbe42f
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movq -0x28(%rbp), %rsi
callq 0xbe450
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/include/jemalloc/internal/arena.h
// Function: arena_mapbits_unallocated_size_set
JEMALLOC_INLINE void
arena_mapbits_unallocated_size_set(arena_chunk_t *chunk, size_t pageind,
    size_t size)
{
	size_t *mapbitsp;

	mapbitsp = arena_mapbitsp_get(chunk, pageind);
	assert((size & PAGE_MASK) == 0);
	assert((*mapbitsp & (CHUNK_MAP_LARGE|CHUNK_MAP_ALLOCATED)) == 0);
	*mapbitsp = size | (*mapbitsp & PAGE_MASK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xba2b0
movq %rax, -0x20(%rbp)
jmp 0xbe8f7
jmp 0xbe8f9
jmp 0xbe8fb
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
andq $0xfff, %rax            # imm = 0xFFF
orq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_chunk_dealloc
static void
arena_chunk_dealloc(arena_t *arena, arena_chunk_t *chunk)
{
	assert(arena_mapbits_allocated_get(chunk, map_bias) == 0);
	assert(arena_mapbits_allocated_get(chunk, chunk_npages-1) == 0);
	assert(arena_mapbits_unallocated_size_get(chunk, map_bias) ==
	    arena_maxclass);
	assert(arena_mapbits_unallocated_size_get(chunk, chunk_npages-1) ==
	    arena_maxclass);
	assert(arena_mapbits_dirty_get(chunk, map_bias) ==
	    arena_mapbits_dirty_get(chunk, chunk_npages-1));

	/*
	 * Remove run from the runs_avail tree, so that the arena does not use
	 * it.
	 */
	arena_avail_remove(arena, chunk, map_bias, chunk_npages-map_bias,
	    false, false);

	if (arena->spare != NULL) {
		arena_chunk_t *spare = arena->spare;

		arena->spare = chunk;
		malloc_mutex_unlock(&arena->lock);
		chunk_dealloc((void *)spare, chunksize, true);
		malloc_mutex_lock(&arena->lock);
		if (config_stats)
			arena->stats.mapped -= chunksize;
	} else
		arena->spare = chunk;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xbe932
jmp 0xbe934
jmp 0xbe936
jmp 0xbe938
jmp 0xbe93a
jmp 0xbe93c
jmp 0xbe93e
jmp 0xbe940
jmp 0xbe942
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x6a927(%rip), %rax     # 0x129278
movq (%rax), %rdx
leaq 0x6a87d(%rip), %rax     # 0x1291d8
movq (%rax), %rcx
leaq 0x6a913(%rip), %rax     # 0x129278
subq (%rax), %rcx
xorl %r9d, %r9d
movl %r9d, %r8d
callq 0xbbc00
movq -0x8(%rbp), %rax
cmpq $0x0, 0xe0(%rax)
je 0xbe9ec
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xe0(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0xb5ee0
movq -0x18(%rbp), %rdi
leaq 0x6a7f9(%rip), %rax     # 0x1291b0
movq (%rax), %rsi
movl $0x1, %edx
callq 0xc0950
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0xb5d20
leaq 0x6a7d8(%rip), %rax     # 0x1291b0
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x30(%rax)
jmp 0xbe9fb
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xe0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_maybe_purge
static inline void
arena_maybe_purge(arena_t *arena)
{
	size_t npurgeable, threshold;

	/* Don't purge if the option is disabled. */
	if (opt_lg_dirty_mult < 0)
		return;
	/* Don't purge if all dirty pages are already being purged. */
	if (arena->ndirty <= arena->npurgatory)
		return;
	npurgeable = arena->ndirty - arena->npurgatory;
	threshold = (arena->nactive >> opt_lg_dirty_mult);
	/*
	 * Don't purge unless the number of purgeable pages exceeds the
	 * threshold.
	 */
	if (npurgeable <= threshold)
		return;

	arena_purge(arena, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x54e64(%rip)     # 0x113888
jge 0xbea28
jmp 0xbea8c
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0xf8(%rcx), %rax
ja 0xbea42
jmp 0xbea8c
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
movq -0x8(%rbp), %rcx
subq 0xf8(%rcx), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rax
movq 0x54e1a(%rip), %rcx     # 0x113888
shrq %cl, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xbea81
jmp 0xbea8c
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xb5d40
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_ralloc_large_shrink
static void
arena_ralloc_large_shrink(arena_t *arena, arena_chunk_t *chunk, void *ptr,
    size_t oldsize, size_t size)
{

	assert(size < oldsize);

	/*
	 * Shrink the run, and make trailing pages available for other
	 * allocations.
	 */
	malloc_mutex_lock(&arena->lock);
	arena_run_trim_tail(arena, chunk, (arena_run_t *)ptr, oldsize, size,
	    true);
	if (config_stats) {
		arena->stats.ndalloc_large++;
		arena->stats.allocated_large -= oldsize;
		arena->stats.lstats[(oldsize >> LG_PAGE) - 1].ndalloc++;
		arena->stats.lstats[(oldsize >> LG_PAGE) - 1].curruns--;

		arena->stats.nmalloc_large++;
		arena->stats.nrequests_large++;
		arena->stats.allocated_large += size;
		arena->stats.lstats[(size >> LG_PAGE) - 1].nmalloc++;
		arena->stats.lstats[(size >> LG_PAGE) - 1].nrequests++;
		arena->stats.lstats[(size >> LG_PAGE) - 1].curruns++;
	}
	malloc_mutex_unlock(&arena->lock);
}

// 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 %r8, -0x28(%rbp)
jmp 0xbeaee
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0xb5d20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movl $0x1, %r9d
callq 0xb6c10
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x60(%rax)
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x20(%rbp), %rcx
shrq $0xc, %rcx
subq $0x1, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x20(%rbp), %rcx
shrq $0xc, %rcx
subq $0x1, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x50(%rax), %rcx
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x28(%rbp), %rcx
shrq $0xc, %rcx
subq $0x1, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x28(%rbp), %rcx
shrq $0xc, %rcx
subq $0x1, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x28(%rbp), %rcx
shrq $0xc, %rcx
subq $0x1, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0xb5ee0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/base.c
// Function: base_alloc
void *
base_alloc(size_t size)
{
	void *ret;
	size_t csize;

	/* Round size up to nearest multiple of the cacheline size. */
	csize = CACHELINE_CEILING(size);

	malloc_mutex_lock(&base_mtx);
	/* Make sure there's enough space for the allocation. */
	if ((uintptr_t)base_next_addr + csize > (uintptr_t)base_past_addr) {
		if (base_pages_alloc(csize)) {
			malloc_mutex_unlock(&base_mtx);
			return (NULL);
		}
	}
	/* Allocate. */
	ret = base_next_addr;
	base_next_addr = (void *)((uintptr_t)base_next_addr + csize);
	malloc_mutex_unlock(&base_mtx);

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x3f, %rax
andq $-0x40, %rax
movq %rax, -0x20(%rbp)
leaq 0x693fd(%rip), %rdi     # 0x1290b0
callq 0xbfd40
movq 0x69419(%rip), %rax     # 0x1290d8
addq -0x20(%rbp), %rax
movq 0x69416(%rip), %rcx     # 0x1290e0
cmpq %rcx, %rax
jbe 0xbfcf6
movq -0x20(%rbp), %rdi
callq 0xbfd60
testb $0x1, %al
jne 0xbfcde
jmp 0xbfcf4
leaq 0x693cb(%rip), %rdi     # 0x1290b0
callq 0xbfe10
movq $0x0, -0x8(%rbp)
jmp 0xbfd27
jmp 0xbfcf6
movq 0x693db(%rip), %rax     # 0x1290d8
movq %rax, -0x18(%rbp)
movq 0x693d0(%rip), %rax     # 0x1290d8
addq -0x20(%rbp), %rax
movq %rax, 0x693c5(%rip)     # 0x1290d8
leaq 0x69396(%rip), %rdi     # 0x1290b0
callq 0xbfe10
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/base.c
// Function: base_pages_alloc
static bool
base_pages_alloc(size_t minsize)
{
	size_t csize;
	bool zero;

	assert(minsize != 0);
	csize = CHUNK_CEILING(minsize);
	zero = false;
	base_pages = chunk_alloc(csize, chunksize, true, &zero,
	    chunk_dss_prec_get());
	if (base_pages == NULL)
		return (true);
	base_next_addr = base_pages;
	base_past_addr = (void *)((uintptr_t)base_pages + csize);

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
jmp 0xbfd6e
movq -0x10(%rbp), %rax
leaq 0x69457(%rip), %rcx     # 0x1291d0
addq (%rcx), %rax
leaq 0x6944d(%rip), %rcx     # 0x1291d0
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x6940c(%rip), %rax     # 0x1291b0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0xc0ae0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl %eax, %r8d
movl $0x1, %edx
leaq -0x19(%rbp), %rcx
callq 0xc0250
movq %rax, 0x69320(%rip)     # 0x1290f0
cmpq $0x0, 0x69318(%rip)     # 0x1290f0
jne 0xbfde0
movb $0x1, -0x1(%rbp)
jmp 0xbfe04
movq 0x69309(%rip), %rax     # 0x1290f0
movq %rax, 0x692ea(%rip)     # 0x1290d8
movq 0x692fb(%rip), %rax     # 0x1290f0
addq -0x18(%rbp), %rax
movq %rax, 0x692e0(%rip)     # 0x1290e0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/base.c
// Function: base_calloc
void *
base_calloc(size_t number, size_t size)
{
	void *ret = base_alloc(number * size);

	if (ret != NULL)
		memset(ret, 0, number * size);

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
imulq -0x10(%rbp), %rdi
callq 0xbfc90
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xbfe6d
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
imulq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x1f110
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/base.c
// Function: base_node_alloc
extent_node_t *
base_node_alloc(void)
{
	extent_node_t *ret;

	malloc_mutex_lock(&base_mtx);
	if (base_nodes != NULL) {
		ret = base_nodes;
		base_nodes = *(extent_node_t **)ret;
		malloc_mutex_unlock(&base_mtx);
	} else {
		malloc_mutex_unlock(&base_mtx);
		ret = (extent_node_t *)base_alloc(sizeof(extent_node_t));
	}

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x69221(%rip), %rdi     # 0x1290b0
callq 0xbfd40
cmpq $0x0, 0x6924c(%rip)     # 0x1290e8
je 0xbfec5
movq 0x69243(%rip), %rax     # 0x1290e8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x69231(%rip)     # 0x1290e8
leaq 0x691f2(%rip), %rdi     # 0x1290b0
callq 0xbfe10
jmp 0xbfedf
leaq 0x691e4(%rip), %rdi     # 0x1290b0
callq 0xbfe10
movl $0x40, %edi
callq 0xbfc90
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/base.c
// Function: base_node_dealloc
void
base_node_dealloc(extent_node_t *node)
{

	malloc_mutex_lock(&base_mtx);
	*(extent_node_t **)node = base_nodes;
	base_nodes = node;
	malloc_mutex_unlock(&base_mtx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x691ad(%rip), %rdi     # 0x1290b0
callq 0xbfd40
movq 0x691d9(%rip), %rcx     # 0x1290e8
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x691c7(%rip)     # 0x1290e8
leaq 0x69188(%rip), %rdi     # 0x1290b0
callq 0xbfe10
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/base.c
// Function: base_boot
bool
base_boot(void)
{

	base_nodes = NULL;
	if (malloc_mutex_init(&base_mtx))
		return (true);

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, 0x69195(%rip) # 0x1290e8
leaq 0x69156(%rip), %rdi     # 0x1290b0
callq 0xcde60
testb $0x1, %al
jne 0xbff65
jmp 0xbff6b
movb $0x1, -0x1(%rbp)
jmp 0xbff6f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/bitmap.c
// Function: bitmap_info_init
void
bitmap_info_init(bitmap_info_t *binfo, size_t nbits)
{
	unsigned i;
	size_t group_count;

	assert(nbits > 0);
	assert(nbits <= (ZU(1) << LG_BITMAP_MAXBITS));

	/*
	 * Compute the number of groups necessary to store nbits bits, and
	 * progressively work upward through the levels until reaching a level
	 * that requires only one group.
	 */
	binfo->levels[0].group_offset = 0;
	group_count = bits2groups(nbits);
	for (i = 1; group_count > 1; i++) {
		assert(i < BITMAP_MAX_LEVELS);
		binfo->levels[i].group_offset = binfo->levels[i-1].group_offset
		    + group_count;
		group_count = bits2groups(group_count);
	}
	binfo->levels[i].group_offset = binfo->levels[i-1].group_offset
	    + group_count;
	binfo->nlevels = i;
	binfo->nbits = nbits;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xbfff2
jmp 0xbfff4
jmp 0xbfff6
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0xc00a0
movq %rax, -0x20(%rbp)
movl $0x1, -0x14(%rbp)
cmpq $0x1, -0x20(%rbp)
jbe 0xc005a
jmp 0xc001f
jmp 0xc0021
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movq 0x10(%rax,%rcx,8), %rdx
addq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movq %rdx, 0x10(%rax,%rcx,8)
movq -0x20(%rbp), %rdi
callq 0xc00a0
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc0016
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movq 0x10(%rax,%rcx,8), %rdx
addq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movq %rdx, 0x10(%rax,%rcx,8)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/chunk.c
// Function: chunk_unmap
void
chunk_unmap(void *chunk, size_t size)
{
	assert(chunk != NULL);
	assert(CHUNK_ADDR2BASE(chunk) == chunk);
	assert(size != 0);
	assert((size & chunksize_mask) == 0);

	if (config_dss && chunk_in_dss(chunk))
		chunk_record(&chunks_szad_dss, &chunks_ad_dss, chunk, size);
	else if (chunk_dealloc_mmap(chunk, size))
		chunk_record(&chunks_szad_mmap, &chunks_ad_mmap, chunk, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xc06c2
jmp 0xc06c4
jmp 0xc06c6
jmp 0xc06c8
jmp 0xc06ca
jmp 0xc06cc
jmp 0xc06ce
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc1140
testb $0x1, %al
jne 0xc06e1
jmp 0xc06fc
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x68a08(%rip), %rdi     # 0x1290f8
leaq 0x68a49(%rip), %rsi     # 0x129140
callq 0xc0710
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/chunk.c
// Function: chunk_dealloc
void
chunk_dealloc(void *chunk, size_t size, bool unmap)
{

	assert(chunk != NULL);
	assert(CHUNK_ADDR2BASE(chunk) == chunk);
	assert(size != 0);
	assert((size & chunksize_mask) == 0);

	if (config_ivsalloc)
		rtree_set(chunks_rtree, (uintptr_t)chunk, NULL);
	if (config_stats || config_prof) {
		malloc_mutex_lock(&chunks_mtx);
		assert(stats_chunks.curchunks >= (size / chunksize));
		stats_chunks.curchunks -= (size / chunksize);
		malloc_mutex_unlock(&chunks_mtx);
	}

	if (unmap)
		chunk_unmap(chunk, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0xc0969
jmp 0xc096b
jmp 0xc096d
jmp 0xc096f
jmp 0xc0971
jmp 0xc0973
jmp 0xc0975
leaq 0x6880c(%rip), %rdi     # 0x129188
callq 0xc0670
jmp 0xc0983
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x6881e(%rip)           # 0x1291b0
movq %rax, %rcx
movq 0x6882c(%rip), %rax     # 0x1291c8
subq %rcx, %rax
movq %rax, 0x68822(%rip)     # 0x1291c8
leaq 0x687db(%rip), %rdi     # 0x129188
callq 0xc0690
testb $0x1, -0x11(%rbp)
je 0xc09c5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc06b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/chunk.c
// Function: chunk_boot
bool
chunk_boot(void)
{

	/* Set variables according to the value of opt_lg_chunk. */
	chunksize = (ZU(1) << opt_lg_chunk);
	assert(chunksize >= PAGE);
	chunksize_mask = chunksize - 1;
	chunk_npages = (chunksize >> LG_PAGE);

	if (config_stats || config_prof) {
		if (malloc_mutex_init(&chunks_mtx))
			return (true);
		memset(&stats_chunks, 0, sizeof(chunk_stats_t));
	}
	if (config_dss && chunk_dss_boot())
		return (true);
	extent_tree_szad_new(&chunks_szad_mmap);
	extent_tree_ad_new(&chunks_ad_mmap);
	extent_tree_szad_new(&chunks_szad_dss);
	extent_tree_ad_new(&chunks_ad_dss);
	if (config_ivsalloc) {
		chunks_rtree = rtree_new((ZU(1) << (LG_SIZEOF_PTR+3)) -
		    opt_lg_chunk);
		if (chunks_rtree == NULL)
			return (true);
	}

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x52eb9(%rip), %rcx     # 0x113898
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x687c2(%rip)     # 0x1291b0
jmp 0xc09f0
movq 0x687b9(%rip), %rax     # 0x1291b0
subq $0x1, %rax
movq %rax, 0x687ce(%rip)     # 0x1291d0
movq 0x687a7(%rip), %rax     # 0x1291b0
shrq $0xc, %rax
movq %rax, 0x687c4(%rip)     # 0x1291d8
leaq 0x6876d(%rip), %rdi     # 0x129188
callq 0xcde60
testb $0x1, %al
jne 0xc0a26
jmp 0xc0a2c
movb $0x1, -0x1(%rbp)
jmp 0xc0a73
leaq 0x68785(%rip), %rdi     # 0x1291b8
xorl %esi, %esi
movl $0x18, %edx
callq 0x1f110
leaq 0x686b2(%rip), %rdi     # 0x1290f8
callq 0xc93b0
leaq 0x686ee(%rip), %rdi     # 0x129140
callq 0xcb0b0
leaq 0x68782(%rip), %rdi     # 0x1291e0
callq 0xc93b0
leaq 0x687be(%rip), %rdi     # 0x129228
callq 0xcb0b0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/chunk_dss.c
// Function: chunk_in_dss
bool
chunk_in_dss(void *chunk)
{
	bool ret;

	cassert(config_dss);

	malloc_mutex_lock(&dss_mtx);
	if ((uintptr_t)chunk >= (uintptr_t)dss_base
	    && (uintptr_t)chunk < (uintptr_t)dss_max)
		ret = true;
	else
		ret = false;
	malloc_mutex_unlock(&dss_mtx);

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0xc0d8e
jmp 0xc0d90
jmp 0xc0d92
leaq 0x684ef(%rip), %rdi     # 0x129288
callq 0xc0d40
movq -0x8(%rbp), %rax
movq 0x68517(%rip), %rcx     # 0x1292c0
cmpq %rcx, %rax
jb 0xc0dc4
movq -0x8(%rbp), %rax
movq 0x684ff(%rip), %rcx     # 0x1292b8
cmpq %rcx, %rax
jae 0xc0dc4
movb $0x1, -0x9(%rbp)
jmp 0xc0dc8
movb $0x0, -0x9(%rbp)
leaq 0x684b9(%rip), %rdi     # 0x129288
callq 0xc0d60
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop