LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_huge_malloc_stats_update
static void
arena_huge_malloc_stats_update(arena_t *arena, size_t usize)
{
	szind_t index = size2index(usize) - nlclasses - NBINS;

	cassert(config_stats);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x1000, -0x20(%rbp)    # imm = 0x1000
setbe %al
testb $0x1, %al
jne 0x3c5e9
jmp 0x3c615
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
subq $0x1, %rcx
shrq $0x3, %rcx
leaq 0x5267c(%rip), %rax     # 0x8ec80
movzbl (%rax,%rcx), %eax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl %eax, -0x14(%rbp)
jmp 0x3c621
movq -0x20(%rbp), %rdi
callq 0x4ca20
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl 0x65fa6(%rip), %eax     # 0xa25d0
subl $0x27, %eax
movl %eax, -0x34(%rbp)
jmp 0x3c632
movq -0x28(%rbp), %rax
movq 0x88(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x88(%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x80(%rax), %rcx
movq %rcx, 0x80(%rax)
movq -0x28(%rbp), %rax
movq 0xa0(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0xa0(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_chunk_alloc_huge_hard
static void *
arena_chunk_alloc_huge_hard(arena_t *arena, chunk_hooks_t *chunk_hooks,
    size_t usize, size_t alignment, bool *zero, size_t csize)
{
	void *ret;
	bool commit = true;

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

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %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)
movb $0x1, -0x39(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
xorl %eax, %eax
movl %eax, %edx
leaq -0x39(%rbp), %rax
movq %rax, (%rsp)
callq 0x50db0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x3c75b
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x44ad0
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rdx
shrq $0xc, %rdx
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0xe0(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3c0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_chunk_dalloc_huge
void
arena_chunk_dalloc_huge(arena_t *arena, void *chunk, size_t usize)
{
	chunk_hooks_t chunk_hooks = CHUNK_HOOKS_INITIALIZER;
	size_t csize;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10250
movq -0x18(%rbp), %rax
leaq 0x65f61(%rip), %rcx     # 0xa2730
addq (%rcx), %rax
leaq 0x65f57(%rip), %rcx     # 0xa2730
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3c870
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rdi
callq 0x3c960
movq -0x18(%rbp), %rdx
shrq $0xc, %rdx
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0xe0(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x58(%rbp), %rcx
leaq -0x50(%rbp), %rsi
movl $0x1, %r8d
callq 0x50ea0
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3c0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_huge_dalloc_stats_update
static void
arena_huge_dalloc_stats_update(arena_t *arena, size_t usize)
{
	szind_t index = size2index(usize) - nlclasses - NBINS;

	cassert(config_stats);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x1000, -0x20(%rbp)    # imm = 0x1000
setbe %al
testb $0x1, %al
jne 0x3c899
jmp 0x3c8c5
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
subq $0x1, %rcx
shrq $0x3, %rcx
leaq 0x523cc(%rip), %rax     # 0x8ec80
movzbl (%rax,%rcx), %eax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl %eax, -0x14(%rbp)
jmp 0x3c8d1
movq -0x20(%rbp), %rdi
callq 0x4ca20
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl 0x65cf6(%rip), %eax     # 0xa25d0
subl $0x27, %eax
movl %eax, -0x34(%rbp)
jmp 0x3c8e2
movq -0x28(%rbp), %rax
movq 0x90(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x90(%rax)
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x80(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x80(%rax)
movq -0x28(%rbp), %rax
movq 0xa0(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0xa0(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_chunk_ralloc_huge_similar
void
arena_chunk_ralloc_huge_similar(arena_t *arena, void *chunk, size_t oldsize,
    size_t usize)
{

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

	malloc_mutex_lock(&arena->lock);
	if (config_stats)
		arena_huge_ralloc_stats_update(arena, oldsize, usize);
	if (oldsize < usize) {
		size_t udiff = usize - oldsize;
		arena->nactive += udiff >> LG_PAGE;
		if (config_stats)
			stats_cactive_add(udiff);
	} else {
		size_t udiff = oldsize - usize;
		arena->nactive -= udiff >> LG_PAGE;
		if (config_stats)
			stats_cactive_sub(udiff);
	}
	malloc_mutex_unlock(&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)
jmp 0x3c9aa
jmp 0x3c9ac
jmp 0x3c9ae
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3ca50
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x3ca07
movq -0x20(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
shrq $0xc, %rcx
movq -0x8(%rbp), %rax
addq 0xe0(%rax), %rcx
movq %rcx, 0xe0(%rax)
movq -0x28(%rbp), %rdi
callq 0x3c770
jmp 0x3ca39
movq -0x18(%rbp), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
shrq $0xc, %rdx
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0xe0(%rax)
movq -0x30(%rbp), %rdi
callq 0x3c960
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_chunk_ralloc_huge_shrink
void
arena_chunk_ralloc_huge_shrink(arena_t *arena, void *chunk, size_t oldsize,
    size_t usize)
{
	size_t udiff = oldsize - usize;
	size_t cdiff = CHUNK_CEILING(oldsize) - CHUNK_CEILING(usize);

	malloc_mutex_lock(&arena->lock);
	if (config_stats) {
		arena_huge_ralloc_stats_update(arena, oldsize, usize);
		if (cdiff != 0) {
			arena->stats.mapped -= cdiff;
			stats_cactive_sub(udiff);
		}
	}
	arena->nactive -= 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(arena, &chunk_hooks, nchunk, cdiff, true);
	}
	malloc_mutex_unlock(&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 -0x18(%rbp), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
leaq 0x65c71(%rip), %rcx     # 0xa2730
addq (%rcx), %rax
leaq 0x65c67(%rip), %rcx     # 0xa2730
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq -0x20(%rbp), %rcx
leaq 0x65c52(%rip), %rdx     # 0xa2730
addq (%rdx), %rcx
leaq 0x65c48(%rip), %rdx     # 0xa2730
movq (%rdx), %rdx
xorq $-0x1, %rdx
andq %rdx, %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3ca50
cmpq $0x0, -0x30(%rbp)
je 0x3cb3a
movq -0x30(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rdi
callq 0x3c960
movq -0x28(%rbp), %rdx
shrq $0xc, %rdx
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0xe0(%rax)
cmpq $0x0, -0x30(%rbp)
je 0x3cbb3
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10250
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
leaq 0x65bb3(%rip), %rdx     # 0xa2730
addq (%rdx), %rcx
leaq 0x65ba9(%rip), %rdx     # 0xa2730
movq (%rdx), %rdx
xorq $-0x1, %rdx
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
movq -0x70(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x68(%rbp), %rsi
movl $0x1, %r8d
callq 0x50ea0
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3c0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_chunk_ralloc_huge_expand_hard
static bool
arena_chunk_ralloc_huge_expand_hard(arena_t *arena, chunk_hooks_t *chunk_hooks,
    void *chunk, size_t oldsize, size_t usize, bool *zero, void *nchunk,
    size_t udiff, size_t cdiff)
{
	bool err;
	bool commit = true;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
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 0x10(%rbp), %rdx
movq 0x20(%rbp), %rcx
leaq 0x65901(%rip), %rax     # 0xa2728
movq (%rax), %r8
movq -0x30(%rbp), %r9
leaq -0x32(%rbp), %rax
movq %rax, (%rsp)
callq 0x50db0
cmpq $0x0, %rax
sete %al
andb $0x1, %al
movb %al, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
je 0x3ceaa
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3a0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x44c30
movq 0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x30(%rax)
movq 0x18(%rbp), %rdx
shrq $0xc, %rdx
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0xe0(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3c0
jmp 0x3cf1f
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x6586f(%rip), %rcx     # 0xa2730
addq (%rcx), %rsi
leaq 0x65865(%rip), %rcx     # 0xa2730
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rsi
movq 0x10(%rbp), %rdx
movq 0x20(%rbp), %rcx
movq -0x8(%rbp), %r8
movl (%r8), %r9d
movl $0x1, %r8d
callq *%rax
testb $0x1, %al
jne 0x3cef2
jmp 0x3cf1d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x10(%rbp), %rdx
movq 0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movb (%rax), %al
movl $0x1, %r9d
andb $0x1, %al
movzbl %al, %r8d
callq 0x51470
movb $0x1, -0x31(%rbp)
jmp 0x3cf1f
movb -0x31(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_lg_dirty_mult_get
ssize_t
arena_lg_dirty_mult_get(arena_t *arena)
{
	ssize_t lg_dirty_mult;

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

	return (lg_dirty_mult);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3a0
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3c0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_lg_dirty_mult_set
bool
arena_lg_dirty_mult_set(arena_t *arena, ssize_t lg_dirty_mult)
{

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

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

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3cfe0
testb $0x1, %al
jne 0x3cf93
movb $0x1, -0x1(%rbp)
jmp 0x3cfc9
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3a0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xd0(%rax)
movq -0x10(%rbp), %rdi
callq 0x3d010
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3c0
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/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_maybe_purge
void
arena_maybe_purge(arena_t *arena)
{

	/* Don't purge if the option is disabled. */
	if (arena->lg_dirty_mult < 0)
		return;
	/* Don't recursively purge. */
	if (arena->purging)
		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(arena, false);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
jge 0x3d02c
jmp 0x3d098
movq -0x8(%rbp), %rax
testb $0x1, 0xd8(%rax)
je 0x3d03b
jmp 0x3d098
jmp 0x3d03d
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xd0(%rcx), %rcx
shrq %cl, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x656d3(%rip), %rcx     # 0xa2738
cmpq (%rcx), %rax
jae 0x3d078
leaq 0x656c7(%rip), %rax     # 0xa2738
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rax
cmpq -0x10(%rbp), %rax
ja 0x3d08b
jmp 0x3d098
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3d0a0
jmp 0x3d03d
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_purge
static void
arena_purge(arena_t *arena, bool all)
{
	chunk_hooks_t chunk_hooks = chunk_hooks_get(arena);
	size_t npurge, npurgeable, 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((arena->nactive >> arena->lg_dirty_mult) < arena->ndirty || all);

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

	npurge = arena_compute_npurge(arena, all);
	qr_new(&purge_runs_sentinel, rd_link);
	extent_node_dirty_linkage_init(&purge_chunks_sentinel);

	npurgeable = arena_stash_dirty(arena, &chunk_hooks, all, npurge,
	    &purge_runs_sentinel, &purge_chunks_sentinel);
	assert(npurgeable >= npurge);
	npurged = arena_purge_stashed(arena, &chunk_hooks, &purge_runs_sentinel,
	    &purge_chunks_sentinel);
	assert(npurged == npurgeable);
	arena_unstash_purged(arena, &chunk_hooks, &purge_runs_sentinel,
	    &purge_chunks_sentinel);

	arena->purging = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x50010
movq -0x8(%rbp), %rax
movb $0x1, 0xd8(%rax)
jmp 0x3d0d1
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x44d60
movq %rax, -0x50(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x3c020
movq -0x8(%rbp), %rdi
movb -0x9(%rbp), %al
movq -0x50(%rbp), %rcx
leaq -0x48(%rbp), %rsi
leaq -0x70(%rbp), %r8
leaq -0xd8(%rbp), %r9
andb $0x1, %al
movzbl %al, %edx
callq 0x44df0
movq %rax, -0x58(%rbp)
jmp 0x3d13c
movq -0x8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x70(%rbp), %rdx
leaq -0xd8(%rbp), %rcx
callq 0x451e0
movq %rax, -0x60(%rbp)
jmp 0x3d15a
movq -0x8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x70(%rbp), %rdx
leaq -0xd8(%rbp), %rcx
callq 0x45850
movq -0x8(%rbp), %rax
movb $0x0, 0xd8(%rax)
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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;
	unsigned regind;
	arena_chunk_map_misc_t *miscelm;
	void *rpages;

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

	regind = 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 0x3d3c2
jmp 0x3d3c4
jmp 0x3d3c6
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movq -0x50(%rbp), %rsi
addq $0x28, %rsi
callq 0x4a700
movl %eax, -0x5c(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
subq $0x10, %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 0x65323(%rip), %rcx     # 0xa2730
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 0x65302(%rip), %rcx     # 0xa2730
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
addq 0x65195(%rip), %rcx     # 0xa25e0
subq %rcx, %rax
movl $0x60, %ecx
xorl %edx, %edx
divq %rcx
addq 0x65179(%rip), %rax     # 0xa25d8
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 0x58(%rcx), %ecx
addq %rcx, %rax
movq -0x50(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x5c(%rbp), %edx
imulq %rdx, %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
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_bin_malloc_hard
static void *
arena_bin_malloc_hard(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(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(arena, chunk, run, bin);
			else
				arena_bin_lower_run(arena, chunk, 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 $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4a8f0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x64234(%rip), %rax     # 0xa1720
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4a930
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x3d5b6
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $0x0, 0x4(%rax)
jbe 0x3d5b6
jmp 0x3d537
jmp 0x3d539
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x3d3b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3d5ac
movq -0x30(%rbp), %rax
leaq 0x651d0(%rip), %rcx     # 0xa2730
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jne 0x3d595
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x4aa70
jmp 0x3d5aa
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x4aaf0
jmp 0x3d5ac
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3d5ea
cmpq $0x0, -0x30(%rbp)
jne 0x3d5c7
movq $0x0, -0x8(%rbp)
jmp 0x3d5ea
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x3d5d5
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x3d3b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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)
{

	if (zero) {
		size_t redzone_size = bin_info->redzone_size;
		memset((void *)((uintptr_t)ptr - redzone_size), 0xa5,
		    redzone_size);
		memset((void *)((uintptr_t)ptr + bin_info->reg_size), 0xa5,
		    redzone_size);
	} else {
		memset((void *)((uintptr_t)ptr - bin_info->redzone_size), 0xa5,
		    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)
testb $0x1, -0x11(%rbp)
je 0x3d65a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
subq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0xa5, %esi
callq 0x10250
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
addq (%rax), %rdi
movq -0x20(%rbp), %rdx
movl $0xa5, %esi
callq 0x10250
jmp 0x3d678
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
subq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movl $0xa5, %esi
callq 0x10250
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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), 0x5a,
	    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 0x3d6d0
movq -0x8(%rbp), %rdi
subq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movl $0x5a, %esi
callq 0x10250
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_redzones_validate
static void
arena_redzones_validate(void *ptr, arena_bin_info_t *bin_info, bool reset)
{
	bool error = false;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
leaq 0x63faf(%rip), %rax     # 0xa16a1
testb $0x1, (%rax)
je 0x3d7ef
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0x3d77c
movq -0x8(%rbp), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xa5, %eax
je 0x3d76c
movb $0x1, -0x12(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
xorl %edx, %edx
movzbl (%rax), %r8d
callq 0x4c9a0
testb $0x1, -0x11(%rbp)
je 0x3d76a
movq -0x38(%rbp), %rax
movb $-0x5b, (%rax)
jmp 0x3d76c
jmp 0x3d76e
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3d71a
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x3d7ed
movq -0x8(%rbp), %rax
addq -0x20(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xa5, %eax
je 0x3d7dd
movb $0x1, -0x12(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movl $0x1, %edx
movzbl (%rax), %r8d
callq 0x4c9a0
testb $0x1, -0x11(%rbp)
je 0x3d7db
movq -0x40(%rbp), %rax
movb $-0x5b, (%rax)
jmp 0x3d7dd
jmp 0x3d7df
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3d784
jmp 0x3d7ef
leaq 0x63eaa(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x3d806
testb $0x1, -0x12(%rbp)
je 0x3d806
callq 0x10070
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_quarantine_junk_small
void
arena_quarantine_junk_small(void *ptr, size_t usize)
{
	szind_t binind;
	arena_bin_info_t *bin_info;
	cassert(config_fill);
	assert(opt_junk_free);
	assert(opt_quarantine);
	assert(usize <= SMALL_MAXCLASS);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
jmp 0x3d822
jmp 0x3d824
jmp 0x3d826
jmp 0x3d828
jmp 0x3d82a
jmp 0x3d82c
jmp 0x3d82e
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x1000, -0x20(%rbp)    # imm = 0x1000
setbe %al
testb $0x1, %al
jne 0x3d847
jmp 0x3d873
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
subq $0x1, %rcx
shrq $0x3, %rcx
leaq 0x5141e(%rip), %rax     # 0x8ec80
movzbl (%rax,%rcx), %eax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl %eax, -0x14(%rbp)
jmp 0x3d87f
movq -0x20(%rbp), %rdi
callq 0x4ca20
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, %ecx
leaq 0x63e8f(%rip), %rax     # 0xa1720
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl $0x1, %edx
callq 0x3d6d0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_run_alloc_large
static arena_run_t *
arena_run_alloc_large(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(arena);
	if (chunk != NULL) {
		run = &arena_miscelm_get(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 $0x40, %rsp
movb %dl, %al
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
jmp 0x3e069
jmp 0x3e06b
jmp 0x3e06d
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x4cb40
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x3e09a
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3e136
movq -0x20(%rbp), %rdi
callq 0x45b90
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x3e11d
movq -0x38(%rbp), %rcx
movq 0x6451f(%rip), %rax     # 0xa25d8
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq 0x64514(%rip), %rax     # 0xa25e0
imulq $0x60, -0x10(%rbp), %rcx
addq %rcx, %rax
xorl %ecx, %ecx
subq 0x644fb(%rip), %rcx     # 0xa25d8
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x28(%rbp), %rdx
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x45c10
testb $0x1, %al
jne 0x3e10b
jmp 0x3e113
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3e136
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x4cb40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_dalloc_bin
void
arena_dalloc_bin(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(chunk, rpages_ind)->run;
	bin = &arena->bins[run->binind];
	malloc_mutex_lock(&bin->lock);
	arena_dalloc_bin_locked_impl(arena, chunk, ptr, bitselm, false);
	malloc_mutex_unlock(&bin->lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x68(%rbp)
movq %rsi, -0x70(%rbp)
movq %rdx, -0x78(%rbp)
movq %rcx, -0x80(%rbp)
movq %r8, -0x88(%rbp)
movq -0x80(%rbp), %rax
movq -0x70(%rbp), %rdx
movq -0x80(%rbp), %rcx
movq %rdx, -0x50(%rbp)
movq %rcx, -0x58(%rbp)
movq -0x50(%rbp), %rdx
movq -0x58(%rbp), %rcx
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq -0x30(%rbp), %rdx
movq -0x38(%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 $0x68, %rcx
movq -0x10(%rbp), %rdx
subq 0x6277f(%rip), %rdx     # 0xa25d8
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x60(%rbp)
movq -0x60(%rbp), %rcx
shrq $0xd, %rcx
subq %rcx, %rax
movq %rax, -0xa0(%rbp)
movq -0x70(%rbp), %rcx
movq -0xa0(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
addq 0x62741(%rip), %rax     # 0xa25e0
imulq $0x60, -0x48(%rbp), %rcx
addq %rcx, %rax
xorl %ecx, %ecx
subq 0x62728(%rip), %rcx     # 0xa25d8
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
addq $0x10, %rax
movq %rax, -0x90(%rbp)
movq -0x68(%rbp), %rax
addq $0x450, %rax            # imm = 0x450
movq -0x90(%rbp), %rcx
movl (%rcx), %ecx
imulq $0xe0, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rdi
callq 0x3c3a0
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x88(%rbp), %rcx
xorl %r8d, %r8d
callq 0x3fb80
movq -0x98(%rbp), %rdi
callq 0x3c3c0
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_dalloc_small
void
arena_dalloc_small(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(chunk, pageind);
	arena_dalloc_bin(arena, chunk, ptr, pageind, bitselm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x68, %rax
movq -0x10(%rbp), %rcx
subq 0x6266d(%rip), %rcx     # 0xa25d8
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x3fde0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_dss_prec_get
dss_prec_t
arena_dss_prec_get(arena_t *arena)
{
	dss_prec_t ret;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3a0
movq -0x8(%rbp), %rax
movl 0xc0(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3c0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_dss_prec_set
bool
arena_dss_prec_set(arena_t *arena, dss_prec_t dss_prec)
{

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3a0
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc0(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c3c0
xorl %eax, %eax
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/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 (!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)
movq -0x10(%rbp), %rdi
callq 0x3cfe0
testb $0x1, %al
jne 0x42d0f
movb $0x1, -0x1(%rbp)
jmp 0x42d23
movq -0x10(%rbp), %rsi
leaq 0x5f8ae(%rip), %rdi     # 0xa25c8
callq 0x42d30
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_prefork
void
arena_prefork(arena_t *arena)
{
	unsigned i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x643d0
movq -0x8(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x643d0
movq -0x8(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
callq 0x643d0
movq -0x8(%rbp), %rdi
addq $0x3f0, %rdi            # imm = 0x3F0
callq 0x643d0
movl $0x0, -0xc(%rbp)
cmpl $0x27, -0xc(%rbp)
jae 0x4497e
movq -0x8(%rbp), %rdi
addq $0x450, %rdi            # imm = 0x450
movl -0xc(%rbp), %eax
imulq $0xe0, %rax, %rax
addq %rax, %rdi
callq 0x643d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x44950
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_postfork_parent
void
arena_postfork_parent(arena_t *arena)
{
	unsigned i;

	for (i = 0; i < NBINS; i++)
		malloc_mutex_postfork_parent(&arena->bins[i].lock);
	malloc_mutex_postfork_parent(&arena->node_cache_mtx);
	malloc_mutex_postfork_parent(&arena->chunks_mtx);
	malloc_mutex_postfork_parent(&arena->huge_mtx);
	malloc_mutex_postfork_parent(&arena->lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x27, -0xc(%rbp)
jae 0x449d1
movq -0x8(%rbp), %rdi
addq $0x450, %rdi            # imm = 0x450
movl -0xc(%rbp), %eax
imulq $0xe0, %rax, %rax
addq %rax, %rdi
callq 0x64410
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x449a3
movq -0x8(%rbp), %rdi
addq $0x3f0, %rdi            # imm = 0x3F0
callq 0x64410
movq -0x8(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
callq 0x64410
movq -0x8(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x64410
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x64410
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_postfork_child
void
arena_postfork_child(arena_t *arena)
{
	unsigned i;

	for (i = 0; i < NBINS; i++)
		malloc_mutex_postfork_child(&arena->bins[i].lock);
	malloc_mutex_postfork_child(&arena->node_cache_mtx);
	malloc_mutex_postfork_child(&arena->chunks_mtx);
	malloc_mutex_postfork_child(&arena->huge_mtx);
	malloc_mutex_postfork_child(&arena->lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x27, -0xc(%rbp)
jae 0x44a61
movq -0x8(%rbp), %rdi
addq $0x450, %rdi            # imm = 0x450
movl -0xc(%rbp), %eax
imulq $0xe0, %rax, %rax
addq %rax, %rdi
callq 0x64450
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x44a33
movq -0x8(%rbp), %rdi
addq $0x3f0, %rdi            # imm = 0x3F0
callq 0x64450
movq -0x8(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
callq 0x64450
movq -0x8(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x64450
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x64450
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_huge_malloc_stats_update_undo
static void
arena_huge_malloc_stats_update_undo(arena_t *arena, size_t usize)
{
	szind_t index = size2index(usize) - nlclasses - NBINS;

	cassert(config_stats);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x1000, -0x20(%rbp)    # imm = 0x1000
setbe %al
testb $0x1, %al
jne 0x44af9
jmp 0x44b25
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
subq $0x1, %rcx
shrq $0x3, %rcx
leaq 0x4a16c(%rip), %rax     # 0x8ec80
movzbl (%rax,%rcx), %eax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl %eax, -0x14(%rbp)
jmp 0x44b31
movq -0x20(%rbp), %rdi
callq 0x4ca20
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl 0x5da96(%rip), %eax     # 0xa25d0
subl $0x27, %eax
movl %eax, -0x34(%rbp)
jmp 0x44b42
movq -0x28(%rbp), %rax
movq 0x88(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x88(%rax)
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x80(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x80(%rax)
movq -0x28(%rbp), %rax
movq 0xa0(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0xa0(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_compute_npurge
static size_t
arena_compute_npurge(arena_t *arena, bool all)
{
	size_t npurge;

	/*
	 * Compute the minimum number of pages that this thread should try to
	 * purge.
	 */
	if (!all) {
		size_t threshold = (arena->nactive >> arena->lg_dirty_mult);
		threshold = threshold < chunk_npages ? chunk_npages : threshold;

		npurge = arena->ndirty - threshold;
	} else
		npurge = arena->ndirty;

	return (npurge);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x44dd8
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xd0(%rcx), %rcx
shrq %cl, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
leaq 0x5d99a(%rip), %rcx     # 0xa2738
cmpq (%rcx), %rax
jae 0x44db3
leaq 0x5d98e(%rip), %rax     # 0xa2738
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x44dbb
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x44de7
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_chunk_alloc
static arena_chunk_t *
arena_chunk_alloc(arena_t *arena)
{
	arena_chunk_t *chunk;

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

	/* Insert the run into the runs_avail tree. */
	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 -0x10(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x45bb9
movq -0x10(%rbp), %rdi
callq 0x45c60
movq %rax, -0x18(%rbp)
jmp 0x45bd9
movq -0x10(%rbp), %rdi
callq 0x45ca0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x45bd7
movq $0x0, -0x8(%rbp)
jmp 0x45c06
jmp 0x45bd9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x5c9f0(%rip), %rdx     # 0xa25d8
leaq 0x5cb49(%rip), %rax     # 0xa2738
movq (%rax), %rcx
subq 0x5c9df(%rip), %rcx     # 0xa25d8
callq 0x461f0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_chunk_init_spare
static arena_chunk_t *
arena_chunk_init_spare(arena_t *arena)
{
	arena_chunk_t *chunk;

	assert(arena->spare != NULL);

	chunk = arena->spare;
	arena->spare = NULL;

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

	return (chunk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x45c6a
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0xc8(%rax)
jmp 0x45c8a
jmp 0x45c8c
jmp 0x45c8e
jmp 0x45c90
jmp 0x45c92
jmp 0x45c94
jmp 0x45c96
jmp 0x45c98
jmp 0x45c9a
movq -0x10(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_chunk_alloc_internal
static arena_chunk_t *
arena_chunk_alloc_internal(arena_t *arena, bool *zero, bool *commit)
{
	arena_chunk_t *chunk;
	chunk_hooks_t chunk_hooks = CHUNK_HOOKS_INITIALIZER;

	chunk = chunk_alloc_cache(arena, &chunk_hooks, NULL, chunksize,
	    chunksize, zero, true);
	if (chunk != NULL) {
		if (arena_chunk_register(arena, chunk, *zero)) {
			chunk_dalloc_cache(arena, &chunk_hooks, chunk,
			    chunksize, true);
			return (NULL);
		}
		*commit = true;
	}
	if (chunk == NULL) {
		chunk = arena_chunk_alloc_internal_hard(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 $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10250
movq -0x10(%rbp), %rdi
leaq 0x5c499(%rip), %rax     # 0xa2728
movq (%rax), %rcx
leaq 0x5c48f(%rip), %rax     # 0xa2728
movq (%rax), %r8
movq -0x18(%rbp), %r9
leaq -0x60(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, (%rsp)
callq 0x50480
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4630f
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x46380
testb $0x1, %al
jne 0x462dd
jmp 0x46308
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x5c43c(%rip), %rax     # 0xa2728
movq (%rax), %rcx
leaq -0x60(%rbp), %rsi
movl $0x1, %r8d
callq 0x50ea0
movq $0x0, -0x8(%rbp)
jmp 0x4636b
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
cmpq $0x0, -0x28(%rbp)
jne 0x4632f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x60(%rbp), %rsi
callq 0x463f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x46363
leaq 0x5c3eb(%rip), %rax     # 0xa2728
movq (%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
movq 0x5c285(%rip), %rcx     # 0xa25d8
shlq $0xc, %rcx
movq -0x10(%rbp), %rax
addq 0x50(%rax), %rcx
movq %rcx, 0x50(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)