LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/bitmap.c
// Function: je_bitmap_init
void
bitmap_init(bitmap_t *bitmap, const bitmap_info_t *binfo)
{
	size_t extra;
	unsigned i;

	/*
	 * Bits are actually inverted with regard to the external bitmap
	 * interface, so the bitmap starts out with all 1 bits, except for
	 * trailing unused bits (if any).  Note that each group uses bit 0 to
	 * correspond to the first logical bit in the group, so extra bits
	 * are the most significant bits of the last group.
	 */
	memset(bitmap, 0xffU, binfo->levels[binfo->nlevels].group_offset <<
	    LG_SIZEOF_BITMAP);
	extra = (BITMAP_GROUP_NBITS - (binfo->nbits & BITMAP_GROUP_NBITS_MASK))
	    & BITMAP_GROUP_NBITS_MASK;
	if (extra != 0)
		bitmap[binfo->levels[1].group_offset - 1] >>= extra;
	for (i = 1; i < binfo->nlevels; i++) {
		size_t group_count = binfo->levels[i].group_offset -
		    binfo->levels[i-1].group_offset;
		extra = (BITMAP_GROUP_NBITS - (group_count &
		    BITMAP_GROUP_NBITS_MASK)) & BITMAP_GROUP_NBITS_MASK;
		if (extra != 0)
			bitmap[binfo->levels[i+1].group_offset - 1] >>= extra;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %eax
movq 0x10(%rsi,%rax,8), %rdx
shlq $0x3, %rdx
movl $0xff, %esi
callq 0x10270
xorl %ecx, %ecx
subl (%rbx), %ecx
andl $0x3f, %ecx
je 0x2e13c
movq 0x18(%rbx), %rax
shrq %cl, -0x8(%r14,%rax,8)
movl 0x8(%rbx), %eax
cmpq $0x2, %rax
jb 0x2e169
decq %rax
xorl %edx, %edx
movl 0x10(%rbx,%rdx,8), %ecx
subl 0x18(%rbx,%rdx,8), %ecx
andl $0x3f, %ecx
je 0x2e161
movq 0x20(%rbx,%rdx,8), %rsi
shrq %cl, -0x8(%r14,%rsi,8)
incq %rdx
cmpq %rdx, %rax
jne 0x2e14a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk.c
// Function: chunk_alloc_default
static void *
chunk_alloc_default(void *new_addr, size_t size, size_t alignment, bool *zero,
    bool *commit, unsigned arena_ind)
{
	void *ret;
	arena_t *arena;

	arena = chunk_arena_get(arena_ind);
	ret = chunk_alloc_core(arena, new_addr, size, alignment, zero,
	    commit, arena->dss_prec);
	if (ret == NULL)
		return (NULL);
	if (config_valgrind)
		JEMALLOC_VALGRIND_MAKE_MEM_UNDEFINED(ret, size);

	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r12
movl %r9d, %edi
callq 0x2f13f
movq %rax, %rbp
movl 0xc0(%rax), %eax
movl %eax, 0x1c(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq $0x0, 0x30(%rsi)
leaq 0x2e0(%rbp), %rdx
leaq 0x350(%rbp), %rcx
subq $0x8, %rsp
movq %rbp, %rdi
xorl %r8d, %r8d
movq %r12, %r9
pushq $0x1
pushq %r15
pushq %r14
pushq %r13
movq %rbx, 0x30(%rsp)
pushq %rbx
callq 0x2e66b
addq $0x30, %rsp
testq %rax, %rax
je 0x2e21d
movq %rax, %rbx
leaq 0x2c482(%rip), %rax     # 0x5a684
cmpb $0x1, (%rax)
je 0x2e2b2
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, 0x10(%rsp)
movl 0x1c(%rsp), %eax
cmpl $0x1, %eax
movq %r14, %r15
jne 0x2e257
movq %rbp, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
movq %r13, %rcx
movq %r15, %r8
movq 0x10(%rsp), %r9
movl %eax, %r14d
callq 0x2f242
movq %rax, %rbx
movl %r14d, %eax
testq %rbx, %rbx
jne 0x2e1fb
testq %r12, %r12
je 0x2e289
cmpl $0x2, %eax
jne 0x2e285
movq %rbp, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
movq %r13, %rcx
movq %r15, %r8
movq 0x10(%rsp), %r9
callq 0x2f242
testq %rax, %rax
jne 0x2e1f8
xorl %ebx, %ebx
jmp 0x2e20b
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r15, %rdx
movq 0x10(%rsp), %rcx
movl %eax, %r14d
callq 0x2f494
movq %rax, %rbx
movl %r14d, %eax
testq %rbx, %rbx
jne 0x2e1fb
jmp 0x2e25c
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x3e7a6
jmp 0x2e20b
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/rtree.h
// Function: je_rtree_set
JEMALLOC_INLINE bool
rtree_set(rtree_t *rtree, uintptr_t key, const extent_node_t *val)
{
	uintptr_t subkey;
	unsigned i, start_level;
	rtree_node_elm_t *node, *child;

	start_level = rtree_start_level(rtree, key);

	node = rtree_subtree_read(rtree, start_level);
	if (node == NULL)
		return (true);
	for (i = start_level; /**/; i++, node = child) {
		subkey = rtree_subkey(rtree, key, i);
		if (i == rtree->height - 1) {
			/*
			 * node is a leaf, so it contains values rather than
			 * child pointers.
			 */
			rtree_val_write(rtree, &node[subkey], val);
			return (false);
		}
		assert(i + 1 < rtree->height);
		child = rtree_child_read(rtree, &node[subkey], i);
		if (child == NULL)
			return (true);
	}
	not_reached();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x2e582
bsrq %r14, %rax
shrq $0x4, %rax
leaq 0x2d1b0(%rip), %rcx     # 0x5b640
movl 0x14(%rcx,%rax,4), %r15d
movl %r15d, %eax
shlq $0x4, %rax
leaq 0x2d19d(%rip), %r12     # 0x5b640
leaq (%rax,%r12), %r13
addq $0x28, %r13
movq (%r13), %rax
cmpq $0x1, %rax
ja 0x2e4bd
xorl %eax, %eax
lock
xaddq %rax, (%r13)
cmpq $0x1, %rax
jbe 0x2e591
movb $0x1, %bpl
testq %rax, %rax
je 0x2e502
xorl %ecx, %ecx
subb 0xc(%r13), %cl
movq %r14, %rsi
shrq %cl, %rsi
movb 0x8(%r13), %cl
movq $-0x1, %rdx
shlq %cl, %rdx
notq %rdx
andq %rsi, %rdx
movl 0x2d15b(%rip), %ecx     # 0x5b650
decl %ecx
cmpl %ecx, %r15d
jne 0x2e513
xchgq %rbx, (%rax,%rdx,8)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq (%rax,%rdx,8), %rsi
movq (%rsi), %rax
cmpq $0x1, %rax
ja 0x2e527
xorl %eax, %eax
lock
xaddq %rax, (%rsi)
cmpq $0x1, %rax
jbe 0x2e575
testq %rax, %rax
je 0x2e502
leal 0x1(%r15), %esi
movq %rsi, %rdx
shlq $0x4, %rdx
movb 0x34(%rdx,%r12), %dil
xorl %ecx, %ecx
subb %dil, %cl
movq %r14, %rdi
shrq %cl, %rdi
movb 0x30(%rdx,%r12), %cl
movq $-0x1, %rdx
shlq %cl, %rdx
notq %rdx
andq %rdi, %rdx
movl 0x2d0e8(%rip), %ecx     # 0x5b650
addl $-0x2, %ecx
cmpl %ecx, %r15d
movl %esi, %r15d
jne 0x2e513
jmp 0x2e4fc
movq %r12, %rdi
movl %r15d, %edx
callq 0x399af
jmp 0x2e52d
movl 0x2d0c7(%rip), %r15d    # 0x5b650
decl %r15d
jmp 0x2e495
leaq 0x2d0a8(%rip), %rdi     # 0x5b640
movl %r15d, %esi
callq 0x39954
jmp 0x2e4c7
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk.c
// Function: je_chunk_alloc_base
void *
chunk_alloc_base(size_t size)
{
	void *ret;
	bool zero, commit;

	/*
	 * Directly call chunk_alloc_mmap() rather than chunk_alloc_core()
	 * because it's critical that chunk_alloc_base() return untouched
	 * demand-zeroed virtual memory.
	 */
	zero = true;
	commit = true;
	ret = chunk_alloc_mmap(size, chunksize, &zero, &commit);
	if (ret == NULL)
		return (NULL);
	if (config_valgrind)
		JEMALLOC_VALGRIND_MAKE_MEM_UNDEFINED(ret, size);

	return (ret);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, %al
leaq 0x7(%rsp), %rdx
movb %al, (%rdx)
leaq 0x6(%rsp), %rcx
movb %al, (%rcx)
movq 0x2d0de(%rip), %rsi     # 0x5b6a8
callq 0x2f494
movq %rax, %r14
testq %rax, %rax
je 0x2e5e3
leaq 0x2c0a6(%rip), %rax     # 0x5a684
cmpb $0x1, (%rax)
je 0x2e5ee
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3e7a6
jmp 0x2e5e3
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk.c
// Function: je_chunk_alloc_cache
void *
chunk_alloc_cache(arena_t *arena, chunk_hooks_t *chunk_hooks, void *new_addr,
    size_t size, size_t alignment, bool *zero, bool dalloc_node)
{
	void *ret;
	bool commit;

	assert(size != 0);
	assert((size & chunksize_mask) == 0);
	assert(alignment != 0);
	assert((alignment & chunksize_mask) == 0);

	commit = true;
	ret = chunk_recycle(arena, chunk_hooks, &arena->chunks_szad_cached,
	    &arena->chunks_ad_cached, true, new_addr, size, alignment, zero,
	    &commit, dalloc_node);
	if (ret == NULL)
		return (NULL);
	assert(commit);
	if (config_valgrind)
		JEMALLOC_VALGRIND_MAKE_MEM_UNDEFINED(ret, size);
	return (ret);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rax
movq %r8, %r10
movq %rcx, %rbx
movq %rdx, %r9
leaq 0x200(%rdi), %rdx
leaq 0x270(%rdi), %rcx
subq $0x8, %rsp
movzbl 0x28(%rsp), %r11d
leaq 0xf(%rsp), %r14
movl $0x1, %r8d
pushq %r11
pushq %r14
pushq %rax
pushq %r10
pushq %rbx
callq 0x2e66b
addq $0x30, %rsp
movq %rax, %r14
testq %rax, %rax
je 0x2e653
leaq 0x2c036(%rip), %rax     # 0x5a684
cmpb $0x1, (%rax)
je 0x2e65e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3e7a6
jmp 0x2e653
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk.c
// Function: je_chunk_alloc_wrapper
void *
chunk_alloc_wrapper(arena_t *arena, chunk_hooks_t *chunk_hooks, void *new_addr,
    size_t size, size_t alignment, bool *zero, bool *commit)
{
	void *ret;

	chunk_hooks_assure_initialized(arena, chunk_hooks);
	ret = chunk_hooks->alloc(new_addr, size, alignment, zero, commit,
	    arena->ind);
	if (ret == NULL)
		return (NULL);
	if (config_valgrind && chunk_hooks->alloc != chunk_alloc_default)
		JEMALLOC_VALGRIND_MAKE_MEM_UNDEFINED(ret, chunksize);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %rbp
callq 0x2eb4e
movl (%rbp), %r9d
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq 0x40(%rsp), %r8
callq *(%rbx)
movq %rax, %r14
testq %rax, %rax
je 0x2eb2b
leaq -0x9a6(%rip), %rax      # 0x2e174
cmpq %rax, (%rbx)
je 0x2eb2b
leaq 0x2bb5e(%rip), %rax     # 0x5a684
cmpb $0x1, (%rax)
je 0x2eb3d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2cb64(%rip), %rsi     # 0x5b6a8
movq %r14, %rdi
callq 0x3e7a6
jmp 0x2eb2b
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk.c
// Function: je_chunk_dalloc_cache
void
chunk_dalloc_cache(arena_t *arena, chunk_hooks_t *chunk_hooks, void *chunk,
    size_t size, bool committed)
{

	assert(chunk != NULL);
	assert(CHUNK_ADDR2BASE(chunk) == chunk);
	assert(size != 0);
	assert((size & chunksize_mask) == 0);

	chunk_record(arena, chunk_hooks, &arena->chunks_szad_cached,
	    &arena->chunks_ad_cached, true, chunk, size, false, committed);
	arena_maybe_purge(arena);
}

// Assembly:
pushq %rbx
movl %r8d, %eax
movq %rcx, %r10
movq %rdx, %r9
movq %rdi, %rbx
leaq 0x200(%rdi), %rdx
leaq 0x270(%rdi), %rcx
subq $0x8, %rsp
movl $0x1, %r8d
pushq %rax
pushq $0x0
pushq %r10
callq 0x2ec26
addq $0x20, %rsp
movq %rbx, %rdi
popq %rbx
jmp 0x278db
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk.c
// Function: je_chunk_dalloc_arena
void
chunk_dalloc_arena(arena_t *arena, chunk_hooks_t *chunk_hooks, void *chunk,
    size_t size, bool zeroed, bool committed)
{

	assert(chunk != NULL);
	assert(CHUNK_ADDR2BASE(chunk) == chunk);
	assert(size != 0);
	assert((size & chunksize_mask) == 0);

	chunk_hooks_assure_initialized(arena, chunk_hooks);
	/* Try to deallocate. */
	if (!chunk_hooks->dalloc(chunk, size, committed, arena->ind))
		return;
	/* Try to decommit; purge if that fails. */
	if (committed) {
		committed = chunk_hooks->decommit(chunk, size, 0, size,
		    arena->ind);
	}
	zeroed = !committed || !chunk_hooks->purge(chunk, size, 0, size,
	    arena->ind);
	chunk_record(arena, chunk_hooks, &arena->chunks_szad_retained,
	    &arena->chunks_ad_retained, false, chunk, size, zeroed, committed);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r13d
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x2eb4e
movl (%r12), %ecx
movq %r14, %rdi
movq %rbx, %rsi
movl %r13d, %edx
callq *0x8(%r15)
testb %al, %al
je 0x2efb8
movb $0x1, %bpl
testb %r13b, %r13b
je 0x2efbe
movl (%r12), %r8d
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq *0x18(%r15)
testb %al, %al
je 0x2efc1
movl (%r12), %r8d
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq *0x20(%r15)
movl %eax, %ebp
xorb $0x1, %bpl
movb $0x1, %r13b
jmp 0x2efc1
addq $0x8, %rsp
jmp 0x2eff6
xorl %r13d, %r13d
leaq 0x2e0(%r12), %rdx
leaq 0x350(%r12), %rcx
subq $0x8, %rsp
movzbl %r13b, %eax
movzbl %bpl, %r10d
movq %r12, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
movq %r14, %r9
pushq %rax
pushq %r10
pushq %rbx
callq 0x2ec26
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk.c
// Function: je_chunk_dalloc_wrapper
void
chunk_dalloc_wrapper(arena_t *arena, chunk_hooks_t *chunk_hooks, void *chunk,
    size_t size, bool committed)
{

	chunk_hooks_assure_initialized(arena, chunk_hooks);
	chunk_hooks->dalloc(chunk, size, committed, arena->ind);
	if (config_valgrind && chunk_hooks->dalloc != chunk_dalloc_default)
		JEMALLOC_VALGRIND_MAKE_MEM_NOACCESS(chunk, size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x2eb4e
movl (%r12), %ecx
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq *0x8(%r15)
leaq -0xd70(%rip), %rax      # 0x2e2c4
cmpq %rax, 0x8(%r15)
je 0x2f046
leaq 0x2b643(%rip), %rax     # 0x5a684
cmpb $0x1, (%rax)
je 0x2f04f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3e764
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk.c
// Function: chunk_arena_get
static arena_t *
chunk_arena_get(unsigned arena_ind)
{
	arena_t *arena;

	/* Dodge tsd for a0 in order to avoid bootstrapping issues. */
	arena = (arena_ind == 0) ? a0get() : arena_get(tsd_fetch(), arena_ind,
	     false, true);
	/*
	 * The arena we're allocating on behalf of must have been initialized
	 * already.
	 */
	assert(arena != NULL);
	return (arena);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testl %edi, %edi
je 0x2f18c
movl %edi, %ebx
movq 0x28e9f(%rip), %r15     # 0x57ff0
movq %fs:0x0, %r14
addq %r15, %r14
movl %fs:(%r15), %eax
testl %eax, %eax
je 0x2f1a7
cmpl $0x2, %eax
je 0x2f1b1
movq %fs:0x30(%r15), %rax
testq %rax, %rax
je 0x2f196
cmpl %ebx, %fs:0x38(%r15)
jbe 0x2f196
movl %ebx, %ecx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x2f196
popq %rbx
popq %r14
popq %r15
retq
popq %rbx
popq %r14
popq %r15
jmp 0x21b4c
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x21fbc
movl $0x1, %fs:(%r15)
jmp 0x2f1b9
movl $0x3, %fs:(%r15)
leaq 0x2cc54(%rip), %rax     # 0x5be14
movl (%rax), %edi
movq %r14, %rsi
callq 0x106f0
testl %eax, %eax
je 0x2f16a
leaq 0x191a4(%rip), %rdi     # 0x48379
callq 0x3d37c
leaq 0x2b43f(%rip), %rax     # 0x5a620
cmpb $0x1, (%rax)
jne 0x2f16a
callq 0x10090
nop
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk_dss.c
// Function: je_chunk_dss_prec_get
dss_prec_t
chunk_dss_prec_get(void)
{
	dss_prec_t ret;

	if (!have_dss)
		return (dss_prec_disabled);
	malloc_mutex_lock(&dss_mtx);
	ret = dss_prec_default;
	malloc_mutex_unlock(&dss_mtx);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x2c4ca(%rip), %rbx     # 0x5b6c0
movq %rbx, %rdi
callq 0x106d0
movl 0x2b1bc(%rip), %ebp     # 0x5a3c0
movq %rbx, %rdi
callq 0x10440
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk_dss.c
// Function: je_chunk_dss_prec_set
bool
chunk_dss_prec_set(dss_prec_t dss_prec)
{

	if (!have_dss)
		return (dss_prec != dss_prec_disabled);
	malloc_mutex_lock(&dss_mtx);
	dss_prec_default = dss_prec;
	malloc_mutex_unlock(&dss_mtx);
	return (false);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x2c49e(%rip), %r14     # 0x5b6c0
movq %r14, %rdi
callq 0x106d0
movl %ebx, 0x2b190(%rip)     # 0x5a3c0
movq %r14, %rdi
callq 0x10440
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk_dss.c
// Function: je_chunk_in_dss
bool
chunk_in_dss(void *chunk)
{
	bool ret;

	cassert(have_dss);

	malloc_mutex_lock(&dss_mtx);
	if ((uintptr_t)chunk >= (uintptr_t)dss_base
	    && (uintptr_t)chunk < (uintptr_t)dss_max)
		ret = true;
	else
		ret = false;
	malloc_mutex_unlock(&dss_mtx);

	return (ret);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2c2b5(%rip), %r14     # 0x5b6c0
movq %r14, %rdi
callq 0x106d0
cmpq %rbx, 0x2c2de(%rip)     # 0x5b6f8
setbe %al
cmpq %rbx, 0x2c2cc(%rip)     # 0x5b6f0
seta %bl
andb %al, %bl
movq %r14, %rdi
callq 0x10440
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk_dss.c
// Function: je_chunk_dss_boot
bool
chunk_dss_boot(void)
{

	cassert(have_dss);

	if (malloc_mutex_init(&dss_mtx))
		return (true);
	dss_base = chunk_dss_sbrk(0);
	dss_prev = dss_base;
	dss_max = dss_base;

	return (false);
}

// Assembly:
pushq %rbx
leaq 0x2c27d(%rip), %rdi     # 0x5b6c0
callq 0x36e44
movl %eax, %ebx
testb %al, %al
jne 0x2f46a
xorl %edi, %edi
callq 0x10320
movq %rax, 0x2c29c(%rip)     # 0x5b6f8
movq %rax, 0x2c285(%rip)     # 0x5b6e8
movq %rax, 0x2c286(%rip)     # 0x5b6f0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk_mmap.c
// Function: je_chunk_alloc_mmap
void *
chunk_alloc_mmap(size_t size, size_t alignment, bool *zero, bool *commit)
{
	void *ret;
	size_t offset;

	/*
	 * Ideally, there would be a way to specify alignment to mmap() (like
	 * NetBSD has), but in the absence of such a feature, we have to work
	 * hard to efficiently create aligned mappings.  The reliable, but
	 * slow method is to create a mapping that is over-sized, then trim the
	 * excess.  However, that always results in one or two calls to
	 * pages_unmap().
	 *
	 * Optimistically try mapping precisely the right amount before falling
	 * back to the slow method, with the expectation that the optimistic
	 * approach works most of the time.
	 */

	assert(alignment != 0);
	assert((alignment & chunksize_mask) == 0);

	ret = pages_map(NULL, size);
	if (ret == NULL)
		return (NULL);
	offset = ALIGNMENT_ADDR2OFFSET(ret, alignment);
	if (offset != 0) {
		pages_unmap(ret, size);
		return (chunk_alloc_mmap_slow(size, alignment, zero, commit));
	}

	assert(ret != NULL);
	*zero = true;
	if (!*commit)
		*commit = pages_decommit(ret, size);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r12
movq %rdi, %r14
xorl %r13d, %r13d
xorl %edi, %edi
movq %r14, %rsi
callq 0x36ed0
testq %rax, %rax
je 0x2f554
movq %rax, %rbp
leaq -0x1(%r12), %r15
testq %rax, %r15
je 0x2f52a
movq %rbp, %rdi
movq %r14, %rsi
callq 0x36f28
leaq (%r14,%r12), %rbx
addq $-0x1000, %rbx          # imm = 0xF000
cmpq %r14, %rbx
jae 0x2f4f5
xorl %r13d, %r13d
jmp 0x2f554
negq %r12
xorl %r13d, %r13d
xorl %edi, %edi
movq %rbx, %rsi
callq 0x36ed0
testq %rax, %rax
je 0x2f554
leaq (%r15,%rax), %rdx
andq %r12, %rdx
subq %rax, %rdx
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x36f76
testq %rax, %rax
je 0x2f4fb
movq %rax, %rbp
movq 0x10(%rsp), %rax
movb $0x1, (%rax)
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
movq %rbp, %r13
jne 0x2f554
movq %rbp, %rdi
movq %r14, %rsi
callq 0x36fc8
movq 0x8(%rsp), %rcx
movb %al, (%rcx)
movq %rbp, %r13
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: je_ctl_byname
int
ctl_byname(const char *name, void *oldp, size_t *oldlenp, void *newp,
    size_t newlen)
{
	int ret;
	size_t depth;
	ctl_node_t const *nodes[CTL_MAX_DEPTH];
	size_t mib[CTL_MAX_DEPTH];
	const ctl_named_node_t *node;

	if (!ctl_initialized && ctl_init()) {
		ret = EAGAIN;
		goto label_return;
	}

	depth = CTL_MAX_DEPTH;
	ret = ctl_lookup(name, nodes, mib, &depth);
	if (ret != 0)
		goto label_return;

	node = ctl_named_node(nodes[depth-1]);
	if (node != NULL && node->ctl)
		ret = node->ctl(mib, depth, oldp, oldlenp, newp, newlen);
	else {
		/* The name refers to a partial path through the ctl tree. */
		ret = ENOENT;
	}

label_return:
	return(ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
cmpb $0x0, 0x2c170(%rip)     # 0x5b700
jne 0x2f5a0
movl $0xb, %ebp
callq 0x2f607
testb %al, %al
jne 0x2f5f6
leaq 0x8(%rsp), %rcx
movq $0x6, (%rcx)
leaq 0x40(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r13, %rdi
callq 0x2f72e
movl %eax, %ebp
testl %eax, %eax
jne 0x2f5f6
movq 0x8(%rsp), %rsi
movq 0x38(%rsp,%rsi,8), %rax
movl $0x2, %ebp
cmpb $0x1, (%rax)
jne 0x2f5f6
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x2f5f6
leaq 0x10(%rsp), %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
callq *%rax
movl %eax, %ebp
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: ctl_init
static bool
ctl_init(void)
{
	bool ret;

	malloc_mutex_lock(&ctl_mtx);
	if (!ctl_initialized) {
		/*
		 * Allocate space for one extra arena stats element, which
		 * contains summed stats across all arenas.
		 */
		ctl_stats.narenas = narenas_total_get();
		ctl_stats.arenas = (ctl_arena_stats_t *)a0malloc(
		    (ctl_stats.narenas + 1) * sizeof(ctl_arena_stats_t));
		if (ctl_stats.arenas == NULL) {
			ret = true;
			goto label_return;
		}
		memset(ctl_stats.arenas, 0, (ctl_stats.narenas + 1) *
		    sizeof(ctl_arena_stats_t));

		/*
		 * Initialize all stats structures, regardless of whether they
		 * ever get used.  Lazy initialization would allow errors to
		 * cause inconsistent state to be viewable by the application.
		 */
		if (config_stats) {
			unsigned i;
			for (i = 0; i <= ctl_stats.narenas; i++) {
				if (ctl_arena_init(&ctl_stats.arenas[i])) {
					unsigned j;
					for (j = 0; j < i; j++) {
						a0dalloc(
						    ctl_stats.arenas[j].lstats);
						a0dalloc(
						    ctl_stats.arenas[j].hstats);
					}
					a0dalloc(ctl_stats.arenas);
					ctl_stats.arenas = NULL;
					ret = true;
					goto label_return;
				}
			}
		}
		ctl_stats.arenas[ctl_stats.narenas].initialized = true;

		ctl_epoch = 0;
		ctl_refresh();
		ctl_initialized = true;
	}

	ret = false;
label_return:
	malloc_mutex_unlock(&ctl_mtx);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2c0f3(%rip), %rdi     # 0x5b708
callq 0x106d0
cmpb $0x0, 0x2c0df(%rip)     # 0x5b700
jne 0x2f6b8
callq 0x21f0f
movl %eax, 0x2c126(%rip)     # 0x5b758
incl %eax
imulq $0xbc8, %rax, %rdi      # imm = 0xBC8
callq 0x21b54
movq %rax, 0x2c119(%rip)     # 0x5b760
movb $0x1, %bl
testq %rax, %rax
je 0x2f6ba
movl 0x2c104(%rip), %ecx     # 0x5b758
incl %ecx
imulq $0xbc8, %rcx, %rdx      # imm = 0xBC8
xorl %ebp, %ebp
movq %rax, %rdi
xorl %esi, %esi
callq 0x10270
movl %ebp, %r14d
imulq $0xbc8, %r14, %rdi      # imm = 0xBC8
addq 0x2c0e6(%rip), %rdi     # 0x5b760
callq 0x2fa80
testb %al, %al
jne 0x2f6d3
incl %ebp
movl 0x2c0cd(%rip), %eax     # 0x5b758
cmpl %eax, %ebp
jbe 0x2f669
movq 0x2c0ca(%rip), %rcx     # 0x5b760
imulq $0xbc8, %rax, %rax      # imm = 0xBC8
movb $0x1, %bl
movb %bl, (%rcx,%rax)
movq $0x0, 0x2c0bb(%rip) # 0x5b768
callq 0x2fae0
movb %bl, 0x2c048(%rip)      # 0x5b700
xorl %ebx, %ebx
leaq 0x2c047(%rip), %rdi     # 0x5b708
callq 0x10440
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testl %ebp, %ebp
je 0x2f715
imulq $0xbc8, %r14, %r14      # imm = 0xBC8
xorl %r15d, %r15d
movq 0x2c078(%rip), %rax     # 0x5b760
movq 0xbb8(%rax,%r15), %rdi
callq 0x21cc3
movq 0x2c064(%rip), %rax     # 0x5b760
movq 0xbc0(%rax,%r15), %rdi
callq 0x21cc3
addq $0xbc8, %r15            # imm = 0xBC8
cmpq %r15, %r14
jne 0x2f6e1
movq 0x2c044(%rip), %rdi     # 0x5b760
callq 0x21cc3
movq $0x0, 0x2c034(%rip) # 0x5b760
jmp 0x2f6ba
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: je_ctl_bymib
int
ctl_bymib(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
    void *newp, size_t newlen)
{
	int ret;
	const ctl_named_node_t *node;
	size_t i;

	if (!ctl_initialized && ctl_init()) {
		ret = EAGAIN;
		goto label_return;
	}

	/* Iterate down the tree. */
	node = super_root_node;
	for (i = 0; i < miblen; i++) {
		assert(node);
		assert(node->nchildren > 0);
		if (ctl_named_node(node->children) != NULL) {
			/* Children are named. */
			if (node->nchildren <= mib[i]) {
				ret = ENOENT;
				goto label_return;
			}
			node = ctl_named_children(node, mib[i]);
		} else {
			const ctl_indexed_node_t *inode;

			/* Indexed element. */
			inode = ctl_indexed_node(node->children);
			node = inode->index(mib, miblen, mib[i]);
			if (node == NULL) {
				ret = ENOENT;
				goto label_return;
			}
		}
	}

	/* Call the ctl function. */
	if (node && node->ctl)
		ret = node->ctl(mib, miblen, oldp, oldlenp, newp, newlen);
	else {
		/* Partial MIB. */
		ret = ENOENT;
	}

label_return:
	return(ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
cmpb $0x0, 0x2bd64(%rip)     # 0x5b700
jne 0x2f9b0
movl $0xb, %ebx
callq 0x2f607
testb %al, %al
jne 0x2fa31
leaq 0x26ac9(%rip), %rax     # 0x56480
testq %r13, %r13
je 0x2fa00
xorl %ebx, %ebx
movq 0x18(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x2f9e0
movl 0x10(%rax), %edx
movq (%rbp,%rbx,8), %rax
cmpq %rdx, %rax
jae 0x2fa2c
cltq
leaq (%rax,%rax,4), %rax
leaq (%rcx,%rax,8), %rax
jmp 0x2f9f3
movq (%rbp,%rbx,8), %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq *0x8(%rcx)
testq %rax, %rax
je 0x2fa2c
incq %rbx
cmpq %rbx, %r13
jne 0x2f9be
testq %rax, %rax
je 0x2fa2c
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x2fa2c
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq (%rsp), %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movl $0x2, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: ctl_arena_init
static bool
ctl_arena_init(ctl_arena_stats_t *astats)
{

	if (astats->lstats == NULL) {
		astats->lstats = (malloc_large_stats_t *)a0malloc(nlclasses *
		    sizeof(malloc_large_stats_t));
		if (astats->lstats == NULL)
			return (true);
	}

	if (astats->hstats == NULL) {
		astats->hstats = (malloc_huge_stats_t *)a0malloc(nhclasses *
		    sizeof(malloc_huge_stats_t));
		if (astats->hstats == NULL)
			return (true);
	}

	return (false);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0xbb8(%rdi)
jne 0x2faac
leaq 0x2babb(%rip), %rax     # 0x5b550
movl (%rax), %edi
shlq $0x5, %rdi
callq 0x21b54
movq %rax, 0xbb8(%rbx)
testq %rax, %rax
je 0x2fadc
cmpq $0x0, 0xbc0(%rbx)
jne 0x2fad8
leaq 0x2ba97(%rip), %rax     # 0x5b554
movl (%rax), %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdi
callq 0x21b54
movq %rax, 0xbc0(%rbx)
testq %rax, %rax
je 0x2fadc
xorl %eax, %eax
jmp 0x2fade
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: tcache_flush_ctl
static int
tcache_flush_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
    void *newp, size_t newlen)
{
	int ret;
	tsd_t *tsd;
	unsigned tcache_ind;

	if (!config_tcache)
		return (ENOENT);

	tsd = tsd_fetch();

	WRITEONLY();
	tcache_ind = UINT_MAX;
	WRITE(tcache_ind, unsigned);
	if (tcache_ind == UINT_MAX) {
		ret = EFAULT;
		goto label_return;
	}
	tcaches_flush(tsd, tcache_ind);

	ret = 0;
label_return:
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %r15
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq 0x26b77(%rip), %rax     # 0x57ff0
movq %fs:0x0, %rbx
addq %rax, %rbx
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x314d1
cmpl $0x2, %ecx
je 0x314da
movl $0x1, %eax
orq %r12, %r13
jne 0x314c7
movl $0xe, %eax
testq %r14, %r14
je 0x314c7
movl $0x16, %eax
cmpq $0x4, %r15
jne 0x314c7
movl (%r14), %esi
movl $0xe, %eax
cmpl $-0x1, %esi
je 0x314c7
movq %rbx, %rdi
callq 0x3d1b3
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x1, %fs:(%rax)
jmp 0x314e1
movl $0x3, %fs:(%rax)
leaq 0x2a92c(%rip), %rax     # 0x5be14
movl (%rax), %edi
movq %rbx, %rsi
callq 0x106f0
testl %eax, %eax
je 0x31491
leaq 0x16e7c(%rip), %rdi     # 0x48379
callq 0x3d37c
leaq 0x29117(%rip), %rax     # 0x5a620
cmpb $0x1, (%rax)
jne 0x31491
callq 0x10090
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: tcache_create_ctl
static int
tcache_create_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
    void *newp, size_t newlen)
{
	int ret;
	tsd_t *tsd;
	unsigned tcache_ind;

	if (!config_tcache)
		return (ENOENT);

	tsd = tsd_fetch();

	malloc_mutex_lock(&ctl_mtx);
	READONLY();
	if (tcaches_create(tsd, &tcache_ind)) {
		ret = EFAULT;
		goto label_return;
	}
	READ(tcache_ind, unsigned);

	ret = 0;
label_return:
	malloc_mutex_unlock(&ctl_mtx);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %rbx
movq 0x26c84(%rip), %rax     # 0x57ff0
movq %fs:0x0, %r15
addq %rax, %r15
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x31413
cmpl $0x2, %ecx
je 0x3141c
leaq 0x2a375(%rip), %rdi     # 0x5b708
callq 0x106d0
movl $0x1, %ebp
orq %r12, %r13
jne 0x313f6
leaq 0x4(%rsp), %rsi
movq %r15, %rdi
callq 0x3d144
movl $0xe, %ebp
testb %al, %al
jne 0x313f6
testq %rbx, %rbx
sete %al
testq %r14, %r14
sete %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x313f6
movq (%r14), %rax
cmpq $0x4, %rax
jne 0x313db
movl 0x4(%rsp), %eax
movl %eax, (%rbx)
jmp 0x313f6
movl $0x4, %edx
cmovbq %rax, %rdx
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x10400
movl $0x16, %ebp
leaq 0x2a30b(%rip), %rdi     # 0x5b708
callq 0x10440
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %fs:(%rax)
jmp 0x31423
movl $0x3, %fs:(%rax)
leaq 0x2a9ea(%rip), %rax     # 0x5be14
movl (%rax), %edi
movq %r15, %rsi
callq 0x106f0
testl %eax, %eax
je 0x3138c
leaq 0x16f36(%rip), %rdi     # 0x48379
callq 0x3d37c
leaq 0x291d1(%rip), %rax     # 0x5a620
cmpb $0x1, (%rax)
jne 0x3138c
callq 0x10090
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: tcache_destroy_ctl
static int
tcache_destroy_ctl(const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;
	tsd_t *tsd;
	unsigned tcache_ind;

	if (!config_tcache)
		return (ENOENT);

	tsd = tsd_fetch();

	WRITEONLY();
	tcache_ind = UINT_MAX;
	WRITE(tcache_ind, unsigned);
	if (tcache_ind == UINT_MAX) {
		ret = EFAULT;
		goto label_return;
	}
	tcaches_destroy(tsd, tcache_ind);

	ret = 0;
label_return:
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %r15
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq 0x26ac1(%rip), %rax     # 0x57ff0
movq %fs:0x0, %rbx
addq %rax, %rbx
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x31587
cmpl $0x2, %ecx
je 0x31590
movl $0x1, %eax
orq %r12, %r13
jne 0x3157d
movl $0xe, %eax
testq %r14, %r14
je 0x3157d
movl $0x16, %eax
cmpq $0x4, %r15
jne 0x3157d
movl (%r14), %esi
movl $0xe, %eax
cmpl $-0x1, %esi
je 0x3157d
movq %rbx, %rdi
callq 0x3d1df
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x1, %fs:(%rax)
jmp 0x31597
movl $0x3, %fs:(%rax)
leaq 0x2a876(%rip), %rax     # 0x5be14
movl (%rax), %edi
movq %rbx, %rsi
callq 0x106f0
testl %eax, %eax
je 0x31547
leaq 0x16dc6(%rip), %rdi     # 0x48379
callq 0x3d37c
leaq 0x29061(%rip), %rax     # 0x5a620
cmpb $0x1, (%rax)
jne 0x31547
callq 0x10090
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: arena_i_index
static const ctl_named_node_t *
arena_i_index(const size_t *mib, size_t miblen, size_t i)
{
	const ctl_named_node_t * ret;

	malloc_mutex_lock(&ctl_mtx);
	if (i > ctl_stats.narenas) {
		ret = NULL;
		goto label_return;
	}

	ret = super_arena_i_node;
label_return:
	malloc_mutex_unlock(&ctl_mtx);
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
leaq 0x2a130(%rip), %r14     # 0x5b708
movq %r14, %rdi
callq 0x106d0
movl 0x2a172(%rip), %eax     # 0x5b758
xorl %r15d, %r15d
cmpq %rbx, %rax
leaq 0x25cfd(%rip), %rax     # 0x572f0
cmovaeq %rax, %r15
movq %r14, %rdi
callq 0x10440
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: arena_i_purge_ctl
static int
arena_i_purge_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
    void *newp, size_t newlen)
{
	int ret;

	READONLY();
	WRITEONLY();
	malloc_mutex_lock(&ctl_mtx);
	arena_purge(mib[1]);
	malloc_mutex_unlock(&ctl_mtx);

	ret = 0;
label_return:
	return (ret);
}

// Assembly:
movl $0x1, %eax
orq %r9, %r8
jne 0x31646
orq %rcx, %rdx
jne 0x31646
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2a0e3(%rip), %r14     # 0x5b708
movq %r14, %rdi
callq 0x106d0
movl 0x8(%rbx), %edi
callq 0x31bf8
movq %r14, %rdi
callq 0x10440
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: arena_i_lg_dirty_mult_ctl
static int
arena_i_lg_dirty_mult_ctl(const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;
	unsigned arena_ind = mib[1];
	arena_t *arena;

	arena = arena_get(tsd_fetch(), arena_ind, false, true);
	if (arena == NULL) {
		ret = EFAULT;
		goto label_return;
	}

	if (oldp != NULL && oldlenp != NULL) {
		size_t oldval = arena_lg_dirty_mult_get(arena);
		READ(oldval, ssize_t);
	}
	if (newp != NULL) {
		if (newlen != sizeof(ssize_t)) {
			ret = EINVAL;
			goto label_return;
		}
		if (arena_lg_dirty_mult_set(arena, *(ssize_t *)newp)) {
			ret = EFAULT;
			goto label_return;
		}
	}

	ret = 0;
label_return:
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r15
movq 0x8(%rdi), %r13
movq 0x2677b(%rip), %r14     # 0x57ff0
movq %fs:0x0, %rbp
addq %r14, %rbp
movl %fs:(%r14), %eax
testl %eax, %eax
je 0x31969
cmpl $0x2, %eax
je 0x31973
movq %fs:0x30(%r14), %rax
testq %rax, %rax
je 0x31943
cmpl %r13d, %fs:0x38(%r14)
jbe 0x31943
movl %r13d, %ecx
movq (%rax,%rcx,8), %r14
testq %r14, %r14
je 0x31943
testq %r15, %r15
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
jne 0x318ef
movq %r9, %r13
movq %r14, %rdi
callq 0x27860
movq %rax, 0x10(%rsp)
movq (%r12), %rcx
cmpq $0x8, %rcx
jne 0x31919
movq %rax, (%r15)
movq %r13, %r9
testq %rbx, %rbx
je 0x31915
movl $0x16, %eax
cmpq $0x8, %r9
jne 0x31934
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2788d
movl %eax, %ecx
movl $0xe, %eax
testb %cl, %cl
jne 0x31934
xorl %eax, %eax
jmp 0x31934
movl $0x8, %edx
cmovbq %rcx, %rdx
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x10400
movl $0x16, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, %rdi
movl %r13d, %esi
xorl %edx, %edx
movq %r9, %r14
callq 0x21fbc
movq %r14, %r9
movq %rax, %r14
testq %rax, %rax
jne 0x318bf
movl $0xe, %eax
jmp 0x31934
movl $0x1, %fs:(%r14)
jmp 0x3197b
movl $0x3, %fs:(%r14)
leaq 0x2a492(%rip), %rax     # 0x5be14
movl (%rax), %edi
movq %rbp, %rsi
movq %r9, 0x8(%rsp)
callq 0x106f0
movq 0x8(%rsp), %r9
testl %eax, %eax
je 0x31896
leaq 0x169d4(%rip), %rdi     # 0x48379
callq 0x3d37c
movq 0x8(%rsp), %r9
leaq 0x28c6a(%rip), %rax     # 0x5a620
cmpb $0x1, (%rax)
jne 0x31896
callq 0x10090
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: arenas_narenas_ctl
static int
arenas_narenas_ctl(const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;
	unsigned narenas;

	malloc_mutex_lock(&ctl_mtx);
	READONLY();
	if (*oldlenp != sizeof(unsigned)) {
		ret = EINVAL;
		goto label_return;
	}
	narenas = ctl_stats.narenas;
	READ(narenas, unsigned);

	ret = 0;
label_return:
	malloc_mutex_unlock(&ctl_mtx);
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %r12
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r14
leaq 0x2990f(%rip), %rdi     # 0x5b708
callq 0x106d0
movl $0x1, %ebx
orq %r12, %r13
jne 0x31e23
movl $0x16, %ebx
cmpq $0x4, (%r15)
jne 0x31e23
xorl %ebx, %ebx
testq %r14, %r14
je 0x31e23
movl 0x29938(%rip), %eax     # 0x5b758
movl %eax, (%r14)
leaq 0x298de(%rip), %rdi     # 0x5b708
callq 0x10440
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: arenas_initialized_ctl
static int
arenas_initialized_ctl(const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;
	unsigned nread, i;

	malloc_mutex_lock(&ctl_mtx);
	READONLY();
	if (*oldlenp != ctl_stats.narenas * sizeof(bool)) {
		ret = EINVAL;
		nread = (*oldlenp < ctl_stats.narenas * sizeof(bool))
		    ? (*oldlenp / sizeof(bool)) : ctl_stats.narenas;
	} else {
		ret = 0;
		nread = ctl_stats.narenas;
	}

	for (i = 0; i < nread; i++)
		((bool *)oldp)[i] = ctl_stats.arenas[i].initialized;

label_return:
	malloc_mutex_unlock(&ctl_mtx);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %rbx
leaq 0x298b2(%rip), %rdi     # 0x5b708
callq 0x106d0
movl $0x1, %ebp
orq %r15, %r12
jne 0x31ea5
movq (%r14), %rcx
movl 0x298ea(%rip), %eax     # 0x5b758
xorl %edx, %edx
cmpq %rax, %rcx
cmovael %eax, %ecx
movl $0x16, %ebp
cmovel %edx, %ebp
cmovel %eax, %ecx
testl %ecx, %ecx
je 0x31ea5
movq 0x298d4(%rip), %rax     # 0x5b760
movl %ecx, %ecx
xorl %edx, %edx
movb (%rax), %sil
movb %sil, (%rbx,%rdx)
incq %rdx
addq $0xbc8, %rax            # imm = 0xBC8
cmpq %rdx, %rcx
jne 0x31e90
leaq 0x2985c(%rip), %rdi     # 0x5b708
callq 0x10440
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: arenas_lg_dirty_mult_ctl
static int
arenas_lg_dirty_mult_ctl(const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;

	if (oldp != NULL && oldlenp != NULL) {
		size_t oldval = arena_lg_dirty_mult_default_get();
		READ(oldval, ssize_t);
	}
	if (newp != NULL) {
		if (newlen != sizeof(ssize_t)) {
			ret = EINVAL;
			goto label_return;
		}
		if (arena_lg_dirty_mult_default_set(*(ssize_t *)newp)) {
			ret = EFAULT;
			goto label_return;
		}
	}

	ret = 0;
label_return:
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %r12
testq %rdx, %rdx
sete %al
testq %rcx, %rcx
sete %cl
orb %al, %cl
jne 0x31ef6
movq %rdx, %r15
callq 0x2a8e5
movq %rax, (%rsp)
movq (%r12), %rcx
cmpq $0x8, %rcx
jne 0x31f1d
movq %rax, (%r15)
testq %rbx, %rbx
je 0x31f19
movl $0x16, %eax
cmpq $0x8, %r14
jne 0x31f36
movq (%rbx), %rdi
callq 0x2a8f1
movl %eax, %ecx
movl $0xe, %eax
testb %cl, %cl
jne 0x31f36
xorl %eax, %eax
jmp 0x31f36
movl $0x8, %edx
cmovbq %rcx, %rdx
movq %rsp, %rsi
movq %r15, %rdi
callq 0x10400
movl $0x16, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: arenas_extend_ctl
static int
arenas_extend_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
    void *newp, size_t newlen)
{
	int ret;
	unsigned narenas;

	malloc_mutex_lock(&ctl_mtx);
	READONLY();
	if (ctl_grow()) {
		ret = EAGAIN;
		goto label_return;
	}
	narenas = ctl_stats.narenas - 1;
	READ(narenas, unsigned);

	ret = 0;
label_return:
	malloc_mutex_unlock(&ctl_mtx);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xbc8, %rsp            # imm = 0xBC8
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %rbx
leaq 0x2951c(%rip), %rdi     # 0x5b708
callq 0x106d0
movl $0x1, %ebp
orq %r15, %r12
jne 0x32333
movl 0x29553(%rip), %edi     # 0x5b758
callq 0x21e07
movl $0xb, %ebp
testq %rax, %rax
je 0x32333
movl 0x2953a(%rip), %eax     # 0x5b758
addl $0x2, %eax
imulq $0xbc8, %rax, %rdi      # imm = 0xBC8
callq 0x21b54
testq %rax, %rax
je 0x32333
movq %rax, %r15
movq 0x29520(%rip), %rsi     # 0x5b760
movl 0x29512(%rip), %eax     # 0x5b758
incl %eax
imulq $0xbc8, %rax, %r12      # imm = 0xBC8
movq %r15, %rdi
movq %r12, %rdx
callq 0x10400
addq %r15, %r12
movl $0xbc8, %edx            # imm = 0xBC8
movq %r12, %rdi
xorl %esi, %esi
callq 0x10270
movq %r12, %rdi
callq 0x2fa80
testb %al, %al
je 0x32285
movq %r15, %rdi
callq 0x21cc3
jmp 0x32333
movl 0x294cd(%rip), %ebp     # 0x5b758
imulq $0xbc8, %rbp, %r13      # imm = 0xBC8
addq %r15, %r13
movq %rsp, %r12
movl $0xbc8, %edx            # imm = 0xBC8
movq %r12, %rdi
movq %r13, %rsi
callq 0x10400
leal 0x1(%rbp), %eax
imulq $0xbc8, %rax, %rbp      # imm = 0xBC8
addq %r15, %rbp
movl $0xbc8, %edx            # imm = 0xBC8
movq %r13, %rdi
movq %rbp, %rsi
callq 0x10400
movl $0xbc8, %edx            # imm = 0xBC8
movq %rbp, %rdi
movq %r12, %rsi
callq 0x10400
movq 0x29484(%rip), %rdi     # 0x5b760
callq 0x21cc3
movq %r15, 0x29478(%rip)     # 0x5b760
movl 0x2946a(%rip), %eax     # 0x5b758
leal 0x1(%rax), %ecx
movl %ecx, 0x29461(%rip)     # 0x5b758
movl %eax, (%r12)
testq %rbx, %rbx
sete %cl
testq %r14, %r14
sete %dl
orb %cl, %dl
jne 0x32316
movq (%r14), %rcx
cmpq $0x4, %rcx
jne 0x3231a
movl %eax, (%rbx)
xorl %ebp, %ebp
jmp 0x32333
movl $0x4, %edx
cmovbq %rcx, %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x10400
movl $0x16, %ebp
leaq 0x293ce(%rip), %rdi     # 0x5b708
callq 0x10440
movl %ebp, %eax
addq $0xbc8, %rsp            # imm = 0xBC8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: stats_arenas_i_index
static const ctl_named_node_t *
stats_arenas_i_index(const size_t *mib, size_t miblen, size_t i)
{
	const ctl_named_node_t * ret;

	malloc_mutex_lock(&ctl_mtx);
	if (i > ctl_stats.narenas || !ctl_stats.arenas[i].initialized) {
		ret = NULL;
		goto label_return;
	}

	ret = super_stats_arenas_i_node;
label_return:
	malloc_mutex_unlock(&ctl_mtx);
	return (ret);
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
leaq 0x28dc8(%rip), %rdi     # 0x5b708
callq 0x106d0
movl 0x28e0d(%rip), %eax     # 0x5b758
cmpq %rbx, %rax
jae 0x32954
xorl %ebx, %ebx
jmp 0x32973
movq 0x28e05(%rip), %rax     # 0x5b760
imulq $0xbc8, %rbx, %rcx      # imm = 0xBC8
leaq 0x24c07(%rip), %rdx     # 0x57570
xorl %ebx, %ebx
cmpb $0x0, (%rax,%rcx)
cmovneq %rdx, %rbx
leaq 0x28d8e(%rip), %rdi     # 0x5b708
callq 0x10440
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/huge.c
// Function: je_huge_malloc
void *
huge_malloc(tsd_t *tsd, arena_t *arena, size_t size, bool zero,
    tcache_t *tcache)
{
	size_t usize;

	usize = s2u(size);
	if (usize == 0) {
		/* size_t overflow. */
		return (NULL);
	}

	return (huge_palloc(tsd, arena, usize, chunksize, zero, tcache));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x1000, %rdx           # imm = 0x1000
ja 0x3611d
decq %rdx
shrq $0x3, %rdx
leaq 0x11eee(%rip), %rax     # 0x47fc0
movzbl (%rax,%rdx), %eax
leaq 0x11763(%rip), %rcx     # 0x47840
movq (%rcx,%rax,8), %rdx
testq %rdx, %rdx
jne 0x360f5
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x255ac(%rip), %rax     # 0x5b6a8
movq (%rax), %rcx
movzbl %bpl, %r8d
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %r9
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x12382
leaq 0x8(%rsp), %r12
movq %rdx, %rdi
movq %r12, %rsi
callq 0x12b3e
movq (%r12), %rdx
jmp 0x360e1
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/huge.c
// Function: huge_ralloc_no_move_expand
static bool
huge_ralloc_no_move_expand(void *ptr, size_t oldsize, size_t usize, bool zero) {
	extent_node_t *node;
	arena_t *arena;
	bool is_zeroed_subchunk, is_zeroed_chunk;

	node = huge_node_get(ptr);
	arena = extent_node_arena_get(node);
	malloc_mutex_lock(&arena->huge_mtx);
	is_zeroed_subchunk = extent_node_zeroed_get(node);
	malloc_mutex_unlock(&arena->huge_mtx);

	/*
	 * Copy zero into is_zeroed_chunk and pass the copy to chunk_alloc(), so
	 * that it is possible to make correct junk/zero fill decisions below.
	 */
	is_zeroed_chunk = zero;

	if (arena_chunk_ralloc_huge_expand(arena, ptr, oldsize, usize,
	     &is_zeroed_chunk))
		return (true);

	malloc_mutex_lock(&arena->huge_mtx);
	/* Update the size of the huge allocation. */
	extent_node_size_set(node, usize);
	malloc_mutex_unlock(&arena->huge_mtx);

	if (zero || (config_fill && unlikely(opt_zero))) {
		if (!is_zeroed_subchunk) {
			memset((void *)((uintptr_t)ptr + oldsize), 0,
			    CHUNK_CEILING(oldsize) - oldsize);
		}
		if (!is_zeroed_chunk) {
			memset((void *)((uintptr_t)ptr +
			    CHUNK_CEILING(oldsize)), 0, usize -
			    CHUNK_CEILING(oldsize));
		}
	} else if (config_fill && unlikely(opt_junk_alloc)) {
		memset((void *)((uintptr_t)ptr + oldsize), 0xa5, usize -
		    oldsize);
	}

	return (false);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r15d
movq %rdx, 0x20(%rsp)
movq %rsi, %r14
movq %rdi, %r12
callq 0x36c66
movq %rax, %r13
movq (%rax), %rbp
leaq 0x1d8(%rbp), %rbx
movq %rbx, %rdi
callq 0x106d0
movb 0x18(%r13), %al
movb %al, 0x6(%rsp)
movq %rbx, %rdi
callq 0x10440
leaq 0x7(%rsp), %r8
movl %r15d, 0x1c(%rsp)
movb %r15b, (%r8)
movq 0x20(%rsp), %r15
movq %rbp, %rdi
movq %r12, 0x8(%rsp)
movq %r12, %rsi
movq %r14, 0x10(%rsp)
movq %r14, %rdx
movq %r15, %rcx
callq 0x2760b
movl %eax, %ebp
testb %al, %al
jne 0x36604
movq %rbx, %rdi
callq 0x106d0
movq %r15, 0x10(%r13)
movq %rbx, %rdi
callq 0x10440
cmpb $0x0, 0x1c(%rsp)
je 0x365ec
movq %r15, %rbx
cmpb $0x0, 0x6(%rsp)
jne 0x365b6
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
leaq (%rax,%rcx), %rdi
leaq 0x25111(%rip), %rax     # 0x5b6b0
movq (%rax), %rdx
leaq (%rdx,%rcx), %rax
notq %rdx
andq %rax, %rdx
subq %rcx, %rdx
xorl %esi, %esi
callq 0x10270
cmpb $0x0, 0x7(%rsp)
jne 0x36604
movq %rbx, %rdx
leaq 0x250e9(%rip), %rax     # 0x5b6b0
movq (%rax), %rax
movq 0x10(%rsp), %rcx
addq %rax, %rcx
notq %rax
andq %rcx, %rax
movq 0x8(%rsp), %rdi
addq %rax, %rdi
subq %rax, %rdx
xorl %esi, %esi
callq 0x10270
jmp 0x36604
leaq 0x24040(%rip), %rax     # 0x5a633
cmpb $0x1, (%rax)
je 0x36580
leaq 0x24022(%rip), %rax     # 0x5a621
cmpb $0x1, (%rax)
je 0x36615
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdx
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdi
addq %rax, %rdi
subq %rax, %rdx
movl $0xa5, %esi
jmp 0x365e5