LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ksherlock[P]wdc-utils/dumpobj.cpp
// Function: read_symbols(std::vector<unsigned char, std::allocator<unsigned char>> const&)
std::vector<symbol> read_symbols(const std::vector<uint8_t> &symbol_data) {

	std::vector<symbol> symbols;

	auto iter = symbol_data.begin();
	while (iter != symbol_data.end()) {
		symbol s;
		s.type = read_8(iter);
		s.flags = read_8(iter);
		s.section = read_8(iter);
		s.offset = s.type == S_UND ? 0 : read_32(iter);
		s.name = read_cstring(iter);


		symbols.emplace_back(std::move(s));
	}

	return symbols;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x7d00
movq -0x10(%rbp), %rdi
callq 0x79b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7a20
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x79e0
testb $0x1, %al
jne 0x38fd
jmp 0x3a0b
leaq -0x50(%rbp), %rdi
callq 0x7d20
leaq -0x20(%rbp), %rdi
callq 0x7a90
movb %al, -0x91(%rbp)
jmp 0x3917
movb -0x91(%rbp), %al
movb %al, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7a90
movb %al, -0x92(%rbp)
jmp 0x3931
movb -0x92(%rbp), %al
movb %al, -0x2f(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7a90
movb %al, -0x93(%rbp)
jmp 0x394b
movb -0x93(%rbp), %al
movb %al, -0x2e(%rbp)
movzbl -0x30(%rbp), %eax
cmpl $0x0, %eax
jne 0x3967
xorl %eax, %eax
movl %eax, -0x98(%rbp)
jmp 0x3986
leaq -0x20(%rbp), %rdi
callq 0x7ac0
movl %eax, -0x9c(%rbp)
jmp 0x3978
movl -0x9c(%rbp), %eax
movl %eax, -0x98(%rbp)
jmp 0x3986
movl -0x98(%rbp), %eax
movl %eax, -0x2c(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7b60
jmp 0x399e
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x80(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
callq 0x3310
movq -0xb0(%rbp), %rdi
callq 0x3160
movq -0x90(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x7d60
jmp 0x39da
leaq -0x50(%rbp), %rdi
callq 0x7de0
jmp 0x38da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7de0
movq -0x90(%rbp), %rdi
callq 0x7e00
jmp 0x3a31
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3a21
movq -0x90(%rbp), %rdi
callq 0x7e00
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3440
nopw (%rax,%rax)
// File: ksherlock[P]wdc-utils/dumpobj.cpp
// Function: dump(char const*)
void dump(const char *name) {
	Header h;
	int fd;
	ssize_t ok;

	fd = open(name, O_RDONLY | O_BINARY);
	if (fd < 0) err(EX_NOINPUT, "Unable to open %s", name);


	ok = read(fd, &h, sizeof(h));
	if (ok != sizeof(h))
		errx(EX_DATAERR, "%s is not an object file", name);

	le_to_host(h.magic);
	le_to_host(h.version);
	le_to_host(h.filetype);

	if (h.magic != MOD_MAGIC || h.version != 1 || h.filetype > 2)
		errx(EX_DATAERR, "%s is not an object file", name);

	lseek(fd, 0, SEEK_SET);
	if (h.filetype == 2) dump_lib(name, fd);

	// files may contain multiple modules.
	while (dump_obj(name, fd)) /* ... */;

	close(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x31f0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x77c9
movq -0x8(%rbp), %rdx
movl $0x42, %edi
leaq 0x13bee(%rip), %rsi     # 0x1b3b0
movb $0x0, %al
callq 0x3250
movl -0x14(%rbp), %edi
leaq -0xf(%rbp), %rsi
movl $0x7, %edx
callq 0x33a0
movq %rax, -0x20(%rbp)
cmpq $0x7, -0x20(%rbp)
je 0x77fc
movq -0x8(%rbp), %rdx
movl $0x41, %edi
leaq 0x138f7(%rip), %rsi     # 0x1b0ec
movb $0x0, %al
callq 0x34a0
leaq -0xf(%rbp), %rdi
callq 0x7e60
leaq -0xf(%rbp), %rdi
addq $0x4, %rdi
callq 0x7e80
leaq -0xf(%rbp), %rdi
addq $0x6, %rdi
callq 0x7ea0
cmpl $0x5a44525a, -0xf(%rbp) # imm = 0x5A44525A
jne 0x783a
movzwl -0xb(%rbp), %eax
cmpl $0x1, %eax
jne 0x783a
movzbl -0x9(%rbp), %eax
cmpl $0x2, %eax
jle 0x7851
movq -0x8(%rbp), %rdx
movl $0x41, %edi
leaq 0x138a2(%rip), %rsi     # 0x1b0ec
movb $0x0, %al
callq 0x34a0
movl -0x14(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x3490
movzbl -0x9(%rbp), %eax
cmpl $0x2, %eax
jne 0x7874
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x7370
jmp 0x7876
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3a40
testb $0x1, %al
jne 0x7888
jmp 0x788a
jmp 0x7876
movl -0x14(%rbp), %edi
callq 0x34d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ksherlock[P]wdc-utils/dumpobj.cpp
// Function: main
int main(int argc, char **argv) {

	int c;
	while ((c = getopt(argc, argv, "Sgn")) != -1) {
			switch(c) {
				case 'S': flags.S = true; break;
				case 'g': flags.g = true; break;
				case 'n': flags.n = true; break;
				default: exit(EX_USAGE); break;
			}
	}

	argv += optind;
	argc -= optind;

	if (argc == 0) usage();

	for (int i = 0; i < argc; ++i) {
		dump(argv[i]);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x13afe(%rip), %rdx     # 0x1b3c2
callq 0x3090
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x7919
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x53, %eax
je 0x78f2
jmp 0x78de
movl -0x1c(%rbp), %eax
subl $0x67, %eax
je 0x78fb
jmp 0x78e8
movl -0x1c(%rbp), %eax
subl $0x6e, %eax
je 0x7904
jmp 0x790d
movb $0x1, 0x1d9b7(%rip)     # 0x252b0
jmp 0x7917
movb $0x1, 0x1d9af(%rip)     # 0x252b1
jmp 0x7917
movb $0x1, 0x1d9a7(%rip)     # 0x252b2
jmp 0x7917
movl $0x40, %edi
callq 0x3300
jmp 0x78b6
movq 0x1d6b8(%rip), %rax     # 0x24fd8
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq 0x1d69d(%rip), %rax     # 0x24fd8
movl (%rax), %ecx
movl -0x8(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x7950
callq 0x3710
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x797b
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7790
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7957
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ksherlock[P]wdc-utils/dumpobj.cpp
// Function: unsigned int read_32<__gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>>(__gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>&)
uint32_t read_32(T &iter) {
	uint32_t tmp = 0;

	tmp |= *iter << 0;
	++iter;
	tmp |= *iter << 8;
	++iter;
	tmp |= *iter << 16;
	++iter;
	tmp |= *iter << 24;
	++iter;


	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x97b0
movzbl (%rax), %eax
shll $0x0, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x97d0
movq -0x8(%rbp), %rdi
callq 0x97b0
movzbl (%rax), %eax
shll $0x8, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x97d0
movq -0x8(%rbp), %rdi
callq 0x97b0
movzbl (%rax), %eax
shll $0x10, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x97d0
movq -0x8(%rbp), %rdi
callq 0x97b0
movzbl (%rax), %eax
shll $0x18, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x97d0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ksherlock[P]wdc-utils/dumpobj.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> read_cstring<__gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>>(__gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>&)
std::string read_cstring(T &iter) {
	std::string s;
	for(;;) {
		uint8_t c = *iter;
		++iter;
		if (!c) break;
		s.push_back(c);
	}
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3380
movq -0x10(%rbp), %rdi
callq 0x97b0
movb (%rax), %al
movb %al, -0x12(%rbp)
movq -0x10(%rbp), %rdi
callq 0x97d0
cmpb $0x0, -0x12(%rbp)
jne 0x7ba3
jmp 0x7bcb
movq -0x38(%rbp), %rdi
movsbl -0x12(%rbp), %esi
callq 0x3230
jmp 0x7bb2
jmp 0x7b84
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3160
jmp 0x7be8
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x7bde
movq -0x38(%rbp), %rdi
callq 0x3160
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ksherlock[P]wdc-utils/dumpobj.cpp
// Function: unsigned short read_16<__gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>>(__gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>&)
uint16_t read_16(T &iter) {
	uint16_t tmp = 0;

	tmp |= *iter << 0;
	++iter;
	tmp |= *iter << 8;
	++iter;
	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movw $0x0, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8260
movzbl (%rax), %ecx
shll $0x0, %ecx
movzwl -0xa(%rbp), %eax
orl %ecx, %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc090
movq -0x8(%rbp), %rdi
callq 0x8260
movzbl (%rax), %ecx
shll $0x8, %ecx
movzwl -0xa(%rbp), %eax
orl %ecx, %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc090
movw -0xa(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
// File: ksherlock[P]wdc-utils/dumpobj.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> read_pstring<__gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>>(__gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>&)
std::string read_pstring(T &iter) {
	std::string s;
	unsigned  size = *iter;
	++iter;
	s.reserve(size);
	while (size--) {
		uint8_t c = *iter;
		++iter;
		s.push_back(c);
	}
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3380
movq -0x10(%rbp), %rdi
callq 0x8260
movzbl (%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc090
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x33d0
jmp 0x8d1c
jmp 0x8d1e
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x18(%rbp)
cmpl $0x0, %eax
je 0x8d6d
movq -0x10(%rbp), %rdi
callq 0x8260
movb (%rax), %al
movb %al, -0x25(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc090
movq -0x30(%rbp), %rdi
movsbl -0x25(%rbp), %esi
callq 0x3230
jmp 0x8d54
jmp 0x8d1e
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3160
jmp 0x8d8a
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x8d80
movq -0x30(%rbp), %rdi
callq 0x3160
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::to_x[abi:cxx11](unsigned int, unsigned int, char)
std::string disassembler::to_x(uint32_t x, unsigned bytes, char prefix) {
	std::string s;
	char buffer[16];
	if (prefix) s.push_back(prefix);

	if (x > 0xff && bytes < 4) bytes = 4;
	if (x > 0xffff && bytes < 6) bytes = 6;
	if (x > 0xffffff && bytes < 8) bytes = 8;

	memset(buffer, '0', sizeof(buffer));
	int i = 16;
	while (x) {
		buffer[--i] = "0123456789abcdef"[x & 0x0f];
		x >>= 4;
	}

	s.append(buffer + 16 - bytes, buffer + 16);

	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x3380
cmpb $0x0, -0x11(%rbp)
je 0xcbec
movq -0x50(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x3230
jmp 0xcbd0
jmp 0xcbec
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x3160
jmp 0xccb1
cmpl $0xff, -0xc(%rbp)
jbe 0xcc02
cmpl $0x4, -0x10(%rbp)
jae 0xcc02
movl $0x4, -0x10(%rbp)
cmpl $0xffff, -0xc(%rbp)     # imm = 0xFFFF
jbe 0xcc18
cmpl $0x6, -0x10(%rbp)
jae 0xcc18
movl $0x6, -0x10(%rbp)
cmpl $0xffffff, -0xc(%rbp)   # imm = 0xFFFFFF
jbe 0xcc2e
cmpl $0x8, -0x10(%rbp)
jae 0xcc2e
movl $0x8, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x30, %esi
movl $0x10, %edx
callq 0x3130
movl $0x10, -0x40(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xcc7c
movl -0xc(%rbp), %eax
andl $0xf, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xefc1(%rip), %rax      # 0x1bc20
movb (%rax,%rcx), %cl
movl -0x40(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x40(%rbp)
cltq
movb %cl, -0x30(%rbp,%rax)
movl -0xc(%rbp), %eax
shrl $0x4, %eax
movl %eax, -0xc(%rbp)
jmp 0xcc48
movq -0x50(%rbp), %rdi
leaq -0x20(%rbp), %rdx
movl -0x10(%rbp), %eax
movq %rdx, %rsi
subq %rax, %rsi
callq 0xf090
jmp 0xcc94
movb $0x1, -0x12(%rbp)
testb $0x1, -0x12(%rbp)
jne 0xcca7
movq -0x50(%rbp), %rdi
callq 0x3160
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3440
nopw (%rax,%rax)
// File: ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::operand_size(unsigned char, bool, bool)
int disassembler::operand_size(uint8_t op, bool m, bool x) {
	unsigned mode = modes[op];
	unsigned size = mode & 0x0f;
	if ((mode & m_I) && x) size++; 
	if ((mode & m_M) && m) size++;
	return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movb %sil, %cl
movb %dil, %dl
movb %dl, -0x1(%rbp)
andb $0x1, %cl
movb %cl, -0x2(%rbp)
andb $0x1, %al
movb %al, -0x3(%rbp)
movzbl -0x1(%rbp), %eax
movl %eax, %ecx
leaq 0xe829(%rip), %rax      # 0x1b510
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xf, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xcd10
testb $0x1, -0x3(%rbp)
je 0xcd10
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0xcd2a
testb $0x1, -0x2(%rbp)
je 0xcd2a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::emit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void disassembler::emit(const std::string &label, const std::string &opcode) {
	std::string tmp;
	tmp = label;

	if (!opcode.empty()) {
		indent_to(tmp, kOpcodeTab);
		tmp += opcode;
	}

	tmp.push_back('\n');
	fputs(tmp.c_str(), stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3380
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3050
jmp 0xcdac
movq -0x10(%rbp), %rdi
callq 0x3430
testb $0x1, %al
jne 0xcdf1
leaq -0x30(%rbp), %rdi
movl $0x14, %esi
callq 0xcb10
jmp 0xcdc9
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3340
jmp 0xcdd8
jmp 0xcdf1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3160
jmp 0xce2d
leaq -0x30(%rbp), %rdi
movl $0xa, %esi
callq 0x3230
jmp 0xce01
leaq -0x30(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
movq 0x181ac(%rip), %rax     # 0x24fc0
movq (%rax), %rsi
callq 0x32e0
jmp 0xce1e
leaq -0x30(%rbp), %rdi
callq 0x3160
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::emit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void disassembler::emit(const std::string &label, const std::string &opcode, const std::string &operand) {

	std::string tmp;
	tmp = label;


	if (!opcode.empty()) {
		indent_to(tmp, kOpcodeTab);
		tmp += opcode;
	}

	if (!operand.empty()) {
		indent_to(tmp, kOperandTab);
		tmp += operand;
	}

	tmp.push_back('\n');
	fputs(tmp.c_str(), stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3380
movq -0x50(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3050
jmp 0xce70
movq -0x10(%rbp), %rdi
callq 0x3430
testb $0x1, %al
jne 0xceb5
leaq -0x38(%rbp), %rdi
movl $0x14, %esi
callq 0xcb10
jmp 0xce8d
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3340
jmp 0xce9c
jmp 0xceb5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3160
jmp 0xcf1f
movq -0x18(%rbp), %rdi
callq 0x3430
testb $0x1, %al
jne 0xcee3
leaq -0x38(%rbp), %rdi
movl $0x1e, %esi
callq 0xcb10
jmp 0xced2
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3340
jmp 0xcee1
jmp 0xcee3
leaq -0x38(%rbp), %rdi
movl $0xa, %esi
callq 0x3230
jmp 0xcef3
leaq -0x38(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
movq 0x180ba(%rip), %rax     # 0x24fc0
movq (%rax), %rsi
callq 0x32e0
jmp 0xcf10
leaq -0x38(%rbp), %rdi
callq 0x3160
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3440
nopl (%rax,%rax)
// File: ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::emit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void disassembler::emit(const std::string &label, const std::string &opcode, const std::string &operand, const std::string &comment) {

	std::string tmp;
	tmp = label;

	if (!opcode.empty()) {
		indent_to(tmp, kOpcodeTab);
		tmp += opcode;
	}

	if (!operand.empty()) {
		indent_to(tmp, kOperandTab);
		tmp += operand;
	}

	if (!comment.empty()) {
		indent_to(tmp, kCommentTab);
		tmp += "; ";
		tmp += comment;	
	}

	tmp.push_back('\n');
	fputs(tmp.c_str(), stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3380
movq -0x58(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3050
jmp 0xcf64
movq -0x10(%rbp), %rdi
callq 0x3430
testb $0x1, %al
jne 0xcfac
leaq -0x40(%rbp), %rdi
movl $0x14, %esi
callq 0xcb10
jmp 0xcf81
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x3340
jmp 0xcf90
jmp 0xcfac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3160
jmp 0xd056
movq -0x18(%rbp), %rdi
callq 0x3430
testb $0x1, %al
jne 0xcfda
leaq -0x40(%rbp), %rdi
movl $0x1e, %esi
callq 0xcb10
jmp 0xcfc9
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x3340
jmp 0xcfd8
jmp 0xcfda
movq -0x20(%rbp), %rdi
callq 0x3430
testb $0x1, %al
jne 0xd01a
leaq -0x40(%rbp), %rdi
movl $0x50, %esi
callq 0xcb10
jmp 0xcff7
leaq 0xec33(%rip), %rsi      # 0x1bc31
leaq -0x40(%rbp), %rdi
callq 0x3260
jmp 0xd009
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x3340
jmp 0xd018
jmp 0xd01a
leaq -0x40(%rbp), %rdi
movl $0xa, %esi
callq 0x3230
jmp 0xd02a
leaq -0x40(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
movq 0x17f83(%rip), %rax     # 0x24fc0
movq (%rax), %rsi
callq 0x32e0
jmp 0xd047
leaq -0x40(%rbp), %rdi
callq 0x3160
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3440
nop
// File: ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::format_data[abi:cxx11](unsigned int, unsigned char const*)
std::pair<std::string, std::string> 
disassembler::format_data(unsigned size, const uint8_t *data) {

	std::string tmp;

	for (unsigned i = 0; i < size; ++i) {
		if (i > 0) tmp += ", ";
		tmp += to_x(data[i], 2, '$');
	}

	return std::make_pair("db", tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3380
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0xd14c
cmpl $0x0, -0x44(%rbp)
jbe 0xd0f2
leaq 0xe16e(%rip), %rsi      # 0x1b242
leaq -0x40(%rbp), %rdi
callq 0x3260
jmp 0xd0df
jmp 0xd0f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xd1b7
movq -0x20(%rbp), %rax
movl -0x44(%rbp), %ecx
movzbl (%rax,%rcx), %esi
leaq -0x78(%rbp), %rdi
movl $0x2, %edx
movl $0x24, %ecx
callq 0xcb90
jmp 0xd112
leaq -0x40(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x3340
jmp 0xd121
leaq -0x78(%rbp), %rdi
callq 0x3160
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xd0bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3160
jmp 0xd1b7
leaq 0xeae1(%rip), %rsi      # 0x1bc34
leaq -0xa0(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0xf100
jmp 0xd165
movq -0xb0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xf140
jmp 0xd17a
leaq -0xa0(%rbp), %rdi
callq 0xf1d0
leaq -0x40(%rbp), %rdi
callq 0x3160
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0xf1d0
leaq -0x40(%rbp), %rdi
callq 0x3160
movq -0x50(%rbp), %rdi
callq 0x3440
nopl (%rax)
// File: ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::dump()
void disassembler::dump() {

	std::string line;

	if (!_st) return;


	auto p = format_data(_st, _bytes);

	indent_to(line, kOpcodeTab);
	line += p.first;
	indent_to(line, kOperandTab);
	line += p.second;

	hexdump(line);
	line.push_back('\n');
	fputs(line.c_str(), stdout);

	_pc += _st;
	reset();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3380
movq -0x88(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xd4cc
movl $0x1, -0x2c(%rbp)
jmp 0xd58e
movq -0x88(%rbp), %rsi
movl 0x8(%rsi), %edx
movq %rsi, %rcx
addq $0x18, %rcx
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq -0x70(%rbp), %rdi
callq *%rax
jmp 0xd4ec
leaq -0x28(%rbp), %rdi
movl $0x14, %esi
callq 0xcb10
jmp 0xd4fc
leaq -0x28(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3340
jmp 0xd50b
leaq -0x28(%rbp), %rdi
movl $0x1e, %esi
callq 0xcb10
jmp 0xd51b
leaq -0x50(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x3340
jmp 0xd52a
movq -0x88(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xd5e0
jmp 0xd53c
leaq -0x28(%rbp), %rdi
movl $0xa, %esi
callq 0x3230
jmp 0xd54c
leaq -0x28(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
movq 0x17a61(%rip), %rax     # 0x24fc0
movq (%rax), %rsi
callq 0x32e0
jmp 0xd569
movq -0x88(%rbp), %rdi
movl 0x8(%rdi), %eax
addl 0x20(%rdi), %eax
movl %eax, 0x20(%rdi)
callq 0xd060
leaq -0x70(%rbp), %rdi
callq 0xf270
movl $0x0, -0x2c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3160
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xd5c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xf270
leaq -0x28(%rbp), %rdi
callq 0x3160
movq -0x78(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::hexdump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void disassembler::hexdump(std::string &line) {
	// print pc and hexdump...

	indent_to(line, kCommentTab);
	line += "; ";

	line += to_x(_pc, 4);
	line.push_back(':');

	int i;
	for (i = 0; i < _st; ++i) {
		line.push_back(' ');
		line += to_x(_bytes[i], 2);
	}
	for ( ; i < 4; ++i) {
		line += "   ";
	}
	line += "  ";
	for (i = 0; i < _st; ++i) {
		uint8_t c = _bytes[i];
		// msb flag?
		if (_traits & msb_hexdump) c &= 0x7f;
		if (isprint(c) && isascii(c)) line += c;
		else line += '.';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
movl $0x50, %esi
callq 0xcb10
movq -0x10(%rbp), %rdi
leaq 0xe61d(%rip), %rsi      # 0x1bc31
callq 0x3260
movq -0x78(%rbp), %rax
movl 0x20(%rax), %esi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0x4, %edx
xorl %ecx, %ecx
callq 0xcb90
movq -0x70(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x3340
jmp 0xd643
leaq -0x30(%rbp), %rdi
callq 0x3160
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
callq 0x3230
movl $0x0, -0x40(%rbp)
movq -0x78(%rbp), %rcx
movl -0x40(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0xd6f7
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0x3230
movq -0x78(%rbp), %rax
movslq -0x40(%rbp), %rcx
movzbl 0x18(%rax,%rcx), %esi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0x2, %edx
xorl %ecx, %ecx
callq 0xcb90
movq -0x80(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x3340
jmp 0xd6af
leaq -0x60(%rbp), %rdi
callq 0x3160
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0xd661
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3160
jmp 0xd7b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3160
jmp 0xd7b2
jmp 0xd6f9
cmpl $0x4, -0x40(%rbp)
jge 0xd71a
movq -0x10(%rbp), %rdi
leaq 0xe554(%rip), %rsi      # 0x1bc5e
callq 0x3260
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0xd6f9
movq -0x10(%rbp), %rdi
leaq 0xe53a(%rip), %rsi      # 0x1bc5f
callq 0x3260
movl $0x0, -0x40(%rbp)
movq -0x78(%rbp), %rcx
movl -0x40(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0xd7a9
movq -0x78(%rbp), %rax
movslq -0x40(%rbp), %rcx
movb 0x18(%rax,%rcx), %cl
movb %cl, -0x61(%rbp)
movl 0x34(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xd761
movzbl -0x61(%rbp), %eax
andl $0x7f, %eax
movb %al, -0x61(%rbp)
movzbl -0x61(%rbp), %edi
callq 0x3450
cmpl $0x0, %eax
je 0xd78e
movzbl -0x61(%rbp), %edi
callq 0x33f0
cmpl $0x0, %eax
je 0xd78e
movb -0x61(%rbp), %al
movq -0x10(%rbp), %rdi
movsbl %al, %esi
callq 0x3170
jmp 0xd79c
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x3170
jmp 0xd79e
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0xd731
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3440
nopl (%rax,%rax)
// File: ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, unsigned int)
void disassembler::dump(const std::string &expr, unsigned size, uint32_t value) {

	std::string line;

	if (_st) dump();

	for (_st = 0; _st < size; ++_st) {
		_bytes[_st] = value & 0xff;
		value >>= 8;
	}

	auto p = format_data(size, expr);

	indent_to(line, kOpcodeTab);
	line += p.first;
	indent_to(line, kOperandTab);
	line += p.second;

	hexdump(line);
	line.push_back('\n');
	fputs(line.c_str(), stdout);

	_pc += _st;
	reset();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3380
movq -0x90(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0xd81b
movq -0x90(%rbp), %rdi
callq 0xd490
jmp 0xd808
jmp 0xd81b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xd957
movq -0x90(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x90(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jae 0xd86c
movq -0x90(%rbp), %rax
movl -0x18(%rbp), %ecx
andl $0xff, %ecx
movb %cl, %dl
movl 0x8(%rax), %ecx
movb %dl, 0x18(%rax,%rcx)
movl -0x18(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x18(%rbp)
movq -0x90(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0xd829
movq -0x90(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rcx
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x88(%rbp), %rdi
callq *%rax
jmp 0xd88c
leaq -0x38(%rbp), %rdi
movl $0x14, %esi
callq 0xcb10
jmp 0xd89c
leaq -0x38(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x3340
jmp 0xd8ae
leaq -0x38(%rbp), %rdi
movl $0x1e, %esi
callq 0xcb10
jmp 0xd8be
leaq -0x68(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3340
jmp 0xd8cd
movq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd5e0
jmp 0xd8df
leaq -0x38(%rbp), %rdi
movl $0xa, %esi
callq 0x3230
jmp 0xd8ef
leaq -0x38(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
movq 0x176be(%rip), %rax     # 0x24fc0
movq (%rax), %rsi
callq 0x32e0
jmp 0xd90c
movq -0x90(%rbp), %rdi
movl 0x8(%rdi), %eax
addl 0x20(%rdi), %eax
movl %eax, 0x20(%rdi)
callq 0xd060
leaq -0x88(%rbp), %rdi
callq 0xf270
leaq -0x38(%rbp), %rdi
callq 0x3160
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xf270
leaq -0x38(%rbp), %rdi
callq 0x3160
movq -0x40(%rbp), %rdi
callq 0x3440
nopl (%rax)
// File: ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::check_labels()
void disassembler::check_labels() {

	if ( _next_label >= 0 && _pc + _st >= _next_label) {
		//flush(); // -- too recursive.  see above.
		if (_st) dump();
		_next_label = next_label(_pc);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x30(%rax)
jl 0xda02
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %eax
addl 0x8(%rcx), %eax
cmpl 0x30(%rcx), %eax
jb 0xda02
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0xd9ec
movq -0x10(%rbp), %rdi
callq 0xd490
movq -0x10(%rbp), %rdi
movl 0x20(%rdi), %esi
movq (%rdi), %rax
callq *0x38(%rax)
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, unsigned int)
void disassembler::operator()(const std::string &expr, unsigned size, uint32_t value) {

	if (_st == 0 || !_code)
		check_labels();

	if (!_code) {
		dump(expr, size, value);
		if (_inline_data) {
			_inline_data -= size;
			if (_inline_data <= 0) _code = true; 
		}
		return;
	}

	if (_st != 1 || size != _size) {
		dump(expr, size, value);
		return;
	}
	for (int i = 0; i < size; ++i) {
		_bytes[_st++] = value & 0xff;
		value >>= 8;
	}
	print(expr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, 0x8(%rax)
je 0xdcce
movq -0x28(%rbp), %rax
testb $0x1, 0x28(%rax)
jne 0xdcd7
movq -0x28(%rbp), %rdi
callq 0xd9b0
movq -0x28(%rbp), %rax
testb $0x1, 0x28(%rax)
jne 0xdd1f
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0xd7c0
movq -0x28(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0xdd1d
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %edx
movl 0x2c(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x2c(%rax)
cmpl $0x0, 0x2c(%rax)
jg 0xdd1b
movq -0x28(%rbp), %rax
movb $0x1, 0x28(%rax)
jmp 0xdd1d
jmp 0xdd9a
movq -0x28(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0xdd35
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x10(%rcx), %eax
je 0xdd4a
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0xd7c0
jmp 0xdd9a
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0xdd8d
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %ecx
andl $0xff, %ecx
movb %cl, %dl
movl 0x8(%rax), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x8(%rax)
movl %ecx, %ecx
movb %dl, 0x18(%rax,%rcx)
movl -0x18(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xdd51
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xdda0
addq $0x30, %rsp
popq %rbp
retq
// File: ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::print(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void disassembler::print(const std::string &expr) {


	std::string line;

	indent_to(line, kOpcodeTab);
	line.append(&opcodes[_op * 3], 3);

	if (_size) {

		indent_to(line, kOperandTab);
		line += prefix();
		line += expr;
		line += suffix();
	}

	hexdump(line);
	line.push_back('\n');
	fputs(line.c_str(), stdout);

	_pc += _size + 1;
	reset();	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3380
movq -0x88(%rbp), %rdi
movl $0x14, %esi
callq 0xcb10
jmp 0xdde1
movq -0x90(%rbp), %rax
movzbl 0xc(%rax), %ecx
movl %ecx, %eax
leal (%rax,%rax,2), %eax
leaq 0xdb18(%rip), %rsi      # 0x1b910
addq %rax, %rsi
leaq -0x30(%rbp), %rdi
movl $0x3, %edx
callq 0x3070
jmp 0xde0b
movq -0x90(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0xded3
leaq -0x30(%rbp), %rdi
movl $0x1e, %esi
callq 0xcb10
jmp 0xde2c
movq -0x90(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0xe8b0
jmp 0xde3e
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3340
jmp 0xde4d
leaq -0x60(%rbp), %rdi
callq 0x3160
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3340
jmp 0xde65
movq -0x90(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0xea80
jmp 0xde77
leaq -0x30(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x3340
jmp 0xde86
leaq -0x80(%rbp), %rdi
callq 0x3160
jmp 0xded3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xdf3c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3160
jmp 0xdf3c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3160
jmp 0xdf3c
movq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xd5e0
jmp 0xdee5
leaq -0x30(%rbp), %rdi
movl $0xa, %esi
callq 0x3230
jmp 0xdef5
leaq -0x30(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
movq 0x170b8(%rip), %rax     # 0x24fc0
movq (%rax), %rsi
callq 0x32e0
jmp 0xdf12
movq -0x90(%rbp), %rdi
movl 0x10(%rdi), %eax
addl $0x1, %eax
addl 0x20(%rdi), %eax
movl %eax, 0x20(%rdi)
callq 0xd060
leaq -0x30(%rbp), %rdi
callq 0x3160
addq $0x90, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x3160
movq -0x38(%rbp), %rdi
callq 0x3440
nop
// File: ksherlock[P]wdc-utils/disassembler.cpp
// Function: branchlike(unsigned char)
static bool branchlike(uint8_t op) {

	switch(op) {
		case 0x10: // bpl
		//case 0x20: // jsr
		//case 0x22: // jsl
		case 0x30: // bmi
		case 0x40: // rti
		case 0x4c: // jmp
		case 0x50: // bvc
		case 0x5c: // jml
		case 0x60: // rts
		case 0x6b: // rtl
		case 0x6c: // jmp
		case 0x70: // bvs
		case 0x7c: // jmp
		case 0x80: // bra
		case 0x82: // brl
		case 0x90: // bcc
		case 0xb0: // bcs
		case 0xd0: // bne
		case 0xdc: // jml
		case 0xf0: // beq
		//case 0xfc: // jsr
			return true;
		default:
			return false;
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x10, %eax
je 0xe891
jmp 0xe7cc
movl -0x8(%rbp), %eax
subl $0x30, %eax
je 0xe891
jmp 0xe7da
movl -0x8(%rbp), %eax
subl $0x40, %eax
je 0xe891
jmp 0xe7e8
movl -0x8(%rbp), %eax
subl $0x4c, %eax
je 0xe891
jmp 0xe7f6
movl -0x8(%rbp), %eax
subl $0x50, %eax
je 0xe891
jmp 0xe804
movl -0x8(%rbp), %eax
subl $0x5c, %eax
je 0xe891
jmp 0xe812
movl -0x8(%rbp), %eax
subl $0x60, %eax
je 0xe891
jmp 0xe81c
movl -0x8(%rbp), %eax
addl $-0x6b, %eax
subl $0x2, %eax
jb 0xe891
jmp 0xe829
movl -0x8(%rbp), %eax
subl $0x70, %eax
je 0xe891
jmp 0xe833
movl -0x8(%rbp), %eax
subl $0x7c, %eax
je 0xe891
jmp 0xe83d
movl -0x8(%rbp), %eax
subl $0x80, %eax
je 0xe891
jmp 0xe849
movl -0x8(%rbp), %eax
subl $0x82, %eax
je 0xe891
jmp 0xe855
movl -0x8(%rbp), %eax
subl $0x90, %eax
je 0xe891
jmp 0xe861
movl -0x8(%rbp), %eax
subl $0xb0, %eax
je 0xe891
jmp 0xe86d
movl -0x8(%rbp), %eax
subl $0xd0, %eax
je 0xe891
jmp 0xe879
movl -0x8(%rbp), %eax
subl $0xdc, %eax
je 0xe891
jmp 0xe885
movl -0x8(%rbp), %eax
subl $0xf0, %eax
jne 0xe897
jmp 0xe891
movb $0x1, -0x1(%rbp)
jmp 0xe89b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::prefix[abi:cxx11]()
std::string disassembler::prefix() {

	std::string tmp;

	switch(_mode & 0xf000) {
		case mImmediate: tmp = "#"; break;
		case mDP: tmp = "<"; break;
		case mDPI: tmp = "(<"; break;
		case mDPIL: tmp = "[<"; break;
		case mAbsoluteIL: tmp = "["; break;

		case mRelative:
		case mBlockMove:
			break;

		// cop, brk are treated as absolute.
		case mAbsolute: 
			//if (_size == 1) printf("\t");
			if (_size > 1) tmp = "|";
			break;
		case mAbsoluteLong: tmp = ">"; break;
		case mAbsoluteI: tmp = "("; break;
	}
	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3380
movq -0x30(%rbp), %rax
movl 0x14(%rax), %eax
andl $0xf000, %eax           # imm = 0xF000
movl %eax, -0x28(%rbp)
subl $0x1000, %eax           # imm = 0x1000
je 0xe983
jmp 0xe8f8
movl -0x28(%rbp), %eax
subl $0x2000, %eax           # imm = 0x2000
je 0xea09
jmp 0xe908
movl -0x28(%rbp), %eax
subl $0x3000, %eax           # imm = 0x3000
je 0xea3d
jmp 0xe918
movl -0x28(%rbp), %eax
subl $0x4000, %eax           # imm = 0x4000
je 0xe9f3
jmp 0xe928
movl -0x28(%rbp), %eax
subl $0x5000, %eax           # imm = 0x5000
je 0xea29
jmp 0xe938
movl -0x28(%rbp), %eax
subl $0x6000, %eax           # imm = 0x6000
je 0xe9b4
jmp 0xe944
movl -0x28(%rbp), %eax
subl $0x7000, %eax           # imm = 0x7000
je 0xe9cb
jmp 0xe950
movl -0x28(%rbp), %eax
subl $0x8000, %eax           # imm = 0x8000
je 0xe9df
jmp 0xe960
movl -0x28(%rbp), %eax
subl $0x9000, %eax           # imm = 0x9000
je 0xea07
jmp 0xe970
movl -0x28(%rbp), %eax
subl $0xa000, %eax           # imm = 0xA000
je 0xea07
jmp 0xea51
movq -0x40(%rbp), %rdi
leaq 0xd2b9(%rip), %rsi      # 0x1bc47
callq 0x3350
jmp 0xe995
jmp 0xea51
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3160
jmp 0xea6e
movq -0x40(%rbp), %rdi
leaq 0xd28b(%rip), %rsi      # 0x1bc4a
callq 0x3350
jmp 0xe9c6
jmp 0xea51
movq -0x40(%rbp), %rdi
leaq 0xd273(%rip), %rsi      # 0x1bc49
callq 0x3350
jmp 0xe9dd
jmp 0xea51
movq -0x40(%rbp), %rdi
leaq 0xd262(%rip), %rsi      # 0x1bc4c
callq 0x3350
jmp 0xe9f1
jmp 0xea51
movq -0x40(%rbp), %rdi
leaq 0xd251(%rip), %rsi      # 0x1bc4f
callq 0x3350
jmp 0xea05
jmp 0xea51
jmp 0xea51
movq -0x30(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jbe 0xea27
movq -0x40(%rbp), %rdi
leaq 0xc7c6(%rip), %rsi      # 0x1b1e4
callq 0x3350
jmp 0xea25
jmp 0xea27
jmp 0xea51
movq -0x40(%rbp), %rdi
leaq 0xc7a9(%rip), %rsi      # 0x1b1dd
callq 0x3350
jmp 0xea3b
jmp 0xea51
movq -0x40(%rbp), %rdi
leaq 0xd209(%rip), %rsi      # 0x1bc51
callq 0x3350
jmp 0xea4f
jmp 0xea51
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xea64
movq -0x40(%rbp), %rdi
callq 0x3160
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3440
nopw (%rax,%rax)
// File: ksherlock[P]wdc-utils/disassembler.cpp
// Function: analyzer::finish()
const std::vector<uint32_t> &analyzer::finish() {
	std::sort(_labels.begin(), _labels.end());
	auto end = std::unique(_labels.begin(), _labels.end());
	_labels.erase(end, _labels.end());
	return _labels;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x28, %rdi
callq 0xf320
movq -0x58(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x28, %rdi
callq 0xf350
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf2e0
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
callq 0xf320
movq -0x58(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x28, %rdi
callq 0xf350
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xf380
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x20(%rbp)
addq $0x28, %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xf450
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
callq 0xf350
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xf450
movq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xf3c0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x50(%rbp)
addq $0x28, %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ksherlock[P]wdc-utils/disassembler.cpp
// Function: analyzer::operator()(unsigned char)
void analyzer::operator()(uint8_t byte) {


	if (!_code) {

		if (_inline_data && --_inline_data <= 0) {
			_code = true;
			reset();
			return;
		}
		return;
	}

	_st++;
	if (_st == 1) {
		_op = byte;
		_mode = modes[_op];

		_size = _mode & 0x0f;
		if (_mode & _flags & m_I) _size++;
		if (_mode & _flags & m_M) _size++;

		if (!_size) { reset(); }
		return;
	}
	unsigned shift = (_st - 2) * 8;
	_arg = _arg + (byte << shift);
	if (_st <= _size) return;


	// all done... now process it
	process();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x8(%rax)
jne 0xee73
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xee6e
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rcx)
cmpl $0x0, %eax
jg 0xee6e
movq -0x18(%rbp), %rdi
movb $0x1, 0x8(%rdi)
callq 0xef40
jmp 0xef33
jmp 0xef33
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
cmpl $0x1, 0xc(%rax)
jne 0xeefb
movq -0x18(%rbp), %rcx
movb -0x9(%rbp), %al
movb %al, 0x10(%rcx)
movzbl 0x10(%rcx), %eax
movl %eax, %edx
leaq 0xc673(%rip), %rax      # 0x1b510
movl (%rax,%rdx,4), %eax
movl %eax, 0x24(%rcx)
movl 0x24(%rcx), %eax
andl $0xf, %eax
movl %eax, 0x14(%rcx)
movl 0x24(%rcx), %eax
andl 0x18(%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xeec7
movq -0x18(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rcx
movl 0x24(%rcx), %eax
andl 0x18(%rcx), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0xeee6
movq -0x18(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0xeef9
movq -0x18(%rbp), %rdi
callq 0xef40
jmp 0xef33
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
subl $0x2, %ecx
shll $0x3, %ecx
movl %ecx, -0x10(%rbp)
movl 0x20(%rax), %eax
movzbl -0x9(%rbp), %edx
movl -0x10(%rbp), %ecx
shll %cl, %edx
movq -0x18(%rbp), %rcx
addl %edx, %eax
movl %eax, 0x20(%rcx)
movl 0xc(%rcx), %eax
cmpl 0x14(%rcx), %eax
ja 0xef2a
jmp 0xef33
movq -0x18(%rbp), %rdi
callq 0xef70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ksherlock[P]wdc-utils/disassembler.cpp
// Function: analyzer::process()
void analyzer::process() {

	if (_traits & disassembler::track_rep_sep) {
		switch(_op) {
			case 0xc2: // REP
				_flags |= (_arg & 0x30);
				break;
			case 0xe2: // SEP
				_flags &= ~(_arg & 0x30);
				break;
		}
	}

	switch (_mode & 0xf000) {
		case mRelative: {

			uint32_t pc = _pc + 1 + _size + _arg;

			if ((_size == 1) && (_arg & 0x80))
				pc += 0xff00;
			pc &= 0xffff;

			_labels.push_back(pc);
			break;
		}
		case mAbsolute:
		case mAbsoluteI:
		case mAbsoluteLong: {
			_labels.push_back(_arg);
			break;
		}
	}
	reset();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xefd5
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0xc2, %eax
je 0xefae
jmp 0xefa2
movl -0x1c(%rbp), %eax
subl $0xe2, %eax
je 0xefc0
jmp 0xefd3
movq -0x18(%rbp), %rax
movl 0x20(%rax), %ecx
andl $0x30, %ecx
orl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
jmp 0xefd3
movq -0x18(%rbp), %rax
movl 0x20(%rax), %ecx
andl $0x30, %ecx
xorl $-0x1, %ecx
andl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
jmp 0xefd5
movq -0x18(%rbp), %rax
movl 0x24(%rax), %eax
andl $0xf000, %eax           # imm = 0xF000
movl %eax, -0x20(%rbp)
subl $0x2000, %eax           # imm = 0x2000
je 0xf064
jmp 0xefed
movl -0x20(%rbp), %eax
subl $0x3000, %eax           # imm = 0x3000
je 0xf064
jmp 0xeff9
movl -0x20(%rbp), %eax
subl $0x5000, %eax           # imm = 0x5000
je 0xf064
jmp 0xf005
movl -0x20(%rbp), %eax
subl $0x9000, %eax           # imm = 0x9000
jne 0xf078
jmp 0xf011
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
addl 0x14(%rax), %ecx
addl 0x20(%rax), %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x1, 0x14(%rax)
jne 0xf046
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xf046
movl -0xc(%rbp), %eax
addl $0xff00, %eax           # imm = 0xFF00
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0xc(%rbp)
addq $0x28, %rdi
leaq -0xc(%rbp), %rsi
callq 0xf490
jmp 0xf078
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x28, %rdi
addq $0x20, %rsi
callq 0xf490
movq -0x18(%rbp), %rdi
callq 0xef40
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ksherlock[P]wdc-utils/zrdz_disassembler.cpp
// Function: zrdz_disassembler::print_externs()
void zrdz_disassembler::print_externs() {

	std::vector<std::string> tmp;

	for (auto &s : _symbols) {
		if (s.type == S_UND) tmp.push_back(s.name);
	}

	if (tmp.empty()) return;
	std::sort(tmp.begin(), tmp.end());
	for (const auto &s : tmp) emit("", "extern", s);
	putchar('\n');

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8280
movq -0xd8(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa6a0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa490
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x15c30
testb $0x1, %al
jne 0x1249f
jmp 0x124e8
leaq -0x30(%rbp), %rdi
callq 0xab10
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x0, %eax
jne 0x124db
movq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x15ec0
jmp 0x124c8
jmp 0x124db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x126af
jmp 0x124dd
leaq -0x30(%rbp), %rdi
callq 0x15cf0
jmp 0x1248c
leaq -0x20(%rbp), %rdi
callq 0x8570
testb $0x1, %al
jne 0x124f7
jmp 0x12503
movl $0x1, -0x50(%rbp)
jmp 0x1269d
leaq -0x20(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0xc5e0
movq -0xe0(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0xc460
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x15f30
jmp 0x12536
leaq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0xc5e0
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
callq 0xc460
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x15f70
testb $0x1, %al
jne 0x1256e
jmp 0x1268a
leaq -0x70(%rbp), %rdi
callq 0xcaf0
movq %rax, -0x80(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x3460
movq -0xe8(%rbp), %rdx
leaq 0x8dd8(%rip), %rsi      # 0x1b374
leaq -0xa0(%rbp), %rdi
callq 0x8060
jmp 0x125aa
leaq -0xc9(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x3460
movq -0xf0(%rbp), %rdx
leaq 0x975c(%rip), %rsi      # 0x1bd27
leaq -0xc8(%rbp), %rdi
callq 0x8060
jmp 0x125d9
movq -0x80(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0xce40
jmp 0x125f2
leaq -0xc8(%rbp), %rdi
callq 0x3160
leaq -0xc9(%rbp), %rdi
callq 0x32b0
leaq -0xa0(%rbp), %rdi
callq 0x3160
leaq -0xa1(%rbp), %rdi
callq 0x32b0
leaq -0x70(%rbp), %rdi
callq 0x15fb0
jmp 0x12558
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1267c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x12664
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x3160
leaq -0xc9(%rbp), %rdi
callq 0x32b0
leaq -0xa0(%rbp), %rdi
callq 0x3160
leaq -0xa1(%rbp), %rdi
callq 0x32b0
jmp 0x126af
movl $0xa, %edi
callq 0x3390
jmp 0x12696
movl $0x0, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8740
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x8740
movq -0x48(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)