LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ParkerLab[P]cta/src/cta.cpp
// Function: operator>>(std::istream&, FASTQRecord&)
std::istream& operator>>(std::istream& is, FASTQRecord& record) {
    getline(is, record.name);
    getline(is, record.sequence);
    getline(is, record.comment);
    getline(is, record.quality);
    return is;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe0e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
callq 0xe0e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0xe0e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
callq 0xe0e0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ParkerLab[P]cta/src/cta.cpp
// Function: is_gzipped_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool is_gzipped_file(const std::string& filename) {
    bool gzipped = false;
    FILE* f = fopen(filename.c_str(), "rb");

    if (f == NULL) {
        throw FileException("Could not open file \"" + filename + "\": " + strerror(errno));
    } else {
        if (fgetc(f) == 0x1f && fgetc(f) == 0x8b) {
            gzipped = true;
        }
    }
    fclose(f);
    return gzipped;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe290
movq %rax, %rdi
leaq 0x52172(%rip), %rsi     # 0x61188
callq 0xe790
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xf13a
movb $0x1, -0x85(%rbp)
movl $0x10, %edi
callq 0xe310
movq %rax, -0x90(%rbp)
movq -0x8(%rbp), %rdx
leaq 0x5213e(%rip), %rsi     # 0x6118b
leaq -0x78(%rbp), %rdi
callq 0x12650
jmp 0xf058
leaq 0x52142(%rip), %rdx     # 0x611a1
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x12600
jmp 0xf06e
callq 0xe070
movl (%rax), %edi
callq 0xe1f0
movq %rax, %rdx
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x12600
jmp 0xf08c
movq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x12760
jmp 0xf09e
movq -0x90(%rbp), %rdi
movb $0x0, -0x85(%rbp)
leaq 0x7ff4d(%rip), %rsi     # 0x8f000
leaq 0x36e6(%rip), %rdx      # 0x127a0
callq 0xeb10
jmp 0xf17e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xf121
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xf118
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xf10f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xe400
leaq -0x58(%rbp), %rdi
callq 0xe400
leaq -0x78(%rbp), %rdi
callq 0xe400
testb $0x1, -0x85(%rbp)
jne 0xf12c
jmp 0xf138
movq -0x90(%rbp), %rdi
callq 0xe4c0
jmp 0xf175
movq -0x18(%rbp), %rdi
callq 0xea10
cmpl $0x1f, %eax
jne 0xf15c
movq -0x18(%rbp), %rdi
callq 0xea10
cmpl $0x8b, %eax
jne 0xf15c
movb $0x1, -0x9(%rbp)
jmp 0xf15e
movq -0x18(%rbp), %rdi
callq 0xe620
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0xeb80
nop
// File: ParkerLab[P]cta/src/cta.cpp
// Function: complement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string complement(const std::string& seq) {
    std::string complemented;
    for (const auto it : seq) {
        complemented += nucleotide_complements.at(it);
    }
    return complemented;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xe8d0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe5d0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xec20
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x12bb0
testb $0x1, %al
jne 0xf2f9
jmp 0xf353
leaq -0x28(%rbp), %rdi
callq 0x12bf0
movb (%rax), %al
movb %al, -0x31(%rbp)
leaq 0x8390a(%rip), %rdi     # 0x92c18
leaq -0x31(%rbp), %rsi
callq 0x12c10
movq %rax, -0x60(%rbp)
jmp 0xf31d
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rax
movsbl (%rax), %esi
callq 0xe420
jmp 0xf32f
jmp 0xf331
leaq -0x28(%rbp), %rdi
callq 0x12cb0
jmp 0xf2e6
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0xe400
jmp 0xf370
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xf366
movq -0x58(%rbp), %rdi
callq 0xe400
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xeb80
nopl (%rax)
// File: ParkerLab[P]cta/src/cta.cpp
// Function: shares_kmer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
bool shares_kmer(const std::string& s1, const std::string& s2, int k) {
    // return true if any kmer from s1 is in s2, else false

    // get all s1 kmers
    std::unordered_set<std::string> kmers;
    for (int i = 0; i <= s1.size() - k; i++) {
        kmers.insert(s1.substr(i, k));
    }


    // check if any kmer from s2 is in the set
    for (int i = 0; i <= s2.size() - k; i++) {
        if (kmers.count(s2.substr(i, k)) > 0) {
            return true;
        }
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x12d10
movl $0x0, -0x5c(%rbp)
movslq -0x5c(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe480
movq %rax, %rcx
movq -0xd8(%rbp), %rax
movslq -0x1c(%rbp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
ja 0xf4ff
movq -0x10(%rbp), %rsi
movslq -0x5c(%rbp), %rdx
movslq -0x1c(%rbp), %rcx
leaq -0x80(%rbp), %rdi
callq 0xe670
jmp 0xf47b
leaq -0x58(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x12d30
movb %dl, -0xe1(%rbp)
movq %rax, -0xe0(%rbp)
jmp 0xf497
movb -0xe1(%rbp), %al
movq -0xe0(%rbp), %rcx
movq %rcx, -0xa0(%rbp)
movb %al, -0x98(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xe400
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0xf436
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xf5f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xe400
jmp 0xf5f4
movl $0x0, -0xa4(%rbp)
movslq -0xa4(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe480
movq %rax, %rcx
movq -0xf0(%rbp), %rax
movslq -0x1c(%rbp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
ja 0xf5cf
movq -0x18(%rbp), %rsi
movslq -0xa4(%rbp), %rdx
movslq -0x1c(%rbp), %rcx
leaq -0xc8(%rbp), %rdi
callq 0xe670
jmp 0xf557
leaq -0x58(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x12d70
movq %rax, -0xf8(%rbp)
jmp 0xf570
leaq -0xc8(%rbp), %rdi
callq 0xe400
movq -0xf8(%rbp), %rax
cmpq $0x0, %rax
jbe 0xf5b9
movb $0x1, -0x1(%rbp)
movl $0x1, -0xcc(%rbp)
jmp 0xf5dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0xe400
jmp 0xf5f4
jmp 0xf5bb
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0xf509
movb $0x0, -0x1(%rbp)
movl $0x1, -0xcc(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x12da0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x12da0
movq -0x88(%rbp), %rdi
callq 0xeb80
nopl (%rax)
// File: ParkerLab[P]cta/src/cta.cpp
// Function: getFileContent(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, bool>>>&)
bool getFileContent(std::string fileName, std::map<std::string,bool> & vecOfStrs)
{

	// Open the File
	std::ifstream in(fileName.c_str());

	// Check if object is valid
	if(!in)
		{
			std::cerr << "Cannot open the File : "<<fileName<<std::endl;
			return false;
		}

	std::string str;
	// Read the next line from File untill it reaches the end.
	while (std::getline(in, str))
		{
			// Line contains string of length > 0 then save it in vector
			if(str.size() > 0)
				vecOfStrs[str] = true;
		}
	//Close The File
	in.close();
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x260(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0xe290
movq %rax, %rsi
leaq -0x220(%rbp), %rdi
movl $0x8, %edx
callq 0xebf0
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0xe2f0
movb %al, -0x251(%rbp)
jmp 0x10ac3
movb -0x251(%rbp), %al
testb $0x1, %al
jne 0x10acf
jmp 0x10b46
movq 0x8150a(%rip), %rdi     # 0x91fe0
leaq 0x50dd9(%rip), %rsi     # 0x618b6
callq 0xe610
movq %rax, -0x268(%rbp)
jmp 0x10aeb
movq -0x260(%rbp), %rsi
movq -0x268(%rbp), %rdi
callq 0xe580
movq %rax, -0x270(%rbp)
jmp 0x10b07
movq -0x270(%rbp), %rdi
movq 0x8140b(%rip), %rsi     # 0x91f20
callq 0xe690
jmp 0x10b1c
movb $0x0, -0x1(%rbp)
movl $0x1, -0x230(%rbp)
jmp 0x10c1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x10c36
leaq -0x250(%rbp), %rdi
callq 0xe8d0
leaq -0x220(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0xe0e0
movq %rax, -0x278(%rbp)
jmp 0x10b6e
movq -0x278(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xe810
movb %al, -0x279(%rbp)
jmp 0x10b8c
movb -0x279(%rbp), %al
testb $0x1, %al
jne 0x10b98
jmp 0x10bf4
leaq -0x250(%rbp), %rdi
callq 0xe480
cmpq $0x0, %rax
jbe 0x10bef
movq -0x18(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x13240
movq %rax, -0x288(%rbp)
jmp 0x10bc3
movq -0x288(%rbp), %rax
movb $0x1, (%rax)
jmp 0x10bef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x250(%rbp), %rdi
callq 0xe400
jmp 0x10c36
jmp 0x10b52
leaq -0x220(%rbp), %rdi
callq 0xe100
jmp 0x10c02
movb $0x1, -0x1(%rbp)
movl $0x1, -0x230(%rbp)
leaq -0x250(%rbp), %rdi
callq 0xe400
leaq -0x220(%rbp), %rdi
callq 0xe150
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
leaq -0x220(%rbp), %rdi
callq 0xe150
movq -0x228(%rbp), %rdi
callq 0xeb80
nop
// File: ParkerLab[P]cta/src/cta.cpp
// Function: FASTQRecord::append_barcode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void append_barcode(const std::string& barcode) {
        if (name.find(' ')!=std::string::npos) {
                name.insert(name.find(' '), "_" + barcode);
        } else {
                name += "_" + barcode;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movl $0x20, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xe880
cmpq $-0x1, %rax
je 0x13f32
movq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x20, %esi
callq 0xe880
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x4da7e(%rip), %rsi     # 0x6196e
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x12650
movq -0x68(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0xea50
jmp 0x13f10
leaq -0x30(%rbp), %rdi
callq 0xe400
jmp 0x13f7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xe400
jmp 0x13f84
movq -0x10(%rbp), %rdx
leaq 0x4da31(%rip), %rsi     # 0x6196e
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x12650
movq -0x68(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0xe830
jmp 0x13f59
leaq -0x60(%rbp), %rdi
callq 0xe400
jmp 0x13f7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xe400
jmp 0x13f84
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xeb80
nopl (%rax)
// File: CK7[P]abawaca/src/ReadMappingReader.cpp
// Function: Bio::VectorReader::next_mapping()
ReadMapping* VectorReader::next_mapping()
{
        ReadMapping* r = NULL;

        if(it==read_mappings.end())
                return NULL;

        try {
                r = new ReadMapping(*(*(it)));
        }
        catch(exception& e) {
		throw Software_bug("Failed to allocate new ReadMapping", "", __PRETTY_FUNCTION__);
        }
	it++;

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movq $0x0, -0x18(%rbp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x98(%rbp)
addq $0x8, %rdi
callq 0x8de0
movq -0x98(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x8da0
testb $0x1, %al
jne 0x85a3
jmp 0x85b0
movq $0x0, -0x8(%rbp)
jmp 0x8777
movl $0xe8, %edi
callq 0x4310
movq %rax, -0xa8(%rbp)
jmp 0x85c3
movq -0xa0(%rbp), %rdi
addq $0x20, %rdi
callq 0x8e10
movq -0xa8(%rbp), %rdi
movq (%rax), %rsi
callq 0x8e30
jmp 0x85e4
movq -0xa8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x8756
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x861a
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x42c0
movl -0x2c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x8784
movq -0x28(%rbp), %rdi
callq 0x4120
movq %rax, -0x38(%rbp)
movb $0x1, -0x82(%rbp)
movl $0x28, %edi
callq 0x4170
movq %rax, -0xb8(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x45d0
movq -0xb0(%rbp), %rdx
leaq 0x19c83(%rip), %rsi     # 0x222f0
leaq -0x58(%rbp), %rdi
callq 0x4470
jmp 0x8678
leaq -0x81(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x45d0
movq -0xc0(%rbp), %rdx
leaq 0x19bd3(%rip), %rsi     # 0x2226c
leaq -0x80(%rbp), %rdi
callq 0x4470
jmp 0x86a4
movq -0xb8(%rbp), %rdi
leaq 0x19c61(%rip), %rcx     # 0x22313
leaq -0x58(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x8fc0
jmp 0x86c1
movq -0xb8(%rbp), %rdi
movb $0x0, -0x82(%rbp)
leaq 0x291ba(%rip), %rsi     # 0x31890
leaq 0xed3(%rip), %rdx       # 0x95b0
callq 0x4590
jmp 0x8795
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x872d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x8718
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x41c0
leaq -0x81(%rbp), %rdi
callq 0x4370
leaq -0x58(%rbp), %rdi
callq 0x41c0
leaq -0x59(%rbp), %rdi
callq 0x4370
testb $0x1, -0x82(%rbp)
jne 0x8741
jmp 0x874d
movq -0xb8(%rbp), %rdi
callq 0x4220
callq 0x4570
jmp 0x8754
jmp 0x8784
movq -0xa0(%rbp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
callq 0x95f0
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x45c0
movq %rax, %rdi
callq 0x7470
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/ReadMappingReader.cpp
// Function: Bio::FileReader::restart()
void FileReader::restart()
{
	if(m_fp)
		fclose(m_fp);
	if((m_fp = fopen(this->file_name().c_str(), "r")) == NULL)
		throw Bio::Bad_file(this->file_name(), "Failed to re-open file", __PRETTY_FUNCTION__);
	m_total_to_read = filesize(m_file_name.c_str());
	m_total_read = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x89cb
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4300
movq -0x68(%rbp), %rdi
callq 0x9e50
movq %rax, %rdi
callq 0x4130
movq %rax, %rdi
leaq 0x19964(%rip), %rsi     # 0x2234a
callq 0x43b0
movq -0x68(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x8ae5
movb $0x1, -0x5a(%rbp)
movl $0x28, %edi
callq 0x4170
movq -0x68(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x9e50
movq %rax, -0x70(%rbp)
jmp 0x8a1e
movq -0x70(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x4140
jmp 0x8a2d
leaq -0x59(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x45d0
movq -0x80(%rbp), %rdx
leaq 0x19943(%rip), %rsi     # 0x22388
leaq -0x58(%rbp), %rdi
callq 0x4470
jmp 0x8a50
movq -0x78(%rbp), %rdi
leaq 0x19944(%rip), %rcx     # 0x2239f
xorl %eax, %eax
movl %eax, %r8d
leaq -0x28(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x9650
jmp 0x8a6f
movq -0x78(%rbp), %rdi
movb $0x0, -0x5a(%rbp)
leaq 0x28f4a(%rip), %rsi     # 0x319c8
leaq 0x13ab(%rip), %rdx      # 0x9e30
callq 0x4590
jmp 0x8b1f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x8ad2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x8ac0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x41c0
leaq -0x59(%rbp), %rdi
callq 0x4370
leaq -0x28(%rbp), %rdi
callq 0x41c0
testb $0x1, -0x5a(%rbp)
jne 0x8ada
jmp 0x8ae3
movq -0x78(%rbp), %rdi
callq 0x4220
jmp 0x8b16
movq -0x68(%rbp), %rdi
addq $0x10, %rdi
callq 0x4130
movq %rax, %rdi
callq 0x1f4c0
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, 0x30(%rax)
movq $0x0, 0x38(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x45c0
nop
// File: CK7[P]abawaca/src/abawaca-build.cpp
// Function: Scaf_segment::add_mapped_read(Bio::ReadMapping const&, unsigned long)
void Scaf_segment::add_mapped_read(const Bio::ReadMapping& rmapped, size_t dimension)
{
	if(dimensions.size() <= dimension)
		dimensions.resize(dimension+1);

	size_t s = (rmapped.ref_pos() < start)? start : rmapped.ref_pos();
	size_t e = ((rmapped.ref_pos()+rmapped.read_length()-1) > end)? end : (rmapped.ref_pos()+rmapped.read_length()-1);
	dimensions[dimension] += double(e-s+1)/(this->end-this->start+1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x78, %rdi
callq 0x10660
cmpq -0x18(%rbp), %rax
ja 0xba90
movq -0x30(%rbp), %rdi
addq $0x78, %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x102d0
movq -0x10(%rbp), %rdi
callq 0x10680
movq -0x30(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jae 0xbab1
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xbabe
movq -0x10(%rbp), %rdi
callq 0x10680
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10680
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x106a0
movq -0x30(%rbp), %rcx
movq %rax, %rdx
movq -0x40(%rbp), %rax
addq %rdx, %rax
subq $0x1, %rax
cmpq 0x50(%rcx), %rax
jbe 0xbb02
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xbb2a
movq -0x10(%rbp), %rdi
callq 0x10680
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x106a0
movq %rax, %rcx
movq -0x50(%rbp), %rax
addq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
incq %rax
movq %rax, %xmm0
movaps 0x16780(%rip), %xmm3    # 0x222d0
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x16784(%rip), %xmm2    # 0x222e0
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x48(%rdi), %rcx
movq 0x50(%rdi), %rax
subq %rcx, %rax
incq %rax
movq %rax, %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
addq $0x78, %rdi
movq -0x18(%rbp), %rsi
callq 0x10590
movsd -0x58(%rbp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: CK7[P]abawaca/src/abawaca-build.cpp
// Function: Scaf::add_mapped_read(Bio::ReadMapping const&, unsigned long)
void Scaf::add_mapped_read(const Bio::ReadMapping& rmapped, size_t dimension)
{
	size_t s=rmapped.ref_pos(), e=rmapped.ref_pos()+rmapped.read_length()-1;
	for(auto it=segment_coords.begin(); it!=segment_coords.end(); it++) {
		if(s > it->second)
			continue;
		if(e < it->first)
			break;
		segments[it-segment_coords.begin()]->add_mapped_read(rmapped, dimension);
	}

	if(dimension == this_sample)
		this->nbps += rmapped.read_length();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10680
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10680
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x106a0
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movq -0x50(%rbp), %rax
addq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
addq $0x48, %rdi
callq 0x10aa0
movq %rax, -0x30(%rbp)
movq -0x58(%rbp), %rdi
addq $0x48, %rdi
callq 0x10b10
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x10ad0
testb $0x1, %al
jne 0xc479
jmp 0xc511
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10b40
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq 0x8(%rcx), %rax
jbe 0xc499
jmp 0xc4fd
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10b40
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq (%rcx), %rax
jae 0xc4b8
jmp 0xc511
movq -0x58(%rbp), %rdi
movq %rdi, %rax
addq $0x60, %rax
movq %rax, -0x70(%rbp)
addq $0x48, %rdi
callq 0x10aa0
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x10b80
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x10b60
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xba50
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x10bc0
movq %rax, -0x48(%rbp)
jmp 0xc452
movq -0x18(%rbp), %rax
cmpq 0x25edc(%rip), %rax     # 0x323f8
jne 0xc536
movq -0x10(%rbp), %rdi
callq 0x106a0
movq %rax, %rcx
movq -0x58(%rbp), %rax
addq 0x78(%rax), %rcx
movq %rcx, 0x78(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: CK7[P]abawaca/src/abawaca-build.cpp
// Function: Links::~Links()
Links::~Links()
{
	set<Links::Link*> links_to_delete;

	for(auto it=links.begin(); it!=links.end(); it++) {
		for(auto sit=it->second.begin(); sit!=it->second.end(); sit++) {
			links_to_delete.insert(sit->second);
		}
	}

	for(auto sit=links_to_delete.begin(); sit!=links_to_delete.end(); sit++)
		delete(*sit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x10c00
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x10c20
movq %rax, -0x40(%rbp)
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x10c80
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x10c50
testb $0x1, %al
jne 0xc5a1
jmp 0xc649
leaq -0x40(%rbp), %rdi
callq 0x10cb0
movq %rax, %rdi
addq $0x28, %rdi
callq 0x10cd0
movq %rax, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x10cb0
movq %rax, %rdi
addq $0x28, %rdi
callq 0x10d30
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x10d00
testb $0x1, %al
jne 0xc5e6
jmp 0xc633
leaq -0x50(%rbp), %rdi
callq 0x10db0
movq %rax, %rsi
addq $0x28, %rsi
leaq -0x38(%rbp), %rdi
callq 0x10d60
movb %dl, -0xa1(%rbp)
movq %rax, -0xa0(%rbp)
jmp 0xc60e
movb -0xa1(%rbp), %al
movq -0xa0(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movb %al, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x10dd0
movq %rax, -0x70(%rbp)
jmp 0xc5ba
jmp 0xc635
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x10e10
movq %rax, -0x78(%rbp)
jmp 0xc577
leaq -0x38(%rbp), %rdi
callq 0x10e50
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x10eb0
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x10e80
testb $0x1, %al
jne 0xc67c
jmp 0xc6c3
leaq -0x80(%rbp), %rdi
callq 0x10ee0
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
cmpq $0x0, %rax
je 0xc6ad
movq -0xb0(%rbp), %rdi
callq 0x10f00
movq -0xb0(%rbp), %rdi
callq 0x42c0
jmp 0xc6af
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
callq 0x10f30
movq %rax, -0x90(%rbp)
jmp 0xc656
leaq -0x38(%rbp), %rdi
callq 0x10f70
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x10f90
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x7470
nopl (%rax)
// File: negativeview[P]Software-Business-Sim/NamedObject.cpp
// Function: NamedObject::NamedObject(char const*, char const*)
NamedObject::NamedObject(const char *tag, const char *fullName) {
	this->_tag = (char *)malloc(strlen(tag) + 1);
	strcpy(this->_tag, tag);

	this->_fullName = (char *)malloc(strlen(fullName) + 1);
	strcpy(this->_fullName, fullName);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x34d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3350
movq -0x18(%rbp), %rdi
callq 0x31a0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x34d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3350
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: negativeview[P]Software-Business-Sim/NameContainer.cpp
// Function: NameContainer::NameContainer()
NameContainer::NameContainer() {
	this->_firstNames = new vector<const char *>();
	this->_lastNames = new vector<const char *>();

	this->_setupLastNames();
	this->_setupFirstNames();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x18, %edi
callq 0x3370
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x31e0
movq -0x20(%rbp), %rdi
callq 0x65b0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x18, %edi
callq 0x3370
movq %rax, %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x31e0
movq -0x18(%rbp), %rdi
callq 0x65b0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq %rax, 0x8(%rdi)
callq 0x5870
movq -0x10(%rbp), %rdi
callq 0x5e20
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: negativeview[P]Software-Business-Sim/CommandList.cpp
// Function: CommandList::executeCommand(char const*)
void CommandList::executeCommand(const char *command) {
	if (command[0] != '\0') {
		int found = 0;
		for (vector<CommandFunctor *>::iterator it = this->_commands->begin(); it != this->_commands->end(); ++it) {
			CommandFunctor *commandFunctor = *it;
			string prefix = commandFunctor->getPrefix();

			if (strncmp(prefix.c_str(), command, strlen(prefix.c_str())) == 0) {
				commandFunctor->executeCommand(command);
				return;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x749f
movq -0x68(%rbp), %rax
movl $0x0, -0x14(%rbp)
movq (%rax), %rdi
callq 0x7520
movq %rax, -0x20(%rbp)
movq -0x68(%rbp), %rax
movq (%rax), %rdi
callq 0x7590
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7550
testb $0x1, %al
jne 0x73e8
jmp 0x749d
leaq -0x20(%rbp), %rdi
callq 0x75c0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xa9e0
leaq -0x50(%rbp), %rdi
callq 0x3180
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3180
movq %rax, %rdi
callq 0x31a0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq %rax, %rdx
callq 0x31b0
cmpl $0x0, %eax
jne 0x7472
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0x7452
movl $0x1, -0x60(%rbp)
jmp 0x7479
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3210
jmp 0x74a8
movl $0x0, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3210
movl -0x60(%rbp), %eax
testl %eax, %eax
je 0x748d
jmp 0x748b
jmp 0x749f
jmp 0x748f
leaq -0x20(%rbp), %rdi
callq 0x75e0
jmp 0x73c2
jmp 0x749f
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x35d0
nopw %cs:(%rax,%rax)
// File: negativeview[P]Software-Business-Sim/Project.cpp
// Function: Project::Project(Company*, Language*, Platform*, Market*)
Project::Project(Company *company, Language *language, Platform *platform, Market *market) {
	this->_company = company;
	this->_platform = platform;
	this->_language = language;
	this->_market = market;
	this->_percentDone = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl $0x0, 0x20(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: negativeview[P]Software-Business-Sim/HireCommand.cpp
// Function: HireCommand::doHireMenu()
Person *HireCommand::doHireMenu() {
	Person *ret = NULL;

	int n_choices = this->_masterState->getPlayerCompany()->getKnownPeople()->size();
    keypad(stdscr, TRUE);
	MENU *my_menu = this->setupMenu((vector<NamedObject *> *)(this->_masterState->getPlayerCompany()->getKnownPeople()));
	WINDOW *my_menu_win = this->setupWindow(my_menu, "Applicants");
	refresh();

    int c;
    int done = 0;
	while(!done) {
		c = wgetch(my_menu_win);
		switch(c) {
			case KEY_DOWN:
				menu_driver(my_menu, REQ_DOWN_ITEM);
				break;
			case KEY_UP:
				menu_driver(my_menu, REQ_UP_ITEM);
				break;
			case 10:	// Enter key, select the user.
				{
					ITEM *currentItem = current_item(my_menu);
					ret = (Person *)item_userptr(currentItem);
					done = 1;
				}
				break;
			case 27:
				done = 1;
				break;
		}
		wrefresh(my_menu_win);
	}

	/* Unpost and free all the memory taken up */
	unpost_menu(my_menu);

	ITEM **my_items = menu_items(my_menu);
	for(int i = 0; i < n_choices; ++i)
		free_item(my_items[i]);
	endwin();
	free_menu(my_menu);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x12e20
movq %rax, %rdi
callq 0xbfd0
movq %rax, %rdi
callq 0x4060
movl %eax, -0x14(%rbp)
movq 0x1bdf1(%rip), %rax     # 0x23fd0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x3140
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x12e20
movq %rax, %rdi
callq 0xbfd0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xaa40
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq 0xfef1(%rip), %rdx      # 0x18111
callq 0xab50
movq %rax, -0x28(%rbp)
callq 0x35b0
movl $0x0, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8247
jmp 0x82da
movq -0x28(%rbp), %rdi
callq 0x3130
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x54(%rbp)
subl $0xa, %eax
je 0x82a2
jmp 0x8260
movl -0x54(%rbp), %eax
subl $0x1b, %eax
je 0x82c5
jmp 0x826a
movl -0x54(%rbp), %eax
subl $0x102, %eax            # imm = 0x102
je 0x8282
jmp 0x8276
movl -0x54(%rbp), %eax
subl $0x103, %eax            # imm = 0x103
je 0x8292
jmp 0x82cc
movq -0x20(%rbp), %rdi
movl $0x203, %esi            # imm = 0x203
callq 0x32d0
jmp 0x82cc
movq -0x20(%rbp), %rdi
movl $0x202, %esi            # imm = 0x202
callq 0x32d0
jmp 0x82cc
movq -0x20(%rbp), %rdi
callq 0x3560
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3580
movq %rax, -0x10(%rbp)
movl $0x1, -0x30(%rbp)
jmp 0x82cc
movl $0x1, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3430
jmp 0x8235
movq -0x20(%rbp), %rdi
callq 0x3290
movq -0x20(%rbp), %rdi
callq 0x30d0
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x831b
movq -0x40(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3470
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x82f7
callq 0x3450
movq -0x20(%rbp), %rdi
callq 0x3110
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: negativeview[P]Software-Business-Sim/HireCommand.cpp
// Function: HireCommand::doGetWage(Person*)
int HireCommand::doGetWage(Person *p) {
	FIELD *field[2];
	FORM *my_form;

	field[0] = new_field(1, 10, 4, 35, 0, 0);
	field[1] = NULL;

	set_field_back(field[0], A_UNDERLINE);
	field_opts_off(field[0], O_AUTOSKIP);
	set_field_type(field[0], TYPE_INTEGER, 0, 1, 1000000);

	my_form = new_form(field);
	post_form(my_form);
	refresh();

	mvprintw(4, 10, "Offer Amount (per year):");
	refresh();

	int ch;
	while (true) {
		ch = getch();
		switch(ch) {
			case KEY_DOWN:
				form_driver(my_form, REQ_NEXT_FIELD);
				form_driver(my_form, REQ_END_LINE);
				break;
			case KEY_UP:
				form_driver(my_form, REQ_PREV_FIELD);
				form_driver(my_form, REQ_END_LINE);
				break;
//			case KEY_DEL:
//				form_driver(my_form, REQ_DEL_PREV);
//				break;
			case 10:
				{
					// Lame attempt to force the buffer to be filled out.
					form_driver(my_form, REQ_NEXT_FIELD);

					char *buffer = field_buffer(field[0], 0);
					return atoi(buffer);
				}
				break;
			default:
				form_driver(my_form, ch);
				break;
		}
	}

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0xa, %esi
movl $0x4, %edx
movl $0x23, %ecx
xorl %r9d, %r9d
movl %r9d, %r8d
callq 0x3150
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movl $0x20000, %esi          # imm = 0x20000
callq 0x34e0
movq -0x20(%rbp), %rdi
movl $0x40, %esi
callq 0x30c0
movq -0x20(%rbp), %rdi
movq 0x1bc36(%rip), %rax     # 0x23fd8
movq (%rax), %rsi
xorl %edx, %edx
movl $0x1, %ecx
movl $0xf4240, %r8d          # imm = 0xF4240
movb $0x0, %al
callq 0x35f0
leaq -0x20(%rbp), %rdi
callq 0x3530
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3340
callq 0x35b0
movl $0x4, %edi
movl $0xa, %esi
leaq 0x10099(%rip), %rdx     # 0x1847e
movb $0x0, %al
callq 0x34c0
callq 0x35b0
movq 0x1bbd8(%rip), %rax     # 0x23fd0
movq (%rax), %rdi
callq 0x3130
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x3c(%rbp)
subl $0xa, %eax
je 0x8464
jmp 0x8410
movl -0x3c(%rbp), %eax
subl $0x102, %eax            # imm = 0x102
je 0x8428
jmp 0x841c
movl -0x3c(%rbp), %eax
subl $0x103, %eax            # imm = 0x103
je 0x8446
jmp 0x8490
movq -0x28(%rbp), %rdi
movl $0x204, %esi            # imm = 0x204
callq 0x3610
movq -0x28(%rbp), %rdi
movl $0x219, %esi            # imm = 0x219
callq 0x3610
jmp 0x849c
movq -0x28(%rbp), %rdi
movl $0x205, %esi            # imm = 0x205
callq 0x3610
movq -0x28(%rbp), %rdi
movl $0x219, %esi            # imm = 0x219
callq 0x3610
jmp 0x849c
movq -0x28(%rbp), %rdi
movl $0x204, %esi            # imm = 0x204
callq 0x3610
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x3500
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3570
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x3610
jmp 0x83f1
nopw %cs:(%rax,%rax)
// File: negativeview[P]Software-Business-Sim/ProjectCommand.cpp
// Function: ProjectCommand::executeCommand(char const*)
void ProjectCommand::executeCommand(const char *line) {
	Language *language = this->languageChoiceMenu();
	if (language == NULL)
		return;

	Platform *platform = this->platformChoiceMenu();
	if (platform == NULL)
		return;

	Market *market = this->marketChoiceMenu();
	if (market == NULL)
		return;

	Project *project = new Project(this->_masterState->getPlayerCompany(), language, platform, market);
	this->_masterState->getPlayerCompany()->addProject(project);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xaca0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x95dd
jmp 0x9669
movq -0x48(%rbp), %rdi
callq 0xae30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x95f3
jmp 0x9669
movq -0x48(%rbp), %rdi
callq 0xafc0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9609
jmp 0x9669
movl $0x28, %edi
callq 0x3370
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq 0x8(%rax), %rdi
callq 0x12e20
movq %rax, -0x50(%rbp)
jmp 0x962d
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x7fb0
jmp 0x9648
movq -0x48(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rdi
callq 0x12e20
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0xb640
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x28, %esi
callq 0x3390
movq -0x38(%rbp), %rdi
callq 0x35d0
nopw %cs:(%rax,%rax)
// File: negativeview[P]Software-Business-Sim/CommandFunctor.cpp
// Function: CommandFunctor::setupMenu(std::vector<NamedObject*, std::allocator<NamedObject*>>*)
MENU *CommandFunctor::setupMenu(vector<NamedObject *> *people) {
    int n_choices = people->size();
    ITEM **my_items = (ITEM **)calloc(n_choices + 1, sizeof(ITEM *));

    int i = 0;
    for (vector<NamedObject *>::iterator it = people->begin(); it != people->end(); ++it) {
    	NamedObject *p = *it;
    	my_items[i] = new_item(p->getTag(), p->getFullName());
    	set_item_userptr(my_items[i], p);
    	i++;
    }
    // Add the sigil.
    my_items[i] = new_item(NULL, NULL);

	MENU *my_menu = new_menu((ITEM **)my_items);

	return my_menu;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb340
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x3230
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb360
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb3d0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb390
testb $0x1, %al
jne 0xaaa7
jmp 0xab14
leaq -0x30(%rbp), %rdi
callq 0xb400
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x5770
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rdi
callq 0x5790
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x33a0
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x40(%rbp), %rsi
callq 0x3160
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xb420
jmp 0xaa87
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x33a0
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdi
callq 0x31f0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: negativeview[P]Software-Business-Sim/CommandFunctor.cpp
// Function: CommandFunctor::setupWindow(tagMENU*, char const*)
WINDOW *CommandFunctor::setupWindow(MENU *my_menu, const char *title) {
	WINDOW *my_menu_win = newwin(10, 40, 4, 4);
	keypad(my_menu_win, TRUE);

    set_menu_win(my_menu, my_menu_win);
    set_menu_sub(my_menu, derwin(my_menu_win, 6, 38, 3, 1));

    box(my_menu_win, 0, 0);
    mvwprintw(my_menu_win, 1, 2, title);
	mvwaddch(my_menu_win, 2, 0, ACS_LTEE);
	mvwhline(my_menu_win, 2, 1, ACS_HLINE, 38);
	mvwaddch(my_menu_win, 2, 39, ACS_RTEE);

	post_menu(my_menu);
	wrefresh(my_menu_win);

	return my_menu_win;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xa, %edi
movl $0x28, %esi
movl $0x4, %ecx
movl %ecx, %edx
callq 0x33b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x3140
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3220
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl $0x6, %esi
movl $0x26, %edx
movl $0x3, %ecx
movl $0x1, %r8d
callq 0x32a0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x3070
movq -0x20(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x3620
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x1, %esi
movl $0x2, %edx
movb $0x0, %al
callq 0x30b0
movq -0x20(%rbp), %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x33c0
cmpl $-0x1, %eax
jne 0xac08
jmp 0xac1e
movq -0x20(%rbp), %rdi
movq 0x193a5(%rip), %rax     # 0x23fb8
movl 0x1d0(%rax), %esi
callq 0x3100
movq -0x20(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x33c0
cmpl $-0x1, %eax
jne 0xac38
jmp 0xac53
movq -0x20(%rbp), %rdi
movq 0x19375(%rip), %rax     # 0x23fb8
movl 0x1c4(%rax), %esi
movl $0x26, %edx
callq 0x3310
movq -0x20(%rbp), %rdi
movl $0x2, %esi
movl $0x27, %edx
callq 0x33c0
cmpl $-0x1, %eax
jne 0xac6d
jmp 0xac83
movq -0x20(%rbp), %rdi
movq 0x19340(%rip), %rax     # 0x23fb8
movl 0x1d4(%rax), %esi
callq 0x3100
movq -0x10(%rbp), %rdi
callq 0x3510
movq -0x20(%rbp), %rdi
callq 0x3430
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: negativeview[P]Software-Business-Sim/CommandFunctor.cpp
// Function: CommandFunctor::languageChoiceMenu()
Language *CommandFunctor::languageChoiceMenu() {
	Language *ret = NULL;

	int n_choices = this->_masterState->getLanguages()->size();
    keypad(stdscr, TRUE);
	MENU *my_menu = this->setupMenu((vector<NamedObject *> *)(this->_masterState->getLanguages()));
	WINDOW *my_menu_win = this->setupWindow(my_menu, "Language");
	refresh();

    int c;
    int done = 0;
	while(!done) {
		c = wgetch(my_menu_win);
		switch(c) {
			case KEY_DOWN:
				menu_driver(my_menu, REQ_DOWN_ITEM);
				break;
			case KEY_UP:
				menu_driver(my_menu, REQ_UP_ITEM);
				break;
			case 10:	// Enter key, select the user.
				{
					ITEM *currentItem = current_item(my_menu);
					ret = (Language *)item_userptr(currentItem);
					done = 1;
				}
				break;
			case 27:
				done = 1;
				break;
		}
		wrefresh(my_menu_win);
	}

	/* Unpost and free all the memory taken up */
	unpost_menu(my_menu);

	ITEM **my_items = menu_items(my_menu);
	for(int i = 0; i < n_choices; ++i)
		free_item(my_items[i]);
	endwin();
	free_menu(my_menu);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x12e00
movq %rax, %rdi
callq 0xb440
movl %eax, -0x14(%rbp)
movq 0x192f9(%rip), %rax     # 0x23fd0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x3140
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x12e00
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xaa40
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq 0xda64(%rip), %rdx      # 0x18774
callq 0xab50
movq %rax, -0x28(%rbp)
callq 0x35b0
movl $0x0, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xad37
jmp 0xadca
movq -0x28(%rbp), %rdi
callq 0x3130
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x54(%rbp)
subl $0xa, %eax
je 0xad92
jmp 0xad50
movl -0x54(%rbp), %eax
subl $0x1b, %eax
je 0xadb5
jmp 0xad5a
movl -0x54(%rbp), %eax
subl $0x102, %eax            # imm = 0x102
je 0xad72
jmp 0xad66
movl -0x54(%rbp), %eax
subl $0x103, %eax            # imm = 0x103
je 0xad82
jmp 0xadbc
movq -0x20(%rbp), %rdi
movl $0x203, %esi            # imm = 0x203
callq 0x32d0
jmp 0xadbc
movq -0x20(%rbp), %rdi
movl $0x202, %esi            # imm = 0x202
callq 0x32d0
jmp 0xadbc
movq -0x20(%rbp), %rdi
callq 0x3560
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3580
movq %rax, -0x10(%rbp)
movl $0x1, -0x30(%rbp)
jmp 0xadbc
movl $0x1, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3430
jmp 0xad25
movq -0x20(%rbp), %rdi
callq 0x3290
movq -0x20(%rbp), %rdi
callq 0x30d0
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xae0b
movq -0x40(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3470
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xade7
callq 0x3450
movq -0x20(%rbp), %rdi
callq 0x3110
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: negativeview[P]Software-Business-Sim/CommandFunctor.cpp
// Function: CommandFunctor::platformChoiceMenu()
Platform *CommandFunctor::platformChoiceMenu() {
	Platform *ret = NULL;

	int n_choices = this->_masterState->getPlatforms()->size();
    keypad(stdscr, TRUE);
	MENU *my_menu = this->setupMenu((vector<NamedObject *> *)(this->_masterState->getPlatforms()));
	WINDOW *my_menu_win = this->setupWindow(my_menu, "Platform");
	refresh();

    int c;
    int done = 0;
	while(!done) {
		c = wgetch(my_menu_win);
		switch(c) {
			case KEY_DOWN:
				menu_driver(my_menu, REQ_DOWN_ITEM);
				break;
			case KEY_UP:
				menu_driver(my_menu, REQ_UP_ITEM);
				break;
			case 10:	// Enter key, select the user.
				{
					ITEM *currentItem = current_item(my_menu);
					ret = (Platform *)item_userptr(currentItem);
					done = 1;
				}
				break;
			case 27:
				done = 1;
				break;
		}
		wrefresh(my_menu_win);
	}

	/* Unpost and free all the memory taken up */
	unpost_menu(my_menu);

	ITEM **my_items = menu_items(my_menu);
	for(int i = 0; i < n_choices; ++i)
		free_item(my_items[i]);
	endwin();
	free_menu(my_menu);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x12de0
movq %rax, %rdi
callq 0xb460
movl %eax, -0x14(%rbp)
movq 0x19169(%rip), %rax     # 0x23fd0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x3140
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x12de0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xaa40
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq 0xd8dd(%rip), %rdx      # 0x1877d
callq 0xab50
movq %rax, -0x28(%rbp)
callq 0x35b0
movl $0x0, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xaec7
jmp 0xaf5a
movq -0x28(%rbp), %rdi
callq 0x3130
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x54(%rbp)
subl $0xa, %eax
je 0xaf22
jmp 0xaee0
movl -0x54(%rbp), %eax
subl $0x1b, %eax
je 0xaf45
jmp 0xaeea
movl -0x54(%rbp), %eax
subl $0x102, %eax            # imm = 0x102
je 0xaf02
jmp 0xaef6
movl -0x54(%rbp), %eax
subl $0x103, %eax            # imm = 0x103
je 0xaf12
jmp 0xaf4c
movq -0x20(%rbp), %rdi
movl $0x203, %esi            # imm = 0x203
callq 0x32d0
jmp 0xaf4c
movq -0x20(%rbp), %rdi
movl $0x202, %esi            # imm = 0x202
callq 0x32d0
jmp 0xaf4c
movq -0x20(%rbp), %rdi
callq 0x3560
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3580
movq %rax, -0x10(%rbp)
movl $0x1, -0x30(%rbp)
jmp 0xaf4c
movl $0x1, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3430
jmp 0xaeb5
movq -0x20(%rbp), %rdi
callq 0x3290
movq -0x20(%rbp), %rdi
callq 0x30d0
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xaf9b
movq -0x40(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3470
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xaf77
callq 0x3450
movq -0x20(%rbp), %rdi
callq 0x3110
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)