LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/chunk_dss.c
// Function: chunk_dss_boot
bool
chunk_dss_boot(void)
{

	cassert(config_dss);

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

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0xc0dea
jmp 0xc0dec
jmp 0xc0dee
leaq 0x68493(%rip), %rdi     # 0x129288
callq 0xcde60
testb $0x1, %al
jne 0xc0e00
jmp 0xc0e06
movb $0x1, -0x1(%rbp)
jmp 0xc0e36
xorl %eax, %eax
movl %eax, %edi
callq 0x1f3e0
movq %rax, 0x684aa(%rip)     # 0x1292c0
movq 0x684a3(%rip), %rax     # 0x1292c0
movq %rax, 0x6848c(%rip)     # 0x1292b0
movq 0x68495(%rip), %rax     # 0x1292c0
movq %rax, 0x68486(%rip)     # 0x1292b8
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/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/chunk_mmap.c
// Function: chunk_alloc_mmap
void *
chunk_alloc_mmap(size_t size, size_t alignment, bool *zero)
{
	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));
	}

	assert(ret != NULL);
	*zero = true;
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0xc0ed6
jmp 0xc0ed8
jmp 0xc0eda
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0xc0f60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xc0efc
movq $0x0, -0x8(%rbp)
jmp 0xc0f4d
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xc0f3a
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc1020
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xc1080
movq %rax, -0x8(%rbp)
jmp 0xc0f4d
jmp 0xc0f3c
jmp 0xc0f3e
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/chunk_mmap.c
// Function: pages_map
static 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.
		 */
		if (munmap(ret, size) == -1) {
			char buf[BUFERROR_BUF];

			buferror(buf, sizeof(buf));
			malloc_printf("<jemalloc: Error in munmap(): %s\n",
			    buf);
			if (opt_abort)
				abort();
		}
		ret = NULL;
	}
