LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/scanner.cpp
// Function: void convert<int>(int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void convert(T &val, const string &s)
{
	std::size_t pos;
	long num = std::stol(s, &pos, 0);
	if (pos < s.size())
		throw error("wrong int:" + s);
	if (num < numeric_limits<T>::min()
			or num > numeric_limits<T>::max())
		throw error("int out of range: " + s);
	val = static_cast<T>(num);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %rsi, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x6c84
movq (%r15), %rcx
cmpq 0x8(%r14), %rcx
jb 0x612c
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x6171
movl %eax, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x3170
movq %rax, %rbx
leaq 0x70ca(%rip), %rsi      # 0xd208
movq %rsp, %rdi
movq %r14, %rdx
callq 0x6076
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xee88(%rip), %rsi      # 0x14fe8
movq 0xee31(%rip), %rdx      # 0x14f98
movq %rbx, %rdi
callq 0x3470
jmp 0x61b4
pushq $0x10
popq %rdi
callq 0x3170
movq %rax, %rbx
leaq 0x7090(%rip), %rsi      # 0xd213
movq %rsp, %rdi
movq %r14, %rdx
callq 0x6076
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xee43(%rip), %rsi      # 0x14fe8
movq 0xedec(%rip), %rdx      # 0x14f98
movq %rbx, %rdi
callq 0x3470
jmp 0x61b8
jmp 0x61ca
movq %rax, %r14
movq %rsp, %rdi
callq 0x3528
testb %bpl, %bpl
jne 0x61cd
jmp 0x61d5
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
movq %r14, %rdi
callq 0x3490
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/module.cpp
// Function: vartbl::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void vartbl::add(const string &s)
{
	auto slot = map.size();
	if (slot > std::numeric_limits<addr>::max())
		throw error(string("table ") + name + " overflow");
	addr a = static_cast<addr>(slot);
	addrmap::add(s, a);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %r14
movq 0x38(%rdi), %rax
cmpq $0x100, %rax            # imm = 0x100
jae 0x7064
movzbl %al, %edx
movq %r14, %rdi
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x7cca
pushq $0x10
popq %rdi
callq 0x3170
movq %rax, %rbx
leaq 0x62b9(%rip), %rsi      # 0xd32f
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x46b2
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x7cab
leaq 0x62a4(%rip), %rdx      # 0xd342
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x46ed
movb $0x1, %bpl
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xdf22(%rip), %rsi      # 0x14fe8
movq 0xdecb(%rip), %rdx      # 0x14f98
movq %rbx, %rdi
callq 0x3470
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x3528
jmp 0x70ea
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
callq 0x3528
jmp 0x70fc
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0x3528
testb %bpl, %bpl
jne 0x7110
jmp 0x7118
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
movq %r14, %rdi
callq 0x3490
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/module.cpp
// Function: symbols::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto symbols::add(const string &s) -> addr
{
	auto it = tbl.find(s);
	if (it != tbl.end())
		return it->second;

	addr a = static_cast<addr>(data.size());
	tbl[s] = a;
	data.insert(data.end(), s.begin(), s.end());
	data.push_back('\0');

	if (data.size() > std::numeric_limits<addr>::max())
		throw error(".sym section overflow");


	return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x854e
testq %rax, %rax
je 0x7183
movzwl 0x28(%rax), %ebp
jmp 0x71d1
leaq 0x38(%rbx), %r15
movl 0x40(%rbx), %ebp
subl 0x38(%rbx), %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x861e
movw %bp, (%rax)
movq 0x40(%rbx), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
addq %rdx, %rcx
movq %r15, %rdi
callq 0x7e3c
leaq 0x7(%rsp), %rsi
movb $0x0, (%rsi)
movq %r15, %rdi
callq 0x8b0e
movq 0x40(%rbx), %rax
subq 0x38(%rbx), %rax
cmpq $0x10000, %rax          # imm = 0x10000
jae 0x71de
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x3170
movq %rax, %rbx
leaq 0x6146(%rip), %rsi      # 0xd336
movq %rax, %rdi
callq 0x3100
movq 0xdde9(%rip), %rsi      # 0x14fe8
movq 0xdd92(%rip), %rdx      # 0x14f98
movq %rbx, %rdi
callq 0x3470
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
movq %r14, %rdi
callq 0x3490
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/module.cpp
// Function: strings::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
auto strings::operator[](const string &s) const -> addr
{
	auto it = tbl.find(s);
	if (it == tbl.end())
		throw error(s + ": no such defined string");
	return it->second;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
addq $0x18, %rdi
callq 0x91d8
testq %rax, %rax
je 0x72c5
movl 0x28(%rax), %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x3170
movq %rax, %rbx
leaq 0x6075(%rip), %rdx      # 0xd34c
movq %rsp, %rdi
movq %r14, %rsi
callq 0x4721
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xdcef(%rip), %rsi      # 0x14fe8
movq 0xdc98(%rip), %rdx      # 0x14f98
movq %rbx, %rdi
callq 0x3470
movq %rax, %r14
movq %rsp, %rdi
callq 0x3528
testb %bpl, %bpl
jne 0x731d
jmp 0x7325
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
movq %r14, %rdi
callq 0x3490
nop
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/module.cpp
// Function: code::add_label(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void code::add_label(const string &s)
{
	auto res = lbl.insert({s, address()});
	if (not res.second)
		throw error(std::string("table ") + "label "
				+ " already has an element " + s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
leaq 0x78(%rdi), %rbx
movl 0x8(%rdi), %ebp
subl (%rdi), %ebp
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x3360
movl %ebp, 0x20(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9206
movl %edx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x3528
testb $0x1, %bl
je 0x7382
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x3170
movq %rax, %rbx
leaq 0x5f9b(%rip), %rsi      # 0xd32f
leaq 0x38(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x46b2
leaq 0x5fbb(%rip), %rdx      # 0xd365
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x46ed
leaq 0x5fac(%rip), %rdx      # 0xd36c
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x46ed
leaq 0x10(%rsp), %rdi
leaq 0x78(%rsp), %rsi
movq %r14, %rdx
callq 0x7cab
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xdbee(%rip), %rsi      # 0x14fe8
movq 0xdb97(%rip), %rdx      # 0x14f98
movq %rbx, %rdi
callq 0x3470
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x3528
jmp 0x741e
movq %rax, %r14
movb $0x1, %bpl
leaq 0x78(%rsp), %rdi
callq 0x3528
jmp 0x7430
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rdi
callq 0x3528
jmp 0x7442
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rdi
callq 0x3528
testb %bpl, %bpl
jne 0x7456
jmp 0x746d
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
jmp 0x746d
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x3528
movq %r14, %rdi
callq 0x3490
nop
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/module.cpp
// Function: code::offset(unsigned int, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
auto code::offset(addr from, addr to,
		const string &label, int line) -> ofs
{
	ofs d = to - from;
	if ((from + d) != to)
		throw error("too long reference to " + label
				+ " at " + std::to_string(line));
	return d;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movl %ecx, %ebp
movl %esi, %eax
subl %edi, %eax
movswl %ax, %ecx
addl %edi, %ecx
cmpl %esi, %ecx
jne 0x749c
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
pushq $0x10
popq %rdi
callq 0x3170
movq %rax, %rbx
leaq 0x5ed4(%rip), %rsi      # 0xd385
leaq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x6076
leaq 0x5ed7(%rip), %rdx      # 0xd39c
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x46ed
movq %rsp, %rdi
movl %ebp, %esi
callq 0x6395
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq %rsp, %rdx
callq 0x632e
movb $0x1, %bpl
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xdadf(%rip), %rsi      # 0x14fe8
movq 0xda88(%rip), %rdx      # 0x14f98
movq %rbx, %rdi
callq 0x3470
movq %rax, %r14
leaq 0x60(%rsp), %rdi
callq 0x3528
jmp 0x752d
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x3528
jmp 0x753d
movq %rax, %r14
movb $0x1, %bpl
leaq 0x40(%rsp), %rdi
callq 0x3528
jmp 0x754f
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0x3528
testb %bpl, %bpl
jne 0x7563
jmp 0x756b
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
movq %r14, %rdi
callq 0x3490
nop
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/module.cpp
// Function: code::add_ref(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void code::add_ref(const std::string &label, int line)
{
	auto it = lbl.find(label);
	if (it != lbl.end()) {
		put(offset(cur_addr, it->second, label, line));
	} else {
		unres.emplace_back(unresolved{label, cur_addr,
				address(), line});
		put(ofs()); // placeholder
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x78, %rdi
callq 0x932c
testq %rax, %rax
je 0x75c0
movl 0xf0(%rbx), %edi
movl 0x28(%rax), %esi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x7476
movswl %ax, %esi
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7e8c
leaq 0xb0(%rbx), %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3360
movl 0xf0(%rbx), %eax
movl %eax, 0x20(%r12)
movl 0x8(%rbx), %eax
subl (%rbx), %eax
movl %eax, 0x24(%r12)
movl %ebp, 0x28(%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x7e9c
movq %rsp, %rdi
callq 0x3528
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7e8c
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3528
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/module.cpp
// Function: code::finish()
void code::finish()
{

	for (const auto &ur: unres) {
		auto it = lbl.find(ur.label);
		if (it == lbl.end())
			throw error("unresolved: " + ur.label
					+ " at " + std::to_string(ur.lineno));
		auto o = offset(ur.offset_base, it->second,
				ur.label, ur.lineno);
		patch(ur.patch_addr, o);
	}

	cur_proc->size = address() - cur_proc->addr;
	cur_proc->type = sym.add(cur_type);
	cur_proc->varc = var.count();

	var.clear();
	lbl.clear();
	unres.clear();
	cur_type.clear();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0xb0(%rdi), %r15
movq 0xb0(%rdi), %r14
movq 0xb8(%rdi), %r13
leaq 0x78(%rdi), %r12
cmpq %r13, %r14
je 0x76e6
movq %r12, %rdi
movq %r14, %rsi
callq 0x932c
testq %rax, %rax
je 0x7755
movl 0x28(%rax), %esi
movl 0x20(%r14), %edi
movl 0x28(%r14), %ecx
movq %r14, %rdx
callq 0x7476
movl 0x24(%r14), %ecx
movq (%rbx), %rdx
movw %ax, (%rdx,%rcx)
addq $0x30, %r14
jmp 0x76a9
movl 0x8(%rbx), %eax
subl (%rbx), %eax
movq 0xc8(%rbx), %rcx
subl (%rcx), %eax
movl %eax, 0x4(%rcx)
movq 0x18(%rbx), %rdi
leaq 0xd0(%rbx), %rsi
callq 0x7166
movq 0xc8(%rbx), %rcx
movw %ax, 0x8(%rcx)
movb 0x58(%rbx), %al
movb %al, 0xb(%rcx)
leaq 0x40(%rbx), %rdi
callq 0x4914
movq %r12, %rdi
callq 0x49d2
movq %r15, %rdi
callq 0x7ed8
andq $0x0, 0xd8(%rbx)
movq 0xd0(%rbx), %rax
movb $0x0, (%rax)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x3170
movq %rax, %rbx
leaq 0x5c3a(%rip), %rsi      # 0xd3a1
leaq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0x6076
leaq 0x5c21(%rip), %rdx      # 0xd39c
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x46ed
movl 0x28(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x6395
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x632e
movb $0x1, %bpl
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xd823(%rip), %rsi      # 0x14fe8
movq 0xd7cc(%rip), %rdx      # 0x14f98
movq %rbx, %rdi
callq 0x3470
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x3528
jmp 0x77e9
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x3528
jmp 0x77fb
movq %rax, %r14
movb $0x1, %bpl
leaq 0x48(%rsp), %rdi
callq 0x3528
jmp 0x780d
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x3528
testb %bpl, %bpl
jne 0x7821
jmp 0x7829
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
movq %r14, %rdi
callq 0x3490
nop
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/module.cpp
// Function: operator<<(std::ostream&, RMDHeader const&)
ostream &operator<<(ostream &s, const RMDHeader &h)
{
	buf_it it(s);
	serializer(it) << h.ident << h.rmd_version << h.name << h.version
		<< h.sizes.exp << h.sizes.ptbl << h.sizes.mtbl
		<< h.sizes.imp << h.sizes.text << h.sizes.sym << h.sizes.str
		<< h.datac << h.flags << h.size << h.pad;
	return s;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rdi,%rax), %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
testq %rax, %rax
sete 0x8(%rcx)
movq %rsi, %r14
movq %rsp, %rdi
movq %rcx, (%rdi)
callq 0x7f46
leaq 0x4(%r14), %rsi
movq %rax, %rdi
callq 0x7f2e
leaq 0x6(%r14), %rsi
movq %rax, %rdi
callq 0x7ee0
leaq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x7f2e
leaq 0xc(%r14), %rsi
movq %rax, %rdi
callq 0x7efa
leaq 0xd(%r14), %rsi
movq %rax, %rdi
callq 0x7efa
leaq 0xe(%r14), %rsi
movq %rax, %rdi
callq 0x7efa
leaq 0xf(%r14), %rsi
movq %rax, %rdi
callq 0x7efa
leaq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x7f14
leaq 0x14(%r14), %rsi
movq %rax, %rdi
callq 0x7ee0
leaq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x7f14
leaq 0x1c(%r14), %rsi
movq %rax, %rdi
callq 0x7efa
leaq 0x1d(%r14), %rsi
movq %rax, %rdi
callq 0x7efa
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x7f14
addq $0x24, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x7f66
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/./module.hpp
// Function: addrmap<unsigned char>::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned char)
void add(const std::string &s, addr a)
	{
		auto res = map.insert({s, a});
		if (not res.second)
			throw std::runtime_error("table " + name
					+ " already has an element " + s);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rdi), %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x3360
movb %bl, 0x20(%r13)
movq %r12, %rdi
movq %r13, %rsi
callq 0x8124
movl %edx, %ebx
movq %rsp, %rdi
callq 0x3528
testb $0x1, %bl
je 0x7d1c
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x3170
movq %rax, %rbx
leaq 0x5601(%rip), %rsi      # 0xd32f
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0x6076
leaq 0x562a(%rip), %rdx      # 0xd36c
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x46ed
movq %rsp, %rdi
leaq 0x48(%rsp), %rsi
movq %r14, %rdx
callq 0x7cab
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xd270(%rip), %rsi      # 0x14fe8
movq 0xd219(%rip), %rdx      # 0x14f98
movq %rbx, %rdi
callq 0x3470
movq %rax, %r14
movq %rsp, %rdi
callq 0x3528
jmp 0x7d9a
movq %rax, %r14
movb $0x1, %bpl
leaq 0x48(%rsp), %rdi
callq 0x3528
jmp 0x7dac
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x3528
testb %bpl, %bpl
jne 0x7dc0
jmp 0x7dd5
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
jmp 0x7dd5
movq %rax, %r14
movq %rsp, %rdi
callq 0x3528
movq %r14, %rdi
callq 0x3490
nop
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/./module.hpp
// Function: operator<<(std::ostream&, table<RMDImport> const&)
std::ostream &operator<<(std::ostream &s, const table &t)
	{
		extern void write(std::ostreambuf_iterator<char> &it, const T &e);
		std::ostreambuf_iterator<char> it(s);
		for (auto &e: t.vec)
			write(it, e);
		return s;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rdi,%rax), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
testq %rax, %rax
sete 0x8(%r14)
movq 0x58(%rsi), %r15
movq 0x60(%rsi), %r12
cmpq %r12, %r15
je 0x7fd1
movq %r14, %rdi
movq %r15, %rsi
callq 0x78ec
addq $0x6, %r15
jmp 0x7fbb
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/./serial.hpp
// Function: std::enable_if<std::is_integral<unsigned int>::value, void>::type serial<std::back_insert_iterator<std::vector<char, std::allocator<char>>>, unsigned int>(std::back_insert_iterator<std::vector<char, std::allocator<char>>>, unsigned int)
std::enable_if_t<std::is_integral<T>::value>
serial(OutputIterator it, T val)
{
	auto v = static_cast<typename std::make_unsigned_t<T>>(val);
	if (sizeof v == 1)
		*it = v;
	else
		for (int i = 0; i != sizeof v; ++i) {
			*it++ = v & 0xFF;
			v >>= 8;
		}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x4
popq %rbp
leaq 0x7(%rsp), %r15
subl $0x1, %ebp
jb 0x91b9
movb %bl, 0x7(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x8b0e
shrl $0x8, %ebx
jmp 0x91a0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/parser.cpp
// Function: parser::read_types[abi:cxx11]()
string parser::read_types()
{
	string type;
	bool more_types = true;
	while (more_types) {
		switch (s.next()) {
		case tok::STRING:
			type += mangle(s.str());
			break;
		case tok::NEWLINE: 
			// fallthrough
		case tok::END:
			more_types = false;
			break;
		default: throw error(s.str() + ": type expected here");
		}
	}
	return type;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %r14
movq (%r15), %rdi
callq 0x53b6
testl %eax, %eax
jne 0xaa99
movq (%r15), %rsi
addq $0x10, %rsi
movq %r14, %rdi
callq 0x9dfb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3510
movq %r14, %rdi
callq 0x3528
jmp 0xaa69
addl $-0x6, %eax
cmpl $0x2, %eax
jae 0xaaaf
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x3170
movq %rax, %r14
movq (%r15), %rsi
addq $0x10, %rsi
leaq 0x2c54(%rip), %rdx      # 0xd71c
leaq 0x8(%rsp), %rdi
callq 0x4721
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xa4fd(%rip), %rsi      # 0x14fe8
movq 0xa4a6(%rip), %rdx      # 0x14f98
movq %r14, %rdi
callq 0x3470
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x3528
testb %bpl, %bpl
jne 0xab11
jmp 0xab2f
movq %rax, %r15
movq %r14, %rdi
callq 0x3210
jmp 0xab2f
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x3528
jmp 0xab2f
jmp 0xab2c
movq %rax, %r15
movq %rbx, %rdi
callq 0x3528
movq %r15, %rdi
callq 0x3490
nop
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/parser.cpp
// Function: parser::run()
void parser::run()
{
	try {
		parse();
		m.finish();
	} catch (std::runtime_error &re) {
		throw source_error(s.line(), re.what());
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
callq 0xa048
movq 0x8(%r15), %rdi
callq 0x7a1e
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0xabf8
movq %r14, %rdi
callq 0x3110
movq %rax, %r14
pushq $0x18
popq %rdi
callq 0x3170
movq %rax, %rbx
movq (%r15), %rax
movl 0x8(%rax), %ebp
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x46b2
movb $0x1, %r15b
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9dd4
xorl %r15d, %r15d
leaq 0xa103(%rip), %rsi      # 0x14cc8
movq 0xa3d4(%rip), %rdx      # 0x14fa0
movq %rbx, %rdi
callq 0x3470
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3528
testb %r15b, %r15b
jne 0xabeb
jmp 0xabf3
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
callq 0x3460
movq %r14, %rdi
callq 0x3490
movq %rax, %rdi
callq 0x47d9
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/parser.cpp
// Function: parser_state::ensure(parser_state::state) const
void ensure(state s) const
	{
		if (st != s)
			throw error("section " + state_str(s)
					+ " expected, but section "
					+ state_str(st) + " is opened");
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
cmpl %esi, (%rdi)
jne 0xadef
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl %esi, %ebp
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x3170
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movl %ebp, %esi
callq 0xb280
leaq 0x292e(%rip), %rsi      # 0xd740
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x62e8
leaq 0x2909(%rip), %rdx      # 0xd731
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x46ed
movl (%r14), %esi
movq %rsp, %rdi
callq 0xb280
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movq %rsp, %rdx
callq 0x632e
leaq 0x28eb(%rip), %rdx      # 0xd749
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x46ed
movb $0x1, %bpl
leaq 0xa0(%rsp), %rsi
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xa159(%rip), %rsi      # 0x14fe8
movq 0xa102(%rip), %rdx      # 0x14f98
movq %rbx, %rdi
callq 0x3470
movq %rax, %r14
leaq 0xa0(%rsp), %rdi
callq 0x3528
jmp 0xaeb6
movq %rax, %r14
movb $0x1, %bpl
leaq 0x80(%rsp), %rdi
callq 0x3528
jmp 0xaecb
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x3528
jmp 0xaedb
movq %rax, %r14
movb $0x1, %bpl
leaq 0x60(%rsp), %rdi
callq 0x3528
jmp 0xaeed
movq %rax, %r14
movb $0x1, %bpl
leaq 0x40(%rsp), %rdi
callq 0x3528
jmp 0xaeff
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0x3528
testb %bpl, %bpl
jne 0xaf13
jmp 0xaf1b
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
movq %r14, %rdi
callq 0x3490
nop
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/./module.hpp
// Function: addrmap<unsigned char>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
addr operator[](const std::string &s) const
	{
		auto it = map.find(s);
		if (it == map.end())
			throw std::runtime_error("table '" + name
					+ "': no entry '" + s + "'");
		return it->second;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %r15
addq $0x20, %rdi
callq 0xb3b8
testq %rax, %rax
je 0xaf8a
movb 0x28(%rax), %al
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x3170
movq %rax, %rbx
leaq 0x27d0(%rip), %rsi      # 0xd76c
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
callq 0x6076
leaq 0x27c4(%rip), %rdx      # 0xd774
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x46ed
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
callq 0x7cab
leaq 0x279a(%rip), %rdx      # 0xd772
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x46ed
movb $0x1, %bpl
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0x9fe8(%rip), %rsi      # 0x14fe8
movq 0x9f91(%rip), %rdx      # 0x14f98
movq %rbx, %rdi
callq 0x3470
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x3528
jmp 0xb024
movq %rax, %r14
movb $0x1, %bpl
leaq 0x48(%rsp), %rdi
callq 0x3528
jmp 0xb036
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x3528
jmp 0xb048
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x3528
testb %bpl, %bpl
jne 0xb05c
jmp 0xb064
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
movq %r14, %rdi
callq 0x3490
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/rasm/parser.cpp
// Function: parser_state::state_str[abi:cxx11](parser_state::state)
static string state_str(state s)
	{
		switch (s) {
		case NONE: return "none";
		case SUB: return ".sub";
		case STR: return ".str";
		default: throw std::logic_error("wrong parser state");
		}
		return "";
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, %esi
je 0xb2b1
cmpl $0x1, %esi
je 0xb2a3
testl %esi, %esi
jne 0xb2d0
leaq 0x24b8(%rip), %rsi      # 0xd754
leaq 0x7(%rsp), %rdx
jmp 0xb2bd
leaq 0x225b(%rip), %rsi      # 0xd505
leaq 0x6(%rsp), %rdx
jmp 0xb2bd
leaq 0x21e3(%rip), %rsi      # 0xd49b
leaq 0x5(%rsp), %rdx
movq %rbx, %rdi
callq 0x46b2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x3170
movq %rax, %rbx
leaq 0x2477(%rip), %rsi      # 0xd759
movq %rax, %rdi
callq 0x33b0
movq 0x9cd7(%rip), %rsi      # 0x14fc8
movq 0x9cb0(%rip), %rdx      # 0x14fa8
movq %rbx, %rdi
callq 0x3470
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
movq %r14, %rdi
callq 0x3490
nop
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/lib/cmdopt.c
// Function: cmdopt_parse
int cmdopt_parse(int argc, char *const argv[], const struct cmdopt *opts)
{
	int arg;
	const struct cmdopt *param_opt = opts;
	while(param_opt->option)
		++param_opt;
	for(arg = 1; arg != argc; ++arg) {
		const char *s = argv[arg];
		if(s[0] != '-') /* non-option parameter */
			handle(param_opt, s);
		else {
			const char *eq = strchr(++s, '='); /* drop out '-' */
			if(eq) { /* parameter with value */
				size_t param_len = eq - s;
				const struct cmdopt *opt;
				for(opt = opts; opt->option; ++opt)
					if(strncmp(s, opt->option, param_len) == 0
							&& opt->option[param_len] == '\0') {
						handle(opt, eq + 1);
						goto loop;
					}
				return arg;
			} else { /* parameter without value */
				const struct cmdopt *opt;
				for(opt = opts; opt->option; ++opt)
					if(strcmp(s, opt->option) == 0) {
						handle(opt, NULL);
						goto loop;
					}
				return arg;
			}
		}
loop: ;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %rbp
leaq -0x20(%rdx), %r15
cmpq $0x0, 0x20(%r15)
leaq 0x20(%r15), %r15
jne 0xbfe0
movl %edi, %ebx
pushq $0x1
popq %rax
movq %rbx, 0x10(%rsp)
cmpq %rbx, %rax
je 0xc0d1
movq %rax, 0x8(%rsp)
movq (%rbp,%rax,8), %r13
cmpb $0x2d, (%r13)
jne 0xc086
incq %r13
movq %r13, %rdi
pushq $0x3d
popq %rsi
callq 0x30d0
movq %r12, %rbx
testq %rax, %rax
je 0xc066
movq %rax, %r14
movq %rbp, 0x18(%rsp)
movq %rax, %rbp
subq %r13, %rbp
movq %r12, 0x20(%rsp)
movq %r12, %rbx
movq (%rbx), %r12
testq %r12, %r12
je 0xc0bd
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x3150
testl %eax, %eax
jne 0xc05c
cmpb $0x0, (%r12,%rbp)
je 0xc093
addq $0x20, %rbx
jmp 0xc03b
addq $0x20, %rbx
movq (%rbx), %rsi
testq %rsi, %rsi
je 0xc0bd
movq %r13, %rdi
callq 0x3380
testl %eax, %eax
jne 0xc062
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc0d5
jmp 0xc0ab
movq %r15, %rdi
movq %r13, %rsi
callq 0xc0d5
jmp 0xc0b0
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc0d5
movq 0x20(%rsp), %r12
movq 0x18(%rsp), %rbp
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %rax
incq %rax
jmp 0xbff5
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0xc0c2
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/lib/cmdopt.c
// Function: handle
static void handle(const struct cmdopt *opt, const char *param)
{
	if(opt->flag)
		*opt->flag = 1;
	if(opt->handler)
		opt->handler(param);
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0xc0e4
movl $0x1, (%rax)
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xc0f2
movq %rsi, %rdi
jmpq *%rax
retq
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/lib/cmdopt.c
// Function: cmdopt_print
void cmdopt_print(const struct cmdopt *opts)
{
	const struct cmdopt *opt;
	int maxlen = 0;
	/* calculate maximum option length */
	for(opt = opts; opt->option; ++opt) {
		int len = strlen(opt->option);
		if(len > maxlen)
			maxlen = len;
	}
	for(opt = opts; opt->option; ++opt)
		printf("  -%-*s%s  %s\n", maxlen, opt->option,
				opt->handler ? "=v" : "  ", opt->description);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
movq %rdi, %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0xc11d
callq 0x3130
cmpl %eax, %ebp
cmovgl %ebp, %eax
addq $0x20, %r14
movl %eax, %ebp
jmp 0xc103
leaq 0x16c8(%rip), %r15      # 0xd7ec
leaq 0x16be(%rip), %r12      # 0xd7e9
leaq 0x16a8(%rip), %r14      # 0xd7da
movq (%rbx), %rdx
testq %rdx, %rdx
je 0xc15c
cmpq $0x0, 0x10(%rbx)
movq %r12, %rcx
cmoveq %r15, %rcx
movq 0x18(%rbx), %r8
movq %r14, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x3040
addq $0x20, %rbx
jmp 0xc132
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: Delay
void Delay(int msec)
{
  struct timeval Timeout;

  msec *= 1000;
  Timeout.tv_usec = msec % 1000000;
  Timeout.tv_sec = msec / 1000000;
  select(0, NULL, NULL, NULL, &Timeout);
}

// Assembly:
subq $0x18, %rsp
imull $0x3e8, %edi, %eax      # imm = 0x3E8
movl $0xf4240, %ecx          # imm = 0xF4240
cltd
idivl %ecx
movslq %edx, %rax
leaq 0x8(%rsp), %r8
movq %rax, 0x8(%r8)
movl $0x3e8, %ecx            # imm = 0x3E8
movl %edi, %eax
cltd
idivl %ecx
cltq
movq %rax, (%r8)
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x20b0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: mygetstr
void mygetstr(win, str, eol)
WINDOW *win;
char *str;
boolean eol;
{
  reg char c, *ptr;
  int y, x, y1, x1;
  reg int i=0;

  ptr = str;
  getyx(win, y1, x1);
  wrefresh(win);
  do {
    c=wgetch(win);
    if ((c == _Erase) && i) {
      ptr--;
      i--;
      getyx(win, y, x);
      mvwaddch(win, y, x-1, ' ');
    } else if (c == _Kill) {
      ptr=str;
      i=0;
      wmove(win, y1, x1);
      wclrtoeol(win);
    } else if ((c == '\n') || (c=='\r')) {
      *ptr = '\0';
      if (eol) {
        waddstr(win, "\n");
	wclrtoeol(win);
      }
      wrefresh(win);
      return;
    } else {
      *ptr++ = c;
      waddch(win, c);
    }
    wrefresh(win);
  } while (c != '\n');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x2492
movswl (%rbx), %r15d
movswl 0x2(%rbx), %r12d
jmp 0x2499
pushq $-0x1
popq %r15
movl %r15d, %r12d
movq %rbx, %rdi
callq 0x2180
movq %r14, %r13
movq %rbx, %rdi
callq 0x22f0
movl %eax, %ebp
movsbl %bpl, %esi
shll $0x18, %ebp
movsbl 0xffd5(%rip), %eax      # 0x12491
cmpl %eax, %esi
jne 0x24db
movq %rbx, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x21d0
movq %rbx, %rdi
callq 0x2210
movq %r14, %r13
jmp 0x24fa
cmpl $0xd000000, %ebp        # imm = 0xD000000
je 0x2519
cmpl $0xa000000, %ebp        # imm = 0xA000000
je 0x2519
movb %sil, (%r13)
incq %r13
movq %rbx, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2180
cmpl $0xa000000, %ebp        # imm = 0xA000000
jne 0x24a4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x0, (%r13)
cmpb $0x0, 0x4(%rsp)
je 0x253f
leaq 0x9745(%rip), %rsi      # 0xbc71
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x2210
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2180
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: SysInit
void SysInit()
{
  srand(getpid());
  initscr();

  if ((LINES < 24) || (COLS < 80)) {
	printf("Sorry, you must have at least a 24 by 80 screen to play.\n");
	exit(1);
  }

  _Erase=erasechar();
  _Kill=killchar();
  noecho();
  raw();
  nonl();

  Disrow = LINES * 19 / 24;
  Cmdrow = LINES - Disrow;
  if (!(Disrow & 1)) {
	Disrow++;	/* Insure Disrow is odd */
	Cmdrow--;
  }
  Discol = COLS - 45;
  if (!(Discol & 1)) {
	Discol--;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x20f0
movl %eax, %edi
callq 0x2230
callq 0x2270
movq 0xfa4f(%rip), %r14      # 0x11fc0
cmpl $0x18, (%r14)
jl 0x25f3
movq 0xfa62(%rip), %rbx      # 0x11fe0
cmpl $0x4f, (%rbx)
jle 0x25f3
callq 0x2170
movb %al, 0xff02(%rip)       # 0x12490
callq 0x2030
movb %al, 0xfef8(%rip)       # 0x12491
callq 0x2050
callq 0x2110
callq 0x2280
movl (%r14), %ecx
imull $0x13, %ecx, %eax
pushq $0x18
popq %rsi
cltd
idivl %esi
movl %eax, 0xfeda(%rip)      # 0x12494
subl %eax, %ecx
movl %ecx, 0xfed6(%rip)      # 0x12498
testb $0x1, %al
jne 0x25d7
orl $0x1, %eax
movl %eax, 0xfec5(%rip)      # 0x12494
decl %ecx
movl %ecx, 0xfec1(%rip)      # 0x12498
movl (%rbx), %eax
leal -0x2d(%rax), %ecx
addl $-0x2e, %eax
testb $0x1, %cl
cmovnel %ecx, %eax
movl %eax, 0xfeb1(%rip)      # 0x1249c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xbf8d(%rip), %rdi      # 0xe587
callq 0x2090
pushq $0x1
popq %rdi
callq 0x20c0
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: DrawRep
void DrawRep()
{
  int i, j;

  werase(Repwin);
  mvwaddstr(Repwin,0,14,"Warp Course Bearing Range");
  j=1;
  for (i=0; i<=Enemies; i++)
    if (Ships[i]) {
      sprintf(scrstr,"%12s:",Snams[i]);
      mvwaddstr(Repwin,j,0,scrstr);
      j++;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xf6af(%rip), %rdi      # 0x129d8
callq 0x2080
movq 0xf6a3(%rip), %rdi      # 0x129d8
pushq $0xe
popq %rdx
xorl %esi, %esi
callq 0x21d0
cmpl $-0x1, %eax
je 0x335a
movq 0xf68d(%rip), %rdi      # 0x129d8
leaq 0x8bc8(%rip), %rsi      # 0xbf1a
pushq $-0x1
popq %rdx
callq 0x2200
pushq $0x1
popq %rbx
leaq 0xf61c(%rip), %r12      # 0x12980
leaq 0xf135(%rip), %r14      # 0x124a0
leaq 0x8bc2(%rip), %r15      # 0xbf34
xorl %ebp, %ebp
xorl %r13d, %r13d
movzbl 0xf252(%rip), %eax      # 0x125d0
cmpq %rax, %r13
ja 0x33d6
cmpq $0x0, (%rbp,%r12)
je 0x33cd
leaq 0xf58e(%rip), %rax      # 0x12920
movq (%rbp,%rax), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2190
movq 0xf62d(%rip), %rdi      # 0x129d8
movl %ebx, %esi
xorl %edx, %edx
callq 0x21d0
cmpl $-0x1, %eax
je 0x33cb
movq 0xf618(%rip), %rdi      # 0x129d8
movq %r14, %rsi
pushq $-0x1
popq %rdx
callq 0x2200
incl %ebx
incq %r13
addq $0x8, %rbp
jmp 0x3377
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: DrawBox
void DrawBox(win, rows, cols)
WINDOW *win;
int rows, cols;
{
  int i, j;

  rows--;
  cols--;
  wmove(win, 0, 1);
  for (i=1; i<cols; i++)
    waddch(win,ACS_HLINE);
  j=cols;
  for (i=1; i<rows; i++)
  {
    mvwaddch(win, i, j, ACS_VLINE);
    mvwaddch(win, i, 0, ACS_VLINE);
  }
  wmove(win, i, 1);
  for (i=1; i<cols; i++)
    waddch(win,ACS_HLINE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
decl %ebx
pushq $0x1
popq %r15
xorl %esi, %esi
movl %r15d, %edx
callq 0x21d0
movq 0xebe5(%rip), %r12      # 0x11ff0
cmpl %ebx, %r15d
jge 0x3425
movl 0x1c4(%r12), %esi
movq %r14, %rdi
callq 0x2150
incl %r15d
jmp 0x340b
decl %ebp
pushq $0x1
popq %r15
cmpl %ebp, %r15d
jge 0x3479
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
callq 0x21d0
cmpl $-0x1, %eax
je 0x3452
movl 0x1e0(%r12), %esi
movq %r14, %rdi
callq 0x2150
movq %r14, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x21d0
cmpl $-0x1, %eax
je 0x3474
movl 0x1e0(%r12), %esi
movq %r14, %rdi
callq 0x2150
incl %r15d
jmp 0x342b
pushq $0x1
popq %rbp
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x21d0
cmpl %ebx, %ebp
jge 0x34a1
movl 0x1c4(%r12), %esi
movq %r14, %rdi
callq 0x2150
incl %ebp
jmp 0x3489
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: Endln
void Endln()
{
  LKnt++;
  if (LKnt == Cmdrow) {
    wrefresh(Cmdwin);
    getch();
    LKnt = 0;
  }
  waddstr(Cmdwin,"\n");
  wclrtoeol(Cmdwin);
  wrefresh(Cmdwin);
}

// Assembly:
pushq %rax
movl 0xf0da(%rip), %eax      # 0x12a14
incl %eax
movl %eax, 0xf0d2(%rip)      # 0x12a14
cmpl 0xeb50(%rip), %eax      # 0x12498
jne 0x396c
movq 0xf097(%rip), %rdi      # 0x129e8
callq 0x2180
movq 0xe68b(%rip), %rax      # 0x11fe8
movq (%rax), %rdi
callq 0x22f0
andl $0x0, 0xf0a8(%rip)      # 0x12a14
movq 0xf075(%rip), %rdi      # 0x129e8
leaq 0x82f7(%rip), %rsi      # 0xbc71
pushq $-0x1
popq %rdx
callq 0x2200
movq 0xf05f(%rip), %rdi      # 0x129e8
callq 0x2210
movq 0xf053(%rip), %rdi      # 0x129e8
popq %rax
jmp 0x2180
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: RMod
double RMod(X)
double X;
{
  double TEMP;

  modf(X/360, &TEMP);
  X -= TEMP * 360;
  if (X >= 360)
    X -= 360;
  if (X < 0)
    X += 360;
  return X;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, (%rsp)
movsd 0x7649(%rip), %xmm1     # 0xb028
divsd %xmm1, %xmm0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x22a0
movsd 0x7638(%rip), %xmm0     # 0xb030
movsd (%rbx), %xmm1
mulsd %xmm0, %xmm1
addsd (%rsp), %xmm1
addsd %xmm1, %xmm0
movsd 0x7617(%rip), %xmm3     # 0xb028
movapd %xmm3, %xmm2
cmpnlesd %xmm1, %xmm2
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
addsd %xmm2, %xmm3
xorpd %xmm1, %xmm1
movapd %xmm2, %xmm0
cmpltsd %xmm1, %xmm0
andpd %xmm0, %xmm3
andnpd %xmm2, %xmm0
orpd %xmm3, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: Bearing
double Bearing(From, NTo)
int From, NTo;
{
  double X, Y, Temp;

  X = Objects[NTo]->XPos - Objects[From]->XPos;
  Y = Objects[From]->YPos - Objects[NTo]->YPos;
  if (X != 0)
    Temp = atan(Y / X) * 180 / M_PI;
  else
    Temp = 90.0;
  if (X >= 0 && Y < 0)
    Temp += 360;
  else if (X < 0)
    Temp += 180;
  return Temp;
}

// Assembly:
subq $0x18, %rsp
movslq %esi, %rax
leaq 0xeb89(%rip), %rcx      # 0x125e0
movq (%rcx,%rax,8), %rax
movsd 0x38(%rax), %xmm2
movslq %edi, %rdx
movq (%rcx,%rdx,8), %rcx
subsd 0x38(%rcx), %xmm2
movsd 0x40(%rcx), %xmm0
subsd 0x40(%rax), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
movsd %xmm0, 0x10(%rsp)
jne 0x3a88
jnp 0x3ab3
divsd %xmm2, %xmm0
movsd %xmm2, 0x8(%rsp)
callq 0x2130
xorpd %xmm1, %xmm1
movsd 0x8(%rsp), %xmm2
mulsd 0x7577(%rip), %xmm0     # 0xb020
divsd 0x7567(%rip), %xmm0     # 0xb018
jmp 0x3abb
movsd 0x757d(%rip), %xmm0     # 0xb038
ucomisd %xmm1, %xmm2
jb 0x3ad3
ucomisd 0x10(%rsp), %xmm1
jbe 0x3ad3
addsd 0x7557(%rip), %xmm0     # 0xb028
jmp 0x3ae1
ucomisd %xmm2, %xmm1
jbe 0x3ae1
addsd 0x753f(%rip), %xmm0     # 0xb020
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: Range
double Range(From, NTo)
int From, NTo;
{
  double X, Y;

  if (Objects[NTo] != NULL) {
    X = Objects[NTo]->XPos - Objects[From]->XPos;
    Y = Objects[From]->YPos - Objects[NTo]->YPos;
    return sqrt(X * X + Y * Y);
  } else
    return 9999.0;
}

// Assembly:
movslq %esi, %rax
leaq 0xeaf0(%rip), %rcx      # 0x125e0
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x3b25
movsd 0x38(%rax), %xmm0
movslq %edi, %rdx
movq (%rcx,%rdx,8), %rcx
subsd 0x38(%rcx), %xmm0
movsd 0x40(%rcx), %xmm1
subsd 0x40(%rax), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
retq
movsd 0x7513(%rip), %xmm0     # 0xb040
retq
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: TrakPhas
void TrakPhas(I, J)
int I, J;
{
  int K;
  double D;

  K = Ships[I]->Pstat[J];
  if (K >= 100)
    K -= 100;
  if (K) {
    if (Ships[K-1] == NULL) {
      Ships[I]->Pstat[J] = 0;
      K = 0;
      if (!I) {
	sprintf(scrstr," Phaser %d disengaging.", J+1);
	SEndln();
      }
    } else {
      D = Bearing(I, K-1) - Objects[I]->Act_Crs;
      D = RMod(D);
      Ships[I]->Pdepl[J] = (long)floor(D + 0.5);
    }
  }
  D = Ships[I]->Pdepl[J];
  /* If phaser was set to fire, but engineering is in the way, don't fire. */
  if (D > 125 && D < 235 && !Ships[I]->Dmge[(int)Engn])
    Ships[I]->Pstat[J] = K;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movslq %edi, %rbx
leaq 0xe4fa(%rip), %r12      # 0x12980
movq (%r12,%rbx,8), %rax
movslq %esi, %r14
movswl 0xd2(%rax,%r14,2), %ecx
leal -0x64(%rcx), %r15d
cmpl $0x64, %ecx
cmovll %ecx, %r15d
testl %r15d, %r15d
je 0x4503
movslq %r15d, %rcx
cmpq $0x0, -0x8(%r12,%rcx,8)
je 0x44f5
leal -0x1(%r15), %esi
movl %ebx, %edi
callq 0x3a49
leaq 0xe11d(%rip), %rax      # 0x125e0
movq (%rax,%rbx,8), %rax
subsd 0x10(%rax), %xmm0
callq 0x39cd
addsd 0x6b6f(%rip), %xmm0     # 0xb048
callq 0x22c0
cvttsd2si %xmm0, %rax
cvtsi2sd %rax, %xmm0
movq (%r12,%rbx,8), %rax
movsd %xmm0, 0x60(%rax,%r14,8)
jmp 0x4506
andw $0x0, 0xd2(%rax,%r14,2)
testl %edi, %edi
je 0x4543
xorl %r15d, %r15d
movsd 0x60(%rax,%r14,8), %xmm0
ucomisd 0x6b7b(%rip), %xmm0     # 0xb090
jbe 0x4537
movsd 0x6b79(%rip), %xmm1     # 0xb098
ucomisd %xmm0, %xmm1
jbe 0x4537
cmpb $0x0, 0xc4(%rax)
jne 0x4537
movw %r15w, 0xd2(%rax,%r14,2)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl %esi, %edx
incl %edx
leaq 0xdf52(%rip), %rdi      # 0x124a0
leaq 0x7a6a(%rip), %rsi      # 0xbfbf
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x2190
callq 0x399b
movq (%r12,%rbx,8), %rax
jmp 0x4506
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: PhHits
int PhHits(From, NTo, Phnum, Units)
int From, NTo, Phnum, *Units;
{
  double F3, G2, G3;
  int Hits;

  Hits = 0;
  *Units = (long)floor(Ships[From]->Pstat[5] / 100.0 *
		       Ships[From]->PChrg[Phnum] + 0.5);
  G2 = Range(From, NTo);
  if (G2 > 1000)
    return Hits;
  F3 = Ships[From]->Pstat[4];
  G3 = Bearing(From, NTo);
  G3 = RMod(Objects[From]->Act_Crs + Ships[From]->Pdepl[Phnum] - G3);
  if (G3 <= F3 || 360 - G3 <= F3)
    Hits = (long)(*Units * sqrt(1 - G2 / 1000) * 45 / F3);
  return Hits;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movslq %edi, %r15
leaq 0xe3fb(%rip), %rax      # 0x12980
movq (%rax,%r15,8), %r12
movswl 0xdc(%r12), %eax
cvtsi2sd %eax, %xmm0
movl %esi, %ebp
divsd 0x6ad0(%rip), %xmm0     # 0xb070
movslq %edx, %r13
mulsd 0x20(%r12,%r13,8), %xmm0
addsd 0x6a96(%rip), %xmm0     # 0xb048
callq 0x22c0
cvttsd2si %xmm0, %rax
movl %eax, (%rbx)
movl %r15d, %edi
movl %ebp, %esi
callq 0x3ae6
xorl %r14d, %r14d
ucomisd 0x6acd(%rip), %xmm0     # 0xb0a0
ja 0x469f
movsd %xmm0, 0x8(%rsp)
movswl 0xda(%r12), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
movl %r15d, %edi
movl %ebp, %esi
callq 0x3a49
leaq 0xdfdd(%rip), %rax      # 0x125e0
movq (%rax,%r15,8), %rax
movsd 0x10(%rax), %xmm1
leaq 0xe36d(%rip), %rax      # 0x12980
movq (%rax,%r15,8), %rax
addsd 0x60(%rax,%r13,8), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x39cd
movsd 0x10(%rsp), %xmm2
ucomisd %xmm0, %xmm2
jae 0x4649
movsd 0x69e9(%rip), %xmm1     # 0xb028
subsd %xmm0, %xmm1
ucomisd %xmm1, %xmm2
jb 0x469f
cvtsi2sdl (%rbx), %xmm3
movsd 0x8(%rsp), %xmm0
divsd 0x6a4d(%rip), %xmm0     # 0xb0a8
addsd 0x69ad(%rip), %xmm0     # 0xb010
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4673
sqrtsd %xmm0, %xmm0
jmp 0x468a
movsd %xmm3, 0x8(%rsp)
callq 0x22e0
movsd 0x8(%rsp), %xmm3
movsd 0x10(%rsp), %xmm2
mulsd %xmm3, %xmm0
mulsd 0x6a1a(%rip), %xmm0     # 0xb0b0
divsd %xmm2, %xmm0
cvttsd2si %xmm0, %r14
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: Launch
void Launch(I, J)
int I, *J;
{
  reg int K;
  reg Object *WITH;

  *J = 0;
  for (K = 1; K < AryMax; K++) {
    if (Objects[K] == NULL) {
      *J = K;
      break;
    }
  }
  if (*J == 0) {
    printf("Sorry, game has run out of array space (Too many Torps, etc)\n");
    exit(1);
  }
  Objects[K] = (Object *)Malloc(sizeof(Object));
  WITH = Objects[K];
  WITH->ObTyp = (-1);
  WITH->XPos = Objects[I]->XPos;
  WITH->YPos = Objects[I]->YPos;
  WITH->Act_Spd = 0.0;
  WITH->Des_Spd = 0.0;
  WITH->Act_Crs = 0.0;
  WITH->Des_Crs = 0.0;
  WITH->Fuel = 0.0;
  WITH->Trgt = 0;
  WITH->Tim_Del = 0.0;
  WITH->Prx_Del = 0.0;
  K = 0;
  for (I = AryMax-1; I > 0; I--) {
    if (Objects[I]) {
      K = I+1;
      break;
    }
  }
  ObjCount = K;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
andl $0x0, (%rsi)
movl %edi, %ebx
pushq $0x1
popq %r15
leaq 0xdd0b(%rip), %r14      # 0x125e0
cmpq $0x64, %r15
je 0x4947
cmpq $0x0, (%r14,%r15,8)
je 0x48e7
incq %r15
jmp 0x48d5
movl %r15d, (%rsi)
pushq $0x50
popq %rdi
callq 0x20d0
orw $-0x1, 0x4a(%rax)
movq %rax, (%r14,%r15,8)
movslq %ebx, %rcx
movq (%r14,%rcx,8), %rcx
movups 0x38(%rcx), %xmm0
movups %xmm0, 0x38(%rax)
andw $0x0, 0x48(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
andq $0x0, 0x30(%rax)
pushq $0x63
popq %rcx
movl %ecx, %eax
subl $0x1, %ecx
jb 0x4939
movl %eax, %edx
cmpq $0x0, (%r14,%rdx,8)
je 0x4925
incb %al
jmp 0x493b
xorl %eax, %eax
movb %al, 0xdc91(%rip)       # 0x125d2
popq %rbx
popq %r14
popq %r15
retq
leaq 0x9c72(%rip), %rdi      # 0xe5c0
callq 0x2090
pushq $0x1
popq %rdi
callq 0x20c0
// File: /workspace/github_c_makefile_star2_O2/hyc[P]trek73c/trekx.c
// Function: TrakTorp
void TrakTorp(I, J)
int I, J;
{
  int K;
  double D;

  K = Ships[I]->Tstat[J];
  if (K >= 100)
    K -= 100;
  if (K) {
    if (Ships[K-1] == NULL) {
      Ships[I]->Tstat[J] = 0;
      K = 0;
      if (!I) {
	sprintf(scrstr," Tube %d disengaging.", J+1);
	SEndln();
      }
    } else {
      D = Bearing(I, K-1) - Objects[I]->Act_Crs;
      D = RMod(D);
      Ships[I]->TDepl[J] = D;
    }
  }
  D = Ships[I]->TDepl[J];
  if (D > 135 && D < 225 && !Ships[I]->Dmge[(long)Engn])
    Ships[I]->Tstat[J] = K;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movslq %edi, %rbx
leaq 0xe013(%rip), %r12      # 0x12980
movq (%r12,%rbx,8), %rax
movslq %esi, %r14
movswl 0x110(%rax,%r14,2), %ecx
leal -0x64(%rcx), %r15d
cmpl $0x64, %ecx
cmovll %ecx, %r15d
testl %r15d, %r15d
je 0x49d6
movslq %r15d, %rcx
cmpq $0x0, -0x8(%r12,%rcx,8)
je 0x49c8
leal -0x1(%r15), %esi
movl %ebx, %edi
callq 0x3a49
leaq 0xdc36(%rip), %rax      # 0x125e0
movq (%rax,%rbx,8), %rax
subsd 0x10(%rax), %xmm0
callq 0x39cd
movq (%r12,%rbx,8), %rax
movsd %xmm0, 0xe0(%rax,%r14,8)
jmp 0x49d9
andw $0x0, 0x110(%rax,%r14,2)
testl %edi, %edi
je 0x4a19
xorl %r15d, %r15d
movsd 0xe0(%rax,%r14,8), %xmm0
ucomisd 0x66d5(%rip), %xmm0     # 0xb0c0
jbe 0x4a0d
movsd 0x665b(%rip), %xmm1     # 0xb050
ucomisd %xmm0, %xmm1
jbe 0x4a0d
cmpb $0x0, 0xc4(%rax)
jne 0x4a0d
movw %r15w, 0x110(%rax,%r14,2)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl %esi, %edx
incl %edx
leaq 0xda7c(%rip), %rdi      # 0x124a0
leaq 0x75fb(%rip), %rsi      # 0xc026
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x2190
callq 0x399b
movq (%r12,%rbx,8), %rax
jmp 0x49d9