LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x50(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movslq %edx, %r14
xorl %r12d, %r12d
movq %rsp, %r13
leaq 0x20(%rsp), %rbp
movq 0x8(%r15), %rax
subq %r14, %rax
cmpq %r12, %rax
jb 0xce4b
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0xc500
movq %rbp, %rdi
movq %r13, %rsi
callq 0x1cbda
movq %r13, %rdi
callq 0xc250
incq %r12
jmp 0xce16
xorl %eax, %eax
movq %rsp, %r15
movq %rax, %r13
movq 0x8(%rbx), %r12
subq %r14, %r12
cmpq %rax, %r12
jb 0xce91
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0xc500
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x1cfe4
movq %rax, %rbp
movq %r15, %rdi
callq 0xc250
leaq 0x1(%r13), %rax
testq %rbp, %rbp
je 0xce50
cmpq %r13, %r12
setae %bl
leaq 0x20(%rsp), %rdi
callq 0xf66e
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcebb
jmp 0xceb6
movq %rax, %rbx
jmp 0xcec6
movq %rax, %rbx
movq %rsp, %rdi
callq 0xc250
leaq 0x20(%rsp), %rdi
callq 0xf66e
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rsi
leaq 0x20(%rsp), %r15
pushq $0x8
popq %rdx
movq %r15, %rdi
callq 0xc870
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x40(%rsp,%rax), %ebp
testb $0x5, %bpl
je 0xd9d5
movq 0x3162c(%rip), %rdi     # 0x3efe0
leaq 0x18ebb(%rip), %rsi     # 0x26876
callq 0xc490
movq %rax, %rdi
movq %r14, %rsi
callq 0xc430
movq %rax, %rdi
callq 0xc270
jmp 0xda31
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x20(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xc0a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xda1f
cmpq $0x0, 0x8(%rsp)
je 0xd9ee
movq %rbx, %rdi
movq %r15, %rsi
callq 0xeede
movb $0x1, (%rax)
jmp 0xd9ee
leaq 0x20(%rsp), %rdi
callq 0xc0c0
movq %rsp, %rdi
callq 0xc250
testb $0x5, %bpl
sete %bl
leaq 0x20(%rsp), %rdi
callq 0xc110
movl %ebx, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xda59
movq %rax, %rbx
jmp 0xda64
movq %rax, %rbx
movq %rsp, %rdi
callq 0xc250
leaq 0x20(%rsp), %rdi
callq 0xc110
movq %rbx, %rdi
callq 0xc820
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x20
popq %rsi
xorl %edx, %edx
callq 0xc640
cmpq $-0x1, %rax
je 0xf522
pushq $0x20
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xc640
movq %rax, %r15
leaq 0x1742c(%rip), %rsi     # 0x2692e
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rdx
callq 0xec1c
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xc760
jmp 0xf544
leaq 0x17405(%rip), %rsi     # 0x2692e
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0xec1c
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc8e0
leaq 0x8(%rsp), %rdi
callq 0xc250
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xf55c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xc250
movq %rbx, %rdi
callq 0xc820
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x20(%rdi), %r15
cmpq 0x10(%rdi), %r15
je 0x5d0d
movq %rdi, %r14
movl $0xe8, %edi
callq 0x4280
movq %rax, %rbx
movq (%r15), %rsi
movq %rax, %rdi
callq 0x615a
addq $0x8, 0x20(%r14)
jmp 0x5d0f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x4250
jmp 0x5d33
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0x5ddf
movq %r14, %rdi
callq 0x4100
pushq $0x28
popq %rdi
callq 0x4150
movq %rax, %rbx
leaq 0x8599(%rip), %rsi      # 0xe2f0
leaq -0x60(%rbp), %rdi
leaq -0x1a(%rbp), %rdx
callq 0x40f0
leaq 0x84ff(%rip), %rsi      # 0xe26a
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x40f0
movb $0x1, %r15b
leaq 0x8591(%rip), %rcx      # 0xe313
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x6282
xorl %r15d, %r15d
leaq 0xeb7c(%rip), %rsi      # 0x14918
leaq 0x7af(%rip), %rdx       # 0x6552
movq %rbx, %rdi
callq 0x4490
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x4130
jmp 0x5dbf
movq %rax, %r14
movb $0x1, %r15b
leaq -0x60(%rbp), %rdi
callq 0x4130
testb %r15b, %r15b
jne 0x5dd2
jmp 0x5dda
movq %rax, %r14
movq %rbx, %rdi
callq 0x41d0
callq 0x4470
movq %r14, %rdi
callq 0x44b0
movq %rax, %rdi
callq 0x59c4
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x5f20
callq 0x4270
movq 0x10(%r14), %rdi
leaq 0x841f(%rip), %rsi      # 0xe34a
callq 0x4300
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x5f56
movq 0x10(%r14), %rdi
callq 0xcedf
movq %rax, 0x30(%r14)
andq $0x0, 0x38(%r14)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0x10, %r14
pushq $0x28
popq %rdi
callq 0x4150
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0x43a0
leaq 0x8410(%rip), %rsi      # 0xe388
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x40f0
movb $0x1, %r15b
leaq 0x8410(%rip), %rcx      # 0xe39f
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0x657c
xorl %r15d, %r15d
leaq 0xeaa4(%rip), %rsi      # 0x14a50
leaq 0xa47(%rip), %rdx       # 0x69fa
movq %rbx, %rdi
callq 0x4490
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x4130
jmp 0x5fcf
movq %rax, %r14
movb $0x1, %r15b
leaq -0x60(%rbp), %rdi
callq 0x4130
testb %r15b, %r15b
jne 0x5fe2
jmp 0x5fea
movq %rax, %r14
movq %rbx, %rdi
callq 0x41d0
movq %r14, %rdi
callq 0x44b0
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/abawaca-build.cpp
// Function: prepare_mer_indexes_recursive(int, 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>>, unsigned long, 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, unsigned long>>>&)
void prepare_mer_indexes_recursive(int k, string mer, map<string, size_t>& mer2index)
{
	if(k==0) {
		static int next_id = 0;
		auto it = mer2index.find(Bio::DNAString(mer).reverse_complement());
		if(it == mer2index.end()) {
			mer2index.insert(pair<string, size_t>(mer, next_id++));
			dimension_order.push_back(mer);
		}
		else {
			mer2index.insert(pair<string, size_t>(mer, it->second));
		}
		return;
	}

	static char acgt[] = {'A', 'C', 'G', 'T'};
	for(auto i=0; i<4; i++) {
		prepare_mer_indexes_recursive(k-1, mer+acgt[i], mer2index);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r13
testl %edi, %edi
je 0x6e25
movl %edi, %r15d
movq %r14, %rbx
movq %r13, %r14
decl %r15d
xorl %r13d, %r13d
leaq -0xb0(%rbp), %r12
cmpq $0x4, %r13
je 0x6ef8
leaq 0x7d87(%rip), %rax      # 0xeb80
movsbl (%r13,%rax), %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x9526
movl %r15d, %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x6db4
movq %r12, %rdi
callq 0x4130
incq %r13
jmp 0x6de8
leaq -0x90(%rbp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0xd1d0
leaq -0x70(%rbp), %rdi
movq %r15, %rsi
callq 0xd3d0
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x43a0
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0xa702
movq %rax, %r15
leaq -0x50(%rbp), %rdi
callq 0x4130
leaq -0x70(%rbp), %rdi
callq 0x4130
leaq -0x90(%rbp), %rdi
callq 0x4130
leaq 0x8(%r14), %rax
cmpq %rax, %r15
je 0x6eb2
addq $0x40, %r15
leaq -0x50(%rbp), %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x9508
movq %r14, %rdi
movq %r12, %rsi
callq 0xa78c
leaq -0x50(%rbp), %rdi
callq 0x4130
jmp 0x6ef8
movslq 0xe4af(%rip), %rbx      # 0x15368
leal 0x1(%rbx), %eax
movl %eax, 0xe4a6(%rip)      # 0x15368
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x43a0
movq %rbx, 0x20(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0xa78c
leaq -0x50(%rbp), %rdi
callq 0x4130
leaq 0xe458(%rip), %rdi      # 0x15348
movq %r13, %rsi
callq 0x94cc
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6f0c
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x6f47
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4130
jmp 0x6f26
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x4130
jmp 0x6f34
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
jmp 0x6f47
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x44b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x78(%rdi), %rax
movq 0x80(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rdx, %rcx
ja 0x7405
leaq 0x78(%r14), %r12
leaq 0x1(%rbx), %rsi
movq %r12, %rdi
callq 0x95b6
movq (%r12), %rax
movq 0x50(%r15), %rcx
movq 0x48(%r14), %rdx
cmpq %rdx, %rcx
movq %rdx, %rsi
cmovaq %rcx, %rsi
movq 0x90(%r15), %rdi
movq 0x50(%r14), %r8
addq %rdi, %rcx
decq %rcx
cmpq %r8, %rcx
cmovaeq %r8, %rcx
subq %rsi, %rcx
incq %rcx
movq %rcx, %xmm0
movq 0x6e8e(%rip), %xmm1     # 0xe2d0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x6e92(%rip), %xmm2     # 0xe2e0
subpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
subq %rdx, %r8
incq %r8
movq %r8, %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
subpd %xmm2, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd %xmm1, %xmm3
addsd (%rax,%rbx,8), %xmm3
movsd %xmm3, (%rax,%rbx,8)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50(%rsi), %r12
movq 0x90(%rsi), %rax
addq %r12, %rax
decq %rax
movq %rax, -0x38(%rbp)
movq 0x48(%rdi), %r13
movq %r13, %r15
cmpq 0x50(%rbx), %r15
je 0x788e
cmpq 0x8(%r15), %r12
ja 0x7884
movq -0x38(%rbp), %rax
cmpq (%r15), %rax
jb 0x788e
movq %r13, %rax
subq 0x48(%rbx), %rax
movq 0x60(%rbx), %rcx
sarq %rax
movq (%rcx,%rax), %rdi
movq %r14, %rsi
movq -0x30(%rbp), %rdx
callq 0x73c6
addq $0x10, %r15
addq $0x10, %r13
jmp 0x7851
movq -0x30(%rbp), %rax
cmpq %rax, 0xdac7(%rip)      # 0x15360
jne 0x78a6
movq 0x90(%r14), %rax
addq %rax, 0x78(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x58(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq 0x20(%rdi), %r15
movq %rdi, -0x30(%rbp)
leaq 0x10(%rdi), %rbx
leaq -0x60(%rbp), %r14
cmpq %rbx, %r15
je 0x7929
movq 0x60(%r15), %r12
leaq 0x50(%r15), %r13
cmpq %r13, %r12
je 0x791c
leaq 0x48(%r12), %rsi
movq %r14, %rdi
callq 0xb3fc
movq %r12, %rdi
callq 0x41c0
movq %rax, %r12
jmp 0x78fd
movq %r15, %rdi
callq 0x41c0
movq %rax, %r15
jmp 0x78f0
movq -0x48(%rbp), %r14
leaq -0x58(%rbp), %rbx
cmpq %rbx, %r14
je 0x795c
movq 0x20(%r14), %r15
testq %r15, %r15
je 0x7947
movq %r15, %rdi
callq 0x964e
movq %r15, %rdi
callq 0x4250
movq %r14, %rdi
callq 0x42e0
movq %rax, %r14
jmp 0x7931
movq -0x30(%rbp), %rbx
addq $0x8, %rbx
leaq -0x60(%rbp), %rdi
callq 0x9ec0
movq %rbx, %rdi
callq 0x9f16
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x59c4
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/abawaca-build.cpp
// Function: Links::write_connections(std::basic_ofstream<char, std::char_traits<char>>&) const
void Links::write_connections(ofstream& os) const
{
	set<Links::Link*> links_to_write;

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

	for(auto sit=links_to_write.begin(); sit!=links_to_write.end(); sit++)
		os << (*sit)->side1.seq << '\t' << (*sit)->side1.end << '\t' << (*sit)->side2.seq << '\t' << (*sit)->side2.end << '\t' << (*sit)->count << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x30(%rbp)
leaq -0x58(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq %rdi, %r14
movq 0x20(%rdi), %r15
addq $0x10, %r14
leaq -0x60(%rbp), %r12
cmpq %r14, %r15
je 0x7a01
movq 0x60(%r15), %r13
leaq 0x50(%r15), %rbx
cmpq %rbx, %r13
je 0x79f4
leaq 0x48(%r13), %rsi
movq %r12, %rdi
callq 0xb3fc
movq %r13, %rdi
callq 0x42e0
movq %rax, %r13
jmp 0x79d6
movq %r15, %rdi
callq 0x42e0
movq %rax, %r15
jmp 0x79c9
movq -0x48(%rbp), %r15
pushq $0x9
popq %r14
movq -0x30(%rbp), %rbx
leaq -0x58(%rbp), %r12
cmpq %r12, %r15
je 0x7aaa
movq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x4220
movq %rax, %rdi
movl %r14d, %esi
callq 0x42f0
movq 0x20(%r15), %rcx
movq 0x20(%rcx), %rsi
movq %rax, %rdi
callq 0x41b0
movq %rax, %rdi
movl %r14d, %esi
callq 0x42f0
movq 0x20(%r15), %rsi
addq $0x28, %rsi
movq %rax, %rdi
callq 0x4220
movq %rax, %rdi
movl %r14d, %esi
callq 0x42f0
movq 0x20(%r15), %rcx
movq 0x48(%rcx), %rsi
movq %rax, %rdi
callq 0x41b0
movq %rax, %rdi
movl %r14d, %esi
callq 0x42f0
movq 0x20(%r15), %rcx
movq 0x50(%rcx), %rsi
movq %rax, %rdi
callq 0x41b0
movq %rax, %rdi
callq 0x4140
movq %r15, %rdi
callq 0x42e0
movq %rax, %r15
jmp 0x7a11
leaq -0x60(%rbp), %rdi
callq 0x9ec0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7ac4
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x9ec0
movq %rbx, %rdi
callq 0x44b0
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/abawaca-build.cpp
// Function: calc_insert_size(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
size_t calc_insert_size(string sam_file)
{
	Bio::SAMReader  reader(sam_file);
	size_t s = 0;
	size_t	n = 0;

	while(reader.good() && (n<20000)) {
		Bio::ReadMappingPtr mapping(reader.next_mapping());
		if(mapping == NULL) {
			break;
		}

		// Note: bowtie2 computes the wrong TLEN for inserts connecting the two ends of a circular scaffold
		if(mapping->mapped() && mapping->pair_mapped() && (mapping->insert_size() > 0) && (mapping->direction() == Bio::ReadMapping::forward)) {
			s += mapping->insert_size();
			n++;
		}
	}

	return (n>0)? s/n : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rsi
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
callq 0x43a0
leaq -0xa0(%rbp), %rdi
movq %rbx, %rsi
callq 0x9734
leaq -0x60(%rbp), %rdi
callq 0x4130
leaq -0x38(%rbp), %r14
movq $0x0, -0x30(%rbp)
leaq -0xa0(%rbp), %r15
leaq -0x40(%rbp), %r12
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x6a2a
testb %al, %al
je 0x80fa
cmpq $0x4e1f, %r13           # imm = 0x4E1F
ja 0x80fa
movq %r15, %rdi
callq 0x5ff8
movq %r12, %rdi
movq %rax, %rsi
callq 0xbb6a
movq -0x40(%rbp), %rbx
testq %rbx, %rbx
je 0x80ed
movq 0x28(%rbx), %rax
testb $0xc, %al
jne 0x80ed
movslq 0x80(%rbx), %rcx
testq %rcx, %rcx
setle %dl
andl $0x10, %eax
shrl $0x4, %eax
orb %dl, %al
jne 0x80ed
addq %rcx, -0x30(%rbp)
incq %r13
movq %r14, %rdi
callq 0xa148
testq %rbx, %rbx
jne 0x8096
testq %r13, %r13
je 0x810d
movq -0x30(%rbp), %rax
xorl %edx, %edx
divq %r13
movq %rax, %rbx
jmp 0x810f
xorl %ebx, %ebx
leaq -0xa0(%rbp), %rdi
callq 0x6a8e
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x4130
jmp 0x814a
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x6a8e
movq %rbx, %rdi
callq 0x44b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3160
leaq 0x1(%rax), %rdi
callq 0x3410
movq %rax, (%r14)
movq %rax, %rdi
movq %r15, %rsi
callq 0x32e0
movq %rbx, %rdi
callq 0x3160
leaq 0x1(%rax), %rdi
callq 0x3410
movq %rax, 0x8(%r14)
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x32e0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x18
popq %r14
movq %r14, %rdi
callq 0x3300
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x3300
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x4330
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x46d2
nop
// File: /workspace/github_cpp_makefile_star2_O2/negativeview[P]Software-Business-Sim/CommandList.cpp
// Function: CommandList::CommandList(MasterState*)
CommandList::CommandList(MasterState *ms) {
	this->_commands = new vector<CommandFunctor *>();

	this->_commands->push_back(new EmployeesCommand(ms));
	this->_commands->push_back(new HireCommand(ms));
	this->_commands->push_back(new InterviewCommand(ms));
	this->_commands->push_back(new PeopleCommand(ms));
	this->_commands->push_back(new ProjectCommand(ms));
	this->_commands->push_back(new StatusCommand(ms));
	this->_commands->push_back(new WaitCommand(ms));
	this->_commands->push_back(new QuitCommand(ms));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x3300
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, (%r14)
pushq $0x50
popq %rdi
callq 0x3300
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5740
leaq -0x28(%rbp), %rsi
movq %r12, (%rsi)
movq %r15, %rdi
callq 0x4f9a
movq (%r14), %r15
pushq $0x50
popq %rdi
callq 0x3300
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5238
leaq -0x28(%rbp), %rsi
movq %r12, (%rsi)
movq %r15, %rdi
callq 0x4f9a
movq (%r14), %r15
pushq $0x50
popq %rdi
callq 0x3300
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5aac
leaq -0x28(%rbp), %rsi
movq %r12, (%rsi)
movq %r15, %rdi
callq 0x4f9a
movq (%r14), %r15
pushq $0x50
popq %rdi
callq 0x3300
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6208
leaq -0x28(%rbp), %rsi
movq %r12, (%rsi)
movq %r15, %rdi
callq 0x4f9a
movq (%r14), %r15
pushq $0x50
popq %rdi
callq 0x3300
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5c98
leaq -0x28(%rbp), %rsi
movq %r12, (%rsi)
movq %r15, %rdi
callq 0x4f9a
movq (%r14), %r15
pushq $0x50
popq %rdi
callq 0x3300
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5e98
leaq -0x28(%rbp), %rsi
movq %r12, (%rsi)
movq %r15, %rdi
callq 0x4f9a
movq (%r14), %r15
pushq $0x50
popq %rdi
callq 0x3300
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5de4
leaq -0x28(%rbp), %rsi
movq %r12, (%rsi)
movq %r15, %rdi
callq 0x4f9a
movq (%r14), %r14
pushq $0x50
popq %rdi
callq 0x3300
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6428
leaq -0x28(%rbp), %rsi
movq %r15, (%rsi)
movq %r14, %rdi
callq 0x4f9a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x50
popq %rsi
movq %r15, %rdi
jmp 0x4edc
jmp 0x4ed3
jmp 0x4ed3
jmp 0x4ed3
jmp 0x4ed3
jmp 0x4ed3
jmp 0x4ed3
movq %rax, %rbx
pushq $0x50
popq %rsi
movq %r12, %rdi
callq 0x3320
movq %rbx, %rdi
callq 0x3510
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, -0x30(%rbp)
cmpb $0x0, (%rsi)
je 0x4f71
movq %rsi, %rbx
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq (%rax), %r15
leaq -0x50(%rbp), %r14
cmpq 0x8(%rax), %r15
je 0x4f71
movq (%r15), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x6556
movq -0x50(%rbp), %r13
movq %r13, %rdi
callq 0x3160
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3180
testl %eax, %eax
je 0x4f5c
movq %r14, %rdi
callq 0x3170
addq $0x8, %r15
movq -0x30(%rbp), %rax
movq (%rax), %rax
jmp 0x4f15
movq (%r12), %rax
movq %r12, %rdi
movq %rbx, %rsi
callq *(%rax)
leaq -0x50(%rbp), %rdi
callq 0x3170
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3510
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, (%rdi)
movq %rcx, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %r8, 0x18(%rdi)
andl $0x0, 0x20(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x8(%rdi), %rdi
callq 0x902e
movq %rax, %rdi
callq 0x714e
movq 0x8(%rax), %r13
subq (%rax), %r13
shrq $0x3, %r13
movq 0xbcd0(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
pushq $0x1
popq %rsi
callq 0x3120
movq 0x8(%r15), %rdi
callq 0x902e
movq %rax, %rdi
callq 0x714e
movq %r15, %rdi
movq %rax, %rsi
callq 0x658e
movq %rax, %rbx
leaq 0x5dd0(%rip), %rdx      # 0xb101
movq %r15, %rdi
movq %rax, %rsi
callq 0x664c
movq %rax, %r12
callq 0x34f0
xorl %r14d, %r14d
xorl %r15d, %r15d
testl %r14d, %r14d
jne 0x53ae
movq %r12, %rdi
callq 0x3110
cmpl $0xa, %eax
je 0x538b
cmpl $0x1b, %eax
je 0x539e
xorl %r14d, %r14d
cmpl $0x103, %eax            # imm = 0x103
je 0x537c
cmpl $0x102, %eax            # imm = 0x102
jne 0x53a4
movq %rbx, %rdi
movl $0x203, %esi            # imm = 0x203
jmp 0x5384
movq %rbx, %rdi
movl $0x202, %esi            # imm = 0x202
callq 0x3270
jmp 0x53a4
movq %rbx, %rdi
callq 0x34a0
movq %rax, %rdi
callq 0x34c0
movq %rax, %r15
pushq $0x1
popq %rax
movl %eax, %r14d
movq %r12, %rdi
callq 0x3380
jmp 0x534a
movq %rbx, %rdi
callq 0x3230
movq %rbx, %rdi
callq 0x30b0
movq %rax, %r14
xorl %r12d, %r12d
testl %r13d, %r13d
cmovlel %r12d, %r13d
cmpq %r12, %r13
je 0x53de
movq (%r14,%r12,8), %rdi
callq 0x33c0
incq %r12
jmp 0x53cb
callq 0x33a0
movq %rbx, %rdi
callq 0x30f0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
pushq $0x1
popq %rbx
pushq $0xa
popq %r14
pushq $0x4
popq %r15
pushq $0x23
popq %rcx
movl %ebx, %edi
movl %r14d, %esi
movl %r15d, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x3130
movq %rax, %r12
leaq -0x40(%rbp), %r13
movq %rax, (%r13)
andq $0x0, 0x8(%r13)
movq %rax, %rdi
movl $0x20000, %esi          # imm = 0x20000
callq 0x3420
pushq $0x40
popq %rsi
movq %r12, %rdi
callq 0x30a0
movq 0xbb79(%rip), %rax      # 0x10fd8
movq (%rax), %rsi
movq %r12, %rdi
xorl %edx, %edx
movl %ebx, %ecx
movl $0xf4240, %r8d          # imm = 0xF4240
xorl %eax, %eax
callq 0x3520
movq %r13, %rdi
callq 0x3470
movq %rax, %rbx
movq %rax, %rdi
callq 0x32d0
callq 0x34f0
leaq 0x5ff2(%rip), %rdx      # 0xb487
movl %r15d, %edi
movl %r14d, %esi
xorl %eax, %eax
callq 0x3400
callq 0x34f0
movq 0xbb22(%rip), %r14      # 0x10fd0
movq (%r14), %rdi
callq 0x3110
cmpl $0x102, %eax            # imm = 0x102
je 0x54d2
cmpl $0x103, %eax            # imm = 0x103
je 0x54cb
cmpl $0xa, %eax
jne 0x54e4
jmp 0x54f0
movl $0x205, %esi            # imm = 0x205
jmp 0x54d7
movl $0x204, %esi            # imm = 0x204
movq %rbx, %rdi
callq 0x3540
movl $0x219, %eax            # imm = 0x219
movq %rbx, %rdi
movl %eax, %esi
callq 0x3540
jmp 0x54ae
movq %rbx, %rdi
movl $0x204, %esi            # imm = 0x204
callq 0x3540
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x3440
movq %rax, %rdi
callq 0x34b0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/negativeview[P]Software-Business-Sim/HireCommand.cpp
// Function: HireCommand::executeCommand(char const*)
void HireCommand::executeCommand(const char *line) {
	while (true) {
		Person *toHire = this->doHireMenu();
		if (toHire == NULL)
			return;

		int hireAmount = this->doGetWage(toHire);
		if (hireAmount < 0)
			continue;

		char message[100];

		if (toHire->acceptWages(hireAmount)) {
			toHire->hire(this->_masterState->getPlayerCompany());
			toHire->setSalary(hireAmount);
			this->_masterState->getPlayerCompany()->addEmployee(toHire);
			sprintf(message, "%s %s joined your company for %d/year", toHire->getFirstName().c_str(), toHire->getLastName().c_str(), hireAmount);
		} else {
			sprintf(message, "%s %s rejected your offer of %d/year", toHire->getFirstName().c_str(), toHire->getLastName().c_str(), hireAmount);
		}
		this->_masterState->addMessage(message);
		this->_masterState->advanceTime(1);
		return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
movq %rbx, %rdi
callq 0x52cc
testq %rax, %rax
je 0x5633
movq %rax, %r15
callq 0x53fe
testl %eax, %eax
js 0x5535
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x8318
testb %al, %al
je 0x55c5
movq 0x8(%rbx), %rdi
callq 0x902e
movq %r15, %rdi
movq %rax, %rsi
callq 0x82c2
movq %r15, %rdi
movl %r14d, %esi
callq 0x8304
movq 0x8(%rbx), %rdi
callq 0x902e
movq %rax, %rdi
movq %r15, %rsi
callq 0x6d28
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x82cc
movq (%r12), %r12
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
callq 0x82e8
leaq -0x60(%rbp), %r15
movq (%r15), %rcx
leaq 0x5edd(%rip), %rsi      # 0xb4a0
jmp 0x55f2
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x82cc
movq (%r12), %r12
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
callq 0x82e8
leaq -0x60(%rbp), %r15
movq (%r15), %rcx
leaq 0x5ed4(%rip), %rsi      # 0xb4c6
leaq -0xd0(%rbp), %rdi
movq %r12, %rdx
movl %r14d, %r8d
xorl %eax, %eax
callq 0x3080
movq %r15, %rdi
callq 0x3170
leaq -0x40(%rbp), %rdi
callq 0x3170
movq 0x8(%rbx), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x8fc6
movq 0x8(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x9038
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5645
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3510
nop
// File: /workspace/github_cpp_makefile_star2_O2/negativeview[P]Software-Business-Sim/InterviewCommand.cpp
// Function: InterviewCommand::executeCommand(char const*)
void InterviewCommand::executeCommand(const char *line) {
	while (true) {
		Person *toInterview = this->personChoiceMenu("Applicants");
		if (toInterview == NULL)
			return;

		bool learnedAnything = false;
		list<Trait *> *believedTraits = toInterview->getBelievedTraits();
		for (list<Trait *>::iterator it = believedTraits->begin(); it != believedTraits->end(); ++it) {
			Trait *t = *it;
			if (rand() % 2 == 0) {
				if (t->discoverMore()) {
					learnedAnything = true;
					char message[100];
					sprintf(message, "Learned more about %s %s's %s", toInterview->getFirstName().c_str(), toInterview->getLastName().c_str(), t->getName().c_str());
					this->_masterState->addMessage(message);
				}
			}
		}

		if (!learnedAnything) {
			this->_masterState->addMessage("That was a thoroughly disappointing interview, in which you learned nothing.");
		}
		this->_masterState->advanceTime(1);

		return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %r13
leaq 0x55a3(%rip), %rsi      # 0xb101
callq 0x6ac0
testq %rax, %rax
je 0x5c57
movq %rax, -0x38(%rbp)
movq %rax, %rdi
callq 0x83d8
movq %rax, %r14
xorl %ebx, %ebx
movq %rax, %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0x5c36
movq 0x10(%r15), %r12
callq 0x30c0
testb $0x1, %al
jne 0x5b80
movq %r12, %rdi
callq 0x9eec
testb %al, %al
je 0x5b80
movq %r13, -0x30(%rbp)
leaq -0x78(%rbp), %rdi
movq -0x38(%rbp), %rbx
movq %rbx, %rsi
callq 0x82cc
movq -0x78(%rbp), %r13
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x82e8
movq -0x58(%rbp), %rbx
leaq -0x98(%rbp), %rdi
movq %r12, %rsi
callq 0x9f0a
movq -0x98(%rbp), %r8
leaq -0x100(%rbp), %r12
movq %r12, %rdi
leaq 0x5960(%rip), %rsi      # 0xb554
movq %r13, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x3080
leaq -0x98(%rbp), %rdi
callq 0x3170
leaq -0x58(%rbp), %rdi
callq 0x3170
leaq -0x78(%rbp), %rdi
callq 0x3170
movq -0x30(%rbp), %r13
movq 0x8(%r13), %rdi
movq %r12, %rsi
callq 0x8fc6
movb $0x1, %bl
jmp 0x5b80
testb $0x1, %bl
jne 0x5c4b
movq 0x8(%r13), %rdi
leaq 0x592c(%rip), %rsi      # 0xb572
callq 0x8fc6
movq 0x8(%r13), %rdi
pushq $0x1
popq %rsi
callq 0x9038
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3170
jmp 0x5c7a
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3510
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x676c
testq %rax, %rax
je 0x5db4
movq %rax, %r14
movq %rbx, %rdi
callq 0x6888
testq %rax, %rax
je 0x5db4
movq %rax, %r12
movq %rbx, %rdi
callq 0x69a4
testq %rax, %rax
je 0x5db4
movq %rax, %r13
pushq $0x28
popq %rdi
callq 0x3300
movq %rax, %r15
movq 0x8(%rbx), %rdi
callq 0x902e
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0x51f8
movq 0x8(%rbx), %rdi
callq 0x902e
movq %rax, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6d06
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x3320
movq %rbx, %rdi
callq 0x3510
nop
// File: /workspace/github_cpp_makefile_star2_O2/negativeview[P]Software-Business-Sim/PeopleCommand.cpp
// Function: PeopleCommand::executeCommand(char const*)
void PeopleCommand::executeCommand(const char *line) {
	vector<Person *> *allPeople = this->_masterState->getPlayerCompany()->getKnownPeople();

	for (vector<Person *>::iterator it = allPeople->begin(); it != allPeople->end(); ++it) {
		Person *currentPerson = *it;

		char message[100];

		sprintf(message, "%s %s", currentPerson->getFirstName().c_str(), currentPerson->getLastName().c_str());
		this->_masterState->addMessage(message);
		
		Company *company = currentPerson->getCompany();
		
		list<Trait *> *personTraits;
		if (company && company == this->_masterState->getPlayerCompany())
			personTraits = currentPerson->getRealTraits();
		else
			personTraits = currentPerson->getBelievedTraits();

		for (list<Trait *>::iterator it2 = personTraits->begin(); it2 != personTraits->end(); ++it2) {
			Trait *t = *it2;
			sprintf(message, "    %10s: %s", t->getName().c_str(), t->getDiscoveryModifiedText().c_str());
			this->_masterState->addMessage(message);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x902e
movq %rax, %rdi
callq 0x714e
movq %rax, -0x30(%rbp)
movq (%rax), %r15
leaq -0x80(%rbp), %rcx
movq -0x30(%rbp), %rax
cmpq 0x8(%rax), %r15
je 0x63f5
movq (%r15), %r13
leaq -0x60(%rbp), %rdi
movq %rcx, %r12
movq %r13, %rsi
callq 0x82cc
movq -0x60(%rbp), %r14
movq %r12, %rdi
movq %r13, %rsi
callq 0x82e8
movq %r15, -0x38(%rbp)
movq -0x80(%rbp), %rcx
leaq -0xf0(%rbp), %r15
movq %r15, %rdi
leaq 0x5419(%rip), %rsi      # 0xb730
movq %r14, %rdx
xorl %eax, %eax
callq 0x3080
movq %r12, %rdi
callq 0x3170
leaq -0x60(%rbp), %rdi
callq 0x3170
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x8fc6
movq %r13, %rdi
callq 0x82a4
testq %rax, %rax
je 0x635c
movq %rax, %r14
movq 0x8(%rbx), %rdi
callq 0x902e
cmpq %rax, %r14
je 0x6366
movq %r13, %rdi
callq 0x83d8
jmp 0x636e
movq %r13, %rdi
callq 0x83ce
movq %rax, %r14
leaq -0x60(%rbp), %r12
movq %rax, -0x40(%rbp)
movq (%r14), %r14
cmpq %rax, %r14
je 0x63e8
movq %rbx, %r13
movq 0x10(%r14), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x9f0a
movq -0x60(%rbp), %rbx
leaq -0x80(%rbp), %rdi
movq %r15, %rsi
callq 0x9f26
movq -0x80(%rbp), %rcx
leaq -0xf0(%rbp), %r15
movq %r15, %rdi
leaq 0x537e(%rip), %rsi      # 0xb736
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3080
leaq -0x80(%rbp), %rdi
callq 0x3170
movq %r12, %rdi
callq 0x3170
movq %r13, %rbx
movq 0x8(%r13), %rdi
movq %r15, %rsi
callq 0x8fc6
movq -0x40(%rbp), %rax
jmp 0x6379
movq -0x38(%rbp), %r15
addq $0x8, %r15
jmp 0x62cb
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6409
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3510
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rsi), %r13
movq %rsi, -0x38(%rbp)
movq 0x8(%rsi), %r15
movq %r15, %rax
subq %r13, %rax
shlq $0x1d, %rax
movabsq $0x100000000, %rdi      # imm = 0x100000000
addq %rax, %rdi
sarq $0x20, %rdi
pushq $0x8
popq %rsi
callq 0x31e0
movq %rax, -0x30(%rbp)
xorl %r14d, %r14d
xorl %ebx, %ebx
leaq (%r14,%r13), %rax
cmpq %r15, %rax
je 0x6626
movq (%r13,%rbx,8), %r15
movq %r15, %rdi
callq 0x42ac
movq %rax, %r12
movq %r15, %rdi
callq 0x42b6
movq %r12, %rdi
movq %rax, %rsi
callq 0x3330
movq -0x30(%rbp), %rcx
movq %rax, (%rcx,%rbx,8)
movq %rax, %rdi
movq %r15, %rsi
callq 0x3140
incq %rbx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %r15
addq $0x8, %r14
jmp 0x65d6
xorl %edi, %edi
xorl %esi, %esi
callq 0x3330
movl %ebx, %ecx
movq -0x30(%rbp), %rdi
movq %rax, (%rdi,%rcx,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
pushq $0xa
popq %rdi
pushq $0x28
popq %rsi
pushq $0x4
popq %rcx
movl %ecx, %edx
callq 0x3340
movq %rax, %r14
pushq $0x1
popq %r12
movq %rax, %rdi
movl %r12d, %esi
callq 0x3120
movq %rbx, %rdi
movq %r14, %rsi
callq 0x31d0
pushq $0x6
popq %rsi
pushq $0x26
popq %rdx
pushq $0x3
popq %rcx
movq %r14, %rdi
movl %r12d, %r8d
callq 0x3240
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3060
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3550
pushq $0x2
popq %r13
movq %r14, %rdi
movl %r12d, %esi
movl %r13d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x3090
movq %r14, %rdi
movl %r13d, %esi
xorl %edx, %edx
callq 0x3350
cmpl $-0x1, %eax
je 0x66f6
movq 0xa8d0(%rip), %rax      # 0x10fb8
movl 0x1d0(%rax), %esi
movq %r14, %rdi
callq 0x30e0
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x3350
cmpl $-0x1, %eax
je 0x6721
movq 0xa8a8(%rip), %rax      # 0x10fb8
movl 0x1c4(%rax), %esi
pushq $0x26
popq %rdx
movq %r14, %rdi
callq 0x32a0
pushq $0x2
popq %rsi
pushq $0x27
popq %rdx
movq %r14, %rdi
callq 0x3350
cmpl $-0x1, %eax
je 0x6749
movq 0xa87d(%rip), %rax      # 0x10fb8
movl 0x1d4(%rax), %esi
movq %r14, %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x3450
movq %r14, %rdi
callq 0x3380
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x9024
movq 0x8(%rax), %r13
subq (%rax), %r13
shrq $0x3, %r13
movq 0xa838(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
pushq $0x1
popq %rsi
callq 0x3120
movq 0x8(%rbx), %rdi
callq 0x9024
movq %rax, %rsi
callq 0x658e
movq %rax, %rbx
leaq 0x4fbf(%rip), %rdx      # 0xb77d
movq %rax, %rsi
callq 0x664c
movq %rax, %r12
callq 0x34f0
xorl %r14d, %r14d
xorl %r15d, %r15d
testl %r14d, %r14d
jne 0x6838
movq %r12, %rdi
callq 0x3110
cmpl $0xa, %eax
je 0x6815
cmpl $0x1b, %eax
je 0x6828
xorl %r14d, %r14d
cmpl $0x103, %eax            # imm = 0x103
je 0x6806
cmpl $0x102, %eax            # imm = 0x102
jne 0x682e
movq %rbx, %rdi
movl $0x203, %esi            # imm = 0x203
jmp 0x680e
movq %rbx, %rdi
movl $0x202, %esi            # imm = 0x202
callq 0x3270
jmp 0x682e
movq %rbx, %rdi
callq 0x34a0
movq %rax, %rdi
callq 0x34c0
movq %rax, %r15
pushq $0x1
popq %rax
movl %eax, %r14d
movq %r12, %rdi
callq 0x3380
jmp 0x67d4
movq %rbx, %rdi
callq 0x3230
movq %rbx, %rdi
callq 0x30b0
movq %rax, %r14
xorl %r12d, %r12d
testl %r13d, %r13d
cmovlel %r12d, %r13d
cmpq %r12, %r13
je 0x6868
movq (%r14,%r12,8), %rdi
callq 0x33c0
incq %r12
jmp 0x6855
callq 0x33a0
movq %rbx, %rdi
callq 0x30f0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop