LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: choose_arena_hard
arena_t *
choose_arena_hard(void)
{
	arena_t *ret;

	if (narenas_auto > 1) {
		unsigned i, choose, first_null;

		choose = 0;
		first_null = narenas_auto;
		malloc_mutex_lock(&arenas_lock);
		assert(arenas[0] != NULL);
		for (i = 1; i < narenas_auto; i++) {
			if (arenas[i] != NULL) {
				/*
				 * Choose the first arena that has the lowest
				 * number of threads assigned to it.
				 */
				if (arenas[i]->nthreads <
				    arenas[choose]->nthreads)
					choose = i;
			} else if (first_null == narenas_auto) {
				/*
				 * Record the index of the first uninitialized
				 * arena, in case all extant arenas are in use.
				 *
				 * NB: It is possible for there to be
				 * discontinuities in terms of initialized
				 * versus uninitialized arenas, due to the
				 * "thread.arena" mallctl.
				 */
				first_null = i;
			}
		}

		if (arenas[choose]->nthreads == 0
		    || first_null == narenas_auto) {
			/*
			 * Use an unloaded arena, or the least loaded arena if
			 * all arenas are already initialized.
			 */
			ret = arenas[choose];
		} else {
			/* Initialize a new arena. */
			ret = arenas_extend(first_null);
		}
		ret->nthreads++;
		malloc_mutex_unlock(&arenas_lock);
	} else {
		ret = arenas[0];
		malloc_mutex_lock(&arenas_lock);
		ret->nthreads++;
		malloc_mutex_unlock(&arenas_lock);
	}

	arenas_tsd_set(&ret);

	return (ret);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x66908(%rip), %ebx     # 0xdbb80
cmpl $0x2, %ebx
jb 0x752ea
leaq 0x66904(%rip), %rdi     # 0xdbb88
callq 0x1faa0
movl 0x668f1(%rip), %eax     # 0xdbb80
movq 0x668e2(%rip), %rcx     # 0xdbb78
xorl %esi, %esi
pushq $0x1
popq %rdx
movl %esi, %edi
cmpq %rax, %rdx
jae 0x752cb
movq (%rcx,%rdx,8), %r8
testq %r8, %r8
je 0x752c1
movl 0x4(%r8), %r8d
movq (%rcx,%rdi,8), %r9
movl %edx, %edi
cmpl 0x4(%r9), %r8d
jb 0x752bd
movl %esi, %edi
movl %edi, %esi
jmp 0x752c6
cmpl %eax, %ebx
cmovel %edx, %ebx
incq %rdx
jmp 0x7529b
movq (%rcx,%rdi,8), %r14
movl 0x4(%r14), %ecx
testl %ecx, %ecx
je 0x75304
cmpl %eax, %ebx
je 0x75304
movl %ebx, %edi
callq 0x7520c
movq %rax, %r14
movl 0x4(%rax), %ecx
jmp 0x75304
movq 0x66887(%rip), %rax     # 0xdbb78
movq (%rax), %r14
leaq 0x6688d(%rip), %rdi     # 0xdbb88
callq 0x1faa0
movl 0x4(%r14), %ecx
incl %ecx
movl %ecx, 0x4(%r14)
leaq 0x66877(%rip), %rdi     # 0xdbb88
callq 0x1fbb0
movq %fs:0x0, %rax
leaq -0x30(%rax), %rsi
movq %r14, %fs:-0x30
movl 0x6687f(%rip), %edi     # 0xdbbb4
callq 0x1f1c0
testl %eax, %eax
je 0x75353
leaq 0x23c1d(%rip), %rdi     # 0x98f62
callq 0x879d0
cmpb $0x1, 0x66809(%rip)     # 0xdbb5a
je 0x7535e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1f1b0
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: arenas_cleanup
void
arenas_cleanup(void *arg)
{
	arena_t *arena = *(arena_t **)arg;

	malloc_mutex_lock(&arenas_lock);
	arena->nthreads--;
	malloc_mutex_unlock(&arenas_lock);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
leaq 0x66817(%rip), %rbx     # 0xdbb88
movq %rbx, %rdi
callq 0x1faa0
decl 0x4(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1fbb0
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: s2u
size_t
s2u(size_t size)
{

	if (size <= SMALL_MAXCLASS)
		return (arena_bin_info[SMALL_SIZE2BIN(size)].reg_size);
	if (size <= arena_maxclass)
		return (PAGE_CEILING(size));
	return (CHUNK_CEILING(size));
}

// Assembly:
movq %rdi, %rax
cmpq $0xe00, %rdi            # imm = 0xE00
ja 0x760ee
decq %rax
shrq $0x3, %rax
leaq 0x23066(%rip), %rcx     # 0x99140
movzbl (%rcx,%rax), %eax
imulq $0x68, %rax, %rax
leaq 0x65b17(%rip), %rcx     # 0xdbc00
movq (%rcx,%rax), %rax
retq
leaq 0x6683b(%rip), %rcx     # 0xdc930
cmpq %rax, (%rcx)
jae 0x7610e
leaq 0x6677f(%rip), %rcx     # 0xdc880
movq (%rcx), %rcx
addq %rcx, %rax
notq %rcx
andq %rcx, %rax
retq
addq $0xfff, %rax            # imm = 0xFFF
andq $-0x1000, %rax          # imm = 0xF000
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: je_posix_memalign
int
je_posix_memalign(void **memptr, size_t alignment, size_t size)
{
	int ret = imemalign(memptr, alignment, size, sizeof(void *));
	JEMALLOC_VALGRIND_MALLOC(ret == 0, *memptr, isalloc(*memptr,
	    config_prof), false);
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
pushq $0x8
popq %rcx
callq 0x761b9
movl %eax, %ebx
testl %eax, %eax
sete %al
andb 0x65a15(%rip), %al      # 0xdbb6a
cmpb $0x1, %al
jne 0x761ad
leaq 0x10(%rsp), %r15
movq $0x1301, (%r15)         # imm = 0x1301
movq (%r14), %rdi
movq %rdi, 0x8(%r15)
callq 0x76240
movq %rax, 0x10(%r15)
movq (%r14), %rdi
callq 0x76125
movq %rax, 0x18(%r15)
xorl %eax, %eax
movq %rax, 0x20(%r15)
movq %rax, 0x28(%r15)
movq %r15, %rax
xorl %edx, %edx
rolq $0x3, %rdi
rolq $0xd, %rdi
rolq $0x3d, %rdi
rolq $0x33, %rdi
xchgq %rbx, %rbx
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: isalloc
JEMALLOC_INLINE size_t
isalloc(const void *ptr, bool demote)
{
	size_t ret;
	arena_chunk_t *chunk;

	assert(ptr != NULL);
	/* Demotion only makes sense if config_prof is true. */
	assert(config_prof || demote == false);

	chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(ptr);
	if (chunk != ptr)
		ret = arena_salloc(ptr, demote);
	else
		ret = huge_salloc(ptr);

	return (ret);
}

// Assembly:
leaq 0x66639(%rip), %rax     # 0xdc880
movq (%rax), %rax
notq %rax
andq %rdi, %rax
cmpq %rdi, %rax
je 0x829cd
subq %rax, %rdi
shrq $0xc, %rdi
leaq 0x666c1(%rip), %rcx     # 0xdc928
subq (%rcx), %rdi
imulq $0x18, %rdi, %rcx
movq 0x40(%rax,%rcx), %rax
movl %eax, %ecx
shrl $0x4, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
jne 0x7628a
andq $-0x1000, %rax          # imm = 0xF000
retq
imulq $0x68, %rcx, %rax
leaq 0x6596b(%rip), %rcx     # 0xdbc00
movq (%rcx,%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: je_aligned_alloc
void *
je_aligned_alloc(size_t alignment, size_t size)
{
	void *ret;
	int err;

	if ((err = imemalign(&ret, alignment, size, 1)) != 0) {
		ret = NULL;
		set_errno(err);
	}
	JEMALLOC_VALGRIND_MALLOC(err == 0, ret, isalloc(ret, config_prof),
	    false);
	return (ret);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rdx
movq %rdi, %rsi
movq %rsp, %rdi
pushq $0x1
popq %rcx
callq 0x761b9
testl %eax, %eax
je 0x762c3
movl %eax, %ebx
callq 0x1f810
movl %ebx, (%rax)
xorl %ebx, %ebx
jmp 0x7632a
cmpb $0x0, 0x658a0(%rip)     # 0xdbb6a
je 0x76326
leaq 0x10(%rsp), %r14
movq $0x1301, (%r14)         # imm = 0x1301
movq (%rsp), %rbx
movq %rbx, 0x8(%r14)
movq %rbx, %rdi
callq 0x76240
movq %rax, 0x10(%r14)
movq %rbx, %rdi
callq 0x76125
movq %rax, 0x18(%r14)
xorl %eax, %eax
movq %rax, 0x20(%r14)
movq %rax, 0x28(%r14)
movq %r14, %rax
xorl %edx, %edx
rolq $0x3, %rdi
rolq $0xd, %rdi
rolq $0x3d, %rdi
rolq $0x33, %rdi
xchgq %rbx, %rbx
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rax
jmp 0x7632a
movq (%rsp), %rbx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: u2rz
JEMALLOC_INLINE size_t
u2rz(size_t usize)
{
	size_t ret;

	if (usize <= SMALL_MAXCLASS) {
		size_t binind = SMALL_SIZE2BIN(usize);
		ret = arena_bin_info[binind].redzone_size;
	} else
		ret = 0;

	return (ret);
}

// Assembly:
cmpq $0xe00, %rdi            # imm = 0xE00
ja 0x766d6
decq %rdi
shrq $0x3, %rdi
leaq 0x22a7f(%rip), %rax     # 0x99140
movzbl (%rax,%rdi), %eax
imulq $0x68, %rax, %rax
leaq 0x65530(%rip), %rcx     # 0xdbc00
movq 0x8(%rcx,%rax), %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: je_free
void
je_free(void *ptr)
{

	UTRACE(ptr, 0, 0);
	if (ptr != NULL) {
		size_t usize;
		size_t rzsize JEMALLOC_CC_SILENCE_INIT(0);

		assert(malloc_initialized || IS_INITIALIZER);

		if (config_prof && opt_prof) {
			usize = isalloc(ptr, config_prof);
			prof_free(ptr, usize);
		} else if (config_stats || config_valgrind)
			usize = isalloc(ptr, config_prof);
		if (config_stats)
			thread_allocated_tsd_get()->deallocated += usize;
		if (config_valgrind && opt_valgrind)
			rzsize = p2rz(ptr);
		iqalloc(ptr);
		JEMALLOC_VALGRIND_FREE(ptr, rzsize);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x76774
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x76240
addq %rax, %fs:-0x20
cmpb $0x1, 0x65461(%rip)     # 0xdbb6a
jne 0x76718
movq %rbx, %rdi
callq 0x76125
movq %rax, %r14
jmp 0x7671b
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x766d9
cmpb $0x1, 0x65440(%rip)     # 0xdbb6a
jne 0x7676d
leaq 0x10(%rsp), %rax
movq $0x1302, (%rax)         # imm = 0x1302
movq %rbx, 0x8(%rax)
movq %r14, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rcx, 0x28(%rax)
xorl %edx, %edx
rolq $0x3, %rdi
rolq $0xd, %rdi
rolq $0x3d, %rdi
rolq $0x33, %rdi
xchgq %rbx, %rbx
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: je_memalign
void *
je_memalign(size_t alignment, size_t size)
{
	void *ret JEMALLOC_CC_SILENCE_INIT(NULL);
	imemalign(&ret, alignment, size, 1);
	JEMALLOC_VALGRIND_MALLOC(ret != NULL, ret, size, false);
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x761b9
movq (%rbx), %rbx
testq %rbx, %rbx
setne %al
andb 0x653c0(%rip), %al      # 0xdbb6a
cmpb $0x1, %al
jne 0x767f8
leaq 0x10(%rsp), %r15
movq $0x1301, (%r15)         # imm = 0x1301
movq %rbx, 0x8(%r15)
movq %r14, 0x10(%r15)
movq %rbx, %rdi
callq 0x76125
movq %rax, 0x18(%r15)
xorl %eax, %eax
movq %rax, 0x20(%r15)
movq %rax, 0x28(%r15)
movq %r15, %rax
xorl %edx, %edx
rolq $0x3, %rdi
rolq $0xd, %rdi
rolq $0x3d, %rdi
rolq $0x33, %rdi
xchgq %rbx, %rbx
movq %rdx, (%rsp)
movq (%rsp), %rax
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: je_valloc
void *
je_valloc(size_t size)
{
	void *ret JEMALLOC_CC_SILENCE_INIT(NULL);
	imemalign(&ret, PAGE, size, 1);
	JEMALLOC_VALGRIND_MALLOC(ret != NULL, ret, size, false);
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
pushq $0x1
popq %rcx
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
movq %r14, %rdx
callq 0x761b9
movq (%rbx), %rbx
testq %rbx, %rbx
setne %al
andb 0x6532e(%rip), %al      # 0xdbb6a
cmpb $0x1, %al
jne 0x7688a
leaq 0x10(%rsp), %r15
movq $0x1301, (%r15)         # imm = 0x1301
movq %rbx, 0x8(%r15)
movq %r14, 0x10(%r15)
movq %rbx, %rdi
callq 0x76125
movq %rax, 0x18(%r15)
xorl %eax, %eax
movq %rax, 0x20(%r15)
movq %rax, 0x28(%r15)
movq %r15, %rax
xorl %edx, %edx
rolq $0x3, %rdi
rolq $0xd, %rdi
rolq $0x3d, %rdi
rolq $0x33, %rdi
xchgq %rbx, %rbx
movq %rdx, (%rsp)
movq (%rsp), %rax
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: je_dallocm
int
je_dallocm(void *ptr, int flags)
{
	size_t usize;
	size_t rzsize JEMALLOC_CC_SILENCE_INIT(0);
	unsigned arena_ind = ((unsigned)(flags >> 8)) - 1;
	bool try_tcache;

	assert(ptr != NULL);
	assert(malloc_initialized || IS_INITIALIZER);

	if (arena_ind != UINT_MAX) {
		arena_chunk_t *chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(ptr);
		try_tcache = (chunk == ptr || chunk->arena !=
		    arenas[arena_ind]);
	} else
		try_tcache = true;

	UTRACE(ptr, 0, 0);
	if (config_stats || config_valgrind)
		usize = isalloc(ptr, config_prof);
	if (config_prof && opt_prof) {
		if (config_stats == false && config_valgrind == false)
			usize = isalloc(ptr, config_prof);
		prof_free(ptr, usize);
	}
	if (config_stats)
		thread_allocated_tsd_get()->deallocated += usize;
	if (config_valgrind && opt_valgrind)
		rzsize = p2rz(ptr);
	iqallocx(ptr, try_tcache);
	JEMALLOC_VALGRIND_FREE(ptr, rzsize);

	return (ALLOCM_SUCCESS);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movb $0x1, %bpl
cmpl $0x100, %esi            # imm = 0x100
jb 0x770d3
leaq 0x657d4(%rip), %rax     # 0xdc880
movq (%rax), %rax
notq %rax
andq %rbx, %rax
cmpq %rbx, %rax
je 0x770d3
sarl $0x8, %esi
decl %esi
movq (%rax), %rax
movq 0x64aaf(%rip), %rcx     # 0xdbb78
movl %esi, %edx
cmpq (%rcx,%rdx,8), %rax
setne %bpl
movq %rbx, %rdi
callq 0x76240
addq %rax, %fs:-0x20
cmpb $0x1, 0x64a7f(%rip)     # 0xdbb6a
jne 0x770fa
movq %rbx, %rdi
callq 0x76125
movq %rax, %r14
jmp 0x770fd
xorl %r14d, %r14d
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x7715e
cmpb $0x1, 0x64a5a(%rip)     # 0xdbb6a
jne 0x77153
leaq 0x10(%rsp), %rax
movq $0x1302, (%rax)         # imm = 0x1302
movq %rbx, 0x8(%rax)
movq %r14, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rcx, 0x28(%rax)
xorl %edx, %edx
rolq $0x3, %rdi
rolq $0xd, %rdi
rolq $0x3d, %rdi
rolq $0x33, %rdi
xchgq %rbx, %rbx
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rax
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: iqallocx
JEMALLOC_INLINE void
iqallocx(void *ptr, bool try_tcache)
{

	if (config_fill && opt_quarantine)
		quarantine(ptr);
	else
		idallocx(ptr, try_tcache);
}

// Assembly:
movq %rdi, %rdx
cmpq $0x0, 0x649f7(%rip)     # 0xdbb60
je 0x77173
movq %rdx, %rdi
jmp 0x842d8
leaq 0x65706(%rip), %rax     # 0xdc880
movq (%rax), %rax
notq %rax
andq %rdx, %rax
cmpq %rdx, %rax
je 0x77197
movq (%rax), %rdi
movzbl %sil, %ecx
movq %rax, %rsi
jmp 0x7739c
pushq $0x1
popq %rsi
movq %rdx, %rdi
jmp 0x82936
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: je_nallocm
int
je_nallocm(size_t *rsize, size_t size, int flags)
{
	size_t usize;
	size_t alignment = (ZU(1) << (flags & ALLOCM_LG_ALIGN_MASK)
	    & (SIZE_T_MAX-1));

	assert(size != 0);

	if (malloc_init())
		return (ALLOCM_ERR_OOM);

	usize = (alignment == 0) ? s2u(size) : sa2u(size, alignment);
	if (usize == 0)
		return (ALLOCM_ERR_OOM);

	if (rsize != NULL)
		*rsize = usize;
	return (ALLOCM_SUCCESS);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ecx
movq %rsi, %r15
movq %rdi, %r14
pushq $0x1
popq %r12
shlq %cl, %r12
pushq $0x1
popq %rbx
callq 0x75442
testb %al, %al
jne 0x771ec
movq %r15, %rdi
andq $-0x2, %r12
je 0x771d8
movq %r12, %rsi
callq 0x76af9
jmp 0x771dd
callq 0x760c0
testq %rax, %rax
je 0x771ec
xorl %ebx, %ebx
testq %r14, %r14
je 0x771ec
movq %rax, (%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: a0alloc
static void *
a0alloc(size_t size, bool zero)
{

	if (malloc_init())
		return (NULL);

	if (size == 0)
		size = 1;

	if (size <= arena_maxclass)
		return (arena_malloc(arenas[0], size, zero, false));
	else
		return (huge_malloc(size, zero));
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x75442
testb %al, %al
je 0x7731f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpq $0x1, %rbx
adcq $0x0, %rbx
leaq 0x65602(%rip), %rax     # 0xdc930
cmpq (%rax), %rbx
jbe 0x77345
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x82520
movq 0x6482c(%rip), %rax     # 0xdbb78
movq (%rax), %rdi
movzbl %bpl, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7762a
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/jemalloc.c
// Function: a0free
void
a0free(void *ptr)
{
	arena_chunk_t *chunk;

	if (ptr == NULL)
		return;

	chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(ptr);
	if (chunk != ptr)
		arena_dalloc(chunk->arena, chunk, ptr, false);
	else
		huge_dalloc(ptr, true);
}

// Assembly:
testq %rdi, %rdi
je 0x77390
movq %rdi, %rdx
leaq 0x65505(%rip), %rax     # 0xdc880
movq (%rax), %rsi
notq %rsi
andq %rdi, %rsi
cmpq %rdi, %rsi
je 0x77391
movq (%rsi), %rdi
xorl %ecx, %ecx
jmp 0x7739c
retq
pushq $0x1
popq %rsi
movq %rdx, %rdi
jmp 0x82936
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/include/jemalloc/internal/tcache.h
// Function: tcache_alloc_easy
JEMALLOC_INLINE void *
tcache_alloc_easy(tcache_bin_t *tbin)
{
	void *ret;

	if (tbin->ncached == 0) {
		tbin->low_water = -1;
		return (NULL);
	}
	tbin->ncached--;
	if ((int)tbin->ncached < tbin->low_water)
		tbin->low_water = tbin->ncached;
	ret = tbin->avail[tbin->ncached];
	return (ret);
}

// Assembly:
movl 0x10(%rdi), %eax
testl %eax, %eax
je 0x779d5
decl %eax
movl %eax, 0x10(%rdi)
cmpl 0x8(%rdi), %eax
jge 0x779ca
movl %eax, 0x8(%rdi)
movq 0x18(%rdi), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %rax
retq
orl $-0x1, 0x8(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x64f2d(%rip), %rax     # 0xdc930
movq (%rax), %rax
cmpq %rdi, %rax
setb %dl
cmpq $0x1001, %rsi           # imm = 0x1001
setae %sil
orb %dl, %sil
jne 0x77a32
movzbl %bpl, %edx
movzbl %cl, %ecx
movq %r8, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x7762a
cmpq %rbx, %rax
jb 0x77a55
movq %r8, %rdi
callq 0x77952
movzbl %bpl, %ecx
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x78736
leaq 0x64e04(%rip), %rax     # 0xdc860
cmpq %r14, (%rax)
jae 0x77a74
movzbl %bpl, %edx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x82531
movzbl %bpl, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x82520
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_run_reg_alloc
static inline void *
arena_run_reg_alloc(arena_run_t *run, arena_bin_info_t *bin_info)
{
	void *ret;
	unsigned regind;
	bitmap_t *bitmap = (bitmap_t *)((uintptr_t)run +
	    (uintptr_t)bin_info->bitmap_offset);

	assert(run->nfree > 0);
	assert(bitmap_full(bitmap, &bin_info->bitmap_info) == false);

	regind = bitmap_sfu(bitmap, &bin_info->bitmap_info);
	ret = (void *)((uintptr_t)run + (uintptr_t)bin_info->reg0_offset +
	    (uintptr_t)(bin_info->reg_interval * regind));
	run->nfree--;
	if (regind == run->nextind)
		run->nextind++;
	assert(regind < run->nextind);
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x24(%rsi), %eax
movl 0x30(%rsi), %r9d
addq %rdi, %rax
leal -0x1(%r9), %ecx
movq 0x38(%rsi,%rcx,8), %rdx
movq (%rax,%rdx,8), %rdx
bsfq %rdx, %r8
movabsq $-0x1, %rdx
cmoveq %rdx, %r8
subq $0x1, %rcx
jb 0x7809b
movq 0x38(%rsi,%rcx,8), %r10
leaq (%rax,%r10,8), %r10
movq (%r10,%r8,8), %r10
shlq $0x6, %r8
bsfq %r10, %r10
cmoveq %rdx, %r10
addq %r10, %r8
jmp 0x78077
movq %r8, %rdx
shrq $0x6, %rdx
movq (%rax,%rdx,8), %r11
movabsq $0x1, %r10
movq %r10, %rbx
movl %r8d, %ecx
shlq %cl, %rbx
movq %r11, %rcx
btcq %r8, %rcx
movq %rcx, (%rax,%rdx,8)
cmpq %rbx, %r11
jne 0x7810d
movabsq $0x8, %r11
leaq -0x7(%r11), %rcx
cmpq %r9, %rcx
jae 0x7810d
movq %rdx, %rbx
shrq $0x6, %rbx
movq (%rsi,%r11,8), %r14
movq %r10, %r15
movl %edx, %ecx
shlq %cl, %r15
leaq (%rax,%r14,8), %rcx
movq (%rcx,%rbx,8), %r14
movq %r14, %r12
btcq %rdx, %r12
movq %r12, (%rcx,%rbx,8)
incq %r11
movq %rbx, %rdx
cmpq %r15, %r14
je 0x780d3
movl 0x64(%rsi), %ecx
movq 0x10(%rsi), %rax
decl 0xc(%rdi)
cmpl %r8d, 0x8(%rdi)
jne 0x78124
leal 0x1(%r8), %edx
movl %edx, 0x8(%rdi)
addq %rdi, %rcx
movl %r8d, %edx
imulq %rdx, %rax
addq %rcx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq (%rsi), %r15
movq %rsi, (%rsp)
movq 0x8(%rsi), %rbp
leaq -0x1(%rdi), %r13
pushq $0x1
popq %r12
xorl %eax, %eax
leaq 0x1d090(%rip), %r14     # 0x953f7
cmpq %rbp, %r12
ja 0x783ad
movzbl (%r13), %r9d
cmpl $0xa5, %r9d
je 0x783a5
cmpq $0x1, %r12
movq %r14, %rdx
leaq 0x14f89(%rip), %rax     # 0x8d311
cmoveq %rax, %rdx
leaq 0x20fe1(%rip), %rdi     # 0x99374
movq %r12, %rsi
movq %rbx, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x88881
movb $0x1, %al
incq %r12
decq %r13
jmp 0x78367
leaq (%r15,%rbx), %r12
xorl %r13d, %r13d
cmpq %r13, %rbp
je 0x783f7
movzbl (%r12,%r13), %r9d
cmpl $0xa5, %r9d
je 0x783f2
cmpq $0x1, %r13
movq %r14, %rdx
leaq 0x14f3c(%rip), %rax     # 0x8d311
cmoveq %rax, %rdx
leaq 0x20fdb(%rip), %rdi     # 0x993bb
movq %r13, %rsi
movq %rbx, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x88881
movb $0x1, %al
incq %r13
jmp 0x783b4
leaq 0x6375c(%rip), %rcx     # 0xdbb5a
andb (%rcx), %al
cmpb $0x1, %al
je 0x78428
subq %rbp, %rbx
movq (%rsp), %rax
movq 0x10(%rax), %rdx
pushq $0x5a
popq %rsi
movq %rbx, %rdi
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_O2/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
pushq $0x1
popq %rdx
movl $0xff, %ecx
movq %r13, %rdi
movq %rbx, %rsi
movl %ebp, %r8d
callq 0x786a2
movq %rax, %r14
testq %rax, %rax
je 0x78661
incq 0x68(%r13)
movdqu 0x50(%r13), %xmm0
movq %rbx, %xmm1
shufpd $0x2, 0x11bd3(%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 0x78669
leaq 0x63509(%rip), %rax     # 0xdbb5b
cmpb $0x1, (%rax)
jne 0x7867b
movq %r14, %rdi
movl $0xa5, %esi
jmp 0x7868c
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 0x634ea(%rip), %rax     # 0xdbb6c
cmpb $0x1, (%rax)
jne 0x78669
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_O2/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 0x7c1f2
movq %rax, %r13
testq %rax, %rax
jne 0x78700
movq %r15, %rdi
callq 0x7a83f
testq %rax, %rax
je 0x78712
leaq 0x6424b(%rip), %rcx     # 0xdc928
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 0x7a9a0
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 0x7c1f2
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/arena.c
// Function: arena_run_trim_tail
static void
arena_run_trim_tail(arena_t *arena, arena_chunk_t *chunk, arena_run_t *run,
    size_t oldsize, size_t newsize, bool dirty)
{
	size_t pageind = ((uintptr_t)run - (uintptr_t)chunk) >> LG_PAGE;
	size_t head_npages = newsize >> LG_PAGE;
	size_t flag_dirty = arena_mapbits_dirty_get(chunk, pageind);

	assert(oldsize > newsize);

	/*
	 * Update the chunk map so that arena_run_dalloc() can treat the
	 * trailing run as separately allocated.  Set the last element of each
	 * run first, in case of single-page runs.
	 */
	assert(arena_mapbits_large_size_get(chunk, pageind) == oldsize);
	arena_mapbits_large_set(chunk, pageind+head_npages-1, 0, flag_dirty);
	arena_mapbits_large_set(chunk, pageind, newsize, flag_dirty);

	if (config_debug) {
		UNUSED size_t tail_npages = (oldsize - newsize) >> LG_PAGE;
		assert(arena_mapbits_large_size_get(chunk,
		    pageind+head_npages+tail_npages-1) == 0);
		assert(arena_mapbits_dirty_get(chunk,
		    pageind+head_npages+tail_npages-1) == flag_dirty);
	}
	arena_mapbits_large_set(chunk, pageind+head_npages, oldsize-newsize,
	    flag_dirty);

	arena_run_dalloc(arena, (arena_run_t *)((uintptr_t)run + newsize),
	    dirty, false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq (%rdx,%r8), %rax
subq %rsi, %rdx
shrq $0xc, %rdx
movq %r8, %r10
shrq $0xc, %r10
leaq 0x63fd4(%rip), %r11     # 0xdc928
movq (%r11), %rbx
movq %rdx, %r14
subq %rbx, %r14
imulq $0x18, %r14, %r14
movq 0x40(%rsi,%r14), %r14
andl $0x8, %r14d
addq %rdx, %r10
notq %rbx
addq %r10, %rbx
imulq $0x18, %rbx, %rbx
movq 0x40(%rsi,%rbx), %r15
andl $0x4, %r15d
orq %r14, %r15
movl $0xff3, %r12d           # imm = 0xFF3
orq %r12, %r15
movq %r15, 0x40(%rsi,%rbx)
subq (%r11), %rdx
imulq $0x18, %rdx, %rdx
movq 0x40(%rsi,%rdx), %rbx
andl $0x4, %ebx
orq %r8, %rbx
orq %r12, %r14
orq %r14, %rbx
movq %rbx, 0x40(%rsi,%rdx)
subq %r8, %rcx
subq (%r11), %r10
imulq $0x18, %r10, %rdx
movq 0x40(%rsi,%rdx), %r8
andl $0x4, %r8d
orq %rcx, %r8
orq %r14, %r8
movq %r8, 0x40(%rsi,%rdx)
movq %rax, %rsi
movl %r9d, %edx
xorl %ecx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x78f00
// File: /workspace/github_c_makefile_star2_O2/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 0x63b13(%rip), %rax     # 0xdc928
movq %rcx, %rdx
subq (%rax), %rdx
imulq $0x18, %rdx, %rax
movq 0x40(%rsi,%rax), %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 0x78a2f
movq %r13, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1fbb0
// File: /workspace/github_c_makefile_star2_O2/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 0x63a91(%rip), %rcx     # 0xdc928
subq (%rcx), %rax
movq %rdi, %r14
imulq $0x18, %rax, %rax
movq 0x40(%rsi,%rax), %r12
movq %r12, %r15
andq $-0x1000, %r15          # imm = 0xF000
leaq 0x62ca4(%rip), %rax     # 0xdbb5b
cmpb $0x1, (%rax)
jne 0x78eca
pushq $0x5a
popq %rsi
movq %rbx, %rdi
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)
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x78f00
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
movl %esi, (%rdi)
andl $0x0, 0x4(%rdi)
addq $0x8, %rdi
callq 0x82b74
movb $0x1, %bpl
testb %al, %al
jne 0x7a1f4
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x50(%rbx)
andq $0x0, 0x70(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
leaq 0x627a0(%rip), %r14     # 0xdc888
movq (%r14), %rdi
leaq 0x62836(%rip), %r15     # 0xdc928
subq (%r15), %rdi
shlq $0x5, %rdi
callq 0x7c708
movq %rax, 0x70(%rbx)
testq %rax, %rax
je 0x7a1f4
movq (%r14), %rdx
subq (%r15), %rdx
shlq $0x5, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1f110
andq $0x0, 0x78(%rbx)
callq 0x7cea8
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
pushq $0x1c
popq %r15
movl $0x98, %r12d
addq $-0x1, %r15
setb %bpl
jae 0x7a1f4
movq %r14, %rdi
callq 0x82b74
testb %al, %al
jne 0x7a1f4
andq $0x0, 0x28(%r14)
leaq 0x38(%r14), %rax
movq %rax, 0x30(%r14)
movq %rax, 0x38(%r14)
movq %rbx, %rax
andq $-0x2, %rax
movq %rax, 0x40(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r14)
movups %xmm0, 0x60(%r14)
andq $0x0, 0x90(%r14)
movups %xmm0, 0x70(%r14)
movups %xmm0, 0x80(%r14)
addq %r12, %r14
addq %r12, %rbx
jmp 0x7a198
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x82bc3
movl $0x120, %r14d           # imm = 0x120
cmpq $0x11c0, %r14           # imm = 0x11C0
je 0x7a7c1
leaq (%rbx,%r14), %rdi
callq 0x82bc3
addq $0x98, %r14
jmp 0x7a7a6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x120, %r14d           # imm = 0x120
cmpq $0x11c0, %r14           # imm = 0x11C0
je 0x7a7f1
leaq (%rbx,%r14), %rdi
callq 0x82bc8
addq $0x98, %r14
jmp 0x7a7d6
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x82bc8
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x120, %r14d           # imm = 0x120
cmpq $0x11c0, %r14           # imm = 0x11C0
je 0x7a82c
leaq (%rbx,%r14), %rdi
callq 0x82bcd
addq $0x98, %r14
jmp 0x7a811
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x82bcd
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, 0x4(%rsp)
movq %rcx, 0x8(%rsp)
movl %edx, (%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rax
orq $0x1, %rax
leaq 0x10(%rsp), %rbx
movq %rax, 0x10(%rbx)
leaq 0x100(%rdi), %r13
leaq 0x108(%rdi), %rbp
movq %rbp, %r12
movq (%r13), %r13
cmpq %rbp, %r13
je 0x7c260
movq %rbx, %rdi
movq %r13, %rsi
callq 0x7b600
testl %eax, %eax
js 0x7c258
je 0x7c25d
movq 0x8(%r13), %r13
andq $-0x2, %r13
jmp 0x7c238
movq %r13, %r12
jmp 0x7c234
movq %r13, %r12
cmpq %rbp, %r12
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
je 0x7c274
xorl %ebx, %ebx
jmp 0x7c2c7
leaq 0x60605(%rip), %rax     # 0xdc880
movq (%rax), %rcx
notq %rcx
andq %r12, %rcx
subq %rcx, %r12
addq $-0x30, %r12
pushq $0x18
popq %rsi
movq %r12, %rax
xorl %edx, %edx
divq %rsi
movq %rax, %rbx
leaq 0x60688(%rip), %rax     # 0xdc928
addq (%rax), %rbx
shlq $0xc, %rbx
addq %rcx, %rbx
movzbl (%rsp), %ecx
movzbl 0x4(%rsp), %r9d
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq 0x8(%rsp), %r8
callq 0x7a9a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x60599(%rip), %rax     # 0xdc880
movq (%rax), %rax
notq %rax
andq %rsi, %rax
subq %rax, %rsi
shrq $0xc, %rsi
leaq 0x6062a(%rip), %rcx     # 0xdc928
subq (%rcx), %rsi
imulq $0x18, %rsi, %rcx
leaq (%rax,%rcx), %rdx
addq $0x30, %rdx
leaq 0x38(%rdi), %rcx
movq %rcx, (%rdx)
movq %rcx, %rax
orq $0x1, %rax
movq %rax, 0x8(%rdx)
movq 0x30(%rdi), %rsi
leaq -0x90(%rsp), %rax
movq %rsi, 0x10(%rax)
cmpq %rcx, %rsi
je 0x7c365
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq %rdx, %rsi
setb %r8b
seta %r9b
subl %r9d, %r8d
movl %r8d, 0x18(%rax)
js 0x7c358
movq 0x8(%rsi), %rsi
andq $-0x2, %rsi
jmp 0x7c35b
movq (%rsi), %rsi
movq %rsi, 0x20(%rax)
addq $0x10, %rax
jmp 0x7c32f
movq %rdx, 0x10(%rax)
leaq -0x80(%rsp), %rcx
cmpq %rcx, %rax
jb 0x7c445
movq (%rax), %rsi
cmpl $0x0, 0x8(%rax)
js 0x7c3cf
movq 0x8(%rsi), %r9
andl $0x1, %r9d
orq %rdx, %r9
movq %r9, 0x8(%rsi)
testb $0x1, 0x8(%rdx)
je 0x7c452
movq (%rsi), %r8
movq 0x8(%r8), %r10
testb $0x1, %r10b
jne 0x7c40b
andl $0x1, %r9d
movq %rdx, %r8
andq $-0x2, %r8
movq (%r8), %rdx
orq %r9, %rdx
movq %rdx, 0x8(%rsi)
movq %rsi, (%r8)
leaq 0x8(%r8), %rdx
movq 0x8(%r8), %r10
andq $-0x2, %r10
orq %r9, %r10
jmp 0x7c421
movq %rdx, (%rsi)
testb $0x1, 0x8(%rdx)
je 0x7c452
movq (%rdx), %rdx
movq 0x8(%rdx), %r8
testb $0x1, %r8b
je 0x7c436
andq $-0x2, %r8
movq %r8, 0x8(%rdx)
movq (%rsi), %r8
movq 0x8(%r8), %rdx
andq $-0x2, %rdx
movq %rdx, (%rsi)
movq 0x8(%r8), %rdx
andl $0x1, %edx
orq %rsi, %rdx
leaq 0x8(%r8), %rsi
jmp 0x7c430
addq $0x8, %rdx
andq $-0x2, %r10
movq %r10, 0x8(%r8)
movq (%rdx), %r10
andq $-0x2, %r10
movq %rsi, %r8
movq %r10, (%rdx)
movq 0x8(%rsi), %rdx
addq $0x8, %rsi
orq $0x1, %rdx
movq %rdx, (%rsi)
movq %r8, %rsi
movq %rsi, (%rax)
addq $-0x10, %rax
movq %rsi, %rdx
jmp 0x7c36e
movq -0x80(%rsp), %rax
movq %rax, 0x30(%rdi)
andb $-0x2, 0x8(%rax)
addq $0x788, %rsp            # imm = 0x788
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6003e(%rip), %rdi     # 0xdc760
callq 0x1faa0
movq 0x6005a(%rip), %r14     # 0xdc788
leaq (%rbx,%r14), %rax
cmpq 0x60057(%rip), %rax     # 0xdc790
jbe 0x7c79a
leaq 0x6013e(%rip), %rax     # 0xdc880
movq (%rax), %r15
leaq (%r15,%rbx), %rax
notq %r15
andq %rax, %r15
leaq 0x7(%rsp), %r14
movb $0x0, (%r14)
leaq 0x60101(%rip), %rax     # 0xdc860
movq (%rax), %r12
callq 0x7cea8
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rcx
movl %eax, %r8d
callq 0x7c988
movq %rax, 0x6001e(%rip)     # 0xdc7a0
testq %rax, %rax
je 0x7c7bc
movq %rax, %r14
addq %rax, %r15
movq %r15, 0x5fffc(%rip)     # 0xdc790
addq %rax, %rbx
movq %rbx, %rax
movq %rax, 0x5ffe7(%rip)     # 0xdc788
leaq 0x5ffb8(%rip), %rdi     # 0xdc760
callq 0x1fbb0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r14d, %r14d
jmp 0x7c7a1
// File: /workspace/github_c_makefile_star2_O2/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 0x7c708
testq %rax, %rax
je 0x7c7e4
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
jmp 0x1f110
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5ff72(%rip), %rdi     # 0xdc760
callq 0x1faa0
movq 0x5ff9e(%rip), %rbx     # 0xdc798
testq %rbx, %rbx
je 0x7c81a
movq (%rbx), %rax
movq %rax, 0x5ff8f(%rip)     # 0xdc798
leaq 0x5ff50(%rip), %rdi     # 0xdc760
callq 0x1fbb0
movq %rbx, %rax
popq %rbx
retq
leaq 0x5ff3f(%rip), %rdi     # 0xdc760
callq 0x1fbb0
pushq $0x40
popq %rdi
popq %rbx
jmp 0x7c708
// File: /workspace/github_c_makefile_star2_O2/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 0x5ff23(%rip), %r14     # 0xdc760
movq %r14, %rdi
callq 0x1faa0
movq 0x5ff4c(%rip), %rax     # 0xdc798
movq %rax, (%rbx)
movq %rbx, 0x5ff42(%rip)     # 0xdc798
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1fbb0
// File: /workspace/github_c_makefile_star2_O2/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:
andq $0x0, 0x10(%rdi)
movq %rsi, %rax
shrq $0x6, %rax
movl %esi, %ecx
andl $0x3f, %ecx
cmpq $0x1, %rcx
sbbq $-0x1, %rax
pushq $0x1
popq %rcx
xorl %edx, %edx
addq %rax, %rdx
movl %ecx, %r8d
movq %rdx, 0x10(%rdi,%r8,8)
cmpq $0x2, %rax
jb 0x7c8e8
movq %rax, %r8
shrq $0x6, %r8
andl $0x3f, %eax
cmpq $0x1, %rax
sbbq $-0x1, %r8
incl %ecx
movq %r8, %rax
jmp 0x7c8be
movl %ecx, 0x8(%rdi)
movq %rsi, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7d1aa
testb %al, %al
je 0x7cd7e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7d084
movl %eax, %ebp
callq 0x7c7e6
movq %rax, %r15
leaq 0x5fbf7(%rip), %rdi     # 0xdc838
callq 0x1faa0
leaq (%rbx,%r12), %rax
leaq 0x8(%rsp), %rsi
movq %rax, 0x28(%rsi)
leaq 0x5fb96(%rip), %rdi     # 0xdc7f0
callq 0x81c90
testq %rax, %rax
je 0x7cc72
movq %rax, %r14
movq 0x28(%rax), %rax
cmpq 0x30(%rsp), %rax
je 0x7ccae
testq %r15, %r15
je 0x7cd72
movq %rbx, 0x28(%r15)
movq %r12, 0x30(%r15)
xorb $0x1, %bpl
movb %bpl, 0x38(%r15)
leaq 0x5fb5e(%rip), %rdi     # 0xdc7f0
movq %r15, %rsi
callq 0x81d1f
leaq 0x5fb07(%rip), %rdi     # 0xdc7a8
movq %r15, %rsi
callq 0x8132c
movq %r15, %r14
jmp 0x7cce8
leaq 0x5faf3(%rip), %r13     # 0xdc7a8
movq %r13, %rdi
movq %r14, %rsi
callq 0x81491
movq %rbx, 0x28(%r14)
addq %r12, 0x30(%r14)
xorb $0x1, %bpl
andb %bpl, 0x38(%r14)
movq %r13, %rdi
movq %r14, %rsi
callq 0x8132c
testq %r15, %r15
je 0x7cce8
movq %r15, %rdi
callq 0x7c82f
leaq 0x5fb01(%rip), %rdi     # 0xdc7f0
movq %r14, %rsi
callq 0x81c05
testq %rax, %rax
je 0x7cd72
movq %rax, %r15
movq 0x30(%rax), %rax
addq 0x28(%r15), %rax
cmpq %rbx, %rax
jne 0x7cd72
leaq 0x5fa95(%rip), %rbx     # 0xdc7a8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x81491
leaq 0x5facb(%rip), %rdi     # 0xdc7f0
movq %r15, %rsi
callq 0x81e79
movq %rbx, %rdi
movq %r14, %rsi
callq 0x81491
movq 0x28(%r15), %rax
movq %rax, 0x28(%r14)
movq 0x30(%r15), %rax
addq %rax, 0x30(%r14)
cmpb $0x1, 0x38(%r14)
jne 0x7cd55
movb 0x38(%r15), %al
jmp 0x7cd57
xorl %eax, %eax
movb %al, 0x38(%r14)
leaq 0x5fa46(%rip), %rdi     # 0xdc7a8
movq %r14, %rsi
callq 0x8132c
movq %r15, %rdi
callq 0x7c82f
leaq 0x5fabf(%rip), %rdi     # 0xdc838
callq 0x1fbb0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq