LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_jemalloc_postfork_child
void
jemalloc_postfork_child(void)
{
	tsd_t *tsd;
	unsigned i, narenas;

	assert(malloc_initialized());

	tsd = tsd_fetch();

	witness_postfork_child(tsd);
	/* Release all mutexes, now that fork() has completed. */
	base_postfork_child(tsd_tsdn(tsd));
	for (i = 0, narenas = narenas_total_get(); i < narenas; i++) {
		arena_t *arena;

		if ((arena = arena_get(tsd_tsdn(tsd), i, false)) != NULL)
			arena_postfork_child(tsd_tsdn(tsd), arena);
	}
	prof_postfork_child(tsd_tsdn(tsd));
	malloc_mutex_postfork_child(tsd_tsdn(tsd), &arenas_lock);
	ctl_postfork_child(tsd_tsdn(tsd));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x2f4bc(%rip), %rax     # 0x47ff0
movq %fs:0x0, %rbx
addq %rax, %rbx
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x18bce
cmpl $0x2, %ecx
je 0x18bd7
movq %rbx, %rdi
callq 0x32448
movq %rbx, %rdi
callq 0x21070
xorl %r14d, %r14d
xorl %eax, %eax
lock
xaddl %eax, 0x2f9cf(%rip)     # 0x48540
movl %eax, %r15d
shlq $0x3, %r15
cmpq %r14, %r15
je 0x18baa
movq 0x2fa2c(%rip), %rax     # 0x485b0
movq (%rax,%r14), %rsi
testq %rsi, %rsi
je 0x18b9b
movq %rbx, %rdi
callq 0x1ec44
addq $0x8, %r14
jmp 0x18b78
xorl %esi, %esi
lock
xaddq %rsi, (%rax,%r14)
testq %rsi, %rsi
jne 0x18b8d
jmp 0x18b95
movq %rbx, %rdi
callq 0x2aa64
leaq 0x2f98f(%rip), %rsi     # 0x48548
movq %rbx, %rdi
callq 0x2947c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2299b
movl $0x1, %fs:(%rax)
jmp 0x18bde
movl $0x3, %fs:(%rax)
leaq 0x308ef(%rip), %rax     # 0x494d4
movl (%rax), %edi
movq %rbx, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x18b54
leaq 0x1e183(%rip), %rdi     # 0x36d81
callq 0x3126c
cmpb $0x1, 0x2f916(%rip)     # 0x48520
jne 0x18b54
callq 0xb070
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: stats_print_atexit
static void
stats_print_atexit(void)
{

	if (config_tcache && config_stats) {
		tsdn_t *tsdn;
		unsigned narenas, i;

		tsdn = tsdn_fetch();

		/*
		 * Merge stats from extant threads.  This is racy, since
		 * individual threads do not lock when recording tcache stats
		 * events.  As a consequence, the final stats may be slightly
		 * out of date by the time they are reported, if other threads
		 * continue to allocate.
		 */
		for (i = 0, narenas = narenas_total_get(); i < narenas; i++) {
			arena_t *arena = arena_get(tsdn, i, false);
			if (arena != NULL) {
				tcache_t *tcache;

				/*
				 * tcache_stats_merge() locks bins, so if any
				 * code is introduced that acquires both arena
				 * and bin locks in the opposite order,
				 * deadlocks may result.
				 */
				malloc_mutex_lock(tsdn, &arena->lock);
				ql_foreach(tcache, &arena->tcache_ql, link) {
					tcache_stats_merge(tsdn, tcache, arena);
				}
				malloc_mutex_unlock(tsdn, &arena->lock);
			}
		}
	}
	je_malloc_stats_print(NULL, NULL, NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x2fb6c(%rip), %rax     # 0x494b0
cmpb $0x1, (%rax)
jne 0x19978
movq 0x2e6a0(%rip), %rax     # 0x47ff0
movq %fs:0x0, %rbx
addq %rax, %rbx
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x19a0c
cmpl $0x2, %ecx
jne 0x1997a
movl $0x3, %fs:(%rax)
jmp 0x19a13
xorl %ebx, %ebx
xorl %r13d, %r13d
xorl %eax, %eax
lock
xaddl %eax, 0x2ebb9(%rip)     # 0x48540
movl %eax, %ebp
cmpq %rbp, %r13
je 0x199f3
movq 0x2ec1b(%rip), %rax     # 0x485b0
movq (%rax,%r13,8), %r14
testq %r14, %r14
je 0x199e3
leaq 0x10(%r14), %r15
movq %r15, %rdi
callq 0xb5a0
movq 0xe0(%r14), %r12
testq %r12, %r12
je 0x199d6
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x30d23
movq (%r12), %r12
cmpq 0xe0(%r14), %r12
jne 0x199b1
xorl %r12d, %r12d
jmp 0x199b1
movq %r15, %rdi
callq 0xb380
incq %r13
jmp 0x19989
xorl %r14d, %r14d
lock
xaddq %r14, (%rax,%r13,8)
testq %r14, %r14
jne 0x1999e
jmp 0x199de
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18617
movl $0x1, %fs:(%rax)
leaq 0x2faba(%rip), %rax     # 0x494d4
movl (%rax), %edi
movq %rbx, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x1997a
leaq 0x1d34e(%rip), %rdi     # 0x36d81
callq 0x3126c
cmpb $0x1, 0x2eae1(%rip)     # 0x48520
jne 0x1997a
callq 0xb070
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_node_alloc
extent_node_t *
arena_node_alloc(tsdn_t *tsdn, arena_t *arena)
{
	extent_node_t *node;

	malloc_mutex_lock(tsdn, &arena->node_cache_mtx);
	node = ql_last(&arena->node_cache, ql_link);
	if (node == NULL) {
		malloc_mutex_unlock(tsdn, &arena->node_cache_mtx);
		return (base_alloc(tsdn, sizeof(extent_node_t)));
	}
	ql_tail_remove(&arena->node_cache, extent_node_t, ql_link);
	malloc_mutex_unlock(tsdn, &arena->node_cache_mtx);
	return (node);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8f8(%rsi), %rbx
movq %rbx, %rdi
callq 0xb5a0
movq 0x8f0(%r15), %rax
testq %rax, %rax
je 0x19e8c
movq 0x58(%rax), %r14
testq %r14, %r14
je 0x19e8c
cmpq %r14, %rax
jne 0x19e69
movq 0x50(%rax), %rax
movq %rax, 0x8f0(%r15)
cmpq %r14, %rax
je 0x19eaa
movq 0x50(%r14), %rax
movq 0x58(%r14), %rcx
movq %rax, 0x50(%rcx)
movq 0x58(%r14), %rcx
movq %rcx, 0x58(%rax)
movq %r14, 0x50(%r14)
movq %r14, 0x58(%r14)
jmp 0x19eb2
movq %rbx, %rdi
callq 0xb380
pushq $0x70
popq %rsi
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20d5c
andq $0x0, 0x8f0(%r15)
movq %rbx, %rdi
callq 0xb380
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_node_dalloc
void
arena_node_dalloc(tsdn_t *tsdn, arena_t *arena, extent_node_t *node)
{

	malloc_mutex_lock(tsdn, &arena->node_cache_mtx);
	ql_elm_new(node, ql_link);
	ql_tail_insert(&arena->node_cache, node, ql_link);
	malloc_mutex_unlock(tsdn, &arena->node_cache_mtx);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
leaq 0x8f8(%rsi), %r14
movq %r14, %rdi
callq 0xb5a0
movq %rbx, 0x50(%rbx)
movq %rbx, 0x58(%rbx)
movq 0x8f0(%r15), %rax
testq %rax, %rax
je 0x19f1d
movq 0x58(%rax), %rax
movq %rax, 0x58(%rbx)
movq 0x8f0(%r15), %rcx
movq %rcx, 0x50(%rbx)
movq %rbx, 0x50(%rax)
movq 0x8f0(%r15), %rax
movq %rbx, 0x58(%rax)
movq 0x50(%rbx), %rbx
movq %rbx, 0x8f0(%r15)
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_chunk_alloc_huge
void *
arena_chunk_alloc_huge(tsdn_t *tsdn, arena_t *arena, size_t usize,
    size_t alignment, size_t *sn, bool *zero)
{
	void *ret;
	chunk_hooks_t chunk_hooks = CHUNK_HOOKS_INITIALIZER;
	size_t csize = CHUNK_CEILING(usize);
	bool commit = true;

	malloc_mutex_lock(tsdn, &arena->lock);

	/* Optimistically update stats. */
	if (config_stats) {
		arena_huge_malloc_stats_update(arena, usize);
		arena->stats.mapped += usize;
	}
	arena_nactive_add(arena, usize >> LG_PAGE);

	ret = chunk_alloc_cache(tsdn, arena, &chunk_hooks, NULL, csize,
	    alignment, sn, zero, &commit, true);
	malloc_mutex_unlock(tsdn, &arena->lock);
	if (ret == NULL) {
		ret = arena_chunk_alloc_huge_hard(tsdn, arena, &chunk_hooks,
		    usize, alignment, sn, zero, csize);
	}

	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, 0x18(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r13
movaps %xmm0, 0x20(%r13)
movaps %xmm0, 0x10(%r13)
movaps %xmm0, (%r13)
andq $0x0, 0x30(%r13)
leaq 0x2f154(%rip), %rax     # 0x490d0
movq (%rax), %rbp
leaq (%rdx,%rbp), %rax
notq %rbp
andq %rax, %rbp
leaq 0x6(%rsp), %rax
movb $0x1, (%rax)
leaq 0x10(%rsi), %r15
movq %r15, %rdi
callq 0xb5a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1a07c
addq %r12, 0x60(%rbx)
movq %r12, %r14
shrq $0xc, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a0f3
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
movq %rbp, %r8
movq 0x10(%rsp), %r9
pushq $0x1
leaq 0xe(%rsp), %rax
pushq %rax
pushq 0x28(%rsp)
pushq 0x38(%rsp)
callq 0x2146e
addq $0x20, %rsp
movq %rax, %r13
movq %r15, %rdi
callq 0xb380
testq %r13, %r13
jne 0x1a06a
movq %r14, 0x28(%rsp)
leaq 0x7(%rsp), %rax
movb $0x1, (%rax)
subq $0x8, %rsp
leaq 0x38(%rsp), %rdx
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
movq %rbp, %r8
movq 0x18(%rsp), %r9
pushq %rax
pushq 0x28(%rsp)
pushq 0x38(%rsp)
callq 0x21943
addq $0x20, %rsp
movq %rax, %r13
testq %rax, %rax
jne 0x1a06a
movq %r15, %rdi
callq 0xb5a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1ecbe
subq %r12, 0x60(%rbx)
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
callq 0x1a267
movq %r15, %rdi
callq 0xb380
movq %r13, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_nactive_add
static void
arena_nactive_add(arena_t *arena, size_t add_pages)
{

	if (config_stats) {
		size_t cactive_add = CHUNK_CEILING((arena->nactive +
		    add_pages) << LG_PAGE) - CHUNK_CEILING(arena->nactive <<
		    LG_PAGE);
		if (cactive_add != 0)
			stats_cactive_add(cactive_add);
	}
	arena->nactive += add_pages;
}

// Assembly:
movq 0x128(%rdi), %rdx
leaq (%rdx,%rsi), %rcx
movq %rcx, %rax
shlq $0xc, %rax
leaq 0x2efc4(%rip), %r8      # 0x490d0
movq (%r8), %r8
addq %r8, %rax
shlq $0xc, %rdx
addq %r8, %rdx
notq %r8
andq %r8, %rax
andq %r8, %rdx
subq %rdx, %rax
je 0x1a13d
leaq 0x2f342(%rip), %rcx     # 0x49470
lock
xaddq %rax, (%rcx)
addq 0x128(%rdi), %rsi
movq %rsi, %rcx
movq %rcx, 0x128(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_chunk_dalloc_huge
void
arena_chunk_dalloc_huge(tsdn_t *tsdn, arena_t *arena, void *chunk, size_t usize,
    size_t sn)
{
	chunk_hooks_t chunk_hooks = CHUNK_HOOKS_INITIALIZER;
	size_t csize;

	csize = CHUNK_CEILING(usize);
	malloc_mutex_lock(tsdn, &arena->lock);
	if (config_stats) {
		arena_huge_dalloc_stats_update(arena, usize);
		arena->stats.mapped -= usize;
	}
	arena_nactive_sub(arena, usize >> LG_PAGE);

	chunk_dalloc_cache(tsdn, arena, &chunk_hooks, chunk, csize, sn, true);
	malloc_mutex_unlock(tsdn, &arena->lock);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, 0x18(%rsp)
movq %rcx, %rbp
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %r12
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r13
movaps %xmm0, 0x20(%r13)
andq $0x0, 0x30(%r13)
movaps %xmm0, 0x10(%r13)
movaps %xmm0, (%r13)
leaq 0x2ef47(%rip), %rax     # 0x490d0
movq (%rax), %rbx
leaq (%rbx,%rcx), %rax
notq %rbx
andq %rax, %rbx
leaq 0x10(%rsi), %r14
movq %r14, %rdi
callq 0xb5a0
movq %r15, %rdi
movq %rbp, %rsi
callq 0x1a1f9
subq %rbp, 0x60(%r15)
shrq $0xc, %rbp
movq %r15, %rdi
movq %rbp, %rsi
callq 0x1a267
movl $0x1, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq 0x10(%rsp), %rcx
movq %rbx, %r8
movq 0x18(%rsp), %r9
callq 0x21b37
movq %r14, %rdi
callq 0xb380
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_nactive_sub
static void
arena_nactive_sub(arena_t *arena, size_t sub_pages)
{

	if (config_stats) {
		size_t cactive_sub = CHUNK_CEILING(arena->nactive << LG_PAGE) -
		    CHUNK_CEILING((arena->nactive - sub_pages) << LG_PAGE);
		if (cactive_sub != 0)
			stats_cactive_sub(cactive_sub);
	}
	arena->nactive -= sub_pages;
}

// Assembly:
movq 0x128(%rdi), %rax
movq %rax, %rdx
shlq $0xc, %rdx
leaq 0x2ee54(%rip), %rcx     # 0x490d0
movq (%rcx), %r8
addq %r8, %rdx
subq %rsi, %rax
movq %rax, %rcx
shlq $0xc, %rcx
addq %r8, %rcx
notq %r8
andq %r8, %rdx
andq %r8, %rcx
subq %rdx, %rcx
je 0x1a2b3
leaq 0x2f1cc(%rip), %rax     # 0x49470
lock
xaddq %rcx, (%rax)
movq 0x128(%rdi), %rax
subq %rsi, %rax
movq %rax, 0x128(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_chunk_ralloc_huge_similar
void
arena_chunk_ralloc_huge_similar(tsdn_t *tsdn, arena_t *arena, void *chunk,
    size_t oldsize, size_t usize)
{

	assert(CHUNK_CEILING(oldsize) == CHUNK_CEILING(usize));
	assert(oldsize != usize);

	malloc_mutex_lock(tsdn, &arena->lock);
	if (config_stats)
		arena_huge_ralloc_stats_update(arena, oldsize, usize);
	if (oldsize < usize)
		arena_nactive_add(arena, (usize - oldsize) >> LG_PAGE);
	else
		arena_nactive_sub(arena, (oldsize - usize) >> LG_PAGE);
	malloc_mutex_unlock(tsdn, &arena->lock);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r12
movq %rsi, %r14
leaq 0x10(%rsi), %rbx
movq %rbx, %rdi
callq 0xb5a0
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1a321
movq %r12, %rsi
subq %r15, %rsi
jae 0x1a302
subq %r12, %r15
shrq $0xc, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1a0f3
jmp 0x1a30e
shrq $0xc, %rsi
movq %r14, %rdi
callq 0x1a267
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_chunk_ralloc_huge_shrink
void
arena_chunk_ralloc_huge_shrink(tsdn_t *tsdn, arena_t *arena, void *chunk,
    size_t oldsize, size_t usize, size_t sn)
{
	size_t udiff = oldsize - usize;
	size_t cdiff = CHUNK_CEILING(oldsize) - CHUNK_CEILING(usize);

	malloc_mutex_lock(tsdn, &arena->lock);
	if (config_stats) {
		arena_huge_ralloc_stats_update(arena, oldsize, usize);
		if (cdiff != 0)
			arena->stats.mapped -= cdiff;
	}
	arena_nactive_sub(arena, udiff >> LG_PAGE);

	if (cdiff != 0) {
		chunk_hooks_t chunk_hooks = CHUNK_HOOKS_INITIALIZER;
		void *nchunk = (void *)((uintptr_t)chunk +
		    CHUNK_CEILING(usize));

		chunk_dalloc_cache(tsdn, arena, &chunk_hooks, nchunk, cdiff,
		    sn, true);
	}
	malloc_mutex_unlock(tsdn, &arena->lock);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, 0x20(%rsp)
movq %r8, %rbx
movq %rcx, %rbp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, 0x18(%rsp)
movq %rcx, %r12
subq %r8, %r12
leaq 0x2ed5b(%rip), %rax     # 0x490d0
movq (%rax), %r15
leaq (%r15,%rcx), %r13
movq %r15, %rax
notq %rax
andq %rax, %r13
addq %r8, %r15
andq %rax, %r15
leaq 0x10(%rsi), %rdi
movq %rdi, 0x28(%rsp)
callq 0xb5a0
movq %r14, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x1a321
subq %r15, %r13
jne 0x1a3bd
shrq $0xc, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x1a267
jmp 0x1a41c
subq %r13, 0x60(%r14)
shrq $0xc, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x1a267
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdx
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
andq $0x0, 0x30(%rdx)
leaq 0x2ece1(%rip), %rax     # 0x490d0
movq (%rax), %rcx
addq %rcx, %rbx
notq %rcx
andq %rbx, %rcx
addq 0x10(%rsp), %rcx
movl $0x1, (%rsp)
movq 0x18(%rsp), %rdi
movq %r14, %rsi
movq %r13, %r8
movq 0x20(%rsp), %r9
callq 0x21b37
movq 0x28(%rsp), %rdi
callq 0xb380
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_lg_dirty_mult_set
bool
arena_lg_dirty_mult_set(tsdn_t *tsdn, arena_t *arena, ssize_t lg_dirty_mult)
{

	if (!arena_lg_dirty_mult_valid(lg_dirty_mult))
		return (true);

	malloc_mutex_lock(tsdn, &arena->lock);
	arena->lg_dirty_mult = lg_dirty_mult;
	arena_maybe_purge(tsdn, arena);
	malloc_mutex_unlock(tsdn, &arena->lock);

	return (false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq -0x40(%rdx), %r13
cmpq $-0x41, %r13
jb 0x1a75e
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsi), %r12
movq %r12, %rdi
callq 0xb5a0
movq %r15, 0x118(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a76f
movq %r12, %rdi
callq 0xb380
cmpq $-0x41, %r13
setb %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_maybe_purge
void
arena_maybe_purge(tsdn_t *tsdn, arena_t *arena)
{

	/* Don't recursively purge. */
	if (arena->purging)
		return;

	if (opt_purge == purge_mode_ratio)
		arena_maybe_purge_ratio(tsdn, arena);
	else
		arena_maybe_purge_decay(tsdn, arena);
}

// Assembly:
cmpb $0x0, 0x120(%rsi)
jne 0x1a98f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x2de39(%rip)     # 0x485d0
je 0x1a87f
cmpq $0x0, 0x1b8(%rbx)
jle 0x1a8cb
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x294b0
movq %r15, %rdi
callq 0x29529
callq 0x29526
testb %al, %al
jne 0x1a7e7
leaq 0x1c8(%rbx), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x294ec
testl %eax, %eax
jg 0x1a990
leaq 0x1d8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x294ec
testl %eax, %eax
jg 0x1a981
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x294e5
leaq 0x1c8(%rbx), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x29502
leaq 0x1c0(%rbx), %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq 0x2951d
movq %rax, %r15
movq %r12, %rdi
movq %rbp, %rsi
callq 0x294e5
movq %r12, %rdi
movq %r15, %rsi
callq 0x29509
movq %r13, %rdi
movq %r12, %rsi
callq 0x294fb
movq %rbx, %rdi
callq 0x1ed21
leaq 0x1e8(%rbx), %r12
cmpq $0xc8, %r15
jb 0x1a8e3
movl $0x638, %edx            # imm = 0x638
movq %r12, %rdi
jmp 0x1a912
movq 0x118(%rbx), %rcx
testq %rcx, %rcx
js 0x1a981
leaq 0x2e842(%rip), %r15     # 0x490d8
movq 0x128(%rbx), %rdx
shrq %cl, %rdx
movq (%r15), %rax
cmpq %rax, %rdx
cmovbeq %rax, %rdx
cmpq %rdx, 0x130(%rbx)
jbe 0x1a981
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ab09
movq 0x118(%rbx), %rcx
jmp 0x1a896
jne 0x1a981
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1ab09
jmp 0x1a981
leaq (%r12,%r15,8), %rsi
movl $0xc8, %r13d
subq %r15, %r13
leal (,%r13,8), %edx
movq %r12, %rdi
callq 0xb450
cmpq $0x2, %r15
jb 0x1a919
leaq (%r12,%r13,8), %rdi
leaq -0x8(,%r15,8), %rdx
xorl %esi, %esi
callq 0xb230
movq 0x130(%rbx), %rax
xorl %ecx, %ecx
movq %rax, %rdx
subq 0x1e0(%rbx), %rdx
cmovbq %rcx, %rdx
movq %rdx, 0x820(%rbx)
leaq 0x1c5a2(%rip), %rsi     # 0x36ee0
xorl %edx, %edx
cmpq $0x640, %rcx            # imm = 0x640
je 0x1a95f
movq (%rcx,%rsi), %rdi
imulq 0x1e8(%rbx,%rcx), %rdi
addq %rdi, %rdx
addq $0x8, %rcx
jmp 0x1a940
shrq $0x18, %rdx
cmpq %rdx, %rax
jbe 0x1a97a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ab09
movq 0x130(%rbx), %rax
movq %rax, 0x1e0(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x294e5
movq %rbx, %rdi
callq 0x1ed21
jmp 0x1a7e7
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_decay_time_set
bool
arena_decay_time_set(tsdn_t *tsdn, arena_t *arena, ssize_t decay_time)
{

	if (!arena_decay_time_valid(decay_time))
		return (true);

	malloc_mutex_lock(tsdn, &arena->lock);
	/*
	 * Restart decay backlog from scratch, which may cause many dirty pages
	 * to be immediately purged.  It would conceptually be possible to map
	 * the old backlog onto the new backlog, but there is no justification
	 * for such complexity since decay_time changes are intended to be
	 * infrequent, either between the {-1, 0, >0} states, or a one-time
	 * arbitrary change during initial arena configuration.
	 */
	arena_decay_init(arena, decay_time);
	arena_maybe_purge(tsdn, arena);
	malloc_mutex_unlock(tsdn, &arena->lock);

	return (false);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movabsq $-0x44b82fa0a, %r13     # imm = 0xFFFFFFFBB47D05F6
leaq (%rdx,%r13), %rbp
incq %rbp
cmpq %r13, %rbp
jb 0x1aa2b
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsi), %r12
movq %r12, %rdi
callq 0xb5a0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1aa40
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a76f
movq %r12, %rdi
callq 0xb380
cmpq %r13, %rbp
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_decay_init
static void
arena_decay_init(arena_t *arena, ssize_t decay_time)
{

	arena->decay.time = decay_time;
	if (decay_time > 0) {
		nstime_init2(&arena->decay.interval, decay_time, 0);
		nstime_idivide(&arena->decay.interval, SMOOTHSTEP_NSTEPS);
	}

	nstime_init(&arena->decay.epoch, 0);
	nstime_update(&arena->decay.epoch);
	arena->decay.jitter_state = (uint64_t)(uintptr_t)arena;
	arena_decay_deadline_init(arena);
	arena->decay.ndirty = arena->ndirty;
	memset(arena->decay.backlog, 0, SMOOTHSTEP_NSTEPS * sizeof(size_t));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, 0x1b8(%rdi)
testq %rsi, %rsi
jle 0x1aa71
leaq 0x1c0(%rbx), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x294b4
movl $0xc8, %esi
movq %r14, %rdi
callq 0x29511
leaq 0x1c8(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x294b0
movq %r14, %rdi
callq 0x29529
movq %rbx, 0x1d0(%rbx)
movq %rbx, %rdi
callq 0x1ed21
movq 0x130(%rbx), %rax
movq %rax, 0x1e0(%rbx)
addq $0x1e8, %rbx            # imm = 0x1E8
movl $0x640, %edx            # imm = 0x640
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb230
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_purge
void
arena_purge(tsdn_t *tsdn, arena_t *arena, bool all)
{

	malloc_mutex_lock(tsdn, &arena->lock);
	if (all)
		arena_purge_to_limit(tsdn, arena, 0);
	else
		arena_maybe_purge(tsdn, arena);
	malloc_mutex_unlock(tsdn, &arena->lock);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsi), %rbx
movq %rbx, %rdi
callq 0xb5a0
movq %r15, %rdi
movq %r14, %rsi
testl %ebp, %ebp
je 0x1aaf2
xorl %edx, %edx
callq 0x1ab09
jmp 0x1aaf7
callq 0x1a76f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_chunk_discard
static void
arena_chunk_discard(tsdn_t *tsdn, arena_t *arena, arena_chunk_t *chunk)
{
	size_t sn, hugepage;
	bool committed;
	chunk_hooks_t chunk_hooks = CHUNK_HOOKS_INITIALIZER;

	chunk_deregister(chunk, &chunk->node);

	sn = extent_node_sn_get(&chunk->node);
	hugepage = chunk->hugepage;
	committed = (arena_mapbits_decommitted_get(chunk, map_bias) == 0);
	if (!committed) {
		/*
		 * Decommit the header.  Mark the chunk as decommitted even if
		 * header decommit fails, since treating a partially committed
		 * chunk as committed has a high potential for causing later
		 * access of decommitted memory.
		 */
		chunk_hooks = chunk_hooks_get(tsdn, arena);
		chunk_hooks.decommit(chunk, chunksize, 0, map_bias << LG_PAGE,
		    arena->ind);
	}
	if (!hugepage) {
		/*
		 * Convert chunk back to the default state, so that all
		 * subsequent chunk allocations start out with chunks that can
		 * be backed by transparent huge pages.
		 */
		pages_huge(chunk, chunksize);
	}

	chunk_dalloc_cache(tsdn, arena, &chunk_hooks, (void *)chunk, chunksize,
	    sn, committed);

	if (config_stats) {
		arena->stats.mapped -= chunksize;
		arena->stats.metadata_mapped -= (map_bias << LG_PAGE);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x40(%rsp)
movq %rdx, %rdi
movq %rdx, %rsi
callq 0x21412
movq 0x18(%r14), %r12
movb 0x70(%r14), %r13b
movq 0x78(%r14), %rbp
testb $0x4, %bpl
je 0x1b3b9
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x211f1
leaq 0x2dd2d(%rip), %rax     # 0x490c8
movq (%rax), %rsi
movq 0x2dc1b(%rip), %rcx     # 0x48fc0
shlq $0xc, %rcx
movl (%rbx), %r8d
movq %r14, %rdi
xorl %edx, %edx
leaq 0x10(%rsp), %rax
callq *0x18(%rax)
testb %r13b, %r13b
jne 0x1b3d0
leaq 0x2dd03(%rip), %rax     # 0x490c8
movq (%rax), %rsi
movq %r14, %rdi
callq 0x296e0
xorl %eax, %eax
testb $0x4, %bpl
sete %al
leaq 0x2dce8(%rip), %r13     # 0x490c8
movq (%r13), %r8
movl %eax, (%rsp)
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
movq %r12, %r9
callq 0x21b37
movq (%r13), %rax
subq %rax, 0x60(%rbx)
movq 0x2dbb4(%rip), %rax     # 0x48fc0
shlq $0xc, %rax
subq %rax, 0x88(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_run_reg_alloc
JEMALLOC_INLINE_C void *
arena_run_reg_alloc(arena_run_t *run, arena_bin_info_t *bin_info)
{
	void *ret;
	size_t regind;
	arena_chunk_map_misc_t *miscelm;
	void *rpages;

	assert(run->nfree > 0);
	assert(!bitmap_full(run->bitmap, &bin_info->bitmap_info));

	regind = (unsigned)bitmap_sfu(run->bitmap, &bin_info->bitmap_info);
	miscelm = arena_run_to_miscelm(run);
	rpages = arena_miscelm_to_rpages(miscelm);
	ret = (void *)((uintptr_t)rpages + (uintptr_t)bin_info->reg0_offset +
	    (uintptr_t)(bin_info->reg_interval * regind));
	run->nfree--;
	return (ret);
}

// Assembly:
leaq 0x8(%rdi), %rcx
xorl %eax, %eax
pushq $0x1
popq %rdx
movq %rcx, %r8
movq (%r8), %r8
testq %r8, %r8
jne 0x1b63a
movl %edx, %r8d
leaq (%rcx,%r8,8), %r8
addl $0x40, %eax
incl %edx
jmp 0x1b624
bsfq %r8, %rcx
movl %eax, %r8d
pushq $0x1
popq %rdx
shlq %cl, %rdx
shrl $0x3, %eax
xorq %rdx, 0x8(%rdi,%rax)
leaq -0x18(%rdi), %rax
leaq 0x2da76(%rip), %rdx     # 0x490d0
movq (%rdx), %r9
notq %r9
andq %rax, %r9
movq 0x2d95e(%rip), %rax     # 0x48fc8
addq %r9, %rax
negq %rax
addq %rdi, %rax
addq $-0x18, %rax
pushq $0x60
popq %r10
xorl %edx, %edx
divq %r10
addq 0x2d939(%rip), %rax     # 0x48fc0
orq %rcx, %r8
shlq $0xc, %rax
imulq 0x10(%rsi), %r8
movl 0x38(%rsi), %ecx
addq %r9, %rcx
addq %r8, %rcx
addq %rcx, %rax
decl 0x4(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_alloc_junk_small
void
arena_alloc_junk_small(void *ptr, arena_bin_info_t *bin_info, bool zero)
{

	size_t redzone_size = bin_info->redzone_size;

	if (zero) {
		memset((void *)((uintptr_t)ptr - redzone_size),
		    JEMALLOC_ALLOC_JUNK, redzone_size);
		memset((void *)((uintptr_t)ptr + bin_info->reg_size),
		    JEMALLOC_ALLOC_JUNK, redzone_size);
	} else {
		memset((void *)((uintptr_t)ptr - redzone_size),
		    JEMALLOC_ALLOC_JUNK, bin_info->reg_interval);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %r14
subq %r14, %rdi
testl %edx, %edx
je 0x1b896
movl $0xa5, %esi
movq %r14, %rdx
callq 0xb230
addq (%rbx), %r15
movq %r15, %rdi
movl $0xa5, %esi
movq %r14, %rdx
jmp 0x1b89f
movq 0x10(%rbx), %rdx
movl $0xa5, %esi
popq %rbx
popq %r14
popq %r15
jmp 0xb230
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_dalloc_junk_small
void
arena_dalloc_junk_small(void *ptr, arena_bin_info_t *bin_info)
{
	size_t redzone_size = bin_info->redzone_size;

	arena_redzones_validate(ptr, bin_info, false);
	memset((void *)((uintptr_t)ptr - redzone_size), JEMALLOC_FREE_JUNK,
	    bin_info->reg_interval);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
subq 0x8(%rsi), %r14
xorl %edx, %edx
callq 0x1b8d4
movq 0x10(%rbx), %rdx
pushq $0x5a
popq %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb230
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_run_alloc_large
static arena_run_t *
arena_run_alloc_large(tsdn_t *tsdn, arena_t *arena, size_t size, bool zero)
{
	arena_chunk_t *chunk;
	arena_run_t *run;

	assert(size <= arena_maxrun);
	assert(size == PAGE_CEILING(size));

	/* Search the arena's chunks for the lowest best fit. */
	run = arena_run_alloc_large_helper(arena, size, zero);
	if (run != NULL)
		return (run);

	/*
	 * No usable runs.  Create a new chunk from which to allocate the run.
	 */
	chunk = arena_chunk_alloc(tsdn, arena);
	if (chunk != NULL) {
		run = &arena_miscelm_get_mutable(chunk, map_bias)->run;
		if (arena_run_split_large(arena, run, size, zero))
			run = NULL;
		return (run);
	}

	/*
	 * arena_chunk_alloc() failed, but another thread may have made
	 * sufficient memory available while this one dropped arena->lock in
	 * arena_chunk_alloc(), so search one more time.
	 */
	return (arena_run_alloc_large_helper(arena, size, zero));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
movl %ecx, %edx
callq 0x20b1b
testq %rax, %rax
jne 0x1bbe9
movq %r15, %rdi
movq %r14, %rsi
callq 0x1ee18
testq %rax, %rax
je 0x1bbf4
movq 0x2d403(%rip), %rcx     # 0x48fc8
leaq (%rcx,%rax), %r15
addq $0x18, %r15
movzbl %bpl, %ecx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1f1be
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
cmoveq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzbl %bpl, %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20b1b
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_dalloc_bin
void
arena_dalloc_bin(tsdn_t *tsdn, arena_t *arena, arena_chunk_t *chunk, void *ptr,
    size_t pageind, arena_chunk_map_bits_t *bitselm)
{
	arena_run_t *run;
	arena_bin_t *bin;
	size_t rpages_ind;

	rpages_ind = pageind - arena_mapbits_small_runind_get(chunk, pageind);
	run = &arena_miscelm_get_mutable(chunk, rpages_ind)->run;
	bin = &arena->bins[run->binind];
	malloc_mutex_lock(tsdn, &bin->lock);
	arena_dalloc_bin_locked_impl(tsdn, arena, chunk, ptr, bitselm, false);
	malloc_mutex_unlock(tsdn, &bin->lock);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x2c599(%rip), %rax     # 0x48fc0
movq %r8, %rcx
subq %rax, %rcx
movq 0x78(%rdx,%rcx,8), %rcx
shrq $0xd, %rcx
subq %rcx, %r8
movq 0x2c588(%rip), %rcx     # 0x48fc8
addq %rdx, %rcx
imulq $0x60, %r8, %rdx
addq %rcx, %rdx
negq %rax
imulq $0x60, %rax, %rax
movl 0x18(%rax,%rdx), %eax
imulq $0xa8, %rax, %rax
leaq (%rsi,%rax), %r13
addq $0x980, %r13            # imm = 0x980
movq %r13, %rdi
callq 0xb5a0
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x1c7f0
movq %r13, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_dalloc_small
void
arena_dalloc_small(tsdn_t *tsdn, arena_t *arena, arena_chunk_t *chunk,
    void *ptr, size_t pageind)
{
	arena_chunk_map_bits_t *bitselm;

	if (config_debug) {
		/* arena_ptr_small_binind_get() does extra sanity checking. */
		assert(arena_ptr_small_binind_get(ptr, arena_mapbits_get(chunk,
		    pageind)) != BININD_INVALID);
	}
	bitselm = arena_bitselm_get_mutable(chunk, pageind);
	arena_dalloc_bin(tsdn, arena, chunk, ptr, pageind, bitselm);
	arena_decay_tick(tsdn, arena);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1ca0b
testq %r14, %r14
je 0x1cac1
movl (%rbx), %esi
movq %r14, %rdi
callq 0x20a5e
testq %rax, %rax
je 0x1cac1
movl (%rax), %ecx
testl %ecx, %ecx
jle 0x1cac9
decl %ecx
movl %ecx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x4(%rax), %ecx
movl %ecx, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1aac4
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_dalloc_large_locked_impl
static void
arena_dalloc_large_locked_impl(tsdn_t *tsdn, arena_t *arena,
    arena_chunk_t *chunk, void *ptr, bool junked)
{
	size_t pageind = ((uintptr_t)ptr - (uintptr_t)chunk) >> LG_PAGE;
	arena_chunk_map_misc_t *miscelm = arena_miscelm_get_mutable(chunk,
	    pageind);
	arena_run_t *run = &miscelm->run;

	if (config_fill || config_stats) {
		size_t usize = arena_mapbits_large_size_get(chunk, pageind) -
		    large_pad;

		if (!junked)
			arena_dalloc_junk_large(ptr, usize);
		if (config_stats) {
			szind_t index = size2index(usize) - NBINS;

			arena->stats.ndalloc_large++;
			arena->stats.allocated_large -= usize;
			arena->stats.lstats[index].ndalloc++;
			arena->stats.lstats[index].curruns--;
		}
	}

	arena_run_dalloc(tsdn, arena, run, true, false, false);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rcx, %rbp
subq %rdx, %rbp
shrq $0xc, %rbp
movq 0x2c4a3(%rip), %r14     # 0x48fc8
movq 0x2c494(%rip), %r13     # 0x48fc0
movq %rbp, %rax
subq %r13, %rax
movq 0x78(%rdx,%rax,8), %r12
shrq %r12
andq $-0x1000, %r12          # imm = 0xF000
leaq -0x1000(%r12), %rdx
testl %r8d, %r8d
jne 0x1cb5e
leaq 0x2b9cd(%rip), %rax     # 0x48522
cmpb $0x1, (%rax)
je 0x1cbf6
cmpq $0x1000, %rdx           # imm = 0x1000
ja 0x1cbdc
addq $-0x1001, %r12          # imm = 0xEFFF
shrq $0x3, %r12
leaq 0x19e47(%rip), %rax     # 0x369c0
movzbl (%rax,%r12), %eax
negq %r13
addq %r15, %r14
imulq $0x60, %rbp, %rcx
addq %r14, %rcx
addl $-0x27, %eax
incq 0xa8(%rbx)
subq %rdx, 0x98(%rbx)
movq 0xd0(%rbx), %rdx
shlq $0x5, %rax
incq 0x8(%rdx,%rax)
imulq $0x60, %r13, %rsi
decq 0x18(%rdx,%rax)
leaq (%rsi,%rcx), %rdx
addq $0x18, %rdx
pushq $0x1
popq %rcx
movq %rbx, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1fd91
movq %rdi, 0x8(%rsp)
movq %rdx, %rdi
movq %rdx, %r12
callq 0x20acc
movq %r12, %rdx
movq 0x8(%rsp), %rdi
jmp 0x1cb7e
pushq $0x5a
popq %rsi
movq %rdi, 0x8(%rsp)
movq %rcx, %rdi
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rdx
callq 0xb230
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rdi
jmp 0x1cb5e
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_dalloc_large
void
arena_dalloc_large(tsdn_t *tsdn, arena_t *arena, arena_chunk_t *chunk,
    void *ptr)
{

	malloc_mutex_lock(tsdn, &arena->lock);
	arena_dalloc_large_locked_impl(tsdn, arena, chunk, ptr, false);
	malloc_mutex_unlock(tsdn, &arena->lock);
	arena_decay_tick(tsdn, arena);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsi), %r13
movq %r13, %rdi
callq 0xb5a0
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x1cb00
movq %r13, %rdi
callq 0xb380
testq %r14, %r14
je 0x1cc7a
movl (%rbx), %esi
movq %r14, %rdi
callq 0x20a5e
testq %rax, %rax
je 0x1cc7a
movl (%rax), %ecx
testl %ecx, %ecx
jle 0x1cc84
decl %ecx
movl %ecx, (%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl 0x4(%rax), %ecx
movl %ecx, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1aac4
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_basic_stats_merge
void
arena_basic_stats_merge(tsdn_t *tsdn, arena_t *arena, unsigned *nthreads,
    const char **dss, ssize_t *lg_dirty_mult, ssize_t *decay_time,
    size_t *nactive, size_t *ndirty)
{

	malloc_mutex_lock(tsdn, &arena->lock);
	arena_basic_stats_merge_locked(arena, nthreads, dss, lg_dirty_mult,
	    decay_time, nactive, ndirty);
	malloc_mutex_unlock(tsdn, &arena->lock);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq 0x50(%rsp), %rbp
movq 0x58(%rsp), %r14
leaq 0x10(%rsi), %rbx
movq %rbx, %rdi
callq 0xb5a0
movq %r14, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
movq %rbp, %r9
callq 0x1de65
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_basic_stats_merge_locked
static void
arena_basic_stats_merge_locked(arena_t *arena, unsigned *nthreads,
    const char **dss, ssize_t *lg_dirty_mult, ssize_t *decay_time,
    size_t *nactive, size_t *ndirty)
{

	*nthreads += arena_nthreads_get(arena, false);
	*dss = dss_prec_names[arena->dss_prec];
	*lg_dirty_mult = arena->lg_dirty_mult;
	*decay_time = arena->decay.time;
	*nactive += arena->nactive;
	*ndirty += arena->ndirty;
}

// Assembly:
movq 0x8(%rsp), %rax
xorl %r10d, %r10d
lock
xaddl %r10d, 0x4(%rdi)
addl %r10d, (%rsi)
movl 0xf8(%rdi), %esi
leaq 0x2a55d(%rip), %r10     # 0x483e0
movq (%r10,%rsi,8), %rsi
movq %rsi, (%rdx)
movq 0x118(%rdi), %rdx
movq %rdx, (%rcx)
movq 0x1b8(%rdi), %rcx
movq %rcx, (%r8)
movq 0x128(%rdi), %rcx
addq %rcx, (%r9)
movq 0x130(%rdi), %rcx
addq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_prefork3
void
arena_prefork3(tsdn_t *tsdn, arena_t *arena)
{
	unsigned i;

	for (i = 0; i < NBINS; i++)
		malloc_mutex_prefork(tsdn, &arena->bins[i].lock);
	malloc_mutex_prefork(tsdn, &arena->huge_mtx);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x980(%rsi), %r15
xorl %r12d, %r12d
cmpq $0x1998, %r12           # imm = 0x1998
je 0x1ebad
leaq (%r15,%r12), %rsi
movq %r14, %rdi
callq 0x2946c
addq $0xa8, %r12
jmp 0x1eb8f
addq $0x830, %rbx            # imm = 0x830
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2946c
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_postfork_parent
void
arena_postfork_parent(tsdn_t *tsdn, arena_t *arena)
{
	unsigned i;

	malloc_mutex_postfork_parent(tsdn, &arena->huge_mtx);
	for (i = 0; i < NBINS; i++)
		malloc_mutex_postfork_parent(tsdn, &arena->bins[i].lock);
	malloc_mutex_postfork_parent(tsdn, &arena->node_cache_mtx);
	malloc_mutex_postfork_parent(tsdn, &arena->chunks_mtx);
	malloc_mutex_postfork_parent(tsdn, &arena->lock);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x830, %rsi            # imm = 0x830
callq 0x29474
leaq 0x980(%rbx), %r15
xorl %r12d, %r12d
cmpq $0x1998, %r12           # imm = 0x1998
je 0x1ec0c
leaq (%r15,%r12), %rsi
movq %r14, %rdi
callq 0x29474
addq $0xa8, %r12
jmp 0x1ebee
leaq 0x8f8(%rbx), %rsi
movq %r14, %rdi
callq 0x29474
leaq 0x8a0(%rbx), %rsi
movq %r14, %rdi
callq 0x29474
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x29474
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_postfork_child
void
arena_postfork_child(tsdn_t *tsdn, arena_t *arena)
{
	unsigned i;

	malloc_mutex_postfork_child(tsdn, &arena->huge_mtx);
	for (i = 0; i < NBINS; i++)
		malloc_mutex_postfork_child(tsdn, &arena->bins[i].lock);
	malloc_mutex_postfork_child(tsdn, &arena->node_cache_mtx);
	malloc_mutex_postfork_child(tsdn, &arena->chunks_mtx);
	malloc_mutex_postfork_child(tsdn, &arena->lock);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x830, %rsi            # imm = 0x830
callq 0x2947c
leaq 0x980(%rbx), %r15
xorl %r12d, %r12d
cmpq $0x1998, %r12           # imm = 0x1998
je 0x1ec86
leaq (%r15,%r12), %rsi
movq %r14, %rdi
callq 0x2947c
addq $0xa8, %r12
jmp 0x1ec68
leaq 0x8f8(%rbx), %rsi
movq %r14, %rdi
callq 0x2947c
leaq 0x8a0(%rbx), %rsi
movq %r14, %rdi
callq 0x2947c
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2947c
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_decay_deadline_init
static void
arena_decay_deadline_init(arena_t *arena)
{

	assert(opt_purge == purge_mode_decay);

	/*
	 * Generate a new deadline that is uniformly random within the next
	 * epoch after the current one.
	 */
	nstime_copy(&arena->decay.deadline, &arena->decay.epoch);
	nstime_add(&arena->decay.deadline, &arena->decay.interval);
	if (arena->decay.time > 0) {
		nstime_t jitter;

		nstime_init(&jitter, prng_range_u64(&arena->decay.jitter_state,
		    nstime_ns(&arena->decay.interval)));
		nstime_add(&arena->decay.deadline, &jitter);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x1d8(%rdi), %rbx
leaq 0x1c8(%rdi), %rsi
movq %rbx, %rdi
callq 0x294e5
leaq 0x1c0(%r14), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x294fb
cmpq $0x0, 0x1b8(%r14)
jle 0x1ee0e
movq %r15, %rdi
callq 0x294c2
leaq -0x1(%rax), %rcx
movq %rcx, %rdx
shrq %rdx
orq %rcx, %rdx
movq %rdx, %rcx
shrq $0x2, %rcx
orq %rdx, %rcx
movq %rcx, %rdx
shrq $0x4, %rdx
orq %rcx, %rdx
movq %rdx, %rcx
shrq $0x8, %rcx
orq %rdx, %rcx
movq %rcx, %rdx
shrq $0x10, %rdx
orq %rcx, %rdx
movq %rdx, %rcx
shrq $0x20, %rcx
orq %rdx, %rcx
leaq 0x1(%rcx), %rdx
bsfq %rdx, %rdx
pushq $0x40
popq %rsi
subq %rdx, %rsi
incq %rcx
pushq $0x41
popq %rcx
cmovneq %rsi, %rcx
movq 0x1d0(%r14), %rdx
movabsq $0x5851f42d4c957f2d, %rdi # imm = 0x5851F42D4C957F2D
movabsq $0x14057b7ef767814f, %r8 # imm = 0x14057B7EF767814F
imulq %rdi, %rdx
addq %r8, %rdx
movq %rdx, %rsi
shrq %cl, %rsi
cmpq %rax, %rsi
jae 0x1eddd
movq %rdx, 0x1d0(%r14)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x294b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x294fb
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_avail_insert
static void
arena_avail_insert(arena_t *arena, arena_chunk_t *chunk, size_t pageind,
    size_t npages)
{
	pszind_t pind = psz2ind(run_quantize_floor(arena_miscelm_size_get(
	    arena_miscelm_get_const(chunk, pageind))));
	assert(npages == (arena_mapbits_unallocated_size_get(chunk, pageind) >>
	    LG_PAGE));
	assert((npages << LG_PAGE) < chunksize);
	assert(pind2sz(pind) <= chunksize);
	arena_run_heap_insert(&arena->runs_avail[pind],
	    arena_miscelm_get_mutable(chunk, pageind));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
addq 0x29df1(%rip), %rbx     # 0x48fc8
movq %rdi, %r14
imulq $0x60, %rdx, %rax
addq %rax, %rbx
xorl %eax, %eax
subq 0x29dd6(%rip), %rax     # 0x48fc0
imulq $0x60, %rax, %rax
addq %rax, %rbx
movq %rbx, %rdi
callq 0x1f2ca
movq %rax, %rdi
callq 0x1f29f
movq %rax, %rdi
callq 0x1f250
movl %eax, %eax
leaq (%r14,%rax,8), %rdi
addq $0x2318, %rdi           # imm = 0x2318
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1f301
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: je_psz2ind
JEMALLOC_INLINE pszind_t
psz2ind(size_t psz)
{

	if (unlikely(psz > HUGE_MAXCLASS))
		return (NPSIZES);
	{
		pszind_t x = lg_floor((psz<<1)-1);
		pszind_t shift = (x < LG_SIZE_CLASS_GROUP + LG_PAGE) ? 0 : x -
		    (LG_SIZE_CLASS_GROUP + LG_PAGE);
		pszind_t grp = shift << LG_SIZE_CLASS_GROUP;

		pszind_t lg_delta = (x < LG_SIZE_CLASS_GROUP + LG_PAGE + 1) ?
		    LG_PAGE : x - LG_SIZE_CLASS_GROUP - 1;

		size_t delta_inverse_mask = ZI(-1) << lg_delta;
		pszind_t mod = ((((psz-1) & delta_inverse_mask) >> lg_delta)) &
		    ((ZU(1) << LG_SIZE_CLASS_GROUP) - 1);

		pszind_t ind = grp + mod;
		return (ind);
	}
}

// Assembly:
movabsq $0x7000000000000000, %rax # imm = 0x7000000000000000
cmpq %rax, %rdi
ja 0x1f299
leaq -0x1(,%rdi,2), %rax
bsrq %rax, %rax
xorl %ecx, %ecx
movl %eax, %edx
subl $0xe, %edx
cmovbl %ecx, %edx
movl %eax, %ecx
addb $-0x3, %cl
cmpl $0xf, %eax
movzbl %cl, %eax
pushq $0xc
popq %rcx
cmovael %eax, %ecx
decq %rdi
shrq %cl, %rdi
shlq %cl, %rdi
shrq %cl, %rdi
andl $0x3, %edi
leal (%rdi,%rdx,4), %eax
retq
movl $0xc7, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_miscelm_size_get
JEMALLOC_INLINE_C size_t
arena_miscelm_size_get(const arena_chunk_map_misc_t *miscelm)
{
	arena_chunk_t *chunk;
	size_t pageind, mapbits;

	chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(miscelm);
	pageind = arena_miscelm_to_pageind(miscelm);
	mapbits = arena_mapbits_get(chunk, pageind);
	return (arena_mapbits_size_decode(mapbits));
}

// Assembly:
movq %rdi, %rax
leaq 0x29dfc(%rip), %rcx     # 0x490d0
movq (%rcx), %rcx
notq %rcx
andq %rdi, %rcx
movq 0x29ce4(%rip), %rdx     # 0x48fc8
addq %rcx, %rdx
subq %rdx, %rax
pushq $0x60
popq %rsi
xorl %edx, %edx
divq %rsi
movq 0x78(%rcx,%rax,8), %rax
shrq %rax
andq $-0x1000, %rax          # imm = 0xF000
retq
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_avail_remove
static void
arena_avail_remove(arena_t *arena, arena_chunk_t *chunk, size_t pageind,
    size_t npages)
{
	pszind_t pind = psz2ind(run_quantize_floor(arena_miscelm_size_get(
	    arena_miscelm_get_const(chunk, pageind))));
	assert(npages == (arena_mapbits_unallocated_size_get(chunk, pageind) >>
	    LG_PAGE));
	assert((npages << LG_PAGE) < chunksize);
	assert(pind2sz(pind) <= chunksize);
	arena_run_heap_remove(&arena->runs_avail[pind],
	    arena_miscelm_get_mutable(chunk, pageind));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
addq 0x2990a(%rip), %rbx     # 0x48fc8
movq %rdi, %r14
imulq $0x60, %rdx, %rax
addq %rax, %rbx
xorl %eax, %eax
subq 0x298ef(%rip), %rax     # 0x48fc0
imulq $0x60, %rax, %rax
addq %rax, %rbx
movq %rbx, %rdi
callq 0x1f2ca
movq %rax, %rdi
callq 0x1f29f
movq %rax, %rdi
callq 0x1f250
movl %eax, %eax
leaq (%r14,%rax,8), %rdi
addq $0x2318, %rdi           # imm = 0x2318
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1f7a7
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/include/jemalloc/internal/arena.h
// Function: arena_run_dirty_insert
JEMALLOC_ALWAYS_INLINE arena_chunk_map_misc_t *
arena_miscelm_get_mutable(arena_chunk_t *chunk, size_t pageind)
{

	assert(pageind >= map_bias);
	assert(pageind < chunk_npages);

	return ((arena_chunk_map_misc_t *)((uintptr_t)chunk +
	    (uintptr_t)map_misc_offset) + pageind-map_bias);
}

// Assembly:
addq 0x29872(%rip), %rsi     # 0x48fc8
imulq $0x60, %rdx, %rax
xorl %edx, %edx
subq 0x2985d(%rip), %rdx     # 0x48fc0
addq %rsi, %rax
imulq $0x60, %rdx, %rdx
addq %rdx, %rax
addq $0x18, %rax
movq %rax, (%rax)
movq %rax, 0x8(%rax)
leaq 0x138(%rdi), %rdx
movq 0x140(%rdi), %rsi
movq %rax, (%rsi)
movq 0x8(%rax), %r8
movq %rdx, (%r8)
movq 0x8(%rax), %rdx
movq %rdx, 0x140(%rdi)
movq %rsi, 0x8(%rax)
addq %rcx, 0x130(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_bin_lower_run
static void
arena_bin_lower_run(arena_t *arena, arena_run_t *run, arena_bin_t *bin)
{

	/*
	 * Make sure that if bin->runcur is non-NULL, it refers to the
	 * oldest/lowest non-full run.  It is okay to NULL runcur out rather
	 * than proactively keeping it pointing at the oldest/lowest non-full
	 * run.
	 */
	if (bin->runcur != NULL &&
	    arena_snad_comp(arena_run_to_miscelm(bin->runcur),
	    arena_run_to_miscelm(run)) > 0) {
		/* Switch runcur. */
		if (bin->runcur->nfree > 0)
			arena_bin_runs_insert(bin, bin->runcur);
		bin->runcur = run;
		if (config_stats)
			bin->stats.reruns++;
	} else
		arena_bin_runs_insert(bin, run);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x50(%rsi), %r15
testq %r15, %r15
je 0x202a1
leaq -0x18(%r15), %rdi
leaq -0x18(%r14), %rsi
callq 0x1fd5c
testl %eax, %eax
jle 0x202a1
cmpl $0x0, 0x4(%r15)
je 0x20290
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20a51
movq %r14, 0x50(%rbx)
incq 0x98(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x20a51