LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/include/jemalloc/internal/tcache.h
// Function: tcache_get
JEMALLOC_INLINE tcache_t *
tcache_get(bool create)
{
	tcache_t *tcache;

	if (config_tcache == false)
		return (NULL);
	if (config_lazy_lock && isthreaded == false)
		return (NULL);

	tcache = *tcache_tsd_get();
	if ((uintptr_t)tcache <= (uintptr_t)TCACHE_STATE_MAX) {
		if (tcache == TCACHE_STATE_DISABLED)
			return (NULL);
		if (tcache == NULL) {
			if (create == false) {
				/*
				 * Creating a tcache here would cause
				 * allocation as a side effect of free().
				 * Ordinarily that would be okay since
				 * tcache_create() failure is a soft failure
				 * that doesn't propagate.  However, if TLS
				 * data are freed via free() as in glibc,
				 * subtle corruption could result from setting
				 * a TLS variable after its backing memory is
				 * freed.
				 */
				return (NULL);
			}
			if (tcache_enabled_get() == false) {
				tcache_enabled_set(false); /* Memoize. */
				return (NULL);
			}
			return (tcache_create(choose_arena(NULL)));
		}
		if (tcache == TCACHE_STATE_PURGATORY) {
			/*
			 * Make a note that an allocator function was called
			 * after tcache_thread_cleanup() was called.
			 */
			tcache = TCACHE_STATE_REINCARNATED;
			tcache_tsd_set(&tcache);
			return (NULL);
		}
		if (tcache == TCACHE_STATE_REINCARNATED)
			return (NULL);
		not_reached();
	}

	return (tcache);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x40d2f(%rip), %r14     # 0xc5f58
movq %fs:(%r14), %rax
cmpq $0x3, %rax
ja 0x852e0
leaq -0x1(%rax), %rcx
cmpq $0x2, %rcx
jb 0x852de
movq %fs:0x0, %rbx
addq %r14, %rbx
cmpq $0x3, %rax
je 0x852a9
testq %rax, %rax
jne 0x852e0
testb %dil, %dil
je 0x852de
movq 0x40d1c(%rip), %rcx     # 0xc5f88
movl %fs:(%rcx), %edx
cmpl $0x2, %edx
jne 0x85281
leaq 0x44d15(%rip), %rdx     # 0xc9f90
movzbl (%rdx), %edx
movl %edx, %fs:(%rcx)
testl %edx, %edx
je 0x852e8
movq 0x40cac(%rip), %rax     # 0xc5f38
movq %fs:(%rax), %rdi
testq %rdi, %rdi
jne 0x8529d
callq 0x7c4da
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x910eb
movq $0x2, %fs:(%r14)
leaq 0x6b8f8(%rip), %rax     # 0xf0bb0
movl (%rax), %edi
movq %rbx, %rsi
callq 0x1f1c0
testl %eax, %eax
je 0x852de
leaq 0x1dea1(%rip), %rdi     # 0xa316e
callq 0x915d4
leaq 0x59881(%rip), %rax     # 0xdeb5a
cmpb $0x1, (%rax)
je 0x8530e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x0, %fs:(%rcx)
cmpq $0x4, %rax
jb 0x852ff
movq %rax, %rdi
callq 0x91234
jmp 0x85304
testq %rax, %rax
jne 0x852de
movq $0x1, %fs:(%r14)
jmp 0x852b1
callq 0x1f1b0
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: ipallocx
JEMALLOC_INLINE void *
ipallocx(size_t usize, size_t alignment, bool zero, bool try_tcache,
    arena_t *arena)
{
	void *ret;

	assert(usize != 0);
	assert(usize == sa2u(usize, alignment));

	if (usize <= arena_maxclass && alignment <= PAGE)
		ret = arena_malloc(arena, usize, zero, try_tcache);
	else {
		if (usize <= arena_maxclass) {
			ret = arena_palloc(choose_arena(arena), usize,
			    alignment, zero);
		} else if (alignment <= chunksize)
			ret = huge_malloc(usize, zero);
		else
			ret = huge_palloc(usize, alignment, zero);
	}

	assert(ALIGNMENT_ADDR2BASE(ret, alignment) == ret);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x5f981(%rip), %rax     # 0xdf930
movq (%rax), %rax
cmpq %rdi, %rax
setb %dl
cmpq $0x1001, %rsi           # imm = 0x1001
setae %sil
orb %dl, %sil
jne 0x7ffde
movzbl %bpl, %edx
movzbl %cl, %ecx
movq %r8, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x7fb8c
cmpq %rbx, %rax
jb 0x80014
testq %r8, %r8
jne 0x7fffe
movq %fs:-0x30, %r8
testq %r8, %r8
jne 0x7fffe
callq 0x7c4da
movq %rax, %r8
movzbl %bpl, %ecx
movq %r8, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x8104f
leaq 0x5f845(%rip), %rax     # 0xdf860
cmpq %r14, (%rax)
jae 0x80033
movzbl %bpl, %edx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x8b92d
movzbl %bpl, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x8b91c
nop
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_dalloc_junk_small
void
arena_dalloc_junk_small(void *ptr, arena_bin_info_t *bin_info)
{
	size_t size = bin_info->reg_size;
	size_t redzone_size = bin_info->redzone_size;
	size_t i;
	bool error = false;

	for (i = 1; i <= redzone_size; i++) {
		unsigned byte;
		if ((byte = *(uint8_t *)((uintptr_t)ptr - i)) != 0xa5) {
			error = true;
			malloc_printf("<jemalloc>: Corrupt redzone "
			    "%zu byte%s before %p (size %zu), byte=%#x\n", i,
			    (i == 1) ? "" : "s", ptr, size, byte);
		}
	}
	for (i = 0; i < redzone_size; i++) {
		unsigned byte;
		if ((byte = *(uint8_t *)((uintptr_t)ptr + size + i)) != 0xa5) {
			error = true;
			malloc_printf("<jemalloc>: Corrupt redzone "
			    "%zu byte%s after end of %p (size %zu), byte=%#x\n",
			    i, (i == 1) ? "" : "s", ptr, size, byte);
		}
	}
	if (opt_abort && error)
		abort();

	memset((void *)((uintptr_t)ptr - redzone_size), 0x5a,
	    bin_info->reg_interval);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rsi), %rbp
testq %rbp, %rbp
je 0x80c1e
movq %rsi, (%rsp)
movq (%rsi), %r15
leaq -0x1(%r14), %rbx
movl $0x1, %r12d
xorl %eax, %eax
leaq 0x2287e(%rip), %r13     # 0xa33f4
movzbl (%rbx), %r9d
cmpl $0xa5, %r9d
je 0x80bae
cmpq $0x1, %r12
leaq 0x1e8f5(%rip), %rdx     # 0x9f483
leaq 0x167ac(%rip), %rax     # 0x97341
cmoveq %rax, %rdx
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x926f9
movb $0x1, %al
incq %r12
decq %rbx
cmpq %rbp, %r12
jbe 0x80b76
testq %rbp, %rbp
je 0x80c0d
leaq (%r15,%r14), %rbx
leaq 0x22872(%rip), %r12     # 0xa343b
xorl %r13d, %r13d
movzbl (%rbx,%r13), %r9d
cmpl $0xa5, %r9d
je 0x80c05
cmpq $0x1, %r13
leaq 0x1e89e(%rip), %rdx     # 0x9f483
leaq 0x16755(%rip), %rax     # 0x97341
cmoveq %rax, %rdx
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x926f9
movb $0x1, %al
incq %r13
cmpq %r13, %rbp
jne 0x80bcc
leaq 0x5df46(%rip), %rcx     # 0xdeb5a
andb (%rcx), %al
cmpb $0x1, %al
movq (%rsp), %rsi
je 0x80c40
subq %rbp, %r14
movq 0x10(%rsi), %rdx
movq %r14, %rdi
movl $0x5a, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1f110
callq 0x1f1b0
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_malloc_large
void *
arena_malloc_large(arena_t *arena, size_t size, bool zero)
{
	void *ret;

	/* Large allocation. */
	size = PAGE_CEILING(size);
	malloc_mutex_lock(&arena->lock);
	ret = (void *)arena_run_alloc(arena, size, true, BININD_INVALID, zero);
	if (ret == NULL) {
		malloc_mutex_unlock(&arena->lock);
		return (NULL);
	}
	if (config_stats) {
		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++;
	}
	if (config_prof)
		arena_prof_accum(arena, size);
	malloc_mutex_unlock(&arena->lock);

	if (zero == false) {
		if (config_fill) {
			if (opt_junk)
				memset(ret, 0xa5, size);
			else if (opt_zero)
				memset(ret, 0, size);
		}
	}

	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r13
addq $0xfff, %r15            # imm = 0xFFF
movq %r15, %rbx
andq $-0x1000, %rbx          # imm = 0xF000
leaq 0x8(%rdi), %r12
movq %r12, %rdi
callq 0x1faa0
movl $0xff, %ecx
movq %r13, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl %ebp, %r8d
callq 0x80fbb
movq %rax, %r14
testq %rax, %rax
je 0x80f7a
incq 0x68(%r13)
movdqu 0x50(%r13), %xmm0
movq %rbx, %xmm1
shufpd $0x2, 0x130fa(%rip), %xmm1 # xmm1 = xmm1[0],mem[1]
paddq %xmm0, %xmm1
movdqu %xmm1, 0x50(%r13)
movq 0x70(%r13), %rax
shrq $0x7, %r15
andq $-0x20, %r15
incq -0x20(%r15,%rax)
movdqu -0x10(%r15,%rax), %xmm0
pcmpeqd %xmm1, %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, -0x10(%r15,%rax)
movq %r12, %rdi
callq 0x1fbb0
testb %bpl, %bpl
jne 0x80f82
leaq 0x5dbf0(%rip), %rax     # 0xdeb5b
cmpb $0x1, (%rax)
jne 0x80f94
movq %r14, %rdi
movl $0xa5, %esi
jmp 0x80fa5
movq %r12, %rdi
callq 0x1fbb0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5dbd1(%rip), %rax     # 0xdeb6c
cmpb $0x1, (%rax)
jne 0x80f82
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1f110
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_run_alloc
static arena_run_t *
arena_run_alloc(arena_t *arena, size_t size, bool large, size_t binind,
    bool zero)
{
	arena_chunk_t *chunk;
	arena_run_t *run;

	assert(size <= arena_maxclass);
	assert((size & PAGE_MASK) == 0);
	assert((large && binind == BININD_INVALID) || (large == false && binind
	    != BININD_INVALID));

	/* Search the arena's chunks for the lowest best fit. */
	run = arena_run_alloc_helper(arena, size, large, binind, zero);
	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_run_t *)((uintptr_t)chunk + (map_bias << LG_PAGE));
		arena_run_split(arena, run, size, large, binind, zero);
		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_helper(arena, size, large, binind, zero));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %rbx
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %r15
callq 0x84fa5
movq %rax, %r13
testq %rax, %rax
jne 0x81019
movq %r15, %rdi
callq 0x8349d
testq %rax, %rax
je 0x8102b
leaq 0x5e932(%rip), %rcx     # 0xdf928
movq (%rcx), %r13
shlq $0xc, %r13
addq %rax, %r13
movzbl %r12b, %ecx
movzbl %bpl, %r9d
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %r8
callq 0x83614
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl %r12b, %edx
movzbl %bpl, %r8d
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x84fa5
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_dalloc_bin
void
arena_dalloc_bin(arena_t *arena, arena_chunk_t *chunk, void *ptr,
    size_t pageind, arena_chunk_map_t *mapelm)
{
	arena_run_t *run;
	arena_bin_t *bin;

	run = (arena_run_t *)((uintptr_t)chunk + (uintptr_t)((pageind -
	    arena_mapbits_small_runind_get(chunk, pageind)) << LG_PAGE));
	bin = run->bin;
	malloc_mutex_lock(&bin->lock);
	arena_dalloc_bin_locked(arena, chunk, ptr, mapelm);
	malloc_mutex_unlock(&bin->lock);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x5e1cf(%rip), %rax     # 0xdf928
movq %rcx, %rdx
subq (%rax), %rdx
leaq (%rdx,%rdx,2), %rax
movq 0x40(%rsi,%rax,8), %rax
shrq $0xc, %rax
subq %rax, %rcx
shlq $0xc, %rcx
movq (%rcx,%rsi), %r13
movq %r13, %rdi
callq 0x1faa0
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x8134a
movq %r13, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1fbb0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdx, %rax
subq %rsi, %rax
shrq $0xc, %rax
leaq 0x5e14d(%rip), %rcx     # 0xdf928
subq (%rcx), %rax
movq %rdi, %r14
leaq (%rax,%rax,2), %rax
movq 0x40(%rsi,%rax,8), %r12
movq %r12, %r15
andq $-0x1000, %r15          # imm = 0xF000
leaq 0x5d360(%rip), %rax     # 0xdeb5b
cmpb $0x1, (%rax)
jne 0x81810
movq %rbx, %rdi
movl $0x5a, %esi
movq %r15, %rdx
callq 0x1f110
incq 0x60(%r14)
subq %r15, 0x50(%r14)
movq 0x70(%r14), %rax
shrq $0x7, %r12
andq $-0x20, %r12
incq -0x18(%r12,%rax)
decq -0x8(%r12,%rax)
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x81848
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_new
bool
arena_new(arena_t *arena, unsigned ind)
{
	unsigned i;
	arena_bin_t *bin;

	arena->ind = ind;
	arena->nthreads = 0;

	if (malloc_mutex_init(&arena->lock))
		return (true);

	if (config_stats) {
		memset(&arena->stats, 0, sizeof(arena_stats_t));
		arena->stats.lstats =
		    (malloc_large_stats_t *)base_alloc(nlclasses *
		    sizeof(malloc_large_stats_t));
		if (arena->stats.lstats == NULL)
			return (true);
		memset(arena->stats.lstats, 0, nlclasses *
		    sizeof(malloc_large_stats_t));
		if (config_tcache)
			ql_new(&arena->tcache_ql);
	}

	if (config_prof)
		arena->prof_accumbytes = 0;

	arena->dss_prec = chunk_dss_prec_get();

	/* Initialize chunks. */
	arena_chunk_dirty_new(&arena->chunks_dirty);
	arena->spare = NULL;

	arena->nactive = 0;
	arena->ndirty = 0;
	arena->npurgatory = 0;

	arena_avail_tree_new(&arena->runs_avail);

	/* Initialize bins. */
	for (i = 0; i < NBINS; i++) {
		bin = &arena->bins[i];
		if (malloc_mutex_init(&bin->lock))
			return (true);
		bin->runcur = NULL;
		arena_run_tree_new(&bin->runs);
		if (config_stats)
			memset(&bin->stats, 0, sizeof(malloc_bin_stats_t));
	}

	return (false);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, (%rdi)
movl $0x0, 0x4(%rdi)
addq $0x8, %rdi
callq 0x8bfc4
movb $0x1, %bpl
testb %al, %al
jne 0x82e4f
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movq $0x0, 0x70(%rbx)
leaq 0x5cb48(%rip), %r14     # 0xdf888
movq (%r14), %rdi
leaq 0x5cbde(%rip), %r15     # 0xdf928
subq (%r15), %rdi
shlq $0x5, %rdi
callq 0x85494
movq %rax, 0x70(%rbx)
testq %rax, %rax
je 0x82e4f
movq (%r14), %rdx
subq (%r15), %rdx
shlq $0x5, %rdx
xorl %r15d, %r15d
movq %rax, %rdi
xorl %esi, %esi
callq 0x1f110
movq $0x0, 0x78(%rbx)
callq 0x85c68
movl %eax, 0x88(%rbx)
leaq 0x98(%rbx), %rax
movq %rax, 0x90(%rbx)
movq %rax, 0xa0(%rbx)
andq $-0x2, %rax
movq %rax, 0xa8(%rbx)
leaq 0x108(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xe0(%rbx)
movups %xmm0, 0xf0(%rbx)
movq %rax, 0x100(%rbx)
movq %rax, 0x108(%rbx)
andq $-0x2, %rax
movq %rax, 0x110(%rbx)
leaq 0x120(%rbx), %r14
addq $0x158, %rbx            # imm = 0x158
movl $0x98, %r12d
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x8bfc4
movl %eax, %ebp
testb %al, %al
jne 0x82e4f
movq %r15, 0x28(%r14)
leaq 0x38(%r14), %rax
movq %rax, 0x30(%r14)
movq %rax, 0x38(%r14)
leaq (%rbx,%r13), %rax
andq $-0x2, %rax
movq %rax, 0x40(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r14)
movups %xmm0, 0x60(%r14)
movups %xmm0, 0x70(%r14)
movups %xmm0, 0x80(%r14)
movq %r15, 0x90(%r14)
addq %r12, %r14
addq %r12, %r13
cmpq $0x10a0, %r13           # imm = 0x10A0
jne 0x82df5
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rcx, %r14
movl %edx, %r10d
movq %rsi, %r11
movq 0x100(%rdi), %r9
leaq 0x108(%rdi), %rcx
cmpq %rcx, %r9
je 0x8501e
movq %r11, %rdx
andq $-0x1000, %rdx          # imm = 0xF000
movq $-0x1000, %rsi          # imm = 0xF000
movq %rcx, %rax
movq 0x10(%r9), %rbx
andq %rsi, %rbx
xorl %ebp, %ebp
cmpq %rbx, %rdx
seta %bpl
sbbl $0x0, %ebp
movq %r9, %rbx
negq %rbx
movl $0x0, %ebx
sbbl %ebx, %ebx
testl %ebp, %ebp
cmovnel %ebp, %ebx
testl %ebx, %ebx
js 0x8500e
je 0x8501e
movq 0x8(%r9), %rbx
andq $-0x2, %rbx
jmp 0x85014
movq (%r9), %rbx
movq %r9, %rax
movq %rbx, %r9
cmpq %rcx, %rbx
jne 0x84fd9
jmp 0x85021
movq %r9, %rax
cmpq %rcx, %rax
sete %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0x85035
xorl %ebx, %ebx
jmp 0x85087
leaq 0x5a844(%rip), %rcx     # 0xdf880
movq (%rcx), %rcx
notq %rcx
andq %rax, %rcx
subq %rcx, %rax
addq $-0x30, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rdx
movq %rdx, %rbx
shrq $0x4, %rbx
leaq 0x5a8c1(%rip), %rax     # 0xdf928
addq (%rax), %rbx
shlq $0xc, %rbx
addq %rcx, %rbx
movzbl %r10b, %ecx
movzbl %r8b, %r9d
movq %rbx, %rsi
movq %r11, %rdx
movq %r14, %r8
callq 0x83614
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
subq $0x788, %rsp            # imm = 0x788
leaq 0x5a7e3(%rip), %rax     # 0xdf880
movq (%rax), %rax
notq %rax
andq %rsi, %rax
subq %rax, %rsi
shrq $0xc, %rsi
leaq 0x5a874(%rip), %rcx     # 0xdf928
subq (%rcx), %rsi
leaq (%rsi,%rsi,2), %rcx
leaq (%rax,%rcx,8), %rcx
addq $0x30, %rcx
leaq 0x38(%rdi), %rdx
movq %rdx, (%rcx)
movq %rdx, %rax
orq $0x1, %rax
movq %rax, 0x8(%rcx)
movq 0x30(%rdi), %r8
leaq -0x80(%rsp), %rsi
movq %r8, (%rsi)
movq %rsi, %rax
cmpq %rdx, %r8
je 0x85122
leaq -0x80(%rsp), %rax
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpq %rcx, %r8
setb %r9b
seta %r10b
subl %r10d, %r9d
movl %r9d, 0x8(%rax)
js 0x85112
movq 0x8(%r8), %r8
andq $-0x2, %r8
jmp 0x85115
movq (%r8), %r8
movq %r8, 0x10(%rax)
addq $0x10, %rax
cmpq %rdx, %r8
jne 0x850ee
movq %rcx, (%rax)
addq $-0x10, %rax
cmpq %rsi, %rax
jb 0x85209
leaq -0x80(%rsp), %rdx
movq (%rax), %rsi
cmpl $0x0, 0x8(%rax)
js 0x8518f
movq 0x8(%rsi), %r9
andl $0x1, %r9d
orq %rcx, %r9
movq %r9, 0x8(%rsi)
testb $0x1, 0x8(%rcx)
je 0x85216
movq (%rsi), %r8
movq 0x8(%r8), %r10
testb $0x1, %r10b
jne 0x851cb
andl $0x1, %r9d
movq %rcx, %r8
andq $-0x2, %r8
movq (%r8), %rcx
orq %r9, %rcx
movq %rcx, 0x8(%rsi)
movq %rsi, (%r8)
leaq 0x8(%r8), %rcx
movq 0x8(%r8), %r10
andq $-0x2, %r10
orq %r9, %r10
jmp 0x851e1
movq %rcx, (%rsi)
testb $0x1, 0x8(%rcx)
je 0x85216
movq (%rcx), %rcx
movq 0x8(%rcx), %r8
testb $0x1, %r8b
je 0x851f6
andq $-0x2, %r8
movq %r8, 0x8(%rcx)
movq (%rsi), %r8
movq 0x8(%r8), %rcx
andq $-0x2, %rcx
movq %rcx, (%rsi)
movq 0x8(%r8), %rcx
andl $0x1, %ecx
orq %rsi, %rcx
leaq 0x8(%r8), %rsi
jmp 0x851f0
addq $0x8, %rcx
andq $-0x2, %r10
movq %r10, 0x8(%r8)
movq (%rcx), %r10
andq $-0x2, %r10
movq %rsi, %r8
movq %r10, (%rcx)
movq 0x8(%rsi), %rcx
addq $0x8, %rsi
orq $0x1, %rcx
movq %rcx, (%rsi)
movq %r8, %rsi
movq %rsi, (%rax)
addq $-0x10, %rax
movq %rsi, %rcx
cmpq %rdx, %rax
jae 0x85137
movq -0x80(%rsp), %rax
movq %rax, 0x30(%rdi)
andb $-0x2, 0x8(%rax)
addq $0x788, %rsp            # imm = 0x788
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x3f, %rbx
andq $-0x40, %rbx
leaq 0x5a2b2(%rip), %rdi     # 0xdf760
callq 0x1faa0
movq 0x5a2ce(%rip), %r14     # 0xdf788
leaq (%rbx,%r14), %rax
cmpq 0x5a2cb(%rip), %rax     # 0xdf790
jbe 0x85528
leaq 0x5a3b2(%rip), %rax     # 0xdf880
movq (%rax), %r15
leaq (%r15,%rbx), %rax
notq %r15
andq %rax, %r15
leaq 0x7(%rsp), %r14
movb $0x0, (%r14)
leaq 0x5a375(%rip), %rax     # 0xdf860
movq (%rax), %r12
callq 0x85c68
movq %r15, %rdi
movq %r12, %rsi
movl $0x1, %edx
movq %r14, %rcx
movl %eax, %r8d
callq 0x85730
movq %rax, 0x5a290(%rip)     # 0xdf7a0
testq %rax, %rax
je 0x8554a
movq %rax, %r14
addq %rax, %r15
movq %r15, 0x5a26e(%rip)     # 0xdf790
addq %rax, %rbx
movq %rbx, %rax
movq %rax, 0x5a259(%rip)     # 0xdf788
leaq 0x5a22a(%rip), %rdi     # 0xdf760
callq 0x1fbb0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r14d, %r14d
jmp 0x8552f
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
imulq %rsi, %rbx
movq %rbx, %rdi
callq 0x85494
testq %rax, %rax
je 0x85572
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
jmp 0x1f110
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq 0x5a1e4(%rip), %rdi     # 0xdf760
callq 0x1faa0
movq 0x5a210(%rip), %rbx     # 0xdf798
testq %rbx, %rbx
je 0x855a8
movq (%rbx), %rax
movq %rax, 0x5a201(%rip)     # 0xdf798
leaq 0x5a1c2(%rip), %rdi     # 0xdf760
callq 0x1fbb0
movq %rbx, %rax
popq %rbx
retq
leaq 0x5a1b1(%rip), %rdi     # 0xdf760
callq 0x1fbb0
movl $0x40, %edi
popq %rbx
jmp 0x85494
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5a193(%rip), %r14     # 0xdf760
movq %r14, %rdi
callq 0x1faa0
movq 0x5a1bc(%rip), %rax     # 0xdf798
movq %rax, (%rbx)
movq %rbx, 0x5a1b2(%rip)     # 0xdf798
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1fbb0
// File: /workspace/github_c_makefile_star2_O3/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:
movq $0x0, 0x10(%rdi)
movq %rsi, %rax
shrq $0x6, %rax
movl %esi, %ecx
andl $0x3f, %ecx
cmpq $0x1, %rcx
sbbq $-0x1, %rax
movl $0x1, %ecx
xorl %edx, %edx
cmpq $0x2, %rax
jb 0x85682
movq %rax, %r8
addq %r8, %rdx
movl %ecx, %r9d
shrq $0x6, %rax
andl $0x3f, %r8d
cmpq $0x1, %r8
sbbq $-0x1, %rax
movq %rdx, 0x10(%rdi,%r9,8)
incl %ecx
movq %rax, %r8
cmpq $0x1, %rax
ja 0x8565c
addq %rax, %rdx
movl %ecx, %eax
movq %rdx, 0x10(%rdi,%rax,8)
movl %ecx, 0x8(%rdi)
movq %rsi, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r12
movq %rdi, %rbx
callq 0x85f92
testb %al, %al
je 0x85b3b
movq %rbx, %rdi
movq %r12, %rsi
callq 0x85e44
movl %eax, %ebp
callq 0x85574
movq %rax, %r15
leaq 0x59e3a(%rip), %rdi     # 0xdf838
callq 0x1faa0
leaq (%rbx,%r12), %rax
leaq 0x8(%rsp), %rsi
movq %rax, 0x28(%rsi)
leaq 0x59dd9(%rip), %rdi     # 0xdf7f0
callq 0x8b011
testq %rax, %rax
je 0x85a2f
movq %rax, %r14
movq 0x28(%rax), %rax
cmpq 0x30(%rsp), %rax
je 0x85a6b
testq %r15, %r15
je 0x85b2f
movq %rbx, 0x28(%r15)
movq %r12, 0x30(%r15)
xorb $0x1, %bpl
movb %bpl, 0x38(%r15)
leaq 0x59da1(%rip), %rdi     # 0xdf7f0
movq %r15, %rsi
callq 0x8b0af
leaq 0x59d4a(%rip), %rdi     # 0xdf7a8
movq %r15, %rsi
callq 0x8a62c
movq %r15, %r14
jmp 0x85aa5
leaq 0x59d36(%rip), %r13     # 0xdf7a8
movq %r13, %rdi
movq %r14, %rsi
callq 0x8a7a8
movq %rbx, 0x28(%r14)
addq %r12, 0x30(%r14)
xorb $0x1, %bpl
andb %bpl, 0x38(%r14)
movq %r13, %rdi
movq %r14, %rsi
callq 0x8a62c
testq %r15, %r15
je 0x85aa5
movq %r15, %rdi
callq 0x855bf
leaq 0x59d44(%rip), %rdi     # 0xdf7f0
movq %r14, %rsi
callq 0x8af83
testq %rax, %rax
je 0x85b2f
movq %rax, %r15
movq 0x30(%rax), %rax
addq 0x28(%r15), %rax
cmpq %rbx, %rax
jne 0x85b2f
leaq 0x59cd8(%rip), %rbx     # 0xdf7a8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8a7a8
leaq 0x59d0e(%rip), %rdi     # 0xdf7f0
movq %r15, %rsi
callq 0x8b21b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a7a8
movq 0x28(%r15), %rax
movq %rax, 0x28(%r14)
movq 0x30(%r15), %rax
addq %rax, 0x30(%r14)
cmpb $0x1, 0x38(%r14)
jne 0x85b12
movb 0x38(%r15), %al
jmp 0x85b14
xorl %eax, %eax
movb %al, 0x38(%r14)
leaq 0x59c89(%rip), %rdi     # 0xdf7a8
movq %r14, %rsi
callq 0x8a62c
movq %r15, %rdi
callq 0x855bf
leaq 0x59d02(%rip), %rdi     # 0xdf838
callq 0x1fbb0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x59cd8(%rip), %r15     # 0xdf838
movq %r15, %rdi
callq 0x1faa0
movq %rbx, %rax
xorl %edx, %edx
divq 0x59cec(%rip)           # 0xdf860
subq %rax, 0x59cfd(%rip)     # 0xdf878
movq %r15, %rdi
callq 0x1fbb0
testl %ebp, %ebp
je 0x85b9c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x859c1
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x59b5d(%rip), %r14     # 0xdf938
movq %r14, %rdi
callq 0x1faa0
cmpq %rbx, 0x59b86(%rip)     # 0xdf970
setbe %al
cmpq %rbx, 0x59b74(%rip)     # 0xdf968
seta %bl
andb %al, %bl
movq %r14, %rdi
callq 0x1fbb0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/chunk_dss.c
// Function: chunk_dss_boot
bool
chunk_dss_boot(void)
{

	cassert(config_dss);

	if (malloc_mutex_init(&dss_mtx))
		return (true);
	dss_base = sbrk(0);
	dss_prev = dss_base;
	dss_max = dss_base;

	return (false);
}

// Assembly:
pushq %rbx
leaq 0x59b25(%rip), %rdi     # 0xdf938
callq 0x8bfc4
movl %eax, %ebx
testb %al, %al
jne 0x85e3a
xorl %edi, %edi
callq 0x1f3e0
movq %rax, 0x59b44(%rip)     # 0xdf970
movq %rax, 0x59b2d(%rip)     # 0xdf960
movq %rax, 0x59b2e(%rip)     # 0xdf968
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/chunk_mmap.c
// Function: chunk_alloc_mmap
void *
chunk_alloc_mmap(size_t size, size_t alignment, bool *zero)
{
	void *ret;
	size_t offset;

	/*
	 * Ideally, there would be a way to specify alignment to mmap() (like
	 * NetBSD has), but in the absence of such a feature, we have to work
	 * hard to efficiently create aligned mappings.  The reliable, but
	 * slow method is to create a mapping that is over-sized, then trim the
	 * excess.  However, that always results in one or two calls to
	 * pages_unmap().
	 *
	 * Optimistically try mapping precisely the right amount before falling
	 * back to the slow method, with the expectation that the optimistic
	 * approach works most of the time.
	 */

	assert(alignment != 0);
	assert((alignment & chunksize_mask) == 0);

	ret = pages_map(NULL, size);
	if (ret == NULL)
		return (NULL);
	offset = ALIGNMENT_ADDR2OFFSET(ret, alignment);
	if (offset != 0) {
		pages_unmap(ret, size);
		return (chunk_alloc_mmap_slow(size, alignment, zero));
	}

	assert(ret != NULL);
	*zero = true;
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
xorl %edi, %edi
movq %r15, %rsi
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x1fc00
movq %rax, %r13
incq %rax
cmpq $0x2, %rax
jb 0x85f39
movq %rbx, (%rsp)
leaq -0x1(%r14), %rbp
testq %r13, %rbp
je 0x85f2f
movq %r13, %rdi
movq %r15, %rsi
callq 0x85f4b
leaq (%r15,%r14), %r12
addq $-0x1000, %r12          # imm = 0xF000
cmpq %r15, %r12
jae 0x85ecb
xorl %r12d, %r12d
jmp 0x85f39
negq %r14
xorl %edi, %edi
movq %r12, %rsi
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x1fc00
leaq 0x1(%rax), %rcx
cmpq $0x2, %rcx
jb 0x85ec6
leaq (%rax,%rbp), %r13
andq %r14, %r13
movq %r13, %rbx
subq %rax, %rbx
movq %r13, %rsi
subq %rax, %rsi
je 0x85f12
movq %rax, %rdi
callq 0x85f4b
leaq (%rbx,%r15), %rax
cmpq %rax, %r12
je 0x85f2a
movq %r12, %rsi
subq %rax, %rsi
leaq (%r15,%r13), %rdi
callq 0x85f4b
testq %r13, %r13
je 0x85ece
movq (%rsp), %rax
movb $0x1, (%rax)
movq %r13, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ctl.c
// Function: ctl_byname
int
ctl_byname(const char *name, void *oldp, size_t *oldlenp, void *newp,
    size_t newlen)
{
	int ret;
	size_t depth;
	ctl_node_t const *nodes[CTL_MAX_DEPTH];
	size_t mib[CTL_MAX_DEPTH];
	const ctl_named_node_t *node;

	if (ctl_initialized == false && ctl_init()) {
		ret = EAGAIN;
		goto label_return;
	}

	depth = CTL_MAX_DEPTH;
	ret = ctl_lookup(name, nodes, mib, &depth);
	if (ret != 0)
		goto label_return;

	node = ctl_named_node(nodes[depth-1]);
	if (node != NULL && node->ctl)
		ret = node->ctl(mib, depth, oldp, oldlenp, newp, newlen);
	else {
		/* The name refers to a partial path through the ctl tree. */
		ret = ENOENT;
	}

label_return:
	return(ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
cmpb $0x0, 0x599bc(%rip)     # 0xdf978
jne 0x85fcc
movl $0xb, %ebp
callq 0x86033
testb %al, %al
jne 0x86022
leaq 0x8(%rsp), %rcx
movq $0x6, (%rcx)
leaq 0x40(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r13, %rdi
callq 0x860fa
movl %eax, %ebp
testl %eax, %eax
jne 0x86022
movq 0x8(%rsp), %rsi
movq 0x38(%rsp,%rsi,8), %rax
movl $0x2, %ebp
cmpb $0x1, (%rax)
jne 0x86022
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x86022
leaq 0x10(%rsp), %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
callq *%rax
movl %eax, %ebp
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ctl.c
// Function: thread_tcache_flush_ctl
static int
thread_tcache_flush_ctl(const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;

	if (config_tcache == false)
		return (ENOENT);

	READONLY();
	WRITEONLY();

	tcache_flush();

	ret = 0;
label_return:
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0x1, %ebx
orq %r9, %r8
jne 0x86f42
orq %rcx, %rdx
jne 0x86f42
movq 0x3f068(%rip), %r15     # 0xc5f58
movq %fs:(%r15), %rdi
xorl %ebx, %ebx
cmpq $0x4, %rdi
jb 0x86f42
movq %fs:0x0, %r14
addq %r15, %r14
callq 0x91234
movq $0x0, %fs:(%r15)
leaq 0x69c94(%rip), %rax     # 0xf0bb0
movl (%rax), %edi
movq %r14, %rsi
callq 0x1f1c0
testl %eax, %eax
je 0x86f42
leaq 0x1c23d(%rip), %rdi     # 0xa316e
callq 0x915d4
leaq 0x57c1d(%rip), %rax     # 0xdeb5a
cmpb $0x1, (%rax)
je 0x86f4a
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1f1b0
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ctl.c
// Function: arena_i_dss_ctl
static int
arena_i_dss_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
    void *newp, size_t newlen)
{
	int ret, i;
	bool match, err;
	const char *dss;
	unsigned arena_ind = mib[1];
	dss_prec_t dss_prec_old = dss_prec_limit;
	dss_prec_t dss_prec = dss_prec_limit;

	malloc_mutex_lock(&ctl_mtx);
	WRITE(dss, const char *);
	match = false;
	for (i = 0; i < dss_prec_limit; i++) {
		if (strcmp(dss_prec_names[i], dss) == 0) {
			dss_prec = i;
			match = true;
			break;
		}
	}
	if (match == false) {
		ret = EINVAL;
		goto label_return;
	}

	if (arena_ind < ctl_stats.narenas) {
		arena_t *arena = arenas[arena_ind];
		if (arena != NULL) {
			dss_prec_old = arena_dss_prec_get(arena);
			arena_dss_prec_set(arena, dss_prec);
			err = false;
		} else
			err = true;
	} else {
		dss_prec_old = chunk_dss_prec_get();
		err = chunk_dss_prec_set(dss_prec);
	}
	dss = dss_prec_names[dss_prec_old];
	READ(dss, const char *);
	if (err) {
		ret = EFAULT;
		goto label_return;
	}

	ret = 0;
label_return:
	malloc_mutex_unlock(&ctl_mtx);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %rbx
movq 0x8(%rdi), %r13
leaq 0x57f32(%rip), %rdi     # 0xdf980
callq 0x1faa0
testq %r15, %r15
je 0x87a71
movl $0x16, %ebp
cmpq $0x8, %r12
jne 0x87b47
movq %rbx, 0x8(%rsp)
movq (%r15), %r12
jmp 0x87a76
movq %rbx, 0x8(%rsp)
movl %r13d, %ebp
xorl %r15d, %r15d
leaq 0x424cd(%rip), %rbx     # 0xc9f50
movq (%rbx,%r15,8), %rdi
movq %r12, %rsi
callq 0x1f880
testl %eax, %eax
je 0x87aa1
incq %r15
cmpq $0x3, %r15
jne 0x87a83
jmp 0x87b42
cmpl %r13d, 0x57f48(%rip)    # 0xdf9f0
jbe 0x87ad7
leaq 0x570c7(%rip), %rax     # 0xdeb78
movq (%rax), %rax
movq (%rax,%rbp,8), %r13
testq %r13, %r13
je 0x87af5
movq %r13, %rdi
callq 0x82aca
movl %eax, %r12d
movq %r13, %rdi
movl %r15d, %esi
callq 0x82af5
xorl %ebp, %ebp
jmp 0x87b00
callq 0x85c68
movl %eax, %r12d
movl %r15d, %edi
callq 0x85c6b
xorl %ecx, %ecx
testb %al, %al
movl $0xe, %ebp
cmovel %ecx, %ebp
jmp 0x87b00
movl $0x3, %r12d
movl $0xe, %ebp
movl %r12d, %eax
movq (%rbx,%rax,8), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
sete %cl
testq %r14, %r14
sete %dl
orb %cl, %dl
jne 0x87b47
movq (%r14), %rcx
cmpq $0x8, %rcx
jne 0x87b2f
movq %rax, (%rdi)
jmp 0x87b47
movl $0x8, %edx
cmovbq %rcx, %rdx
leaq 0x10(%rsp), %rsi
callq 0x1fbd0
movl $0x16, %ebp
leaq 0x57e32(%rip), %rdi     # 0xdf980
callq 0x1fbb0
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ctl.c
// Function: arenas_purge_ctl
static int
arenas_purge_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
    void *newp, size_t newlen)
{
	int ret;
	unsigned arena_ind;

	malloc_mutex_lock(&ctl_mtx);
	WRITEONLY();
	arena_ind = UINT_MAX;
	WRITE(arena_ind, unsigned);
	if (newp != NULL && arena_ind >= ctl_stats.narenas)
		ret = EFAULT;
	else {
		if (arena_ind == UINT_MAX)
			arena_ind = ctl_stats.narenas;
		arena_purge(arena_ind);
		ret = 0;
	}

label_return:
	malloc_mutex_unlock(&ctl_mtx);
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %r15
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
leaq 0x57a40(%rip), %rdi     # 0xdf980
callq 0x1faa0
movl $0x1, %ebx
orq %r12, %r13
jne 0x87f7e
testq %r14, %r14
je 0x87f71
movl $0x16, %ebx
cmpq $0x4, %r15
jne 0x87f7e
movl (%r14), %edi
movl $0xe, %ebx
cmpl 0x57a83(%rip), %edi     # 0xdf9f0
jb 0x87f77
jmp 0x87f7e
movl 0x57a79(%rip), %edi     # 0xdf9f0
callq 0x87b64
xorl %ebx, %ebx
leaq 0x579fb(%rip), %rdi     # 0xdf980
callq 0x1fbb0
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/huge.c
// Function: huge_palloc
void *
huge_palloc(size_t size, size_t alignment, bool zero)
{
	void *ret;
	size_t csize;
	extent_node_t *node;
	bool is_zeroed;

	/* Allocate one or more contiguous chunks for this request. */

	csize = CHUNK_CEILING(size);
	if (csize == 0) {
		/* size is large enough to cause size_t wrap-around. */
		return (NULL);
	}

	/* Allocate an extent node with which to track the chunk. */
	node = base_node_alloc();
	if (node == NULL)
		return (NULL);

	/*
	 * Copy zero into is_zeroed and pass the copy to chunk_alloc(), so that
	 * it is possible to make correct junk/zero fill decisions below.
	 */
	is_zeroed = zero;
	ret = chunk_alloc(csize, alignment, false, &is_zeroed,
	    chunk_dss_prec_get());
	if (ret == NULL) {
		base_node_dealloc(node);
		return (NULL);
	}

	/* Insert node into huge. */
	node->addr = ret;
	node->size = csize;

	malloc_mutex_lock(&huge_mtx);
	extent_tree_ad_insert(&huge, node);
	if (config_stats) {
		stats_cactive_add(csize);
		huge_nmalloc++;
		huge_allocated += csize;
	}
	malloc_mutex_unlock(&huge_mtx);

	if (config_fill && zero == false) {
		if (opt_junk)
			memset(ret, 0xa5, csize);
		else if (opt_zero && is_zeroed == false)
			memset(ret, 0, csize);
	}

	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x53f40(%rip), %rax     # 0xdf880
movq (%rax), %rbx
addq %rbx, %rdi
notq %rbx
andq %rdi, %rbx
je 0x8b9fb
movl %edx, %ebp
movq %rsi, %r14
callq 0x85574
testq %rax, %rax
je 0x8b9fb
movq %rax, %r15
leaq 0xf(%rsp), %r12
movb %bpl, (%r12)
callq 0x85c68
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r12, %rcx
movl %eax, %r8d
callq 0x85730
testq %rax, %rax
je 0x8b9f3
movq %rax, %r14
movq %rax, 0x28(%r15)
movq %rbx, 0x30(%r15)
leaq 0x54068(%rip), %r12     # 0xdfa08
movq %r12, %rdi
callq 0x1faa0
leaq 0x54081(%rip), %rdi     # 0xdfa30
movq %r15, %rsi
callq 0x8b0af
leaq 0x651c2(%rip), %rax     # 0xf0b80
lock
addq %rbx, (%rax)
incq 0x540af(%rip)           # 0xdfa78
addq %rbx, 0x540b0(%rip)     # 0xdfa80
movq %r12, %rdi
callq 0x1fbb0
testb %bpl, %bpl
jne 0x8b9fe
leaq 0x53177(%rip), %rax     # 0xdeb5b
cmpb $0x1, (%rax)
jne 0x8ba0e
movq %r14, %rdi
movl $0xa5, %esi
jmp 0x8ba26
movq %r15, %rdi
callq 0x855bf
xorl %r14d, %r14d
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x53157(%rip), %rax     # 0xdeb6c
cmpb $0x1, (%rax)
jne 0x8b9fe
cmpb $0x0, 0xf(%rsp)
jne 0x8b9fe
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x1f110
jmp 0x8b9fe
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/huge.c
// Function: huge_ralloc_no_move
void *
huge_ralloc_no_move(void *ptr, size_t oldsize, size_t size, size_t extra)
{

	/*
	 * Avoid moving the allocation if the size class can be left the same.
	 */
	if (oldsize > arena_maxclass
	    && CHUNK_CEILING(oldsize) >= CHUNK_CEILING(size)
	    && CHUNK_CEILING(oldsize) <= CHUNK_CEILING(size+extra)) {
		assert(CHUNK_CEILING(oldsize) == oldsize);
		if (config_fill && opt_junk && size < oldsize) {
			memset((void *)((uintptr_t)ptr + size), 0x5a,
			    oldsize - size);
		}
		return (ptr);
	}

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

// Assembly:
pushq %rbx
movq %rsi, %rax
leaq 0x53ef5(%rip), %rsi     # 0xdf930
cmpq %rax, (%rsi)
jae 0x8ba74
movq %rdi, %rbx
leaq 0x53e36(%rip), %rsi     # 0xdf880
movq (%rsi), %rdi
leaq (%rdi,%rax), %rsi
movq %rdi, %r8
notq %r8
andq %r8, %rsi
leaq (%rdi,%rdx), %r9
andq %r8, %r9
cmpq %r9, %rsi
jb 0x8ba74
addq %rdx, %rcx
addq %rdi, %rcx
andq %r8, %rcx
cmpq %rcx, %rsi
jbe 0x8ba7b
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
subq %rdx, %rax
jbe 0x8ba76
leaq 0x530d4(%rip), %rcx     # 0xdeb5b
cmpb $0x0, (%rcx)
je 0x8ba76
addq %rbx, %rdx
movq %rdx, %rdi
movl $0x5a, %esi
movq %rax, %rdx
callq 0x1f110
jmp 0x8ba76
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/huge.c
// Function: huge_dalloc
void
huge_dalloc(void *ptr, bool unmap)
{
	extent_node_t *node, key;

	malloc_mutex_lock(&huge_mtx);

	/* Extract from tree of huge allocations. */
	key.addr = ptr;
	node = extent_tree_ad_search(&huge, &key);
	assert(node != NULL);
	assert(node->addr == ptr);
	extent_tree_ad_remove(&huge, node);

	if (config_stats) {
		stats_cactive_sub(node->size);
		huge_ndalloc++;
		huge_allocated -= node->size;
	}

	malloc_mutex_unlock(&huge_mtx);

	if (unmap && config_fill && config_dss && opt_junk)
		memset(node->addr, 0x5a, node->size);

	chunk_dealloc(node->addr, node->size, unmap);

	base_node_dealloc(node);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x53bf4(%rip), %r15     # 0xdfa08
movq %r15, %rdi
callq 0x1faa0
leaq 0x8(%rsp), %rsi
movq %r14, 0x28(%rsi)
leaq 0x53c04(%rip), %r14     # 0xdfa30
movq %r14, %rdi
callq 0x8afdb
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x8b21b
xorl %eax, %eax
subq 0x30(%r12), %rax
leaq 0x64d30(%rip), %rcx     # 0xf0b80
lock
addq %rax, (%rcx)
incq 0x53c2d(%rip)           # 0xdfa88
movq 0x30(%r12), %rax
subq %rax, 0x53c19(%rip)     # 0xdfa80
movq %r15, %rdi
callq 0x1fbb0
movq 0x28(%r12), %rdi
movq 0x30(%r12), %rsi
movl %ebx, %edx
callq 0x85b4a
movq %r12, %rdi
callq 0x855bf
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/huge.c
// Function: huge_salloc
size_t
huge_salloc(const void *ptr)
{
	size_t ret;
	extent_node_t *node, key;

	malloc_mutex_lock(&huge_mtx);

	/* Extract from tree of huge allocations. */
	key.addr = __DECONST(void *, ptr);
	node = extent_tree_ad_search(&huge, &key);
	assert(node != NULL);

	ret = node->size;

	malloc_mutex_unlock(&huge_mtx);

	return (ret);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x53b63(%rip), %r14     # 0xdfa08
movq %r14, %rdi
callq 0x1faa0
leaq 0x8(%rsp), %rsi
movq %rbx, 0x28(%rsi)
leaq 0x53b73(%rip), %rdi     # 0xdfa30
callq 0x8afdb
movq 0x30(%rax), %rbx
movq %r14, %rdi
callq 0x1fbb0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/huge.c
// Function: huge_prof_ctx_get
prof_ctx_t *
huge_prof_ctx_get(const void *ptr)
{
	prof_ctx_t *ret;
	extent_node_t *node, key;

	malloc_mutex_lock(&huge_mtx);

	/* Extract from tree of huge allocations. */
	key.addr = __DECONST(void *, ptr);
	node = extent_tree_ad_search(&huge, &key);
	assert(node != NULL);

	ret = node->prof_ctx;

	malloc_mutex_unlock(&huge_mtx);

	return (ret);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x53b1e(%rip), %r14     # 0xdfa08
movq %r14, %rdi
callq 0x1faa0
leaq 0x8(%rsp), %rsi
movq %rbx, 0x28(%rsi)
leaq 0x53b2e(%rip), %rdi     # 0xdfa30
callq 0x8afdb
movq 0x20(%rax), %rbx
movq %r14, %rdi
callq 0x1fbb0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/huge.c
// Function: huge_prof_ctx_set
void
huge_prof_ctx_set(const void *ptr, prof_ctx_t *ctx)
{
	extent_node_t *node, key;

	malloc_mutex_lock(&huge_mtx);

	/* Extract from tree of huge allocations. */
	key.addr = __DECONST(void *, ptr);
	node = extent_tree_ad_search(&huge, &key);
	assert(node != NULL);

	node->prof_ctx = ctx;

	malloc_mutex_unlock(&huge_mtx);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x53ad4(%rip), %r15     # 0xdfa08
movq %r15, %rdi
callq 0x1faa0
movq %rsp, %rsi
movq %r14, 0x28(%rsi)
leaq 0x53ae6(%rip), %rdi     # 0xdfa30
callq 0x8afdb
movq %rbx, 0x20(%rax)
movq %r15, %rdi
callq 0x1fbb0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/prof.c
// Function: prof_leave
static inline void
prof_leave(prof_tdata_t *prof_tdata)
{
	bool idump, gdump;

	cassert(config_prof);

	malloc_mutex_unlock(&bt2ctx_mtx);

	assert(prof_tdata->enq);
	prof_tdata->enq = false;
	idump = prof_tdata->enq_idump;
	prof_tdata->enq_idump = false;
	gdump = prof_tdata->enq_gdump;
	prof_tdata->enq_gdump = false;

	if (idump)
		prof_idump();
	if (gdump)
		prof_gdump();
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x54449(%rip), %rdi     # 0xe0b28
callq 0x1fbb0
movb $0x0, 0x58(%rbx)
movb 0x59(%rbx), %al
movb 0x5a(%rbx), %bpl
movw $0x0, 0x59(%rbx)
cmpb $0x1, %al
jne 0x8c6fe
callq 0x8cb7b
addq $0x8, %rsp
testb %bpl, %bpl
je 0x8c70e
popq %rbx
popq %rbp
jmp 0x8d182
popq %rbx
popq %rbp
retq