LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regfwalk.c
// Function: regf_unicode2wchar
static const wchar_t *regf_unicode2wchar(const void *ptr, unsigned len)
{
#define __MAX_LEN	50
	static wchar_t __obuf[__MAX_LEN + 4 + 1];
	uint16_t __ibuf[__MAX_LEN * 2];
	unsigned __len;
	char *ibuf = (char *)__ibuf;
	char *obuf = (char *)__obuf;
	size_t ilen, olen, res;

	__len = len / 2 > __MAX_LEN ? __MAX_LEN : len / 2;

	memcpy(__ibuf, ptr, __len * sizeof(__ibuf[0]));

	ilen = __len * sizeof(__ibuf[0]);
	olen = __len * sizeof(__obuf[0]);

	iconv(st.icd, NULL, NULL, NULL, NULL);	/* Reset descriptor */

	res = iconv(st.icd, &ibuf, &ilen, &obuf, &olen);
	if (res == (size_t)-1)
		return L"<error>";

	if (__len != len / 2) {
		__obuf[__MAX_LEN + 0] = '.';
		__obuf[__MAX_LEN + 1] = '.';
		__obuf[__MAX_LEN + 2] = '.';
		__obuf[__MAX_LEN + 3] = '\0';
	} else {
		__obuf[__len] = '\0';
	}

	return __obuf;
#undef __MAX_LEN
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq 0x6f39(%rip), %rax      # 0x9140
movq %rax, -0xf8(%rbp)
movl -0x14(%rbp), %eax
shrl %eax
cmpl $0x32, %eax
jbe 0x2225
movl $0x32, %eax
movl %eax, -0x114(%rbp)
jmp 0x2230
movl -0x14(%rbp), %eax
shrl %eax
movl %eax, -0x114(%rbp)
movl -0x114(%rbp), %eax
movl %eax, -0xe4(%rbp)
leaq -0xe0(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0xe4(%rbp), %eax
movl %eax, %edx
shlq %rdx
callq 0x10f0
movl -0xe4(%rbp), %eax
shlq %rax
movq %rax, -0x100(%rbp)
movl -0xe4(%rbp), %eax
shlq $0x2, %rax
movq %rax, -0x108(%rbp)
movq 0x6e71(%rip), %rdi      # 0x90f0
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rsi
movq %r8, %rdx
movq %r8, %rcx
callq 0x1050
movq 0x6e57(%rip), %rdi      # 0x90f0
leaq -0xf0(%rbp), %rsi
leaq -0x100(%rbp), %rdx
leaq -0xf8(%rbp), %rcx
leaq -0x108(%rbp), %r8
callq 0x1050
movq %rax, -0x110(%rbp)
cmpq $-0x1, -0x110(%rbp)
jne 0x22d8
leaq 0x4c66(%rip), %rax      # 0x6f38
movq %rax, -0x8(%rbp)
jmp 0x2332
movl -0xe4(%rbp), %eax
movl -0x14(%rbp), %ecx
shrl %ecx
cmpl %ecx, %eax
je 0x2311
movl $0x2e, 0x6f17(%rip)     # 0x9208
movl $0x2e, 0x6f11(%rip)     # 0x920c
movl $0x2e, 0x6f0b(%rip)     # 0x9210
movl $0x0, 0x6f05(%rip)      # 0x9214
jmp 0x2327
movl -0xe4(%rbp), %eax
movl %eax, %ecx
leaq 0x6e20(%rip), %rax      # 0x9140
movl $0x0, (%rax,%rcx,4)
leaq 0x6e12(%rip), %rax      # 0x9140
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regfwalk.c
// Function: regf_parse_sk
static int regf_parse_sk(const char *pref, unsigned off)
{
	const struct regf_cell *rc = st.data + off;
	const struct regf_sk *sk = (void *)rc->data;

	if (regf_cell_check_sign_len(st.data, off, "sk", sizeof(*sk)))
		return -1;

	printf("%ssk.{off,len} = 0x%08X, 0x%08X\n", pref, off, -rc->sz);
	printf("%ssk.{prev,next} = 0x%08X, 0x%08X\n", pref, sk->prev, sk->next);
	printf("%ssk.refcnt = 0x%08X\n", pref, sk->refcnt);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x6b7a(%rip), %rax      # 0x9100
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq 0x6b5d(%rip), %rdi      # 0x9100
movl -0x14(%rbp), %esi
leaq 0x4148(%rip), %rdx      # 0x66f5
movl $0x10, %ecx
callq 0x4fd0
cmpl $0x0, %eax
je 0x25c5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2622
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
subl (%rax), %ecx
leaq 0x411d(%rip), %rdi      # 0x66f8
movb $0x0, %al
callq 0x10a0
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
leaq 0x411e(%rip), %rdi      # 0x6719
movb $0x0, %al
callq 0x10a0
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
movl 0xc(%rax), %edx
leaq 0x4128(%rip), %rdi      # 0x673c
movb $0x0, %al
callq 0x10a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regfwalk.c
// Function: regf_parse_lst
static int regf_parse_lst(const char *pref, unsigned off)
{
	const struct regf_cell *rc = st.data + off;
	const struct regf_lst *lst = (void *)rc->data;

	if (regf_cell_check_len(st.data, off, "lst", sizeof(*lst)))
		return -1;

	printf("%s%.2s.{off,len} = 0x%08X, 0x%08X\n", pref, lst->sign, off, -rc->sz);

	if (strncmp(lst->sign, "lf", 2) == 0) {
		return regf_parse_lst_lf(pref, off);
	} else if (strncmp(lst->sign, "lh", 2) == 0) {
		return regf_parse_lst_lh(pref, off);
	} else if (strncmp(lst->sign, "li", 2) == 0) {
		return regf_parse_lst_li(pref, off);
	} else if (strncmp(lst->sign, "ri", 2) == 0) {
		return regf_parse_lst_ri(pref, off);
	} else {
		PR_ERR(off, "lst", "unexpected list signature\n");
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x6aba(%rip), %rax      # 0x9100
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq 0x6a9d(%rip), %rdi      # 0x9100
movl -0x14(%rbp), %esi
leaq 0x4725(%rip), %rdx      # 0x6d92
movl $0x4, %ecx
callq 0x4ee0
cmpl $0x0, %eax
je 0x2688
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2779
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
xorl %r8d, %r8d
subl (%rax), %r8d
leaq 0x40ae(%rip), %rdi      # 0x6752
movb $0x0, %al
callq 0x10a0
movq -0x28(%rbp), %rdi
leaq 0x40bf(%rip), %rsi      # 0x6775
movl $0x2, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0x26d9
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2970
movl %eax, -0x4(%rbp)
jmp 0x2779
movq -0x28(%rbp), %rdi
leaq 0x4094(%rip), %rsi      # 0x6778
movl $0x2, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0x2704
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2b20
movl %eax, -0x4(%rbp)
jmp 0x2779
movq -0x28(%rbp), %rdi
leaq 0x406c(%rip), %rsi      # 0x677b
movl $0x2, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0x272f
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2cd0
movl %eax, -0x4(%rbp)
jmp 0x2779
movq -0x28(%rbp), %rdi
leaq 0x4044(%rip), %rsi      # 0x677e
movl $0x2, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0x275a
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2e70
movl %eax, -0x4(%rbp)
jmp 0x2779
movl -0x14(%rbp), %esi
leaq 0x401d(%rip), %rdi      # 0x6781
leaq 0x4627(%rip), %rdx      # 0x6d92
movb $0x0, %al
callq 0x4c10
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regfwalk.c
// Function: regf_parse_vk_type
static const char *regf_parse_vk_type(uint32_t type)
{
	switch (type) {
	case REGF_VK_T_NONE: return "REG_NONE";
	case REGF_VK_T_SZ: return "REG_SZ";
	case REGF_VK_T_EXPAND_SZ: return "REG_EXPAND_SZ";
	case REGF_VK_T_BINARY: return "REG_BINARY";
	case REGF_VK_T_DWORD: return "REG_DWORD";
	case REGF_VK_T_DWORD_BE: return "REG_DWORD_BIG_ENDIAN";
	case REGF_VK_T_LINK: return "REG_LINK";
	case REGF_VK_T_MULTI_SZ: return "REG_MULTI_SZ";
	case REGF_VK_T_RES_LST: return "REG_RESOURCE_LIST";
	case REGF_VK_T_RES_DESC: return "REG_FULL_RESOURCE_DESCRIPTOR";
	case REGF_VK_T_RES_REQ: return "REG_RESOURCE_REQUIREMENTS_LIST";
	case REGF_VK_T_QWORD: return "REG_QWORD";
	}
	return "UNKNOWN";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xb, %rax
ja 0x34a1
movq -0x18(%rbp), %rax
leaq 0x2c11(%rip), %rcx      # 0x6004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x37aa(%rip), %rax      # 0x6bad
movq %rax, -0x8(%rbp)
jmp 0x34ac
leaq 0x37a3(%rip), %rax      # 0x6bb6
movq %rax, -0x8(%rbp)
jmp 0x34ac
leaq 0x379a(%rip), %rax      # 0x6bbd
movq %rax, -0x8(%rbp)
jmp 0x34ac
leaq 0x3798(%rip), %rax      # 0x6bcb
movq %rax, -0x8(%rbp)
jmp 0x34ac
leaq 0x3796(%rip), %rax      # 0x6bd6
movq %rax, -0x8(%rbp)
jmp 0x34ac
leaq 0x3793(%rip), %rax      # 0x6be0
movq %rax, -0x8(%rbp)
jmp 0x34ac
leaq 0x379b(%rip), %rax      # 0x6bf5
movq %rax, -0x8(%rbp)
jmp 0x34ac
leaq 0x3797(%rip), %rax      # 0x6bfe
movq %rax, -0x8(%rbp)
jmp 0x34ac
leaq 0x3797(%rip), %rax      # 0x6c0b
movq %rax, -0x8(%rbp)
jmp 0x34ac
leaq 0x379c(%rip), %rax      # 0x6c1d
movq %rax, -0x8(%rbp)
jmp 0x34ac
leaq 0x37ac(%rip), %rax      # 0x6c3a
movq %rax, -0x8(%rbp)
jmp 0x34ac
leaq 0x37be(%rip), %rax      # 0x6c59
movq %rax, -0x8(%rbp)
jmp 0x34ac
leaq 0x37bb(%rip), %rax      # 0x6c63
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regfwalk.c
// Function: regf_print_data
static int regf_print_data(const char *pref, const void *p, unsigned type,
			   unsigned len)
{
	switch (type) {
	case REGF_VK_T_DWORD:
		printf("%sdword: %s\n", pref, regf_dword2str(p, len));
		break;
	case REGF_VK_T_QWORD:
		printf("%sqword: %s\n", pref, regf_qword2str(p, len));
		break;
	case REGF_VK_T_SZ:
		printf("%sstr: %ls\n", pref, regf_unicode2wchar(p, len));
		break;
	case REGF_VK_T_EXPAND_SZ:
		printf("%sestr: %ls\n", pref, regf_unicode2wchar(p, len));
		break;
	default:
		printf("%shex: %s\n", pref, regf_hexdump(p, len));
		break;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0xa, %eax
ja 0x35ad
movq -0x20(%rbp), %rax
leaq 0x2b3f(%rip), %rcx      # 0x6034
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x37c0
movq -0x28(%rbp), %rsi
movq %rax, %rdx
leaq 0x374b(%rip), %rdi      # 0x6c6b
movb $0x0, %al
callq 0x10a0
jmp 0x35d6
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x3840
movq -0x30(%rbp), %rsi
movq %rax, %rdx
leaq 0x372a(%rip), %rdi      # 0x6c78
movb $0x0, %al
callq 0x10a0
jmp 0x35d6
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x21e0
movq -0x38(%rbp), %rsi
movq %rax, %rdx
leaq 0x370c(%rip), %rdi      # 0x6c85
movb $0x0, %al
callq 0x10a0
jmp 0x35d6
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x21e0
movq -0x40(%rbp), %rsi
movq %rax, %rdx
leaq 0x36ed(%rip), %rdi      # 0x6c91
movb $0x0, %al
callq 0x10a0
jmp 0x35d6
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x38c0
movq -0x48(%rbp), %rsi
movq %rax, %rdx
leaq 0x36cf(%rip), %rdi      # 0x6c9e
movb $0x0, %al
callq 0x10a0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regfwalk.c
// Function: regf_parse_raw
static int regf_parse_raw(const char *pref, unsigned off, unsigned type, unsigned len)
{
	const struct regf_cell *rc = st.data + off;

	if (regf_cell_check_len(st.data, off, "data", len))
		return -1;

	return regf_print_data(pref, rc->data, type, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq 0x5b04(%rip), %rax      # 0x9100
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq 0x5af3(%rip), %rdi      # 0x9100
movl -0x14(%rbp), %esi
movl -0x1c(%rbp), %ecx
leaq 0x36c8(%rip), %rdx      # 0x6ce2
callq 0x4ee0
cmpl $0x0, %eax
je 0x362d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3647
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x4, %rsi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x34c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regfwalk.c
// Function: regf_parse_db
static int regf_parse_db(const char *pref, unsigned off)
{
#define DB_PR_WARN(__fmt, ...)	PR_WARN(off, "db", __fmt, ##__VA_ARGS__)
	const struct regf_cell *rc = st.data + off;
	const struct regf_db *db = (void *)rc->data;
	char __pref[0x10];
	struct cell *cell;
	int res;

	if (regf_cell_check_sign_len(st.data, off, "db", sizeof(*db)))
		return -1;

	printf("%sdb.{off,len} = 0x%08X, 0x%08X\n", pref, off, -rc->sz);
	printf("%sdb.nsegm = %u\n", pref, db->nsegm);

	if (db->nsegm) {
		cell = cache_cell_find(db->segm_off);
		if (!cell) {
			DB_PR_WARN("could not find segments list cell 0x%08X\n",
				   db->segm_off);
			return -1;
		}
		cache_cell_updref(cell, CT_SLST);
		snprintf(__pref, sizeof(__pref), "%s  ", pref);
		res = regf_parse_slst(__pref, db->segm_off, db->nsegm);
		if (res) {
			DB_PR_WARN("could not parse segments list cell 0x%08X\n",
				   db->segm_off);
			return -1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x5a9a(%rip), %rax      # 0x9100
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq 0x5a7d(%rip), %rdi      # 0x9100
movl -0x14(%rbp), %esi
leaq 0x365a(%rip), %rdx      # 0x6ce7
movl $0x8, %ecx
callq 0x4fd0
cmpl $0x0, %eax
je 0x36a8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x37a8
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
subl (%rax), %ecx
leaq 0x362c(%rip), %rdi      # 0x6cea
movb $0x0, %al
callq 0x10a0
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %edx
leaq 0x3633(%rip), %rdi      # 0x6d0b
movb $0x0, %al
callq 0x10a0
movq -0x28(%rbp), %rax
cmpw $0x0, 0x2(%rax)
je 0x37a1
movq -0x28(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x1c10
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x372d
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
leaq 0x3606(%rip), %rdi      # 0x6d1c
leaq 0x35ca(%rip), %rdx      # 0x6ce7
movb $0x0, %al
callq 0x4c10
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x37a8
movq -0x48(%rbp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x1c70
leaq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x10, %esi
leaq 0x2c0e(%rip), %rdx      # 0x635d
movb $0x0, %al
callq 0x10b0
leaq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %edx
callq 0x39b0
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0x379f
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
leaq 0x35ce(%rip), %rdi      # 0x6d56
leaq 0x3558(%rip), %rdx      # 0x6ce7
movb $0x0, %al
callq 0x4c10
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x37a8
jmp 0x37a1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regfwalk.c
// Function: regf_dword2str
static const char *regf_dword2str(const void *ptr, unsigned len)
{
	static char buf[0x20];

	if (len == 0) {
		return "0";
	} else if (len == 4) {
		snprintf(buf, sizeof(buf), "0x%08X (%d)", *(uint32_t *)ptr,
			 *(int32_t *)ptr);
		return buf;
	}

	return "<invalid length>";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x37e2
leaq 0x34cd(%rip), %rax      # 0x6ca9
movq %rax, -0x8(%rbp)
jmp 0x3829
cmpl $0x4, -0x14(%rbp)
jne 0x381c
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl (%rax), %r8d
leaq 0x5b24(%rip), %rdi      # 0x9320
movl $0x20, %esi
leaq 0x34a3(%rip), %rdx      # 0x6cab
movb $0x0, %al
callq 0x10b0
leaq 0x5b0a(%rip), %rax      # 0x9320
movq %rax, -0x8(%rbp)
jmp 0x3829
jmp 0x381e
leaq 0x3492(%rip), %rax      # 0x6cb7
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regfwalk.c
// Function: regf_qword2str
static const char *regf_qword2str(const void *ptr, unsigned len)
{
	static char buf[0x40];

	if (len == 0) {
		return "0";
	} else if (len == 8) {
		snprintf(buf, sizeof(buf), "0x%016"PRIX64" (%"PRId64")",
			 *(uint64_t *)ptr, *(int64_t *)ptr);
		return buf;
	}

	return "<invalid length>";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x3862
leaq 0x344d(%rip), %rax      # 0x6ca9
movq %rax, -0x8(%rbp)
jmp 0x38aa
cmpl $0x8, -0x14(%rbp)
jne 0x389d
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %r8
leaq 0x5ac3(%rip), %rdi      # 0x9340
movl $0x40, %esi
leaq 0x343f(%rip), %rdx      # 0x6cc8
movb $0x0, %al
callq 0x10b0
leaq 0x5aa9(%rip), %rax      # 0x9340
movq %rax, -0x8(%rbp)
jmp 0x38aa
jmp 0x389f
leaq 0x3411(%rip), %rax      # 0x6cb7
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regfwalk.c
// Function: regf_hexdump
static const char *regf_hexdump(const void *ptr, unsigned len)
{
#define __MAX_LEN	16
	static char buf[__MAX_LEN * 3 + 4 + 1];
	char *p = buf, *e = buf + sizeof(buf);
	const uint8_t *a = ptr;
	unsigned i, __len;

	__len = len > __MAX_LEN ? __MAX_LEN : len;
	for (i = 0; i < __len; ++i)
		p += snprintf(p, e - p, " %02X", a[i]);

	if (__len != len)
		p += snprintf(p, e - p, " ...");

	return &buf[1];
#undef __MAX_LEN
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x5aaa(%rip), %rax      # 0x9380
movq %rax, -0x18(%rbp)
leaq 0x5a9f(%rip), %rax      # 0x9380
addq $0x35, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x10, -0xc(%rbp)
jbe 0x3901
movl $0x10, %eax
movl %eax, -0x34(%rbp)
jmp 0x3907
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jae 0x395f
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
subq %rax, %rsi
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
movzbl (%rax,%rcx), %ecx
leaq 0x339a(%rip), %rdx      # 0x6cd7
movb $0x0, %al
callq 0x10b0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3914
movl -0x30(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x3994
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
subq %rax, %rsi
leaq 0x3360(%rip), %rdx      # 0x6cdd
movb $0x0, %al
callq 0x10b0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
leaq 0x59e5(%rip), %rax      # 0x9380
addq $0x1, %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regfwalk.c
// Function: regf_parse_slst
static int regf_parse_slst(const char *pref, unsigned off, unsigned num)
{
#define SLST_PR_WARN(__fmt, ...)PR_WARN(off, "slst", __fmt, ##__VA_ARGS__)
	const struct regf_cell *rc = st.data + off;
	const uint32_t *segs = (void *)rc->data;
	struct cell *cell;
	int i, ret = 0;

	if (regf_cell_check_len(st.data, off, "slst", num * sizeof(segs[0])))
		return -1;

	printf("%ssegm.{off,len} = 0x%08X, 0x%08X\n", pref, off, -rc->sz);

	for (i = 0; i < num; ++i) {
		printf("%ssegm[%u] = 0x%08X\n", pref, i, segs[i]);
		cell = cache_cell_find(segs[i]);
		if (!cell) {
			SLST_PR_WARN("could not find data segment cell 0x%08X\n",
				     segs[i]);
			ret = -1;
			continue;
		}
		cache_cell_updref(cell, CT_DATAS);
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq 0x5737(%rip), %rax      # 0x9100
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x38(%rbp)
movq 0x5713(%rip), %rdi      # 0x9100
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %eax
shlq $0x2, %rax
movl %eax, %ecx
leaq 0x3391(%rip), %rdx      # 0x6d91
callq 0x4ee0
cmpl $0x0, %eax
je 0x3a16
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3acf
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
subl (%rax), %ecx
leaq 0x336a(%rip), %rdi      # 0x6d96
movb $0x0, %al
callq 0x10a0
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x3ac9
movq -0x10(%rbp), %rsi
movl -0x34(%rbp), %edx
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
leaq 0x335a(%rip), %rdi      # 0x6db9
movb $0x0, %al
callq 0x10a0
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x1c10
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3aad
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
leaq 0x3338(%rip), %rdi      # 0x6dce
leaq 0x32f4(%rip), %rdx      # 0x6d91
movb $0x0, %al
callq 0x4c10
movl $0xffffffff, -0x38(%rbp) # imm = 0xFFFFFFFF
jmp 0x3abb
movq -0x30(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x1c70
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3a3a
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/rbtree.c
// Function: rbtree_predecessor
struct rbtree_head *rbtree_predecessor(const struct rbtree *t,
				       const struct rbtree_head *node)
{
	struct rbtree_head *tmp;

	if (!rbt_is_nil(t, node->left))
		return rbtree_maximum(t, node->left);

	tmp = rbt_get_p(node);
	while (!rbt_is_nil(t, tmp) && node == tmp->left) {
		node = tmp;
		tmp = rbt_get_p(tmp);
	}

	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3c00
cmpl $0x0, %eax
jne 0x3cbd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3c30
movq %rax, -0x8(%rbp)
jmp 0x3d21
movq -0x18(%rbp), %rax
movq (%rax), %rax
andq $-0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3c00
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
jne 0x3cf7
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x3d00
jmp 0x3d19
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
andq $-0x2, %rax
movq %rax, -0x20(%rbp)
jmp 0x3ccc
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/rbtree.c
// Function: rbtree_successor
struct rbtree_head *rbtree_successor(const struct rbtree *t,
				     const struct rbtree_head *node)
{
	struct rbtree_head *tmp;

	if (!rbt_is_nil(t, node->right))
		return rbtree_minimum(t, node->right);

	tmp = rbt_get_p(node);
	while (!rbt_is_nil(t, tmp) && node == tmp->right) {
		node = tmp;
		tmp = rbt_get_p(tmp);
	}

	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3c00
cmpl $0x0, %eax
jne 0x3d6d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3bb0
movq %rax, -0x8(%rbp)
jmp 0x3dd1
movq -0x18(%rbp), %rax
movq (%rax), %rax
andq $-0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3c00
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
jne 0x3da7
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x3db0
jmp 0x3dc9
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
andq $-0x2, %rax
movq %rax, -0x20(%rbp)
jmp 0x3d7c
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/rbtree.c
// Function: rbtree_left_rotate
void rbtree_left_rotate(struct rbtree *t, struct rbtree_head *node)
{
	struct rbtree_head *n;

	if (rbt_is_nil(t, node->right))
		return;

	n = node->right;

	node->right = n->left;
	if (!rbt_is_nil(t, n->left))
		rbt_set_p(n->left, node);

	rbt_set_p(n, rbt_get_p(node));
	if (rbt_is_nil(t, rbt_get_p(node))) {
		t->rbt_root = n;
	} else {
		if (rbt_get_p(node)->left == node)
			rbt_get_p(node)->left = n;
		else
			rbt_get_p(node)->right = n;
	}

	n->left = node;
	rbt_set_p(node, n);
}

// 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 0x10(%rax), %rsi
callq 0x3c00
cmpl $0x0, %eax
je 0x3e0b
jmp 0x3f14
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3c00
cmpl $0x0, %eax
jne 0x3e62
movq -0x10(%rbp), %rcx
andq $-0x2, %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
andq $0x1, %rax
orq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
andq $-0x2, %rcx
andq $-0x2, %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
orq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
andq $-0x2, %rsi
callq 0x3c00
cmpl $0x0, %eax
je 0x3eac
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3eeb
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $-0x2, %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x3ed6
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $-0x2, %rax
movq %rcx, 0x8(%rax)
jmp 0x3ee9
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $-0x2, %rax
movq %rcx, 0x10(%rax)
jmp 0x3eeb
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
andq $-0x2, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/rbtree.c
// Function: rbtree_right_rotate
void rbtree_right_rotate(struct rbtree *t, struct rbtree_head *node)
{
	struct rbtree_head *n;

	if (rbt_is_nil(t, node->left))
		return;

	n = node->left;

	node->left = n->right;
	if (!rbt_is_nil(t, n->right))
		rbt_set_p(n->right, node);

	rbt_set_p(n, rbt_get_p(node));
	if (rbt_is_nil(t, rbt_get_p(node))) {
		t->rbt_root = n;
	} else {
		if (rbt_get_p(node)->left == node)
			rbt_get_p(node)->left = n;
		else
			rbt_get_p(node)->right = n;
	}

	n->right = node;
	rbt_set_p(node, n);
}

// 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 0x8(%rax), %rsi
callq 0x3c00
cmpl $0x0, %eax
je 0x3f4b
jmp 0x4054
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3c00
cmpl $0x0, %eax
jne 0x3fa2
movq -0x10(%rbp), %rcx
andq $-0x2, %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
andq $0x1, %rax
orq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
andq $-0x2, %rcx
andq $-0x2, %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
orq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
andq $-0x2, %rsi
callq 0x3c00
cmpl $0x0, %eax
je 0x3fec
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x402b
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $-0x2, %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x4016
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $-0x2, %rax
movq %rcx, 0x8(%rax)
jmp 0x4029
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $-0x2, %rax
movq %rcx, 0x10(%rax)
jmp 0x402b
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
andq $-0x2, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/rbtree.c
// Function: rbtree_insert
void rbtree_insert(struct rbtree *t, struct rbtree_head *node)
{
	struct rbtree_head *prev = &t->rbt_nil;
	struct rbtree_head *n = t->rbt_root;

	while (!rbt_is_nil(t, n)) {
		prev = n;
		n = node->key < n->key ? n->left : n->right;
	}

	if (!rbt_is_nil(t, prev)) {
		rbt_set_p(node, prev);
		if (node->key < prev->key)
			prev->left = node;
		else
			prev->right = node;
	} else {
		rbt_set_p(node, &t->rbt_nil);
		t->rbt_root = node;
	}

	rbt_set_color(node, RBT_RED);	/* Color new node in red */
	node->left = &t->rbt_nil;
	node->right = &t->rbt_nil;

	__rbtree_insert_fixup(t, node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3c00
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x40a2
jmp 0x40de
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x40c8
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x40d4
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x4087
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3c00
cmpl $0x0, %eax
jne 0x4139
movq -0x18(%rbp), %rcx
andq $-0x2, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x412b
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x4137
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x4165
movq -0x8(%rbp), %rcx
addq $0x8, %rcx
andq $-0x2, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
andq $-0x2, %rcx
orq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
addq $0x8, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
addq $0x8, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x41b0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/rbtree.c
// Function: rbtree_lookup
struct rbtree_head *rbtree_lookup(struct rbtree *t, uint32_t key)
{
	struct rbtree_head *n = t->rbt_root;

	while (!rbt_is_nil(t, n)) {
		if (n->key == key)
			return n;
		else if (n->key > key)
			n = n->left;
		else
			n = n->right;
	}

	return &t->rbt_nil;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3c00
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4bb5
jmp 0x4bf5
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x4bcb
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4c01
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jbe 0x4be5
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4bf1
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4bf3
jmp 0x4b9a
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/oobmsg.c
// Function: oob_print
void oob_print(const char *fmt, ...)
{
	va_list val;

	fflush(stdout);	/* Syncronize stdout stream */

	va_start(val, fmt);

	vfprintf(stderr, fmt, val);

	fflush(stderr);	/* Syncronize stderr stream */

	va_end(val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x4c45
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x4365(%rip), %rax      # 0x8fd8
movq (%rax), %rdi
callq 0x1110
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq 0x4355(%rip), %rax      # 0x8ff8
movq %rax, -0xd8(%rbp)
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1160
movq -0xd8(%rbp), %rax
movq (%rax), %rdi
callq 0x1110
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regf_cmn.c
// Function: _regf_cell_check_basic
static inline int __regf_cell_check_basic(const struct regf_cell *cell,
					  unsigned off, const char *cell_type)
{
	if (off % 8) {
		PR_ERR(off, cell_type, "unaligned cell offset\n");
		return -1;
	}

	if (cell->sz > 0) {
		PR_ERR(off, cell_type, "cell is marked as free\n");
		return -1;
	}

	if (cell->sz == 0) {
		PR_ERR(off, cell_type, "zero cell size\n");
		return -1;
	}

	if (-cell->sz % 8) {
		PR_ERR(off, cell_type, "unaligned cell length 0x%08X\n",
		       -cell->sz);
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
andl $0x7, %eax
cmpl $0x0, %eax
je 0x4d5f
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq 0x220c(%rip), %rdi      # 0x6f58
movb $0x0, %al
callq 0x4c10
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4def
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x4d86
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq 0x2208(%rip), %rdi      # 0x6f7e
movb $0x0, %al
callq 0x4c10
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4def
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x4dad
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq 0x2208(%rip), %rdi      # 0x6fa5
movb $0x0, %al
callq 0x4c10
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4def
movq -0x10(%rbp), %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x4de8
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
subl (%rax), %ecx
leaq 0x21ec(%rip), %rdi      # 0x6fc4
movb $0x0, %al
callq 0x4c10
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4def
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regf_cmn.c
// Function: regf_cell_check_sign
int regf_cell_check_sign(const void *base, unsigned off, const char *sign)
{
	const struct regf_cell *cell = base + off;

	if (__regf_cell_check_basic(cell, off, sign))
		return -1;

	return __regf_cell_check_sign(cell, off, sign);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x4d20
cmpl $0x0, %eax
je 0x4e3f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4e52
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x4e60
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regf_cmn.c
// Function: _regf_cell_check_sign
static inline int __regf_cell_check_sign(const struct regf_cell *cell,
					 unsigned off, const char *sign)
{
	const char *__sign = (void *)cell->data;

	if (*(uint16_t *)__sign ^ *(uint16_t *)sign) {
		PR_ERR(off, sign, "invalid cell signature %02X %02X (%.2s)\n",
		       __sign[0], __sign[1], __sign);
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzwl (%rax), %eax
movq -0x20(%rbp), %rcx
movzwl (%rcx), %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
je 0x4ec6
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
movq -0x28(%rbp), %rax
movsbl 0x1(%rax), %r8d
movq -0x28(%rbp), %r9
leaq 0x213b(%rip), %rdi      # 0x6ff1
movb $0x0, %al
callq 0x4c10
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4ecd
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/rsa9000[P]regfanalysistools/regf_cmn.c
// Function: regf_cell_check_len
int regf_cell_check_len(const void *base, unsigned off, const char *cell_type,
			unsigned data_min_len)
{
	const struct regf_cell *cell = base + off;

	if (__regf_cell_check_basic(cell, off, cell_type))
		return -1;

	return __regf_cell_check_len(cell, off, cell_type, data_min_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x4d20
cmpl $0x0, %eax
je 0x4f22
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4f38
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x4f50
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regf_cmn.c
// Function: _regf_cell_check_len
static inline int __regf_cell_check_len(const struct regf_cell *cell,
					unsigned off, const char *cell_type,
					unsigned data_min_len)
{
	unsigned len = (sizeof(*cell) + data_min_len + 7) & ~7;	/* Align */

	if (len > -cell->sz) {
		PR_ERR(off, cell_type,
		       "cell space (0x%08X) is too small for 0x%08X bytes of data\n",
		       -cell->sz - sizeof(*cell), data_min_len);
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x4, %rax
addq $0x7, %rax
andq $-0x8, %rax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x10(%rbp), %rdx
xorl %ecx, %ecx
subl (%rdx), %ecx
cmpl %ecx, %eax
jbe 0x4fb8
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
xorl %eax, %eax
subl (%rcx), %eax
movslq %eax, %rcx
subq $0x4, %rcx
movl -0x24(%rbp), %r8d
leaq 0x2081(%rip), %rdi      # 0x7029
movb $0x0, %al
callq 0x4c10
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4fbf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regf_cmn.c
// Function: regf_cell_check_sign_len
int regf_cell_check_sign_len(const void *base, unsigned off, const char *sign,
			     unsigned data_min_len)
{
	const struct regf_cell *cell = base + off;

	if (__regf_cell_check_basic(cell, off, sign))
		return -1;

	if (__regf_cell_check_sign(cell, off, sign))
		return -1;

	return __regf_cell_check_len(cell, off, sign, data_min_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x4d20
cmpl $0x0, %eax
je 0x5012
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5046
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x4e60
cmpl $0x0, %eax
je 0x5030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5046
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x4f50
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sTeeLM[P]dwipe/device.c
// Function: dwipe_is_partition
int dwipe_is_partition(const char * name)
{
    /* if /sys/class/block/sda1/device/partition exist ? */
    char b [FILENAME_MAX];

    snprintf(b, sizeof(b), "/sys/class/block/%s/partition", name);
    dwipe_log( DWIPE_LOG_INFO, "testing device '%s'.", b );
    if(!access(b, F_OK)) {
        dwipe_log( DWIPE_LOG_INFO, "'%s' is a partition.", name );
        return 1;
    }
    dwipe_log( DWIPE_LOG_INFO, "'%s' is not a partition.", name );
    return 0;
}

// Assembly:
subq $0x1018, %rsp           # imm = 0x1018
movq %rdi, 0x1008(%rsp)
movq %rsp, %rdi
movq 0x1008(%rsp), %rcx
movl $0x1000, %esi           # imm = 0x1000
leaq 0xc0e0(%rip), %rdx      # 0xf846
movb $0x0, %al
callq 0x3180
movq %rsp, %rdx
movl $0x2, %edi
leaq 0xc0e8(%rip), %rsi      # 0xf864
movb $0x0, %al
callq 0xade0
movq %rsp, %rdi
xorl %esi, %esi
callq 0x3350
cmpl $0x0, %eax
jne 0x37ba
movq 0x1008(%rsp), %rdx
movl $0x2, %edi
leaq 0xc0d3(%rip), %rsi      # 0xf879
movb $0x0, %al
callq 0xade0
movl $0x1, 0x1014(%rsp)
jmp 0x37e0
movq 0x1008(%rsp), %rdx
movl $0x2, %edi
leaq 0xc0c0(%rip), %rsi      # 0xf88e
movb $0x0, %al
callq 0xade0
movl $0x0, 0x1014(%rsp)
movl 0x1014(%rsp), %eax
addq $0x1018, %rsp           # imm = 0x1018
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sTeeLM[P]dwipe/gui.c
// Function: dwipe_gui_title
void dwipe_gui_title( WINDOW* w, const char* s )
{
/**
 * Prints the string 's' centered on the first line of the window 'w'.
 *
 */

	/* The number of lines in the window. (Not used.) */
	int wy;

	/* The number of columns in the window. */
	int wx;

	/* Get the window dimensions. */
	getmaxyx( w, wy, wx );
	
	/* Print the title. */
	mvwprintw( w, 0, ( wx - strlen( s ) ) / 2, "%s", s );

}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
xorl %eax, %eax
cmpq 0x30(%rsp), %rax
je 0x5aa9
movq 0x30(%rsp), %rax
movswl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x5ab4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x1c(%rsp)
jmp 0x5ab4
movl 0x1c(%rsp), %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
cmpq 0x30(%rsp), %rax
je 0x5ad7
movq 0x30(%rsp), %rax
movswl 0x6(%rax), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x5ae2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x18(%rsp)
jmp 0x5ae2
movl 0x18(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movslq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3150
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
subq %rcx, %rax
shrq %rax
movl %eax, %edx
movq 0x28(%rsp), %r8
xorl %esi, %esi
leaq 0xa6ba(%rip), %rcx      # 0x101e5
movb $0x0, %al
callq 0x31c0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sTeeLM[P]dwipe/gui.c
// Function: dwipe_gui_free
void dwipe_gui_free( void )
{
/**
 * Releases the ncurses gui.
 *
 */

	/* Free ncurses resources. */
	delwin( footer_window  );
	delwin( header_window  );
	delwin( main_window    );
	delwin( options_window );
	delwin( stats_window   );
	endwin();

}

// Assembly:
pushq %rax
movq 0xe858(%rip), %rdi      # 0x14800
callq 0x32c0
movq 0xe844(%rip), %rdi      # 0x147f8
callq 0x32c0
movq 0xe858(%rip), %rdi      # 0x14818
callq 0x32c0
movq 0xe83c(%rip), %rdi      # 0x14808
callq 0x32c0
movq 0xe838(%rip), %rdi      # 0x14810
callq 0x32c0
callq 0x3420
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sTeeLM[P]dwipe/gui.c
// Function: dwipe_gui_load
void
dwipe_gui_load( void )
{
/**
 * Prints the system load average to the statistics window.
 *
 * @modifies stat_window      Prints the system load average to the statistics window.
 *
 */

	/* A file handle for the stat file. */
	FILE* dwipe_fp;

	/* The one, five, and fifteen minute load averages. */
	float load_01;
	float load_05;
	float load_15;


	/* Open the loadavg file. */
	dwipe_fp = fopen( DWIPE_KNOB_LOADAVG, "r" );

	/* Print the label. */
	mvwprintw( stats_window, DWIPE_GUI_STATS_LOAD_Y, DWIPE_GUI_STATS_LOAD_X, "Load Averages:" );

	if( dwipe_fp )
	{
		/* The load averages are the first three numbers in the file. */
		if( 3 == fscanf( dwipe_fp, "%f %f %f", &load_01, &load_05, &load_15 ) )
		{
			/* Print the load average. */
			mvwprintw( stats_window, DWIPE_GUI_STATS_LOAD_Y, DWIPE_GUI_STATS_TAB,
			  "%04.2f %04.2f %04.2f", load_01, load_05, load_15 );
		}

		else
		{
			/* Print an error. */
			mvwprintw( stats_window, DWIPE_GUI_STATS_LOAD_Y, DWIPE_GUI_STATS_TAB, "(fscanf error %i)", errno );
		}

		/* Close the loadavg file. */
		fclose( dwipe_fp );
	}

	else
	{
		mvwprintw( stats_window, DWIPE_GUI_STATS_LOAD_Y, DWIPE_GUI_STATS_TAB, "(fopen error %i)", errno );
	}

}

// Assembly:
subq $0x28, %rsp
leaq 0x8654(%rip), %rdi      # 0x1103f
leaq 0x66c3(%rip), %rsi      # 0xf0b5
callq 0x3280
movq %rax, 0x20(%rsp)
movq 0xbe0d(%rip), %rdi      # 0x14810
movl $0x3, %esi
movl $0x1, %edx
leaq 0x8639(%rip), %rcx      # 0x1104d
movb $0x0, %al
callq 0x31c0
cmpq $0x0, 0x20(%rsp)
je 0x8ad0
movq 0x20(%rsp), %rdi
leaq 0x8629(%rip), %rsi      # 0x1105c
leaq 0x1c(%rsp), %rdx
leaq 0x18(%rsp), %rcx
leaq 0x14(%rsp), %r8
movb $0x0, %al
callq 0x30e0
movl %eax, %ecx
movl $0x3, %eax
cmpl %ecx, %eax
jne 0x8a93
movq 0xbdb5(%rip), %rdi      # 0x14810
movss 0x1c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movss 0x18(%rsp), %xmm1
cvtss2sd %xmm1, %xmm1
movss 0x14(%rsp), %xmm2
cvtss2sd %xmm2, %xmm2
movl $0x3, %esi
movl $0x10, %edx
leaq 0x85db(%rip), %rcx      # 0x11065
movb $0x3, %al
callq 0x31c0
jmp 0x8ac4
movq 0xbd76(%rip), %rax      # 0x14810
movq %rax, 0x8(%rsp)
callq 0x3070
movq 0x8(%rsp), %rdi
movl (%rax), %r8d
movl $0x3, %esi
movl $0x10, %edx
leaq 0x85bd(%rip), %rcx      # 0x1107a
movb $0x0, %al
callq 0x31c0
movq 0x20(%rsp), %rdi
callq 0x3140
jmp 0x8aff
movq 0xbd39(%rip), %rax      # 0x14810
movq %rax, (%rsp)
callq 0x3070
movq (%rsp), %rdi
movl (%rax), %r8d
movl $0x3, %esi
movl $0x10, %edx
leaq 0x8594(%rip), %rcx      # 0x1108c
movb $0x0, %al
callq 0x31c0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)