LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x139a
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x5c37(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
callq 0x1100
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq 0x5c28(%rip), %r14      # 0x6ff8
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1150
movq (%r14), %rdi
callq 0x1100
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %esi, %ebp
movq %rdi, %rsi
leaq 0x20(%rsp), %rdi
movq %rsp, %rax
movq %rdi, (%rax)
leaq 0x5171(%rip), %rbx      # 0x7140
leaq 0x18(%rsp), %r15
movq %rbx, (%r15)
movl %ebp, %eax
shrl %eax
cmpl $0x66, %ebp
movl $0x32, %r14d
cmovbl %eax, %r14d
movl %r14d, %r12d
addl %r12d, %r12d
movq %r12, %rdx
callq 0x10e0
leaq 0x10(%rsp), %r13
movq %r12, (%r13)
leaq (,%r14,4), %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq 0x50d9(%rip), %rdi      # 0x70f0
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1050
movq 0x50c4(%rip), %rdi      # 0x70f0
movq %rsp, %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x1050
cmpq $-0x1, %rax
je 0x206c
cmpl $0x66, %ebp
jb 0x2075
movabsq $0x2e0000002e, %rax     # imm = 0x2E0000002E
movq %rax, 0x51af(%rip)      # 0x7208
movl $0x2e, 0x51ad(%rip)     # 0x7210
leaq 0x51aa(%rip), %rax      # 0x7214
jmp 0x2079
leaq 0x2e39(%rip), %rbx      # 0x4eac
jmp 0x207f
leaq (%rbx,%r14,4), %rax
movl $0x0, (%rax)
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x505b(%rip), %r15      # 0x7100
leaq 0x2c57(%rip), %rdx      # 0x4d03
movq %r15, %rdi
movl $0x4, %ecx
callq 0x341e
testl %eax, %eax
je 0x20c8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
movl %ebx, %eax
leaq (%r15,%rax), %rcx
addq %rax, %r15
addq $0x4, %r15
xorl %r8d, %r8d
subl (%rcx), %r8d
leaq 0x260f(%rip), %rdi      # 0x46f1
movq %r14, %rsi
movq %r15, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x10a0
leaq 0x261c(%rip), %rsi      # 0x4714
movl $0x2, %edx
movq %r15, %rdi
callq 0x1040
testl %eax, %eax
je 0x216d
leaq 0x2607(%rip), %rsi      # 0x4717
movl $0x2, %edx
movq %r15, %rdi
callq 0x1040
testl %eax, %eax
je 0x217c
leaq 0x25f2(%rip), %rsi      # 0x471a
movl $0x2, %edx
movq %r15, %rdi
callq 0x1040
testl %eax, %eax
je 0x218b
leaq 0x25dd(%rip), %rsi      # 0x471d
movl $0x2, %edx
movq %r15, %rdi
callq 0x1040
testl %eax, %eax
je 0x219a
leaq 0x25c8(%rip), %rdi      # 0x4720
leaq 0x2ba4(%rip), %rdx      # 0x4d03
movl %ebx, %esi
xorl %eax, %eax
callq 0x1339
jmp 0x20bd
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2306
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2433
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x255b
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2678
// File: /workspace/github_c_makefile_star2_O1/rsa9000[P]regfanalysistools/regfwalk.c
// Function: regf_parse_vlst
static int regf_parse_vlst(const char *pref, unsigned off, unsigned num)
{
#define VLST_PR_WARN(__fmt, ...)	PR_WARN(off, "vlst", __fmt, ##__VA_ARGS__)
	const struct regf_cell *rc = st.data + off;
	const uint32_t *vals = (void *)rc->data;
	size_t pref_len = strlen(pref);
	char __pref[pref_len + 3];
	struct cell *cell;
	unsigned i;
	int res, ret = 0;

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

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

	snprintf(__pref, sizeof(__pref), "%s  ", pref);

	for (i = 0; i < num; ++i) {
		printf("%svals[%u] = 0x%08X\n", pref, i, vals[i]);
		cell = cache_cell_find(vals[i]);
		if (!cell) {
			VLST_PR_WARN("could not find value cell 0x%08X\n",
				     vals[i]);
			ret = -1;
			continue;
		}
		cache_cell_updref(cell, CT_VK);
		res = regf_parse_vk(__pref, vals[i]);
		if (res) {
			VLST_PR_WARN("could not parse value key in cell 0x%08X\n",
				     vals[i]);
			ret = -1;
			continue;
		}
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r13d
movl %esi, %ebx
movq %rdi, %r14
movq 0x4f37(%rip), %r15      # 0x7100
callq 0x1080
movq %rax, %r12
movq %rsp, %rcx
addq $0x12, %rax
andq $-0x10, %rax
subq %rax, %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, %rsp
movq %r13, -0x38(%rbp)
leal (,%r13,4), %ecx
leaq 0x26f8(%rip), %rdx      # 0x48f1
movq %r15, %rdi
movl %ebx, -0x2c(%rbp)
movl %ebx, %esi
callq 0x341e
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x22f4
movl -0x2c(%rbp), %edx
movl %edx, %eax
addq %rax, %r15
addq $0x3, %r12
xorl %r13d, %r13d
xorl %ecx, %ecx
subl (%r15), %ecx
leaq 0x26c7(%rip), %rdi      # 0x48f6
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
leaq 0x20bc(%rip), %rdx      # 0x42fc
movq -0x40(%rbp), %rdi
movq %r12, %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x10b0
cmpl $0x0, -0x38(%rbp)
je 0x22f4
movl -0x38(%rbp), %ebx
xorl %r12d, %r12d
xorl %r13d, %r13d
movl 0x4(%r15,%r12,4), %ecx
leaq 0x26a9(%rip), %rdi      # 0x4919
movq %r14, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x10a0
movl 0x4(%r15,%r12,4), %esi
leaq 0x4e8f(%rip), %rdi      # 0x7118
callq 0x3329
leaq 0x4e8b(%rip), %rcx      # 0x7120
cmpq %rcx, %rax
sete %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
leaq 0x2684(%rip), %rdi      # 0x492e
jne 0x22cc
incl 0x24(%rax)
orb $0x40, 0x28(%rax)
movl 0x4(%r15,%r12,4), %esi
movq -0x40(%rbp), %rdi
callq 0x2795
leaq 0x2698(%rip), %rdi      # 0x4960
testl %eax, %eax
je 0x22e8
movl 0x4(%r15,%r12,4), %ecx
movl -0x2c(%rbp), %esi
leaq 0x2616(%rip), %rdx      # 0x48f1
xorl %eax, %eax
callq 0x1339
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
incq %r12
cmpq %r12, %rbx
jne 0x2264
movl %r13d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rsa9000[P]regfanalysistools/regfwalk.c
// Function: regf_parse_lst_lf
static int regf_parse_lst_lf(const char *pref, unsigned off)
{
#define LF_PR_WARN(__fmt, ...)	PR_WARN(off, "lf", __fmt, ##__VA_ARGS__)
	const struct regf_cell *rc = st.data + off;
	const struct regf_lst *lst = (void *)rc->data;
	const struct regf_lf_elem *elems = (void *)lst->data;
	size_t pref_len = strlen(pref);
	char __pref[pref_len + 3];
	struct cell *cell;
	int i, res, ret = 0;

	snprintf(__pref, sizeof(__pref), "%s  ", pref);

	printf("%slf.nelem = %u\n", pref, lst->nelem);
	for (i = 0; i < lst->nelem; ++i) {
		printf("%slf.elem[%u]{off,hint} = 0x%08X, %.4s\n",
		       pref, i, elems[i].off, elems[i].hint);
		cell = cache_cell_find(elems[i].off);
		if (!cell) {
			LF_PR_WARN("could not find key cell 0x%08X\n",
				   elems[i].off);
			ret = -1;
			continue;
		}
		cache_cell_updref(cell, CT_NK);
		res = regf_parse_nk(pref, elems[i].off);
		if (res) {
			LF_PR_WARN("could not parse subkey in cell 0x%08X\n",
				   elems[i].off);
			ret = -1;
			continue;
		}
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x4de2(%rip), %r12      # 0x7100
movl %esi, -0x2c(%rbp)
movl %esi, %r13d
callq 0x1080
leaq 0x3(%rax), %rsi
movq %rsp, %rdi
addq $0x12, %rax
andq $-0x10, %rax
subq %rax, %rdi
movq %rdi, %rsp
leaq 0x1fb7(%rip), %rdx      # 0x42fc
xorl %r15d, %r15d
movq %r14, %rcx
xorl %eax, %eax
callq 0x10b0
movzwl 0x6(%r12,%r13), %edx
leaq 0x23eb(%rip), %rdi      # 0x474a
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
cmpw $0x0, 0x6(%r12,%r13)
je 0x2421
leaq (%r12,%r13), %rbx
addq %r13, %r12
addq $0xc, %r12
xorl %r13d, %r13d
xorl %r15d, %r15d
movl 0x8(%rbx,%r13,8), %ecx
leaq 0x23c8(%rip), %rdi      # 0x475b
movq %r14, %rsi
movl %r13d, %edx
movq %r12, %r8
xorl %eax, %eax
callq 0x10a0
movl 0x8(%rbx,%r13,8), %esi
leaq 0x4d69(%rip), %rdi      # 0x7118
callq 0x3329
leaq 0x4d65(%rip), %rcx      # 0x7120
cmpq %rcx, %rax
sete %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
leaq 0x23b3(%rip), %rdi      # 0x4783
jne 0x23f1
incl 0x24(%rax)
orb $0x2, 0x28(%rax)
movl 0x8(%rbx,%r13,8), %esi
movq %r14, %rdi
callq 0x19fb
leaq 0x23c6(%rip), %rdi      # 0x47b3
testl %eax, %eax
je 0x240d
movl 0x8(%rbx,%r13,8), %ecx
movl -0x2c(%rbp), %esi
leaq 0x2314(%rip), %rdx      # 0x4714
xorl %eax, %eax
callq 0x1339
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
incq %r13
movzwl 0x6(%rbx), %eax
addq $0x8, %r12
cmpq %rax, %r13
jb 0x2387
movl %r15d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rsa9000[P]regfanalysistools/regfwalk.c
// Function: regf_parse_lst_lh
static int regf_parse_lst_lh(const char *pref, unsigned off)
{
#define LH_PR_WARN(__fmt, ...)	PR_WARN(off, "lh", __fmt, ##__VA_ARGS__)
	const struct regf_cell *rc = st.data + off;
	const struct regf_lst *lst = (void *)rc->data;
	const struct regf_lh_elem *elems = (void *)lst->data;
	size_t pref_len = strlen(pref);
	char __pref[pref_len + 3];
	struct cell *cell;
	int i, res, ret = 0;

	snprintf(__pref, sizeof(__pref), "%s  ", pref);

	printf("%slh.nelem = %u\n", pref, lst->nelem);
	for (i = 0; i < lst->nelem; ++i) {
		printf("%slh.elem[%u]{off,hash} = 0x%08X, 0x%08X\n",
		       pref, i, elems[i].off, elems[i].hash);
		cell = cache_cell_find(elems[i].off);
		if (!cell) {
			LH_PR_WARN("could not find key cell 0x%08X\n",
				   elems[i].off);
			ret = -1;
			continue;
		}
		cache_cell_updref(cell, CT_NK);
		res = regf_parse_nk(pref, elems[i].off);
		if (res) {
			LH_PR_WARN("could not parse subkey in cell 0x%08X\n",
				   elems[i].off);
			ret = -1;
			continue;
		}
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x4cb5(%rip), %rbx      # 0x7100
movl %esi, -0x2c(%rbp)
movl %esi, %r12d
callq 0x1080
leaq 0x3(%rax), %rsi
movq %rsp, %rdi
addq $0x12, %rax
andq $-0x10, %rax
subq %rax, %rdi
movq %rdi, %rsp
leaq 0x1e8a(%rip), %rdx      # 0x42fc
xorl %r15d, %r15d
movq %r14, %rcx
xorl %eax, %eax
callq 0x10b0
movzwl 0x6(%rbx,%r12), %edx
leaq 0x235e(%rip), %rdi      # 0x47ea
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
cmpw $0x0, 0x6(%rbx,%r12)
je 0x2549
leaq (%rbx,%r12), %r13
addq %r12, %rbx
addq $0x8, %rbx
xorl %r12d, %r12d
xorl %r15d, %r15d
movl (%rbx,%r12,8), %ecx
movl 0x4(%rbx,%r12,8), %r8d
leaq 0x2337(%rip), %rdi      # 0x47fb
movq %r14, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x10a0
movl (%rbx,%r12,8), %esi
leaq 0x4c3c(%rip), %rdi      # 0x7118
callq 0x3329
leaq 0x4c38(%rip), %rcx      # 0x7120
cmpq %rcx, %rax
sete %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
leaq 0x2286(%rip), %rdi      # 0x4783
jne 0x251d
incl 0x24(%rax)
orb $0x2, 0x28(%rax)
movl (%rbx,%r12,8), %esi
movq %r14, %rdi
callq 0x19fb
leaq 0x229a(%rip), %rdi      # 0x47b3
testl %eax, %eax
je 0x2538
movl (%rbx,%r12,8), %ecx
movl -0x2c(%rbp), %esi
leaq 0x21ec(%rip), %rdx      # 0x4717
xorl %eax, %eax
callq 0x1339
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
incq %r12
movzwl 0x6(%r13), %eax
cmpq %rax, %r12
jb 0x24b4
movl %r15d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rsa9000[P]regfanalysistools/regfwalk.c
// Function: regf_parse_lst_li
static int regf_parse_lst_li(const char *pref, unsigned off)
{
#define LI_PR_WARN(__fmt, ...)	PR_WARN(off, "li", __fmt, ##__VA_ARGS__)
	const struct regf_cell *rc = st.data + off;
	const struct regf_lst *lst = (void *)rc->data;
	const struct regf_li_elem *elems = (void *)lst->data;
	size_t pref_len = strlen(pref);
	char __pref[pref_len + 3];
	struct cell *cell;
	int i, res, ret = 0;

	snprintf(__pref, sizeof(__pref), "%s  ", pref);

	printf("%sli.nelem = %u\n", pref, lst->nelem);
	for (i = 0; i < lst->nelem; ++i) {
		printf("%sli.elem[%u].off = 0x%08X\n",
		       pref, i, elems[i].off);
		cell = cache_cell_find(elems[i].off);
		if (!cell) {
			LI_PR_WARN("could not find key cell 0x%08X\n",
				   elems[i].off);
			ret = -1;
			continue;
		}
		cache_cell_updref(cell, CT_NK);
		res = regf_parse_nk(pref, elems[i].off);
		if (res) {
			LI_PR_WARN("could not parse subkey in cell 0x%08X\n",
				   elems[i].off);
			ret = -1;
			continue;
		}
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x4b8b(%rip), %r13      # 0x7100
movl %esi, %r12d
callq 0x1080
leaq 0x3(%rax), %rsi
movq %rsp, %rdi
addq $0x12, %rax
andq $-0x10, %rax
subq %rax, %rdi
movq %rdi, %rsp
leaq 0x1d63(%rip), %rdx      # 0x42fc
xorl %r15d, %r15d
movq %r14, %rcx
xorl %eax, %eax
callq 0x10b0
movzwl 0x6(%r13,%r12), %edx
leaq 0x2272(%rip), %rdi      # 0x4825
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
cmpw $0x0, 0x6(%r13,%r12)
je 0x2666
addq %r12, %r13
xorl %r12d, %r12d
xorl %r15d, %r15d
movl 0x8(%r13,%r12,4), %ecx
leaq 0x2257(%rip), %rdi      # 0x4836
movq %r14, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x10a0
movl 0x8(%r13,%r12,4), %esi
leaq 0x4b20(%rip), %rdi      # 0x7118
callq 0x3329
leaq 0x4b1c(%rip), %rcx      # 0x7120
cmpq %rcx, %rax
sete %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
leaq 0x216a(%rip), %rdi      # 0x4783
jne 0x263a
incl 0x24(%rax)
orb $0x2, 0x28(%rax)
movl 0x8(%r13,%r12,4), %esi
movq %r14, %rdi
callq 0x19fb
leaq 0x217d(%rip), %rdi      # 0x47b3
testl %eax, %eax
je 0x2655
movl 0x8(%r13,%r12,4), %ecx
movl %ebx, %esi
leaq 0x20d2(%rip), %rdx      # 0x471a
xorl %eax, %eax
callq 0x1339
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
incq %r12
movzwl 0x6(%r13), %eax
cmpq %rax, %r12
jb 0x25d3
movl %r15d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rsa9000[P]regfanalysistools/regfwalk.c
// Function: regf_parse_lst_ri
static int regf_parse_lst_ri(const char *pref, unsigned off)
{
#define RI_PR_WARN(__fmt, ...)	PR_WARN(off, "ri", __fmt, ##__VA_ARGS__)
	const struct regf_cell *rc = st.data + off;
	const struct regf_lst *lst = (void *)rc->data;
	const struct regf_ri_elem *elems = (void *)lst->data;
	size_t pref_len = strlen(pref);
	char __pref[pref_len + 3];
	struct cell *cell;
	int i, res, ret = 0;

	snprintf(__pref, sizeof(__pref), "%s  ", pref);

	printf("%sri.nelem = %u\n", pref, lst->nelem);
	for (i = 0; i < lst->nelem; ++i) {
		printf("%sri.elem[%u].off = 0x%08X\n",
		       pref, i, elems[i].off);
		cell = cache_cell_find(elems[i].off);
		if (!cell) {
			RI_PR_WARN("could not find keys list cell 0x%08X\n",
				   elems[i].off);
			ret = -1;
			continue;
		}
		cache_cell_updref(cell, CT_LST);
		res = regf_parse_lst(pref, elems[i].off);
		if (res) {
			RI_PR_WARN("could not parse subkey list in cell 0x%08X\n",
				   elems[i].off);
			ret = -1;
			continue;
		}
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x4a6e(%rip), %r13      # 0x7100
movl %esi, %r12d
callq 0x1080
leaq 0x3(%rax), %rsi
movq %rsp, %rdi
addq $0x12, %rax
andq $-0x10, %rax
subq %rax, %rdi
movq %rdi, %rsp
leaq 0x1c46(%rip), %rdx      # 0x42fc
xorl %r15d, %r15d
movq %r14, %rcx
xorl %eax, %eax
callq 0x10b0
movzwl 0x6(%r13,%r12), %edx
leaq 0x2182(%rip), %rdi      # 0x4852
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
cmpw $0x0, 0x6(%r13,%r12)
je 0x2783
addq %r12, %r13
xorl %r12d, %r12d
xorl %r15d, %r15d
movl 0x8(%r13,%r12,4), %ecx
leaq 0x2167(%rip), %rdi      # 0x4863
movq %r14, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x10a0
movl 0x8(%r13,%r12,4), %esi
leaq 0x4a03(%rip), %rdi      # 0x7118
callq 0x3329
leaq 0x49ff(%rip), %rcx      # 0x7120
cmpq %rcx, %rax
sete %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
leaq 0x2149(%rip), %rdi      # 0x487f
jne 0x2757
incl 0x24(%rax)
orb $0x10, 0x28(%rax)
movl 0x8(%r13,%r12,4), %esi
movq %r14, %rdi
callq 0x2094
leaq 0x2162(%rip), %rdi      # 0x48b5
testl %eax, %eax
je 0x2772
movl 0x8(%r13,%r12,4), %ecx
movl %ebx, %esi
leaq 0x1fb8(%rip), %rdx      # 0x471d
xorl %eax, %eax
callq 0x1339
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
incq %r12
movzwl 0x6(%r13), %eax
cmpq %rax, %r12
jb 0x26f0
movl %r15d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x3, %edx
jg 0x2c09
cmpl $0x1, %edx
je 0x2cac
cmpl $0x2, %edx
jne 0x2c50
movq %r14, %rdi
movl %ecx, %esi
callq 0x1fa7
leaq 0x1ffe(%rip), %rdi      # 0x4c02
jmp 0x2cbd
cmpl $0xb, %edx
je 0x2cc8
cmpl $0x4, %edx
jne 0x2c50
testl %ecx, %ecx
je 0x2d3c
cmpl $0x4, %ecx
jne 0x2d4e
movl (%r14), %ecx
leaq 0x46ee(%rip), %r14      # 0x7320
leaq 0x1fe3(%rip), %rdx      # 0x4c1c
movl $0x20, %esi
movq %r14, %rdi
movl %ecx, %r8d
xorl %eax, %eax
callq 0x10b0
jmp 0x2d55
movq %rbx, 0x10(%rsp)
testl %ecx, %ecx
movl %ecx, 0xc(%rsp)
je 0x2cfa
cmpl $0x10, %ecx
movl $0x10, %r13d
cmovbl %ecx, %r13d
leaq 0x470b(%rip), %rbx      # 0x7380
leaq 0x1fcc(%rip), %r12      # 0x4c48
xorl %ebp, %ebp
movq %rbx, %r15
movq %rbx, %rsi
subq %r15, %rsi
addq $0x35, %rsi
movzbl (%r14,%rbp), %ecx
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x10b0
cltq
addq %rax, %r15
incq %rbp
cmpq %rbp, %r13
jne 0x2c81
jmp 0x2d01
movq %r14, %rdi
movl %ecx, %esi
callq 0x1fa7
leaq 0x1f39(%rip), %rdi      # 0x4bf6
movq %rbx, %rsi
movq %rax, %rdx
jmp 0x2d72
testl %ecx, %ecx
je 0x2d45
cmpl $0x8, %ecx
jne 0x2d5e
movq (%r14), %rcx
leaq 0x4661(%rip), %r14      # 0x7340
leaq 0x1f53(%rip), %rdx      # 0x4c39
movl $0x40, %esi
movq %r14, %rdi
movq %rcx, %r8
xorl %eax, %eax
callq 0x10b0
jmp 0x2d65
leaq 0x467f(%rip), %r15      # 0x7380
cmpl $0x11, 0xc(%rsp)
jb 0x2d27
leaq 0x4671(%rip), %rsi      # 0x7380
subq %r15, %rsi
addq $0x35, %rsi
leaq 0x1f31(%rip), %rdx      # 0x4c4e
movq %r15, %rdi
xorl %eax, %eax
callq 0x10b0
leaq 0x1ee1(%rip), %rdi      # 0x4c0f
leaq 0x464c(%rip), %rdx      # 0x7381
movq 0x10(%rsp), %rsi
jmp 0x2d72
leaq 0x1ed7(%rip), %r14      # 0x4c1a
jmp 0x2d55
leaq 0x1ece(%rip), %r14      # 0x4c1a
jmp 0x2d65
leaq 0x1ed3(%rip), %r14      # 0x4c28
leaq 0x1e80(%rip), %rdi      # 0x4bdc
jmp 0x2d6c
leaq 0x1ec3(%rip), %r14      # 0x4c28
leaq 0x1e7d(%rip), %rdi      # 0x4be9
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10a0
nop
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x8(%rsi), %rcx
addq $0x8, %rdi
cmpq %rcx, %rdi
je 0x2de1
movq %rcx, %rax
movq 0x10(%rcx), %rcx
cmpq %rcx, %rdi
jne 0x2dca
jmp 0x2ded
cmpq 0x8(%rax), %rsi
movq %rax, %rsi
jne 0x2ded
movq (%rsi), %rax
andq $-0x2, %rax
cmpq %rax, %rdi
jne 0x2dd8
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x10(%rsi), %rcx
addq $0x8, %rdi
cmpq %rcx, %rdi
je 0x2e12
movq %rcx, %rax
movq 0x8(%rcx), %rcx
cmpq %rcx, %rdi
jne 0x2dfb
jmp 0x2e1e
cmpq 0x10(%rax), %rsi
movq %rax, %rsi
jne 0x2e1e
movq (%rsi), %rax
andq $-0x2, %rax
cmpq %rax, %rdi
jne 0x2e09
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x10(%rsi), %rax
leaq 0x8(%rdi), %rcx
cmpq %rax, %rcx
je 0x2e94
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsi)
cmpq %rdx, %rcx
je 0x2e4d
movq %rsi, %r8
andq $-0x2, %r8
movq (%rdx), %r9
andl $0x1, %r9d
orq %r8, %r9
movq %r9, (%rdx)
movq (%rsi), %rdx
andq $-0x2, %rdx
movq (%rax), %r8
andl $0x1, %r8d
orq %rdx, %r8
movq %r8, (%rax)
movq (%rsi), %rdx
movq %rdx, %r8
andq $-0x2, %r8
cmpq %r8, %rcx
je 0x2e80
leaq 0x8(%r8), %rcx
leaq 0x10(%r8), %rdi
cmpq %rsi, 0x8(%r8)
cmoveq %rcx, %rdi
movq %rax, (%rdi)
movq %rsi, 0x8(%rax)
andq $-0x2, %rax
andl $0x1, %edx
orq %rax, %rdx
movq %rdx, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x8(%rsi), %rax
leaq 0x8(%rdi), %rcx
cmpq %rax, %rcx
je 0x2f0a
movq 0x10(%rax), %rdx
movq %rdx, 0x8(%rsi)
cmpq %rdx, %rcx
je 0x2ec3
movq %rsi, %r8
andq $-0x2, %r8
movq (%rdx), %r9
andl $0x1, %r9d
orq %r8, %r9
movq %r9, (%rdx)
movq (%rsi), %rdx
andq $-0x2, %rdx
movq (%rax), %r8
andl $0x1, %r8d
orq %rdx, %r8
movq %r8, (%rax)
movq (%rsi), %rdx
movq %rdx, %r8
andq $-0x2, %r8
cmpq %r8, %rcx
je 0x2ef6
leaq 0x8(%r8), %rcx
leaq 0x10(%r8), %rdi
cmpq %rsi, 0x8(%r8)
cmoveq %rcx, %rdi
movq %rax, (%rdi)
movq %rsi, 0x10(%rax)
andq $-0x2, %rax
andl $0x1, %edx
orq %rax, %rdx
movq %rdx, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movq (%rdi), %rsi
movq %rax, %rcx
cmpq %rsi, %rax
je 0x2f3f
movl 0x18(%r14), %edx
movq %rsi, %rcx
xorl %esi, %esi
cmpl 0x18(%rcx), %edx
setae %sil
movq 0x8(%rcx,%rsi,8), %rsi
cmpq %rsi, %rax
jne 0x2f29
movq (%r14), %rdx
andl $0x1, %edx
cmpq %rcx, %rax
je 0x2f66
movq %rcx, %rsi
andq $-0x2, %rsi
orq %rsi, %rdx
movq %rdx, (%r14)
movl 0x18(%r14), %edx
cmpl 0x18(%rcx), %edx
jae 0x2f78
addq $0x8, %rcx
jmp 0x2f7c
movq %rax, %rcx
andq $-0x2, %rcx
orq %rcx, %rdx
movq %rdx, (%r14)
movq %rbx, %rcx
jmp 0x2f7c
addq $0x10, %rcx
movq %r14, (%rcx)
movq (%r14), %r15
movq %r15, %rcx
orq $0x1, %rcx
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %rax, 0x10(%r14)
andq $-0x2, %r15
movq (%r15), %rax
testb $0x1, %al
je 0x3082
andq $-0x2, %rax
movq 0x8(%rax), %rcx
cmpq %r15, %rcx
je 0x3002
testb $0x1, (%rcx)
jne 0x3054
cmpq 0x8(%r15), %r14
jne 0x2fcd
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2e95
movq %r15, %r14
movq (%r14), %rax
andq $-0x2, %rax
andq $-0x2, (%rax)
movq (%r14), %rax
andq $-0x2, %rax
movq (%rax), %rax
andq $-0x2, %rax
orq $0x1, (%rax)
movq (%r14), %rax
andq $-0x2, %rax
movq (%rax), %rsi
andq $-0x2, %rsi
movq %rbx, %rdi
callq 0x2e1f
jmp 0x307a
movq 0x10(%rax), %rcx
testb $0x1, (%rcx)
jne 0x3054
cmpq 0x10(%r15), %r14
jne 0x301f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2e1f
movq %r15, %r14
movq (%r14), %rax
andq $-0x2, %rax
andq $-0x2, (%rax)
movq (%r14), %rax
andq $-0x2, %rax
movq (%rax), %rax
andq $-0x2, %rax
orq $0x1, (%rax)
movq (%r14), %rax
andq $-0x2, %rax
movq (%rax), %rsi
andq $-0x2, %rsi
movq %rbx, %rdi
callq 0x2e95
jmp 0x307a
movq %rax, (%r15)
andb $-0x2, (%rcx)
movq (%r14), %rax
andq $-0x2, %rax
movq (%rax), %rax
andq $-0x2, %rax
orq $0x1, (%rax)
movq (%r14), %rax
andq $-0x2, %rax
movq (%rax), %r14
andq $-0x2, %r14
movq (%r14), %r15
jmp 0x2f94
movq (%rbx), %rax
andq $-0x2, (%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rdi, %rax
movq (%rdi), %rcx
addq $0x8, %rax
cmpq %rcx, %rax
je 0x334d
cmpl %esi, 0x18(%rcx)
je 0x334a
setbe %dl
movzbl %dl, %edx
movq 0x8(%rcx,%rdx,8), %rcx
jmp 0x3333
movq %rcx, %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rax
testb $0x7, %sil
je 0x33b4
leaq 0x1b4a(%rip), %rdi      # 0x4efc
jmp 0x33c6
movl %esi, %eax
addq %rax, %rdi
movl (%rdi), %ecx
testl %ecx, %ecx
jle 0x33d4
leaq 0x1b5c(%rip), %rdi      # 0x4f22
xorl %eax, %eax
callq 0x1339
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
je 0x33ed
negl %ecx
testb $0x7, %cl
je 0x33f6
leaq 0x1b84(%rip), %rdi      # 0x4f68
xorl %eax, %eax
callq 0x1339
jmp 0x33cd
leaq 0x1b55(%rip), %rdi      # 0x4f49
jmp 0x33c6
movzwl 0x4(%rdi), %ecx
xorl %eax, %eax
cmpw (%rdx), %cx
je 0x33d2
leaq 0x4(%rdi), %r9
movsbl 0x4(%rdi), %ecx
movsbl 0x5(%rdi), %r8d
leaq 0x1b80(%rip), %rdi      # 0x4f95
xorl %eax, %eax
callq 0x1339
jmp 0x33cd
// File: /workspace/github_c_makefile_star2_O1/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 %rax
testb $0x7, %sil
je 0x342e
leaq 0x1ad0(%rip), %rdi      # 0x4efc
jmp 0x3441
movl %ecx, %r8d
movl %esi, %eax
movl (%rdi,%rax), %ecx
testl %ecx, %ecx
jle 0x344f
leaq 0x1ae1(%rip), %rdi      # 0x4f22
xorl %eax, %eax
callq 0x1339
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
je 0x3468
negl %ecx
testb $0x7, %cl
je 0x3471
leaq 0x1b09(%rip), %rdi      # 0x4f68
xorl %eax, %eax
callq 0x1339
jmp 0x3448
leaq 0x1ada(%rip), %rdi      # 0x4f49
jmp 0x3441
leal 0xb(%r8), %r9d
andl $-0x8, %r9d
movslq (%rdi,%rax), %rcx
negq %rcx
xorl %eax, %eax
cmpl %ecx, %r9d
jbe 0x344d
addq $-0x4, %rcx
leaq 0x1b3b(%rip), %rdi      # 0x4fcd
xorl %eax, %eax
callq 0x1339
jmp 0x3448
// File: /workspace/github_c_makefile_star2_O1/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 %rax
testb $0x7, %sil
je 0x34ab
leaq 0x1a53(%rip), %rdi      # 0x4efc
jmp 0x34c0
movl %ecx, %r8d
movl %esi, %eax
addq %rax, %rdi
movl (%rdi), %ecx
testl %ecx, %ecx
jle 0x34ce
leaq 0x1a62(%rip), %rdi      # 0x4f22
xorl %eax, %eax
callq 0x1339
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
je 0x34e7
negl %ecx
testb $0x7, %cl
je 0x34f0
leaq 0x1a8a(%rip), %rdi      # 0x4f68
xorl %eax, %eax
callq 0x1339
jmp 0x34c7
leaq 0x1a5b(%rip), %rdi      # 0x4f49
jmp 0x34c0
movzwl 0x4(%rdi), %eax
cmpw (%rdx), %ax
jne 0x3522
leal 0xb(%r8), %r9d
andl $-0x8, %r9d
movslq (%rdi), %rcx
negq %rcx
xorl %eax, %eax
cmpl %ecx, %r9d
jbe 0x34cc
addq $-0x4, %rcx
leaq 0x1ab4(%rip), %rdi      # 0x4fcd
xorl %eax, %eax
callq 0x1339
jmp 0x34c7
leaq 0x4(%rdi), %r9
movsbl 0x4(%rdi), %ecx
movsbl 0x5(%rdi), %r8d
leaq 0x1a5f(%rip), %rdi      # 0x4f95
xorl %eax, %eax
callq 0x1339
jmp 0x34c7
// File: /workspace/github_c_makefile_star2_O1/sTeeLM[P]dwipe/device.c
// Function: dwipe_device_strsize
void dwipe_device_strsize(char * buffer, int buflen, loff_t size)
{
    long double real = size;
    long double real1 = size;
    if(real > 1024*1024*1024*1024.0 ) { /* 1TiB */
        real /= 1024*1024*1024*1024.0;
        real1 /= 1000*1000*1000*1000.0;
        snprintf(buffer, buflen, "Size: %.2Lf TiB(%.2Lf TB)", real, real1);
    } else if(real > 1024*1024*1024.0 ) { /* 1GiB */
        real /= 1024*1024*1024.0;
        real1 /= 1000*1000*1000.0;
        snprintf(buffer, buflen, "Size: %.2Lf GiB(%.2Lf GB)", real, real1);
    } else if(real > 1024*1024.0 ) { /* 1MiB */
        real /= 1024*1024.0;
        real1 /= 1000*1000.0;
        snprintf(buffer, buflen, "Size: %.2Lf MiB(%.2Lf KB)", real, real1);
    } else if(real > 1024*1024.0 ) { /* 1KiB */
        real /= 1024.0;
        real1 /= 1000.0;
        snprintf(buffer, buflen, "Size: %.2Lf KiB(%.2Lf KB)", real, real1);
    } else {
        snprintf(buffer, buflen, "Size: %.2Lf B", real);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdx, 0x20(%rsp)
fildll 0x20(%rsp)
movabsq $0x10000000001, %rax    # imm = 0x10000000001
cmpq %rax, %rdx
jl 0x387b
fld %st(0)
fmuls 0x77b4(%rip)            # 0xb014
fxch %st(1)
fdivl 0x77b0(%rip)            # 0xb018
movslq %esi, %rsi
fstpt 0x10(%rsp)
fstpt (%rsp)
leaq 0x7f3f(%rip), %rdx      # 0xb7b8
jmp 0x38e0
cmpq $0x40000001, %rdx       # imm = 0x40000001
jl 0x38a7
fld %st(0)
fmuls 0x7780(%rip)            # 0xb00c
fxch %st(1)
fdivs 0x777c(%rip)            # 0xb010
movslq %esi, %rsi
fstpt 0x10(%rsp)
fstpt (%rsp)
leaq 0x7f2d(%rip), %rdx      # 0xb7d2
jmp 0x38e0
cmpq $0x100001, %rdx         # imm = 0x100001
jl 0x38d3
fld %st(0)
fmuls 0x774c(%rip)            # 0xb004
fxch %st(1)
fdivs 0x7748(%rip)            # 0xb008
movslq %esi, %rsi
fstpt 0x10(%rsp)
fstpt (%rsp)
leaq 0x7f1b(%rip), %rdx      # 0xb7ec
jmp 0x38e0
movslq %esi, %rsi
fstpt (%rsp)
leaq 0x7f26(%rip), %rdx      # 0xb806
xorl %eax, %eax
callq 0x3180
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x670c(%rip), %rdi      # 0xd0a7
leaq 0x46fb(%rip), %rsi      # 0xb09d
callq 0x3280
movq %rax, %rbx
movq 0xae6f(%rip), %rdi      # 0x11820
leaq 0x66fd(%rip), %rcx      # 0xd0b5
movl $0x3, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x31c0
testq %rbx, %rbx
je 0x6a29
leaq 0x66ef(%rip), %rsi      # 0xd0c4
leaq 0x14(%rsp), %rdx
leaq 0x10(%rsp), %rcx
leaq 0xc(%rsp), %r8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30e0
movq 0xae2b(%rip), %r14      # 0x11820
cmpl $0x3, %eax
jne 0x6a5a
cvtss2sd 0x14(%rsp), %xmm0
cvtss2sd 0x10(%rsp), %xmm1
cvtss2sd 0xc(%rsp), %xmm2
leaq 0x66ba(%rip), %rcx      # 0xd0cd
movq %r14, %rdi
movl $0x3, %esi
movl $0x10, %edx
movb $0x3, %al
callq 0x31c0
jmp 0x6a7d
movq 0xadf0(%rip), %rbx      # 0x11820
callq 0x3070
movl (%rax), %r8d
leaq 0x66b5(%rip), %rcx      # 0xd0f4
movq %rbx, %rdi
movl $0x3, %esi
movl $0x10, %edx
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x31c0
callq 0x3070
movl (%rax), %r8d
leaq 0x6679(%rip), %rcx      # 0xd0e2
movq %r14, %rdi
movl $0x3, %esi
movl $0x10, %edx
xorl %eax, %eax
callq 0x31c0
movq %rbx, %rdi
callq 0x3140
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/sTeeLM[P]dwipe/method.c
// Function: dwipe_method_label
const char* dwipe_method_label( dwipe_method_t method )
{
/**
 *  Returns a pointer to the name of the method function.
 *
 */

	if( method == &dwipe_dod522022m ) { return dwipe_dod522022m_label; }
	if( method == &dwipe_dodshort   ) { return dwipe_dodshort_label;   }
	if( method == &dwipe_gutmann    ) { return dwipe_gutmann_label;    }
	if( method == &dwipe_ops2       ) { return dwipe_ops2_label;       }
	if( method == &dwipe_random     ) { return dwipe_random_label;     }
	if( method == &dwipe_zero       ) { return dwipe_zero_label;       }

	/* else */
	return dwipe_unknown_label;

}

// Assembly:
leaq 0x82(%rip), %rax        # 0x7cfd
cmpq %rax, %rdi
je 0x7cce
leaq 0x188(%rip), %rax       # 0x7e0f
cmpq %rax, %rdi
je 0x7cd7
leaq 0x23f(%rip), %rax       # 0x7ed2
cmpq %rax, %rdi
je 0x7ce0
leaq 0x3ad(%rip), %rax       # 0x804c
cmpq %rax, %rdi
je 0x7ce9
leaq 0x56e(%rip), %rax       # 0x8219
cmpq %rax, %rdi
je 0x7cf2
leaq 0x588(%rip), %rax       # 0x823f
cmpq %rax, %rdi
leaq 0x99d7(%rip), %rcx      # 0x11698
leaq 0x99d8(%rip), %rax      # 0x116a0
cmoveq %rcx, %rax
jmp 0x7cf9
leaq 0x999b(%rip), %rax      # 0x11670
jmp 0x7cf9
leaq 0x999a(%rip), %rax      # 0x11678
jmp 0x7cf9
leaq 0x9999(%rip), %rax      # 0x11680
jmp 0x7cf9
leaq 0x9998(%rip), %rax      # 0x11688
jmp 0x7cf9
leaq 0x9997(%rip), %rax      # 0x11690
movq (%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/sTeeLM[P]dwipe/method.c
// Function: dwipe_dod522022m
int dwipe_dod522022m( DWIPE_METHOD_SIGNATURE )
{
/**
 * United States Department of Defense 5220.22-M standard wipe.
 * 
 */

	/* A result holder. */
	int r;

	/* Random characters. (Elements 2 and 6 are unused.) */
	char dod [7];

	dwipe_pattern_t patterns [] =
	{
		{  1, &dod[0] }, /* Pass 1: A random character.               */
		{  1, &dod[1] }, /* Pass 2: The bitwise complement of pass 1. */
		{ -1, ""      }, /* Pass 3: A random stream.                  */
		{  1, &dod[3] }, /* Pass 4: A random character.               */
		{  1, &dod[4] }, /* Pass 5: A random character.               */
		{  1, &dod[5] }, /* Pass 6: The bitwise complement of pass 5. */
		{ -1, ""      }, /* Pass 7: A random stream.                  */
		{  0, NULL   }
	};

	/* Load the array with random characters. */
	r = read( c->entropy_fd, &dod, sizeof( dod ) );

	/* NOTE: Only the random data in dod[0], dod[3], and dod[4] is actually used. */

	/* Check the result. */
	if( r != sizeof( dod ) )
	{
		r = errno;
		dwipe_perror( r, __FUNCTION__, "read" );
		dwipe_log( DWIPE_LOG_FATAL, "Unable to seed the %s method.", dwipe_dod522022m_label );

		/* Ensure a negative return. */
		if( r < 0 ) { return  r; }
		else        { return -1; }

	}

	/* Pass 2 is the bitwise complement of Pass 1. */
	dod[1] = ~ dod[0];

	/* Pass 4 is the bitwise complement of Pass 3. */
	dod[5] = ~ dod[4];

	/* Run the DoD 5220.22-M method. */
	return dwipe_runmethod( c, patterns );

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %r14
movl $0x1, %eax
movl %eax, 0x10(%rsp)
leaq 0x9(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movl %eax, 0x20(%rsp)
leaq 0xa(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, 0x30(%rsp)
leaq 0x5c93(%rip), %rcx      # 0xd9cf
movq %rcx, 0x38(%rsp)
movl %eax, 0x40(%rsp)
leaq 0xc(%rsp), %rdx
movq %rdx, 0x48(%rsp)
movl %eax, 0x50(%rsp)
leaq 0xd(%rsp), %rdx
movq %rdx, 0x58(%rsp)
movl %eax, 0x60(%rsp)
leaq 0xe(%rsp), %rax
movq %rax, 0x68(%rsp)
movl %ebx, 0x70(%rsp)
movq %rcx, 0x78(%rsp)
movl $0x0, 0x80(%rsp)
movq $0x0, 0x88(%rsp)
movl 0x2d8(%rdi), %edi
movl $0x7, %edx
callq 0x3240
cmpl $0x7, %eax
jne 0x7dc5
movb 0x9(%rsp), %al
movb 0xd(%rsp), %cl
notb %al
movb %al, 0xa(%rsp)
notb %cl
movb %cl, 0xe(%rsp)
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x8256
movl %eax, %ebx
jmp 0x7e01
callq 0x3070
movl (%rax), %ebp
leaq 0x56a3(%rip), %rsi      # 0xd476
leaq 0x56ad(%rip), %rdx      # 0xd487
movl %ebp, %edi
callq 0x7c3f
movq 0x9888(%rip), %rdx      # 0x11670
leaq 0x569d(%rip), %rsi      # 0xd48c
movl $0x6, %edi
xorl %eax, %eax
callq 0x79f8
cmpl $-0x1, %ebp
cmovll %ebp, %ebx
movl %ebx, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sTeeLM[P]dwipe/mt19937ar-cok.c
// Function: init_genrand
void init_genrand( twister_state_t* state, unsigned long s)
{
	int j;
	state->array[0]= s & 0xffffffffUL;
	for( j = 1; j < N; j++ )
	{
		state->array[j] = (1812433253UL * (state->array[j-1] ^ (state->array[j-1] >> 30)) + j); 
		state->array[j] &= 0xffffffffUL;  /* for >32 bit machines */
	}
	state->left = 1;
	state->initf = 1;
}

// Assembly:
movl %esi, %eax
movq %rax, (%rdi)
movl $0x1, %ecx
movq %rax, %rdx
shrq $0x1e, %rdx
xorl %eax, %edx
imull $0x6c078965, %edx, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, (%rdi,%rcx,8)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x89d6
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x1380(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/sTeeLM[P]dwipe/mt19937ar-cok.c
// Function: twister_init
void twister_init( twister_state_t* state, unsigned long init_key[], unsigned long key_length )
{
    int i = 1;
	 int j = 0;
    int k = ( N > key_length ? N : key_length );

    init_genrand( state, 19650218UL );

    for( ; k; k-- )
	 {
		state->array[i] = (state->array[i] ^ ((state->array[i-1] ^ (state->array[i-1] >> 30)) * 1664525UL)) + init_key[j] + j;
		state->array[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
		++i;
		++j;

		if ( i >= N )
		{
			state->array[0] = state->array[N-1];
			i = 1;
		}

		if ( j >= key_length )
		{
			j = 0;
		}
    }

    for( k = N -1; k; k-- )
	 {
		state->array[i] = (state->array[i] ^ ((state->array[i-1] ^ (state->array[i-1] >> 30)) * 1566083941UL)) - i;
		state->array[i] &= 0xffffffffUL;
		++i;

		if ( i >= N )
		{
			state->array[0] = state->array[N-1];
			i = 1;
		}
    }

	state->array[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */ 
	state->left = 1;
	state->initf = 1;
}

// Assembly:
cmpq $0x271, %rdx            # imm = 0x271
movl $0x270, %r8d            # imm = 0x270
cmovaeq %rdx, %r8
movq $0x12bd6aa, (%rdi)      # imm = 0x12BD6AA
movl $0x1, %eax
movl $0x12bd6aa, %ecx        # imm = 0x12BD6AA
movq %rcx, %r9
shrq $0x1e, %r9
xorl %ecx, %r9d
imull $0x6c078965, %r9d, %ecx # imm = 0x6C078965
addl %eax, %ecx
movq %rcx, (%rdi,%rax,8)
incq %rax
cmpq $0x270, %rax            # imm = 0x270
jne 0x8a2b
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x1380(%rdi)
testl %r8d, %r8d
je 0x8ad5
pushq %r15
pushq %r14
pushq %rbx
movl $0x1, %ecx
xorl %r9d, %r9d
xorl %r10d, %r10d
movslq %ecx, %r11
movq -0x8(%rdi,%r11,8), %rbx
movq %rbx, %r14
shrq $0x1e, %r14
xorl %ebx, %r14d
imull $0x19660d, %r14d, %ebx  # imm = 0x19660D
xorl (%rdi,%r11,8), %ebx
movslq %r10d, %r14
movl (%rsi,%r14,8), %r15d
addl %r14d, %r15d
addl %ebx, %r15d
movq %r15, (%rdi,%r11,8)
cmpl $0x26f, %ecx            # imm = 0x26F
jge 0x8aad
incl %ecx
jmp 0x8abc
movq 0x1378(%rdi), %rcx
movq %rcx, (%rdi)
movl $0x1, %ecx
incl %r10d
movslq %r10d, %r10
cmpq %rdx, %r10
cmovael %r9d, %r10d
decl %r8d
jne 0x8a73
popq %rbx
popq %r14
popq %r15
jmp 0x8ada
movl $0x1, %ecx
movl $0xfffffd91, %edx       # imm = 0xFFFFFD91
movslq %ecx, %rsi
movq -0x8(%rdi,%rsi,8), %r8
movq %r8, %r9
shrq $0x1e, %r9
xorl %r8d, %r9d
imull $0x5d588b65, %r9d, %r8d # imm = 0x5D588B65
xorl (%rdi,%rsi,8), %r8d
subl %esi, %r8d
movq %r8, (%rdi,%rsi,8)
cmpl $0x26f, %ecx            # imm = 0x26F
jge 0x8b0f
incl %ecx
jmp 0x8b1e
movq 0x1378(%rdi), %rcx
movq %rcx, (%rdi)
movl $0x1, %ecx
incl %edx
jne 0x8adf
movl $0x80000000, %ecx       # imm = 0x80000000
movq %rcx, (%rdi)
movq %rax, 0x1380(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/sTeeLM[P]dwipe/mt19937ar-cok.c
// Function: twister_genrand_int32
unsigned long twister_genrand_int32( twister_state_t* state )
{
    unsigned long y;

    if ( --state->left == 0 ) { next_state( state ); }
    y = *state->next++;

    /* Tempering */
    y ^= (y >> 11);
    y ^= (y << 7) & 0x9d2c5680UL;
    y ^= (y << 15) & 0xefc60000UL;
    y ^= (y >> 18);

    return y;
}

// Assembly:
decl 0x1380(%rdi)
jne 0x8c93
cmpl $0x0, 0x1384(%rdi)
jne 0x8b89
movq $0x1571, (%rdi)         # imm = 0x1571
movl $0x1, %eax
movl $0x1571, %ecx           # imm = 0x1571
movq %rcx, %rdx
shrq $0x1e, %rdx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
movq %rcx, (%rdi,%rax,8)
incq %rax
cmpq $0x270, %rax            # imm = 0x270
jne 0x8b58
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x1380(%rdi)
movl $0x9908b0df, %ecx       # imm = 0x9908B0DF
movl $0x270, 0x1380(%rdi)    # imm = 0x270
movq %rdi, 0x1388(%rdi)
xorl %eax, %eax
movl $0x80000000, %edx       # imm = 0x80000000
movl (%rdi,%rax), %esi
andl %edx, %esi
movl 0x8(%rdi,%rax), %r8d
movl %r8d, %r9d
andl $0x7ffffffe, %r9d       # imm = 0x7FFFFFFE
orl %esi, %r9d
shrl %r9d
andl $0x1, %r8d
negl %r8d
andl %ecx, %r8d
xorq 0xc68(%rdi,%rax), %r8
xorq %r9, %r8
movq %r8, (%rdi,%rax)
addq $0x8, %rax
cmpl $0x718, %eax            # imm = 0x718
jne 0x8ba6
leaq (%rdi,%rax), %rdx
xorl %esi, %esi
movdqa 0x4d3e(%rip), %xmm0     # 0xd930
movdqa 0x4d46(%rip), %xmm1     # 0xd940
movdqa 0x4d4e(%rip), %xmm2     # 0xd950
movdqu -0x718(%rdx,%rsi,8), %xmm4
movdqu (%rdx,%rsi,8), %xmm5
pand %xmm0, %xmm5
movdqu 0x8(%rdx,%rsi,8), %xmm3
movdqa %xmm3, %xmm6
pand %xmm1, %xmm6
por %xmm5, %xmm6
psrlq $0x1, %xmm6
pxor %xmm4, %xmm6
movdqa %xmm3, %xmm4
pslld $0x1f, %xmm4
psrad $0x1f, %xmm4
pand %xmm2, %xmm4
pxor %xmm6, %xmm4
movdqu %xmm4, (%rdx,%rsi,8)
addq $0x2, %rsi
cmpq $0x18c, %rsi            # imm = 0x18C
jne 0x8c02
pshufd $0xee, %xmm3, %xmm0     # xmm0 = xmm3[2,3,2,3]
movq %xmm0, %rdx
andl $0x80000000, %edx       # imm = 0x80000000
movl (%rdi), %esi
movl %esi, %r8d
andl $0x7ffffffe, %r8d       # imm = 0x7FFFFFFE
orl %edx, %r8d
shrl %r8d
andl $0x1, %esi
negl %esi
andl %ecx, %esi
xorq 0x548(%rdi,%rax), %rsi
xorq %r8, %rsi
movq %rsi, 0xc60(%rdi,%rax)
movq 0x1388(%rdi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x1388(%rdi)
movq (%rax), %rax
movq %rax, %rcx
shrq $0xb, %rcx
xorq %rax, %rcx
movl %ecx, %eax
shll $0x7, %eax
andl $0x9d2c5680, %eax       # imm = 0x9D2C5680
xorq %rcx, %rax
movl %eax, %ecx
shll $0xf, %ecx
andl $0xefc60000, %ecx       # imm = 0xEFC60000
xorq %rax, %rcx
movq %rcx, %rax
shrq $0x12, %rax
xorq %rcx, %rax
retq