LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x25091(%rip), %r14     # 0x57ce8
movq %r14, %rdi
callq 0x106d0
movb 0x250aa(%rip), %bpl     # 0x57d10
movb %bl, 0x250a4(%rip)      # 0x57d10
movq %r14, %rdi
callq 0x10440
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
leaq 0x25093(%rip), %rbx     # 0x57d18
movq %rbx, %rdi
callq 0x106d0
movb 0x250ac(%rip), %bpl     # 0x57d40
movq %rbx, %rdi
callq 0x10440
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x25066(%rip), %r14     # 0x57d18
movq %r14, %rdi
callq 0x106d0
movb 0x2507f(%rip), %bpl     # 0x57d40
movb %bl, 0x25079(%rip)      # 0x57d40
movq %r14, %rdi
callq 0x10440
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpb $0x1, 0x24a93(%rip)     # 0x57770
jne 0x32d43
pushq %rbx
leaq 0x24af1(%rip), %rdi     # 0x577d8
callq 0x3130c
leaq 0x25055(%rip), %rdi     # 0x57d48
callq 0x3130c
leaq 0x25079(%rip), %rdi     # 0x57d78
callq 0x3130c
leaq 0x24a7d(%rip), %rdi     # 0x57788
callq 0x3130c
xorl %ebx, %ebx
cmpq $0xa000, %rbx           # imm = 0xA000
je 0x32d29
movq %rbx, %rdi
callq 0x3130c
addq $0x28, %rbx
jmp 0x32d12
xorl %ebx, %ebx
cmpq $0x2800, %rbx           # imm = 0x2800
je 0x32d42
movq %rbx, %rdi
callq 0x3130c
addq $0x28, %rbx
jmp 0x32d2b
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpb $0x1, 0x24a25(%rip)     # 0x57770
jne 0x32d67
pushq %rbx
xorl %ebx, %ebx
cmpq $0x2800, %rbx           # imm = 0x2800
je 0x32d68
movq %rbx, %rdi
callq 0x31311
addq $0x28, %rbx
jmp 0x32d50
retq
xorl %ebx, %ebx
cmpq $0xa000, %rbx           # imm = 0xA000
je 0x32d81
movq %rbx, %rdi
callq 0x31311
addq $0x28, %rbx
jmp 0x32d6a
leaq 0x24a00(%rip), %rdi     # 0x57788
callq 0x31311
leaq 0x24fe4(%rip), %rdi     # 0x57d78
callq 0x31311
leaq 0x24fa8(%rip), %rdi     # 0x57d48
callq 0x31311
leaq 0x24a2c(%rip), %rdi     # 0x577d8
popq %rbx
jmp 0x31311
// File: /workspace/github_c_makefile_star2_O2/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:
cmpb $0x1, 0x249b7(%rip)     # 0x57770
jne 0x32dd5
pushq %rbx
xorl %ebx, %ebx
cmpq $0x2800, %rbx           # imm = 0x2800
je 0x32dd6
movq %rbx, %rdi
callq 0x31316
addq $0x28, %rbx
jmp 0x32dbe
retq
xorl %ebx, %ebx
cmpq $0xa000, %rbx           # imm = 0xA000
je 0x32def
movq %rbx, %rdi
callq 0x31316
addq $0x28, %rbx
jmp 0x32dd8
leaq 0x24992(%rip), %rdi     # 0x57788
callq 0x31316
leaq 0x24f76(%rip), %rdi     # 0x57d78
callq 0x31316
leaq 0x24f3a(%rip), %rdi     # 0x57d48
callq 0x31316
leaq 0x249be(%rip), %rdi     # 0x577d8
popq %rbx
jmp 0x31316
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/quarantine.c
// Function: quarantine_drain_one
static void
quarantine_drain_one(tsd_t *tsd, quarantine_t *quarantine)
{
	quarantine_obj_t *obj = &quarantine->objs[quarantine->first];
	assert(obj->usize == isalloc(obj->ptr, config_prof));
	idalloctm(tsd, obj->ptr, NULL, false);
	quarantine->curbytes -= obj->usize;
	quarantine->curobjs--;
	quarantine->first = (quarantine->first + 1) & ((ZU(1) <<
	    quarantine->lg_maxobjs) - 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rsi), %rax
shlq $0x4, %rax
leaq (%rsi,%rax), %r14
addq $0x20, %r14
movq (%r14), %rdx
leaq 0x236fd(%rip), %rax     # 0x576b0
movq (%rax), %rsi
notq %rsi
andq %rdx, %rsi
movq %rdx, %rcx
subq %rsi, %rcx
je 0x34011
shrq $0xc, %rcx
leaq 0x23589(%rip), %rax     # 0x57558
movq %rcx, %rdi
subq (%rax), %rdi
testb $0x2, 0x68(%rsi,%rdi,8)
movq (%rsi), %rdi
jne 0x3401d
callq 0x244f0
movq 0x8(%r14), %rax
subq %rax, (%rbx)
decq 0x8(%rbx)
movq 0x10(%rbx), %rax
movb 0x18(%rbx), %cl
pushq $-0x1
popq %rdx
shlq %cl, %rdx
incq %rax
notq %rdx
andq %rax, %rdx
movq %rdx, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rsi
xorl %edx, %edx
callq 0x30dbc
jmp 0x33fe4
callq 0x24608
jmp 0x33fe4
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/rtree.c
// Function: je_rtree_new
bool
rtree_new(rtree_t *rtree, unsigned bits, rtree_node_alloc_t *alloc,
    rtree_node_dalloc_t *dalloc)
{
	unsigned bits_in_leaf, height, i;

	assert(bits > 0 && bits <= (sizeof(uintptr_t) << 3));

	bits_in_leaf = (bits % RTREE_BITS_PER_LEVEL) == 0 ? RTREE_BITS_PER_LEVEL
	    : (bits % RTREE_BITS_PER_LEVEL);
	if (bits > bits_in_leaf) {
		height = 1 + (bits - bits_in_leaf) / RTREE_BITS_PER_LEVEL;
		if ((height-1) * RTREE_BITS_PER_LEVEL + bits_in_leaf != bits)
			height++;
	} else
		height = 1;
	assert((height-1) * RTREE_BITS_PER_LEVEL + bits_in_leaf == bits);

	rtree->alloc = alloc;
	rtree->dalloc = dalloc;
	rtree->height = height;

	/* Root level. */
	rtree->levels[0].subtree = NULL;
	rtree->levels[0].bits = (height > 1) ? RTREE_BITS_PER_LEVEL :
	    bits_in_leaf;
	rtree->levels[0].cumbits = rtree->levels[0].bits;
	/* Interior levels. */
	for (i = 1; i < height-1; i++) {
		rtree->levels[i].subtree = NULL;
		rtree->levels[i].bits = RTREE_BITS_PER_LEVEL;
		rtree->levels[i].cumbits = rtree->levels[i-1].cumbits +
		    RTREE_BITS_PER_LEVEL;
	}
	/* Leaf level. */
	if (height > 1) {
		rtree->levels[height-1].subtree = NULL;
		rtree->levels[height-1].bits = bits_in_leaf;
		rtree->levels[height-1].cumbits = bits;
	}

	/* Compute lookup table to be used by rtree_start_level(). */
	for (i = 0; i < RTREE_HEIGHT_MAX; i++) {
		rtree->start_level[i] = hmin(RTREE_HEIGHT_MAX - 1 - i, height -
		    1);
	}

	return (false);
}

// Assembly:
pushq %rbx
movl %esi, %r10d
movl %r10d, %eax
andl $0xf, %eax
movl $0x10, %r9d
cmovel %r9d, %eax
movl %esi, %r11d
subl %eax, %r11d
jbe 0x34063
movl %r11d, %r8d
shrl $0x4, %r8d
andl $-0x10, %r11d
movl %eax, %ebx
addq %r11, %rbx
xorl %r11d, %r11d
cmpq %r10, %rbx
sete %r11b
subl %r11d, %r8d
addl $0x2, %r8d
jmp 0x34069
movl $0x1, %r8d
movq %rdx, (%rdi)
movq %rcx, 0x8(%rdi)
movl %r8d, 0x10(%rdi)
leaq 0x28(%rdi), %rdx
andq $0x0, 0x28(%rdi)
cmpl $0x2, %r8d
cmovbl %eax, %r9d
movl %r9d, 0x30(%rdi)
movl %r9d, 0x34(%rdi)
leal -0x1(%r8), %ecx
leaq 0x44(%rdi), %r9
movabsq $0x1, %r10
cmpq %rcx, %r10
jae 0x340c5
andq $0x0, -0xc(%r9)
movl $0x10, -0x4(%r9)
movl -0x10(%r9), %r11d
addl $0x10, %r11d
movl %r11d, (%r9)
incq %r10
addq $0x10, %r9
jmp 0x3409f
cmpl $0x2, %r8d
jb 0x340e1
movq %rcx, %r8
shlq $0x4, %r8
andq $0x0, (%rdx,%r8)
movl %eax, 0x8(%rdx,%r8)
movl %esi, 0xc(%rdx,%r8)
movl $0x3, %eax
xorl %edx, %edx
cmpq $0x4, %rdx
je 0x34100
cmpl %ecx, %eax
movl %ecx, %esi
cmovbl %eax, %esi
movl %esi, 0x14(%rdi,%rdx,4)
incq %rdx
decl %eax
jmp 0x340e8
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x28(%rdi), %r15
xorl %r14d, %r14d
movl 0x10(%rbx), %eax
cmpq %rax, %r14
jae 0x34137
movq (%r15), %rsi
testq %rsi, %rsi
je 0x3412e
movq %rbx, %rdi
movl %r14d, %edx
callq 0x3413d
incq %r14
addq $0x10, %r15
jmp 0x34113
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/rtree.c
// Function: rtree_delete_subtree
static void
rtree_delete_subtree(rtree_t *rtree, rtree_node_elm_t *node, unsigned level)
{

	if (level + 1 < rtree->height) {
		size_t nchildren, i;

		nchildren = ZU(1) << rtree->levels[level].bits;
		for (i = 0; i < nchildren; i++) {
			rtree_node_elm_t *child = node[i].child;
			if (child != NULL)
				rtree_delete_subtree(rtree, child, level + 1);
		}
	}
	rtree->dalloc(node);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
leal 0x1(%rdx), %ebp
movq %rdi, %r12
cmpl 0x10(%rdi), %ebp
jae 0x34187
movl %edx, %eax
shlq $0x4, %rax
movl 0x30(%r12,%rax), %r14d
xorl %r15d, %r15d
movq %r15, %rax
movl %r14d, %ecx
shrq %cl, %rax
testq %rax, %rax
jne 0x34187
movq (%rbx,%r15,8), %rsi
testq %rsi, %rsi
je 0x34182
movq %r12, %rdi
movl %ebp, %edx
callq 0x3413d
incq %r15
jmp 0x34161
movq %rbx, %rdi
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *0x8(%rax)
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/rtree.c
// Function: rtree_node_init
static rtree_node_elm_t *
rtree_node_init(rtree_t *rtree, unsigned level, rtree_node_elm_t **elmp)
{
	rtree_node_elm_t *node;

	if (atomic_cas_p((void **)elmp, NULL, RTREE_NODE_INITIALIZING)) {
		/*
		 * Another thread is already in the process of initializing.
		 * Spin-wait until initialization is complete.
		 */
		do {
			CPU_SPINWAIT;
			node = atomic_read_p((void **)elmp);
		} while (node == RTREE_NODE_INITIALIZING);
	} else {
		node = rtree->alloc(ZU(1) << rtree->levels[level].bits);
		if (node == NULL)
			return (NULL);
		atomic_write_p((void **)elmp, node);
	}

	return (node);
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
movq %rdi, %rdx
pushq $0x1
popq %rdi
xorl %eax, %eax
lock
cmpxchgq %rdi, (%rbx)
sete %al
testb %al, %al
je 0x341dc
movl %esi, %eax
shlq $0x4, %rax
movb 0x30(%rdx,%rax), %cl
shlq %cl, %rdi
callq *(%rdx)
testq %rax, %rax
je 0x341ed
movq %rax, %rcx
xchgq %rcx, (%rbx)
jmp 0x341ef
pause
xorl %eax, %eax
lock
xaddq %rax, (%rbx)
cmpq $0x1, %rax
je 0x341dc
jmp 0x341ef
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/tcache.c
// Function: je_tcache_event_hard
void
tcache_event_hard(tsd_t *tsd, tcache_t *tcache)
{
	szind_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(tsd, tcache, tbin, binind,
			    tbin->ncached - tbin->low_water + (tbin->low_water
			    >> 2));
		} else {
			tcache_bin_flush_large(tsd, 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 %rsi, %rbx
movl 0x1c(%rsi), %r15d
movq %r15, %rax
shlq $0x5, %rax
leaq (%rsi,%rax), %r14
addq $0x20, %r14
movl 0x8(%r14), %eax
testl %eax, %eax
jle 0x36fd3
movq 0x20dfe(%rip), %r12     # 0x57db0
movl %eax, %r8d
shrl $0x2, %r8d
subl %eax, %r8d
addl 0x10(%r14), %r8d
cmpl $0x26, %r15d
ja 0x36fe6
movq %r14, %rdx
movl %r15d, %ecx
callq 0x37034
jmp 0x36ff4
jns 0x37008
movl 0xc(%r14), %eax
cmpl $0x2, %eax
jb 0x37008
decl %eax
movl %eax, 0xc(%r14)
jmp 0x37008
movq %r14, %rsi
movl %r15d, %edx
movl %r8d, %ecx
callq 0x371b7
movl (%r12,%r15,4), %eax
movl 0xc(%r14), %ecx
incl %ecx
shrl %cl, %eax
testl %eax, %eax
je 0x37008
movl %ecx, 0xc(%r14)
movl 0x10(%r14), %eax
movl %eax, 0x8(%r14)
movl 0x1c(%rbx), %eax
incl %eax
xorl %ecx, %ecx
cmpq %rax, 0x20d9a(%rip)     # 0x57db8
cmovnel %eax, %ecx
movl %ecx, 0x1c(%rbx)
andl $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/tcache.c
// Function: je_tcache_alloc_small_hard
void *
tcache_alloc_small_hard(tsd_t *tsd, arena_t *arena, tcache_t *tcache,
    tcache_bin_t *tbin, szind_t binind)
{
	void *ret;

	arena_tcache_fill_small(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
movl %r8d, %edx
movq %rcx, %rbx
movq %rsi, %rdi
movq %rcx, %rsi
xorl %ecx, %ecx
callq 0x22f30
movl 0x10(%rbx), %eax
testl %eax, %eax
je 0x37344
decl %eax
movl %eax, 0x10(%rbx)
cmpl 0x8(%rbx), %eax
jl 0x3734c
movq 0x18(%rbx), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %rax
popq %rbx
retq
orl $-0x1, 0x8(%rbx)
xorl %eax, %eax
jmp 0x37342
movl %eax, 0x8(%rbx)
jmp 0x37338
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/tcache.c
// Function: je_tcache_arena_associate
void
tcache_arena_associate(tcache_t *tcache, arena_t *arena)
{

	if (config_stats) {
		/* Link into list of extant tcaches. */
		malloc_mutex_lock(&arena->lock);
		ql_elm_new(tcache, link);
		ql_tail_insert(&arena->tcache_ql, tcache, link);
		malloc_mutex_unlock(&arena->lock);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x8(%rsi), %r14
movq %r14, %rdi
callq 0x106d0
movq %r15, (%r15)
movq %r15, 0x8(%r15)
movq 0xa8(%rbx), %rax
testq %rax, %rax
je 0x3739e
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%r15)
movq %rax, (%r15)
movq %r15, (%rcx)
movq %r15, 0x8(%rax)
movq (%r15), %r15
movq %r15, 0xa8(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10440
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/tcache.c
// Function: je_tcache_arena_dissociate
void
tcache_arena_dissociate(tcache_t *tcache, arena_t *arena)
{

	if (config_stats) {
		/* Unlink from list of extant tcaches. */
		malloc_mutex_lock(&arena->lock);
		if (config_debug) {
			bool in_ql = false;
			tcache_t *iter;
			ql_foreach(iter, &arena->tcache_ql, link) {
				if (iter == tcache) {
					in_ql = true;
					break;
				}
			}
			assert(in_ql);
		}
		ql_remove(&arena->tcache_ql, tcache, link);
		tcache_stats_merge(tcache, arena);
		malloc_mutex_unlock(&arena->lock);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsi), %rbx
movq %rbx, %rdi
callq 0x106d0
movq 0xa8(%r14), %rax
cmpq %r15, %rax
jne 0x37400
movq (%rax), %rax
movq %rax, 0xa8(%r14)
cmpq %r15, %rax
je 0x3741c
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
movq %r15, (%r15)
movq %r15, 0x8(%r15)
jmp 0x37424
andq $0x0, 0xa8(%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x3743c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10440
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/tcache.c
// Function: je_tcache_stats_merge
void
tcache_stats_merge(tcache_t *tcache, arena_t *arena)
{
	unsigned i;

	cassert(config_stats);

	/* Merge and reset tcache stats. */
	for (i = 0; i < NBINS; i++) {
		arena_bin_t *bin = &arena->bins[i];
		tcache_bin_t *tbin = &tcache->tbins[i];
		malloc_mutex_lock(&bin->lock);
		bin->stats.nrequests += tbin->tstats.nrequests;
		malloc_mutex_unlock(&bin->lock);
		tbin->tstats.nrequests = 0;
	}

	for (; i < nhbins; i++) {
		malloc_large_stats_t *lstats = &arena->stats.lstats[i - NBINS];
		tcache_bin_t *tbin = &tcache->tbins[i];
		arena->stats.nrequests_large += tbin->tstats.nrequests;
		lstats->nrequests += tbin->tstats.nrequests;
		tbin->tstats.nrequests = 0;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x450(%rsi), %r15
leaq 0x20(%rdi), %r12
pushq $0x20
popq %r13
cmpq $0x500, %r13            # imm = 0x500
je 0x37490
movq %r15, %rdi
callq 0x106d0
movq (%r14,%r13), %rax
addq %rax, 0xa8(%r15)
movq %r15, %rdi
callq 0x10440
andq $0x0, (%r14,%r13)
addq $0x20, %r13
addq $0xe0, %r15
jmp 0x3745a
xorl %eax, %eax
leal 0x27(%rax), %ecx
cmpq %rcx, 0x2091c(%rip)     # 0x57db8
jbe 0x374c5
movq 0x98(%rbx), %rdx
movl %eax, %esi
shlq $0x5, %rcx
movq (%r12,%rcx), %rdi
addq %rdi, 0x78(%rbx)
shlq $0x5, %rsi
addq %rdi, 0x10(%rdx,%rsi)
andq $0x0, (%r12,%rcx)
incl %eax
jmp 0x37492
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/tcache.c
// Function: je_tcache_get_hard
tcache_t *
tcache_get_hard(tsd_t *tsd)
{
	arena_t *arena;

	if (!tcache_enabled_get()) {
		if (tsd_nominal(tsd))
			tcache_enabled_set(false); /* Memoize. */
		return (NULL);
	}
	arena = arena_choose(tsd, NULL);
	if (unlikely(arena == NULL))
		return (NULL);
	return (tcache_create(tsd, arena));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x1cb12(%rip), %r15     # 0x53ff0
movq %fs:0x0, %rbx
addq %r15, %rbx
movl %fs:(%r15), %eax
testl %eax, %eax
je 0x37557
cmpl $0x2, %eax
je 0x37561
movl %fs:0x40(%r15), %eax
cmpl $0x2, %eax
jne 0x3750d
movzbl 0x1eed8(%rip), %eax     # 0x563e0
movl %eax, %fs:0x40(%r15)
testl %eax, %eax
je 0x3752e
movq %r14, %rdi
callq 0x37351
testq %rax, %rax
je 0x3754f
movq %r14, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x375ec
cmpl $0x1, (%r14)
jne 0x3754f
movl %fs:(%r15), %eax
testl %eax, %eax
je 0x375a3
cmpl $0x2, %eax
je 0x375ad
andl $0x0, %fs:0x40(%r15)
movq %rbx, %rdi
callq 0x378b2
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, %fs:(%r15)
jmp 0x37569
movl $0x3, %fs:(%r15)
leaq 0x208a4(%rip), %rax     # 0x57e14
movl (%rax), %edi
movq %rbx, %rsi
callq 0x106f0
testl %eax, %eax
je 0x374f7
leaq 0xb930(%rip), %rdi      # 0x42eb9
callq 0x37d1c
leaq 0x1f08b(%rip), %rax     # 0x56620
cmpb $0x1, (%rax)
jne 0x374f7
callq 0x10090
movl $0x1, %fs:(%r15)
jmp 0x375b5
movl $0x3, %fs:(%r15)
leaq 0x20858(%rip), %rax     # 0x57e14
movl (%rax), %edi
movq %rbx, %rsi
callq 0x106f0
testl %eax, %eax
je 0x37541
leaq 0xb8e4(%rip), %rdi      # 0x42eb9
callq 0x37d1c
leaq 0x1f03f(%rip), %rax     # 0x56620
cmpb $0x1, (%rax)
jne 0x37541
jmp 0x3759e
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/tcache.c
// Function: je_tcaches_create
bool
tcaches_create(tsd_t *tsd, unsigned *r_ind)
{
	tcache_t *tcache;
	tcaches_t *elm;

	if (tcaches == NULL) {
		tcaches = base_alloc(sizeof(tcache_t *) *
		    (MALLOCX_TCACHE_MAX+1));
		if (tcaches == NULL)
			return (true);
	}

	if (tcaches_avail == NULL && tcaches_past > MALLOCX_TCACHE_MAX)
		return (true);
	tcache = tcache_create(tsd, a0get());
	if (tcache == NULL)
		return (true);

	if (tcaches_avail != NULL) {
		elm = tcaches_avail;
		tcaches_avail = tcaches_avail->next;
		elm->tcache = tcache;
		*r_ind = elm - tcaches;
	} else {
		elm = &tcaches[tcaches_past];
		elm->tcache = tcache;
		*r_ind = tcaches_past;
		tcaches_past++;
	}

	return (false);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x202de(%rip)     # 0x57dc8
jne 0x37b02
movl $0x7ff0, %edi           # imm = 0x7FF0
callq 0x287c8
movq %rax, 0x202cb(%rip)     # 0x57dc8
testq %rax, %rax
je 0x37b58
cmpq $0x0, 0x202c6(%rip)     # 0x57dd0
movb $0x1, %bpl
jne 0x37b1b
cmpl $0xffd, 0x202bf(%rip)   # imm = 0xFFD
ja 0x37b7b
callq 0x1c298
movq %r14, %rdi
movq %rax, %rsi
callq 0x375ec
testq %rax, %rax
je 0x37b7b
movq 0x20299(%rip), %rcx     # 0x57dd0
testq %rcx, %rcx
je 0x37b5d
movq (%rcx), %rdx
movq %rdx, 0x2028a(%rip)     # 0x57dd0
movq %rax, (%rcx)
subq 0x20278(%rip), %rcx     # 0x57dc8
shrq $0x3, %rcx
movl %ecx, (%rbx)
jmp 0x37b79
movb $0x1, %bpl
jmp 0x37b7b
movq 0x20264(%rip), %rcx     # 0x57dc8
movl 0x2026e(%rip), %edx     # 0x57dd8
movq %rax, (%rcx,%rdx,8)
movl %edx, (%rbx)
leal 0x1(%rdx), %eax
movl %eax, 0x2025f(%rip)     # 0x57dd8
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/tcache.c
// Function: je_tcaches_destroy
void
tcaches_destroy(tsd_t *tsd, unsigned ind)
{
	tcaches_t *elm = &tcaches[ind];
	tcaches_elm_flush(tsd, elm);
	elm->next = tcaches_avail;
	tcaches_avail = elm;
}

// Assembly:
pushq %rbx
movq 0x20218(%rip), %rax     # 0x57dc8
movl %esi, %ecx
leaq (%rax,%rcx,8), %rbx
movq %rbx, %rsi
callq 0x37b91
movq 0x2020b(%rip), %rax     # 0x57dd0
movq %rax, (%rbx)
movq %rbx, 0x20201(%rip)     # 0x57dd0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/tcache.c
// Function: je_tcache_boot
bool
tcache_boot(void)
{
	unsigned i;

	/*
	 * If necessary, clamp opt_lg_tcache_max, now that large_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) > large_maxclass)
		tcache_maxclass = large_maxclass;
	else
		tcache_maxclass = (1U << opt_lg_tcache_max);

	nhbins = size2index(tcache_maxclass) + 1;

	/* 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_MIN) {
			tcache_bin_info[i].ncached_max =
			    TCACHE_NSLOTS_SMALL_MIN;
		} else 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 0x1e810(%rip), %rcx     # 0x563e8
testq %rcx, %rcx
js 0x37be2
cmpl $0xd, %ecx
ja 0x37c31
movq $0x3800, 0x201f3(%rip) # imm = 0x3800
movl $0x3800, %eax           # imm = 0x3800
leaq -0x1(,%rax,2), %rcx
bsrq %rcx, %rcx
xorl %edx, %edx
movq %rcx, %rsi
subq $0x5, %rsi
cmovaeq %rsi, %rdx
leal -0x3(%rcx), %esi
cmpq $0x6, %rcx
movzbl %sil, %esi
pushq $0x3
popq %rcx
cmovael %esi, %ecx
decq %rax
shrq %cl, %rax
shlq %cl, %rax
shrq %cl, %rax
andl $0x3, %eax
leaq (%rax,%rdx,4), %rdi
jmp 0x37c68
pushq $0x1
popq %rax
shll %cl, %eax
leaq 0x1f903(%rip), %rcx     # 0x57540
movq (%rcx), %rcx
cmpq %rax, %rcx
cmovbq %rcx, %rax
movq %rax, 0x20192(%rip)     # 0x57de0
cmpq $0x1000, %rax           # imm = 0x1000
ja 0x37bf2
decq %rax
shrq $0x3, %rax
leaq 0xae9c(%rip), %rcx      # 0x42b00
movzbl (%rcx,%rax), %edi
pushq %rax
incl %edi
movq %rdi, 0x20146(%rip)     # 0x57db8
shlq $0x2, %rdi
callq 0x287c8
movq %rax, 0x2012e(%rip)     # 0x57db0
testq %rax, %rax
je 0x37d11
leaq 0x1ea0e(%rip), %rdx     # 0x566a0
addq $0x20, %rdx
xorl %esi, %esi
pushq $0x14
popq %rdi
xorl %ecx, %ecx
cmpq $0x27, %rsi
je 0x37ce3
movl (%rdx), %r8d
addl %r8d, %r8d
cmpl $0x14, %r8d
ja 0x37cbb
movl $0x14, (%rax,%rsi,4)
movl %edi, %r8d
jmp 0x37cd7
cmpl $0xc8, %r8d
ja 0x37cca
movl %r8d, (%rax,%rsi,4)
jmp 0x37cd7
movl $0xc8, (%rax,%rsi,4)
movl $0xc8, %r8d
addl %r8d, %ecx
incq %rsi
addq $0x60, %rdx
jmp 0x37c9d
movl %ecx, 0x200d7(%rip)     # 0x57dc0
movq 0x200c8(%rip), %rdx     # 0x57db8
addl $0x14, %ecx
pushq $0x27
popq %rsi
movl %esi, %esi
cmpq %rsi, %rdx
jbe 0x37d11
movl $0x14, (%rax,%rsi,4)
movl %ecx, 0x200b6(%rip)     # 0x57dc0
incl %esi
addl $0x14, %ecx
jmp 0x37cf6
testq %rax, %rax
sete %al
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/util.c
// Function: je_buferror
int
buferror(int err, char *buf, size_t buflen)
{

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
callq 0x10430
cmpq %r14, %rax
je 0x37d77
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x100b0
movb $0x0, -0x1(%r14,%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/util.c
// Function: u2s
static char *
u2s(uintmax_t x, unsigned base, bool uppercase, char *s, size_t *slen_p)
{
	unsigned i;

	i = U2S_BUFSIZE - 1;
	s[i] = '\0';
	switch (base) {
	case 10:
		do {
			i--;
			s[i] = "0123456789"[x % (uint64_t)10];
			x /= (uint64_t)10;
		} while (x > 0);
		break;
	case 16: {
		const char *digits = (uppercase)
		    ? "0123456789ABCDEF"
		    : "0123456789abcdef";

		do {
			i--;
			s[i] = digits[x & 0xf];
			x >>= 4;
		} while (x > 0);
		break;
	} default: {
		const char *digits = (uppercase)
		    ? "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
		    : "0123456789abcdefghijklmnopqrstuvwxyz";

		assert(base >= 2 && base <= 36);
		do {
			i--;
			s[i] = digits[x % (uint64_t)base];
			x /= (uint64_t)base;
		} while (x > 0);
	}}

	*slen_p = U2S_BUFSIZE - 1 - i;
	return (&s[i]);
}

// Assembly:
movb $0x0, 0x40(%rcx)
cmpl $0x10, %esi
je 0x38a8c
pushq $0x40
popq %r9
cmpl $0xa, %esi
jne 0x38acf
leaq 0xba98(%rip), %rsi      # 0x44500
pushq $0xa
popq %r10
movq %rdi, %rax
xorl %edx, %edx
divq %r10
decl %r9d
movb (%rdx,%rsi), %dl
movb %dl, (%rcx,%r9)
movl %r9d, %edx
cmpq $0xa, %rdi
movq %rax, %rdi
jae 0x38a6c
jmp 0x38b03
leaq 0xba78(%rip), %rsi      # 0x4450b
leaq 0xba82(%rip), %rax      # 0x4451c
testb %dl, %dl
cmovneq %rsi, %rax
pushq $0x40
popq %rdx
pushq $0x3f
popq %rsi
movq %rdi, %r10
movl %edi, %r9d
andl $0xf, %r9d
movb (%rax,%r9), %r11b
movl %esi, %r9d
movb %r11b, (%rcx,%r9)
shrq $0x4, %r10
decl %edx
decq %rsi
cmpq $0x10, %rdi
movq %r10, %rdi
jae 0x38aa9
jmp 0x38b03
leaq 0xba57(%rip), %rax      # 0x4452d
leaq 0xba75(%rip), %r10      # 0x44552
testb %dl, %dl
cmovneq %rax, %r10
movl %esi, %esi
movq %rdi, %rax
xorl %edx, %edx
divq %rsi
decl %r9d
movb (%r10,%rdx), %dl
movb %dl, (%rcx,%r9)
movl %r9d, %edx
cmpq %rsi, %rdi
movq %rax, %rdi
jae 0x38ae5
pushq $0x40
popq %rax
subl %edx, %eax
movq %rax, (%r8)
addq %r9, %rcx
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/util.c
// Function: x2s
static char *
x2s(uintmax_t x, bool alt_form, bool uppercase, char *s, size_t *slen_p)
{

	s = u2s(x, 16, uppercase, s, slen_p);
	if (alt_form) {
		s -= 2;
		(*slen_p) += 2;
		memcpy(s, uppercase ? "0X" : "0x", 2);
	}
	return (s);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %r8, %r14
movl %edx, %ebx
movl %esi, %ebp
pushq $0x10
popq %rsi
callq 0x38a4f
testl %ebp, %ebp
je 0x38b44
addq $0x2, (%r14)
xorb $0x1, %bl
movzbl %bl, %ecx
shll $0xd, %ecx
orl $0x5830, %ecx           # imm = 0x5830
movw %cx, -0x2(%rax)
addq $-0x2, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/tsd.c
// Function: je_tsd_cleanup
void
tsd_cleanup(void *arg)
{
	tsd_t *tsd = (tsd_t *)arg;

	switch (tsd->state) {
	case tsd_state_uninitialized:
		/* Do nothing. */
		break;
	case tsd_state_nominal:
#define O(n, t)								\
		n##_cleanup(tsd);
MALLOC_TSD
#undef O
		tsd->state = tsd_state_purgatory;
		tsd_set(tsd);
		break;
	case tsd_state_purgatory:
		/*
		 * The previous time this destructor was called, we set the
		 * state to tsd_state_purgatory so that other destructors
		 * wouldn't cause re-creation of the tsd.  This time, do
		 * nothing, and do not request another callback.
		 */
		break;
	case tsd_state_reincarnated:
		/*
		 * Another destructor deallocated memory after this destructor
		 * was called.  Reset state to tsd_state_purgatory and request
		 * another callback.
		 */
		tsd->state = tsd_state_purgatory;
		tsd_set(tsd);
		break;
	default:
		not_reached();
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
leaq 0xb80f(%rip), %rcx      # 0x44578
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x378b2
movq %rbx, %rdi
callq 0x1c901
movq %rbx, %rdi
callq 0x1c902
movq %rbx, %rdi
callq 0x32b13
movq %rbx, %rdi
callq 0x1c903
movq %rbx, %rdi
callq 0x1c947
movq %rbx, %rdi
callq 0x1c95e
movq %rbx, %rdi
callq 0x1c95f
movq %rbx, %rdi
callq 0x37ad7
movq %rbx, %rdi
callq 0x33c8b
movl $0x2, (%rbx)
movq %fs:0x0, %rax
leaq -0x50(%rax), %rax
pushq $0xa
popq %rcx
movq %rax, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl 0x1f02a(%rip), %edi     # 0x57e14
movq %rax, %rsi
callq 0x106f0
testl %eax, %eax
je 0x38e0e
leaq 0xa0bc(%rip), %rdi      # 0x42eb9
callq 0x37d1c
leaq 0x1d817(%rip), %rax     # 0x56620
cmpb $0x1, (%rax)
je 0x38e10
popq %rbx
retq
callq 0x10090
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/tsd.c
// Function: je_malloc_tsd_boot0
bool
malloc_tsd_boot0(void)
{

	ncleanups = 0;
	if (tsd_boot0())
		return (true);
	*tsd_arenas_cache_bypassp_get(tsd_fetch()) = true;
	return (false);
}

// Assembly:
pushq %rbx
andl $0x0, 0x1eff3(%rip)     # 0x57e10
leaq 0x1eff0(%rip), %rdi     # 0x57e14
leaq -0xcf(%rip), %rsi       # 0x38d5c
callq 0x10260
movl %eax, %ebx
testl %eax, %eax
jne 0x38e67
movb $0x1, 0x1efb3(%rip)     # 0x57df0
movq %fs:0x0, %rax
leaq -0x50(%rax), %rsi
movl %fs:-0x50, %eax
testl %eax, %eax
je 0x38e6e
cmpl $0x2, %eax
je 0x38e7c
movb $0x1, %fs:-0x14
testl %ebx, %ebx
setne %al
popq %rbx
retq
movl $0x1, %fs:-0x50
jmp 0x38e88
movl $0x3, %fs:-0x50
movl 0x1ef86(%rip), %edi     # 0x57e14
callq 0x106f0
testl %eax, %eax
je 0x38e5e
leaq 0xa01b(%rip), %rdi      # 0x42eb9
callq 0x37d1c
leaq 0x1d776(%rip), %rax     # 0x56620
cmpb $0x1, (%rax)
jne 0x38e5e
callq 0x10090
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/ckh.c
// Function: je_ckh_iter
bool
ckh_iter(ckh_t *ckh, size_t *tabind, void **key, void **data)
{
	size_t i, ncells;

	for (i = *tabind, ncells = (ZU(1) << (ckh->lg_curbuckets +
	    LG_CKH_BUCKET_CELLS)); i < ncells; i++) {
		if (ckh->tab[i].key != NULL) {
			if (key != NULL)
				*key = (void *)ckh->tab[i].key;
			if (data != NULL)
				*data = (void *)ckh->tab[i].data;
			*tabind = i + 1;
			return (false);
		}
	}

	return (true);
}

// Assembly:
movq %rcx, %rax
movq (%rsi), %r8
movl 0x14(%rdi), %ecx
addl $0x2, %ecx
movq %r8, %r9
shlq $0x4, %r9
movq %r8, %r10
shrq %cl, %r10
testq %r10, %r10
jne 0x39647
movq 0x28(%rdi), %r11
movq (%r11,%r9), %r11
testq %r11, %r11
jne 0x39628
incq %r8
addq $0x10, %r9
jmp 0x39607
testq %rdx, %rdx
je 0x39630
movq %r11, (%rdx)
testq %rax, %rax
je 0x39641
movq 0x28(%rdi), %rcx
movq 0x8(%rcx,%r9), %rcx
movq %rcx, (%rax)
incq %r8
movq %r8, (%rsi)
testq %r10, %r10
setne %al
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/ckh.c
// Function: ckh_try_insert
JEMALLOC_INLINE_C bool
ckh_try_insert(ckh_t *ckh, void const**argkey, void const**argdata)
{
	size_t hashes[2], bucket;
	const void *key = *argkey;
	const void *data = *argdata;

	ckh->hash(key, hashes);

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r15
movq (%rsi), %rbx
movq (%rdx), %r14
leaq 0x20(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq *0x18(%r15)
movb 0x14(%r15), %cl
pushq $-0x1
popq %rsi
shlq %cl, %rsi
notq %rsi
andq (%r12), %rsi
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x3ad16
testb %al, %al
je 0x3a061
movb 0x14(%r15), %cl
pushq $-0x1
popq %r12
shlq %cl, %r12
notq %r12
andq 0x28(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x3ad16
testb %al, %al
je 0x3a061
movq %rbp, (%rsp)
movq (%rbp), %r14
movq %r13, 0x8(%rsp)
movq (%r13), %rbx
movq %r12, %rbp
movq %r14, %rax
movq %rbx, %rcx
imull $0x41c64e69, (%r15), %edx # imm = 0x41C64E69
addl $0x303b, %edx           # imm = 0x303B
movl %edx, (%r15)
movq 0x28(%r15), %rsi
movq %rbp, %rdi
shlq $0x6, %rdi
shrl $0x1a, %edx
andl $-0x10, %edx
orq %rdi, %rdx
movq (%rsi,%rdx), %r14
movq 0x8(%rsi,%rdx), %rbx
movq %rax, (%rsi,%rdx)
movq %rcx, 0x8(%rsi,%rdx)
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
callq *0x18(%r15)
movb 0x14(%r15), %cl
pushq $-0x1
popq %rax
shlq %cl, %rax
notq %rax
movq 0x18(%rsp), %rcx
andq %rax, %rcx
andq 0x10(%rsp), %rax
cmpq %rbp, %rcx
movq %rax, %rbp
cmovneq %rcx, %rbp
cmpq %r12, %rbp
sete %r13b
je 0x3a076
movq %r15, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3ad16
testb %al, %al
jne 0x39fd1
jmp 0x3a064
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rax
movq %r14, (%rax)
movq 0x8(%rsp), %rax
movq %rbx, (%rax)
jmp 0x3a064
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/ckh.c
// Function: ckh_isearch
JEMALLOC_INLINE_C size_t
ckh_isearch(ckh_t *ckh, const void *key)
{
	size_t hashes[2], bucket, cell;

	assert(ckh != NULL);

	ckh->hash(key, hashes);

	/* Search primary bucket. */
	bucket = hashes[0] & ((ZU(1) << ckh->lg_curbuckets) - 1);
	cell = ckh_bucket_search(ckh, bucket, key);
	if (cell != SIZE_T_MAX)
		return (cell);

	/* Search secondary bucket. */
	bucket = hashes[1] & ((ZU(1) << ckh->lg_curbuckets) - 1);
	cell = ckh_bucket_search(ckh, bucket, key);
	return (cell);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r12
movq %rsi, %rdi
movq %r12, %rsi
callq *0x18(%r14)
movb 0x14(%r14), %cl
pushq $-0x1
popq %r15
movq %r15, %rsi
shlq %cl, %rsi
notq %rsi
andq (%r12), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x3ade6
cmpq $-0x1, %rax
jne 0x3aa0d
movb 0x14(%r14), %cl
shlq %cl, %r15
notq %r15
andq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3ade6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/ckh.c
// Function: je_ckh_search
bool
ckh_search(ckh_t *ckh, const void *searchkey, void **key, void **data)
{
	size_t cell;

	assert(ckh != NULL);

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

	return (true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
callq 0x3a9ac
cmpq $-0x1, %rax
je 0x3aa61
testq %r15, %r15
je 0x3aa49
movq 0x28(%r14), %rcx
movq %rax, %rdx
shlq $0x4, %rdx
movq (%rcx,%rdx), %rcx
movq %rcx, (%r15)
testq %rbx, %rbx
je 0x3aa61
movq 0x28(%r14), %rcx
movq %rax, %rdx
shlq $0x4, %rdx
movq 0x8(%rcx,%rdx), %rcx
movq %rcx, (%rbx)
cmpq $-0x1, %rax
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/include/jemalloc/internal/hash.h
// Function: je_hash
JEMALLOC_INLINE void
hash(const void *key, size_t len, const uint32_t seed, size_t r_hash[2])
{
#if (LG_SIZEOF_PTR == 3 && !defined(JEMALLOC_BIG_ENDIAN))
	hash_x64_128(key, len, seed, (uint64_t *)r_hash);
#else
	uint64_t hashes[2];
	hash_x86_128(key, len, seed, hashes);
	r_hash[0] = (size_t)hashes[0];
	r_hash[1] = (size_t)hashes[1];
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ecx
movabsq $-0x775ed61580000000, %r10 # imm = 0x88A129EA80000000
movabsq $-0x783c846eeebdac2b, %r8 # imm = 0x87C37B91114253D5
movabsq $0x4e8b26fe00000000, %r11 # imm = 0x4E8B26FE00000000
movabsq $0x4cf5ad432745937f, %r9 # imm = 0x4CF5AD432745937F
pushq $0x10
popq %rbp
movl %esi, %eax
cltd
idivl %ebp
movl %ecx, %r14d
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %r15d
cmovgl %eax, %r15d
shlq $0x4, %r15
movq %r14, %rcx
cmpq %rdx, %r15
je 0x3ab62
movq (%rdi,%rdx), %r13
movq %r13, %r12
imulq %r8, %r12
imulq %r10, %r13
shrq $0x21, %r12
orq %r13, %r12
imulq %r9, %r12
xorq %rcx, %r12
rolq $0x1b, %r12
movq 0x8(%rdi,%rdx), %rcx
addq %r14, %r12
leaq (%r12,%r12,4), %r13
movq %rcx, %rbp
imulq %r9, %rbp
imulq %r11, %rcx
shrq $0x1f, %rbp
orq %rcx, %rbp
imulq %r8, %rbp
xorq %r14, %rbp
rolq $0x1f, %rbp
leaq (%r12,%r12,4), %rcx
addq $0x52dce729, %rcx       # imm = 0x52DCE729
leaq 0x52dce729(,%r13), %r14
addq %rbp, %r14
leaq (%r14,%r14,4), %r14
addq $0x38495ab5, %r14       # imm = 0x38495AB5
addq $0x10, %rdx
jmp 0x3aaec
cltq
shlq $0x4, %rax
movl %esi, %r15d
andl $0xf, %r15d
xorl %edx, %edx
leaq 0x9a10(%rip), %r12      # 0x44588
movslq (%r12,%r15,4), %r15
addq %r12, %r15
jmpq *%r15
movzbl 0xe(%rdi,%rax), %edx
shlq $0x30, %rdx
movzbl 0xd(%rdi,%rax), %r15d
shlq $0x28, %r15
orq %r15, %rdx
movzbl 0xc(%rdi,%rax), %r15d
shlq $0x20, %r15
xorq %r15, %rdx
movzbl 0xb(%rdi,%rax), %r15d
shll $0x18, %r15d
xorq %r15, %rdx
movzbl 0xa(%rdi,%rax), %r15d
shll $0x10, %r15d
xorq %r15, %rdx
movzbl 0x9(%rdi,%rax), %r15d
shll $0x8, %r15d
xorq %r15, %rdx
movzbl 0x8(%rdi,%rax), %r15d
xorq %rdx, %r15
movq %r15, %rdx
imulq %r9, %rdx
imulq %r11, %r15
shrq $0x1f, %rdx
orq %r15, %rdx
imulq %r8, %rdx
xorq %rdx, %r14
movzbl 0x7(%rdi,%rax), %edx
shlq $0x38, %rdx
movzbl 0x6(%rdi,%rax), %r11d
shlq $0x30, %r11
orq %r11, %rdx
movzbl 0x5(%rdi,%rax), %r11d
shlq $0x28, %r11
xorq %r11, %rdx
movzbl 0x4(%rdi,%rax), %r11d
shlq $0x20, %r11
xorq %r11, %rdx
movzbl 0x3(%rdi,%rax), %r11d
shll $0x18, %r11d
xorq %r11, %rdx
movzbl 0x2(%rdi,%rax), %r11d
shll $0x10, %r11d
xorq %r11, %rdx
movzbl 0x1(%rdi,%rax), %r11d
shll $0x8, %r11d
xorq %r11, %rdx
movzbl (%rdi,%rax), %eax
xorq %rdx, %rax
imulq %rax, %r8
imulq %r10, %rax
shrq $0x21, %r8
orq %rax, %r8
imulq %r9, %r8
xorq %r8, %rcx
movslq %esi, %rax
xorq %rax, %rcx
xorq %rax, %r14
addq %r14, %rcx
addq %rcx, %r14
movq %rcx, %rdi
callq 0x3ae4b
movq %rax, %r15
movq %r14, %rdi
callq 0x3ae4b
addq %rax, %r15
addq %r15, %rax
movq %r15, (%rbx)
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/ckh.c
// Function: ckh_try_bucket_insert
JEMALLOC_INLINE_C bool
ckh_try_bucket_insert(ckh_t *ckh, size_t bucket, const void *key,
    const void *data)
{
	ckhc_t *cell;
	unsigned offset, i;

	/*
	 * Cycle through the cells in the bucket, starting at a random position.
	 * The randomness avoids worst-case search overhead as buckets fill up.
	 */
	prng32(offset, LG_CKH_BUCKET_CELLS, ckh->prng_state, CKH_A, CKH_C);
	for (i = 0; i < (ZU(1) << LG_CKH_BUCKET_CELLS); i++) {
		cell = &ckh->tab[(bucket << LG_CKH_BUCKET_CELLS) +
		    ((i + offset) & ((ZU(1) << LG_CKH_BUCKET_CELLS) - 1))];
		if (cell->key == NULL) {
			cell->key = key;
			cell->data = data;
			ckh->count++;
			return (false);
		}
	}

	return (true);
}

// Assembly:
imull $0x41c64e69, (%rdi), %eax # imm = 0x41C64E69
addl $0x303b, %eax           # imm = 0x303B
movl %eax, (%rdi)
shrl $0x1e, %eax
movq 0x28(%rdi), %r8
shlq $0x2, %rsi
xorl %r11d, %r11d
movl %r11d, %r9d
cmpl $0x4, %r11d
je 0x3ad62
leal (%rax,%r9), %r10d
andl $0x3, %r10d
orq %rsi, %r10
shlq $0x4, %r10
leal 0x1(%r9), %r11d
cmpq $0x0, (%r8,%r10)
jne 0x3ad31
addq %r10, %r8
movq %rdx, (%r8)
movq %rcx, 0x8(%r8)
incq 0x8(%rdi)
cmpl $0x4, %r9d
setae %al
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/ckh.c
// Function: ckh_rebuild
JEMALLOC_INLINE_C bool
ckh_rebuild(ckh_t *ckh, ckhc_t *aTab)
{
	size_t count, i, nins;
	const void *key, *data;

	count = ckh->count;
	ckh->count = 0;
	for (i = nins = 0; nins < count; i++) {
		if (aTab[i].key != NULL) {
			key = aTab[i].key;
			data = aTab[i].data;
			if (ckh_try_insert(ckh, &key, &data)) {
				ckh->count = count;
				return (true);
			}
			nins++;
		}
	}

	return (false);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r13
andq $0x0, 0x8(%rdi)
addq $0x8, %r14
xorl %ebp, %ebp
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
cmpq %r13, %rbp
jae 0x3add1
movq -0x8(%r14), %rax
testq %rax, %rax
je 0x3adc7
movq %rax, 0x10(%rsp)
movq (%r14), %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x39f3e
testb %al, %al
jne 0x3adcd
incq %rbp
addq $0x10, %r14
jmp 0x3ad97
movq %r13, 0x8(%rbx)
cmpq %r13, %rbp
setb %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gplessis[P]dotdeb-redis/deps/jemalloc/src/ckh.c
// Function: ckh_bucket_search
JEMALLOC_INLINE_C size_t
ckh_bucket_search(ckh_t *ckh, size_t bucket, const void *key)
{
	ckhc_t *cell;
	unsigned i;

	for (i = 0; i < (ZU(1) << LG_CKH_BUCKET_CELLS); i++) {
		cell = &ckh->tab[(bucket << LG_CKH_BUCKET_CELLS) + i];
		if (cell->key != NULL && ckh->keycomp(key, cell->key))
			return ((bucket << LG_CKH_BUCKET_CELLS) + i);
	}

	return (SIZE_T_MAX);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq (,%rsi,4), %r13
shlq $0x6, %r14
xorl %ebp, %ebp
pushq $-0x1
popq %r12
cmpq $0x4, %rbp
je 0x3ae39
movq 0x28(%r15), %rax
movq (%rax,%r14), %rsi
testq %rsi, %rsi
je 0x3ae2a
movq %rbx, %rdi
callq *0x20(%r15)
testb %al, %al
jne 0x3ae33
incq %rbp
addq $0x10, %r14
jmp 0x3ae0c
addq %rbp, %r13
movq %r13, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rdi, %rax
shrq $0x21, %rax
xorq %rdi, %rax
movabsq $-0xae502812aa7333, %rcx # imm = 0xFF51AFD7ED558CCD
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x21, %rax
xorq %rcx, %rax
movabsq $-0x3b314601e57a13ad, %rcx # imm = 0xC4CEB9FE1A85EC53
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x21, %rax
xorq %rcx, %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/annot-tsv.c
// Function: cols_split
cols_t *cols_split(const char *line, cols_t *cols, char delim)
{
    if ( !cols ) cols = (cols_t*) calloc(1,sizeof(cols_t));
    if ( !cols ) error("Out of memory, failed to allocate %zu bytes\n",sizeof(cols_t));
    if ( cols->rmme ) free(cols->rmme);
    cols->n = 0;
    cols->rmme = strdup(line);
    if ( !cols->rmme ) error("Out of memory\n");
    char *ss = cols->rmme;
    while (1)
    {
        char *se = ss;
        while ( *se && *se!=delim ) se++;
        char tmp = *se;
        *se = 0;
        cols->n++;
        if ( cols->n > cols->m )
        {
            cols->m += 10;
            cols->off = realloc(cols->off, sizeof(*cols->off)*cols->m);
            if ( !cols->off ) error("Out of memory, failed to allocate %zu bytes\n",sizeof(*cols->off)*cols->m);
        }
        cols->off[ cols->n - 1 ] = ss;
        if ( !tmp ) break;
        ss = se + 1;
    }
    return cols;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
jne 0x5ae8
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x4300
movq %rax, %r14
testq %rax, %rax
je 0x5b92
movq 0x10(%r14), %rdi
callq 0x45c0
andl $0x0, (%r14)
movq %r15, %rdi
callq 0x4930
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x5b84
movq %rax, %r15
movq %r15, %r12
movb (%r15), %bpl
incq %r15
testb %bpl, %bpl
je 0x5b1c
cmpb %bl, %bpl
jne 0x5b0c
movb $0x0, -0x1(%r15)
movl (%r14), %ecx
movl 0x4(%r14), %esi
leal 0x1(%rcx), %edx
movl %edx, (%r14)
movq 0x8(%r14), %rax
cmpl %esi, %edx
jbe 0x5b57
addl $0xa, %esi
movl %esi, 0x4(%r14)
shlq $0x3, %rsi
movq %rax, %rdi
callq 0x4840
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x5b6e
movl (%r14), %ecx
decl %ecx
movl %ecx, %ecx
movq %r12, (%rax,%rcx,8)
testb %bpl, %bpl
jne 0x5b09
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x4(%r14), %esi
shlq $0x3, %rsi
leaq 0x6f633(%rip), %rdi     # 0x751b0
xorl %eax, %eax
callq 0x5b9e
leaq 0x6f652(%rip), %rdi     # 0x751dd
xorl %eax, %eax
callq 0x5b9e
leaq 0x6f617(%rip), %rdi     # 0x751b0
pushq $0x18
popq %rsi
jmp 0x5b7d
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/annot-tsv.c
// Function: error
static void HTS_FORMAT(HTS_PRINTF_FMT, 1, 2) HTS_NORETURN
error(const char *format, ...)
{
    va_list ap;
    fflush(stdout);
    va_start(ap, format);
    vfprintf(stderr, format, ap);
    va_end(ap);
    fflush(stderr);
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x5bff
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x983aa(%rip), %rax     # 0x9dfb0
movq (%rax), %rdi
callq 0x45a0
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq 0x983a3(%rip), %r14     # 0x9dfd8
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x4690
movq (%r14), %rdi
callq 0x45a0
pushq $0x1
popq %rdi
callq 0x45e0
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/annot-tsv.c
// Function: cols_clear
void cols_clear(cols_t *cols)
{
    if ( !cols ) return;
    free(cols->rmme);
    free(cols->off);
    cols->rmme = NULL;
    cols->off  = NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x5df5
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x45c0
movq 0x8(%rbx), %rdi
callq 0x45c0
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
popq %rbx
retq