LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/include/jemalloc/internal/spin.h
// Function: je_spin_adaptive
JEMALLOC_INLINE void
spin_adaptive(spin_t *spin)
{
	volatile uint64_t i;

	for (i = 0; i < (KQU(1) << spin->iteration); i++)
		CPU_SPINWAIT;

	if (spin->iteration < 63)
		spin->iteration++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
cmpq %rcx, %rax
jae 0x3a12a
pause
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3a100
movq -0x8(%rbp), %rax
cmpl $0x3f, (%rax)
jae 0x3a13e
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: malloc_slow_flag_init
static void
malloc_slow_flag_init(void)
{
	/*
	 * Combine the runtime options into malloc_slow for fast path.  Called
	 * after processing all the options.
	 */
	malloc_slow_flags |= (opt_junk_alloc ? flag_opt_junk_alloc : 0)
	    | (opt_junk_free ? flag_opt_junk_free : 0)
	    | (opt_quarantine ? flag_opt_quarantine : 0)
	    | (opt_zero ? flag_opt_zero : 0)
	    | (opt_utrace ? flag_opt_utrace : 0)
	    | (opt_xmalloc ? flag_opt_xmalloc : 0);

	if (config_valgrind)
		malloc_slow_flags |= (in_valgrind ? flag_in_valgrind : 0);

	malloc_slow = (malloc_slow_flags != 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0x69377(%rip), %dl      # 0xa3501
xorl %ecx, %ecx
movl $0x1, %eax
testb $0x1, %dl
cmovnel %eax, %ecx
movb 0x69364(%rip), %sil     # 0xa3502
xorl %eax, %eax
movl $0x2, %edx
testb $0x1, %sil
cmovnel %edx, %eax
orl %eax, %ecx
movq 0x69353(%rip), %rsi     # 0xa3508
xorl %eax, %eax
movl $0x4, %edx
cmpq $0x0, %rsi
cmovnel %edx, %eax
orl %eax, %ecx
movb 0x69347(%rip), %sil     # 0xa3513
xorl %eax, %eax
movl $0x8, %edx
testb $0x1, %sil
cmovnel %edx, %eax
orl %eax, %ecx
movb 0x6932e(%rip), %sil     # 0xa3511
xorl %eax, %eax
movl $0x10, %edx
testb $0x1, %sil
cmovnel %edx, %eax
orl %eax, %ecx
movb 0x69318(%rip), %sil     # 0xa3512
xorl %eax, %eax
movl $0x40, %edx
testb $0x1, %sil
cmovnel %edx, %eax
orl %eax, %ecx
movzbl 0x6938f(%rip), %eax     # 0xa35a0
orl %ecx, %eax
movb %al, 0x69387(%rip)      # 0xa35a0
movb 0x6935d(%rip), %dl      # 0xa357c
xorl %ecx, %ecx
movl $0x20, %eax
testb $0x1, %dl
cmovnel %eax, %ecx
movzbl 0x6936d(%rip), %eax     # 0xa35a0
orl %ecx, %eax
movb %al, 0x69365(%rip)      # 0xa35a0
movzbl 0x6935e(%rip), %eax     # 0xa35a0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x690e8(%rip)      # 0xa3338
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_node_alloc
extent_node_t *
arena_node_alloc(tsdn_t *tsdn, arena_t *arena)
{
	extent_node_t *node;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8f8, %rsi            # imm = 0x8F8
callq 0x3a660
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8f0(%rax)
je 0x3a527
movq -0x18(%rbp), %rax
movq 0x8f0(%rax), %rax
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x3a52f
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x3a52f
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3a569
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8f8, %rsi            # imm = 0x8F8
callq 0x3a6b0
movq -0x10(%rbp), %rdi
movl $0x70, %esi
callq 0x50230
movq %rax, -0x8(%rbp)
jmp 0x3a64d
jmp 0x3a56b
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8f0(%rax)
je 0x3a58e
movq -0x18(%rbp), %rax
movq 0x8f0(%rax), %rax
movq 0x58(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x3a596
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x3a596
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x8f0(%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0x3a5c9
movq -0x18(%rbp), %rax
movq 0x8f0(%rax), %rax
movq 0x50(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8f0(%rax)
movq -0x18(%rbp), %rax
movq 0x8f0(%rax), %rax
cmpq -0x28(%rbp), %rax
je 0x3a61e
jmp 0x3a5dc
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rax
movq %rcx, 0x50(%rax)
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rcx
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x58(%rax)
movq -0x28(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x28(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x58(%rax)
jmp 0x3a62d
movq -0x18(%rbp), %rax
movq $0x0, 0x8f0(%rax)
jmp 0x3a62f
jmp 0x3a631
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8f8, %rsi            # imm = 0x8F8
callq 0x3a6b0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
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: je_arena_node_dalloc
void
arena_node_dalloc(tsdn_t *tsdn, arena_t *arena, extent_node_t *node)
{

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8f8, %rsi            # imm = 0x8F8
callq 0x3a660
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 0x3a722
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8f0(%rax)
je 0x3a781
jmp 0x3a732
movq -0x10(%rbp), %rax
movq 0x8f0(%rax), %rax
movq 0x58(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
movq 0x8f0(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8f0(%rax), %rax
movq %rcx, 0x58(%rax)
jmp 0x3a781
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8f0(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8f8, %rsi            # imm = 0x8F8
callq 0x3a6b0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_chunk_alloc_huge
void *
arena_chunk_alloc_huge(tsdn_t *tsdn, arena_t *arena, size_t usize,
    size_t alignment, size_t *sn, bool *zero)
{
	void *ret;
	chunk_hooks_t chunk_hooks = CHUNK_HOOKS_INITIALIZER;
	size_t csize = CHUNK_CEILING(usize);
	bool commit = true;

	malloc_mutex_lock(tsdn, &arena->lock);

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

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

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0xb210
movq -0x18(%rbp), %rax
leaq 0x698c2(%rip), %rcx     # 0xa40b0
addq (%rcx), %rax
leaq 0x698b8(%rip), %rcx     # 0xa40b0
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x78(%rbp)
movb $0x1, -0x79(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a660
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3a8f0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x60(%rax), %rcx
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
shrq $0xc, %rsi
callq 0x3a9e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x78(%rbp), %r8
movq -0x20(%rbp), %r9
movq -0x28(%rbp), %r11
movq -0x30(%rbp), %r10
leaq -0x70(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
leaq -0x79(%rbp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
callq 0x518e0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a6b0
cmpq $0x0, -0x38(%rbp)
jne 0x3a8d6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %r10
movq -0x78(%rbp), %rax
leaq -0x70(%rbp), %rdx
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x3aa80
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %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_nactive_add
static void
arena_nactive_add(arena_t *arena, size_t add_pages)
{

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
addq -0x10(%rbp), %rax
shlq $0xc, %rax
leaq 0x696a6(%rip), %rcx     # 0xa40b0
addq (%rcx), %rax
leaq 0x6969c(%rip), %rcx     # 0xa40b0
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x128(%rcx), %rcx
shlq $0xc, %rcx
leaq 0x6967c(%rip), %rdx     # 0xa40b0
addq (%rdx), %rcx
leaq 0x69672(%rip), %rdx     # 0xa40b0
movq (%rdx), %rdx
xorq $-0x1, %rdx
andq %rdx, %rcx
subq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3aa5f
movq -0x18(%rbp), %rdi
callq 0x44790
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x128(%rax), %rcx
movq %rcx, 0x128(%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_chunk_alloc_huge_hard
static void *
arena_chunk_alloc_huge_hard(tsdn_t *tsdn, arena_t *arena,
    chunk_hooks_t *chunk_hooks, size_t usize, size_t alignment, size_t *sn,
    bool *zero, size_t csize)
{
	void *ret;
	bool commit = true;

	ret = chunk_alloc_wrapper(tsdn, arena, chunk_hooks, NULL, csize,
	    alignment, sn, zero, &commit);
	if (ret == NULL) {
		/* Revert optimistic stats updates. */
		malloc_mutex_lock(tsdn, &arena->lock);
		if (config_stats) {
			arena_huge_malloc_stats_update_undo(arena, usize);
			arena->stats.mapped -= usize;
		}
		arena_nactive_sub(arena, usize >> LG_PAGE);
		malloc_mutex_unlock(tsdn, &arena->lock);
	}

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %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)
movb $0x1, -0x39(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq 0x18(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %r11
movq 0x10(%rbp), %r10
xorl %eax, %eax
movl %eax, %ecx
leaq -0x39(%rbp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x52090
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x3ab41
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a660
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x447c0
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
shrq $0xc, %rsi
callq 0x3ad10
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a6b0
movq -0x38(%rbp), %rax
addq $0x60, %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_chunk_dalloc_huge
void
arena_chunk_dalloc_huge(tsdn_t *tsdn, arena_t *arena, void *chunk, size_t usize,
    size_t sn)
{
	chunk_hooks_t chunk_hooks = CHUNK_HOOKS_INITIALIZER;
	size_t csize;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0xb210
movq -0x20(%rbp), %rax
leaq 0x69529(%rip), %rcx     # 0xa40b0
addq (%rcx), %rax
leaq 0x6951f(%rip), %rcx     # 0xa40b0
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a660
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3ac20
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
shrq $0xc, %rsi
callq 0x3ad10
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x68(%rbp), %r8
movq -0x28(%rbp), %r9
leaq -0x60(%rbp), %rdx
movl $0x1, (%rsp)
callq 0x523b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a6b0
addq $0x70, %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_nactive_sub
static void
arena_nactive_sub(arena_t *arena, size_t sub_pages)
{

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
shlq $0xc, %rax
leaq 0x6937a(%rip), %rcx     # 0xa40b0
addq (%rcx), %rax
leaq 0x69370(%rip), %rcx     # 0xa40b0
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x128(%rcx), %rcx
subq -0x10(%rbp), %rcx
shlq $0xc, %rcx
leaq 0x6934c(%rip), %rdx     # 0xa40b0
addq (%rdx), %rcx
leaq 0x69342(%rip), %rdx     # 0xa40b0
movq (%rdx), %rdx
xorq $-0x1, %rdx
andq %rdx, %rcx
subq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3ad8f
movq -0x18(%rbp), %rdi
callq 0x448b0
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x128(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_chunk_ralloc_huge_similar
void
arena_chunk_ralloc_huge_similar(tsdn_t *tsdn, arena_t *arena, void *chunk,
    size_t oldsize, size_t usize)
{

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

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

// Assembly:
pushq %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 0x3adce
jmp 0x3add0
jmp 0x3add2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a660
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3ae50
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x3ae15
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
subq -0x20(%rbp), %rsi
shrq $0xc, %rsi
callq 0x3a9e0
jmp 0x3ae2a
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
subq -0x28(%rbp), %rsi
shrq $0xc, %rsi
callq 0x3ad10
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a6b0
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: je_arena_chunk_ralloc_huge_shrink
void
arena_chunk_ralloc_huge_shrink(tsdn_t *tsdn, arena_t *arena, void *chunk,
    size_t oldsize, size_t usize, size_t sn)
{
	size_t udiff = oldsize - usize;
	size_t cdiff = CHUNK_CEILING(oldsize) - CHUNK_CEILING(usize);

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
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 -0x20(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
leaq 0x691e6(%rip), %rcx     # 0xa40b0
addq (%rcx), %rax
leaq 0x691dc(%rip), %rcx     # 0xa40b0
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq -0x28(%rbp), %rcx
leaq 0x691c7(%rip), %rdx     # 0xa40b0
addq (%rdx), %rcx
leaq 0x691bd(%rip), %rdx     # 0xa40b0
movq (%rdx), %rdx
xorq $-0x1, %rdx
andq %rdx, %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a660
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3ae50
cmpq $0x0, -0x40(%rbp)
je 0x3af40
movq -0x40(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
shrq $0xc, %rsi
callq 0x3ad10
cmpq $0x0, -0x40(%rbp)
je 0x3afb6
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0xb210
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
leaq 0x69139(%rip), %rdx     # 0xa40b0
addq (%rdx), %rcx
leaq 0x6912f(%rip), %rdx     # 0xa40b0
movq (%rdx), %rdx
xorq $-0x1, %rdx
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x80(%rbp), %rcx
movq -0x40(%rbp), %r8
movq -0x30(%rbp), %r9
leaq -0x78(%rbp), %rdx
movl $0x1, (%rsp)
callq 0x523b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a6b0
addq $0x90, %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_ralloc_huge_expand_hard
static bool
arena_chunk_ralloc_huge_expand_hard(tsdn_t *tsdn, arena_t *arena,
    chunk_hooks_t *chunk_hooks, void *chunk, size_t oldsize, size_t usize,
    size_t *sn, bool *zero, void *nchunk, size_t udiff, size_t cdiff)
{
	bool err;
	bool commit = true;

	err = (chunk_alloc_wrapper(tsdn, arena, chunk_hooks, nchunk, cdiff,
	    chunksize, sn, zero, &commit) == NULL);
	if (err) {
		/* Revert optimistic stats updates. */
		malloc_mutex_lock(tsdn, &arena->lock);
		if (config_stats) {
			arena_huge_ralloc_stats_update_undo(arena, oldsize,
			    usize);
			arena->stats.mapped -= cdiff;
		}
		arena_nactive_sub(arena, udiff >> LG_PAGE);
		malloc_mutex_unlock(tsdn, &arena->lock);
	} else if (chunk_hooks->merge(chunk, CHUNK_CEILING(oldsize), nchunk,
	    cdiff, true, arena->ind)) {
		chunk_dalloc_wrapper(tsdn, arena, chunk_hooks, nchunk, cdiff,
		    *sn, *zero, true);
		err = true;
	}
	return (err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
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)
movb $0x1, -0x32(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq 0x20(%rbp), %rcx
movq 0x30(%rbp), %r8
leaq 0x68e05(%rip), %rax     # 0xa40a8
movq (%rax), %r9
movq 0x10(%rbp), %r11
movq 0x18(%rbp), %r10
leaq -0x32(%rbp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x52090
cmpq $0x0, %rax
sete %al
andb $0x1, %al
movb %al, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
je 0x3b333
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a660
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x44950
movq 0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rdi
movq 0x28(%rbp), %rsi
shrq $0xc, %rsi
callq 0x3ad10
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a6b0
jmp 0x3b3b7
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq 0x68d66(%rip), %rcx     # 0xa40b0
addq (%rcx), %rsi
leaq 0x68d5c(%rip), %rcx     # 0xa40b0
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rsi
movq 0x20(%rbp), %rdx
movq 0x30(%rbp), %rcx
movq -0x10(%rbp), %r8
movl (%r8), %r9d
movl $0x1, %r8d
callq *%rax
testb $0x1, %al
jne 0x3b37b
jmp 0x3b3b5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq 0x20(%rbp), %rcx
movq 0x30(%rbp), %r8
movq 0x10(%rbp), %rax
movq (%rax), %r9
movq 0x18(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0x52a50
movb $0x1, -0x31(%rbp)
jmp 0x3b3b7
movb -0x31(%rbp), %al
andb $0x1, %al
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_lg_dirty_mult_get
ssize_t
arena_lg_dirty_mult_get(tsdn_t *tsdn, arena_t *arena)
{
	ssize_t lg_dirty_mult;

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

	return (lg_dirty_mult);
}

// Assembly:
pushq %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
movq 0x118(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a6b0
movq -0x18(%rbp), %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: je_arena_lg_dirty_mult_set
bool
arena_lg_dirty_mult_set(tsdn_t *tsdn, arena_t *arena, ssize_t lg_dirty_mult)
{

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

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

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3b4a0
testb $0x1, %al
jne 0x3b447
movb $0x1, -0x1(%rbp)
jmp 0x3b489
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a660
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x118(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3b4d0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a6b0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
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_maybe_purge
void
arena_maybe_purge(tsdn_t *tsdn, arena_t *arena)
{

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x120(%rax)
je 0x3b4ef
jmp 0x3b514
cmpl $0x0, 0x680ba(%rip)     # 0xa35b0
jne 0x3b507
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3b710
jmp 0x3b514
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3b7a0
addq $0x10, %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: je_arena_decay_time_set
bool
arena_decay_time_set(tsdn_t *tsdn, arena_t *arena, ssize_t decay_time)
{

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

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

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3b5f0
testb $0x1, %al
jne 0x3b597
movb $0x1, -0x1(%rbp)
jmp 0x3b5d7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a660
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3b630
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3b4d0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a6b0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
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_time_valid
static bool
arena_decay_time_valid(ssize_t decay_time)
{

	if (decay_time < -1)
		return (false);
	if (decay_time == -1 || (uint64_t)decay_time <= NSTIME_SEC_MAX)
		return (true);
	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $-0x1, -0x10(%rbp)
jge 0x3b605
movb $0x0, -0x1(%rbp)
jmp 0x3b626
cmpq $-0x1, -0x10(%rbp)
je 0x3b61c
movabsq $0x44b82fa08, %rax      # imm = 0x44B82FA08
cmpq %rax, -0x10(%rbp)
ja 0x3b622
movb $0x1, -0x1(%rbp)
jmp 0x3b626
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
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_init
static void
arena_decay_init(arena_t *arena, ssize_t decay_time)
{

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1b8(%rax)
cmpq $0x0, -0x10(%rbp)
jle 0x3b68b
movq -0x8(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x66ce0
movq -0x8(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
addq $0x8, %rdi
movl $0xc8, %esi
callq 0x66e50
movq -0x8(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x66cc0
movq -0x8(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
addq $0x10, %rdi
callq 0x66eb0
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1d0(%rax)
movq -0x8(%rbp), %rdi
callq 0x44a80
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1e0(%rax)
movq -0x8(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
addq $0x30, %rdi
xorl %esi, %esi
movl $0x640, %edx            # imm = 0x640
callq 0xb210
addq $0x10, %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_maybe_purge_ratio
static void
arena_maybe_purge_ratio(tsdn_t *tsdn, arena_t *arena)
{

	assert(opt_purge == purge_mode_ratio);

	/* Don't purge if the option is disabled. */
	if (arena->lg_dirty_mult < 0)
		return;

	/*
	 * Iterate, since preventing recursive purging could otherwise leave too
	 * many dirty pages.
	 */
	while (true) {
		size_t threshold = (arena->nactive >> arena->lg_dirty_mult);
		if (threshold < chunk_npages)
			threshold = chunk_npages;
		/*
		 * Don't purge unless the number of purgeable pages exceeds the
		 * threshold.
		 */
		if (arena->ndirty <= threshold)
			return;
		arena_purge_to_limit(tsdn, arena, threshold);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x3b722
movq -0x10(%rbp), %rax
cmpq $0x0, 0x118(%rax)
jge 0x3b732
jmp 0x3b795
jmp 0x3b734
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x118(%rcx), %rcx
shrq %cl, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x6895c(%rip), %rcx     # 0xa40b8
cmpq (%rcx), %rax
jae 0x3b76f
leaq 0x68950(%rip), %rax     # 0xa40b8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rax
cmpq -0x18(%rbp), %rax
ja 0x3b782
jmp 0x3b795
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3b910
jmp 0x3b734
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_maybe_purge_decay
static void
arena_maybe_purge_decay(tsdn_t *tsdn, arena_t *arena)
{
	nstime_t time;

	assert(opt_purge == purge_mode_decay);

	/* Purge all or nothing if the option is disabled. */
	if (arena->decay.time <= 0) {
		if (arena->decay.time == 0)
			arena_purge_to_limit(tsdn, arena, 0);
		return;
	}

	nstime_init(&time, 0);
	nstime_update(&time);
	if (unlikely(!nstime_monotonic() && nstime_compare(&arena->decay.epoch,
	    &time) > 0)) {
		/*
		 * Time went backwards.  Move the epoch back in time and
		 * generate a new deadline, with the expectation that time
		 * typically flows forward for long enough periods of time that
		 * epochs complete.  Unfortunately, this strategy is susceptible
		 * to clock jitter triggering premature epoch advances, but
		 * clock jitter estimation and compensation isn't feasible here
		 * because calls into this code are event-driven.
		 */
		nstime_copy(&arena->decay.epoch, &time);
		arena_decay_deadline_init(arena);
	} else {
		/* Verify that time does not go backwards. */
		assert(nstime_compare(&arena->decay.epoch, &time) <= 0);
	}

	/*
	 * If the deadline has been reached, advance to the current epoch and
	 * purge to the new limit if necessary.  Note that dirty pages created
	 * during the current epoch are not subject to purge until a future
	 * epoch, so as a result purging only happens during epoch advances.
	 */
	if (arena_decay_deadline_reached(arena, &time))
		arena_decay_epoch_advance(tsdn, arena, &time);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x3b7b2
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1b8(%rax)
jg 0x3b7e4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1b8(%rax)
jne 0x3b7df
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3b910
jmp 0x3b88d
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x66cc0
leaq -0x18(%rbp), %rdi
callq 0x66eb0
callq 0x66ea0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0x3b82c
movq -0x10(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
addq $0x10, %rdi
leaq -0x18(%rbp), %rsi
callq 0x66d90
cmpl $0x0, %eax
setg %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3b863
movq -0x10(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
addq $0x10, %rdi
leaq -0x18(%rbp), %rsi
callq 0x66d70
movq -0x10(%rbp), %rdi
callq 0x44a80
jmp 0x3b869
jmp 0x3b865
jmp 0x3b867
jmp 0x3b869
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x44c70
testb $0x1, %al
jne 0x3b87c
jmp 0x3b88d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x44cb0
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_purge
void
arena_purge(tsdn_t *tsdn, arena_t *arena, bool all)
{

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

// Assembly:
pushq %rbp
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
addq $0x10, %rsi
callq 0x3a660
testb $0x1, -0x11(%rbp)
je 0x3b8e1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3b910
jmp 0x3b8ee
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3b4d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x3a6b0
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_purge_to_limit
static void
arena_purge_to_limit(tsdn_t *tsdn, arena_t *arena, size_t ndirty_limit)
{
	chunk_hooks_t chunk_hooks = chunk_hooks_get(tsdn, arena);
	size_t npurge, npurged;
	arena_runs_dirty_link_t purge_runs_sentinel;
	extent_node_t purge_chunks_sentinel;

	arena->purging = true;

	/*
	 * Calls to arena_dirty_count() are disabled even for debug builds
	 * because overhead grows nonlinearly as memory usage increases.
	 */
	if (false && config_debug) {
		size_t ndirty = arena_dirty_count(arena);
		assert(ndirty == arena->ndirty);
	}
	assert(opt_purge != purge_mode_ratio || (arena->nactive >>
	    arena->lg_dirty_mult) < arena->ndirty || ndirty_limit == 0);

	qr_new(&purge_runs_sentinel, rd_link);
	extent_node_dirty_linkage_init(&purge_chunks_sentinel);

	npurge = arena_stash_dirty(tsdn, arena, &chunk_hooks, ndirty_limit,
	    &purge_runs_sentinel, &purge_chunks_sentinel);
	if (npurge == 0)
		goto label_return;
	npurged = arena_purge_stashed(tsdn, arena, &chunk_hooks,
	    &purge_runs_sentinel, &purge_chunks_sentinel);
	assert(npurged == npurge);
	arena_unstash_purged(tsdn, arena, &chunk_hooks, &purge_runs_sentinel,
	    &purge_chunks_sentinel);

	if (config_stats)
		arena->stats.npurge++;

label_return:
	arena->purging = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x51160
movq -0x10(%rbp), %rax
movb $0x1, 0x120(%rax)
jmp 0x3b945
jmp 0x3b947
leaq -0x70(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x3a2d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
leaq -0x50(%rbp), %rdx
leaq -0x70(%rbp), %r8
leaq -0xe0(%rbp), %r9
callq 0x44fb0
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x3b990
jmp 0x3b9de
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x70(%rbp), %rcx
leaq -0xe0(%rbp), %r8
callq 0x45480
movq %rax, -0x60(%rbp)
jmp 0x3b9b2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x70(%rbp), %rcx
leaq -0xe0(%rbp), %r8
callq 0x45b60
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x70(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x120(%rax)
addq $0xe0, %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_huge_reset_stats_cancel
static void
arena_huge_reset_stats_cancel(arena_t *arena, size_t usize)
{
	szind_t index = size2index(usize) - nlclasses - NBINS;

	cassert(config_stats);

	arena->stats.ndalloc_huge++;
	arena->stats.hstats[index].ndalloc--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x1000, -0x18(%rbp)    # imm = 0x1000
setbe %al
testb $0x1, %al
jne 0x3c3b9
jmp 0x3c3e3
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
subq $0x1, %rcx
shrq $0x3, %rcx
leaq 0x546ac(%rip), %rax     # 0x90a80
movzbl (%rax,%rcx), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x3c3ef
movq -0x18(%rbp), %rdi
callq 0x4d7d0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
subl 0x671bc(%rip), %eax     # 0xa35b4
subl $0x27, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3c400
movq -0x20(%rbp), %rax
movq 0xc8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xc8(%rax)
movq -0x20(%rbp), %rax
movq 0xd8(%rax), %rax
movl -0x2c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %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_reg_alloc
JEMALLOC_INLINE_C void *
arena_run_reg_alloc(arena_run_t *run, arena_bin_info_t *bin_info)
{
	void *ret;
	size_t regind;
	arena_chunk_map_misc_t *miscelm;
	void *rpages;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x48(%rbp)
movq %rsi, -0x50(%rbp)
jmp 0x3c912
jmp 0x3c914
jmp 0x3c916
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movq -0x50(%rbp), %rsi
addq $0x28, %rsi
callq 0x4b470
movl %eax, %eax
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
subq $0x18, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
leaq 0x67750(%rip), %rcx     # 0xa40b0
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x6772f(%rip), %rcx     # 0xa40b0
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
addq 0x6760a(%rip), %rcx     # 0xa3fa8
subq %rcx, %rax
movl $0x60, %ecx
xorl %edx, %edx
divq %rcx
addq 0x675ee(%rip), %rax     # 0xa3fa0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0xc, %rcx
addq %rcx, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq -0x50(%rbp), %rcx
movl 0x38(%rcx), %ecx
addq %rcx, %rax
movq -0x50(%rbp), %rcx
movq 0x10(%rcx), %rcx
imulq -0x60(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x58(%rbp), %rax
addq $0x70, %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_malloc_hard
static void *
arena_bin_malloc_hard(tsdn_t *tsdn, arena_t *arena, arena_bin_t *bin)
{
	szind_t binind;
	arena_bin_info_t *bin_info;
	arena_run_t *run;

	binind = arena_bin_index(arena, bin);
	bin_info = &arena_bin_info[binind];
	bin->runcur = NULL;
	run = arena_bin_nonfull_run_get(tsdn, arena, bin);
	if (bin->runcur != NULL && bin->runcur->nfree > 0) {
		/*
		 * Another thread updated runcur while this one ran without the
		 * bin lock in arena_bin_nonfull_run_get().
		 */
		void *ret;
		assert(bin->runcur->nfree > 0);
		ret = arena_run_reg_alloc(bin->runcur, bin_info);
		if (run != NULL) {
			arena_chunk_t *chunk;

			/*
			 * arena_run_alloc_small() may have allocated run, or
			 * it may have pulled run from the bin's run tree.
			 * Therefore it is unsafe to make any assumptions about
			 * how run has previously been used, and
			 * arena_bin_lower_run() must be called, as if a region
			 * were just deallocated from the run.
			 */
			chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(run);
			if (run->nfree == bin_info->nregs) {
				arena_dalloc_bin_run(tsdn, arena, chunk, run,
				    bin);
			} else
				arena_bin_lower_run(arena, run, bin);
		}
		return (ret);
	}

	if (run == NULL)
		return (NULL);

	bin->runcur = run;

	assert(bin->runcur->nfree > 0);

	return (arena_run_reg_alloc(bin->runcur, bin_info));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4b580
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
leaq 0x66b80(%rip), %rax     # 0xa35c0
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4b5c0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x3cb0e
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
cmpl $0x0, 0x4(%rax)
jbe 0x3cb0e
jmp 0x3ca8f
jmp 0x3ca91
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x3c900
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x3cb04
movq -0x38(%rbp), %rax
leaq 0x675f8(%rip), %rcx     # 0xa40b0
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x30(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jne 0x3caf1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x4b720
jmp 0x3cb02
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4b7c0
jmp 0x3cb04
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3cb42
cmpq $0x0, -0x38(%rbp)
jne 0x3cb1f
movq $0x0, -0x8(%rbp)
jmp 0x3cb42
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x50(%rax)
jmp 0x3cb2d
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x3c900
movq %rax, -0x8(%rbp)
movq -0x8(%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: je_arena_alloc_junk_small
void
arena_alloc_junk_small(void *ptr, arena_bin_info_t *bin_info, bool zero)
{

	size_t redzone_size = bin_info->redzone_size;

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

// Assembly:
pushq %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 -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x11(%rbp)
je 0x3cbaa
movq -0x8(%rbp), %rdi
subq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0xa5, %esi
callq 0xb210
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
addq (%rax), %rdi
movq -0x20(%rbp), %rdx
movl $0xa5, %esi
callq 0xb210
jmp 0x3cbc4
movq -0x8(%rbp), %rdi
subq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movl $0xa5, %esi
callq 0xb210
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: je_arena_dalloc_junk_small
void
arena_dalloc_junk_small(void *ptr, arena_bin_info_t *bin_info)
{
	size_t redzone_size = bin_info->redzone_size;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3cc20
movq -0x8(%rbp), %rdi
subq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movl $0x5a, %esi
callq 0xb210
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_run_alloc_large
static arena_run_t *
arena_run_alloc_large(tsdn_t *tsdn, arena_t *arena, size_t size, bool zero)
{
	arena_chunk_t *chunk;
	arena_run_t *run;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x3d30d
jmp 0x3d30f
jmp 0x3d311
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movb -0x31(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x4d920
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x3d33e
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3d3de
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x45ee0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x3d3c5
movq -0x40(%rbp), %rcx
movq 0x66c3f(%rip), %rax     # 0xa3fa0
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq 0x66c34(%rip), %rax     # 0xa3fa8
imulq $0x60, -0x10(%rbp), %rcx
addq %rcx, %rax
xorl %ecx, %ecx
subq 0x66c1b(%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
movb -0x31(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x46000
testb $0x1, %al
jne 0x3d3b3
jmp 0x3d3bb
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3d3de
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movb -0x31(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x4d920
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)