LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/prof.c
// Function: prof_tdata_expire
static bool
prof_tdata_expire(tsdn_t *tsdn, prof_tdata_t *tdata)
{
	bool destroy_tdata;

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

	return (destroy_tdata);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x673d0
movq -0x10(%rbp), %rax
testb $0x1, 0x21(%rax)
jne 0x7134a
movq -0x10(%rbp), %rax
movb $0x1, 0x21(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x71323
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x7133a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x6c450
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x7134e
movb $0x0, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x68140
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/include/jemalloc/internal/hash.h
// Function: je_hash_get_block_64
JEMALLOC_INLINE uint64_t
hash_get_block_64(const uint64_t *p, int i)
{

	/* Handle unaligned read. */
	if (unlikely((uintptr_t)p & (sizeof(uint64_t)-1)) != 0) {
		uint64_t ret;

		memcpy(&ret, (uint8_t *)(p + i), sizeof(uint64_t));
		return (ret);
	}

	return (p[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x72605
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x72615
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/tcache.c
// Function: je_tcache_alloc_small_hard
void *
tcache_alloc_small_hard(tsdn_t *tsdn, arena_t *arena, tcache_t *tcache,
    tcache_bin_t *tbin, szind_t binind, bool *tcache_success)
{
	void *ret;

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

	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
movl %r8d, -0x44(%rbp)
movq %r9, -0x50(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdx
movl -0x44(%rbp), %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0x3c650
movq -0x40(%rbp), %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
sete %al
testb $0x1, %al
jne 0x7f57a
jmp 0x7f596
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x7f5f5
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, %edx
xorl %ecx, %ecx
subq %rdx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
setl %al
testb $0x1, %al
jne 0x7f5df
jmp 0x7f5ed
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/tcache.c
// Function: tcache_arena_dissociate
static void
tcache_arena_dissociate(tsdn_t *tsdn, tcache_t *tcache, arena_t *arena)
{

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x7f660
movq -0x18(%rbp), %rax
movq 0xe0(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x7f76f
movq -0x18(%rbp), %rax
movq 0xe0(%rax), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xe0(%rax)
movq -0x18(%rbp), %rax
movq 0xe0(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x7f7c0
jmp 0x7f782
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x7f7cf
movq -0x18(%rbp), %rax
movq $0x0, 0xe0(%rax)
jmp 0x7f7d1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x817f0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x7f6b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/tcache.c
// Function: tcache_arena_associate
static void
tcache_arena_associate(tsdn_t *tsdn, tcache_t *tcache, arena_t *arena)
{

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x7f660
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x7f83e
movq -0x18(%rbp), %rax
cmpq $0x0, 0xe0(%rax)
je 0x7f89b
jmp 0x7f84e
movq -0x18(%rbp), %rax
movq 0xe0(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0xe0(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0xe0(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x7f89b
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xe0(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x7f6b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/tcache.c
// Function: je_tcache_stats_merge
void
tcache_stats_merge(tsdn_t *tsdn, tcache_t *tcache, arena_t *arena)
{
	unsigned i;

	cassert(config_stats);

	malloc_mutex_assert_owner(tsdn, &arena->lock);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x81806
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x81930
movl $0x0, -0x1c(%rbp)
cmpl $0x27, -0x1c(%rbp)
jae 0x81898
movq -0x18(%rbp), %rax
addq $0x980, %rax            # imm = 0x980
movl -0x1c(%rbp), %ecx
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x28, %rax
movl -0x1c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x7f660
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
addq 0x70(%rax), %rcx
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x7f6b0
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8181e
jmp 0x8189a
movl -0x1c(%rbp), %eax
cmpl 0x22c3d(%rip), %eax     # 0xa44e0
jae 0x8191e
movq -0x18(%rbp), %rax
movq 0xd0(%rax), %rax
movl -0x1c(%rbp), %ecx
subl $0x27, %ecx
movl %ecx, %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq $0x28, %rax
movl -0x1c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
addq 0xb0(%rax), %rcx
movq %rcx, 0xb0(%rax)
movq -0x40(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rax
movq $0x0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8189a
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/tcache.c
// Function: je_tcaches_create
bool
tcaches_create(tsd_t *tsd, unsigned *r_ind)
{
	arena_t *arena;
	tcache_t *tcache;
	tcaches_t *elm;

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

	if (tcaches_avail == NULL && tcaches_past > MALLOCX_TCACHE_MAX)
		return (true);
	arena = arena_ichoose(tsd, NULL);
	if (unlikely(arena == NULL))
		return (true);
	tcache = tcache_create(tsd_tsdn(tsd), arena);
	if (tcache == NULL)
		return (true);

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

	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
cmpq $0x0, 0x22b70(%rip)     # 0xa44e8
jne 0x819ac
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x7ff0, %esi           # imm = 0x7FF0
callq 0x50230
movq %rax, 0x22b51(%rip)     # 0xa44e8
cmpq $0x0, 0x22b49(%rip)     # 0xa44e8
jne 0x819aa
movb $0x1, -0x11(%rbp)
jmp 0x81ab6
jmp 0x819ac
cmpq $0x0, 0x22b3c(%rip)     # 0xa44f0
jne 0x819cb
cmpl $0xffd, 0x22b38(%rip)   # imm = 0xFFD
jbe 0x819cb
movb $0x1, -0x11(%rbp)
jmp 0x81ab6
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x81ad0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x819fe
movb $0x1, -0x11(%rbp)
jmp 0x81ab6
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x7fd30
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x81a27
movb $0x1, -0x11(%rbp)
jmp 0x81ab6
cmpq $0x0, 0x22ac1(%rip)     # 0xa44f0
je 0x81a74
movq 0x22ab8(%rip), %rax     # 0xa44f0
movq %rax, -0x40(%rbp)
movq 0x22aad(%rip), %rax     # 0xa44f0
movq (%rax), %rax
movq %rax, 0x22aa3(%rip)     # 0xa44f0
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq 0x22a85(%rip), %rcx     # 0xa44e8
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
jmp 0x81ab2
movq 0x22a6d(%rip), %rax     # 0xa44e8
movl 0x22a77(%rip), %ecx     # 0xa44f8
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movl 0x22a5b(%rip), %ecx     # 0xa44f8
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl 0x22a4f(%rip), %eax     # 0xa44f8
addl $0x1, %eax
movl %eax, 0x22a46(%rip)     # 0xa44f8
movb $0x0, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/tsd.c
// Function: je_malloc_tsd_boot0
tsd_t *
malloc_tsd_boot0(void)
{
	tsd_t *tsd;

	ncleanups = 0;
	if (tsd_boot0())
		return (NULL);
	tsd = tsd_fetch();
	*tsd_arenas_tdata_bypassp_get(tsd) = true;
	return (tsd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, 0x21fbe(%rip)     # 0xa4530
leaq 0x21fbb(%rip), %rdi     # 0xa4534
leaq -0x1d0(%rip), %rsi      # 0x823b0
callq 0xb200
cmpl $0x0, %eax
je 0x82590
movb $0x1, -0x39(%rbp)
jmp 0x8259b
movb $0x1, 0x21f79(%rip)     # 0xa4510
movb $0x0, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x825a3
jmp 0x825b0
movq $0x0, -0x48(%rbp)
jmp 0x82727
movb $0x1, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %fs:0x0, %rax
leaq -0x68(%rax), %rax
movq %rax, -0x30(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x825f2
xorl %eax, %eax
testb $0x1, %al
jne 0x825de
jmp 0x825f2
cmpq $0x0, -0x30(%rbp)
jne 0x825f2
movq $0x0, -0x20(%rbp)
jmp 0x82707
movq -0x30(%rbp), %rax
cmpl $0x1, (%rax)
setne %al
testb $0x1, %al
jne 0x82605
jmp 0x826ff
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x8267f
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq %fs:0x0, %rax
leaq -0x68(%rax), %rdi
movq -0x10(%rbp), %rsi
movl $0x68, %edx
callq 0xb310
movl 0x21ef0(%rip), %edi     # 0xa4534
movq %fs:0x0, %rax
leaq -0x68(%rax), %rsi
callq 0xb590
cmpl $0x0, %eax
je 0x8267d
leaq 0xe815(%rip), %rdi      # 0x90e7a
callq 0x828c0
leaq 0x20e8f(%rip), %rax     # 0xa3500
testb $0x1, (%rax)
je 0x8267b
callq 0xb050
jmp 0x8267d
jmp 0x826fd
movq -0x30(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x826f9
movq -0x30(%rbp), %rax
movl $0x3, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %fs:0x0, %rax
leaq -0x68(%rax), %rdi
movq -0x18(%rbp), %rsi
movl $0x68, %edx
callq 0xb310
movl 0x21e76(%rip), %edi     # 0xa4534
movq %fs:0x0, %rax
leaq -0x68(%rax), %rsi
callq 0xb590
cmpl $0x0, %eax
je 0x826f7
leaq 0xe79b(%rip), %rdi      # 0x90e7a
callq 0x828c0
leaq 0x20e15(%rip), %rax     # 0xa3500
testb $0x1, (%rax)
je 0x826f5
callq 0xb050
jmp 0x826f7
jmp 0x826fb
jmp 0x826fb
jmp 0x826fd
jmp 0x826ff
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb $0x1, 0x44(%rax)
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/util.c
// Function: je_buferror
int
buferror(int err, char *buf, size_t buflen)
{

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xb330
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x829a2
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xb080
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/witness.c
// Function: je_witness_lock_error
void
witness_lock_error(const witness_list_t *witnesses, const witness_t *witness)
{
	witness_t *w;

	malloc_printf("<jemalloc>: Lock rank order reversal:");
	ql_foreach(w, witnesses, link) {
		malloc_printf(" %s(%u)", w->name, w->rank);
	}
	malloc_printf(" %s(%u)\n", witness->name, witness->rank);
	abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xdcea(%rip), %rdi      # 0x93a01
movb $0x0, %al
callq 0x85c20
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x85d7d
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0xdce2(%rip), %rdi      # 0x93a27
movb $0x0, %al
callq 0x85c20
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
je 0x85d6b
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x85d73
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x85d73
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x85d29
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0xdcb3(%rip), %rdi      # 0x93a45
movb $0x0, %al
callq 0x85c20
callq 0xb050
nop
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/witness.c
// Function: je_witness_lockless_error
void
witness_lockless_error(const witness_list_t *witnesses)
{
	witness_t *w;

	malloc_printf("<jemalloc>: Should not own any locks:");
	ql_foreach(w, witnesses, link) {
		malloc_printf(" %s(%u)", w->name, w->rank);
	}
	malloc_printf("\n");
	abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xdc5e(%rip), %rdi      # 0x93a71
movb $0x0, %al
callq 0x85c20
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x85e79
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0xdbe6(%rip), %rdi      # 0x93a27
movb $0x0, %al
callq 0x85c20
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
je 0x85e67
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x85e6f
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0x85e6f
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x85e25
leaq 0x927c(%rip), %rdi      # 0x8f0fc
movb $0x0, %al
callq 0x85c20
callq 0xb050
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/witness.c
// Function: je_witness_postfork_child
void
witness_postfork_child(tsd_t *tsd)
{
#ifndef JEMALLOC_MUTEX_INIT_CB
	witness_list_t *witnesses;

	witnesses = tsd_witnessesp_get(tsd);
	ql_new(witnesses);
#endif
	tsd_witness_fork_set(tsd, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x58, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x60(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/ckh.c
// Function: ckh_try_bucket_insert
JEMALLOC_INLINE_C bool
ckh_try_bucket_insert(ckh_t *ckh, size_t bucket, const void *key,
    const void *data)
{
	ckhc_t *cell;
	unsigned offset, i;

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

	return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdx, -0x48(%rbp)
movq %rcx, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x2, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movabsq $0x5851f42d4c957f2d, %rax # imm = 0x5851F42D4C957F2D
imulq -0x8(%rbp), %rax
movabsq $0x14057b7ef767814f, %rcx # imm = 0x14057B7EF767814F
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movl $0x40, %ecx
subl -0x14(%rbp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl %eax, -0x5c(%rbp)
movl $0x0, -0x60(%rbp)
movl -0x60(%rbp), %eax
cmpq $0x4, %rax
jae 0x8c873
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x40(%rbp), %rcx
shlq $0x2, %rcx
movl -0x60(%rbp), %edx
addl -0x5c(%rbp), %edx
movl %edx, %edx
andq $0x3, %rdx
addq %rdx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x8c866
movq -0x48(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movb $0x0, -0x29(%rbp)
jmp 0x8c877
jmp 0x8c868
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x8c7fc
movb $0x1, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/keiranrowan[P]tiny-core/./src/wc.c
// Function: help
void help() {
	printf("wc [-w|-c|-l] [FILE]...\n");
	printf("    -w = Print word count\n");
	printf("    -c = Print character count\n");
	printf("    -l = Print line count\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x948(%rip), %rdi       # 0x2043
movb $0x0, %al
callq 0x1040
leaq 0x953(%rip), %rdi       # 0x205c
movb $0x0, %al
callq 0x1040
leaq 0x960(%rip), %rdi       # 0x2077
movb $0x0, %al
callq 0x1040
leaq 0x972(%rip), %rdi       # 0x2097
movb $0x0, %al
callq 0x1040
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/addr-accessible.c
// Function: main
int
main(void)
{
    long local_target;
    int *shm_target;
    int me;

    shmem_init();
    me = shmem_my_pe();

    shm_target = (int *) shmem_malloc(sizeof(int));

    if (me == 0) {
        char *msg = "OK";

        if (! check_it(&global_target)) {    /* long global: yes */
            msg = "FAIL (global long)";
        }
        if (! check_it(&static_target)) {    /* static int global: yes */
            msg = "FAIL (static int)";
        }
        if (! check_it(&local_target)) {  /* main() stack: no */
            msg = "FAIL (stack variable)";
        }
        if (! check_it(shm_target)) {    /* shmem_malloc: yes */
            msg = "FAIL (shmem_malloc)";
        }

        puts(msg);

    }

    shmem_free(shm_target);

    shmem_finalize();

    return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
callq 0x1080
callq 0x1060
movl %eax, 0xc(%rsp)
movl $0x4, %edi
callq 0x1070
movq %rax, 0x10(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x1254
leaq 0xe29(%rip), %rax       # 0x2004
movq %rax, (%rsp)
leaq 0x2e82(%rip), %rdi      # 0x4068
callq 0x1270
cmpl $0x0, %eax
jne 0x11fb
leaq 0xe10(%rip), %rax       # 0x2007
movq %rax, (%rsp)
leaq 0x2e6e(%rip), %rdi      # 0x4070
callq 0x1270
cmpl $0x0, %eax
jne 0x1217
leaq 0xe07(%rip), %rax       # 0x201a
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x1270
cmpl $0x0, %eax
jne 0x1231
leaq 0xdff(%rip), %rax       # 0x202c
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x1270
cmpl $0x0, %eax
jne 0x124b
leaq 0xdfb(%rip), %rax       # 0x2042
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x1030
movq 0x10(%rsp), %rdi
callq 0x1090
callq 0x1050
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yurrriq[P]knrc/src/fahrcels.c
// Function: print_header
void print_header(char lhs[], char rhs[])
{
    printf("| %s | %s |\n", lhs, rhs);
    putchar('|');
    for (size_t i = 0; i < strlen(lhs) + 2; ++i)
        putchar('-');
    putchar('+');
    for (size_t i = 0; i < strlen(rhs) + 2; ++i)
        putchar('-');
    puts("|");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0xe81(%rip), %rdi       # 0x2020
movb $0x0, %al
callq 0x1060
movl $0x7c, %edi
callq 0x1030
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1050
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq $0x2, %rcx
cmpq %rcx, %rax
jae 0x11f1
movl $0x2d, %edi
callq 0x1030
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x11b8
movl $0x2b, %edi
callq 0x1030
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1050
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq $0x2, %rcx
cmpq %rcx, %rax
jae 0x123c
movl $0x2d, %edi
callq 0x1030
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1203
leaq 0xdea(%rip), %rdi       # 0x202d
callq 0x1040
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/yurrriq[P]knrc/src/fahrcels.c
// Function: main
int main()
{
    fahrcels();
    puts("\n");
    celsfahr();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x12c0
leaq 0xd07(%rip), %rdi       # 0x2052
callq 0x1040
callq 0x1250
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/melynx[P]peekaboo/libpeekaboo/arch/aarch64.c
// Function: aarch64_regfile_pp
void aarch64_regfile_pp(regfile_aarch64_t *regfile)
{
	char *regname[] = {"r0", "r1", "r2", "r3", "r4", "r5",
		           "r6", "r7", "r8", "r9", "r10", "r11",
		           "r12", "r13", "r14", "r15", "r16", "r17",
		           "r18", "r19", "r20", "r21", "r22", "r23",
		           "r24", "r25", "r26", "r27", "r28", "r29",
		           "lr", "sp", "pc", "nzcv", "fpcr", "fpsr"};

	for (int x=0; x<31; x++)
	{
		printf("%s:%" PRIx64 "\n", regname[x], ((uint64_t *)&(regfile->gpr))[x]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x8(%rbp)
leaq -0x130(%rbp), %rdi
leaq 0x4393(%rip), %rsi      # 0x8720
movl $0x120, %edx            # imm = 0x120
callq 0x41d0
movl $0x0, -0x134(%rbp)
cmpl $0x1f, -0x134(%rbp)
jge 0x43e7
movslq -0x134(%rbp), %rax
movq -0x130(%rbp,%rax,8), %rsi
movq -0x8(%rbp), %rax
movslq -0x134(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x1cb4(%rip), %rdi      # 0x6083
movb $0x0, %al
callq 0x4120
movl -0x134(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x134(%rbp)
jmp 0x43a1
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/melynx[P]peekaboo/libpeekaboo/arch/amd64.c
// Function: amd64_regfile_pp
void amd64_regfile_pp(regfile_amd64_t *regfile)
{
	printf("\tRegisters:\n");
	char *gpr_string[] = {"rdi",
	                     "rsi",
	                     "rsp",
	                     "rbp",
	                     "rbx",
	                     "rdx",
	                     "rcx",
	                     "rax",
	                     "r8 ",
	                     "r9 ",
	                     "r10",
	                     "r11",
	                     "r12",
	                     "r13",
	                     "r14",
	                     "r15",
	                     "rflags",
	                     "rip"};

	for (int x=0; x<18; x++)
	{
		printf("\t  %s: %" PRIx64 "\n", gpr_string[x], ((uint64_t *)&(regfile->gpr))[x]);
	}
	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1c85(%rip), %rdi      # 0x608b
movb $0x0, %al
callq 0x4120
leaq -0xa0(%rbp), %rdi
leaq 0x4425(%rip), %rsi      # 0x8840
movl $0x90, %edx
callq 0x41d0
movl $0x0, -0xa4(%rbp)
cmpl $0x12, -0xa4(%rbp)
jge 0x4475
movslq -0xa4(%rbp), %rax
movq -0xa0(%rbp,%rax,8), %rsi
movq -0x8(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x1c6e(%rip), %rdi      # 0x60cb
movb $0x0, %al
callq 0x4120
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0x442f
leaq 0x2a11(%rip), %rdi      # 0x6e8d
movb $0x0, %al
callq 0x4120
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/melynx[P]peekaboo/libpeekaboo/arch/amd64_syscall.c
// Function: amd64_syscall_pp
int amd64_syscall_pp(regfile_amd64_t *regfile, uint64_t rvalue, bool print_details)
{
	const uint64_t syscall_id = regfile->gpr.reg_rax;
	if (syscall_id >= sizeof(syscall_infos)/sizeof(struct_syscall_info))
	{
		// Unrecognized syscall ID. Return.
		printf("syscall %lu", syscall_id);
		return -1;
	}
	const struct_syscall_info *syscall_info = &syscall_infos[syscall_id];

	if (!print_details)
	{
		// Just print what syscall is this. Job done!
		printf("syscall %s (%lu)", syscall_info->sys_name, syscall_id);
		return 0;
	}
	
	// Print arguments and rvalue.
	printf("%s(", syscall_info->sys_name);
	assert(syscall_info->nargs <= sizeof(args_offset)/sizeof(uint64_t));
	unsigned int arg_idx;
	for (arg_idx = 0; arg_idx < syscall_info->nargs; arg_idx++)
	{
		if (arg_idx != 0) printf(", ");
		printf("0x%lx", ((uint64_t *)&regfile->gpr)[args_offset[arg_idx]]);
	}
	printf(") = 0x%lx", rvalue);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x14f, -0x28(%rbp)     # imm = 0x14F
jb 0x44db
movq -0x28(%rbp), %rsi
leaq 0x1c0f(%rip), %rdi      # 0x60d7
movb $0x0, %al
callq 0x4120
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x45d0
movq -0x28(%rbp), %rcx
leaq 0x43ea(%rip), %rax      # 0x88d0
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x451d
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x28(%rbp), %rdx
leaq 0x1bd9(%rip), %rdi      # 0x60e3
movb $0x0, %al
callq 0x4120
movl $0x0, -0x4(%rbp)
jmp 0x45d0
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x1bc8(%rip), %rdi      # 0x60f4
movb $0x0, %al
callq 0x4120
movq -0x30(%rbp), %rax
movl (%rax), %eax
cmpq $0x6, %rax
ja 0x4541
jmp 0x4560
leaq 0x1bb0(%rip), %rdi      # 0x60f8
leaq 0x1be5(%rip), %rsi      # 0x6134
movl $0x185, %edx            # imm = 0x185
leaq 0x1bee(%rip), %rcx      # 0x6149
callq 0x4150
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x45b7
cmpl $0x0, -0x34(%rbp)
je 0x4586
leaq 0x1c03(%rip), %rdi      # 0x6182
movb $0x0, %al
callq 0x4120
movq -0x10(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, %edx
leaq 0x27fa(%rip), %rcx      # 0x6d90
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x1be4(%rip), %rdi      # 0x6189
movb $0x0, %al
callq 0x4120
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4567
movq -0x18(%rbp), %rsi
leaq 0x1bc3(%rip), %rdi      # 0x6185
movb $0x0, %al
callq 0x4120
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/melynx[P]peekaboo/libpeekaboo/arch/x86.c
// Function: x86_regfile_pp
void x86_regfile_pp(regfile_x86_t *regfile)
{
	char * regname[] = {"eax",
						"ecx",
						"edx",
						"ebx",
						"esp",
						"ebp",
						"esi",
						"edi"};

	for (int x=0; x < 8; x++)
		printf("%s:%" PRIx32 "\n", regname[x], ((uint32_t *)&(regfile->gpr))[x]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x57c9(%rip), %rsi      # 0x9dc0
movl $0x40, %edx
callq 0x41d0
movl $0x0, -0x54(%rbp)
cmpl $0x8, -0x54(%rbp)
jge 0x463b
movslq -0x54(%rbp), %rax
movq -0x50(%rbp,%rax,8), %rsi
movq -0x8(%rbp), %rax
movslq -0x54(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x27b7(%rip), %rdi      # 0x6de0
movb $0x0, %al
callq 0x4120
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x4608
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/melynx[P]peekaboo/libpeekaboo/libpeekaboo.c
// Function: create_folder
int create_folder(char *name, char *output, uint32_t max_size)
{
	DIR *dir = opendir(name);
	char *resolved_name = realpath(name, output);
	if (errno == ENOENT)
		mkdir(name, S_IRWXU|S_IRWXG|S_IROTH);
	else
		return -1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40f0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x41c0
movq %rax, -0x30(%rbp)
callq 0x4080
cmpl $0x2, (%rax)
jne 0x469b
movq -0x10(%rbp), %rdi
movl $0x1fc, %esi            # imm = 0x1FC
callq 0x40b0
jmp 0x46a4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x46ab
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/melynx[P]peekaboo/libpeekaboo/libpeekaboo.c
// Function: term_dir
int term_dir(char *path, int size)
{
	int path_len = strlen(path);
	// check if directory terminates with '/'
	if (path[path_len-1] != '/')
	{
		if (path_len > MAX_PATH-1) return -1;

		path[path_len] = '/';
		path[path_len+1] = 0;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4110
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x4720
cmpl $0xff, -0x18(%rbp)
jle 0x4703
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4727
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x2f, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/melynx[P]peekaboo/libpeekaboo/libpeekaboo.c
// Function: join_path
int join_path(char *dir_path, char *filename, int size)
{
	if (!term_dir(dir_path, size))
	{
		int dir_len;
		int file_len;

		dir_len = strlen(dir_path);
		file_len = strlen(filename);

		if (dir_len + file_len >= size) return -1;
		strncat(dir_path, filename, size);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x40d0
cmpl $0x0, %eax
jne 0x4791
movq -0x10(%rbp), %rdi
callq 0x4110
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4110
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jl 0x4780
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4798
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x4180
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/melynx[P]peekaboo/libpeekaboo/libpeekaboo.c
// Function: create_trace_file
int create_trace_file(char *dir_path, char *filename, int size, FILE **output)
{
	char path[MAX_PATH];

	strncpy(path, dir_path, MAX_PATH);
	if (join_path(path, filename, size)) return -1;
	*output = fopen(path, "wb");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0x130(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x4090
leaq -0x130(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x4160
cmpl $0x0, %eax
je 0x4800
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4824
leaq -0x130(%rbp), %rdi
leaq 0x25d9(%rip), %rsi      # 0x6de7
callq 0x4250
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/melynx[P]peekaboo/libpeekaboo/libpeekaboo.c
// Function: close_trace
void close_trace(peekaboo_trace_t *trace_ptr)
{
	fflush(trace_ptr->insn_trace);
	fflush(trace_ptr->bytes_map);
	fflush(trace_ptr->regfile);
	fflush(trace_ptr->memfile);
	fflush(trace_ptr->memrefs);
	//fflush(trace_ptr->metafile);

	fclose(trace_ptr->insn_trace);
	fclose(trace_ptr->bytes_map);
	fclose(trace_ptr->regfile);
	fclose(trace_ptr->memfile);
	fclose(trace_ptr->memrefs);
	//fclose(trace_ptr->metafile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4200
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4200
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4200
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x4200
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4200
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x40e0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x40e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x40e0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x40e0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x40e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/melynx[P]peekaboo/libpeekaboo/libpeekaboo.c
// Function: create_trace
peekaboo_trace_t *create_trace(char *name)
{
	char dir_path[MAX_PATH];
	peekaboo_trace_t *trace_ptr;

	if (create_folder(name, dir_path, MAX_PATH)) 
	{
		return NULL;
	}

	trace_ptr = (peekaboo_trace_t *)malloc(sizeof(peekaboo_trace_t));
	if (!trace_ptr) PEEKABOO_DIE("libpeekaboo: Unable to malloc trace instance.\n");

	create_trace_file(dir_path, "insn.trace", MAX_PATH, &trace_ptr->insn_trace);
	create_trace_file(dir_path, "regfile", MAX_PATH, &trace_ptr->regfile);
	create_trace_file(dir_path, "memfile", MAX_PATH, &trace_ptr->memfile);
	create_trace_file(dir_path, "memrefs", MAX_PATH, &trace_ptr->memrefs);
	create_trace_file(dir_path, "metafile", MAX_PATH, &trace_ptr->metafile);

	/* Since version 2, insn.bytemap is shared by all threads. So we do not create
	 * here.
	 */
	//create_trace_file(dir_path, "insn.bytemap", MAX_PATH, &trace_ptr->bytes_map);


	return trace_ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x110(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x4060
cmpl $0x0, %eax
je 0x4906
movq $0x0, -0x8(%rbp)
jmp 0x49f9
movl $0x40, %edi
callq 0x41f0
movq %rax, -0x118(%rbp)
cmpq $0x0, -0x118(%rbp)
jne 0x4943
movq 0x56c8(%rip), %rax      # 0x9ff0
movq (%rax), %rdi
leaq 0x24b8(%rip), %rsi      # 0x6dea
movb $0x0, %al
callq 0x4190
movl $0x1, %edi
callq 0x4260
leaq -0x110(%rbp), %rdi
movq -0x118(%rbp), %rcx
leaq 0x24c1(%rip), %rsi      # 0x6e19
movl $0x100, %edx            # imm = 0x100
callq 0x4030
leaq -0x110(%rbp), %rdi
movq -0x118(%rbp), %rcx
addq $0x10, %rcx
leaq 0x24a9(%rip), %rsi      # 0x6e24
movl $0x100, %edx            # imm = 0x100
callq 0x4030
leaq -0x110(%rbp), %rdi
movq -0x118(%rbp), %rcx
addq $0x20, %rcx
leaq 0x248e(%rip), %rsi      # 0x6e2c
movl $0x100, %edx            # imm = 0x100
callq 0x4030
leaq -0x110(%rbp), %rdi
movq -0x118(%rbp), %rcx
addq $0x18, %rcx
leaq 0x2473(%rip), %rsi      # 0x6e34
movl $0x100, %edx            # imm = 0x100
callq 0x4030
leaq -0x110(%rbp), %rdi
movq -0x118(%rbp), %rcx
addq $0x28, %rcx
leaq 0x2458(%rip), %rsi      # 0x6e3c
movl $0x100, %edx            # imm = 0x100
callq 0x4030
movq -0x118(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/melynx[P]peekaboo/libpeekaboo/libpeekaboo.c
// Function: load_bytes_map
void load_bytes_map(peekaboo_trace_t *trace)
{
	fseek(trace->bytes_map, 0, SEEK_END);
	size_t bytesmap_size = ftell(trace->bytes_map);
	size_t num_maps = bytesmap_size / sizeof(bytes_map_t);

	trace->internal->bytes_map_buf = malloc(bytesmap_size);
	trace->internal->bytes_map_size = bytesmap_size;

	rewind(trace->bytes_map);
	printf("Found %lu instructions in bytemap...\n", num_maps);
	if (fread(trace->internal->bytes_map_buf, sizeof(bytes_map_t), num_maps, trace->bytes_map) != num_maps)
	{
		PEEKABOO_DIE("libpeekaboo: BYTES MAP READ ERROR!\n");
	}
	printf("\n");
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x4220
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x41a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x5, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x41f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4130
movq -0x18(%rbp), %rsi
leaq 0x23b6(%rip), %rdi      # 0x6e45
movb $0x0, %al
callq 0x4120
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x20, %esi
callq 0x40c0
cmpq -0x18(%rbp), %rax
je 0x4ae0
movq 0x552b(%rip), %rax      # 0x9ff0
movq (%rax), %rdi
leaq 0x239c(%rip), %rsi      # 0x6e6b
movb $0x0, %al
callq 0x4190
movl $0x1, %edi
callq 0x4260
leaq 0x23a6(%rip), %rdi      # 0x6e8d
movb $0x0, %al
callq 0x4120
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/melynx[P]peekaboo/libpeekaboo/libpeekaboo.c
// Function: find_bytes_map
bytes_map_t *find_bytes_map(uint64_t pc, peekaboo_trace_t *trace)
{
	bytes_map_t *bytes_map_buf = trace->internal->bytes_map_buf;
	size_t map_size = trace->internal->bytes_map_size;
	size_t num_maps = map_size / sizeof(bytes_map_t);
	int x;
	for (x=0; x<num_maps; x++)
	{
		if ((bytes_map_buf+x)->pc == pc)
			return bytes_map_buf+x;
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
shrq $0x5, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x4b83
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x4b76
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x4b8b
jmp 0x4b78
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4b3f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/melynx[P]peekaboo/libpeekaboo/libpeekaboo.c
// Function: get_addr
uint64_t get_addr(size_t id, peekaboo_trace_t *trace)
{
	if (!id) PEEKABOO_DIE("libpeekaboo: Error. Instruction index 0 is not accepted.\n");

	uint64_t addr = 0;
	size_t ptr_size = get_ptr_size(trace);

	fseek(trace->insn_trace, (id-1) * ptr_size, SEEK_SET);
	size_t fread_bytes = fread(&addr, ptr_size, 1, trace->insn_trace);
	return addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4c39
movq 0x53d2(%rip), %rax      # 0x9ff0
movq (%rax), %rdi
leaq 0x2267(%rip), %rsi      # 0x6e8f
movb $0x0, %al
callq 0x4190
movl $0x1, %edi
callq 0x4260
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4290
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
subq $0x1, %rsi
imulq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x4220
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
leaq -0x18(%rbp), %rdi
movl $0x1, %edx
callq 0x40c0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/melynx[P]peekaboo/libpeekaboo/libpeekaboo.c
// Function: get_num_mem
size_t get_num_mem(size_t id, peekaboo_trace_t *trace)
{
	if (!id) PEEKABOO_DIE("libpeekaboo: Error. Instruction index 0 is not accepted.\n");

	size_t num_mem = 0;
	fseek(trace->memrefs, (id-1) * sizeof(memref_t), SEEK_SET);
	size_t fread_bytes = fread(&num_mem, sizeof(memref_t), 1, trace->memrefs);
	return num_mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4cc9
movq 0x5342(%rip), %rax      # 0x9ff0
movq (%rax), %rdi
leaq 0x21d7(%rip), %rsi      # 0x6e8f
movb $0x0, %al
callq 0x4190
movl $0x1, %edi
callq 0x4260
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rsi
subq $0x1, %rsi
shlq $0x2, %rsi
xorl %edx, %edx
callq 0x4220
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
leaq -0x18(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x40c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/melynx[P]peekaboo/libpeekaboo/libpeekaboo.c
// Function: free_peekaboo_trace
void free_peekaboo_trace(peekaboo_trace_t *trace_ptr)
{
	fclose(trace_ptr->bytes_map);
	fclose(trace_ptr->insn_trace);
	fclose(trace_ptr->regfile);
	fclose(trace_ptr->memfile);
	fclose(trace_ptr->memrefs);
	if (trace_ptr->memrefs_offsets)	fclose(trace_ptr->memrefs_offsets);
	free(trace_ptr->internal->bytes_map_buf);
	free(trace_ptr->internal);
	free(trace_ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x40e0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x40e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x40e0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x40e0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x40e0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x5794
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x40e0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x4070
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x4070
movq -0x8(%rbp), %rdi
callq 0x4070
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/melynx[P]peekaboo/libpeekaboo/libpeekaboo.c
// Function: write_metadata
void write_metadata(peekaboo_trace_t *trace_ptr, enum ARCH arch, uint32_t version)
{
	metadata_hdr_t metadata;
	metadata.arch = arch;
	metadata.version = version;
	if (arch == ARCH_AMD64)
	{
		#ifdef _STORE_SIMD
			metadata.storage_options.amd64.has_simd = 1;
		#else
			metadata.storage_options.amd64.has_simd = 0;
		#endif
		#ifdef _STORE_FXSAVE
			metadata.storage_options.amd64.has_fxsave = 1;
		#else
			metadata.storage_options.amd64.has_fxsave = 0;
		#endif
	}
	fwrite(&metadata, sizeof(metadata_hdr_t), 1, trace_ptr->metafile);
	fflush(trace_ptr->metafile);
	fclose(trace_ptr->metafile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x3, -0xc(%rbp)
jne 0x5802
movl $0x1, -0x18(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
leaq -0x20(%rbp), %rdi
movl $0x10, %esi
movl $0x1, %edx
callq 0x4270
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x4200
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x40e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)