LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
jmp 0x60c2e
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
cmpq $0x1000, -0x40(%rbp)    # imm = 0x1000
setbe %al
testb $0x1, %al
jne 0x60c4b
jmp 0x60c75
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
shrq $0x3, %rcx
leaq 0x2fe1a(%rip), %rax     # 0x90a80
movzbl (%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x60c81
movq -0x40(%rbp), %rdi
callq 0x60d20
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x5c(%rbp)
cmpl $0x0, -0x5c(%rbp)
jne 0x60cb8
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x2f65a(%rip), %rax     # 0x90300
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x60ced
movl -0x5c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x2f62d(%rip), %rax     # 0x90300
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x60ce5
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x65ae0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x65b10
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x830, %rsi            # imm = 0x830
callq 0x635b0
movq -0x20(%rbp), %rdi
callq 0x65bd0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x830, %rsi            # imm = 0x830
callq 0x63600
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x65ae0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x65b10
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x830, %rsi            # imm = 0x830
callq 0x635b0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x65d80
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x830, %rsi            # imm = 0x830
callq 0x63600
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/mutex.c
// Function: je_malloc_mutex_postfork_child
void
malloc_mutex_postfork_child(tsdn_t *tsdn, malloc_mutex_t *mutex)
{

#ifdef JEMALLOC_MUTEX_INIT_CB
	malloc_mutex_unlock(tsdn, mutex);
#else
	if (malloc_mutex_init(mutex, mutex->witness.name,
	    mutex->witness.rank)) {
		malloc_printf("<jemalloc>: Error re-initializing mutex in "
		    "child\n");
		if (opt_abort)
			abort();
	}
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x30(%rax), %edx
callq 0x66ad0
testb $0x1, %al
jne 0x66c4e
jmp 0x66c6f
leaq 0x2ab9b(%rip), %rdi     # 0x917f0
movb $0x0, %al
callq 0x85c20
leaq 0x3c89d(%rip), %rax     # 0xa3500
testb $0x1, (%rax)
je 0x66c6d
callq 0xb050
jmp 0x66c6f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x66d70
movq -0x10(%rbp), %rdi
callq 0x66f20
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x66d90
cmpl $0x0, %eax
setg %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x66f09
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x66d70
movb $0x1, -0x1(%rbp)
jmp 0x66f0d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/pages.c
// Function: je_pages_map
void *
pages_map(void *addr, size_t size, bool *commit)
{
	void *ret;

	assert(size != 0);

	if (os_overcommits)
		*commit = true;

#ifdef _WIN32
	/*
	 * If VirtualAlloc can't allocate at the given address when one is
	 * given, it fails and returns NULL.
	 */
	ret = VirtualAlloc(addr, size, MEM_RESERVE | (*commit ? MEM_COMMIT : 0),
	    PAGE_READWRITE);
#else
	/*
	 * We don't use MAP_FIXED here, because it can cause the *replacement*
	 * of existing mappings, and we only want to create new mappings.
	 */
	{
		int prot = *commit ? PAGES_PROT_COMMIT : PAGES_PROT_DECOMMIT;

		ret = mmap(addr, size, prot, mmap_flags, -1, 0);
	}
	assert(ret != NULL);

	if (ret == MAP_FAILED)
		ret = NULL;
	else if (addr != NULL && ret != addr) {
		/*
		 * We succeeded in mapping memory, but not in the right place.
		 */
		pages_unmap(ret, size);
		ret = NULL;
	}
#endif
	assert(ret == NULL || (addr == NULL && ret != addr)
	    || (addr != NULL && ret == addr));
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x66f76
testb $0x1, 0x3d1fb(%rip)     # 0xa4178
je 0x66f86
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movq -0x18(%rbp), %rax
movb (%rax), %dl
xorl %eax, %eax
movl $0x3, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %edx
movl 0x3d1cf(%rip), %ecx     # 0xa417c
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %r9d
callq 0xb180
movq %rax, -0x20(%rbp)
jmp 0x66fc3
movq $-0x1, %rax
cmpq %rax, -0x20(%rbp)
jne 0x66fda
movq $0x0, -0x20(%rbp)
jmp 0x67002
cmpq $0x0, -0x8(%rbp)
je 0x67000
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x67000
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x67010
movq $0x0, -0x20(%rbp)
jmp 0x67002
jmp 0x67004
jmp 0x67006
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, 0x3d02a(%rip)     # 0xa4178
je 0x67156
movb $0x1, -0x1(%rbp)
jmp 0x671c5
movb -0x19(%rbp), %dl
xorl %eax, %eax
movl $0x3, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %edx
movl 0x3d002(%rip), %ecx     # 0xa417c
orl $0x10, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %r9d
callq 0xb180
movq %rax, -0x28(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x28(%rbp)
jne 0x671a4
movb $0x1, -0x1(%rbp)
jmp 0x671c5
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x671c1
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x67010
movb $0x1, -0x1(%rbp)
jmp 0x671c5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/pages.c
// Function: os_overcommits_proc
static bool
os_overcommits_proc(void)
{
	int fd;
	char buf[1];
	ssize_t nread;

#if defined(JEMALLOC_USE_SYSCALL) && defined(SYS_open)
	fd = (int)syscall(SYS_open, "/proc/sys/vm/overcommit_memory", O_RDONLY);
#else
	fd = open("/proc/sys/vm/overcommit_memory", O_RDONLY);
#endif
	if (fd == -1)
		return (false); /* Error. */

#if defined(JEMALLOC_USE_SYSCALL) && defined(SYS_read)
	nread = (ssize_t)syscall(SYS_read, fd, &buf, sizeof(buf));
#else
	nread = read(fd, &buf, sizeof(buf));
#endif

#if defined(JEMALLOC_USE_SYSCALL) && defined(SYS_close)
	syscall(SYS_close, fd);
#else
	close(fd);
#endif

	if (nread < 1)
		return (false); /* Error. */
	/*
	 * /proc/sys/vm/overcommit_memory meanings:
	 * 0: Heuristic overcommit.
	 * 1: Always overcommit.
	 * 2: Never overcommit.
	 */
	return (buf[0] == '0' || buf[0] == '1');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x2, %edi
leaq 0x2a531(%rip), %rsi     # 0x91845
xorl %edx, %edx
movb $0x0, %al
callq 0xb2f0
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
jne 0x6732c
movb $0x0, -0x1(%rbp)
jmp 0x67386
movl -0x8(%rbp), %esi
xorl %eax, %eax
movl %eax, %edi
leaq -0x9(%rbp), %rdx
movl $0x1, %ecx
movb $0x0, %al
callq 0xb2f0
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %esi
movl $0x3, %edi
movb $0x0, %al
callq 0xb2f0
cmpq $0x1, -0x18(%rbp)
jge 0x67363
movb $0x0, -0x1(%rbp)
jmp 0x67386
movsbl -0x9(%rbp), %ecx
movb $0x1, %al
cmpl $0x30, %ecx
movb %al, -0x19(%rbp)
je 0x6737e
movsbl -0x9(%rbp), %eax
cmpl $0x31, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: prof_tctx_should_destroy
static bool
prof_tctx_should_destroy(tsdn_t *tsdn, prof_tctx_t *tctx)
{

	malloc_mutex_assert_owner(tsdn, tctx->tdata->lock);

	if (opt_prof_accum)
		return (false);
	if (tctx->cnts.curobjs != 0)
		return (false);
	if (tctx->prepared)
		return (false);
	return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0x6c410
testb $0x1, 0x3cd3a(%rip)     # 0xa4184
je 0x67452
movb $0x0, -0x1(%rbp)
jmp 0x67477
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x67463
movb $0x0, -0x1(%rbp)
jmp 0x67477
movq -0x18(%rbp), %rax
testb $0x1, 0x58(%rax)
je 0x67473
movb $0x0, -0x1(%rbp)
jmp 0x67477
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: je_prof_free_sampled_object
void
prof_free_sampled_object(tsd_t *tsd, size_t usize, prof_tctx_t *tctx)
{

	malloc_mutex_lock(tsd_tsdn(tsd), tctx->tdata->lock);
	assert(tctx->cnts.curobjs > 0);
	assert(tctx->cnts.curbytes >= usize);
	tctx->cnts.curobjs--;
	tctx->cnts.curbytes -= usize;

	if (prof_tctx_should_destroy(tsd_tsdn(tsd), tctx))
		prof_tctx_destroy(tsd, tctx);
	else
		malloc_mutex_unlock(tsd_tsdn(tsd), tctx->tdata->lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0x673d0
jmp 0x681e1
jmp 0x681e3
jmp 0x681e5
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x67420
testb $0x1, %al
jne 0x68223
jmp 0x68232
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x67490
jmp 0x6824d
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0x68140
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: prof_thr_uid_alloc
JEMALLOC_INLINE_C uint64_t
prof_thr_uid_alloc(tsdn_t *tsdn)
{
	uint64_t thr_uid;

	malloc_mutex_lock(tsdn, &next_thr_uid_mtx);
	thr_uid = next_thr_uid;
	next_thr_uid++;
	malloc_mutex_unlock(tsdn, &next_thr_uid_mtx);

	return (thr_uid);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3af29(%rip), %rsi     # 0xa4440
callq 0x673d0
movq 0x3af15(%rip), %rax     # 0xa4438
movq %rax, -0x10(%rbp)
movq 0x3af0a(%rip), %rax     # 0xa4438
addq $0x1, %rax
movq %rax, 0x3aeff(%rip)     # 0xa4438
movq -0x8(%rbp), %rdi
leaq 0x3aefc(%rip), %rsi     # 0xa4440
callq 0x68140
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3ad91(%rip), %rsi     # 0xa4308
callq 0x673d0
movb 0x3add6(%rip), %al      # 0xa4358
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3ad76(%rip), %rsi     # 0xa4308
callq 0x68140
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x69606
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x69660
movq %rax, -0x40(%rbp)
jmp 0x6960e
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x6960e
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movb 0x84(%rax), %al
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6a3b0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movb -0x31(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x694c0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: prof_tdata_detach
static void
prof_tdata_detach(tsd_t *tsd, prof_tdata_t *tdata)
{
	bool destroy_tdata;

	malloc_mutex_lock(tsd_tsdn(tsd), tdata->lock);
	if (tdata->attached) {
		destroy_tdata = prof_tdata_should_destroy(tsd_tsdn(tsd), tdata,
		    true);
		/*
		 * Only detach if !destroy_tdata, because detaching would allow
		 * another thread to win the race to destroy tdata.
		 */
		if (!destroy_tdata)
			tdata->attached = false;
		tsd_prof_tdata_set(tsd, NULL);
	} else
		destroy_tdata = false;
	malloc_mutex_unlock(tsd_tsdn(tsd), tdata->lock);
	if (destroy_tdata)
		prof_tdata_destroy(tsd, tdata, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rax
movq (%rax), %rsi
callq 0x673d0
movq -0x38(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x6a42d
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0x1, %edx
callq 0x6c450
andb $0x1, %al
movb %al, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x6a40f
movq -0x38(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x6a431
movb $0x0, -0x39(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rax
movq (%rax), %rsi
callq 0x68140
testb $0x1, -0x39(%rbp)
je 0x6a461
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0x1, %edx
callq 0x6d310
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
jmp 0x6a482
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x39d6b(%rip), %rsi     # 0xa4200
callq 0x673d0
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x39da3(%rip), %rsi     # 0xa4250
callq 0x673d0
movq -0x30(%rbp), %rax
movq %rax, 0x39de3(%rip)     # 0xa42a0
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq 0x39dd4(%rip), %rdi     # 0xa42a8
leaq 0xf5(%rip), %rdx        # 0x6a5d0
callq 0x6a560
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x6a510
movq -0x40(%rbp), %rsi
leaq 0x39db2(%rip), %rdi     # 0xa42a8
callq 0x6a620
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rsi
xorl %edx, %edx
callq 0x6a6f0
jmp 0x6a518
movq $0x0, -0x38(%rbp)
jmp 0x6a51a
cmpq $0x0, -0x38(%rbp)
jne 0x6a4c5
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x39d1c(%rip), %rsi     # 0xa4250
callq 0x68140
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x39cb4(%rip), %rsi     # 0xa4200
callq 0x68140
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x38599(%rip), %rsi     # 0xa42b0
callq 0x673d0
movb 0x385de(%rip), %al      # 0xa4300
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3857e(%rip), %rsi     # 0xa42b0
callq 0x68140
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x38541(%rip), %rsi     # 0xa42b0
callq 0x673d0
movb 0x38586(%rip), %al      # 0xa4300
andb $0x1, %al
movb %al, -0xa(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movb %al, 0x38576(%rip)      # 0xa4300
movq -0x8(%rbp), %rdi
leaq 0x3851b(%rip), %rsi     # 0xa42b0
callq 0x68140
movb -0xa(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: je_prof_thread_active_init_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
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x384a9(%rip), %rsi     # 0xa4308
callq 0x673d0
movb 0x384ee(%rip), %al      # 0xa4358
andb $0x1, %al
movb %al, -0xa(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movb %al, 0x384de(%rip)      # 0xa4358
movq -0x8(%rbp), %rdi
leaq 0x38483(%rip), %rsi     # 0xa4308
callq 0x68140
movb -0xa(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x384a9(%rip), %rsi     # 0xa4360
callq 0x673d0
movb 0x384ee(%rip), %al      # 0xa43b0
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3848e(%rip), %rsi     # 0xa4360
callq 0x68140
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x38451(%rip), %rsi     # 0xa4360
callq 0x673d0
movb 0x38496(%rip), %al      # 0xa43b0
andb $0x1, %al
movb %al, -0xa(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movb %al, 0x38486(%rip)      # 0xa43b0
movq -0x8(%rbp), %rdi
leaq 0x3842b(%rip), %rsi     # 0xa4360
callq 0x68140
movb -0xa(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
testb $0x1, 0x3817d(%rip)     # 0xa4180
je 0x6c0a5
movq -0x8(%rbp), %rdi
leaq 0x381ec(%rip), %rsi     # 0xa4200
callq 0x66b40
movq -0x8(%rbp), %rdi
leaq 0x383c4(%rip), %rsi     # 0xa43e8
callq 0x66b40
movq -0x8(%rbp), %rdi
leaq 0x3821c(%rip), %rsi     # 0xa4250
callq 0x66b40
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jae 0x6c06e
movq -0x8(%rbp), %rdi
movq 0x38444(%rip), %rsi     # 0xa4498
movl -0xc(%rbp), %eax
imulq $0x50, %rax, %rax
addq %rax, %rsi
callq 0x66b40
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6c040
movl $0x0, -0xc(%rbp)
cmpl $0x400, -0xc(%rbp)      # imm = 0x400
jae 0x6c0a3
movq -0x8(%rbp), %rdi
movq 0x38407(%rip), %rsi     # 0xa4490
movl -0xc(%rbp), %eax
imulq $0x50, %rax, %rax
addq %rax, %rsi
callq 0x66b40
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6c075
jmp 0x6c0a5
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
testb $0x1, 0x380bd(%rip)     # 0xa4180
je 0x6c115
movq -0x8(%rbp), %rdi
leaq 0x381e0(%rip), %rsi     # 0xa42b0
callq 0x66b40
movq -0x8(%rbp), %rdi
leaq 0x380b8(%rip), %rsi     # 0xa4198
callq 0x66b40
movq -0x8(%rbp), %rdi
leaq 0x38270(%rip), %rsi     # 0xa4360
callq 0x66b40
movq -0x8(%rbp), %rdi
leaq 0x38340(%rip), %rsi     # 0xa4440
callq 0x66b40
movq -0x8(%rbp), %rdi
leaq 0x381f8(%rip), %rsi     # 0xa4308
callq 0x66b40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
testb $0x1, 0x3804d(%rip)     # 0xa4180
je 0x6c223
movq -0x8(%rbp), %rdi
leaq 0x381c4(%rip), %rsi     # 0xa4308
callq 0x66bc0
movq -0x8(%rbp), %rdi
leaq 0x382ec(%rip), %rsi     # 0xa4440
callq 0x66bc0
movq -0x8(%rbp), %rdi
leaq 0x381fc(%rip), %rsi     # 0xa4360
callq 0x66bc0
movq -0x8(%rbp), %rdi
leaq 0x38024(%rip), %rsi     # 0xa4198
callq 0x66bc0
movq -0x8(%rbp), %rdi
leaq 0x3812c(%rip), %rsi     # 0xa42b0
callq 0x66bc0
movl $0x0, -0xc(%rbp)
cmpl $0x400, -0xc(%rbp)      # imm = 0x400
jae 0x6c1be
movq -0x8(%rbp), %rdi
movq 0x382ec(%rip), %rsi     # 0xa4490
movl -0xc(%rbp), %eax
imulq $0x50, %rax, %rax
addq %rax, %rsi
callq 0x66bc0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6c190
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jae 0x6c1f3
movq -0x8(%rbp), %rdi
movq 0x382bf(%rip), %rsi     # 0xa4498
movl -0xc(%rbp), %eax
imulq $0x50, %rax, %rax
addq %rax, %rsi
callq 0x66bc0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6c1c5
movq -0x8(%rbp), %rdi
leaq 0x38052(%rip), %rsi     # 0xa4250
callq 0x66bc0
movq -0x8(%rbp), %rdi
leaq 0x381da(%rip), %rsi     # 0xa43e8
callq 0x66bc0
movq -0x8(%rbp), %rdi
leaq 0x37fe2(%rip), %rsi     # 0xa4200
callq 0x66bc0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
testb $0x1, 0x37f3d(%rip)     # 0xa4180
je 0x6c333
movq -0x8(%rbp), %rdi
leaq 0x380b4(%rip), %rsi     # 0xa4308
callq 0x66c20
movq -0x8(%rbp), %rdi
leaq 0x381dc(%rip), %rsi     # 0xa4440
callq 0x66c20
movq -0x8(%rbp), %rdi
leaq 0x380ec(%rip), %rsi     # 0xa4360
callq 0x66c20
movq -0x8(%rbp), %rdi
leaq 0x37f14(%rip), %rsi     # 0xa4198
callq 0x66c20
movq -0x8(%rbp), %rdi
leaq 0x3801c(%rip), %rsi     # 0xa42b0
callq 0x66c20
movl $0x0, -0xc(%rbp)
cmpl $0x400, -0xc(%rbp)      # imm = 0x400
jae 0x6c2ce
movq -0x8(%rbp), %rdi
movq 0x381dc(%rip), %rsi     # 0xa4490
movl -0xc(%rbp), %eax
imulq $0x50, %rax, %rax
addq %rax, %rsi
callq 0x66c20
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6c2a0
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jae 0x6c303
movq -0x8(%rbp), %rdi
movq 0x381af(%rip), %rsi     # 0xa4498
movl -0xc(%rbp), %eax
imulq $0x50, %rax, %rax
addq %rax, %rsi
callq 0x66c20
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6c2d5
movq -0x8(%rbp), %rdi
leaq 0x37f42(%rip), %rsi     # 0xa4250
callq 0x66c20
movq -0x8(%rbp), %rdi
leaq 0x380ca(%rip), %rsi     # 0xa43e8
callq 0x66c20
movq -0x8(%rbp), %rdi
leaq 0x37ed2(%rip), %rsi     # 0xa4200
callq 0x66c20
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: prof_tdata_should_destroy_unlocked
static bool
prof_tdata_should_destroy_unlocked(prof_tdata_t *tdata, bool even_if_attached)
{

	if (tdata->attached && !even_if_attached)
		return (false);
	if (ckh_count(&tdata->bt2tctx) != 0)
		return (false);
	return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x6d3aa
testb $0x1, -0x11(%rbp)
jne 0x6d3aa
movb $0x0, -0x1(%rbp)
jmp 0x6d3c7
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x87920
cmpq $0x0, %rax
je 0x6d3c3
movb $0x0, -0x1(%rbp)
jmp 0x6d3c7
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: prof_tdata_merge_iter
static prof_tdata_t *
prof_tdata_merge_iter(prof_tdata_tree_t *tdatas, prof_tdata_t *tdata,
    void *opaque)
{
	struct prof_tdata_merge_iter_arg_s *arg =
	    (struct prof_tdata_merge_iter_arg_s *)opaque;

	malloc_mutex_lock(arg->tsdn, tdata->lock);
	if (!tdata->expired) {
		size_t tabind;
		union {
			prof_tctx_t	*p;
			void		*v;
		} tctx;

		tdata->dumping = true;
		memset(&tdata->cnt_summed, 0, sizeof(prof_cnt_t));
		for (tabind = 0; !ckh_iter(&tdata->bt2tctx, &tabind, NULL,
		    &tctx.v);)
			prof_tctx_merge_tdata(arg->tsdn, tctx.p, tdata);

		arg->cnt_all.curobjs += tdata->cnt_summed.curobjs;
		arg->cnt_all.curbytes += tdata->cnt_summed.curbytes;
		if (opt_prof_accum) {
			arg->cnt_all.accumobjs += tdata->cnt_summed.accumobjs;
			arg->cnt_all.accumbytes += tdata->cnt_summed.accumbytes;
		}
	} else
		tdata->dumping = false;
	malloc_mutex_unlock(arg->tsdn, tdata->lock);

	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x673d0
movq -0x10(%rbp), %rax
testb $0x1, 0x21(%rax)
jne 0x6e915
movq -0x10(%rbp), %rax
movb $0x1, 0x83(%rax)
movq -0x10(%rbp), %rdi
addq $0x88, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0xb210
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x30(%rbp), %rcx
callq 0x87940
xorb $-0x1, %al
testb $0x1, %al
jne 0x6e898
jmp 0x6e8ae
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x6f1b0
jmp 0x6e877
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rcx
movq -0x20(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rcx
movq -0x20(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
testb $0x1, 0x358a1(%rip)     # 0xa4184
je 0x6e913
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
movq -0x20(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rcx
movq -0x20(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
jmp 0x6e920
movq -0x10(%rbp), %rax
movb $0x0, 0x83(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x68140
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: prof_gctx_merge_iter
static prof_gctx_t *
prof_gctx_merge_iter(prof_gctx_tree_t *gctxs, prof_gctx_t *gctx, void *opaque)
{
	struct prof_gctx_merge_iter_arg_s *arg =
	    (struct prof_gctx_merge_iter_arg_s *)opaque;

	malloc_mutex_lock(arg->tsdn, gctx->lock);
	tctx_tree_iter(&gctx->tctxs, NULL, prof_tctx_merge_iter,
	    (void *)arg->tsdn);
	if (gctx->cnt_summed.curobjs != 0)
		arg->leak_ngctx++;
	malloc_mutex_unlock(arg->tsdn, gctx->lock);

	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x673d0
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0xb47(%rip), %rdx       # 0x6f540
callq 0x6f4d0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6ea19
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x68140
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: je_prof_dump_header
static bool
prof_dump_header(tsdn_t *tsdn, bool propagate_err, const prof_cnt_t *cnt_all)
{
	bool ret;

	if (prof_dump_printf(propagate_err,
	    "heap_v2/%"FMTu64"\n"
	    "  t*: %"FMTu64": %"FMTu64" [%"FMTu64": %"FMTu64"]\n",
	    ((uint64_t)1U << lg_prof_sample), cnt_all->curobjs,
	    cnt_all->curbytes, cnt_all->accumobjs, cnt_all->accumbytes))
		return (true);

	malloc_mutex_lock(tsdn, &tdatas_mtx);
	ret = (tdata_tree_iter(&tdatas, NULL, prof_tdata_dump_iter,
	    (void *)&propagate_err) != NULL);
	malloc_mutex_unlock(tsdn, &tdatas_mtx);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movb -0x11(%rbp), %dil
movq 0x357dd(%rip), %rcx     # 0xa42a0
movl $0x1, %edx
shlq %cl, %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %r8
movq -0x20(%rbp), %rax
movq 0x10(%rax), %r9
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
leaq 0x22e55(%rip), %rsi     # 0x91946
andb $0x1, %dil
movzbl %dil, %edi
movq %rax, (%rsp)
movb $0x0, %al
callq 0x6f820
testb $0x1, %al
jne 0x6eb0a
jmp 0x6eb10
movb $0x1, -0x1(%rbp)
jmp 0x6eb5f
movq -0x10(%rbp), %rdi
leaq 0x35735(%rip), %rsi     # 0xa4250
callq 0x673d0
leaq 0x35781(%rip), %rdi     # 0xa42a8
xorl %eax, %eax
movl %eax, %esi
leaq 0xdce(%rip), %rdx       # 0x6f900
leaq -0x11(%rbp), %rcx
callq 0x6a560
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x356fe(%rip), %rsi     # 0xa4250
callq 0x68140
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: prof_gctx_dump_iter
static prof_gctx_t *
prof_gctx_dump_iter(prof_gctx_tree_t *gctxs, prof_gctx_t *gctx, void *opaque)
{
	prof_gctx_t *ret;
	struct prof_gctx_dump_iter_arg_s *arg =
	    (struct prof_gctx_dump_iter_arg_s *)opaque;

	malloc_mutex_lock(arg->tsdn, gctx->lock);

	if (prof_dump_gctx(arg->tsdn, arg->propagate_err, gctx, &gctx->bt,
	    gctxs)) {
		ret = gctx;
		goto label_return;
	}

	ret = NULL;
label_return:
	malloc_mutex_unlock(arg->tsdn, gctx->lock);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x673d0
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movb 0x8(%rax), %al
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq $0x48, %rcx
movq -0x8(%rbp), %r8
andb $0x1, %al
movzbl %al, %esi
callq 0x6fa80
testb $0x1, %al
jne 0x6ebcd
jmp 0x6ebd7
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x6ebdf
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x68140
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: prof_tctx_merge_tdata
static void
prof_tctx_merge_tdata(tsdn_t *tsdn, prof_tctx_t *tctx, prof_tdata_t *tdata)
{

	malloc_mutex_assert_owner(tsdn, tctx->tdata->lock);

	malloc_mutex_lock(tsdn, tctx->gctx->lock);

	switch (tctx->state) {
	case prof_tctx_state_initializing:
		malloc_mutex_unlock(tsdn, tctx->gctx->lock);
		return;
	case prof_tctx_state_nominal:
		tctx->state = prof_tctx_state_dumping;
		malloc_mutex_unlock(tsdn, tctx->gctx->lock);

		memcpy(&tctx->dump_cnts, &tctx->cnts, sizeof(prof_cnt_t));

		tdata->cnt_summed.curobjs += tctx->dump_cnts.curobjs;
		tdata->cnt_summed.curbytes += tctx->dump_cnts.curbytes;
		if (opt_prof_accum) {
			tdata->cnt_summed.accumobjs +=
			    tctx->dump_cnts.accumobjs;
			tdata->cnt_summed.accumbytes +=
			    tctx->dump_cnts.accumbytes;
		}
		break;
	case prof_tctx_state_dumping:
	case prof_tctx_state_purgatory:
		not_reached();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0x6c410
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rsi
callq 0x673d0
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x6f219
jmp 0x6f1fb
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x6f232
jmp 0x6f205
movl -0x1c(%rbp), %eax
addl $-0x2, %eax
subl $0x2, %eax
jb 0x6f2ec
jmp 0x6f2ee
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rsi
callq 0x68140
jmp 0x6f2ee
movq -0x10(%rbp), %rax
movl $0x2, 0x5c(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rsi
callq 0x68140
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rdx
movq %rdx, 0x60(%rax)
movq 0x20(%rcx), %rdx
movq %rdx, 0x68(%rax)
movq 0x28(%rcx), %rdx
movq %rdx, 0x70(%rax)
movq 0x30(%rcx), %rcx
movq %rcx, 0x78(%rax)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x18(%rbp), %rax
addq 0x88(%rax), %rcx
movq %rcx, 0x88(%rax)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x18(%rbp), %rax
addq 0x90(%rax), %rcx
movq %rcx, 0x90(%rax)
testb $0x1, 0x34ed0(%rip)     # 0xa4184
je 0x6f2ea
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rcx
movq -0x18(%rbp), %rax
addq 0x98(%rax), %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rcx
movq -0x18(%rbp), %rax
addq 0xa0(%rax), %rcx
movq %rcx, 0xa0(%rax)
jmp 0x6f2ee
jmp 0x6f2ee
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: prof_tctx_merge_iter
static prof_tctx_t *
prof_tctx_merge_iter(prof_tctx_tree_t *tctxs, prof_tctx_t *tctx, void *arg)
{
	tsdn_t *tsdn = (tsdn_t *)arg;

	malloc_mutex_assert_owner(tsdn, tctx->gctx->lock);

	switch (tctx->state) {
	case prof_tctx_state_nominal:
		/* New since dumping started; ignore. */
		break;
	case prof_tctx_state_dumping:
	case prof_tctx_state_purgatory:
		prof_tctx_merge_gctx(tsdn, tctx, tctx->gctx);
		break;
	default:
		not_reached();
	}

	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rsi
callq 0x6c410
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0x6f58e
jmp 0x6f581
movl -0x24(%rbp), %eax
addl $-0x2, %eax
subl $0x2, %eax
jb 0x6f590
jmp 0x6f5a7
jmp 0x6f5a9
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdx
callq 0x6f790
jmp 0x6f5a9
jmp 0x6f5a9
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: prof_tctx_merge_gctx
static void
prof_tctx_merge_gctx(tsdn_t *tsdn, prof_tctx_t *tctx, prof_gctx_t *gctx)
{

	malloc_mutex_assert_owner(tsdn, gctx->lock);

	gctx->cnt_summed.curobjs += tctx->dump_cnts.curobjs;
	gctx->cnt_summed.curbytes += tctx->dump_cnts.curbytes;
	if (opt_prof_accum) {
		gctx->cnt_summed.accumobjs += tctx->dump_cnts.accumobjs;
		gctx->cnt_summed.accumbytes += tctx->dump_cnts.accumbytes;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x6c410
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x18(%rbp), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x18(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
testb $0x1, 0x349a1(%rip)     # 0xa4184
je 0x6f80d
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rcx
movq -0x18(%rbp), %rax
addq 0x38(%rax), %rcx
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rcx
movq -0x18(%rbp), %rax
addq 0x40(%rax), %rcx
movq %rcx, 0x40(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: prof_tctx_dump_iter
static prof_tctx_t *
prof_tctx_dump_iter(prof_tctx_tree_t *tctxs, prof_tctx_t *tctx, void *opaque)
{
	struct prof_tctx_dump_iter_arg_s *arg =
	    (struct prof_tctx_dump_iter_arg_s *)opaque;

	malloc_mutex_assert_owner(arg->tsdn, tctx->gctx->lock);

	switch (tctx->state) {
	case prof_tctx_state_initializing:
	case prof_tctx_state_nominal:
		/* Not captured by this dump. */
		break;
	case prof_tctx_state_dumping:
	case prof_tctx_state_purgatory:
		if (prof_dump_printf(arg->propagate_err,
		    "  t%"FMTu64": %"FMTu64": %"FMTu64" [%"FMTu64": "
		    "%"FMTu64"]\n", tctx->thr_uid, tctx->dump_cnts.curobjs,
		    tctx->dump_cnts.curbytes, tctx->dump_cnts.accumobjs,
		    tctx->dump_cnts.accumbytes))
			return (tctx);
		break;
	default:
		not_reached();
	}
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rsi
callq 0x6c410
movq -0x18(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x2, %eax
jb 0x6faf1
jmp 0x6fae4
movl -0x2c(%rbp), %eax
addl $-0x2, %eax
subl $0x2, %eax
jb 0x6faf3
jmp 0x6fb4f
jmp 0x6fb51
movq -0x28(%rbp), %rax
movb 0x8(%rax), %dil
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x68(%rax), %r8
movq -0x18(%rbp), %rax
movq 0x70(%rax), %r9
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
leaq 0x21ea2(%rip), %rsi     # 0x919cc
andb $0x1, %dil
movzbl %dil, %edi
movq %rax, (%rsp)
movb $0x0, %al
callq 0x6f820
testb $0x1, %al
jne 0x6fb43
jmp 0x6fb4d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6fb59
jmp 0x6fb51
jmp 0x6fb51
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: prof_tctx_finish_iter
static prof_tctx_t *
prof_tctx_finish_iter(prof_tctx_tree_t *tctxs, prof_tctx_t *tctx, void *arg)
{
	tsdn_t *tsdn = (tsdn_t *)arg;
	prof_tctx_t *ret;

	malloc_mutex_assert_owner(tsdn, tctx->gctx->lock);

	switch (tctx->state) {
	case prof_tctx_state_nominal:
		/* New since dumping started; ignore. */
		break;
	case prof_tctx_state_dumping:
		tctx->state = prof_tctx_state_nominal;
		break;
	case prof_tctx_state_purgatory:
		ret = tctx;
		goto label_return;
	default:
		not_reached();
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rsi
callq 0x6c410
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x1, %eax
je 0x70ad5
jmp 0x70ac1
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x70ad7
jmp 0x70acb
movl -0x2c(%rbp), %eax
subl $0x3, %eax
je 0x70ae4
jmp 0x70aee
jmp 0x70af0
movq -0x10(%rbp), %rax
movl $0x1, 0x5c(%rax)
jmp 0x70af0
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x70af8
jmp 0x70af0
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)