LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/include/jemalloc/internal/rtree.h
// Function: huge_node_get
JEMALLOC_ALWAYS_INLINE unsigned
rtree_start_level(rtree_t *rtree, uintptr_t key)
{
	unsigned start_level;

	if (unlikely(key == 0))
		return (rtree->height - 1);

	start_level = rtree->start_level[lg_floor(key) >>
	    LG_RTREE_BITS_PER_LEVEL];
	assert(start_level < rtree->height);
	return (start_level);
}

// Assembly:
testq %rdi, %rdi
je 0x2e4b3
bsrq %rdi, %rax
shrl $0x4, %eax
leaq 0x1ec9f(%rip), %rcx     # 0x4d060
movl 0x14(%rcx,%rax,4), %esi
movl %esi, %eax
shlq $0x4, %rax
movq 0x28(%rcx,%rax), %rax
movl 0x10(%rcx), %edx
subl %edx, %esi
addl $0x4, %esi
leaq 0xe731(%rip), %rcx      # 0x3cb10
movslq (%rcx,%rsi,4), %rsi
addq %rcx, %rsi
jmpq *%rsi
leal -0x4(%rdx), %esi
shlq $0x4, %rsi
leaq 0x1ec6a(%rip), %r8      # 0x4d060
xorl %ecx, %ecx
subb 0x34(%r8,%rsi), %cl
movq %rdi, %r9
shrq %cl, %r9
movb 0x30(%r8,%rsi), %cl
movq $-0x1, %rsi
shlq %cl, %rsi
notq %rsi
andq %r9, %rsi
movq (%rax,%rsi,8), %rax
leal -0x3(%rdx), %esi
shlq $0x4, %rsi
leaq 0x1ec36(%rip), %r8      # 0x4d060
xorl %ecx, %ecx
subb 0x34(%r8,%rsi), %cl
movq %rdi, %r9
shrq %cl, %r9
movb 0x30(%r8,%rsi), %cl
movq $-0x1, %rsi
shlq %cl, %rsi
notq %rsi
andq %r9, %rsi
movq (%rax,%rsi,8), %rax
leal -0x2(%rdx), %esi
shlq $0x4, %rsi
leaq 0x1ec02(%rip), %r8      # 0x4d060
xorl %ecx, %ecx
subb 0x34(%r8,%rsi), %cl
movq %rdi, %r9
shrq %cl, %r9
movb 0x30(%r8,%rsi), %cl
movq $-0x1, %rsi
shlq %cl, %rsi
notq %rsi
andq %r9, %rsi
movq (%rax,%rsi,8), %rax
decl %edx
shlq $0x4, %rdx
leaq 0x1ebcf(%rip), %rsi     # 0x4d060
xorl %ecx, %ecx
subb 0x34(%rsi,%rdx), %cl
shrq %cl, %rdi
movb 0x30(%rsi,%rdx), %cl
movq $-0x1, %rdx
shlq %cl, %rdx
notq %rdx
andq %rdi, %rdx
movq (%rax,%rdx,8), %rax
retq
leaq 0x1eba6(%rip), %rcx     # 0x4d060
movl 0x10(%rcx), %esi
decl %esi
movl %esi, %eax
shlq $0x4, %rax
movq 0x28(%rcx,%rax), %rax
movl 0x10(%rcx), %edx
subl %edx, %esi
addl $0x4, %esi
leaq 0xe637(%rip), %rcx      # 0x3cb10
movslq (%rcx,%rsi,4), %rsi
addq %rcx, %rsi
jmpq *%rsi
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/huge.c
// Function: je_huge_salloc
size_t
huge_salloc(tsdn_t *tsdn, const void *ptr)
{
	size_t size;
	extent_node_t *node;
	arena_t *arena;

	node = huge_node_get(ptr);
	arena = extent_node_arena_get(node);
	malloc_mutex_lock(tsdn, &arena->huge_mtx);
	size = extent_node_size_get(node);
	malloc_mutex_unlock(tsdn, &arena->huge_mtx);

	return (size);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdi
callq 0x2e3aa
movq %rax, %rbx
movl $0x830, %r14d           # imm = 0x830
addq (%rax), %r14
movq %r14, %rdi
callq 0xb5a0
movq 0x10(%rbx), %rbx
movq %r14, %rdi
callq 0xb380
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/huge.c
// Function: je_huge_prof_tctx_set
void
huge_prof_tctx_set(tsdn_t *tsdn, const void *ptr, prof_tctx_t *tctx)
{
	extent_node_t *node;
	arena_t *arena;

	node = huge_node_get(ptr);
	arena = extent_node_arena_get(node);
	malloc_mutex_lock(tsdn, &arena->huge_mtx);
	extent_node_prof_tctx_set(node, tctx);
	malloc_mutex_unlock(tsdn, &arena->huge_mtx);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %rdi
callq 0x2e3aa
movq %rax, %r14
movl $0x830, %r15d           # imm = 0x830
addq (%rax), %r15
movq %r15, %rdi
callq 0xb5a0
movq %rbx, 0x28(%r14)
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/nstime.c
// Function: je_nstime_update
bool
nstime_update(nstime_t *time)
{
	nstime_t old_time;

	nstime_copy(&old_time, time);
	nstime_get(time);

	/* Handle non-monotonic clocks. */
	if (unlikely(nstime_compare(&old_time, time) > 0)) {
		nstime_copy(time, &old_time);
		return (true);
	}

	return (false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
movq %rsp, %r14
movl $0x6, %edi
movq %r14, %rsi
callq 0xb140
imulq $0x3b9aca00, (%r14), %rax # imm = 0x3B9ACA00
addq 0x8(%r14), %rax
movq %rax, (%rbx)
cmpq %rax, %r15
ja 0x2e751
cmpq %rax, %r15
seta %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %r15, (%rbx)
jmp 0x2e741
nop
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/pages.c
// Function: je_pages_trim
void *
pages_trim(void *addr, size_t alloc_size, size_t leadsize, size_t size,
    bool *commit)
{
	void *ret = (void *)((uintptr_t)addr + leadsize);

	assert(alloc_size >= leadsize + size);
#ifdef _WIN32
	{
		void *new_addr;

		pages_unmap(addr, alloc_size);
		new_addr = pages_map(ret, size, commit);
		if (new_addr == ret)
			return (ret);
		if (new_addr)
			pages_unmap(new_addr, size);
		return (NULL);
	}
#else
	{
		size_t trailsize = alloc_size - leadsize - size;

		if (leadsize != 0)
			pages_unmap(addr, leadsize);
		if (trailsize != 0)
			pages_unmap((void *)((uintptr_t)ret + size), trailsize);
		return (ret);
	}
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq (%rcx,%rdx), %r13
testq %rdx, %rdx
je 0x2e83b
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2e7c4
addq %r12, %rbx
cmpq %r13, %r15
je 0x2e854
subq %r13, %r15
addq %rbx, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x2e7c4
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/pages.c
// Function: pages_commit_impl
static bool
pages_commit_impl(void *addr, size_t size, bool commit)
{

	if (os_overcommits)
		return (true);

#ifdef _WIN32
	return (commit ? (addr != VirtualAlloc(addr, size, MEM_COMMIT,
	    PAGE_READWRITE)) : (!VirtualFree(addr, size, MEM_DECOMMIT)));
#else
	{
		int prot = commit ? PAGES_PROT_COMMIT : PAGES_PROT_DECOMMIT;
		void *result = mmap(addr, size, prot, mmap_flags | MAP_FIXED,
		    -1, 0);
		if (result == MAP_FAILED)
			return (true);
		if (result != addr) {
			/*
			 * We succeeded in mapping memory, but not in the right
			 * place.
			 */
			pages_unmap(result, size);
			return (true);
		}
		return (false);
	}
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movb $0x1, %bl
cmpb $0x0, 0x1e922(%rip)     # 0x4d198
jne 0x2e8b5
movq %rsi, %r14
movq %rdi, %r15
movzbl %dl, %eax
leal (%rax,%rax,2), %edx
movl 0x1e912(%rip), %ecx     # 0x4d19c
orl $0x10, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0xb1a0
cmpq $-0x1, %rax
je 0x2e8b5
cmpq %r15, %rax
je 0x2e8b3
movq %rax, %rdi
movq %r14, %rsi
callq 0x2e7c4
jmp 0x2e8b5
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/pages.c
// Function: je_pages_boot
void
pages_boot(void)
{

#ifndef _WIN32
	mmap_flags = MAP_PRIVATE | MAP_ANON;
#endif

#ifdef JEMALLOC_SYSCTL_VM_OVERCOMMIT
	os_overcommits = os_overcommits_sysctl();
#elif defined(JEMALLOC_PROC_SYS_VM_OVERCOMMIT_MEMORY)
	os_overcommits = os_overcommits_proc();
#  ifdef MAP_NORESERVE
	if (os_overcommits)
		mmap_flags |= MAP_NORESERVE;
#  endif
#else
	os_overcommits = false;
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x22, 0x1e89a(%rip)    # 0x4d19c
leaq 0xe26c(%rip), %rsi      # 0x3cb75
movl $0x2, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0xb320
movq %rax, %rbx
cmpl $-0x1, %ebx
je 0x2e964
leaq 0x7(%rsp), %rdx
movl $0x1, %ecx
xorl %edi, %edi
movl %ebx, %esi
xorl %eax, %eax
callq 0xb320
movq %rax, %r14
movl $0x3, %edi
movl %ebx, %esi
xorl %eax, %eax
callq 0xb320
testq %r14, %r14
jle 0x2e964
movb 0x7(%rsp), %al
andb $-0x2, %al
cmpb $0x30, %al
sete 0x1e83f(%rip)           # 0x4d198
jne 0x2e96b
orb $0x40, 0x1e83b(%rip)    # 0x4d19d
jmp 0x2e96b
movb $0x0, 0x1e82d(%rip)     # 0x4d198
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: je_prof_thread_active_init_get
bool
prof_thread_active_init_get(tsdn_t *tsdn)
{
	bool active_init;

	malloc_mutex_lock(tsdn, &prof_thread_active_init_mtx);
	active_init = prof_thread_active_init;
	malloc_mutex_unlock(tsdn, &prof_thread_active_init_mtx);
	return (active_init);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x1e273(%rip), %rbx     # 0x4d310
movq %rbx, %rdi
callq 0xb5a0
movb 0x1e2b4(%rip), %bpl     # 0x4d360
movq %rbx, %rdi
callq 0xb380
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: je_prof_tdata_reinit
prof_tdata_t *
prof_tdata_reinit(tsd_t *tsd, prof_tdata_t *tdata)
{
	uint64_t thr_uid = tdata->thr_uid;
	uint64_t thr_discrim = tdata->thr_discrim + 1;
	char *thread_name = (tdata->thread_name != NULL) ?
	    prof_thread_name_alloc(tsd_tsdn(tsd), tdata->thread_name) : NULL;
	bool active = tdata->active;

	prof_tdata_detach(tsd, tdata);
	return (prof_tdata_init_impl(tsd, thr_uid, thr_discrim, thread_name,
	    active));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r15
testq %r15, %r15
je 0x2f1f9
movq %r15, %rdi
callq 0xb190
testq %rax, %rax
je 0x2f1f9
leaq 0x1(%rax), %r12
cmpq $0x1000, %r12           # imm = 0x1000
jbe 0x2f25b
movq %r12, %rdi
callq 0x114bc
movl %eax, %ebp
leaq 0x1d4a2(%rip), %rax     # 0x4c5b0
movq (%rax), %rax
movq (%rax), %rsi
testq %rsi, %rsi
jne 0x2f131
xorl %esi, %esi
lock
xaddq %rsi, (%rax)
testq %rsi, %rsi
jne 0x2f131
xorl %edi, %edi
xorl %esi, %esi
callq 0x1ae84
movq %rax, %rsi
movq %r14, %rdi
movq %r12, %rdx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0xd1d4
testq %rax, %rax
je 0x2f1f9
movq %rax, %r13
leaq 0x1df7c(%rip), %rbp     # 0x4d0d0
movq (%rbp), %rax
notq %rax
andq %r13, %rax
cmpq %rax, %r13
movq %r13, (%rsp)
jne 0x2f174
movq %r13, %rdi
callq 0x2e39f
movq %rax, %rsi
jmp 0x2f177
movq (%rax), %rsi
movq (%rbp), %rax
notq %rax
andq %r13, %rax
subq %rax, %r13
jne 0x2f1a0
movq %r14, %rdi
movq (%rsp), %r13
movq %rsi, %rbp
movq %r13, %rsi
callq 0x2e4e2
movq %rbp, %rsi
movq %r13, %rdi
jmp 0x2f1e5
shrq $0xc, %r13
leaq 0x1de15(%rip), %rcx     # 0x4cfc0
subq (%rcx), %r13
movq 0x78(%rax,%r13,8), %rax
movl %eax, %ecx
shrl $0x5, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
jne 0x2f1d4
shrq %rax
andq $-0x1000, %rax          # imm = 0xF000
addq $-0x1000, %rax          # imm = 0xF000
jmp 0x2f1e1
movl %ecx, %eax
leaq 0xc463(%rip), %rcx      # 0x3b640
movq (%rcx,%rax,8), %rax
movq (%rsp), %rdi
lock
xaddq %rax, 0x90(%rsi)
movq %r15, %rsi
movq %r12, %rdx
callq 0xb340
movq (%rbx), %rdi
callq 0xb5a0
cmpb $0x1, 0x20(%rbx)
jne 0x2f221
leaq 0x40(%rbx), %rdi
callq 0x372f8
testq %rax, %rax
je 0x2f229
movb $0x0, 0x20(%rbx)
movq $0x0, 0x20(%r14)
movq (%rbx), %rdi
callq 0xb380
movq $0x0, 0x20(%r14)
movq (%rbx), %rdi
callq 0xb380
leaq 0x1e018(%rip), %r15     # 0x4d258
movq %r15, %rdi
callq 0xb5a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2f3bb
movq %r15, %rdi
callq 0xb380
shrq $0x3, %rax
leaq 0xcb5a(%rip), %rcx      # 0x3bdc0
movzbl (%rcx,%rax), %ebp
jmp 0x2f107
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: je_prof_reset
void
prof_reset(tsd_t *tsd, size_t lg_sample)
{
	prof_tdata_t *next;

	assert(lg_sample < (sizeof(uint64_t) << 3));

	malloc_mutex_lock(tsd_tsdn(tsd), &prof_dump_mtx);
	malloc_mutex_lock(tsd_tsdn(tsd), &tdatas_mtx);

	lg_prof_sample = lg_sample;

	next = NULL;
	do {
		prof_tdata_t *to_destroy = tdata_tree_iter(&tdatas, next,
		    prof_tdata_reset_iter, (void *)tsd);
		if (to_destroy != NULL) {
			next = tdata_tree_next(&tdatas, to_destroy);
			prof_tdata_destroy_locked(tsd, to_destroy, false);
		} else
			next = NULL;
	} while (next != NULL);

	malloc_mutex_unlock(tsd_tsdn(tsd), &tdatas_mtx);
	malloc_mutex_unlock(tsd_tsdn(tsd), &prof_dump_mtx);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1df88(%rip), %rdi     # 0x4d208
callq 0xb5a0
leaq 0x1dfcc(%rip), %rdi     # 0x4d258
callq 0xb5a0
movq %r14, 0x1e010(%rip)     # 0x4d2a8
xorl %r14d, %r14d
movq 0x1e00e(%rip), %rsi     # 0x4d2b0
testq %r14, %r14
je 0x2f2b4
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2fdfe
jmp 0x2f2bf
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x2fe74
testq %rax, %rax
je 0x2f2dc
movq 0x30(%rax), %rcx
andq $-0x2, %rcx
je 0x2f2e1
movq %rcx, %r14
movq 0x28(%rcx), %rcx
testq %rcx, %rcx
jne 0x2f2ce
jmp 0x2f33e
xorl %r14d, %r14d
jmp 0x2f349
movq 0x1dfc8(%rip), %rdx     # 0x4d2b0
movq 0x8(%rax), %rcx
xorl %r14d, %r14d
xorl %esi, %esi
cmpq 0x8(%rdx), %rcx
seta %sil
sbbl $0x0, %esi
jne 0x2f30f
movq 0x10(%rax), %rdi
xorl %esi, %esi
cmpq 0x10(%rdx), %rdi
seta %sil
sbbl $0x0, %esi
testl %esi, %esi
js 0x2f322
je 0x2f32b
movq 0x30(%rdx), %rsi
andq $-0x2, %rsi
movb $0x1, %dil
jmp 0x2f330
movq 0x28(%rdx), %rsi
movb $0x1, %dil
jmp 0x2f333
xorl %edi, %edi
movq %rdx, %rsi
movq %r14, %rdx
movq %rdx, %r14
movq %rsi, %rdx
testb %dil, %dil
jne 0x2f2ef
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2f3bb
testq %r14, %r14
jne 0x2f29b
leaq 0x1deff(%rip), %rdi     # 0x4d258
callq 0xb380
leaq 0x1dea3(%rip), %rdi     # 0x4d208
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: je_prof_active_get
bool
prof_active_get(tsdn_t *tsdn)
{
	bool prof_active_current;

	malloc_mutex_lock(tsdn, &prof_active_mtx);
	prof_active_current = prof_active;
	malloc_mutex_unlock(tsdn, &prof_active_mtx);
	return (prof_active_current);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x1d7f4(%rip), %rbx     # 0x4d2b8
movq %rbx, %rdi
callq 0xb5a0
movb 0x1d835(%rip), %bpl     # 0x4d308
movq %rbx, %rdi
callq 0xb380
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: je_prof_active_set
bool
prof_active_set(tsdn_t *tsdn, bool active)
{
	bool prof_active_old;

	malloc_mutex_lock(tsdn, &prof_active_mtx);
	prof_active_old = prof_active;
	prof_active = active;
	malloc_mutex_unlock(tsdn, &prof_active_mtx);
	return (prof_active_old);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
leaq 0x1d7c7(%rip), %r14     # 0x4d2b8
movq %r14, %rdi
callq 0xb5a0
movb 0x1d808(%rip), %bpl     # 0x4d308
movb %bl, 0x1d802(%rip)      # 0x4d308
movq %r14, %rdi
callq 0xb380
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: je_prof_thread_name_set
bool
prof_thread_active_init_set(tsdn_t *tsdn, bool active_init)
{
	bool active_init_old;

	malloc_mutex_lock(tsdn, &prof_thread_active_init_mtx);
	active_init_old = prof_thread_active_init;
	prof_thread_active_init = active_init;
	malloc_mutex_unlock(tsdn, &prof_thread_active_init_mtx);
	return (active_init_old);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
leaq 0x1d7ee(%rip), %r14     # 0x4d310
movq %r14, %rdi
callq 0xb5a0
movb 0x1d82f(%rip), %bpl     # 0x4d360
movb %bl, 0x1d829(%rip)      # 0x4d360
movq %r14, %rdi
callq 0xb380
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: je_prof_gdump_get
bool
prof_gdump_get(tsdn_t *tsdn)
{
	bool prof_gdump_current;

	malloc_mutex_lock(tsdn, &prof_gdump_mtx);
	prof_gdump_current = prof_gdump_val;
	malloc_mutex_unlock(tsdn, &prof_gdump_mtx);
	return (prof_gdump_current);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x1d818(%rip), %rbx     # 0x4d368
movq %rbx, %rdi
callq 0xb5a0
movb 0x1d859(%rip), %bpl     # 0x4d3b8
movq %rbx, %rdi
callq 0xb380
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: je_prof_gdump_set
bool
prof_gdump_set(tsdn_t *tsdn, bool gdump)
{
	bool prof_gdump_old;

	malloc_mutex_lock(tsdn, &prof_gdump_mtx);
	prof_gdump_old = prof_gdump_val;
	prof_gdump_val = gdump;
	malloc_mutex_unlock(tsdn, &prof_gdump_mtx);
	return (prof_gdump_old);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
leaq 0x1d7eb(%rip), %r14     # 0x4d368
movq %r14, %rdi
callq 0xb5a0
movb 0x1d82c(%rip), %bpl     # 0x4d3b8
movb %bl, 0x1d826(%rip)      # 0x4d3b8
movq %r14, %rdi
callq 0xb380
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: je_prof_prefork0
void
prof_prefork0(tsdn_t *tsdn)
{

	if (opt_prof) {
		unsigned i;

		malloc_mutex_prefork(tsdn, &prof_dump_mtx);
		malloc_mutex_prefork(tsdn, &bt2gctx_mtx);
		malloc_mutex_prefork(tsdn, &tdatas_mtx);
		for (i = 0; i < PROF_NTDATA_LOCKS; i++)
			malloc_mutex_prefork(tsdn, &tdata_locks[i]);
		for (i = 0; i < PROF_NCTX_LOCKS; i++)
			malloc_mutex_prefork(tsdn, &gctx_locks[i]);
	}
}

// Assembly:
cmpb $0x1, 0x1d5f8(%rip)     # 0x4d1a0
jne 0x2fc18
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1d650(%rip), %rsi     # 0x4d208
callq 0x2e62e
leaq 0x1d7fc(%rip), %rsi     # 0x4d3c0
movq %rbx, %rdi
callq 0x2e62e
leaq 0x1d685(%rip), %rsi     # 0x4d258
movq %rbx, %rdi
callq 0x2e62e
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e62e
addq $0x50, %r14
cmpq $0x5000, %r14           # imm = 0x5000
jne 0x2fbde
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e62e
addq $0x50, %r14
cmpq $0x14000, %r14          # imm = 0x14000
jne 0x2fbf9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: je_prof_prefork1
void
prof_prefork1(tsdn_t *tsdn)
{

	if (opt_prof) {
		malloc_mutex_prefork(tsdn, &prof_active_mtx);
		malloc_mutex_prefork(tsdn, &prof_dump_seq_mtx);
		malloc_mutex_prefork(tsdn, &prof_gdump_mtx);
		malloc_mutex_prefork(tsdn, &next_thr_uid_mtx);
		malloc_mutex_prefork(tsdn, &prof_thread_active_init_mtx);
	}
}

// Assembly:
cmpb $0x1, 0x1d580(%rip)     # 0x4d1a0
jne 0x2fc6f
pushq %rbx
movq %rdi, %rbx
leaq 0x1d68b(%rip), %rsi     # 0x4d2b8
callq 0x2e62e
leaq 0x1d57f(%rip), %rsi     # 0x4d1b8
movq %rbx, %rdi
callq 0x2e62e
leaq 0x1d720(%rip), %rsi     # 0x4d368
movq %rbx, %rdi
callq 0x2e62e
leaq 0x1d7c1(%rip), %rsi     # 0x4d418
movq %rbx, %rdi
callq 0x2e62e
leaq 0x1d6aa(%rip), %rsi     # 0x4d310
movq %rbx, %rdi
popq %rbx
jmp 0x2e62e
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: je_prof_postfork_parent
void
prof_postfork_parent(tsdn_t *tsdn)
{

	if (opt_prof) {
		unsigned i;

		malloc_mutex_postfork_parent(tsdn,
		    &prof_thread_active_init_mtx);
		malloc_mutex_postfork_parent(tsdn, &next_thr_uid_mtx);
		malloc_mutex_postfork_parent(tsdn, &prof_gdump_mtx);
		malloc_mutex_postfork_parent(tsdn, &prof_dump_seq_mtx);
		malloc_mutex_postfork_parent(tsdn, &prof_active_mtx);
		for (i = 0; i < PROF_NCTX_LOCKS; i++)
			malloc_mutex_postfork_parent(tsdn, &gctx_locks[i]);
		for (i = 0; i < PROF_NTDATA_LOCKS; i++)
			malloc_mutex_postfork_parent(tsdn, &tdata_locks[i]);
		malloc_mutex_postfork_parent(tsdn, &tdatas_mtx);
		malloc_mutex_postfork_parent(tsdn, &bt2gctx_mtx);
		malloc_mutex_postfork_parent(tsdn, &prof_dump_mtx);
	}
}

// Assembly:
cmpb $0x1, 0x1d529(%rip)     # 0x4d1a0
jne 0x2fd36
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1d685(%rip), %rsi     # 0x4d310
callq 0x2e636
leaq 0x1d781(%rip), %rsi     # 0x4d418
movq %rbx, %rdi
callq 0x2e636
leaq 0x1d6c2(%rip), %rsi     # 0x4d368
movq %rbx, %rdi
callq 0x2e636
leaq 0x1d503(%rip), %rsi     # 0x4d1b8
movq %rbx, %rdi
callq 0x2e636
leaq 0x1d5f4(%rip), %rsi     # 0x4d2b8
movq %rbx, %rdi
callq 0x2e636
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e636
addq $0x50, %r14
cmpq $0x14000, %r14          # imm = 0x14000
jne 0x2fccf
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e636
addq $0x50, %r14
cmpq $0x5000, %r14           # imm = 0x5000
jne 0x2fcea
leaq 0x1d54f(%rip), %rsi     # 0x4d258
movq %rbx, %rdi
callq 0x2e636
leaq 0x1d6a8(%rip), %rsi     # 0x4d3c0
movq %rbx, %rdi
callq 0x2e636
leaq 0x1d4e1(%rip), %rsi     # 0x4d208
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e636
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: je_prof_postfork_child
void
prof_postfork_child(tsdn_t *tsdn)
{

	if (opt_prof) {
		unsigned i;

		malloc_mutex_postfork_child(tsdn, &prof_thread_active_init_mtx);
		malloc_mutex_postfork_child(tsdn, &next_thr_uid_mtx);
		malloc_mutex_postfork_child(tsdn, &prof_gdump_mtx);
		malloc_mutex_postfork_child(tsdn, &prof_dump_seq_mtx);
		malloc_mutex_postfork_child(tsdn, &prof_active_mtx);
		for (i = 0; i < PROF_NCTX_LOCKS; i++)
			malloc_mutex_postfork_child(tsdn, &gctx_locks[i]);
		for (i = 0; i < PROF_NTDATA_LOCKS; i++)
			malloc_mutex_postfork_child(tsdn, &tdata_locks[i]);
		malloc_mutex_postfork_child(tsdn, &tdatas_mtx);
		malloc_mutex_postfork_child(tsdn, &bt2gctx_mtx);
		malloc_mutex_postfork_child(tsdn, &prof_dump_mtx);
	}
}

// Assembly:
cmpb $0x1, 0x1d462(%rip)     # 0x4d1a0
jne 0x2fdfd
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1d5be(%rip), %rsi     # 0x4d310
callq 0x2e63e
leaq 0x1d6ba(%rip), %rsi     # 0x4d418
movq %rbx, %rdi
callq 0x2e63e
leaq 0x1d5fb(%rip), %rsi     # 0x4d368
movq %rbx, %rdi
callq 0x2e63e
leaq 0x1d43c(%rip), %rsi     # 0x4d1b8
movq %rbx, %rdi
callq 0x2e63e
leaq 0x1d52d(%rip), %rsi     # 0x4d2b8
movq %rbx, %rdi
callq 0x2e63e
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e63e
addq $0x50, %r14
cmpq $0x14000, %r14          # imm = 0x14000
jne 0x2fd96
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e63e
addq $0x50, %r14
cmpq $0x5000, %r14           # imm = 0x5000
jne 0x2fdb1
leaq 0x1d488(%rip), %rsi     # 0x4d258
movq %rbx, %rdi
callq 0x2e63e
leaq 0x1d5e1(%rip), %rsi     # 0x4d3c0
movq %rbx, %rdi
callq 0x2e63e
leaq 0x1d41a(%rip), %rsi     # 0x4d208
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e63e
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/quarantine.c
// Function: je_quarantine_alloc_hook_work
void
quarantine_alloc_hook_work(tsd_t *tsd)
{
	quarantine_t *quarantine;

	if (!tsd_nominal(tsd))
		return;

	quarantine = quarantine_init(tsd_tsdn(tsd), LG_MAXOBJS_INIT);
	/*
	 * Check again whether quarantine has been initialized, because
	 * quarantine_init() may have triggered recursive initialization.
	 */
	if (tsd_quarantine_get(tsd) == NULL)
		tsd_quarantine_set(tsd, quarantine);
	else
		idalloctm(tsd_tsdn(tsd), quarantine, NULL, true, true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x1, (%rdi)
je 0x2fed4
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdi, %rbx
movl $0xa, %esi
callq 0x1150b
movq %rax, %r14
cmpq $0x0, 0x50(%rbx)
je 0x2ffa7
movq %rax, %r15
leaq 0x1d1d7(%rip), %r13     # 0x4d0d0
movq (%r13), %rax
notq %rax
andq %r15, %rax
cmpq %rax, %r15
je 0x2ffb0
movq (%rax), %r12
movq (%r13), %rax
notq %rax
andq %r15, %rax
movq %r15, %rcx
subq %rax, %rcx
je 0x2ffc0
shrq $0xc, %rcx
leaq 0x1d090(%rip), %rdx     # 0x4cfc0
subq (%rdx), %rcx
movq 0x78(%rax,%rcx,8), %rax
movl %eax, %ecx
shrl $0x5, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
je 0x2ffe1
movl %ecx, %eax
leaq 0xb6eb(%rip), %rcx      # 0x3b640
movq (%rcx,%rax,8), %rax
negq %rax
lock
xaddq %rax, 0x90(%r12)
movq (%r13), %rdx
notq %rdx
andq %r15, %rdx
subq %rdx, %r15
je 0x2ffcd
shrq $0xc, %r15
leaq 0x1d040(%rip), %rax     # 0x4cfc0
movq %r15, %rcx
subq (%rax), %rcx
testb $0x2, 0x78(%rdx,%rcx,8)
movq (%rdx), %rsi
movq %rbx, %rdi
movq %r14, %rcx
jne 0x2fff5
movq %r15, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xdf6b
movq %r14, 0x50(%rbx)
jmp 0x2feca
movq %r14, %rdi
callq 0x2e39f
movq %rax, %r12
jmp 0x2ff0f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e4e2
jmp 0x2ff59
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x11227
shrq %rax
andq $-0x1000, %rax          # imm = 0xF000
addq $-0x1000, %rax          # imm = 0xF000
jmp 0x2ff59
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xdfd3
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/quarantine.c
// Function: je_quarantine_cleanup
void
quarantine_cleanup(tsd_t *tsd)
{
	quarantine_t *quarantine;

	if (!config_fill)
		return;

	quarantine = tsd_quarantine_get(tsd);
	if (quarantine != NULL) {
		quarantine_drain(tsd_tsdn(tsd), quarantine, 0);
		idalloctm(tsd_tsdn(tsd), quarantine, NULL, true, true);
		tsd_quarantine_set(tsd, NULL);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x50(%rdi), %r14
testq %r14, %r14
je 0x304a7
movq %rdi, %rbx
cmpq $0x0, (%r14)
je 0x303f4
cmpq $0x0, 0x8(%r14)
je 0x303f4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x304f8
jmp 0x303da
leaq 0x1ccd5(%rip), %r12     # 0x4d0d0
movq (%r12), %rax
notq %rax
andq %r14, %rax
cmpq %rax, %r14
je 0x304b3
movq (%rax), %r15
movq (%r12), %rax
notq %rax
andq %r14, %rax
movq %r14, %rcx
subq %rax, %rcx
je 0x304c3
shrq $0xc, %rcx
leaq 0x1cb8e(%rip), %rdx     # 0x4cfc0
subq (%rdx), %rcx
movq 0x78(%rax,%rcx,8), %rax
movl %eax, %ecx
shrl $0x5, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
je 0x304dd
movl %ecx, %eax
leaq 0xb1e9(%rip), %rcx      # 0x3b640
movq (%rcx,%rax,8), %rax
negq %rax
lock
xaddq %rax, 0x90(%r15)
movq (%r12), %rdx
notq %rdx
andq %r14, %rdx
movq %r14, %r8
subq %rdx, %r8
je 0x304d0
shrq $0xc, %r8
leaq 0x1cb3c(%rip), %rax     # 0x4cfc0
movq %r8, %rcx
subq (%rax), %rcx
testb $0x2, 0x78(%rdx,%rcx,8)
movq (%rdx), %rsi
movq %rbx, %rdi
movq %r14, %rcx
jne 0x304f1
callq 0xdf6b
movq $0x0, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x2e39f
movq %rax, %r15
jmp 0x30411
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e4e2
jmp 0x3045b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11227
jmp 0x3049f
shrq %rax
andq $-0x1000, %rax          # imm = 0xF000
addq $-0x1000, %rax          # imm = 0xF000
jmp 0x3045b
callq 0xdfd3
jmp 0x3049f
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/quarantine.c
// Function: quarantine_drain_one
static void
quarantine_drain_one(tsdn_t *tsdn, quarantine_t *quarantine)
{
	quarantine_obj_t *obj = &quarantine->objs[quarantine->first];
	assert(obj->usize == isalloc(tsdn, obj->ptr, config_prof));
	idalloctm(tsdn, obj->ptr, NULL, false, true);
	quarantine->curbytes -= obj->usize;
	quarantine->curobjs--;
	quarantine->first = (quarantine->first + 1) & ((ZU(1) <<
	    quarantine->lg_maxobjs) - 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rsi), %rax
shlq $0x4, %rax
leaq (%rsi,%rax), %r14
addq $0x20, %r14
movq (%r14), %rcx
leaq 0x1cbb7(%rip), %rax     # 0x4d0d0
movq (%rax), %rdx
notq %rdx
andq %rcx, %rdx
movq %rcx, %r8
subq %rdx, %r8
je 0x3057b
shrq $0xc, %r8
leaq 0x1ca8b(%rip), %rax     # 0x4cfc0
movq %r8, %rsi
subq (%rax), %rsi
testb $0x2, 0x78(%rdx,%rsi,8)
movq (%rdx), %rsi
jne 0x30585
callq 0xdf6b
movq 0x8(%r14), %rax
subq %rax, (%rbx)
decq 0x8(%rbx)
movq 0x10(%rbx), %rax
movb 0x18(%rbx), %cl
movq $-0x1, %rdx
shlq %cl, %rdx
incq %rax
notq %rdx
andq %rax, %rdx
movq %rdx, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rcx, %rsi
callq 0x11227
jmp 0x3054a
callq 0xdfd3
jmp 0x3054a
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/rtree.c
// Function: je_rtree_new
bool
rtree_new(rtree_t *rtree, unsigned bits, rtree_node_alloc_t *alloc,
    rtree_node_dalloc_t *dalloc)
{
	unsigned bits_in_leaf, height, i;

	assert(RTREE_HEIGHT_MAX == ((ZU(1) << (LG_SIZEOF_PTR+3)) /
	    RTREE_BITS_PER_LEVEL));
	assert(bits > 0 && bits <= (sizeof(uintptr_t) << 3));

	bits_in_leaf = (bits % RTREE_BITS_PER_LEVEL) == 0 ? RTREE_BITS_PER_LEVEL
	    : (bits % RTREE_BITS_PER_LEVEL);
	if (bits > bits_in_leaf) {
		height = 1 + (bits - bits_in_leaf) / RTREE_BITS_PER_LEVEL;
		if ((height-1) * RTREE_BITS_PER_LEVEL + bits_in_leaf != bits)
			height++;
	} else
		height = 1;
	assert((height-1) * RTREE_BITS_PER_LEVEL + bits_in_leaf == bits);

	rtree->alloc = alloc;
	rtree->dalloc = dalloc;
	rtree->height = height;

	/* Root level. */
	rtree->levels[0].subtree = NULL;
	rtree->levels[0].bits = (height > 1) ? RTREE_BITS_PER_LEVEL :
	    bits_in_leaf;
	rtree->levels[0].cumbits = rtree->levels[0].bits;
	/* Interior levels. */
	for (i = 1; i < height-1; i++) {
		rtree->levels[i].subtree = NULL;
		rtree->levels[i].bits = RTREE_BITS_PER_LEVEL;
		rtree->levels[i].cumbits = rtree->levels[i-1].cumbits +
		    RTREE_BITS_PER_LEVEL;
	}
	/* Leaf level. */
	if (height > 1) {
		rtree->levels[height-1].subtree = NULL;
		rtree->levels[height-1].bits = bits_in_leaf;
		rtree->levels[height-1].cumbits = bits;
	}

	/* Compute lookup table to be used by rtree_start_level(). */
	for (i = 0; i < RTREE_HEIGHT_MAX; i++) {
		rtree->start_level[i] = hmin(RTREE_HEIGHT_MAX - 1 - i, height -
		    1);
	}

	return (false);
}

// Assembly:
movl %esi, %eax
andl $0xf, %eax
movl $0x10, %r9d
cmovel %r9d, %eax
movl $0x1, %r8d
movl %esi, %r10d
subl %eax, %r10d
jbe 0x305c8
movl %r10d, %r8d
shrl $0x4, %r8d
andl $-0x10, %r10d
addl %eax, %r10d
xorl %r11d, %r11d
cmpl %esi, %r10d
sete %r11b
subl %r11d, %r8d
addl $0x2, %r8d
movq %rdx, (%rdi)
movq %rcx, 0x8(%rdi)
movl %r8d, 0x10(%rdi)
movq $0x0, 0x28(%rdi)
cmpl $0x2, %r8d
cmovbl %eax, %r9d
movl %r9d, 0x30(%rdi)
movl %r9d, 0x34(%rdi)
leal -0x1(%r8), %ecx
movl %ecx, %edx
cmpl $0x2, %ecx
jb 0x30622
leaq 0x44(%rdi), %r9
leaq -0x1(%rdx), %r10
movq $0x0, -0xc(%r9)
movl $0x10, -0x4(%r9)
movl -0x10(%r9), %r11d
addl $0x10, %r11d
movl %r11d, (%r9)
addq $0x10, %r9
decq %r10
jne 0x305fe
cmpl $0x2, %r8d
jb 0x30642
leaq 0x28(%rdi), %r8
shlq $0x4, %rdx
movq $0x0, (%r8,%rdx)
movl %eax, 0x8(%r8,%rdx)
movl %esi, 0xc(%r8,%rdx)
movl $0x3, %eax
xorl %edx, %edx
cmpl %ecx, %eax
movl %ecx, %esi
cmovbl %eax, %esi
movl %esi, 0x14(%rdi,%rdx,4)
incq %rdx
decl %eax
cmpq $0x4, %rdx
jne 0x30649
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/rtree.c
// Function: je_rtree_delete
void
rtree_delete(rtree_t *rtree)
{
	unsigned i;

	for (i = 0; i < rtree->height; i++) {
		rtree_node_elm_t *subtree = rtree->levels[i].subtree;
		if (subtree != NULL)
			rtree_delete_subtree(rtree, subtree, i);
	}
}

// Assembly:
cmpl $0x0, 0x10(%rdi)
je 0x3069e
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x28(%rdi), %r15
xorl %r14d, %r14d
movq (%r15), %rsi
testq %rsi, %rsi
je 0x3068a
movq %rbx, %rdi
movl %r14d, %edx
callq 0x3069f
incq %r14
movl 0x10(%rbx), %eax
addq $0x10, %r15
cmpq %rax, %r14
jb 0x30677
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/rtree.c
// Function: rtree_delete_subtree
static void
rtree_delete_subtree(rtree_t *rtree, rtree_node_elm_t *node, unsigned level)
{

	if (level + 1 < rtree->height) {
		size_t nchildren, i;

		nchildren = ZU(1) << rtree->levels[level].bits;
		for (i = 0; i < nchildren; i++) {
			rtree_node_elm_t *child = node[i].child;
			if (child != NULL)
				rtree_delete_subtree(rtree, child, level + 1);
		}
	}
	rtree->dalloc(node);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
leal 0x1(%rdx), %ebp
movq %rdi, %r12
cmpl 0x10(%rdi), %ebp
jae 0x306eb
movl %edx, %eax
shlq $0x4, %rax
movl 0x30(%r12,%rax), %r14d
movl $0x1, %r15d
movq -0x8(%rbx,%r15,8), %rsi
testq %rsi, %rsi
je 0x306da
movq %r12, %rdi
movl %ebp, %edx
callq 0x3069f
movq %r15, %rax
movl %r14d, %ecx
shrq %cl, %rax
incq %r15
testq %rax, %rax
je 0x306c6
movq %rbx, %rdi
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *0x8(%rax)
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/rtree.c
// Function: rtree_node_init
static rtree_node_elm_t *
rtree_node_init(rtree_t *rtree, unsigned level, rtree_node_elm_t **elmp)
{
	rtree_node_elm_t *node;

	if (atomic_cas_p((void **)elmp, NULL, RTREE_NODE_INITIALIZING)) {
		spin_t spinner;

		/*
		 * Another thread is already in the process of initializing.
		 * Spin-wait until initialization is complete.
		 */
		spin_init(&spinner);
		do {
			spin_adaptive(&spinner);
			node = atomic_read_p((void **)elmp);
		} while (node == RTREE_NODE_INITIALIZING);
	} else {
		node = rtree->alloc(ZU(1) << rtree->levels[level].bits);
		if (node == NULL)
			return (NULL);
		atomic_write_p((void **)elmp, node);
	}

	return (node);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %rdx
xorl %ecx, %ecx
movl $0x1, %edi
xorl %eax, %eax
lock
cmpxchgq %rdi, (%rbx)
sete %al
testb %al, %al
je 0x30748
movl %esi, %eax
shlq $0x4, %rax
movb 0x30(%rdx,%rax), %cl
shlq %cl, %rdi
callq *(%rdx)
testq %rax, %rax
je 0x30787
movq %rax, %rcx
xchgq %rcx, (%rbx)
jmp 0x30789
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl %ecx, %edx
shrq %cl, %rax
testq %rax, %rax
jne 0x30770
pause
incq 0x8(%rsp)
movq 0x8(%rsp), %rax
movl %edx, %ecx
jmp 0x30758
cmpl $0x3f, %edx
adcl $0x0, %edx
xorl %eax, %eax
lock
xaddq %rax, (%rbx)
movl %edx, %ecx
cmpq $0x1, %rax
je 0x30748
jmp 0x30789
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/tcache.c
// Function: je_tcache_event_hard
void
tcache_event_hard(tsd_t *tsd, tcache_t *tcache)
{
	szind_t binind = tcache->next_gc_bin;
	tcache_bin_t *tbin = &tcache->tbins[binind];
	tcache_bin_info_t *tbin_info = &tcache_bin_info[binind];

	if (tbin->low_water > 0) {
		/*
		 * Flush (ceiling) 3/4 of the objects below the low water mark.
		 */
		if (binind < NBINS) {
			tcache_bin_flush_small(tsd, tcache, tbin, binind,
			    tbin->ncached - tbin->low_water + (tbin->low_water
			    >> 2));
		} else {
			tcache_bin_flush_large(tsd, tbin, binind, tbin->ncached
			    - tbin->low_water + (tbin->low_water >> 2), tcache);
		}
		/*
		 * Reduce fill count by 2X.  Limit lg_fill_div such that the
		 * fill count is always at least 1.
		 */
		if ((tbin_info->ncached_max >> (tbin->lg_fill_div+1)) >= 1)
			tbin->lg_fill_div++;
	} else if (tbin->low_water < 0) {
		/*
		 * Increase fill count by 2X.  Make sure lg_fill_div stays
		 * greater than 0.
		 */
		if (tbin->lg_fill_div > 1)
			tbin->lg_fill_div--;
	}
	tbin->low_water = tbin->ncached;

	tcache->next_gc_bin++;
	if (tcache->next_gc_bin == nhbins)
		tcache->next_gc_bin = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x20(%rsi), %r15d
movq %r15, %rax
shlq $0x5, %rax
leaq (%rsi,%rax), %r14
addq $0x28, %r14
movl 0x8(%r14), %eax
testl %eax, %eax
jle 0x35103
movq 0x18396(%rip), %r12     # 0x4d478
movl %eax, %r8d
shrl $0x2, %r8d
subl %eax, %r8d
addl 0x10(%r14), %r8d
cmpl $0x26, %r15d
ja 0x35116
movq %r14, %rdx
movl %r15d, %ecx
callq 0x35162
jmp 0x35124
jns 0x35138
movl 0xc(%r14), %eax
cmpl $0x2, %eax
jb 0x35138
decl %eax
movl %eax, 0xc(%r14)
jmp 0x35138
movq %r14, %rsi
movl %r15d, %edx
movl %r8d, %ecx
callq 0x353a2
movl (%r12,%r15,4), %eax
movl 0xc(%r14), %ecx
incl %ecx
shrl %cl, %eax
testl %eax, %eax
je 0x35138
movl %ecx, 0xc(%r14)
movl 0x10(%r14), %eax
movl %eax, 0x8(%r14)
movl 0x20(%rbx), %eax
incl %eax
movl %eax, 0x20(%rbx)
xorl %ecx, %ecx
cmpl 0x18330(%rip), %eax     # 0x4d480
cmovnel %eax, %ecx
movl %ecx, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/tcache.c
// Function: je_tcache_alloc_small_hard
void *
tcache_alloc_small_hard(tsdn_t *tsdn, arena_t *arena, tcache_t *tcache,
    tcache_bin_t *tbin, szind_t binind, bool *tcache_success)
{
	void *ret;

	arena_tcache_fill_small(tsdn, arena, tbin, binind, config_prof ?
	    tcache->prof_accumbytes : 0);
	if (config_prof)
		tcache->prof_accumbytes = 0;
	ret = tcache_alloc_easy(tbin, tcache_success);

	return (ret);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %r14
movq %rcx, %rbx
movq %rcx, %rdx
movl %r8d, %ecx
xorl %r8d, %r8d
callq 0xcdad
movl 0x10(%rbx), %ecx
testq %rcx, %rcx
je 0x35616
movb $0x1, (%r14)
movq 0x18(%rbx), %rax
movq %rcx, %rdx
shlq $0x3, %rdx
negq %rdx
movq (%rax,%rdx), %rax
decl %ecx
movl %ecx, 0x10(%rbx)
cmpl 0x8(%rbx), %ecx
jl 0x35625
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xffffffff, 0x8(%rbx)  # imm = 0xFFFFFFFF
movb $0x0, (%r14)
xorl %eax, %eax
jmp 0x3560e
movl %ecx, 0x8(%rbx)
jmp 0x3560e
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/tcache.c
// Function: tcache_arena_dissociate
static void
tcache_arena_dissociate(tsdn_t *tsdn, tcache_t *tcache, arena_t *arena)
{

	if (config_stats) {
		/* Unlink from list of extant tcaches. */
		malloc_mutex_lock(tsdn, &arena->lock);
		if (config_debug) {
			bool in_ql = false;
			tcache_t *iter;
			ql_foreach(iter, &arena->tcache_ql, link) {
				if (iter == tcache) {
					in_ql = true;
					break;
				}
			}
			assert(in_ql);
		}
		ql_remove(&arena->tcache_ql, tcache, link);
		tcache_stats_merge(tsdn, tcache, arena);
		malloc_mutex_unlock(tsdn, &arena->lock);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x10(%rdx), %rbx
movq %rbx, %rdi
callq 0xb5a0
movq 0xe0(%r14), %rax
cmpq %r15, %rax
jne 0x35675
movq (%rax), %rax
movq %rax, 0xe0(%r14)
cmpq %r15, 0xe0(%r14)
je 0x35698
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq %rax, (%rcx)
movq (%r15), %rax
movq %rcx, 0x8(%rax)
movq %r15, (%r15)
movq %r15, 0x8(%r15)
jmp 0x356a3
movq $0x0, 0xe0(%r14)
movq %r15, %rsi
movq %r14, %rdx
callq 0x35aba
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/tcache.c
// Function: tcache_arena_associate
static void
tcache_arena_associate(tsdn_t *tsdn, tcache_t *tcache, arena_t *arena)
{

	if (config_stats) {
		/* Link into list of extant tcaches. */
		malloc_mutex_lock(tsdn, &arena->lock);
		ql_elm_new(tcache, link);
		ql_tail_insert(&arena->tcache_ql, tcache, link);
		malloc_mutex_unlock(tsdn, &arena->lock);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x10(%rsi), %r14
movq %r14, %rdi
callq 0xb5a0
movq %r15, (%r15)
movq %r15, 0x8(%r15)
movq 0xe0(%rbx), %rax
testq %rax, %rax
je 0x356f7
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%r15)
movq %rax, (%r15)
movq %r15, (%rcx)
movq %r15, 0x8(%rax)
movq (%r15), %rax
movq %rax, 0xe0(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/tcache.c
// Function: je_tcache_get_hard
tcache_t *
tcache_get_hard(tsd_t *tsd)
{
	arena_t *arena;

	if (!tcache_enabled_get()) {
		if (tsd_nominal(tsd))
			tcache_enabled_set(false); /* Memoize. */
		return (NULL);
	}
	arena = arena_choose(tsd, NULL);
	if (unlikely(arena == NULL))
		return (NULL);
	return (tcache_create(tsd_tsdn(tsd), arena));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x168cb(%rip), %r15     # 0x4bfe8
movq %fs:0x0, %rbx
addq %r15, %rbx
movl %fs:(%r15), %eax
testl %eax, %eax
je 0x357c9
cmpl $0x2, %eax
je 0x357d3
movl %fs:0x48(%r15), %eax
cmpl $0x2, %eax
jne 0x35754
movzbl 0x16cd1(%rip), %eax     # 0x4c420
movl %eax, %fs:0x48(%r15)
testl %eax, %eax
je 0x35773
movq 0x30(%r14), %rsi
testq %rsi, %rsi
je 0x357ba
testq %rsi, %rsi
je 0x357b2
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x11700
cmpl $0x1, (%r14)
jne 0x357b2
movl %fs:(%r15), %eax
testl %eax, %eax
je 0x35815
cmpl $0x2, %eax
je 0x3581f
movl $0x0, %fs:0x48(%r15)
movq %fs:0x8(%r15), %rsi
testq %rsi, %rsi
je 0x357b2
movq %rbx, %rdi
callq 0x3587a
movq $0x0, %fs:0x8(%r15)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
xorl %esi, %esi
callq 0x1b0d1
movq %rax, %rsi
jmp 0x35761
movl $0x1, %fs:(%r15)
jmp 0x357db
movl $0x3, %fs:(%r15)
leaq 0x17cf2(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %rbx, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x3573e
leaq 0x6986(%rip), %rdi      # 0x3c181
callq 0x35efc
leaq 0x16d19(%rip), %rax     # 0x4c520
cmpb $0x1, (%rax)
jne 0x3573e
callq 0xb070
movl $0x1, %fs:(%r15)
jmp 0x35827
movl $0x3, %fs:(%r15)
leaq 0x17ca6(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %rbx, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x3578e
leaq 0x693a(%rip), %rdi      # 0x3c181
callq 0x35efc
leaq 0x16ccd(%rip), %rax     # 0x4c520
cmpb $0x1, (%rax)
jne 0x3578e
jmp 0x35810
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/tcache.c
// Function: je_tcache_stats_merge
void
tcache_stats_merge(tsdn_t *tsdn, tcache_t *tcache, arena_t *arena)
{
	unsigned i;

	cassert(config_stats);

	malloc_mutex_assert_owner(tsdn, &arena->lock);

	/* Merge and reset tcache stats. */
	for (i = 0; i < NBINS; i++) {
		arena_bin_t *bin = &arena->bins[i];
		tcache_bin_t *tbin = &tcache->tbins[i];
		malloc_mutex_lock(tsdn, &bin->lock);
		bin->stats.nrequests += tbin->tstats.nrequests;
		malloc_mutex_unlock(tsdn, &bin->lock);
		tbin->tstats.nrequests = 0;
	}

	for (; i < nhbins; i++) {
		malloc_large_stats_t *lstats = &arena->stats.lstats[i - NBINS];
		tcache_bin_t *tbin = &tcache->tbins[i];
		arena->stats.nrequests_large += tbin->tstats.nrequests;
		lstats->nrequests += tbin->tstats.nrequests;
		tbin->tstats.nrequests = 0;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x980(%rdx), %r15
movl $0x28, %r12d
movq %r15, %rdi
callq 0xb5a0
movq (%r14,%r12), %rax
addq %rax, 0x70(%r15)
movq %r15, %rdi
callq 0xb380
movq $0x0, (%r14,%r12)
addq $0xa8, %r15
addq $0x20, %r12
cmpq $0x508, %r12            # imm = 0x508
jne 0x35ad5
movl 0x17971(%rip), %eax     # 0x4d480
cmpq $0x28, %rax
jb 0x35b5b
movq 0xb0(%rbx), %rcx
movq 0xd0(%rbx), %rdx
shlq $0x5, %rax
addq $-0x4e0, %rax           # imm = 0xFB20
xorl %esi, %esi
movq 0x508(%r14,%rsi), %rdi
addq %rdi, 0x10(%rdx,%rsi)
addq %rdi, %rcx
movq $0x0, 0x508(%r14,%rsi)
addq $0x20, %rsi
cmpq %rsi, %rax
jne 0x35b2f
movq %rcx, 0xb0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/tcache.c
// Function: je_tcaches_destroy
void
tcaches_destroy(tsd_t *tsd, unsigned ind)
{
	tcaches_t *elm = &tcaches[ind];
	tcaches_elm_flush(tsd, elm);
	elm->next = tcaches_avail;
	tcaches_avail = elm;
}

// Assembly:
pushq %rbx
movq 0x178ed(%rip), %rax     # 0x4d488
movl %esi, %ecx
leaq (%rax,%rcx,8), %rbx
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x35bb5
callq 0x3587a
movq $0x0, (%rbx)
movq 0x178d4(%rip), %rax     # 0x4d490
movq %rax, (%rbx)
movq %rbx, 0x178ca(%rip)     # 0x4d490
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/tcache.c
// Function: je_tcache_boot
bool
tcache_boot(tsdn_t *tsdn)
{
	unsigned i;

	/*
	 * If necessary, clamp opt_lg_tcache_max, now that large_maxclass is
	 * known.
	 */
	if (opt_lg_tcache_max < 0 || (ZU(1) << opt_lg_tcache_max) < SMALL_MAXCLASS)
		tcache_maxclass = SMALL_MAXCLASS;
	else if ((ZU(1) << opt_lg_tcache_max) > large_maxclass)
		tcache_maxclass = large_maxclass;
	else
		tcache_maxclass = (ZU(1) << opt_lg_tcache_max);

	nhbins = size2index(tcache_maxclass) + 1;

	/* Initialize tcache_bin_info. */
	tcache_bin_info = (tcache_bin_info_t *)base_alloc(tsdn, nhbins *
	    sizeof(tcache_bin_info_t));
	if (tcache_bin_info == NULL)
		return (true);
	stack_nelms = 0;
	for (i = 0; i < NBINS; i++) {
		if ((arena_bin_info[i].nregs << 1) <= TCACHE_NSLOTS_SMALL_MIN) {
			tcache_bin_info[i].ncached_max =
			    TCACHE_NSLOTS_SMALL_MIN;
		} else if ((arena_bin_info[i].nregs << 1) <=
		    TCACHE_NSLOTS_SMALL_MAX) {
			tcache_bin_info[i].ncached_max =
			    (arena_bin_info[i].nregs << 1);
		} else {
			tcache_bin_info[i].ncached_max =
			    TCACHE_NSLOTS_SMALL_MAX;
		}
		stack_nelms += tcache_bin_info[i].ncached_max;
	}
	for (; i < nhbins; i++) {
		tcache_bin_info[i].ncached_max = TCACHE_NSLOTS_LARGE;
		stack_nelms += tcache_bin_info[i].ncached_max;
	}

	return (false);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x16855(%rip), %rcx     # 0x4c428
testq %rcx, %rcx
sets %al
cmpq $0xe, %rcx
setb %dl
orb %al, %dl
movl $0x3800, %edi           # imm = 0x3800
jne 0x35c02
movl $0x1, %edi
shlq %cl, %rdi
leaq 0x173a8(%rip), %rax     # 0x4cfa0
movq (%rax), %rax
cmpq %rax, %rdi
cmovaeq %rax, %rdi
movq %rdi, 0x17897(%rip)     # 0x4d4a0
cmpq $0x1000, %rdi           # imm = 0x1000
ja 0x35cd5
decq %rdi
shrq $0x3, %rdi
leaq 0x619c(%rip), %rax      # 0x3bdc0
movzbl (%rax,%rdi), %esi
incl %esi
movl %esi, 0x17850(%rip)     # 0x4d480
shlq $0x2, %rsi
movq %rbx, %rdi
callq 0xff71
movq %rax, 0x17835(%rip)     # 0x4d478
testq %rax, %rax
je 0x35ccd
movl $0x0, 0x1782e(%rip)     # 0x4d484
leaq 0x16983(%rip), %rdx     # 0x4c5e0
addq $0x20, %rdx
xorl %esi, %esi
xorl %ecx, %ecx
movl (%rdx), %edi
addl %edi, %edi
cmpl $0x14, %edi
ja 0x35c77
movl $0x14, (%rax,%rsi,4)
jmp 0x35c8b
cmpl $0xc8, %edi
ja 0x35c84
movl %edi, (%rax,%rsi,4)
jmp 0x35c8b
movl $0xc8, (%rax,%rsi,4)
addl (%rax,%rsi,4), %ecx
incq %rsi
addq $0x40, %rdx
cmpq $0x27, %rsi
jne 0x35c65
movl %ecx, 0x177e3(%rip)     # 0x4d484
cmpl $0x28, 0x177d8(%rip)    # 0x4d480
jb 0x35ccd
movl $0x27, %edx
movl $0x14, (%rax,%rdx,4)
addl $0x14, %ecx
incq %rdx
movl 0x177be(%rip), %esi     # 0x4d480
cmpq %rsi, %rdx
jb 0x35caf
movl %ecx, 0x177b7(%rip)     # 0x4d484
testq %rax, %rax
sete %al
popq %rbx
retq
callq 0x11aed
movl %eax, %esi
jmp 0x35c28
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/tsd.c
// Function: je_tsd_cleanup
void
tsd_cleanup(void *arg)
{
	tsd_t *tsd = (tsd_t *)arg;

	switch (tsd->state) {
	case tsd_state_uninitialized:
		/* Do nothing. */
		break;
	case tsd_state_nominal:
#define	O(n, t)								\
		n##_cleanup(tsd);
MALLOC_TSD
#undef O
		tsd->state = tsd_state_purgatory;
		tsd_set(tsd);
		break;
	case tsd_state_purgatory:
		/*
		 * The previous time this destructor was called, we set the
		 * state to tsd_state_purgatory so that other destructors
		 * wouldn't cause re-creation of the tsd.  This time, do
		 * nothing, and do not request another callback.
		 */
		break;
	case tsd_state_reincarnated:
		/*
		 * Another destructor deallocated memory after this destructor
		 * was called.  Reset state to tsd_state_purgatory and request
		 * another callback.
		 */
		tsd->state = tsd_state_purgatory;
		tsd_set(tsd);
		break;
	default:
		not_reached();
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
leaq 0x8b4f(%rip), %rcx      # 0x3e86c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x3585e
movq %rbx, %rdi
callq 0x1b31a
movq %rbx, %rdi
callq 0x1b31b
movq %rbx, %rdi
callq 0x2fab9
movq %rbx, %rdi
callq 0x1b31c
movq %rbx, %rdi
callq 0x1b359
movq %rbx, %rdi
callq 0x1b393
movq %rbx, %rdi
callq 0x1b3b6
movq %rbx, %rdi
callq 0x1b3b7
movq %rbx, %rdi
callq 0x35ab9
movq %rbx, %rdi
callq 0x303c2
movq %rbx, %rdi
callq 0x370ba
movq %rbx, %rdi
callq 0x370bb
movl $0x2, (%rbx)
movq %fs:0x0, %rax
leaq -0x68(%rax), %rax
movl $0xd, %ecx
movq %rax, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl 0x1771c(%rip), %edi     # 0x4d4d4
movq %rax, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x35ddc
leaq 0x63b6(%rip), %rdi      # 0x3c181
callq 0x35efc
leaq 0x16749(%rip), %rax     # 0x4c520
cmpb $0x1, (%rax)
je 0x35dde
popq %rbx
retq
callq 0xb070
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/tsd.c
// Function: je_malloc_tsd_boot0
tsd_t *
malloc_tsd_boot0(void)
{
	tsd_t *tsd;

	ncleanups = 0;
	if (tsd_boot0())
		return (NULL);
	tsd = tsd_fetch();
	*tsd_arenas_tdata_bypassp_get(tsd) = true;
	return (tsd);
}

// Assembly:
pushq %rbx
movl $0x0, 0x176e2(%rip)     # 0x4d4d0
leaq 0x176df(%rip), %rdi     # 0x4d4d4
leaq -0xec(%rip), %rsi       # 0x35d10
callq 0xb220
testl %eax, %eax
je 0x35e09
xorl %ebx, %ebx
jmp 0x35e3a
movb $0x1, 0x176a0(%rip)     # 0x4d4b0
movq %fs:0x0, %rax
leaq -0x68(%rax), %rbx
movl %fs:-0x68, %eax
testl %eax, %eax
je 0x35e3f
cmpl $0x2, %eax
je 0x35e4d
movb $0x1, %fs:-0x24
movq %rbx, %rax
popq %rbx
retq
movl $0x1, %fs:-0x68
jmp 0x35e59
movl $0x3, %fs:-0x68
movl 0x17675(%rip), %edi     # 0x4d4d4
movq %rbx, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x35e31
leaq 0x630f(%rip), %rdi      # 0x3c181
callq 0x35efc
leaq 0x166a2(%rip), %rax     # 0x4c520
cmpb $0x1, (%rax)
jne 0x35e31
callq 0xb070