LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: taurheim[P]AgNES/codeGenerator.cpp
// Function: CodeGenerator::padAddress[abi:cxx11](int)
std::string CodeGenerator::padAddress(int num)
{
    std::ostringstream ss;
    ss << std::setw(4) << std::setfill('0') << num;
    std::string result = ss.str();
    if (result.length() > 4)
    {
        result.erase(0, result.length() - 4);
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x33d0
movl $0x4, %edi
callq 0x21eb0
movl %eax, -0x1ac(%rbp)
jmp 0x21885
movl -0x1ac(%rbp), %eax
movl %eax, -0x194(%rbp)
movl -0x194(%rbp), %esi
leaq -0x190(%rbp), %rdi
callq 0x3370
movq %rax, -0x1c8(%rbp)
jmp 0x218ac
movl $0x30, %edi
callq 0x21ed0
movb %al, -0x1c9(%rbp)
jmp 0x218be
movq -0x1c8(%rbp), %rdi
movb -0x1c9(%rbp), %al
movb %al, -0x1a5(%rbp)
movzbl -0x1a5(%rbp), %esi
callq 0x3490
movq %rax, -0x1d8(%rbp)
jmp 0x218e6
movq -0x1d8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3500
jmp 0x218f7
movq -0x1c0(%rbp), %rdi
movb $0x0, -0x1a6(%rbp)
leaq -0x190(%rbp), %rsi
callq 0x3310
jmp 0x21913
movq -0x1c0(%rbp), %rdi
callq 0x3470
cmpq $0x4, %rax
jbe 0x21980
movq -0x1c0(%rbp), %rdi
callq 0x3470
movq -0x1c0(%rbp), %rdi
movq %rax, %rdx
addq $-0x4, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x30c0
jmp 0x2194a
jmp 0x21980
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x219b8
movq -0x1c0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
callq 0x31d0
jmp 0x219b8
movb $0x1, -0x1a6(%rbp)
testb $0x1, -0x1a6(%rbp)
jne 0x2199c
movq -0x1c0(%rbp), %rdi
callq 0x31d0
leaq -0x190(%rbp), %rdi
callq 0x30d0
movq -0x1b8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
leaq -0x190(%rbp), %rdi
callq 0x30d0
movq -0x1a0(%rbp), %rdi
callq 0x3520
// File: taurheim[P]AgNES/codeGenerator.cpp
// Function: CodeGenerator::allocateStackSpace(int)
void CodeGenerator::allocateStackSpace(int size) {
    if (size == 0) return;
    // SBC: A = A - M - (1 - C)
    loadConstIntoA(256 - size);
    code << "CLC" << nl;
    code << "ADC " << cSP << nl;
    code << "STA " << cSP << nl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x219f2
jmp 0x21a8c
movq -0x18(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
subl -0xc(%rbp), %esi
callq 0x21600
movq -0x18(%rbp), %rdi
addq $0x80, %rdi
leaq 0x30a7(%rip), %rsi      # 0x24abc
callq 0x32e0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
callq 0x32a0
movq -0x18(%rbp), %rdi
addq $0x80, %rdi
leaq 0x316d(%rip), %rsi      # 0x24ba5
callq 0x32e0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rsi
callq 0x32a0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
callq 0x32a0
movq -0x18(%rbp), %rdi
addq $0x80, %rdi
leaq 0x2fac(%rip), %rsi      # 0x24a17
callq 0x32e0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rsi
callq 0x32a0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
callq 0x32a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: schneebergerlab[P]DrLink/detect_recombsite.cpp
// Function: check_candidate_cosite(std::multimap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<unsigned long, 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, std::pair<unsigned long, unsigned long>>>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long, unsigned long)
bool check_candidate_cosite(multimap<string, std::pair<unsigned long, unsigned long> >* badMolecule,
                            string mkey,
                            unsigned long mstart,
                            unsigned long mend)
{
    bool passchecking = true; // if not in bad molecule set, passing checking
    std::pair <multimap<string, std::pair<unsigned long, unsigned long> >::iterator, 
               multimap<string, std::pair<unsigned long, unsigned long> >::iterator> clitr_region;
    clitr_region = (*badMolecule).equal_range(mkey);
    multimap<string, std::pair<unsigned long, unsigned long> >::iterator clitr;
    for (clitr=clitr_region.first; clitr!=clitr_region.second; ++clitr)
    {
        std::pair<unsigned long, unsigned long> span = (*clitr).second;
        if( (mstart>=span.first && mstart<=span.second) ||
            (mend>=span.first   && mend<=span.second) )
        {
            // caution: might be too stringent here: check overlapping size then?
            passchecking = false;
            break;
        }
    }
    return passchecking; 
}

// Assembly:
subq $0x68, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movb $0x1, 0x47(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2de90
movq (%rsp), %rsi
movq 0x60(%rsp), %rdi
callq 0x2dec0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2df00
leaq 0x18(%rsp), %rdi
callq 0x2df30
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rsi
addq $0x8, %rsi
leaq 0x18(%rsp), %rdi
callq 0x2df50
testb $0x1, %al
jne 0x2b8af
jmp 0x2b910
leaq 0x18(%rsp), %rdi
callq 0x2df70
movq 0x20(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x28(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x8(%rsp), %rax
jb 0x2b8e3
movq 0x50(%rsp), %rax
cmpq 0x10(%rsp), %rax
jbe 0x2b8fb
movq 0x48(%rsp), %rax
cmpq 0x8(%rsp), %rax
jb 0x2b902
movq 0x48(%rsp), %rax
cmpq 0x10(%rsp), %rax
ja 0x2b902
movb $0x0, 0x47(%rsp)
jmp 0x2b910
jmp 0x2b904
leaq 0x18(%rsp), %rdi
callq 0x2df90
jmp 0x2b896
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: schneebergerlab[P]DrLink/separate_chr_v2.cpp
// Function: gen_random(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, int)
bool gen_random(string* str, const int len) {
    // from stackoverflow
    static const char alphanum[] =
        "0123456789"
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "abcdefghijklmnopqrstuvwxyz";
    for (int i = 0; i < len; ++i) {
        (*str) += alphanum[rand() % (sizeof(alphanum) - 1)];
    }
    return true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x602c4
callq 0x5120
cltq
movl $0x3e, %ecx
xorl %edx, %edx
divq %rcx
leaq 0xac89(%rip), %rax      # 0x6af30
movb (%rax,%rdx), %al
movq 0x10(%rsp), %rdi
movsbl %al, %esi
callq 0x52b0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x60285
movb $0x1, %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: bool exprtk::collect_variables<double, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::deque>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::symbol_table<double>&, std::deque<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
inline bool collect_variables(const std::string& expression,
                                 exprtk::symbol_table<T>& extrnl_symbol_table,
                                 Sequence<std::string, Allocator>& symbol_list)
   {
      typedef details::collector_helper<T> collect_t;

      std::set<std::string> symbol_set;

      const bool variable_pass = collect_t::collection_pass
                                    (expression, symbol_set, true, false, false, extrnl_symbol_table);
      const bool vector_pass   = collect_t::collection_pass
                                    (expression, symbol_set, true, false,  true, extrnl_symbol_table);

      if (!variable_pass && !vector_pass)
         return false;

      std::set<std::string>::iterator itr = symbol_set.begin();

      while (symbol_set.end() != itr)
      {
         symbol_list.push_back(*itr);
         ++itr;
      }

      return true;
   }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x119b80
movq 0x18(%rsp), %rsi
movq 0x98(%rsp), %rdi
movq 0x90(%rsp), %r9
movl $0x1, %edx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x121520
movb %al, 0x27(%rsp)
jmp 0x119099
movb 0x27(%rsp), %al
andb $0x1, %al
movb %al, 0x57(%rsp)
movq 0x98(%rsp), %rdi
movq 0x90(%rsp), %r9
leaq 0x58(%rsp), %rsi
xorl %ecx, %ecx
movl $0x1, %r8d
movl %r8d, %edx
callq 0x121520
movb %al, 0x17(%rsp)
jmp 0x1190ce
movb 0x17(%rsp), %al
andb $0x1, %al
movb %al, 0x43(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x119118
testb $0x1, 0x43(%rsp)
jne 0x119118
movb $0x0, 0xa7(%rsp)
movl $0x1, 0x3c(%rsp)
jmp 0x11918d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x119c60
jmp 0x1191a8
leaq 0x58(%rsp), %rdi
callq 0x1218f0
movq %rax, 0x30(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x11d910
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x11d8f0
testb $0x1, %al
jne 0x11914b
jmp 0x11917d
movq 0x88(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x121980
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x121920
jmp 0x119171
leaq 0x30(%rsp), %rdi
callq 0x1219a0
jmp 0x119127
movb $0x1, 0xa7(%rsp)
movl $0x1, 0x3c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x119c60
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x111450
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: bool exprtk::collect_functions<double, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::deque>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::symbol_table<double>&, std::deque<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
inline bool collect_functions(const std::string& expression,
                                 exprtk::symbol_table<T>& extrnl_symbol_table,
                                 Sequence<std::string, Allocator>& symbol_list)
   {
      typedef details::collector_helper<T> collect_t;

      std::set<std::string> symbol_set;

      const bool variable_pass = collect_t::collection_pass
                                    (expression, symbol_set, false, true, false, extrnl_symbol_table);
      const bool vector_pass   = collect_t::collection_pass
                                    (expression, symbol_set, false, true,  true, extrnl_symbol_table);

      if (!variable_pass && !vector_pass)
         return false;

      std::set<std::string>::iterator itr = symbol_set.begin();

      while (symbol_set.end() != itr)
      {
         symbol_list.push_back(*itr);
         ++itr;
      }

      return true;
   }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x119b80
movq 0x18(%rsp), %rsi
movq 0x98(%rsp), %rdi
movq 0x90(%rsp), %r9
movl $0x1, %ecx
xorl %r8d, %r8d
movl %r8d, %edx
callq 0x121520
movb %al, 0x27(%rsp)
jmp 0x119259
movb 0x27(%rsp), %al
andb $0x1, %al
movb %al, 0x57(%rsp)
movq 0x98(%rsp), %rdi
movq 0x90(%rsp), %r9
leaq 0x58(%rsp), %rsi
xorl %edx, %edx
movl $0x1, %r8d
movl %r8d, %ecx
callq 0x121520
movb %al, 0x17(%rsp)
jmp 0x11928e
movb 0x17(%rsp), %al
andb $0x1, %al
movb %al, 0x43(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x1192d8
testb $0x1, 0x43(%rsp)
jne 0x1192d8
movb $0x0, 0xa7(%rsp)
movl $0x1, 0x3c(%rsp)
jmp 0x11934d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x119c60
jmp 0x119368
leaq 0x58(%rsp), %rdi
callq 0x1218f0
movq %rax, 0x30(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x11d910
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x11d8f0
testb $0x1, %al
jne 0x11930b
jmp 0x11933d
movq 0x88(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x121980
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x121920
jmp 0x119331
leaq 0x30(%rsp), %rdi
callq 0x1219a0
jmp 0x1192e7
movb $0x1, 0xa7(%rsp)
movl $0x1, 0x3c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x119c60
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x111450
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: CMU-SAFARI[P]optimal-seed-solver/spacedSeedSolver.cc
// Function: SpacedSeedSolver::storeHash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SpacedSeedSolver::storeHash(string tableName) {
	ofstream storeFile;
	storeFile.open(tableName.c_str() );

	storeFile<< mask << endl;

	for (int i = 0; i < freqTable.size(); i++)
		storeFile << freqTable[i] << endl;

	storeFile.close();
}

// Assembly:
subq $0x258, %rsp            # imm = 0x258
movq %rsi, 0x28(%rsp)
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq 0x250(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x3570
movq 0x28(%rsp), %rdi
callq 0x3150
movq 0x30(%rsp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x3060
jmp 0x66d6
movq 0x20(%rsp), %rsi
addq $0x2a8, %rsi            # imm = 0x2A8
leaq 0x48(%rsp), %rdi
callq 0x3280
movq %rax, 0x18(%rsp)
jmp 0x66f3
movq 0x18(%rsp), %rdi
movq 0x168b9(%rip), %rsi     # 0x1cfb8
callq 0x3310
jmp 0x6706
movl $0x0, 0x38(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x290, %rdi            # imm = 0x290
callq 0x6e30
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x679b
movq 0x20(%rsp), %rdi
addq $0x290, %rdi            # imm = 0x290
movslq 0x38(%rsp), %rsi
callq 0x6e10
movl (%rax), %esi
leaq 0x48(%rsp), %rdi
callq 0x3450
movq %rax, 0x8(%rsp)
jmp 0x675f
movq 0x8(%rsp), %rdi
movq 0x1684d(%rip), %rsi     # 0x1cfb8
callq 0x3310
jmp 0x6772
jmp 0x6774
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x670e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x34c0
jmp 0x67b9
leaq 0x48(%rsp), %rdi
callq 0x34a0
jmp 0x67a7
leaq 0x48(%rsp), %rdi
callq 0x34c0
addq $0x258, %rsp            # imm = 0x258
retq
movq 0x40(%rsp), %rdi
callq 0x35c0
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]optimal-seed-solver/spacedSeedSolver.cc
// Function: SpacedSeedSolver::loadHash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SpacedSeedSolver::loadHash(string tableName) {
	ifstream storeFile;
	storeFile.open(tableName.c_str() );

	storeFile >> mask;

	unsigned int oneCount = 0;
	for (int i = 0; i < mask.length(); i++)
		if (mask[i] == '1')
			oneCount++;

	freqTable.resize( (1 << (2 * oneCount) ), 0);
	
	seed = string(oneCount, 'N');

	for (int i = 0; i < freqTable.size(); i++)
		storeFile >> freqTable[i];

	storeFile.close();
}

// Assembly:
subq $0x298, %rsp            # imm = 0x298
movq %rsi, 0x30(%rsp)
movq %rdi, 0x290(%rsp)
movq %rsi, 0x288(%rsp)
movq 0x290(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x80(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x3370
movq 0x30(%rsp), %rdi
callq 0x3150
movq 0x38(%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x31e0
jmp 0x6829
movq 0x28(%rsp), %rsi
addq $0x2a8, %rsi            # imm = 0x2A8
leaq 0x80(%rsp), %rdi
callq 0x3400
jmp 0x6844
movl $0x0, 0x70(%rsp)
movl $0x0, 0x6c(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x6c(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x2a8, %rdi            # imm = 0x2A8
callq 0x34d0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x68d8
movq 0x28(%rsp), %rdi
addq $0x2a8, %rdi            # imm = 0x2A8
movslq 0x6c(%rsp), %rsi
callq 0x3650
movq %rax, 0x18(%rsp)
jmp 0x6899
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x31, %eax
jne 0x68c6
movl 0x70(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x70(%rsp)
jmp 0x68c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x6a07
jmp 0x68c8
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x6854
movq 0x28(%rsp), %rdi
addq $0x290, %rdi            # imm = 0x290
movb 0x70(%rsp), %cl
addb %cl, %cl
movl $0x1, %eax
shll %cl, %eax
movl %eax, %esi
movl $0x0, 0x68(%rsp)
leaq 0x68(%rsp), %rdx
callq 0x6cd0
jmp 0x6907
movl 0x70(%rsp), %eax
movq %rax, 0x8(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x35d0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rcx
leaq 0x48(%rsp), %rdi
movl $0x4e, %edx
callq 0x6d90
jmp 0x693a
movq 0x28(%rsp), %rdi
addq $0x270, %rdi            # imm = 0x270
leaq 0x48(%rsp), %rsi
callq 0x33b0
leaq 0x48(%rsp), %rdi
callq 0x31d0
leaq 0x47(%rsp), %rdi
callq 0x3330
movl $0x0, 0x40(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x40(%rsp), %rax
movq %rax, (%rsp)
addq $0x290, %rdi            # imm = 0x290
callq 0x6e30
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x69e3
movq 0x28(%rsp), %rdi
addq $0x290, %rdi            # imm = 0x290
movslq 0x40(%rsp), %rsi
callq 0x6e10
movq %rax, %rsi
leaq 0x80(%rsp), %rdi
callq 0x3080
jmp 0x69ba
jmp 0x69bc
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x696c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x47(%rsp), %rdi
callq 0x3330
jmp 0x6a07
leaq 0x80(%rsp), %rdi
callq 0x30d0
jmp 0x69f2
leaq 0x80(%rsp), %rdi
callq 0x3100
addq $0x298, %rsp            # imm = 0x298
retq
leaq 0x80(%rsp), %rdi
callq 0x3100
movq 0x78(%rsp), %rdi
callq 0x35c0
nop
// File: CMU-SAFARI[P]optimal-seed-solver/spacedSeedSolver.cc
// Function: SpacedSeedSolver::solveDNA(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
unsigned int SpacedSeedSolver::solveDNA(string DNA, unsigned int seedNum) {
	unsigned int totalFreq = 0;
	
	for (int i = 0; i < seedNum; i++) {
		string spacedSeed = DNA.substr(i * mask.length(), mask.length() );
		unsigned int oneCount = 0;
		for (int i = 0; i < spacedSeed.length(); i++) {
		   if (mask[i] == '1') {
				seed[oneCount] = spacedSeed[i];
				oneCount++;
		   }
		}
		unsigned int hash = hashGen.calculateHash(seed, seed.length() );
		totalFreq += freqTable[hash];
	}
	return totalFreq;
}

// Assembly:
subq $0xb8, %rsp
movq %rsi, 0x50(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movl %edx, 0xa4(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x58(%rsp)
movl $0x0, 0xa0(%rsp)
movl $0x0, 0x9c(%rsp)
movl 0x9c(%rsp), %eax
cmpl 0xa4(%rsp), %eax
jae 0x6c40
movq 0x58(%rsp), %rdi
movslq 0x9c(%rsp), %rax
movq %rax, 0x40(%rsp)
addq $0x2a8, %rdi            # imm = 0x2A8
callq 0x34d0
movq 0x58(%rsp), %rdi
movq %rax, %rcx
movq 0x40(%rsp), %rax
imulq %rcx, %rax
movq %rax, 0x48(%rsp)
addq $0x2a8, %rdi            # imm = 0x2A8
callq 0x34d0
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq %rax, %rcx
leaq 0x78(%rsp), %rdi
callq 0x32f0
movl $0x0, 0x74(%rsp)
movl $0x0, 0x70(%rsp)
movslq 0x70(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x34d0
movq %rax, %rcx
movq 0x38(%rsp), %rax
cmpq %rcx, %rax
jae 0x6bb6
movq 0x58(%rsp), %rdi
addq $0x2a8, %rdi            # imm = 0x2A8
movslq 0x70(%rsp), %rsi
callq 0x3650
movq %rax, 0x30(%rsp)
jmp 0x6b23
movq 0x30(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x31, %eax
jne 0x6ba4
movslq 0x70(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x3650
movq %rax, 0x28(%rsp)
jmp 0x6b46
movq 0x58(%rsp), %rdi
movq 0x28(%rsp), %rax
movb (%rax), %al
movb %al, 0x1f(%rsp)
addq $0x270, %rdi            # imm = 0x270
movl 0x74(%rsp), %eax
movl %eax, %esi
callq 0x3650
movq %rax, 0x20(%rsp)
jmp 0x6b6f
movq 0x20(%rsp), %rax
movb 0x1f(%rsp), %cl
movb %cl, (%rax)
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0x6ba4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x31d0
jmp 0x6c4f
jmp 0x6ba6
movl 0x70(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x70(%rsp)
jmp 0x6ae1
movq 0x58(%rsp), %rdi
movq %rdi, %rax
addq $0x268, %rax            # imm = 0x268
movq %rax, 0x8(%rsp)
addq $0x270, %rdi            # imm = 0x270
movq %rdi, 0x10(%rsp)
callq 0x34d0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl %eax, %edx
callq 0x14390
movl %eax, 0x18(%rsp)
jmp 0x6bf1
movq 0x58(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, 0x60(%rsp)
addq $0x290, %rdi            # imm = 0x290
movl 0x60(%rsp), %eax
movl %eax, %esi
callq 0x6e10
movl (%rax), %eax
addl 0xa0(%rsp), %eax
movl %eax, 0xa0(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x31d0
movl 0x9c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x9c(%rsp)
jmp 0x6a66
movl 0xa0(%rsp), %eax
addq $0xb8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x35c0
nopl (%rax)
// File: Lartu[P]coraldb/source/map_functions.cpp
// Function: set_key(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&)
void set_key(const std::string &key, const std::string &value)
{
    /* Sets the value of a key into the dictionary. If the key is not found,
     * it's added. Otherwise, it's value is changed.
     * Time complexity:
     * - Average: O(1)
     * - Worst case: O(n)
     */
    global_db_mutex.lock();
    if (global_db.find(key) == global_db.end())
        global_db.emplace(key, value);
    else
        global_db[key] = value;
    global_db_mutex.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xd8a9(%rip), %rdi      # 0x11360
callq 0x5f80
movq -0x8(%rbp), %rsi
leaq 0xd861(%rip), %rdi      # 0x11328
callq 0x5fe0
movq %rax, -0x18(%rbp)
leaq 0xd851(%rip), %rdi      # 0x11328
callq 0x6010
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5fb0
testb $0x1, %al
jne 0x3af3
jmp 0x3b10
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0xd826(%rip), %rdi      # 0x11328
callq 0x6040
movq %rax, -0x30(%rbp)
movb %dl, -0x28(%rbp)
jmp 0x3b34
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rsi
leaq 0xd805(%rip), %rdi      # 0x11328
callq 0x6090
movq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x3030
leaq 0xd825(%rip), %rdi      # 0x11360
callq 0x60c0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Lartu[P]coraldb/source/map_functions.cpp
// Function: read_key(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>>&)
bool read_key(const std::string &key, std::string &out)
{
    /* Returns the value of a key via the out parameter. If a value could be
     * read, the function returns true. Otherwise it returns false.
     * Time complexity:
     * - Average: O(1)
     * - Worst case: O(n)
     */
    bool found;
    global_db_mutex.lock();
    std::unordered_map<std::string, std::string>::const_iterator it = global_db.find(key);
    found = it != global_db.end();
    if (found)
    {
        out = it->second;
    }
    global_db_mutex.unlock();
    return found;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xd7f9(%rip), %rdi      # 0x11360
callq 0x5f80
movq -0x8(%rbp), %rsi
leaq 0xd7b1(%rip), %rdi      # 0x11328
callq 0x5fe0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x60e0
leaq 0xd794(%rip), %rdi      # 0x11328
callq 0x6010
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6110
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x3bce
leaq -0x20(%rbp), %rdi
callq 0x6140
movq %rax, %rsi
addq $0x20, %rsi
movq -0x10(%rbp), %rdi
callq 0x3030
leaq 0xd78b(%rip), %rdi      # 0x11360
callq 0x60c0
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Lartu[P]coraldb/source/map_functions.cpp
// Function: probe_key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool probe_key(const std::string &key)
{
    /* Returns true if the key exists in the dictionary, false otherwise.
     * Time complexity:
     * - Average: O(1)
     * - Worst case: O(n)
     */
    bool found;
    global_db_mutex.lock();
    found = global_db.find(key) != global_db.end();
    global_db_mutex.unlock();
    return found;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xd71d(%rip), %rdi      # 0x11360
callq 0x5f80
movq -0x8(%rbp), %rsi
leaq 0xd6d5(%rip), %rdi      # 0x11328
callq 0x5fe0
movq %rax, -0x18(%rbp)
leaq 0xd6c5(%rip), %rdi      # 0x11328
callq 0x6010
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6110
andb $0x1, %al
movb %al, -0x9(%rbp)
leaq 0xd6db(%rip), %rdi      # 0x11360
callq 0x60c0
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Lartu[P]coraldb/source/checkpoint.cpp
// Function: test_save_file_permissions()
int test_save_file_permissions()
{
    FILE *fp = fopen(global_filename.c_str(), "a+");
    if (fp == NULL)
    {
        if (errno == EACCES)
        {
            std::cerr << "CoralDB: Cannot write to checkpoint file " << global_filename << ", permission denied." << std::endl;
        }
        else
        {
            std::cerr << "CoralDB: Cannot write to checkpoint file " << global_filename << ": " << strerror(errno) << "." << std::endl;
        }
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xc291(%rip), %rdi      # 0x113b0
callq 0x3160
movq %rax, %rdi
leaq 0x60fa(%rip), %rsi      # 0xb228
callq 0x3360
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5202
callq 0x3040
cmpl $0xd, (%rax)
jne 0x518e
movq 0xbe9d(%rip), %rdi      # 0x10ff0
leaq 0x60d1(%rip), %rsi      # 0xb22b
callq 0x3300
movq %rax, %rdi
leaq 0xc247(%rip), %rsi      # 0x113b0
callq 0x32a0
movq %rax, %rdi
leaq 0x60dd(%rip), %rsi      # 0xb255
callq 0x3300
movq %rax, %rdi
movq 0xbe21(%rip), %rsi      # 0x10fa8
callq 0x3320
jmp 0x51f9
movq 0xbe5b(%rip), %rdi      # 0x10ff0
leaq 0x608f(%rip), %rsi      # 0xb22b
callq 0x3300
movq %rax, %rdi
leaq 0xc205(%rip), %rsi      # 0x113b0
callq 0x32a0
movq %rax, %rdi
leaq 0x5f12(%rip), %rsi      # 0xb0cc
callq 0x3300
movq %rax, -0x18(%rbp)
callq 0x3040
movl (%rax), %edi
callq 0x3130
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x3300
movq %rax, %rdi
leaq 0x6083(%rip), %rsi      # 0xb268
callq 0x3300
movq %rax, %rdi
movq 0xbdb4(%rip), %rsi      # 0x10fa8
callq 0x3320
movl $0x1, -0x4(%rbp)
jmp 0x5209
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Lartu[P]coraldb/source/coraldb.cpp
// Function: show_help()
void show_help()
{
    print_version();
    std::cout << "Usage: coraldb [switches]" << std::endl;
    std::cout << " -h, --help          shows this help" << std::endl;
    std::cout << " -p, --port          sets the database port" << std::endl;
    std::cout << " -f, --file          sets the database checkpoint file" << std::endl;
    std::cout << " -c, --checkpoint    sets the checkpoint timeout in seconds" << std::endl;
    std::cout << " -a, --anyport       use any available port" << std::endl;
    std::cout << " -v, --version       prints version information" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x5250
movq 0xbcf8(%rip), %rdi      # 0x10fc8
leaq 0x600b(%rip), %rsi      # 0xb2e2
callq 0x3300
movq %rax, %rdi
movq 0xbcc2(%rip), %rsi      # 0x10fa8
callq 0x3320
movq 0xbcd6(%rip), %rdi      # 0x10fc8
leaq 0x6003(%rip), %rsi      # 0xb2fc
callq 0x3300
movq %rax, %rdi
movq 0xbca0(%rip), %rsi      # 0x10fa8
callq 0x3320
movq 0xbcb4(%rip), %rdi      # 0x10fc8
leaq 0x6006(%rip), %rsi      # 0xb321
callq 0x3300
movq %rax, %rdi
movq 0xbc7e(%rip), %rsi      # 0x10fa8
callq 0x3320
movq 0xbc92(%rip), %rdi      # 0x10fc8
leaq 0x6010(%rip), %rsi      # 0xb34d
callq 0x3300
movq %rax, %rdi
movq 0xbc5c(%rip), %rsi      # 0x10fa8
callq 0x3320
movq 0xbc70(%rip), %rdi      # 0x10fc8
leaq 0x6025(%rip), %rsi      # 0xb384
callq 0x3300
movq %rax, %rdi
movq 0xbc3a(%rip), %rsi      # 0x10fa8
callq 0x3320
movq 0xbc4e(%rip), %rdi      # 0x10fc8
leaq 0x603f(%rip), %rsi      # 0xb3c0
callq 0x3300
movq %rax, %rdi
movq 0xbc18(%rip), %rsi      # 0x10fa8
callq 0x3320
movq 0xbc2c(%rip), %rdi      # 0x10fc8
leaq 0x6049(%rip), %rsi      # 0xb3ec
callq 0x3300
movq %rax, %rdi
movq 0xbbf6(%rip), %rsi      # 0x10fa8
callq 0x3320
popq %rbp
retq
nopl (%rax)
// File: Lartu[P]coraldb/source/coraldb.cpp
// Function: main
int main(int argc, char **argv)
{
    int arg_out = parse_arguments(argc, argv);
    if (arg_out == 0)
    {
        print_version();
        if (test_save_file_permissions() == 0)
        {
            load_checkpoint();
            std::thread checkpoint_thread(checkpoint_handler);
            checkpoint_thread.detach();
            start_socket();
        }
        else
        {
            return 1;
        }
    }
    else
    {
        return arg_out;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x53c0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x5e42
callq 0x5250
callq 0x5110
cmpl $0x0, %eax
jne 0x5e37
callq 0x4e80
leaq -0xbd6(%rip), %rsi      # 0x5220
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x6850
movq -0x38(%rbp), %rdi
callq 0x34f0
jmp 0x5e0e
callq 0x5bf0
jmp 0x5e15
leaq -0x20(%rbp), %rdi
callq 0x6820
jmp 0x5e40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6820
jmp 0x5e5a
movl $0x1, -0x4(%rbp)
jmp 0x5e51
jmp 0x5e4a
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5e51
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3500
nopw %cs:(%rax,%rax)
// File: jovermann[P]streplace/src/CommandLineParser.cpp
// Function: ut1::CommandLineParser::Option::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
void CommandLineParser::Option::setValue(const std::string& v, char listSepChar_)
{
    if (isList && (count > 0))
    {
        value += listSepChar_;
        value += v;
    }
    else
    {
        value = v;
    }
    count++;
    if (argName.empty())
    {
        value = std::to_string(count);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
testb $0x1, 0x88(%rax)
je 0x7d9f
movq -0x40(%rbp), %rax
cmpl $0x0, 0xb0(%rax)
jbe 0x7d9f
movq -0x40(%rbp), %rdi
movb -0x11(%rbp), %al
addq $0x90, %rdi
movsbl %al, %esi
callq 0x73f0
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x90, %rdi
callq 0x77b0
jmp 0x7db3
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x90, %rdi
callq 0x7070
movq -0x40(%rbp), %rdi
movl 0xb0(%rdi), %eax
addl $0x1, %eax
movl %eax, 0xb0(%rdi)
addq $0x48, %rdi
callq 0x7990
testb $0x1, %al
jne 0x7dd5
jmp 0x7e05
movq -0x40(%rbp), %rax
movl 0xb0(%rax), %esi
leaq -0x38(%rbp), %rdi
callq 0xb1d0
movq -0x40(%rbp), %rdi
addq $0x90, %rdi
leaq -0x38(%rbp), %rsi
callq 0x7750
leaq -0x38(%rbp), %rdi
callq 0x73c0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jovermann[P]streplace/src/CommandLineParser.cpp
// Function: ut1::CommandLineParser::getShortOption(char)
CommandLineParser::Option* CommandLineParser::getShortOption(char shortOption)
{
    auto it = shortOptionToLongOption.find(shortOption);
    if (it == shortOptionToLongOption.end())
    {
        return nullptr;
    }
    return getOption(it->second);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x48, %rdi
leaq -0x11(%rbp), %rsi
callq 0xc2f0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x48, %rdi
callq 0xc350
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc320
testb $0x1, %al
jne 0x88cf
jmp 0x88d9
movq $0x0, -0x8(%rbp)
jmp 0x88f6
leaq -0x20(%rbp), %rdi
callq 0xc380
movq -0x30(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0xb080
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: jovermann[P]streplace/src/CommandLineParser.cpp
// Function: ut1::CommandLineParser::getCount(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
unsigned CommandLineParser::getCount(const std::string& longOption) const
{
    const Option* option = getOption(longOption);
    if (option)
    {
        return option->count;
    }
    else
    {
        throw std::runtime_error("CommandLineParser::getCount(): Unknown option '" + longOption + "'!");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xab60
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xaa98
movq -0x18(%rbp), %rax
movl 0xb0(%rax), %eax
addq $0x70, %rsp
popq %rbp
retq
movb $0x1, -0x65(%rbp)
movl $0x10, %edi
callq 0x7310
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x3f60d(%rip), %rsi     # 0x4a0c2
leaq -0x58(%rbp), %rdi
callq 0xb5b0
jmp 0xaac0
leaq 0x3f62b(%rip), %rdx     # 0x4a0f2
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xb720
jmp 0xaad6
movq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7950
jmp 0xaae5
movq -0x70(%rbp), %rdi
movb $0x0, -0x65(%rbp)
movq 0x5f4f4(%rip), %rsi     # 0x69fe8
movq 0x5f495(%rip), %rdx     # 0x69f90
callq 0x79d0
jmp 0xab58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xab3c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xab33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x73c0
leaq -0x58(%rbp), %rdi
callq 0x73c0
testb $0x1, -0x65(%rbp)
jne 0xab44
jmp 0xab4d
movq -0x70(%rbp), %rdi
callq 0x74a0
jmp 0xab4f
movq -0x60(%rbp), %rdi
callq 0x7a30
nopl (%rax,%rax)
// File: jovermann[P]streplace/src/CommandLineParser.cpp
// Function: ut1::CommandLineParser::getStr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const std::string& CommandLineParser::getStr(const std::string& longOption) const
{
    const Option* option = getOption(longOption);
    if (option)
    {
        return option->value;
    }
    else
    {
        throw std::runtime_error("CommandLineParser::getStr(): Unknown option '" + longOption + "'!");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xab60
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xabc8
movq -0x18(%rbp), %rax
addq $0x90, %rax
addq $0x70, %rsp
popq %rbp
retq
movb $0x1, -0x65(%rbp)
movl $0x10, %edi
callq 0x7310
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x3f510(%rip), %rsi     # 0x4a0f5
leaq -0x58(%rbp), %rdi
callq 0xb5b0
jmp 0xabf0
leaq 0x3f4fb(%rip), %rdx     # 0x4a0f2
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xb720
jmp 0xac06
movq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7950
jmp 0xac15
movq -0x70(%rbp), %rdi
movb $0x0, -0x65(%rbp)
movq 0x5f3c4(%rip), %rsi     # 0x69fe8
movq 0x5f365(%rip), %rdx     # 0x69f90
callq 0x79d0
jmp 0xac88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xac6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xac63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x73c0
leaq -0x58(%rbp), %rdi
callq 0x73c0
testb $0x1, -0x65(%rbp)
jne 0xac74
jmp 0xac7d
movq -0x70(%rbp), %rdi
callq 0x74a0
jmp 0xac7f
movq -0x60(%rbp), %rdi
callq 0x7a30
nopl (%rax,%rax)
// File: jovermann[P]streplace/src/CommandLineParser.cpp
// Function: ut1::CommandLineParser::getInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
long long CommandLineParser::getInt(const std::string& longOption) const
{
    std::string value = getStr(longOption);
    const char* end   = nullptr;
    long long   r     = std::strtoll(value.c_str(), const_cast<char**>(&end), 0);
    ut1::skipSpace(end);
    if (end && (end != value.c_str()) && (*end == 0))
    {
        return r;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xab90
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x7280
movq $0x0, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7260
movq %rax, %rdi
leaq -0x40(%rbp), %rsi
xorl %edx, %edx
callq 0x70a0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x12610
cmpq $0x0, -0x40(%rbp)
je 0xad86
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7260
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
je 0xad86
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xad86
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x4c(%rbp)
jmp 0xad95
movq $0x0, -0x8(%rbp)
movl $0x1, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x73c0
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jovermann[P]streplace/src/CommandLineParser.cpp
// Function: ut1::CommandLineParser::getUInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
unsigned long long CommandLineParser::getUInt(const std::string& longOption) const
{
    std::string        value = getStr(longOption);
    const char*        end   = nullptr;
    unsigned long long r     = std::strtoull(value.c_str(), const_cast<char**>(&end), 0);
    ut1::skipSpace(end);
    if (end && (end != value.c_str()) && (*end == 0))
    {
        return r;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xab90
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x7280
movq $0x0, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7260
movq %rax, %rdi
leaq -0x40(%rbp), %rsi
xorl %edx, %edx
callq 0x7820
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x12610
cmpq $0x0, -0x40(%rbp)
je 0xae46
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7260
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
je 0xae46
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xae46
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x4c(%rbp)
jmp 0xae55
movq $0x0, -0x8(%rbp)
movl $0x1, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x73c0
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jovermann[P]streplace/src/CommandLineParser.cpp
// Function: ut1::CommandLineParser::getDouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
double CommandLineParser::getDouble(const std::string& longOption) const
{
    std::string value = getStr(longOption);
    const char* end   = nullptr;
    double      r     = std::strtod(value.c_str(), const_cast<char**>(&end));
    ut1::skipSpace(end);
    if (end && (end != value.c_str()) && (*end == 0))
    {
        return r;
    }
    return 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xab90
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x7280
movq $0x0, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7260
movq %rax, %rdi
leaq -0x40(%rbp), %rsi
callq 0x74c0
movsd %xmm0, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x12610
cmpq $0x0, -0x40(%rbp)
je 0xaf07
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7260
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
je 0xaf07
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xaf07
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movl $0x1, -0x4c(%rbp)
jmp 0xaf16
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movl $0x1, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x73c0
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jovermann[P]streplace/src/CommandLineParser.cpp
// Function: ut1::CommandLineParser::setValue(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&, bool)
void CommandLineParser::setValue(const std::string& longOption, const std::string& value, bool clearList)
{
    Option* option = getOption(longOption);
    if (option)
    {
        if (clearList)
        {
            option->value = "";
        }
        option->setValue(value, listSepChar);
    }
    else
    {
        throw std::runtime_error("CommandLineParser::setValue(): Unknown option '" + longOption + "'!");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq -0x10(%rbp), %rsi
callq 0xb080
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xafa4
testb $0x1, -0x19(%rbp)
je 0xaf87
movq -0x28(%rbp), %rdi
addq $0x90, %rdi
leaq 0x3f10c(%rip), %rsi     # 0x4a08e
callq 0x7850
movq -0x80(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movsbl 0x90(%rax), %edx
callq 0x7d40
jmp 0xb067
movb $0x1, -0x75(%rbp)
movl $0x10, %edi
callq 0x7310
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x3f15f(%rip), %rsi     # 0x4a123
leaq -0x68(%rbp), %rdi
callq 0xb5b0
jmp 0xafcf
leaq 0x3f11c(%rip), %rdx     # 0x4a0f2
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xb720
jmp 0xafe5
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x7950
jmp 0xaff7
movq -0x88(%rbp), %rdi
movb $0x0, -0x75(%rbp)
movq 0x5efdf(%rip), %rsi     # 0x69fe8
movq 0x5ef80(%rip), %rdx     # 0x69f90
callq 0x79d0
jmp 0xb079
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xb051
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xb048
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x73c0
leaq -0x68(%rbp), %rdi
callq 0x73c0
testb $0x1, -0x75(%rbp)
jne 0xb059
jmp 0xb065
movq -0x88(%rbp), %rdi
callq 0x74a0
jmp 0xb070
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x7a30
nopl (%rax)
// File: jovermann[P]streplace/src/CommandLineParser.cpp
// Function: ut1::CommandLineParser::getOption(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
CommandLineParser::Option* CommandLineParser::getOption(const std::string& longOption)
{
    auto it = options.find(longOption);
    if (it == options.end())
    {
        return nullptr;
    }
    return &(it->second);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0xc240
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0xc2a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc270
testb $0x1, %al
jne 0xb0c5
jmp 0xb0cf
movq $0x0, -0x8(%rbp)
jmp 0xb0e0
leaq -0x20(%rbp), %rdi
callq 0xc2d0
addq $0x20, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jovermann[P]streplace/src/CommandLineParser.cpp
// Function: ut1::CommandLineParser::reportErrorAndExit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void CommandLineParser::reportErrorAndExit(const std::string& message, int exitStatus)
{
    if (instance)
    {
        // This is the 99.999% case.
        instance->error(message, exitStatus);
    }
    else
    {
        // We will virtually never end up in this case since an instance of CommandLineOptions should be
        // created as the first thing.
        std::cout << message << "\n";
        std::exit(exitStatus);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, 0x5f871(%rip)     # 0x6a9f8
je 0xb19c
movq 0x5f868(%rip), %rdi     # 0x6a9f8
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0xb0f0
movq -0x8(%rbp), %rsi
movq 0x5ee01(%rip), %rdi     # 0x69fa8
callq 0x7560
movq %rax, %rdi
leaq 0x3eed7(%rip), %rsi     # 0x4a08d
callq 0x75d0
movl -0xc(%rbp), %edi
callq 0x7740
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jovermann[P]streplace/src/MiscUtils.cpp
// Function: ut1::replaceStringInPlace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, 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&)
void replaceStringInPlace(std::string& s, const std::string& from, const std::string& to)
{
    if (!from.empty())
    {
        for (size_t pos = 0;; pos += to.size())
        {
            pos = s.find(from, pos);
            if (pos == std::string::npos)
            {
                break;
            }
            s.replace(pos, from.size(), to);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7990
testb $0x1, %al
jne 0x115c9
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7b60
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0x11587
jmp 0x115c7
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7460
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
callq 0x71f0
movq -0x18(%rbp), %rdi
callq 0x7460
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x11569
jmp 0x115c9
addq $0x30, %rsp
popq %rbp
retq
nop
// File: jovermann[P]streplace/src/MiscUtils.cpp
// Function: ut1::splitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, int)
std::vector<std::string> splitString(const std::string& s, char sep, int maxSplit)
{
    std::vector<std::string> r;

    // Special case: Empty string results in empty list (rather than a list with a single empty string).
    if (s.empty())
    {
        return r;
    }

    for (size_t start = 0;; maxSplit--)
    {
        size_t end = s.find(sep, start);
        if ((end == std::string::npos) || (maxSplit == 0))
        {
            r.push_back(s.substr(start));
            break;
        }
        r.push_back(s.substr(start, end - start));
        start = end + 1;
    }
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x90(%rbp)
movb %dl, %al
movq %rdi, %rdx
movq %rdx, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xb2d0
movq -0x10(%rbp), %rdi
callq 0x7990
testb $0x1, %al
jne 0x11cf4
jmp 0x11d04
movb $0x1, -0x19(%rbp)
movl $0x1, -0x20(%rbp)
jmp 0x11e06
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
movq -0x28(%rbp), %rdx
movsbl %al, %esi
callq 0x77f0
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
je 0x11d30
cmpl $0x0, -0x18(%rbp)
jne 0x11d95
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x50(%rbp), %rdi
movq $-0x1, %rcx
callq 0x7630
jmp 0x11d4a
movq -0x90(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xc080
jmp 0x11d5c
leaq -0x50(%rbp), %rdi
callq 0x73c0
jmp 0x11dfb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x11e28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x73c0
jmp 0x11e28
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
subq %rdx, %rcx
leaq -0x80(%rbp), %rdi
callq 0x7630
jmp 0x11daf
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xc080
jmp 0x11dc1
leaq -0x80(%rbp), %rdi
callq 0x73c0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x11d0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x73c0
jmp 0x11e28
movb $0x1, -0x19(%rbp)
movl $0x1, -0x20(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x11e18
movq -0x90(%rbp), %rdi
callq 0xb3c0
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0xb3c0
movq -0x58(%rbp), %rdi
callq 0x7a30
nopl (%rax)