LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_jemalloc_prefork
void
jemalloc_prefork(void)
#else
JEMALLOC_EXPORT void
_malloc_prefork(void)
#endif
{
	tsd_t *tsd;
	unsigned i, j, narenas;
	arena_t *arena;

#ifdef JEMALLOC_MUTEX_INIT_CB
	if (!malloc_initialized())
		return;
#endif
	assert(malloc_initialized());

	tsd = tsd_fetch();

	narenas = narenas_total_get();

	witness_prefork(tsd);
	/* Acquire all mutexes in a safe order. */
	ctl_prefork(tsd_tsdn(tsd));
	malloc_mutex_prefork(tsd_tsdn(tsd), &arenas_lock);
	prof_prefork0(tsd_tsdn(tsd));
	for (i = 0; i < 3; i++) {
		for (j = 0; j < narenas; j++) {
			if ((arena = arena_get(tsd_tsdn(tsd), j, false)) !=
			    NULL) {
				switch (i) {
				case 0:
					arena_prefork0(tsd_tsdn(tsd), arena);
					break;
				case 1:
					arena_prefork1(tsd_tsdn(tsd), arena);
					break;
				case 2:
					arena_prefork2(tsd_tsdn(tsd), arena);
					break;
				default: not_reached();
				}
			}
		}
	}
	base_prefork(tsd_tsdn(tsd));
	for (i = 0; i < narenas; i++) {
		if ((arena = arena_get(tsd_tsdn(tsd), i, false)) != NULL)
			arena_prefork3(tsd_tsdn(tsd), arena);
	}
	prof_prefork1(tsd_tsdn(tsd));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x2bebb(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %rbx
addq %rax, %rbx
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x20258
cmpl $0x2, %ecx
je 0x20261
xorl %r15d, %r15d
xorl %ebp, %ebp
lock
xaddl %ebp, 0x2c3e6(%rip)     # 0x4c540
movq %rbx, %rdi
callq 0x37666
movq %rbx, %rdi
callq 0x27df0
leaq 0x2c3d7(%rip), %rsi     # 0x4c548
movq %rbx, %rdi
callq 0x2e48e
movq %rbx, %rdi
callq 0x2f9be
movl %ebp, %r14d
leaq (,%r14,8), %r12
testl %ebp, %ebp
je 0x201ea
xorl %r13d, %r13d
movq 0x2c416(%rip), %rax     # 0x4c5b0
movq (%rax,%r13), %rsi
testq %rsi, %rsi
je 0x201d0
movq %rbx, %rdi
cmpl $0x2, %r15d
je 0x201b9
cmpl $0x1, %r15d
jne 0x201c0
callq 0x2485c
jmp 0x201c5
callq 0x24868
jmp 0x201c5
callq 0x24853
addq $0x8, %r13
cmpq %r13, %r12
jne 0x20193
jmp 0x201df
xorl %esi, %esi
lock
xaddq %rsi, (%rax,%r13)
testq %rsi, %rsi
jne 0x201a3
jmp 0x201c5
incl %r15d
cmpl $0x3, %r15d
jne 0x2018c
jmp 0x201fd
incl %r15d
cmpl $0x3, %r15d
jne 0x2018c
movq %rbx, %rdi
callq 0x26392
jmp 0x20242
movq %rbx, %rdi
callq 0x26392
testl %ebp, %ebp
je 0x20242
shlq $0x3, %r14
xorl %r15d, %r15d
movq 0x2c399(%rip), %rax     # 0x4c5b0
movq (%rax,%r15), %rsi
testq %rsi, %rsi
je 0x20233
movq %rbx, %rdi
callq 0x24874
addq $0x8, %r15
cmpq %r15, %r14
jne 0x20210
jmp 0x20242
xorl %esi, %esi
lock
xaddq %rsi, (%rax,%r15)
testq %rsi, %rsi
jne 0x20220
jmp 0x20228
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2fa36
movl $0x1, %fs:(%rax)
jmp 0x20268
movl $0x3, %fs:(%rax)
leaq 0x2d265(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %rbx, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x2014d
leaq 0x1bf79(%rip), %rdi     # 0x3c201
callq 0x3645c
cmpb $0x1, 0x2c28c(%rip)     # 0x4c520
jne 0x2014d
callq 0xb070
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_jemalloc_postfork_parent
void
jemalloc_postfork_parent(void)
#else
JEMALLOC_EXPORT void
_malloc_postfork(void)
#endif
{
	tsd_t *tsd;
	unsigned i, narenas;

#ifdef JEMALLOC_MUTEX_INIT_CB
	if (!malloc_initialized())
		return;
#endif
	assert(malloc_initialized());

	tsd = tsd_fetch();

	witness_postfork_parent(tsd);
	/* Release all mutexes, now that fork() has completed. */
	base_postfork_parent(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_parent(tsd_tsdn(tsd), arena);
	}
	prof_postfork_parent(tsd_tsdn(tsd));
	malloc_mutex_postfork_parent(tsd_tsdn(tsd), &arenas_lock);
	ctl_postfork_parent(tsd_tsdn(tsd));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x2bd3d(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %rbx
addq %rax, %rbx
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x20349
cmpl $0x2, %ecx
je 0x20352
movq %rbx, %rdi
callq 0x3766b
movq %rbx, %rdi
callq 0x2639e
xorl %eax, %eax
lock
xaddl %eax, 0x2c25b(%rip)     # 0x4c540
testl %eax, %eax
je 0x20325
movl %eax, %r14d
shlq $0x3, %r14
xorl %r15d, %r15d
movq 0x2c2b6(%rip), %rax     # 0x4c5b0
movq (%rax,%r15), %rsi
testq %rsi, %rsi
je 0x20316
movq %rbx, %rdi
callq 0x248c5
addq $0x8, %r15
cmpq %r15, %r14
jne 0x202f3
jmp 0x20325
xorl %esi, %esi
lock
xaddq %rsi, (%rax,%r15)
testq %rsi, %rsi
jne 0x20303
jmp 0x2030b
movq %rbx, %rdi
callq 0x2fa8d
leaq 0x2c214(%rip), %rsi     # 0x4c548
movq %rbx, %rdi
callq 0x2e496
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x27dfc
movl $0x1, %fs:(%rax)
jmp 0x20359
movl $0x3, %fs:(%rax)
leaq 0x2d174(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %rbx, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x202cb
leaq 0x1be88(%rip), %rdi     # 0x3c201
callq 0x3645c
cmpb $0x1, 0x2c19b(%rip)     # 0x4c520
jne 0x202cb
callq 0xb070
// File: /workspace/github_c_makefile_star2_O3/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 0x2bc4c(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %rbx
addq %rax, %rbx
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x2043a
cmpl $0x2, %ecx
je 0x20443
movq %rbx, %rdi
callq 0x37670
movq %rbx, %rdi
callq 0x263aa
xorl %eax, %eax
lock
xaddl %eax, 0x2c16a(%rip)     # 0x4c540
testl %eax, %eax
je 0x20416
movl %eax, %r14d
shlq $0x3, %r14
xorl %r15d, %r15d
movq 0x2c1c5(%rip), %rax     # 0x4c5b0
movq (%rax,%r15), %rsi
testq %rsi, %rsi
je 0x20407
movq %rbx, %rdi
callq 0x2493d
addq $0x8, %r15
cmpq %r15, %r14
jne 0x203e4
jmp 0x20416
xorl %esi, %esi
lock
xaddq %rsi, (%rax,%r15)
testq %rsi, %rsi
jne 0x203f4
jmp 0x203fc
movq %rbx, %rdi
callq 0x2fb54
leaq 0x2c123(%rip), %rsi     # 0x4c548
movq %rbx, %rdi
callq 0x2e49e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x27e08
movl $0x1, %fs:(%rax)
jmp 0x2044a
movl $0x3, %fs:(%rax)
leaq 0x2d083(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %rbx, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x203bc
leaq 0x1bd97(%rip), %rdi     # 0x3c201
callq 0x3645c
cmpb $0x1, 0x2c0aa(%rip)     # 0x4c520
jne 0x203bc
callq 0xb070
// File: /workspace/github_c_makefile_star2_O3/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: malloc_init_hard_a0
static bool
malloc_init_hard_a0(void)
{
	bool ret;

	malloc_mutex_lock(TSDN_NULL, &init_lock);
	ret = malloc_init_hard_a0_locked();
	malloc_mutex_unlock(TSDN_NULL, &init_lock);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x2bd4d(%rip), %rbx     # 0x4c360
movq %rbx, %rdi
callq 0xb5a0
callq 0x20633
movl %eax, %ebp
movq %rbx, %rdi
callq 0xb380
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2c02a(%rip), %rax     # 0x4d4b0
cmpb $0x1, (%rax)
jne 0x214ba
movq 0x2ab56(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %rbx
addq %rax, %rbx
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x2154d
cmpl $0x2, %ecx
jne 0x214bc
movl $0x3, %fs:(%rax)
jmp 0x21554
xorl %ebx, %ebx
xorl %eax, %eax
lock
xaddl %eax, 0x2b07a(%rip)     # 0x4c540
testl %eax, %eax
je 0x21534
movl %eax, %r13d
xorl %ebp, %ebp
movq 0x2b0da(%rip), %rax     # 0x4c5b0
movq (%rax,%rbp,8), %r14
testq %r14, %r14
je 0x21524
leaq 0x10(%r14), %r15
movq %r15, %rdi
callq 0xb5a0
movq 0xe0(%r14), %r12
testq %r12, %r12
je 0x21512
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x35f59
movq (%r12), %r12
cmpq 0xe0(%r14), %r12
jne 0x214f2
movq %r15, %rdi
callq 0xb380
incq %rbp
cmpq %r13, %rbp
jne 0x214cf
jmp 0x21534
xorl %r14d, %r14d
lock
xaddq %r14, (%rax,%rbp,8)
testq %r14, %r14
jne 0x214df
jmp 0x2151a
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 0x1ff56
movl $0x1, %fs:(%rax)
leaq 0x2bf79(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %rbx, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x214bc
leaq 0x1ac8d(%rip), %rdi     # 0x3c201
callq 0x3645c
cmpb $0x1, 0x2afa0(%rip)     # 0x4c520
jne 0x214bc
callq 0xb070
// File: /workspace/github_c_makefile_star2_O3/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 0x2192d
movq 0x58(%rax), %r14
testq %r14, %r14
je 0x2192d
cmpq %r14, %rax
jne 0x2190a
movq 0x50(%rax), %rax
movq %rax, 0x8f0(%r15)
cmpq %r14, %rax
je 0x2194d
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 0x21958
movq %rbx, %rdi
callq 0xb380
movl $0x70, %esi
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf880
movq $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_O3/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)
movq $0x0, 0x30(%r13)
leaq 0x2b6ab(%rip), %rax     # 0x4d0d0
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 0x21b25
addq %r12, 0x60(%rbx)
movq %r12, %r14
shrq $0xc, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21b9c
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 0x26812
addq $0x20, %rsp
movq %rax, %r13
movq %r15, %rdi
callq 0xb380
testq %r13, %r13
jne 0x21b13
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 0x26d04
addq $0x20, %rsp
movq %rax, %r13
testq %rax, %rax
jne 0x21b13
movq %r15, %rdi
callq 0xb5a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x249b5
subq %r12, 0x60(%rbx)
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
callq 0x21d13
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_O3/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 0x2b51b(%rip), %r8      # 0x4d0d0
movq (%r8), %r8
addq %r8, %rax
shlq $0xc, %rdx
addq %r8, %rdx
notq %r8
andq %r8, %rax
andq %r8, %rdx
subq %rdx, %rax
je 0x21be6
leaq 0x2b899(%rip), %rcx     # 0x4d470
lock
xaddq %rax, (%rcx)
addq 0x128(%rdi), %rsi
movq %rsi, %rcx
movq %rcx, 0x128(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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)
movaps %xmm0, 0x10(%r13)
movaps %xmm0, (%r13)
movq $0x0, 0x30(%r13)
leaq 0x2b49b(%rip), %rax     # 0x4d0d0
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 0x21ca5
subq %rbp, 0x60(%r15)
shrq $0xc, %rbp
movq %r15, %rdi
movq %rbp, %rsi
callq 0x21d13
movl $0x1, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq 0x10(%rsp), %rcx
movq %rbx, %r8
movq 0x18(%rsp), %r9
callq 0x26fb0
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_O3/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 0x2b3a8(%rip), %rcx     # 0x4d0d0
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 0x21d5f
leaq 0x2b720(%rip), %rax     # 0x4d470
lock
xaddq %rcx, (%rax)
movq 0x128(%rdi), %rax
subq %rsi, %rax
movq %rax, 0x128(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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
callq 0x21ca5
movq %r14, %rdi
movq %r15, %rsi
callq 0x21b25
movq %r12, %rsi
subq %r15, %rsi
jae 0x21db6
subq %r12, %r15
shrq $0xc, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x21b9c
jmp 0x21dc2
shrq $0xc, %rsi
movq %r14, %rdi
callq 0x21d13
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O3/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 0x2b2c8(%rip), %rax     # 0x4d0d0
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
callq 0x21ca5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21b25
subq %r15, %r13
jne 0x21e58
shrq $0xc, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x21d13
jmp 0x21eba
subq %r13, 0x60(%r14)
shrq $0xc, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x21d13
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdx
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq $0x0, 0x30(%rdx)
leaq 0x2b243(%rip), %rax     # 0x4d0d0
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 0x26fb0
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_O3/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 0x2220a
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 0x2221b
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_O3/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 0x2247f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x2a38d(%rip)     # 0x4c5d0
je 0x2232b
cmpq $0x0, 0x1b8(%rbx)
jle 0x22380
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x2e4d0
movq %r15, %rdi
callq 0x2e56f
callq 0x2e56c
testb %al, %al
jne 0x22293
leaq 0x1c8(%rbx), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2e532
testl %eax, %eax
jg 0x22480
leaq 0x1d8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2e532
testl %eax, %eax
jg 0x22471
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x2e52b
leaq 0x1c8(%rbx), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x2e548
leaq 0x1c0(%rbx), %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq 0x2e563
movq %rax, %r15
movq %r12, %rdi
movq %rbp, %rsi
callq 0x2e52b
movq %r12, %rdi
movq %r15, %rsi
callq 0x2e54f
movq %r13, %rdi
movq %r12, %rsi
callq 0x2e541
movq %rbx, %rdi
callq 0x24a18
leaq 0x1e8(%rbx), %r12
cmpq $0xc8, %r15
jb 0x22398
movl $0x638, %edx            # imm = 0x638
movq %r12, %rdi
jmp 0x223c7
movq 0x118(%rbx), %rcx
testq %rcx, %rcx
js 0x22471
movq 0x128(%rbx), %rdx
shrq %cl, %rdx
leaq 0x2ad8c(%rip), %r15     # 0x4d0d8
movq (%r15), %rax
cmpq %rax, %rdx
cmovbeq %rax, %rdx
cmpq %rdx, 0x130(%rbx)
jbe 0x22471
movq %r14, %rdi
movq %rbx, %rsi
callq 0x225f9
movq 0x128(%rbx), %rdx
movb 0x118(%rbx), %cl
shrq %cl, %rdx
jmp 0x2234c
jne 0x22471
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x225f9
jmp 0x22471
leaq (%r12,%r15,8), %rsi
movl $0xc8, %r13d
subq %r15, %r13
leal (,%r13,8), %edx
movq %r12, %rdi
callq 0xb450
cmpq $0x2, %r15
jb 0x223ce
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)
pxor %xmm0, %xmm0
leaq 0x19f69(%rip), %rdx     # 0x3c360
movdqu 0x1e8(%rbx,%rcx), %xmm1
movdqa (%rcx,%rdx), %xmm2
movdqa %xmm2, %xmm3
psrlq $0x20, %xmm3
pmuludq %xmm1, %xmm3
movdqa %xmm1, %xmm4
psrlq $0x20, %xmm4
pmuludq %xmm2, %xmm4
paddq %xmm3, %xmm4
psllq $0x20, %xmm4
pmuludq %xmm1, %xmm2
paddq %xmm2, %xmm0
paddq %xmm4, %xmm0
addq $0x10, %rcx
cmpq $0x640, %rcx            # imm = 0x640
jne 0x223f7
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddq %xmm0, %xmm1
movq %xmm1, %rdx
shrq $0x18, %rdx
cmpq %rdx, %rax
jbe 0x2246a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x225f9
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 0x2e52b
movq %rbx, %rdi
callq 0x24a18
jmp 0x22293
// File: /workspace/github_c_makefile_star2_O3/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 0x2251b
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 0x22530
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2221b
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_O3/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 0x22561
leaq 0x1c0(%rbx), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x2e4d4
movl $0xc8, %esi
movq %r14, %rdi
callq 0x2e557
leaq 0x1c8(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x2e4d0
movq %r14, %rdi
callq 0x2e56f
movq %rbx, 0x1d0(%rbx)
movq %rbx, %rdi
callq 0x24a18
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_O3/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 0x225e2
xorl %edx, %edx
callq 0x225f9
jmp 0x225e7
callq 0x2221b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O3/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)
movq $0x0, 0x40(%rsp)
movq %rdx, %rdi
movq %rdx, %rsi
callq 0x267b6
movq 0x18(%r14), %r12
movb 0x70(%r14), %r13b
movq 0x78(%r14), %rbp
testb $0x4, %bpl
je 0x22f99
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x26557
leaq 0x2a14d(%rip), %rax     # 0x4d0c8
movq (%rax), %rsi
movq 0x2a03b(%rip), %rcx     # 0x4cfc0
shlq $0xc, %rcx
movl (%rbx), %r8d
movq %r14, %rdi
xorl %edx, %edx
leaq 0x10(%rsp), %rax
callq *0x18(%rax)
testb %r13b, %r13b
jne 0x22fb0
leaq 0x2a123(%rip), %rax     # 0x4d0c8
movq (%rax), %rsi
movq %r14, %rdi
callq 0x2e734
xorl %eax, %eax
testb $0x4, %bpl
sete %al
leaq 0x2a108(%rip), %r13     # 0x4d0c8
movq (%r13), %r8
movl %eax, (%rsp)
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
movq %r12, %r9
callq 0x26fb0
movq (%r13), %rax
subq %rax, 0x60(%rbx)
movq 0x29fd4(%rip), %rax     # 0x4cfc0
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_O3/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 0x2332b
movl $0xa5, %esi
movq %r14, %rdx
callq 0xb230
addq (%rbx), %r15
movq %r15, %rdi
movl $0xa5, %esi
movq %r14, %rdx
jmp 0x23334
movq 0x10(%rbx), %rdx
movl $0xa5, %esi
popq %rbx
popq %r14
popq %r15
jmp 0xb230
// File: /workspace/github_c_makefile_star2_O3/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 0xf720
testq %rax, %rax
jne 0x2352e
movq %r15, %rdi
movq %r14, %rsi
callq 0x24b13
testq %rax, %rax
je 0x23539
movq 0x29ac3(%rip), %rcx     # 0x4cfc8
leaq (%rcx,%rax), %r15
addq $0x18, %r15
movzbl %bpl, %r8d
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x24f71
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 0xf720
// File: /workspace/github_c_makefile_star2_O3/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 0x297f2(%rip), %rax     # 0x4cfc0
movq %r8, %rcx
subq %rax, %rcx
movq 0x78(%rdx,%rcx,8), %rcx
shrq $0xd, %rcx
subq %rcx, %r8
movq 0x297e1(%rip), %rcx     # 0x4cfc8
addq %rdx, %rcx
leaq (%r8,%r8,2), %rdx
shlq $0x5, %rdx
addq %rcx, %rdx
negq %rax
leaq (%rax,%rax,2), %rax
shlq $0x5, %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 0x2355a
movq %r13, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O3/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 0x2973e(%rip), %r14     # 0x4cfc8
movq 0x2972f(%rip), %r13     # 0x4cfc0
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 0x238c3
leaq 0x28c68(%rip), %rax     # 0x4c522
cmpb $0x1, (%rax)
je 0x2397a
cmpq $0x1000, %rdx           # imm = 0x1000
ja 0x2395d
addq $-0x1001, %r12          # imm = 0xEFFF
shrq $0x3, %r12
leaq 0x1855e(%rip), %rax     # 0x3be40
movzbl (%rax,%r12), %eax
negq %r13
addq %r15, %r14
leaq (,%rbp,2), %rcx
addq %rbp, %rcx
shlq $0x5, %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)
leaq (,%r13,2), %rsi
addq %r13, %rsi
decq 0x18(%rdx,%rax)
shlq $0x5, %rsi
leaq (%rsi,%rcx), %rdx
addq $0x18, %rdx
movq %rbx, %rsi
movl $0x1, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xed9d
movq %rdi, 0x8(%rsp)
movq %rdx, %rdi
movq %rdx, %r12
callq 0xf6d1
movq %r12, %rdx
movq 0x8(%rsp), %rdi
jmp 0x238e7
movq %rdi, 0x8(%rsp)
movq %rcx, %rdi
movl $0x5a, %esi
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rdx
callq 0xb230
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rdi
jmp 0x238c3
// File: /workspace/github_c_makefile_star2_O3/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 0x2e496
leaq 0x980(%rbx), %r15
xorl %r12d, %r12d
leaq (%r15,%r12), %rsi
movq %r14, %rdi
callq 0x2e496
addq $0xa8, %r12
cmpq $0x1998, %r12           # imm = 0x1998
jne 0x248e9
leaq 0x8f8(%rbx), %rsi
movq %r14, %rdi
callq 0x2e496
leaq 0x8a0(%rbx), %rsi
movq %r14, %rdi
callq 0x2e496
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2e496
// File: /workspace/github_c_makefile_star2_O3/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 0x2e49e
leaq 0x980(%rbx), %r15
xorl %r12d, %r12d
leaq (%r15,%r12), %rsi
movq %r14, %rdi
callq 0x2e49e
addq $0xa8, %r12
cmpq $0x1998, %r12           # imm = 0x1998
jne 0x24961
leaq 0x8f8(%rbx), %rsi
movq %r14, %rdi
callq 0x2e49e
leaq 0x8a0(%rbx), %rsi
movq %r14, %rdi
callq 0x2e49e
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2e49e
// File: /workspace/github_c_makefile_star2_O3/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 0x2e52b
leaq 0x1c0(%r14), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2e541
cmpq $0x0, 0x1b8(%r14)
jle 0x24b09
movq %r15, %rdi
callq 0x2e4e2
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
movl $0x40, %esi
subq %rdx, %rsi
incq %rcx
movl $0x41, %ecx
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 0x24ad8
movq %rdx, 0x1d0(%r14)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2e4d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e541
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x50(%rsi), %rdx
testq %rdx, %rdx
je 0x25b56
leaq -0x18(%rdx), %rax
leaq -0x18(%rdi), %rcx
leaq 0x275e7(%rip), %r8      # 0x4d0d0
movq (%r8), %r9
notq %r9
movq %rax, %r8
andq %r9, %r8
movq 0x18(%r8), %r10
andq %rcx, %r9
xorl %r8d, %r8d
cmpq 0x18(%r9), %r10
seta %r8b
sbbl $0x0, %r8d
jne 0x25b1b
xorl %r8d, %r8d
cmpq %rcx, %rax
seta %r8b
sbbl $0x0, %r8d
testl %r8d, %r8d
jle 0x25b5d
cmpl $0x0, 0x4(%rdx)
je 0x25b9f
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x58(%rsi), %rcx
testq %rcx, %rcx
je 0x25b98
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
testq %rdx, %rdx
je 0x25b4d
movq %rax, (%rdx)
movq %rcx, (%rax)
addq $0x8, %rcx
jmp 0x25b9c
addq $-0x18, %rdi
movq %rdi, %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
movq 0x58(%rsi), %rax
testq %rax, %rax
je 0x25b8d
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rcx)
testq %rdx, %rdx
je 0x25b84
movq %rcx, (%rdx)
movq %rax, (%rcx)
addq $0x8, %rax
jmp 0x25b94
addq $0x58, %rsi
movq %rsi, %rax
movq %rcx, (%rax)
retq
leaq 0x58(%rsi), %rcx
movq %rax, (%rcx)
movq %rdi, 0x50(%rsi)
incq 0x98(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x26cc8(%rip), %r12     # 0x4cfd8
movq %r12, %rdi
callq 0xb5a0
movq 0x26d11(%rip), %rax     # 0x4d030
movq %rax, (%r15)
movq 0x26d0f(%rip), %rax     # 0x4d038
movq %rax, (%r14)
movq 0x26d0d(%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_O3/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 0x26c84(%rip), %rdi     # 0x4cfd8
leaq 0x1672d(%rip), %rsi     # 0x3ca88
movl $0xb, %edx
callq 0x2e43c
movl %eax, %ebx
testb %al, %al
jne 0x26388
xorl %r14d, %r14d
movq %r14, 0x26cd3(%rip)     # 0x4d048
leaq 0x26cac(%rip), %rdi     # 0x4d028
callq 0x2c2a8
movq %r14, 0x26cc8(%rip)     # 0x4d050
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x27081(%rip), %rax     # 0x4d4b0
cmpb $0x1, (%rax)
jne 0x26461
movq 0x25bad(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %rbp
addq %rax, %rbp
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x264a6
cmpl $0x2, %ecx
jne 0x26463
movq %r9, 0x10(%rsp)
movl $0x3, %fs:(%rax)
jmp 0x264b2
xorl %ebp, %ebp
leaq 0x26146(%rip), %rax     # 0x4c5b0
movq (%rax), %rax
movl %ebx, %ecx
movq (%rax,%rcx,8), %rsi
testq %rsi, %rsi
je 0x2649c
movq %r12, (%rsp)
movq %rbp, %rdi
movq %r13, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x26ec4
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 0x26478
movq %r9, 0x10(%rsp)
movl $0x1, %fs:(%rax)
leaq 0x2701b(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %rbp, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x264ed
leaq 0x15d33(%rip), %rdi     # 0x3c201
callq 0x3645c
leaq 0x26046(%rip), %rax     # 0x4c520
cmpb $0x1, (%rax)
movq 0x10(%rsp), %r9
jne 0x26463
callq 0xb070
movq 0x10(%rsp), %r9
jmp 0x26463
// File: /workspace/github_c_makefile_star2_O3/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 0x26891
movq %rax, %r14
testq %rax, %rax
je 0x26879
leaq 0x25d28(%rip), %rax     # 0x4c59c
cmpb $0x1, (%rax)
je 0x26884
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x376c2
jmp 0x26879