LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: je_u2rz
JEMALLOC_INLINE size_t
u2rz(size_t usize)
{
	size_t ret;

	if (usize <= SMALL_MAXCLASS) {
		szind_t binind = size2index(usize);
		ret = arena_bin_info[binind].redzone_size;
	} else
		ret = 0;

	return (ret);
}

// Assembly:
cmpq $0x3800, %rdi           # imm = 0x3800
ja 0x23a55
pushq %rax
cmpq $0x1000, %rdi           # imm = 0x1000
ja 0x23a58
decq %rdi
shrq $0x3, %rdi
leaq 0x2458a(%rip), %rax     # 0x47fc0
movzbl (%rdi,%rax), %eax
movl %eax, %eax
leaq (%rax,%rax,2), %rax
shlq $0x5, %rax
leaq 0x36c55(%rip), %rcx     # 0x5a6a0
movq 0x8(%rcx,%rax), %rax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
callq 0x26dcf
jmp 0x23a3a
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: je_free
JEMALLOC_NOTHROW
je_free(void *ptr)
{

	UTRACE(ptr, 0, 0);
	if (likely(ptr != NULL)) {
		tsd_t *tsd = tsd_fetch();
		ifree(tsd, ptr, tcache_get(tsd, false));
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x23aa1
movq %rdi, %rbx
movq 0x3457d(%rip), %r15     # 0x57ff0
movq %fs:0x0, %r14
addq %r15, %r14
movl %fs:(%r15), %eax
testl %eax, %eax
je 0x23aa7
cmpl $0x2, %eax
je 0x23ab1
movq %fs:0x8(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2374a
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, %fs:(%r15)
jmp 0x23ab9
movl $0x3, %fs:(%r15)
leaq 0x38354(%rip), %rax     # 0x5be14
movl (%rax), %edi
movq %r14, %rsi
callq 0x106f0
testl %eax, %eax
je 0x23a8c
leaq 0x248a4(%rip), %rdi     # 0x48379
callq 0x3d37c
cmpb $0x1, 0x36b3f(%rip)     # 0x5a620
jne 0x23a8c
callq 0x10090
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: je_dallocx
JEMALLOC_NOTHROW
je_dallocx(void *ptr, int flags)
{
	tsd_t *tsd;
	tcache_t *tcache;

	assert(ptr != NULL);
	assert(malloc_initialized() || IS_INITIALIZER);

	tsd = tsd_fetch();
	if (unlikely((flags & MALLOCX_TCACHE_MASK) != 0)) {
		if ((flags & MALLOCX_TCACHE_MASK) == MALLOCX_TCACHE_NONE)
			tcache = NULL;
		else
			tcache = tcaches_get(tsd, MALLOCX_TCACHE_GET(flags));
	} else
		tcache = tcache_get(tsd, false);

	UTRACE(ptr, 0, 0);
	ifree(tsd_fetch(), ptr, tcache);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
movq 0x32a6d(%rip), %r13     # 0x57ff0
movq %fs:0x0, %r14
addq %r13, %r14
movl %fs:(%r13), %eax
testl %eax, %eax
je 0x255eb
cmpl $0x2, %eax
je 0x25643
andl $0xfff00, %r15d         # imm = 0xFFF00
jne 0x255dd
movq %fs:0x8(%r13), %r12
movl %fs:(%r13), %eax
testl %eax, %eax
je 0x255f6
cmpl $0x2, %eax
je 0x25680
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2374a
cmpl $0x100, %r15d           # imm = 0x100
jne 0x25604
xorl %r12d, %r12d
jmp 0x255af
movl $0x1, %fs:(%r13)
jmp 0x2564c
movl $0x1, %fs:(%r13)
jmp 0x25689
shrl $0x8, %r15d
addl $-0x2, %r15d
leaq 0x367b5(%rip), %rax     # 0x5bdc8
movq (%rax), %rbp
movq (%rbp,%r15,8), %r12
testq %r12, %r12
jne 0x255af
movq %fs:0x28(%r13), %rsi
testq %rsi, %rsi
je 0x256c0
movq %r14, %rdi
callq 0x12ffe
movq %rax, %r12
movq %rax, (%rbp,%r15,8)
jmp 0x255af
movl $0x3, %fs:(%r13)
leaq 0x367c1(%rip), %rax     # 0x5be14
movl (%rax), %edi
movq %r14, %rsi
callq 0x106f0
testl %eax, %eax
je 0x255a1
leaq 0x22d0d(%rip), %rdi     # 0x48379
callq 0x3d37c
cmpb $0x1, 0x34fa8(%rip)     # 0x5a620
jne 0x255a1
jmp 0x256bb
movl $0x3, %fs:(%r13)
leaq 0x36784(%rip), %rax     # 0x5be14
movl (%rax), %edi
movq %r14, %rsi
callq 0x106f0
testl %eax, %eax
je 0x255c1
leaq 0x22cd0(%rip), %rdi     # 0x48379
callq 0x3d37c
cmpb $0x1, 0x34f6b(%rip)     # 0x5a620
jne 0x255c1
callq 0x10090
movq %r14, %rdi
callq 0x22135
movq %rax, %rsi
jmp 0x2562e
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: je_malloc_usable_size
JEMALLOC_NOTHROW
je_malloc_usable_size(JEMALLOC_USABLE_SIZE_CONST void *ptr)
{
	size_t ret;

	assert(malloc_initialized() || IS_INITIALIZER);
	malloc_thread_init();

	if (config_ivsalloc)
		ret = ivsalloc(ptr, config_prof);
	else
		ret = (ptr == NULL) ? 0 : isalloc(ptr, config_prof);

	return (ret);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x346a0(%rip)     # 0x5a628
jne 0x25fdd
testq %rbx, %rbx
je 0x25fd9
leaq 0x3571a(%rip), %rax     # 0x5b6b0
movq (%rax), %rax
notq %rax
andq %rbx, %rax
cmpq %rbx, %rax
je 0x25fe4
subq %rax, %rbx
shrq $0xc, %rbx
leaq 0x355a6(%rip), %rcx     # 0x5b558
subq (%rcx), %rbx
movq 0x68(%rax,%rbx,8), %rax
movl %eax, %ecx
shrl $0x5, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
je 0x25fed
movl %ecx, %eax
leaq 0x2186d(%rip), %rcx     # 0x47840
movq (%rcx,%rax,8), %rax
jmp 0x25fdb
xorl %eax, %eax
popq %rbx
retq
callq 0x11d21
jmp 0x25f8a
movq %rbx, %rdi
popq %rbx
jmp 0x36d46
shrq %rax
andq $-0x1000, %rax          # imm = 0xF000
addq $-0x1000, %rax          # imm = 0xF000
jmp 0x25fdb
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: je_jemalloc_postfork_child
void
jemalloc_postfork_child(void)
{
	unsigned i;

	assert(malloc_initialized());

	/* Release all mutexes, now that fork() has completed. */
	base_postfork_child();
	chunk_postfork_child();
	for (i = 0; i < narenas_total; i++) {
		if (arenas[i] != NULL)
			arena_postfork_child(arenas[i]);
	}
	malloc_mutex_postfork_child(&arenas_lock);
	prof_postfork_child();
	ctl_postfork_child();
}

// Assembly:
pushq %rbx
callq 0x2e060
callq 0x2f13a
movl 0x34587(%rip), %eax     # 0x5a670
testl %eax, %eax
je 0x2611b
movq 0x34584(%rip), %rcx     # 0x5a678
xorl %ebx, %ebx
movq (%rcx,%rbx,8), %rdi
testq %rdi, %rdi
je 0x26111
callq 0x2b89a
movq 0x3456d(%rip), %rcx     # 0x5a678
movl 0x3455f(%rip), %eax     # 0x5a670
incq %rbx
movl %eax, %edx
cmpq %rdx, %rbx
jb 0x260f6
leaq 0x34526(%rip), %rdi     # 0x5a648
callq 0x36ea0
callq 0x38a23
popq %rbx
jmp 0x2fa74
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/jemalloc.c
// Function: malloc_init_hard_a0
static bool
malloc_init_hard_a0(void)
{
	bool ret;

	malloc_mutex_lock(&init_lock);
	ret = malloc_init_hard_a0_locked();
	malloc_mutex_unlock(&init_lock);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x34224(%rip), %rbx     # 0x5a360
movq %rbx, %rdi
callq 0x106d0
callq 0x2615c
movl %eax, %ebp
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/jemalloc.c
// Function: stats_print_atexit
static void
stats_print_atexit(void)
{

	if (config_tcache && config_stats) {
		unsigned narenas, i;

		/*
		 * Merge stats from extant threads.  This is racy, since
		 * individual threads do not lock when recording tcache stats
		 * events.  As a consequence, the final stats may be slightly
		 * out of date by the time they are reported, if other threads
		 * continue to allocate.
		 */
		for (i = 0, narenas = narenas_total_get(); i < narenas; i++) {
			arena_t *arena = arenas[i];
			if (arena != NULL) {
				tcache_t *tcache;

				/*
				 * tcache_stats_merge() locks bins, so if any
				 * code is introduced that acquires both arena
				 * and bin locks in the opposite order,
				 * deadlocks may result.
				 */
				malloc_mutex_lock(&arena->lock);
				ql_foreach(tcache, &arena->tcache_ql, link) {
					tcache_stats_merge(tcache, arena);
				}
				malloc_mutex_unlock(&arena->lock);
			}
		}
	}
	je_malloc_stats_print(NULL, NULL, NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x33902(%rip), %rbx     # 0x5a648
movq %rbx, %rdi
callq 0x106d0
movl 0x3391b(%rip), %r12d    # 0x5a670
movq %rbx, %rdi
callq 0x10440
testq %r12, %r12
je 0x26dbb
movq 0x3390f(%rip), %rax     # 0x5a678
xorl %r13d, %r13d
movq (%rax,%r13,8), %rbx
testq %rbx, %rbx
je 0x26db3
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x106d0
movq 0xa8(%rbx), %r15
testq %r15, %r15
je 0x26da4
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3ccf2
movq (%r15), %r15
cmpq 0xa8(%rbx), %r15
jne 0x26d88
movq %r14, %rdi
callq 0x10440
movq 0x338c5(%rip), %rax     # 0x5a678
incq %r13
cmpq %r12, %r13
jne 0x26d6c
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x399bc
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_chunk_cache_maybe_insert
void
arena_chunk_cache_maybe_insert(arena_t *arena, extent_node_t *node, bool cache)
{

	if (cache) {
		extent_node_dirty_linkage_init(node);
		extent_node_dirty_insert(node, &arena->runs_dirty,
		    &arena->chunks_cache);
		arena->ndirty += arena_chunk_dirty_npages(node);
	}
}

// Assembly:
testl %edx, %edx
je 0x27084
leaq 0x28(%rsi), %rax
movq %rax, 0x30(%rsi)
movq %rsi, 0x40(%rsi)
leaq 0x158(%rdi), %rcx
leaq 0x168(%rdi), %rdx
movq 0x160(%rdi), %r8
movq %rax, (%r8)
movq %rcx, 0x28(%rsi)
movq %rax, 0x160(%rdi)
movq %r8, 0x30(%rsi)
movq 0x1a8(%rdi), %rax
movq %rsi, 0x38(%rax)
movq %rdx, 0x38(%rsi)
movq %rsi, 0x1a8(%rdi)
movq %rax, 0x40(%rsi)
movq 0x10(%rsi), %rax
shrq $0xc, %rax
addq %rax, 0xe8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_chunk_cache_maybe_remove
void
arena_chunk_cache_maybe_remove(arena_t *arena, extent_node_t *node, bool dirty)
{

	if (dirty) {
		extent_node_dirty_remove(node);
		assert(arena->ndirty >= arena_chunk_dirty_npages(node));
		arena->ndirty -= arena_chunk_dirty_npages(node);
	}
}

// Assembly:
testl %edx, %edx
je 0x270cb
leaq 0x28(%rsi), %rax
movq 0x28(%rsi), %rcx
movq 0x30(%rsi), %rdx
movq %rcx, (%rdx)
movq %rdx, 0x8(%rcx)
movq %rax, 0x28(%rsi)
movq %rax, 0x30(%rsi)
movq 0x38(%rsi), %rax
movq 0x40(%rsi), %rcx
movq %rax, 0x38(%rcx)
movq %rcx, 0x40(%rax)
movq %rsi, 0x38(%rsi)
movq %rsi, 0x40(%rsi)
movq 0x10(%rsi), %rax
shrq $0xc, %rax
subq %rax, 0xe8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_node_alloc
extent_node_t *
arena_node_alloc(arena_t *arena)
{
	extent_node_t *node;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
leaq 0x3f0(%rdi), %rbx
movq %rbx, %rdi
callq 0x106d0
movq 0x3e8(%r15), %rax
testq %rax, %rax
je 0x2712b
movq 0x50(%rax), %r14
testq %r14, %r14
je 0x2712b
cmpq %r14, %rax
jne 0x27108
movq 0x48(%rax), %rax
movq %rax, 0x3e8(%r15)
cmpq %r14, %rax
je 0x27142
movq 0x48(%r14), %rax
movq 0x50(%r14), %rcx
movq %rax, 0x48(%rcx)
movq 0x50(%r14), %rcx
movq %rcx, 0x50(%rax)
movq %r14, 0x48(%r14)
movq %r14, 0x50(%r14)
jmp 0x2714d
movq %rbx, %rdi
callq 0x10440
movl $0x68, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x2dd78
movq $0x0, 0x3e8(%r15)
movq %rbx, %rdi
callq 0x10440
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: je_arena_chunk_alloc_huge
void *
arena_chunk_alloc_huge(arena_t *arena, size_t usize, size_t alignment,
    bool *zero)
{
	void *ret;
	chunk_hooks_t chunk_hooks = CHUNK_HOOKS_INITIALIZER;
	size_t csize = CHUNK_CEILING(usize);

	malloc_mutex_lock(&arena->lock);

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

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

	if (config_stats && ret != NULL)
		stats_cactive_add(usize);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r12
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movq $0x0, 0x30(%r12)
leaq 0x344a3(%rip), %rax     # 0x5b6b0
movq (%rax), %rbp
leaq (%rsi,%rbp), %rax
notq %rbp
andq %rax, %rbp
leaq 0x8(%rdi), %r15
movq %r15, %rdi
callq 0x106d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x272ed
addq %rbx, 0x30(%r14)
movq %rbx, %r13
shrq $0xc, %r13
addq %r13, 0xe0(%r14)
movl $0x1, (%rsp)
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %rbp, %rcx
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %r9
callq 0x2e5fb
movq %rax, %r12
movq %r15, %rdi
callq 0x10440
testq %r12, %r12
jne 0x272a4
leaq 0xf(%rsp), %rax
movb $0x1, (%rax)
movq %rax, (%rsp)
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
movq %rbp, %rcx
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %r9
callq 0x2ead2
testq %rax, %rax
je 0x272c2
movq %rax, %r12
leaq 0x34afd(%rip), %rax     # 0x5bda8
lock
xaddq %rbx, (%rax)
movq %r12, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x106d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2b8f7
subq %rbx, 0x30(%r14)
subq %r13, 0xe0(%r14)
movq %r15, %rdi
callq 0x10440
xorl %r12d, %r12d
jmp 0x272b0
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x1000, %rsi           # imm = 0x1000
ja 0x2735a
leaq -0x1(%r14), %rax
shrq $0x3, %rax
leaq 0x20cb1(%rip), %rcx     # 0x47fc0
movzbl (%rcx,%rax), %eax
subl 0x34237(%rip), %eax     # 0x5b550
addl $-0x27, %eax
movq %r14, %xmm0
shufpd $0x2, 0x1ece6(%rip), %xmm0 # xmm0 = xmm0[0],mem[1]
movdqu 0x80(%rbx), %xmm1
paddq %xmm1, %xmm0
movdqu %xmm0, 0x80(%rbx)
movq 0xa0(%rbx), %rcx
leaq (%rax,%rax,2), %rax
incq (%rcx,%rax,8)
incq 0x10(%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x2da8d
jmp 0x27313
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movq $0x0, 0x30(%r12)
leaq 0x3430e(%rip), %rax     # 0x5b6b0
movq (%rax), %r13
leaq (%rdx,%r13), %rax
notq %r13
andq %rax, %r13
leaq 0x8(%rdi), %rbp
movq %rbp, %rdi
callq 0x106d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x27415
subq %r15, 0x30(%r14)
movq %r15, %rax
negq %rax
leaq 0x349d1(%rip), %rcx     # 0x5bda8
lock
xaddq %rax, (%rcx)
shrq $0xc, %r15
subq %r15, 0xe0(%r14)
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r13, %rcx
movl $0x1, %r8d
callq 0x2ebea
movq %rbp, %rdi
callq 0x10440
addq $0x38, %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/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x1000, %rsi           # imm = 0x1000
ja 0x27479
leaq -0x1(%r14), %rax
shrq $0x3, %rax
leaq 0x20b89(%rip), %rcx     # 0x47fc0
movzbl (%rcx,%rax), %eax
subl 0x3410f(%rip), %eax     # 0x5b550
incq 0x90(%rbx)
subq %r14, 0x80(%rbx)
addl $-0x27, %eax
movq 0xa0(%rbx), %rcx
leaq (%rax,%rax,2), %rax
movdqu 0x8(%rcx,%rax,8), %xmm0
paddq 0x20f35(%rip), %xmm0    # 0x483a0
movdqu %xmm0, 0x8(%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x2da8d
jmp 0x2743b
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x106d0
movq %r15, %rdi
movq %r12, %rsi
callq 0x27415
movq %r15, %rdi
movq %r14, %rsi
callq 0x272ed
movq %r12, %rax
movq 0xe0(%r15), %rcx
subq %r14, %rax
jae 0x274e7
subq %r12, %r14
movq %r14, %rax
shrq $0xc, %rax
addq %rax, %rcx
movq %rcx, 0xe0(%r15)
leaq 0x348c8(%rip), %rax     # 0x5bda8
lock
xaddq %r14, (%rax)
jmp 0x27507
movq %rax, %rdx
shrq $0xc, %rdx
subq %rdx, %rcx
movq %rcx, 0xe0(%r15)
negq %rax
leaq 0x348a6(%rip), %rcx     # 0x5bda8
lock
xaddq %rax, (%rcx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10440
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, (%rsp)
movq %rdi, %rbx
movq %rdx, %rbp
subq %rcx, %rbp
leaq 0x3416e(%rip), %rax     # 0x5b6b0
movq (%rax), %r14
leaq (%r14,%rdx), %r13
movq %r14, %rax
notq %rax
andq %rax, %r13
addq %rcx, %r14
andq %rax, %r14
addq $0x8, %rdi
movq %rdi, 0x8(%rsp)
callq 0x106d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x27415
movq %rbx, %rdi
movq %r12, %rsi
callq 0x272ed
subq %r14, %r13
jne 0x2758e
shrq $0xc, %rbp
subq %rbp, 0xe0(%rbx)
jmp 0x275f2
subq %r13, 0x30(%rbx)
movq %rbp, %rax
negq %rax
leaq 0x34809(%rip), %rcx     # 0x5bda8
lock
xaddq %rax, (%rcx)
shrq $0xc, %rbp
subq %rbp, 0xe0(%rbx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq $0x0, 0x30(%rsi)
leaq 0x340df(%rip), %rax     # 0x5b6b0
movq (%rax), %rdx
addq %rdx, %r12
notq %rdx
andq %r12, %rdx
addq (%rsp), %rdx
movq %rbx, %rdi
movq %r13, %rcx
movl $0x1, %r8d
callq 0x2ebea
movq 0x8(%rsp), %rdi
callq 0x10440
addq $0x48, %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/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq -0x40(%rsi), %r12
cmpq $-0x41, %r12
jb 0x278c8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq %r15, %rdi
callq 0x106d0
movq %r14, 0xd0(%rbx)
movq %rbx, %rdi
callq 0x278db
movq %r15, %rdi
callq 0x10440
cmpq $-0x41, %r12
setb %al
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/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:
movq 0xd0(%rdi), %rcx
testq %rcx, %rcx
js 0x278fe
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0xd8(%rdi)
je 0x278ff
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xe0(%rbx), %rax
shrq %cl, %rax
leaq 0x33da8(%rip), %r14     # 0x5b6b8
movq (%r14), %rcx
cmpq %rcx, %rax
cmovbeq %rcx, %rax
cmpq %rax, 0xe8(%rbx)
jbe 0x278f7
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2793f
movq 0xe0(%rbx), %rax
movb 0xd0(%rbx), %cl
shrq %cl, %rax
jmp 0x27910
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0x28585
movq 0x8(%r14), %r15
movq %rbx, %rdi
subq %r15, %rdi
movl $0xa5, %esi
movq %r15, %rdx
callq 0x10270
addq (%r14), %rbx
movq %rbx, %rdi
movl $0xa5, %esi
movq %r15, %rdx
jmp 0x28595
subq 0x8(%r14), %rbx
movq 0x10(%r14), %rdx
movq %rbx, %rdi
movl $0xa5, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x10270
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
subq 0x8(%rsi), %r14
xorl %edx, %edx
callq 0x285cc
movq 0x10(%rbx), %rdx
movq %r14, %rdi
movl $0x5a, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10270
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x32043(%rip), %rax     # 0x5a621
cmpb $0x1, (%rax)
jne 0x286d0
movq 0x8(%rsi), %r13
testq %r13, %r13
je 0x286d0
movl %edx, %ebx
movq %rdi, %r14
movq (%rsi), %r15
leaq -0x1(%rdi), %rbp
movl $0x1, %r12d
xorl %eax, %eax
movzbl (%rbp), %ecx
cmpl $0xa5, %ecx
je 0x28655
cmpq $0x1, %r12
leaq 0x17a14(%rip), %rdx     # 0x40033
leaq 0x1cc6a(%rip), %rax     # 0x45290
cmoveq %rax, %rdx
movl %ecx, (%rsp)
leaq 0x1fd9c(%rip), %rdi     # 0x483d0
movq %r12, %rsi
leaq 0x1fddb(%rip), %rcx     # 0x48419
movq %r14, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x3e4a4
movb $0x1, %al
testb %bl, %bl
je 0x28655
movb $-0x5b, (%rbp)
incq %r12
decq %rbp
cmpq %r13, %r12
jbe 0x28608
testq %r13, %r13
je 0x286c3
leaq (%r15,%r14), %r12
xorl %ebp, %ebp
movzbl (%r12,%rbp), %ecx
cmpl $0xa5, %ecx
je 0x286bb
cmpq $0x1, %rbp
leaq 0x179b0(%rip), %rdx     # 0x40033
leaq 0x1cc06(%rip), %rax     # 0x45290
cmoveq %rax, %rdx
movl %ecx, (%rsp)
leaq 0x1fd38(%rip), %rdi     # 0x483d0
movq %rbp, %rsi
leaq 0x1fd71(%rip), %rcx     # 0x48413
movq %r14, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x3e4a4
movb $0x1, %al
testb %bl, %bl
je 0x286bb
movb $-0x5b, (%rbp,%r12)
incq %rbp
cmpq %rbp, %r13
jne 0x2866b
leaq 0x31f56(%rip), %rcx     # 0x5a620
andb (%rcx), %al
cmpb $0x1, %al
je 0x286df
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x10090
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
cmpq $0x1000, %rsi           # imm = 0x1000
ja 0x28725
decq %rsi
shrq $0x3, %rsi
leaq 0x1f8c1(%rip), %rax     # 0x47fc0
movzbl (%rax,%rsi), %eax
movl %eax, %eax
leaq (%rax,%rax,2), %rax
shlq $0x5, %rax
leaq 0x31f8c(%rip), %rsi     # 0x5a6a0
addq %rax, %rsi
movq %rbx, %rdi
movl $0x1, %edx
popq %rbx
jmp 0x285cc
movq %rsi, %rdi
callq 0x2da8d
jmp 0x28703
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2dae7
testq %rax, %rax
jne 0x28c19
movq %r14, %rdi
callq 0x2b95a
testq %rax, %rax
je 0x28c24
movq 0x32970(%rip), %rcx     # 0x5b560
leaq (%rcx,%rax), %r15
addq $0x10, %r15
movzbl %bpl, %r8d
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x2bf9c
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
cmoveq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzbl %bpl, %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2dae7
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x31d1c(%rip), %rax     # 0x5b558
movq %rcx, %rdx
subq %rax, %rdx
movq 0x68(%rsi,%rdx,8), %rdx
shrq $0xd, %rdx
subq %rdx, %rcx
movq 0x31d0b(%rip), %rdx     # 0x5b560
addq %rsi, %rdx
leaq (%rcx,%rcx,2), %rcx
shlq $0x5, %rcx
addq %rdx, %rcx
negq %rax
leaq (%rax,%rax,2), %rax
shlq $0x5, %rax
movl 0x10(%rax,%rcx), %eax
imulq $0xe0, %rax, %rax
leaq (%rdi,%rax), %r12
addq $0x450, %r12            # imm = 0x450
movq %r12, %rdi
callq 0x106d0
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x2955a
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10440
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_dalloc_large_locked_impl
static void
arena_dalloc_large_locked_impl(arena_t *arena, arena_chunk_t *chunk,
    void *ptr, bool junked)
{
	size_t pageind = ((uintptr_t)ptr - (uintptr_t)chunk) >> LG_PAGE;
	arena_chunk_map_misc_t *miscelm = arena_miscelm_get(chunk, pageind);
	arena_run_t *run = &miscelm->run;

	if (config_fill || config_stats) {
		size_t usize = arena_mapbits_large_size_get(chunk, pageind) -
		    large_pad;

		if (!junked)
			arena_dalloc_junk_large(ptr, usize);
		if (config_stats) {
			szind_t index = size2index(usize) - NBINS;

			arena->stats.ndalloc_large++;
			arena->stats.allocated_large -= usize;
			arena->stats.lstats[index].ndalloc++;
			arena->stats.lstats[index].curruns--;
		}
	}

	arena_run_dalloc_decommit(arena, chunk, run);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %r12
subq %rsi, %r12
shrq $0xc, %r12
movq 0x31c69(%rip), %rbp     # 0x5b560
movq 0x31c5a(%rip), %r13     # 0x5b558
movq %r12, %rax
subq %r13, %rax
movq 0x68(%rsi,%rax,8), %r15
shrq %r15
andq $-0x1000, %r15          # imm = 0xF000
leaq -0x1000(%r15), %r8
testl %ecx, %ecx
jne 0x2992e
leaq 0x30cfd(%rip), %rax     # 0x5a622
cmpb $0x1, (%rax)
je 0x299be
cmpq $0x1000, %r8            # imm = 0x1000
ja 0x299ae
addq $-0x1001, %r15          # imm = 0xEFFF
shrq $0x3, %r15
leaq 0x1e677(%rip), %rax     # 0x47fc0
movzbl (%rax,%r15), %eax
negq %r13
addq %rbx, %rbp
leaq (%r12,%r12,2), %rcx
shlq $0x5, %rcx
addq %rbp, %rcx
leaq (,%r13,2), %rdx
addq %r13, %rdx
addl $-0x27, %eax
incq 0x70(%r14)
subq %r8, 0x60(%r14)
movq 0x98(%r14), %rsi
shlq $0x5, %rax
incq 0x8(%rsi,%rax)
shlq $0x5, %rdx
decq 0x18(%rsi,%rax)
addq %rcx, %rdx
addq $0x10, %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2d880
movq %r8, %rdi
movq %r8, %r15
callq 0x2da8d
movq %r15, %r8
jmp 0x2994e
movq %rdx, %rdi
movl $0x5a, %esi
movq %r8, %rdx
movq %r8, (%rsp)
callq 0x10270
movq (%rsp), %r8
jmp 0x2992e
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x36e96
leaq 0x1d8(%rbx), %rdi
callq 0x36e96
leaq 0x3c0(%rbx), %rdi
callq 0x36e96
leaq 0x3f0(%rbx), %rdi
callq 0x36e96
movl $0x450, %r14d           # imm = 0x450
leaq (%rbx,%r14), %rdi
callq 0x36e96
addq $0xe0, %r14
cmpq $0x2670, %r14           # imm = 0x2670
jne 0x2b81c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x450, %r14d           # imm = 0x450
leaq (%rbx,%r14), %rdi
callq 0x36e9b
addq $0xe0, %r14
cmpq $0x2670, %r14           # imm = 0x2670
jne 0x2b84a
leaq 0x3f0(%rbx), %rdi
callq 0x36e9b
leaq 0x3c0(%rbx), %rdi
callq 0x36e9b
leaq 0x1d8(%rbx), %rdi
callq 0x36e9b
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x36e9b
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x450, %r14d           # imm = 0x450
leaq (%rbx,%r14), %rdi
callq 0x36ea0
addq $0xe0, %r14
cmpq $0x2670, %r14           # imm = 0x2670
jne 0x2b8a7
leaq 0x3f0(%rbx), %rdi
callq 0x36ea0
leaq 0x3c0(%rbx), %rdi
callq 0x36ea0
leaq 0x1d8(%rbx), %rdi
callq 0x36ea0
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x36ea0
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x1000, %rsi           # imm = 0x1000
ja 0x2b950
leaq -0x1(%r14), %rax
shrq $0x3, %rax
leaq 0x1c6a7(%rip), %rcx     # 0x47fc0
movzbl (%rcx,%rax), %eax
subl 0x2fc2d(%rip), %eax     # 0x5b550
addl $-0x27, %eax
decq 0x88(%rbx)
subq %r14, 0x80(%rbx)
movq 0xa0(%rbx), %rcx
leaq (%rax,%rax,2), %rax
decq (%rcx,%rax,8)
decq 0x10(%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x2da8d
jmp 0x2b91d
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_bin_lower_run
static void
arena_bin_lower_run(arena_t *arena, arena_chunk_t *chunk, arena_run_t *run,
    arena_bin_t *bin)
{

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rsi), %rsi
cmpq %rdi, %rsi
jbe 0x2d019
cmpl $0x0, 0x4(%rsi)
je 0x2d006
movq %rbx, %rdi
callq 0x2d921
movq %r14, 0x28(%rbx)
incq 0xd0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2d921
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_bin_nonfull_run_tryget
static arena_run_t *
arena_bin_nonfull_run_tryget(arena_bin_t *bin)
{
	arena_run_t *run = arena_bin_runs_first(bin);
	if (run != NULL) {
		arena_bin_runs_remove(bin, run);
		if (config_stats)
			bin->stats.reruns++;
	}
	return (run);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rcx
leaq 0x38(%rdi), %rax
cmpq %rax, %rcx
je 0x2d04c
movq %rcx, %r14
movq (%rcx), %rcx
cmpq %rax, %rcx
jne 0x2d03f
jmp 0x2d04f
movq %rcx, %r14
cmpq %rax, %r14
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
je 0x2d064
xorl %r14d, %r14d
jmp 0x2d07a
addq $0x10, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2d085
incq 0xd0(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_run_alloc_small_helper
static arena_run_t *
arena_run_alloc_small_helper(arena_t *arena, size_t size, szind_t binind)
{
	arena_run_t *run = arena_run_first_best_fit(arena, size);
	if (run != NULL) {
		if (arena_run_split_small(arena, run, size, binind))
			run = NULL;
	}
	return (run);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r12
callq 0x2d6bb
testq %rax, %rax
je 0x2d553
movq %rax, %r14
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
movl %ebx, %ecx
callq 0x2d561
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
cmoveq %r14, %rax
jmp 0x2d555
xorl %eax, %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/arena.c
// Function: arena_run_split_small
static bool
arena_run_split_small(arena_t *arena, arena_run_t *run, size_t size,
    szind_t binind)
{
	arena_chunk_t *chunk;
	arena_chunk_map_misc_t *miscelm;
	size_t flag_dirty, flag_decommitted, run_ind, need_pages, i;

	assert(binind != BININD_INVALID);

	chunk = (arena_chunk_t *)CHUNK_ADDR2BASE(run);
	miscelm = arena_run_to_miscelm(run);
	run_ind = arena_miscelm_to_pageind(miscelm);
	flag_dirty = arena_mapbits_dirty_get(chunk, run_ind);
	flag_decommitted = arena_mapbits_decommitted_get(chunk, run_ind);
	need_pages = (size >> LG_PAGE);
	assert(need_pages > 0);

	if (flag_decommitted != 0 && arena->chunk_hooks.commit(chunk, chunksize,
	    run_ind << LG_PAGE, size, arena->ind))
		return (true);

	arena_run_split_remove(arena, chunk, run_ind, flag_dirty,
	    flag_decommitted, need_pages);

	for (i = 0; i < need_pages; i++) {
		size_t flag_unzeroed = arena_mapbits_unzeroed_get(chunk,
		    run_ind+i);
		arena_mapbits_small_set(chunk, run_ind+i, i, binind,
		    flag_unzeroed);
		if (config_debug && flag_dirty == 0 && flag_unzeroed == 0)
			arena_run_page_validate_zeroed(chunk, run_ind+i);
	}
	JEMALLOC_VALGRIND_MAKE_MEM_UNDEFINED((void *)((uintptr_t)chunk +
	    (run_ind << LG_PAGE)), (need_pages << LG_PAGE));
	return (false);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r15d
movq %rdx, %r9
movq %rdi, %r10
leaq 0x2e131(%rip), %rax     # 0x5b6b0
movq (%rax), %r14
notq %r14
leaq -0x10(%rsi), %rax
andq %r14, %rax
andq %rsi, %r14
addq 0x2dfca(%rip), %rax     # 0x5b560
negq %rax
addq %rsi, %rax
addq $-0x10, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq $0x6, %rdx
movq 0x2dfa0(%rip), %r12     # 0x5b558
addq %rdx, %r12
movq 0x68(%r14,%rdx,8), %rbx
movl %ebx, %ebp
andl $0x10, %ebp
movq %r9, %r13
shrq $0xc, %r13
andq $0x4, %rbx
movq %r9, 0x10(%rsp)
jne 0x2d5e8
movq %r10, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbp, %rcx
xorl %r8d, %r8d
jmp 0x2d627
leaq 0x2e0b9(%rip), %rax     # 0x5b6a8
movq (%rax), %rsi
movq %r12, %rdx
shlq $0xc, %rdx
movl (%r10), %r8d
movq %r14, %rdi
movq %r9, %rcx
movq %r10, 0x8(%rsp)
callq *0x428(%r10)
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x2d694
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbp, %rcx
movq %rbx, %r8
movq %r13, %r9
callq 0x2c229
movq 0x10(%rsp), %rsi
cmpq $0x1000, %rsi           # imm = 0x1000
jb 0x2d686
shll $0x5, %r15d
incl %r15d
leaq (%r14,%r12,8), %rax
addq $0x68, %rax
xorl %ecx, %ecx
movq 0x2df03(%rip), %rdx     # 0x5b558
shlq $0x3, %rdx
movq %rax, %rdi
subq %rdx, %rdi
negq %rdx
movq (%rdi), %r8
andl $0x8, %r8d
movq %rcx, %rdi
orq %r15, %rdi
orq %r8, %rdi
movq %rdi, (%rax,%rdx)
addq $0x8, %rax
addq $0x2000, %rcx           # imm = 0x2000
decq %r13
jne 0x2d64e
leaq 0x2cff7(%rip), %rax     # 0x5a684
cmpb $0x1, (%rax)
je 0x2d6a3
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
shlq $0xc, %r12
addq %r14, %r12
andq $-0x1000, %rsi          # imm = 0xF000
movq %r12, %rdi
callq 0x3e7a6
jmp 0x2d692
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_run_first_best_fit
static arena_run_t *
arena_run_first_best_fit(arena_t *arena, size_t size)
{
	size_t search_size = run_quantize_first(size);
	arena_chunk_map_misc_t *key = arena_miscelm_key_create(search_size);
	arena_chunk_map_misc_t *miscelm =
	    arena_avail_tree_nsearch(&arena->runs_avail, key);
	if (miscelm == NULL)
		return (NULL);
	return (&miscelm->run);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x2bf06
cmpq %r14, %rax
jae 0x2d77a
movq $-0x1, %rax
cmpq $0x3801, %r14           # imm = 0x3801
jb 0x2d74f
movq %r14, %rax
addq $-0x1000, %rax          # imm = 0xF000
js 0x2d85a
leaq -0x1(,%rax,2), %rax
bsrq %rax, %rcx
xorl %eax, %eax
movq %rcx, %rdx
subq $0x5, %rdx
cmovaeq %rdx, %rax
leal -0x3(%rcx), %edx
cmpq $0x6, %rcx
movzbl %dl, %edx
movl $0x3, %ecx
cmovael %edx, %ecx
leaq -0x1001(%r14), %rdx
shrq %cl, %rdx
shlq %cl, %rdx
shrq %cl, %rdx
andl $0x3, %edx
leal (%rdx,%rax,4), %ecx
incl %ecx
leaq 0x1a0fa(%rip), %rdx     # 0x47840
movl $0x1fff, %eax           # imm = 0x1FFF
addq (%rdx,%rcx,8), %rax
cmpq %r14, 0x2de1a(%rip)     # 0x5b570
jbe 0x2d77a
movq 0x2de19(%rip), %rcx     # 0x5b578
addq $0x1000, %r14           # imm = 0x1000
movq %r14, %rdx
shrq $0xc, %rdx
cmpb $0x1, (%rcx,%rdx)
jne 0x2d75f
cmpq %r14, %rax
cmovaeq %r14, %rax
movq 0xf0(%r15), %rbp
addq $0xf8, %r15
movq %r15, %rbx
cmpq %r15, %rbp
je 0x2d837
movabsq $0x7ffffffffffff000, %rdx # imm = 0x7FFFFFFFFFFFF000
leaq 0x2df0b(%rip), %rcx     # 0x5b6b0
movq (%rcx), %r12
movq 0x2ddb1(%rip), %r13     # 0x5b560
notq %r12
andq %rdx, %rax
movq %rax, %rdi
callq 0x2bf06
movq %rax, %r14
movq %r15, %rbx
movq %rbp, %rcx
andq %r12, %rcx
movq %rbp, %rax
subq %r13, %rax
subq %rcx, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rdx
shrq $0x6, %rdx
movq 0x68(%rcx,%rdx,8), %rdi
shrq %rdi
movabsq $0x7ffffffffffff000, %rax # imm = 0x7FFFFFFFFFFFF000
andq %rax, %rdi
callq 0x2bf06
xorl %ecx, %ecx
cmpq %rax, %r14
seta %cl
sbbl $0x0, %ecx
cmpq %rax, %r14
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovel %eax, %ecx
testl %ecx, %ecx
js 0x2d823
je 0x2d834
movq 0x8(%rbp), %rax
andq $-0x2, %rax
jmp 0x2d82a
movq (%rbp), %rax
movq %rbp, %rbx
movq %rax, %rbp
cmpq %r15, %rax
jne 0x2d7c3
jmp 0x2d837
movq %rbp, %rbx
xorl %ecx, %ecx
cmpq %r15, %rbx
cmovneq %rbx, %rcx
leaq 0x10(%rcx), %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movabsq $0x7ffffffffffff000, %rcx # imm = 0x7FFFFFFFFFFFF000
orq $0xfff, %rcx            # imm = 0xFFF
andq %rcx, %rax
cmpq $0x1, %rax
movl $0x40, %ecx
sbbq $0x0, %rcx
jmp 0x2d708
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/arena.c
// Function: arena_run_alloc_large_helper
static arena_run_t *
arena_run_alloc_large_helper(arena_t *arena, size_t size, bool zero)
{
	arena_run_t *run = arena_run_first_best_fit(arena, s2u(size));
	if (run != NULL) {
		if (arena_run_split_large(arena, run, size, zero))
			run = NULL;
	}
	return (run);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x1000, %rsi           # imm = 0x1000
ja 0x2db5d
leaq -0x1(%rbx), %rax
shrq $0x3, %rax
leaq 0x1a4b2(%rip), %rcx     # 0x47fc0
movzbl (%rcx,%rax), %eax
leaq 0x19d27(%rip), %rcx     # 0x47840
movq (%rcx,%rax,8), %rsi
movq %r14, %rdi
callq 0x2d6bb
testq %rax, %rax
je 0x2db50
movq %rax, %r15
movzbl %bpl, %r8d
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x2bf9c
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
cmoveq %r15, %rax
jmp 0x2db52
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1229f
movq (%r15), %rsi
jmp 0x2db1d
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/base.c
// Function: je_base_stats_get
void
base_stats_get(size_t *allocated, size_t *resident, size_t *mapped)
{

	malloc_mutex_lock(&base_mtx);
	assert(base_allocated <= base_resident);
	assert(base_resident <= base_mapped);
	*allocated = base_allocated;
	*resident = base_resident;
	*mapped = base_mapped;
	malloc_mutex_unlock(&base_mtx);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2d59f(%rip), %r12     # 0x5b580
movq %r12, %rdi
callq 0x106d0
movq 0x2d628(%rip), %rax     # 0x5b618
movq %rax, (%r15)
movq 0x2d626(%rip), %rax     # 0x5b620
movq %rax, (%r14)
movq 0x2d624(%rip), %rax     # 0x5b628
movq %rax, (%rbx)
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10440
// File: /workspace/github_c_makefile_star2_O3/gplessis[P]dotdeb-redis/deps/jemalloc/src/bitmap.c
// Function: je_bitmap_info_init
void
bitmap_info_init(bitmap_info_t *binfo, size_t nbits)
{
	unsigned i;
	size_t group_count;

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

	/*
	 * Compute the number of groups necessary to store nbits bits, and
	 * progressively work upward through the levels until reaching a level
	 * that requires only one group.
	 */
	binfo->levels[0].group_offset = 0;
	group_count = BITMAP_BITS2GROUPS(nbits);
	for (i = 1; group_count > 1; i++) {
		assert(i < BITMAP_MAX_LEVELS);
		binfo->levels[i].group_offset = binfo->levels[i-1].group_offset
		    + group_count;
		group_count = BITMAP_BITS2GROUPS(group_count);
	}
	binfo->levels[i].group_offset = binfo->levels[i-1].group_offset
	    + group_count;
	assert(binfo->levels[i].group_offset <= BITMAP_GROUPS_MAX);
	binfo->nlevels = i;
	binfo->nbits = nbits;
}

// Assembly:
movq $0x0, 0x10(%rdi)
leaq 0x3f(%rsi), %rax
movq %rax, %rdx
shrq $0x6, %rdx
cmpq $0x80, %rax
jb 0x2e0b0
movl $0x1, %eax
xorl %ecx, %ecx
movq %rdx, %r8
addq %r8, %rcx
movl %eax, %edx
movq %rcx, 0x10(%rdi,%rdx,8)
incl %eax
leaq 0x3f(%r8), %rdx
shrq $0x6, %rdx
cmpq $0x40, %r8
movq %rdx, %r8
ja 0x2e091
jmp 0x2e0b7
movl $0x1, %eax
xorl %ecx, %ecx
addq %rdx, %rcx
movl %eax, %edx
movq %rcx, 0x10(%rdi,%rdx,8)
movl %eax, 0x8(%rdi)
movq %rsi, (%rdi)
retq