#endif
	assert(ret == NULL || (addr == NULL && ret != addr)
	    || (addr != NULL && ret == addr));
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xc0f72
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 0x1fc20
movq %rax, -0x18(%rbp)
jmp 0xc0f9a
movq $-0x1, %rax
cmpq %rax, -0x18(%rbp)
jne 0xc0fb1
movq $0x0, -0x18(%rbp)
jmp 0xc1011
cmpq $0x0, -0x8(%rbp)
je 0xc100f
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0xc100f
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1f970
cmpl $-0x1, %eax
jne 0xc1007
leaq -0x60(%rbp), %rdi
movl $0x40, %esi
callq 0xd72a0
leaq -0x60(%rbp), %rsi
leaq 0x2c971(%rip), %rdi     # 0xed95e
movb $0x0, %al
callq 0xda3b0
leaq 0x674af(%rip), %rax     # 0x1284aa
testb $0x1, (%rax)
je 0xc1005
callq 0x1f1b0
jmp 0xc1007
movq $0x0, -0x18(%rbp)
jmp 0xc1011
jmp 0xc1013
jmp 0xc1015
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/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)
{
	void *ret, *pages;
	size_t alloc_size, leadsize;

	alloc_size = size + alignment - PAGE;
	/* Beware size_t wrap-around. */
	if (alloc_size < size)
		return (NULL);
	do {
		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;
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%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 0xc10ba
movq $0x0, -0x8(%rbp)
jmp 0xc1134
jmp 0xc10bc
movq -0x38(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0xc0f60
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xc10de
movq $0x0, -0x8(%rbp)
jmp 0xc1134
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
addq %rcx, %rax
xorl %ecx, %ecx
subq -0x18(%rbp), %rcx
andq %rcx, %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0xc1160
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xc10bc
jmp 0xc1123
jmp 0xc1125
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ctl.c
// Function: 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 == false && 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)
movb 0x680d3(%rip), %al      # 0x1292c8
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xc1216
callq 0xc12c0
testb $0x1, %al
jne 0xc120a
jmp 0xc1216
movl $0xb, -0x2c(%rbp)
jmp 0xc12a8
movq $0x6, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0xc13e0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0xc1241
jmp 0xc12a8
movq -0x38(%rbp), %rax
subq $0x1, %rax
movq -0x70(%rbp,%rax,8), %rdi
callq 0xc16e0
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0xa8(%rbp)
je 0xc129f
movq -0xa8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xc129f
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 0xc12a6
movl $0x2, -0x2c(%rbp)
jmp 0xc12a8
movl -0x2c(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ctl.c
// Function: ctl_init
static bool
ctl_init(void)
{
	bool ret;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x68001(%rip), %rdi     # 0x1292d0
callq 0xc19c0
movb 0x67fee(%rip), %al      # 0x1292c8
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xc13c1
jmp 0xc12ea
jmp 0xc12ec
leaq 0x671dd(%rip), %rax     # 0x1284d0
movl (%rax), %eax
movl %eax, 0x68045(%rip)     # 0x129340
movl 0x6803f(%rip), %eax     # 0x129340
addl $0x1, %eax
movl %eax, %eax
imulq $0x870, %rax, %rdi      # imm = 0x870
callq 0xbfc90
movq %rax, 0x6802f(%rip)     # 0x129348
cmpq $0x0, 0x68027(%rip)     # 0x129348
jne 0xc132c
movb $0x1, -0x1(%rbp)
jmp 0xc13c5
movq 0x68015(%rip), %rdi     # 0x129348
movl 0x68007(%rip), %eax     # 0x129340
addl $0x1, %eax
movl %eax, %eax
imulq $0x870, %rax, %rdx      # imm = 0x870
xorl %esi, %esi
callq 0x1f110
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x67fe4(%rip), %eax     # 0x129340
ja 0xc1390
movq 0x67fe3(%rip), %rdi     # 0x129348
movl -0x8(%rbp), %eax
imulq $0x870, %rax, %rax      # imm = 0x870
addq %rax, %rdi
callq 0xc1a20
testb $0x1, %al
jne 0xc137d
jmp 0xc1383
movb $0x1, -0x1(%rbp)
jmp 0xc13c5
jmp 0xc1385
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xc1353
movq 0x67fb1(%rip), %rax     # 0x129348
movl 0x67fa3(%rip), %ecx     # 0x129340
imulq $0x870, %rcx, %rcx      # imm = 0x870
addq %rcx, %rax
movb $0x1, (%rax)
movq $0x0, 0x67f9b(%rip) # 0x129350
callq 0xc1a90
movb $0x1, 0x67f07(%rip)     # 0x1292c8
movb $0x0, -0x1(%rbp)
leaq 0x67f04(%rip), %rdi     # 0x1292d0
callq 0xc1d60
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ctl.c
// Function: ctl_nametomib
int
ctl_nametomib(const char *name, size_t *mibp, size_t *miblenp)
{
	int ret;

	if (ctl_initialized == false && 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)
movb 0x67b9e(%rip), %al      # 0x1292c8
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xc1748
callq 0xc12c0
testb $0x1, %al
jne 0xc173f
jmp 0xc1748
movl $0xb, -0x1c(%rbp)
jmp 0xc1760
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0xc13e0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/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 *)base_alloc(nlclasses *
		    sizeof(malloc_large_stats_t));
		if (astats->lstats == NULL)
			return (true);
	}

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x868(%rax)
jne 0xc1a7b
leaq 0x67797(%rip), %rax     # 0x1291d8
movq (%rax), %rdi
leaq 0x6782d(%rip), %rax     # 0x129278
subq (%rax), %rdi
shlq $0x5, %rdi
callq 0xbfc90
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x868(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x868(%rax)
jne 0xc1a79
movb $0x1, -0x1(%rbp)
jmp 0xc1a7f
jmp 0xc1a7b
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/nilyang[P]redis-tdd-annotation/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->pactive,
	    &cstats->pdirty, &cstats->astats, cstats->bstats, cstats->lstats);

	for (i = 0; i < NBINS; i++) {
		cstats->allocated_small += cstats->bstats[i].allocated;
		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 $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
movq -0x8(%rbp), %rdx
addq $0x10, %rdx
movq -0x8(%rbp), %rcx
addq $0x18, %rcx
movq -0x8(%rbp), %r8
addq $0x20, %r8
movq -0x8(%rbp), %r9
addq $0x88, %r9
movq -0x8(%rbp), %rax
movq 0x868(%rax), %rax
movq %rax, (%rsp)
callq 0xb8390
movl $0x0, -0x14(%rbp)
cmpl $0x1c, -0x14(%rbp)
jae 0xc1fd7
movq -0x8(%rbp), %rax
addq $0x88, %rax
movl -0x14(%rbp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
addq 0x68(%rax), %rcx
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
addq $0x88, %rax
movl -0x14(%rbp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
addq 0x70(%rax), %rcx
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rax
addq $0x88, %rax
movl -0x14(%rbp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
addq 0x78(%rax), %rcx
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rax
addq $0x88, %rax
movl -0x14(%rbp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
addq 0x80(%rax), %rcx
movq %rcx, 0x80(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc1f2a
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ctl.c
// Function: thread_tcache_flush_ctl
static int
thread_tcache_flush_ctl(const size_t *mib, size_t miblen, void *oldp,
    size_t *oldlenp, void *newp, size_t newlen)
{
	int ret;

	if (config_tcache == false)
		return (ENOENT);

	READONLY();
	WRITEONLY();

	tcache_flush();

	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 0xc2d1e
cmpq $0x0, -0x30(%rbp)
je 0xc2d27
movl $0x1, -0x34(%rbp)
jmp 0xc2d50
jmp 0xc2d29
jmp 0xc2d2b
cmpq $0x0, -0x18(%rbp)
jne 0xc2d39
cmpq $0x0, -0x20(%rbp)
je 0xc2d42
movl $0x1, -0x34(%rbp)
jmp 0xc2d50
jmp 0xc2d44
callq 0xc2f20
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/include/jemalloc/internal/tcache.h
// Function: tcache_flush
void
tcache_flush(void)
{
	tcache_t *tcache;

	cassert(config_tcache);

	tcache = *tcache_tsd_get();
	if ((uintptr_t)tcache <= (uintptr_t)TCACHE_STATE_MAX)
		return;
	tcache_destroy(tcache);
	tcache = NULL;
	tcache_tsd_set(&tcache);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0xc2f2a
callq 0xc2b30
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x3, %rax
ja 0xc2f42
jmp 0xc2f5c
movq -0x8(%rbp), %rdi
callq 0xd6170
movq $0x0, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
callq 0xc2ea0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ctl.c
// Function: arenas_purge_ctl
static int
arenas_purge_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
    void *newp, size_t newlen)
{
	int ret;
	unsigned arena_ind;

	malloc_mutex_lock(&ctl_mtx);
	WRITEONLY();
	arena_ind = UINT_MAX;
	WRITE(arena_ind, unsigned);
	if (newp != NULL && arena_ind >= ctl_stats.narenas)
		ret = EFAULT;
	else {
		if (arena_ind == UINT_MAX)
			arena_ind = ctl_stats.narenas;
		arena_purge(arena_ind);
		ret = 0;
	}

label_return:
	malloc_mutex_unlock(&ctl_mtx);
	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)
leaq 0x640d9(%rip), %rdi     # 0x1292d0
callq 0xc19c0
cmpq $0x0, -0x18(%rbp)
jne 0xc520a
cmpq $0x0, -0x20(%rbp)
je 0xc5213
movl $0x1, -0x34(%rbp)
jmp 0xc5279
jmp 0xc5215
movl $0xffffffff, -0x38(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x28(%rbp)
je 0xc523c
cmpq $0x4, -0x30(%rbp)
je 0xc5233
movl $0x16, -0x34(%rbp)
jmp 0xc5279
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
jmp 0xc523e
cmpq $0x0, -0x28(%rbp)
je 0xc5259
movl -0x38(%rbp), %eax
cmpl 0x640f2(%rip), %eax     # 0x129340
jb 0xc5259
movl $0xe, -0x34(%rbp)
jmp 0xc5277
cmpl $-0x1, -0x38(%rbp)
jne 0xc5268
movl 0x640db(%rip), %eax     # 0x129340
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %edi
callq 0xc4a20
movl $0x0, -0x34(%rbp)
jmp 0xc5279
leaq 0x64050(%rip), %rdi     # 0x1292d0
callq 0xc1d60
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/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;

	malloc_mutex_lock(&ctl_mtx);
	READONLY();
	if (ctl_grow()) {
		ret = EAGAIN;
		goto label_return;
	}
	READ(ctl_stats.narenas - 1, 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 0x64019(%rip), %rdi     # 0x1292d0
callq 0xc19c0
cmpq $0x0, -0x28(%rbp)
jne 0xc52ca
cmpq $0x0, -0x30(%rbp)
je 0xc52d6
movl $0x1, -0x34(%rbp)
jmp 0xc5374
jmp 0xc52d8
callq 0xc5780
testb $0x1, %al
jne 0xc52e3
jmp 0xc52ef
movl $0xb, -0x34(%rbp)
jmp 0xc5374
jmp 0xc52f1
cmpq $0x0, -0x18(%rbp)
je 0xc536b
cmpq $0x0, -0x20(%rbp)
je 0xc536b
movq -0x20(%rbp), %rax
cmpq $0x4, (%rax)
je 0xc535a
movq -0x20(%rbp), %rcx
movl $0x4, %eax
cmpq (%rcx), %rax
ja 0xc5322
movl $0x4, %eax
movq %rax, -0x48(%rbp)
jmp 0xc532d
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 0x63fb4(%rip), %rsi     # 0x1292f8
addq $0x48, %rsi
addq $-0x1, %rsi
callq 0x1fbf0
movl $0x16, -0x34(%rbp)
jmp 0xc5374
movl 0x63fe0(%rip), %ecx     # 0x129340
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0xc536b
jmp 0xc536d
movl $0x0, -0x34(%rbp)
leaq 0x63f55(%rip), %rdi     # 0x1292d0
callq 0xc1d60
movl -0x34(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/extent.c
// Function: extent_szad_comp
static inline int
extent_szad_comp(extent_node_t *a, extent_node_t *b)
{
	int ret;
	size_t a_size = a->size;
	size_t b_size = b->size;

	ret = (a_size > b_size) - (a_size < b_size);
	if (ret == 0) {
		uintptr_t a_addr = (uintptr_t)a->addr;
		uintptr_t b_addr = (uintptr_t)b->addr;

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

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
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 0xc96be
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
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
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/huge.c
// Function: huge_ralloc_no_move
void *
huge_ralloc_no_move(void *ptr, size_t oldsize, size_t size, size_t extra)
{

	/*
	 * Avoid moving the allocation if the size class can be left the same.
	 */
	if (oldsize > arena_maxclass
	    && CHUNK_CEILING(oldsize) >= CHUNK_CEILING(size)
	    && CHUNK_CEILING(oldsize) <= CHUNK_CEILING(size+extra)) {
		assert(CHUNK_CEILING(oldsize) == oldsize);
		if (config_fill && opt_junk && size < oldsize) {
			memset((void *)((uintptr_t)ptr + size), 0x5a,
			    oldsize - size);
		}
		return (ptr);
	}

	/* Reallocation would require a move. */
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
leaq 0x5c25d(%rip), %rcx     # 0x129280
cmpq (%rcx), %rax
jbe 0xcd0f8
movq -0x18(%rbp), %rax
leaq 0x5c199(%rip), %rcx     # 0x1291d0
addq (%rcx), %rax
leaq 0x5c18f(%rip), %rcx     # 0x1291d0
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq -0x20(%rbp), %rcx
leaq 0x5c17a(%rip), %rdx     # 0x1291d0
addq (%rdx), %rcx
leaq 0x5c170(%rip), %rdx     # 0x1291d0
movq (%rdx), %rdx
xorq $-0x1, %rdx
andq %rdx, %rcx
cmpq %rcx, %rax
jb 0xcd0f8
movq -0x18(%rbp), %rax
leaq 0x5c152(%rip), %rcx     # 0x1291d0
addq (%rcx), %rax
leaq 0x5c148(%rip), %rcx     # 0x1291d0
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq -0x20(%rbp), %rcx
addq -0x28(%rbp), %rcx
leaq 0x5c12f(%rip), %rdx     # 0x1291d0
addq (%rdx), %rcx
leaq 0x5c125(%rip), %rdx     # 0x1291d0
movq (%rdx), %rdx
xorq $-0x1, %rdx
andq %rdx, %rcx
cmpq %rcx, %rax
ja 0xcd0f8
jmp 0xcd0bc
jmp 0xcd0be
leaq 0x5b3e6(%rip), %rax     # 0x1284ab
testb $0x1, (%rax)
je 0xcd0ee
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xcd0ee
movq -0x10(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
subq -0x20(%rbp), %rdx
movl $0x5a, %esi
callq 0x1f110
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcd100
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/huge.c
// Function: huge_dalloc
void
huge_dalloc(void *ptr, bool unmap)
{
	extent_node_t *node, key;

	malloc_mutex_lock(&huge_mtx);

	/* Extract from tree of huge allocations. */
	key.addr = ptr;
	node = extent_tree_ad_search(&huge, &key);
	assert(node != NULL);
	assert(node->addr == ptr);
	extent_tree_ad_remove(&huge, node);

	if (config_stats) {
		stats_cactive_sub(node->size);
		huge_ndalloc++;
		huge_allocated -= node->size;
	}

	malloc_mutex_unlock(&huge_mtx);

	if (unmap && config_fill && config_dss && opt_junk)
		memset(node->addr, 0x5a, node->size);

	chunk_dealloc(node->addr, node->size, unmap);

	base_node_dealloc(node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
leaq 0x5c04d(%rip), %rdi     # 0x129358
callq 0xccf90
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x5c061(%rip), %rdi     # 0x129380
leaq -0x58(%rbp), %rsi
callq 0xcb490
movq %rax, -0x18(%rbp)
jmp 0xcd32e
jmp 0xcd330
jmp 0xcd332
movq -0x18(%rbp), %rsi
leaq 0x5c043(%rip), %rdi     # 0x129380
callq 0xcbaf0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xcd3f0
movq 0x5c082(%rip), %rax     # 0x1293d8
addq $0x1, %rax
movq %rax, 0x5c077(%rip)     # 0x1293d8
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movq 0x5c060(%rip), %rax     # 0x1293d0
subq %rcx, %rax
movq %rax, 0x5c056(%rip)     # 0x1293d0
leaq 0x5bfd7(%rip), %rdi     # 0x129358
callq 0xccfe0
testb $0x1, -0x9(%rbp)
je 0xcd3ba
xorl %eax, %eax
testb $0x1, %al
jne 0xcd394
jmp 0xcd3ba
leaq 0x5b110(%rip), %rax     # 0x1284ab
testb $0x1, (%rax)
je 0xcd3ba
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdx
movl $0x5a, %esi
callq 0x1f110
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rsi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0xc0950
movq -0x18(%rbp), %rdi
callq 0xbfef0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/huge.c
// Function: huge_salloc
size_t
huge_salloc(const void *ptr)
{
	size_t ret;
	extent_node_t *node, key;

	malloc_mutex_lock(&huge_mtx);

	/* Extract from tree of huge allocations. */
	key.addr = __DECONST(void *, ptr);
	node = extent_tree_ad_search(&huge, &key);
	assert(node != NULL);

	ret = node->size;

	malloc_mutex_unlock(&huge_mtx);

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x5bf25(%rip), %rdi     # 0x129358
callq 0xccf90
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x5bf39(%rip), %rdi     # 0x129380
leaq -0x58(%rbp), %rsi
callq 0xcb490
movq %rax, -0x18(%rbp)
jmp 0xcd456
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
leaq 0x5beef(%rip), %rdi     # 0x129358
callq 0xccfe0
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/huge.c
// Function: huge_prof_ctx_get
prof_ctx_t *
huge_prof_ctx_get(const void *ptr)
{
	prof_ctx_t *ret;
	extent_node_t *node, key;

	malloc_mutex_lock(&huge_mtx);

	/* Extract from tree of huge allocations. */
	key.addr = __DECONST(void *, ptr);
	node = extent_tree_ad_search(&huge, &key);
	assert(node != NULL);

	ret = node->prof_ctx;

	malloc_mutex_unlock(&huge_mtx);

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x5bec5(%rip), %rdi     # 0x129358
callq 0xccf90
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x5bed9(%rip), %rdi     # 0x129380
leaq -0x58(%rbp), %rsi
callq 0xcb490
movq %rax, -0x18(%rbp)
jmp 0xcd4b6
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
leaq 0x5be8f(%rip), %rdi     # 0x129358
callq 0xccfe0
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/huge.c
// Function: huge_prof_ctx_set
void
huge_prof_ctx_set(const void *ptr, prof_ctx_t *ctx)
{
	extent_node_t *node, key;

	malloc_mutex_lock(&huge_mtx);

	/* Extract from tree of huge allocations. */
	key.addr = __DECONST(void *, ptr);
	node = extent_tree_ad_search(&huge, &key);
	assert(node != NULL);

	node->prof_ctx = ctx;

	malloc_mutex_unlock(&huge_mtx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x5be61(%rip), %rdi     # 0x129358
callq 0xccf90
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x5be75(%rip), %rdi     # 0x129380
leaq -0x58(%rbp), %rsi
callq 0xcb490
movq %rax, -0x18(%rbp)
jmp 0xcd51a
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
leaq 0x5be2b(%rip), %rdi     # 0x129358
callq 0xccfe0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/huge.c
// Function: huge_boot
bool
huge_boot(void)
{

	/* Initialize chunks data. */
	if (malloc_mutex_init(&huge_mtx))
		return (true);
	extent_tree_ad_new(&huge);

	if (config_stats) {
		huge_nmalloc = 0;
		huge_ndalloc = 0;
		huge_allocated = 0;
	}

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x5be09(%rip), %rdi     # 0x129358
callq 0xcde60
testb $0x1, %al
jne 0xcd55a
jmp 0xcd560
movb $0x1, -0x1(%rbp)
jmp 0xcd591
leaq 0x5be19(%rip), %rdi     # 0x129380
callq 0xcb0b0
movq $0x0, 0x5be51(%rip) # 0x1293c8
movq $0x0, 0x5be56(%rip) # 0x1293d8
movq $0x0, 0x5be43(%rip) # 0x1293d0
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/nilyang[P]redis-tdd-annotation/deps/jemalloc/include/jemalloc/internal/prof.h
// Function: prof_tdata_get
prof_tdata_t *
prof_tdata_get(void)
{
	prof_tdata_t *prof_tdata;

	cassert(config_prof);

	prof_tdata = *prof_tdata_tsd_get();
	if ((uintptr_t)prof_tdata <= (uintptr_t)PROF_TDATA_STATE_MAX) {
		if (prof_tdata == NULL)
			prof_tdata = prof_tdata_init();
	}

	return (prof_tdata);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0xce56a
jmp 0xce56c
jmp 0xce56e
callq 0xceaa0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x2, %rax
ja 0xce596
cmpq $0x0, -0x8(%rbp)
jne 0xce594
callq 0xcefd0
movq %rax, -0x8(%rbp)
jmp 0xce596
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/prof.c
// Function: prof_enter
static inline void
prof_enter(prof_tdata_t *prof_tdata)
{

	cassert(config_prof);

	assert(prof_tdata->enq == false);
	prof_tdata->enq = true;

	malloc_mutex_lock(&bt2ctx_mtx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0xce5ae
jmp 0xce5b0
jmp 0xce5b2
jmp 0xce5b4
jmp 0xce5b6
movq -0x8(%rbp), %rax
movb $0x1, 0x58(%rax)
leaq 0x5beb3(%rip), %rdi     # 0x12a478
callq 0xce760
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/prof.c
// Function: prof_leave
static inline void
prof_leave(prof_tdata_t *prof_tdata)
{
	bool idump, gdump;

	cassert(config_prof);

	malloc_mutex_unlock(&bt2ctx_mtx);

	assert(prof_tdata->enq);
	prof_tdata->enq = false;
	idump = prof_tdata->enq_idump;
	prof_tdata->enq_idump = false;
	gdump = prof_tdata->enq_gdump;
	prof_tdata->enq_gdump = false;

	if (idump)
		prof_idump();
	if (gdump)
		prof_gdump();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0xce60e
jmp 0xce610
jmp 0xce612
leaq 0x5be5f(%rip), %rdi     # 0x12a478
callq 0xce780
jmp 0xce620
movq -0x8(%rbp), %rax
movb $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
movb 0x59(%rax), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x59(%rax)
movq -0x8(%rbp), %rax
movb 0x5a(%rax), %al
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x5a(%rax)
testb $0x1, -0x9(%rbp)
je 0xce65b
callq 0xce9e0
testb $0x1, -0xa(%rbp)
je 0xce666
callq 0xcef10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/prof.c
// Function: bt_dup
static prof_bt_t *
bt_dup(prof_bt_t *bt)
{
	prof_bt_t *ret;

	cassert(config_prof);

	/*
	 * Create a single allocation that has space for vec immediately
	 * following the prof_bt_t structure.  The backtraces that get
	 * stored in the backtrace caches are copied from stack-allocated
	 * temporary variables, so size is known at creation time.  Making this
	 * a contiguous object improves cache locality.
	 */
	ret = (prof_bt_t *)imalloc(QUANTUM_CEILING(sizeof(prof_bt_t)) +
	    (bt->len * sizeof(void *)));
	if (ret == NULL)
		return (NULL);
	ret->vec = (void **)((uintptr_t)ret +
	    QUANTUM_CEILING(sizeof(prof_bt_t)));
	memcpy(ret->vec, bt->vec, bt->len * sizeof(void *));
	ret->len = bt->len;

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
jmp 0xce67e
jmp 0xce680
jmp 0xce682
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %edi
shlq $0x3, %rdi
addq $0x10, %rdi
callq 0xce5d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xce6ad
movq $0x0, -0x8(%rbp)
jmp 0xce6f2
movq -0x18(%rbp), %rcx
addq $0x10, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
shlq $0x3, %rdx
callq 0x1fbf0
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/prof.c
// Function: prof_ctx_merge
static void
prof_ctx_merge(prof_ctx_t *ctx, prof_thr_cnt_t *cnt)
{
	bool destroy;

	cassert(config_prof);

	/* Merge cnt stats and detach from ctx. */
	malloc_mutex_lock(ctx->lock);
	ctx->cnt_merged.curobjs += cnt->cnts.curobjs;
	ctx->cnt_merged.curbytes += cnt->cnts.curbytes;
	ctx->cnt_merged.accumobjs += cnt->cnts.accumobjs;
	ctx->cnt_merged.accumbytes += cnt->cnts.accumbytes;
	ql_remove(&ctx->cnts_ql, cnt, cnts_link);
	if (opt_prof_accum == false && ql_first(&ctx->cnts_ql) == NULL &&
	    ctx->cnt_merged.curobjs == 0 && ctx->nlimbo == 0) {
		/*
		 * Increment ctx->nlimbo in order to keep another thread from
		 * winning the race to destroy ctx while this one has ctx->lock
		 * dropped.  Without this, it would be possible for another
		 * thread to:
		 *
		 * 1) Sample an allocation associated with ctx.
		 * 2) Deallocate the sampled object.
		 * 3) Successfully prof_ctx_destroy(ctx).
		 *
		 * The result would be that ctx no longer exists by the time
		 * this thread accesses it in prof_ctx_destroy().
		 */
		ctx->nlimbo++;
		destroy = true;
	} else
		destroy = false;
	malloc_mutex_unlock(ctx->lock);
	if (destroy)
		prof_ctx_destroy(ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xce7b2
jmp 0xce7b4
jmp 0xce7b6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xce760
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
addq 0x38(%rax), %rcx
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
addq 0x40(%rax), %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x8(%rbp), %rax
addq 0x48(%rax), %rcx
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x8(%rbp), %rax
addq 0x50(%rax), %rcx
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xce834
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0xce882
jmp 0xce844
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xce88e
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
jmp 0xce890
movb 0x5ab4e(%rip), %al      # 0x1293e4
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xce8d3
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0xce8d3
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0xce8d3
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0xce8d3
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movb $0x1, -0x11(%rbp)
jmp 0xce8d7
movb $0x0, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xce780
testb $0x1, -0x11(%rbp)
je 0xce8f3
movq -0x8(%rbp), %rdi
callq 0xce900
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/prof.c
// Function: prof_ctx_destroy
static void
prof_ctx_destroy(prof_ctx_t *ctx)
{
	prof_tdata_t *prof_tdata;

	cassert(config_prof);

	/*
	 * Check that ctx is still unused by any thread cache before destroying
	 * it.  prof_lookup() increments ctx->nlimbo in order to avoid a race
	 * condition with this function, as does prof_ctx_merge() in order to
	 * avoid a race between the main body of prof_ctx_merge() and entry
	 * into this function.
	 */
	prof_tdata = *prof_tdata_tsd_get();
	assert((uintptr_t)prof_tdata > (uintptr_t)PROF_TDATA_STATE_MAX);
	prof_enter(prof_tdata);
	malloc_mutex_lock(ctx->lock);
	if (ql_first(&ctx->cnts_ql) == NULL && ctx->cnt_merged.curobjs == 0 &&
	    ctx->nlimbo == 1) {
		assert(ctx->cnt_merged.curbytes == 0);
		assert(ctx->cnt_merged.accumobjs == 0);
		assert(ctx->cnt_merged.accumbytes == 0);
		/* Remove ctx from bt2ctx. */
		if (ckh_remove(&bt2ctx, ctx->bt, NULL, NULL))
			assert(false);
		prof_leave(prof_tdata);
		/* Destroy ctx. */
		malloc_mutex_unlock(ctx->lock);
		bt_destroy(ctx->bt);
		idalloc(ctx);
	} else {
		/*
		 * Compensate for increment in prof_ctx_merge() or
		 * prof_lookup().
		 */
		ctx->nlimbo--;
		malloc_mutex_unlock(ctx->lock);
		prof_leave(prof_tdata);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0xce90e
jmp 0xce910
jmp 0xce912
callq 0xceaa0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xce920
movq -0x10(%rbp), %rdi
callq 0xce5a0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xce760
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0xce9b5
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0xce9b5
movq -0x8(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0xce9b5
jmp 0xce958
jmp 0xce95a
jmp 0xce95c
jmp 0xce95e
jmp 0xce960
jmp 0xce962
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x5aa78(%rip), %rdi     # 0x1293e8
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xdb840
testb $0x1, %al
jne 0xce982
jmp 0xce988
jmp 0xce984
jmp 0xce986
jmp 0xce988
movq -0x10(%rbp), %rdi
callq 0xce600
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xce780
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xd0540
movq -0x8(%rbp), %rdi
callq 0xce700
jmp 0xce9d8
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xce780
movq -0x10(%rbp), %rdi
callq 0xce600
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/prof.c
// Function: prof_idump
void
prof_idump(void)
{
	prof_tdata_t *prof_tdata;
	char filename[PATH_MAX + 1];

	cassert(config_prof);

	if (prof_booted == false)
		return;
	/*
	 * Don't call prof_tdata_get() here, because it could cause recursive
	 * allocation.
	 */
	prof_tdata = *prof_tdata_tsd_get();
	if ((uintptr_t)prof_tdata <= (uintptr_t)PROF_TDATA_STATE_MAX)
		return;
	if (prof_tdata->enq) {
		prof_tdata->enq_idump = true;
		return;
	}

	if (opt_prof_prefix[0] != '\0') {
		malloc_mutex_lock(&prof_dump_seq_mtx);
		prof_dump_filename(filename, 'i', prof_dump_iseq);
		prof_dump_iseq++;
		malloc_mutex_unlock(&prof_dump_seq_mtx);
		prof_dump(false, filename, false);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1010, %rsp           # imm = 0x1010
jmp 0xce9ed
jmp 0xce9ef
jmp 0xce9f1
movb 0x5aa21(%rip), %al      # 0x129418
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xcea06
jmp 0xcea90
callq 0xceaa0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x2, %rax
ja 0xcea1e
jmp 0xcea90
movq -0x8(%rbp), %rax
testb $0x1, 0x58(%rax)
je 0xcea32
movq -0x8(%rbp), %rax
movb $0x1, 0x59(%rax)
jmp 0xcea90
movsbl 0x5a9e7(%rip), %eax     # 0x129420
cmpl $0x0, %eax
je 0xcea90
leaq 0x5b9e3(%rip), %rdi     # 0x12a428
callq 0xce760
leaq -0x1010(%rbp), %rdi
movq 0x5b9f8(%rip), %rdx     # 0x12a450
movl $0x69, %esi
callq 0xceac0
movq 0x5b9e7(%rip), %rax     # 0x12a450
addq $0x1, %rax
movq %rax, 0x5b9dc(%rip)     # 0x12a450
leaq 0x5b9ad(%rip), %rdi     # 0x12a428
callq 0xce780
leaq -0x1010(%rbp), %rsi
xorl %edx, %edx
movl %edx, %edi
callq 0xceb80
addq $0x1010, %rsp           # imm = 0x1010
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/prof.c
// Function: prof_dump_filename
static void
prof_dump_filename(char *filename, char v, int64_t vseq)
{

	cassert(config_prof);

	if (vseq != UINT64_C(0xffffffffffffffff)) {
	        /* "<prefix>.<pid>.<seq>.v<vseq>.heap" */
		malloc_snprintf(filename, DUMP_FILENAME_BUFSIZE,
		    "%s.%d.%"PRIu64".%c%"PRId64".heap",
		    opt_prof_prefix, (int)getpid(), prof_dump_seq, v, vseq);
	} else {
	        /* "<prefix>.<pid>.<seq>.<v>.heap" */
		malloc_snprintf(filename, DUMP_FILENAME_BUFSIZE,
		    "%s.%d.%"PRIu64".%c.heap",
		    opt_prof_prefix, (int)getpid(), prof_dump_seq, v);
	}
	prof_dump_seq++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0xcead8
jmp 0xceada
jmp 0xceadc
cmpq $-0x1, -0x18(%rbp)
je 0xceb2c
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x1f410
movq -0x20(%rbp), %rdi
movl %eax, %r8d
movq 0x5b9b2(%rip), %r9      # 0x12a4b0
movsbl -0x9(%rbp), %r10d
movq -0x18(%rbp), %rax
movl $0x1001, %esi           # imm = 0x1001
leaq 0x1efc3(%rip), %rdx     # 0xedad6
leaq 0x5a906(%rip), %rcx     # 0x129420
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0xda1c0
jmp 0xceb68
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1f410
movq -0x28(%rbp), %rdi
movl %eax, %r8d
movq 0x5b969(%rip), %r9      # 0x12a4b0
movsbl -0x9(%rbp), %eax
movl $0x1001, %esi           # imm = 0x1001
leaq 0x1ef94(%rip), %rdx     # 0xedaeb
leaq 0x5a8c2(%rip), %rcx     # 0x129420
movl %eax, (%rsp)
movb $0x0, %al
callq 0xda1c0
movq 0x5b941(%rip), %rax     # 0x12a4b0
addq $0x1, %rax
movq %rax, 0x5b936(%rip)     # 0x12a4b0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/prof.c
// Function: prof_mdump
bool
prof_mdump(const char *filename)
{
	char filename_buf[DUMP_FILENAME_BUFSIZE];

	cassert(config_prof);

	if (opt_prof == false || prof_booted == false)
		return (true);

	if (filename == NULL) {
		/* No filename specified, so automatically generate one. */
		if (opt_prof_prefix[0] == '\0')
			return (true);
		malloc_mutex_lock(&prof_dump_seq_mtx);
		prof_dump_filename(filename_buf, 'm', prof_dump_mseq);
		prof_dump_mseq++;
		malloc_mutex_unlock(&prof_dump_seq_mtx);
		filename = filename_buf;
	}
	return (prof_dump(true, filename, false));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x10(%rbp)
jmp 0xcee51
jmp 0xcee53
jmp 0xcee55
movb 0x5a586(%rip), %al      # 0x1293e1
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xcee75
movb 0x5a5ad(%rip), %al      # 0x129418
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xcee7b
movb $0x1, -0x1(%rbp)
jmp 0xceef6
cmpq $0x0, -0x10(%rbp)
jne 0xceee1
movsbl 0x5a597(%rip), %eax     # 0x129420
cmpl $0x0, %eax
jne 0xcee94
movb $0x1, -0x1(%rbp)
jmp 0xceef6
leaq 0x5b58d(%rip), %rdi     # 0x12a428
callq 0xce760
leaq -0x1020(%rbp), %rdi
movq 0x5b5aa(%rip), %rdx     # 0x12a458
movl $0x6d, %esi
callq 0xceac0
movq 0x5b599(%rip), %rax     # 0x12a458
addq $0x1, %rax
movq %rax, 0x5b58e(%rip)     # 0x12a458
leaq 0x5b557(%rip), %rdi     # 0x12a428
callq 0xce780
leaq -0x1020(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movl $0x1, %edi
xorl %edx, %edx
callq 0xceb80
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x1020, %rsp           # imm = 0x1020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/prof.c
// Function: prof_gdump
void
prof_gdump(void)
{
	prof_tdata_t *prof_tdata;
	char filename[DUMP_FILENAME_BUFSIZE];

	cassert(config_prof);

	if (prof_booted == false)
		return;
	/*
	 * Don't call prof_tdata_get() here, because it could cause recursive
	 * allocation.
	 */
	prof_tdata = *prof_tdata_tsd_get();
	if ((uintptr_t)prof_tdata <= (uintptr_t)PROF_TDATA_STATE_MAX)
		return;
	if (prof_tdata->enq) {
		prof_tdata->enq_gdump = true;
		return;
	}

	if (opt_prof_prefix[0] != '\0') {
		malloc_mutex_lock(&prof_dump_seq_mtx);
		prof_dump_filename(filename, 'u', prof_dump_useq);
		prof_dump_useq++;
		malloc_mutex_unlock(&prof_dump_seq_mtx);
		prof_dump(false, filename, false);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1010, %rsp           # imm = 0x1010
jmp 0xcef1d
jmp 0xcef1f
jmp 0xcef21
movb 0x5a4f1(%rip), %al      # 0x129418
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xcef36
jmp 0xcefc0
callq 0xceaa0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x2, %rax
ja 0xcef4e
jmp 0xcefc0
movq -0x8(%rbp), %rax
testb $0x1, 0x58(%rax)
je 0xcef62
movq -0x8(%rbp), %rax
movb $0x1, 0x5a(%rax)
jmp 0xcefc0
movsbl 0x5a4b7(%rip), %eax     # 0x129420
cmpl $0x0, %eax
je 0xcefc0
leaq 0x5b4b3(%rip), %rdi     # 0x12a428
callq 0xce760
leaq -0x1010(%rbp), %rdi
movq 0x5b4d8(%rip), %rdx     # 0x12a460
movl $0x75, %esi
callq 0xceac0
movq 0x5b4c7(%rip), %rax     # 0x12a460
addq $0x1, %rax
movq %rax, 0x5b4bc(%rip)     # 0x12a460
leaq 0x5b47d(%rip), %rdi     # 0x12a428
callq 0xce780
leaq -0x1010(%rbp), %rsi
xorl %edx, %edx
movl %edx, %edi
callq 0xceb80
addq $0x1010, %rsp           # imm = 0x1010
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/prof.c
// Function: prof_tdata_init
prof_tdata_t *
prof_tdata_init(void)
{
	prof_tdata_t *prof_tdata;

	cassert(config_prof);

	/* Initialize an empty cache for this thread. */
	prof_tdata = (prof_tdata_t *)imalloc(sizeof(prof_tdata_t));
	if (prof_tdata == NULL)
		return (NULL);

	if (ckh_new(&prof_tdata->bt2cnt, PROF_CKH_MINITEMS,
	    prof_bt_hash, prof_bt_keycomp)) {
		idalloc(prof_tdata);
		return (NULL);
	}
	ql_new(&prof_tdata->lru_ql);

	prof_tdata->vec = imalloc(sizeof(void *) * PROF_BT_MAX);
	if (prof_tdata->vec == NULL) {
		ckh_delete(&prof_tdata->bt2cnt);
		idalloc(prof_tdata);
		return (NULL);
	}

	prof_tdata->prng_state = 0;
	prof_tdata->threshold = 0;
	prof_tdata->accum = 0;

	prof_tdata->enq = false;
	prof_tdata->enq_idump = false;
	prof_tdata->enq_gdump = false;

	prof_tdata_tsd_set(&prof_tdata);

	return (prof_tdata);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0xcefda
jmp 0xcefdc
jmp 0xcefde
movl $0x60, %edi
callq 0xce5d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xcf000
movq $0x0, -0x8(%rbp)
jmp 0xcf0cf
movq -0x10(%rbp), %rdi
movl $0x40, %esi
leaq 0xd0(%rip), %rdx        # 0xcf0e0
leaq 0x199(%rip), %rcx       # 0xcf1b0
callq 0xdb1b0
testb $0x1, %al
jne 0xcf022
jmp 0xcf038
movq -0x10(%rbp), %rdi
callq 0xce700
movq $0x0, -0x8(%rbp)
jmp 0xcf0cf
jmp 0xcf03a
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movl $0x400, %edi            # imm = 0x400
callq 0xce5d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0xcf082
movq -0x10(%rbp), %rdi
callq 0xdb480
movq -0x10(%rbp), %rdi
callq 0xce700
movq $0x0, -0x8(%rbp)
jmp 0xcf0cf
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x58(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x59(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x5a(%rax)
leaq -0x10(%rbp), %rdi
callq 0xcf230
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)