LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk_dss.c
// Function: je_chunk_dss_prec_get
dss_prec_t
chunk_dss_prec_get(void)
{
	dss_prec_t ret;

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

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

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

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

	cassert(have_dss);

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

	return (ret);
}

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

	cassert(have_dss);

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

	return (false);
}

// Assembly:
pushq %rbx
leaq 0x2d902(%rip), %rdi     # 0x576c0
callq 0x312bc
movl %eax, %ebx
testb %al, %al
jne 0x29de5
xorl %edi, %edi
callq 0x10320
movq %rax, 0x2d921(%rip)     # 0x576f8
movq %rax, 0x2d90a(%rip)     # 0x576e8
movq %rax, 0x2d90b(%rip)     # 0x576f0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk_mmap.c
// Function: je_chunk_alloc_mmap
void *
chunk_alloc_mmap(size_t size, size_t alignment, bool *zero, bool *commit)
{
	void *ret;
	size_t offset;

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

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

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

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

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

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

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

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

label_return:
	return(ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
cmpb $0x0, 0x2d7f5(%rip)     # 0x57700
jne 0x29f1b
callq 0x29f7a
testb %al, %al
je 0x29f1b
pushq $0xb
popq %rax
jmp 0x29f6c
leaq 0x8(%rsp), %rcx
movq $0x6, (%rcx)
leaq 0x40(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r13, %rdi
callq 0x2a098
testl %eax, %eax
jne 0x29f6c
movq 0x8(%rsp), %rsi
movq 0x38(%rsp,%rsi,8), %rcx
pushq $0x2
popq %rax
cmpb $0x1, (%rcx)
jne 0x29f6c
movq 0x20(%rcx), %r10
testq %r10, %r10
je 0x29f6c
leaq 0x10(%rsp), %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
callq *%r10
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: ctl_init
static bool
ctl_init(void)
{
	bool ret;

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2d780(%rip), %rdi     # 0x57708
callq 0x106d0
cmpb $0x0, 0x2d76c(%rip)     # 0x57700
jne 0x2a02e
callq 0x1c653
movl %eax, 0x2d7b3(%rip)     # 0x57758
incl %eax
imulq $0xbc8, %rax, %rdi      # imm = 0xBC8
callq 0x1c2a0
movq %rax, 0x2d7a6(%rip)     # 0x57760
movb $0x1, %bl
testq %rax, %rax
je 0x2a030
movl 0x2d790(%rip), %r14d    # 0x57758
leal 0x1(%r14), %ecx
imulq $0xbc8, %rcx, %rdx      # imm = 0xBC8
xorl %ebp, %ebp
movq %rax, %rdi
xorl %esi, %esi
callq 0x10270
movq 0x2d77a(%rip), %rdi     # 0x57760
cmpl %r14d, %ebp
ja 0x2a00c
movl %ebp, %r14d
imulq $0xbc8, %r14, %rax      # imm = 0xBC8
addq %rax, %rdi
callq 0x2a3e7
testb %al, %al
jne 0x2a049
incl %ebp
movl 0x2d74e(%rip), %r14d    # 0x57758
jmp 0x29fdf
movl %r14d, %eax
imulq $0xbc8, %rax, %rax      # imm = 0xBC8
movb $0x1, %bl
movb %bl, (%rdi,%rax)
andq $0x0, 0x2d745(%rip)     # 0x57768
callq 0x2a443
movb %bl, 0x2d6d2(%rip)      # 0x57700
xorl %ebx, %ebx
leaq 0x2d6d1(%rip), %rdi     # 0x57708
callq 0x10440
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
imulq $0xbc8, %r14, %r14      # imm = 0xBC8
xorl %r15d, %r15d
movq 0x2d706(%rip), %rdi     # 0x57760
cmpq %r15, %r14
je 0x2a089
movq 0xbb8(%rdi,%r15), %rdi
callq 0x1c41b
movq 0x2d6ed(%rip), %rax     # 0x57760
movq 0xbc0(%rax,%r15), %rdi
callq 0x1c41b
addq $0xbc8, %r15            # imm = 0xBC8
jmp 0x2a053
callq 0x1c41b
andq $0x0, 0x2d6ca(%rip)     # 0x57760
jmp 0x2a030
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: je_ctl_bymib
int
ctl_bymib(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
    void *newp, size_t newlen)
{
	int ret;
	const ctl_named_node_t *node;
	size_t i;

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

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

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

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

label_return:
	return(ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
cmpb $0x0, 0x2d407(%rip)     # 0x57700
jne 0x2a30c
callq 0x29f7a
testb %al, %al
je 0x2a30c
pushq $0xb
popq %rbx
jmp 0x2a398
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
leaq 0x28163(%rip), %rax     # 0x52480
xorl %r14d, %r14d
pushq $0x2
popq %rbx
cmpq %r14, %r13
je 0x2a364
movq 0x18(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x2a34c
movl 0x10(%rax), %edx
movq (%rbp,%r14,8), %rax
cmpq %rdx, %rax
jae 0x2a398
cltq
imulq $0x28, %rax, %rax
addq %rax, %rcx
movq %rcx, %rax
jmp 0x2a35f
movq (%rbp,%r14,8), %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq *0x8(%rcx)
testq %rax, %rax
je 0x2a398
incq %r14
jmp 0x2a323
testq %rax, %rax
je 0x2a398
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x2a398
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: ctl_arena_init
static bool
ctl_arena_init(ctl_arena_stats_t *astats)
{

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

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

	return (false);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0xbb8(%rdi)
jne 0x2a413
leaq 0x2d154(%rip), %rax     # 0x57550
movl (%rax), %edi
shlq $0x5, %rdi
callq 0x1c2a0
movq %rax, 0xbb8(%rbx)
testq %rax, %rax
je 0x2a43f
cmpq $0x0, 0xbc0(%rbx)
jne 0x2a43b
leaq 0x2d130(%rip), %rax     # 0x57554
movl (%rax), %eax
imulq $0x18, %rax, %rdi
callq 0x1c2a0
movq %rax, 0xbc0(%rbx)
testq %rax, %rax
je 0x2a43f
xorl %eax, %eax
jmp 0x2a441
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: ctl_arena_clear
static void
ctl_arena_clear(ctl_arena_stats_t *astats)
{

	astats->dss = dss_prec_names[dss_prec_limit];
	astats->lg_dirty_mult = -1;
	astats->pactive = 0;
	astats->pdirty = 0;
	if (config_stats) {
		memset(&astats->astats, 0, sizeof(arena_stats_t));
		astats->allocated_small = 0;
		astats->nmalloc_small = 0;
		astats->ndalloc_small = 0;
		astats->nrequests_small = 0;
		memset(astats->bstats, 0, NBINS * sizeof(malloc_bin_stats_t));
		memset(astats->lstats, 0, nlclasses *
		    sizeof(malloc_large_stats_t));
		memset(astats->hstats, 0, nhclasses *
		    sizeof(malloc_huge_stats_t));
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x2ba4b(%rip), %rax     # 0x563a0
movq 0x18(%rax), %rax
movq %rax, 0x8(%rdi)
orq $-0x1, 0x10(%rdi)
addq $0x18, %rdi
movl $0xba0, %edx            # imm = 0xBA0
xorl %esi, %esi
callq 0x10270
movq 0xbb8(%rbx), %rdi
leaq 0x2cbd0(%rip), %rax     # 0x57550
movl (%rax), %edx
shlq $0x5, %rdx
xorl %esi, %esi
callq 0x10270
movq 0xbc0(%rbx), %rdi
leaq 0x2cbb9(%rip), %rax     # 0x57554
movl (%rax), %eax
imulq $0x18, %rax, %rdx
xorl %esi, %esi
popq %rbx
jmp 0x10270
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: tcache_flush_ctl
static int
tcache_flush_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
    void *newp, size_t newlen)
{
	int ret;
	tsd_t *tsd;
	unsigned tcache_ind;

	if (!config_tcache)
		return (ENOENT);

	tsd = tsd_fetch();

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %r15
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq 0x2840c(%rip), %rax     # 0x53ff0
movq %fs:0x0, %rbx
addq %rax, %rbx
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x2bc34
cmpl $0x2, %ecx
je 0x2bc3d
orq %r12, %r13
je 0x2bc05
pushq $0x1
jmp 0x2bc29
pushq $0xe
popq %rax
testq %r14, %r14
je 0x2bc2a
cmpq $0x4, %r15
jne 0x2bc27
movl (%r14), %esi
cmpl $-0x1, %esi
je 0x2bc2a
movq %rbx, %rdi
callq 0x37b82
xorl %eax, %eax
jmp 0x2bc2a
pushq $0x16
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x1, %fs:(%rax)
jmp 0x2bc44
movl $0x3, %fs:(%rax)
leaq 0x2c1c9(%rip), %rax     # 0x57e14
movl (%rax), %edi
movq %rbx, %rsi
callq 0x106f0
testl %eax, %eax
je 0x2bbfc
leaq 0x17259(%rip), %rdi     # 0x42eb9
callq 0x37d1c
leaq 0x2a9b4(%rip), %rax     # 0x56620
cmpb $0x1, (%rax)
jne 0x2bbfc
callq 0x10090
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: tcache_create_ctl
static int
tcache_create_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
    void *newp, size_t newlen)
{
	int ret;
	tsd_t *tsd;
	unsigned tcache_ind;

	if (!config_tcache)
		return (ENOENT);

	tsd = tsd_fetch();

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %rbx
movq 0x28513(%rip), %rax     # 0x53ff0
movq %fs:0x0, %r15
addq %rax, %r15
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x2bb7e
cmpl $0x2, %ecx
je 0x2bb87
leaq 0x2bc04(%rip), %rdi     # 0x57708
callq 0x106d0
orq %r12, %r13
je 0x2bb12
pushq $0x1
jmp 0x2bb25
leaq 0x4(%rsp), %rsi
movq %r15, %rdi
callq 0x37ad8
testb %al, %al
je 0x2bb43
pushq $0xe
popq %rbp
leaq 0x2bbdb(%rip), %rdi     # 0x57708
callq 0x10440
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %rbx, %rbx
sete %al
testq %r14, %r14
sete %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x2bb26
movq (%r14), %rax
cmpq $0x4, %rax
jne 0x2bb66
movl 0x4(%rsp), %eax
movl %eax, (%rbx)
jmp 0x2bb26
pushq $0x4
popq %rdx
cmovbq %rax, %rdx
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x10400
pushq $0x16
jmp 0x2bb25
movl $0x1, %fs:(%rax)
jmp 0x2bb8e
movl $0x3, %fs:(%rax)
leaq 0x2c27f(%rip), %rax     # 0x57e14
movl (%rax), %edi
movq %r15, %rsi
callq 0x106f0
testl %eax, %eax
je 0x2bafd
leaq 0x1730b(%rip), %rdi     # 0x42eb9
callq 0x37d1c
leaq 0x2aa66(%rip), %rax     # 0x56620
cmpb $0x1, (%rax)
jne 0x2bafd
callq 0x10090
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: tcache_destroy_ctl
static int
tcache_destroy_ctl(const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;
	tsd_t *tsd;
	unsigned tcache_ind;

	if (!config_tcache)
		return (ENOENT);

	tsd = tsd_fetch();

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %r15
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq 0x2835e(%rip), %rax     # 0x53ff0
movq %fs:0x0, %rbx
addq %rax, %rbx
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x2bce2
cmpl $0x2, %ecx
je 0x2bceb
orq %r12, %r13
je 0x2bcb3
pushq $0x1
jmp 0x2bcd7
pushq $0xe
popq %rax
testq %r14, %r14
je 0x2bcd8
cmpq $0x4, %r15
jne 0x2bcd5
movl (%r14), %esi
cmpl $-0x1, %esi
je 0x2bcd8
movq %rbx, %rdi
callq 0x37ba8
xorl %eax, %eax
jmp 0x2bcd8
pushq $0x16
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x1, %fs:(%rax)
jmp 0x2bcf2
movl $0x3, %fs:(%rax)
leaq 0x2c11b(%rip), %rax     # 0x57e14
movl (%rax), %edi
movq %rbx, %rsi
callq 0x106f0
testl %eax, %eax
je 0x2bcaa
leaq 0x171ab(%rip), %rdi     # 0x42eb9
callq 0x37d1c
leaq 0x2a906(%rip), %rax     # 0x56620
cmpb $0x1, (%rax)
jne 0x2bcaa
callq 0x10090
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: arena_i_index
static const ctl_named_node_t *
arena_i_index(const size_t *mib, size_t miblen, size_t i)
{
	const ctl_named_node_t * ret;

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

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

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

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

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r15
movl 0x8(%rdi), %ebp
movq 0x28077(%rip), %rax     # 0x53ff0
movq %fs:0x0, %r13
addq %rax, %r13
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x2c020
cmpl $0x2, %ecx
je 0x2c029
pushq $0x1
popq %rcx
movq %r13, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x2a9a9
pushq $0xe
popq %rbp
testq %rax, %rax
je 0x2c00f
movq %rax, %r13
testq %r15, %r15
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
jne 0x2bfdc
movq %r13, %rdi
callq 0x22974
movq %rax, (%rsp)
movq (%r12), %rcx
cmpq $0x8, %rcx
jne 0x2bffa
movq %rax, (%r15)
testq %rbx, %rbx
je 0x2bff6
cmpq $0x8, %r14
jne 0x2c00c
movq (%rbx), %rsi
movq %r13, %rdi
callq 0x229a1
testb %al, %al
jne 0x2c00f
xorl %ebp, %ebp
jmp 0x2c00f
pushq $0x8
popq %rdx
cmovbq %rcx, %rdx
movq %rsp, %rsi
movq %r15, %rdi
callq 0x10400
pushq $0x16
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %fs:(%rax)
jmp 0x2c030
movl $0x3, %fs:(%rax)
leaq 0x2bddd(%rip), %rax     # 0x57e14
movl (%rax), %edi
movq %r13, %rsi
callq 0x106f0
testl %eax, %eax
je 0x2bf99
leaq 0x16e69(%rip), %rdi     # 0x42eb9
callq 0x37d1c
leaq 0x2a5c4(%rip), %rax     # 0x56620
cmpb $0x1, (%rax)
jne 0x2bf99
callq 0x10090
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: arena_purge
static void
arena_purge(unsigned arena_ind)
{
	tsd_t *tsd;
	unsigned i;
	bool refreshed;
	VARIABLE_ARRAY(arena_t *, tarenas, ctl_stats.narenas);

	tsd = tsd_fetch();
	for (i = 0, refreshed = false; i < ctl_stats.narenas; i++) {
		tarenas[i] = arena_get(tsd, i, false, false);
		if (tarenas[i] == NULL && !refreshed) {
			tarenas[i] = arena_get(tsd, i, false, true);
			refreshed = true;
		}
	}

	if (arena_ind == ctl_stats.narenas) {
		unsigned i;
		for (i = 0; i < ctl_stats.narenas; i++) {
			if (tarenas[i] != NULL)
				arena_purge_all(tarenas[i]);
		}
	} else {
		assert(arena_ind < ctl_stats.narenas);
		if (tarenas[arena_ind] != NULL)
			arena_purge_all(tarenas[arena_ind]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movl 0x2b4f0(%rip), %eax     # 0x57758
movq %rsp, %r13
leaq 0xf(,%rax,8), %rax
andq $-0x10, %rax
subq %rax, %r13
movq %r13, %rsp
movq 0x27d6c(%rip), %rax     # 0x53ff0
movq %fs:0x0, %r14
addq %rax, %r14
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x2c349
cmpl $0x2, %ecx
je 0x2c352
xorl %r15d, %r15d
xorl %r12d, %r12d
movl 0x2b4a8(%rip), %eax     # 0x57758
cmpq %rax, %r15
jae 0x2c2f3
movq %r14, %rdi
movl %r15d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2a9a9
movq %rax, (%r13,%r15,8)
testq %rax, %rax
setne %al
orb %r12b, %al
testb $0x1, %al
jne 0x2c2ee
movq %r14, %rdi
movl %r15d, %esi
xorl %edx, %edx
pushq $0x1
popq %rcx
callq 0x2a9a9
movq %rax, (%r13,%r15,8)
movb $0x1, %r12b
incq %r15
jmp 0x2c2aa
cmpl %ebx, %eax
jne 0x2c31b
xorl %r14d, %r14d
movl %ebx, %eax
cmpq %rax, %r14
jae 0x2c33a
movq (%r13,%r14,8), %rdi
testq %rdi, %rdi
je 0x2c316
callq 0x22f03
movl 0x2b442(%rip), %ebx     # 0x57758
incq %r14
jmp 0x2c2fa
movl %ebx, %eax
movq (%r13,%rax,8), %rdi
testq %rdi, %rdi
je 0x2c33a
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22f03
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %fs:(%rax)
jmp 0x2c359
movl $0x3, %fs:(%rax)
leaq 0x2bab4(%rip), %rax     # 0x57e14
movl (%rax), %edi
movq %r14, %rsi
callq 0x106f0
testl %eax, %eax
je 0x2c2a4
leaq 0x16b40(%rip), %rdi     # 0x42eb9
callq 0x37d1c
leaq 0x2a29b(%rip), %rax     # 0x56620
cmpb $0x1, (%rax)
jne 0x2c2a4
callq 0x10090
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: arenas_narenas_ctl
static int
arenas_narenas_ctl(const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;
	unsigned narenas;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r14
leaq 0x2b35a(%rip), %rdi     # 0x57708
callq 0x106d0
orq %r15, %r12
je 0x2c3bc
pushq $0x1
jmp 0x2c3d6
cmpq $0x4, (%rbx)
jne 0x2c3d4
xorl %ebx, %ebx
testq %r14, %r14
je 0x2c3d7
movl 0x2b389(%rip), %eax     # 0x57758
movl %eax, (%r14)
jmp 0x2c3d7
pushq $0x16
popq %rbx
leaq 0x2b32a(%rip), %rdi     # 0x57708
callq 0x10440
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: arenas_initialized_ctl
static int
arenas_initialized_ctl(const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;
	unsigned nread, i;

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %rbx
leaq 0x2b2fc(%rip), %rdi     # 0x57708
callq 0x106d0
orq %r15, %r12
je 0x2c41b
pushq $0x1
popq %rbx
jmp 0x2c45b
movq (%r14), %rax
movl 0x2b334(%rip), %ecx     # 0x57758
cmpq %rcx, %rax
movl %eax, %edx
cmovael %ecx, %edx
cmovel %ecx, %edx
movq 0x2b32a(%rip), %rsi     # 0x57760
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x2c450
movb (%rsi), %r8b
movb %r8b, (%rbx,%rdi)
incq %rdi
addq $0xbc8, %rsi            # imm = 0xBC8
jmp 0x2c438
xorl %edx, %edx
cmpq %rcx, %rax
pushq $0x16
popq %rbx
cmovel %edx, %ebx
leaq 0x2b2a6(%rip), %rdi     # 0x57708
callq 0x10440
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: arenas_lg_dirty_mult_ctl
static int
arenas_lg_dirty_mult_ctl(const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xbc8, %rsp            # imm = 0xBC8
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %rbx
leaq 0x2af92(%rip), %rdi     # 0x57708
callq 0x106d0
orq %r15, %r12
je 0x2c788
pushq $0x1
popq %rbp
jmp 0x2c89f
movl 0x2afca(%rip), %edi     # 0x57758
callq 0x1c564
pushq $0xb
popq %rbp
testq %rax, %rax
je 0x2c89f
movl 0x2afb3(%rip), %eax     # 0x57758
addl $0x2, %eax
imulq $0xbc8, %rax, %rdi      # imm = 0xBC8
callq 0x1c2a0
testq %rax, %rax
je 0x2c89f
movq %rax, %r15
movq 0x2af99(%rip), %rsi     # 0x57760
movl 0x2af8b(%rip), %eax     # 0x57758
incl %eax
imulq $0xbc8, %rax, %r12      # imm = 0xBC8
movq %r15, %rdi
movq %r12, %rdx
callq 0x10400
addq %r15, %r12
movl $0xbc8, %edx            # imm = 0xBC8
movq %r12, %rdi
xorl %esi, %esi
callq 0x10270
movq %r12, %rdi
callq 0x2a3e7
testb %al, %al
je 0x2c80c
movq %r15, %rdi
callq 0x1c41b
jmp 0x2c89f
movl 0x2af46(%rip), %ebp     # 0x57758
imulq $0xbc8, %rbp, %r13      # imm = 0xBC8
addq %r15, %r13
movq %rsp, %r12
movl $0xbc8, %edx            # imm = 0xBC8
movq %r12, %rdi
movq %r13, %rsi
callq 0x10400
leal 0x1(%rbp), %eax
imulq $0xbc8, %rax, %rbp      # imm = 0xBC8
addq %r15, %rbp
movl $0xbc8, %edx            # imm = 0xBC8
movq %r13, %rdi
movq %rbp, %rsi
callq 0x10400
movl $0xbc8, %edx            # imm = 0xBC8
movq %rbp, %rdi
movq %r12, %rsi
callq 0x10400
movq 0x2aefd(%rip), %rdi     # 0x57760
callq 0x1c41b
movq %r15, 0x2aef1(%rip)     # 0x57760
movl 0x2aee3(%rip), %eax     # 0x57758
leal 0x1(%rax), %ecx
movl %ecx, 0x2aeda(%rip)     # 0x57758
movl %eax, (%r12)
testq %rbx, %rbx
sete %cl
testq %r14, %r14
sete %dl
orb %cl, %dl
jne 0x2c89d
movq (%r14), %rcx
cmpq $0x4, %rcx
jne 0x2c8bf
movl %eax, (%rbx)
xorl %ebp, %ebp
leaq 0x2ae62(%rip), %rdi     # 0x57708
callq 0x10440
movl %ebp, %eax
addq $0xbc8, %rsp            # imm = 0xBC8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x4
popq %rdx
cmovbq %rcx, %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x10400
pushq $0x16
jmp 0x2c782
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: stats_arenas_i_index
static const ctl_named_node_t *
stats_arenas_i_index(const size_t *mib, size_t miblen, size_t i)
{
	const ctl_named_node_t * ret;

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

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

// Assembly:
pushq %rbx
movq %rdx, %rbx
leaq 0x2a89d(%rip), %rdi     # 0x57708
callq 0x106d0
movl 0x2a8e2(%rip), %eax     # 0x57758
cmpq %rbx, %rax
jae 0x2ce7f
xorl %ebx, %ebx
jmp 0x2ce9e
movq 0x2a8da(%rip), %rax     # 0x57760
imulq $0xbc8, %rbx, %rcx      # imm = 0xBC8
leaq 0x266dc(%rip), %rdx     # 0x53570
xorl %ebx, %ebx
cmpb $0x0, (%rax,%rcx)
cmovneq %rdx, %rbx
leaq 0x2a863(%rip), %rdi     # 0x57708
callq 0x10440
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/extent.c
// Function: extent_szad_comp
JEMALLOC_INLINE_C int
extent_szad_comp(extent_node_t *a, extent_node_t *b)
{
	int ret;
	size_t a_qsize = extent_quantize(extent_node_size_get(a));
	size_t b_qsize = extent_quantize(extent_node_size_get(b));

	/*
	 * Compare based on quantized size rather than size, in order to sort
	 * equally useful extents only by address.
	 */
	ret = (a_qsize > b_qsize) - (a_qsize < b_qsize);
	if (ret == 0) {
		uintptr_t a_addr = (uintptr_t)extent_node_addr_get(a);
		uintptr_t b_addr = (uintptr_t)extent_node_addr_get(b);

		ret = (a_addr > b_addr) - (a_addr < b_addr);
	}

	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0x2fcff
movq %rax, %r15
movq 0x10(%rbx), %rdi
callq 0x2fcff
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %r15
seta %al
sbbl $0x0, %eax
jne 0x2e8c4
movq 0x8(%r14), %rcx
xorl %eax, %eax
cmpq 0x8(%rbx), %rcx
seta %al
sbbl $0x0, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/huge.c
// Function: je_huge_malloc
void *
huge_malloc(tsd_t *tsd, arena_t *arena, size_t size, bool zero,
    tcache_t *tcache)
{
	size_t usize;

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

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

// Assembly:
movq %r8, %r9
movl %ecx, %eax
cmpq $0x1000, %rdx           # imm = 0x1000
ja 0x2fdc5
decq %rdx
shrq $0x3, %rdx
leaq 0x12d68(%rip), %rcx     # 0x42b00
movzbl (%rcx,%rdx), %ecx
leaq 0x125dd(%rip), %rdx     # 0x42380
movq (%rdx,%rcx,8), %r10
testq %r10, %r10
je 0x2fdc2
leaq 0x278f5(%rip), %rcx     # 0x576a8
movq (%rcx), %rcx
movzbl %al, %r8d
movq %r10, %rdx
jmp 0x2fe11
xorl %eax, %eax
retq
testq %rdx, %rdx
js 0x2fdfb
leaq -0x1(,%rdx,2), %rcx
bsrq %rcx, %r8
leal -0x3(%r8), %ecx
pushq $-0x1
popq %r11
shlq %cl, %r11
cmpq $0x6, %r8
notq %r11
pushq $0x7
popq %r10
cmovaeq %r11, %r10
addq %r10, %rdx
notq %r10
andq %rdx, %r10
jmp 0x2fda7
movq %rdx, %rcx
btrq $0x3f, %rcx
cmpq $0x1, %rcx
pushq $0x40
popq %r8
sbbq $0x0, %r8
jmp 0x2fdd6
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/huge.c
// Function: huge_ralloc_no_move_expand
static bool
huge_ralloc_no_move_expand(void *ptr, size_t oldsize, size_t usize, bool zero) {
	extent_node_t *node;
	arena_t *arena;
	bool is_zeroed_subchunk, is_zeroed_chunk;

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

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

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

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

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

	return (false);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r15d
movq %rdx, 0x20(%rsp)
movq %rsi, %r14
movq %rdi, %r12
callq 0x3110a
movq %rax, %r13
movq (%rax), %rbp
leaq 0x1d8(%rbp), %rbx
movq %rbx, %rdi
callq 0x106d0
movb 0x18(%r13), %al
movb %al, 0x6(%rsp)
movq %rbx, %rdi
callq 0x10440
leaq 0x7(%rsp), %r8
movl %r15d, 0x1c(%rsp)
movb %r15b, (%r8)
movq 0x20(%rsp), %r15
movq %rbp, %rdi
movq %r12, 0x8(%rsp)
movq %r12, %rsi
movq %r14, 0x10(%rsp)
movq %r14, %rdx
movq %r15, %rcx
callq 0x226e1
movl %eax, %ebp
testb %al, %al
jne 0x30aae
movq %rbx, %rdi
callq 0x106d0
movq %r15, 0x10(%r13)
movq %rbx, %rdi
callq 0x10440
cmpb $0x0, 0x1c(%rsp)
je 0x30a96
movq %r15, %rbx
cmpb $0x0, 0x6(%rsp)
jne 0x30a60
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
leaq (%rax,%rcx), %rdi
leaq 0x26c67(%rip), %rax     # 0x576b0
movq (%rax), %rdx
leaq (%rdx,%rcx), %rax
notq %rdx
andq %rax, %rdx
subq %rcx, %rdx
xorl %esi, %esi
callq 0x10270
cmpb $0x0, 0x7(%rsp)
jne 0x30aae
movq %rbx, %rdx
leaq 0x26c3f(%rip), %rax     # 0x576b0
movq (%rax), %rax
movq 0x10(%rsp), %rcx
addq %rax, %rcx
notq %rax
andq %rcx, %rax
movq 0x8(%rsp), %rdi
addq %rax, %rdi
subq %rax, %rdx
xorl %esi, %esi
callq 0x10270
jmp 0x30aae
leaq 0x25b96(%rip), %rax     # 0x56633
cmpb $0x1, (%rax)
je 0x30a2a
leaq 0x25b78(%rip), %rax     # 0x56621
cmpb $0x1, (%rax)
je 0x30abf
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdx
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdi
addq %rax, %rdi
subq %rax, %rdx
movl $0xa5, %esi
jmp 0x30a8f
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/rtree.h
// Function: huge_node_get
JEMALLOC_INLINE unsigned
rtree_start_level(rtree_t *rtree, uintptr_t key)
{
	unsigned start_level;

	if (unlikely(key == 0))
		return (rtree->height - 1);

	start_level = rtree->start_level[lg_floor(key) >>
	    LG_RTREE_BITS_PER_LEVEL];
	assert(start_level < rtree->height);
	return (start_level);
}

// Assembly:
testq %rdi, %rdi
je 0x311a5
bsrq %rdi, %rax
shrq $0x4, %rax
leaq 0x2651e(%rip), %rcx     # 0x57640
movl 0x14(%rcx,%rax,4), %edx
movl %edx, %eax
shlq $0x4, %rax
leaq 0x2650d(%rip), %rsi     # 0x57640
movq 0x28(%rsi,%rax), %r8
cmpq $0x1, %r8
ja 0x3114d
addq %rsi, %rax
addq $0x28, %rax
xorl %r8d, %r8d
lock
xaddq %r8, (%rax)
pushq %rbx
movl 0x10(%rsi), %r10d
movabsq $-0x1, %r9
movl %edx, %eax
shlq $0x4, %rax
xorl %ecx, %ecx
subb 0x34(%rsi,%rax), %cl
movq %rdi, %rbx
shrq %cl, %rbx
movb 0x30(%rsi,%rax), %cl
movq %r9, %r11
shlq %cl, %r11
notq %r11
andq %rbx, %r11
leal -0x1(%r10), %ecx
movq (%r8,%r11,8), %rax
cmpl %ecx, %edx
je 0x311a3
cmpq $0x1, %rax
ja 0x3119c
xorl %eax, %eax
lock
xaddq %rax, (%r8,%r11,8)
movl 0x10(%rsi), %r10d
incl %edx
movq %rax, %r8
jmp 0x3115c
popq %rbx
retq
leaq 0x26494(%rip), %rax     # 0x57640
movl 0x10(%rax), %edx
decl %edx
jmp 0x31126
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/huge.c
// Function: je_huge_salloc
size_t
huge_salloc(const void *ptr)
{
	size_t size;
	extent_node_t *node;
	arena_t *arena;

	node = huge_node_get(ptr);
	arena = extent_node_arena_get(node);
	malloc_mutex_lock(&arena->huge_mtx);
	size = extent_node_size_get(node);
	malloc_mutex_unlock(&arena->huge_mtx);

	return (size);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x3110a
movq %rax, %rbx
movl $0x1d8, %r14d           # imm = 0x1D8
addq (%rax), %r14
movq %r14, %rdi
callq 0x106d0
movq 0x10(%rbx), %rbx
movq %r14, %rdi
callq 0x10440
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/huge.c
// Function: je_huge_prof_tctx_get
prof_tctx_t *
huge_prof_tctx_get(const void *ptr)
{
	prof_tctx_t *tctx;
	extent_node_t *node;
	arena_t *arena;

	node = huge_node_get(ptr);
	arena = extent_node_arena_get(node);
	malloc_mutex_lock(&arena->huge_mtx);
	tctx = extent_node_prof_tctx_get(node);
	malloc_mutex_unlock(&arena->huge_mtx);

	return (tctx);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x3110a
movq %rax, %rbx
movl $0x1d8, %r14d           # imm = 0x1D8
addq (%rax), %r14
movq %r14, %rdi
callq 0x106d0
movq 0x20(%rbx), %rbx
movq %r14, %rdi
callq 0x10440
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/huge.c
// Function: je_huge_prof_tctx_set
void
huge_prof_tctx_set(const void *ptr, prof_tctx_t *tctx)
{
	extent_node_t *node;
	arena_t *arena;

	node = huge_node_get(ptr);
	arena = extent_node_arena_get(node);
	malloc_mutex_lock(&arena->huge_mtx);
	extent_node_prof_tctx_set(node, tctx);
	malloc_mutex_unlock(&arena->huge_mtx);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
callq 0x3110a
movq %rax, %r14
movl $0x1d8, %r15d           # imm = 0x1D8
addq (%rax), %r15
movq %r15, %rdi
callq 0x106d0
movq %rbx, 0x20(%r14)
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10440
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: je_size2index_compute
JEMALLOC_INLINE szind_t
size2index_compute(size_t size)
{

#if (NTBINS != 0)
	if (size <= (ZU(1) << LG_TINY_MAXCLASS)) {
		size_t lg_tmin = LG_TINY_MAXCLASS - NTBINS + 1;
		size_t lg_ceil = lg_floor(pow2_ceil(size));
		return (lg_ceil < lg_tmin ? 0 : lg_ceil - lg_tmin);
	}
#endif
	{
		size_t x = unlikely(ZI(size) < 0) ? ((size<<1) ?
		    (ZU(1)<<(LG_SIZEOF_PTR+3)) : ((ZU(1)<<(LG_SIZEOF_PTR+3))-1))
		    : lg_floor((size<<1)-1);
		size_t shift = (x < LG_SIZE_CLASS_GROUP + LG_QUANTUM) ? 0 :
		    x - (LG_SIZE_CLASS_GROUP + LG_QUANTUM);
		size_t grp = shift << LG_SIZE_CLASS_GROUP;

		size_t lg_delta = (x < LG_SIZE_CLASS_GROUP + LG_QUANTUM + 1)
		    ? LG_QUANTUM : x - LG_SIZE_CLASS_GROUP - 1;

		size_t delta_inverse_mask = ZI(-1) << lg_delta;
		size_t mod = ((((size-1) & delta_inverse_mask) >> lg_delta)) &
		    ((ZU(1) << LG_SIZE_CLASS_GROUP) - 1);

		size_t index = NTBINS + grp + mod;
		return (index);
	}
}

// Assembly:
testq %rdi, %rdi
js 0x312a4
leaq -0x1(,%rdi,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
pushq $0x3
popq %rcx
cmovael %edx, %ecx
decq %rdi
shrq %cl, %rdi
shlq %cl, %rdi
shrq %cl, %rdi
andl $0x3, %edi
leal (%rdi,%rax,4), %eax
retq
movq %rdi, %rax
btrq $0x3f, %rax
cmpq $0x1, %rax
pushq $0x40
popq %rcx
sbbq $0x0, %rcx
jmp 0x31274
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/pages.c
// Function: je_pages_trim
void *
pages_trim(void *addr, size_t alloc_size, size_t leadsize, size_t size)
{
	void *ret = (void *)((uintptr_t)addr + leadsize);

	assert(alloc_size >= leadsize + size);
#ifdef _WIN32
	{
		void *new_addr;

		pages_unmap(addr, alloc_size);
		new_addr = pages_map(ret, size);
		if (new_addr == ret)
			return (ret);
		if (new_addr)
			pages_unmap(new_addr, size);
		return (NULL);
	}
#else
	{
		size_t trailsize = alloc_size - leadsize - size;

		if (leadsize != 0)
			pages_unmap(addr, leadsize);
		if (trailsize != 0)
			pages_unmap((void *)((uintptr_t)ret + size), trailsize);
		return (ret);
	}
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq (%rcx,%rdx), %r13
testq %rdx, %rdx
je 0x3140b
movq %rbx, %rdi
movq %r12, %rsi
callq 0x31396
addq %r12, %rbx
cmpq %r13, %r15
je 0x31424
subq %r13, %r15
addq %rbx, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x31396
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_thread_active_init_get
bool
prof_thread_active_init_get(void)
{
	bool active_init;

	malloc_mutex_lock(&prof_thread_active_init_mtx);
	active_init = prof_thread_active_init;
	malloc_mutex_unlock(&prof_thread_active_init_mtx);
	return (active_init);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x26077(%rip), %rbx     # 0x57ce8
movq %rbx, %rdi
callq 0x106d0
movb 0x26090(%rip), %bpl     # 0x57d10
movq %rbx, %rdi
callq 0x10440
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_reset
void
prof_reset(tsd_t *tsd, size_t lg_sample)
{
	prof_tdata_t *next;

	assert(lg_sample < (sizeof(uint64_t) << 3));

	malloc_mutex_lock(&prof_dump_mtx);
	malloc_mutex_lock(&tdatas_mtx);

	lg_prof_sample = lg_sample;

	next = NULL;
	do {
		prof_tdata_t *to_destroy = tdata_tree_iter(&tdatas, next,
		    prof_tdata_reset_iter, NULL);
		if (to_destroy != NULL) {
			next = tdata_tree_next(&tdatas, to_destroy);
			prof_tdata_destroy_locked(tsd, to_destroy, false);
		} else
			next = NULL;
	} while (next != NULL);

	malloc_mutex_unlock(&tdatas_mtx);
	malloc_mutex_unlock(&prof_dump_mtx);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x25798(%rip), %rdi     # 0x577b0
callq 0x106d0
leaq 0x257b4(%rip), %rdi     # 0x577d8
callq 0x106d0
movq %r14, 0x257d0(%rip)     # 0x57800
xorl %r15d, %r15d
leaq 0x257d6(%rip), %r13     # 0x57810
leaq 0x257c7(%rip), %rbp     # 0x57808
movq 0x257c0(%rip), %rsi     # 0x57808
testq %r15, %r15
je 0x32057
movq %r15, %rdi
callq 0x32ef0
jmp 0x3205f
movq %rsi, %rdi
callq 0x32f53
movq %rax, %r14
cmpq %r13, %rax
je 0x320cd
testq %r14, %r14
je 0x320cd
movq 0x30(%r14), %rax
andq $-0x2, %rax
cmpq %r13, %rax
jne 0x320a8
movq %rbp, %rax
movq %r13, %r15
movq (%rax), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x32ecc
testl %eax, %eax
js 0x3209e
je 0x320b4
movq 0x30(%r12), %r12
andq $-0x2, %r12
jmp 0x32082
leaq 0x28(%r12), %rax
movq %r12, %r15
jmp 0x3207f
movq %rax, %r15
movq 0x28(%rax), %rax
cmpq %r13, %rax
jne 0x320a8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3213d
cmpq %r13, %r15
je 0x320cd
testq %r15, %r15
jne 0x32041
leaq 0x25704(%rip), %rdi     # 0x577d8
callq 0x10440
leaq 0x256d0(%rip), %rdi     # 0x577b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10440
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_active_get
bool
prof_active_get(void)
{
	bool prof_active_current;

	malloc_mutex_lock(&prof_active_mtx);
	prof_active_current = prof_active;
	malloc_mutex_unlock(&prof_active_mtx);
	return (prof_active_current);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x2519a(%rip), %rbx     # 0x57cb8
movq %rbx, %rdi
callq 0x106d0
movb 0x251b3(%rip), %bpl     # 0x57ce0
movq %rbx, %rdi
callq 0x10440
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_active_set
bool
prof_active_set(bool active)
{
	bool prof_active_old;

	malloc_mutex_lock(&prof_active_mtx);
	prof_active_old = prof_active;
	prof_active = active;
	malloc_mutex_unlock(&prof_active_mtx);
	return (prof_active_old);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x2516d(%rip), %r14     # 0x57cb8
movq %r14, %rdi
callq 0x106d0
movb 0x25186(%rip), %bpl     # 0x57ce0
movb %bl, 0x25180(%rip)      # 0x57ce0
movq %r14, %rdi
callq 0x10440
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_thread_name_get
const char *
prof_thread_name_get(void)
{
	tsd_t *tsd;
	prof_tdata_t *tdata;

	tsd = tsd_fetch();
	tdata = prof_tdata_get(tsd, true);
	if (tdata == NULL)
		return ("");
	return (tdata->thread_name != NULL ? tdata->thread_name : "");
}

// Assembly:
pushq %rax
movq 0x21479(%rip), %rax     # 0x53ff0
movq %fs:0x0, %rsi
addq %rax, %rsi
cmpl $0x2, %fs:(%rax)
je 0x32baf
movl $0x1, %fs:(%rax)
leaq 0x2527d(%rip), %rax     # 0x57e14
movl (%rax), %edi
callq 0x106f0
leaq 0x10314(%rip), %rdi     # 0x42eb9
callq 0x37d1c
callq 0x10090
movl $0x3, %fs:(%rax)
jmp 0x32b90
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_thread_active_set
bool
prof_thread_active_set(bool active)
{
	tsd_t *tsd;
	prof_tdata_t *tdata;

	tsd = tsd_fetch();
	tdata = prof_tdata_get(tsd, true);
	if (tdata == NULL)
		return (true);
	tdata->active = active;
	return (false);
}

// Assembly:
pushq %rax
movq 0x213e7(%rip), %rax     # 0x53ff0
movq %fs:0x0, %rsi
addq %rax, %rsi
cmpl $0x2, %fs:(%rax)
je 0x32c41
movl $0x1, %fs:(%rax)
leaq 0x251eb(%rip), %rax     # 0x57e14
movl (%rax), %edi
callq 0x106f0
leaq 0x10282(%rip), %rdi     # 0x42eb9
callq 0x37d1c
callq 0x10090
movl $0x3, %fs:(%rax)
jmp 0x32c22