LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1faa0
movdqu 0x30(%r14), %xmm1
movdqu 0x38(%rbx), %xmm0
paddq %xmm1, %xmm0
movdqu 0x48(%rbx), %xmm1
movdqu %xmm0, 0x38(%rbx)
movdqu 0x40(%r14), %xmm2
paddq %xmm1, %xmm2
movdqu %xmm2, 0x48(%rbx)
movq 0x58(%rbx), %rax
cmpq %r14, %rax
jne 0x8ca17
movq (%rax), %rax
movq %rax, 0x58(%rbx)
cmpq %r14, %rax
je 0x8ca39
movq (%r14), %rcx
movq 0x8(%r14), %rdx
movq %rcx, (%rdx)
movq %rdx, 0x8(%rcx)
movq %r14, (%r14)
movq %r14, 0x8(%r14)
testq %rax, %rax
sete %al
jmp 0x8ca43
movq $0x0, 0x58(%rbx)
movb $0x1, %al
cmpb $0x0, 0x5304a(%rip)     # 0xdfa94
sete %cl
movq %xmm0, %rdx
testq %rdx, %rdx
sete %dl
andb %al, %cl
andb %dl, %cl
cmpb $0x1, %cl
jne 0x8ca67
cmpl $0x0, 0x10(%rbx)
je 0x8ca77
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1fbb0
movl $0x1, 0x10(%rbx)
movq 0x8(%rbx), %rdi
callq 0x1fbb0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8ca93
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %fs:-0x18, %r14
movb $0x1, 0x58(%r14)
leaq 0x54079(%rip), %rdi     # 0xe0b28
callq 0x1faa0
movq 0x8(%rbx), %rdi
callq 0x1faa0
cmpq $0x0, 0x58(%rbx)
jne 0x8cb34
cmpq $0x0, 0x38(%rbx)
jne 0x8cb34
cmpl $0x1, 0x10(%rbx)
jne 0x8cb34
movq (%rbx), %rsi
leaq 0x52fbd(%rip), %rdi     # 0xdfa98
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x936a4
leaq 0x5403d(%rip), %rdi     # 0xe0b28
callq 0x1fbb0
movb $0x0, 0x58(%r14)
movb 0x59(%r14), %al
movb 0x5a(%r14), %bpl
movw $0x0, 0x59(%r14)
cmpb $0x1, %al
jne 0x8cb0d
callq 0x8cb7b
testb %bpl, %bpl
je 0x8cb17
callq 0x8d182
movq 0x8(%rbx), %rdi
callq 0x1fbb0
movq (%rbx), %rdi
callq 0x8c711
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x8c711
decl 0x10(%rbx)
movq 0x8(%rbx), %rdi
callq 0x1fbb0
leaq 0x53fe1(%rip), %rdi     # 0xe0b28
callq 0x1fbb0
movb $0x0, 0x58(%r14)
movb 0x59(%r14), %al
movb 0x5a(%r14), %bl
movw $0x0, 0x59(%r14)
cmpb $0x1, %al
jne 0x8cb69
callq 0x8cb7b
testb %bl, %bl
je 0x8cb76
popq %rbx
popq %r14
popq %rbp
jmp 0x8d182
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpb $0x1, 0x52f46(%rip)     # 0xdfac8
jne 0x8cbfc
movq %fs:-0x18, %rax
cmpq $0x3, %rax
jb 0x8cbfc
cmpb $0x1, 0x58(%rax)
jne 0x8cb9e
movb $0x1, 0x59(%rax)
retq
cmpb $0x0, 0x52f2b(%rip)     # 0xdfad0
je 0x8cbfc
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
leaq 0x53f20(%rip), %rbx     # 0xe0ad8
movq %rbx, %rdi
callq 0x1faa0
movq 0x53f39(%rip), %rdx     # 0xe0b00
movq %rsp, %r14
movq %r14, %rdi
movl $0x69, %esi
callq 0x8cbfd
incq 0x53f22(%rip)           # 0xe0b00
movq %rbx, %rdi
callq 0x1fbb0
xorl %edi, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x8cc71
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
callq 0x1f410
movq 0x53f4a(%rip), %r9      # 0xe0b60
cmpq $-0x1, %r15
je 0x8cc3b
leaq 0x169b2(%rip), %rdx     # 0xa35d5
leaq 0x52ea6(%rip), %rcx     # 0xdfad0
movl $0x1001, %esi           # imm = 0x1001
movq %r14, %rdi
movl %eax, %r8d
xorl %eax, %eax
pushq %r15
jmp 0x8cc5a
subq $0x8, %rsp
leaq 0x169a4(%rip), %rdx     # 0xa35ea
leaq 0x52e83(%rip), %rcx     # 0xdfad0
movl $0x1001, %esi           # imm = 0x1001
movq %r14, %rdi
movl %eax, %r8d
xorl %eax, %eax
pushq %rbx
callq 0x9255e
addq $0x10, %rsp
incq 0x53ef5(%rip)           # 0xe0b60
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movb $0x1, %al
cmpb $0x0, 0x52984(%rip)     # 0xdfa91
je 0x8d181
cmpb $0x1, 0x529b2(%rip)     # 0xdfac8
jne 0x8d181
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x8d168
cmpb $0x0, 0x5299f(%rip)     # 0xdfad0
je 0x8d177
leaq 0x5399e(%rip), %r14     # 0xe0ad8
movq %r14, %rdi
callq 0x1faa0
movq 0x539bf(%rip), %rdx     # 0xe0b08
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x6d, %esi
callq 0x8cbfd
incq 0x539a8(%rip)           # 0xe0b08
movq %r14, %rdi
callq 0x1fbb0
movl $0x1, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x8cc71
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpb $0x1, 0x5293f(%rip)     # 0xdfac8
jne 0x8d203
movq %fs:-0x18, %rax
cmpq $0x3, %rax
jb 0x8d203
cmpb $0x1, 0x58(%rax)
jne 0x8d1a5
movb $0x1, 0x5a(%rax)
retq
cmpb $0x0, 0x52924(%rip)     # 0xdfad0
je 0x8d203
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
leaq 0x53919(%rip), %rbx     # 0xe0ad8
movq %rbx, %rdi
callq 0x1faa0
movq 0x53942(%rip), %rdx     # 0xe0b10
movq %rsp, %r14
movq %r14, %rdi
movl $0x75, %esi
callq 0x8cbfd
incq 0x5392b(%rip)           # 0xe0b10
movq %rbx, %rdi
callq 0x1fbb0
xorl %edi, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x8cc71
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movl $0x60, %edi
callq 0x8c482
testq %rax, %rax
je 0x8d2b5
movq %rax, %rbx
leaq 0x9a(%rip), %rdx        # 0x8d2bc
leaq 0x190(%rip), %rcx       # 0x8d3b9
movl $0x40, %esi
movq %rax, %rdi
callq 0x92b08
testb %al, %al
jne 0x8d2ad
movq $0x0, 0x30(%rbx)
movl $0x400, %edi            # imm = 0x400
callq 0x8c482
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0x8d2a5
movq %fs:0x0, %rax
leaq -0x18(%rax), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x4b(%rbx)
movups %xmm0, 0x40(%rbx)
movq %rbx, %fs:-0x18
movl 0x538d9(%rip), %edi     # 0xe0b58
callq 0x1f1c0
testl %eax, %eax
je 0x8d2b7
leaq 0x164dc(%rip), %rdi     # 0xa376b
callq 0x915d4
leaq 0x518bf(%rip), %rax     # 0xdeb5a
cmpb $0x1, (%rax)
jne 0x8d2b7
callq 0x1f1b0
movq %rbx, %rdi
callq 0x92f1a
movq %rbx, %rdi
callq 0x8c711
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movabsq $-0x395b586ca42e166b, %rax # imm = 0xC6A4A7935BD1E995
movq (%rdi), %r8
movl 0x8(%rdi), %edi
movabsq $0x35253c9ade8f4ca8, %r9 # imm = 0x35253C9ADE8F4CA8
imulq %rdi, %r9
movabsq $-0x6bedd0cca4ccd516, %r10 # imm = 0x94122F335B332AEA
xorq %r9, %r10
testq %rdi, %rdi
je 0x8d326
leaq (,%rdi,8), %r11
xorl %ebx, %ebx
movq (%r8,%rbx), %r15
imulq %rax, %r15
movq %r15, %r14
shrq $0x2f, %r14
xorq %r15, %r14
imulq %rax, %r14
xorq %r10, %r14
imulq %rax, %r14
addq $0x8, %rbx
movq %r14, %r10
cmpq %rbx, %r11
jne 0x8d2fb
jmp 0x8d329
movq %r10, %r14
movq %r14, %r11
shrq $0x2f, %r11
xorq %r14, %r11
imulq %rax, %r11
movq %r11, %r10
shrq $0x2f, %r10
xorq %r11, %r10
cmpl $0x20, %esi
ja 0x8d34f
movl %r10d, %r10d
shrq $0x20, %r11
jmp 0x8d3ad
movabsq $-0x7bcd5b89999443ed, %rsi # imm = 0x8432A476666BBC13
xorq %rsi, %r9
testq %rdi, %rdi
je 0x8d392
shlq $0x3, %rdi
xorl %esi, %esi
movq (%r8,%rsi), %rbx
imulq %rax, %rbx
movq %rbx, %r11
shrq $0x2f, %r11
xorq %rbx, %r11
imulq %rax, %r11
xorq %r9, %r11
imulq %rax, %r11
addq $0x8, %rsi
movq %r11, %r9
cmpq %rsi, %rdi
jne 0x8d367
jmp 0x8d395
movq %r9, %r11
movq %r11, %rsi
shrq $0x2f, %rsi
xorq %r11, %rsi
imulq %rax, %rsi
movq %rsi, %r11
shrq $0x2f, %r11
xorq %rsi, %r11
movq %r10, (%rdx)
movq %r11, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/prof.c
// Function: prof_tdata_cleanup
void
prof_tdata_cleanup(void *arg)
{
	prof_thr_cnt_t *cnt;
	prof_tdata_t *prof_tdata = *(prof_tdata_t **)arg;

	cassert(config_prof);

	if (prof_tdata == PROF_TDATA_STATE_REINCARNATED) {
		/*
		 * Another destructor deallocated memory after this destructor
		 * was called.  Reset prof_tdata to PROF_TDATA_STATE_PURGATORY
		 * in order to receive another callback.
		 */
		prof_tdata = PROF_TDATA_STATE_PURGATORY;
		prof_tdata_tsd_set(&prof_tdata);
	} else if (prof_tdata == PROF_TDATA_STATE_PURGATORY) {
		/*
		 * The previous time this destructor was called, we set the key
		 * to PROF_TDATA_STATE_PURGATORY so that other destructors
		 * wouldn't cause re-creation of the prof_tdata.  This time, do
		 * nothing, so that the destructor will not be called again.
		 */
	} else if (prof_tdata != NULL) {
		/*
		 * Delete the hash table.  All of its contents can still be
		 * iterated over via the LRU.
		 */
		ckh_delete(&prof_tdata->bt2cnt);
		/*
		 * Iteratively merge cnt's into the global stats and delete
		 * them.
		 */
		while ((cnt = ql_last(&prof_tdata->lru_ql, lru_link)) != NULL) {
			ql_remove(&prof_tdata->lru_ql, cnt, lru_link);
			prof_ctx_merge(cnt->ctx, cnt);
			idalloc(cnt);
		}
		idalloc(prof_tdata->vec);
		idalloc(prof_tdata);
		prof_tdata = PROF_TDATA_STATE_PURGATORY;
		prof_tdata_tsd_set(&prof_tdata);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
cmpq $0x1, %rbx
je 0x8d471
testq $-0x3, %rbx
je 0x8d4b5
movq %rbx, %rdi
callq 0x92f1a
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x8d460
movq 0x18(%rax), %r14
testq %r14, %r14
je 0x8d460
cmpq %r14, %rax
jne 0x8d423
movq 0x10(%rax), %rax
movq %rax, 0x30(%rbx)
cmpq %r14, %rax
je 0x8d442
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movq %rax, 0x10(%rcx)
movq %rcx, 0x18(%rax)
movq %r14, 0x10(%r14)
movq %r14, 0x18(%r14)
jmp 0x8d44a
movq $0x0, 0x30(%rbx)
movq 0x20(%r14), %rdi
movq %r14, %rsi
callq 0x8c9cc
movq %r14, %rdi
callq 0x8c711
jmp 0x8d404
movq 0x38(%rbx), %rdi
callq 0x8c711
movq %rbx, %rdi
callq 0x8c711
movq %fs:0x0, %rax
leaq -0x18(%rax), %rsi
movq $0x2, %fs:-0x18
movl 0x536c4(%rip), %edi     # 0xe0b58
callq 0x1f1c0
testl %eax, %eax
je 0x8d4b5
leaq 0x162c7(%rip), %rdi     # 0xa376b
callq 0x915d4
leaq 0x516aa(%rip), %rax     # 0xdeb5a
cmpb $0x1, (%rax)
je 0x8d4bd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1f1b0
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x5254e(%rip)     # 0xdfa91
jne 0x8d619
leaq 0x52548(%rip), %rdi     # 0xdfa98
leaq -0x29b(%rip), %rdx      # 0x8d2bc
leaq -0x1a5(%rip), %rcx      # 0x8d3b9
movl $0x40, %esi
callq 0x92b08
movb $0x1, %bl
testb %al, %al
jne 0x8d622
leaq 0x535af(%rip), %rdi     # 0xe0b28
callq 0x8bfc4
testb %al, %al
jne 0x8d622
leaq 0x535cb(%rip), %rdi     # 0xe0b58
leaq -0x1b6(%rip), %rsi      # 0x8d3de
callq 0x1f5a0
testl %eax, %eax
jne 0x8d62c
movb $0x1, 0x524e8(%rip)     # 0xdfa90
leaq 0x53529(%rip), %rdi     # 0xe0ad8
callq 0x8bfc4
testb %al, %al
jne 0x8d622
leaq 0x7e(%rip), %rdi        # 0x8d63d
callq 0x93de0
testl %eax, %eax
je 0x8d5e0
leaq 0x15a54(%rip), %rdi     # 0xa3023
callq 0x915d4
leaq 0x5157f(%rip), %rax     # 0xdeb5a
cmpb $0x1, (%rax)
je 0x8d638
movl $0xa000, %edi           # imm = 0xA000
callq 0x85494
movq %rax, 0x5355f(%rip)     # 0xe0b50
testq %rax, %rax
je 0x8d622
xorl %r14d, %r14d
movq 0x53550(%rip), %rdi     # 0xe0b50
addq %r14, %rdi
callq 0x8bfc4
testb %al, %al
jne 0x8d622
addq $0x28, %r14
cmpq $0xa000, %r14           # imm = 0xA000
jne 0x8d5f9
movb $0x1, 0x524a8(%rip)     # 0xdfac8
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x15f77(%rip), %rdi     # 0xa35aa
callq 0x915d4
callq 0x1f1b0
// File: /workspace/github_c_makefile_star2_O3/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:
cmpb $0x1, 0x52484(%rip)     # 0xdfac8
jne 0x8d6db
cmpb $0x1, 0x3c937(%rip)     # 0xc9f88
jne 0x8d6db
cmpb $0x0, 0x52472(%rip)     # 0xdfad0
je 0x8d6db
pushq %r14
pushq %rbx
subq $0x1018, %rsp           # imm = 0x1018
leaq 0x53467(%rip), %rbx     # 0xe0ad8
movq %rbx, %rdi
callq 0x1faa0
callq 0x1f410
movq 0x534db(%rip), %r9      # 0xe0b60
movl $0x66, (%rsp)
leaq 0x15f57(%rip), %rdx     # 0xa35ea
leaq 0x52436(%rip), %rcx     # 0xdfad0
leaq 0x10(%rsp), %r14
movl $0x1001, %esi           # imm = 0x1001
movq %r14, %rdi
movl %eax, %r8d
xorl %eax, %eax
callq 0x9255e
incq 0x534a8(%rip)           # 0xe0b60
movq %rbx, %rdi
callq 0x1fbb0
movzbl 0x523cc(%rip), %edx     # 0xdfa93
xorl %edi, %edi
movq %r14, %rsi
callq 0x8cc71
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpb $0x1, 0x523ae(%rip)     # 0xdfa91
jne 0x8d71d
pushq %rbx
leaq 0x5343b(%rip), %rdi     # 0xe0b28
callq 0x1faa0
leaq 0x533df(%rip), %rdi     # 0xe0ad8
callq 0x1faa0
xorl %ebx, %ebx
movq 0x53449(%rip), %rdi     # 0xe0b50
addq %rbx, %rdi
callq 0x1faa0
addq $0x28, %rbx
cmpq $0xa000, %rbx           # imm = 0xA000
jne 0x8d700
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpb $0x1, 0x5236c(%rip)     # 0xdfa91
jne 0x8d75f
pushq %rbx
xorl %ebx, %ebx
movq 0x5341f(%rip), %rdi     # 0xe0b50
addq %rbx, %rdi
callq 0x8c018
addq $0x28, %rbx
cmpq $0xa000, %rbx           # imm = 0xA000
jne 0x8d72a
leaq 0x5338b(%rip), %rdi     # 0xe0ad8
callq 0x8c018
leaq 0x533cf(%rip), %rdi     # 0xe0b28
popq %rbx
jmp 0x8c018
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpb $0x1, 0x5232a(%rip)     # 0xdfa91
jne 0x8d7a1
pushq %rbx
xorl %ebx, %ebx
movq 0x533dd(%rip), %rdi     # 0xe0b50
addq %rbx, %rdi
callq 0x8c01d
addq $0x28, %rbx
cmpq $0xa000, %rbx           # imm = 0xA000
jne 0x8d76c
leaq 0x53349(%rip), %rdi     # 0xe0ad8
callq 0x8c01d
leaq 0x5338d(%rip), %rdi     # 0xe0b28
popq %rbx
jmp 0x8c01d
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movl %edi, %ebp
movl 0x5321a(%rip), %edi     # 0xe0b68
movl 0x53218(%rip), %edx     # 0xe0b6c
leaq 0x53215(%rip), %rsi     # 0xe0b70
callq 0x1fb30
movq %rax, %rbx
cmpq $-0x1, %rax
setne %al
orb %bpl, %al
jne 0x8d987
leaq 0x15dbf(%rip), %rdi     # 0xa3735
callq 0x915d4
leaq 0x511d8(%rip), %rax     # 0xdeb5a
cmpb $0x1, (%rax)
je 0x8d99f
cmpq $-0x1, %rbx
sete %al
movl $0x0, 0x531d4(%rip)     # 0xe0b6c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1f1b0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebp
movq %rsi, %rdi
callq 0x1f4f0
movq %rax, %r15
xorl %ebx, %ebx
testl %r15d, %r15d
je 0x8da3d
movl 0x5319f(%rip), %r13d    # 0xe0b6c
movzbl %bpl, %ebp
cmpl $0x10000, %r13d         # imm = 0x10000
jne 0x8d9ed
movl %ebp, %edi
callq 0x8d943
testb %bpl, %al
jne 0x8da3b
movl 0x5317f(%rip), %r13d    # 0xe0b6c
leal (%r15,%r13), %eax
movl %r15d, %ecx
subl %ebx, %ecx
movl $0x10000, %r12d         # imm = 0x10000
subl %r13d, %r12d
cmpl $0x10001, %eax          # imm = 0x10001
cmovbl %ecx, %r12d
movl %r13d, %edi
leaq 0x5315e(%rip), %rax     # 0xe0b70
addq %rax, %rdi
movl %ebx, %esi
addq %r14, %rsi
movq %r12, %rdx
callq 0x1fbd0
addl %r12d, %r13d
movl %r13d, 0x53140(%rip)    # 0xe0b6c
addl %ebx, %r12d
movl %r12d, %ebx
cmpl %r15d, %r12d
jb 0x8d9d1
xorl %ebx, %ebx
jmp 0x8da3d
movb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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:
cmpq %rsi, (%rdi)
jbe 0x8e2b1
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rdi), %r15
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x8e2a6
movq 0x10(%r14), %r12
shlq $0x4, %r12
movq (%r15,%r12), %rdi
callq 0x8df80
movq (%r14), %rdx
subq 0x8(%r15,%r12), %rdx
movq 0x8(%r14), %rax
movq %rdx, (%r14)
decq %rax
movq %rax, 0x8(%r14)
movq 0x10(%r14), %rsi
incq %rsi
movb 0x18(%r14), %cl
movq $-0x1, %rdi
shlq %cl, %rdi
notq %rdi
andq %rsi, %rdi
movq %rdi, 0x10(%r14)
cmpq %rbx, %rdx
ja 0x8e256
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq (%rdi), %rbx
cmpq $0x1, %rbx
je 0x8e3e7
testq $-0x3, %rbx
je 0x8e42b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8e23b
movq %rbx, %rdi
callq 0x8df80
movq %fs:0x0, %rax
leaq -0x10(%rax), %rsi
movq $0x2, %fs:-0x10
movl 0x6276a(%rip), %edi     # 0xf0b74
callq 0x1f1c0
testl %eax, %eax
je 0x8e42b
leaq 0x1537f(%rip), %rdi     # 0xa3799
callq 0x915d4
leaq 0x50734(%rip), %rax     # 0xdeb5a
cmpb $0x1, (%rax)
je 0x8e42d
popq %rbx
retq
callq 0x1f1b0
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x24(%rdi), %r15d
movq %r15, %rax
shlq $0x5, %rax
leaq (%rdi,%rax), %r14
addq $0x28, %r14
movl 0x8(%r14), %eax
testl %eax, %eax
jle 0x90b97
movq 0x6001a(%rip), %r12     # 0xf0b90
movl %eax, %edx
shrl $0x2, %edx
subl %eax, %edx
addl 0x10(%r14), %edx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
cmpl $0x1b, %r15d
ja 0x90baa
callq 0x90bee
jmp 0x90baf
jns 0x90bc3
movl 0xc(%r14), %eax
cmpl $0x2, %eax
jb 0x90bc3
decl %eax
movl %eax, 0xc(%r14)
jmp 0x90bc3
callq 0x90dea
movl (%r12,%r15,4), %eax
movl 0xc(%r14), %ecx
incl %ecx
shrl %cl, %eax
testl %eax, %eax
je 0x90bc3
movl %ecx, 0xc(%r14)
movl 0x10(%r14), %eax
movl %eax, 0x8(%r14)
movl 0x24(%rbx), %eax
incl %eax
xorl %ecx, %ecx
cmpq %rax, 0x5ffbf(%rip)     # 0xf0b98
cmovel %ecx, %eax
movl %eax, 0x24(%rbx)
movl %ecx, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/tcache.c
// Function: tcache_alloc_small_hard
void *
tcache_alloc_small_hard(tcache_t *tcache, tcache_bin_t *tbin, size_t binind)
{
	void *ret;

	arena_tcache_fill_small(tcache->arena, tbin, binind,
	    config_prof ? tcache->prof_accumbytes : 0);
	if (config_prof)
		tcache->prof_accumbytes = 0;
	ret = tcache_alloc_easy(tbin);

	return (ret);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x18(%rdi), %rdi
xorl %ecx, %ecx
callq 0x804f6
movl 0x10(%rbx), %eax
testl %eax, %eax
je 0x90f82
decl %eax
movl %eax, 0x10(%rbx)
cmpl 0x8(%rbx), %eax
jge 0x90f76
movl %eax, 0x8(%rbx)
movq 0x18(%rbx), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %rax
jmp 0x90f8b
movl $0xffffffff, 0x8(%rbx)  # imm = 0xFFFFFFFF
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
addq $0x8, %rdi
callq 0x1faa0
movq 0x18(%rbx), %rdi
movq 0x78(%rdi), %rax
cmpq %rbx, %rax
jne 0x91007
movq (%rax), %rax
movq %rax, 0x78(%rdi)
cmpq %rbx, %rax
je 0x91023
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
movq %rbx, (%rbx)
movq %rbx, 0x8(%rbx)
jmp 0x9102b
movq $0x0, 0x78(%rdi)
addq $0x8, %rdi
callq 0x1fbb0
movq 0x18(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x91041
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/tcache.c
// Function: tcache_create
tcache_t *
tcache_create(arena_t *arena)
{
	tcache_t *tcache;
	size_t size, stack_offset;
	unsigned i;

	size = offsetof(tcache_t, tbins) + (sizeof(tcache_bin_t) * nhbins);
	/* Naturally align the pointer stacks. */
	size = PTR_CEILING(size);
	stack_offset = size;
	size += stack_nelms * sizeof(void *);
	/*
	 * Round up to the nearest multiple of the cacheline size, in order to
	 * avoid the possibility of false cacheline sharing.
	 *
	 * That this works relies on the same logic as in ipalloc(), but we
	 * cannot directly call ipalloc() here due to tcache bootstrapping
	 * issues.
	 */
	size = (size + CACHELINE_MASK) & (-CACHELINE);

	if (size <= SMALL_MAXCLASS)
		tcache = (tcache_t *)arena_malloc_small(arena, size, true);
	else if (size <= tcache_maxclass)
		tcache = (tcache_t *)arena_malloc_large(arena, size, true);
	else
		tcache = (tcache_t *)icallocx(size, false, arena);

	if (tcache == NULL)
		return (NULL);

	tcache_arena_associate(tcache, arena);

	assert((TCACHE_NSLOTS_SMALL_MAX & 1U) == 0);
	for (i = 0; i < nhbins; i++) {
		tcache->tbins[i].lg_fill_div = 1;
		tcache->tbins[i].avail = (void **)((uintptr_t)tcache +
		    (uintptr_t)stack_offset);
		stack_offset += tcache_bin_info[i].ncached_max * sizeof(void *);
	}

	tcache_tsd_set(&tcache);

	return (tcache);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x5fa9e(%rip), %r15d    # 0xf0b98
shll $0x5, %r15d
addl $0x2f, %r15d
andl $-0x18, %r15d
movl 0x5fa94(%rip), %eax     # 0xf0ba0
leaq (%r15,%rax,8), %r14
addq $0x3f, %r14
andq $-0x40, %r14
cmpq $0xe00, %r14            # imm = 0xE00
ja 0x91133
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x80c45
jmp 0x91189
cmpq 0x5fa6e(%rip), %r14     # 0xf0ba8
jbe 0x91157
leaq 0x4e7ed(%rip), %rax     # 0xdf930
cmpq %r14, (%rax)
jae 0x9115c
movq %r14, %rdi
movl $0x1, %esi
callq 0x8b91c
jmp 0x91189
movq %rbx, %rdi
jmp 0x9117c
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x9117c
movq 0x34dcd(%rip), %rax     # 0xc5f38
movq %fs:(%rax), %rdi
testq %rdi, %rdi
jne 0x9117c
callq 0x7c4da
movq %rax, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x80ebe
movq %rax, %r14
testq %rax, %rax
je 0x91226
movq %r14, %rdi
movq %rbx, %rsi
callq 0x90f8d
movq 0x5f9f1(%rip), %rax     # 0xf0b98
testq %rax, %rax
je 0x911e6
leaq 0x28(%r14), %rcx
movl $0x1, %edx
xorl %esi, %esi
movq %rsi, %rdi
shlq $0x5, %rdi
movl $0x1, 0xc(%rcx,%rdi)
leaq (%r15,%r14), %r8
movq %r8, 0x18(%rcx,%rdi)
movq 0x5f9ba(%rip), %rdi     # 0xf0b90
movl (%rdi,%rsi,4), %esi
leaq (%r15,%rsi,8), %r15
movl %edx, %esi
incl %edx
cmpq %rsi, %rax
ja 0x911b7
movq %fs:0x0, %rax
leaq -0x8(%rax), %rsi
movq %r14, %fs:-0x8
movl 0x5f9ab(%rip), %edi     # 0xf0bb0
callq 0x1f1c0
testl %eax, %eax
je 0x91226
leaq 0x11f59(%rip), %rdi     # 0xa316e
callq 0x915d4
leaq 0x4d939(%rip), %rax     # 0xdeb5a
cmpb $0x1, (%rax)
je 0x9122f
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1f1b0
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/tcache.c
// Function: tcache_boot0
bool
tcache_boot0(void)
{
	unsigned i;

	/*
	 * If necessary, clamp opt_lg_tcache_max, now that arena_maxclass is
	 * known.
	 */
	if (opt_lg_tcache_max < 0 || (1U << opt_lg_tcache_max) < SMALL_MAXCLASS)
		tcache_maxclass = SMALL_MAXCLASS;
	else if ((1U << opt_lg_tcache_max) > arena_maxclass)
		tcache_maxclass = arena_maxclass;
	else
		tcache_maxclass = (1U << opt_lg_tcache_max);

	nhbins = NBINS + (tcache_maxclass >> LG_PAGE);

	/* Initialize tcache_bin_info. */
	tcache_bin_info = (tcache_bin_info_t *)base_alloc(nhbins *
	    sizeof(tcache_bin_info_t));
	if (tcache_bin_info == NULL)
		return (true);
	stack_nelms = 0;
	for (i = 0; i < NBINS; i++) {
		if ((arena_bin_info[i].nregs << 1) <= TCACHE_NSLOTS_SMALL_MAX) {
			tcache_bin_info[i].ncached_max =
			    (arena_bin_info[i].nregs << 1);
		} else {
			tcache_bin_info[i].ncached_max =
			    TCACHE_NSLOTS_SMALL_MAX;
		}
		stack_nelms += tcache_bin_info[i].ncached_max;
	}
	for (; i < nhbins; i++) {
		tcache_bin_info[i].ncached_max = TCACHE_NSLOTS_LARGE;
		stack_nelms += tcache_bin_info[i].ncached_max;
	}

	return (false);
}

// Assembly:
movq 0x38b2b(%rip), %rcx     # 0xc9f98
movl $0xe00, %eax            # imm = 0xE00
testq %rcx, %rcx
js 0x91494
cmpl $0xc, %ecx
jb 0x91494
movl $0x1, %eax
shll %cl, %eax
leaq 0x4e4a6(%rip), %rcx     # 0xdf930
movq (%rcx), %rcx
cmpq %rax, %rcx
cmovbq %rcx, %rax
pushq %rax
movq %rax, 0x5f70c(%rip)     # 0xf0ba8
shrq $0xc, %rax
leaq 0x1c(%rax), %rcx
movq %rcx, 0x5f6ed(%rip)     # 0xf0b98
leaq 0x70(,%rax,4), %rdi
callq 0x85494
movq %rax, 0x5f6d1(%rip)     # 0xf0b90
testq %rax, %rax
je 0x9159e
leaq 0x4d731(%rip), %rcx     # 0xdec00
addq $0x20, %rcx
pxor %xmm0, %xmm0
xorl %edx, %edx
movdqa 0x2b4f(%rip), %xmm1     # 0x94030
movdqa 0x131c7(%rip), %xmm2    # 0xa46b0
movdqa 0x131cf(%rip), %xmm3    # 0xa46c0
movd 0x138(%rcx), %xmm4
movd 0xd0(%rcx), %xmm5
punpckldq %xmm4, %xmm5    # xmm5 = xmm5[0],xmm4[0],xmm5[1],xmm4[1]
movd 0x68(%rcx), %xmm4
movd (%rcx), %xmm6
punpckldq %xmm4, %xmm6    # xmm6 = xmm6[0],xmm4[0],xmm6[1],xmm4[1]
punpcklqdq %xmm5, %xmm6    # xmm6 = xmm6[0],xmm5[0]
paddd %xmm6, %xmm6
movdqa %xmm6, %xmm4
pxor %xmm1, %xmm4
pcmpgtd %xmm2, %xmm4
movdqa %xmm4, %xmm5
pandn %xmm6, %xmm5
pand %xmm3, %xmm4
por %xmm5, %xmm4
movdqu %xmm4, (%rax,%rdx,4)
paddd %xmm4, %xmm0
addq $0x4, %rdx
addq $0x1a0, %rcx            # imm = 0x1A0
cmpq $0x1c, %rdx
jne 0x914f1
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddd %xmm0, %xmm1
pshufd $0x55, %xmm1, %xmm0     # xmm0 = xmm1[1,1,1,1]
paddd %xmm1, %xmm0
movd %xmm0, 0x5f636(%rip)    # 0xf0ba0
movq 0x5f627(%rip), %rcx     # 0xf0b98
cmpq $0x1d, %rcx
jb 0x9159e
movd %xmm0, %edx
movl $0x1c, %edi
movl $0x1d, %esi
movl $0x14, (%rax,%rdi,4)
addl $0x14, %edx
movl %esi, %edi
incl %esi
cmpq %rdi, %rcx
ja 0x91585
movl %edx, 0x5f602(%rip)     # 0xf0ba0
testq %rax, %rax
sete %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rcx, %r8
movq %rdx, %r9
movq %rdi, %rbx
movl $0x2a, (%rdi)
movq $0x0, 0x8(%rdi)
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
movq %rsi, %rax
mulq %rcx
shrq %rdx
leaq (%rdx,%rdx,2), %rdx
movq %rsi, %rax
subq %rdx, %rax
xorq $0x3, %rax
addq %rsi, %rax
mulq %rcx
addq %rdx, %rdx
andq $-0x4, %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leal 0x3(%rax), %ecx
movl $0x1, %esi
shlq %cl, %rsi
incl %eax
cmpq %rdx, %rsi
jb 0x92b53
movl %eax, 0x10(%rbx)
movl %eax, 0x14(%rbx)
movq %r9, 0x18(%rbx)
movq %r8, 0x20(%rbx)
movl $0x10, %edx
shlq %cl, %rdx
leaq 0x3f(%rdx), %rdi
andq $-0x40, %rdi
movb $0x1, %al
cmpq %rdx, %rdi
jb 0x92c18
leaq 0x4cd9b(%rip), %rcx     # 0xdf930
movq (%rcx), %rcx
cmpq %rcx, %rdi
jbe 0x92bca
leaq 0xfff(%rdx), %rdi
andq $-0x1000, %rdi          # imm = 0xF000
cmpq %rdx, %rdi
jb 0x92c18
cmpq %rcx, %rdi
jbe 0x92c04
leaq 0x4ccc4(%rip), %rcx     # 0xdf880
movq (%rcx), %rcx
addq %rcx, %rdi
notq %rcx
andq %rcx, %rdi
jmp 0x92c04
cmpq $0xe00, %rdi            # imm = 0xE00
ja 0x92bf6
decq %rdi
shrq $0x3, %rdi
leaq 0x105df(%rip), %rcx     # 0xa31c0
movzbl (%rcx,%rdi), %ecx
imulq $0x68, %rcx, %rcx
leaq 0x4c010(%rip), %rdx     # 0xdec00
movq (%rdx,%rcx), %rdi
jmp 0x92c04
addq $0xfff, %rdi            # imm = 0xFFF
andq $-0x1000, %rdi          # imm = 0xF000
testq %rdi, %rdi
je 0x92c18
callq 0x92c1a
movq %rax, 0x28(%rbx)
testq %rax, %rax
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rax
movq %rsi, (%rax)
leaq 0x18(%rsp), %rcx
movq %rdx, (%rcx)
movq %rax, %rsi
movq %rcx, %rdx
callq 0x93425
testb %al, %al
je 0x93402
movl 0x14(%rbx), %eax
movq %rax, 0x10(%rsp)
leal 0x2(%rax), %r14d
movl $0x20, %eax
movl %r14d, %ecx
shlq %cl, %rax
leaq 0x3f(%rax), %rdi
andq $-0x40, %rdi
cmpq %rax, %rdi
setb %cl
jb 0x9340c
movl %ecx, 0xc(%rsp)
leaq 0x1(%r14), %rcx
movq %rcx, %r13
leaq 0x4c679(%rip), %rcx     # 0xdf930
movq (%rcx), %rcx
cmpq %rcx, %rdi
jbe 0x932f0
leaq 0xfff(%rax), %rdi
andq $-0x1000, %rdi          # imm = 0xF000
cmpq %rax, %rdi
jb 0x9340c
cmpq %rcx, %rdi
jbe 0x9332a
leaq 0x4c59e(%rip), %rax     # 0xdf880
movq (%rax), %rax
addq %rax, %rdi
notq %rax
andq %rax, %rdi
jmp 0x9332a
cmpq $0xe00, %rdi            # imm = 0xE00
ja 0x9331c
decq %rdi
shrq $0x3, %rdi
leaq 0xfeb9(%rip), %rax      # 0xa31c0
movzbl (%rax,%rdi), %eax
imulq $0x68, %rax, %rax
leaq 0x4b8ea(%rip), %rcx     # 0xdec00
movq (%rcx,%rax), %rdi
jmp 0x9332a
addq $0xfff, %rdi            # imm = 0xFFF
andq $-0x1000, %rdi          # imm = 0xF000
testq %rdi, %rdi
je 0x9340c
callq 0x92c1a
testq %rax, %rax
je 0x9340c
movq 0x28(%rbx), %r15
movq %rax, 0x28(%rbx)
decl %r14d
movl %r14d, 0x14(%rbx)
movq 0x8(%rbx), %r14
movq $0x0, 0x8(%rbx)
testq %r14, %r14
je 0x933de
leaq 0x8(%r15), %rbp
xorl %r12d, %r12d
movq -0x8(%rbp), %rax
testq %rax, %rax
je 0x93398
movq %rax, 0x30(%rsp)
movq (%rbp), %rax
movq %rax, 0x28(%rsp)
movq %rbx, %rdi
leaq 0x30(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x93425
testb %al, %al
jne 0x933a3
incq %r12
addq $0x10, %rbp
cmpq %r14, %r12
jb 0x93368
jmp 0x933de
movq %r14, 0x8(%rbx)
movq 0x28(%rbx), %rdi
callq 0x92f20
movq %r15, 0x28(%rbx)
movq 0x10(%rsp), %rax
movl %eax, 0x14(%rbx)
leaq 0x1(%r13), %rcx
movl $0x10, %eax
shlq %cl, %rax
leaq 0x3f(%rax), %rdi
andq $-0x40, %rdi
movq %r13, %r14
cmpq %rax, %rdi
jae 0x932ad
jmp 0x9340c
movq %r15, %rdi
callq 0x92f20
movq %rbx, %rdi
leaq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x93425
testb %al, %al
jne 0x9327a
jmp 0x93412
movl $0x0, 0xc(%rsp)
jmp 0x93412
movb $0x1, %al
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ckh.c
// Function: ckh_string_hash
void
ckh_string_hash(const void *key, unsigned minbits, size_t *hash1, size_t *hash2)
{
	size_t ret1, ret2;
	uint64_t h;

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

	h = hash(key, strlen((const char *)key), 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(key, strlen((const char *)key),
		    UINT64_C(0x8432a476666bbc13));
	}

	*hash1 = ret1;
	*hash2 = ret2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movabsq $-0x395b586ca42e166b, %r12 # imm = 0xC6A4A7935BD1E995
callq 0x1f4f0
movq %rax, %rcx
imulq %r12, %rcx
movabsq $-0x6bedd0cca4ccd516, %rdi # imm = 0x94122F335B332AEA
xorq %rcx, %rdi
movq %rax, %rdx
shrq $0x3, %rdx
movq %rax, %rsi
andq $-0x8, %rsi
addq %r15, %rsi
cmpq $0x8, %rax
jae 0x93ab3
movq %r15, %r9
jmp 0x93ae7
leaq (,%rdx,8), %r8
xorl %r9d, %r9d
movq (%r15,%r9), %r10
imulq %r12, %r10
movq %r10, %r11
shrq $0x2f, %r11
xorq %r10, %r11
imulq %r12, %r11
xorq %r11, %rdi
imulq %r12, %rdi
addq $0x8, %r9
cmpq %r9, %r8
jne 0x93abe
movq %rsi, %r9
movl %eax, %r8d
andl $0x7, %r8d
leaq 0x10cff(%rip), %r10     # 0xa47f4
movslq (%r10,%r8,4), %r11
addq %r10, %r11
jmpq *%r11
movzbl 0x6(%r9), %r10d
shlq $0x30, %r10
xorq %r10, %rdi
movzbl 0x5(%r9), %r10d
shlq $0x28, %r10
xorq %r10, %rdi
movzbl 0x4(%r9), %r10d
shlq $0x20, %r10
xorq %r10, %rdi
movzbl 0x3(%r9), %r10d
shll $0x18, %r10d
xorq %r10, %rdi
movzbl 0x2(%r9), %r10d
shll $0x10, %r10d
xorq %r10, %rdi
movzbl 0x1(%r9), %r10d
shll $0x8, %r10d
xorq %r10, %rdi
movzbl (%r9), %r9d
xorq %rdi, %r9
imulq %r12, %r9
movq %r9, %rdi
movq %rdi, %r9
shrq $0x2f, %r9
xorq %rdi, %r9
imulq %r12, %r9
movq %r9, %rdi
shrq $0x2f, %rdi
xorq %r9, %rdi
cmpl $0x20, %ebp
ja 0x93b7d
movl %edi, %edi
shrq $0x20, %r9
jmp 0x93c3a
movabsq $-0x7bcd5b89999443ed, %r9 # imm = 0x8432A476666BBC13
xorq %r9, %rcx
cmpq $0x8, %rax
jb 0x93bbf
shlq $0x3, %rdx
xorl %eax, %eax
movq (%r15,%rax), %r9
imulq %r12, %r9
movq %r9, %r10
shrq $0x2f, %r10
xorq %r9, %r10
imulq %r12, %r10
xorq %r10, %rcx
imulq %r12, %rcx
addq $0x8, %rax
cmpq %rax, %rdx
jne 0x93b96
movq %rsi, %r15
leaq 0x10c4e(%rip), %rax     # 0xa4814
movslq (%rax,%r8,4), %rdx
addq %rax, %rdx
jmpq *%rdx
movzbl 0x6(%r15), %eax
shlq $0x30, %rax
xorq %rax, %rcx
movzbl 0x5(%r15), %eax
shlq $0x28, %rax
xorq %rax, %rcx
movzbl 0x4(%r15), %eax
shlq $0x20, %rax
xorq %rax, %rcx
movzbl 0x3(%r15), %eax
shll $0x18, %eax
xorq %rax, %rcx
movzbl 0x2(%r15), %eax
shll $0x10, %eax
xorq %rax, %rcx
movzbl 0x1(%r15), %eax
shll $0x8, %eax
xorq %rax, %rcx
movzbl (%r15), %eax
xorq %rcx, %rax
imulq %r12, %rax
movq %rax, %rcx
movq %rcx, %rax
shrq $0x2f, %rax
xorq %rcx, %rax
imulq %r12, %rax
movq %rax, %r9
shrq $0x2f, %r9
xorq %rax, %r9
movq %rdi, (%r14)
movq %r9, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq