LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_chunk_dalloc
static void
arena_chunk_dalloc(tsdn_t *tsdn, arena_t *arena, arena_chunk_t *chunk)
{
	arena_chunk_t *spare;

	assert(arena_mapbits_allocated_get(chunk, map_bias) == 0);
	assert(arena_mapbits_allocated_get(chunk, chunk_npages-1) == 0);
	assert(arena_mapbits_unallocated_size_get(chunk, map_bias) ==
	    arena_maxrun);
	assert(arena_mapbits_unallocated_size_get(chunk, chunk_npages-1) ==
	    arena_maxrun);
	assert(arena_mapbits_dirty_get(chunk, map_bias) ==
	    arena_mapbits_dirty_get(chunk, chunk_npages-1));
	assert(arena_mapbits_decommitted_get(chunk, map_bias) ==
	    arena_mapbits_decommitted_get(chunk, chunk_npages-1));

	/* Remove run from runs_avail, so that the arena does not use it. */
	arena_avail_remove(arena, chunk, map_bias, chunk_npages-map_bias);

	ql_remove(&arena->achunks, &chunk->node, ql_link);
	spare = arena->spare;
	arena->spare = chunk;
	if (spare != NULL)
		arena_spare_discard(tsdn, arena, spare);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x4b266
jmp 0x4b268
jmp 0x4b26a
jmp 0x4b26c
jmp 0x4b26e
jmp 0x4b270
jmp 0x4b272
jmp 0x4b274
jmp 0x4b276
jmp 0x4b278
jmp 0x4b27a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x58d17(%rip), %rdx     # 0xa3fa0
leaq 0x58e28(%rip), %rax     # 0xa40b8
movq (%rax), %rcx
subq 0x58d06(%rip), %rcx     # 0xa3fa0
callq 0x47fa0
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jne 0x4b2cd
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movq 0x50(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x100(%rax)
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq %rcx, %rax
je 0x4b325
jmp 0x4b2e3
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x58(%rax)
jmp 0x4b334
movq -0x10(%rbp), %rax
movq $0x0, 0x100(%rax)
jmp 0x4b336
movq -0x10(%rbp), %rax
movq 0x110(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x110(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x4b36c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4b380
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_spare_discard
static void
arena_spare_discard(tsdn_t *tsdn, arena_t *arena, arena_chunk_t *spare)
{

	assert(arena->spare != spare);

	if (arena_mapbits_dirty_get(spare, map_bias) != 0) {
		arena_run_dirty_remove(arena, spare, map_bias,
		    chunk_npages-map_bias);
	}

	arena_chunk_discard(tsdn, arena, spare);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rsi, -0x70(%rbp)
movq %rdx, -0x78(%rbp)
jmp 0x4b399
movq -0x78(%rbp), %rcx
movq 0x58bfc(%rip), %rax     # 0xa3fa0
movq %rcx, -0x50(%rbp)
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x78, %rax
movq -0x10(%rbp), %rcx
subq 0x58ba1(%rip), %rcx     # 0xa3fa0
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x4b448
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq 0x58b6e(%rip), %rdx     # 0xa3fa0
leaq 0x58c7f(%rip), %rax     # 0xa40b8
movq (%rax), %rcx
subq 0x58b5d(%rip), %rcx     # 0xa3fa0
callq 0x48070
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdx
callq 0x3c470
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/include/jemalloc/internal/bitmap.h
// Function: je_bitmap_sfu
JEMALLOC_INLINE size_t
bitmap_sfu(bitmap_t *bitmap, const bitmap_info_t *binfo)
{
	size_t bit;
	bitmap_t g;
	unsigned i;

	assert(!bitmap_full(bitmap, binfo));

#ifdef USE_TREE
	i = binfo->nlevels - 1;
	g = bitmap[binfo->levels[i].group_offset];
	bit = ffs_lu(g) - 1;
	while (i > 0) {
		i--;
		g = bitmap[binfo->levels[i].group_offset + bit];
		bit = (bit << LG_BITMAP_GROUP_NBITS) + (ffs_lu(g) - 1);
	}
#else
	i = 0;
	g = bitmap[0];
	while ((bit = ffs_lu(g)) == 0) {
		i++;
		g = bitmap[i];
	}
	bit = (i << LG_BITMAP_GROUP_NBITS) + (bit - 1);
#endif
	bitmap_set(bitmap, binfo, bit);
	return (bit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0x4b482
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdx
tzcntq %rdx, %rax
addq $0x1, %rax
xorl %ecx, %ecx
cmpq $0x0, %rdx
cmoveq %rcx, %rax
movl %eax, %eax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x4b4d9
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x4b494
movl -0x2c(%rbp), %eax
shll $0x6, %eax
movl %eax, %eax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4b510
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_bin_nonfull_run_get
static arena_run_t *
arena_bin_nonfull_run_get(tsdn_t *tsdn, arena_t *arena, arena_bin_t *bin)
{
	arena_run_t *run;
	szind_t binind;
	arena_bin_info_t *bin_info;

	/* Look for a usable run. */
	run = arena_bin_nonfull_run_tryget(bin);
	if (run != NULL)
		return (run);
	/* No existing runs have any space available. */

	binind = arena_bin_index(arena, bin);
	bin_info = &arena_bin_info[binind];

	/* Allocate a new run. */
	malloc_mutex_unlock(tsdn, &bin->lock);
	/******************************/
	malloc_mutex_lock(tsdn, &arena->lock);
	run = arena_run_alloc_small(tsdn, arena, bin_info->run_size, binind);
	if (run != NULL) {
		/* Initialize run internals. */
		run->binind = binind;
		run->nfree = bin_info->nregs;
		bitmap_init(run->bitmap, &bin_info->bitmap_info);
	}
	malloc_mutex_unlock(tsdn, &arena->lock);
	/********************************/
	malloc_mutex_lock(tsdn, &bin->lock);
	if (run != NULL) {
		if (config_stats) {
			bin->stats.nruns++;
			bin->stats.curruns++;
		}
		return (run);
	}

	/*
	 * arena_run_alloc_small() failed, but another thread may have made
	 * sufficient memory available while this one dropped bin->lock above,
	 * so search one more time.
	 */
	run = arena_bin_nonfull_run_tryget(bin);
	if (run != NULL)
		return (run);

	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4b880
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4b5f5
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4b70a
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4b580
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %ecx
leaq 0x57faf(%rip), %rax     # 0xa35c0
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3a6b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a660
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdx
movl -0x2c(%rbp), %ecx
callq 0x4b8e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4b689
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x38(%rbp), %rsi
addq $0x28, %rsi
callq 0x50d10
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a6b0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3a660
cmpq $0x0, -0x28(%rbp)
je 0x4b6e4
movq -0x20(%rbp), %rax
movq 0x90(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x90(%rax)
movq -0x20(%rbp), %rax
movq 0xa0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xa0(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4b70a
movq -0x20(%rbp), %rdi
callq 0x4b880
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4b702
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4b70a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_dalloc_bin_run
static void
arena_dalloc_bin_run(tsdn_t *tsdn, arena_t *arena, arena_chunk_t *chunk,
    arena_run_t *run, arena_bin_t *bin)
{

	assert(run != bin->runcur);

	malloc_mutex_unlock(tsdn, &bin->lock);
	/******************************/
	malloc_mutex_lock(tsdn, &arena->lock);
	arena_run_dalloc(tsdn, arena, run, true, false, false);
	malloc_mutex_unlock(tsdn, &arena->lock);
	/****************************/
	malloc_mutex_lock(tsdn, &bin->lock);
	if (config_stats)
		bin->stats.curruns--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
jmp 0x4b73e
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3a6b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a660
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %ecx
xorl %r9d, %r9d
movl %r9d, %r8d
callq 0x49a50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a6b0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3a660
movq -0x28(%rbp), %rax
movq 0xa0(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xa0(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_bin_lower_run
static void
arena_bin_lower_run(arena_t *arena, arena_run_t *run, arena_bin_t *bin)
{

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x4b864
movq -0x38(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
subq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
subq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x498a0
cmpl $0x0, %eax
jle 0x4b864
movq -0x38(%rbp), %rax
movq 0x50(%rax), %rax
cmpl $0x0, 0x4(%rax)
jbe 0x4b840
movq -0x38(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0x4d530
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x38(%rbp), %rax
movq 0x98(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x98(%rax)
jmp 0x4b871
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4d530
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_bin_nonfull_run_tryget
static arena_run_t *
arena_bin_nonfull_run_tryget(arena_bin_t *bin)
{
	arena_chunk_map_misc_t *miscelm;

	miscelm = arena_run_heap_remove_first(&bin->runs);
	if (miscelm == NULL)
		return (NULL);
	if (config_stats)
		bin->stats.reruns++;

	return (&miscelm->run);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x4b9d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4b8ae
movq $0x0, -0x8(%rbp)
jmp 0x4b8d0
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x98(%rax)
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_run_alloc_small
static arena_run_t *
arena_run_alloc_small(tsdn_t *tsdn, arena_t *arena, size_t size, szind_t binind)
{
	arena_chunk_t *chunk;
	arena_run_t *run;

	assert(size <= arena_maxrun);
	assert(size == PAGE_CEILING(size));
	assert(binind != BININD_INVALID);

	/* Search the arena's chunks for the lowest best fit. */
	run = arena_run_alloc_small_helper(arena, size, binind);
	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_small(arena, run, size, binind))
			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_small_helper(arena, size, binind));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movl %ecx, -0x34(%rbp)
jmp 0x4b8f9
jmp 0x4b8fb
jmp 0x4b8fd
jmp 0x4b8ff
jmp 0x4b901
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0x4c7e0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x4b929
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x4b9bf
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x45ee0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x4b9ab
movq -0x40(%rbp), %rcx
movq 0x58654(%rip), %rax     # 0xa3fa0
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq 0x58649(%rip), %rax     # 0xa3fa8
imulq $0x60, -0x10(%rbp), %rcx
addq %rcx, %rax
xorl %ecx, %ecx
subq 0x58630(%rip), %rcx     # 0xa3fa0
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
addq $0x18, %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x34(%rbp), %ecx
callq 0x4c840
testb $0x1, %al
jne 0x4b999
jmp 0x4b9a1
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x4b9bf
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0x4c7e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_run_first_best_fit
static arena_run_t *
arena_run_first_best_fit(arena_t *arena, size_t size)
{
	pszind_t pind, i;

	pind = psz2ind(run_quantize_ceil(size));

	for (i = pind; pind2sz(i) <= chunksize; i++) {
		arena_chunk_map_misc_t *miscelm = arena_run_heap_first(
		    &arena->runs_avail[i]);
		if (miscelm != NULL)
			return (&miscelm->run);
	}

	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4ce00
movq %rax, %rdi
callq 0x46cc0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
callq 0x46fe0
leaq 0x572ff(%rip), %rcx     # 0xa40a8
cmpq (%rcx), %rax
ja 0x4cdee
movq -0x10(%rbp), %rdi
addq $0x2318, %rdi           # imm = 0x2318
movl -0x20(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4ce60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4cde1
movq -0x28(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x8(%rbp)
jmp 0x4cdf6
jmp 0x4cde3
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4cd9a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_run_quantize_ceil
static size_t
run_quantize_ceil(size_t size)
{
	size_t ret;

	assert(size > 0);
	assert(size <= HUGE_MAXCLASS);
	assert((size & PAGE_MASK) == 0);

	ret = run_quantize_floor(size);
	if (ret < size) {
		/*
		 * Skip a quantization that may have an adequately large run,
		 * because under-sized runs may be mixed in.  This only happens
		 * when an unusual size is requested, i.e. for aligned
		 * allocation, and is just one of several places where linear
		 * search would potentially find sufficiently aligned available
		 * memory somewhere lower.
		 */
		ret = pind2sz(psz2ind(ret - large_pad + 1)) + large_pad;
	}
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x4ce0e
jmp 0x4ce10
jmp 0x4ce12
jmp 0x4ce14
jmp 0x4ce16
movq -0x8(%rbp), %rdi
callq 0x46da0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x4ce52
movq -0x10(%rbp), %rdi
subq $0x1000, %rdi           # imm = 0x1000
addq $0x1, %rdi
callq 0x46cc0
movl %eax, %edi
callq 0x46fe0
addq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: je_decay_ticker_get
JEMALLOC_INLINE ticker_t *
decay_ticker_get(tsd_t *tsd, unsigned ind)
{
	arena_tdata_t *tdata;

	tdata = arena_tdata_get(tsd, ind, true);
	if (unlikely(tdata == NULL))
		return (NULL);
	return (&tdata->decay_ticker);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x4d640
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4d5c7
movq $0x0, -0x8(%rbp)
jmp 0x4d5cf
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: je_arena_tdata_get
JEMALLOC_INLINE arena_tdata_t *
arena_tdata_get(tsd_t *tsd, unsigned ind, bool refresh_if_missing)
{
	arena_tdata_t *tdata;
	arena_tdata_t *arenas_tdata = tsd_arenas_tdata_get(tsd);

	if (unlikely(arenas_tdata == NULL)) {
		/* arenas_tdata hasn't been initialized yet. */
		return (arena_tdata_get_hard(tsd, ind));
	}
	if (unlikely(ind >= tsd_narenas_tdata_get(tsd))) {
		/*
		 * ind is invalid, cache is old (too small), or tdata to be
		 * initialized.
		 */
		return (refresh_if_missing ? arena_tdata_get_hard(tsd, ind) :
		    NULL);
	}

	tdata = &arenas_tdata[ind];
	if (likely(tdata != NULL) || !refresh_if_missing)
		return (tdata);
	return (arena_tdata_get_hard(tsd, ind));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
andb $0x1, %al
movb %al, -0x35(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4d6a0
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x1a120
movq %rax, -0x28(%rbp)
jmp 0x4d743
movl -0x34(%rbp), %eax
movq -0x30(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
setae %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4d6f8
testb $0x1, -0x35(%rbp)
je 0x4d6e6
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x1a120
movq %rax, -0x50(%rbp)
jmp 0x4d6ee
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x4d6ee
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x4d743
movq -0x48(%rbp), %rax
movl -0x34(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x4d729
testb $0x1, -0x35(%rbp)
jne 0x4d733
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x4d743
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x1a120
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_run_alloc_large_helper
static arena_run_t *
arena_run_alloc_large_helper(arena_t *arena, size_t size, bool zero)
{
	arena_run_t *run = arena_run_first_best_fit(arena, size);
	if (run != NULL) {
		if (arena_run_split_large(arena, run, size, zero))
			run = NULL;
	}
	return (run);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4cd70
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4d978
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x46000
testb $0x1, %al
jne 0x4d96e
jmp 0x4d976
movq $0x0, -0x20(%rbp)
jmp 0x4d978
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_run_reg_dalloc
JEMALLOC_INLINE_C void
arena_run_reg_dalloc(arena_run_t *run, void *ptr)
{
	arena_chunk_t *chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(run);
	size_t pageind = ((uintptr_t)ptr - (uintptr_t)chunk) >> LG_PAGE;
	size_t mapbits = arena_mapbits_get(chunk, pageind);
	szind_t binind = arena_ptr_small_binind_get(ptr, mapbits);
	arena_bin_info_t *bin_info = &arena_bin_info[binind];
	size_t regind = arena_run_regind(run, bin_info, ptr);

	assert(run->nfree < bin_info->nregs);
	/* Freeing an interior pointer can cause assertion failure. */
	assert(((uintptr_t)ptr -
	    ((uintptr_t)arena_miscelm_to_rpages(arena_run_to_miscelm(run)) +
	    (uintptr_t)bin_info->reg0_offset)) %
	    (uintptr_t)bin_info->reg_interval == 0);
	assert((uintptr_t)ptr >=
	    (uintptr_t)arena_miscelm_to_rpages(arena_run_to_miscelm(run)) +
	    (uintptr_t)bin_info->reg0_offset);
	/* Freeing an unallocated pointer can cause assertion failure. */
	assert(bitmap_get(run->bitmap, &bin_info->bitmap_info, regind));

	bitmap_unset(run->bitmap, &bin_info->bitmap_info, regind);
	run->nfree++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x68(%rbp)
movq %rsi, -0x70(%rbp)
movq -0x68(%rbp), %rax
leaq 0x554e2(%rip), %rcx     # 0xa40b0
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rax
movq -0x78(%rbp), %rcx
subq %rcx, %rax
shrq $0xc, %rax
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rcx
movq -0x80(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x78, %rax
movq -0x28(%rbp), %rcx
subq 0x5535e(%rip), %rcx     # 0xa3fa0
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x70(%rbp), %rcx
movq -0x88(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $0x1fe0, %rax           # imm = 0x1FE0
shrq $0x5, %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x8c(%rbp)
movl -0x8c(%rbp), %eax
movl %eax, %ecx
leaq 0x54929(%rip), %rax     # 0xa35c0
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x98(%rbp)
movq -0x68(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x4edb0
movq %rax, -0xa0(%rbp)
jmp 0x4ecc2
jmp 0x4ecc4
jmp 0x4ecc6
jmp 0x4ecc8
jmp 0x4ecca
jmp 0x4eccc
jmp 0x4ecce
movq -0x68(%rbp), %rdi
addq $0x8, %rdi
movq -0x98(%rbp), %rsi
addq $0x28, %rsi
movq -0xa0(%rbp), %rdx
callq 0x4ef70
movq -0x68(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_dissociate_bin_run
static void
arena_dissociate_bin_run(arena_chunk_t *chunk, arena_run_t *run,
    arena_bin_t *bin)
{

	/* Dissociate run from bin. */
	if (run == bin->runcur)
		bin->runcur = NULL;
	else {
		szind_t binind = arena_bin_index(extent_node_arena_get(
		    &chunk->node), bin);
		arena_bin_info_t *bin_info = &arena_bin_info[binind];

		/*
		 * The following block's conditional is necessary because if the
		 * run only contains one region, then it never gets inserted
		 * into the non-full runs tree.
		 */
		if (bin_info->nregs != 1) {
			arena_chunk_map_misc_t *miscelm =
			    arena_run_to_miscelm(run);

			arena_run_heap_remove(&bin->runs, miscelm);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jne 0x4ed40
movq -0x28(%rbp), %rax
movq $0x0, 0x50(%rax)
jmp 0x4eda8
movq -0x18(%rbp), %rdi
callq 0x40d80
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x4b580
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %ecx
leaq 0x5485c(%rip), %rax     # 0xa35c0
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x1, 0x20(%rax)
je 0x4eda6
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
subq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
addq $0x58, %rdi
movq -0x40(%rbp), %rsi
callq 0x48220
jmp 0x4eda8
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/include/jemalloc/internal/bitmap.h
// Function: je_bitmap_unset
JEMALLOC_INLINE void
bitmap_unset(bitmap_t *bitmap, const bitmap_info_t *binfo, size_t bit)
{
	size_t goff;
	bitmap_t *gp;
	bitmap_t g;
	UNUSED bool propagate;

	assert(bit < binfo->nbits);
	assert(bitmap_get(bitmap, binfo, bit));
	goff = bit >> LG_BITMAP_GROUP_NBITS;
	gp = &bitmap[goff];
	g = *gp;
	propagate = (g == 0);
	assert((g & (ZU(1) << (bit & BITMAP_GROUP_NBITS_MASK))) == 0);
	g ^= ZU(1) << (bit & BITMAP_GROUP_NBITS_MASK);
	*gp = g;
	assert(!bitmap_get(bitmap, binfo, bit));
#ifdef USE_TREE
	/* Propagate group state transitions up the tree. */
	if (propagate) {
		unsigned i;
		for (i = 1; i < binfo->nlevels; i++) {
			bit = goff;
			goff = bit >> LG_BITMAP_GROUP_NBITS;
			gp = &bitmap[binfo->levels[i].group_offset + goff];
			g = *gp;
			propagate = (g == 0);
			assert((g & (ZU(1) << (bit & BITMAP_GROUP_NBITS_MASK)))
			    == 0);
			g ^= ZU(1) << (bit & BITMAP_GROUP_NBITS_MASK);
			*gp = g;
			if (!propagate)
				break;
		}
	}
#endif /* USE_TREE */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x4ef82
jmp 0x4ef84
jmp 0x4ef86
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x4efbf
movq -0x18(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %eax
shlq %cl, %rax
xorq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4efe4
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/base.c
// Function: base_chunk_alloc
static extent_node_t *
base_chunk_alloc(tsdn_t *tsdn, size_t minsize)
{
	extent_node_t *node;
	size_t csize, nsize;
	void *addr;

	malloc_mutex_assert_owner(tsdn, &base_mtx);
	assert(minsize != 0);
	node = base_node_try_alloc(tsdn);
	/* Allocate enough space to also carve a node out if necessary. */
	nsize = (node == NULL) ? CACHELINE_CEILING(sizeof(extent_node_t)) : 0;
	csize = CHUNK_CEILING(minsize + nsize);
	addr = chunk_alloc_base(csize);
	if (addr == NULL) {
		if (node != NULL)
			base_node_dalloc(tsdn, node);
		return (NULL);
	}
	base_mapped += csize;
	if (node == NULL) {
		node = (extent_node_t *)addr;
		addr = (void *)((uintptr_t)addr + nsize);
		csize -= nsize;
		if (config_stats) {
			base_allocated += nsize;
			base_resident += PAGE_CEILING(nsize);
		}
	}
	base_extent_node_init(node, addr, csize);
	return (node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5391d(%rip), %rsi     # 0xa3fb8
callq 0x50b20
jmp 0x506a2
movq -0x10(%rbp), %rdi
callq 0x50b50
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl $0x80, %ecx
cmpq $0x0, %rdx
cmoveq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq -0x30(%rbp), %rax
leaq 0x539db(%rip), %rcx     # 0xa40b0
addq (%rcx), %rax
leaq 0x539d1(%rip), %rcx     # 0xa40b0
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x51850
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x50722
cmpq $0x0, -0x20(%rbp)
je 0x50715
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x50840
movq $0x0, -0x8(%rbp)
jmp 0x507a7
movq -0x28(%rbp), %rax
addq 0x538f3(%rip), %rax     # 0xa4020
movq %rax, 0x538ec(%rip)     # 0xa4020
cmpq $0x0, -0x20(%rbp)
jne 0x5078e
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq 0x538a7(%rip), %rax     # 0xa4010
movq %rax, 0x538a0(%rip)     # 0xa4010
movq -0x30(%rbp), %rax
addq $0xfff, %rax            # imm = 0xFFF
andq $-0x1000, %rax          # imm = 0xF000
addq 0x53891(%rip), %rax     # 0xa4018
movq %rax, 0x5388a(%rip)     # 0xa4018
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x50be0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/base.c
// Function: base_node_dalloc
static void
base_node_dalloc(tsdn_t *tsdn, extent_node_t *node)
{

	malloc_mutex_assert_owner(tsdn, &base_mtx);

	JEMALLOC_VALGRIND_MAKE_MEM_UNDEFINED(node, sizeof(extent_node_t));
	*(extent_node_t **)node = base_nodes;
	base_nodes = node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x5375d(%rip), %rsi     # 0xa3fb8
callq 0x50b20
leaq 0x52d15(%rip), %rax     # 0xa357c
movb (%rax), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x50888
movq -0x10(%rbp), %rdi
movl $0x70, %esi
callq 0x86000
jmp 0x5088a
movq 0x5379f(%rip), %rcx     # 0xa4030
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x5378d(%rip)     # 0xa4030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x536b5(%rip), %rsi     # 0xa3fb8
callq 0x50630
jmp 0x5090a
jmp 0x5090c
jmp 0x5090e
movq 0x536fb(%rip), %rcx     # 0xa4010
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0x536f5(%rip), %rcx     # 0xa4018
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq 0x536ef(%rip), %rcx     # 0xa4020
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
leaq 0x53675(%rip), %rsi     # 0xa3fb8
callq 0x508b0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x53659(%rip), %rdi     # 0xa3fb8
leaq 0x40d52(%rip), %rsi     # 0x916b8
movl $0xb, %edx
callq 0x66ad0
testb $0x1, %al
jne 0x50976
jmp 0x5097c
movb $0x1, -0x1(%rbp)
jmp 0x509a2
movq $0x0, 0x536a1(%rip) # 0xa4028
leaq 0x5367a(%rip), %rdi     # 0xa4008
callq 0x5d300
movq $0x0, 0x53692(%rip) # 0xa4030
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/base.c
// Function: base_node_try_alloc
static extent_node_t *
base_node_try_alloc(tsdn_t *tsdn)
{
	extent_node_t *node;

	malloc_mutex_assert_owner(tsdn, &base_mtx);

	if (base_nodes == NULL)
		return (NULL);
	node = base_nodes;
	base_nodes = *(extent_node_t **)node;
	JEMALLOC_VALGRIND_MAKE_MEM_UNDEFINED(node, sizeof(extent_node_t));
	return (node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x53451(%rip), %rsi     # 0xa3fb8
callq 0x50b20
cmpq $0x0, 0x534bc(%rip)     # 0xa4030
jne 0x50b80
movq $0x0, -0x8(%rbp)
jmp 0x50bcb
movq 0x534a9(%rip), %rax     # 0xa4030
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x53497(%rip)     # 0xa4030
leaq 0x529dc(%rip), %rax     # 0xa357c
movb (%rax), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x50bc1
movq -0x18(%rbp), %rdi
movl $0x70, %esi
callq 0x86000
jmp 0x50bc3
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/bitmap.c
// Function: je_bitmap_info_init
void
bitmap_info_init(bitmap_info_t *binfo, size_t nbits)
{

	assert(nbits > 0);
	assert(nbits <= (ZU(1) << LG_BITMAP_MAXBITS));

	binfo->ngroups = BITMAP_BITS2GROUPS(nbits);
	binfo->nbits = nbits;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x50cde
jmp 0x50ce0
jmp 0x50ce2
movq -0x10(%rbp), %rcx
addq $0x3f, %rcx
shrq $0x6, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/bitmap.c
// Function: je_bitmap_init
void
bitmap_init(bitmap_t *bitmap, const bitmap_info_t *binfo)
{
	size_t extra;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x50da0
movq -0x20(%rbp), %rdi
movq %rax, %rdx
movl $0xff, %esi
callq 0xb210
movq -0x10(%rbp), %rax
movq (%rax), %rcx
andq $0x3f, %rcx
movl $0x40, %eax
subq %rcx, %rax
andq $0x3f, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x50d8b
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x8(%rdx), %rdx
subq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movq (%rax,%rdx,8), %rdx
shrq %cl, %rdx
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x48(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdx, -0x58(%rbp)
movq %rcx, -0x60(%rbp)
movq %r8, -0x68(%rbp)
movl %r9d, -0x6c(%rbp)
leaq 0x53706(%rip), %rax     # 0xa4510
testb $0x1, (%rax)
jne 0x50e1c
movq $0x0, -0x40(%rbp)
jmp 0x50f9b
movb $0x0, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq 0x521c1(%rip), %rcx     # 0xa2ff0
movq %fs:0x0, %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x50e61
xorl %eax, %eax
testb $0x1, %al
jne 0x50e4d
jmp 0x50e61
cmpq $0x0, -0x30(%rbp)
jne 0x50e61
movq $0x0, -0x20(%rbp)
jmp 0x50f8b
movq -0x30(%rbp), %rax
cmpl $0x1, (%rax)
setne %al
testb $0x1, %al
jne 0x50e74
jmp 0x50f83
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x50efa
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x5215a(%rip), %rax     # 0xa2ff0
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl $0x68, %edx
callq 0xb310
leaq 0x5367d(%rip), %rax     # 0xa4534
movl (%rax), %edi
movq 0x52130(%rip), %rax     # 0xa2ff0
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0xb590
cmpl $0x0, %eax
je 0x50ef5
leaq 0x3ff9d(%rip), %rdi     # 0x90e7a
callq 0x828c0
leaq 0x52617(%rip), %rax     # 0xa3500
testb $0x1, (%rax)
je 0x50ef3
callq 0xb050
jmp 0x50ef5
jmp 0x50f81
movq -0x30(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x50f7d
movq -0x30(%rbp), %rax
movl $0x3, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq 0x520d4(%rip), %rax     # 0xa2ff0
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl $0x68, %edx
callq 0xb310
leaq 0x535f7(%rip), %rax     # 0xa4534
movl (%rax), %edi
movq 0x520aa(%rip), %rax     # 0xa2ff0
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0xb590
cmpl $0x0, %eax
je 0x50f7b
leaq 0x3ff17(%rip), %rdi     # 0x90e7a
callq 0x828c0
leaq 0x52591(%rip), %rax     # 0xa3500
testb $0x1, (%rax)
je 0x50f79
callq 0xb050
jmp 0x50f7b
jmp 0x50f7f
jmp 0x50f7f
jmp 0x50f81
jmp 0x50f83
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
movl -0x6c(%rbp), %esi
callq 0x53210
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x58(%rbp), %r8
movq -0x60(%rbp), %r9
movq -0x68(%rbp), %rax
movq %rax, (%rsp)
callq 0x52300
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/chunk.c
// Function: chunk_purge_default
static bool
chunk_purge_default(void *chunk, size_t size, size_t offset, size_t length,
    unsigned arena_ind)
{

	assert(chunk != NULL);
	assert(CHUNK_ADDR2BASE(chunk) == chunk);
	assert((offset & PAGE_MASK) == 0);
	assert(length != 0);
	assert((length & PAGE_MASK) == 0);

	return (pages_purge((void *)((uintptr_t)chunk + (uintptr_t)offset),
	    length));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
jmp 0x510be
jmp 0x510c0
jmp 0x510c2
jmp 0x510c4
jmp 0x510c6
jmp 0x510c8
jmp 0x510ca
jmp 0x510cc
jmp 0x510ce
movq -0x8(%rbp), %rdi
addq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x67200
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/chunk.c
// Function: je_chunk_hooks_get
chunk_hooks_t
chunk_hooks_get(tsdn_t *tsdn, arena_t *arena)
{
	chunk_hooks_t chunk_hooks;

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

	return (chunk_hooks);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8a0, %rsi            # imm = 0x8A0
callq 0x511d0
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x51220
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl $0x38, %edx
callq 0xb310
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8a0, %rsi            # imm = 0x8A0
callq 0x51260
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/chunk.c
// Function: je_chunk_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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movb 0x28(%rbp), %al
movq 0x20(%rbp), %r10
movq 0x18(%rbp), %r10
movq 0x10(%rbp), %r10
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movq %r8, -0x50(%rbp)
movq %r9, -0x58(%rbp)
andb $0x1, %al
movb %al, -0x59(%rbp)
jmp 0x51920
jmp 0x51922
jmp 0x51924
jmp 0x51926
jmp 0x51928
jmp 0x5192a
jmp 0x5192c
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
addq $0x880, %rcx            # imm = 0x880
movq -0x38(%rbp), %r8
addq $0x888, %r8             # imm = 0x888
movq -0x48(%rbp), %r12
movq -0x50(%rbp), %r15
movq -0x58(%rbp), %r14
movq 0x10(%rbp), %rbx
movq 0x18(%rbp), %r11
movq 0x20(%rbp), %r10
movb -0x59(%rbp), %al
movl $0x1, %r9d
andb $0x1, %al
movq %r12, (%rsp)
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movq %r11, 0x20(%rsp)
movq %r10, 0x28(%rsp)
movzbl %al, %eax
movl %eax, 0x30(%rsp)
callq 0x51a00
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
jne 0x519af
movq $0x0, -0x28(%rbp)
jmp 0x519e2
jmp 0x519b1
leaq 0x51bc4(%rip), %rax     # 0xa357c
movb (%rax), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x519d8
movq -0x68(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x86000
jmp 0x519da
movq -0x68(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/chunk.c
// Function: je_chunk_alloc_wrapper
void *
chunk_alloc_wrapper(tsdn_t *tsdn, arena_t *arena, chunk_hooks_t *chunk_hooks,
    void *new_addr, size_t size, size_t alignment, size_t *sn, bool *zero,
    bool *commit)
{
	void *ret;

	chunk_hooks_assure_initialized(tsdn, arena, chunk_hooks);

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

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

		*sn = arena_extent_sn_next(arena);

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

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x521f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %r11
movq 0x18(%rbp), %r10
movq 0x20(%rbp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x52220
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x521dc
movq -0x20(%rbp), %rax
leaq -0x133e(%rip), %rcx     # 0x50de0
cmpq %rcx, (%rax)
jne 0x5214e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq 0x18(%rbp), %r9
movq 0x20(%rbp), %rax
movq %rax, (%rsp)
callq 0x52300
movq %rax, -0x40(%rbp)
jmp 0x52176
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq 0x18(%rbp), %rcx
movq 0x20(%rbp), %r8
movq -0x18(%rbp), %r9
movl (%r9), %r9d
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x52187
movq $0x0, -0x8(%rbp)
jmp 0x521e4
movq -0x18(%rbp), %rdi
callq 0x43560
movq %rax, %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
leaq -0x13c5(%rip), %rcx     # 0x50de0
cmpq %rcx, (%rax)
je 0x521da
jmp 0x521ac
leaq 0x513c9(%rip), %rax     # 0xa357c
movb (%rax), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x521d6
movq -0x40(%rbp), %rdi
movq 0x51ed7(%rip), %rsi     # 0xa40a8
callq 0x86000
jmp 0x521d8
jmp 0x521da
jmp 0x521dc
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/chunk.c
// Function: chunk_alloc_retained
static void *
chunk_alloc_retained(tsdn_t *tsdn, arena_t *arena, chunk_hooks_t *chunk_hooks,
    void *new_addr, size_t size, size_t alignment, size_t *sn, bool *zero,
    bool *commit)
{
	void *ret;

	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_retained, &arena->chunks_ad_retained, false,
	    new_addr, size, alignment, sn, zero, commit, true);

	if (config_stats && ret != NULL)
		arena->stats.retained -= size;

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq %r9, -0x48(%rbp)
jmp 0x52253
jmp 0x52255
jmp 0x52257
jmp 0x52259
jmp 0x5225b
jmp 0x5225d
jmp 0x5225f
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
addq $0x890, %rcx            # imm = 0x890
movq -0x28(%rbp), %r8
addq $0x898, %r8             # imm = 0x898
movq -0x38(%rbp), %r15
movq -0x40(%rbp), %r14
movq -0x48(%rbp), %rbx
movq 0x10(%rbp), %r11
movq 0x18(%rbp), %r10
movq 0x20(%rbp), %rax
xorl %r9d, %r9d
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movl $0x1, 0x30(%rsp)
callq 0x51a00
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x522e4
movq -0x40(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x68(%rax)
movq -0x50(%rbp), %rax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)