LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_chunk_cache_maybe_remove
void
arena_chunk_cache_maybe_remove(arena_t *arena, extent_node_t *node, bool dirty)
{

	if (dirty) {
		extent_node_dirty_remove(node);
		assert(arena->ndirty >= arena_chunk_dirty_npages(node));
		arena->ndirty -= arena_chunk_dirty_npages(node);
	}
}

// Assembly:
testl %edx, %edx
je 0x21a43
leaq 0x30(%rsi), %rax
movq 0x30(%rsi), %rcx
movq 0x38(%rsi), %rdx
movq %rcx, (%rdx)
movq 0x30(%rsi), %rcx
movq %rdx, 0x8(%rcx)
movq %rax, 0x30(%rsi)
movq %rax, 0x38(%rsi)
movq 0x40(%rsi), %rax
movq 0x48(%rsi), %rcx
movq %rax, 0x40(%rcx)
movq 0x40(%rsi), %rax
movq %rcx, 0x48(%rax)
movq %rsi, 0x40(%rsi)
movq %rsi, 0x48(%rsi)
movq 0x10(%rsi), %rax
shrq $0xc, %rax
subq %rax, 0x130(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x21a73
movq 0x58(%rax), %r14
jmp 0x21a76
xorl %r14d, %r14d
testq %r14, %r14
je 0x21a86
testq %rax, %rax
je 0x21aa6
movq 0x58(%rax), %rcx
jmp 0x21aa8
movq %rbx, %rdi
callq 0xb380
movl $0x70, %esi
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xff71
xorl %ecx, %ecx
cmpq %rcx, %rax
jne 0x21ab8
movq 0x50(%rax), %rax
movq %rax, 0x8f0(%r15)
cmpq %rcx, 0x8f0(%r15)
je 0x21ae3
movq 0x50(%rcx), %rax
movq 0x58(%rcx), %rdx
movq %rax, 0x50(%rdx)
movq 0x50(%rcx), %rax
movq 0x58(%rcx), %rdx
movq %rdx, 0x58(%rax)
movq %rcx, 0x50(%rcx)
movq %rcx, 0x58(%rcx)
jmp 0x21aee
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_O1/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, %r15
movq %rsi, %r14
leaq 0x8f8(%rsi), %rbx
movq %rbx, %rdi
callq 0xb5a0
movq %r15, 0x50(%r15)
movq %r15, 0x58(%r15)
movq 0x8f0(%r14), %rax
testq %rax, %rax
je 0x21b55
movq 0x58(%rax), %rax
movq %rax, 0x58(%r15)
movq 0x8f0(%r14), %rcx
movq %rcx, 0x50(%r15)
movq %r15, 0x50(%rax)
movq 0x8f0(%r14), %rax
movq %r15, 0x58(%rax)
movq 0x50(%r15), %rax
movq %rax, 0x8f0(%r14)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O1/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 0x2b515(%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 0x21cbb
addq %r12, 0x60(%rbx)
movq %r12, %r14
shrq $0xc, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21d1e
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 0x2687b
addq $0x20, %rsp
movq %rax, %r13
movq %r15, %rdi
callq 0xb380
testq %r13, %r13
jne 0x21ca9
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 0x26d69
addq $0x20, %rsp
movq %rax, %r13
testq %rax, %rax
jne 0x21ca9
movq %r15, %rdi
callq 0xb5a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x24aa6
subq %r12, 0x60(%rbx)
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
callq 0x21e7e
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_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_huge_malloc_stats_update
static void
arena_huge_malloc_stats_update(arena_t *arena, size_t usize)
{
	szind_t index = size2index(usize) - nlclasses - NBINS;

	cassert(config_stats);

	arena->stats.nmalloc_huge++;
	arena->stats.allocated_huge += usize;
	arena->stats.hstats[index].nmalloc++;
	arena->stats.hstats[index].curhchunks++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x1000, %rsi           # imm = 0x1000
ja 0x21d14
leaq -0x1(%r14), %rax
shrq $0x3, %rax
leaq 0x1a0e3(%rip), %rcx     # 0x3bdc0
movzbl (%rcx,%rax), %eax
subl 0x2a8ed(%rip), %eax     # 0x4c5d4
addl $-0x27, %eax
incq 0xc0(%rbx)
addq %r14, 0xb8(%rbx)
movq 0xd8(%rbx), %rcx
leaq (%rax,%rax,2), %rax
incq (%rcx,%rax,8)
incq 0x10(%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0xfdc2
jmp 0x21ce1
// File: /workspace/github_c_makefile_star2_O1/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), %rcx
leaq (%rcx,%rsi), %rax
shlq $0xc, %rax
leaq 0x2b39c(%rip), %rdx     # 0x4d0d0
movq (%rdx), %rdx
addq %rdx, %rax
shlq $0xc, %rcx
addq %rdx, %rcx
notq %rdx
andq %rdx, %rax
andq %rdx, %rcx
subq %rcx, %rax
je 0x21d5b
leaq 0x2b71a(%rip), %rcx     # 0x4d470
lock
xaddq %rax, (%rcx)
addq %rsi, 0x128(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2b326(%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 0x21e1a
subq %rbp, 0x60(%r15)
shrq $0xc, %rbp
movq %r15, %rdi
movq %rbp, %rsi
callq 0x21e7e
movl $0x1, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq 0x10(%rsp), %rcx
movq %rbx, %r8
movq 0x18(%rsp), %r9
callq 0x27026
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_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_huge_dalloc_stats_update
static void
arena_huge_dalloc_stats_update(arena_t *arena, size_t usize)
{
	szind_t index = size2index(usize) - nlclasses - NBINS;

	cassert(config_stats);

	arena->stats.ndalloc_huge++;
	arena->stats.allocated_huge -= usize;
	arena->stats.hstats[index].ndalloc++;
	arena->stats.hstats[index].curhchunks--;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x1000, %rsi           # imm = 0x1000
ja 0x21e74
leaq -0x1(%r14), %rax
shrq $0x3, %rax
leaq 0x19f84(%rip), %rcx     # 0x3bdc0
movzbl (%rcx,%rax), %eax
subl 0x2a78e(%rip), %eax     # 0x4c5d4
addl $-0x27, %eax
incq 0xc8(%rbx)
subq %r14, 0xb8(%rbx)
movq 0xd8(%rbx), %rcx
leaq (%rax,%rax,2), %rax
incq 0x8(%rcx,%rax,8)
decq 0x10(%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0xfdc2
jmp 0x21e40
// File: /workspace/github_c_makefile_star2_O1/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, %rcx
shlq $0xc, %rcx
leaq 0x2b23d(%rip), %rdx     # 0x4d0d0
movq (%rdx), %rdx
addq %rdx, %rcx
subq %rsi, %rax
shlq $0xc, %rax
addq %rdx, %rax
notq %rdx
andq %rdx, %rcx
andq %rdx, %rax
subq %rcx, %rax
je 0x21ebd
leaq 0x2b5b8(%rip), %rcx     # 0x4d470
lock
xaddq %rax, (%rcx)
subq %rsi, 0x128(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x21e1a
movq %r14, %rdi
movq %r15, %rsi
callq 0x21cbb
movq %r12, %rsi
subq %r15, %rsi
jae 0x21f14
subq %r12, %r15
shrq $0xc, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x21d1e
jmp 0x21f20
shrq $0xc, %rsi
movq %r14, %rdi
callq 0x21e7e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/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 0x2b16a(%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 0x21e1a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21cbb
subq %r15, %r13
jne 0x21fb6
shrq $0xc, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x21e7e
jmp 0x22018
subq %r13, 0x60(%r14)
shrq $0xc, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x21e7e
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdx
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq $0x0, 0x30(%rdx)
leaq 0x2b0e5(%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 0x27026
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_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_lg_dirty_mult_get
ssize_t
arena_lg_dirty_mult_get(tsdn_t *tsdn, arena_t *arena)
{
	ssize_t lg_dirty_mult;

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

	return (lg_dirty_mult);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x10(%rsi), %r14
movq %r14, %rdi
callq 0xb5a0
movq 0x118(%rbx), %rbx
movq %r14, %rdi
callq 0xb380
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/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 0x22357
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 0x22368
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_O1/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 0x22593
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x2a240(%rip)     # 0x4c5d0
je 0x22478
cmpq $0x0, 0x1b8(%rbx)
jle 0x224d1
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x2e670
movq %r15, %rdi
callq 0x2e70f
callq 0x2e70c
testb %al, %al
jne 0x223e0
leaq 0x1c8(%rbx), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2e6d2
testl %eax, %eax
jg 0x22594
leaq 0x1d8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2e6d2
testl %eax, %eax
jg 0x22585
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x2e6cb
leaq 0x1c8(%rbx), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x2e6e8
leaq 0x1c0(%rbx), %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq 0x2e703
movq %rax, %r15
movq %r12, %rdi
movq %rbp, %rsi
callq 0x2e6cb
movq %r12, %rdi
movq %r15, %rsi
callq 0x2e6ef
movq %r13, %rdi
movq %r12, %rsi
callq 0x2e6e1
movq %rbx, %rdi
callq 0x24b09
leaq 0x1e8(%rbx), %r12
cmpq $0xc8, %r15
jb 0x224e9
movl $0x638, %edx            # imm = 0x638
movq %r12, %rdi
jmp 0x22518
cmpq $0x0, 0x118(%rbx)
js 0x22585
movq 0x128(%rbx), %rdx
movb 0x118(%rbx), %cl
shrq %cl, %rdx
leaq 0x2ac3b(%rip), %r15     # 0x4d0d8
movq (%r15), %rax
cmpq %rax, %rdx
cmovbeq %rax, %rdx
cmpq %rdx, 0x130(%rbx)
jbe 0x22585
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2270d
movq 0x128(%rbx), %rdx
movb 0x118(%rbx), %cl
shrq %cl, %rdx
jmp 0x2249d
jne 0x22585
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2270d
jmp 0x22585
leaq (%r12,%r15,8), %rsi
movl $0xc8, %r13d
subq %r15, %r13
leal (,%r13,8), %edx
movq %r12, %rdi
callq 0xb450
cmpq $0x2, %r15
jb 0x2251f
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 0x19d5c(%rip), %rsi     # 0x3c2a0
xorl %edx, %edx
movq (%rcx,%rsi), %rdi
imulq 0x1e8(%rbx,%rcx), %rdi
addq %rdi, %rdx
addq $0x8, %rcx
cmpq $0x640, %rcx            # imm = 0x640
jne 0x22546
shrq $0x18, %rdx
cmpq %rdx, %rax
jbe 0x22577
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2270d
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 0x2e6cb
movq %rbx, %rdi
callq 0x24b09
jmp 0x223e0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_decay_time_get
ssize_t
arena_decay_time_get(tsdn_t *tsdn, arena_t *arena)
{
	ssize_t decay_time;

	malloc_mutex_lock(tsdn, &arena->lock);
	decay_time = arena->decay.time;
	malloc_mutex_unlock(tsdn, &arena->lock);

	return (decay_time);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x10(%rsi), %r14
movq %r14, %rdi
callq 0xb5a0
movq 0x1b8(%rbx), %rbx
movq %r14, %rdi
callq 0xb380
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/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 0x2262f
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 0x22644
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22368
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_O1/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 0x22675
leaq 0x1c0(%rbx), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x2e674
movl $0xc8, %esi
movq %r14, %rdi
callq 0x2e6f7
leaq 0x1c8(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x2e670
movq %r14, %rdi
callq 0x2e70f
movq %rbx, 0x1d0(%rbx)
movq %rbx, %rdi
callq 0x24b09
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_O1/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 0x226f6
xorl %edx, %edx
callq 0x2270d
jmp 0x226fb
callq 0x22368
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O1/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 0x26812
movq 0x18(%r14), %r12
movb 0x70(%r14), %r13b
movq 0x78(%r14), %rbp
testb $0x4, %bpl
je 0x2306a
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x265ab
leaq 0x2a07c(%rip), %rax     # 0x4d0c8
movq (%rax), %rsi
movq 0x29f6a(%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 0x23081
leaq 0x2a052(%rip), %rax     # 0x4d0c8
movq (%rax), %rsi
movq %r14, %rdi
callq 0x2e8d0
xorl %eax, %eax
testb $0x4, %bpl
sete %al
leaq 0x2a037(%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 0x27026
movq (%r13), %rax
subq %rax, 0x60(%rbx)
movq 0x29f03(%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_O1/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 0x23428
movl $0xa5, %esi
movq %r14, %rdx
callq 0xb230
addq (%rbx), %r15
movq %r15, %rdi
movl $0xa5, %esi
movq %r14, %rdx
jmp 0x23431
movq 0x10(%rbx), %rdx
movl $0xa5, %esi
popq %rbx
popq %r14
popq %r15
jmp 0xb230
// File: /workspace/github_c_makefile_star2_O1/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 0x23468
movq 0x10(%rbx), %rdx
movq %r14, %rdi
movl $0x5a, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb230
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_redzones_validate
static void
arena_redzones_validate(void *ptr, arena_bin_info_t *bin_info, bool reset)
{
	bool error = false;

	if (opt_junk_alloc) {
		size_t size = bin_info->reg_size;
		size_t redzone_size = bin_info->redzone_size;
		size_t i;

		for (i = 1; i <= redzone_size; i++) {
			uint8_t *byte = (uint8_t *)((uintptr_t)ptr - i);
			if (*byte != JEMALLOC_ALLOC_JUNK) {
				error = true;
				arena_redzone_corruption(ptr, size, false, i,
				    *byte);
				if (reset)
					*byte = JEMALLOC_ALLOC_JUNK;
			}
		}
		for (i = 0; i < redzone_size; i++) {
			uint8_t *byte = (uint8_t *)((uintptr_t)ptr + size + i);
			if (*byte != JEMALLOC_ALLOC_JUNK) {
				error = true;
				arena_redzone_corruption(ptr, size, true, i,
				    *byte);
				if (reset)
					*byte = JEMALLOC_ALLOC_JUNK;
			}
		}
	}

	if (opt_abort && error)
		abort();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x290a7(%rip), %rax     # 0x4c521
cmpb $0x1, (%rax)
jne 0x234f6
movl %edx, %ebx
movq %rdi, %r14
movq (%rsi), %r15
movq 0x8(%rsi), %r13
testq %r13, %r13
je 0x234fa
leaq -0x1(%r14), %rbp
movl $0x1, %r12d
xorl %eax, %eax
movzbl (%rbp), %ecx
cmpl $0xa5, %ecx
je 0x234e9
cmpq $0x1, %r12
leaq 0x15b86(%rip), %rdx     # 0x39039
leaq 0x1628b(%rip), %rax     # 0x39745
cmoveq %rax, %rdx
movl %ecx, (%rsp)
leaq 0x18d79(%rip), %rdi     # 0x3c241
movq %r12, %rsi
leaq 0x18db8(%rip), %rcx     # 0x3c28a
movq %r14, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x36ef7
movb $0x1, %al
testb %bl, %bl
je 0x234e9
movb $-0x5b, (%rbp)
incq %r12
decq %rbp
cmpq %r13, %r12
jbe 0x2349c
jmp 0x234fc
xorl %eax, %eax
jmp 0x2355f
xorl %eax, %eax
testq %r13, %r13
je 0x2355f
leaq (%r15,%r14), %r12
xorl %ebp, %ebp
movzbl (%r12,%rbp), %ecx
cmpl $0xa5, %ecx
je 0x23557
cmpq $0x1, %rbp
leaq 0x15b1a(%rip), %rdx     # 0x39039
leaq 0x1621f(%rip), %rax     # 0x39745
cmoveq %rax, %rdx
movl %ecx, (%rsp)
leaq 0x18d0d(%rip), %rdi     # 0x3c241
movq %rbp, %rsi
leaq 0x18d46(%rip), %rcx     # 0x3c284
movq %r14, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x36ef7
movb $0x1, %al
testb %bl, %bl
je 0x23557
movb $-0x5b, (%rbp,%r12)
incq %rbp
cmpq %rbp, %r13
jne 0x23507
leaq 0x28fba(%rip), %rcx     # 0x4c520
cmpb $0x1, (%rcx)
jne 0x2356f
testb $0x1, %al
jne 0x2357e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xb070
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_quarantine_junk_small
void
arena_quarantine_junk_small(void *ptr, size_t usize)
{
	szind_t binind;
	arena_bin_info_t *bin_info;
	cassert(config_fill);
	assert(opt_junk_free);
	assert(opt_quarantine);
	assert(usize <= SMALL_MAXCLASS);

	binind = size2index(usize);
	bin_info = &arena_bin_info[binind];
	arena_redzones_validate(ptr, bin_info, true);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x1000, %rsi           # imm = 0x1000
ja 0x235c0
decq %rsi
shrq $0x3, %rsi
leaq 0x18822(%rip), %rax     # 0x3bdc0
movzbl (%rax,%rsi), %eax
movl %eax, %eax
shlq $0x6, %rax
leaq 0x29031(%rip), %rsi     # 0x4c5e0
addq %rax, %rsi
movq %rbx, %rdi
movl $0x1, %edx
popq %rbx
jmp 0x23468
movq %rsi, %rdi
callq 0xfdc2
jmp 0x235a2
// File: /workspace/github_c_makefile_star2_O1/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 0xfe11
testq %rax, %rax
jne 0x2362e
movq %r15, %rdi
movq %r14, %rsi
callq 0x24c04
testq %rax, %rax
je 0x23639
movq 0x299c3(%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 0x25003
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 0xfe11
// File: /workspace/github_c_makefile_star2_O1/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 0x296e8(%rip), %rax     # 0x4cfc0
movq %r8, %rcx
subq %rax, %rcx
movq 0x78(%rdx,%rcx,8), %rcx
shrq $0xd, %rcx
subq %rcx, %r8
movq 0x296d7(%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 0x2365a
movq %r13, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O1/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 0x29634(%rip), %r14     # 0x4cfc8
movq 0x29625(%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 0x239cd
leaq 0x28b5e(%rip), %rax     # 0x4c522
cmpb $0x1, (%rax)
je 0x23a84
cmpq $0x1000, %rdx           # imm = 0x1000
ja 0x23a67
addq $-0x1001, %r12          # imm = 0xEFFF
shrq $0x3, %r12
leaq 0x183d4(%rip), %rax     # 0x3bdc0
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 0xf459
movq %rdi, 0x8(%rsp)
movq %rdx, %rdi
movq %rdx, %r12
callq 0xfdc2
movq %r12, %rdx
movq 0x8(%rsp), %rdi
jmp 0x239f1
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 0x239cd
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_dss_prec_get
dss_prec_t
arena_dss_prec_get(tsdn_t *tsdn, arena_t *arena)
{
	dss_prec_t ret;

	malloc_mutex_lock(tsdn, &arena->lock);
	ret = arena->dss_prec;
	malloc_mutex_unlock(tsdn, &arena->lock);
	return (ret);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x10(%rsi), %r14
movq %r14, %rdi
callq 0xb5a0
movl 0xf8(%rbx), %ebx
movq %r14, %rdi
callq 0xb380
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_dss_prec_set
bool
arena_dss_prec_set(tsdn_t *tsdn, arena_t *arena, dss_prec_t dss_prec)
{

	if (!have_dss)
		return (dss_prec != dss_prec_disabled);
	malloc_mutex_lock(tsdn, &arena->lock);
	arena->dss_prec = dss_prec;
	malloc_mutex_unlock(tsdn, &arena->lock);
	return (false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
leaq 0x10(%rsi), %r15
movq %r15, %rdi
callq 0xb5a0
movl %ebx, 0xf8(%r14)
movq %r15, %rdi
callq 0xb380
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rbx
leaq 0x10(%rsi), %rbp
movq %rbp, %rdi
callq 0xb5a0
xorl %eax, %eax
lock
xaddl %eax, 0x4(%r13)
addl %eax, (%r12)
movl 0xf8(%r13), %eax
leaq 0x2881f(%rip), %rcx     # 0x4c3e0
movq (%rcx,%rax,8), %rax
movq %rax, (%r15)
movq 0x118(%r13), %rax
movq %rax, (%r14)
movq 0x1b8(%r13), %rax
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq 0x128(%r13), %rax
addq %rax, (%rbx)
movq 0x130(%r13), %rax
movq 0x8(%rsp), %rcx
addq %rax, (%rcx)
movq %rbp, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb380
// File: /workspace/github_c_makefile_star2_O1/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 0x2e636
leaq 0x980(%rbx), %r15
xorl %r12d, %r12d
leaq (%r15,%r12), %rsi
movq %r14, %rdi
callq 0x2e636
addq $0xa8, %r12
cmpq $0x1998, %r12           # imm = 0x1998
jne 0x249da
leaq 0x8f8(%rbx), %rsi
movq %r14, %rdi
callq 0x2e636
leaq 0x8a0(%rbx), %rsi
movq %r14, %rdi
callq 0x2e636
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2e636
// File: /workspace/github_c_makefile_star2_O1/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 0x2e63e
leaq 0x980(%rbx), %r15
xorl %r12d, %r12d
leaq (%r15,%r12), %rsi
movq %r14, %rdi
callq 0x2e63e
addq $0xa8, %r12
cmpq $0x1998, %r12           # imm = 0x1998
jne 0x24a52
leaq 0x8f8(%rbx), %rsi
movq %r14, %rdi
callq 0x2e63e
leaq 0x8a0(%rbx), %rsi
movq %r14, %rdi
callq 0x2e63e
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2e63e
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_huge_malloc_stats_update_undo
static void
arena_huge_malloc_stats_update_undo(arena_t *arena, size_t usize)
{
	szind_t index = size2index(usize) - nlclasses - NBINS;

	cassert(config_stats);

	arena->stats.nmalloc_huge--;
	arena->stats.allocated_huge -= usize;
	arena->stats.hstats[index].nmalloc--;
	arena->stats.hstats[index].curhchunks--;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x1000, %rsi           # imm = 0x1000
ja 0x24aff
leaq -0x1(%r14), %rax
shrq $0x3, %rax
leaq 0x172f8(%rip), %rcx     # 0x3bdc0
movzbl (%rcx,%rax), %eax
subl 0x27b02(%rip), %eax     # 0x4c5d4
addl $-0x27, %eax
decq 0xc0(%rbx)
subq %r14, 0xb8(%rbx)
movq 0xd8(%rbx), %rcx
leaq (%rax,%rax,2), %rax
decq (%rcx,%rax,8)
decq 0x10(%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0xfdc2
jmp 0x24acc
// File: /workspace/github_c_makefile_star2_O1/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 0x2e6cb
leaq 0x1c0(%r14), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2e6e1
cmpq $0x0, 0x1b8(%r14)
jle 0x24bfa
movq %r15, %rdi
callq 0x2e682
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 0x24bc9
movq %rdx, 0x1d0(%r14)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2e670
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e6e1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/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), %rcx
testq %rcx, %rcx
je 0x25be4
leaq -0x18(%rcx), %rax
leaq -0x18(%rdi), %rdx
leaq 0x2755d(%rip), %r8      # 0x4d0d0
movq (%r8), %r9
notq %r9
movq %rax, %r8
andq %r9, %r8
movq 0x18(%r8), %r10
andq %rdx, %r9
xorl %r8d, %r8d
cmpq 0x18(%r9), %r10
seta %r8b
sbbl $0x0, %r8d
jne 0x25ba5
xorl %r8d, %r8d
cmpq %rdx, %rax
seta %r8b
sbbl $0x0, %r8d
testl %r8d, %r8d
jle 0x25be4
cmpl $0x0, 0x4(%rcx)
je 0x25c28
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x58(%rsi), %rcx
testq %rcx, %rcx
je 0x25c21
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0x25bdb
movq %rax, (%rdx)
movq %rcx, (%rax)
addq $0x8, %rcx
jmp 0x25c25
leaq -0x18(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, -0x18(%rdi)
movq $0x0, -0x8(%rdi)
movq 0x58(%rsi), %rcx
testq %rcx, %rcx
je 0x25c1c
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0x25c14
movq %rax, (%rdx)
movq %rcx, (%rax)
movq %rax, 0x8(%rcx)
retq
movq %rax, 0x58(%rsi)
retq
leaq 0x58(%rsi), %rcx
movq %rax, (%rcx)
movq %rdi, 0x50(%rsi)
incq 0x98(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_run_alloc_small_helper
static arena_run_t *
arena_run_alloc_small_helper(arena_t *arena, size_t size, szind_t binind)
{
	arena_run_t *run = arena_run_first_best_fit(arena, size);
	if (run != NULL) {
		if (arena_run_split_small(arena, run, size, binind))
			run = NULL;
	}
	return (run);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r12
callq 0xf9f8
testq %rax, %rax
je 0x26107
movq %rax, %r14
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
movl %ebx, %ecx
callq 0x26115
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
cmoveq %r14, %rax
jmp 0x26109
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_run_split_small
static bool
arena_run_split_small(arena_t *arena, arena_run_t *run, size_t size,
    szind_t binind)
{
	arena_chunk_t *chunk;
	arena_chunk_map_misc_t *miscelm;
	size_t flag_dirty, flag_decommitted, run_ind, need_pages, i;

	assert(binind != BININD_INVALID);

	chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(run);
	miscelm = arena_run_to_miscelm(run);
	run_ind = arena_miscelm_to_pageind(miscelm);
	flag_dirty = arena_mapbits_dirty_get(chunk, run_ind);
	flag_decommitted = arena_mapbits_decommitted_get(chunk, run_ind);
	need_pages = (size >> LG_PAGE);
	assert(need_pages > 0);

	if (flag_decommitted != 0 && arena->chunk_hooks.commit(chunk, chunksize,
	    run_ind << LG_PAGE, size, arena->ind))
		return (true);

	arena_run_split_remove(arena, chunk, run_ind, flag_dirty,
	    flag_decommitted, need_pages);

	for (i = 0; i < need_pages; i++) {
		size_t flag_unzeroed = arena_mapbits_unzeroed_get(chunk,
		    run_ind+i);
		arena_mapbits_small_set(chunk, run_ind+i, i, binind,
		    flag_unzeroed);
		if (config_debug && flag_dirty == 0 && flag_unzeroed == 0)
			arena_run_page_validate_zeroed(chunk, run_ind+i);
	}
	JEMALLOC_VALGRIND_MAKE_MEM_UNDEFINED((void *)((uintptr_t)chunk +
	    (run_ind << LG_PAGE)), (need_pages << LG_PAGE));
	return (false);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movq %rdx, %r12
movq %rdi, %r10
leaq 0x26fa0(%rip), %rax     # 0x4d0d0
movq (%rax), %r14
notq %r14
leaq -0x18(%rsi), %rax
andq %r14, %rax
addq 0x26e84(%rip), %rax     # 0x4cfc8
negq %rax
addq %rsi, %rax
addq $-0x18, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
andq %rsi, %r14
shrq $0x6, %rdx
movq 0x26e57(%rip), %r9      # 0x4cfc0
addq %rdx, %r9
movq 0x78(%r14,%rdx,8), %rbx
movq %rbx, %r13
andq $0x4, %r13
je 0x261bb
leaq 0x26f47(%rip), %rax     # 0x4d0c8
movq (%rax), %rsi
movq %r9, %rdx
shlq $0xc, %rdx
movl (%r10), %r8d
movq %r14, %rdi
movq %r12, %rcx
movq %r12, (%rsp)
movq %r9, %r12
movq %r10, %rbp
callq *0x958(%r10)
movq %rbp, %r10
movq %r12, %r9
movq (%rsp), %r12
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x26244
andl $0x10, %ebx
movq %r12, %rbp
shrq $0xc, %rbp
movq %r10, %rdi
movq %r14, %rsi
movq %r9, %rdx
movq %rbx, %rcx
movq %r13, %r8
movq %r9, %rbx
movq %rbp, %r9
callq 0x2529c
movq %rbx, %rdi
movq %r12, %r8
cmpq $0x1000, %r12           # imm = 0x1000
jb 0x26236
shll $0x5, %r15d
incl %r15d
leaq (%r14,%rdi,8), %rax
addq $0x78, %rax
xorl %ecx, %ecx
movq 0x26dba(%rip), %rdx     # 0x4cfc0
shlq $0x3, %rdx
movq %rax, %rsi
subq %rdx, %rsi
negq %rdx
movq (%rsi), %rsi
andl $0x8, %esi
movq %rcx, %r9
orq %r15, %r9
orq %rsi, %r9
movq %r9, (%rax,%rdx)
addq $0x8, %rax
addq $0x2000, %rcx           # imm = 0x2000
decq %rbp
jne 0x261ff
leaq 0x2635f(%rip), %rax     # 0x4c59c
cmpb $0x1, (%rax)
je 0x26253
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
shlq $0xc, %rdi
addq %r14, %rdi
movq %r8, %rsi
andq $-0x1000, %rsi          # imm = 0xF000
callq 0x37116
jmp 0x26242