LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
testb $0x1, 0x4f869(%rip)     # 0xa2780
jne 0x52f30
callq 0x529d0
testb $0x1, %al
jne 0x52f24
jmp 0x52f30
movl $0xb, -0x34(%rbp)
jmp 0x53044
leaq 0x4a549(%rip), %rax     # 0x9d480
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x53002
jmp 0x52f53
jmp 0x52f55
jmp 0x52f57
jmp 0x52f59
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x52e60
cmpq $0x0, %rax
je 0x52faa
movq -0x40(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
movq -0x48(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
ja 0x52f8d
movl $0x2, -0x34(%rbp)
jmp 0x53044
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %esi
callq 0x53050
movq %rax, -0x40(%rbp)
jmp 0x52fef
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x530a0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rcx
movq -0x48(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x52fed
movl $0x2, -0x34(%rbp)
jmp 0x53044
jmp 0x52fef
jmp 0x52ff1
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x52f43
cmpq $0x0, -0x40(%rbp)
je 0x5303b
movq -0x40(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x5303b
movq -0x40(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq *%rax
movl %eax, -0x34(%rbp)
jmp 0x53042
movl $0x2, -0x34(%rbp)
jmp 0x53044
movl -0x34(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: je_ctl_boot
bool
ctl_boot(void)
{

	if (malloc_mutex_init(&ctl_mtx))
		return (true);

	ctl_initialized = false;

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x4f6a9(%rip), %rdi     # 0xa2788
callq 0x64360
testb $0x1, %al
jne 0x530ea
jmp 0x530f0
movb $0x1, -0x1(%rbp)
jmp 0x530fb
movb $0x0, 0x4f689(%rip)     # 0xa2780
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xbb8(%rax)
jne 0x531e2
leaq 0x4f41f(%rip), %rax     # 0xa25d0
movl (%rax), %eax
movl %eax, %edi
shlq $0x5, %rdi
callq 0x246c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xbb8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xbb8(%rax)
jne 0x531e0
movb $0x1, -0x1(%rbp)
jmp 0x5322a
jmp 0x531e2
movq -0x10(%rbp), %rax
cmpq $0x0, 0xbc0(%rax)
jne 0x53226
leaq 0x4f3dd(%rip), %rax     # 0xa25d4
movl (%rax), %eax
imulq $0x18, %rax, %rdi
callq 0x246c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xbc0(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xbc0(%rax)
jne 0x53224
movb $0x1, -0x1(%rbp)
jmp 0x5322a
jmp 0x53226
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x4dd3d(%rip), %rax     # 0xa1420
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $-0x1, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
xorl %esi, %esi
movl $0x78, %edx
callq 0x10250
movq -0x8(%rbp), %rax
movq $0x0, 0xa0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xa8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xb0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xb8(%rax)
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
xorl %esi, %esi
movl $0xaf8, %edx            # imm = 0xAF8
callq 0x10250
movq -0x8(%rbp), %rax
movq 0xbb8(%rax), %rdi
leaq 0x4ee44(%rip), %rax     # 0xa25d0
movl (%rax), %eax
movl %eax, %edx
shlq $0x5, %rdx
xorl %esi, %esi
callq 0x10250
movq -0x8(%rbp), %rax
movq 0xbc0(%rax), %rdi
leaq 0x4ee27(%rip), %rax     # 0xa25d4
movl (%rax), %eax
imulq $0x18, %rax, %rdx
xorl %esi, %esi
callq 0x10250
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: ctl_arena_refresh
static void
ctl_arena_refresh(arena_t *arena, unsigned i)
{
	ctl_arena_stats_t *astats = &ctl_stats.arenas[i];
	ctl_arena_stats_t *sstats = &ctl_stats.arenas[ctl_stats.narenas];

	ctl_arena_clear(astats);

	sstats->nthreads += astats->nthreads;
	if (config_stats) {
		ctl_arena_stats_amerge(astats, arena);
		/* Merge into sum stats as well. */
		ctl_arena_stats_smerge(sstats, astats);
	} else {
		astats->pactive += arena->nactive;
		astats->pdirty += arena->ndirty;
		/* Merge into sum stats as well. */
		sstats->pactive += arena->nactive;
		sstats->pdirty += arena->ndirty;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x4eeda(%rip), %rax     # 0xa27e0
movl -0xc(%rbp), %ecx
imulq $0xbc8, %rcx, %rcx      # imm = 0xBC8
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq 0x4eec2(%rip), %rax     # 0xa27e0
movl 0x4eeb4(%rip), %ecx     # 0xa27d8
imulq $0xbc8, %rcx, %rcx      # imm = 0xBC8
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x536d0
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x53970
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x53ae0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: ctl_arena_stats_amerge
static void
ctl_arena_stats_amerge(ctl_arena_stats_t *cstats, arena_t *arena)
{
	unsigned i;

	arena_stats_merge(arena, &cstats->dss, &cstats->lg_dirty_mult,
	    &cstats->pactive, &cstats->pdirty, &cstats->astats, cstats->bstats,
	    cstats->lstats, cstats->hstats);

	for (i = 0; i < NBINS; i++) {
		cstats->allocated_small += cstats->bstats[i].curregs *
		    index2size(i);
		cstats->nmalloc_small += cstats->bstats[i].nmalloc;
		cstats->ndalloc_small += cstats->bstats[i].ndalloc;
		cstats->nrequests_small += cstats->bstats[i].nrequests;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
addq $0x10, %rdx
movq -0x20(%rbp), %rcx
addq $0x18, %rcx
movq -0x20(%rbp), %r8
addq $0x20, %r8
movq -0x20(%rbp), %r9
addq $0x28, %r9
movq -0x20(%rbp), %r11
addq $0xc0, %r11
movq -0x20(%rbp), %rax
movq 0xbb8(%rax), %r10
movq -0x20(%rbp), %rax
movq 0xbc0(%rax), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x42d60
movl $0x0, -0x2c(%rbp)
cmpl $0x27, -0x2c(%rbp)
jae 0x53acb
movq -0x20(%rbp), %rax
addq $0xc0, %rax
movl -0x2c(%rbp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rcx
movl -0x2c(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %edx
leaq 0x3aadf(%rip), %rax     # 0x8e500
movq (%rax,%rdx,8), %rax
movq %rax, -0x10(%rbp)
imulq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
addq 0xa0(%rax), %rcx
movq %rcx, 0xa0(%rax)
movq -0x20(%rbp), %rax
addq $0xc0, %rax
movl -0x2c(%rbp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
addq 0xa8(%rax), %rcx
movq %rcx, 0xa8(%rax)
movq -0x20(%rbp), %rax
addq $0xc0, %rax
movl -0x2c(%rbp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
addq 0xb0(%rax), %rcx
movq %rcx, 0xb0(%rax)
movq -0x20(%rbp), %rax
addq $0xc0, %rax
movl -0x2c(%rbp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
addq 0xb8(%rax), %rcx
movq %rcx, 0xb8(%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x539e7
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq %r9, -0x48(%rbp)
movq 0x482a1(%rip), %rcx     # 0x9efe8
movq %fs:0x0, %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
setne %al
testb $0x1, %al
jne 0x56d6a
jmp 0x56e79
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x56df0
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x4825c(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl $0x50, %edx
callq 0x103b0
leaq 0x4c167(%rip), %rax     # 0xa2f14
movl (%rax), %edi
movq 0x48232(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0x106d0
cmpl $0x0, %eax
je 0x56deb
leaq 0x38266(%rip), %rdi     # 0x8f039
callq 0x7c0e0
leaq 0x4a8c1(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x56de9
callq 0x10070
jmp 0x56deb
jmp 0x56e77
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x56e73
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq 0x481d6(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl $0x50, %edx
callq 0x103b0
leaq 0x4c0e1(%rip), %rax     # 0xa2f14
movl (%rax), %edi
movq 0x481ac(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0x106d0
cmpl $0x0, %eax
je 0x56e71
leaq 0x381e0(%rip), %rdi     # 0x8f039
callq 0x7c0e0
leaq 0x4a83b(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x56e6f
callq 0x10070
jmp 0x56e71
jmp 0x56e75
jmp 0x56e75
jmp 0x56e77
jmp 0x56e79
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x56e8f
cmpq $0x0, -0x38(%rbp)
je 0x56e98
movl $0x1, -0x4c(%rbp)
jmp 0x56ee5
jmp 0x56e9a
movl $0xffffffff, -0x5c(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x40(%rbp)
je 0x56ec1
cmpq $0x4, -0x48(%rbp)
je 0x56eb8
movl $0x16, -0x4c(%rbp)
jmp 0x56ee5
movq -0x40(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
jmp 0x56ec3
cmpl $-0x1, -0x5c(%rbp)
jne 0x56ed2
movl $0xe, -0x4c(%rbp)
jmp 0x56ee5
movq -0x58(%rbp), %rdi
movl -0x5c(%rbp), %esi
callq 0x7bbd0
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/tcache.h
// Function: je_tcache_enabled_get
JEMALLOC_INLINE bool
tcache_enabled_get(void)
{
	tsd_t *tsd;
	tcache_enabled_t tcache_enabled;

	cassert(config_tcache);

	tsd = tsd_fetch();
	tcache_enabled = tsd_tcache_enabled_get(tsd);
	if (tcache_enabled == tcache_enabled_default) {
		tcache_enabled = (tcache_enabled_t)opt_tcache;
		tsd_tcache_enabled_set(tsd, tcache_enabled);
	}

	return ((bool)tcache_enabled);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
jmp 0x54f7a
movq 0x4a067(%rip), %rcx     # 0x9efe8
movq %fs:0x0, %rax
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x1, (%rax)
setne %al
testb $0x1, %al
jne 0x54fa4
jmp 0x550b3
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x5502a
movq -0x38(%rbp), %rax
movl $0x1, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x4a022(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x30(%rbp), %rsi
movl $0x50, %edx
callq 0x103b0
leaq 0x4df2d(%rip), %rax     # 0xa2f14
movl (%rax), %edi
movq 0x49ff8(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0x106d0
cmpl $0x0, %eax
je 0x55025
leaq 0x3a02c(%rip), %rdi     # 0x8f039
callq 0x7c0e0
leaq 0x4c687(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x55023
callq 0x10070
jmp 0x55025
jmp 0x550b1
movq -0x38(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x550ad
movq -0x38(%rbp), %rax
movl $0x3, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x49f9c(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x28(%rbp), %rsi
movl $0x50, %edx
callq 0x103b0
leaq 0x4dea7(%rip), %rax     # 0xa2f14
movl (%rax), %edi
movq 0x49f72(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0x106d0
cmpl $0x0, %eax
je 0x550ab
leaq 0x39fa6(%rip), %rdi     # 0x8f039
callq 0x7c0e0
leaq 0x4c601(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x550a9
callq 0x10070
jmp 0x550ab
jmp 0x550af
jmp 0x550af
jmp 0x550b1
jmp 0x550b3
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x44(%rbp)
cmpl $0x2, -0x44(%rbp)
jne 0x55104
leaq 0x4c37e(%rip), %rax     # 0xa1460
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rcx
movl -0x44(%rbp), %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x40(%rax)
cmpl $0x0, -0x44(%rbp)
setne %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/tcache.h
// Function: je_tcache_enabled_set
JEMALLOC_INLINE void
tcache_enabled_set(bool enabled)
{
	tsd_t *tsd;
	tcache_enabled_t tcache_enabled;

	cassert(config_tcache);

	tsd = tsd_fetch();

	tcache_enabled = (tcache_enabled_t)enabled;
	tsd_tcache_enabled_set(tsd, tcache_enabled);

	if (!enabled)
		tcache_cleanup(tsd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x29(%rbp)
jmp 0x55132
movq 0x49eaf(%rip), %rcx     # 0x9efe8
movq %fs:0x0, %rax
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
setne %al
testb $0x1, %al
jne 0x5515c
jmp 0x5526b
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x551e2
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x49e6a(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movl $0x50, %edx
callq 0x103b0
leaq 0x4dd75(%rip), %rax     # 0xa2f14
movl (%rax), %edi
movq 0x49e40(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0x106d0
cmpl $0x0, %eax
je 0x551dd
leaq 0x39e74(%rip), %rdi     # 0x8f039
callq 0x7c0e0
leaq 0x4c4cf(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x551db
callq 0x10070
jmp 0x551dd
jmp 0x55269
movq -0x28(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x55265
movq -0x28(%rbp), %rax
movl $0x3, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x49de4(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movl $0x50, %edx
callq 0x103b0
leaq 0x4dcef(%rip), %rax     # 0xa2f14
movl (%rax), %edi
movq 0x49dba(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0x106d0
cmpl $0x0, %eax
je 0x55263
leaq 0x39dee(%rip), %rdi     # 0x8f039
callq 0x7c0e0
leaq 0x4c449(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x55261
callq 0x10070
jmp 0x55263
jmp 0x55267
jmp 0x55267
jmp 0x55269
jmp 0x5526b
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x3c(%rbp), %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x40(%rax)
testb $0x1, -0x29(%rbp)
jne 0x552a5
movq -0x38(%rbp), %rdi
callq 0x7aee0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/tcache.h
// Function: je_tcache_flush
JEMALLOC_INLINE void
tcache_flush(void)
{
	tsd_t *tsd;

	cassert(config_tcache);

	tsd = tsd_fetch();
	tcache_cleanup(tsd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
jmp 0x552ba
movq 0x49d27(%rip), %rcx     # 0x9efe8
movq %fs:0x0, %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
setne %al
testb $0x1, %al
jne 0x552e4
jmp 0x553f3
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x5536a
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x49ce2(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl $0x50, %edx
callq 0x103b0
leaq 0x4dbed(%rip), %rax     # 0xa2f14
movl (%rax), %edi
movq 0x49cb8(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0x106d0
cmpl $0x0, %eax
je 0x55365
leaq 0x39cec(%rip), %rdi     # 0x8f039
callq 0x7c0e0
leaq 0x4c347(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x55363
callq 0x10070
jmp 0x55365
jmp 0x553f1
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x553ed
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq 0x49c5c(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl $0x50, %edx
callq 0x103b0
leaq 0x4db67(%rip), %rax     # 0xa2f14
movl (%rax), %edi
movq 0x49c32(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0x106d0
cmpl $0x0, %eax
je 0x553eb
leaq 0x39c66(%rip), %rdi     # 0x8f039
callq 0x7c0e0
leaq 0x4c2c1(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x553e9
callq 0x10070
jmp 0x553eb
jmp 0x553ef
jmp 0x553ef
jmp 0x553f1
jmp 0x553f3
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7aee0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq %r9, -0x48(%rbp)
movq 0x480d1(%rip), %rcx     # 0x9efe8
movq %fs:0x0, %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
setne %al
testb $0x1, %al
jne 0x56f3a
jmp 0x57049
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x56fc0
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x4808c(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl $0x50, %edx
callq 0x103b0
leaq 0x4bf97(%rip), %rax     # 0xa2f14
movl (%rax), %edi
movq 0x48062(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0x106d0
cmpl $0x0, %eax
je 0x56fbb
leaq 0x38096(%rip), %rdi     # 0x8f039
callq 0x7c0e0
leaq 0x4a6f1(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x56fb9
callq 0x10070
jmp 0x56fbb
jmp 0x57047
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x57043
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq 0x48006(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl $0x50, %edx
callq 0x103b0
leaq 0x4bf11(%rip), %rax     # 0xa2f14
movl (%rax), %edi
movq 0x47fdc(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0x106d0
cmpl $0x0, %eax
je 0x57041
leaq 0x38010(%rip), %rdi     # 0x8f039
callq 0x7c0e0
leaq 0x4a66b(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x5703f
callq 0x10070
jmp 0x57041
jmp 0x57045
jmp 0x57045
jmp 0x57047
jmp 0x57049
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5705f
cmpq $0x0, -0x38(%rbp)
je 0x57068
movl $0x1, -0x4c(%rbp)
jmp 0x570b5
jmp 0x5706a
movl $0xffffffff, -0x5c(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x40(%rbp)
je 0x57091
cmpq $0x4, -0x48(%rbp)
je 0x57088
movl $0x16, -0x4c(%rbp)
jmp 0x570b5
movq -0x40(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
jmp 0x57093
cmpl $-0x1, -0x5c(%rbp)
jne 0x570a2
movl $0xe, -0x4c(%rbp)
jmp 0x570b5
movq -0x58(%rbp), %rdi
movl -0x5c(%rbp), %esi
callq 0x7bc40
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x4b6ad(%rip), %rdi     # 0xa2788
callq 0x53170
movq -0x18(%rbp), %rax
movl 0x4b6ee(%rip), %ecx     # 0xa27d8
cmpq %rcx, %rax
jbe 0x570f9
movq $0x0, -0x20(%rbp)
jmp 0x57104
leaq 0x471f0(%rip), %rax     # 0x9e2f0
movq %rax, -0x20(%rbp)
leaq 0x4b67d(%rip), %rdi     # 0xa2788
callq 0x536b0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5714e
cmpq $0x0, -0x30(%rbp)
je 0x57157
movl $0x1, -0x34(%rbp)
jmp 0x571a2
jmp 0x57159
jmp 0x5715b
cmpq $0x0, -0x18(%rbp)
jne 0x57169
cmpq $0x0, -0x20(%rbp)
je 0x57172
movl $0x1, -0x34(%rbp)
jmp 0x571a2
jmp 0x57174
leaq 0x4b60d(%rip), %rdi     # 0xa2788
callq 0x53170
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %edi
callq 0x57ae0
leaq 0x4b5f2(%rip), %rdi     # 0xa2788
callq 0x536b0
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq 0x4aa11(%rip), %rdi     # 0xa2788
callq 0x53170
cmpq $0x0, -0x28(%rbp)
jne 0x57d8a
cmpq $0x0, -0x30(%rbp)
je 0x57d96
movl $0x1, -0x34(%rbp)
jmp 0x57e24
jmp 0x57d98
movq -0x20(%rbp), %rax
cmpq $0x4, (%rax)
je 0x57dab
movl $0x16, -0x34(%rbp)
jmp 0x57e24
movl 0x4aa27(%rip), %eax     # 0xa27d8
movl %eax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x57e1b
cmpq $0x0, -0x20(%rbp)
je 0x57e1b
movq -0x20(%rbp), %rax
cmpq $0x4, (%rax)
je 0x57e12
movq -0x20(%rbp), %rcx
movl $0x4, %eax
cmpq (%rcx), %rax
ja 0x57de5
movl $0x4, %eax
movq %rax, -0x48(%rbp)
jmp 0x57df0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0x103b0
movl $0x16, -0x34(%rbp)
jmp 0x57e24
movl -0x38(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x57e1d
movl $0x0, -0x34(%rbp)
leaq 0x4a95d(%rip), %rdi     # 0xa2788
callq 0x536b0
movl -0x34(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/ctl.c
// Function: arenas_initialized_ctl
static int
arenas_initialized_ctl(const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;
	unsigned nread, i;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq 0x4a921(%rip), %rdi     # 0xa2788
callq 0x53170
cmpq $0x0, -0x28(%rbp)
jne 0x57e7a
cmpq $0x0, -0x30(%rbp)
je 0x57e86
movl $0x1, -0x34(%rbp)
jmp 0x57f2e
jmp 0x57e88
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x4a943(%rip), %ecx     # 0xa27d8
shlq $0x0, %rcx
cmpq %rcx, %rax
je 0x57edf
movl $0x16, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x4a926(%rip), %ecx     # 0xa27d8
shlq $0x0, %rcx
cmpq %rcx, %rax
jae 0x57ecc
movq -0x20(%rbp), %rax
movq (%rax), %rax
shrq $0x0, %rax
movq %rax, -0x48(%rbp)
jmp 0x57ed6
movl 0x4a906(%rip), %eax     # 0xa27d8
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl %eax, -0x38(%rbp)
jmp 0x57eef
movl $0x0, -0x34(%rbp)
movl 0x4a8ec(%rip), %eax     # 0xa27d8
movl %eax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x38(%rbp), %eax
jae 0x57f2c
movq 0x4a8db(%rip), %rax     # 0xa27e0
movl -0x3c(%rbp), %ecx
imulq $0xbc8, %rcx, %rcx      # imm = 0xBC8
addq %rcx, %rax
movb (%rax), %dl
movq -0x18(%rbp), %rax
movl -0x3c(%rbp), %ecx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x57ef6
jmp 0x57f2e
leaq 0x4a853(%rip), %rdi     # 0xa2788
callq 0x536b0
movl -0x34(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x57ff4
cmpq $0x0, -0x20(%rbp)
je 0x57ff4
callq 0x42ca0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x57ff0
cmpq $0x0, -0x20(%rbp)
je 0x57ff0
movq -0x20(%rbp), %rax
cmpq $0x8, (%rax)
je 0x57fe5
movq -0x20(%rbp), %rcx
movl $0x8, %eax
cmpq (%rcx), %rax
ja 0x57fb8
movl $0x8, %eax
movq %rax, -0x50(%rbp)
jmp 0x57fc3
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq -0x40(%rbp), %rsi
callq 0x103b0
movl $0x16, -0x34(%rbp)
jmp 0x5802f
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x57ff2
jmp 0x57ff4
cmpq $0x0, -0x28(%rbp)
je 0x58028
cmpq $0x8, -0x30(%rbp)
je 0x5800b
movl $0x16, -0x34(%rbp)
jmp 0x5802f
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x42cf0
testb $0x1, %al
jne 0x5801d
jmp 0x58026
movl $0xe, -0x34(%rbp)
jmp 0x5802f
jmp 0x58028
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq 0x4a1d1(%rip), %rdi     # 0xa2788
callq 0x53170
cmpq $0x0, -0x28(%rbp)
jne 0x585ca
cmpq $0x0, -0x30(%rbp)
je 0x585d6
movl $0x1, -0x34(%rbp)
jmp 0x58668
jmp 0x585d8
callq 0x58bc0
testb $0x1, %al
jne 0x585e3
jmp 0x585ec
movl $0xb, -0x34(%rbp)
jmp 0x58668
movl 0x4a1e6(%rip), %eax     # 0xa27d8
subl $0x1, %eax
movl %eax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5865f
cmpq $0x0, -0x20(%rbp)
je 0x5865f
movq -0x20(%rbp), %rax
cmpq $0x4, (%rax)
je 0x58656
movq -0x20(%rbp), %rcx
movl $0x4, %eax
cmpq (%rcx), %rax
ja 0x58629
movl $0x4, %eax
movq %rax, -0x48(%rbp)
jmp 0x58634
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0x103b0
movl $0x16, -0x34(%rbp)
jmp 0x58668
movl -0x38(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x58661
movl $0x0, -0x34(%rbp)
leaq 0x4a119(%rip), %rdi     # 0xa2788
callq 0x536b0
movl -0x34(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x4937d(%rip), %rdi     # 0xa2788
callq 0x53170
movq -0x18(%rbp), %rax
movl 0x493be(%rip), %ecx     # 0xa27d8
cmpq %rcx, %rax
ja 0x59436
movq 0x493ba(%rip), %rax     # 0xa27e0
imulq $0xbc8, -0x18(%rbp), %rcx # imm = 0xBC8
addq %rcx, %rax
testb $0x1, (%rax)
jne 0x59440
movq $0x0, -0x20(%rbp)
jmp 0x5944b
leaq 0x45129(%rip), %rax     # 0x9e570
movq %rax, -0x20(%rbp)
leaq 0x49336(%rip), %rdi     # 0xa2788
callq 0x536b0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5f760
movq %rax, %rdi
callq 0x5f6d0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5f760
movq %rax, %rdi
callq 0x5f6d0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x20(%rbp), %rcx
cmpq -0x28(%rbp), %rcx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x5bf56
movq -0x8(%rbp), %rdi
callq 0x5f780
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5f780
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x30(%rbp), %rcx
cmpq -0x38(%rbp), %rcx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/huge.c
// Function: je_huge_malloc
void *
huge_malloc(tsd_t *tsd, arena_t *arena, size_t size, bool zero,
    tcache_t *tcache)
{
	size_t usize;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movb %cl, %al
movq %rdi, -0x80(%rbp)
movq %rsi, -0x88(%rbp)
movq %rdx, -0x90(%rbp)
andb $0x1, %al
movb %al, -0x91(%rbp)
movq %r8, -0xa0(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x1000, -0x70(%rbp)    # imm = 0x1000
setbe %al
testb $0x1, %al
jne 0x5f90a
jmp 0x5f965
movq -0x70(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
subq $0x1, %rcx
shrq $0x3, %rcx
leaq 0x2f353(%rip), %rax     # 0x8ec80
movzbl (%rax,%rcx), %eax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x2ebb8(%rip), %rax     # 0x8e500
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x5fa2d
movq -0x70(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
setl %al
testb $0x1, %al
jne 0x5f97b
jmp 0x5f99d
movq -0x28(%rbp), %rdx
shlq %rdx
movl $0x3f, %eax
movl $0x40, %ecx
cmpq $0x0, %rdx
cmovneq %rcx, %rax
movq %rax, -0xb0(%rbp)
jmp 0x5f9b4
movq -0x28(%rbp), %rdi
shlq %rdi
subq $0x1, %rdi
callq 0x63d20
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x6, -0x30(%rbp)
jae 0x5f9d4
movl $0x3, %eax
movq %rax, -0xb8(%rbp)
jmp 0x5f9e7
movq -0x30(%rbp), %rax
subq $0x2, %rax
subq $0x1, %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
addq -0x48(%rbp), %rax
movq -0x48(%rbp), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0xa8(%rbp)
jne 0x5fa4c
movq $0x0, -0x78(%rbp)
jmp 0x5fa84
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0xa8(%rbp), %rdx
leaq 0x42cc3(%rip), %rax     # 0xa2728
movq (%rax), %rcx
movb -0x91(%rbp), %al
movq -0xa0(%rbp), %r9
andb $0x1, %al
movzbl %al, %r8d
callq 0x5faa0
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x63a60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x63a90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x61da0
movq -0x18(%rbp), %rdi
callq 0x63b50
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x61dc0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x63a60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x63a90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x61da0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x63ce0
movq -0x20(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x61dc0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/rtree.h
// Function: je_rtree_get
JEMALLOC_INLINE extent_node_t *
rtree_get(rtree_t *rtree, uintptr_t key, bool dependent)
{
	uintptr_t subkey;
	unsigned i, start_level;
	rtree_node_elm_t *node, *child;

	start_level = rtree_start_level(rtree, key);

	for (i = start_level, node = rtree_subtree_tryread(rtree, start_level);
	    /**/; i++, node = child) {
		if (!dependent && unlikely(!rtree_node_valid(node)))
			return (NULL);
		subkey = rtree_subkey(rtree, key, i);
		if (i == rtree->height - 1) {
			/*
			 * node is a leaf, so it contains values rather than
			 * child pointers.
			 */
			return (rtree_val_read(rtree, &node[subkey],
			    dependent));
		}
		assert(i < rtree->height - 1);
		child = rtree_child_tryread(&node[subkey]);
	}
	not_reached();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x64150
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x641c0
movq %rax, -0x38(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x640c9
movq -0x38(%rbp), %rdi
callq 0x64220
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x640c9
movq $0x0, -0x8(%rbp)
jmp 0x64146
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x64240
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x64114
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x642a0
movq %rax, -0x8(%rbp)
jmp 0x64146
jmp 0x64116
jmp 0x64118
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x642f0
movq %rax, -0x40(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x6409d
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/mutex.c
// Function: je_malloc_mutex_postfork_child
void
malloc_mutex_postfork_child(malloc_mutex_t *mutex)
{

#ifdef JEMALLOC_MUTEX_INIT_CB
	malloc_mutex_unlock(mutex);
#else
	if (malloc_mutex_init(mutex)) {
		malloc_printf("<jemalloc>: Error re-initializing mutex in "
		    "child\n");
		if (opt_abort)
			abort();
	}
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x64360
testb $0x1, %al
jne 0x6446b
jmp 0x6448c
leaq 0x2ae11(%rip), %rdi     # 0x8f283
movb $0x0, %al
callq 0x7f490
leaq 0x3d220(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x6448a
callq 0x10070
jmp 0x6448c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/pages.c
// Function: je_pages_map
void *
pages_map(void *addr, size_t size)
{
	void *ret;

	assert(size != 0);

#ifdef _WIN32
	/*
	 * If VirtualAlloc can't allocate at the given address when one is
	 * given, it fails and returns NULL.
	 */
	ret = VirtualAlloc(addr, size, MEM_COMMIT | MEM_RESERVE,
	    PAGE_READWRITE);
#else
	/*
	 * We don't use MAP_FIXED here, because it can cause the *replacement*
	 * of existing mappings, and we only want to create new mappings.
	 */
	ret = mmap(addr, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON,
	    -1, 0);
	assert(ret != NULL);

	if (ret == MAP_FAILED)
		ret = NULL;
	else if (addr != NULL && ret != addr) {
		/*
		 * We succeeded in mapping memory, but not in the right place.
		 */
		pages_unmap(ret, size);
		ret = NULL;
	}
#endif
	assert(ret == NULL || (addr == NULL && ret != addr)
	    || (addr != NULL && ret == addr));
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x644c2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %r9d
callq 0x101b0
movq %rax, -0x18(%rbp)
jmp 0x644ea
movq $-0x1, %rax
cmpq %rax, -0x18(%rbp)
jne 0x64501
movq $0x0, -0x18(%rbp)
jmp 0x64529
cmpq $0x0, -0x8(%rbp)
je 0x64527
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x64527
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x64540
movq $0x0, -0x18(%rbp)
jmp 0x64529
jmp 0x6452b
jmp 0x6452d
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x645e6
movq -0x10(%rbp), %rax
subq -0x18(%rbp), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6460a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x64540
cmpq $0x0, -0x30(%rbp)
je 0x64622
movq -0x28(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x64540
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: prof_tctx_should_destroy
static bool
prof_tctx_should_destroy(prof_tctx_t *tctx)
{

	if (opt_prof_accum)
		return (false);
	if (tctx->cnts.curobjs != 0)
		return (false);
	if (tctx->prepared)
		return (false);
	return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
testb $0x1, 0x3e0a5(%rip)     # 0xa27f4
je 0x64757
movb $0x0, -0x1(%rbp)
jmp 0x6477c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x64768
movb $0x0, -0x1(%rbp)
jmp 0x6477c
movq -0x10(%rbp), %rax
testb $0x1, 0x58(%rax)
je 0x64778
movb $0x0, -0x1(%rbp)
jmp 0x6477c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_free_sampled_object
void
prof_free_sampled_object(tsd_t *tsd, size_t usize, prof_tctx_t *tctx)
{

	malloc_mutex_lock(tctx->tdata->lock);
	assert(tctx->cnts.curobjs > 0);
	assert(tctx->cnts.curbytes >= usize);
	tctx->cnts.curobjs--;
	tctx->cnts.curbytes -= usize;

	if (prof_tctx_should_destroy(tctx))
		prof_tctx_destroy(tsd, tctx);
	else
		malloc_mutex_unlock(tctx->tdata->lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x64720
jmp 0x653f5
jmp 0x653f7
jmp 0x653f9
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rdi
callq 0x64740
testb $0x1, %al
jne 0x6542b
jmp 0x6543a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x64790
jmp 0x65449
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x65380
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: prof_thr_uid_alloc
JEMALLOC_INLINE_C uint64_t
prof_thr_uid_alloc(void)
{
	uint64_t thr_uid;

	malloc_mutex_lock(&next_thr_uid_mtx);
	thr_uid = next_thr_uid;
	next_thr_uid++;
	malloc_mutex_unlock(&next_thr_uid_mtx);

	return (thr_uid);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x3c801(%rip), %rdi     # 0xa2e40
callq 0x64720
movq 0x3c7ed(%rip), %rax     # 0xa2e38
movq %rax, -0x8(%rbp)
movq 0x3c7e2(%rip), %rax     # 0xa2e38
addq $0x1, %rax
movq %rax, 0x3c7d7(%rip)     # 0xa2e38
leaq 0x3c7d8(%rip), %rdi     # 0xa2e40
callq 0x65380
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x3c6f1(%rip), %rdi     # 0xa2d80
callq 0x64720
movb 0x3c70e(%rip), %al      # 0xa2da8
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq 0x3c6da(%rip), %rdi     # 0xa2d80
callq 0x65380
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)