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: je_arena_malloc_hard
void *
arena_malloc_hard(tsdn_t *tsdn, arena_t *arena, size_t size, szind_t ind,
    bool zero)
{

	assert(!tsdn_null(tsdn) || arena != NULL);

	if (likely(!tsdn_null(tsdn)))
		arena = arena_choose(tsdn_tsd(tsdn), arena);
	if (unlikely(arena == NULL))
		return (NULL);

	if (likely(size <= SMALL_MAXCLASS))
		return (arena_malloc_small(tsdn, arena, ind, zero));
	if (likely(size <= large_maxclass))
		return (arena_malloc_large(tsdn, arena, ind, zero));
	return (huge_malloc(tsdn, arena, index2size(ind), zero));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %r8b, %al
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdx, -0x48(%rbp)
movl %ecx, -0x4c(%rbp)
andb $0x1, %al
movb %al, -0x4d(%rbp)
jmp 0x3d411
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3d44d
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3d540
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3d473
movq $0x0, -0x30(%rbp)
jmp 0x3d527
cmpq $0x3800, -0x48(%rbp)    # imm = 0x3800
setbe %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3d4ad
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x4c(%rbp), %edx
movb -0x4d(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x3d570
movq %rax, -0x30(%rbp)
jmp 0x3d527
movq -0x48(%rbp), %rax
cmpq 0x66ac8(%rip), %rax     # 0xa3f80
setbe %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3d4ea
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x4c(%rbp), %edx
movb -0x4d(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x3ce10
movq %rax, -0x30(%rbp)
jmp 0x3d527
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x4c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x52df6(%rip), %rax     # 0x90300
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movb -0x4d(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x60e60
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x50, %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: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x78(%rbp)
movq %rsi, -0x80(%rbp)
movq %rdx, -0x88(%rbp)
movq %rcx, -0x90(%rbp)
movq %r8, -0x98(%rbp)
movq %r9, -0xa0(%rbp)
movq -0x98(%rbp), %rax
movq -0x88(%rbp), %rdx
movq -0x98(%rbp), %rcx
movq %rdx, -0x60(%rbp)
movq %rcx, -0x68(%rbp)
movq -0x60(%rbp), %rdx
movq -0x68(%rbp), %rcx
movq %rdx, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq %rdx, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
movq -0x8(%rbp), %rcx
addq $0x78, %rcx
movq -0x10(%rbp), %rdx
subq 0x646e1(%rip), %rdx     # 0xa3fa0
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x70(%rbp)
movq -0x70(%rbp), %rcx
shrq $0xd, %rcx
subq %rcx, %rax
movq %rax, -0xb8(%rbp)
movq -0x88(%rbp), %rcx
movq -0xb8(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
addq 0x646a0(%rip), %rax     # 0xa3fa8
imulq $0x60, -0x58(%rbp), %rcx
addq %rcx, %rax
xorl %ecx, %ecx
subq 0x64687(%rip), %rcx     # 0xa3fa0
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
addq $0x18, %rax
movq %rax, -0xa8(%rbp)
movq -0x80(%rbp), %rax
addq $0x980, %rax            # imm = 0x980
movq -0xa8(%rbp), %rcx
movl (%rcx), %ecx
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0xb0(%rbp)
movq -0x78(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x3a660
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq -0x90(%rbp), %rcx
movq -0xa0(%rbp), %r8
xorl %r9d, %r9d
callq 0x3f5a0
movq -0x78(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x3a6b0
addq $0xc0, %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: je_arena_dalloc_small
void
arena_dalloc_small(tsdn_t *tsdn, arena_t *arena, arena_chunk_t *chunk,
    void *ptr, size_t pageind)
{
	arena_chunk_map_bits_t *bitselm;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
movq %rdx, -0x70(%rbp)
movq %rcx, -0x78(%rbp)
movq %r8, -0x80(%rbp)
movq -0x70(%rbp), %rcx
movq -0x80(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
addq $0x78, %rax
movq -0x48(%rbp), %rcx
subq 0x645be(%rip), %rcx     # 0xa3fa0
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rcx
movq -0x80(%rbp), %r8
movq -0x88(%rbp), %r9
callq 0x3f820
movq -0x60(%rbp), %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
sete %al
testb $0x1, %al
jne 0x3fa4d
jmp 0x3fa4f
jmp 0x3faa3
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0x4d580
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
sete %al
testb $0x1, %al
jne 0x3fa80
jmp 0x3fa82
jmp 0x3faa3
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x4d5e0
testb $0x1, %al
jne 0x3fa94
jmp 0x3faa3
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x3b8a0
addq $0x90, %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: je_arena_dalloc_large
void
arena_dalloc_large(tsdn_t *tsdn, arena_t *arena, arena_chunk_t *chunk,
    void *ptr)
{

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rsi, -0x58(%rbp)
movq %rdx, -0x60(%rbp)
movq %rcx, -0x68(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a660
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x68(%rbp), %rcx
xorl %r8d, %r8d
callq 0x3fb40
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a6b0
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, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
sete %al
testb $0x1, %al
jne 0x3fe6f
jmp 0x3fe71
jmp 0x3fec5
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0x4d580
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
sete %al
testb $0x1, %al
jne 0x3fea2
jmp 0x3fea4
jmp 0x3fec5
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x4d5e0
testb $0x1, %al
jne 0x3feb6
jmp 0x3fec5
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x3b8a0
addq $0x70, %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: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a660
movq -0x10(%rbp), %rax
movl 0xf8(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a6b0
movl -0x14(%rbp), %eax
addq $0x20, %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: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a660
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xf8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a6b0
xorl %eax, %eax
andb $0x1, %al
addq $0x20, %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: je_arena_lg_dirty_mult_default_set
bool
arena_lg_dirty_mult_default_set(ssize_t lg_dirty_mult)
{

	if (opt_purge != purge_mode_ratio)
		return (true);
	if (!arena_lg_dirty_mult_valid(lg_dirty_mult))
		return (true);
	atomic_write_z((size_t *)&lg_dirty_mult_default, (size_t)lg_dirty_mult);
	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpl $0x0, 0x6086d(%rip)     # 0xa35b0
je 0x42d4b
movb $0x1, -0x1(%rbp)
jmp 0x42d72
movq -0x10(%rbp), %rdi
callq 0x3b4a0
testb $0x1, %al
jne 0x42d5e
movb $0x1, -0x1(%rbp)
jmp 0x42d72
movq -0x10(%rbp), %rsi
leaq 0x6121f(%rip), %rdi     # 0xa3f88
callq 0x42d80
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/arena.c
// Function: je_arena_decay_time_default_set
bool
arena_decay_time_default_set(ssize_t decay_time)
{

	if (opt_purge != purge_mode_decay)
		return (true);
	if (!arena_decay_time_valid(decay_time))
		return (true);
	atomic_write_z((size_t *)&decay_time_default, (size_t)decay_time);
	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpl $0x1, 0x607cd(%rip)     # 0xa35b0
je 0x42deb
movb $0x1, -0x1(%rbp)
jmp 0x42e12
movq -0x10(%rbp), %rdi
callq 0x3b5f0
testb $0x1, %al
jne 0x42dfe
movb $0x1, -0x1(%rbp)
jmp 0x42e12
movq -0x10(%rbp), %rsi
leaq 0x61187(%rip), %rdi     # 0xa3f90
callq 0x42d80
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/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
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a660
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq 0x10(%rbp), %r9
movq 0x18(%rbp), %rax
movq %rax, (%rsp)
callq 0x42ea0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a6b0
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_basic_stats_merge_locked
static void
arena_basic_stats_merge_locked(arena_t *arena, unsigned *nthreads,
    const char **dss, ssize_t *lg_dirty_mult, ssize_t *decay_time,
    size_t *nactive, size_t *ndirty)
{

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x43440
movl %eax, %ecx
movq -0x10(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0xf8(%rax), %eax
movl %eax, %ecx
leaq 0x604d4(%rip), %rax     # 0xa33c0
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x1b8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rcx
movq -0x30(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rcx
movq 0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%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: je_arena_prefork3
void
arena_prefork3(tsdn_t *tsdn, arena_t *arena)
{
	unsigned i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x27, -0x14(%rbp)
jae 0x445d9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x980, %rsi            # imm = 0x980
movl -0x14(%rbp), %eax
imulq $0xa8, %rax, %rax
addq %rax, %rsi
callq 0x66b40
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x445a7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x830, %rsi            # imm = 0x830
callq 0x66b40
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: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x830, %rsi            # imm = 0x830
callq 0x66bc0
movl $0x0, -0x14(%rbp)
cmpl $0x27, -0x14(%rbp)
jae 0x4465d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x980, %rsi            # imm = 0x980
movl -0x14(%rbp), %eax
imulq $0xa8, %rax, %rax
addq %rax, %rsi
callq 0x66bc0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4462b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8f8, %rsi            # imm = 0x8F8
callq 0x66bc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8a0, %rsi            # imm = 0x8A0
callq 0x66bc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x66bc0
addq $0x20, %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: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x830, %rsi            # imm = 0x830
callq 0x66c20
movl $0x0, -0x14(%rbp)
cmpl $0x27, -0x14(%rbp)
jae 0x446fd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x980, %rsi            # imm = 0x980
movl -0x14(%rbp), %eax
imulq $0xa8, %rax, %rax
addq %rax, %rsi
callq 0x66c20
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x446cb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8f8, %rsi            # imm = 0x8F8
callq 0x66c20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8a0, %rsi            # imm = 0x8A0
callq 0x66c20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x66c20
addq $0x20, %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_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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
jmp 0x44a8e
movq -0x60(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
addq $0x20, %rdi
movq -0x60(%rbp), %rsi
addq $0x1b8, %rsi            # imm = 0x1B8
addq $0x10, %rsi
callq 0x66d70
movq -0x60(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
addq $0x20, %rdi
movq -0x60(%rbp), %rsi
addq $0x1b8, %rsi            # imm = 0x1B8
addq $0x8, %rsi
callq 0x66dd0
movq -0x60(%rbp), %rax
cmpq $0x0, 0x1b8(%rax)
jle 0x44bda
movq -0x60(%rbp), %rax
addq $0x1b8, %rax            # imm = 0x1B8
addq $0x18, %rax
movq %rax, -0x70(%rbp)
movq -0x60(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
addq $0x8, %rdi
callq 0x66d10
movq -0x70(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x44be0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdx
tzcntq %rdx, %rax
addq $0x1, %rax
xorl %ecx, %ecx
cmpq $0x0, %rdx
cmoveq %rcx, %rax
subl $0x1, %eax
movl %eax, -0x54(%rbp)
movq -0x40(%rbp), %rcx
movl -0x54(%rbp), %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movabsq $0x5851f42d4c957f2d, %rax # imm = 0x5851F42D4C957F2D
imulq -0x8(%rbp), %rax
movabsq $0x14057b7ef767814f, %rcx # imm = 0x14057B7EF767814F
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movl $0x40, %ecx
subl -0x1c(%rbp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0x44b4a
movq -0x50(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x66cc0
movq -0x60(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
addq $0x20, %rdi
leaq -0x68(%rbp), %rsi
callq 0x66dd0
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/include/jemalloc/internal/util.h
// Function: je_pow2_ceil_u64
JEMALLOC_INLINE uint64_t
pow2_ceil_u64(uint64_t x)
{

	x--;
	x |= x >> 1;
	x |= x >> 2;
	x |= x >> 4;
	x |= x >> 8;
	x |= x >> 16;
	x |= x >> 32;
	x++;
	return (x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x4, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x8, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x10, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x20, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %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/arena.c
// Function: arena_decay_epoch_advance_helper
static void
arena_decay_epoch_advance_helper(arena_t *arena, const nstime_t *time)
{
	uint64_t nadvance_u64;
	nstime_t delta;

	assert(opt_purge == purge_mode_decay);
	assert(arena_decay_deadline_reached(arena, time));

	nstime_copy(&delta, time);
	nstime_subtract(&delta, &arena->decay.epoch);
	nadvance_u64 = nstime_divide(&delta, &arena->decay.interval);
	assert(nadvance_u64 > 0);

	/* Add nadvance_u64 decay intervals to epoch. */
	nstime_copy(&delta, &arena->decay.interval);
	nstime_imultiply(&delta, nadvance_u64);
	nstime_add(&arena->decay.epoch, &delta);

	/* Set a new deadline. */
	arena_decay_deadline_init(arena);

	/* Update the backlog. */
	arena_decay_backlog_update(arena, nadvance_u64);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x44d02
jmp 0x44d04
jmp 0x44d06
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x66d70
movq -0x8(%rbp), %rsi
addq $0x1b8, %rsi            # imm = 0x1B8
addq $0x10, %rsi
leaq -0x20(%rbp), %rdi
callq 0x66e00
movq -0x8(%rbp), %rsi
addq $0x1b8, %rsi            # imm = 0x1B8
addq $0x8, %rsi
leaq -0x20(%rbp), %rdi
callq 0x66e80
movq %rax, -0x18(%rbp)
jmp 0x44d49
movq -0x8(%rbp), %rsi
addq $0x1b8, %rsi            # imm = 0x1B8
addq $0x8, %rsi
leaq -0x20(%rbp), %rdi
callq 0x66d70
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x66e30
movq -0x8(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
addq $0x10, %rdi
leaq -0x20(%rbp), %rsi
callq 0x66dd0
movq -0x8(%rbp), %rdi
callq 0x44a80
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x44e10
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_decay_epoch_advance_purge
static void
arena_decay_epoch_advance_purge(tsdn_t *tsdn, arena_t *arena)
{
	size_t ndirty_limit = arena_decay_backlog_npages_limit(arena);

	if (arena->ndirty > ndirty_limit)
		arena_purge_to_limit(tsdn, arena, ndirty_limit);
	arena->decay.ndirty = arena->ndirty;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x44f40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rax
cmpq -0x18(%rbp), %rax
jbe 0x44def
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3b910
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1e0(%rax)
addq $0x20, %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_decay_backlog_update
static void
arena_decay_backlog_update(arena_t *arena, uint64_t nadvance_u64)
{

	if (nadvance_u64 >= SMOOTHSTEP_NSTEPS) {
		memset(arena->decay.backlog, 0, (SMOOTHSTEP_NSTEPS-1) *
		    sizeof(size_t));
	} else {
		size_t nadvance_z = (size_t)nadvance_u64;

		assert((uint64_t)nadvance_z == nadvance_u64);

		memmove(arena->decay.backlog, &arena->decay.backlog[nadvance_z],
		    (SMOOTHSTEP_NSTEPS - nadvance_z) * sizeof(size_t));
		if (nadvance_z > 1) {
			memset(&arena->decay.backlog[SMOOTHSTEP_NSTEPS -
			    nadvance_z], 0, (nadvance_z-1) * sizeof(size_t));
		}
	}

	arena_decay_backlog_update_last(arena);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0xc8, -0x10(%rbp)
jb 0x44e4a
movq -0x8(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
addq $0x30, %rdi
xorl %esi, %esi
movl $0x638, %edx            # imm = 0x638
callq 0xb210
jmp 0x44eca
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x44e54
movq -0x8(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
addq $0x30, %rdi
movq -0x8(%rbp), %rsi
addq $0x1b8, %rsi            # imm = 0x1B8
addq $0x30, %rsi
movq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movl $0xc8, %edx
subq -0x18(%rbp), %rdx
shlq $0x3, %rdx
callq 0xb430
cmpq $0x1, -0x18(%rbp)
jbe 0x44ec8
movq -0x8(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
addq $0x30, %rdi
movl $0xc8, %eax
subq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0xb210
jmp 0x44eca
movq -0x8(%rbp), %rdi
callq 0x44ee0
addq $0x20, %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_decay_backlog_npages_limit
static size_t
arena_decay_backlog_npages_limit(const arena_t *arena)
{
	static const uint64_t h_steps[] = {
#define	STEP(step, h, x, y) \
		h,
		SMOOTHSTEP
#undef STEP
	};
	uint64_t sum;
	size_t npages_limit_backlog;
	unsigned i;

	assert(opt_purge == purge_mode_decay);

	/*
	 * For each element of decay_backlog, multiply by the corresponding
	 * fixed-point smoothstep decay factor.  Sum the products, then divide
	 * to round down to the nearest whole number of pages.
	 */
	sum = 0;
	for (i = 0; i < SMOOTHSTEP_NSTEPS; i++)
		sum += arena->decay.backlog[i] * h_steps[i];
	npages_limit_backlog = (size_t)(sum >> SMOOTHSTEP_BFP);

	return (npages_limit_backlog);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x44f4a
movq $0x0, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0xc8, -0x1c(%rbp)
jae 0x44f95
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq 0x1e8(%rax,%rcx,8), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
leaq 0x4c013(%rip), %rcx     # 0x90f90
imulq (%rcx,%rdx,8), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x44f59
movq -0x10(%rbp), %rax
shrq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
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_chunk_alloc
static arena_chunk_t *
arena_chunk_alloc(tsdn_t *tsdn, arena_t *arena)
{
	arena_chunk_t *chunk;

	if (arena->spare != NULL)
		chunk = arena_chunk_init_spare(arena);
	else {
		chunk = arena_chunk_init_hard(tsdn, arena);
		if (chunk == NULL)
			return (NULL);
	}

	ql_elm_new(&chunk->node, ql_link);
	ql_tail_insert(&arena->achunks, &chunk->node, ql_link);
	arena_avail_insert(arena, chunk, map_bias, chunk_npages-map_bias);

	return (chunk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x110(%rax)
je 0x45f0d
movq -0x18(%rbp), %rdi
callq 0x46050
movq %rax, -0x20(%rbp)
jmp 0x45f34
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x46090
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x45f32
movq $0x0, -0x8(%rbp)
jmp 0x45fef
jmp 0x45f34
jmp 0x45f36
movq -0x20(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x20(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x58(%rax)
jmp 0x45f50
movq -0x18(%rbp), %rax
cmpq $0x0, 0x100(%rax)
je 0x45faf
jmp 0x45f60
movq -0x18(%rbp), %rax
movq 0x100(%rax), %rax
movq 0x58(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rax
movq 0x100(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x20(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
movq %rcx, 0x50(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x100(%rax), %rax
movq %rcx, 0x58(%rax)
jmp 0x45faf
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x100(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq 0x5dfcf(%rip), %rdx     # 0xa3fa0
leaq 0x5e0e0(%rip), %rax     # 0xa40b8
movq (%rax), %rcx
subq 0x5dfbe(%rip), %rcx     # 0xa3fa0
callq 0x466a0
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/src/arena.c
// Function: arena_avail_insert
static void
arena_avail_insert(arena_t *arena, arena_chunk_t *chunk, size_t pageind,
    size_t npages)
{
	pszind_t pind = psz2ind(run_quantize_floor(arena_miscelm_size_get(
	    arena_miscelm_get_const(chunk, pageind))));
	assert(npages == (arena_mapbits_unallocated_size_get(chunk, pageind) >>
	    LG_PAGE));
	assert((npages << LG_PAGE) < chunksize);
	assert(pind2sz(pind) <= chunksize);
	arena_run_heap_insert(&arena->runs_avail[pind],
	    arena_miscelm_get_mutable(chunk, pageind));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdx, -0x48(%rbp)
movq %rcx, -0x50(%rbp)
movq -0x40(%rbp), %rcx
movq -0x48(%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), %rdi
addq 0x5d8c5(%rip), %rdi     # 0xa3fa8
imulq $0x60, -0x10(%rbp), %rax
addq %rax, %rdi
xorl %eax, %eax
subq 0x5d8ac(%rip), %rax     # 0xa3fa0
imulq $0x60, %rax, %rax
addq %rax, %rdi
callq 0x46e10
movq %rax, %rdi
callq 0x46da0
movq %rax, %rdi
callq 0x46cc0
movl %eax, -0x54(%rbp)
jmp 0x46715
jmp 0x46717
jmp 0x46719
jmp 0x4671b
jmp 0x4671d
movq -0x38(%rbp), %rdi
addq $0x2318, %rdi           # imm = 0x2318
movl -0x54(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rsi
addq 0x5d85b(%rip), %rsi     # 0xa3fa8
imulq $0x60, -0x30(%rbp), %rax
addq %rax, %rsi
xorl %eax, %eax
subq 0x5d842(%rip), %rax     # 0xa3fa0
imulq $0x60, %rax, %rax
addq %rax, %rsi
callq 0x46f20
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_chunk_alloc_internal
static arena_chunk_t *
arena_chunk_alloc_internal(tsdn_t *tsdn, arena_t *arena, bool *zero,
    bool *commit)
{
	arena_chunk_t *chunk;
	chunk_hooks_t chunk_hooks = CHUNK_HOOKS_INITIALIZER;
	size_t sn;

	chunk = chunk_alloc_cache(tsdn, arena, &chunk_hooks, NULL, chunksize,
	    chunksize, &sn, zero, commit, true);
	if (chunk != NULL) {
		if (arena_chunk_register(tsdn, arena, chunk, sn, *zero)) {
			chunk_dalloc_cache(tsdn, arena, &chunk_hooks, chunk,
			    chunksize, sn, true);
			return (NULL);
		}
	}
	if (chunk == NULL) {
		chunk = arena_chunk_alloc_internal_hard(tsdn, arena,
		    &chunk_hooks, zero, commit);
	}

	if (config_stats && chunk != NULL) {
		arena->stats.mapped += chunksize;
		arena->stats.metadata_mapped += (map_bias << LG_PAGE);
	}

	return (chunk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0xb210
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x5d8fe(%rip), %rax     # 0xa40a8
movq (%rax), %r8
leaq 0x5d8f4(%rip), %rax     # 0xa40a8
movq (%rax), %r9
movq -0x20(%rbp), %r10
movq -0x28(%rbp), %rax
leaq -0x68(%rbp), %rdx
xorl %ecx, %ecx
leaq -0x70(%rbp), %r11
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
callq 0x518e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x4684c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x70(%rbp), %rcx
movq -0x20(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x468c0
testb $0x1, %al
jne 0x46816
jmp 0x4684a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rcx
leaq 0x5d87f(%rip), %rax     # 0xa40a8
movq (%rax), %r8
movq -0x70(%rbp), %r9
leaq -0x68(%rbp), %rdx
movl $0x1, (%rsp)
callq 0x523b0
movq $0x0, -0x8(%rbp)
jmp 0x468b2
jmp 0x4684c
cmpq $0x0, -0x30(%rbp)
jne 0x46870
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0x68(%rbp), %rdx
callq 0x46940
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x468aa
leaq 0x5d82a(%rip), %rax     # 0xa40a8
movq (%rax), %rcx
movq -0x18(%rbp), %rax
addq 0x60(%rax), %rcx
movq %rcx, 0x60(%rax)
movq 0x5d70c(%rip), %rcx     # 0xa3fa0
shlq $0xc, %rcx
movq -0x18(%rbp), %rax
addq 0x88(%rax), %rcx
movq %rcx, 0x88(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/include/jemalloc/internal/extent.h
// Function: je_extent_node_init
JEMALLOC_INLINE void
extent_node_init(extent_node_t *node, arena_t *arena, void *addr, size_t size,
    size_t sn, bool zeroed, bool committed)
{

	extent_node_arena_set(node, arena);
	extent_node_addr_set(node, addr);
	extent_node_size_set(node, size);
	extent_node_sn_set(node, sn);
	extent_node_zeroed_set(node, zeroed);
	extent_node_committed_set(node, committed);
	extent_node_achunk_set(node, false);
	if (config_prof)
		extent_node_prof_tctx_set(node, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %r9d, %eax
movq %rcx, -0x48(%rbp)
movq %rdx, %rcx
movq -0x48(%rbp), %rdx
movq %rcx, -0x40(%rbp)
movq %rsi, %rcx
movq -0x40(%rbp), %rsi
movq %rcx, -0x38(%rbp)
movq %rdi, %r9
movq -0x38(%rbp), %rdi
movb %al, %cl
movb 0x10(%rbp), %al
movq %r9, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %cl
movb %cl, -0x29(%rbp)
andb $0x1, %al
movb %al, -0x2a(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x46c00
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x46c20
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x46c40
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x46c60
movq -0x8(%rbp), %rdi
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x46c80
movq -0x8(%rbp), %rdi
movb -0x2a(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x46ca0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x46be0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%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_psz2ind
JEMALLOC_INLINE pszind_t
psz2ind(size_t psz)
{

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movabsq $0x7000000000000000, %rax # imm = 0x7000000000000000
cmpq %rax, -0x10(%rbp)
seta %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x46cfa
movl $0xc7, -0x4(%rbp)
jmp 0x46d8f
movq -0x10(%rbp), %rdi
shlq %rdi
subq $0x1, %rdi
callq 0x46fc0
movl %eax, -0x14(%rbp)
cmpl $0xe, -0x14(%rbp)
jae 0x46d1a
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x46d23
movl -0x14(%rbp), %eax
subl $0xe, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x1c(%rbp)
cmpl $0xf, -0x14(%rbp)
jae 0x46d42
movl $0xc, %eax
movl %eax, -0x38(%rbp)
jmp 0x46d4e
movl -0x14(%rbp), %eax
subl $0x2, %eax
subl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %ecx
movq $-0x1, %rax
shlq %cl, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
subq $0x1, %rax
andq -0x28(%rbp), %rax
movl -0x20(%rbp), %ecx
shrq %cl, %rax
andq $0x3, %rax
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %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_miscelm_size_get
JEMALLOC_INLINE_C size_t
arena_miscelm_size_get(const arena_chunk_map_misc_t *miscelm)
{
	arena_chunk_t *chunk;
	size_t pageind, mapbits;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x78(%rbp)
movq -0x78(%rbp), %rax
leaq 0x5d289(%rip), %rcx     # 0xa40b0
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
leaq 0x5d268(%rip), %rcx     # 0xa40b0
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rax
movq -0x68(%rbp), %rcx
addq 0x5d143(%rip), %rcx     # 0xa3fa8
subq %rcx, %rax
movl $0x60, %ecx
xorl %edx, %edx
divq %rcx
addq 0x5d127(%rip), %rax     # 0xa3fa0
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rcx
movq -0x88(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rcx
movq -0x58(%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 0x5d0c2(%rip), %rcx     # 0xa3fa0
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
andq $-0x2000, %rax          # imm = 0xE000
shrq %rax
movq %rax, -0x48(%rbp)
movq -0x48(%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/src/arena.c
// Function: arena_avail_remove
static void
arena_avail_remove(arena_t *arena, arena_chunk_t *chunk, size_t pageind,
    size_t npages)
{
	pszind_t pind = psz2ind(run_quantize_floor(arena_miscelm_size_get(
	    arena_miscelm_get_const(chunk, pageind))));
	assert(npages == (arena_mapbits_unallocated_size_get(chunk, pageind) >>
	    LG_PAGE));
	assert((npages << LG_PAGE) < chunksize);
	assert(pind2sz(pind) <= chunksize);
	arena_run_heap_remove(&arena->runs_avail[pind],
	    arena_miscelm_get_mutable(chunk, pageind));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdx, -0x48(%rbp)
movq %rcx, -0x50(%rbp)
movq -0x40(%rbp), %rcx
movq -0x48(%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), %rdi
addq 0x5bfc5(%rip), %rdi     # 0xa3fa8
imulq $0x60, -0x10(%rbp), %rax
addq %rax, %rdi
xorl %eax, %eax
subq 0x5bfac(%rip), %rax     # 0xa3fa0
imulq $0x60, %rax, %rax
addq %rax, %rdi
callq 0x46e10
movq %rax, %rdi
callq 0x46da0
movq %rax, %rdi
callq 0x46cc0
movl %eax, -0x54(%rbp)
jmp 0x48015
jmp 0x48017
jmp 0x48019
jmp 0x4801b
jmp 0x4801d
movq -0x38(%rbp), %rdi
addq $0x2318, %rdi           # imm = 0x2318
movl -0x54(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rsi
addq 0x5bf5b(%rip), %rsi     # 0xa3fa8
imulq $0x60, -0x30(%rbp), %rax
addq %rax, %rsi
xorl %eax, %eax
subq 0x5bf42(%rip), %rax     # 0xa3fa0
imulq $0x60, %rax, %rax
addq %rax, %rsi
callq 0x48220
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: arena_run_dirty_remove
static void
arena_run_dirty_remove(arena_t *arena, arena_chunk_t *chunk, size_t pageind,
    size_t npages)
{
	arena_chunk_map_misc_t *miscelm = arena_miscelm_get_mutable(chunk,
	    pageind);

	assert(npages == (arena_mapbits_unallocated_size_get(chunk, pageind) >>
	    LG_PAGE));
	assert(arena_mapbits_dirty_get(chunk, pageind) == CHUNK_MAP_DIRTY);
	assert(arena_mapbits_dirty_get(chunk, pageind+npages-1) ==
	    CHUNK_MAP_DIRTY);

	qr_remove(&miscelm->rd, rd_link);
	assert(arena->ndirty >= npages);
	arena->ndirty -= npages;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq 0x5bf09(%rip), %rax     # 0xa3fa8
imulq $0x60, -0x10(%rbp), %rcx
addq %rcx, %rax
xorl %ecx, %ecx
subq 0x5bef0(%rip), %rcx     # 0xa3fa0
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x480bd
jmp 0x480bf
jmp 0x480c1
jmp 0x480c3
jmp 0x480c5
jmp 0x480c7
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
addq $0x18, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rcx
addq $0x18, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x48110
jmp 0x48112
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x130(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x130(%rax)
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_dirty_insert
static void
arena_run_dirty_insert(arena_t *arena, arena_chunk_t *chunk, size_t pageind,
    size_t npages)
{
	arena_chunk_map_misc_t *miscelm = arena_miscelm_get_mutable(chunk,
	    pageind);

	assert(npages == (arena_mapbits_unallocated_size_get(chunk, pageind) >>
	    LG_PAGE));
	assert(arena_mapbits_dirty_get(chunk, pageind) == CHUNK_MAP_DIRTY);
	assert(arena_mapbits_dirty_get(chunk, pageind+npages-1) ==
	    CHUNK_MAP_DIRTY);

	qr_new(&miscelm->rd, rd_link);
	qr_meld(&arena->runs_dirty, &miscelm->rd, rd_link);
	arena->ndirty += npages;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq 0x5be49(%rip), %rax     # 0xa3fa8
imulq $0x60, -0x10(%rbp), %rcx
addq %rcx, %rax
xorl %ecx, %ecx
subq 0x5be30(%rip), %rcx     # 0xa3fa0
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x4817d
jmp 0x4817f
jmp 0x48181
jmp 0x48183
jmp 0x48185
jmp 0x48187
movq -0x38(%rbp), %rcx
addq $0x18, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rcx
addq $0x18, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x481a9
movq -0x38(%rbp), %rcx
addq $0x18, %rcx
movq -0x18(%rbp), %rax
movq 0x140(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
addq $0x138, %rcx            # imm = 0x138
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x140(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x140(%rax)
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0x130(%rax), %rcx
movq %rcx, 0x130(%rax)
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_snad_comp
JEMALLOC_INLINE_C int
arena_snad_comp(const arena_chunk_map_misc_t *a,
    const arena_chunk_map_misc_t *b)
{
	int ret;

	assert(a != NULL);
	assert(b != NULL);

	ret = arena_sn_comp(a, b);
	if (ret != 0)
		return (ret);

	ret = arena_ad_comp(a, b);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0x498b2
jmp 0x498b4
jmp 0x498b6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x49900
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x498d4
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x498ea
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x49970
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
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_sn_comp
JEMALLOC_INLINE_C int
arena_sn_comp(const arena_chunk_map_misc_t *a, const arena_chunk_map_misc_t *b)
{
	size_t a_sn, b_sn;

	assert(a != NULL);
	assert(b != NULL);

	a_sn = extent_node_sn_get(arena_miscelm_extent_get(a));
	b_sn = extent_node_sn_get(arena_miscelm_extent_get(b));

	return ((a_sn > b_sn) - (a_sn < b_sn));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x49912
jmp 0x49914
jmp 0x49916
movq -0x8(%rbp), %rdi
callq 0x499e0
movq %rax, %rdi
callq 0x499c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x499e0
movq %rax, %rdi
callq 0x499c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x18(%rbp), %rcx
cmpq -0x20(%rbp), %rcx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)