LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0xdb972
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %esi
leaq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq *%rax
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xdd050
movq %rax, -0x38(%rbp)
cmpq $-0x1, -0x38(%rbp)
je 0xdb9d6
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xdba14
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xdd050
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ckh.c
// Function: ckh_shrink
static void
ckh_shrink(ckh_t *ckh)
{
	ckhc_t *tab, *ttab;
	size_t lg_curcells, usize;
	unsigned lg_prevbuckets;

	/*
	 * It is possible (though unlikely, given well behaved hashes) that the
	 * table rebuild will fail.
	 */
	lg_prevbuckets = ckh->lg_curbuckets;
	lg_curcells = ckh->lg_curbuckets + LG_CKH_BUCKET_CELLS - 1;
	usize = sa2u(sizeof(ckhc_t) << lg_curcells, CACHELINE);
	if (usize == 0)
		return;
	tab = (ckhc_t *)ipalloc(usize, CACHELINE, true);
	if (tab == NULL) {
		/*
		 * An OOM error isn't worth propagating, since it doesn't
		 * prevent this or future operations from proceeding.
		 */
		return;
	}
	/* Swap in new table. */
	ttab = ckh->tab;
	ckh->tab = tab;
	tab = ttab;
	ckh->lg_curbuckets = lg_curcells - LG_CKH_BUCKET_CELLS;

	if (ckh_rebuild(ckh, tab) == false) {
		idalloc(tab);
#ifdef CKH_COUNT
		ckh->nshrinks++;
#endif
		return;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
addl $0x2, %eax
subl $0x1, %eax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movl $0x10, %edi
shlq %cl, %rdi
movl $0x40, %esi
callq 0xdb2e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xdba6f
jmp 0xdbb05
movq -0x28(%rbp), %rdi
movl $0x40, %esi
movl $0x1, %edx
callq 0xdb440
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xdba8f
jmp 0xdbb05
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
subq $0x2, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xdcf70
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xdbae2
movq -0x10(%rbp), %rdi
callq 0xdb4b0
jmp 0xdbb05
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xdb4b0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x2c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/deps/jemalloc/src/ckh.c
// Function: ckh_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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0xdbbb9
jmp 0xdbbbb
jmp 0xdbbbd
jmp 0xdbbbf
jmp 0xdbbc1
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1f4d0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movabsq $-0x6bedd0cca4ccd516, %rdx # imm = 0x94122F335B332AEA
callq 0xdbc70
movq %rax, -0x38(%rbp)
cmpl $0x20, -0xc(%rbp)
ja 0xdbc12
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x30(%rbp)
jmp 0xdbc45
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1f4d0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movabsq $-0x7bcd5b89999443ed, %rdx # imm = 0x8432A476666BBC13
callq 0xdbc70
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0xdbea9
jmp 0xdbeab
jmp 0xdbead
jmp 0xdbeaf
jmp 0xdbeb1
jmp 0xdbeb3
jmp 0xdbeb5
movq $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x8, %esi
movabsq $-0x267cc69197779f7e, %rdx # imm = 0xD983396E68886082
callq 0xdbc70
movq %rax, -0x38(%rbp)
cmpl $0x20, -0xc(%rbp)
ja 0xdbf07
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x30(%rbp)
jmp 0xdbf2f
jmp 0xdbf09
jmp 0xdbf0b
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x8, %esi
movabsq $0x5e2be9aff8709a5d, %rdx # imm = 0x5E2BE9AFF8709A5D
callq 0xdbc70
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movb %dl, %cl
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jge 0x197b
movsbl -0x11(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x20(%rbp)
jmp 0x1982
movsbl -0x11(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movb %al, -0x11(%rbp)
movsbl -0x12(%rbp), %eax
cmpl $0x0, %eax
jle 0x199e
movsbl -0x12(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0x19a5
movsbl -0x12(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movb %al, -0x12(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1a32
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1a0f
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x19e4
movsbl -0x11(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x19eb
movsbl -0x12(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
imull -0x4(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x19c6
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
imull -0x4(%rbp), %ecx
addl -0x4(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x19b2
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1a64
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
imull -0x4(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1a39
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpq $0x0, 0x84c05(%rip)     # 0x96cc8
je 0x120cf
cmpl $0x0, -0x8(%rbp)
je 0x121fb
cmpq $0x0, 0x84bf1(%rip)     # 0x96cc8
je 0x120e5
movq 0x84be8(%rip), %rdi     # 0x96cc8
callq 0x17ec0
cmpq $0x0, 0x84adb(%rip)     # 0x96bc8
jne 0x1210a
movq 0x84ac2(%rip), %rdi     # 0x96bb8
movl 0x84ac4(%rip), %esi     # 0x96bc0
callq 0x17f80
movq %rax, 0x84bc0(%rip)     # 0x96cc8
jmp 0x1211d
movq 0x84ab7(%rip), %rdi     # 0x96bc8
callq 0x181b0
movq %rax, 0x84bab(%rip)     # 0x96cc8
movq 0x84ba4(%rip), %rax     # 0x96cc8
cmpl $0x0, (%rax)
je 0x121cb
movq 0x83ebc(%rip), %rax     # 0x95ff0
movq (%rax), %rdi
leaq 0x717e4(%rip), %rsi     # 0x83922
movb $0x0, %al
callq 0xc320
cmpq $0x0, 0x84a7b(%rip)     # 0x96bc8
jne 0x12181
movq 0x83e9a(%rip), %rax     # 0x95ff0
movq (%rax), %rdi
movq 0x84a58(%rip), %rdx     # 0x96bb8
movl 0x84a5a(%rip), %ecx     # 0x96bc0
movq 0x84b5b(%rip), %r8      # 0x96cc8
addq $0x4, %r8
leaq 0x717ca(%rip), %rsi     # 0x83942
movb $0x0, %al
callq 0xc320
jmp 0x121ab
movq 0x83e68(%rip), %rax     # 0x95ff0
movq (%rax), %rdi
movq 0x84a36(%rip), %rdx     # 0x96bc8
movq 0x84b2f(%rip), %rcx     # 0x96cc8
addq $0x4, %rcx
leaq 0x717a9(%rip), %rsi     # 0x8394d
movb $0x0, %al
callq 0xc320
movq 0x84b16(%rip), %rdi     # 0x96cc8
callq 0x17ec0
movq $0x0, 0x84b06(%rip) # 0x96cc8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12202
movq 0x84af6(%rip), %rax     # 0x96cc8
movl 0x84(%rax), %esi
xorl %eax, %eax
movl %eax, %edi
movl $0xf, %edx
callq 0xc990
callq 0x13570
cmpl $0x0, %eax
je 0x121f9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12202
jmp 0x121fb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/discnt-cli.c
// Function: noninteractive
static int noninteractive(int argc, char **argv) {
    int retval = 0;
    if (config.stdinarg) {
        argv = zrealloc(argv, (argc+1)*sizeof(char*));
        argv[argc] = readArgFromStdin();
        retval = cliSendCommand(argc+1, argv, config.repeat);
    } else {
        /* stdin is probably a tty, can be tested with S_ISCHR(s.st_mode) */
        retval = cliSendCommand(argc, argv, config.repeat);
    }
    return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, 0x8388f(%rip)     # 0x96c0c
je 0x133ca
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x14bf0
movq %rax, -0x10(%rbp)
callq 0x149b0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %edi
addl $0x1, %edi
movq -0x10(%rbp), %rsi
movq 0x83812(%rip), %rax     # 0x96bd0
movl %eax, %edx
callq 0x13b20
movl %eax, -0x14(%rbp)
jmp 0x133e2
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq 0x837f8(%rip), %rax     # 0x96bd0
movl %eax, %edx
callq 0x13b20
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xe410
movq %rax, %rdi
leaq 0x6eb6b(%rip), %rsi     # 0x82032
leaq 0x6f647(%rip), %rdx     # 0x82b15
movb $0x0, %al
callq 0xf4d0
movq %rax, -0x8(%rbp)
callq 0x152f0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0xc310
cmpq $0x0, %rax
je 0x13561
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x152f0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x70402(%rip), %rsi     # 0x83912
movb $0x0, %al
callq 0xf4d0
movq %rax, -0x8(%rbp)
callq 0x15300
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0xc310
cmpq $0x0, %rax
je 0x1354d
movq -0x8(%rbp), %rdi
leaq 0x703d9(%rip), %rsi     # 0x8391b
movb $0x0, %al
callq 0xf4d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x6efaf(%rip), %rsi     # 0x82507
callq 0xeff0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/discnt-cli.c
// Function: cliAuth
static int cliAuth() {
    redisReply *reply;
    if (config.auth == NULL) return REDIS_OK;

    reply = redisCommand(context,"AUTH %s",config.auth);
    if (reply != NULL) {
        freeReplyObject(reply);
        return REDIS_OK;
    }
    return REDIS_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x83690(%rip)     # 0x96c10
jne 0x1358b
movl $0x0, -0x4(%rbp)
jmp 0x135cb
movq 0x83736(%rip), %rdi     # 0x96cc8
movq 0x83677(%rip), %rdx     # 0x96c10
leaq 0x703b5(%rip), %rsi     # 0x83955
movb $0x0, %al
callq 0x18b20
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x135c4
movq -0x10(%rbp), %rdi
callq 0x165c0
movl $0x0, -0x4(%rbp)
jmp 0x135cb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/discnt-cli.c
// Function: reconnectingInfo
static redisReply *reconnectingInfo(void) {
    redisContext *c = context;
    redisReply *reply = NULL;
    int tries = 0;

    assert(!c->err);
    while(reply == NULL) {
        while (c->err & (REDIS_ERR_IO | REDIS_ERR_EOF)) {
            printf("Reconnecting (%d)...\r", ++tries);
            fflush(stdout);

            redisFree(c);
            c = redisConnect(config.hostip,config.hostport);
            usleep(1000000);
        }

        reply = redisCommand(c,"INFO");
        if (c->err && !(c->err & (REDIS_ERR_IO | REDIS_ERR_EOF))) {
            fprintf(stderr, "Error: %s\n", c->errstr);
            exit(1);
        } else if (tries > 0) {
            printf("\n");
        }
    }

    context = c;
    return reply;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x83679(%rip), %rax     # 0x96cc8
movq %rax, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x1366d
jmp 0x1368c
leaq 0x705e0(%rip), %rdi     # 0x83c54
leaq 0x705e1(%rip), %rsi     # 0x83c5c
movl $0x258, %edx            # imm = 0x258
leaq 0x705e2(%rip), %rcx     # 0x83c69
callq 0xc210
jmp 0x1368e
cmpq $0x0, -0x10(%rbp)
jne 0x1376c
jmp 0x1369b
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x136fa
movl -0x14(%rbp), %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
leaq 0x705d3(%rip), %rdi     # 0x83c8c
movb $0x0, %al
callq 0xc1c0
movq 0x828f9(%rip), %rax     # 0x95fc0
movq (%rax), %rdi
callq 0xc3e0
movq -0x8(%rbp), %rdi
callq 0x17ec0
movq 0x834d9(%rip), %rdi     # 0x96bb8
movl 0x834db(%rip), %esi     # 0x96bc0
callq 0x17f80
movq %rax, -0x8(%rbp)
movl $0xf4240, %edi          # imm = 0xF4240
callq 0xc670
jmp 0x1369b
movq -0x8(%rbp), %rdi
leaq 0x6f245(%rip), %rsi     # 0x8294a
movb $0x0, %al
callq 0x18b20
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x13751
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x13751
movq 0x828c2(%rip), %rax     # 0x95ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
addq $0x4, %rdx
leaq 0x70562(%rip), %rsi     # 0x83ca2
movb $0x0, %al
callq 0xc320
movl $0x1, %edi
callq 0xc590
cmpl $0x0, -0x14(%rbp)
jle 0x13765
leaq 0x701b2(%rip), %rdi     # 0x83910
movb $0x0, %al
callq 0xc1c0
jmp 0x13767
jmp 0x1368e
movq -0x8(%rbp), %rax
movq %rax, 0x83551(%rip)     # 0x96cc8
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x83158(%rip)     # 0x96bc8
je 0x13a9c
movq 0x8314f(%rip), %rcx     # 0x96bc8
leaq 0x83138(%rip), %rdi     # 0x96bb8
addq $0x70, %rdi
movl $0x80, %esi
leaq 0x7032f(%rip), %rdx     # 0x83dbf
movb $0x0, %al
callq 0xc1d0
movl %eax, -0x4(%rbp)
jmp 0x13aee
movq 0x83115(%rip), %rdi     # 0x96bb8
movl $0x3a, %esi
callq 0xc1b0
movq %rax, %rcx
leaq 0x6e645(%rip), %rdx     # 0x820fc
leaq 0x6e636(%rip), %rax     # 0x820f4
cmpq $0x0, %rcx
cmovneq %rax, %rdx
movq 0x830eb(%rip), %rcx     # 0x96bb8
movl 0x830ec(%rip), %r8d     # 0x96bc0
leaq 0x830dd(%rip), %rdi     # 0x96bb8
addq $0x70, %rdi
movl $0x80, %esi
movb $0x0, %al
callq 0xc1d0
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rax
leaq 0x830bf(%rip), %rdi     # 0x96bb8
addq $0x70, %rdi
addq %rax, %rdi
movslq -0x4(%rbp), %rax
movl $0x80, %esi
subq %rax, %rsi
leaq 0x7026d(%rip), %rdx     # 0x83d80
movb $0x0, %al
callq 0xc1d0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/discnt-cli.c
// Function: cliOutputGenericHelp
static void cliOutputGenericHelp(void) {
    sds version = cliVersion();
    printf(
        "discnt %s\r\n"
        "Type: \"help @<group>\" to get a list of commands in <group>\r\n"
        "      \"help <command>\" for help on <command>\r\n"
        "      \"help <tab>\" to get a list of possible help topics\r\n"
        "      \"quit\" to exit\r\n",
        version
    );
    sdsfree(version);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x134b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x6fb96(%rip), %rdi     # 0x83e62
movb $0x0, %al
callq 0xc1c0
movq -0x8(%rbp), %rdi
callq 0xe540
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
callq 0xe410
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x5, %eax
ja 0x144d8
movq -0x28(%rbp), %rax
leaq 0x6e1b9(%rip), %rcx     # 0x82570
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x14500
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rdx
callq 0xef60
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6f523(%rip), %rsi     # 0x83910
movl $0x1, %edx
callq 0xef60
movq %rax, -0x10(%rbp)
jmp 0x14500
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rdx
callq 0xef60
movq %rax, -0x10(%rbp)
jmp 0x14500
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x6fb57(%rip), %rsi     # 0x83f8c
movb $0x0, %al
callq 0xf4d0
movq %rax, -0x10(%rbp)
jmp 0x14500
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x144d6
cmpq $0x0, -0x20(%rbp)
jbe 0x14476
movq -0x10(%rbp), %rdi
movq 0x827b3(%rip), %rsi     # 0x96c20
callq 0xeff0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x14380
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x14070
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0xef60
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe540
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1444d
jmp 0x14500
movq 0x81b11(%rip), %rax     # 0x95ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %edx
leaq 0x6faa2(%rip), %rsi     # 0x83f91
movb $0x0, %al
callq 0xc320
movl $0x1, %edi
callq 0xc590
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/deps/linenoise/linenoise.c
// Function: linenoiseRaw
static int linenoiseRaw(char *buf, size_t buflen, const char *prompt) {
    int count;

    if (buflen == 0) {
        errno = EINVAL;
        return -1;
    }
    if (!isatty(STDIN_FILENO)) {
        /* Not a tty: read from file / pipe. */
        if (fgets(buf, buflen, stdin) == NULL) return -1;
        count = strlen(buf);
        if (count && buf[count-1] == '\n') {
            count--;
            buf[count] = '\0';
        }
    } else {
        /* Interactive editing. */
        if (enableRawMode(STDIN_FILENO) == -1) return -1;
        count = linenoiseEdit(STDIN_FILENO, STDOUT_FILENO, buf, buflen, prompt);
        disableRawMode(STDIN_FILENO);
        printf("\n");
    }
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1b732
callq 0xc080
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1b7f3
xorl %edi, %edi
callq 0xc0d0
cmpl $0x0, %eax
jne 0x1b7a8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %esi
movq 0x7a879(%rip), %rax     # 0x95fc8
movq (%rax), %rdx
callq 0xc2c0
cmpq $0x0, %rax
jne 0x1b769
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1b7f3
movq -0x10(%rbp), %rdi
callq 0xc190
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x1b7a6
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x1b7a6
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x1b7ed
xorl %edi, %edi
callq 0x1b3e0
cmpl $-0x1, %eax
jne 0x1b7bd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1b7f3
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
xorl %edi, %edi
movl $0x1, %esi
callq 0x1c2c0
movl %eax, -0x24(%rbp)
xorl %edi, %edi
callq 0x1b4c0
leaq 0x6812a(%rip), %rdi     # 0x83910
movb $0x0, %al
callq 0xc1c0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movl $0x0, 0x54(%rsp)
movl %edi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl $0x1, %edi
movl $0x6, %edx
movl %edx, %esi
callq 0x18050
cmpq $0x0, %rax
je 0x7b3f
movq 0xf14d5(%rip), %rax     # 0xf8fd8
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movl $0x1, %edi
movl $0x6, %edx
movl %edx, %esi
callq 0x18050
movq 0x20(%rsp), %rdi
movq %rax, %rdx
leaq 0xbf4dd(%rip), %rsi     # 0xc7008
movb $0x0, %al
callq 0x76e0
movl $0x1, 0x54(%rsp)
jmp 0x7c3f
callq 0x8080
callq 0x7c50
movq %rax, 0x30(%rsp)
movl 0x50(%rsp), %edi
subl $0x1, %edi
movq 0x48(%rsp), %rsi
addq $0x8, %rsi
callq 0x1b340
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x1ae10
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rdx
leaq 0x38(%rsp), %rsi
callq 0x28210
movl %eax, %ecx
movl %ecx, 0x2c(%rsp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x1f(%rsp)
jne 0x7ba4
cmpq $0x0, 0x38(%rsp)
setne %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x7bae
jmp 0x7bba
movq 0x38(%rsp), %rdi
callq 0x1a930
jmp 0x7b72
cmpl $0x0, 0x2c(%rsp)
je 0x7c04
movq 0xf1410(%rip), %rax     # 0xf8fd8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x7ed0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0xbf409(%rip), %rsi     # 0xc7004
movb $0x0, %al
callq 0x76e0
jmp 0x7c12
leaq 0xbf408(%rip), %rdi     # 0xc7013
movb $0x0, %al
callq 0x7060
movq 0x40(%rsp), %rdi
callq 0x28130
movq 0x30(%rsp), %rdi
callq 0x8030
cmpl $0x0, 0x2c(%rsp)
je 0x7c37
movl $0x1, 0x54(%rsp)
jmp 0x7c3f
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movb $0x0, 0x8dfd(%rip)      # 0xc138
leaq 0x8dfe(%rip), %rdi      # 0xc140
callq 0x43b0
movq $0x0, 0x8e66(%rip) # 0xc1b8
movq $0x0, 0x8e63(%rip) # 0xc1c0
movq $0x0, 0x8e60(%rip) # 0xc1c8
movq $0x0, 0x8e5d(%rip) # 0xc1d0
movq $0x0, 0x8e5a(%rip) # 0xc1d8
movq $0x0, 0x8e57(%rip) # 0xc1e0
movq $0x0, 0x8e54(%rip) # 0xc1e8
movq $0x0, 0x8e51(%rip) # 0xc1f0
movq $0x0, 0x8e4e(%rip) # 0xc1f8
movq $0x0, 0x8e4b(%rip) # 0xc200
movq $0x0, 0x8e48(%rip) # 0xc208
movq $0x0, 0x8e45(%rip) # 0xc210
movl $0xf, %edi
leaq 0xe09(%rip), %rsi       # 0x41e0
callq 0x3140
movq $-0x1, %rcx
cmpq %rcx, %rax
jne 0x3407
leaq 0x4cb9(%rip), %rdi      # 0x80a8
leaq 0x4cb4(%rip), %rsi      # 0x80aa
movl $0x2f, %edx
leaq 0x4caf(%rip), %rcx      # 0x80b1
callq 0x30c0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x4, %edi
callq 0x3180
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x365f
leaq 0x4a61(%rip), %rdi      # 0x80a8
leaq 0x4a5c(%rip), %rsi      # 0x80aa
movl $0x1af, %edx            # imm = 0x1AF
leaq 0x4bc8(%rip), %rcx      # 0x8222
callq 0x30c0
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rsi
leaq 0x8acd(%rip), %rdi      # 0xc140
callq 0x4940
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/seojangho[P]clee/clee.c
// Function: clee_behavior2request
enum __ptrace_request clee_behavior2request(clee_behavior behavior) {
    switch (behavior) {
        case interrupt:
            return PTRACE_INTERRUPT;
        case detach:
            return PTRACE_DETACH;
        case next:
            return PTRACE_CONT;
        case next_syscall:
            return PTRACE_SYSCALL;
        case next_step:
            return PTRACE_SINGLESTEP;
        defalt:
            CLEE_ERROR;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x4, %eax
ja 0x36d6
movq -0x10(%rbp), %rax
leaq 0x4962(%rip), %rcx      # 0x8004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4207, -0x4(%rbp)     # imm = 0x4207
jmp 0x36d6
movl $0x11, -0x4(%rbp)
jmp 0x36d6
movl $0x7, -0x4(%rbp)
jmp 0x36d6
movl $0x18, -0x4(%rbp)
jmp 0x36d6
movl $0x9, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movb $0x0, -0x11(%rbp)
leaq 0x86ca(%rip), %rdi      # 0xc140
callq 0x5430
movl %eax, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3abe
movl -0x18(%rbp), %esi
leaq 0x86a9(%rip), %rdi      # 0xc140
callq 0x4c20
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x3ab1
movb $0x1, -0x11(%rbp)
jmp 0x3abe
jmp 0x3ab3
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3a85
testb $0x1, -0x11(%rbp)
je 0x3ace
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x3ad6
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x3ad6
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x3a60
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3b1d
leaq 0x45a3(%rip), %rdi      # 0x80a8
leaq 0x459e(%rip), %rsi      # 0x80aa
movl $0x1c7, %edx            # imm = 0x1C7
leaq 0x4728(%rip), %rcx      # 0x8240
callq 0x30c0
movq -0x10(%rbp), %rdi
callq 0x3030
movq -0x10(%rbp), %rsi
leaq 0x860f(%rip), %rdi      # 0xc140
callq 0x5020
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
callq 0x42c0
cmpq $-0x26, 0x8737(%rip)    # 0xc288
jne 0x3b6c
cmpq $0x0, 0x865d(%rip)      # 0xc1b8
je 0x3b65
movb $0x0, %al
callq *0x8653(%rip)           # 0xc1b8
callq 0x4310
jmp 0x3b80
cmpq $0x0, 0x864c(%rip)      # 0xc1c0
je 0x3b7e
movb $0x0, %al
callq *0x8642(%rip)           # 0xc1c0
jmp 0x3b80
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/seojangho[P]clee/clee.c
// Function: clee_get_arg
reg clee_get_arg(int n) {
    switch (n) {
        case 0:
            return syscall_regs.rdi;
        case 1:
            return syscall_regs.rsi;
        case 2:
            return syscall_regs.rdx;
        case 3:
            return syscall_regs.r10;
        case 4:
            return syscall_regs.r8;
        case 5:
            return syscall_regs.r9;
        default:
            CLEE_ERROR;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0x3c8a
movq -0x18(%rbp), %rax
leaq 0x43e5(%rip), %rcx      # 0x8018
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8665(%rip), %rax      # 0xc2a8
movq %rax, -0x8(%rbp)
jmp 0x3ca9
movq 0x8650(%rip), %rax      # 0xc2a0
movq %rax, -0x8(%rbp)
jmp 0x3ca9
movq 0x863b(%rip), %rax      # 0xc298
movq %rax, -0x8(%rbp)
jmp 0x3ca9
movq 0x8606(%rip), %rax      # 0xc270
movq %rax, -0x8(%rbp)
jmp 0x3ca9
movq 0x8609(%rip), %rax      # 0xc280
movq %rax, -0x8(%rbp)
jmp 0x3ca9
movq 0x85f4(%rip), %rax      # 0xc278
movq %rax, -0x8(%rbp)
jmp 0x3ca9
leaq 0x4417(%rip), %rdi      # 0x80a8
leaq 0x4412(%rip), %rsi      # 0x80aa
movl $0x10b, %edx            # imm = 0x10B
leaq 0x449b(%rip), %rcx      # 0x813f
callq 0x30c0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/seojangho[P]clee/clee.c
// Function: clee_set_arg
void clee_set_arg(int n, reg value) {
    switch (n) {
        case 0:
            syscall_regs.rdi = value;
            return;
        case 1:
            syscall_regs.rsi = value;
            return;
        case 2:
            syscall_regs.rdx = value;
            return;
        case 3:
            syscall_regs.r10 = value;
            return;
        case 4:
            syscall_regs.r8 = value;
            return;
        case 5:
            syscall_regs.r9 = value;
            return;
        default:
            CLEE_ERROR;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0x3d3e
movq -0x18(%rbp), %rax
leaq 0x4349(%rip), %rcx      # 0x8030
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq %rax, 0x85ad(%rip)      # 0xc2a8
jmp 0x3d5d
movq -0x10(%rbp), %rax
movq %rax, 0x8598(%rip)      # 0xc2a0
jmp 0x3d5d
movq -0x10(%rbp), %rax
movq %rax, 0x8583(%rip)      # 0xc298
jmp 0x3d5d
movq -0x10(%rbp), %rax
movq %rax, 0x854e(%rip)      # 0xc270
jmp 0x3d5d
movq -0x10(%rbp), %rax
movq %rax, 0x8551(%rip)      # 0xc280
jmp 0x3d5d
movq -0x10(%rbp), %rax
movq %rax, 0x853c(%rip)      # 0xc278
jmp 0x3d5d
leaq 0x4363(%rip), %rdi      # 0x80a8
leaq 0x435e(%rip), %rsi      # 0x80aa
movl $0x124, %edx            # imm = 0x124
leaq 0x43fd(%rip), %rcx      # 0x8155
callq 0x30c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/seojangho[P]clee/clee.c
// Function: clee_get_trigger
void (*clee_get_trigger(clee_events ev))() {
    switch (ev) {
        case syscall_entry:
            return event_handlers.syscall_entry;
        case syscall_exit:
            return event_handlers.syscall_exit;
        case exited:
            return event_handlers.exited;
        case terminated:
            return event_handlers.terminated;
        case continued:
            return event_handlers.continued;
        case stopped:
            return event_handlers.stopped;
        case new_process:
            return event_handlers.new_process;
        case syscall_clone:
            return event_handlers.syscall_clone;
        case syscall_fork:
            return event_handlers.syscall_fork;
        case syscall_vfork:
            return event_handlers.syscall_vfork;
        case syscall_seccomp:
            return event_handlers.syscall_seccomp;
        case successful_exec:
            return event_handlers.successful_exec;
        default:
            CLEE_ERROR;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xb, %rax
ja 0x4058
movq -0x18(%rbp), %rax
leaq 0x40d1(%rip), %rcx      # 0x8078
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8201(%rip), %rax      # 0xc1b8
movq %rax, -0x8(%rbp)
jmp 0x4077
movq 0x81f9(%rip), %rax      # 0xc1c0
movq %rax, -0x8(%rbp)
jmp 0x4077
movq 0x81f1(%rip), %rax      # 0xc1c8
movq %rax, -0x8(%rbp)
jmp 0x4077
movq 0x81e9(%rip), %rax      # 0xc1d0
movq %rax, -0x8(%rbp)
jmp 0x4077
movq 0x81e1(%rip), %rax      # 0xc1d8
movq %rax, -0x8(%rbp)
jmp 0x4077
movq 0x81dc(%rip), %rax      # 0xc1e0
movq %rax, -0x8(%rbp)
jmp 0x4077
movq 0x81d7(%rip), %rax      # 0xc1e8
movq %rax, -0x8(%rbp)
jmp 0x4077
movq 0x81d2(%rip), %rax      # 0xc1f0
movq %rax, -0x8(%rbp)
jmp 0x4077
movq 0x81cd(%rip), %rax      # 0xc1f8
movq %rax, -0x8(%rbp)
jmp 0x4077
movq 0x81c8(%rip), %rax      # 0xc200
movq %rax, -0x8(%rbp)
jmp 0x4077
movq 0x81c3(%rip), %rax      # 0xc208
movq %rax, -0x8(%rbp)
jmp 0x4077
movq 0x81be(%rip), %rax      # 0xc210
movq %rax, -0x8(%rbp)
jmp 0x4077
leaq 0x4049(%rip), %rdi      # 0x80a8
leaq 0x4044(%rip), %rsi      # 0x80aa
movl $0x17f, %edx            # imm = 0x17F
leaq 0x4133(%rip), %rcx      # 0x81a5
callq 0x30c0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x8152(%rip), %edi      # 0xc21c
leaq -0x38(%rbp), %rsi
movl $0x1, %r8d
leaq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r9d
movq %r8, %rdx
callq 0x3120
movq %rax, -0x40(%rbp)
cmpq $-0x1, %rax
jne 0x410e
leaq 0x3fb2(%rip), %rdi      # 0x80a8
leaq 0x3fad(%rip), %rsi      # 0x80aa
movl $0x188, %edx            # imm = 0x188
leaq 0x40c4(%rip), %rcx      # 0x81cd
callq 0x30c0
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x80c2(%rip), %edi      # 0xc21c
leaq -0x38(%rbp), %rsi
movl $0x1, %r8d
leaq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r9d
movq %r8, %rdx
callq 0x31e0
movq %rax, -0x40(%rbp)
cmpq $-0x1, %rax
jne 0x419e
leaq 0x3f22(%rip), %rdi      # 0x80a8
leaq 0x3f1d(%rip), %rsi      # 0x80aa
movl $0x192, %edx            # imm = 0x192
leaq 0x405e(%rip), %rcx      # 0x81f7
callq 0x30c0
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x7f31(%rip), %rdi      # 0xc140
callq 0x5430
cmpl $0x0, %eax
jbe 0x424b
leaq 0x7f20(%rip), %rdi      # 0xc140
xorl %esi, %esi
callq 0x4c20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
movl $0x9, %esi
callq 0x3170
leaq 0x7efe(%rip), %rdi      # 0xc140
xorl %esi, %esi
callq 0x5170
jmp 0x4208
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
xorl %esi, %esi
callq 0x3170
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x4284
movb $0x1, -0x1(%rbp)
jmp 0x42b3
callq 0x3040
cmpl $0x3, (%rax)
jne 0x4294
movb $0x0, -0x1(%rbp)
jmp 0x42b3
leaq 0x3e0d(%rip), %rdi      # 0x80a8
leaq 0x3e08(%rip), %rsi      # 0x80aa
movl $0x1d4, %edx            # imm = 0x1D4
leaq 0x3fb3(%rip), %rcx      # 0x8261
callq 0x30c0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/seojangho[P]clee/simclist.c
// Function: list_init
int list_init(list_t *restrict l) {
    if (l == NULL) return -1;

    seed_random();

    l->numels = 0;

    /* head/tail sentinels and mid pointer */
    l->head_sentinel = (struct list_entry_s *)malloc(sizeof(struct list_entry_s));
    l->tail_sentinel = (struct list_entry_s *)malloc(sizeof(struct list_entry_s));
    l->head_sentinel->next = l->tail_sentinel;
    l->tail_sentinel->prev = l->head_sentinel;
    l->head_sentinel->prev = l->tail_sentinel->next = l->mid = NULL;
    l->head_sentinel->data = l->tail_sentinel->data = NULL;

    /* iteration attributes */
    l->iter_active = 0;
    l->iter_pos = 0;
    l->iter_curentry = NULL;

    /* free-list attributes */
    l->spareels = (struct list_entry_s **)malloc(SIMCLIST_MAX_SPARE_ELEMS * sizeof(struct list_entry_s *));
    l->spareelsnum = 0;

#ifdef SIMCLIST_WITH_THREADS
    l->threadcount = 0;
#endif

    list_attributes_setdefaults(l);

    assert(list_repOk(l));
    assert(list_attrOk(l));

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x43cf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x44c3
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movl $0x18, %edi
callq 0x3180
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x18, %edi
callq 0x3180
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movl $0x28, %edi
callq 0x3180
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x10(%rbp), %rdi
callq 0x44d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/seojangho[P]clee/simclist.c
// Function: list_attributes_setdefaults
int list_attributes_setdefaults(list_t *restrict l) {
    l->attrs.comparator = NULL;
    l->attrs.seeker = NULL;

    /* also free() element data when removing and element from the list */
    l->attrs.meter = NULL;
    l->attrs.copy_data = 0;

    l->attrs.hasher = NULL;

    /* serializer/unserializer */
    l->attrs.serializer = NULL;
    l->attrs.unserializer = NULL;

    assert(list_attrOk(l));
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x70(%rax)
xorl %eax, %eax
popq %rbp
retq
nop