LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/prof.c
// Function: prof_bt_hash
static void
prof_bt_hash(const void *key, unsigned minbits, size_t *hash1, size_t *hash2)
{
	size_t ret1, ret2;
	uint64_t h;
	prof_bt_t *bt = (prof_bt_t *)key;

	cassert(config_prof);
	assert(minbits <= 32 || (SIZEOF_PTR == 8 && minbits <= 64));
	assert(hash1 != NULL);
	assert(hash2 != NULL);

	h = hash(bt->vec, bt->len * sizeof(void *),
	    UINT64_C(0x94122f335b332aea));
	if (minbits <= 32) {
		/*
		 * Avoid doing multiple hashes, since a single hash provides
		 * enough bits.
		 */
		ret1 = h & ZU(0xffffffffU);
		ret2 = h >> 32;
	} else {
		ret1 = h;
		ret2 = hash(bt->vec, bt->len * sizeof(void *),
		    UINT64_C(0x8432a476666bbc13));
	}

	*hash1 = ret1;
	*hash2 = ret2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0xcf101
jmp 0xcf103
jmp 0xcf105
jmp 0xcf107
jmp 0xcf109
jmp 0xcf10b
jmp 0xcf10d
jmp 0xcf10f
jmp 0xcf111
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
shlq $0x3, %rsi
movabsq $-0x6bedd0cca4ccd516, %rdx # imm = 0x94122F335B332AEA
callq 0xd0c40
movq %rax, -0x38(%rbp)
cmpl $0x20, -0xc(%rbp)
ja 0xcf15e
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x30(%rbp)
jmp 0xcf18d
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
shlq $0x3, %rsi
movabsq $-0x7bcd5b89999443ed, %rdx # imm = 0x8432A476666BBC13
callq 0xd0c40
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %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_bt_keycomp
static bool
prof_bt_keycomp(const void *k1, const void *k2)
{
	const prof_bt_t *bt1 = (prof_bt_t *)k1;
	const prof_bt_t *bt2 = (prof_bt_t *)k2;

	cassert(config_prof);

	if (bt1->len != bt2->len)
		return (false);
	return (memcmp(bt1->vec, bt2->vec, bt1->len * sizeof(void *)) == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xcf1d2
jmp 0xcf1d4
jmp 0xcf1d6
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0xcf1ec
movb $0x0, -0x1(%rbp)
jmp 0xcf217
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
shlq $0x3, %rdx
callq 0x1f950
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
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_boot1
void
prof_boot1(void)
{

	cassert(config_prof);

	/*
	 * opt_prof and prof_promote must be in their final state before any
	 * arenas are initialized, so this function must be executed early.
	 */

	if (opt_prof_leak && opt_prof == false) {
		/*
		 * Enable opt_prof, but in such a way that profiles are never
		 * automatically dumped.
		 */
		opt_prof = true;
		opt_prof_gdump = false;
		prof_interval = 0;
	} else if (opt_prof) {
		if (opt_lg_prof_interval >= 0) {
			prof_interval = (((uint64_t)1U) <<
			    opt_lg_prof_interval);
		} else
			prof_interval = 0;
	}

	prof_promote = (opt_prof && opt_lg_prof_sample > LG_PAGE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
jmp 0xcf456
jmp 0xcf458
jmp 0xcf45a
jmp 0xcf45c
testb $0x1, 0x59f80(%rip)     # 0x1293e3
je 0xcf490
movb 0x59f76(%rip), %al      # 0x1293e1
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xcf490
movb $0x1, 0x59f65(%rip)     # 0x1293e1
movb $0x0, 0x59f5f(%rip)     # 0x1293e2
movq $0x0, 0x5afda(%rip) # 0x12a468
jmp 0xcf4ca
testb $0x1, 0x59f4a(%rip)     # 0x1293e1
je 0xcf4c8
cmpq $0x0, 0x4442f(%rip)     # 0x1138d0
jl 0xcf4bb
movq 0x44426(%rip), %rcx     # 0x1138d0
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x5afaf(%rip)     # 0x12a468
jmp 0xcf4c6
movq $0x0, 0x5afa2(%rip) # 0x12a468
jmp 0xcf4c8
jmp 0xcf4ca
xorl %eax, %eax
testb $0x1, 0x59f0e(%rip)     # 0x1293e1
movb %al, -0x1(%rbp)
je 0xcf4e6
cmpq $0xc, 0x443e8(%rip)     # 0x1138c8
seta %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
movb %al, 0x5af7f(%rip)      # 0x12a470
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_boot2
bool
prof_boot2(void)
{

	cassert(config_prof);

	if (opt_prof) {
		unsigned i;

		if (ckh_new(&bt2ctx, PROF_CKH_MINITEMS, prof_bt_hash,
		    prof_bt_keycomp))
			return (true);
		if (malloc_mutex_init(&bt2ctx_mtx))
			return (true);
		if (prof_tdata_tsd_boot()) {
			malloc_write(
			    "<jemalloc>: Error in pthread_key_create()\n");
			abort();
		}

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

		if (atexit(prof_fdump) != 0) {
			malloc_write("<jemalloc>: Error in atexit()\n");
			if (opt_abort)
				abort();
		}

		ctx_locks = (malloc_mutex_t *)base_alloc(PROF_NCTX_LOCKS *
		    sizeof(malloc_mutex_t));
		if (ctx_locks == NULL)
			return (true);
		for (i = 0; i < PROF_NCTX_LOCKS; i++) {
			if (malloc_mutex_init(&ctx_locks[i]))
				return (true);
		}
	}

#ifdef JEMALLOC_PROF_LIBGCC
	/*
	 * Cause the backtracing machinery to allocate its internal state
	 * before enabling profiling.
	 */
	_Unwind_Backtrace(prof_unwind_init_callback, NULL);
#endif

	prof_booted = true;

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0xcf50a
jmp 0xcf50c
jmp 0xcf50e
testb $0x1, 0x59ecc(%rip)     # 0x1293e1
je 0xcf62d
leaq 0x59ec6(%rip), %rdi     # 0x1293e8
movl $0x40, %esi
leaq -0x44e(%rip), %rdx      # 0xcf0e0
leaq -0x385(%rip), %rcx      # 0xcf1b0
callq 0xdb1b0
testb $0x1, %al
jne 0xcf540
jmp 0xcf549
movb $0x1, -0x1(%rbp)
jmp 0xcf638
leaq 0x5af28(%rip), %rdi     # 0x12a478
callq 0xcde60
testb $0x1, %al
jne 0xcf55b
jmp 0xcf564
movb $0x1, -0x1(%rbp)
jmp 0xcf638
callq 0xcf650
testb $0x1, %al
jne 0xcf56f
jmp 0xcf580
leaq 0x1e535(%rip), %rdi     # 0xedaab
callq 0xd7210
callq 0x1f1b0
leaq 0x5aea1(%rip), %rdi     # 0x12a428
callq 0xcde60
testb $0x1, %al
jne 0xcf592
jmp 0xcf59b
movb $0x1, -0x1(%rbp)
jmp 0xcf638
leaq 0xee(%rip), %rdi        # 0xcf690
callq 0xdd0f0
cmpl $0x0, %eax
je 0xcf5cb
leaq 0x1df50(%rip), %rdi     # 0xed503
callq 0xd7210
leaq 0x58eeb(%rip), %rax     # 0x1284aa
testb $0x1, (%rax)
je 0xcf5c9
callq 0x1f1b0
jmp 0xcf5cb
movl $0xa000, %edi           # imm = 0xA000
callq 0xbfc90
movq %rax, 0x5aec4(%rip)     # 0x12a4a0
cmpq $0x0, 0x5aebc(%rip)     # 0x12a4a0
jne 0xcf5ec
movb $0x1, -0x1(%rbp)
jmp 0xcf638
movl $0x0, -0x8(%rbp)
cmpl $0x400, -0x8(%rbp)      # imm = 0x400
jae 0xcf62b
movq 0x5ae9d(%rip), %rdi     # 0x12a4a0
movl -0x8(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0xcde60
testb $0x1, %al
jne 0xcf618
jmp 0xcf61e
movb $0x1, -0x1(%rbp)
jmp 0xcf638
jmp 0xcf620
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xcf5f3
jmp 0xcf62d
movb $0x1, 0x59de4(%rip)     # 0x129418
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/prof.c
// Function: prof_fdump
static void
prof_fdump(void)
{
	char filename[DUMP_FILENAME_BUFSIZE];

	cassert(config_prof);

	if (prof_booted == false)
		return;

	if (opt_prof_final && opt_prof_prefix[0] != '\0') {
		malloc_mutex_lock(&prof_dump_seq_mtx);
		prof_dump_filename(filename, 'f', UINT64_C(0xffffffffffffffff));
		malloc_mutex_unlock(&prof_dump_seq_mtx);
		prof_dump(false, filename, opt_prof_leak);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1010, %rsp           # imm = 0x1010
jmp 0xcf69d
jmp 0xcf69f
jmp 0xcf6a1
movb 0x59d71(%rip), %al      # 0x129418
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xcf6b3
jmp 0xcf711
testb $0x1, 0x4421e(%rip)     # 0x1138d8
je 0xcf711
movsbl 0x59d5d(%rip), %eax     # 0x129420
cmpl $0x0, %eax
je 0xcf711
leaq 0x5ad59(%rip), %rdi     # 0x12a428
callq 0xce760
leaq -0x1010(%rbp), %rdi
movl $0x66, %esi
movq $-0x1, %rdx
callq 0xceac0
leaq 0x5ad35(%rip), %rdi     # 0x12a428
callq 0xce780
leaq -0x1010(%rbp), %rsi
movb 0x59cde(%rip), %al      # 0x1293e3
xorl %edi, %edi
andb $0x1, %al
movzbl %al, %edx
callq 0xceb80
addq $0x1010, %rsp           # imm = 0x1010
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/prof.c
// Function: prof_prefork
void
prof_prefork(void)
{

	if (opt_prof) {
		unsigned i;

		malloc_mutex_lock(&bt2ctx_mtx);
		malloc_mutex_lock(&prof_dump_seq_mtx);
		for (i = 0; i < PROF_NCTX_LOCKS; i++)
			malloc_mutex_lock(&ctx_locks[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testb $0x1, 0x59cb2(%rip)     # 0x1293e1
je 0xcf77c
leaq 0x5ad40(%rip), %rdi     # 0x12a478
callq 0xce760
leaq 0x5ace4(%rip), %rdi     # 0x12a428
callq 0xce760
movl $0x0, -0x4(%rbp)
cmpl $0x400, -0x4(%rbp)      # imm = 0x400
jae 0xcf77a
movq 0x5ad40(%rip), %rdi     # 0x12a4a0
movl -0x4(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0xce760
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xcf750
jmp 0xcf77c
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/prof.c
// Function: prof_postfork_parent
void
prof_postfork_parent(void)
{

	if (opt_prof) {
		unsigned i;

		for (i = 0; i < PROF_NCTX_LOCKS; i++)
			malloc_mutex_postfork_parent(&ctx_locks[i]);
		malloc_mutex_postfork_parent(&prof_dump_seq_mtx);
		malloc_mutex_postfork_parent(&bt2ctx_mtx);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testb $0x1, 0x59c42(%rip)     # 0x1293e1
je 0xcf7ea
movl $0x0, -0x4(%rbp)
cmpl $0x400, -0x4(%rbp)      # imm = 0x400
jae 0xcf7d2
movq 0x5ace8(%rip), %rdi     # 0x12a4a0
movl -0x4(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0xcdf10
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xcf7a8
leaq 0x5ac4f(%rip), %rdi     # 0x12a428
callq 0xcdf10
leaq 0x5ac93(%rip), %rdi     # 0x12a478
callq 0xcdf10
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_postfork_child
void
prof_postfork_child(void)
{

	if (opt_prof) {
		unsigned i;

		for (i = 0; i < PROF_NCTX_LOCKS; i++)
			malloc_mutex_postfork_child(&ctx_locks[i]);
		malloc_mutex_postfork_child(&prof_dump_seq_mtx);
		malloc_mutex_postfork_child(&bt2ctx_mtx);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testb $0x1, 0x59be2(%rip)     # 0x1293e1
je 0xcf84a
movl $0x0, -0x4(%rbp)
cmpl $0x400, -0x4(%rbp)      # imm = 0x400
jae 0xcf832
movq 0x5ac88(%rip), %rdi     # 0x12a4a0
movl -0x4(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0xcdf50
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xcf808
leaq 0x5abef(%rip), %rdi     # 0x12a428
callq 0xcdf50
leaq 0x5ac33(%rip), %rdi     # 0x12a478
callq 0xcdf50
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_printf
static bool
prof_printf(bool propagate_err, const char *format, ...)
{
	bool ret;
	va_list ap;
	char buf[PROF_PRINTF_BUFSIZE];

	va_start(ap, format);
	malloc_vsnprintf(buf, sizeof(buf), format, ap);
	va_end(ap);
	ret = prof_write(propagate_err, buf);

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
testb %al, %al
je 0xd0777
movaps %xmm0, -0x130(%rbp)
movaps %xmm1, -0x120(%rbp)
movaps %xmm2, -0x110(%rbp)
movaps %xmm3, -0x100(%rbp)
movaps %xmm4, -0xf0(%rbp)
movaps %xmm5, -0xe0(%rbp)
movaps %xmm6, -0xd0(%rbp)
movaps %xmm7, -0xc0(%rbp)
movq %r9, -0x138(%rbp)
movq %r8, -0x140(%rbp)
movq %rcx, -0x148(%rbp)
movq %rdx, -0x150(%rbp)
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x160(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq -0x10(%rbp), %rdx
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x168(%rbp)
movl $0x80, %esi
leaq -0x30(%rbp), %rcx
callq 0xd7600
movq -0x168(%rbp), %rsi
movzbl -0x1(%rbp), %edi
andl $0x1, %edi
callq 0xd0b10
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x170, %rsp            # imm = 0x170
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_dump_ctx
static bool
prof_dump_ctx(bool propagate_err, prof_ctx_t *ctx, prof_bt_t *bt)
{
	unsigned i;

	cassert(config_prof);

	/*
	 * Current statistics can sum to 0 as a result of unmerged per thread
	 * statistics.  Additionally, interval- and growth-triggered dumps can
	 * occur between the time a ctx is created and when its statistics are
	 * filled in.  Avoid dumping any ctx that is an artifact of either
	 * implementation detail.
	 */
	if ((opt_prof_accum == false && ctx->cnt_summed.curobjs == 0) ||
	    (opt_prof_accum && ctx->cnt_summed.accumobjs == 0)) {
		assert(ctx->cnt_summed.curobjs == 0);
		assert(ctx->cnt_summed.curbytes == 0);
		assert(ctx->cnt_summed.accumobjs == 0);
		assert(ctx->cnt_summed.accumbytes == 0);
		return (false);
	}

	if (prof_printf(propagate_err, "%"PRId64": %"PRId64
	    " [%"PRIu64": %"PRIu64"] @",
	    ctx->cnt_summed.curobjs, ctx->cnt_summed.curbytes,
	    ctx->cnt_summed.accumobjs, ctx->cnt_summed.accumbytes))
		return (true);

	for (i = 0; i < bt->len; i++) {
		if (prof_printf(propagate_err, " %#"PRIxPTR,
		    (uintptr_t)bt->vec[i]))
			return (true);
	}

	if (prof_write(propagate_err, "\n"))
		return (true);

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0xd082a
jmp 0xd082c
jmp 0xd082e
movb 0x58bb0(%rip), %al      # 0x1293e4
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xd0849
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xd085d
testb $0x1, 0x58b94(%rip)     # 0x1293e4
je 0xd0876
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0xd0876
jmp 0xd085f
jmp 0xd0861
jmp 0xd0863
jmp 0xd0865
jmp 0xd0867
jmp 0xd0869
jmp 0xd086b
jmp 0xd086d
movb $0x0, -0x1(%rbp)
jmp 0xd092c
movb -0x2(%rbp), %al
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rdx
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq -0x10(%rbp), %rsi
movq 0x28(%rsi), %r8
movq -0x10(%rbp), %rsi
movq 0x30(%rsi), %r9
leaq 0x1d358(%rip), %rsi     # 0xedbf8
andb $0x1, %al
movzbl %al, %edi
movb $0x0, %al
callq 0xd0730
testb $0x1, %al
jne 0xd08b2
jmp 0xd08b8
movb $0x1, -0x1(%rbp)
jmp 0xd092c
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0xd0908
movb -0x2(%rbp), %al
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movl -0x1c(%rbp), %edx
movq (%rcx,%rdx,8), %rdx
leaq 0x1d32b(%rip), %rsi     # 0xedc0e
andb $0x1, %al
movzbl %al, %edi
movb $0x0, %al
callq 0xd0730
testb $0x1, %al
jne 0xd08f5
jmp 0xd08fb
movb $0x1, -0x1(%rbp)
jmp 0xd092c
jmp 0xd08fd
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd08bf
movb -0x2(%rbp), %al
leaq 0xfea7(%rip), %rsi      # 0xe07b9
andb $0x1, %al
movzbl %al, %edi
callq 0xd0b10
testb $0x1, %al
jne 0xd0922
jmp 0xd0928
movb $0x1, -0x1(%rbp)
jmp 0xd092c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/prof.c
// Function: prof_dump_maps
static bool
prof_dump_maps(bool propagate_err)
{
	int mfd;
	char filename[PATH_MAX + 1];

	cassert(config_prof);

	malloc_snprintf(filename, sizeof(filename), "/proc/%d/maps",
	    (int)getpid());
	mfd = open(filename, O_RDONLY);
	if (mfd != -1) {
		ssize_t nread;

		if (prof_write(propagate_err, "\nMAPPED_LIBRARIES:\n") &&
		    propagate_err)
			return (true);
		nread = 0;
		do {
			prof_dump_buf_end += nread;
			if (prof_dump_buf_end == PROF_DUMP_BUFSIZE) {
				/* Make space in prof_dump_buf before read(). */
				if (prof_flush(propagate_err) && propagate_err)
					return (true);
			}
			nread = read(mfd, &prof_dump_buf[prof_dump_buf_end],
			    PROF_DUMP_BUFSIZE - prof_dump_buf_end);
		} while (nread > 0);
		close(mfd);
	} else
		return (true);

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movb %dil, %al
andb $0x1, %al
movb %al, -0x2(%rbp)
jmp 0xd0955
jmp 0xd0957
jmp 0xd0959
leaq -0x1010(%rbp), %rax
movq %rax, -0x1020(%rbp)
callq 0x1f410
movq -0x1020(%rbp), %rdi
movl %eax, %ecx
movl $0x1001, %esi           # imm = 0x1001
leaq 0x1d293(%rip), %rdx     # 0xedc14
movb $0x0, %al
callq 0xda1c0
leaq -0x1010(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x1fc10
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
je 0xd0a5e
movb -0x2(%rbp), %al
leaq 0x1d273(%rip), %rsi     # 0xedc22
andb $0x1, %al
movzbl %al, %edi
callq 0xd0b10
testb $0x1, %al
jne 0xd09bf
jmp 0xd09ce
testb $0x1, -0x2(%rbp)
je 0xd09ce
movb $0x1, -0x1(%rbp)
jmp 0xd0a68
movq $0x0, -0x1018(%rbp)
movq -0x1018(%rbp), %rcx
movl 0x59ad6(%rip), %eax     # 0x12a4bc
addq %rcx, %rax
movl %eax, 0x59acd(%rip)     # 0x12a4bc
cmpl $0x10000, 0x59ac3(%rip) # imm = 0x10000
jne 0xd0a1c
movb -0x2(%rbp), %al
andb $0x1, %al
movzbl %al, %edi
callq 0xd0a80
testb $0x1, %al
jne 0xd0a0e
jmp 0xd0a1a
testb $0x1, -0x2(%rbp)
je 0xd0a1a
movb $0x1, -0x1(%rbp)
jmp 0xd0a68
jmp 0xd0a1c
movl -0x8(%rbp), %edi
movl 0x59a97(%rip), %eax     # 0x12a4bc
leaq 0x59a94(%rip), %rsi     # 0x12a4c0
addq %rax, %rsi
movl $0x10000, %eax          # imm = 0x10000
subl 0x59a82(%rip), %eax     # 0x12a4bc
movl %eax, %eax
movl %eax, %edx
callq 0x1f330
movq %rax, -0x1018(%rbp)
cmpq $0x0, -0x1018(%rbp)
jg 0xd09d9
movl -0x8(%rbp), %edi
callq 0x1f170
jmp 0xd0a64
movb $0x1, -0x1(%rbp)
jmp 0xd0a68
movb $0x0, -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_flush
static bool
prof_flush(bool propagate_err)
{
	bool ret = false;
	ssize_t err;

	cassert(config_prof);

	err = write(prof_dump_fd, prof_dump_buf, prof_dump_buf_end);
	if (err == -1) {
		if (propagate_err == false) {
			malloc_write("<jemalloc>: write() failed during heap "
			    "profile flush\n");
			if (opt_abort)
				abort();
		}
		ret = true;
	}
	prof_dump_buf_end = 0;

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb $0x0, -0x2(%rbp)
jmp 0xd0a96
jmp 0xd0a98
jmp 0xd0a9a
movl 0x59a18(%rip), %edi     # 0x12a4b8
movl 0x59a16(%rip), %eax     # 0x12a4bc
movl %eax, %edx
leaq 0x59a11(%rip), %rsi     # 0x12a4c0
callq 0x1fb50
movq %rax, -0x10(%rbp)
cmpq $-0x1, -0x10(%rbp)
jne 0xd0aef
movb -0x1(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xd0aeb
leaq 0x1d163(%rip), %rdi     # 0xedc36
callq 0xd7210
leaq 0x579cb(%rip), %rax     # 0x1284aa
testb $0x1, (%rax)
je 0xd0ae9
callq 0x1f1b0
jmp 0xd0aeb
movb $0x1, -0x2(%rbp)
movl $0x0, 0x599c3(%rip)     # 0x12a4bc
movb -0x2(%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/prof.c
// Function: prof_write
static bool
prof_write(bool propagate_err, const char *s)
{
	unsigned i, slen, n;

	cassert(config_prof);

	i = 0;
	slen = strlen(s);
	while (i < slen) {
		/* Flush the buffer if it is full. */
		if (prof_dump_buf_end == PROF_DUMP_BUFSIZE)
			if (prof_flush(propagate_err) && propagate_err)
				return (true);

		if (prof_dump_buf_end + slen <= PROF_DUMP_BUFSIZE) {
			/* Finish writing. */
			n = slen - i;
		} else {
			/* Write as much of s as will fit. */
			n = PROF_DUMP_BUFSIZE - prof_dump_buf_end;
		}
		memcpy(&prof_dump_buf[prof_dump_buf_end], &s[i], n);
		prof_dump_buf_end += n;
		i += n;
	}

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xd0b26
jmp 0xd0b28
jmp 0xd0b2a
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1f4d0
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0xd0be0
cmpl $0x10000, 0x59969(%rip) # imm = 0x10000
jne 0xd0b76
movb -0x2(%rbp), %al
andb $0x1, %al
movzbl %al, %edi
callq 0xd0a80
testb $0x1, %al
jne 0xd0b68
jmp 0xd0b74
testb $0x1, -0x2(%rbp)
je 0xd0b74
movb $0x1, -0x1(%rbp)
jmp 0xd0be4
jmp 0xd0b76
movl 0x59940(%rip), %eax     # 0x12a4bc
addl -0x18(%rbp), %eax
cmpl $0x10000, %eax          # imm = 0x10000
ja 0xd0b91
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xd0b9f
movl $0x10000, %eax          # imm = 0x10000
subl 0x59920(%rip), %eax     # 0x12a4bc
movl %eax, -0x1c(%rbp)
movl 0x59917(%rip), %eax     # 0x12a4bc
leaq 0x59914(%rip), %rdi     # 0x12a4c0
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
addq %rax, %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x1fbf0
movl -0x1c(%rbp), %eax
addl 0x598f0(%rip), %eax     # 0x12a4bc
movl %eax, 0x598ea(%rip)     # 0x12a4bc
movl -0x1c(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0xd0b3d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/quarantine.c
// Function: quarantine_init
static quarantine_t *
quarantine_init(size_t lg_maxobjs)
{
	quarantine_t *quarantine;

	quarantine = (quarantine_t *)imalloc(offsetof(quarantine_t, objs) +
	    ((ZU(1) << lg_maxobjs) * sizeof(quarantine_obj_t)));
	if (quarantine == NULL)
		return (NULL);
	quarantine->curbytes = 0;
	quarantine->curobjs = 0;
	quarantine->first = 0;
	quarantine->lg_maxobjs = lg_maxobjs;

	quarantine_tsd_set(&quarantine);

	return (quarantine);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movl $0x1, %edi
shlq %cl, %rdi
shlq $0x4, %rdi
addq $0x20, %rdi
callq 0xd1610
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd10ca
movq $0x0, -0x8(%rbp)
jmp 0xd110a
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq -0x18(%rbp), %rdi
callq 0xd1140
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/quarantine.c
// Function: quarantine_drain
static void
quarantine_drain(quarantine_t *quarantine, size_t upper_bound)
{

	while (quarantine->curbytes > upper_bound && quarantine->curobjs > 0) {
		quarantine_obj_t *obj = &quarantine->objs[quarantine->first];
		assert(obj->usize == isalloc(obj->ptr, config_prof));
		idalloc(obj->ptr);
		quarantine->curbytes -= obj->usize;
		quarantine->curobjs--;
		quarantine->first = (quarantine->first + 1) & ((ZU(1) <<
		    quarantine->lg_maxobjs) - 1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x19(%rbp)
jbe 0xd11e1
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
seta %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xd11ed
jmp 0xd1273
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0xd120a
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0xd1120
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movl $0x1, %eax
shlq %cl, %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rax
andq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xd11c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/quarantine.c
// Function: quarantine_grow
static quarantine_t *
quarantine_grow(quarantine_t *quarantine)
{
	quarantine_t *ret;

	ret = quarantine_init(quarantine->lg_maxobjs + 1);
	if (ret == NULL)
		return (quarantine);

	ret->curbytes = quarantine->curbytes;
	ret->curobjs = quarantine->curobjs;
	if (quarantine->first + quarantine->curobjs <= (ZU(1) <<
	    quarantine->lg_maxobjs)) {
		/* objs ring buffer data are contiguous. */
		memcpy(ret->objs, &quarantine->objs[quarantine->first],
		    quarantine->curobjs * sizeof(quarantine_obj_t));
	} else {
		/* objs ring buffer data wrap around. */
		size_t ncopy_a = (ZU(1) << quarantine->lg_maxobjs) -
		    quarantine->first;
		size_t ncopy_b = quarantine->curobjs - ncopy_a;

		memcpy(ret->objs, &quarantine->objs[quarantine->first], ncopy_a
		    * sizeof(quarantine_obj_t));
		memcpy(&ret->objs[ncopy_a], quarantine->objs, ncopy_b *
		    sizeof(quarantine_obj_t));
	}

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x1, %rdi
callq 0xd1090
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd12b5
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd13b8
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x8(%rcx), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
cmpq %rcx, %rax
ja 0xd1330
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
shlq $0x4, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
shlq $0x4, %rdx
callq 0x1fbf0
jmp 0xd13b0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movl $0x1, %eax
shlq %cl, %rax
movq -0x10(%rbp), %rcx
subq 0x10(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
shlq $0x4, %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
shlq $0x4, %rdx
callq 0x1fbf0
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
movq -0x28(%rbp), %rdx
shlq $0x4, %rdx
callq 0x1fbf0
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/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/quarantine.c
// Function: quarantine_boot
bool
quarantine_boot(void)
{

	cassert(config_fill);

	if (quarantine_tsd_boot())
		return (true);

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0xd13da
callq 0xd1400
testb $0x1, %al
jne 0xd13e5
jmp 0xd13eb
movb $0x1, -0x1(%rbp)
jmp 0xd13ef
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/quarantine.c
// Function: quarantine_cleanup
static void
quarantine_cleanup(void *arg)
{
	quarantine_t *quarantine = *(quarantine_t **)arg;

	if (quarantine == QUARANTINE_STATE_REINCARNATED) {
		/*
		 * Another destructor deallocated memory after this destructor
		 * was called.  Reset quarantine to QUARANTINE_STATE_PURGATORY
		 * in order to receive another callback.
		 */
		quarantine = QUARANTINE_STATE_PURGATORY;
		quarantine_tsd_set(&quarantine);
	} else if (quarantine == QUARANTINE_STATE_PURGATORY) {
		/*
		 * The previous time this destructor was called, we set the key
		 * to QUARANTINE_STATE_PURGATORY so that other destructors
		 * wouldn't cause re-creation of the quarantine.  This time, do
		 * nothing, so that the destructor will not be called again.
		 */
	} else if (quarantine != NULL) {
		quarantine_drain(quarantine, 0);
		idalloc(quarantine);
		quarantine = QUARANTINE_STATE_PURGATORY;
		quarantine_tsd_set(&quarantine);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x1, %eax
cmpq %rax, -0x10(%rbp)
jne 0xd2286
movl $0x2, %eax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xd1140
jmp 0xd22c6
movl $0x2, %eax
cmpq %rax, -0x10(%rbp)
jne 0xd2293
jmp 0xd22c4
cmpq $0x0, -0x10(%rbp)
je 0xd22c2
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd11b0
movq -0x10(%rbp), %rdi
callq 0xd1120
movl $0x2, %eax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xd1140
jmp 0xd22c4
jmp 0xd22c6
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/tcache.c
// Function: tcache_event_hard
void
tcache_event_hard(tcache_t *tcache)
{
	size_t binind = tcache->next_gc_bin;
	tcache_bin_t *tbin = &tcache->tbins[binind];
	tcache_bin_info_t *tbin_info = &tcache_bin_info[binind];

	if (tbin->low_water > 0) {
		/*
		 * Flush (ceiling) 3/4 of the objects below the low water mark.
		 */
		if (binind < NBINS) {
			tcache_bin_flush_small(tbin, binind, tbin->ncached -
			    tbin->low_water + (tbin->low_water >> 2), tcache);
		} else {
			tcache_bin_flush_large(tbin, binind, tbin->ncached -
			    tbin->low_water + (tbin->low_water >> 2), tcache);
		}
		/*
		 * Reduce fill count by 2X.  Limit lg_fill_div such that the
		 * fill count is always at least 1.
		 */
		if ((tbin_info->ncached_max >> (tbin->lg_fill_div+1)) >= 1)
			tbin->lg_fill_div++;
	} else if (tbin->low_water < 0) {
		/*
		 * Increase fill count by 2X.  Make sure lg_fill_div stays
		 * greater than 0.
		 */
		if (tbin->lg_fill_div > 1)
			tbin->lg_fill_div--;
	}
	tbin->low_water = tbin->ncached;

	tcache->next_gc_bin++;
	if (tcache->next_gc_bin == nhbins)
		tcache->next_gc_bin = 0;
	tcache->ev_cnt = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq 0x64fc3(%rip), %rax     # 0x13a4e8
movq -0x10(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jle 0xd55c7
cmpq $0x1c, -0x10(%rbp)
jae 0xd5576
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x18(%rbp), %rax
subl 0x8(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
sarl $0x2, %eax
addl %eax, %edx
movq -0x8(%rbp), %rcx
callq 0xd5640
jmp 0xd55a1
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x18(%rbp), %rax
subl 0x8(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
sarl $0x2, %eax
addl %eax, %edx
movq -0x8(%rbp), %rcx
callq 0xd58d0
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %ecx
addl $0x1, %ecx
shrl %cl, %eax
cmpl $0x1, %eax
jb 0xd55c5
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0xd55ec
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jge 0xd55ea
movq -0x18(%rbp), %rax
cmpl $0x1, 0xc(%rax)
jbe 0xd55e8
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0xd55ea
jmp 0xd55ec
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
cmpq 0x64edb(%rip), %rax     # 0x13a4f0
jne 0xd5622
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/tcache.c
// Function: tcache_arena_dissociate
void
tcache_arena_dissociate(tcache_t *tcache)
{

	if (config_stats) {
		/* Unlink from list of extant tcaches. */
		malloc_mutex_lock(&tcache->arena->lock);
		ql_remove(&tcache->arena->tcache_ql, tcache, link);
		malloc_mutex_unlock(&tcache->arena->lock);
		tcache_stats_merge(tcache, tcache->arena);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x8, %rdi
callq 0xd5bf0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x78(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0xd5d7a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x78(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x78(%rax), %rax
cmpq -0x8(%rbp), %rax
je 0xd5dcc
jmp 0xd5d8e
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xd5ddc
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq $0x0, 0x78(%rax)
jmp 0xd5dde
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x8, %rdi
callq 0xd5c50
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0xd5e10
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/tcache.c
// Function: tcache_thread_cleanup
void
tcache_thread_cleanup(void *arg)
{
	tcache_t *tcache = *(tcache_t **)arg;

	if (tcache == TCACHE_STATE_DISABLED) {
		/* Do nothing. */
	} else if (tcache == TCACHE_STATE_REINCARNATED) {
		/*
		 * Another destructor called an allocator function after this
		 * destructor was called.  Reset tcache to
		 * TCACHE_STATE_PURGATORY in order to receive another callback.
		 */
		tcache = TCACHE_STATE_PURGATORY;
		tcache_tsd_set(&tcache);
	} else if (tcache == TCACHE_STATE_PURGATORY) {
		/*
		 * The previous time this destructor was called, we set the key
		 * to TCACHE_STATE_PURGATORY so that other destructors wouldn't
		 * cause re-creation of the tcache.  This time, do nothing, so
		 * that the destructor will not be called again.
		 */
	} else if (tcache != NULL) {
		assert(tcache != TCACHE_STATE_PURGATORY);
		tcache_destroy(tcache);
		tcache = TCACHE_STATE_PURGATORY;
		tcache_tsd_set(&tcache);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x1, %eax
cmpq %rax, -0x10(%rbp)
jne 0xd6444
jmp 0xd649c
movl $0x2, %eax
cmpq %rax, -0x10(%rbp)
jne 0xd6463
movl $0x3, %eax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xd6100
jmp 0xd649a
movl $0x3, %eax
cmpq %rax, -0x10(%rbp)
jne 0xd6470
jmp 0xd6498
cmpq $0x0, -0x10(%rbp)
je 0xd6496
jmp 0xd6479
jmp 0xd647b
movq -0x10(%rbp), %rdi
callq 0xd6170
movl $0x3, %eax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xd6100
jmp 0xd6498
jmp 0xd649a
jmp 0xd649c
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/util.c
// Function: buferror
int
buferror(char *buf, size_t buflen)
{

#ifdef _WIN32
	FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), 0,
	    (LPSTR)buf, buflen, NULL);
	return (0);
#elif defined(_GNU_SOURCE)
	char *b = strerror_r(errno, buf, buflen);
	if (b != buf) {
		strncpy(buf, b, buflen);
		buf[buflen-1] = '\0';
	}
	return (0);
#else
	return (strerror_r(errno, buf, buflen));
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1f820
movl (%rax), %edi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x1f380
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0xd72f3
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x1f9e0
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ckh.c
// Function: ckh_new
bool
ckh_new(ckh_t *ckh, size_t minitems, ckh_hash_t *hash, ckh_keycomp_t *keycomp)
{
	bool ret;
	size_t mincells, usize;
	unsigned lg_mincells;

	assert(minitems > 0);
	assert(hash != NULL);
	assert(keycomp != NULL);

#ifdef CKH_COUNT
	ckh->ngrows = 0;
	ckh->nshrinks = 0;
	ckh->nshrinkfails = 0;
	ckh->ninserts = 0;
	ckh->nrelocs = 0;
#endif
	ckh->prng_state = 42; /* Value doesn't really matter. */
	ckh->count = 0;

	/*
	 * Find the minimum power of 2 that is large enough to fit aBaseCount
	 * entries.  We are using (2+,2) cuckoo hashing, which has an expected
	 * maximum load factor of at least ~0.86, so 0.75 is a conservative load
	 * factor that will typically allow 2^aLgMinItems to fit without ever
	 * growing the table.
	 */
	assert(LG_CKH_BUCKET_CELLS > 0);
	mincells = ((minitems + (3 - (minitems % 3))) / 3) << 2;
	for (lg_mincells = LG_CKH_BUCKET_CELLS;
	    (ZU(1) << lg_mincells) < mincells;
	    lg_mincells++)
		; /* Do nothing. */
	ckh->lg_minbuckets = lg_mincells - LG_CKH_BUCKET_CELLS;
	ckh->lg_curbuckets = lg_mincells - LG_CKH_BUCKET_CELLS;
	ckh->hash = hash;
	ckh->keycomp = keycomp;

	usize = sa2u(sizeof(ckhc_t) << lg_mincells, CACHELINE);
	if (usize == 0) {
		ret = true;
		goto label_return;
	}
	ckh->tab = (ckhc_t *)ipalloc(usize, CACHELINE, true);
	if (ckh->tab == NULL) {
		ret = true;
		goto label_return;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0xdb1ca
jmp 0xdb1cc
jmp 0xdb1ce
jmp 0xdb1d0
jmp 0xdb1d2
movq -0x8(%rbp), %rax
movl $0x2a, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0xdb1ea
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
movq -0x48(%rbp), %rax
movl $0x3, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
shlq $0x2, %rax
movq %rax, -0x30(%rbp)
movl $0x2, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
cmpq -0x30(%rbp), %rax
jae 0xdb248
jmp 0xdb23d
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xdb228
movl -0x3c(%rbp), %ecx
subl $0x2, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x3c(%rbp), %ecx
subl $0x2, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0x3c(%rbp), %eax
movl %eax, %ecx
movl $0x10, %edi
shlq %cl, %rdi
movl $0x40, %esi
callq 0xdb2e0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xdb2a2
movb $0x1, -0x21(%rbp)
jmp 0xdb2d5
movq -0x38(%rbp), %rdi
movl $0x40, %esi
movl $0x1, %edx
callq 0xdb440
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0xdb2d1
movb $0x1, -0x21(%rbp)
jmp 0xdb2d5
movb $0x0, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ckh.c
// Function: ckh_insert
bool
ckh_insert(ckh_t *ckh, const void *key, const void *data)
{
	bool ret;

	assert(ckh != NULL);
	assert(ckh_search(ckh, key, NULL, NULL));

#ifdef CKH_COUNT
	ckh->ninserts++;
#endif

	while (ckh_try_insert(ckh, &key, &data)) {
		if (ckh_grow(ckh)) {
			ret = true;
			goto label_return;
		}
	}

	ret = false;
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)
jmp 0xdb5e6
jmp 0xdb5e8
jmp 0xdb5ea
jmp 0xdb5ec
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0xdb630
testb $0x1, %al
jne 0xdb603
jmp 0xdb61a
movq -0x8(%rbp), %rdi
callq 0xdb730
testb $0x1, %al
jne 0xdb612
jmp 0xdb618
movb $0x1, -0x19(%rbp)
jmp 0xdb61e
jmp 0xdb5ec
movb $0x0, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ckh.c
// Function: ckh_try_insert
JEMALLOC_INLINE bool
ckh_try_insert(ckh_t *ckh, void const**argkey, void const**argdata)
{
	size_t hash1, hash2, bucket;
	const void *key = *argkey;
	const void *data = *argdata;

	ckh->hash(key, ckh->lg_curbuckets, &hash1, &hash2);

	/* Try to insert in primary bucket. */
	bucket = hash1 & ((ZU(1) << ckh->lg_curbuckets) - 1);
	if (ckh_try_bucket_insert(ckh, bucket, key, data) == false)
		return (false);

	/* Try to insert in secondary bucket. */
	bucket = hash2 & ((ZU(1) << ckh->lg_curbuckets) - 1);
	if (ckh_try_bucket_insert(ckh, bucket, key, data) == false)
		return (false);

	/*
	 * Try to find a place for this item via iterative eviction/relocation.
	 */
	return (ckh_evict_reloc_insert(ckh, bucket, argkey, argdata));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %esi
leaq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq *%rax
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0xdcd00
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xdb6bd
movb $0x0, -0x1(%rbp)
jmp 0xdb71d
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0xdcd00
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xdb703
movb $0x0, -0x1(%rbp)
jmp 0xdb71d
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xdcdd0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ckh.c
// Function: ckh_grow
static bool
ckh_grow(ckh_t *ckh)
{
	bool ret;
	ckhc_t *tab, *ttab;
	size_t lg_curcells;
	unsigned lg_prevbuckets;

#ifdef CKH_COUNT
	ckh->ngrows++;
#endif

	/*
	 * It is possible (though unlikely, given well behaved hashes) that the
	 * table will have to be doubled more than once in order to create a
	 * usable table.
	 */
	lg_prevbuckets = ckh->lg_curbuckets;
	lg_curcells = ckh->lg_curbuckets + LG_CKH_BUCKET_CELLS;
	while (true) {
		size_t usize;

		lg_curcells++;
		usize = sa2u(sizeof(ckhc_t) << lg_curcells, CACHELINE);
		if (usize == 0) {
			ret = true;
			goto label_return;
		}
		tab = (ckhc_t *)ipalloc(usize, CACHELINE, true);
		if (tab == NULL) {
			ret = true;
			goto label_return;
		}
		/* Swap in new table. */
		ttab = ckh->tab;
		ckh->tab = tab;
		tab = ttab;
		ckh->lg_curbuckets = lg_curcells - LG_CKH_BUCKET_CELLS;

		if (ckh_rebuild(ckh, tab) == false) {
			idalloc(tab);
			break;
		}

		/* Rebuilding failed, so back out partially rebuilt table. */
		idalloc(ckh->tab);
		ckh->tab = tab;
		ckh->lg_curbuckets = lg_prevbuckets;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
addl $0x2, %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movl $0x10, %edi
shlq %cl, %rdi
movl $0x40, %esi
callq 0xdb2e0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xdb78c
movb $0x1, -0x9(%rbp)
jmp 0xdb82f
movq -0x38(%rbp), %rdi
movl $0x40, %esi
movl $0x1, %edx
callq 0xdb440
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xdb7b0
movb $0x1, -0x9(%rbp)
jmp 0xdb82f
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
subq $0x2, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xdcf70
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xdb803
movq -0x18(%rbp), %rdi
callq 0xdb4b0
jmp 0xdb82b
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xdb4b0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x2c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0xdb756
movb $0x0, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ckh.c
// Function: ckh_remove
bool
ckh_remove(ckh_t *ckh, const void *searchkey, void **key, void **data)
{
	size_t cell;

	assert(ckh != NULL);

	cell = ckh_isearch(ckh, searchkey);
	if (cell != SIZE_T_MAX) {
		if (key != NULL)
			*key = (void *)ckh->tab[cell].key;
		if (data != NULL)
			*data = (void *)ckh->tab[cell].data;
		ckh->tab[cell].key = NULL;
		ckh->tab[cell].data = NULL; /* Not necessary. */

		ckh->count--;
		/* Try to halve the table if it is less than 1/4 full. */
		if (ckh->count < (ZU(1) << (ckh->lg_curbuckets
		    + LG_CKH_BUCKET_CELLS - 2)) && ckh->lg_curbuckets
		    > ckh->lg_minbuckets) {
			/* Ignore error due to OOM. */
			ckh_shrink(ckh);
		}

		return (false);
	}

	return (true);
}

// 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)
jmp 0xdb85a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xdb960
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
je 0xdb94a
cmpq $0x0, -0x20(%rbp)
je 0xdb89a
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0xdb8bf
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
addl $0x2, %ecx
subl $0x2, %ecx
movl %ecx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
cmpq %rcx, %rax
jae 0xdb944
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jbe 0xdb944
movq -0x10(%rbp), %rdi
callq 0xdba20
movb $0x0, -0x1(%rbp)
jmp 0xdb94e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)