LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x49f8f(%rip), %rbx     # 0x83758
movq %rbx, %rdi
callq 0x12960
movl 0x49fa8(%rip), %r12d    # 0x83780
movq %rbx, %rdi
callq 0x125c0
testq %r12, %r12
je 0x3983c
xorl %r13d, %r13d
movq 0x49f99(%rip), %rax     # 0x83788
movq (%rax,%r13,8), %rbx
testq %rbx, %rbx
je 0x39834
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x12960
movq 0xa8(%rbx), %r15
testq %r15, %r15
je 0x3982c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4ecea
movq (%r15), %r15
cmpq 0xa8(%rbx), %r15
jne 0x3980b
xorl %r15d, %r15d
jmp 0x3980b
movq %r14, %rdi
callq 0x125c0
incq %r13
cmpq %r12, %r13
jne 0x397e8
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4b9e0
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x12960
movq 0x3e8(%r15), %rax
testq %rax, %rax
je 0x39b8d
movq 0x50(%rax), %r14
jmp 0x39b90
xorl %r14d, %r14d
testq %r14, %r14
je 0x39ba0
testq %rax, %rax
je 0x39bb7
movq 0x50(%rax), %rcx
jmp 0x39bb9
movq %rbx, %rdi
callq 0x125c0
movl $0x68, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x3fe04
xorl %ecx, %ecx
cmpq %rcx, %rax
jne 0x39bc9
movq 0x48(%rax), %rax
movq %rax, 0x3e8(%r15)
cmpq %rcx, 0x3e8(%r15)
je 0x39bf4
movq 0x48(%rcx), %rax
movq 0x50(%rcx), %rdx
movq %rax, 0x48(%rdx)
movq 0x48(%rcx), %rax
movq 0x50(%rcx), %rdx
movq %rdx, 0x50(%rax)
movq %rcx, 0x48(%rcx)
movq %rcx, 0x50(%rcx)
jmp 0x39bff
movq $0x0, 0x3e8(%r15)
movq %rbx, %rdi
callq 0x125c0
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/jemalloc/src/arena.c
// Function: je_arena_node_dalloc
void
arena_node_dalloc(arena_t *arena, extent_node_t *node)
{

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x3f0(%rdi), %rbx
movq %rbx, %rdi
callq 0x12960
movq %r15, 0x48(%r15)
movq %r15, 0x50(%r15)
movq 0x3e8(%r14), %rax
testq %rax, %rax
je 0x39c60
movq 0x50(%rax), %rax
movq %rax, 0x50(%r15)
movq 0x3e8(%r14), %rcx
movq %rcx, 0x48(%r15)
movq %r15, 0x48(%rax)
movq 0x3e8(%r14), %rax
movq %r15, 0x50(%rax)
movq 0x48(%r15), %rax
movq %rax, 0x3e8(%r14)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x125c0
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x4a9e1(%rip), %rax     # 0x846a0
movq (%rax), %rbp
leaq (%rsi,%rbp), %rax
notq %rbp
andq %rax, %rbp
leaq 0x8(%rdi), %r15
movq %r15, %rdi
callq 0x12960
movq %r14, %rdi
movq %rbx, %rsi
callq 0x39d9f
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 0x406a5
movq %rax, %r12
movq %r15, %rdi
callq 0x125c0
testq %r12, %r12
jne 0x39d7c
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 0x40b77
movq %rax, %r12
testq %rax, %rax
jne 0x39d7c
movq %r15, %rdi
callq 0x12960
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3d97c
subq %rbx, 0x30(%r14)
subq %r13, 0xe0(%r14)
movq %r15, %rdi
callq 0x125c0
testq %r12, %r12
je 0x39d8d
leaq 0x4b010(%rip), %rax     # 0x84d98
lock
xaddq %rbx, (%rax)
movq %r12, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x4a860(%rip), %rax     # 0x846a0
movq (%rax), %r13
leaq (%rdx,%r13), %rax
notq %r13
andq %rax, %r13
leaq 0x8(%rdi), %rbp
movq %rbp, %rdi
callq 0x12960
movq %r14, %rdi
movq %r15, %rsi
callq 0x39eb3
subq %r15, 0x30(%r14)
movq %r15, %rax
negq %rax
leaq 0x4af23(%rip), %rcx     # 0x84d98
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 0x40c92
movq %rbp, %rdi
callq 0x125c0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x12960
movq %r15, %rdi
movq %r12, %rsi
callq 0x39eb3
movq %r15, %rdi
movq %r14, %rsi
callq 0x39d9f
movq %r12, %rax
movq 0xe0(%r15), %rcx
subq %r14, %rax
jae 0x39f7b
subq %r12, %r14
movq %r14, %rax
shrq $0xc, %rax
addq %rax, %rcx
movq %rcx, 0xe0(%r15)
leaq 0x4ae24(%rip), %rax     # 0x84d98
lock
xaddq %r14, (%rax)
jmp 0x39f9b
movq %rax, %rdx
shrq $0xc, %rdx
subq %rdx, %rcx
movq %rcx, 0xe0(%r15)
negq %rax
leaq 0x4ae02(%rip), %rcx     # 0x84d98
lock
xaddq %rax, (%rcx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x125c0
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x4a6ca(%rip), %rax     # 0x846a0
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 0x12960
movq %rbx, %rdi
movq %r15, %rsi
callq 0x39eb3
movq %rbx, %rdi
movq %r12, %rsi
callq 0x39d9f
subq %r14, %r13
jne 0x3a022
shrq $0xc, %rbp
subq %rbp, 0xe0(%rbx)
jmp 0x3a086
subq %r13, 0x30(%rbx)
movq %rbp, %rax
negq %rax
leaq 0x4ad65(%rip), %rcx     # 0x84d98
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 0x4a63b(%rip), %rax     # 0x846a0
movq (%rax), %rdx
addq %rdx, %r12
notq %rdx
andq %r12, %rdx
addq (%rsp), %rdx
movq %rbx, %rdi
movq %r13, %rcx
movl $0x1, %r8d
callq 0x40c92
movq 0x8(%rsp), %rdi
callq 0x125c0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/jemalloc/src/arena.c
// Function: je_arena_lg_dirty_mult_get
ssize_t
arena_lg_dirty_mult_get(arena_t *arena)
{
	ssize_t lg_dirty_mult;

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

	return (lg_dirty_mult);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x12960
movq 0xd0(%rbx), %rbx
movq %r14, %rdi
callq 0x125c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x3a346
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq %r15, %rdi
callq 0x12960
movq %r14, 0xd0(%rbx)
movq %rbx, %rdi
callq 0x3a359
movq %r15, %rdi
callq 0x125c0
cmpq $-0x41, %r12
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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:
cmpq $0x0, 0xd0(%rdi)
js 0x3a37a
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0xd8(%rdi)
je 0x3a37b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xe0(%rbx), %rax
movb 0xd0(%rbx), %cl
shrq %cl, %rax
leaq 0x4a316(%rip), %r14     # 0x846a8
movq (%r14), %rcx
cmpq %rcx, %rax
cmovbeq %rcx, %rax
cmpq %rax, 0xe8(%rbx)
jbe 0x3a373
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3a3c1
movq 0xe0(%rbx), %rax
movb 0xd0(%rbx), %cl
shrq %cl, %rax
jmp 0x3a392
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x3aff1
movq 0x8(%r14), %r15
movq %rbx, %rdi
subq %r15, %rdi
movl $0xa5, %esi
movq %r15, %rdx
callq 0x12380
addq (%r14), %rbx
movq %rbx, %rdi
movl $0xa5, %esi
movq %r15, %rdx
jmp 0x3b001
subq 0x8(%r14), %rbx
movq 0x10(%r14), %rdx
movq %rbx, %rdi
movl $0xa5, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x12380
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x3b038
movq 0x10(%rbx), %rdx
movq %r14, %rdi
movl $0x5a, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12380
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x3fb85
testq %rax, %rax
jne 0x3b66b
movq %r14, %rdi
callq 0x3d9df
testq %rax, %rax
je 0x3b676
movq 0x48f0e(%rip), %rcx     # 0x84550
leaq (%rcx,%rax), %r15
addq $0x10, %r15
movzbl %bpl, %r8d
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x3e02e
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 0x3fb85
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x48bd3(%rip), %rax     # 0x84548
movq %rcx, %rdx
subq %rax, %rdx
movq 0x68(%rsi,%rdx,8), %rdx
shrq $0xd, %rdx
subq %rdx, %rcx
movq 0x48bc2(%rip), %rdx     # 0x84550
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 0x12960
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x3b696
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x125c0
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x48b20(%rip), %rbp     # 0x84550
movq 0x48b11(%rip), %r13     # 0x84548
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 0x3ba67
leaq 0x47cd4(%rip), %rax     # 0x83732
cmpb $0x1, (%rax)
je 0x3baf7
cmpq $0x1000, %r8            # imm = 0x1000
ja 0x3bae7
addq $-0x1001, %r15          # imm = 0xEFFF
shrq $0x3, %r15
leaq 0x1dd7e(%rip), %rax     # 0x59800
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 $-0x24, %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 0x3f91d
movq %r8, %rdi
movq %r8, %r15
callq 0x3fb29
movq %r15, %r8
jmp 0x3ba87
movq %rdx, %rdi
movl $0x5a, %esi
movq %r8, %rdx
movq %r8, (%rsp)
callq 0x12380
movq (%rsp), %r8
jmp 0x3ba67
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/jemalloc/src/arena.c
// Function: je_arena_dss_prec_get
dss_prec_t
arena_dss_prec_get(arena_t *arena)
{
	dss_prec_t ret;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x12960
movl 0xc0(%rbx), %ebx
movq %r14, %rdi
callq 0x125c0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/jemalloc/src/arena.c
// Function: je_arena_dss_prec_set
bool
arena_dss_prec_set(arena_t *arena, dss_prec_t dss_prec)
{

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8(%rdi), %r15
movq %r15, %rdi
callq 0x12960
movl %ebx, 0xc0(%r14)
movq %r15, %rdi
callq 0x125c0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x48e82
leaq 0x1d8(%rbx), %rdi
callq 0x48e82
leaq 0x3c0(%rbx), %rdi
callq 0x48e82
leaq 0x3f0(%rbx), %rdi
callq 0x48e82
addq $0x450, %rbx            # imm = 0x450
xorl %r14d, %r14d
leaq (%rbx,%r14), %rdi
callq 0x48e82
addq $0xe0, %r14
cmpq $0x1f80, %r14           # imm = 0x1F80
jne 0x3d89b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x450(%rdi), %r14
xorl %r15d, %r15d
leaq (%r14,%r15), %rdi
callq 0x48e87
addq $0xe0, %r15
cmpq $0x1f80, %r15           # imm = 0x1F80
jne 0x3d8ce
leaq 0x3f0(%rbx), %rdi
callq 0x48e87
leaq 0x3c0(%rbx), %rdi
callq 0x48e87
leaq 0x1d8(%rbx), %rdi
callq 0x48e87
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x48e87
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x450(%rdi), %r14
xorl %r15d, %r15d
leaq (%r14,%r15), %rdi
callq 0x48e8c
addq $0xe0, %r15
cmpq $0x1f80, %r15           # imm = 0x1F80
jne 0x3d92e
leaq 0x3f0(%rbx), %rdi
callq 0x48e8c
leaq 0x3c0(%rbx), %rdi
callq 0x48e8c
leaq 0x1d8(%rbx), %rdi
callq 0x48e8c
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x48e8c
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/jemalloc/src/arena.c
// Function: arena_dalloc_bin_run
static void
arena_dalloc_bin_run(arena_t *arena, arena_chunk_t *chunk, arena_run_t *run,
    arena_bin_t *bin)
{

	assert(run != bin->runcur);
	assert(arena_run_tree_search(&bin->runs, arena_run_to_miscelm(run)) ==
	    NULL);

	malloc_mutex_unlock(&bin->lock);
	/******************************/
	malloc_mutex_lock(&arena->lock);
	arena_run_dalloc_decommit(arena, chunk, run);
	malloc_mutex_unlock(&arena->lock);
	/****************************/
	malloc_mutex_lock(&bin->lock);
	if (config_stats)
		bin->stats.curruns--;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, %rdi
callq 0x125c0
leaq 0x8(%r12), %r13
movq %r13, %rdi
callq 0x12960
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3f91d
movq %r13, %rdi
callq 0x125c0
movq %rbx, %rdi
callq 0x12960
decq 0xd8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x3f0e6
cmpl $0x0, 0x4(%rsi)
je 0x3f0d3
movq %rbx, %rdi
callq 0x3f9be
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 0x3f9be
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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), %rdx
leaq 0x38(%rdi), %rax
cmpq %rax, %rdx
je 0x3f119
movq %rdx, %rcx
movq (%rdx), %rdx
cmpq %rax, %rdx
jne 0x3f10c
jmp 0x3f11c
movq %rdx, %rcx
xorl %edx, %edx
cmpq %rax, %rcx
cmovneq %rcx, %rdx
leaq 0x10(%rdx), %r14
testq %rdx, %rdx
cmoveq %rdx, %r14
je 0x3f144
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3f14f
incq 0xd0(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3dfa2
movq %rax, %rdx
cmpq %r15, %rax
jae 0x3f81a
movq $-0x1, %rdx
cmpq $0x3801, %r15           # imm = 0x3801
jb 0x3f7ef
leaq -0x1000(%r15), %rdi
cmpq $0x1000, %rdi           # imm = 0x1000
ja 0x3f913
leaq -0x1001(%r15), %rax
shrq $0x3, %rax
leaq 0x1a027(%rip), %rcx     # 0x59800
movzbl (%rcx,%rax), %eax
incl %eax
leaq 0x1989a(%rip), %rcx     # 0x59080
movl $0x1fff, %edx           # imm = 0x1FFF
addq (%rcx,%rax,8), %rdx
cmpq %r15, 0x44d6a(%rip)     # 0x84560
jbe 0x3f81a
movq 0x44d69(%rip), %rax     # 0x84568
addq $0x1000, %r15           # imm = 0x1000
movq %r15, %rcx
shrq $0xc, %rcx
cmpb $0x1, (%rax,%rcx)
jne 0x3f7ff
cmpq %r15, %rdx
cmovaeq %r15, %rdx
movabsq $0x7ffffffffffff000, %rcx # imm = 0x7FFFFFFFFFFFF000
movq 0xf0(%rbx), %r12
addq $0xf8, %rbx
leaq 0x44e67(%rip), %rax     # 0x846a0
movq (%rax), %r13
notq %r13
movq 0x44d0a(%rip), %rax     # 0x84550
movq %rax, (%rsp)
andq %rcx, %rdx
movq %rbx, %r14
cmpq %r14, %r12
je 0x3f8f0
movq %rdx, %rbp
movq %rdx, %rdi
callq 0x3dfa2
movq %rax, %r15
movq %r12, %rcx
andq %r13, %rcx
movq (%rsp), %rax
leaq (%rax,%rcx), %rdx
movq %r12, %rax
subq %rdx, %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 0x3dfa2
xorl %ecx, %ecx
cmpq %rax, %r15
seta %cl
sbbl $0x0, %ecx
cmpq %rax, %r15
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovel %eax, %ecx
testl %ecx, %ecx
js 0x3f8d2
je 0x3f8da
movq 0x8(%r12), %rax
andq $-0x2, %rax
movb $0x1, %cl
movq %rbx, %r12
jmp 0x3f8df
movq (%r12), %rax
movb $0x1, %cl
jmp 0x3f8df
xorl %ecx, %ecx
movq %r12, %rax
movq %rbp, %rdx
movq %r12, %rbx
movq %rax, %r12
testb %cl, %cl
jne 0x3f850
xorl %ecx, %ecx
cmpq %r14, %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
callq 0x3fb29
jmp 0x3f7dd
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x3fbfb
leaq -0x1(%rbx), %rax
shrq $0x3, %rax
leaq 0x19c54(%rip), %rcx     # 0x59800
movzbl (%rcx,%rax), %eax
leaq 0x194c9(%rip), %rcx     # 0x59080
movq (%rcx,%rax,8), %rsi
movq %r14, %rdi
callq 0x3f782
testq %rax, %rax
je 0x3fbee
movq %rax, %r15
movzbl %bpl, %r8d
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x3e02e
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
cmoveq %r15, %rax
jmp 0x3fbf0
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 0x14b02
movq (%r15), %rsi
jmp 0x3fbbb
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x444f3(%rip), %r12     # 0x84570
movq %r12, %rdi
callq 0x12960
movq 0x4457c(%rip), %rax     # 0x84608
movq %rax, (%r15)
movq 0x4457a(%rip), %rax     # 0x84610
movq %rax, (%r14)
movq 0x44578(%rip), %rax     # 0x84618
movq %rax, (%rbx)
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x125c0
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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), %rdx
movq %rdx, %rcx
shrq $0x6, %rcx
movl $0x1, %eax
cmpq $0x80, %rdx
jb 0x40156
movl $0x1, %eax
leal -0x1(%rax), %edx
movq 0x10(%rdi,%rdx,8), %rdx
addq %rcx, %rdx
movl %eax, %r8d
movq %rdx, 0x10(%rdi,%r8,8)
incl %eax
leaq 0x3f(%rcx), %rdx
shrq $0x6, %rdx
cmpq $0x40, %rcx
movq %rdx, %rcx
ja 0x4012e
jmp 0x40159
movq %rcx, %rdx
leal -0x1(%rax), %ecx
addq 0x10(%rdi,%rcx,8), %rdx
movl %eax, %ecx
movq %rdx, 0x10(%rdi,%rcx,8)
movl %eax, 0x8(%rdi)
movq %rsi, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x12380
xorl %ecx, %ecx
subl (%rbx), %ecx
andl $0x3f, %ecx
je 0x401d3
movq 0x18(%rbx), %rax
shrq %cl, -0x8(%r14,%rax,8)
movl 0x8(%rbx), %eax
cmpq $0x2, %rax
jb 0x40200
decq %rax
xorl %edx, %edx
movl 0x10(%rbx,%rdx,8), %ecx
subl 0x18(%rbx,%rdx,8), %ecx
andl $0x3f, %ecx
je 0x401f8
movq 0x20(%rbx,%rdx,8), %rsi
shrq %cl, -0x8(%r14,%rsi,8)
incq %rdx
cmpq %rdx, %rax
jne 0x401e1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x411cc
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 0x4071f
addq $0x30, %rsp
testq %rax, %rax
je 0x402b7
movq %rax, %rbx
testq %rbx, %rbx
je 0x40326
leaq 0x434f5(%rip), %rax     # 0x83794
cmpb $0x1, (%rax)
jne 0x40328
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x507e2
jmp 0x40328
movq %r15, 0x10(%rsp)
movl 0x1c(%rsp), %eax
cmpl $0x1, %eax
movq %r14, %r15
jne 0x402f1
movq %rbp, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
movq %r13, %rcx
movq %r15, %r8
movq 0x10(%rsp), %r9
movl %eax, %r14d
callq 0x412ce
movq %rax, %rbx
movl %r14d, %eax
testq %rbx, %rbx
jne 0x4028f
testq %r12, %r12
je 0x4033a
cmpl $0x2, %eax
jne 0x4031f
movq %rbp, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
movq %r13, %rcx
movq %r15, %r8
movq 0x10(%rsp), %r9
callq 0x412ce
testq %rax, %rax
jne 0x4028c
xorl %ebx, %ebx
jmp 0x4028f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r15, %rdx
movq 0x10(%rsp), %rcx
movl %eax, %r14d
callq 0x4157c
movq %rax, %rbx
movl %r14d, %eax
testq %rbx, %rbx
jne 0x4028f
jmp 0x402f6
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/jemalloc/src/chunk.c
// Function: je_chunk_hooks_get
chunk_hooks_t
chunk_hooks_get(arena_t *arena)
{
	chunk_hooks_t chunk_hooks;

	malloc_mutex_lock(&arena->chunks_mtx);
	chunk_hooks = chunk_hooks_get_locked(arena);
	malloc_mutex_unlock(&arena->chunks_mtx);

	return (chunk_hooks);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3c0(%rsi), %r15
movq %r15, %rdi
callq 0x12960
movups 0x418(%rbx), %xmm0
movups 0x428(%rbx), %xmm1
movups 0x438(%rbx), %xmm2
movups %xmm0, (%r14)
movups %xmm1, 0x10(%r14)
movups %xmm2, 0x20(%r14)
movq 0x448(%rbx), %rax
movq %rax, 0x30(%r14)
movq %r15, %rdi
callq 0x125c0
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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
movb 0x20(%rsp), %r8b
leaq 0x7(%rsp), %r11
movb $0x1, (%r11)
leaq 0x200(%rdi), %rdx
leaq 0x270(%rdi), %rcx
subq $0x8, %rsp
movzbl %r8b, %r14d
movl $0x1, %r8d
pushq %r14
pushq %r11
pushq %rax
pushq %r10
pushq %rbx
callq 0x4071f
addq $0x30, %rsp
testq %rax, %rax
je 0x40711
movq %rax, %r14
leaq 0x43095(%rip), %rax     # 0x83794
cmpb $0x1, (%rax)
jne 0x40714
movq %r14, %rdi
movq %rbx, %rsi
callq 0x507e2
jmp 0x40714
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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, %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbp
callq 0x40bf6
movl (%rbp), %r9d
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
movq 0x40(%rsp), %r8
callq *(%r14)
testq %rax, %rax
je 0x40be2
movq %rax, %rbx
leaq -0x9b8(%rip), %rax      # 0x40208
cmpq %rax, (%r14)
je 0x40be4
leaq 0x42bc8(%rip), %rax     # 0x83794
cmpb $0x1, (%rax)
jne 0x40be4
movq 0x43ac0(%rip), %rsi     # 0x84698
movq %rbx, %rdi
callq 0x507e2
jmp 0x40be4
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x40cce
addq $0x20, %rsp
movq %rbx, %rdi
popq %rbx
jmp 0x3a359
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 %r12
pushq %rbx
movl %r9d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x40bf6
movl (%r12), %ecx
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq *0x8(%r15)
testb %al, %al
je 0x41086
testb %bpl, %bpl
je 0x41036
movl (%r12), %r8d
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq *0x18(%r15)
movl %eax, %ebp
movb $0x1, %al
testb %bpl, %bpl
je 0x41052
movl (%r12), %r8d
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq *0x20(%r15)
xorb $0x1, %al
leaq 0x2e0(%r12), %rdx
leaq 0x350(%r12), %rcx
subq $0x8, %rsp
movzbl %bpl, %r10d
movzbl %al, %eax
movq %r12, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
movq %r14, %r9
pushq %r10
pushq %rax
pushq %rbx
callq 0x40cce
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x40bf6
movl (%r12), %ecx
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq *0x8(%r15)
leaq -0xd5f(%rip), %rax      # 0x40363
cmpq %rax, 0x8(%r15)
je 0x410d4
leaq 0x426c5(%rip), %rax     # 0x83794
cmpb $0x1, (%rax)
je 0x410dd
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 0x507a0
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x41219
movl %edi, %ebx
movq 0x2ce0a(%rip), %r15     # 0x6dfe8
movq %fs:0x0, %r14
addq %r15, %r14
movl %fs:(%r15), %eax
testl %eax, %eax
je 0x41234
cmpl $0x2, %eax
je 0x4123e
movq %fs:0x30(%r15), %rax
testq %rax, %rax
je 0x41223
cmpl %ebx, %fs:0x38(%r15)
jbe 0x41223
movl %ebx, %ecx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x41223
popq %rbx
popq %r14
popq %r15
retq
popq %rbx
popq %r14
popq %r15
jmp 0x34670
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x348cd
movl $0x1, %fs:(%r15)
jmp 0x41246
movl $0x3, %fs:(%r15)
leaq 0x43bb7(%rip), %rax     # 0x84e04
movl (%rax), %edi
movq %r14, %rsi
callq 0x12990
testl %eax, %eax
je 0x411f7
leaq 0x18952(%rip), %rdi     # 0x59bb4
callq 0x4f37c
leaq 0x424c2(%rip), %rax     # 0x83730
cmpb $0x1, (%rax)
jne 0x411f7
callq 0x120c0
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x4342e(%rip), %rbx     # 0x846b0
movq %rbx, %rdi
callq 0x12960
movl 0x2ddc0(%rip), %ebp     # 0x6f050
movq %rbx, %rdi
callq 0x125c0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x43402(%rip), %r14     # 0x846b0
movq %r14, %rdi
callq 0x12960
movl %ebx, 0x2dd94(%rip)     # 0x6f050
movq %r14, %rdi
callq 0x125c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x431bc(%rip), %r14     # 0x846b0
movq %r14, %rdi
callq 0x12960
cmpq %rbx, 0x431e5(%rip)     # 0x846e8
setbe %al
cmpq %rbx, 0x431d3(%rip)     # 0x846e0
seta %bl
andb %al, %bl
movq %r14, %rdi
callq 0x125c0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/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 0x43184(%rip), %rdi     # 0x846b0
callq 0x48e30
movl %eax, %ebx
testb %al, %al
jne 0x41553
xorl %edi, %edi
callq 0x12460
movq %rax, 0x431a3(%rip)     # 0x846e8
movq %rax, 0x4318c(%rip)     # 0x846d8
movq %rax, 0x4318d(%rip)     # 0x846e0
movl %ebx, %eax
popq %rbx
retq