LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_tdata_reinit
prof_tdata_t *
prof_tdata_reinit(tsd_t *tsd, prof_tdata_t *tdata)
{
	uint64_t thr_uid = tdata->thr_uid;
	uint64_t thr_discrim = tdata->thr_discrim + 1;
	char *thread_name = (tdata->thread_name != NULL) ?
	    prof_thread_name_alloc(tsd, tdata->thread_name) : NULL;
	bool active = tdata->active;

	prof_tdata_detach(tsd, tdata);
	return (prof_tdata_init_impl(tsd, thr_uid, thr_discrim, thread_name,
	    active));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6670e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x66760
movq %rax, -0x38(%rbp)
jmp 0x66716
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x66716
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movb 0x84(%rax), %al
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x674a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x665f0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: prof_tdata_detach
static void
prof_tdata_detach(tsd_t *tsd, prof_tdata_t *tdata)
{
	bool destroy_tdata;

	malloc_mutex_lock(tdata->lock);
	if (tdata->attached) {
		destroy_tdata = prof_tdata_should_destroy(tdata, true);
		/*
		 * Only detach if !destroy_tdata, because detaching would allow
		 * another thread to win the race to destroy tdata.
		 */
		if (!destroy_tdata)
			tdata->attached = false;
		tsd_prof_tdata_set(tsd, NULL);
	} else
		destroy_tdata = false;
	malloc_mutex_unlock(tdata->lock);
	if (destroy_tdata)
		prof_tdata_destroy(tsd, tdata, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x64720
movq -0x20(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x67505
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x695f0
andb $0x1, %al
movb %al, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x674e7
movq -0x20(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x67509
movb $0x0, -0x21(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x65380
testb $0x1, -0x21(%rbp)
je 0x6752d
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x6a490
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_reset
void
prof_reset(tsd_t *tsd, size_t lg_sample)
{
	prof_tdata_t *next;

	assert(lg_sample < (sizeof(uint64_t) << 3));

	malloc_mutex_lock(&prof_dump_mtx);
	malloc_mutex_lock(&tdatas_mtx);

	lg_prof_sample = lg_sample;

	next = NULL;
	do {
		prof_tdata_t *to_destroy = tdata_tree_iter(&tdatas, next,
		    prof_tdata_reset_iter, NULL);
		if (to_destroy != NULL) {
			next = tdata_tree_next(&tdatas, to_destroy);
			prof_tdata_destroy_locked(tsd, to_destroy, false);
		} else
			next = NULL;
	} while (next != NULL);

	malloc_mutex_unlock(&tdatas_mtx);
	malloc_mutex_unlock(&prof_dump_mtx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x67552
leaq 0x3b2ef(%rip), %rdi     # 0xa2848
callq 0x64720
leaq 0x3b30b(%rip), %rdi     # 0xa2870
callq 0x64720
movq -0x10(%rbp), %rax
movq %rax, 0x3b323(%rip)     # 0xa2898
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x3b318(%rip), %rdi     # 0xa28a0
leaq 0xf1(%rip), %rdx        # 0x67680
xorl %eax, %eax
movl %eax, %ecx
callq 0x67600
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x675c8
movq -0x20(%rbp), %rsi
leaq 0x3b2f2(%rip), %rdi     # 0xa28a0
callq 0x676c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x677d0
jmp 0x675d0
movq $0x0, -0x18(%rbp)
jmp 0x675d2
cmpq $0x0, -0x18(%rbp)
jne 0x6757d
leaq 0x3b290(%rip), %rdi     # 0xa2870
callq 0x65380
leaq 0x3b25c(%rip), %rdi     # 0xa2848
callq 0x65380
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_active_get
bool
prof_active_get(void)
{
	bool prof_active_current;

	malloc_mutex_lock(&prof_active_mtx);
	prof_active_current = prof_active;
	malloc_mutex_unlock(&prof_active_mtx);
	return (prof_active_current);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x3a0c1(%rip), %rdi     # 0xa2d50
callq 0x64720
movb 0x3a0de(%rip), %al      # 0xa2d78
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq 0x3a0aa(%rip), %rdi     # 0xa2d50
callq 0x65380
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_active_set
bool
prof_active_set(bool active)
{
	bool prof_active_old;

	malloc_mutex_lock(&prof_active_mtx);
	prof_active_old = prof_active;
	prof_active = active;
	malloc_mutex_unlock(&prof_active_mtx);
	return (prof_active_old);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq 0x3a079(%rip), %rdi     # 0xa2d50
callq 0x64720
movb 0x3a096(%rip), %al      # 0xa2d78
andb $0x1, %al
movb %al, -0x2(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
movb %al, 0x3a086(%rip)      # 0xa2d78
leaq 0x3a057(%rip), %rdi     # 0xa2d50
callq 0x65380
movb -0x2(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_thread_name_get
const char *
prof_thread_name_get(void)
{
	tsd_t *tsd;
	prof_tdata_t *tdata;

	tsd = tsd_fetch();
	tdata = prof_tdata_get(tsd, true);
	if (tdata == NULL)
		return ("");
	return (tdata->thread_name != NULL ? tdata->thread_name : "");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x362c9(%rip), %rcx     # 0x9efe8
movq %fs:0x0, %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
setne %al
testb $0x1, %al
jne 0x68d42
jmp 0x68e51
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x68dc8
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x36284(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl $0x50, %edx
callq 0x103b0
leaq 0x3a18f(%rip), %rax     # 0xa2f14
movl (%rax), %edi
movq 0x3625a(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0x106d0
cmpl $0x0, %eax
je 0x68dc3
leaq 0x2628e(%rip), %rdi     # 0x8f039
callq 0x7c0e0
leaq 0x388e9(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x68dc1
callq 0x10070
jmp 0x68dc3
jmp 0x68e4f
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x68e4b
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq 0x361fe(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl $0x50, %edx
callq 0x103b0
leaq 0x3a109(%rip), %rax     # 0xa2f14
movl (%rax), %edi
movq 0x361d4(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0x106d0
cmpl $0x0, %eax
je 0x68e49
leaq 0x26208(%rip), %rdi     # 0x8f039
callq 0x7c0e0
leaq 0x38863(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x68e47
callq 0x10070
jmp 0x68e49
jmp 0x68e4d
jmp 0x68e4d
jmp 0x68e4f
jmp 0x68e51
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_thread_active_get
bool
prof_thread_active_get(void)
{
	tsd_t *tsd;
	prof_tdata_t *tdata;

	tsd = tsd_fetch();
	tdata = prof_tdata_get(tsd, true);
	if (tdata == NULL)
		return (false);
	return (tdata->active);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x36139(%rip), %rcx     # 0x9efe8
movq %fs:0x0, %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
setne %al
testb $0x1, %al
jne 0x68ed2
jmp 0x68fe1
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x68f58
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x360f4(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl $0x50, %edx
callq 0x103b0
leaq 0x39fff(%rip), %rax     # 0xa2f14
movl (%rax), %edi
movq 0x360ca(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0x106d0
cmpl $0x0, %eax
je 0x68f53
leaq 0x260fe(%rip), %rdi     # 0x8f039
callq 0x7c0e0
leaq 0x38759(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x68f51
callq 0x10070
jmp 0x68f53
jmp 0x68fdf
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x68fdb
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq 0x3606e(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl $0x50, %edx
callq 0x103b0
leaq 0x39f79(%rip), %rax     # 0xa2f14
movl (%rax), %edi
movq 0x36044(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0x106d0
cmpl $0x0, %eax
je 0x68fd9
leaq 0x26078(%rip), %rdi     # 0x8f039
callq 0x7c0e0
leaq 0x386d3(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x68fd7
callq 0x10070
jmp 0x68fd9
jmp 0x68fdd
jmp 0x68fdd
jmp 0x68fdf
jmp 0x68fe1
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_thread_active_set
bool
prof_thread_active_set(bool active)
{
	tsd_t *tsd;
	prof_tdata_t *tdata;

	tsd = tsd_fetch();
	tdata = prof_tdata_get(tsd, true);
	if (tdata == NULL)
		return (true);
	tdata->active = active;
	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x23(%rbp)
movq 0x35fd1(%rip), %rcx     # 0x9efe8
movq %fs:0x0, %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
setne %al
testb $0x1, %al
jne 0x6903a
jmp 0x69149
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x690c0
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x35f8c(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl $0x50, %edx
callq 0x103b0
leaq 0x39e97(%rip), %rax     # 0xa2f14
movl (%rax), %edi
movq 0x35f62(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0x106d0
cmpl $0x0, %eax
je 0x690bb
leaq 0x25f96(%rip), %rdi     # 0x8f039
callq 0x7c0e0
leaq 0x385f1(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x690b9
callq 0x10070
jmp 0x690bb
jmp 0x69147
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x69143
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq 0x35f06(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rdi
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl $0x50, %edx
callq 0x103b0
leaq 0x39e11(%rip), %rax     # 0xa2f14
movl (%rax), %edi
movq 0x35edc(%rip), %rax     # 0x9efe8
movq %fs:0x0, %rsi
addq %rax, %rsi
callq 0x106d0
cmpl $0x0, %eax
je 0x69141
leaq 0x25f10(%rip), %rdi     # 0x8f039
callq 0x7c0e0
leaq 0x3856b(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x6913f
callq 0x10070
jmp 0x69141
jmp 0x69145
jmp 0x69145
jmp 0x69147
jmp 0x69149
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_thread_active_init_set
bool
prof_thread_active_init_set(bool active_init)
{
	bool active_init_old;

	malloc_mutex_lock(&prof_thread_active_init_mtx);
	active_init_old = prof_thread_active_init;
	prof_thread_active_init = active_init;
	malloc_mutex_unlock(&prof_thread_active_init_mtx);
	return (active_init_old);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq 0x39c09(%rip), %rdi     # 0xa2d80
callq 0x64720
movb 0x39c26(%rip), %al      # 0xa2da8
andb $0x1, %al
movb %al, -0x2(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
movb %al, 0x39c16(%rip)      # 0xa2da8
leaq 0x39be7(%rip), %rdi     # 0xa2d80
callq 0x65380
movb -0x2(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_gdump_get
bool
prof_gdump_get(void)
{
	bool prof_gdump_current;

	malloc_mutex_lock(&prof_gdump_mtx);
	prof_gdump_current = prof_gdump_val;
	malloc_mutex_unlock(&prof_gdump_mtx);
	return (prof_gdump_current);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x39bf1(%rip), %rdi     # 0xa2db0
callq 0x64720
movb 0x39c0e(%rip), %al      # 0xa2dd8
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq 0x39bda(%rip), %rdi     # 0xa2db0
callq 0x65380
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_gdump_set
bool
prof_gdump_set(bool gdump)
{
	bool prof_gdump_old;

	malloc_mutex_lock(&prof_gdump_mtx);
	prof_gdump_old = prof_gdump_val;
	prof_gdump_val = gdump;
	malloc_mutex_unlock(&prof_gdump_mtx);
	return (prof_gdump_old);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq 0x39ba9(%rip), %rdi     # 0xa2db0
callq 0x64720
movb 0x39bc6(%rip), %al      # 0xa2dd8
andb $0x1, %al
movb %al, -0x2(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
movb %al, 0x39bb6(%rip)      # 0xa2dd8
leaq 0x39b87(%rip), %rdi     # 0xa2db0
callq 0x65380
movb -0x2(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_prefork
void
prof_prefork(void)
{

	if (opt_prof) {
		unsigned i;

		malloc_mutex_prefork(&tdatas_mtx);
		malloc_mutex_prefork(&bt2gctx_mtx);
		malloc_mutex_prefork(&next_thr_uid_mtx);
		malloc_mutex_prefork(&prof_dump_seq_mtx);
		for (i = 0; i < PROF_NCTX_LOCKS; i++)
			malloc_mutex_prefork(&gctx_locks[i]);
		for (i = 0; i < PROF_NTDATA_LOCKS; i++)
			malloc_mutex_prefork(&tdata_locks[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testb $0x1, 0x394a1(%rip)     # 0xa27f0
je 0x693e9
leaq 0x39514(%rip), %rdi     # 0xa2870
callq 0x643d0
leaq 0x39aa8(%rip), %rdi     # 0xa2e10
callq 0x643d0
leaq 0x39acc(%rip), %rdi     # 0xa2e40
callq 0x643d0
leaq 0x39488(%rip), %rdi     # 0xa2808
callq 0x643d0
movl $0x0, -0x4(%rbp)
cmpl $0x400, -0x4(%rbp)      # imm = 0x400
jae 0x693b6
movq 0x39acc(%rip), %rdi     # 0xa2e68
movl -0x4(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x643d0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6938c
movl $0x0, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jae 0x693e7
movq 0x39aa3(%rip), %rdi     # 0xa2e70
movl -0x4(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x643d0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x693bd
jmp 0x693e9
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_postfork_parent
void
prof_postfork_parent(void)
{

	if (opt_prof) {
		unsigned i;

		for (i = 0; i < PROF_NTDATA_LOCKS; i++)
			malloc_mutex_postfork_parent(&tdata_locks[i]);
		for (i = 0; i < PROF_NCTX_LOCKS; i++)
			malloc_mutex_postfork_parent(&gctx_locks[i]);
		malloc_mutex_postfork_parent(&prof_dump_seq_mtx);
		malloc_mutex_postfork_parent(&next_thr_uid_mtx);
		malloc_mutex_postfork_parent(&bt2gctx_mtx);
		malloc_mutex_postfork_parent(&tdatas_mtx);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testb $0x1, 0x393f1(%rip)     # 0xa27f0
je 0x69497
movl $0x0, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jae 0x69436
movq 0x39a54(%rip), %rdi     # 0xa2e70
movl -0x4(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x64410
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6940c
movl $0x0, -0x4(%rbp)
cmpl $0x400, -0x4(%rbp)      # imm = 0x400
jae 0x69467
movq 0x39a1b(%rip), %rdi     # 0xa2e68
movl -0x4(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x64410
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6943d
leaq 0x3939a(%rip), %rdi     # 0xa2808
callq 0x64410
leaq 0x399c6(%rip), %rdi     # 0xa2e40
callq 0x64410
leaq 0x3998a(%rip), %rdi     # 0xa2e10
callq 0x64410
leaq 0x393de(%rip), %rdi     # 0xa2870
callq 0x64410
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_postfork_child
void
prof_postfork_child(void)
{

	if (opt_prof) {
		unsigned i;

		for (i = 0; i < PROF_NTDATA_LOCKS; i++)
			malloc_mutex_postfork_child(&tdata_locks[i]);
		for (i = 0; i < PROF_NCTX_LOCKS; i++)
			malloc_mutex_postfork_child(&gctx_locks[i]);
		malloc_mutex_postfork_child(&prof_dump_seq_mtx);
		malloc_mutex_postfork_child(&next_thr_uid_mtx);
		malloc_mutex_postfork_child(&bt2gctx_mtx);
		malloc_mutex_postfork_child(&tdatas_mtx);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testb $0x1, 0x39341(%rip)     # 0xa27f0
je 0x69547
movl $0x0, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jae 0x694e6
movq 0x399a4(%rip), %rdi     # 0xa2e70
movl -0x4(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x64450
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x694bc
movl $0x0, -0x4(%rbp)
cmpl $0x400, -0x4(%rbp)      # imm = 0x400
jae 0x69517
movq 0x3996b(%rip), %rdi     # 0xa2e68
movl -0x4(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x64450
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x694ed
leaq 0x392ea(%rip), %rdi     # 0xa2808
callq 0x64450
leaq 0x39916(%rip), %rdi     # 0xa2e40
callq 0x64450
leaq 0x398da(%rip), %rdi     # 0xa2e10
callq 0x64450
leaq 0x3932e(%rip), %rdi     # 0xa2870
callq 0x64450
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: prof_tdata_should_destroy
static bool
prof_tdata_should_destroy(prof_tdata_t *tdata, bool even_if_attached)
{

	if (tdata->attached && !even_if_attached)
		return (false);
	if (ckh_count(&tdata->bt2tctx) != 0)
		return (false);
	return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x6961a
testb $0x1, -0x11(%rbp)
jne 0x6961a
movb $0x0, -0x1(%rbp)
jmp 0x69637
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x812c0
cmpq $0x0, %rax
je 0x69633
movb $0x0, -0x1(%rbp)
jmp 0x69637
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: prof_gctx_should_destroy
static bool
prof_gctx_should_destroy(prof_gctx_t *gctx)
{

	if (opt_prof_accum)
		return (false);
	if (!tctx_tree_empty(&gctx->tctxs))
		return (false);
	if (gctx->nlimbo != 0)
		return (false);
	return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
testb $0x1, 0x383b1(%rip)     # 0xa27f4
je 0x6a44b
movb $0x0, -0x1(%rbp)
jmp 0x6a476
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x6a5c0
testb $0x1, %al
jne 0x6a462
movb $0x0, -0x1(%rbp)
jmp 0x6a476
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x6a472
movb $0x0, -0x1(%rbp)
jmp 0x6a476
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: prof_tctx_comp
JEMALLOC_INLINE_C int
prof_tctx_comp(const prof_tctx_t *a, const prof_tctx_t *b)
{
	uint64_t a_thr_uid = a->thr_uid;
	uint64_t b_thr_uid = b->thr_uid;
	int ret = (a_thr_uid > b_thr_uid) - (a_thr_uid < b_thr_uid);
	if (ret == 0) {
		uint64_t a_thr_discrim = a->thr_discrim;
		uint64_t b_thr_discrim = b->thr_discrim;
		ret = (a_thr_discrim > b_thr_discrim) - (a_thr_discrim <
		    b_thr_discrim);
		if (ret == 0) {
			uint64_t a_tctx_uid = a->tctx_uid;
			uint64_t b_tctx_uid = b->tctx_uid;
			ret = (a_tctx_uid > b_tctx_uid) - (a_tctx_uid <
			    b_tctx_uid);
		}
	}
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x18(%rbp), %rcx
cmpq -0x20(%rbp), %rcx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x6a5b8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x30(%rbp), %rcx
cmpq -0x38(%rbp), %rcx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x6a5b6
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x40(%rbp), %rcx
cmpq -0x48(%rbp), %rcx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0x6a5b8
movl -0x24(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/atomic.h
// Function: je_atomic_add_uint32
JEMALLOC_INLINE uint32_t
atomic_add_uint32(uint32_t *p, uint32_t x)
{
	uint32_t t = x;

	asm volatile (
	    "lock; xaddl %0, %1;"
	    : "+r" (t), "=m" (*p) /* Outputs. */
	    : "m" (*p) /* Inputs. */
	    );

	return (t + x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rdx
lock
xaddl %eax, (%rcx)
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: prof_tdata_merge_iter
static prof_tdata_t *
prof_tdata_merge_iter(prof_tdata_tree_t *tdatas, prof_tdata_t *tdata, void *arg)
{
	prof_cnt_t *cnt_all = (prof_cnt_t *)arg;

	malloc_mutex_lock(tdata->lock);
	if (!tdata->expired) {
		size_t tabind;
		union {
			prof_tctx_t	*p;
			void		*v;
		} tctx;

		tdata->dumping = true;
		memset(&tdata->cnt_summed, 0, sizeof(prof_cnt_t));
		for (tabind = 0; !ckh_iter(&tdata->bt2tctx, &tabind, NULL,
		    &tctx.v);)
			prof_tctx_merge_tdata(tctx.p, tdata);

		cnt_all->curobjs += tdata->cnt_summed.curobjs;
		cnt_all->curbytes += tdata->cnt_summed.curbytes;
		if (opt_prof_accum) {
			cnt_all->accumobjs += tdata->cnt_summed.accumobjs;
			cnt_all->accumbytes += tdata->cnt_summed.accumbytes;
		}
	} else
		tdata->dumping = false;
	malloc_mutex_unlock(tdata->lock);

	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x64720
movq -0x10(%rbp), %rax
testb $0x1, 0x21(%rax)
jne 0x6b905
movq -0x10(%rbp), %rax
movb $0x1, 0x83(%rax)
movq -0x10(%rbp), %rdi
addq $0x88, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x10250
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x30(%rbp), %rcx
callq 0x812e0
xorb $-0x1, %al
testb $0x1, %al
jne 0x6b891
jmp 0x6b8a0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6c290
jmp 0x6b870
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rcx
movq -0x20(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rcx
movq -0x20(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
testb $0x1, 0x36f21(%rip)     # 0xa27f4
je 0x6b903
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
movq -0x20(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rcx
movq -0x20(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
jmp 0x6b910
movq -0x10(%rbp), %rax
movb $0x0, 0x83(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x65380
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: prof_gctx_merge_iter
static prof_gctx_t *
prof_gctx_merge_iter(prof_gctx_tree_t *gctxs, prof_gctx_t *gctx, void *arg)
{
	size_t *leak_ngctx = (size_t *)arg;

	malloc_mutex_lock(gctx->lock);
	tctx_tree_iter(&gctx->tctxs, NULL, prof_tctx_merge_iter, NULL);
	if (gctx->cnt_summed.curobjs != 0)
		(*leak_ngctx)++;
	malloc_mutex_unlock(gctx->lock);

	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x64720
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq 0xc55(%rip), %rdx       # 0x6c640
movq %rcx, %rsi
callq 0x6c5c0
movq -0x10(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x6ba0f
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x65380
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_dump_open
static int
prof_dump_open(bool propagate_err, const char *filename)
{
	int fd;

	fd = creat(filename, 0644);
	if (fd == -1 && !propagate_err) {
		malloc_printf("<jemalloc>: creat(\"%s\"), 0644) failed\n",
		    filename);
		if (opt_abort)
			abort();
	}

	return (fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1a4, %esi            # imm = 0x1A4
callq 0x105d0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x6ba86
testb $0x1, -0x1(%rbp)
jne 0x6ba86
movq -0x10(%rbp), %rsi
leaq 0x238cf(%rip), %rdi     # 0x8f33b
movb $0x0, %al
callq 0x7f490
leaq 0x35c26(%rip), %rax     # 0xa16a0
testb $0x1, (%rax)
je 0x6ba84
callq 0x10070
jmp 0x6ba86
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: je_prof_dump_header
static bool
prof_dump_header(bool propagate_err, const prof_cnt_t *cnt_all)
{
	bool ret;

	if (prof_dump_printf(propagate_err,
	    "heap_v2/%"FMTu64"\n"
	    "  t*: %"FMTu64": %"FMTu64" [%"FMTu64": %"FMTu64"]\n",
	    ((uint64_t)1U << lg_prof_sample), cnt_all->curobjs,
	    cnt_all->curbytes, cnt_all->accumobjs, cnt_all->accumbytes))
		return (true);

	malloc_mutex_lock(&tdatas_mtx);
	ret = (tdata_tree_iter(&tdatas, NULL, prof_tdata_dump_iter,
	    (void *)&propagate_err) != NULL);
	malloc_mutex_unlock(&tdatas_mtx);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movb -0x2(%rbp), %dil
movq 0x36de9(%rip), %rcx     # 0xa2898
movl $0x1, %edx
shlq %cl, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %r9
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
leaq 0x23885(%rip), %rsi     # 0x8f362
andb $0x1, %dil
movzbl %dil, %edi
movq %rax, (%rsp)
movb $0x0, %al
callq 0x6c910
testb $0x1, %al
jne 0x6baf6
jmp 0x6bafc
movb $0x1, -0x1(%rbp)
jmp 0x6bb43
leaq 0x36d6d(%rip), %rdi     # 0xa2870
callq 0x64720
leaq 0x36d91(%rip), %rdi     # 0xa28a0
xorl %eax, %eax
movl %eax, %esi
leaq 0xed6(%rip), %rdx       # 0x6c9f0
leaq -0x2(%rbp), %rcx
callq 0x67600
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq 0x36d3a(%rip), %rdi     # 0xa2870
callq 0x65380
movb -0x11(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: prof_gctx_dump_iter
static prof_gctx_t *
prof_gctx_dump_iter(prof_gctx_tree_t *gctxs, prof_gctx_t *gctx, void *arg)
{
	prof_gctx_t *ret;
	bool propagate_err = *(bool *)arg;

	malloc_mutex_lock(gctx->lock);

	if (prof_dump_gctx(propagate_err, gctx, &gctx->bt, gctxs)) {
		ret = gctx;
		goto label_return;
	}

	ret = NULL;
label_return:
	malloc_mutex_unlock(gctx->lock);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x64720
movb -0x21(%rbp), %al
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0xc8, %rdx
movq -0x8(%rbp), %rcx
andb $0x1, %al
movzbl %al, %edi
callq 0x6cb70
testb $0x1, %al
jne 0x6bba1
jmp 0x6bbab
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x6bbb3
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x65380
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: prof_dump_close
static bool
prof_dump_close(bool propagate_err)
{
	bool ret;

	assert(prof_dump_fd != -1);
	ret = prof_dump_flush(propagate_err);
	close(prof_dump_fd);
	prof_dump_fd = -1;

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6bbf2
movb -0x1(%rbp), %al
andb $0x1, %al
movzbl %al, %edi
callq 0x6cb50
andb $0x1, %al
movb %al, -0x2(%rbp)
movl 0x3727e(%rip), %edi     # 0xa2e88
callq 0x10280
movl $0xffffffff, 0x3726f(%rip) # imm = 0xFFFFFFFF
movb -0x2(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: prof_leakcheck
static void
prof_leakcheck(const prof_cnt_t *cnt_all, size_t leak_ngctx,
    const char *filename)
{

	if (cnt_all->curbytes != 0) {
		malloc_printf("<jemalloc>: Leak summary: %"FMTu64" byte%s, %"
		    FMTu64" object%s, %zu context%s\n",
		    cnt_all->curbytes, (cnt_all->curbytes != 1) ? "s" : "",
		    cnt_all->curobjs, (cnt_all->curobjs != 1) ? "s" : "",
		    leak_ngctx, (leak_ngctx != 1) ? "s" : "");
		malloc_printf(
		    "<jemalloc>: Run jeprof on \"%s\" for leak detail\n",
		    filename);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6bd0f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x2264e(%rip), %rdx     # 0x8e2e8
leaq 0x1b392(%rip), %rax     # 0x87033
cmpq $0x1, %rcx
cmovneq %rax, %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x2262a(%rip), %r8      # 0x8e2e8
leaq 0x1b36e(%rip), %rax     # 0x87033
cmpq $0x1, %rdi
cmovneq %rax, %r8
movq -0x10(%rbp), %r9
movq -0x10(%rbp), %r10
leaq 0x2260c(%rip), %rax     # 0x8e2e8
leaq 0x1b350(%rip), %rdi     # 0x87033
cmpq $0x1, %r10
cmovneq %rdi, %rax
leaq 0x2374b(%rip), %rdi     # 0x8f43d
movq %rax, (%rsp)
movb $0x0, %al
callq 0x7f490
movq -0x18(%rbp), %rsi
leaq 0x23778(%rip), %rdi     # 0x8f480
movb $0x0, %al
callq 0x7f490
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: prof_tctx_merge_tdata
static void
prof_tctx_merge_tdata(prof_tctx_t *tctx, prof_tdata_t *tdata)
{

	malloc_mutex_lock(tctx->gctx->lock);

	switch (tctx->state) {
	case prof_tctx_state_initializing:
		malloc_mutex_unlock(tctx->gctx->lock);
		return;
	case prof_tctx_state_nominal:
		tctx->state = prof_tctx_state_dumping;
		malloc_mutex_unlock(tctx->gctx->lock);

		memcpy(&tctx->dump_cnts, &tctx->cnts, sizeof(prof_cnt_t));

		tdata->cnt_summed.curobjs += tctx->dump_cnts.curobjs;
		tdata->cnt_summed.curbytes += tctx->dump_cnts.curbytes;
		if (opt_prof_accum) {
			tdata->cnt_summed.accumobjs +=
			    tctx->dump_cnts.accumobjs;
			tdata->cnt_summed.accumbytes +=
			    tctx->dump_cnts.accumbytes;
		}
		break;
	case prof_tctx_state_dumping:
	case prof_tctx_state_purgatory:
		not_reached();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rdi
callq 0x64720
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x6c2de
jmp 0x6c2c0
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x6c2f3
jmp 0x6c2ca
movl -0x14(%rbp), %eax
addl $-0x2, %eax
subl $0x2, %eax
jb 0x6c3a9
jmp 0x6c3ab
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rdi
callq 0x65380
jmp 0x6c3ab
movq -0x8(%rbp), %rax
movl $0x2, 0x5c(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rdi
callq 0x65380
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rdx
movq %rdx, 0x60(%rax)
movq 0x20(%rcx), %rdx
movq %rdx, 0x68(%rax)
movq 0x28(%rcx), %rdx
movq %rdx, 0x70(%rax)
movq 0x30(%rcx), %rcx
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x88(%rax), %rcx
movq %rcx, 0x88(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x90(%rax), %rcx
movq %rcx, 0x90(%rax)
testb $0x1, 0x36483(%rip)     # 0xa27f4
je 0x6c3a7
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x98(%rax), %rcx
movq %rcx, 0x98(%rax)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0xa0(%rax), %rcx
movq %rcx, 0xa0(%rax)
jmp 0x6c3ab
jmp 0x6c3ab
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: prof_tctx_merge_iter
static prof_tctx_t *
prof_tctx_merge_iter(prof_tctx_tree_t *tctxs, prof_tctx_t *tctx, void *arg)
{

	switch (tctx->state) {
	case prof_tctx_state_nominal:
		/* New since dumping started; ignore. */
		break;
	case prof_tctx_state_dumping:
	case prof_tctx_state_purgatory:
		prof_tctx_merge_gctx(tctx, tctx->gctx);
		break;
	default:
		not_reached();
	}

	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x6c672
jmp 0x6c665
movl -0x1c(%rbp), %eax
addl $-0x2, %eax
subl $0x2, %eax
jb 0x6c674
jmp 0x6c687
jmp 0x6c689
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x6c890
jmp 0x6c689
jmp 0x6c689
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: prof_tctx_merge_gctx
static void
prof_tctx_merge_gctx(prof_tctx_t *tctx, prof_gctx_t *gctx)
{

	gctx->cnt_summed.curobjs += tctx->dump_cnts.curobjs;
	gctx->cnt_summed.curbytes += tctx->dump_cnts.curbytes;
	if (opt_prof_accum) {
		gctx->cnt_summed.accumobjs += tctx->dump_cnts.accumobjs;
		gctx->cnt_summed.accumbytes += tctx->dump_cnts.accumbytes;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0xa8(%rax), %rcx
movq %rcx, 0xa8(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0xb0(%rax), %rcx
movq %rcx, 0xb0(%rax)
testb $0x1, 0x35f1d(%rip)     # 0xa27f4
je 0x6c90d
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0xb8(%rax), %rcx
movq %rcx, 0xb8(%rax)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0xc0(%rax), %rcx
movq %rcx, 0xc0(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: prof_dump_printf
static bool
prof_dump_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_dump_write(propagate_err, buf);

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
testb %al, %al
je 0x6c957
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 0x7c510
movq -0x168(%rbp), %rsi
movzbl -0x1(%rbp), %edi
andl $0x1, %edi
callq 0x6cb30
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/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: prof_tdata_dump_iter
static prof_tdata_t *
prof_tdata_dump_iter(prof_tdata_tree_t *tdatas, prof_tdata_t *tdata, void *arg)
{
	bool propagate_err = *(bool *)arg;

	if (!tdata->dumping)
		return (NULL);

	if (prof_dump_printf(propagate_err,
	    "  t%"FMTu64": %"FMTu64": %"FMTu64" [%"FMTu64": %"FMTu64"]%s%s\n",
	    tdata->thr_uid, tdata->cnt_summed.curobjs,
	    tdata->cnt_summed.curbytes, tdata->cnt_summed.accumobjs,
	    tdata->cnt_summed.accumbytes,
	    (tdata->thread_name != NULL) ? " " : "",
	    (tdata->thread_name != NULL) ? tdata->thread_name : ""))
		return (tdata);
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x83(%rax)
jne 0x6ca2c
movq $0x0, -0x8(%rbp)
jmp 0x6cb1b
movb -0x21(%rbp), %al
movb %al, -0x59(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x2185f(%rip), %rax     # 0x8e2e8
leaq 0x1f4e4(%rip), %rcx     # 0x8bf74
cmpq $0x0, %rdx
cmovneq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6cab5
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x68(%rbp)
jmp 0x6cac2
leaq 0x2182c(%rip), %rax     # 0x8e2e8
movq %rax, -0x68(%rbp)
jmp 0x6cac2
movq -0x40(%rbp), %r9
movq -0x48(%rbp), %r8
movq -0x50(%rbp), %rcx
movq -0x58(%rbp), %rdx
movb -0x59(%rbp), %al
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %r10
movq -0x68(%rbp), %r11
movq %rsp, %rsi
movq %r11, 0x10(%rsi)
movq %r10, 0x8(%rsi)
movq %rdi, (%rsi)
movzbl %al, %edi
andl $0x1, %edi
leaq 0x228c3(%rip), %rsi     # 0x8f3bf
xorl %eax, %eax
callq 0x6c910
testb $0x1, %al
jne 0x6cb09
jmp 0x6cb13
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6cb1b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: prof_tctx_dump_iter
static prof_tctx_t *
prof_tctx_dump_iter(prof_tctx_tree_t *tctxs, prof_tctx_t *tctx, void *arg)
{
	bool propagate_err = *(bool *)arg;

	switch (tctx->state) {
	case prof_tctx_state_initializing:
	case prof_tctx_state_nominal:
		/* Not captured by this dump. */
		break;
	case prof_tctx_state_dumping:
	case prof_tctx_state_purgatory:
		if (prof_dump_printf(propagate_err,
		    "  t%"FMTu64": %"FMTu64": %"FMTu64" [%"FMTu64": "
		    "%"FMTu64"]\n", tctx->thr_uid, tctx->dump_cnts.curobjs,
		    tctx->dump_cnts.curbytes, tctx->dump_cnts.accumobjs,
		    tctx->dump_cnts.accumbytes))
			return (tctx);
		break;
	default:
		not_reached();
	}
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x28(%rbp)
subl $0x2, %eax
jb 0x6cbcd
jmp 0x6cbc0
movl -0x28(%rbp), %eax
addl $-0x2, %eax
subl $0x2, %eax
jb 0x6cbcf
jmp 0x6cc27
jmp 0x6cc29
movb -0x21(%rbp), %dil
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x68(%rax), %r8
movq -0x18(%rbp), %rax
movq 0x70(%rax), %r9
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
leaq 0x227e6(%rip), %rsi     # 0x8f3e8
andb $0x1, %dil
movzbl %dil, %edi
movq %rax, (%rsp)
movb $0x0, %al
callq 0x6c910
testb $0x1, %al
jne 0x6cc1b
jmp 0x6cc25
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6cc31
jmp 0x6cc29
jmp 0x6cc29
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: prof_open_maps
static int
prof_open_maps(const char *format, ...)
{
	int mfd;
	va_list ap;
	char filename[PATH_MAX + 1];

	va_start(ap, format);
	malloc_vsnprintf(filename, sizeof(filename), format, ap);
	va_end(ap);
	mfd = open(filename, O_RDONLY);

	return (mfd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1100, %rsp           # imm = 0x1100
testb %al, %al
je 0x6cc87
movaps %xmm0, -0x10c0(%rbp)
movaps %xmm1, -0x10b0(%rbp)
movaps %xmm2, -0x10a0(%rbp)
movaps %xmm3, -0x1090(%rbp)
movaps %xmm4, -0x1080(%rbp)
movaps %xmm5, -0x1070(%rbp)
movaps %xmm6, -0x1060(%rbp)
movaps %xmm7, -0x1050(%rbp)
movq %r9, -0x10c8(%rbp)
movq %r8, -0x10d0(%rbp)
movq %rcx, -0x10d8(%rbp)
movq %rdx, -0x10e0(%rbp)
movq %rsi, -0x10e8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x10f0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x8, -0x30(%rbp)
movq -0x8(%rbp), %rdx
leaq -0x1040(%rbp), %rdi
movq %rdi, -0x10f8(%rbp)
movl $0x1001, %esi           # imm = 0x1001
leaq -0x30(%rbp), %rcx
callq 0x7c510
movq -0x10f8(%rbp), %rdi
xorl %esi, %esi
movb %sil, %al
callq 0x10550
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x1100, %rsp           # imm = 0x1100
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: prof_tctx_finish_iter
static prof_tctx_t *
prof_tctx_finish_iter(prof_tctx_tree_t *tctxs, prof_tctx_t *tctx, void *arg)
{
	prof_tctx_t *ret;

	switch (tctx->state) {
	case prof_tctx_state_nominal:
		/* New since dumping started; ignore. */
		break;
	case prof_tctx_state_dumping:
		tctx->state = prof_tctx_state_nominal;
		break;
	case prof_tctx_state_purgatory:
		ret = tctx;
		goto label_return;
	default:
		not_reached();
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0x6dd65
jmp 0x6dd51
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x6dd67
jmp 0x6dd5b
movl -0x24(%rbp), %eax
subl $0x3, %eax
je 0x6dd74
jmp 0x6dd7e
jmp 0x6dd80
movq -0x10(%rbp), %rax
movl $0x1, 0x5c(%rax)
jmp 0x6dd80
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x6dd88
jmp 0x6dd80
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/prof.c
// Function: prof_tdata_expire
static bool
prof_tdata_expire(prof_tdata_t *tdata)
{
	bool destroy_tdata;

	malloc_mutex_lock(tdata->lock);
	if (!tdata->expired) {
		tdata->expired = true;
		destroy_tdata = tdata->attached ? false :
		    prof_tdata_should_destroy(tdata, false);
	} else
		destroy_tdata = false;
	malloc_mutex_unlock(tdata->lock);

	return (destroy_tdata);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x64720
movq -0x8(%rbp), %rax
testb $0x1, 0x21(%rax)
jne 0x6e61e
movq -0x8(%rbp), %rax
movb $0x1, 0x21(%rax)
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x6e5fb
xorl %eax, %eax
movl %eax, -0x10(%rbp)
jmp 0x6e60e
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x695f0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0x6e622
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x65380
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/hash.h
// Function: je_hash_fmix_64
JEMALLOC_INLINE uint64_t
hash_fmix_64(uint64_t k)
{

	k ^= k >> 33;
	k *= KQU(0xff51afd7ed558ccd);
	k ^= k >> 33;
	k *= KQU(0xc4ceb9fe1a85ec53);
	k ^= k >> 33;

	return (k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x21, %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movabsq $-0xae502812aa7333, %rax # imm = 0xFF51AFD7ED558CCD
imulq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x21, %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movabsq $-0x3b314601e57a13ad, %rax # imm = 0xC4CEB9FE1A85EC53
imulq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x21, %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/jemalloc/src/rtree.c
// Function: je_rtree_delete
void
rtree_delete(rtree_t *rtree)
{
	unsigned i;

	for (i = 0; i < rtree->height; i++) {
		rtree_node_elm_t *subtree = rtree->levels[i].subtree;
		if (subtree != NULL)
			rtree_delete_subtree(rtree, subtree, i);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x7523c
movq -0x8(%rbp), %rax
addq $0x28, %rax
movl -0xc(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7522f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0x75250
jmp 0x75231
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x751f3
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)