LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/chunk.c
// Function: chunk_alloc_default_impl
static void *
chunk_alloc_default_impl(tsdn_t *tsdn, arena_t *arena, void *new_addr,
    size_t size, size_t alignment, bool *zero, bool *commit)
{
	void *ret;

	ret = chunk_alloc_core(tsdn, arena, new_addr, size, alignment, zero,
	    commit, arena->dss_prec);
	if (ret == NULL)
		return (NULL);
	if (config_valgrind)
		JEMALLOC_VALGRIND_MAKE_MEM_UNDEFINED(ret, size);

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %r10
movq -0x18(%rbp), %rax
movl 0xf8(%rax), %eax
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x532f0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x5236c
movq $0x0, -0x8(%rbp)
jmp 0x5239f
jmp 0x5236e
leaq 0x51207(%rip), %rax     # 0xa357c
movb (%rax), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x52395
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x86000
jmp 0x52397
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/chunk.c
// Function: je_chunk_dalloc_cache
void
chunk_dalloc_cache(tsdn_t *tsdn, arena_t *arena, chunk_hooks_t *chunk_hooks,
    void *chunk, size_t size, size_t sn, bool committed)
{

	assert(chunk != NULL);
	assert(CHUNK_ADDR2BASE(chunk) == chunk);
	assert(size != 0);
	assert((size & chunksize_mask) == 0);

	chunk_record(tsdn, arena, chunk_hooks, &arena->chunks_szsnad_cached,
	    &arena->chunks_ad_cached, true, chunk, size, sn, false,
	    committed);
	arena_maybe_purge(tsdn, arena);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movb 0x10(%rbp), %al
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
andb $0x1, %al
movb %al, -0x41(%rbp)
jmp 0x523dd
jmp 0x523df
jmp 0x523e1
jmp 0x523e3
jmp 0x523e5
jmp 0x523e7
jmp 0x523e9
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0x880, %rcx            # imm = 0x880
movq -0x20(%rbp), %r8
addq $0x888, %r8             # imm = 0x888
movq -0x30(%rbp), %rbx
movq -0x38(%rbp), %r11
movq -0x40(%rbp), %r10
movb -0x41(%rbp), %al
movl $0x1, %r9d
xorl %r14d, %r14d
andb $0x1, %al
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movzbl %al, %eax
movl %eax, 0x20(%rsp)
callq 0x52460
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3b4d0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/chunk.c
// Function: chunk_alloc_core
static void *
chunk_alloc_core(tsdn_t *tsdn, arena_t *arena, void *new_addr, size_t size,
    size_t alignment, bool *zero, bool *commit, dss_prec_t dss_prec)
{
	void *ret;

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

	/* "primary" dss. */
	if (have_dss && dss_prec == dss_prec_primary && (ret =
	    chunk_alloc_dss(tsdn, arena, new_addr, size, alignment, zero,
	    commit)) != NULL)
		return (ret);
	/* mmap. */
	if ((ret = chunk_alloc_mmap(new_addr, size, alignment, zero, commit)) !=
	    NULL)
		return (ret);
	/* "secondary" dss. */
	if (have_dss && dss_prec == dss_prec_secondary && (ret =
	    chunk_alloc_dss(tsdn, arena, new_addr, size, alignment, zero,
	    commit)) != NULL)
		return (ret);

	/* All strategies for allocation failed. */
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
jmp 0x53319
jmp 0x5331b
jmp 0x5331d
jmp 0x5331f
jmp 0x53321
jmp 0x53323
jmp 0x53325
cmpl $0x1, 0x18(%rbp)
jne 0x53364
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x534f0
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x53364
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x533d8
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x53b30
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x53391
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x533d8
cmpl $0x2, 0x18(%rbp)
jne 0x533d0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x534f0
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x533d0
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x533d8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %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/chunk_dss.c
// Function: chunk_dss_max_update
static void *
chunk_dss_max_update(void *new_addr)
{
	void *max_cur;
	spin_t spinner;

	/*
	 * Get the current end of the DSS as max_cur and assure that dss_max is
	 * up to date.
	 */
	spin_init(&spinner);
	while (true) {
		void *max_prev = atomic_read_p(&dss_max);

		max_cur = chunk_dss_sbrk(0);
		if ((uintptr_t)max_prev > (uintptr_t)max_cur) {
			/*
			 * Another thread optimistically updated dss_max.  Wait
			 * for it to finish.
			 */
			spin_adaptive(&spinner);
			continue;
		}
		if (!atomic_cas_p(&dss_max, max_prev, max_cur))
			break;
	}
	/* Fixed new_addr can only be supported if it is at the edge of DSS. */
	if (new_addr != NULL && max_cur != new_addr)
		return (NULL);

	return (max_cur);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x53a40
leaq 0x5090c(%rip), %rdi     # 0xa40c8
xorl %eax, %eax
movl %eax, %esi
callq 0x53910
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x53870
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x537ee
leaq -0x1c(%rbp), %rdi
callq 0x53a60
jmp 0x537b5
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x508cb(%rip), %rdi     # 0xa40c8
callq 0x53840
testb $0x1, %al
jne 0x53808
jmp 0x5380a
jmp 0x537b5
cmpq $0x0, -0x10(%rbp)
je 0x53825
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x53825
movq $0x0, -0x8(%rbp)
jmp 0x5382d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
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/chunk_dss.c
// Function: je_chunk_dss_mergeable
bool
chunk_dss_mergeable(void *chunk_a, void *chunk_b)
{
	void *max;

	cassert(have_dss);

	max = atomic_read_p(&dss_max);
	return (chunk_in_dss_helper(chunk_a, max) ==
	    chunk_in_dss_helper(chunk_b, max));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x53952
leaq 0x5076f(%rip), %rdi     # 0xa40c8
xorl %eax, %eax
movl %eax, %esi
callq 0x53910
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x538d0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x538d0
movb %al, %cl
movl -0x1c(%rbp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/chunk_dss.c
// Function: je_chunk_dss_boot
void
chunk_dss_boot(void)
{

	cassert(have_dss);

	dss_base = chunk_dss_sbrk(0);
	dss_exhausted = (unsigned)(dss_base == (void *)-1);
	dss_max = dss_base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
jmp 0x539a6
jmp 0x539a8
xorl %eax, %eax
movl %eax, %edi
callq 0x53870
movq %rax, 0x50718(%rip)     # 0xa40d0
movq $-0x1, %rax
cmpq %rax, 0x5070a(%rip)     # 0xa40d0
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x506ec(%rip)     # 0xa40c0
movq 0x506f5(%rip), %rax     # 0xa40d0
movq %rax, 0x506e6(%rip)     # 0xa40c8
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/chunk_mmap.c
// Function: je_chunk_alloc_mmap
void *
chunk_alloc_mmap(void *new_addr, size_t size, size_t alignment, bool *zero,
    bool *commit)
{
	void *ret;
	size_t offset;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
jmp 0x53b4e
jmp 0x53b50
jmp 0x53b52
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x66f60
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x53b78
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x53b82
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x53bdb
jmp 0x53b84
jmp 0x53b86
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x53bc8
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x67010
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x53bf0
movq %rax, -0x8(%rbp)
jmp 0x53bdb
jmp 0x53bca
jmp 0x53bcc
movq -0x28(%rbp), %rax
movb $0x1, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -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/ctl.c
// Function: je_ctl_byname
int
ctl_byname(tsd_t *tsd, const char *name, void *oldp, size_t *oldlenp,
    void *newp, size_t newlen)
{
	int ret;
	size_t depth;
	ctl_node_t const *nodes[CTL_MAX_DEPTH];
	size_t mib[CTL_MAX_DEPTH];
	const ctl_named_node_t *node;

	if (!ctl_initialized && ctl_init(tsd_tsdn(tsd))) {
		ret = EAGAIN;
		goto label_return;
	}

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

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

label_return:
	return(ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
testb $0x1, 0x503be(%rip)     # 0xa40d8
jne 0x53d3f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x53e00
testb $0x1, %al
jne 0x53d33
jmp 0x53d3f
movl $0xb, -0x44(%rbp)
jmp 0x53de5
movq $0x6, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x80(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
leaq -0x50(%rbp), %r8
callq 0x53fa0
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0x53d76
jmp 0x53de5
movq -0x50(%rbp), %rax
subq $0x1, %rax
movq -0x80(%rbp,%rax,8), %rdi
callq 0x542a0
movq %rax, -0xb8(%rbp)
cmpq $0x0, -0xb8(%rbp)
je 0x53ddc
movq -0xb8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x53ddc
movq -0xb8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq -0x40(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
movl %eax, -0x44(%rbp)
jmp 0x53de3
movl $0x2, -0x44(%rbp)
jmp 0x53de5
movl -0x44(%rbp), %eax
addq $0xc0, %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/ctl.c
// Function: je_ctl_nametomib
int
ctl_nametomib(tsdn_t *tsdn, const char *name, size_t *mibp, size_t *miblenp)
{
	int ret;

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

	ret = ctl_lookup(tsdn, name, NULL, mibp, miblenp);
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 %rcx, -0x20(%rbp)
testb $0x1, 0x4fde9(%rip)     # 0xa40d8
jne 0x54309
movq -0x8(%rbp), %rdi
callq 0x53e00
testb $0x1, %al
jne 0x54300
jmp 0x54309
movl $0xb, -0x24(%rbp)
jmp 0x54325
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0x53fa0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/ctl.c
// Function: je_ctl_boot
bool
ctl_boot(void)
{

	if (malloc_mutex_init(&ctl_mtx, "ctl", WITNESS_RANK_CTL))
		return (true);

	ctl_initialized = false;

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x4fb91(%rip), %rdi     # 0xa40e0
leaq 0x3d1bb(%rip), %rsi     # 0x91711
movl $0x1, %edx
callq 0x66ad0
testb $0x1, %al
jne 0x54566
jmp 0x5456c
movb $0x1, -0x1(%rbp)
jmp 0x54577
movb $0x0, 0x4fb65(%rip)     # 0xa40d8
movb $0x0, -0x1(%rbp)
movb -0x1(%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/ctl.c
// Function: ctl_arena_refresh
static void
ctl_arena_refresh(tsdn_t *tsdn, arena_t *arena, unsigned i)
{
	ctl_arena_stats_t *astats = &ctl_stats.arenas[i];
	ctl_arena_stats_t *sstats = &ctl_stats.arenas[ctl_stats.narenas];

	ctl_arena_clear(astats);
	ctl_arena_stats_amerge(tsdn, astats, arena);
	/* Merge into sum stats as well. */
	ctl_arena_stats_smerge(sstats, astats);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq 0x4f57e(%rip), %rax     # 0xa4168
movl -0x14(%rbp), %ecx
imulq $0xbd8, %rcx, %rcx      # imm = 0xBD8
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq 0x4f566(%rip), %rax     # 0xa4168
movl 0x4f558(%rip), %ecx     # 0xa4160
imulq $0xbd8, %rcx, %rcx      # imm = 0xBD8
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x54a10
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x54cc0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x54e60
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/ctl.c
// Function: ctl_arena_stats_amerge
static void
ctl_arena_stats_amerge(tsdn_t *tsdn, ctl_arena_stats_t *cstats, arena_t *arena)
{
	unsigned i;

	if (config_stats) {
		arena_stats_merge(tsdn, arena, &cstats->nthreads, &cstats->dss,
		    &cstats->lg_dirty_mult, &cstats->decay_time,
		    &cstats->pactive, &cstats->pdirty, &cstats->astats,
		    cstats->bstats, cstats->lstats, cstats->hstats);

		for (i = 0; i < NBINS; i++) {
			cstats->allocated_small += cstats->bstats[i].curregs *
			    index2size(i);
			cstats->nmalloc_small += cstats->bstats[i].nmalloc;
			cstats->ndalloc_small += cstats->bstats[i].ndalloc;
			cstats->nrequests_small += cstats->bstats[i].nrequests;
		}
	} else {
		arena_basic_stats_merge(tsdn, arena, &cstats->nthreads,
		    &cstats->dss, &cstats->lg_dirty_mult, &cstats->decay_time,
		    &cstats->pactive, &cstats->pdirty);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq $0x4, %rdx
movq -0x40(%rbp), %rcx
addq $0x8, %rcx
movq -0x40(%rbp), %r8
addq $0x10, %r8
movq -0x40(%rbp), %r9
addq $0x18, %r9
movq -0x40(%rbp), %r15
addq $0x20, %r15
movq -0x40(%rbp), %r14
addq $0x28, %r14
movq -0x40(%rbp), %rbx
addq $0x30, %rbx
movq -0x40(%rbp), %r11
addq $0xd0, %r11
movq -0x40(%rbp), %rax
movq 0xbc8(%rax), %r10
movq -0x40(%rbp), %rax
movq 0xbd0(%rax), %rax
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x42f50
movl $0x0, -0x4c(%rbp)
cmpl $0x27, -0x4c(%rbp)
jae 0x54e47
movq -0x40(%rbp), %rax
addq $0xd0, %rax
movl -0x4c(%rbp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rcx
movl -0x4c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %edx
leaq 0x3b563(%rip), %rax     # 0x90300
movq (%rax,%rdx,8), %rax
movq %rax, -0x28(%rbp)
imulq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
addq 0xb0(%rax), %rcx
movq %rcx, 0xb0(%rax)
movq -0x40(%rbp), %rax
addq $0xd0, %rax
movl -0x4c(%rbp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq -0x40(%rbp), %rax
addq 0xb8(%rax), %rcx
movq %rcx, 0xb8(%rax)
movq -0x40(%rbp), %rax
addq $0xd0, %rax
movl -0x4c(%rbp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq -0x40(%rbp), %rax
addq 0xc0(%rax), %rcx
movq %rcx, 0xc0(%rax)
movq -0x40(%rbp), %rax
addq $0xd0, %rax
movl -0x4c(%rbp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rcx
movq -0x40(%rbp), %rax
addq 0xc8(%rax), %rcx
movq %rcx, 0xc8(%rax)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x54d63
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/ctl.c
// Function: tcache_flush_ctl
static int
tcache_flush_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;
	unsigned tcache_ind;

	if (!config_tcache)
		return (ENOENT);

	WRITEONLY();
	tcache_ind = UINT_MAX;
	WRITE(tcache_ind, unsigned);
	if (tcache_ind == UINT_MAX) {
		ret = EFAULT;
		goto label_return;
	}
	tcaches_flush(tsd, tcache_ind);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x57d82
cmpq $0x0, -0x28(%rbp)
je 0x57d8b
movl $0x1, -0x34(%rbp)
jmp 0x57dd8
jmp 0x57d8d
movl $0xffffffff, -0x38(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x30(%rbp)
je 0x57db4
cmpq $0x4, 0x10(%rbp)
je 0x57dab
movl $0x16, -0x34(%rbp)
jmp 0x57dd8
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
jmp 0x57db6
cmpl $-0x1, -0x38(%rbp)
jne 0x57dc5
movl $0xe, -0x34(%rbp)
jmp 0x57dd8
movq -0x8(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x81b00
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
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/ctl.c
// Function: tcache_create_ctl
static int
tcache_create_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;
	unsigned tcache_ind;

	if (!config_tcache)
		return (ENOENT);

	malloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);
	READONLY();
	if (tcaches_create(tsd, &tcache_ind)) {
		ret = EFAULT;
		goto label_return;
	}
	READ(tcache_ind, unsigned);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x4c469(%rip), %rsi     # 0xa40e0
callq 0x54620
cmpq $0x0, -0x40(%rbp)
jne 0x57c8a
cmpq $0x0, 0x10(%rbp)
je 0x57c96
movl $0x1, -0x44(%rbp)
jmp 0x57d26
jmp 0x57c98
movq -0x18(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x81960
testb $0x1, %al
jne 0x57cab
jmp 0x57cb4
movl $0xe, -0x44(%rbp)
jmp 0x57d26
jmp 0x57cb6
cmpq $0x0, -0x30(%rbp)
je 0x57d1d
cmpq $0x0, -0x38(%rbp)
je 0x57d1d
movq -0x38(%rbp), %rax
cmpq $0x4, (%rax)
je 0x57d14
movq -0x38(%rbp), %rcx
movl $0x4, %eax
cmpq (%rcx), %rax
ja 0x57ce7
movl $0x4, %eax
movq %rax, -0x58(%rbp)
jmp 0x57cf2
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq -0x48(%rbp), %rsi
callq 0xb310
movl $0x16, -0x44(%rbp)
jmp 0x57d26
movl -0x48(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
jmp 0x57d1f
movl $0x0, -0x44(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x4c3a7(%rip), %rsi     # 0xa40e0
callq 0x549c0
movl -0x44(%rbp), %eax
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/ctl.c
// Function: tcache_destroy_ctl
static int
tcache_destroy_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;
	unsigned tcache_ind;

	if (!config_tcache)
		return (ENOENT);

	WRITEONLY();
	tcache_ind = UINT_MAX;
	WRITE(tcache_ind, unsigned);
	if (tcache_ind == UINT_MAX) {
		ret = EFAULT;
		goto label_return;
	}
	tcaches_destroy(tsd, tcache_ind);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x57e22
cmpq $0x0, -0x28(%rbp)
je 0x57e2b
movl $0x1, -0x34(%rbp)
jmp 0x57e78
jmp 0x57e2d
movl $0xffffffff, -0x38(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x30(%rbp)
je 0x57e54
cmpq $0x4, 0x10(%rbp)
je 0x57e4b
movl $0x16, -0x34(%rbp)
jmp 0x57e78
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
jmp 0x57e56
cmpl $-0x1, -0x38(%rbp)
jne 0x57e65
movl $0xe, -0x34(%rbp)
jmp 0x57e78
movq -0x8(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x81b70
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
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/ctl.c
// Function: arena_i_index
static const ctl_named_node_t *
arena_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) {
		ret = NULL;
		goto label_return;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x4c22d(%rip), %rsi     # 0xa40e0
callq 0x54620
movq -0x20(%rbp), %rax
movl 0x4c29e(%rip), %ecx     # 0xa4160
cmpq %rcx, %rax
jbe 0x57ed1
movq $0x0, -0x28(%rbp)
jmp 0x57edc
leaq 0x4a358(%rip), %rax     # 0xa2230
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x4c1f9(%rip), %rsi     # 0xa40e0
callq 0x549c0
movq -0x28(%rbp), %rax
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/ctl.c
// Function: arena_i_purge_ctl
static int
arena_i_purge_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;

	READONLY();
	WRITEONLY();
	arena_i_purge(tsd_tsdn(tsd), (unsigned)mib[1], true);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x57f32
cmpq $0x0, 0x10(%rbp)
je 0x57f3b
movl $0x1, -0x3c(%rbp)
jmp 0x57f7f
jmp 0x57f3d
jmp 0x57f3f
cmpq $0x0, -0x28(%rbp)
jne 0x57f4d
cmpq $0x0, -0x30(%rbp)
je 0x57f56
movl $0x1, -0x3c(%rbp)
jmp 0x57f7f
jmp 0x57f58
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %esi
movl $0x1, %edx
callq 0x58880
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/ctl.c
// Function: arena_i_decay_ctl
static int
arena_i_decay_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;

	READONLY();
	WRITEONLY();
	arena_i_purge(tsd_tsdn(tsd), (unsigned)mib[1], false);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x57fc2
cmpq $0x0, 0x10(%rbp)
je 0x57fcb
movl $0x1, -0x3c(%rbp)
jmp 0x5800c
jmp 0x57fcd
jmp 0x57fcf
cmpq $0x0, -0x28(%rbp)
jne 0x57fdd
cmpq $0x0, -0x30(%rbp)
je 0x57fe6
movl $0x1, -0x3c(%rbp)
jmp 0x5800c
jmp 0x57fe8
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %esi
xorl %edx, %edx
callq 0x58880
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
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/ctl.c
// Function: arena_i_reset_ctl
static int
arena_i_reset_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;
	unsigned arena_ind;
	arena_t *arena;

	READONLY();
	WRITEONLY();

	if ((config_valgrind && unlikely(in_valgrind)) || (config_fill &&
	    unlikely(opt_quarantine))) {
		ret = EFAULT;
		goto label_return;
	}

	arena_ind = (unsigned)mib[1];
	if (config_debug) {
		malloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);
		assert(arena_ind < ctl_stats.narenas);
		malloc_mutex_unlock(tsd_tsdn(tsd), &ctl_mtx);
	}
	assert(arena_ind >= opt_narenas);

	arena = arena_get(tsd_tsdn(tsd), arena_ind, false);

	arena_reset(tsd, arena);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x58052
cmpq $0x0, 0x10(%rbp)
je 0x5805e
movl $0x1, -0x3c(%rbp)
jmp 0x580f8
jmp 0x58060
jmp 0x58062
cmpq $0x0, -0x28(%rbp)
jne 0x58070
cmpq $0x0, -0x30(%rbp)
je 0x58079
movl $0x1, -0x3c(%rbp)
jmp 0x580f8
jmp 0x5807b
leaq 0x4b4fa(%rip), %rax     # 0xa357c
movb (%rax), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x580b4
leaq 0x4b46c(%rip), %rax     # 0xa3508
cmpq $0x0, (%rax)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x580bd
movl $0xe, -0x3c(%rbp)
jmp 0x580f8
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, -0x40(%rbp)
jmp 0x580ca
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl -0x40(%rbp), %esi
xorl %edx, %edx
callq 0x54b20
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x3ba00
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
addq $0x50, %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/ctl.c
// Function: arena_i_lg_dirty_mult_ctl
static int
arena_i_lg_dirty_mult_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,
    void *oldp, size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;
	unsigned arena_ind = (unsigned)mib[1];
	arena_t *arena;

	arena = arena_get(tsd_tsdn(tsd), arena_ind, false);
	if (arena == NULL) {
		ret = EFAULT;
		goto label_return;
	}

	if (oldp != NULL && oldlenp != NULL) {
		size_t oldval = arena_lg_dirty_mult_get(tsd_tsdn(tsd), arena);
		READ(oldval, ssize_t);
	}
	if (newp != NULL) {
		if (newlen != sizeof(ssize_t)) {
			ret = EINVAL;
			goto label_return;
		}
		if (arena_lg_dirty_mult_set(tsd_tsdn(tsd), arena,
		    *(ssize_t *)newp)) {
			ret = EFAULT;
			goto label_return;
		}
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq %r9, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl -0x50(%rbp), %esi
xorl %edx, %edx
callq 0x54b20
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x583bc
movl $0xe, -0x4c(%rbp)
jmp 0x584a3
cmpq $0x0, -0x38(%rbp)
je 0x58458
cmpq $0x0, -0x40(%rbp)
je 0x58458
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x3b3d0
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x58454
cmpq $0x0, -0x40(%rbp)
je 0x58454
movq -0x40(%rbp), %rax
cmpq $0x8, (%rax)
je 0x58449
movq -0x40(%rbp), %rcx
movl $0x8, %eax
cmpq (%rcx), %rax
ja 0x5841c
movl $0x8, %eax
movq %rax, -0x70(%rbp)
jmp 0x58427
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x38(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq -0x60(%rbp), %rsi
callq 0xb310
movl $0x16, -0x4c(%rbp)
jmp 0x584a3
movq -0x60(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
jmp 0x58456
jmp 0x58458
cmpq $0x0, -0x48(%rbp)
je 0x5849c
cmpq $0x8, 0x10(%rbp)
je 0x5846f
movl $0x16, -0x4c(%rbp)
jmp 0x584a3
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x48(%rbp), %rax
movq (%rax), %rdx
callq 0x3b420
testb $0x1, %al
jne 0x58491
jmp 0x5849a
movl $0xe, -0x4c(%rbp)
jmp 0x584a3
jmp 0x5849c
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/ctl.c
// Function: arena_i_decay_time_ctl
static int
arena_i_decay_time_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;
	unsigned arena_ind = (unsigned)mib[1];
	arena_t *arena;

	arena = arena_get(tsd_tsdn(tsd), arena_ind, false);
	if (arena == NULL) {
		ret = EFAULT;
		goto label_return;
	}

	if (oldp != NULL && oldlenp != NULL) {
		size_t oldval = arena_decay_time_get(tsd_tsdn(tsd), arena);
		READ(oldval, ssize_t);
	}
	if (newp != NULL) {
		if (newlen != sizeof(ssize_t)) {
			ret = EINVAL;
			goto label_return;
		}
		if (arena_decay_time_set(tsd_tsdn(tsd), arena,
		    *(ssize_t *)newp)) {
			ret = EFAULT;
			goto label_return;
		}
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq %r9, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl -0x50(%rbp), %esi
xorl %edx, %edx
callq 0x54b20
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x5850c
movl $0xe, -0x4c(%rbp)
jmp 0x585f3
cmpq $0x0, -0x38(%rbp)
je 0x585a8
cmpq $0x0, -0x40(%rbp)
je 0x585a8
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x3b520
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x585a4
cmpq $0x0, -0x40(%rbp)
je 0x585a4
movq -0x40(%rbp), %rax
cmpq $0x8, (%rax)
je 0x58599
movq -0x40(%rbp), %rcx
movl $0x8, %eax
cmpq (%rcx), %rax
ja 0x5856c
movl $0x8, %eax
movq %rax, -0x70(%rbp)
jmp 0x58577
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x38(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq -0x60(%rbp), %rsi
callq 0xb310
movl $0x16, -0x4c(%rbp)
jmp 0x585f3
movq -0x60(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
jmp 0x585a6
jmp 0x585a8
cmpq $0x0, -0x48(%rbp)
je 0x585ec
cmpq $0x8, 0x10(%rbp)
je 0x585bf
movl $0x16, -0x4c(%rbp)
jmp 0x585f3
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x48(%rbp), %rax
movq (%rax), %rdx
callq 0x3b570
testb $0x1, %al
jne 0x585e1
jmp 0x585ea
movl $0xe, -0x4c(%rbp)
jmp 0x585f3
jmp 0x585ec
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/ctl.c
// Function: arena_i_purge
static void
arena_i_purge(tsdn_t *tsdn, unsigned arena_ind, bool all)
{

	malloc_mutex_lock(tsdn, &ctl_mtx);
	{
		unsigned narenas = ctl_stats.narenas;

		if (arena_ind == narenas) {
			unsigned i;
			VARIABLE_ARRAY(arena_t *, tarenas, narenas);

			for (i = 0; i < narenas; i++)
				tarenas[i] = arena_get(tsdn, i, false);

			/*
			 * No further need to hold ctl_mtx, since narenas and
			 * tarenas contain everything needed below.
			 */
			malloc_mutex_unlock(tsdn, &ctl_mtx);

			for (i = 0; i < narenas; i++) {
				if (tarenas[i] != NULL)
					arena_purge(tsdn, tarenas[i], all);
			}
		} else {
			arena_t *tarena;

			assert(arena_ind < narenas);

			tarena = arena_get(tsdn, arena_ind, false);

			/* No further need to hold ctl_mtx. */
			malloc_mutex_unlock(tsdn, &ctl_mtx);

			if (tarena != NULL)
				arena_purge(tsdn, tarena, all);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x4b83f(%rip), %rsi     # 0xa40e0
callq 0x54620
movl 0x4b8b4(%rip), %eax     # 0xa4160
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x58977
movl -0x14(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
leaq 0xf(,%rax,8), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x38(%rbp)
movq %rcx, %rsp
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x58918
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
xorl %edx, %edx
callq 0x54b20
movq %rax, %rdx
movq -0x38(%rbp), %rax
movl -0x18(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x588e9
movq -0x8(%rbp), %rdi
leaq 0x4b7bd(%rip), %rsi     # 0xa40e0
callq 0x549c0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x5896e
movq -0x38(%rbp), %rax
movl -0x18(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x58961
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x3b8a0
jmp 0x58963
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5892f
movq -0x20(%rbp), %rax
movq %rax, %rsp
jmp 0x589bb
jmp 0x58979
jmp 0x5897b
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x54b20
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x4b748(%rip), %rsi     # 0xa40e0
callq 0x549c0
cmpq $0x0, -0x30(%rbp)
je 0x589b9
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x3b8a0
jmp 0x589bb
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/ctl.c
// Function: arenas_narenas_ctl
static int
arenas_narenas_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;
	unsigned narenas;

	malloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);
	READONLY();
	if (*oldlenp != sizeof(unsigned)) {
		ret = EINVAL;
		goto label_return;
	}
	narenas = ctl_stats.narenas;
	READ(narenas, unsigned);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x4b6e9(%rip), %rsi     # 0xa40e0
callq 0x54620
cmpq $0x0, -0x40(%rbp)
jne 0x58a0a
cmpq $0x0, 0x10(%rbp)
je 0x58a16
movl $0x1, -0x44(%rbp)
jmp 0x58aa4
jmp 0x58a18
movq -0x38(%rbp), %rax
cmpq $0x4, (%rax)
je 0x58a2b
movl $0x16, -0x44(%rbp)
jmp 0x58aa4
movl 0x4b72f(%rip), %eax     # 0xa4160
movl %eax, -0x48(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x58a9b
cmpq $0x0, -0x38(%rbp)
je 0x58a9b
movq -0x38(%rbp), %rax
cmpq $0x4, (%rax)
je 0x58a92
movq -0x38(%rbp), %rcx
movl $0x4, %eax
cmpq (%rcx), %rax
ja 0x58a65
movl $0x4, %eax
movq %rax, -0x58(%rbp)
jmp 0x58a70
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq -0x48(%rbp), %rsi
callq 0xb310
movl $0x16, -0x44(%rbp)
jmp 0x58aa4
movl -0x48(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
jmp 0x58a9d
movl $0x0, -0x44(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x4b629(%rip), %rsi     # 0xa40e0
callq 0x549c0
movl -0x44(%rbp), %eax
addq $0x60, %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/ctl.c
// Function: arenas_initialized_ctl
static int
arenas_initialized_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;
	unsigned nread, i;

	malloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);
	READONLY();
	if (*oldlenp != ctl_stats.narenas * sizeof(bool)) {
		ret = EINVAL;
		nread = (*oldlenp < ctl_stats.narenas * sizeof(bool))
		    ? (unsigned)(*oldlenp / sizeof(bool)) : ctl_stats.narenas;
	} else {
		ret = 0;
		nread = ctl_stats.narenas;
	}

	for (i = 0; i < nread; i++)
		((bool *)oldp)[i] = ctl_stats.arenas[i].initialized;

label_return:
	malloc_mutex_unlock(tsd_tsdn(tsd), &ctl_mtx);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x4b5d9(%rip), %rsi     # 0xa40e0
callq 0x54620
cmpq $0x0, -0x40(%rbp)
jne 0x58b1a
cmpq $0x0, 0x10(%rbp)
je 0x58b26
movl $0x1, -0x44(%rbp)
jmp 0x58bcb
jmp 0x58b28
movq -0x38(%rbp), %rax
movq (%rax), %rax
movl 0x4b62b(%rip), %ecx     # 0xa4160
shlq $0x0, %rcx
cmpq %rcx, %rax
je 0x58b7c
movl $0x16, -0x44(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movl 0x4b60e(%rip), %ecx     # 0xa4160
shlq $0x0, %rcx
cmpq %rcx, %rax
jae 0x58b6b
movq -0x38(%rbp), %rax
movq (%rax), %rax
shrq $0x0, %rax
movl %eax, -0x50(%rbp)
jmp 0x58b74
movl 0x4b5ef(%rip), %eax     # 0xa4160
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0x58b8c
movl $0x0, -0x44(%rbp)
movl 0x4b5d7(%rip), %eax     # 0xa4160
movl %eax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x48(%rbp), %eax
jae 0x58bc9
movq 0x4b5c6(%rip), %rax     # 0xa4168
movl -0x4c(%rbp), %ecx
imulq $0xbd8, %rcx, %rcx      # imm = 0xBD8
addq %rcx, %rax
movb (%rax), %dl
movq -0x30(%rbp), %rax
movl -0x4c(%rbp), %ecx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x58b93
jmp 0x58bcb
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x4b502(%rip), %rsi     # 0xa40e0
callq 0x549c0
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/ctl.c
// Function: arenas_lg_dirty_mult_ctl
static int
arenas_lg_dirty_mult_ctl(tsd_t *tsd, const size_t *mib, size_t miblen,
    void *oldp, size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;

	if (oldp != NULL && oldlenp != NULL) {
		size_t oldval = arena_lg_dirty_mult_default_get();
		READ(oldval, ssize_t);
	}
	if (newp != NULL) {
		if (newlen != sizeof(ssize_t)) {
			ret = EINVAL;
			goto label_return;
		}
		if (arena_lg_dirty_mult_default_set(*(ssize_t *)newp)) {
			ret = EFAULT;
			goto label_return;
		}
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x58c98
cmpq $0x0, -0x28(%rbp)
je 0x58c98
callq 0x42ce0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x58c94
cmpq $0x0, -0x28(%rbp)
je 0x58c94
movq -0x28(%rbp), %rax
cmpq $0x8, (%rax)
je 0x58c89
movq -0x28(%rbp), %rcx
movl $0x8, %eax
cmpq (%rcx), %rax
ja 0x58c5c
movl $0x8, %eax
movq %rax, -0x50(%rbp)
jmp 0x58c67
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq -0x40(%rbp), %rsi
callq 0xb310
movl $0x16, -0x34(%rbp)
jmp 0x58cd3
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x58c96
jmp 0x58c98
cmpq $0x0, -0x30(%rbp)
je 0x58ccc
cmpq $0x8, 0x10(%rbp)
je 0x58caf
movl $0x16, -0x34(%rbp)
jmp 0x58cd3
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x42d30
testb $0x1, %al
jne 0x58cc1
jmp 0x58cca
movl $0xe, -0x34(%rbp)
jmp 0x58cd3
jmp 0x58ccc
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/ctl.c
// Function: arenas_decay_time_ctl
static int
arenas_decay_time_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;

	if (oldp != NULL && oldlenp != NULL) {
		size_t oldval = arena_decay_time_default_get();
		READ(oldval, ssize_t);
	}
	if (newp != NULL) {
		if (newlen != sizeof(ssize_t)) {
			ret = EINVAL;
			goto label_return;
		}
		if (arena_decay_time_default_set(*(ssize_t *)newp)) {
			ret = EFAULT;
			goto label_return;
		}
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x58d88
cmpq $0x0, -0x28(%rbp)
je 0x58d88
callq 0x42db0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x58d84
cmpq $0x0, -0x28(%rbp)
je 0x58d84
movq -0x28(%rbp), %rax
cmpq $0x8, (%rax)
je 0x58d79
movq -0x28(%rbp), %rcx
movl $0x8, %eax
cmpq (%rcx), %rax
ja 0x58d4c
movl $0x8, %eax
movq %rax, -0x50(%rbp)
jmp 0x58d57
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq -0x40(%rbp), %rsi
callq 0xb310
movl $0x16, -0x34(%rbp)
jmp 0x58dc3
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x58d86
jmp 0x58d88
cmpq $0x0, -0x30(%rbp)
je 0x58dbc
cmpq $0x8, 0x10(%rbp)
je 0x58d9f
movl $0x16, -0x34(%rbp)
jmp 0x58dc3
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x42dd0
testb $0x1, %al
jne 0x58db1
jmp 0x58dba
movl $0xe, -0x34(%rbp)
jmp 0x58dc3
jmp 0x58dbc
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/ctl.c
// Function: arenas_extend_ctl
static int
arenas_extend_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;
	unsigned narenas;

	malloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);
	READONLY();
	if (ctl_grow(tsd_tsdn(tsd))) {
		ret = EAGAIN;
		goto label_return;
	}
	narenas = ctl_stats.narenas - 1;
	READ(narenas, unsigned);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq %r9, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x4ad59(%rip), %rsi     # 0xa40e0
callq 0x54620
cmpq $0x0, -0x48(%rbp)
jne 0x5939a
cmpq $0x0, 0x10(%rbp)
je 0x593a6
movl $0x1, -0x4c(%rbp)
jmp 0x59444
jmp 0x593a8
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x599e0
testb $0x1, %al
jne 0x593bf
jmp 0x593c8
movl $0xb, -0x4c(%rbp)
jmp 0x59444
movl 0x4ad92(%rip), %eax     # 0xa4160
subl $0x1, %eax
movl %eax, -0x50(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x5943b
cmpq $0x0, -0x40(%rbp)
je 0x5943b
movq -0x40(%rbp), %rax
cmpq $0x4, (%rax)
je 0x59432
movq -0x40(%rbp), %rcx
movl $0x4, %eax
cmpq (%rcx), %rax
ja 0x59405
movl $0x4, %eax
movq %rax, -0x60(%rbp)
jmp 0x59410
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq -0x50(%rbp), %rsi
callq 0xb310
movl $0x16, -0x4c(%rbp)
jmp 0x59444
movl -0x50(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
jmp 0x5943d
movl $0x0, -0x4c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x4ac89(%rip), %rsi     # 0xa40e0
callq 0x549c0
movl -0x4c(%rbp), %eax
addq $0x60, %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/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x49ccd(%rip), %rsi     # 0xa40e0
callq 0x54620
movq -0x20(%rbp), %rax
movl 0x49d3e(%rip), %ecx     # 0xa4160
cmpq %rcx, %rax
ja 0x5a43e
movq 0x49d3a(%rip), %rax     # 0xa4168
imulq $0xbd8, -0x20(%rbp), %rcx # imm = 0xBD8
addq %rcx, %rax
testb $0x1, (%rax)
jne 0x5a448
movq $0x0, -0x28(%rbp)
jmp 0x5a453
leaq 0x480e1(%rip), %rax     # 0xa2530
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x49c82(%rip), %rsi     # 0xa40e0
callq 0x549c0
movq -0x28(%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/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x60b50
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x5d4de
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5d512
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x60bc0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x5d4fc
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5d512
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5f0e0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)