LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x10(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r13
movq %r13, %rdi
callq 0x4e76
movb %bl, 0x20(%r13)
movq %r12, %rdi
movq %r13, %rsi
callq 0x8de0
movl %edx, %ebx
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x8953
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
testb $0x1, %bl
je 0x8967
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x59cb(%rip), %rsi      # 0xe346
leaq 0x48(%rsp), %rdi
movq %r15, %rdx
callq 0x67b9
leaq 0x59f4(%rip), %rsi      # 0xe383
leaq 0x48(%rsp), %rdi
callq 0x3500
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x89bc
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x89c9
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rsp, %rdi
movq %r14, %rdx
callq 0x889a
movb $0x1, %r15b
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3440
xorl %r15d, %r15d
movq 0xb5e8(%rip), %rsi      # 0x13ff0
movq 0xb5a1(%rip), %rdx      # 0x13fb0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x8a38
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x8a38
movq %rax, %r14
movb $0x1, %r15b
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x8a57
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x8a57
movq %rax, %r14
movb $0x1, %r15b
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8a7a
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x8a7a
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x8aa2
movq %rbx, %rdi
callq 0x31f0
jmp 0x8aa2
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x8aa2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_c_makefile_star2_O1/almk277[P]ROSE/rasm/./module.hpp
// Function: operator<<(std::ostream&, table<RMDModule> 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 %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rdi,%rax), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
sete 0x10(%rsp)
movq 0x58(%rsi), %r15
movq 0x60(%rsi), %r12
cmpq %r12, %r15
je 0x8cc6
leaq 0x8(%rsp), %r13
leaq 0x18(%rsp), %r14
movq %r13, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movzwl (%r15), %edx
movl 0x10(%rsp), %esi
callq 0xa44a
leaq 0x2(%r15), %rsi
movq %r14, %rdi
callq 0x8b8e
addq $0x4, %r15
cmpq %r12, %r15
jne 0x8c9a
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/almk277[P]ROSE/rasm/./serial.hpp
// Function: std::enable_if<std::is_integral<unsigned short>::value, void>::type serial<std::ostreambuf_iterator<char, std::char_traits<char>>, unsigned short>(std::ostreambuf_iterator<char, std::char_traits<char>>, unsigned short)
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 %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl $0x2, %r15d
movl $0x1, %r12d
testb $0x1, %bpl
jne 0xa47b
movq 0x28(%r14), %rax
cmpq 0x30(%r14), %rax
jae 0xa488
movb %bl, (%rax)
incq 0x28(%r14)
movzwl %bx, %ebx
shrl $0x8, %ebx
decl %r15d
jne 0xa465
jmp 0xa4a1
movzbl %bl, %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x68(%rax)
cmpl $-0x1, %eax
movzbl %bpl, %ebp
cmovel %r12d, %ebp
jmp 0xa47b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movb $0x1, %bpl
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r15
movq (%r14), %rdi
callq 0x56b4
leal -0x6(%rax), %ecx
cmpl $0x2, %ecx
jae 0xba92
xorl %ebp, %ebp
jmp 0xbace
testl %eax, %eax
jne 0xbae6
movq (%r14), %rsi
addq $0x10, %rsi
movq %r15, %rdi
callq 0xab33
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x30a0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xbace
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
testb $0x1, %bpl
jne 0xba7e
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3150
movq %rax, %r15
movq (%r14), %rsi
addq $0x10, %rsi
leaq 0x2bd7(%rip), %rdx      # 0xe6d8
leaq 0x8(%rsp), %rdi
callq 0x49df
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0x84cc(%rip), %rsi      # 0x13ff0
movq 0x8485(%rip), %rdx      # 0x13fb0
movq %r15, %rdi
callq 0x3480
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xbb55
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xbb55
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xbb85
movq %r15, %rdi
callq 0x31f0
jmp 0xbb85
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xbb85
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xbb85
jmp 0xbb82
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0xbb99
movq (%r12), %rsi
incq %rsi
callq 0x3260
movq %r14, %rdi
callq 0x34a0
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xada8
movq 0x8(%r15), %rdi
callq 0x862e
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0xbc7c
movq %r14, %rdi
callq 0x3110
movq %rax, %r14
movl $0x18, %edi
callq 0x3150
movq %rax, %rbx
movq (%r15), %rax
movl 0x8(%rax), %r15d
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x49a2
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x32f0
leaq 0x8103(%rip), %rax      # 0x13d28
movq %rax, (%rbx)
movl %r15d, 0x10(%rbx)
xorl %ebp, %ebp
leaq 0x80a3(%rip), %rsi      # 0x13cd8
movq 0x837c(%rip), %rdx      # 0x13fb8
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbc6a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xbc6a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xbc77
movq %rbx, %rdi
callq 0x31f0
callq 0x3460
movq %r14, %rdi
callq 0x34a0
movq %rax, %rdi
callq 0x4acf
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
cmpl %esi, (%rdi)
jne 0xbfd1
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %ebp
movq %rdi, %r14
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
movl %ebp, %esi
callq 0xc696
leaq 0x2706(%rip), %rsi      # 0xe6fc
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rdx
callq 0x6b15
leaq 0x26de(%rip), %rsi      # 0xe6ed
leaq 0x80(%rsp), %rdi
callq 0x3500
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xc03d
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0xc049
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl (%r14), %esi
leaq 0x40(%rsp), %rdi
callq 0xc696
leaq 0xa0(%rsp), %rdi
movq %rsp, %rsi
leaq 0x40(%rsp), %rdx
callq 0x6be6
leaq 0x267b(%rip), %rsi      # 0xe705
leaq 0xa0(%rsp), %rdi
callq 0x3500
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xc0ba
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0xc0c7
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0x7ef9(%rip), %rsi      # 0x13ff0
movq 0x7eb2(%rip), %rdx      # 0x13fb0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xc128
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xc128
movq %rax, %r14
movb $0x1, %bpl
leaq 0xb0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc151
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xc151
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc174
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xc174
movq %rax, %r14
movb $0x1, %bpl
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xc192
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xc192
movq %rax, %r14
movb $0x1, %bpl
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc1bb
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xc1bb
movq %rax, %r14
movb $0x1, %bpl
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc1de
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xc1de
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xc1eb
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x34a0
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %r15
addq $0x20, %rdi
callq 0xc81a
testq %rax, %rax
je 0xc2ca
movb 0x28(%rax), %al
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x244a(%rip), %rsi      # 0xe728
leaq 0x40(%rsp), %rdi
movq %r15, %rdx
callq 0x67b9
leaq 0x243e(%rip), %rsi      # 0xe730
leaq 0x40(%rsp), %rdi
callq 0x3500
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xc31d
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0xc329
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x60(%rsp), %rdi
movq %r14, %rdx
callq 0x889a
leaq 0x23d7(%rip), %rsi      # 0xe72e
leaq 0x60(%rsp), %rdi
callq 0x3500
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xc384
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0xc391
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0x7c2f(%rip), %rsi      # 0x13ff0
movq 0x7be8(%rip), %rdx      # 0x13fb0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xc3f2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xc3f2
movq %rax, %r14
movb $0x1, %bpl
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc415
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xc415
movq %rax, %r14
movb $0x1, %bpl
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xc433
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xc433
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc456
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xc456
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xc463
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x34a0
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xc6d9
cmpl $0x1, %esi
je 0xc6c2
testl %esi, %esi
jne 0xc701
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2057(%rip), %rsi      # 0xe710
leaq 0x2054(%rip), %rdx      # 0xe714
jmp 0xc6ee
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1e06(%rip), %rsi      # 0xe4d6
leaq 0x1e03(%rip), %rdx      # 0xe4da
jmp 0xc6ee
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1d8a(%rip), %rsi      # 0xe471
leaq 0x1d87(%rip), %rdx      # 0xe475
movq %rbx, %rdi
callq 0x4f06
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x2000(%rip), %rsi      # 0xe715
movq %rax, %rdi
callq 0x33b0
movq 0x78ac(%rip), %rsi      # 0x13fd0
movq 0x7895(%rip), %rdx      # 0x13fc0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_c_makefile_star2_O1/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 $0x38, %rsp
movq %rdx, %r13
movq %rsi, %r12
movq %rdx, %rbx
cmpq $0x0, (%rbx)
leaq 0x20(%rbx), %rbx
jne 0xd3f7
cmpl $0x1, %edi
je 0xd56a
movl %edi, %eax
movq %rax, 0x30(%rsp)
leaq 0x20(%r13), %rax
movq %rax, 0x20(%rsp)
movl $0x1, %r14d
movq %r12, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movq (%r12,%r14,8), %r15
cmpb $0x2d, (%r15)
jne 0xd4a6
incq %r15
movq %r15, %rdi
movl $0x3d, %esi
callq 0x30d0
testq %rax, %rax
je 0xd4cf
movq (%r13), %rbp
testq %rbp, %rbp
je 0xd4fc
movq %rax, 0x28(%rsp)
movq %rax, %r13
subq %r15, %r13
movq 0x20(%rsp), %r12
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x3130
testl %eax, %eax
jne 0xd488
cmpb $0x0, (%rbp,%r13)
je 0xd526
movq (%r12), %rbp
addq $0x20, %r12
testq %rbp, %rbp
jne 0xd46a
xorl %ebp, %ebp
movl %r14d, 0xc(%rsp)
movq 0x18(%rsp), %r13
jmp 0xd552
movq -0x18(%rbx), %rax
testq %rax, %rax
je 0xd4b5
movl $0x1, (%rax)
movq -0x10(%rbx), %rax
movb $0x1, %bpl
testq %rax, %rax
je 0xd557
movq %r15, %rdi
callq *%rax
jmp 0xd557
movq (%r13), %rsi
movq 0x20(%rsp), %r12
testq %rsi, %rsi
je 0xd4f3
movq %r15, %rdi
callq 0x3370
testl %eax, %eax
je 0xd505
movq (%r12), %rsi
addq $0x20, %r12
jmp 0xd4d8
xorl %ebp, %ebp
movl %r14d, 0xc(%rsp)
jmp 0xd552
xorl %ebp, %ebp
movl %r14d, 0xc(%rsp)
jmp 0xd557
movq -0x18(%r12), %rax
testq %rax, %rax
je 0xd515
movl $0x1, (%rax)
movq -0x10(%r12), %rax
movb $0x1, %bpl
testq %rax, %rax
je 0xd552
xorl %edi, %edi
jmp 0xd550
movq -0x18(%r12), %rax
testq %rax, %rax
je 0xd536
movl $0x1, (%rax)
movq -0x10(%r12), %rax
movb $0x1, %bpl
testq %rax, %rax
movq 0x18(%rsp), %r13
je 0xd552
movq 0x28(%rsp), %rdi
incq %rdi
callq *%rax
movq 0x10(%rsp), %r12
testb %bpl, %bpl
je 0xd56e
incq %r14
cmpq 0x30(%rsp), %r14
jne 0xd42a
xorl %eax, %eax
jmp 0xd572
movl 0xc(%rsp), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xd5bd
leaq 0x20(%rbx), %r15
xorl %ebp, %ebp
callq 0x3120
movq %rax, %r14
cmpl %r14d, %ebp
cmovgl %ebp, %r14d
movq (%r15), %rdi
addq $0x20, %r15
movl %r14d, %ebp
testq %rdi, %rdi
jne 0xd59d
jmp 0xd5c0
xorl %r14d, %r14d
movq (%rbx), %rdx
testq %rdx, %rdx
je 0xd60a
addq $0x20, %rbx
leaq 0x11d5(%rip), %r12      # 0xe7a8
leaq 0x11cb(%rip), %r13      # 0xe7a5
leaq 0x11b5(%rip), %r15      # 0xe796
cmpq $0x0, -0x10(%rbx)
movq %r13, %rcx
cmoveq %r12, %rcx
movq -0x8(%rbx), %r8
movq %r15, %rdi
movl %r14d, %esi
xorl %eax, %eax
callq 0x3040
movq (%rbx), %rdx
addq $0x20, %rbx
testq %rdx, %rdx
jne 0xd5e1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
cltq
imulq $0x431bde83, %rax, %rcx # imm = 0x431BDE83
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x32, %rcx
addl %edx, %ecx
imull $0xf4240, %ecx, %ecx    # imm = 0xF4240
subl %ecx, %eax
cltq
leaq 0x8(%rsp), %r8
movq %rax, 0x8(%r8)
movslq %edi, %rax
imulq $0x10624dd3, %rax, %rax # imm = 0x10624DD3
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x26, %rax
addl %ecx, %eax
cltq
movq %rax, (%r8)
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x20c0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x24c9
movswl (%rbx), %r12d
testq %rbx, %rbx
je 0x24d3
movswl 0x2(%rbx), %r15d
movq %rbx, %rdi
callq 0x2190
movq %r14, %r13
movq %rbx, %rdi
callq 0x2300
movl %eax, %ebp
movsbl %bpl, %esi
shll $0x18, %ebp
movsbl 0x10fab(%rip), %eax     # 0x134a1
cmpl %eax, %esi
jne 0x2515
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0x21e0
movq %rbx, %rdi
callq 0x2220
movq %r14, %r13
jmp 0x2534
cmpl $0xd000000, %ebp        # imm = 0xD000000
je 0x2553
cmpl $0xa000000, %ebp        # imm = 0xA000000
je 0x2553
movb %sil, (%r13)
incq %r13
movq %rbx, %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x2190
cmpl $0xa000000, %ebp        # imm = 0xA000000
jne 0x24de
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x0, (%r13)
cmpb $0x0, 0x4(%rsp)
je 0x257b
leaq 0xb6cb(%rip), %rsi      # 0xdc31
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
movq %rbx, %rdi
callq 0x2220
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2190
// File: /workspace/github_c_makefile_star2_O1/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 0x2100
movl %eax, %edi
callq 0x2240
callq 0x2280
movq 0x10a13(%rip), %r14     # 0x12fc0
cmpl $0x18, (%r14)
jl 0x264c
movq 0x10a22(%rip), %rbx     # 0x12fe0
cmpl $0x4f, (%rbx)
jle 0x264c
callq 0x2180
movb %al, 0x10ece(%rip)      # 0x134a0
callq 0x2030
movb %al, 0x10ec4(%rip)      # 0x134a1
callq 0x2060
callq 0x2120
callq 0x2290
movl (%r14), %eax
leal (%rax,%rax,8), %ecx
leal (%rax,%rcx,2), %ecx
movslq %ecx, %rcx
imulq $0x2aaaaaab, %rcx, %rcx # imm = 0x2AAAAAAB
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
movl %ecx, 0x10e92(%rip)     # 0x134a4
subl %ecx, %eax
movl %eax, 0x10e8e(%rip)     # 0x134a8
testb $0x1, %cl
jne 0x2630
orl $0x1, %ecx
movl %ecx, 0x10e7c(%rip)     # 0x134a4
decl %eax
movl %eax, 0x10e78(%rip)     # 0x134a8
movl (%rbx), %eax
leal -0x2d(%rax), %ecx
addl $-0x2e, %eax
testb $0x1, %cl
cmovnel %ecx, %eax
movl %eax, 0x10e68(%rip)     # 0x134ac
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xdef4(%rip), %rdi      # 0x10547
callq 0x20a0
movl $0x1, %edi
callq 0x20d0
// File: /workspace/github_c_makefile_star2_O1/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 0x103fd(%rip), %rdi     # 0x139e8
callq 0x2090
movq 0x103f1(%rip), %rdi     # 0x139e8
xorl %esi, %esi
movl $0xe, %edx
callq 0x21e0
cmpl $-0x1, %eax
je 0x3620
movq 0x103d9(%rip), %rdi     # 0x139e8
leaq 0xa8c4(%rip), %rsi      # 0xdeda
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
movl $0x1, %ebx
movq $-0x1, %r12
leaq 0x1035d(%rip), %r13     # 0x13990
leaq 0xfe76(%rip), %r14      # 0x134b0
leaq 0xa8b3(%rip), %r15      # 0xdef4
xorl %ebp, %ebp
cmpq $0x0, (%rbp,%r13)
je 0x368f
leaq 0x102de(%rip), %rax     # 0x13930
movq (%rbp,%rax), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21a0
movq 0x1037d(%rip), %rdi     # 0x139e8
movl %ebx, %esi
xorl %edx, %edx
callq 0x21e0
cmpl $-0x1, %eax
je 0x368d
movq 0x10368(%rip), %rdi     # 0x139e8
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
incl %ebx
movzbl 0xff4a(%rip), %eax      # 0x135e0
incq %r12
addq $0x8, %rbp
cmpq %rax, %r12
jb 0x3643
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
movl $0x1, %r12d
xorl %esi, %esi
movl $0x1, %edx
callq 0x21e0
cmpl $0x3, %ebx
jl 0x36f8
leal -0x2(%rbx), %ebp
movq 0xf90b(%rip), %r13      # 0x12ff0
movl 0x1c4(%r13), %esi
movq %r14, %rdi
callq 0x2160
decl %ebp
jne 0x36e5
cmpl $0x3, %r15d
jl 0x3772
leal -0x1(%rbx), %ebp
movl $0x2, %r13d
subl %r15d, %r13d
movl $0x1, %r15d
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x21e0
cmpl $-0x1, %eax
je 0x3737
movq 0xf8c7(%rip), %rax      # 0x12ff0
movl 0x1e0(%rax), %esi
movq %r14, %rdi
callq 0x2160
movq %r14, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x21e0
cmpl $-0x1, %eax
je 0x375e
movq 0xf8a0(%rip), %rax      # 0x12ff0
movl 0x1e0(%rax), %esi
movq %r14, %rdi
callq 0x2160
movl %r15d, %r12d
incl %r12d
leal (%r15,%r13), %eax
incl %eax
movl %r12d, %r15d
cmpl $0x1, %eax
jne 0x3710
movq %r14, %rdi
movl %r12d, %esi
movl $0x1, %edx
callq 0x21e0
cmpl $0x3, %ebx
jl 0x37a4
addl $-0x2, %ebx
movq 0xf85f(%rip), %r15      # 0x12ff0
movl 0x1c4(%r15), %esi
movq %r14, %rdi
callq 0x2160
decl %ebx
jne 0x3791
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xfdc5(%rip), %eax      # 0x13a24
incl %eax
movl %eax, 0xfdbd(%rip)      # 0x13a24
cmpl 0xf83b(%rip), %eax      # 0x134a8
jne 0x3c94
movq 0xfd82(%rip), %rdi      # 0x139f8
callq 0x2190
movq 0xf366(%rip), %rax      # 0x12fe8
movq (%rax), %rdi
callq 0x2300
movl $0x0, 0xfd90(%rip)      # 0x13a24
movq 0xfd5d(%rip), %rdi      # 0x139f8
leaq 0x9f8f(%rip), %rsi      # 0xdc31
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
movq 0xfd45(%rip), %rdi      # 0x139f8
callq 0x2220
movq 0xfd39(%rip), %rdi      # 0x139f8
popq %rax
jmp 0x2190
// File: /workspace/github_c_makefile_star2_O1/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 0x9315(%rip), %xmm1     # 0xd020
divsd %xmm1, %xmm0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x22b0
movsd 0x9304(%rip), %xmm0     # 0xd028
movsd (%rbx), %xmm1
mulsd %xmm0, %xmm1
addsd (%rsp), %xmm1
addsd %xmm1, %xmm0
movsd 0x92e3(%rip), %xmm3     # 0xd020
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_O1/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 0xf86d(%rip), %rcx      # 0x135f0
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 0x3db4
jnp 0x3ddf
divsd %xmm2, %xmm0
movsd %xmm2, 0x8(%rsp)
callq 0x2140
xorpd %xmm1, %xmm1
movsd 0x8(%rsp), %xmm2
mulsd 0x9243(%rip), %xmm0     # 0xd018
divsd 0x9233(%rip), %xmm0     # 0xd010
jmp 0x3de7
movsd 0x9249(%rip), %xmm0     # 0xd030
ucomisd %xmm1, %xmm2
jb 0x3dff
ucomisd 0x10(%rsp), %xmm1
jbe 0x3dff
addsd 0x9223(%rip), %xmm0     # 0xd020
jmp 0x3e0d
ucomisd %xmm2, %xmm1
jbe 0x3e0d
addsd 0x920b(%rip), %xmm0     # 0xd018
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xf7d4(%rip), %rcx      # 0x135f0
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x3e5f
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
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x22f0
sqrtsd %xmm0, %xmm0
retq
movsd 0x91d1(%rip), %xmm0     # 0xd038
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movslq %edi, %rbx
leaq 0xf002(%rip), %r12      # 0x13990
movq (%r12,%rbx,8), %rax
movslq %esi, %r15
movswl 0xd2(%rax,%r15,2), %ecx
leal -0x64(%rcx), %r13d
cmpl $0x64, %ecx
cmovll %ecx, %r13d
testl %r13d, %r13d
je 0x4a84
movslq %r13d, %rcx
cmpq $0x0, -0x8(%r12,%rcx,8)
je 0x4a75
leal -0x1(%r13), %esi
movl %ebx, %edi
callq 0x3d75
leaq 0xec1d(%rip), %rax      # 0x135f0
movq (%rax,%rbx,8), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, (%rsp)
movsd 0x8637(%rip), %xmm2     # 0xd020
divsd %xmm2, %xmm0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x22b0
movsd 0x8626(%rip), %xmm0     # 0xd028
movsd (%r14), %xmm1
mulsd %xmm0, %xmm1
addsd (%rsp), %xmm1
addsd %xmm1, %xmm0
movsd 0x8604(%rip), %xmm3     # 0xd020
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
addsd 0x85f2(%rip), %xmm0     # 0xd048
callq 0x22d0
cvttsd2si %xmm0, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movq (%r12,%rbx,8), %rax
movsd %xmm0, 0x60(%rax,%r15,8)
jmp 0x4a87
movw $0x0, 0xd2(%rax,%r15,2)
testl %edi, %edi
je 0x4aca
xorl %r13d, %r13d
movq (%r12,%rbx,8), %rax
movsd 0x60(%rax,%r15,8), %xmm0
ucomisd 0x85e6(%rip), %xmm0     # 0xd080
jbe 0x4abc
movsd 0x85e4(%rip), %xmm1     # 0xd088
ucomisd %xmm0, %xmm1
jbe 0x4abc
cmpb $0x0, 0xc4(%rax)
jne 0x4abc
movw %r13w, 0xd2(%rax,%r15,2)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl %esi, %edx
incl %edx
leaq 0xe9db(%rip), %r14      # 0x134b0
leaq 0x94a3(%rip), %rsi      # 0xdf7f
xorl %r13d, %r13d
movq %r14, %rdi
xorl %eax, %eax
callq 0x21a0
movq 0xef08(%rip), %rdi      # 0x139f8
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
callq 0x3c58
jmp 0x4a87
// File: /workspace/github_c_makefile_star2_O1/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 $0x28, %rsp
movq %rcx, %rbx
movslq %edi, %r14
leaq 0xee71(%rip), %r12      # 0x13990
movq (%r12,%r14,8), %rax
movswl 0xdc(%rax), %ecx
cvtsi2sd %ecx, %xmm0
movl %esi, %ebp
divsd 0x8558(%rip), %xmm0     # 0xd090
movslq %edx, %r13
mulsd 0x20(%rax,%r13,8), %xmm0
addsd 0x84fe(%rip), %xmm0     # 0xd048
callq 0x22d0
cvttsd2si %xmm0, %rax
movq %rbx, (%rsp)
movl %eax, (%rbx)
movslq %ebp, %rax
leaq 0xea8c(%rip), %rbx      # 0x135f0
movq (%rbx,%rax,8), %rax
testq %rax, %rax
je 0x4ba1
movsd 0x38(%rax), %xmm0
movq (%rbx,%r14,8), %rcx
subsd 0x38(%rcx), %xmm0
movsd 0x40(%rcx), %xmm1
subsd 0x40(%rax), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4bab
sqrtsd %xmm0, %xmm0
jmp 0x4bb0
movsd 0x848f(%rip), %xmm0     # 0xd038
jmp 0x4bb0
callq 0x22f0
xorl %r15d, %r15d
ucomisd 0x84dd(%rip), %xmm0     # 0xd098
ja 0x4cea
movsd %xmm0, 0x10(%rsp)
movq (%r12,%r14,8), %rax
movswl 0xda(%rax), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x8(%rsp)
movl %r14d, %edi
movl %ebp, %esi
callq 0x3d75
movq (%rbx,%r14,8), %rax
movsd 0x10(%rax), %xmm1
movq (%r12,%r14,8), %rax
addsd 0x60(%rax,%r13,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
movapd %xmm1, %xmm0
divsd 0x840d(%rip), %xmm0     # 0xd020
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x22b0
movsd 0x8400(%rip), %xmm0     # 0xd028
movsd (%r14), %xmm1
mulsd %xmm0, %xmm1
addsd 0x18(%rsp), %xmm1
addsd %xmm1, %xmm0
movsd 0x83dd(%rip), %xmm3     # 0xd020
movapd %xmm3, %xmm2
cmpnlesd %xmm1, %xmm2
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
movapd %xmm3, %xmm0
orpd %xmm1, %xmm2
movapd %xmm2, %xmm3
addsd %xmm0, %xmm3
xorpd %xmm4, %xmm4
movapd %xmm2, %xmm1
cmpltsd %xmm4, %xmm1
andpd %xmm1, %xmm3
andnpd %xmm2, %xmm1
movsd 0x8(%rsp), %xmm2
orpd %xmm3, %xmm1
ucomisd %xmm1, %xmm2
jae 0x4c93
subsd %xmm1, %xmm0
ucomisd %xmm0, %xmm2
jb 0x4cea
movq (%rsp), %rax
xorps %xmm1, %xmm1
cvtsi2sdl (%rax), %xmm1
movsd 0x10(%rsp), %xmm0
divsd 0x83f4(%rip), %xmm0     # 0xd0a0
addsd 0x83ac(%rip), %xmm0     # 0xd060
ucomisd %xmm4, %xmm0
jb 0x4cc0
sqrtsd %xmm0, %xmm0
jmp 0x4cd5
movsd %xmm1, (%rsp)
callq 0x22f0
movsd (%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
mulsd %xmm1, %xmm0
mulsd 0x83c7(%rip), %xmm0     # 0xd0a8
divsd %xmm2, %xmm0
cvttsd2si %xmm0, %r15
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl %edi, %ebx
movl $0x0, (%rsi)
movl $0x1, %r15d
leaq 0xe665(%rip), %r14      # 0x135f0
cmpq $0x0, (%r14,%r15,8)
je 0x4fa3
incq %r15
cmpq $0x64, %r15
jne 0x4f8b
movl $0x64, %r15d
jmp 0x4fa6
movl %r15d, (%rsi)
cmpl $0x0, (%rsi)
je 0x501a
movl $0x50, %edi
callq 0x20e0
movq %rax, (%r14,%r15,8)
movw $0xffff, 0x4a(%rax)     # imm = 0xFFFF
movslq %ebx, %rcx
movq (%r14,%rcx,8), %rcx
movsd 0x38(%rcx), %xmm0
movsd %xmm0, 0x38(%rax)
movsd 0x40(%rcx), %xmm0
movsd %xmm0, 0x40(%rax)
movw $0x0, 0x48(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x30(%rax)
movl $0x64, %eax
leal -0x1(%rax), %ecx
cmpq $0x0, (%r14,%rcx,8)
jne 0x500e
movl %ecx, %eax
cmpl $0x1, %ecx
ja 0x4ffb
xorl %eax, %eax
movb %al, 0xe5ce(%rip)       # 0x135e2
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb55f(%rip), %rdi      # 0x10580
callq 0x20a0
movl $0x1, %edi
callq 0x20d0
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movslq %edi, %rbx
leaq 0xe949(%rip), %r12      # 0x13990
movq (%r12,%rbx,8), %rax
movslq %esi, %r15
movswl 0x110(%rax,%r15,2), %ecx
leal -0x64(%rcx), %r13d
cmpl $0x64, %ecx
cmovll %ecx, %r13d
testl %r13d, %r13d
je 0x5126
movslq %r13d, %rcx
cmpq $0x0, -0x8(%r12,%rcx,8)
je 0x5117
leal -0x1(%r13), %esi
movl %ebx, %edi
callq 0x3d75
leaq 0xe564(%rip), %rax      # 0x135f0
movq (%rax,%rbx,8), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, (%rsp)
movsd 0x7f7e(%rip), %xmm2     # 0xd020
divsd %xmm2, %xmm0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x22b0
movsd 0x7f6d(%rip), %xmm0     # 0xd028
movsd (%r14), %xmm1
mulsd %xmm0, %xmm1
addsd (%rsp), %xmm1
addsd %xmm1, %xmm0
movsd 0x7f4b(%rip), %xmm3     # 0xd020
movapd %xmm3, %xmm2
cmpnlesd %xmm1, %xmm2
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
addsd %xmm2, %xmm3
xorpd %xmm0, %xmm0
movapd %xmm2, %xmm1
cmpltsd %xmm0, %xmm1
andpd %xmm1, %xmm3
andnpd %xmm2, %xmm1
orpd %xmm3, %xmm1
movq (%r12,%rbx,8), %rax
movlpd %xmm1, 0xe0(%rax,%r15,8)
jmp 0x5129
movw $0x0, 0x110(%rax,%r15,2)
testl %edi, %edi
je 0x516f
xorl %r13d, %r13d
movq (%r12,%rbx,8), %rax
movsd 0xe0(%rax,%r15,8), %xmm0
ucomisd 0x7f79(%rip), %xmm0     # 0xd0b8
jbe 0x5161
movsd 0x7f0f(%rip), %xmm1     # 0xd058
ucomisd %xmm0, %xmm1
jbe 0x5161
cmpb $0x0, 0xc4(%rax)
jne 0x5161
movw %r13w, 0x110(%rax,%r15,2)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl %esi, %edx
incl %edx
leaq 0xe336(%rip), %r14      # 0x134b0
leaq 0x8e65(%rip), %rsi      # 0xdfe6
xorl %r13d, %r13d
movq %r14, %rdi
xorl %eax, %eax
callq 0x21a0
movq 0xe863(%rip), %rdi      # 0x139f8
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
callq 0x3c58
jmp 0x5129
// File: /workspace/github_c_makefile_star2_O1/hyc[P]trek73c/trekx.c
// Function: AMHits
int AMHits(I, J)
int I, J;
{
  int Hits;
  double F1, F2, G2;

  Hits = 0;
  F1 = Objects[I]->Fuel * 5;
  G2 = Range(I, J);
  F2 = F1 * 10;
  if (G2 <= F2)
    Hits = (long)(F1 * sqrt(1 - G2 / F2));
  return Hits;
}

// Assembly:
pushq %rax
movslq %edi, %rax
leaq 0xe1ba(%rip), %rcx      # 0x135f0
movq (%rcx,%rax,8), %rax
movsd 0x20(%rax), %xmm2
mulsd 0x7c89(%rip), %xmm2     # 0xd0d0
movslq %esi, %rdx
movq (%rcx,%rdx,8), %rcx
testq %rcx, %rcx
je 0x5483
movsd 0x38(%rcx), %xmm0
subsd 0x38(%rax), %xmm0
movsd 0x40(%rax), %xmm1
subsd 0x40(%rcx), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x548d
sqrtsd %xmm0, %xmm0
jmp 0x549c
movsd 0x7bad(%rip), %xmm0     # 0xd038
jmp 0x549c
movsd %xmm2, (%rsp)
callq 0x22f0
movsd (%rsp), %xmm2
movsd 0x7b64(%rip), %xmm1     # 0xd008
mulsd %xmm2, %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
jb 0x54ef
divsd %xmm1, %xmm0
movsd 0x7ba4(%rip), %xmm1     # 0xd060
subsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x54d3
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x54e6
movapd %xmm1, %xmm0
movsd %xmm2, (%rsp)
callq 0x22f0
movsd (%rsp), %xmm2
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/hyc[P]trek73c/trekx.c
// Function: Antimatter
void Antimatter(I)
int I;
{
  int J, M, K0;
  boolean Boom;
  reg Object *WITH;

  WITH = Objects[I];
  M = WITH->ObTyp % 10;
  WITH->Tim_Del++;
  K0 = (long)WITH->Tim_Del;
  if (K0 > 10000) {
    Detonate(I);
    return;
  }
  Boom = false;
  if (WITH->Prx_Del != 0) {
    for (J = 0; J < ObjCount; J++) {
      if (Objects[J] != NULL && J != I) {
	if (Objects[J]->ObTyp < 20 && WITH->Prx_Del >= Range(I, J) && J != M)
	  Boom = true;
      }
    }
  }
  if (Boom)
    Detonate(I);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movslq %edi, %r12
leaq 0xdded(%rip), %rsi      # 0x135f0
movq (%rsi,%r12,8), %r9
movswq 0x4a(%r9), %rax
movsd 0x30(%r9), %xmm0
addsd 0x7846(%rip), %xmm0     # 0xd060
movsd %xmm0, 0x30(%r9)
cvttsd2si %xmm0, %rcx
cmpl $0x2710, %ecx           # imm = 0x2710
jg 0x5958
movsd 0x28(%r9), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5847
jnp 0x596b
cmpb $0x0, 0xdd94(%rip)      # 0x135e2
je 0x596b
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
movl %eax, %r14d
movl %edi, 0x4(%rsp)
movl %edi, %ebp
xorl %r15d, %r15d
movsd 0x77b5(%rip), %xmm2     # 0xd038
xorpd %xmm3, %xmm3
movq %rsi, %rbx
xorl %r13d, %r13d
movq %r9, 0x8(%rsp)
movq (%rbx), %rax
testq %rax, %rax
sete %cl
cmpq %r15, %rbp
sete %dl
orb %cl, %dl
jne 0x5938
cmpw $0x13, 0x4a(%rax)
jg 0x5938
movsd 0x28(%r9), %xmm4
movq (%rbx), %rax
movapd %xmm2, %xmm0
testq %rax, %rax
je 0x591f
movsd 0x38(%rax), %xmm0
movq (%rsi,%r12,8), %rcx
subsd 0x38(%rcx), %xmm0
movsd 0x40(%rcx), %xmm1
subsd 0x40(%rax), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd %xmm3, %xmm0
jb 0x58f6
sqrtsd %xmm0, %xmm0
jmp 0x591f
movsd %xmm4, 0x10(%rsp)
callq 0x22f0
movsd 0x10(%rsp), %xmm4
xorpd %xmm3, %xmm3
movsd 0x7725(%rip), %xmm2     # 0xd038
movq 0x8(%rsp), %r9
leaq 0xdcd1(%rip), %rsi      # 0x135f0
cmpq %r15, %r14
movzbl %r13b, %eax
movl $0x1, %r13d
cmovel %eax, %r13d
ucomisd %xmm0, %xmm4
cmovbl %eax, %r13d
incq %r15
movzbl 0xdca0(%rip), %eax      # 0x135e2
addq $0x8, %rbx
cmpq %rax, %r15
jb 0x5892
testb %r13b, %r13b
movl 0x4(%rsp), %edi
je 0x596b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x54f1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hyc[P]trek73c/trekx.c
// Function: Detach
void Detach(I)
int I;
{
  int J;
  boolean Drop;

  Launch(I, &J);
  Drop = false;
  Objects[J]->Tim_Del = 10000 - 10 / Iter;
  Objects[J]->Fuel = Objects[I]->Fuel;
  Objects[I]->Fuel = 0.0;
  Objects[J]->ObTyp = I + 10;
  Ships[I]->Regen = 0.0;
  Ships[I]->Fcap = 0;
  Ships[I]->Weff = 10.0;
  Ships[I]->Dmge[(long)Engn] = true;
  Ships[I]->Dmge[(long)Prob] = true;
  for (J = 0; J < Phasers; J++) {
    if (Ships[I]->PChrg[J] > 0)
      Drop = true;
  }
  if (Drop) {
    for (J = 0; J <= 3; J++)
      Ships[I]->Seff[J] = 0.0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x4(%rsp), %r14
movq %r14, %rsi
callq 0x4f71
movsd 0x66de(%rip), %xmm0     # 0xd0f8
divsd 0xc78e(%rip), %xmm0     # 0x131b0
addsd 0x669e(%rip), %xmm0     # 0xd0c8
movslq (%r14), %rax
leaq 0xcbbc(%rip), %rcx      # 0x135f0
movq (%rcx,%rax,8), %rdx
movsd %xmm0, 0x30(%rdx)
movslq %ebx, %rax
movq (%rcx,%rax,8), %rcx
movsd 0x20(%rcx), %xmm0
movsd %xmm0, 0x20(%rdx)
xorl %esi, %esi
movq %rsi, 0x20(%rcx)
leal 0xa(%rax), %ecx
movw %cx, 0x4a(%rdx)
leaq 0xcf2e(%rip), %rcx      # 0x13990
movq (%rcx,%rax,8), %rdx
movq %rsi, (%rdx)
movb $0x0, 0x18(%rdx)
movabsq $0x4024000000000000, %rsi # imm = 0x4024000000000000
movq %rsi, 0x8(%rdx)
movb $0x1, %sil
movb %sil, 0xc4(%rdx)
movq (%rcx,%rax,8), %rdx
movb %sil, 0xc2(%rdx)
movzbl 0xc729(%rip), %edx      # 0x131c0
testl %edx, %edx
je 0x6af7
movq (%rcx,%rax,8), %rsi
movl %edx, %edi
xorl %r8d, %r8d
xorpd %xmm0, %xmm0
movl $0x1, %r10d
xorl %r9d, %r9d
movsd 0x20(%rsi,%r8,8), %xmm1
ucomisd %xmm0, %xmm1
movzbl %r9b, %r9d
cmoval %r10d, %r9d
incq %r8
cmpq %r8, %rdi
jne 0x6ab1
movl %edx, 0x4(%rsp)
testb %r9b, %r9b
je 0x6aff
movq (%rcx,%rax,8), %rax
xorpd %xmm0, %xmm0
movupd %xmm0, 0xb0(%rax)
movupd %xmm0, 0xa0(%rax)
movl $0x4, 0x4(%rsp)
jmp 0x6aff
movl $0x0, 0x4(%rsp)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/hyc[P]trek73c/trekx.c
// Function: Yes
boolean Yes()
{
  Char Ch;

  waddstr(Cmdwin,"? [Y/N] ");
  wrefresh(Cmdwin);
  Ch=wgetch(Cmdwin);
  waddstr(Cmdwin,"\n");
  wclrtoeol(Cmdwin);
  wrefresh(Cmdwin);
  if (toupper(Ch) == 'Y')
    return true;
  else
    return false;
}

// Assembly:
pushq %rbx
movq 0xbfd3(%rip), %rdi      # 0x139f8
leaq 0x6baa(%rip), %rsi      # 0xe5d6
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
movq 0xbfbb(%rip), %rdi      # 0x139f8
callq 0x2190
movq 0xbfaf(%rip), %rdi      # 0x139f8
callq 0x2300
movl %eax, %ebx
movq 0xbfa1(%rip), %rdi      # 0x139f8
leaq 0x61d3(%rip), %rsi      # 0xdc31
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
movq 0xbf89(%rip), %rdi      # 0x139f8
callq 0x2220
movq 0xbf7d(%rip), %rdi      # 0x139f8
callq 0x2190
callq 0x2110
movq (%rax), %rax
movsbq %bl, %rcx
cmpl $0x59, (%rax,%rcx,4)
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/hyc[P]trek73c/trekx.c
// Function: Getwarp
boolean Getwarp(ok)
boolean ok;
{
  double temp;
  short code;

  waddstr(Cmdwin,"\n   Warp factor [-9 to 9] ");
  mygetstr(Cmdwin,scrstr,true);
  code = (sscanf(scrstr, "%lg", &temp) == 0);
  if (code > 0) {
    ok = false;
    return ok;
  }
  if (fabs(temp) > 9) {
    ok = false;
    ChWhat();
  } else if ((fabs(temp) >= 1) && Ships[0]->Dmge[(int)Warp]) {
    ok=false;
    NoEngy();
  } else if (ok)
    Objects[0]->Des_Spd = temp;
  return ok;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movq 0xbe3b(%rip), %rdi      # 0x139f8
leaq 0x6ae6(%rip), %rsi      # 0xe6aa
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
movq 0xbe23(%rip), %rdi      # 0x139f8
leaq 0xb8d4(%rip), %r14      # 0x134b0
movq %r14, %rsi
movl $0x1, %edx
callq 0x249f
leaq 0x77b8(%rip), %rsi      # 0xf3a8
xorl %ebp, %ebp
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x20b0
testl %eax, %eax
je 0x7c5f
movsd 0x8(%rsp), %xmm0
movapd 0x55fd(%rip), %xmm1     # 0xd210
andpd %xmm0, %xmm1
ucomisd 0x5529(%rip), %xmm1     # 0xd148
jbe 0x7c28
callq 0x7add
jmp 0x7c5d
ucomisd 0x5430(%rip), %xmm1     # 0xd060
jb 0x7c49
movq 0xbd57(%rip), %rax      # 0x13990
cmpb $0x0, 0xc3(%rax)
je 0x7c49
callq 0x7b01
jmp 0x7c5d
testb %bl, %bl
je 0x7c5d
movq 0xb99c(%rip), %rax      # 0x135f0
movsd %xmm0, 0x8(%rax)
movl %ebx, %ebp
jmp 0x7c5f
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq