LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/include/jemalloc/internal/hash.h
// Function: hash
JEMALLOC_INLINE uint64_t
hash(const void *key, size_t len, uint64_t seed)
{
	const uint64_t m = UINT64_C(0xc6a4a7935bd1e995);
	const int r = 47;
	uint64_t h = seed ^ (len * m);
	const uint64_t *data = (const uint64_t *)key;
	const uint64_t *end = data + (len/8);
	const unsigned char *data2;

	assert(((uintptr_t)key & 0x7) == 0);

	while(data != end) {
		uint64_t k = *data++;

		k *= m;
		k ^= k >> r;
		k *= m;

		h ^= k;
		h *= m;
	}

	data2 = (const unsigned char *)data;
	switch(len & 7) {
	case 7: h ^= ((uint64_t)(data2[6])) << 48;
	case 6: h ^= ((uint64_t)(data2[5])) << 40;
	case 5: h ^= ((uint64_t)(data2[4])) << 32;
	case 4: h ^= ((uint64_t)(data2[3])) << 24;
	case 3: h ^= ((uint64_t)(data2[2])) << 16;
	case 2: h ^= ((uint64_t)(data2[1])) << 8;
	case 1: h ^= ((uint64_t)(data2[0]));
		h *= m;
	}

	h ^= h >> r;
	h *= m;
	h ^= h >> r;

	return (h);
}

// Assembly:
movabsq $-0x395b586ca42e166b, %rax # imm = 0xC6A4A7935BD1E995
movq %rsi, %rcx
imulq %rax, %rcx
xorq %rdx, %rcx
movq %rsi, %rdx
shrq $0x3, %rdx
movq %rsi, %r8
andq $-0x8, %r8
xorl %r9d, %r9d
cmpq %r9, %r8
je 0x84259
movq (%rdi,%r9), %r10
imulq %rax, %r10
movq %r10, %r11
shrq $0x2f, %r11
xorq %r10, %r11
imulq %rax, %r11
xorq %rcx, %r11
imulq %rax, %r11
addq $0x8, %r9
movq %r11, %rcx
jmp 0x8422e
andl $0x7, %esi
leaq 0x152c1(%rip), %r8      # 0x99524
movslq (%r8,%rsi,4), %rsi
addq %r8, %rsi
jmpq *%rsi
movzbl 0x6(%rdi,%rdx,8), %esi
shlq $0x30, %rsi
xorq %rsi, %rcx
movzbl 0x5(%rdi,%rdx,8), %esi
shlq $0x28, %rsi
xorq %rsi, %rcx
movzbl 0x4(%rdi,%rdx,8), %esi
shlq $0x20, %rsi
xorq %rsi, %rcx
movzbl 0x3(%rdi,%rdx,8), %esi
shll $0x18, %esi
xorq %rsi, %rcx
movzbl 0x2(%rdi,%rdx,8), %esi
shll $0x10, %esi
xorq %rsi, %rcx
movzbl 0x1(%rdi,%rdx,8), %esi
shll $0x8, %esi
xorq %rsi, %rcx
movzbl (%rdi,%rdx,8), %edx
xorq %rcx, %rdx
imulq %rax, %rdx
movq %rdx, %rcx
movq %rcx, %rdx
shrq $0x2f, %rdx
xorq %rcx, %rdx
imulq %rax, %rdx
movq %rdx, %rax
shrq $0x2f, %rax
xorq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/quarantine.c
// Function: quarantine_init
static quarantine_t *
quarantine_init(size_t lg_maxobjs)
{
	quarantine_t *quarantine;

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

	quarantine_tsd_set(&quarantine);

	return (quarantine);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %r15
movl %ebx, %ecx
shlq %cl, %r15
leaq 0x20(%r15), %r13
leaq 0x58416(%rip), %rax     # 0xdc930
cmpq %r13, (%rax)
jae 0x8452e
movq %r13, %rdi
xorl %esi, %esi
callq 0x82520
jmp 0x84651
cmpq $0xde0, %r15            # imm = 0xDE0
ja 0x845c1
pushq $0x1
popq %rdi
callq 0x8497d
testq %rax, %rax
je 0x8463f
movq %rax, %r14
addq $0x1f, %r15
shrq $0x3, %r15
leaq 0x14be2(%rip), %rax     # 0x99140
movzbl (%rax,%r15), %ebp
movl %ebp, %eax
shll $0x5, %eax
leaq (%r14,%rax), %r12
addq $0x28, %r12
movq %r12, %rdi
callq 0x84a70
testq %rax, %rax
jne 0x84594
movq %r14, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x87422
testq %rax, %rax
je 0x8465d
movq %rax, %r15
leaq 0x575bd(%rip), %rax     # 0xdbb5b
cmpb $0x1, (%rax)
jne 0x84662
imulq $0x68, %rbp, %rsi
addq 0x3ea1e(%rip), %rsi     # 0xc2fd0
movq %r15, %rdi
xorl %edx, %edx
callq 0x782ed
jmp 0x8467b
leaq 0x695e0(%rip), %rax     # 0xedba8
cmpq %r13, (%rax)
jb 0x8462b
pushq $0x1
popq %rdi
callq 0x8497d
testq %rax, %rax
je 0x8462b
movq %rax, %r14
addq $0x101f, %r15           # imm = 0x101F
movq %r15, %r13
andq $-0x1000, %r13          # imm = 0xF000
shrq $0x7, %r15
andq $-0x20, %r15
leaq (%r15,%rax), %r12
addq $0x388, %r12            # imm = 0x388
movq %r12, %rdi
callq 0x84a70
testq %rax, %rax
je 0x846b5
movq %rax, %r15
leaq 0x5753f(%rip), %rax     # 0xdbb5b
cmpb $0x1, (%rax)
jne 0x84662
movq %r15, %rdi
movl $0xa5, %esi
jmp 0x84673
callq 0x84a0f
movq %rax, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x785a7
jmp 0x84651
callq 0x84a0f
movq %rax, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x7842d
movq %rax, %r15
movq %rax, (%rsp)
testq %rax, %rax
jne 0x8468b
xorl %r15d, %r15d
jmp 0x846a3
leaq 0x57503(%rip), %rax     # 0xdbb6c
cmpb $0x1, (%rax)
jne 0x8467b
movq %r15, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x1f110
incq (%r12)
movq %r14, %rdi
callq 0x84a96
movq %r15, (%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
andq $0x0, 0x10(%r15)
movq %rbx, 0x18(%r15)
movq %rsp, %rdi
callq 0x848aa
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r14), %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x785a7
movq %rax, %r15
testq %rax, %rax
jne 0x8467f
jmp 0x8465d
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/quarantine.c
// Function: quarantine_drain
static void
quarantine_drain(quarantine_t *quarantine, size_t upper_bound)
{

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rdi), %r15
movq (%rdi), %rax
pushq $-0x1
popq %r12
cmpq %rbx, %rax
jbe 0x84958
cmpq $0x0, 0x8(%r14)
je 0x84958
movq 0x10(%r14), %r13
shlq $0x4, %r13
movq (%r15,%r13), %rdi
callq 0x846cd
movq (%r14), %rax
movq 0x10(%r14), %rdx
subq 0x8(%r15,%r13), %rax
movq %rax, (%r14)
decq 0x8(%r14)
movb 0x18(%r14), %cl
movq %r12, %rsi
shlq %cl, %rsi
incq %rdx
notq %rsi
andq %rdx, %rsi
movq %rsi, 0x10(%r14)
jmp 0x8490f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/tcache.c
// Function: tcache_event_hard
void
tcache_event_hard(tcache_t *tcache)
{
	size_t binind = tcache->next_gc_bin;
	tcache_bin_t *tbin = &tcache->tbins[binind];
	tcache_bin_info_t *tbin_info = &tcache_bin_info[binind];

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x24(%rdi), %r15d
movq %r15, %rax
shlq $0x5, %rax
leaq (%rdi,%rax), %r14
addq $0x28, %r14
movl 0x8(%r14), %eax
testl %eax, %eax
jle 0x8709d
movq 0x66b14(%rip), %r12     # 0xedb90
movl %eax, %edx
shrl $0x2, %edx
subl %eax, %edx
addl 0x10(%r14), %edx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
cmpl $0x1b, %r15d
ja 0x870b0
callq 0x870f5
jmp 0x870b5
jns 0x870c9
movl 0xc(%r14), %eax
cmpl $0x2, %eax
jb 0x870c9
decl %eax
movl %eax, 0xc(%r14)
jmp 0x870c9
callq 0x872d5
movl (%r12,%r15,4), %eax
movl 0xc(%r14), %ecx
incl %ecx
shrl %cl, %eax
testl %eax, %eax
je 0x870c9
movl %ecx, 0xc(%r14)
movl 0x10(%r14), %eax
movl %eax, 0x8(%r14)
movl 0x24(%rbx), %eax
incl %eax
xorl %ecx, %ecx
cmpq %rax, 0x66ab9(%rip)     # 0xedb98
cmovnel %eax, %ecx
movl %ecx, 0x24(%rbx)
andl $0x0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/tcache.c
// Function: tcache_alloc_small_hard
void *
tcache_alloc_small_hard(tcache_t *tcache, tcache_bin_t *tbin, size_t binind)
{
	void *ret;

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

	return (ret);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x18(%rdi), %rdi
xorl %ecx, %ecx
callq 0x77ecc
movl 0x10(%rbx), %eax
testl %eax, %eax
je 0x87451
decl %eax
movl %eax, 0x10(%rbx)
cmpl 0x8(%rbx), %eax
jge 0x87445
movl %eax, 0x8(%rbx)
movq 0x18(%rbx), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %rax
jmp 0x87457
orl $-0x1, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/tcache.c
// Function: tcache_arena_dissociate
void
tcache_arena_dissociate(tcache_t *tcache)
{

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
addq $0x8, %rdi
callq 0x1faa0
movq 0x18(%rbx), %rdi
movq 0x78(%rdi), %rax
cmpq %rbx, %rax
jne 0x874d3
movq (%rax), %rax
movq %rax, 0x78(%rdi)
cmpq %rbx, %rax
je 0x874ef
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
movq %rbx, (%rbx)
movq %rbx, 0x8(%rbx)
jmp 0x874f4
andq $0x0, 0x78(%rdi)
addq $0x8, %rdi
callq 0x1fbb0
movq 0x18(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x8750a
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/tcache.c
// Function: tcache_create
tcache_t *
tcache_create(arena_t *arena)
{
	tcache_t *tcache;
	size_t size, stack_offset;
	unsigned i;

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

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

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

	tcache_arena_associate(tcache, arena);

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

	tcache_tsd_set(&tcache);

	return (tcache);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x665ee(%rip), %r15d    # 0xedb98
shll $0x5, %r15d
addl $0x2f, %r15d
andl $-0x18, %r15d
movl 0x665e4(%rip), %eax     # 0xedba0
leaq (%r15,%rax,8), %r14
addq $0x3f, %r14
andq $-0x40, %r14
cmpq $0xe00, %r14            # imm = 0xE00
ja 0x875e1
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7842d
jmp 0x87636
cmpq 0x665c0(%rip), %r14     # 0xedba8
jbe 0x87603
leaq 0x5533f(%rip), %rax     # 0xdc930
cmpq %r14, (%rax)
jae 0x8760b
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x82520
jmp 0x87636
pushq $0x1
popq %rdx
movq %rbx, %rdi
jmp 0x8762e
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x8762b
movq 0x3b91e(%rip), %rax     # 0xc2f38
movq %fs:(%rax), %rdi
testq %rdi, %rdi
jne 0x8762b
callq 0x7526e
movq %rax, %rdi
pushq $0x1
popq %rdx
movq %r14, %rsi
callq 0x785a7
movq %rax, %r14
movq %rax, 0x8(%rsp)
testq %r14, %r14
je 0x87696
movq %r14, %rdi
movq %rbx, %rsi
callq 0x87459
movq 0x66543(%rip), %rax     # 0xedb98
leaq 0x28(%r14), %rcx
xorl %edx, %edx
movl %edx, %edx
cmpq %rdx, %rax
jbe 0x8768c
movq %rdx, %rsi
shlq $0x5, %rsi
movl $0x1, 0xc(%rcx,%rsi)
leaq (%r15,%r14), %rdi
movq %rdi, 0x18(%rcx,%rsi)
movq 0x6650f(%rip), %rsi     # 0xedb90
movl (%rsi,%rdx,4), %esi
leaq (%r15,%rsi,8), %r15
incl %edx
jmp 0x8765b
leaq 0x8(%rsp), %rdi
callq 0x876a3
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/tcache.c
// Function: tcache_boot0
bool
tcache_boot0(void)
{
	unsigned i;

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

	nhbins = NBINS + (tcache_maxclass >> LG_PAGE);

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

	return (false);
}

// Assembly:
movq 0x3f6ba(%rip), %rcx     # 0xc6f98
movl $0xe00, %eax            # imm = 0xE00
testq %rcx, %rcx
js 0x87903
cmpl $0xc, %ecx
jb 0x87903
pushq $0x1
popq %rax
shll %cl, %eax
leaq 0x55037(%rip), %rcx     # 0xdc930
movq (%rcx), %rcx
cmpq %rax, %rcx
cmovbq %rcx, %rax
pushq %rax
movq %rax, 0x6629d(%rip)     # 0xedba8
shrq $0xc, %rax
leaq 0x1c(%rax), %rcx
movq %rcx, 0x6627e(%rip)     # 0xedb98
leaq 0x70(,%rax,4), %rdi
callq 0x7c708
movq %rax, 0x66262(%rip)     # 0xedb90
testq %rax, %rax
je 0x87998
leaq 0x542c6(%rip), %rdx     # 0xdbc00
addq $0x20, %rdx
xorl %esi, %esi
movl $0xc8, %edi
xorl %ecx, %ecx
cmpq $0x1c, %rsi
je 0x8796a
movl (%rdx), %r8d
addl %r8d, %r8d
cmpl %edi, %r8d
cmovael %edi, %r8d
movl %r8d, (%rax,%rsi,4)
addl %r8d, %ecx
incq %rsi
addq $0x68, %rdx
jmp 0x87947
movl %ecx, 0x66230(%rip)     # 0xedba0
movq 0x66221(%rip), %rdx     # 0xedb98
addl $0x14, %ecx
pushq $0x1c
popq %rsi
movl %esi, %esi
cmpq %rsi, %rdx
jbe 0x87998
movl $0x14, (%rax,%rsi,4)
movl %ecx, 0x6620f(%rip)     # 0xedba0
incl %esi
addl $0x14, %ecx
jmp 0x8797d
testq %rax, %rax
sete %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ckh.c
// Function: ckh_insert
bool
ckh_insert(ckh_t *ckh, const void *key, const void *data)
{
	bool ret;

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rsi, (%rax)
leaq 0x8(%rsp), %rcx
movq %rdx, (%rcx)
pushq $0x10
popq %r14
movq %rbx, %rdi
movq %rax, %rsi
movq %rcx, %rdx
callq 0x8924d
movb %al, 0x7(%rsp)
testb %al, %al
je 0x8923a
movl 0x14(%rbx), %r15d
leal 0x2(%r15), %r12d
leal 0x1(%r15), %ebp
incq %r12
movq %r14, %rdi
movl %r12d, %ecx
shlq %cl, %rdi
callq 0x88c4d
testq %rax, %rax
je 0x8923a
movq %rax, %rdi
callq 0x88ce2
testq %rax, %rax
je 0x8923a
movq 0x28(%rbx), %r13
movq %rax, 0x28(%rbx)
movl %ebp, 0x14(%rbx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x898a7
testb %al, %al
je 0x89223
movq 0x28(%rbx), %rdi
callq 0x88f4e
movq %r13, 0x28(%rbx)
movl %r15d, 0x14(%rbx)
incl %ebp
jmp 0x891d1
movq %r13, %rdi
callq 0x88f4e
leaq 0x10(%rsp), %rax
leaq 0x8(%rsp), %rcx
jmp 0x891af
movb 0x7(%rsp), %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ckh.c
// Function: ckh_try_insert
JEMALLOC_INLINE bool
ckh_try_insert(ckh_t *ckh, void const**argkey, void const**argdata)
{
	size_t hash1, hash2, bucket;
	const void *key = *argkey;
	const void *data = *argdata;

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r13
movq %rdi, %r15
movq (%rsi), %r14
movq %rdx, 0x8(%rsp)
movq (%rdx), %r12
movl 0x14(%rdi), %esi
leaq 0x30(%rsp), %rbx
leaq 0x18(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq *0x18(%r15)
movb 0x14(%r15), %cl
pushq $-0x1
popq %rbp
movq %rbp, %rsi
shlq %cl, %rsi
notq %rsi
andq (%rbx), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %r12, %rcx
callq 0x89853
testb %al, %al
je 0x89384
movb 0x14(%r15), %cl
movq %rbp, %rbx
shlq %cl, %rbx
notq %rbx
andq 0x18(%rsp), %rbx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x89853
testb %al, %al
je 0x89384
movq %r13, 0x10(%rsp)
movq (%r13), %r13
movq 0x8(%rsp), %rax
movq (%rax), %r14
movq %rbx, %r12
movq %r13, %rax
movq %r14, %rcx
imull $0x41c64e69, (%r15), %edx # imm = 0x41C64E69
addl $0x303b, %edx           # imm = 0x303B
movl %edx, (%r15)
movq 0x28(%r15), %rsi
movq %r12, %rdi
shlq $0x6, %rdi
shrl $0x1a, %edx
andl $-0x10, %edx
orq %rdi, %rdx
movq (%rsi,%rdx), %r13
movq 0x8(%rsi,%rdx), %r14
movq %rax, (%rsi,%rdx)
movq %rcx, 0x8(%rsi,%rdx)
movl 0x14(%r15), %esi
movq %r13, %rdi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq *0x18(%r15)
movb 0x14(%r15), %cl
pushq $-0x1
popq %rax
shlq %cl, %rax
notq %rax
movq 0x20(%rsp), %rcx
andq %rax, %rcx
andq 0x28(%rsp), %rax
cmpq %r12, %rcx
movq %rax, %r12
cmovneq %rcx, %r12
cmpq %rbx, %r12
sete %bpl
je 0x89397
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x89853
testb %al, %al
jne 0x892eb
jmp 0x89386
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rax
movq %r13, (%rax)
movq 0x8(%rsp), %rax
movq %r14, (%rax)
jmp 0x89386
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ckh.c
// Function: ckh_remove
bool
ckh_remove(ckh_t *ckh, const void *searchkey, void **key, void **data)
{
	size_t cell;

	assert(ckh != NULL);

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

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

		return (false);
	}

	return (true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r14
callq 0x8949c
movq %rax, %rbx
cmpq $-0x1, %rax
je 0x89489
testq %r12, %r12
je 0x893e4
movq 0x28(%r14), %rax
movq %rbx, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rax
movq %rax, (%r12)
testq %r15, %r15
je 0x893fc
movq 0x28(%r14), %rax
movq %rbx, %rcx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rax
movq %rax, (%r15)
movq 0x28(%r14), %rax
movq %rbx, %rcx
shlq $0x4, %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%rcx)
movq 0x8(%r14), %rax
decq %rax
movq %rax, 0x8(%r14)
movl 0x14(%r14), %r15d
movl %r15d, %ecx
shrq %cl, %rax
testq %rax, %rax
jne 0x89489
cmpl 0x10(%r14), %r15d
jbe 0x89489
leal 0x1(%r15), %ecx
pushq $0x10
popq %rdi
shlq %cl, %rdi
callq 0x88c4d
testq %rax, %rax
je 0x89489
movq %rax, %rdi
callq 0x88ce2
testq %rax, %rax
je 0x89489
movq 0x28(%r14), %r12
movq %rax, 0x28(%r14)
leal -0x1(%r15), %eax
movl %eax, 0x14(%r14)
movq %r14, %rdi
movq %r12, %rsi
callq 0x898a7
testb %al, %al
je 0x89481
movq 0x28(%r14), %rdi
callq 0x88f4e
movq %r12, 0x28(%r14)
movl %r15d, 0x14(%r14)
jmp 0x89489
movq %r12, %rdi
callq 0x88f4e
cmpq $-0x1, %rbx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ckh.c
// Function: ckh_isearch
JEMALLOC_INLINE size_t
ckh_isearch(ckh_t *ckh, const void *key)
{
	size_t hash1, hash2, bucket, cell;

	assert(ckh != NULL);

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

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

	/* Search secondary bucket. */
	bucket = hash2 & ((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
movl 0x14(%rdi), %esi
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r12, %rdx
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 0x89923
cmpq $-0x1, %rax
jne 0x89507
movb 0x14(%r14), %cl
shlq %cl, %r15
notq %r15
andq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x89923
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ckh.c
// Function: ckh_string_hash
void
ckh_string_hash(const void *key, unsigned minbits, size_t *hash1, size_t *hash2)
{
	size_t ret1, ret2;
	uint64_t h;

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

	h = hash(key, strlen((const char *)key), UINT64_C(0x94122f335b332aea));
	if (minbits <= 32) {
		/*
		 * Avoid doing multiple hashes, since a single hash provides
		 * enough bits.
		 */
		ret1 = h & ZU(0xffffffffU);
		ret2 = h >> 32;
	} else {
		ret1 = h;
		ret2 = hash(key, strlen((const char *)key),
		    UINT64_C(0x8432a476666bbc13));
	}

	*hash1 = ret1;
	*hash2 = ret2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
callq 0x1f4f0
movq %rax, %r13
movabsq $-0x6bedd0cca4ccd516, %rdx # imm = 0x94122F335B332AEA
movq %r12, %rdi
movq %rax, %rsi
callq 0x895dc
movq %rax, %r15
cmpl $0x20, %ebp
ja 0x895b2
movl %r15d, %ecx
shrq $0x20, %r15
movq %r15, %rax
movq %rcx, %r15
jmp 0x895c7
movabsq $-0x7bcd5b89999443ed, %rdx # imm = 0x8432A476666BBC13
movq %r12, %rdi
movq %r13, %rsi
callq 0x895dc
movq %r15, (%r14)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ckh.c
// Function: ckh_pointer_hash
void
ckh_pointer_hash(const void *key, unsigned minbits, size_t *hash1,
    size_t *hash2)
{
	size_t ret1, ret2;
	uint64_t h;
	union {
		const void	*v;
		uint64_t	i;
	} u;

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

	assert(sizeof(u.v) == sizeof(u.i));
#if (LG_SIZEOF_PTR != LG_SIZEOF_INT)
	u.i = 0;
#endif
	u.v = key;
	h = hash(&u.i, sizeof(u.i), UINT64_C(0xd983396e68886082));
	if (minbits <= 32) {
		/*
		 * Avoid doing multiple hashes, since a single hash provides
		 * enough bits.
		 */
		ret1 = h & ZU(0xffffffffU);
		ret2 = h >> 32;
	} else {
		assert(SIZEOF_PTR == 8);
		ret1 = h;
		ret2 = hash(&u.i, sizeof(u.i), UINT64_C(0x5e2be9aff8709a5d));
	}

	*hash1 = ret1;
	*hash2 = ret2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rsp, %rax
movq %rdi, (%rax)
pushq $0x8
popq %rsi
movabsq $-0x267cc69197779f7e, %rdx # imm = 0xD983396E68886082
movq %rax, %rdi
callq 0x895dc
movq %rax, %r15
cmpl $0x20, %ebp
ja 0x896f9
movl %r15d, %ecx
shrq $0x20, %r15
movq %r15, %rax
movq %rcx, %r15
jmp 0x8970e
movq %rsp, %rdi
pushq $0x8
popq %rsi
movabsq $0x5e2be9aff8709a5d, %rdx # imm = 0x5E2BE9AFF8709A5D
callq 0x895dc
movq %r15, (%r14)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/ksw2/cli.c
// Function: ksw_gen_simple_mat
static void ksw_gen_simple_mat(int m, int8_t *mat, int8_t a, int8_t b)
{
	int i, j;
	a = a < 0? -a : a;
	b = b > 0? -b : b;
	for (i = 0; i < m - 1; ++i) {
		for (j = 0; j < m - 1; ++j)
			mat[i * m + j] = i == j? a : b;
		mat[i * m + m - 1] = 0;
	}
	for (j = 0; j < m; ++j)
		mat[(m - 1) * m + j] = 0;
}

// Assembly:
movl %esi, %eax
sarb $0x7, %al
xorb %al, %sil
subb %al, %sil
movl %edx, %r8d
sarb $0x7, %r8b
xorb %r8b, %dl
subb %dl, %r8b
xorl %eax, %eax
movzbl %sil, %ecx
movzbl %r8b, %edx
movq %rdi, %rsi
cmpq $0x4, %rax
je 0x184a
leaq (%rax,%rax,4), %r8
xorl %r9d, %r9d
cmpq $0x4, %r9
je 0x183b
cmpq %r9, %rax
movl %edx, %r10d
cmovel %ecx, %r10d
movb %r10b, (%rsi,%r9)
incq %r9
jmp 0x1822
movb $0x0, 0x4(%rdi,%r8)
incq %rax
addq $0x5, %rsi
jmp 0x1815
pushq $-0x5
popq %rax
testq %rax, %rax
je 0x185c
movb $0x0, 0x19(%rdi,%rax)
incq %rax
jmp 0x184d
retq
// File: /workspace/github_c_makefile_star2_O2/erikdubbelboer[P]discnt/src/discnt-cli.c
// Function: cliConnect
static int cliConnect(int force) {
    if (context == NULL || force) {
        if (context != NULL)
            redisFree(context);

        if (config.hostsocket == NULL) {
            context = redisConnect(config.hostip,config.hostport);
        } else {
            context = redisConnectUnix(config.hostsocket);
        }

        if (context->err) {
            fprintf(stderr,"Could not connect to Discnt at ");
            if (config.hostsocket == NULL)
                fprintf(stderr,"%s:%d: %s\n",config.hostip,config.hostport,context->errstr);
            else
                fprintf(stderr,"%s: %s\n",config.hostsocket,context->errstr);
            redisFree(context);
            context = NULL;
            return REDIS_ERR;
        }

        /* Set aggressive KEEP_ALIVE socket option in the Discnt context socket
         * in order to prevent timeouts caused by the execution of long
         * commands. At the same time this improves the detection of real
         * errors. */
        anetKeepAlive(NULL, context->fd, DISCNT_CLI_KEEPALIVE_INTERVAL);

        /* Do AUTH and select the right DB. */
        if (cliAuth() != REDIS_OK)
            return REDIS_ERR;
    }
    return REDIS_OK;
}

// Assembly:
pushq %rbx
movl %edi, %eax
movq 0x39457(%rip), %rdi     # 0x49c98
testq %rdi, %rdi
setne %cl
testl %eax, %eax
sete %al
xorl %ebx, %ebx
testb %cl, %al
jne 0x10963
testq %rdi, %rdi
je 0x10860
callq 0x1350c
movq 0x39331(%rip), %rdi     # 0x49b98
testq %rdi, %rdi
je 0x10873
callq 0x13683
jmp 0x10885
movq 0x3930e(%rip), %rdi     # 0x49b88
movl 0x39310(%rip), %esi     # 0x49b90
callq 0x13561
movq %rax, 0x3940c(%rip)     # 0x49c98
cmpl $0x0, (%rax)
jne 0x108e0
movl 0x84(%rax), %esi
xorl %ebx, %ebx
pushq $0xf
popq %rdx
xorl %edi, %edi
callq 0xc8f7
movq 0x39336(%rip), %rdx     # 0x49be0
testq %rdx, %rdx
je 0x10963
movq 0x393de(%rip), %rdi     # 0x49c98
leaq 0x26005(%rip), %rsi     # 0x368c6
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x13b70
testq %rax, %rax
je 0x10960
movq %rax, %rdi
callq 0x123f0
jmp 0x10963
movq 0x38711(%rip), %rbx     # 0x48ff8
movq (%rbx), %rcx
leaq 0x25fa2(%rip), %rdi     # 0x36893
pushq $0x1f
popq %rsi
pushq $0x1
popq %rdx
callq 0xc5d0
movq 0x39295(%rip), %rdx     # 0x49b98
movq (%rbx), %rdi
testq %rdx, %rdx
jne 0x10933
movq 0x39276(%rip), %rdx     # 0x49b88
movl 0x39278(%rip), %ecx     # 0x49b90
movq 0x39379(%rip), %r8      # 0x49c98
addq $0x4, %r8
leaq 0x25f89(%rip), %rsi     # 0x368b3
xorl %eax, %eax
callq 0xc360
jmp 0x1094c
movq 0x3935e(%rip), %rcx     # 0x49c98
addq $0x4, %rcx
leaq 0x25f79(%rip), %rsi     # 0x368be
xorl %eax, %eax
callq 0xc360
movq 0x39345(%rip), %rdi     # 0x49c98
callq 0x1350c
andq $0x0, 0x39338(%rip)     # 0x49c98
pushq $-0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/erikdubbelboer[P]discnt/src/discnt-cli.c
// Function: cliVersion
static sds cliVersion(void) {
    sds version;
    version = sdscatprintf(sdsempty(), "%s", DISCNT_VERSION);

    /* Add git commit and working tree status when available */
    if (strtoll(discntGitSHA1(),NULL,16)) {
        version = sdscatprintf(version, " (git:%s", discntGitSHA1());
        if (strtoll(discntGitDirty(),NULL,10))
            version = sdscatprintf(version, "-dirty");
        version = sdscat(version, ")");
    }
    return version;
}

// Assembly:
pushq %rbx
callq 0xd778
leaq 0x24687(%rip), %rsi     # 0x35032
leaq 0x250ef(%rip), %rdx     # 0x35aa1
movq %rax, %rdi
xorl %eax, %eax
callq 0xe064
movq %rax, %rbx
callq 0x11b10
pushq $0x10
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0xc350
testq %rax, %rax
je 0x10a2d
callq 0x11b10
leaq 0x25ea1(%rip), %rsi     # 0x36883
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe064
movq %rax, %rbx
callq 0x11b18
pushq $0xa
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0xc350
testq %rax, %rax
je 0x10a1d
leaq 0x25e7c(%rip), %rsi     # 0x3688c
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe064
movq %rax, %rbx
leaq 0x24a3b(%rip), %rsi     # 0x3545f
movq %rbx, %rdi
popq %rbx
jmp 0xdde3
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/erikdubbelboer[P]discnt/src/discnt-cli.c
// Function: cliRefreshPrompt
static void cliRefreshPrompt(void) {
    int len;

    if (config.hostsocket != NULL)
        len = snprintf(config.prompt,sizeof(config.prompt),"discnt %s",
                       config.hostsocket);
    else
        len = snprintf(config.prompt,sizeof(config.prompt),
                       strchr(config.hostip,':') ? "[%s]:%d" : "%s:%d",
                       config.hostip, config.hostport);
    snprintf(config.prompt+len,sizeof(config.prompt)-len,"> ");
}

// Assembly:
pushq %rbx
movq 0x38f79(%rip), %rcx     # 0x49b98
testq %rcx, %rcx
je 0x10c40
leaq 0x38fcd(%rip), %rdi     # 0x49bf8
leaq 0x25ff5(%rip), %rdx     # 0x36c27
movl $0x80, %esi
xorl %eax, %eax
callq 0xc1f0
jmp 0x10c84
movq 0x38f41(%rip), %rbx     # 0x49b88
pushq $0x3a
popq %rsi
movq %rbx, %rdi
callq 0xc1d0
testq %rax, %rax
leaq 0x244a0(%rip), %rax     # 0x350fc
leaq 0x24491(%rip), %rdx     # 0x350f4
cmoveq %rax, %rdx
movl 0x38f22(%rip), %r8d     # 0x49b90
leaq 0x38f83(%rip), %rdi     # 0x49bf8
movl $0x80, %esi
movq %rbx, %rcx
xorl %eax, %eax
callq 0xc1f0
cltq
leaq 0x38efb(%rip), %rcx     # 0x49b88
leaq (%rax,%rcx), %rdi
addq $0x70, %rdi
movl $0x80, %esi
subq %rax, %rsi
leaq 0x25f59(%rip), %rdx     # 0x36bfd
xorl %eax, %eax
popq %rbx
jmp 0xc1f0
// File: /workspace/github_c_makefile_star2_O2/erikdubbelboer[P]discnt/src/discnt-cli.c
// Function: cliReadReply
static int cliReadReply(int output_raw_strings) {
    void *_reply;
    redisReply *reply;
    sds out = NULL;

    if (redisGetReply(context,&_reply) != REDIS_OK) {
        if (config.shutdown) {
            redisFree(context);
            context = NULL;
            return REDIS_OK;
        }
        if (config.interactive) {
            /* Filter cases where we should reconnect */
            if (context->err == REDIS_ERR_IO &&
                (errno == ECONNRESET || errno == EPIPE))
                return REDIS_ERR;
            if (context->err == REDIS_ERR_EOF)
                return REDIS_ERR;
        }
        cliPrintContextError();
        exit(1);
        return REDIS_ERR; /* avoid compiler warning */
    }

    reply = (redisReply*)_reply;

    config.last_cmd_type = reply->type;

    if (output_raw_strings) {
        out = cliFormatReplyRaw(reply);
    } else {
        if (config.output == OUTPUT_RAW) {
            out = cliFormatReplyRaw(reply);
            out = sdscat(out,"\n");
        } else if (config.output == OUTPUT_STANDARD) {
            out = cliFormatReplyTTY(reply,"");
        } else if (config.output == OUTPUT_CSV) {
            out = cliFormatReplyCSV(reply);
            out = sdscat(out,"\n");
        }
    }
    fwrite(out,sdslen(out),1,stdout);
    sdsfree(out);
    freeReplyObject(reply);
    return REDIS_OK;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebp
movq 0x38b85(%rip), %rdi     # 0x49c98
leaq 0x8(%rsp), %rsi
callq 0x13919
testl %eax, %eax
je 0x11143
cmpl $0x0, 0x38a8c(%rip)     # 0x49bb4
je 0x11161
movq 0x38b67(%rip), %rdi     # 0x49c98
callq 0x1350c
andq $0x0, 0x38b5a(%rip)     # 0x49c98
jmp 0x11223
movq 0x8(%rsp), %rbx
movl (%rbx), %eax
movl %eax, 0x38b30(%rip)     # 0x49c80
testl %ebp, %ebp
je 0x111aa
movq %rbx, %rdi
callq 0x112a4
jmp 0x111f0
cmpl $0x0, 0x38a48(%rip)     # 0x49bb0
je 0x1119d
movq 0x38b27(%rip), %rax     # 0x49c98
movl (%rax), %eax
pushq $-0x1
popq %rbx
cmpl $0x3, %eax
je 0x11225
cmpl $0x1, %eax
jne 0x1119d
callq 0xc0a0
movl (%rax), %eax
cmpl $0x20, %eax
je 0x11225
cmpl $0x68, %eax
je 0x11225
callq 0x110a1
pushq $0x1
popq %rdi
callq 0xc5b0
movl 0x38a38(%rip), %eax     # 0x49be8
testl %eax, %eax
je 0x111e1
cmpl $0x2, %eax
je 0x111c8
cmpl $0x1, %eax
jne 0x11230
movq %rbx, %rdi
callq 0x112a4
jmp 0x111d0
movq %rbx, %rdi
callq 0x1158e
leaq 0x256aa(%rip), %rsi     # 0x36881
movq %rax, %rdi
callq 0xdde3
jmp 0x111f0
leaq 0x2569a(%rip), %rsi     # 0x36882
movq %rbx, %rdi
callq 0x113b8
movq %rax, %r14
movq %r14, %rdi
callq 0x110ca
movq 0x37dbe(%rip), %rcx     # 0x48fc0
movq (%rcx), %rcx
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0xc5d0
movq %r14, %rdi
callq 0xd7f4
movq %rbx, %rdi
callq 0x123f0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorl %r14d, %r14d
jmp 0x111f3
// File: /workspace/github_c_makefile_star2_O2/erikdubbelboer[P]discnt/src/discnt-cli.c
// Function: cliFormatReplyRaw
static sds cliFormatReplyRaw(redisReply *r) {
    sds out = sdsempty(), tmp;
    size_t i;

    switch (r->type) {
    case REDIS_REPLY_NIL:
        /* Nothing... */
        break;
    case REDIS_REPLY_ERROR:
        out = sdscatlen(out,r->str,r->len);
        out = sdscatlen(out,"\n",1);
        break;
    case REDIS_REPLY_STATUS:
    case REDIS_REPLY_STRING:
        out = sdscatlen(out,r->str,r->len);
        break;
    case REDIS_REPLY_INTEGER:
        out = sdscatprintf(out,"%lld",r->integer);
        break;
    case REDIS_REPLY_ARRAY:
        for (i = 0; i < r->elements; i++) {
            if (i > 0) out = sdscat(out,config.mb_delim);
            tmp = cliFormatReplyRaw(r->element[i]);
            out = sdscatlen(out,tmp,sdslen(tmp));
            sdsfree(tmp);
        }
        break;
    default:
        fprintf(stderr,"Unknown reply type: %d\n", r->type);
        exit(1);
    }
    return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xd778
movq %rax, %rbx
movl (%r14), %edx
leal -0x1(%rdx), %eax
cmpl $0x5, %eax
ja 0x11398
leaq 0x2422f(%rip), %rcx     # 0x354fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%r14), %rsi
movslq 0x10(%r14), %rdx
movq %rbx, %rdi
jmp 0x11368
xorl %r12d, %r12d
cmpq 0x20(%r14), %r12
jae 0x1133c
testq %r12, %r12
je 0x11306
movq 0x388f5(%rip), %rsi     # 0x49bf0
movq %rbx, %rdi
callq 0xdde3
movq %rax, %rbx
movq 0x28(%r14), %rax
movq (%rax,%r12,8), %rdi
callq 0x112a4
movq %rax, %r15
movq %rax, %rdi
callq 0x110ca
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xdd84
movq %rax, %rbx
movq %r15, %rdi
callq 0xd7f4
incq %r12
jmp 0x112e9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x18(%r14), %rsi
movslq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0xdd84
leaq 0x2551f(%rip), %rsi     # 0x36881
pushq $0x1
popq %rdx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xdd84
movq 0x8(%r14), %rdx
leaq 0x25a45(%rip), %rsi     # 0x36dc8
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe064
movq 0x37c59(%rip), %rax     # 0x48ff8
movq (%rax), %rdi
leaq 0x25a24(%rip), %rsi     # 0x36dcd
xorl %eax, %eax
callq 0xc360
pushq $0x1
popq %rdi
callq 0xc5b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/examples/gff3validator.c
// Function: main
int main(int argc, const char *argv[])
{
  GtNodeStream *gff3_in_stream;
  GtGenomeNode *gn;
  GtError *err;
  int had_err;

  if (gt_version_check(GT_MAJOR_VERSION, GT_MINOR_VERSION, GT_MICRO_VERSION)) {
    fprintf(stderr, "error: %s\n", gt_version_check(GT_MAJOR_VERSION,
                                                    GT_MINOR_VERSION,
                                                    GT_MICRO_VERSION));
    return EXIT_FAILURE;
  }

  /* initialize */
  gt_lib_init();

  /* create error object */
  err = gt_error_new();

  /* create GFF3 input stream (with ID attribute checking) */
  gff3_in_stream = gt_gff3_in_stream_new_unsorted(argc-1, argv+1);
  gt_gff3_in_stream_check_id_attributes((GtGFF3InStream*) gff3_in_stream);

  /* pull the features through the stream and free them afterwards */
  while (!(had_err = gt_node_stream_next(gff3_in_stream, &gn, err)) && gn)
    gt_genome_node_delete(gn);

  /* handle error */
  if (had_err)
    fprintf(stderr, "%s: error: %s\n", argv[0], gt_error_get(err));
  else
    printf("input is valid GFF3\n");

  /* free */
  gt_node_stream_delete(gff3_in_stream);
  gt_error_delete(err);

  if (had_err)
    return EXIT_FAILURE;
  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %r15d
pushq $0x1
popq %rbp
pushq $0x6
popq %rdx
movl %ebp, %edi
movl %edx, %esi
callq 0x11d4c
testq %rax, %rax
jne 0x7baf
callq 0x7ee8
callq 0x7c0c
movq %rax, %rbx
decl %r15d
leaq 0x8(%r14), %rsi
movl %r15d, %edi
callq 0x13ed5
movq %rax, %r15
movq %rax, %rdi
callq 0x13af5
movq %rsp, %r13
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x1c1ee
movl %eax, %r12d
testl %eax, %eax
jne 0x7b74
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7b74
callq 0x1376f
jmp 0x7b4f
testl %r12d, %r12d
jne 0x7bdb
leaq 0x65493(%rip), %rdi     # 0x6d013
callq 0x77c0
xorl %ebp, %ebp
testl %r12d, %r12d
setne %bpl
movq %r15, %rdi
callq 0x1c147
movq %rbx, %rdi
callq 0x7ead
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x9c41a(%rip), %rax     # 0xa3fd0
movq (%rax), %rbx
pushq $0x6
popq %rdx
movl %ebp, %edi
movl %edx, %esi
callq 0x11d4c
leaq 0x6543c(%rip), %rsi     # 0x6d008
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x7710
jmp 0x7b9e
movq 0x9c3ee(%rip), %rax     # 0xa3fd0
movq (%rax), %r13
movq (%r14), %r14
movq %rbx, %rdi
callq 0x7da9
leaq 0x6540d(%rip), %rsi     # 0x6d004
movq %r13, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x7710
jmp 0x7b85
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/clee.c
// Function: clee_init
void clee_init() {
    tracing = false;
    list_init(&children);
    event_handlers.syscall_entry = NULL;
    event_handlers.syscall_exit = NULL;
    event_handlers.exited = NULL;
    event_handlers.terminated = NULL;
    event_handlers.continued = NULL;
    event_handlers.stopped = NULL;
    event_handlers.new_process = NULL;
    event_handlers.syscall_clone = NULL;
    event_handlers.syscall_fork = NULL;
    event_handlers.syscall_vfork = NULL;
    event_handlers.syscall_seccomp = NULL;
    event_handlers.successful_exec = NULL;
    if (signal(SIGTERM, clee_signal_handler) == SIG_ERR) {
        CLEE_ERROR;
    }
}

// Assembly:
pushq %rax
movb $0x0, 0x7e1c(%rip)      # 0xb110
leaq 0x7e1d(%rip), %rdi      # 0xb118
callq 0x3c60
andq $0x0, 0x7e88(%rip)      # 0xb190
andq $0x0, 0x7e88(%rip)      # 0xb198
andq $0x0, 0x7e88(%rip)      # 0xb1a0
andq $0x0, 0x7e88(%rip)      # 0xb1a8
andq $0x0, 0x7e88(%rip)      # 0xb1b0
andq $0x0, 0x7e88(%rip)      # 0xb1b8
andq $0x0, 0x7e88(%rip)      # 0xb1c0
andq $0x0, 0x7e88(%rip)      # 0xb1c8
andq $0x0, 0x7e88(%rip)      # 0xb1d0
andq $0x0, 0x7e88(%rip)      # 0xb1d8
andq $0x0, 0x7e88(%rip)      # 0xb1e0
andq $0x0, 0x7e88(%rip)      # 0xb1e8
leaq 0x7d7(%rip), %rsi       # 0x3b3e
pushq $0xf
popq %rdi
callq 0x3120
cmpq $-0x1, %rax
je 0x3377
popq %rax
retq
leaq 0x2ca2(%rip), %rdi      # 0x6020
leaq 0x2c9d(%rip), %rsi      # 0x6022
leaq 0x2c9d(%rip), %rcx      # 0x6029
pushq $0x2f
popq %rdx
callq 0x30c0
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/clee.c
// Function: clee_children_add
void clee_children_add(pid_t pid) {
    clee_tracee *new_tracee = malloc(sizeof(clee_tracee));
    if (new_tracee == NULL) {
        CLEE_ERROR;
    }
    new_tracee->pid = pid;
    list_append(&children, new_tracee);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
pushq $0x4
popq %rdi
callq 0x3160
testq %rax, %rax
je 0x357c
movl %ebx, (%rax)
leaq 0x7ba5(%rip), %rdi      # 0xb118
movq %rax, %rsi
popq %rbx
jmp 0x3e74
leaq 0x2a9d(%rip), %rdi      # 0x6020
leaq 0x2a98(%rip), %rsi      # 0x6022
leaq 0x2c09(%rip), %rcx      # 0x619a
movl $0x1af, %edx            # imm = 0x1AF
callq 0x30c0
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/clee.c
// Function: clee_children_lookup
clee_tracee *clee_children_lookup(pid_t pid) {
    clee_tracee *tracee;
    _Bool found = false;
    int i;
    int len = list_size(&children);
    for (i = 0; i < len; i++) {
        tracee = list_get_at(&children, i);
        if (tracee->pid == pid) {
            found = true;
            break;
        }
    }
    return (found ? tracee : NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
leaq 0x7872(%rip), %r15      # 0xb118
movq %r15, %rdi
callq 0x434e
movl %eax, %ebp
xorl %r14d, %r14d
testl %eax, %eax
cmovlel %r14d, %ebp
xorl %r12d, %r12d
cmpl %r12d, %ebp
je 0x38d6
movq %r15, %rdi
movl %r12d, %esi
callq 0x3fc4
incl %r12d
cmpl %ebx, (%rax)
jne 0x38bc
movq %rax, %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/clee.c
// Function: clee_children_delete
void clee_children_delete(pid_t pid) {
    clee_tracee *tracee = clee_children_lookup(pid);
    if (tracee == NULL) {
        CLEE_ERROR;
    }
    free(tracee);
    list_delete(&children, tracee);
}

// Assembly:
pushq %rbx
callq 0x3895
testq %rax, %rax
je 0x3908
movq %rax, %rbx
movq %rax, %rdi
callq 0x3030
leaq 0x7819(%rip), %rdi      # 0xb118
movq %rbx, %rsi
popq %rbx
jmp 0x415f
leaq 0x2711(%rip), %rdi      # 0x6020
leaq 0x270c(%rip), %rsi      # 0x6022
leaq 0x289b(%rip), %rcx      # 0x61b8
movl $0x1c7, %edx            # imm = 0x1C7
callq 0x30c0
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/clee.c
// Function: clee_syscall
void clee_syscall() {
    clee_syscall_regs_get();
    if (syscall_regs.rax == -ENOSYS) {
        if (event_handlers.syscall_entry != NULL) {
            (event_handlers.syscall_entry)();
        }
        clee_syscall_regs_set();
    } else {
        if (event_handlers.syscall_exit != NULL) {
            (event_handlers.syscall_exit)();
        }
    }
}

// Assembly:
pushq %rax
callq 0x3bc0
cmpq $-0x26, 0x792b(%rip)    # 0xb260
jne 0x394d
movq 0x7852(%rip), %rcx      # 0xb190
testq %rcx, %rcx
je 0x3947
xorl %eax, %eax
callq *%rcx
popq %rax
jmp 0x3c01
movq 0x7844(%rip), %rcx      # 0xb198
testq %rcx, %rcx
je 0x395e
xorl %eax, %eax
popq %rdx
jmpq *%rcx
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/clee.c
// Function: clee_read
ssize_t clee_read(void *src, void *dst, size_t len) {
    struct iovec remote = {src, len};
    struct iovec local = {dst, len};
    ssize_t readed;
    if ((readed = process_vm_readv(event_pid, &local, 1, &remote, 1, 0)) == -1) {
        CLEE_ERROR;
    }
    return readed;
}

// Assembly:
subq $0x28, %rsp
leaq 0x18(%rsp), %rcx
movq %rdi, (%rcx)
movq %rdx, 0x8(%rcx)
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movl 0x775f(%rip), %edi      # 0xb1f4
pushq $0x1
popq %rdx
movq %rax, %rsi
movq %rdx, %r8
xorl %r9d, %r9d
callq 0x3100
cmpq $-0x1, %rax
je 0x3ab1
addq $0x28, %rsp
retq
leaq 0x2568(%rip), %rdi      # 0x6020
leaq 0x2563(%rip), %rsi      # 0x6022
leaq 0x267f(%rip), %rcx      # 0x6145
movl $0x188, %edx            # imm = 0x188
callq 0x30c0
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/clee.c
// Function: clee_write
ssize_t clee_write(void *src, void *dst, size_t len) {
    struct iovec remote = {dst, len};
    struct iovec local = {src, len};
    ssize_t written;
    if ((written = process_vm_writev(event_pid, &local, 1, &remote, 1, 0)) == -1) {
        CLEE_ERROR;
    }
    return written;
}

// Assembly:
subq $0x28, %rsp
leaq 0x18(%rsp), %rcx
movq %rsi, (%rcx)
movq %rdx, 0x8(%rcx)
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
movq %rdx, 0x8(%rsi)
movl 0x7702(%rip), %edi      # 0xb1f4
pushq $0x1
popq %rdx
movq %rdx, %r8
xorl %r9d, %r9d
callq 0x31b0
cmpq $-0x1, %rax
je 0x3b0b
addq $0x28, %rsp
retq
leaq 0x250e(%rip), %rdi      # 0x6020
leaq 0x2509(%rip), %rsi      # 0x6022
leaq 0x264f(%rip), %rcx      # 0x616f
movl $0x192, %edx            # imm = 0x192
callq 0x30c0
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/clee.c
// Function: clee_kill
void clee_kill() {
    while (list_size(&children) > 0) {
        clee_tracee *tracee = list_get_at(&children, 0);
        kill(tracee->pid, 9);
        list_delete_at(&children, 0);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x75cb(%rip), %rbx      # 0xb118
pushq $0x9
popq %rbp
movq %rbx, %rdi
callq 0x434e
testl %eax, %eax
je 0x3b7b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3fc4
movl (%rax), %edi
movl %ebp, %esi
callq 0x3150
movq %rbx, %rdi
xorl %esi, %esi
callq 0x41d8
jmp 0x3b50
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/seojangho[P]clee/clee.c
// Function: clee_process_exists
_Bool clee_process_exists(pid_t pid) {
    int result = kill(pid, 0);
    if (result == 0) {
        return true;
    } else if (errno == ESRCH) {
        return false;
    } else {
        CLEE_ERROR;
    }
}

// Assembly:
pushq %rbx
xorl %esi, %esi
callq 0x3150
movl %eax, %ebx
testl %eax, %eax
je 0x3b9a
callq 0x3040
cmpl $0x3, (%rax)
jne 0x3ba1
testl %ebx, %ebx
sete %al
popq %rbx
retq
leaq 0x2478(%rip), %rdi      # 0x6020
leaq 0x2473(%rip), %rsi      # 0x6022
leaq 0x2623(%rip), %rcx      # 0x61d9
movl $0x1d4, %edx            # imm = 0x1D4
callq 0x30c0