LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/ctl.c
// Function: stats_arenas_i_index
static const ctl_named_node_t *
stats_arenas_i_index(tsdn_t *tsdn, const size_t *mib, size_t miblen, size_t i)
{
	const ctl_named_node_t * ret;

	malloc_mutex_lock(tsdn, &ctl_mtx);
	if (i > ctl_stats.narenas || !ctl_stats.arenas[i].initialized) {
		ret = NULL;
		goto label_return;
	}

	ret = super_stats_arenas_i_node;
label_return:
	malloc_mutex_unlock(tsdn, &ctl_mtx);
	return (ret);
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
leaq 0x24097(%rip), %rdi     # 0x49100
callq 0xb5a0
movl 0x2410c(%rip), %eax     # 0x49180
cmpq %rbx, %rax
jae 0x2507d
xorl %ebx, %ebx
jmp 0x2509c
movq 0x24104(%rip), %rax     # 0x49188
imulq $0xbd8, %rbx, %rcx      # imm = 0xBD8
leaq 0x2248e(%rip), %rdx     # 0x47520
xorl %ebx, %ebx
cmpb $0x0, (%rax,%rcx)
cmovneq %rdx, %rbx
leaq 0x2405d(%rip), %rdi     # 0x49100
callq 0xb380
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/extent.c
// Function: extent_szsnad_comp
JEMALLOC_INLINE_C int
extent_szsnad_comp(const extent_node_t *a, const extent_node_t *b)
{
	int ret;

	ret = extent_sz_comp(a, b);
	if (ret != 0)
		return (ret);

	ret = extent_sn_comp(a, b);
	if (ret != 0)
		return (ret);

	ret = extent_ad_comp(a, b);
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0x28002
movq %rax, %r15
movq 0x10(%rbx), %rdi
callq 0x28002
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %r15
seta %al
sbbl $0x0, %eax
jne 0x26be9
movq 0x18(%r14), %rcx
xorl %eax, %eax
cmpq 0x18(%rbx), %rcx
seta %al
sbbl $0x0, %eax
jne 0x26be9
movq 0x8(%r14), %rcx
xorl %eax, %eax
cmpq 0x8(%rbx), %rcx
seta %al
sbbl $0x0, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/extent.c
// Function: extent_quantize
JEMALLOC_INLINE_C size_t
extent_quantize(size_t size)
{
	size_t ret;
	szind_t ind;

	assert(size > 0);

	ind = size2index(size + 1);
	if (ind == 0) {
		/* Avoid underflow. */
		return (index2size(0));
	}
	ret = index2size(ind - 1);
	assert(ret <= size);
	return (ret);
}

// Assembly:
leaq 0x1(%rdi), %rax
cmpq $0x1000, %rax           # imm = 0x1000
ja 0x2803b
shrq $0x3, %rdi
leaq 0xe9a7(%rip), %rax      # 0x369c0
movzbl (%rax,%rdi), %eax
testl %eax, %eax
je 0x28030
decl %eax
shlq $0x3, %rax
addq 0x1ff9a(%rip), %rax     # 0x47fc8
jmp 0x28037
leaq 0xe209(%rip), %rax      # 0x36240
movq (%rax), %rax
retq
movabsq $0x7000000000000000, %rcx # imm = 0x7000000000000000
cmpq %rcx, %rax
ja 0x28082
leaq -0x1(,%rax,2), %rax
bsrq %rax, %rax
xorl %ecx, %ecx
movl %eax, %edx
subl $0x5, %edx
cmovbl %ecx, %edx
movl %eax, %ecx
addb $-0x3, %cl
cmpl $0x6, %eax
movzbl %cl, %eax
pushq $0x3
popq %rcx
cmovael %eax, %ecx
shrq %cl, %rdi
shlq %cl, %rdi
shrq %cl, %rdi
andl $0x3, %edi
leal (%rdi,%rdx,4), %eax
jmp 0x2801d
movl $0xeb, %eax
jmp 0x28021
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/huge.c
// Function: je_huge_dalloc
void
huge_dalloc(tsdn_t *tsdn, void *ptr)
{
	extent_node_t *node;
	arena_t *arena;

	node = huge_node_get(ptr);
	arena = extent_node_arena_get(node);
	huge_node_unset(ptr, node);
	malloc_mutex_lock(tsdn, &arena->huge_mtx);
	ql_remove(&arena->huge, node, ql_link);
	malloc_mutex_unlock(tsdn, &arena->huge_mtx);

	huge_dalloc_junk(extent_node_addr_get(node),
	    extent_node_size_get(node));
	arena_chunk_dalloc_huge(tsdn, extent_node_arena_get(node),
	    extent_node_addr_get(node), extent_node_size_get(node),
	    extent_node_sn_get(node));
	idalloctm(tsdn, node, NULL, true, true);

	arena_decay_tick(tsdn, arena);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x291b0
movq %rax, %r15
movq (%rax), %r14
movq %r12, %rdi
movq %rax, %rsi
callq 0x21412
leaq 0x830(%r14), %r13
movq %r13, %rdi
callq 0xb5a0
movq 0x828(%r14), %rax
cmpq %r15, %rax
jne 0x29002
movq 0x50(%rax), %rax
movq %rax, 0x828(%r14)
movq %r15, %r12
cmpq %r15, %rax
je 0x2902d
movq 0x50(%r12), %rax
movq 0x58(%r12), %rcx
movq %rax, 0x50(%rcx)
movq 0x58(%r12), %rcx
movq %rcx, 0x58(%rax)
movq %r12, 0x50(%r12)
movq %r12, 0x58(%r12)
jmp 0x29035
andq $0x0, 0x828(%r14)
movq %r13, %rdi
callq 0xb380
leaq 0x1f4de(%rip), %rax     # 0x48522
cmpb $0x1, (%rax)
je 0x29136
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq 0x10(%r12), %rcx
movq 0x18(%r12), %r8
movq %rbx, %rdi
callq 0x1a145
leaq 0x20061(%rip), %rbp     # 0x490d0
movq (%rbp), %rax
notq %rax
andq %r15, %rax
movq %r15, %rcx
subq %rax, %rcx
je 0x2914d
movq (%rax), %r13
shrq $0xc, %rcx
leaq 0x1ff2d(%rip), %rdx     # 0x48fc0
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 0x29172
movl %ecx, %eax
leaq 0xd188(%rip), %rcx      # 0x36240
movq (%rcx,%rax,8), %rax
negq %rax
lock
xaddq %rax, 0x90(%r13)
movq (%rbp), %rdx
notq %rdx
andq %r15, %rdx
subq %rdx, %r15
je 0x29165
shrq $0xc, %r15
leaq 0x1feda(%rip), %rax     # 0x48fc0
movq %r15, %rcx
subq (%rax), %rcx
testb $0x2, 0x78(%rdx,%rcx,8)
movq (%rdx), %rsi
movq %rbx, %rdi
movq %r12, %rcx
jne 0x29186
movq %r15, %r8
callq 0x1ca94
testq %rbx, %rbx
je 0x29127
movl (%r14), %esi
movq %rbx, %rdi
callq 0x293fd
testq %rax, %rax
je 0x29127
movl (%rax), %ecx
testl %ecx, %ecx
jle 0x29190
decl %ecx
movl %ecx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r12), %rdi
movq 0x10(%r12), %rdx
pushq $0x5a
popq %rsi
callq 0xb230
jmp 0x2904d
movq %r12, %rdi
callq 0x28ce3
movq %rax, %r13
movq %r12, %rsi
callq 0x292e1
jmp 0x290bc
movq %rbx, %rdi
movq %r12, %rsi
callq 0x28fb2
jmp 0x29108
shrq %rax
andq $-0x1000, %rax          # imm = 0xF000
addq $-0x1000, %rax          # imm = 0xF000
jmp 0x290bc
callq 0x1cc1f
jmp 0x29108
movl 0x4(%rax), %ecx
movl %ecx, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1aac4
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/huge.c
// Function: huge_node_get
static extent_node_t *
huge_node_get(const void *ptr)
{
	extent_node_t *node;

	node = chunk_lookup(ptr, true);
	assert(!extent_node_achunk_get(node));

	return (node);
}

// Assembly:
pushq $-0x1
popq %rax
testq %rdi, %rdi
je 0x292af
bsrq %rdi, %rcx
shrl $0x4, %ecx
leaq 0x1fe96(%rip), %rsi     # 0x49060
movl 0x14(%rsi,%rcx,4), %ecx
movl 0x10(%rsi), %edx
movl %ecx, %r8d
shlq $0x4, %r8
movq 0x28(%rsi,%r8), %rsi
subl %edx, %ecx
addl $0x4, %ecx
leaq 0xe547(%rip), %r8       # 0x37730
movslq (%r8,%rcx,4), %rcx
addq %r8, %rcx
jmpq *%rcx
leal -0x4(%rdx), %r8d
shlq $0x4, %r8
leaq 0x1fe5f(%rip), %r9      # 0x49060
xorl %ecx, %ecx
subb 0x34(%r9,%r8), %cl
movq %rdi, %r10
shrq %cl, %r10
movb 0x30(%r9,%r8), %cl
movq %rax, %r8
shlq %cl, %r8
notq %r8
andq %r10, %r8
movq (%rsi,%r8,8), %rsi
leal -0x3(%rdx), %r8d
shlq $0x4, %r8
leaq 0x1fe2e(%rip), %r9      # 0x49060
xorl %ecx, %ecx
subb 0x34(%r9,%r8), %cl
movq %rdi, %r10
shrq %cl, %r10
movb 0x30(%r9,%r8), %cl
movq %rax, %r8
shlq %cl, %r8
notq %r8
andq %r10, %r8
movq (%rsi,%r8,8), %rsi
leal -0x2(%rdx), %r8d
shlq $0x4, %r8
leaq 0x1fdfd(%rip), %r9      # 0x49060
xorl %ecx, %ecx
subb 0x34(%r9,%r8), %cl
movq %rdi, %r10
shrq %cl, %r10
movb 0x30(%r9,%r8), %cl
movq %rax, %r8
shlq %cl, %r8
notq %r8
andq %r10, %r8
movq (%rsi,%r8,8), %rsi
decl %edx
shlq $0x4, %rdx
leaq 0x1fdce(%rip), %r8      # 0x49060
xorl %ecx, %ecx
subb 0x34(%r8,%rdx), %cl
shrq %cl, %rdi
movb 0x30(%r8,%rdx), %cl
shlq %cl, %rax
notq %rax
andq %rdi, %rax
movq (%rsi,%rax,8), %rax
retq
leaq 0x1fdaa(%rip), %rcx     # 0x49060
movl 0x10(%rcx), %edx
leal -0x1(%rdx), %r8d
movl %r8d, %esi
shlq $0x4, %rsi
movq 0x28(%rcx,%rsi), %rsi
subl %edx, %r8d
addl $0x4, %r8d
leaq 0xe459(%rip), %rcx      # 0x37730
movslq (%rcx,%r8,4), %r8
addq %rcx, %r8
jmpq *%r8
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x6
popq %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0xb140
imulq $0x3b9aca00, (%r14), %rax # imm = 0x3B9ACA00
addq 0x8(%r14), %rax
movq %rax, (%rbx)
cmpq %rax, %r15
ja 0x29569
cmpq %rax, %r15
seta %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %r15, (%rbx)
jmp 0x29559
nop
// File: /workspace/github_c_makefile_star2_O2/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, 0x1fb0e(%rip)     # 0x49198
jne 0x296c7
movq %rsi, %r14
movq %rdi, %r15
movzbl %dl, %eax
leal (%rax,%rax,2), %edx
movl 0x1fafe(%rip), %ecx     # 0x4919c
orl $0x10, %ecx
pushq $-0x1
popq %r8
xorl %r9d, %r9d
callq 0xb1a0
cmpq $-0x1, %rax
je 0x296c7
cmpq %r15, %rax
je 0x296c5
movq %rax, %rdi
movq %r14, %rsi
callq 0x295dc
jmp 0x296c7
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x1fa8e(%rip)    # 0x4919c
leaq 0xe080(%rip), %rsi      # 0x37795
pushq $0x2
popq %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0xb320
movq %rax, %rbx
cmpl $-0x1, %ebx
je 0x2976a
leaq 0x7(%rsp), %rdx
pushq $0x1
popq %rcx
xorl %edi, %edi
movl %ebx, %esi
xorl %eax, %eax
callq 0xb320
movq %rax, %r14
pushq $0x3
popq %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0xb320
testq %r14, %r14
jle 0x2976a
movb 0x7(%rsp), %al
andb $-0x2, %al
cmpb $0x30, %al
sete 0x1fa39(%rip)           # 0x49198
jne 0x29771
orb $0x40, 0x1fa35(%rip)    # 0x4919d
jmp 0x29771
movb $0x0, 0x1fa27(%rip)     # 0x49198
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x1f4d0(%rip), %rbx     # 0x49310
movq %rbx, %rdi
callq 0xb5a0
movb 0x1f511(%rip), %bpl     # 0x49360
movq %rbx, %rdi
callq 0xb380
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x29fe3
movq %r15, %rdi
callq 0xb190
testq %rax, %rax
je 0x29fe3
leaq 0x1(%rax), %r12
cmpq $0x1000, %r12           # imm = 0x1000
ja 0x29ead
shrq $0x3, %rax
leaq 0xcb19(%rip), %rcx      # 0x369c0
movzbl (%rcx,%rax), %ebp
jmp 0x29ef7
movl $0xeb, %ebp
movabsq $0x7000000000000000, %rcx # imm = 0x7000000000000000
cmpq %rcx, %r12
ja 0x29ef7
leaq -0x1(,%r12,2), %rcx
bsrq %rcx, %rcx
xorl %edx, %edx
movl %ecx, %esi
subl $0x5, %esi
cmovbl %edx, %esi
movl %ecx, %edx
addb $-0x3, %dl
cmpl $0x6, %ecx
movzbl %dl, %edx
pushq $0x3
popq %rcx
cmovael %edx, %ecx
shrq %cl, %rax
shlq %cl, %rax
shrq %cl, %rax
andl $0x3, %eax
leal (%rax,%rsi,4), %ebp
leaq 0x1e6b2(%rip), %rax     # 0x485b0
movq (%rax), %rax
movq (%rax), %rsi
testq %rsi, %rsi
jne 0x29f21
xorl %esi, %esi
lock
xaddq %rsi, (%rax)
testq %rsi, %rsi
jne 0x29f21
xorl %edi, %edi
xorl %esi, %esi
callq 0x12af5
movq %rax, %rsi
movq %r14, %rdi
movq %r12, %rdx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0x1bc0d
testq %rax, %rax
je 0x29fe3
movq %rax, %r13
leaq 0x1f18c(%rip), %rbp     # 0x490d0
movq (%rbp), %rax
notq %rax
andq %r13, %rax
cmpq %rax, %r13
jne 0x29f6a
movq %r13, %rdi
callq 0x28ce3
movq %rax, %rsi
movq (%rbp), %rax
notq %rax
andq %r13, %rax
jmp 0x29f6d
movq (%rax), %rsi
cmpq %rax, %r13
jne 0x29f85
movq %r14, %rdi
movq %rsi, %rbp
movq %r13, %rsi
callq 0x292e1
movq %rbp, %rsi
jmp 0x29fcc
movq %r13, %rcx
subq %rax, %rcx
shrq $0xc, %rcx
leaq 0x1f02a(%rip), %rdx     # 0x48fc0
subq (%rdx), %rcx
movq 0x78(%rax,%rcx,8), %rax
movl %eax, %ecx
shrl $0x5, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
jne 0x29fbf
shrq %rax
andq $-0x1000, %rax          # imm = 0xF000
addq $-0x1000, %rax          # imm = 0xF000
jmp 0x29fcc
movl %ecx, %eax
leaq 0xc278(%rip), %rcx      # 0x36240
movq (%rcx,%rax,8), %rax
lock
xaddq %rax, 0x90(%rsi)
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xb340
movq (%rbx), %rdi
callq 0xb5a0
cmpb $0x1, 0x20(%rbx)
jne 0x2a021
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2ab2b
testb %al, %al
je 0x2a018
andq $0x0, 0x20(%r14)
movq (%rbx), %rdi
callq 0xb380
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ab4f
movb $0x0, 0x20(%rbx)
andq $0x0, 0x20(%r14)
movq (%rbx), %rdi
callq 0xb380
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1f1c9(%rip), %rdi     # 0x49208
callq 0xb5a0
leaq 0x1f20d(%rip), %rdi     # 0x49258
callq 0xb5a0
movq %r14, 0x1f251(%rip)     # 0x492a8
xorl %r15d, %r15d
leaq 0x1f24f(%rip), %r13     # 0x492b0
movq 0x1f248(%rip), %rsi     # 0x492b0
testq %r15, %r15
je 0x2a07a
movq %r15, %rdi
movq %rbx, %rdx
callq 0x2aba5
jmp 0x2a085
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x2ac07
movq %rax, %r14
testq %rax, %rax
je 0x2a0e4
movq 0x30(%r14), %rax
andq $-0x2, %rax
je 0x2a0b5
movq %rax, %r15
movq 0x28(%rax), %rax
testq %rax, %rax
jne 0x2a097
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a14f
testq %r15, %r15
jne 0x2a061
jmp 0x2a0e4
movq %r13, %rax
xorl %r15d, %r15d
movq (%rax), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x2ab81
testl %eax, %eax
js 0x2a0da
je 0x2a0a3
movq 0x30(%r12), %r12
andq $-0x2, %r12
jmp 0x2a0be
leaq 0x28(%r12), %rax
movq %r12, %r15
jmp 0x2a0bb
leaq 0x1f16d(%rip), %rdi     # 0x49258
callq 0xb380
leaq 0x1f111(%rip), %rdi     # 0x49208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O2/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 0x1eacb(%rip), %rbx     # 0x492b8
movq %rbx, %rdi
callq 0xb5a0
movb 0x1eb0c(%rip), %bpl     # 0x49308
movq %rbx, %rdi
callq 0xb380
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1ea9e(%rip), %r14     # 0x492b8
movq %r14, %rdi
callq 0xb5a0
movb 0x1eadf(%rip), %bpl     # 0x49308
movb %bl, 0x1ead9(%rip)      # 0x49308
movq %r14, %rdi
callq 0xb380
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1eac5(%rip), %r14     # 0x49310
movq %r14, %rdi
callq 0xb5a0
movb 0x1eb06(%rip), %bpl     # 0x49360
movb %bl, 0x1eb00(%rip)      # 0x49360
movq %r14, %rdi
callq 0xb380
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1eaef(%rip), %rbx     # 0x49368
movq %rbx, %rdi
callq 0xb5a0
movb 0x1eb30(%rip), %bpl     # 0x493b8
movq %rbx, %rdi
callq 0xb380
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1eac2(%rip), %r14     # 0x49368
movq %r14, %rdi
callq 0xb5a0
movb 0x1eb03(%rip), %bpl     # 0x493b8
movb %bl, 0x1eafd(%rip)      # 0x493b8
movq %r14, %rdi
callq 0xb380
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x1e8cf(%rip)     # 0x491a0
jne 0x2a945
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1e927(%rip), %rsi     # 0x49208
callq 0x2946c
leaq 0x1ead3(%rip), %rsi     # 0x493c0
movq %rbx, %rdi
callq 0x2946c
leaq 0x1e95c(%rip), %rsi     # 0x49258
movq %rbx, %rdi
callq 0x2946c
xorl %r14d, %r14d
cmpq $0x5000, %r14           # imm = 0x5000
je 0x2a921
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2946c
addq $0x50, %r14
jmp 0x2a907
xorl %r14d, %r14d
cmpq $0x14000, %r14          # imm = 0x14000
je 0x2a93e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2946c
addq $0x50, %r14
jmp 0x2a924
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x1e853(%rip)     # 0x491a0
jne 0x2a99c
pushq %rbx
movq %rdi, %rbx
leaq 0x1e95e(%rip), %rsi     # 0x492b8
callq 0x2946c
leaq 0x1e852(%rip), %rsi     # 0x491b8
movq %rbx, %rdi
callq 0x2946c
leaq 0x1e9f3(%rip), %rsi     # 0x49368
movq %rbx, %rdi
callq 0x2946c
leaq 0x1ea94(%rip), %rsi     # 0x49418
movq %rbx, %rdi
callq 0x2946c
leaq 0x1e97d(%rip), %rsi     # 0x49310
movq %rbx, %rdi
popq %rbx
jmp 0x2946c
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x1e7fc(%rip)     # 0x491a0
jne 0x2aa12
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1e95c(%rip), %rsi     # 0x49310
callq 0x29474
leaq 0x1ea58(%rip), %rsi     # 0x49418
movq %rbx, %rdi
callq 0x29474
leaq 0x1e999(%rip), %rsi     # 0x49368
movq %rbx, %rdi
callq 0x29474
leaq 0x1e7da(%rip), %rsi     # 0x491b8
movq %rbx, %rdi
callq 0x29474
leaq 0x1e8cb(%rip), %rsi     # 0x492b8
movq %rbx, %rdi
callq 0x29474
xorl %r14d, %r14d
cmpq $0x14000, %r14          # imm = 0x14000
je 0x2aa13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29474
addq $0x50, %r14
jmp 0x2a9f8
retq
xorl %r14d, %r14d
cmpq $0x5000, %r14           # imm = 0x5000
je 0x2aa30
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29474
addq $0x50, %r14
jmp 0x2aa16
leaq 0x1e821(%rip), %rsi     # 0x49258
movq %rbx, %rdi
callq 0x29474
leaq 0x1e97a(%rip), %rsi     # 0x493c0
movq %rbx, %rdi
callq 0x29474
leaq 0x1e7b3(%rip), %rsi     # 0x49208
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x29474
// File: /workspace/github_c_makefile_star2_O2/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, 0x1e735(%rip)     # 0x491a0
jne 0x2aad9
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1e895(%rip), %rsi     # 0x49310
callq 0x2947c
leaq 0x1e991(%rip), %rsi     # 0x49418
movq %rbx, %rdi
callq 0x2947c
leaq 0x1e8d2(%rip), %rsi     # 0x49368
movq %rbx, %rdi
callq 0x2947c
leaq 0x1e713(%rip), %rsi     # 0x491b8
movq %rbx, %rdi
callq 0x2947c
leaq 0x1e804(%rip), %rsi     # 0x492b8
movq %rbx, %rdi
callq 0x2947c
xorl %r14d, %r14d
cmpq $0x14000, %r14          # imm = 0x14000
je 0x2aada
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2947c
addq $0x50, %r14
jmp 0x2aabf
retq
xorl %r14d, %r14d
cmpq $0x5000, %r14           # imm = 0x5000
je 0x2aaf7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2947c
addq $0x50, %r14
jmp 0x2aadd
leaq 0x1e75a(%rip), %rsi     # 0x49258
movq %rbx, %rdi
callq 0x2947c
leaq 0x1e8b3(%rip), %rsi     # 0x493c0
movq %rbx, %rdi
callq 0x2947c
leaq 0x1e6ec(%rip), %rsi     # 0x49208
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2947c
// File: /workspace/github_c_makefile_star2_O2/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)
jne 0x2ad30
movq %rdi, %rbx
pushq $0xa
popq %rsi
callq 0x2ad9a
movq %rax, %r14
cmpq $0x0, 0x50(%rbx)
je 0x2ad2c
movq %rax, %r15
leaq 0x1e44b(%rip), %r13     # 0x490d0
movq (%r13), %rax
notq %rax
andq %r15, %rax
cmpq %rax, %r15
je 0x2ad3a
movq (%rax), %r12
cmpq %rax, %r15
je 0x2ad54
movq %r15, %rcx
subq %rax, %rcx
shrq $0xc, %rcx
leaq 0x1e30b(%rip), %rdx     # 0x48fc0
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 0x2ad78
movl %ecx, %eax
leaq 0xb566(%rip), %rcx      # 0x36240
movq (%rcx,%rax,8), %rax
negq %rax
lock
xaddq %rax, 0x90(%r12)
movq (%r13), %rdx
notq %rdx
andq %r15, %rdx
subq %rdx, %r15
je 0x2ad64
shrq $0xc, %r15
leaq 0x1e2bb(%rip), %rax     # 0x48fc0
movq %r15, %rcx
subq (%rax), %rcx
testb $0x2, 0x78(%rdx,%rcx,8)
movq (%rdx), %rsi
movq %rbx, %rdi
movq %r14, %rcx
jne 0x2ad8c
movq %r15, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1ca94
movq %r14, 0x50(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x28ce3
movq %rax, %r12
movq (%r13), %rax
notq %rax
andq %r15, %rax
jmp 0x2ac9b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x292e1
jmp 0x2acde
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x28fb2
shrq %rax
andq $-0x1000, %rax          # imm = 0xF000
addq $-0x1000, %rax          # imm = 0xF000
jmp 0x2acde
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1cc1f
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/quarantine.c
// Function: quarantine_init
static quarantine_t *
quarantine_init(tsdn_t *tsdn, size_t lg_maxobjs)
{
	quarantine_t *quarantine;
	size_t size;

	size = offsetof(quarantine_t, objs) + ((ZU(1) << lg_maxobjs) *
	    sizeof(quarantine_obj_t));
	quarantine = (quarantine_t *)iallocztm(tsdn, size, size2index(size),
	    false, NULL, true, arena_get(TSDN_NULL, 0, true), true);
	if (quarantine == NULL)
		return (NULL);
	quarantine->curbytes = 0;
	quarantine->curobjs = 0;
	quarantine->first = 0;
	quarantine->lg_maxobjs = lg_maxobjs;

	return (quarantine);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
pushq $0x10
popq %rax
movl %ebx, %ecx
shlq %cl, %rax
movq %rdi, %r14
leaq 0x20(%rax), %r15
cmpq $0xfe0, %rax            # imm = 0xFE0
ja 0x2ae90
addq $0x1f, %rax
shrq $0x3, %rax
leaq 0xbbee(%rip), %rcx      # 0x369c0
movzbl (%rcx,%rax), %ebp
leaq 0x1d7d3(%rip), %rax     # 0x485b0
movq (%rax), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0x2aee2
movq %r14, %rdi
movq %r15, %rdx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0x1bc0d
movq %rax, %r15
testq %rax, %rax
je 0x2ae7e
leaq 0x1e2c5(%rip), %r13     # 0x490d0
movq (%r13), %rax
notq %rax
andq %r15, %rax
cmpq %rax, %r15
je 0x2af03
movq (%rax), %r12
cmpq %rax, %r15
je 0x2af1d
movq %r15, %rcx
subq %rax, %rcx
shrq $0xc, %rcx
leaq 0x1e185(%rip), %rdx     # 0x48fc0
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 0x2af2d
movl %ecx, %eax
leaq 0xb3e0(%rip), %rcx      # 0x36240
movq (%rcx,%rax,8), %rax
lock
xaddq %rax, 0x90(%r12)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
andq $0x0, 0x10(%r15)
movq %rbx, 0x18(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movabsq $0x6fffffffffffffe0, %rcx # imm = 0x6FFFFFFFFFFFFFE0
cmpq %rcx, %rax
ja 0x2af41
leaq -0x1(,%r15,2), %rcx
bsrq %rcx, %rcx
xorl %edx, %edx
movl %ecx, %esi
subl $0x5, %esi
cmovbl %edx, %esi
movl %ecx, %edx
addb $-0x3, %dl
cmpl $0x6, %ecx
movzbl %dl, %edx
pushq $0x3
popq %rcx
cmovael %edx, %ecx
addq $0x1f, %rax
shrq %cl, %rax
shlq %cl, %rax
shrq %cl, %rax
andl $0x3, %eax
leal (%rax,%rsi,4), %ebp
jmp 0x2add6
xorl %esi, %esi
lock
xaddq %rsi, (%rax)
testq %rsi, %rsi
jne 0x2adec
xorl %edi, %edi
xorl %esi, %esi
callq 0x12af5
movq %rax, %rsi
jmp 0x2adec
movq %r15, %rdi
callq 0x28ce3
movq %rax, %r12
movq (%r13), %rax
notq %rax
andq %r15, %rax
jmp 0x2ae21
movq %r14, %rdi
movq %r15, %rsi
callq 0x292e1
jmp 0x2ae64
shrq %rax
andq $-0x1000, %rax          # imm = 0xF000
addq $-0x1000, %rax          # imm = 0xF000
jmp 0x2ae64
movl $0xeb, %ebp
jmp 0x2add6
// File: /workspace/github_c_makefile_star2_O2/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 0x2b431
movq %rdi, %rbx
movq %r14, %rsi
xorl %edx, %edx
callq 0x2b339
leaq 0x1dd41(%rip), %r12     # 0x490d0
movq (%r12), %rax
notq %rax
andq %r14, %rax
cmpq %rax, %r14
je 0x2b43d
movq (%rax), %r15
cmpq %rax, %r14
je 0x2b457
movq %r14, %rcx
subq %rax, %rcx
shrq $0xc, %rcx
leaq 0x1dc01(%rip), %rdx     # 0x48fc0
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 0x2b471
movl %ecx, %eax
leaq 0xae5c(%rip), %rcx      # 0x36240
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 0x2b464
shrq $0xc, %r8
leaq 0x1dbaf(%rip), %rax     # 0x48fc0
movq %r8, %rcx
subq (%rax), %rcx
testb $0x2, 0x78(%rdx,%rcx,8)
movq (%rdx), %rsi
movq %rbx, %rdi
movq %r14, %rcx
jne 0x2b485
callq 0x1ca94
andq $0x0, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x28ce3
movq %rax, %r15
movq (%r12), %rax
notq %rax
andq %r14, %rax
jmp 0x2b3a5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x292e1
jmp 0x2b3e8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28fb2
jmp 0x2b42c
shrq %rax
andq $-0x1000, %rax          # imm = 0xF000
addq $-0x1000, %rax          # imm = 0xF000
jmp 0x2b3e8
callq 0x1cc1f
jmp 0x2b42c
// File: /workspace/github_c_makefile_star2_O2/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 0x1dc23(%rip), %rax     # 0x490d0
movq (%rax), %rdx
notq %rdx
andq %rcx, %rdx
movq %rcx, %r8
subq %rdx, %r8
je 0x2b50b
shrq $0xc, %r8
leaq 0x1daf7(%rip), %rax     # 0x48fc0
movq %r8, %rsi
subq (%rax), %rsi
testb $0x2, 0x78(%rdx,%rsi,8)
movq (%rdx), %rsi
jne 0x2b515
callq 0x1ca94
movq 0x8(%r14), %rax
subq %rax, (%rbx)
decq 0x8(%rbx)
movq 0x10(%rbx), %rax
movb 0x18(%rbx), %cl
pushq $-0x1
popq %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 0x28fb2
jmp 0x2b4de
callq 0x1cc1f
jmp 0x2b4de
// File: /workspace/github_c_makefile_star2_O2/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 0x1b426
movl 0x10(%rbx), %ecx
testq %rcx, %rcx
je 0x305d9
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 0x305e5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
orl $-0x1, 0x8(%rbx)
movb $0x0, (%r14)
xorl %eax, %eax
jmp 0x305d1
movl %ecx, 0x8(%rbx)
jmp 0x305d1
// File: /workspace/github_c_makefile_star2_O2/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 0x3063c
movq (%rax), %rax
movq %rax, 0xe0(%r14)
cmpq %r15, %rax
je 0x30658
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
movq %r15, (%r15)
movq %r15, 0x8(%r15)
jmp 0x30660
andq $0x0, 0xe0(%r14)
movq %r15, %rsi
movq %r14, %rdx
callq 0x30d23
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O2/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 0x306b7
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%r15)
movq %rax, (%r15)
movq %r15, (%rcx)
movq %r15, 0x8(%rax)
movq (%r15), %r15
movq %r15, 0xe0(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x28
popq %r12
cmpq $0x508, %r12            # imm = 0x508
je 0x30d6f
movq %r15, %rdi
callq 0xb5a0
movq (%r14,%r12), %rax
addq %rax, 0x70(%r15)
movq %r15, %rdi
callq 0xb380
andq $0x0, (%r14,%r12)
addq $0x20, %r12
addq $0xa8, %r15
jmp 0x30d3c
movl 0x1870b(%rip), %eax     # 0x49480
pushq $0x27
popq %rcx
xorl %edx, %edx
cmpq %rax, %rcx
jae 0x30dac
movq 0xd0(%rbx), %rsi
movq 0x508(%r14,%rdx), %rdi
addq %rdi, 0xb0(%rbx)
addq %rdi, 0x10(%rsi,%rdx)
andq $0x0, 0x508(%r14,%rdx)
incq %rcx
addq $0x20, %rdx
jmp 0x30d7a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/tcache.c
// Function: je_tcaches_create
bool
tcaches_create(tsd_t *tsd, unsigned *r_ind)
{
	arena_t *arena;
	tcache_t *tcache;
	tcaches_t *elm;

	if (tcaches == NULL) {
		tcaches = base_alloc(tsd_tsdn(tsd), sizeof(tcache_t *) *
		    (MALLOCX_TCACHE_MAX+1));
		if (tcaches == NULL)
			return (true);
	}

	if (tcaches_avail == NULL && tcaches_past > MALLOCX_TCACHE_MAX)
		return (true);
	arena = arena_ichoose(tsd, NULL);
	if (unlikely(arena == NULL))
		return (true);
	tcache = tcache_create(tsd_tsdn(tsd), arena);
	if (tcache == NULL)
		return (true);

	if (tcaches_avail != NULL) {
		elm = tcaches_avail;
		tcaches_avail = tcaches_avail->next;
		elm->tcache = tcache;
		*r_ind = (unsigned)(elm - tcaches);
	} else {
		elm = &tcaches[tcaches_past];
		elm->tcache = tcache;
		*r_ind = tcaches_past;
		tcaches_past++;
	}

	return (false);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x186be(%rip)     # 0x49488
jne 0x30de5
movl $0x7ff0, %esi           # imm = 0x7FF0
movq %r14, %rdi
callq 0x20d5c
movq %rax, 0x186a8(%rip)     # 0x49488
testq %rax, %rax
je 0x30e46
cmpq $0x0, 0x186a3(%rip)     # 0x49490
movb $0x1, %bpl
jne 0x30dfe
cmpl $0xffd, 0x1869c(%rip)   # imm = 0xFFD
ja 0x30e69
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3101e
testq %rax, %rax
je 0x30e69
movq %r14, %rdi
movq %rax, %rsi
callq 0x307e8
testq %rax, %rax
je 0x30e69
movq 0x1866b(%rip), %rcx     # 0x49490
testq %rcx, %rcx
je 0x30e4b
movq (%rcx), %rdx
movq %rdx, 0x1865c(%rip)     # 0x49490
movq %rax, (%rcx)
subq 0x1864a(%rip), %rcx     # 0x49488
shrq $0x3, %rcx
movl %ecx, (%rbx)
jmp 0x30e67
movb $0x1, %bpl
jmp 0x30e69
movq 0x18636(%rip), %rcx     # 0x49488
movl 0x18640(%rip), %edx     # 0x49498
movq %rax, (%rcx,%rdx,8)
movl %edx, (%rbx)
leal 0x1(%rdx), %eax
movl %eax, 0x18631(%rip)     # 0x49498
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x17562(%rip), %rcx     # 0x48428
cmpq $0xd, %rcx
jg 0x30f17
movq $0x3800, 0x185c9(%rip) # imm = 0x3800
movl $0x3800, %eax           # imm = 0x3800
leaq -0x1(,%rax,2), %rcx
bsrq %rcx, %rcx
xorl %edx, %edx
movl %ecx, %esi
subl $0x5, %esi
cmovbl %edx, %esi
movl %ecx, %edx
addb $-0x3, %dl
cmpl $0x6, %ecx
movzbl %dl, %edx
pushq $0x3
popq %rcx
cmovael %edx, %ecx
decq %rax
shrq %cl, %rax
shlq %cl, %rax
shrq %cl, %rax
andl $0x3, %eax
leal (%rax,%rsi,4), %esi
jmp 0x30f53
pushq $0x1
popq %rax
shlq %cl, %rax
leaq 0x1807c(%rip), %rcx     # 0x48fa0
movq (%rcx), %rcx
cmpq %rcx, %rax
cmovaeq %rcx, %rax
movq %rax, 0x1856b(%rip)     # 0x494a0
cmpq $0x1000, %rax           # imm = 0x1000
ja 0x31001
decq %rax
shrq $0x3, %rax
leaq 0x5a71(%rip), %rcx      # 0x369c0
movzbl (%rcx,%rax), %esi
pushq %rax
incl %esi
movl %esi, 0x18524(%rip)     # 0x49480
shlq $0x2, %rsi
callq 0x20d5c
movq %rax, 0x1850c(%rip)     # 0x49478
testq %rax, %rax
je 0x30ff9
leaq 0x17664(%rip), %rdx     # 0x485e0
addq $0x20, %rdx
xorl %esi, %esi
pushq $0x14
popq %rdi
xorl %ecx, %ecx
cmpq $0x27, %rsi
je 0x30fcd
movl (%rdx), %r8d
addl %r8d, %r8d
cmpl $0x14, %r8d
ja 0x30fa5
movl $0x14, (%rax,%rsi,4)
movl %edi, %r8d
jmp 0x30fc1
cmpl $0xc8, %r8d
ja 0x30fb4
movl %r8d, (%rax,%rsi,4)
jmp 0x30fc1
movl $0xc8, (%rax,%rsi,4)
movl $0xc8, %r8d
addl %r8d, %ecx
incq %rsi
addq $0x40, %rdx
jmp 0x30f87
movl %ecx, 0x184b1(%rip)     # 0x49484
addl $0x14, %ecx
pushq $0x27
popq %rdx
movl 0x184a1(%rip), %esi     # 0x49480
cmpq %rsi, %rdx
jae 0x30ff9
movl $0x14, (%rax,%rdx,4)
movl %ecx, 0x18493(%rip)     # 0x49484
incq %rdx
addl $0x14, %ecx
jmp 0x30fd9
testq %rax, %rax
sete %al
popq %rcx
retq
movl $0xeb, %esi
movabsq $0x7000000000000000, %rcx # imm = 0x7000000000000000
cmpq %rcx, %rax
ja 0x30f53
jmp 0x30edc
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0x18373(%rip)     # 0x494d0
leaq 0x18370(%rip), %rdi     # 0x494d4
leaq -0xe7(%rip), %rsi       # 0x31084
callq 0xb220
testl %eax, %eax
je 0x31178
xorl %ebx, %ebx
jmp 0x311a9
movb $0x1, 0x18331(%rip)     # 0x494b0
movq %fs:0x0, %rax
leaq -0x68(%rax), %rbx
movl %fs:-0x68, %eax
testl %eax, %eax
je 0x311ae
cmpl $0x2, %eax
je 0x311bc
movb $0x1, %fs:-0x24
movq %rbx, %rax
popq %rbx
retq
movl $0x1, %fs:-0x68
jmp 0x311c8
movl $0x3, %fs:-0x68
movl 0x18306(%rip), %edi     # 0x494d4
movq %rbx, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x311a0
leaq 0x5ba0(%rip), %rdi      # 0x36d81
callq 0x3126c
leaq 0x17333(%rip), %rax     # 0x48520
cmpb $0x1, (%rax)
jne 0x311a0
callq 0xb070
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/util.c
// Function: je_buferror
int
buferror(int err, char *buf, size_t buflen)
{

#ifdef _WIN32
	FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, err, 0,
	    (LPSTR)buf, (DWORD)buflen, NULL);
	return (0);
#elif defined(__GLIBC__) && defined(_GNU_SOURCE)
	char *b = strerror_r(err, buf, buflen);
	if (b != buf) {
		strncpy(buf, b, buflen);
		buf[buflen-1] = '\0';
	}
	return (0);
#else
	return (strerror_r(err, buf, buflen));
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
callq 0xb360
cmpq %r14, %rax
je 0x312c7
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xb0a0
movb $0x0, -0x1(%r14,%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/witness.c
// Function: je_witness_lock_error
void
witness_lock_error(const witness_list_t *witnesses, const witness_t *witness)
{
	witness_t *w;

	malloc_printf("<jemalloc>: Lock rank order reversal:");
	ql_foreach(w, witnesses, link) {
		malloc_printf(" %s(%u)", w->name, w->rank);
	}
	malloc_printf(" %s(%u)\n", witness->name, witness->rank);
	abort();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x726f(%rip), %rdi      # 0x395cf
xorl %eax, %eax
callq 0x322ac
movq (%r14), %r12
leaq 0x7284(%rip), %r15      # 0x395f5
testq %r12, %r12
je 0x32398
movq (%r12), %rsi
movl 0x8(%r12), %edx
movq %r15, %rdi
xorl %eax, %eax
callq 0x322ac
movq 0x18(%r12), %r12
cmpq (%r14), %r12
jne 0x32371
xorl %r12d, %r12d
jmp 0x32371
movq (%rbx), %rsi
movl 0x8(%rbx), %edx
leaq 0x726e(%rip), %rdi      # 0x39613
xorl %eax, %eax
callq 0x322ac
callq 0xb070
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/witness.c
// Function: je_witness_lockless_error
void
witness_lockless_error(const witness_list_t *witnesses)
{
	witness_t *w;

	malloc_printf("<jemalloc>: Should not own any locks:");
	ql_foreach(w, witnesses, link) {
		malloc_printf(" %s(%u)", w->name, w->rank);
	}
	malloc_printf("\n");
	abort();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x724b(%rip), %rdi      # 0x3963f
xorl %eax, %eax
callq 0x322ac
movq (%rbx), %r15
leaq 0x71f0(%rip), %r14      # 0x395f5
testq %r15, %r15
je 0x32429
movq (%r15), %rsi
movl 0x8(%r15), %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x322ac
movq 0x18(%r15), %r15
cmpq (%rbx), %r15
jne 0x32405
xorl %r15d, %r15d
jmp 0x32405
leaq 0x2293(%rip), %rdi      # 0x346c3
xorl %eax, %eax
callq 0x322ac
callq 0xb070