LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/base.c
// Function: je_base_stats_get
void
base_stats_get(tsdn_t *tsdn, size_t *allocated, size_t *resident,
    size_t *mapped)
{

	malloc_mutex_lock(tsdn, &base_mtx);
	assert(base_allocated <= base_resident);
	assert(base_resident <= base_mapped);
	*allocated = base_allocated;
	*resident = base_resident;
	*mapped = base_mapped;
	malloc_mutex_unlock(tsdn, &base_mtx);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x26c74(%rip), %r12     # 0x4cfd8
movq %r12, %rdi
callq 0xb5a0
movq 0x26cbd(%rip), %rax     # 0x4d030
movq %rax, (%r15)
movq 0x26cbb(%rip), %rax     # 0x4d038
movq %rax, (%r14)
movq 0x26cb9(%rip), %rax     # 0x4d040
movq %rax, (%rbx)
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/base.c
// Function: je_base_boot
bool
base_boot(void)
{

	if (malloc_mutex_init(&base_mtx, "base", WITNESS_RANK_BASE))
		return (true);
	base_extent_sn_next = 0;
	extent_tree_szsnad_new(&base_avail_szsnad);
	base_nodes = NULL;

	return (false);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x26c30(%rip), %rdi     # 0x4cfd8
leaq 0x16619(%rip), %rsi     # 0x3c9c8
movl $0xb, %edx
callq 0x2e5dc
movl %eax, %ebx
testb %al, %al
jne 0x263dc
xorl %r14d, %r14d
movq %r14, 0x26c7f(%rip)     # 0x4d048
leaq 0x26c58(%rip), %rdi     # 0x4d028
callq 0x2c3ec
movq %r14, 0x26c74(%rip)     # 0x4d050
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/bitmap.c
// Function: je_bitmap_init
void
bitmap_init(bitmap_t *bitmap, const bitmap_info_t *binfo)
{
	size_t extra;

	memset(bitmap, 0xffU, bitmap_size(binfo));
	extra = (BITMAP_GROUP_NBITS - (binfo->nbits & BITMAP_GROUP_NBITS_MASK))
	    & BITMAP_GROUP_NBITS_MASK;
	if (extra != 0)
		bitmap[binfo->ngroups - 1] >>= extra;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
shlq $0x3, %rdx
movl $0xff, %esi
callq 0xb230
xorl %ecx, %ecx
subl (%r14), %ecx
andl $0x3f, %ecx
je 0x2644b
movq 0x8(%r14), %rax
shrq %cl, -0x8(%rbx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/chunk.c
// Function: chunk_alloc_default
static void *
chunk_alloc_default(void *new_addr, size_t size, size_t alignment, bool *zero,
    bool *commit, unsigned arena_ind)
{
	tsdn_t *tsdn;
	arena_t *arena;

	tsdn = tsdn_fetch();
	arena = chunk_arena_get(tsdn, arena_ind);

	return (chunk_alloc_default_impl(tsdn, arena, new_addr, size, alignment,
	    zero, commit));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebx
movq %r8, %r12
movq %rcx, %r9
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
leaq 0x2702d(%rip), %rax     # 0x4d4b0
cmpb $0x1, (%rax)
jne 0x264b5
movq 0x25b59(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %rbp
addq %rax, %rbp
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x264fa
cmpl $0x2, %ecx
jne 0x264b7
movq %r9, 0x10(%rsp)
movl $0x3, %fs:(%rax)
jmp 0x26506
xorl %ebp, %ebp
leaq 0x260f2(%rip), %rax     # 0x4c5b0
movq (%rax), %rax
movl %ebx, %ecx
movq (%rax,%rcx,8), %rsi
testq %rsi, %rsi
je 0x264f0
movq %r12, (%rsp)
movq %rbp, %rdi
movq %r13, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x26f29
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %esi, %esi
lock
xaddq %rsi, (%rax,%rcx,8)
jmp 0x264cc
movq %r9, 0x10(%rsp)
movl $0x1, %fs:(%rax)
leaq 0x26fc7(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %rbp, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x26541
leaq 0x15c5f(%rip), %rdi     # 0x3c181
callq 0x35efc
leaq 0x25ff2(%rip), %rax     # 0x4c520
cmpb $0x1, (%rax)
movq 0x10(%rsp), %r9
jne 0x264b7
callq 0xb070
movq 0x10(%rsp), %r9
jmp 0x264b7
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/chunk.c
// Function: je_chunk_hooks_get
chunk_hooks_t
chunk_hooks_get(tsdn_t *tsdn, arena_t *arena)
{
	chunk_hooks_t chunk_hooks;

	malloc_mutex_lock(tsdn, &arena->chunks_mtx);
	chunk_hooks = chunk_hooks_get_locked(arena);
	malloc_mutex_unlock(tsdn, &arena->chunks_mtx);

	return (chunk_hooks);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8a0(%rdx), %r15
movq %r15, %rdi
callq 0xb5a0
movups 0x948(%rbx), %xmm0
movups 0x958(%rbx), %xmm1
movups 0x968(%rbx), %xmm2
movups %xmm0, (%r14)
movups %xmm1, 0x10(%r14)
movups %xmm2, 0x20(%r14)
movq 0x978(%rbx), %rax
movq %rax, 0x30(%r14)
movq %r15, %rdi
callq 0xb380
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/chunk.c
// Function: je_chunk_hooks_set
chunk_hooks_t
chunk_hooks_set(tsdn_t *tsdn, arena_t *arena, const chunk_hooks_t *chunk_hooks)
{
	chunk_hooks_t old_chunk_hooks;

	malloc_mutex_lock(tsdn, &arena->chunks_mtx);
	old_chunk_hooks = arena->chunk_hooks;
	/*
	 * Copy each field atomically so that it is impossible for readers to
	 * see partially updated pointers.  There are places where readers only
	 * need one hook function pointer (therefore no need to copy the
	 * entirety of arena->chunk_hooks), and stale reads do not affect
	 * correctness, so they perform unlocked reads.
	 */
#define	ATOMIC_COPY_HOOK(n) do {					\
	union {								\
		chunk_##n##_t	**n;					\
		void		**v;					\
	} u;								\
	u.n = &arena->chunk_hooks.n;					\
	atomic_write_p(u.v, chunk_hooks->n);				\
} while (0)
	ATOMIC_COPY_HOOK(alloc);
	ATOMIC_COPY_HOOK(dalloc);
	ATOMIC_COPY_HOOK(commit);
	ATOMIC_COPY_HOOK(decommit);
	ATOMIC_COPY_HOOK(purge);
	ATOMIC_COPY_HOOK(split);
	ATOMIC_COPY_HOOK(merge);
#undef ATOMIC_COPY_HOOK
	malloc_mutex_unlock(tsdn, &arena->chunks_mtx);

	return (old_chunk_hooks);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x8a0(%rdx), %r15
movq %r15, %rdi
callq 0xb5a0
movups 0x948(%r14), %xmm0
movups 0x958(%r14), %xmm1
movups 0x968(%r14), %xmm2
movups %xmm0, (%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm2, 0x20(%rbx)
movq 0x978(%r14), %rax
movq %rax, 0x30(%rbx)
movq (%r12), %rax
xchgq %rax, 0x948(%r14)
movq 0x8(%r12), %rax
xchgq %rax, 0x950(%r14)
movq 0x10(%r12), %rax
xchgq %rax, 0x958(%r14)
movq 0x18(%r12), %rax
xchgq %rax, 0x960(%r14)
movq 0x20(%r12), %rax
xchgq %rax, 0x968(%r14)
movq 0x28(%r12), %rax
xchgq %rax, 0x970(%r14)
movq 0x30(%r12), %rax
xchgq %rax, 0x978(%r14)
movq %r15, %rdi
callq 0xb380
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/include/jemalloc/internal/rtree.h
// Function: je_rtree_set
JEMALLOC_INLINE bool
rtree_set(rtree_t *rtree, uintptr_t key, const extent_node_t *val)
{
	uintptr_t subkey;
	unsigned i, start_level;
	rtree_node_elm_t *node, *child;

	start_level = rtree_start_level(rtree, key);

	node = rtree_subtree_read(rtree, start_level, false);
	if (node == NULL)
		return (true);
	for (i = start_level; /**/; i++, node = child) {
		subkey = rtree_subkey(rtree, key, i);
		if (i == rtree->height - 1) {
			/*
			 * node is a leaf, so it contains values rather than
			 * child pointers.
			 */
			rtree_val_write(rtree, &node[subkey], val);
			return (false);
		}
		assert(i + 1 < rtree->height);
		child = rtree_child_read(rtree, &node[subkey], i, false);
		if (child == NULL)
			return (true);
	}
	not_reached();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x267dc
bsrq %r14, %rax
shrl $0x4, %eax
leaq 0x26974(%rip), %rcx     # 0x4d060
movl 0x14(%rcx,%rax,4), %r15d
movl %r15d, %r13d
movq %r13, %rcx
shlq $0x4, %rcx
leaq 0x2695e(%rip), %r12     # 0x4d060
movq 0x28(%rcx,%r12), %rax
cmpq $0x1, %rax
jbe 0x267eb
cmpq $0x1, %rax
jbe 0x267fe
movb $0x1, %bpl
testq %rax, %rax
je 0x2675c
shlq $0x4, %r13
xorl %ecx, %ecx
subb 0x34(%r13,%r12), %cl
movq %r14, %rsi
shrq %cl, %rsi
movb 0x30(%r13,%r12), %cl
movq $-0x1, %rdx
shlq %cl, %rdx
notq %rdx
andq %rsi, %rdx
movl 0x26921(%rip), %ecx     # 0x4d070
decl %ecx
cmpl %ecx, %r15d
jne 0x2676d
xchgq %rbx, (%rax,%rdx,8)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq (%rax,%rdx,8), %rsi
movq (%rsi), %rax
cmpq $0x1, %rax
ja 0x26781
xorl %eax, %eax
lock
xaddq %rax, (%rsi)
cmpq $0x1, %rax
jbe 0x267cf
testq %rax, %rax
je 0x2675c
leal 0x1(%r15), %esi
movq %rsi, %rdx
shlq $0x4, %rdx
movb 0x34(%rdx,%r12), %dil
xorl %ecx, %ecx
subb %dil, %cl
movq %r14, %rdi
shrq %cl, %rdi
movb 0x30(%rdx,%r12), %cl
movq $-0x1, %rdx
shlq %cl, %rdx
notq %rdx
andq %rdi, %rdx
movl 0x268ae(%rip), %ecx     # 0x4d070
addl $-0x2, %ecx
cmpl %ecx, %r15d
movl %esi, %r15d
jne 0x2676d
jmp 0x26756
movq %r12, %rdi
movl %r15d, %edx
callq 0x3078f
jmp 0x26787
movl 0x2688d(%rip), %r15d    # 0x4d070
decl %r15d
jmp 0x266f1
addq %r12, %rcx
addq $0x28, %rcx
xorl %eax, %eax
lock
xaddq %rax, (%rcx)
jmp 0x26711
leaq 0x2685b(%rip), %rdi     # 0x4d060
movl %r15d, %esi
callq 0x306fc
jmp 0x2671b
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/chunk.c
// Function: je_chunk_alloc_base
void *
chunk_alloc_base(size_t size)
{
	void *ret;
	bool zero, commit;

	/*
	 * Directly call chunk_alloc_mmap() rather than chunk_alloc_core()
	 * because it's critical that chunk_alloc_base() return untouched
	 * demand-zeroed virtual memory.
	 */
	zero = true;
	commit = true;
	ret = chunk_alloc_mmap(NULL, size, chunksize, &zero, &commit);
	if (ret == NULL)
		return (NULL);
	if (config_valgrind)
		JEMALLOC_VALGRIND_MAKE_MEM_UNDEFINED(ret, size);

	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movb $0x1, %al
leaq 0xf(%rsp), %rcx
movb %al, (%rcx)
leaq 0xe(%rsp), %r8
movb %al, (%r8)
movq 0x2688b(%rip), %rdx     # 0x4d0c8
xorl %r14d, %r14d
xorl %edi, %edi
movq %rbx, %rsi
callq 0x278bc
testq %rax, %rax
je 0x26861
movq %rax, %r15
leaq 0x25d43(%rip), %rax     # 0x4c59c
cmpb $0x1, (%rax)
je 0x2686e
movq %r15, %r14
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %rbx, %rsi
callq 0x37116
jmp 0x2685e
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/chunk.c
// Function: je_chunk_alloc_cache
void *
chunk_alloc_cache(tsdn_t *tsdn, arena_t *arena, chunk_hooks_t *chunk_hooks,
    void *new_addr, size_t size, size_t alignment, size_t *sn, bool *zero,
    bool *commit, bool dalloc_node)
{
	void *ret;

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

	ret = chunk_recycle(tsdn, arena, chunk_hooks,
	    &arena->chunks_szsnad_cached, &arena->chunks_ad_cached, true,
	    new_addr, size, alignment, sn, zero, commit, dalloc_node);
	if (ret == NULL)
		return (NULL);
	if (config_valgrind)
		JEMALLOC_VALGRIND_MAKE_MEM_UNDEFINED(ret, size);
	return (ret);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movaps 0x50(%rsp), %xmm0
movq 0x60(%rsp), %r10
leaq 0x880(%rsi), %rax
leaq 0x888(%rsi), %r8
movzbl 0x68(%rsp), %r11d
movl %r11d, 0x30(%rsp)
movq %r10, 0x28(%rsp)
movups %xmm0, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq %rbx, 0x8(%rsp)
movq %rcx, (%rsp)
movq %rax, %rcx
movl $0x1, %r9d
callq 0x268fd
testq %rax, %rax
je 0x268ef
movq %rax, %r14
leaq 0x25cbf(%rip), %rax     # 0x4c59c
cmpb $0x1, (%rax)
jne 0x268f2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x37116
jmp 0x268f2
xorl %r14d, %r14d
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/chunk.c
// Function: je_chunk_alloc_wrapper
void *
chunk_alloc_wrapper(tsdn_t *tsdn, arena_t *arena, chunk_hooks_t *chunk_hooks,
    void *new_addr, size_t size, size_t alignment, size_t *sn, bool *zero,
    bool *commit)
{
	void *ret;

	chunk_hooks_assure_initialized(tsdn, arena, chunk_hooks);

	ret = chunk_alloc_retained(tsdn, arena, chunk_hooks, new_addr, size,
	    alignment, sn, zero, commit);
	if (ret == NULL) {
		if (chunk_hooks->alloc == chunk_alloc_default) {
			/* Call directly to propagate tsdn. */
			ret = chunk_alloc_default_impl(tsdn, arena, new_addr,
			    size, alignment, zero, commit);
		} else {
			ret = chunk_hooks->alloc(new_addr, size, alignment,
			    zero, commit, arena->ind);
		}

		if (ret == NULL)
			return (NULL);

		*sn = arena_extent_sn_next(arena);

		if (config_valgrind && chunk_hooks->alloc !=
		    chunk_alloc_default)
			JEMALLOC_VALGRIND_MAKE_MEM_UNDEFINED(ret, chunksize);
	}

	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbp
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x26e8d
leaq 0x890(%r14), %rcx
leaq 0x898(%r14), %r8
subq $0x8, %rsp
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
xorl %r9d, %r9d
pushq $0x1
pushq 0x60(%rsp)
pushq 0x60(%rsp)
pushq 0x60(%rsp)
movq %rbp, 0x28(%rsp)
pushq %rbp
pushq %r12
pushq %r15
callq 0x268fd
addq $0x40, %rsp
testq %rax, %rax
je 0x26dee
movq %rax, %rbp
subq %r12, 0x68(%r14)
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq 0x48(%rsp), %r11
movq 0x50(%rsp), %r10
movq (%rsp), %r8
movq (%r13), %rax
leaq -0x9ae(%rip), %rbx      # 0x2645c
cmpq %rbx, %rax
je 0x26e25
movl (%r14), %r9d
movq %r15, %rdi
movq %r12, %rsi
movq %r8, %rdx
movq %r11, %rcx
movq %r10, %r8
callq *%rax
jmp 0x26e40
subq $0x8, %rsp
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r11, %r9
pushq %r10
callq 0x26f29
addq $0x10, %rsp
movq %rax, %rbp
movq 0x40(%rsp), %r15
testq %rax, %rax
je 0x26e86
movq %r14, %rdi
callq 0x23e89
movq %rax, (%r15)
cmpq %rbx, (%r13)
je 0x26ddc
leaq 0x25733(%rip), %rax     # 0x4c59c
cmpb $0x1, (%rax)
jne 0x26ddc
movq 0x2624f(%rip), %rsi     # 0x4d0c8
movq %rbp, %rdi
callq 0x37116
jmp 0x26ddc
xorl %ebp, %ebp
jmp 0x26ddc
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq 0x60(%rsp), %r8
movl 0xf8(%rsi), %ebx
cmpl $0x1, %ebx
jne 0x26f93
movq %r8, (%rsp)
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %rcx, %r12
movq %r15, %r8
movq %r13, 0x10(%rsp)
movq %r15, %r13
movq %r9, %r15
callq 0x275b0
movq 0x60(%rsp), %r8
movq %r15, %r9
movq %r13, %r15
movq 0x10(%rsp), %r13
movq %r12, %rcx
testq %rax, %rax
je 0x26f93
movq %rax, %r12
jmp 0x26ff3
movq %r9, 0x20(%rsp)
movq %r14, 0x18(%rsp)
movq %r13, %rdi
movq %rcx, 0x10(%rsp)
movq %rcx, %rsi
movq %r15, %rdx
movq %r9, %rcx
movq %r8, %r14
callq 0x278bc
testq %rax, %rax
je 0x26fc0
movq %rax, %r12
jmp 0x26fee
movq 0x20(%rsp), %r9
cmpl $0x2, %ebx
jne 0x26feb
movq %r14, (%rsp)
movq 0x18(%rsp), %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq 0x10(%rsp), %rcx
movq %r15, %r8
callq 0x275b0
testq %rax, %rax
jne 0x26fbb
xorl %r12d, %r12d
movq 0x10(%rsp), %rcx
testq %r12, %r12
je 0x27011
leaq 0x2559d(%rip), %rax     # 0x4c59c
cmpb $0x1, (%rax)
jne 0x27014
movq %r12, %rdi
movq %rcx, %rsi
callq 0x37116
jmp 0x27014
xorl %r12d, %r12d
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %r9, %rax
movq %r8, %r10
movq %rcx, %r11
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x880(%rsi), %rcx
leaq 0x888(%rsi), %r8
subq $0x8, %rsp
movzbl 0x28(%rsp), %r15d
movl $0x1, %r9d
pushq %r15
pushq $0x0
pushq %rax
pushq %r10
pushq %r11
callq 0x2707a
addq $0x30, %rsp
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x22368
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/chunk.c
// Function: je_chunk_dalloc_wrapper
void
chunk_dalloc_wrapper(tsdn_t *tsdn, arena_t *arena, chunk_hooks_t *chunk_hooks,
    void *chunk, size_t size, size_t sn, bool zeroed, bool committed)
{
	bool err;

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

	chunk_hooks_assure_initialized(tsdn, arena, chunk_hooks);
	/* Try to deallocate. */
	if (chunk_hooks->dalloc == chunk_dalloc_default) {
		/* Call directly to propagate tsdn. */
		err = chunk_dalloc_default_impl(chunk, size);
	} else
		err = chunk_hooks->dalloc(chunk, size, committed, arena->ind);

	if (!err)
		return;
	/* Try to decommit; purge if that fails. */
	if (committed) {
		committed = chunk_hooks->decommit(chunk, size, 0, size,
		    arena->ind);
	}
	zeroed = !committed || !chunk_hooks->purge(chunk, size, 0, size,
	    arena->ind);
	chunk_record(tsdn, arena, chunk_hooks, &arena->chunks_szsnad_retained,
	    &arena->chunks_ad_retained, false, chunk, size, sn, zeroed,
	    committed);

	if (config_stats)
		arena->stats.retained += size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbp
movb 0x48(%rsp), %r12b
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x26e8d
movq 0x8(%r13), %rax
leaq -0xeda(%rip), %rcx      # 0x2654b
cmpq %rcx, %rax
je 0x2743b
movl (%r14), %ecx
movzbl %r12b, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq *%rax
jmp 0x27452
movq %r15, %rdi
callq 0x27840
testb %al, %al
jne 0x27456
movq %r15, %rdi
movq %rbx, %rsi
callq 0x27978
testb %al, %al
je 0x274c7
testb %r12b, %r12b
je 0x27470
movl (%r14), %r8d
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq *0x18(%r13)
movl %eax, %r12d
movb $0x1, %al
testb %r12b, %r12b
je 0x2748b
movl (%r14), %r8d
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq *0x20(%r13)
xorb $0x1, %al
leaq 0x890(%r14), %rcx
leaq 0x898(%r14), %r8
subq $0x8, %rsp
movzbl %r12b, %r10d
movzbl %al, %eax
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
xorl %r9d, %r9d
pushq %r10
pushq %rax
pushq 0x18(%rsp)
pushq %rbx
pushq %r15
callq 0x2707a
addq $0x30, %rsp
addq %rbx, 0x68(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
xorl %edi, %edi
callq 0xb2a0
movq %rax, 0x2584f(%rip)     # 0x4d0f0
xorl %ecx, %ecx
cmpq $-0x1, %rax
sete %cl
movl %ecx, 0x25830(%rip)     # 0x4d0e0
movq %rax, 0x25831(%rip)     # 0x4d0e8
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %r8, %rdx
callq 0x2e758
testq %rax, %rax
sete %cl
cmpq %r13, %rax
sete %dl
orb %cl, %dl
jne 0x27969
leaq -0x1(%r15), %rbx
testq %rax, %rbx
je 0x27916
movq %rax, %rdi
movq %r12, %rsi
callq 0x2e7c4
leaq (%r12,%r15), %r13
addq $-0x1000, %r13          # imm = 0xF000
cmpq %r12, %r13
jae 0x2791c
xorl %eax, %eax
jmp 0x27969
movq %rbp, (%rsp)
jmp 0x27962
movq %rbp, (%rsp)
negq %r15
xorl %edi, %edi
movq %r13, %rsi
movq %r14, %rdx
callq 0x2e758
movq %rax, %rbp
movl $0x0, %eax
testq %rbp, %rbp
je 0x27958
leaq (%rbx,%rbp), %rdx
andq %r15, %rdx
subq %rbp, %rdx
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rcx
movq %r14, %r8
callq 0x2e812
testq %rbp, %rbp
je 0x27912
testq %rax, %rax
je 0x27923
movq (%rsp), %rcx
movb $0x1, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, %r12
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %r13
cmpb $0x0, 0x25755(%rip)     # 0x4d0f8
jne 0x279b8
movq %r13, %rdi
callq 0x27a21
movl %eax, %ecx
movl $0xb, %eax
testb %cl, %cl
jne 0x27a12
leaq 0x8(%rsp), %r8
movq $0x6, (%r8)
leaq 0x40(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x27b80
testl %eax, %eax
jne 0x27a12
movq 0x8(%rsp), %rdx
movq 0x38(%rsp,%rdx,8), %rcx
movl $0x2, %eax
cmpb $0x1, (%rcx)
jne 0x27a12
movq 0x20(%rcx), %r10
testq %r10, %r10
je 0x27a12
movq %r12, (%rsp)
leaq 0x10(%rsp), %rsi
movq %r13, %rdi
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
callq *%r10
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/ctl.c
// Function: je_ctl_bymib
int
ctl_bymib(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;
	const ctl_named_node_t *node;
	size_t i;

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

	/* Iterate down the tree. */
	node = super_root_node;
	for (i = 0; i < miblen; i++) {
		assert(node);
		assert(node->nchildren > 0);
		if (ctl_named_node(node->children) != NULL) {
			/* Children are named. */
			if (node->nchildren <= (unsigned)mib[i]) {
				ret = ENOENT;
				goto label_return;
			}
			node = ctl_named_children(node, mib[i]);
		} else {
			const ctl_indexed_node_t *inode;

			/* Indexed element. */
			inode = ctl_indexed_node(node->children);
			node = inode->index(tsd_tsdn(tsd), mib, miblen, mib[i]);
			if (node == NULL) {
				ret = ENOENT;
				goto label_return;
			}
		}
	}

	/* Call the ctl function. */
	if (node && node->ctl)
		ret = node->ctl(tsd, mib, miblen, oldp, oldlenp, newp, newlen);
	else {
		/* Partial MIB. */
		ret = ENOENT;
	}

label_return:
	return(ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
cmpb $0x0, 0x252df(%rip)     # 0x4d0f8
jne 0x27e30
movq %rbp, %rdi
callq 0x27a21
movl $0xb, %ecx
testb %al, %al
jne 0x27eb1
leaq 0x224a9(%rip), %rax     # 0x4a2e0
testq %r12, %r12
je 0x27e76
xorl %ebx, %ebx
movq 0x18(%rax), %r8
movq (%r13,%rbx,8), %rcx
cmpb $0x1, (%r8)
jne 0x27e5c
cmpl %ecx, 0x10(%rax)
jbe 0x27eac
leaq (%rcx,%rcx,4), %rax
leaq (%r8,%rax,8), %rax
jmp 0x27e6e
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq *0x8(%r8)
testq %rax, %rax
je 0x27eac
incq %rbx
cmpq %rbx, %r12
jne 0x27e3e
movl $0x2, %ecx
testq %rax, %rax
je 0x27eb1
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x27eb1
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq (%rsp), %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movl $0x2, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/ctl.c
// Function: ctl_arena_init
static bool
ctl_arena_init(ctl_arena_stats_t *astats)
{

	if (astats->lstats == NULL) {
		astats->lstats = (malloc_large_stats_t *)a0malloc(nlclasses *
		    sizeof(malloc_large_stats_t));
		if (astats->lstats == NULL)
			return (true);
	}

	if (astats->hstats == NULL) {
		astats->hstats = (malloc_huge_stats_t *)a0malloc(nhclasses *
		    sizeof(malloc_huge_stats_t));
		if (astats->hstats == NULL)
			return (true);
	}

	return (false);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0xbc8(%rdi)
jne 0x27f38
leaq 0x246b3(%rip), %rax     # 0x4c5d4
movl (%rax), %edi
shlq $0x5, %rdi
callq 0x1ad50
movq %rax, 0xbc8(%rbx)
testq %rax, %rax
je 0x27f68
cmpq $0x0, 0xbd0(%rbx)
jne 0x27f64
leaq 0x2506f(%rip), %rax     # 0x4cfb8
movl (%rax), %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdi
callq 0x1ad50
movq %rax, 0xbd0(%rbx)
testq %rax, %rax
je 0x27f68
xorl %eax, %eax
jmp 0x27f6a
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/ctl.c
// Function: thread_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 %rbx
movl $0x1, %eax
orq 0x10(%rsp), %r9
jne 0x28a63
orq %r8, %rcx
jne 0x28a63
movq 0x235a7(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %rbx
addq %rax, %rbx
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x28a65
cmpl $0x2, %ecx
je 0x28a6e
movq %rbx, %rdi
callq 0x3585e
xorl %eax, %eax
popq %rbx
retq
movl $0x1, %fs:(%rax)
jmp 0x28a75
movl $0x3, %fs:(%rax)
leaq 0x24a58(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %rbx, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x28a59
leaq 0x136f0(%rip), %rdi     # 0x3c181
callq 0x35efc
leaq 0x23a83(%rip), %rax     # 0x4c520
cmpb $0x1, (%rax)
jne 0x28a59
callq 0xb070
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r9, %r12
movq %r8, %r14
movq %rcx, %rbx
movq %rdi, %r15
leaq 0x23c01(%rip), %rdi     # 0x4d100
callq 0xb5a0
movl $0x1, %ebp
orq 0x40(%rsp), %r12
jne 0x29564
leaq 0xc(%rsp), %rsi
movq %r15, %rdi
callq 0x11a2a
movl $0xe, %ebp
testb %al, %al
jne 0x29564
testq %rbx, %rbx
sete %al
testq %r14, %r14
sete %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x29564
movq (%r14), %rax
cmpq $0x4, %rax
jne 0x29549
movl 0xc(%rsp), %eax
movl %eax, (%rbx)
jmp 0x29564
movl $0x4, %edx
cmovbq %rax, %rdx
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0xb340
movl $0x16, %ebp
leaq 0x23b95(%rip), %rdi     # 0x4d100
callq 0xb380
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
leaq 0x23af4(%rip), %r14     # 0x4d100
movq %r14, %rdi
callq 0xb5a0
movl 0x23b66(%rip), %eax     # 0x4d180
xorl %r15d, %r15d
cmpq %rbx, %rax
leaq 0x21bf9(%rip), %rax     # 0x4b220
cmovaeq %rax, %r15
movq %r14, %rdi
callq 0xb380
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl $0x1, %ebx
orq 0x10(%rsp), %r9
jne 0x2967d
orq %r8, %rcx
jne 0x2967d
movl 0x8(%rsi), %esi
xorl %ebx, %ebx
xorl %edx, %edx
callq 0x29b32
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r9, %rbx
movq %r8, %r13
movq %rcx, %r12
movq %rdi, %r14
movl 0x8(%rsi), %eax
leaq 0x22d48(%rip), %rcx     # 0x4c5b0
movq (%rcx), %rcx
movq (%rcx,%rax,8), %r15
testq %r15, %r15
je 0x2990e
movl $0xe, %eax
testq %r15, %r15
je 0x29900
testq %r12, %r12
sete %al
testq %r13, %r13
sete %cl
orb %al, %cl
jne 0x298d3
movq %r14, %rdi
movq %r15, %rsi
callq 0x222e8
movq %rax, 0x8(%rsp)
movq (%r13), %r13
cmpq $0x8, %r13
jne 0x298b2
movq %rax, (%r12)
jmp 0x298c8
movl $0x8, %edx
cmovbq %r13, %rdx
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0xb340
movl $0x16, %eax
cmpq $0x8, %r13
jne 0x29900
testq %rbx, %rbx
je 0x298fe
movl $0x16, %eax
cmpq $0x8, 0x40(%rsp)
jne 0x29900
movq (%rbx), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x22315
movl %eax, %ecx
movl $0xe, %eax
testb %cl, %cl
jne 0x29900
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r15d, %r15d
lock
xaddq %r15, (%rcx,%rax,8)
jmp 0x29878
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r9, %rbx
movq %r8, %r13
movq %rcx, %r12
movq %rdi, %r14
movl 0x8(%rsi), %eax
leaq 0x22c71(%rip), %rcx     # 0x4c5b0
movq (%rcx), %rcx
movq (%rcx,%rax,8), %r15
testq %r15, %r15
je 0x299e5
movl $0xe, %eax
testq %r15, %r15
je 0x299d7
testq %r12, %r12
sete %al
testq %r13, %r13
sete %cl
orb %al, %cl
jne 0x299aa
movq %r14, %rdi
movq %r15, %rsi
callq 0x225ae
movq %rax, 0x8(%rsp)
movq (%r13), %r13
cmpq $0x8, %r13
jne 0x29989
movq %rax, (%r12)
jmp 0x2999f
movl $0x8, %edx
cmovbq %r13, %rdx
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0xb340
movl $0x16, %eax
cmpq $0x8, %r13
jne 0x299d7
testq %rbx, %rbx
je 0x299d5
movl $0x16, %eax
cmpq $0x8, 0x40(%rsp)
jne 0x299d7
movq (%rbx), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x225db
movl %eax, %ecx
movl $0xe, %eax
testb %cl, %cl
jne 0x299d7
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r15d, %r15d
lock
xaddq %r15, (%rcx,%rax,8)
jmp 0x2994f
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/ctl.c
// Function: arena_i_chunk_hooks_ctl
static int
arena_i_chunk_hooks_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;

	malloc_mutex_lock(tsd_tsdn(tsd), &ctl_mtx);
	if (arena_ind < narenas_total_get() && (arena =
	    arena_get(tsd_tsdn(tsd), arena_ind, false)) != NULL) {
		if (newp != NULL) {
			chunk_hooks_t old_chunk_hooks, new_chunk_hooks;
			WRITE(new_chunk_hooks, chunk_hooks_t);
			old_chunk_hooks = chunk_hooks_set(tsd_tsdn(tsd), arena,
			    &new_chunk_hooks);
			READ(old_chunk_hooks, chunk_hooks_t);
		} else {
			chunk_hooks_t old_chunk_hooks =
			    chunk_hooks_get(tsd_tsdn(tsd), arena);
			READ(old_chunk_hooks, chunk_hooks_t);
		}
	} else {
		ret = EFAULT;
		goto label_return;
	}
	ret = 0;
label_return:
	malloc_mutex_unlock(tsd_tsdn(tsd), &ctl_mtx);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, %r12
movq %r8, %r14
movq %rcx, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %r13
leaq 0x236e8(%rip), %rdi     # 0x4d100
callq 0xb5a0
callq 0x1ae79
movl $0xe, %ebp
cmpl %r13d, %eax
jbe 0x29b08
movl %r13d, %eax
leaq 0x22b76(%rip), %rcx     # 0x4c5b0
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rdx
testq %rdx, %rdx
je 0x29b25
testq %rdx, %rdx
je 0x29b08
testq %r12, %r12
je 0x29aa0
cmpq $0x38, 0xb0(%rsp)
jne 0x29b03
movq 0x30(%r12), %rax
leaq 0x40(%rsp), %rcx
movq %rax, 0x30(%rcx)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movaps %xmm2, 0x20(%rcx)
movaps %xmm1, 0x10(%rcx)
movaps %xmm0, (%rcx)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x26604
jmp 0x29aad
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x265ab
testq %rbx, %rbx
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x29ae9
movq (%r14), %rax
cmpq $0x38, %rax
jne 0x29aed
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rbx)
movups 0x8(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups 0x28(%rsp), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
xorl %ebp, %ebp
jmp 0x29b08
movl $0x38, %edx
cmovbq %rax, %rdx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xb340
movl $0x16, %ebp
leaq 0x235f1(%rip), %rdi     # 0x4d100
callq 0xb380
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edx, %edx
lock
xaddq %rdx, (%rcx,%rax,8)
jmp 0x29a4a
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x235b0(%rip), %rdi     # 0x4d100
callq 0xb5a0
movl 0x23624(%rip), %r12d    # 0x4d180
cmpl %r15d, %r12d
jne 0x29bb6
movq %rsp, -0x30(%rbp)
movq %rsp, %r13
leaq 0xf(,%r12,8), %rax
andq $-0x10, %rax
subq %rax, %r13
movq %r13, %rsp
testq %r12, %r12
je 0x29bfa
leaq (,%r12,8), %rax
xorl %ecx, %ecx
leaq 0x22a20(%rip), %rdx     # 0x4c5b0
movq (%rdx), %rdi
movq (%rdi,%rcx), %rsi
testq %rsi, %rsi
je 0x29bac
movq %rsi, (%r13,%rcx)
addq $0x8, %rcx
cmpq %rcx, %rax
jne 0x29b90
jmp 0x29bfa
xorl %esi, %esi
lock
xaddq %rsi, (%rdi,%rcx)
jmp 0x29b9c
leaq 0x229f3(%rip), %rax     # 0x4c5b0
movq (%rax), %rax
movl %r15d, %ecx
movq (%rax,%rcx,8), %r15
testq %r15, %r15
je 0x29c42
leaq 0x2352d(%rip), %rdi     # 0x4d100
callq 0xb380
testq %r15, %r15
je 0x29c33
movzbl %r14b, %edx
movq %rbx, %rdi
movq %r15, %rsi
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x226c8
leaq 0x234ff(%rip), %rdi     # 0x4d100
callq 0xb380
testq %r12, %r12
je 0x29c2f
xorl %r15d, %r15d
movzbl %r14b, %r14d
movq (%r13,%r15,8), %rsi
testq %rsi, %rsi
je 0x29c27
movq %rbx, %rdi
movl %r14d, %edx
callq 0x226c8
incq %r15
cmpq %r15, %r12
jne 0x29c12
movq -0x30(%rbp), %rsp
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
lock
xaddq %r15, (%rax,%rcx,8)
jmp 0x29bcc
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %r8, %r15
movq %rcx, %r14
leaq 0x23498(%rip), %rdi     # 0x4d100
callq 0xb5a0
movl $0x1, %ebx
orq 0x30(%rsp), %r12
jne 0x29c94
movl $0x16, %ebx
cmpq $0x4, (%r15)
jne 0x29c94
xorl %ebx, %ebx
testq %r14, %r14
je 0x29c94
movl 0x234ef(%rip), %eax     # 0x4d180
movl %eax, (%r14)
leaq 0x23465(%rip), %rdi     # 0x4d100
callq 0xb380
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r14
movq %rcx, %rbx
leaq 0x2343b(%rip), %rdi     # 0x4d100
callq 0xb5a0
movl $0x1, %ebp
orq 0x30(%rsp), %r15
jne 0x29d16
movq (%r14), %rcx
movl 0x234a1(%rip), %eax     # 0x4d180
xorl %edx, %edx
cmpq %rax, %rcx
cmovael %eax, %ecx
movl $0x16, %ebp
cmovel %edx, %ebp
cmovel %eax, %ecx
testl %ecx, %ecx
je 0x29d16
movq 0x2348b(%rip), %rax     # 0x4d188
movl %ecx, %ecx
xorl %edx, %edx
movb (%rax), %sil
movb %sil, (%rbx,%rdx)
incq %rdx
addq $0xbd8, %rax            # imm = 0xBD8
cmpq %rdx, %rcx
jne 0x29d01
leaq 0x233e3(%rip), %rdi     # 0x4d100
callq 0xb380
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r9, %rbx
movq %rcx, %r14
testq %rcx, %rcx
sete %al
testq %r8, %r8
sete %cl
orb %al, %cl
jne 0x29d8a
movq %r8, %r15
callq 0x23b07
movq %rax, 0x8(%rsp)
movq (%r15), %r15
cmpq $0x8, %r15
jne 0x29d69
movq %rax, (%r14)
jmp 0x29d7f
movl $0x8, %edx
cmovbq %r15, %rdx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xb340
movl $0x16, %eax
cmpq $0x8, %r15
jne 0x29db1
testq %rbx, %rbx
je 0x29daf
movl $0x16, %eax
cmpq $0x8, 0x30(%rsp)
jne 0x29db1
movq (%rbx), %rdi
callq 0x23b13
movl %eax, %ecx
movl $0xe, %eax
testb %cl, %cl
jne 0x29db1
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r9, %rbx
movq %rcx, %r14
testq %rcx, %rcx
sete %al
testq %r8, %r8
sete %cl
orb %al, %cl
jne 0x29e16
movq %r8, %r15
callq 0x23b34
movq %rax, 0x8(%rsp)
movq (%r15), %r15
cmpq $0x8, %r15
jne 0x29df5
movq %rax, (%r14)
jmp 0x29e0b
movl $0x8, %edx
cmovbq %r15, %rdx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xb340
movl $0x16, %eax
cmpq $0x8, %r15
jne 0x29e3d
testq %rbx, %rbx
je 0x29e3b
movl $0x16, %eax
cmpq $0x8, 0x30(%rsp)
jne 0x29e3d
movq (%rbx), %rdi
callq 0x23b40
movl %eax, %ecx
movl $0xe, %eax
testb %cl, %cl
jne 0x29e3d
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xbd8, %rsp            # imm = 0xBD8
movq %r9, %r12
movq %r8, %r14
movq %rcx, %rbx
movq %rdi, %r15
leaq 0x2302e(%rip), %rdi     # 0x4d100
callq 0xb5a0
movl $0x1, %ebp
orq 0xc10(%rsp), %r12
jne 0x2a221
movl 0x23090(%rip), %esi     # 0x4d180
movq %r15, %rdi
callq 0x1ae84
movl $0xb, %ebp
testq %rax, %rax
je 0x2a221
movl 0x23074(%rip), %eax     # 0x4d180
addl $0x2, %eax
imulq $0xbd8, %rax, %rdi      # imm = 0xBD8
callq 0x1ad50
testq %rax, %rax
je 0x2a221
movq %rax, %r15
movq 0x2305a(%rip), %rsi     # 0x4d188
movl 0x2304c(%rip), %eax     # 0x4d180
incl %eax
imulq $0xbd8, %rax, %r12      # imm = 0xBD8
movq %r15, %rdi
movq %r12, %rdx
callq 0xb340
addq %r15, %r12
movl $0xbd8, %edx            # imm = 0xBD8
movq %r12, %rdi
xorl %esi, %esi
callq 0xb230
movq %r12, %rdi
callq 0x27f0c
testb %al, %al
je 0x2a173
movq %r15, %rdi
callq 0x1ad5c
jmp 0x2a221
movl 0x23007(%rip), %ebp     # 0x4d180
imulq $0xbd8, %rbp, %r13      # imm = 0xBD8
addq %r15, %r13
movq %rsp, %r12
movl $0xbd8, %edx            # imm = 0xBD8
movq %r12, %rdi
movq %r13, %rsi
callq 0xb340
leal 0x1(%rbp), %eax
imulq $0xbd8, %rax, %rbp      # imm = 0xBD8
addq %r15, %rbp
movl $0xbd8, %edx            # imm = 0xBD8
movq %r13, %rdi
movq %rbp, %rsi
callq 0xb340
movl $0xbd8, %edx            # imm = 0xBD8
movq %rbp, %rdi
movq %r12, %rsi
callq 0xb340
movq 0x22fbe(%rip), %rdi     # 0x4d188
callq 0x1ad5c
movq %r15, 0x22fb2(%rip)     # 0x4d188
movl 0x22fa4(%rip), %eax     # 0x4d180
leal 0x1(%rax), %ecx
movl %ecx, 0x22f9b(%rip)     # 0x4d180
movl %eax, (%r12)
testq %rbx, %rbx
sete %cl
testq %r14, %r14
sete %dl
orb %cl, %dl
jne 0x2a204
movq (%r14), %rcx
cmpq $0x4, %rcx
jne 0x2a208
movl %eax, (%rbx)
xorl %ebp, %ebp
jmp 0x2a221
movl $0x4, %edx
cmovbq %rcx, %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xb340
movl $0x16, %ebp
leaq 0x22ed8(%rip), %rdi     # 0x4d100
callq 0xb380
movl %ebp, %eax
addq $0xbd8, %rsp            # imm = 0xBD8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/ctl.c
// Function: stats_arenas_i_index
static const ctl_named_node_t *
stats_arenas_i_index(tsdn_t *tsdn, const size_t *mib, size_t miblen, size_t i)
{
	const ctl_named_node_t * ret;

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

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

// Assembly:
pushq %rbx
movq %rcx, %rbx
leaq 0x228ae(%rip), %rdi     # 0x4d100
callq 0xb5a0
movl 0x22923(%rip), %eax     # 0x4d180
cmpq %rbx, %rax
jae 0x2a866
xorl %ebx, %ebx
jmp 0x2a885
movq 0x2291b(%rip), %rax     # 0x4d188
imulq $0xbd8, %rbx, %rcx      # imm = 0xBD8
leaq 0x20ca5(%rip), %rdx     # 0x4b520
xorl %ebx, %ebx
cmpb $0x0, (%rax,%rcx)
cmovneq %rdx, %rbx
leaq 0x22874(%rip), %rdi     # 0x4d100
callq 0xb380
movq %rbx, %rax
popq %rbx
retq