LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/atomic.h
// Function: atomic_write_uint64
JEMALLOC_INLINE void
atomic_write_uint64(uint64_t *p, uint64_t x)
{

	asm volatile (
	    "xchgq %1, %0;" /* Lock is implied by xchgq. */
	    : "=m" (*p), "+r" (x) /* Outputs. */
	    : "m" (*p) /* Inputs. */
	    : "memory" /* Clobbers. */
	    );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
xchgq %rax, (%rcx)
movq %rax, -0x10(%rbp)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/base.c
// Function: base_chunk_alloc
static extent_node_t *
base_chunk_alloc(size_t minsize)
{
	extent_node_t *node;
	size_t csize, nsize;
	void *addr;

	assert(minsize != 0);
	node = base_node_try_alloc();
	/* Allocate enough space to also carve a node out if necessary. */
	nsize = (node == NULL) ? CACHELINE_CEILING(sizeof(extent_node_t)) : 0;
	csize = CHUNK_CEILING(minsize + nsize);
	addr = chunk_alloc_base(csize);
	if (addr == NULL) {
		if (node != NULL)
			base_node_dalloc(node);
		return (NULL);
	}
	base_mapped += csize;
	if (node == NULL) {
		node = (extent_node_t *)addr;
		addr = (void *)((uintptr_t)addr + nsize);
		csize -= nsize;
		if (config_stats) {
			base_allocated += nsize;
			base_resident += PAGE_CEILING(nsize);
		}
	}
	extent_node_init(node, NULL, addr, csize, true, true);
	return (node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
jmp 0x4f71e
callq 0x4fb00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl $0x80, %ecx
cmpq $0x0, %rdx
cmoveq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x28(%rbp), %rax
leaq 0x52fe3(%rip), %rcx     # 0xa2730
addq (%rcx), %rax
leaq 0x52fd9(%rip), %rcx     # 0xa2730
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x50400
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x4f796
cmpq $0x0, -0x18(%rbp)
je 0x4f789
movq -0x18(%rbp), %rdi
callq 0x4f8c0
movq $0x0, -0x8(%rbp)
jmp 0x4f828
movq -0x20(%rbp), %rax
addq 0x52f07(%rip), %rax     # 0xa26a8
movq %rax, 0x52f00(%rip)     # 0xa26a8
cmpq $0x0, -0x18(%rbp)
jne 0x4f802
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq 0x52ebb(%rip), %rax     # 0xa2698
movq %rax, 0x52eb4(%rip)     # 0xa2698
movq -0x28(%rbp), %rax
addq $0xfff, %rax            # imm = 0xFFF
andq $-0x1000, %rax          # imm = 0xF000
addq 0x52ea5(%rip), %rax     # 0xa26a0
movq %rax, 0x52e9e(%rip)     # 0xa26a0
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %r9d
movl %r9d, %r8d
callq 0x4f640
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/base.c
// Function: je_base_stats_get
void
base_stats_get(size_t *allocated, size_t *resident, size_t *mapped)
{

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x52ca5(%rip), %rdi     # 0xa2600
callq 0x4f6f0
jmp 0x4f962
jmp 0x4f964
jmp 0x4f966
movq 0x52d2b(%rip), %rcx     # 0xa2698
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq 0x52d25(%rip), %rcx     # 0xa26a0
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0x52d1f(%rip), %rcx     # 0xa26a8
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
leaq 0x52c69(%rip), %rdi     # 0xa2600
callq 0x4f920
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/base.c
// Function: je_base_boot
bool
base_boot(void)
{

	if (malloc_mutex_init(&base_mtx))
		return (true);
	extent_tree_szad_new(&base_avail_szad);
	base_nodes = NULL;

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x52c41(%rip), %rdi     # 0xa2600
callq 0x64360
testb $0x1, %al
jne 0x4f9ca
jmp 0x4f9d0
movb $0x1, -0x1(%rbp)
jmp 0x4f9eb
leaq 0x52c51(%rip), %rdi     # 0xa2628
callq 0x5bc00
movq $0x0, 0x52cc9(%rip) # 0xa26b0
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/base.c
// Function: base_node_try_alloc
static extent_node_t *
base_node_try_alloc(void)
{
	extent_node_t *node;

	if (base_nodes == NULL)
		return (NULL);
	node = base_nodes;
	base_nodes = *(extent_node_t **)node;
	JEMALLOC_VALGRIND_MAKE_MEM_UNDEFINED(node, sizeof(extent_node_t));
	return (node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x52ba0(%rip)     # 0xa26b0
jne 0x4fb1c
movq $0x0, -0x8(%rbp)
jmp 0x4fb67
movq 0x52b8d(%rip), %rax     # 0xa26b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x52b7b(%rip)     # 0xa26b0
leaq 0x51bc8(%rip), %rax     # 0xa1704
movb (%rax), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4fb5d
movq -0x10(%rbp), %rdi
movl $0x68, %esi
callq 0x7faa0
jmp 0x4fb5f
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/bitmap.c
// Function: je_bitmap_info_init
void
bitmap_info_init(bitmap_info_t *binfo, size_t nbits)
{
	unsigned i;
	size_t group_count;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x4fb8e
jmp 0x4fb90
jmp 0x4fb92
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x3f, %rax
shrq $0x6, %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x14(%rbp)
cmpq $0x1, -0x20(%rbp)
jbe 0x4fbfc
jmp 0x4fbbe
jmp 0x4fbc0
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movq 0x10(%rax,%rcx,8), %rdx
addq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movq %rdx, 0x10(%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x3f, %rax
shrq $0x6, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4fbb5
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movq 0x10(%rax,%rcx,8), %rdx
addq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movq %rdx, 0x10(%rax,%rcx,8)
jmp 0x4fc1f
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/bitmap.c
// Function: je_bitmap_init
void
bitmap_init(bitmap_t *bitmap, const bitmap_info_t *binfo)
{
	size_t extra;
	unsigned i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movq 0x10(%rax,%rcx,8), %rdx
shlq $0x3, %rdx
movl $0xff, %esi
callq 0x10250
movq -0x10(%rbp), %rax
movq (%rax), %rcx
andq $0x3f, %rcx
movl $0x40, %eax
subq %rcx, %rax
andq $0x3f, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4fd0b
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x18(%rdx), %rdx
subq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movq (%rax,%rdx,8), %rdx
shrq %cl, %rdx
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x4fda2
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq 0x10(%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
movl -0x1c(%rbp), %edx
subl $0x1, %edx
movl %edx, %edx
subq 0x10(%rcx,%rdx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
andq $0x3f, %rcx
movl $0x40, %eax
subq %rcx, %rax
andq $0x3f, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4fd92
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdx
movl -0x1c(%rbp), %esi
addl $0x1, %esi
movl %esi, %esi
movq 0x10(%rdx,%rsi,8), %rdx
subq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movq (%rax,%rdx,8), %rdx
shrq %cl, %rdx
movq -0x38(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x4fd94
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4fd12
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk.c
// Function: chunk_alloc_default
static void *
chunk_alloc_default(void *new_addr, size_t size, size_t alignment, bool *zero,
    bool *commit, unsigned arena_ind)
{
	void *ret;
	arena_t *arena;

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

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movl -0x34(%rbp), %edi
callq 0x51e70
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq -0x48(%rbp), %rax
movl 0xc0(%rax), %eax
movl %eax, (%rsp)
callq 0x52000
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x4fe1b
movq $0x0, -0x8(%rbp)
jmp 0x4fe4e
jmp 0x4fe1d
leaq 0x518e0(%rip), %rax     # 0xa1704
movb (%rax), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4fe44
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7faa0
jmp 0x4fe46
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk.c
// Function: je_chunk_hooks_get
chunk_hooks_t
chunk_hooks_get(arena_t *arena)
{
	chunk_hooks_t chunk_hooks;

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

	return (chunk_hooks);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
callq 0x50070
movq -0x8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x50090
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x38, %edx
callq 0x103b0
movq -0x8(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
callq 0x500d0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk.c
// Function: je_chunk_hooks_set
chunk_hooks_t
chunk_hooks_set(arena_t *arena, const chunk_hooks_t *chunk_hooks)
{
	chunk_hooks_t old_chunk_hooks;

	malloc_mutex_lock(&arena->chunks_mtx);
	old_chunk_hooks = arena->chunk_hooks;
	/*
	 * Copy each field atomically so that it is impossible for readers to
	 * see partially updated pointers.  There are places where readers only
	 * need one hook function pointer (therefore no need to copy the
	 * entirety of arena->chunk_hooks), and stale reads do not affect
	 * correctness, so they perform unlocked reads.
	 */
#define	ATOMIC_COPY_HOOK(n) do {					\
	union {								\
		chunk_##n##_t	**n;					\
		void		**v;					\
	} u;								\
	u.n = &arena->chunk_hooks.n;					\
	atomic_write_p(u.v, chunk_hooks->n);				\
} while (0)
	ATOMIC_COPY_HOOK(alloc);
	ATOMIC_COPY_HOOK(dalloc);
	ATOMIC_COPY_HOOK(commit);
	ATOMIC_COPY_HOOK(decommit);
	ATOMIC_COPY_HOOK(purge);
	ATOMIC_COPY_HOOK(split);
	ATOMIC_COPY_HOOK(merge);
#undef ATOMIC_COPY_HOOK
	malloc_mutex_unlock(&arena->chunks_mtx);

	return (old_chunk_hooks);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
callq 0x50070
movq -0x50(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x418, %rsi            # imm = 0x418
movl $0x38, %edx
callq 0x103b0
movq -0x8(%rbp), %rax
addq $0x418, %rax            # imm = 0x418
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x50250
jmp 0x50151
movq -0x8(%rbp), %rax
addq $0x418, %rax            # imm = 0x418
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x50250
jmp 0x50176
movq -0x8(%rbp), %rax
addq $0x418, %rax            # imm = 0x418
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x50250
jmp 0x5019b
movq -0x8(%rbp), %rax
addq $0x418, %rax            # imm = 0x418
addq $0x18, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x50250
jmp 0x501c0
movq -0x8(%rbp), %rax
addq $0x418, %rax            # imm = 0x418
addq $0x20, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x50250
jmp 0x501e5
movq -0x8(%rbp), %rax
addq $0x418, %rax            # imm = 0x418
addq $0x28, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x50250
jmp 0x5020a
movq -0x8(%rbp), %rax
addq $0x418, %rax            # imm = 0x418
addq $0x30, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x50250
movq -0x8(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
callq 0x500d0
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/rtree.h
// Function: je_rtree_set
JEMALLOC_INLINE bool
rtree_set(rtree_t *rtree, uintptr_t key, const extent_node_t *val)
{
	uintptr_t subkey;
	unsigned i, start_level;
	rtree_node_elm_t *node, *child;

	start_level = rtree_start_level(rtree, key);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x51840
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x518b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x50314
movb $0x1, -0x1(%rbp)
jmp 0x503a9
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x51910
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x50361
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x51970
movb $0x0, -0x1(%rbp)
jmp 0x503a9
jmp 0x50363
jmp 0x50365
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movl -0x2c(%rbp), %edx
callq 0x519a0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x50391
movb $0x1, -0x1(%rbp)
jmp 0x503a9
jmp 0x50393
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x5031a
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk.c
// Function: je_chunk_alloc_base
void *
chunk_alloc_base(size_t size)
{
	void *ret;
	bool zero, commit;

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

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movb $0x1, -0x19(%rbp)
movb $0x1, -0x1a(%rbp)
movq -0x10(%rbp), %rdi
movq 0x52309(%rip), %rsi     # 0xa2728
leaq -0x19(%rbp), %rdx
leaq -0x1a(%rbp), %rcx
callq 0x52720
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x50441
movq $0x0, -0x8(%rbp)
jmp 0x50474
jmp 0x50443
leaq 0x512ba(%rip), %rax     # 0xa1704
movb (%rax), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x5046a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7faa0
jmp 0x5046c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk.c
// Function: je_chunk_alloc_cache
void *
chunk_alloc_cache(arena_t *arena, chunk_hooks_t *chunk_hooks, void *new_addr,
    size_t size, size_t alignment, bool *zero, bool dalloc_node)
{
	void *ret;
	bool commit;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movb 0x10(%rbp), %al
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq %r9, -0x48(%rbp)
andb $0x1, %al
movb %al, -0x49(%rbp)
jmp 0x504b0
jmp 0x504b2
jmp 0x504b4
jmp 0x504b6
jmp 0x504b8
jmp 0x504ba
jmp 0x504bc
movb $0x1, -0x59(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x200, %rdx            # imm = 0x200
movq -0x20(%rbp), %rcx
addq $0x270, %rcx            # imm = 0x270
movq -0x30(%rbp), %r9
movq -0x38(%rbp), %r14
movq -0x40(%rbp), %rbx
movq -0x48(%rbp), %r11
movb -0x49(%rbp), %al
movl $0x1, %r8d
leaq -0x59(%rbp), %r10
andb $0x1, %al
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movzbl %al, %eax
movl %eax, 0x20(%rsp)
callq 0x50580
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x50531
movq $0x0, -0x18(%rbp)
jmp 0x50568
jmp 0x50533
jmp 0x50535
jmp 0x50537
leaq 0x511c6(%rip), %rax     # 0xa1704
movb (%rax), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x5055e
movq -0x58(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x7faa0
jmp 0x50560
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk.c
// Function: je_chunk_alloc_wrapper
void *
chunk_alloc_wrapper(arena_t *arena, chunk_hooks_t *chunk_hooks, void *new_addr,
    size_t size, size_t alignment, bool *zero, bool *commit)
{
	void *ret;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x50e70
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq 0x10(%rbp), %r8
movq -0x10(%rbp), %r9
movl (%r9), %r9d
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x50e1a
movq $0x0, -0x8(%rbp)
jmp 0x50e62
movq -0x18(%rbp), %rax
leaq -0x1075(%rip), %rcx     # 0x4fdb0
cmpq %rcx, (%rax)
je 0x50e5a
jmp 0x50e2c
leaq 0x508d1(%rip), %rax     # 0xa1704
movb (%rax), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x50e56
movq -0x40(%rbp), %rdi
movq 0x518d7(%rip), %rsi     # 0xa2728
callq 0x7faa0
jmp 0x50e58
jmp 0x50e5a
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk.c
// Function: je_chunk_dalloc_cache
void
chunk_dalloc_cache(arena_t *arena, chunk_hooks_t *chunk_hooks, void *chunk,
    size_t size, bool committed)
{

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0x50ec2
jmp 0x50ec4
jmp 0x50ec6
jmp 0x50ec8
jmp 0x50eca
jmp 0x50ecc
jmp 0x50ece
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x200, %rdx            # imm = 0x200
movq -0x8(%rbp), %rcx
addq $0x270, %rcx            # imm = 0x270
movq -0x18(%rbp), %r9
movq -0x20(%rbp), %r10
movb -0x21(%rbp), %al
movl $0x1, %r8d
xorl %r11d, %r11d
andb $0x1, %al
movq %r10, (%rsp)
movl $0x0, 0x8(%rsp)
movzbl %al, %eax
movl %eax, 0x10(%rsp)
callq 0x50f30
movq -0x8(%rbp), %rdi
callq 0x3d010
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk.c
// Function: je_chunk_dalloc_arena
void
chunk_dalloc_arena(arena_t *arena, chunk_hooks_t *chunk_hooks, void *chunk,
    size_t size, bool zeroed, bool committed)
{

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %r8d, -0x44(%rbp)
movq %rcx, %rax
movl -0x44(%rbp), %ecx
movq %rax, -0x40(%rbp)
movq %rdx, %rax
movq -0x40(%rbp), %rdx
movq %rax, -0x38(%rbp)
movq %rsi, %rax
movq -0x38(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq %rdi, %r8
movq -0x30(%rbp), %rdi
movb %r9b, %al
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %cl
movb %cl, -0x21(%rbp)
andb $0x1, %al
movb %al, -0x22(%rbp)
jmp 0x514c3
jmp 0x514c5
jmp 0x514c7
jmp 0x514c9
jmp 0x514cb
jmp 0x514cd
jmp 0x514cf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x50e70
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movb -0x22(%rbp), %dl
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
andb $0x1, %dl
movzbl %dl, %edx
callq *%rax
testb $0x1, %al
jne 0x51506
jmp 0x515b6
testb $0x1, -0x22(%rbp)
je 0x51530
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rdx
movl (%rdx), %r8d
xorl %edx, %edx
callq *%rax
andb $0x1, %al
movb %al, -0x22(%rbp)
movb $0x1, %al
testb $0x1, -0x22(%rbp)
movb %al, -0x45(%rbp)
je 0x5155f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rdx
movl (%rdx), %r8d
xorl %edx, %edx
callq *%rax
xorb $-0x1, %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x2e0, %rdx            # imm = 0x2E0
movq -0x8(%rbp), %rcx
addq $0x350, %rcx            # imm = 0x350
movq -0x18(%rbp), %r9
movq -0x20(%rbp), %r11
movb -0x21(%rbp), %r10b
movb -0x22(%rbp), %al
xorl %r8d, %r8d
andb $0x1, %r10b
andb $0x1, %al
movq %r11, (%rsp)
movzbl %r10b, %r10d
movl %r10d, 0x8(%rsp)
movzbl %al, %eax
movl %eax, 0x10(%rsp)
callq 0x50f30
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk.c
// Function: je_chunk_dalloc_wrapper
void
chunk_dalloc_wrapper(arena_t *arena, chunk_hooks_t *chunk_hooks, void *chunk,
    size_t size, bool committed)
{

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x50e70
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movb -0x21(%rbp), %dl
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
andb $0x1, %dl
movzbl %dl, %edx
callq *%rax
movq -0x10(%rbp), %rax
leaq -0x17b9(%rip), %rcx     # 0x4fe60
cmpq %rcx, 0x8(%rax)
je 0x5164c
jmp 0x51621
leaq 0x500dc(%rip), %rax     # 0xa1704
movb (%rax), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x51648
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7fa30
jmp 0x5164a
jmp 0x5164c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk.c
// Function: je_chunk_purge_arena
bool
chunk_purge_arena(arena_t *arena, void *chunk, size_t offset, size_t length)
{

	assert(chunk != NULL);
	assert(CHUNK_ADDR2BASE(chunk) == chunk);
	assert((offset & PAGE_MASK) == 0);
	assert(length != 0);
	assert((length & PAGE_MASK) == 0);

	return (pages_purge((void *)((uintptr_t)chunk + (uintptr_t)offset),
	    length));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x5167a
jmp 0x5167c
jmp 0x5167e
jmp 0x51680
jmp 0x51682
jmp 0x51684
jmp 0x51686
jmp 0x51688
jmp 0x5168a
movq -0x10(%rbp), %rdi
addq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x646b0
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk.c
// Function: je_chunk_boot
bool
chunk_boot(void)
{
#ifdef _WIN32
	SYSTEM_INFO info;
	GetSystemInfo(&info);

	/*
	 * Verify actual page size is equal to or an integral multiple of
	 * configured page size.
	 */
	if (info.dwPageSize & ((1U << LG_PAGE) - 1))
		return (true);

	/*
	 * Configure chunksize (if not set) to match granularity (usually 64K),
	 * so pages_map will always take fast path.
	 */
	if (!opt_lg_chunk) {
		opt_lg_chunk = jemalloc_ffs((int)info.dwAllocationGranularity)
		    - 1;
	}
#else
	if (!opt_lg_chunk)
		opt_lg_chunk = LG_CHUNK_DEFAULT;
#endif

	/* Set variables according to the value of opt_lg_chunk. */
	chunksize = (ZU(1) << opt_lg_chunk);
	assert(chunksize >= PAGE);
	chunksize_mask = chunksize - 1;
	chunk_npages = (chunksize >> LG_PAGE);

	if (have_dss && chunk_dss_boot())
		return (true);
	if (rtree_new(&chunks_rtree, (ZU(1) << (LG_SIZEOF_PTR+3)) -
	    opt_lg_chunk, chunks_rtree_node_alloc, NULL))
		return (true);

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x50f98(%rip)     # 0xa26b8
jne 0x5172d
movq $0x15, 0x50f8b(%rip) # 0xa26b8
movq 0x50f84(%rip), %rcx     # 0xa26b8
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x50fe5(%rip)     # 0xa2728
jmp 0x51745
movq 0x50fdc(%rip), %rax     # 0xa2728
subq $0x1, %rax
movq %rax, 0x50fd9(%rip)     # 0xa2730
movq 0x50fca(%rip), %rax     # 0xa2728
shrq $0xc, %rax
movq %rax, 0x50fcf(%rip)     # 0xa2738
callq 0x52660
testb $0x1, %al
jne 0x51774
jmp 0x5177a
movb $0x1, -0x1(%rbp)
jmp 0x517af
movl $0x40, %eax
subq 0x50f32(%rip), %rax     # 0xa26b8
movl %eax, %esi
leaq 0x50f31(%rip), %rdi     # 0xa26c0
leaq 0x2a(%rip), %rdx        # 0x517c0
xorl %eax, %eax
movl %eax, %ecx
callq 0x74f90
testb $0x1, %al
jne 0x517a5
jmp 0x517ab
movb $0x1, -0x1(%rbp)
jmp 0x517af
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/rtree.h
// Function: je_rtree_start_level
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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x51878
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x518a3
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x51a00
movq %rax, %rcx
movq -0x28(%rbp), %rax
shrq $0x4, %rcx
movl 0x14(%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
jmp 0x5189d
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %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_subtree_read
JEMALLOC_INLINE rtree_node_elm_t *
rtree_subtree_read(rtree_t *rtree, unsigned level)
{
	rtree_node_elm_t *subtree;

	subtree = rtree_subtree_tryread(rtree, level);
	if (unlikely(!rtree_node_valid(subtree)))
		subtree = rtree_subtree_read_hard(rtree, level);
	return (subtree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x51a20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x51a80
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x518fb
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x75300
movq %rax, -0x18(%rbp)
movq -0x18(%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/include/jemalloc/internal/rtree.h
// Function: je_rtree_child_read
JEMALLOC_INLINE rtree_node_elm_t *
rtree_child_read(rtree_t *rtree, rtree_node_elm_t *elm, unsigned level)
{
	rtree_node_elm_t *child;

	child = rtree_child_tryread(elm);
	if (unlikely(!rtree_node_valid(child)))
		child = rtree_child_read_hard(rtree, elm, level);
	return (child);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x51b10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x51a80
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x519f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x753f0
movq %rax, -0x20(%rbp)
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/include/jemalloc/internal/rtree.h
// Function: je_rtree_subtree_tryread
JEMALLOC_INLINE rtree_node_elm_t *
rtree_subtree_tryread(rtree_t *rtree, unsigned level)
{
	rtree_node_elm_t *subtree;

	/* Double-checked read (first read may be stale. */
	subtree = rtree->levels[level].subtree;
	if (!rtree_node_valid(subtree))
		subtree = atomic_read_p(&rtree->levels[level].subtree_pun);
	return (subtree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x28, %rax
movl -0xc(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x51a80
testb $0x1, %al
jne 0x51a74
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl -0xc(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x51aa0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/rtree.h
// Function: je_rtree_child_tryread
JEMALLOC_INLINE rtree_node_elm_t *
rtree_child_tryread(rtree_node_elm_t *elm)
{
	rtree_node_elm_t *child;

	/* Double-checked read (first read may be stale. */
	child = elm->child;
	if (!rtree_node_valid(child))
		child = atomic_read_p(&elm->pun);
	return (child);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x51a80
testb $0x1, %al
jne 0x51b45
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x51aa0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk.c
// Function: chunk_arena_get
static arena_t *
chunk_arena_get(unsigned arena_ind)
{
	arena_t *arena;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x51e8f
callq 0x246a0
movq %rax, -0x30(%rbp)
jmp 0x51fdf
movq 0x4d152(%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 0x51eb9
jmp 0x51fc8
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x51f3f
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x4d10d(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl $0x50, %edx
callq 0x103b0
leaq 0x51018(%rip), %rax     # 0xa2f14
movl (%rax), %edi
movq 0x4d0e3(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0x106d0
cmpl $0x0, %eax
je 0x51f3a
leaq 0x3d117(%rip), %rdi     # 0x8f039
callq 0x7c0e0
leaq 0x4f772(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x51f38
callq 0x10070
jmp 0x51f3a
jmp 0x51fc6
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x51fc2
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq 0x4d087(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl $0x50, %edx
callq 0x103b0
leaq 0x50f92(%rip), %rax     # 0xa2f14
movl (%rax), %edi
movq 0x4d05d(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0x106d0
cmpl $0x0, %eax
je 0x51fc0
leaq 0x3d091(%rip), %rdi     # 0x8f039
callq 0x7c0e0
leaq 0x4f6ec(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x51fbe
callq 0x10070
jmp 0x51fc0
jmp 0x51fc4
jmp 0x51fc4
jmp 0x51fc6
jmp 0x51fc8
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x52170
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x51fe9
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x50491(%rip), %rdi     # 0xa2740
callq 0x522e0
movl 0x4f186(%rip), %eax     # 0xa1440
movl %eax, -0x4(%rbp)
leaq 0x5047c(%rip), %rdi     # 0xa2740
callq 0x52300
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x5040e(%rip), %rdi     # 0xa2740
callq 0x522e0
movl -0x4(%rbp), %eax
movl %eax, 0x4f100(%rip)     # 0xa1440
leaq 0x503f9(%rip), %rdi     # 0xa2740
callq 0x52300
xorl %eax, %eax
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/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x5260e
leaq 0x5012b(%rip), %rdi     # 0xa2740
callq 0x522e0
movq -0x8(%rbp), %rax
movq 0x50153(%rip), %rcx     # 0xa2778
cmpq %rcx, %rax
jb 0x52640
movq -0x8(%rbp), %rax
movq 0x5013b(%rip), %rcx     # 0xa2770
cmpq %rcx, %rax
jae 0x52640
movb $0x1, -0x9(%rbp)
jmp 0x52644
movb $0x0, -0x9(%rbp)
leaq 0x500f5(%rip), %rdi     # 0xa2740
callq 0x52300
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0x5266a
leaq 0x500cf(%rip), %rdi     # 0xa2740
callq 0x64360
testb $0x1, %al
jne 0x5267c
jmp 0x52682
movb $0x1, -0x1(%rbp)
jmp 0x526b2
xorl %eax, %eax
movl %eax, %edi
callq 0x525e0
movq %rax, 0x500e6(%rip)     # 0xa2778
movq 0x500df(%rip), %rax     # 0xa2778
movq %rax, 0x500c8(%rip)     # 0xa2768
movq 0x500d1(%rip), %rax     # 0xa2778
movq %rax, 0x500c2(%rip)     # 0xa2770
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
jmp 0x5273a
jmp 0x5273c
jmp 0x5273e
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x644b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x52760
movq $0x0, -0x8(%rbp)
jmp 0x527d6
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x527a2
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x64540
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x527e0
movq %rax, -0x8(%rbp)
jmp 0x527d6
jmp 0x527a4
jmp 0x527a6
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
movq -0x28(%rbp), %rax
testb $0x1, (%rax)
jne 0x527ce
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x64680
movb %al, %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/chunk_mmap.c
// Function: chunk_alloc_mmap_slow
static void *
chunk_alloc_mmap_slow(size_t size, size_t alignment, bool *zero, bool *commit)
{
	void *ret;
	size_t alloc_size;

	alloc_size = size + alignment - PAGE;
	/* Beware size_t wrap-around. */
	if (alloc_size < size)
		return (NULL);
	do {
		void *pages;
		size_t leadsize;
		pages = pages_map(NULL, alloc_size);
		if (pages == NULL)
			return (NULL);
		leadsize = ALIGNMENT_CEILING((uintptr_t)pages, alignment) -
		    (uintptr_t)pages;
		ret = pages_trim(pages, alloc_size, leadsize, size);
	} while (ret == NULL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
subq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x52821
movq $0x0, -0x8(%rbp)
jmp 0x528bc
jmp 0x52823
movq -0x38(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x644b0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x52845
movq $0x0, -0x8(%rbp)
jmp 0x528bc
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
addq %rcx, %rax
xorl %ecx, %ecx
subq -0x18(%rbp), %rcx
andq %rcx, %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x645c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x52823
jmp 0x5288a
jmp 0x5288c
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
movq -0x28(%rbp), %rax
testb $0x1, (%rax)
jne 0x528b4
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x64680
movb %al, %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
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: je_ctl_byname
int
ctl_byname(const char *name, void *oldp, size_t *oldlenp, void *newp,
    size_t newlen)
{
	int ret;
	size_t depth;
	ctl_node_t const *nodes[CTL_MAX_DEPTH];
	size_t mib[CTL_MAX_DEPTH];
	const ctl_named_node_t *node;

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

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

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

label_return:
	return(ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
testb $0x1, 0x4fe6a(%rip)     # 0xa2780
jne 0x5292f
callq 0x529d0
testb $0x1, %al
jne 0x52923
jmp 0x5292f
movl $0xb, -0x2c(%rbp)
jmp 0x529c1
movq $0x6, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x52b60
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x5295a
jmp 0x529c1
movq -0x38(%rbp), %rax
subq $0x1, %rax
movq -0x70(%rbp,%rax,8), %rdi
callq 0x52e60
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0xa8(%rbp)
je 0x529b8
movq -0xa8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x529b8
movq -0xa8(%rbp), %rax
movq 0x20(%rax), %rax
leaq -0xa0(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
callq *%rax
movl %eax, -0x2c(%rbp)
jmp 0x529bf
movl $0x2, -0x2c(%rbp)
jmp 0x529c1
movl -0x2c(%rbp), %eax
addq $0xb0, %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_nametomib
int
ctl_nametomib(const char *name, size_t *mibp, size_t *miblenp)
{
	int ret;

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

	ret = ctl_lookup(name, NULL, mibp, miblenp);
label_return:
	return(ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
testb $0x1, 0x4f8d5(%rip)     # 0xa2780
jne 0x52ec1
callq 0x529d0
testb $0x1, %al
jne 0x52eb8
jmp 0x52ec1
movl $0xb, -0x1c(%rbp)
jmp 0x52ed9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x52b60
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)