// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/dumpobj.cpp
// Function: dump_obj(char const*, int)
bool dump_obj(const char *name, int fd)
{
	Mod_head h;
	ssize_t ok;

	ok = read(fd, &h, sizeof(h));
	if (ok == 0) return false;

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


	le_to_host(h.h_magic);
	le_to_host(h.h_version);
	le_to_host(h.h_filtyp);
	le_to_host(h.h_namlen);
	le_to_host(h.h_recsize);
	le_to_host(h.h_secsize);
	le_to_host(h.h_symsize);
	le_to_host(h.h_optsize);
	le_to_host(h.h_tot_secs);
	le_to_host(h.h_num_secs);
	le_to_host(h.h_num_syms);

	assert(h.h_magic == MOD_MAGIC);
	assert(h.h_version == 1);
	assert(h.h_filtyp == 1);

	// now read the name (h_namlen includes 0 terminator.)
	std::vector<char> oname;
	oname.resize(h.h_namlen);
	ok = read(fd, oname.data(), h.h_namlen);
	if (ok != h.h_namlen) errx(EX_DATAERR, "%s", name);


	// records [until record_eof]

	std::vector<uint8_t> data;
	data.resize(h.h_recsize);
	ok = read(fd, data.data(), h.h_recsize);
	if (ok != h.h_recsize) errx(EX_DATAERR, "%s records truncated", name);


	std::vector<uint8_t> section_data;
	section_data.resize(h.h_secsize);
	ok = read(fd, section_data.data(), h.h_secsize);
	if (ok != h.h_secsize) errx(EX_DATAERR, "%s sections truncated", name);


	std::vector<uint8_t> symbol_data;
	symbol_data.resize(h.h_symsize);
	ok = read(fd, symbol_data.data(), h.h_symsize);
	if (ok != h.h_symsize) errx(EX_DATAERR, "%s symbols truncated", name);

	if (h.h_optsize) lseek(fd, h.h_optsize, SEEK_CUR);


	zrdz_disassembler d(read_sections(section_data), read_symbols(symbol_data));

	uint8_t op = REC_END;
	unsigned line = 0;


	d.front_matter(std::string(oname.data()));

	auto iter = data.begin();
	while (iter != data.end()) {


		op = read_8(iter);
		if (op == 0) break;
		if (op < 0xf0) {
			auto end = iter + op;
			while (iter != end) {
				d(*iter++);
			}
			continue;
		}

		switch(op) {

			case REC_RELEXP:
			case REC_EXPR:
				{

					// todo -- pass the relative flag to ()
					// so it can verify it's appropriate for the opcode.

					// todo -- move all this stuff to a separate function.
					uint8_t size = read_8(iter);

					std::vector<std::string> stack;

					// todo -- need to keep operation for precedence?
					// this ignores all precedence...

					for(;;) {
						uint8_t op = read_8(iter);
						if (op == OP_END) break;
						switch (op) {
							case OP_LOC: {
								uint8_t section = read_8(iter);
								uint32_t offset = read_32(iter);


								std::string name;
								if (flags.n) {
									name = d.section_name(section) + "+" + d.to_x(offset, 4, '$');
								} else {
									name = d.location_name(section, offset);
								}
								stack.emplace_back(std::move(name));
								break;
							}

							case OP_VAL:
								stack.push_back(d.to_x(read_32(iter), 4, '$'));
								break;

							case OP_SYM: {
								uint16_t symbol = read_16(iter);
								stack.emplace_back(d.symbol_name(symbol));
								break;
							}

							// unary operatos
							case OP_NOT:
							case OP_NEG:
							case OP_FLP: {
								static const std::string ops[] = {
									".NOT.", "-", "\\"
								};

								if (stack.empty()) errx(EX_DATAERR, "%s : stack underflow error", name);
								std::string a = std::move(stack.back()); stack.pop_back();
								std::string b(ops[op-10]);
								stack.emplace_back(b + a);
								break;
							}

							// binary operators
							case OP_EXP:
							case OP_MUL:
							case OP_DIV:
							case OP_MOD:
							case OP_SHR:
							case OP_SHL:
							case OP_ADD:
							case OP_SUB:
							case OP_AND:
							case OP_OR:
							case OP_XOR:
							case OP_EQ:
							case OP_GT:
							case OP_LT:
							case OP_UGT:
							case OP_ULT: {
								static const std::string ops[] = {
									"**", "*", "/", ".MOD.", ">>", "<<", "+", "-", "&", "|", "^", "=", ">", "<", ".UGT.", ".ULT."

								};
								if (stack.size() < 2) errx(EX_DATAERR, "%s : stack underflow error", name);
								std::string a = std::move(stack.back()); stack.pop_back();
								std::string b = std::move(stack.back()); stack.pop_back();
								stack.emplace_back(b + ops[op-20] + a);
								break;
							}
							default:
								errx(EX_DATAERR, "%s: unknown expression opcode %02x", name, op);

						}
					}
					if (stack.size() != 1) errx(EX_DATAERR, "%s stack overflow error.", name);
					d(stack.front(), size);
				}
				break;

			case REC_DEBUG:
				{
					d.flush();
					uint16_t size = read_16(iter);

					auto end = iter + size;
					while (iter < end) {
						uint8_t op = read_8(iter);
						switch(op) {
							case D_LONGA_ON:
								d.set_m(true);
								d.emit("", "longa", "on");
								break;
							case D_LONGA_OFF:
								d.set_m(false);
								d.emit("", "longa", "off");
								break;
							case D_LONGI_ON:
								d.set_x(true);
								d.emit("", "longi", "on");
								break;
							case D_LONGI_OFF:
								d.set_x(false);
								d.emit("", "longi", "off");
								break;
							case D_C_FILE: {
								std::string file = read_cstring(iter);
								line = read_16(iter);
								std::string tmp = file + ", " + std::to_string(line);
								d.emit("", ".file", tmp);
								break;
							}
							case D_C_LINE: {
								line = read_16(iter);
								d.emit("",".line", std::to_string(line));
								break;
							}
							case D_C_BLOCK: {
								uint16_t block = read_16(iter);
								d.emit("",".block", std::to_string(block));
								break;
							}
							case D_C_ENDBLOCK: {
								uint16_t block = read_16(iter);
								d.emit("",".endblock", std::to_string(block));
								break;
							}
							case D_C_FUNC: {
								uint16_t arg = read_16(iter);
								d.emit("",".function", std::to_string(arg));
								break;								
							}
							case D_C_ENDFUNC: {
								uint16_t line = read_16(iter);
								uint16_t local_offset = read_16(iter);
								uint16_t arg_offset = read_16(iter);
								std::string tmp;
								tmp = std::to_string(line) + ", "
									+ std::to_string(local_offset) + ", "
									+ std::to_string(arg_offset);
								d.emit("",".endfunc", tmp);
								break;
							}

							// etag? reserved for enums but not actually used?
							case D_C_STAG:
							case D_C_ETAG:
							case D_C_UTAG: {
								const char *kOpNames[] = { ".stag", ".etag", ".utag" };
								const char *opname = kOpNames[op - D_C_STAG];

								std::string name = read_cstring(iter);
								uint16_t size = read_16(iter);
								uint16_t tag = read_16(iter);

								std::string tmp;
								tmp = name + ", " + std::to_string(size) + ", " + std::to_string(tag);
								d.emit("", opname, tmp);
								break;
							}
							case D_C_EOS: {
								d.emit("", ".eos");
								break; 
							}

							case D_C_MEMBER:
							case D_C_SYM: {
								// warning - i don't fully understand this one..
								std::string name = read_cstring(iter);
								uint8_t version = read_8(iter); //???
								uint32_t value;
								if (version == 0) value = read_16(iter); // symbol
								if (version == 1) value = read_32(iter); // numeric value.
								assert(version == 0 || version == 1);
								uint32_t type = read_32(iter);
								uint8_t klass = read_8(iter);
								uint16_t size = read_16(iter);


								const char *opname = ".sym";
								if (op == D_C_MEMBER) opname = ".member";


								std::string attr;

								if (version == 0) {
									std::string svalue;
									svalue = d.symbol_name(value);

									attr = name + ", " + svalue;
								}

								if (version == 1) {
									attr = name + ", " + std::to_string(value);
								}

								attr += ", " + std::to_string(type);
								attr += ", " + std::to_string(klass);
								attr += ", " + std::to_string(size);


								/*
								 * type bits 1 ... 5 are T_xxxx
								 * then 3 bits of DT_xxx (repeatedly)
								 *
								 * eg, char ** = (DT_PTR << 11) + (DT_PTR << 8) + T_CHAR
								 */
								int t = type & 0x1f;
								if ((t == T_STRUCT) || (t == T_UNION)) {
									uint16_t tag = read_16(iter);
									attr += ", " + std::to_string(tag);
								}

								// need to do it until t == 0 for
								// multidimensional arrays.
								for ( t = type >> 5; t; t >>= 3) {
									if ((t & 0x07) == DT_ARY) {
										uint16_t dim = read_16(iter);
										attr += ", " + std::to_string(dim);
									}
								}


								d.emit("", opname, attr);

								break;
							}

							default:
								errx(EX_DATAERR, "%s: unknown debug opcode %02x (%d)", name, op, op);
								break;

						}
					}
				}
				break;

			case REC_SECT: {
				uint8_t sec = read_8(iter);
				d.set_section(sec);
				break;
			}

			case REC_ORG: {
				d.flush();
				uint32_t org = read_32(iter);
				d.emit("", ".org", d.to_x(org, 4, '$'));
				d.set_pc(org);
				break;
			}

			case REC_SPACE: {
				uint16_t count = read_16(iter);
				d.space(count);
				break;
			}

			case REC_LINE: {
				// bump line counter, no argument.
				d.flush();
				++line;
				break;
			}
			default:
				d.flush();
				errx(EX_DATAERR, "%s: unknown opcode %02x", name, op);
		}
	}


	unsigned f = 0;
	if (flags.S) f |= 0x01;
	d.back_matter(f);

	if (iter != data.end() || op != REC_END) errx(EX_DATAERR, "%s records ended early", name);



	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp            # imm = 0x298
movl %esi, %ebx
movq %rdi, %r15
leaq 0x148(%rsp), %rsi
pushq $0x18
popq %rdx
movl %ebx, %edi
callq 0x2290
movq %rax, %r12
testq %rax, %rax
je 0x3c2a
cmpq $0x18, %r12
jne 0x3cfc
cmpl $0x5a44525a, 0x148(%rsp) # imm = 0x5A44525A
jne 0x3d10
cmpw $0x1, 0x14c(%rsp)
jne 0x3d2f
cmpb $0x1, 0x14e(%rsp)
jne 0x3d4e
xorps %xmm0, %xmm0
leaq 0x1f0(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movzbl 0x14f(%rsp), %r14d
movq %r14, %rsi
callq 0x487c
movq 0x1f0(%rsp), %rsi
movl %ebx, %edi
movq %r14, %rdx
callq 0x2290
cmpq %r14, %rax
jne 0x3d6d
xorps %xmm0, %xmm0
leaq 0x160(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movl 0x150(%rsp), %r14d
movq %r14, %rsi
callq 0x48a8
movq 0x160(%rsp), %rsi
movl %ebx, %edi
movq %r14, %rdx
callq 0x2290
cmpq %r14, %rax
jne 0x3d81
xorps %xmm0, %xmm0
leaq 0x1d0(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movzwl 0x154(%rsp), %r14d
movq %r14, %rsi
callq 0x48a8
movq 0x1d0(%rsp), %rsi
movl %ebx, %edi
movq %r14, %rdx
callq 0x2290
cmpq %r14, %rax
jne 0x3d95
xorps %xmm0, %xmm0
leaq 0x1b0(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movl 0x156(%rsp), %r14d
movq %r14, %rsi
callq 0x48a8
movq 0x1b0(%rsp), %rsi
movl %ebx, %edi
movq %r14, %rdx
callq 0x2290
cmpq %r14, %rax
jne 0x3da9
movzwl 0x15a(%rsp), %esi
testq %rsi, %rsi
je 0x28af
pushq $0x1
popq %rdx
movl %ebx, %edi
callq 0x2340
leaq 0x48(%rsp), %rdi
leaq 0x1d0(%rsp), %rsi
callq 0x251c
leaq 0x78(%rsp), %rdi
leaq 0x1b0(%rsp), %rsi
callq 0x2620
leaq 0x208(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x78(%rsp), %rdx
callq 0x73a8
leaq 0x78(%rsp), %rdi
callq 0x485a
leaq 0x48(%rsp), %rdi
callq 0x47fc
movq 0x1f0(%rsp), %rsi
leaq 0x48(%rsp), %rdi
leaq 0x78(%rsp), %rdx
callq 0x48d4
movq %r12, 0x180(%rsp)
movq %r15, 0xb8(%rsp)
leaq 0x208(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x7678
leaq 0x48(%rsp), %r13
movq %r13, %rdi
callq 0x20d0
movq 0x160(%rsp), %rax
movq %rsp, %rcx
movq %rax, (%rcx)
movq $0x0, 0xe8(%rsp)
leaq 0x100(%rsp), %r12
leaq 0x98(%rsp), %rbp
leaq 0x78(%rsp), %r14
leaq 0xf8b6(%rip), %rcx      # 0x12230
movq %rcx, 0x140(%rsp)
leaq 0xf917(%rip), %rcx      # 0x122a0
movq %rcx, 0x10(%rsp)
leaq 0xfa4b(%rip), %rcx      # 0x123e0
movq %rcx, 0x138(%rsp)
leaq 0xfa5c(%rip), %rcx      # 0x12400
movq %rcx, 0x130(%rsp)
leaq 0xfa6d(%rip), %rcx      # 0x12420
movq %rcx, 0x128(%rsp)
leaq 0xfa7e(%rip), %rcx      # 0x12440
movq %rcx, 0x120(%rsp)
cmpq 0x168(%rsp), %rax
je 0x3bad
movzbl (%rax), %ecx
leaq 0x1(%rax), %rbx
movq %rbx, (%rsp)
testq %rcx, %rcx
je 0x3ba1
cmpb $-0x11, %cl
movq %rcx, 0xe8(%rsp)
ja 0x2a1f
addq %rcx, %rbx
movq (%rsp), %rax
cmpq %rbx, %rax
je 0x29ca
leaq 0x1(%rax), %rcx
movq %rcx, (%rsp)
movzbl (%rax), %esi
leaq 0x208(%rsp), %rdi
callq 0x63a4
jmp 0x29fc
addl $0xffffff10, %ecx       # imm = 0xFFFFFF10
cmpl $0x6, %ecx
ja 0x3cce
leaq 0x85eb(%rip), %rdx      # 0xb020
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movzbl 0x1(%rax), %ecx
movl %ecx, 0xf0(%rsp)
addq $0x2, %rax
movq %rax, (%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
movzbl (%rax), %r15d
leaq 0x1(%rax), %rcx
movq %rcx, (%rsp)
cmpq $0x23, %r15
ja 0x3c5b
leaq 0x8600(%rip), %rdx      # 0xb07c
movslq (%rdx,%r15,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movb 0xf9f5(%rip), %al       # 0x12480
testb %al, %al
je 0x2d13
movq 0x28(%rsp), %rsi
movq %rsi, %rax
subq 0x20(%rsp), %rax
cmpq $0x20, %rax
jbe 0x3c42
addq $-0x20, %rsi
movq %r13, %rdi
callq 0x2240
movq 0x28(%rsp), %rdi
addq $-0x20, %rdi
movq %rdi, 0x28(%rsp)
callq 0x20d0
movq 0x28(%rsp), %rsi
addq $-0x20, %rsi
movq %r14, %rdi
callq 0x2240
movq 0x28(%rsp), %rdi
addq $-0x20, %rdi
movq %rdi, 0x28(%rsp)
callq 0x20d0
leal -0x14(%r15), %edx
shlq $0x5, %rdx
leaq 0xf784(%rip), %rax      # 0x12280
addq %rax, %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x4a10
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x4a48
leaq 0x20(%rsp), %rdi
movq %rbp, %rsi
callq 0x49d4
movq %rbp, %rdi
callq 0x20d0
movq %r12, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x20d0
movq %r13, %rdi
callq 0x20d0
movq (%rsp), %rax
jmp 0x2a5f
movb 0xf71c(%rip), %al       # 0x12270
testb %al, %al
je 0x2ece
movq 0x28(%rsp), %rsi
cmpq %rsi, 0x20(%rsp)
je 0x3c42
addq $-0x20, %rsi
movq %r13, %rdi
callq 0x2240
movq 0x28(%rsp), %rdi
addq $-0x20, %rdi
movq %rdi, 0x28(%rsp)
callq 0x20d0
leal -0xa(%r15), %esi
shlq $0x5, %rsi
leaq 0xf676(%rip), %rax      # 0x12210
addq %rax, %rsi
movq %r14, %rdi
callq 0x2260
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x4a10
leaq 0x20(%rsp), %rdi
movq %rbp, %rsi
callq 0x49d4
movq %rbp, %rdi
jmp 0x2b30
movq %rsp, %rdi
callq 0x490f
movq %r13, %rdi
movl %eax, %esi
pushq $0x4
popq %rdx
pushq $0x24
popq %rcx
callq 0x56d0
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
callq 0x49d4
jmp 0x2b3d
movzbl 0x1(%rax), %ecx
leaq 0x2(%rax), %rdx
movq %rdx, (%rsp)
movzbl 0x2(%rax), %edx
shll $0x8, %edx
orl %ecx, %edx
addq $0x3, %rax
movq %rax, (%rsp)
movq %r13, %rdi
leaq 0x208(%rsp), %rsi
callq 0x885c
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
callq 0x49d4
jmp 0x2b3d
movzbl 0x1(%rax), %ebx
addq $0x2, %rax
movq %rax, (%rsp)
movq %rsp, %rdi
callq 0x490f
leaq 0x58(%rsp), %rcx
movq %rcx, 0x48(%rsp)
andq $0x0, 0x50(%rsp)
movl %eax, %r15d
movb $0x0, 0x58(%rsp)
cmpb $0x1, 0xf59d(%rip)      # 0x12201
jne 0x2cd9
movq %r12, %rdi
leaq 0x208(%rsp), %rsi
movl %ebx, %edx
callq 0x88c2
movq %rbp, %rdi
movq %r12, %rsi
leaq 0x8551(%rip), %rdx      # 0xb1d6
callq 0x49b4
leaq 0xc0(%rsp), %rbx
movq %rbx, %rdi
movl %r15d, %esi
pushq $0x4
popq %rdx
pushq $0x24
popq %rcx
callq 0x56d0
movq %r14, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x494d
movq %r13, %rdi
movq %r14, %rsi
callq 0x2220
movq %r14, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x20d0
movq %rbp, %rdi
callq 0x20d0
movq %r12, %rdi
jmp 0x2cfc
movq %r14, %rdi
leaq 0x208(%rsp), %rsi
movl %ebx, %edx
movl %r15d, %ecx
callq 0x8590
movq %r13, %rdi
movq %r14, %rsi
callq 0x2220
movq %r14, %rdi
callq 0x20d0
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
callq 0x49d4
jmp 0x2b3d
leaq 0xf766(%rip), %rdi      # 0x12480
callq 0x2330
testl %eax, %eax
je 0x2a93
leaq 0xf552(%rip), %rdi      # 0x12280
leaq 0x84c8(%rip), %rsi      # 0xb1fd
movq %r13, %rdx
callq 0x48d4
leaq 0xf55c(%rip), %rdi      # 0x122a0
leaq 0x84b3(%rip), %rsi      # 0xb1fe
movq %r14, %rdx
callq 0x48d4
leaq 0xf566(%rip), %rdi      # 0x122c0
leaq 0x849f(%rip), %rsi      # 0xb200
movq %rbp, %rdx
callq 0x48d4
leaq 0xf570(%rip), %rdi      # 0x122e0
leaq 0x848b(%rip), %rsi      # 0xb202
movq %r12, %rdx
callq 0x48d4
leaq 0xf57a(%rip), %rdi      # 0x12300
leaq 0x847b(%rip), %rsi      # 0xb208
leaq 0xc0(%rsp), %rdx
callq 0x48d4
leaq 0xf57f(%rip), %rdi      # 0x12320
leaq 0x8463(%rip), %rsi      # 0xb20b
leaq 0x190(%rsp), %rdx
callq 0x48d4
leaq 0xf584(%rip), %rdi      # 0x12340
leaq 0x8413(%rip), %rsi      # 0xb1d6
leaq 0x278(%rsp), %rdx
callq 0x48d4
leaq 0xf589(%rip), %rdi      # 0x12360
leaq 0x8400(%rip), %rsi      # 0xb1de
leaq 0x77(%rsp), %rdx
callq 0x48d4
leaq 0xf591(%rip), %rdi      # 0x12380
leaq 0x8418(%rip), %rsi      # 0xb20e
leaq 0x76(%rsp), %rdx
callq 0x48d4
leaq 0xf599(%rip), %rdi      # 0x123a0
leaq 0x8402(%rip), %rsi      # 0xb210
leaq 0x75(%rsp), %rdx
callq 0x48d4
leaq 0xf5a1(%rip), %rdi      # 0x123c0
leaq 0x83ec(%rip), %rsi      # 0xb212
leaq 0x74(%rsp), %rdx
callq 0x48d4
leaq 0xf5a9(%rip), %rdi      # 0x123e0
leaq 0x83d6(%rip), %rsi      # 0xb214
leaq 0x73(%rsp), %rdx
callq 0x48d4
leaq 0xf5b1(%rip), %rdi      # 0x12400
leaq 0x83b3(%rip), %rsi      # 0xb209
leaq 0x72(%rsp), %rdx
callq 0x48d4
leaq 0xf5b9(%rip), %rdi      # 0x12420
leaq 0x8e84(%rip), %rsi      # 0xbcf2
leaq 0x71(%rsp), %rdx
callq 0x48d4
leaq 0xf5c1(%rip), %rdi      # 0x12440
leaq 0x8390(%rip), %rsi      # 0xb216
leaq 0x70(%rsp), %rdx
callq 0x48d4
leaq 0xf5c9(%rip), %rdi      # 0x12460
leaq 0x837e(%rip), %rsi      # 0xb21c
leaq 0x6f(%rsp), %rdx
callq 0x48d4
leaq -0xad6(%rip), %rdi      # 0x23d9
xorl %esi, %esi
leaq 0xf320(%rip), %rdx      # 0x121d8
callq 0x21a0
leaq 0xf5bc(%rip), %rdi      # 0x12480
callq 0x2120
jmp 0x2a93
leaq 0xf39b(%rip), %rdi      # 0x12270
callq 0x2330
testl %eax, %eax
je 0x2b5c
leaq 0xf327(%rip), %rdi      # 0x12210
leaq 0x82e8(%rip), %rsi      # 0xb1d8
movq %r13, %rdx
callq 0x48d4
leaq 0xf331(%rip), %rdi      # 0x12230
leaq 0x82d8(%rip), %rsi      # 0xb1de
movq %r14, %rdx
callq 0x48d4
leaq 0xf33b(%rip), %rdi      # 0x12250
leaq 0x82c4(%rip), %rsi      # 0xb1e0
movq %rbp, %rdx
callq 0x48d4
leaq -0xb7b(%rip), %rdi      # 0x23b0
xorl %esi, %esi
leaq 0xf2a4(%rip), %rdx      # 0x121d8
callq 0x21a0
leaq 0xf330(%rip), %rdi      # 0x12270
callq 0x2120
jmp 0x2b5c
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rax
subq %rsi, %rax
cmpq $0x20, %rax
jne 0x3c96
leaq 0x208(%rsp), %rdi
movl 0xf0(%rsp), %edx
xorl %ecx, %ecx
callq 0x61b4
leaq 0x20(%rsp), %rdi
callq 0x4a68
jmp 0x3b98
movzbl 0x1(%rax), %ecx
leaq 0x2(%rax), %rdx
movq %rdx, (%rsp)
movzbl 0x2(%rax), %esi
shll $0x8, %esi
orl %ecx, %esi
addq $0x3, %rax
movq %rax, (%rsp)
leaq 0x208(%rsp), %rdi
callq 0x6018
jmp 0x3b98
movzbl 0x1(%rax), %esi
addq $0x2, %rax
movq %rax, (%rsp)
leaq 0x208(%rsp), %rdi
callq 0x8122
jmp 0x3b98
leaq 0x208(%rsp), %rdi
callq 0x5fc6
movq (%rsp), %rcx
movzbl (%rcx), %eax
leaq 0x1(%rcx), %rdx
movq %rdx, (%rsp)
movzbl 0x1(%rcx), %edx
shll $0x8, %edx
orq %rax, %rdx
leaq 0x2(%rcx), %rax
movq %rax, (%rsp)
addq %rdx, %rcx
addq $0x2, %rcx
movq %rcx, 0xf0(%rsp)
cmpq 0xf0(%rsp), %rax
jae 0x3b98
movzbl (%rax), %r15d
leaq 0x1(%rax), %rcx
movq %rcx, (%rsp)
leal -0x64(%r15), %ecx
cmpl $0xf, %ecx
ja 0x3caf
leaq 0x7ffe(%rip), %rdx      # 0xb03c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
addl $-0x67, %r15d
leaq 0x80ba(%rip), %rax      # 0xb10c
movslq (%rax,%r15,4), %rax
movq %rax, 0xe0(%rsp)
movq %r13, %rdi
movq %rsp, %rsi
callq 0x4a89
movq (%rsp), %rax
movzbl (%rax), %ecx
movl %ecx, 0x1c(%rsp)
leaq 0x1(%rax), %rcx
movq %rcx, (%rsp)
movzbl 0x1(%rax), %ebx
leaq 0x2(%rax), %rcx
movq %rcx, (%rsp)
movzbl 0x2(%rax), %ecx
movl %ecx, 0xc(%rsp)
leaq 0x3(%rax), %rcx
movq %rcx, (%rsp)
movzbl 0x3(%rax), %r15d
addq $0x4, %rax
movq %rax, (%rsp)
leaq 0x88(%rsp), %rax
movq %rax, 0x78(%rsp)
andq $0x0, 0x80(%rsp)
movb $0x0, 0x88(%rsp)
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
leaq 0x819c(%rip), %rdx      # 0xb26e
callq 0x4add
shll $0x8, %ebx
addl 0x1c(%rsp), %ebx
leaq 0x190(%rsp), %rdi
movl %ebx, %esi
callq 0x4b54
leaq 0xc0(%rsp), %rbx
movq %rbx, %rdi
leaq 0x20(%rsp), %rsi
leaq 0x190(%rsp), %rdx
callq 0x494d
movq %r12, %rdi
movq %rbx, %rsi
leaq 0x8157(%rip), %rdx      # 0xb26e
callq 0x49b4
shll $0x8, %r15d
addl 0xc(%rsp), %r15d
leaq 0x278(%rsp), %rbx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x4b54
movq %rbp, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x494d
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2220
movq %rbp, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x20d0
movq %r12, %rdi
callq 0x20d0
leaq 0xc0(%rsp), %r15
movq %r15, %rdi
callq 0x20d0
leaq 0x190(%rsp), %rdi
callq 0x20d0
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x20d0
movq %rbp, %rdi
leaq 0x8203(%rip), %rsi      # 0xb3a0
movq %r15, %rdx
callq 0x48d4
leaq 0x7f60(%rip), %rax      # 0xb10c
movq 0xe0(%rsp), %rsi
addq %rax, %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x48d4
movq %rbp, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x5864
jmp 0x3ad5
movq %r13, %rdi
movq %rsp, %rsi
callq 0x4a89
movq (%rsp), %rax
movb (%rax), %dl
leaq 0x1(%rax), %rcx
movq %rcx, (%rsp)
testb %dl, %dl
movb %dl, 0x1c(%rsp)
je 0x3778
cmpb $0x1, %dl
jne 0x3c77
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x490f
movl %eax, 0xc(%rsp)
jmp 0x379c
orb $0x10, 0x224(%rsp)
movq %r13, %rdi
leaq 0x8177(%rip), %rsi      # 0xb3a0
movq %r12, %rdx
callq 0x48d4
movq %r14, %rdi
leaq 0x802d(%rip), %rsi      # 0xb268
leaq 0xc0(%rsp), %rdx
callq 0x48d4
movq %rbp, %rdi
leaq 0x8bd3(%rip), %rsi      # 0xbe25
leaq 0x20(%rsp), %rdx
callq 0x48d4
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x5864
jmp 0x3add
movzbl 0x1(%rax), %ebx
leaq 0x2(%rax), %rcx
movq %rcx, (%rsp)
movzbl 0x2(%rax), %r15d
addq $0x3, %rax
movq %rax, (%rsp)
movq %r13, %rdi
leaq 0x810e(%rip), %rsi      # 0xb3a0
movq %r12, %rdx
callq 0x48d4
movq %r14, %rdi
leaq 0x7fe0(%rip), %rsi      # 0xb284
leaq 0xc0(%rsp), %rdx
callq 0x48d4
shll $0x8, %r15d
orl %ebx, %r15d
movq %rbp, %rdi
movl %r15d, %esi
callq 0x4b54
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x5864
jmp 0x3add
orb $0x20, 0x224(%rsp)
movq %r13, %rdi
leaq 0x80b8(%rip), %rsi      # 0xb3a0
movq %r12, %rdx
callq 0x48d4
movq %r14, %rdi
leaq 0x7f64(%rip), %rsi      # 0xb25e
leaq 0xc0(%rsp), %rdx
callq 0x48d4
movq %rbp, %rdi
leaq 0x8b14(%rip), %rsi      # 0xbe25
leaq 0x20(%rsp), %rdx
callq 0x48d4
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x5864
jmp 0x3add
movzbl 0x1(%rax), %ecx
leaq 0x2(%rax), %rdx
movq %rdx, (%rsp)
movzbl 0x2(%rax), %esi
shll $0x8, %esi
orl %ecx, %esi
leaq 0x3(%rax), %rcx
movq %rcx, (%rsp)
movzbl 0x3(%rax), %ecx
movl %ecx, 0x1c(%rsp)
leaq 0x4(%rax), %rcx
movq %rcx, (%rsp)
movzbl 0x4(%rax), %r15d
leaq 0x5(%rax), %rcx
movq %rcx, (%rsp)
movzbl 0x5(%rax), %ecx
movl %ecx, 0xe0(%rsp)
leaq 0x6(%rax), %rcx
movq %rcx, (%rsp)
movzbl 0x6(%rax), %ecx
movl %ecx, 0xc(%rsp)
addq $0x7, %rax
movq %rax, (%rsp)
leaq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
andq $0x0, 0x50(%rsp)
movb $0x0, 0x58(%rsp)
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x4b54
leaq 0xc0(%rsp), %rdi
movq %rbx, %rsi
leaq 0x7eaf(%rip), %rdx      # 0xb26e
callq 0x49b4
shll $0x8, %r15d
addl 0x1c(%rsp), %r15d
leaq 0x190(%rsp), %rbx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x4b54
movq %r12, %rdi
leaq 0xc0(%rsp), %rsi
movq %rbx, %rdx
callq 0x494d
movq %rbp, %rdi
movq %r12, %rsi
leaq 0x7e6e(%rip), %rdx      # 0xb26e
callq 0x49b4
movl 0xc(%rsp), %esi
shll $0x8, %esi
addl 0xe0(%rsp), %esi
leaq 0x278(%rsp), %rbx
movq %rbx, %rdi
callq 0x4b54
movq %r14, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x494d
movq %r13, %rdi
movq %r14, %rsi
callq 0x2220
movq %r14, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x20d0
movq %rbp, %rdi
callq 0x20d0
movq %r12, %rdi
callq 0x20d0
leaq 0x190(%rsp), %rdi
callq 0x20d0
leaq 0xc0(%rsp), %rbx
movq %rbx, %rdi
callq 0x20d0
leaq 0x20(%rsp), %rdi
callq 0x20d0
movq %r14, %rdi
leaq 0x7f13(%rip), %rsi      # 0xb3a0
movq %r12, %rdx
callq 0x48d4
movq %rbp, %rdi
leaq 0x7df9(%rip), %rsi      # 0xb298
movq %rbx, %rdx
callq 0x48d4
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x5864
jmp 0x3add
andb $-0x11, 0x224(%rsp)
movq %r13, %rdi
leaq 0x7ed4(%rip), %rsi      # 0xb3a0
movq %r12, %rdx
callq 0x48d4
movq %r14, %rdi
leaq 0x7d8a(%rip), %rsi      # 0xb268
leaq 0xc0(%rsp), %rdx
callq 0x48d4
movq %rbp, %rdi
leaq 0x7d6f(%rip), %rsi      # 0xb264
leaq 0x20(%rsp), %rdx
callq 0x48d4
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x5864
jmp 0x3add
movq %r13, %rdi
leaq 0x7e84(%rip), %rsi      # 0xb3a0
movq %rbp, %rdx
callq 0x48d4
movq %r14, %rdi
leaq 0x7d85(%rip), %rsi      # 0xb2b3
movq %r12, %rdx
callq 0x48d4
movq %r13, %rdi
movq %r14, %rsi
callq 0x57e2
jmp 0x3ae5
movq %r13, %rdi
movq %rsp, %rsi
callq 0x4a89
movq (%rsp), %rax
movzbl (%rax), %r15d
leaq 0x1(%rax), %rcx
movq %rcx, (%rsp)
movzbl 0x1(%rax), %ebx
addq $0x2, %rax
movq %rax, (%rsp)
movq %rbp, %rdi
movq %r13, %rsi
leaq 0x7cf4(%rip), %rdx      # 0xb26e
callq 0x4add
shll $0x8, %ebx
orl %r15d, %ebx
movq %r12, %rdi
movl %ebx, %esi
callq 0x4b15
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x494d
movq %r12, %rdi
callq 0x20d0
movq %rbp, %rdi
callq 0x20d0
movq %rbp, %rdi
leaq 0x7de9(%rip), %rsi      # 0xb3a0
leaq 0xc0(%rsp), %rdx
callq 0x48d4
movq %r12, %rdi
leaq 0x7ca3(%rip), %rsi      # 0xb271
leaq 0x20(%rsp), %rdx
callq 0x48d4
movq %rbp, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x5864
jmp 0x3ad5
movzbl 0x1(%rax), %ebx
leaq 0x2(%rax), %rcx
movq %rcx, (%rsp)
movzbl 0x2(%rax), %r15d
addq $0x3, %rax
movq %rax, (%rsp)
movq %r13, %rdi
leaq 0x7d92(%rip), %rsi      # 0xb3a0
movq %r12, %rdx
callq 0x48d4
movq %r14, %rdi
leaq 0x7c57(%rip), %rsi      # 0xb277
leaq 0xc0(%rsp), %rdx
callq 0x48d4
shll $0x8, %r15d
orl %ebx, %r15d
movq %rbp, %rdi
movl %r15d, %esi
callq 0x4b15
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x5864
jmp 0x3add
andb $-0x21, 0x224(%rsp)
movq %r13, %rdi
leaq 0x7d3c(%rip), %rsi      # 0xb3a0
movq %r12, %rdx
callq 0x48d4
movq %r14, %rdi
leaq 0x7be8(%rip), %rsi      # 0xb25e
leaq 0xc0(%rsp), %rdx
callq 0x48d4
movq %rbp, %rdi
leaq 0x7bd7(%rip), %rsi      # 0xb264
leaq 0x20(%rsp), %rdx
callq 0x48d4
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x5864
jmp 0x3add
movzbl 0x1(%rax), %ebx
leaq 0x2(%rax), %rcx
movq %rcx, (%rsp)
movzbl 0x2(%rax), %r15d
addq $0x3, %rax
movq %rax, (%rsp)
movq %r13, %rdi
leaq 0x7cd3(%rip), %rsi      # 0xb3a0
movq %r12, %rdx
callq 0x48d4
movq %r14, %rdi
leaq 0x7b9e(%rip), %rsi      # 0xb27d
leaq 0xc0(%rsp), %rdx
callq 0x48d4
shll $0x8, %r15d
orl %ebx, %r15d
movq %rbp, %rdi
movl %r15d, %esi
callq 0x4b54
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x5864
jmp 0x3add
movzbl 0x1(%rax), %ebx
leaq 0x2(%rax), %rcx
movq %rcx, (%rsp)
movzbl 0x2(%rax), %r15d
addq $0x3, %rax
movq %rax, (%rsp)
movq %r13, %rdi
leaq 0x7c6c(%rip), %rsi      # 0xb3a0
movq %r12, %rdx
callq 0x48d4
movq %r14, %rdi
leaq 0x7b48(%rip), %rsi      # 0xb28e
leaq 0xc0(%rsp), %rdx
callq 0x48d4
shll $0x8, %r15d
orl %ebx, %r15d
movq %rbp, %rdi
movl %r15d, %esi
callq 0x4b54
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x5864
jmp 0x3add
movzbl 0x1(%rax), %ecx
leaq 0x2(%rax), %rdx
movq %rdx, (%rsp)
movzbl 0x2(%rax), %edx
shll $0x8, %edx
orl %ecx, %edx
movl %edx, 0xc(%rsp)
addq $0x3, %rax
movq %rax, (%rsp)
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x490f
movq (%rsp), %rcx
movzbl (%rcx), %edx
movl %edx, 0xe0(%rsp)
leaq 0x1(%rcx), %rdx
movq %rdx, (%rsp)
movzbl 0x1(%rcx), %edx
movl %edx, 0xf8(%rsp)
leaq 0x2(%rcx), %rdx
movq %rdx, (%rsp)
movzbl 0x2(%rcx), %edx
movl %edx, 0xfc(%rsp)
addq $0x3, %rcx
cmpl $0x6a, %r15d
leaq 0x7aee(%rip), %rsi      # 0xb2d5
leaq 0x7aec(%rip), %rdx      # 0xb2da
cmoveq %rdx, %rsi
movq %rsi, 0x188(%rsp)
movl %eax, %r15d
andq $0x0, 0x80(%rsp)
movq %rcx, (%rsp)
leaq 0x88(%rsp), %rax
movq %rax, 0x78(%rsp)
movb $0x0, 0x88(%rsp)
cmpb $0x0, 0x1c(%rsp)
je 0x387d
movq %r12, %rdi
movq %r13, %rsi
leaq 0x7a3b(%rip), %rdx      # 0xb26e
callq 0x4add
leaq 0xc0(%rsp), %rbx
movq %rbx, %rdi
movl 0xc(%rsp), %esi
callq 0x4b15
movq %rbp, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x494d
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2220
movq %rbp, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x20d0
movq %r12, %rdi
jmp 0x390b
leaq 0xa8(%rsp), %rax
movq %rax, 0x98(%rsp)
andq $0x0, 0xa0(%rsp)
movb $0x0, 0xa8(%rsp)
movq %r12, %rdi
leaq 0x208(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x885c
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2220
movq %r12, %rdi
callq 0x20d0
leaq 0xc0(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
leaq 0x7994(%rip), %rdx      # 0xb26e
callq 0x4add
movq %r12, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x4a48
movq %r14, %rdi
movq %r12, %rsi
callq 0x2220
movq %r12, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x20d0
movq %rbp, %rdi
callq 0x20d0
movq %r12, %rdi
movl %r15d, %esi
callq 0x4b15
movq %rbp, %rdi
leaq 0x7949(%rip), %rsi      # 0xb26e
movq %r12, %rdx
callq 0x4bad
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2380
movq %rbp, %rdi
callq 0x20d0
movq %r12, %rdi
callq 0x20d0
movq %r12, %rdi
movl 0xe0(%rsp), %esi
callq 0x4b54
movq %rbp, %rdi
leaq 0x790d(%rip), %rsi      # 0xb26e
movq %r12, %rdx
callq 0x4bad
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2380
movl 0xfc(%rsp), %ebx
shll $0x8, %ebx
addl 0xf8(%rsp), %ebx
movq %rbp, %rdi
callq 0x20d0
movq %r12, %rdi
callq 0x20d0
movq %r12, %rdi
movl %ebx, %esi
callq 0x4b54
movq %rbp, %rdi
leaq 0x78c5(%rip), %rsi      # 0xb26e
movq %r12, %rdx
callq 0x4bad
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2380
movq %rbp, %rdi
callq 0x20d0
movq %r12, %rdi
callq 0x20d0
movl %r15d, %eax
andl $0x1e, %eax
cmpl $0xa, %eax
jne 0x3a2c
movq (%rsp), %rax
movzbl (%rax), %ecx
leaq 0x1(%rax), %rdx
movq %rdx, (%rsp)
movzbl 0x1(%rax), %esi
shll $0x8, %esi
orl %ecx, %esi
addq $0x2, %rax
movq %rax, (%rsp)
movq %r12, %rdi
callq 0x4b54
movq %rbp, %rdi
leaq 0x7865(%rip), %rsi      # 0xb26e
movq %r12, %rdx
callq 0x4bad
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2380
movq %rbp, %rdi
callq 0x20d0
movq %r12, %rdi
callq 0x20d0
shrl $0x5, %r15d
testl %r15d, %r15d
je 0x3a9b
movl %r15d, %eax
andl $0x7, %eax
cmpl $0x3, %eax
jne 0x3a95
movq (%rsp), %rax
movzbl (%rax), %ecx
leaq 0x1(%rax), %rdx
movq %rdx, (%rsp)
movzbl 0x1(%rax), %esi
shll $0x8, %esi
orl %ecx, %esi
addq $0x2, %rax
movq %rax, (%rsp)
movq %r12, %rdi
callq 0x4b54
movq %rbp, %rdi
leaq 0x77fc(%rip), %rsi      # 0xb26e
movq %r12, %rdx
callq 0x4bad
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2380
movq %rbp, %rdi
callq 0x20d0
movq %r12, %rdi
callq 0x20d0
shrl $0x3, %r15d
jmp 0x3a30
movq %rbp, %rdi
leaq 0x78fb(%rip), %rsi      # 0xb3a0
leaq 0xc0(%rsp), %rdx
callq 0x48d4
movq %r12, %rdi
movq 0x188(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x48d4
movq %rbp, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x5864
movq %r12, %rdi
callq 0x20d0
movq %rbp, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x20d0
movq %r13, %rdi
callq 0x20d0
movq (%rsp), %rax
jmp 0x3010
leaq 0x208(%rsp), %rdi
callq 0x5fc6
jmp 0x3b98
leaq 0x208(%rsp), %rdi
callq 0x5fc6
movq %rsp, %rdi
callq 0x490f
movl %eax, %r15d
movq %r13, %rdi
leaq 0x786e(%rip), %rsi      # 0xb3a0
movq %r12, %rdx
callq 0x48d4
movq %r14, %rdi
leaq 0x77c1(%rip), %rsi      # 0xb305
leaq 0xc0(%rsp), %rdx
callq 0x48d4
movq %rbp, %rdi
movl %r15d, %esi
pushq $0x4
popq %rdx
pushq $0x24
popq %rcx
callq 0x56d0
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x5864
movq %rbp, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x20d0
movq %r13, %rdi
callq 0x20d0
leaq 0x208(%rsp), %rdi
movl %r15d, %esi
callq 0x4bd2
movq (%rsp), %rax
jmp 0x29ca
movq $0x0, 0xe8(%rsp)
movzbl 0xe64c(%rip), %esi      # 0x12200
leaq 0x208(%rsp), %rdi
callq 0x8284
cmpb $0x0, 0xe8(%rsp)
movq 0x180(%rsp), %r12
jne 0x3dbd
movq 0x168(%rsp), %rax
cmpq %rax, (%rsp)
jne 0x3dbd
leaq 0x208(%rsp), %rdi
callq 0x7642
leaq 0x1b0(%rsp), %rdi
callq 0x5362
leaq 0x1d0(%rsp), %rdi
callq 0x5362
leaq 0x160(%rsp), %rdi
callq 0x5362
leaq 0x1f0(%rsp), %rdi
callq 0x51f6
testq %r12, %r12
setne %al
addq $0x298, %rsp            # imm = 0x298
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7599(%rip), %rsi      # 0xb1e2
pushq $0x41
popq %rdi
movq 0xb8(%rsp), %rdx
xorl %eax, %eax
callq 0x2350
leaq 0x75c0(%rip), %rsi      # 0xb222
pushq $0x41
popq %rdi
movq 0xb8(%rsp), %rdx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x2350
leaq 0x763a(%rip), %rdi      # 0xb2b8
leaq 0x74c3(%rip), %rsi      # 0xb148
leaq 0x74c8(%rip), %rcx      # 0xb154
movl $0x1c6, %edx            # imm = 0x1C6
callq 0x2130
leaq 0x75a8(%rip), %rsi      # 0xb245
pushq $0x41
popq %rdi
movq 0xb8(%rsp), %rdx
xorl %eax, %eax
callq 0x2350
leaq 0x762c(%rip), %rsi      # 0xb2e2
pushq $0x41
popq %rdi
movq 0xb8(%rsp), %rdx
movl %r15d, %ecx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x2350
leaq 0x208(%rsp), %rdi
callq 0x5fc6
leaq 0x7628(%rip), %rsi      # 0xb30a
pushq $0x41
popq %rdi
movq 0xb8(%rsp), %rdx
movq 0xe8(%rsp), %rcx
xorl %eax, %eax
callq 0x2350
leaq 0x7415(%rip), %rsi      # 0xb118
pushq $0x41
popq %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2350
leaq 0x741a(%rip), %rdi      # 0xb131
leaq 0x742a(%rip), %rsi      # 0xb148
leaq 0x742f(%rip), %rcx      # 0xb154
movl $0xd0, %edx
callq 0x2130
leaq 0x743f(%rip), %rdi      # 0xb175
leaq 0x740b(%rip), %rsi      # 0xb148
leaq 0x7410(%rip), %rcx      # 0xb154
movl $0xd1, %edx
callq 0x2130
leaq 0x7431(%rip), %rdi      # 0xb186
leaq 0x73ec(%rip), %rsi      # 0xb148
leaq 0x73f1(%rip), %rcx      # 0xb154
movl $0xd2, %edx
callq 0x2130
leaq 0x7fb6(%rip), %rsi      # 0xbd2a
pushq $0x41
popq %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2350
leaq 0x740e(%rip), %rsi      # 0xb196
pushq $0x41
popq %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2350
leaq 0x740f(%rip), %rsi      # 0xb1ab
pushq $0x41
popq %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2350
leaq 0x7411(%rip), %rsi      # 0xb1c1
pushq $0x41
popq %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2350
leaq 0x755e(%rip), %rsi      # 0xb322
pushq $0x41
popq %rdi
movq 0xb8(%rsp), %rdx
xorl %eax, %eax
callq 0x2350
movq %rax, %rbx
leaq 0xe580(%rip), %rax      # 0x12360
jmp 0x3ef9
movq %rax, %rbx
leaq 0xe551(%rip), %rax      # 0x12340
jmp 0x3ef9
movq %rax, %rbx
leaq 0xe582(%rip), %rax      # 0x12380
jmp 0x3ef9
movq %rax, %rbx
leaq 0xe593(%rip), %rax      # 0x123a0
jmp 0x3ef9
movq %rax, %rbx
jmp 0x3ec5
movq %rax, %rbx
jmp 0x3e46
movq %rax, %rbx
jmp 0x3ee1
movq %rax, %rbx
jmp 0x3ef1
movq %rax, %rbx
jmp 0x3ea5
movq %rax, %rbx
leaq 0xe622(%rip), %rax      # 0x12460
movq %rax, 0x120(%rsp)
movq 0x120(%rsp), %rax
movq %rax, 0x128(%rsp)
jmp 0x3ed1
movq %rax, %rbx
leaq 0xe49e(%rip), %rax      # 0x12300
jmp 0x3ef9
movq %rax, %rbx
leaq 0xe46f(%rip), %rax      # 0x122e0
jmp 0x3ef9
movq %rax, %rbx
leaq 0xe540(%rip), %rax      # 0x123c0
jmp 0x3ef9
movq %rax, %rbx
leaq 0xe494(%rip), %rax      # 0x12320
jmp 0x3ef9
movq %rax, %rbx
jmp 0x3efe
movq %rax, %rbx
leaq 0xe3b3(%rip), %rax      # 0x12250
movq %rax, 0x140(%rsp)
leaq 0xe364(%rip), %r14      # 0x12210
movq 0x140(%rsp), %r15
addq $-0x20, %r15
movq %r15, %rdi
callq 0x20d0
cmpq %r14, %r15
jne 0x3eb4
leaq 0xe3a4(%rip), %rdi      # 0x12270
jmp 0x3f22
movq %rax, %rbx
movq 0x128(%rsp), %rax
movq %rax, 0x130(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x138(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xe37b(%rip), %r14      # 0x12280
movq 0x10(%rsp), %r15
addq $-0x20, %r15
movq %r15, %rdi
callq 0x20d0
cmpq %r14, %r15
jne 0x3f0a
leaq 0xe55e(%rip), %rdi      # 0x12480
callq 0x2110
jmp 0x4306
movq %rax, %rbx
leaq 0xe38a(%rip), %rax      # 0x122c0
jmp 0x3ef9
movq %rax, %rbx
jmp 0x3f1b
jmp 0x411d
jmp 0x42c1
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x485a
jmp 0x3f59
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x47fc
jmp 0x431d
jmp 0x414e
jmp 0x4221
jmp 0x411d
jmp 0x428a
jmp 0x42c1
jmp 0x42c1
jmp 0x42c1
jmp 0x42c1
jmp 0x42c1
jmp 0x4221
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
jmp 0x41d2
jmp 0x4221
jmp 0x42c1
jmp 0x42c1
jmp 0x411d
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x20d0
jmp 0x404b
jmp 0x428a
jmp 0x428a
jmp 0x4266
jmp 0x428a
jmp 0x428a
jmp 0x4221
jmp 0x4221
jmp 0x428a
jmp 0x411d
jmp 0x428a
jmp 0x426b
jmp 0x42c1
jmp 0x41c7
jmp 0x4221
jmp 0x411d
jmp 0x42c1
jmp 0x411d
jmp 0x42c1
jmp 0x4221
jmp 0x4221
jmp 0x428a
jmp 0x42c1
jmp 0x411d
jmp 0x42c1
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
jmp 0x4292
movq %rax, %rbx
jmp 0x4106
jmp 0x4221
jmp 0x4221
jmp 0x428a
movq %rax, %rbx
leaq 0x278(%rsp), %rdi
callq 0x20d0
jmp 0x40d3
jmp 0x411d
jmp 0x428a
jmp 0x411d
jmp 0x4221
jmp 0x411d
jmp 0x4221
jmp 0x428a
movq %rax, %rbx
jmp 0x4113
jmp 0x42c1
jmp 0x42c1
jmp 0x42c1
jmp 0x428a
jmp 0x42c1
jmp 0x411d
jmp 0x42c1
jmp 0x4221
jmp 0x411d
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x20d0
jmp 0x40e7
jmp 0x411d
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x20d0
jmp 0x40f9
movq %rax, %rbx
leaq 0x190(%rsp), %rdi
callq 0x20d0
leaq 0xc0(%rsp), %rdi
callq 0x20d0
leaq 0x20(%rsp), %rdi
jmp 0x4292
movq %rax, %rbx
jmp 0x4297
jmp 0x428a
jmp 0x4303
jmp 0x4303
jmp 0x428a
jmp 0x4266
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
jmp 0x4276
movq %rax, %rbx
jmp 0x431d
movq %rax, %rbx
jmp 0x432a
movq %rax, %rbx
jmp 0x4337
movq %rax, %rbx
jmp 0x4344
jmp 0x42c1
jmp 0x428a
jmp 0x4266
jmp 0x4266
jmp 0x428a
jmp 0x428a
jmp 0x426b
jmp 0x426b
jmp 0x42c1
jmp 0x4266
jmp 0x426b
jmp 0x428a
jmp 0x4221
jmp 0x41c7
movq %rax, %rbx
jmp 0x420d
movq %rax, %rbx
jmp 0x421a
jmp 0x42c1
movq %rax, %rbx
jmp 0x4200
jmp 0x428a
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x20d0
jmp 0x4224
movq %rax, %rbx
jmp 0x41f3
jmp 0x428a
movq %rax, %rbx
leaq 0x278(%rsp), %rdi
callq 0x20d0
leaq 0x100(%rsp), %rdi
callq 0x20d0
leaq 0xc0(%rsp), %rdi
callq 0x20d0
leaq 0x190(%rsp), %rdi
callq 0x20d0
leaq 0x20(%rsp), %rdi
jmp 0x4283
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
jmp 0x4283
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x20d0
jmp 0x4248
movq %rax, %rbx
jmp 0x4255
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x20d0
leaq 0x100(%rsp), %rdi
jmp 0x42f2
jmp 0x42bc
jmp 0x42bc
movq %rax, %rbx
jmp 0x427b
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x20d0
leaq 0x100(%rsp), %rdi
callq 0x20d0
jmp 0x428d
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x20d0
leaq 0x48(%rsp), %rdi
callq 0x20d0
jmp 0x4310
jmp 0x42bc
jmp 0x4303
jmp 0x4303
jmp 0x42bc
jmp 0x42bc
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
jmp 0x42e3
jmp 0x42ea
movq %rax, %rbx
jmp 0x42f7
movq %rax, %rbx
jmp 0x4310
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x20d0
jmp 0x42db
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x20d0
jmp 0x42ed
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x20d0
leaq 0x48(%rsp), %rdi
callq 0x20d0
jmp 0x4306
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4a68
leaq 0x208(%rsp), %rdi
callq 0x7642
leaq 0x1b0(%rsp), %rdi
callq 0x5362
leaq 0x1d0(%rsp), %rdi
callq 0x5362
leaq 0x160(%rsp), %rdi
callq 0x5362
leaq 0x1f0(%rsp), %rdi
callq 0x51f6
movq %rbx, %rdi
callq 0x2300