LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/taurheim[P]AgNES/codeGenerator.cpp
// Function: CodeGenerator::deallocateStackSpace(int)
void CodeGenerator::deallocateStackSpace(int size) {
    if (size == 0) return;
    loadConstIntoA(size);
    code << "CLC" << nl; //Set stupid carry
    code << "ADC " << cSP << nl;
    code << "STA " << cSP << nl;
}

// Assembly:
testl %esi, %esi
je 0x10fb1
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x10d7c
leaq 0x80(%rbx), %r14
leaq 0x1abd(%rip), %rsi      # 0x129e8
movl $0x3, %edx
movq %r14, %rdi
callq 0x32d0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x32d0
leaq 0x1b83(%rip), %rsi      # 0x12ad1
movl $0x4, %edx
movq %r14, %rdi
callq 0x32d0
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r14, %rdi
callq 0x32d0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %rax, %rdi
callq 0x32d0
leaq 0x19c2(%rip), %rsi      # 0x12943
movl $0x4, %edx
movq %r14, %rdi
callq 0x32d0
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r14, %rdi
callq 0x32d0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x32d0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movl %edx, %r14d
movq %rdi, %rbx
leaq -0x190(%rbp), %r15
movq %r15, %rdi
callq 0x3310
movq (%r15), %rax
movq -0x18(%rax), %rcx
movq $0x4, -0x180(%rbp,%rcx)
movq -0x18(%rax), %rax
leaq (%rax,%rbp), %r15
addq $-0x190, %r15           # imm = 0xFE70
cmpb $0x0, 0xe1(%r15)
jne 0x11018
movq %r15, %rdi
movl $0x20, %esi
callq 0x3260
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
leaq -0x190(%rbp), %rdi
movl %r14d, %esi
callq 0x3410
leaq -0x188(%rbp), %rsi
movq %rbx, %rdi
callq 0x33a0
movq 0x8(%rbx), %rdx
cmpq $0x5, %rdx
jb 0x11056
addq $-0x4, %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x30b0
movq 0x6f6b(%rip), %rsi      # 0x17fc8
leaq -0x190(%rbp), %rdi
callq 0x3170
leaq -0x120(%rbp), %rdi
callq 0x3100
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x1109f
callq 0x3250
jmp 0x1109f
movq %rax, %r14
movq 0x6f22(%rip), %rsi      # 0x17fc8
leaq -0x190(%rbp), %rdi
callq 0x3170
leaq -0x120(%rbp), %rdi
callq 0x3100
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %esi, %esi
je 0x1117a
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x100, %eax            # imm = 0x100
subl %esi, %eax
movl %eax, %esi
callq 0x10d7c
leaq 0x80(%rbx), %r14
leaq 0x18f4(%rip), %rsi      # 0x129e8
movl $0x3, %edx
movq %r14, %rdi
callq 0x32d0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x32d0
leaq 0x19ba(%rip), %rsi      # 0x12ad1
movl $0x4, %edx
movq %r14, %rdi
callq 0x32d0
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r14, %rdi
callq 0x32d0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %rax, %rdi
callq 0x32d0
leaq 0x17f9(%rip), %rsi      # 0x12943
movl $0x4, %edx
movq %r14, %rdi
callq 0x32d0
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r14, %rdi
callq 0x32d0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x32d0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/schneebergerlab[P]DrLink/analyze_molecule.cpp
// Function: decipher_cigar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int decipher_cigar(string cigar)
{
    // CIGAR alphabet: M I D N S H P; * = X: 23S23M1D8M1I16M1D29M
    char *cstr = (char*)cigar.c_str();
    string numstr("");
    int covlen = 0;
    for (int i=0; i<cigar.size(); i++)
    {
        if(cstr[i]>='0' && cstr[i]<='9')
        {
            numstr += cstr[i];
        }
        else
        if(cstr[i] == 'M' || cstr[i] == 'I'|| cstr[i] == 'D'|| cstr[i] == 'N'|| 
           cstr[i] == 'S' || cstr[i] == 'H'|| cstr[i] == 'P')
        {
            if(cstr[i] == 'M' || cstr[i] == 'D')
            {
                covlen += atoi(numstr.c_str());
            }
            numstr.clear();
        }
    }    
    return covlen;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %r12
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x33a08(%rip), %rdx     # 0x3eb0a
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x5384
cmpq $0x0, 0x8(%rbx)
je 0xb180
xorl %r13d, %r13d
leaq 0x8(%rsp), %r14
movl $0x9430, %r15d          # imm = 0x9430
xorl %ebp, %ebp
movzbl (%r12,%r13), %eax
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0xb140
movsbl %al, %esi
movq %r14, %rdi
callq 0x42b0
jmp 0xb175
addl $-0x44, %eax
cmpl $0xf, %eax
ja 0xb175
btl %eax, %r15d
jb 0xb164
movl $0x201, %ecx            # imm = 0x201
btl %eax, %ecx
jae 0xb175
movq 0x8(%rsp), %rdi
callq 0x44d0
addl %eax, %ebp
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
incq %r13
cmpq %r13, 0x8(%rbx)
ja 0xb126
jmp 0xb182
xorl %ebp, %ebp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb19e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4340
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb1ce
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4340
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
callq 0x21d6e
movb $0x1, %bl
cmpq %rdx, %rax
je 0x1e85b
movq %rdx, %r12
movq 0x40(%rax), %rdx
movq 0x48(%rax), %rcx
cmpq %r15, %rdx
seta %sil
cmpq %r15, %rcx
setb %dil
orb %sil, %dil
cmpb $0x1, %dil
jne 0x1e859
cmpq %r14, %rdx
seta %dl
cmpq %r14, %rcx
setb %cl
orb %dl, %cl
cmpb $0x1, %cl
jne 0x1e859
movq %rax, %rdi
callq 0x4230
cmpq %r12, %rax
jne 0x1e818
jmp 0x1e85b
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %esi, %esi
jle 0x364cc
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movabsq $-0x7bdef7bdef7bdef7, %r15 # imm = 0x8421084210842109
leaq 0x8a15(%rip), %r12      # 0x3eea0
callq 0x40e0
movslq %eax, %rcx
movq %rcx, %rax
shrq %rax
mulq %r15
shrq $0x4, %rdx
movq %rdx, %rax
shlq $0x6, %rax
addq %rdx, %rdx
subq %rax, %rdx
addq %rcx, %rdx
movsbl (%r12,%rdx), %esi
movq %r14, %rdi
callq 0x42b0
decl %ebx
jne 0x3648b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3440
movq (%r14), %rsi
movq %r15, %rdi
movl $0x10, %edx
callq 0x3050
movq 0x2a8(%rbx), %rsi
movq 0x2b0(%rbx), %rdx
leaq 0x8(%rsp), %rdi
callq 0x32e0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3260
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
movq 0x290(%rbx), %rax
cmpq %rax, 0x298(%rbx)
je 0x4adc
xorl %r12d, %r12d
leaq 0x8(%rsp), %r14
movl (%rax,%r12,4), %esi
movq %r14, %rdi
callq 0x31c0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3260
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
incq %r12
movq 0x290(%rbx), %rax
movq 0x298(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
ja 0x4a89
leaq 0x8(%rsp), %rdi
callq 0x33a0
movq 0x94d3(%rip), %rax      # 0xdfc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x3220
leaq 0x100(%rsp), %rdi
callq 0x30f0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4b29
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x33c0
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x32d0
movq (%r14), %rsi
movq %r15, %rdi
movl $0x8, %edx
callq 0x3190
leaq 0x2a8(%rbx), %r14
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x3340
movq 0x2b0(%rbx), %rax
testq %rax, %rax
je 0x4bae
movq (%r14), %rcx
xorl %edx, %edx
xorl %r14d, %r14d
xorl %esi, %esi
cmpb $0x31, (%rcx,%rdx)
sete %sil
addl %esi, %r14d
incq %rdx
cmpq %rdx, %rax
jne 0x4b97
jmp 0x4bb1
xorl %r14d, %r14d
leal (%r14,%r14), %ecx
movl $0x1, %esi
shll %cl, %esi
leaq 0x290(%rbx), %rdi
movq %rsp, %rdx
movl $0x0, (%rdx)
callq 0x4da0
movl %r14d, %esi
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rsp, %rdi
movl $0x4e, %edx
callq 0x32f0
leaq 0x270(%rbx), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x3310
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x4c11
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3290
movq 0x290(%rbx), %rsi
cmpq %rsi, 0x298(%rbx)
je 0x4c58
xorl %r15d, %r15d
leaq 0x20(%rsp), %r14
xorl %r12d, %r12d
addq %r15, %rsi
movq %r14, %rdi
callq 0x3470
incq %r12
movq 0x290(%rbx), %rsi
movq 0x298(%rbx), %rax
subq %rsi, %rax
sarq $0x2, %rax
addq $0x4, %r15
cmpq %r12, %rax
ja 0x4c2c
leaq 0x20(%rsp), %rdi
callq 0x3090
leaq 0x20(%rsp), %rdi
callq 0x30c0
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4c83
jmp 0x4c83
jmp 0x4c83
jmp 0x4c83
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
testl %edx, %edx
je 0x4d66
movq %rdi, %r14
leaq 0x270(%rdi), %r15
leaq 0x268(%rdi), %r12
movl %edx, %r13d
xorl %ebx, %ebx
xorl %ebp, %ebp
movq 0x2b0(%r14), %rcx
movq %rcx, %rdx
imulq %rbx, %rdx
movq %rsp, %rdi
movq 0x20(%rsp), %rsi
callq 0x32a0
movq 0x8(%rsp), %rdx
testq %rdx, %rdx
je 0x4d1f
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x2a8(%r14), %rsi
cmpb $0x31, (%rsi,%rax)
jne 0x4d17
movq (%rsp), %rdx
movb (%rdx,%rax), %dl
movl %ecx, %esi
movq (%r15), %rdi
movb %dl, (%rdi,%rsi)
incl %ecx
movq 0x8(%rsp), %rdx
incq %rax
cmpq %rax, %rdx
ja 0x4cf4
movl 0x278(%r14), %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x979a
movl %eax, %eax
movq 0x290(%r14), %rcx
addl (%rcx,%rax,4), %ebp
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x4d58
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3290
incq %rbx
cmpq %r13, %rbx
jne 0x4ccb
jmp 0x4d68
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x4d97
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6808(%rip), %rdi      # 0xa320
callq 0x3410
testl %eax, %eax
jne 0x3b69
leaq 0x67c0(%rip), %rdi      # 0xa2e8
movq %r14, %rsi
callq 0x597c
leaq 0x67b1(%rip), %rdi      # 0xa2e8
movq %r14, %rsi
testq %rax, %rax
je 0x3b51
callq 0x5e6a
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31b0
jmp 0x3b59
movq %rbx, %rdx
callq 0x5aa8
leaq 0x67c0(%rip), %rdi      # 0xa320
popq %rbx
popq %r14
popq %rbp
jmp 0x3230
movl %eax, %edi
callq 0x31e0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x679c(%rip), %rdi      # 0xa320
callq 0x3410
testl %eax, %eax
jne 0x3bc9
leaq 0x6754(%rip), %rdi      # 0xa2e8
movq %r14, %rsi
callq 0x597c
movq %rax, %r14
testq %rax, %rax
je 0x3bb0
leaq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x31b0
testq %r14, %r14
setne %bl
leaq 0x6763(%rip), %rdi      # 0xa320
callq 0x3230
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl %eax, %edi
callq 0x31e0
// File: /workspace/github_cpp_makefile_star2_O3/Lartu[P]coraldb/source/map_functions.cpp
// Function: drop_key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void drop_key(const std::string &key)
{
    /* Erases the element with the key from the dictionary.
     * Time complexity:
     * - Average: O(1)
     * - Worst case: O(n)
     */
    global_db_mutex.lock();
    global_db.erase(key);
    global_db_mutex.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6740(%rip), %rdi      # 0xa320
callq 0x3410
testl %eax, %eax
jne 0x3c0a
leaq 0x66f8(%rip), %rdi      # 0xa2e8
movq %rbx, %rsi
callq 0x5fb0
leaq 0x6721(%rip), %rdi      # 0xa320
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3230
movl %eax, %edi
callq 0x31e0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x66ff(%rip), %rdi      # 0xa320
callq 0x3410
testl %eax, %eax
jne 0x3c54
leaq 0x66b7(%rip), %rdi      # 0xa2e8
movq %rbx, %rsi
callq 0x597c
testq %rax, %rax
setne %bl
leaq 0x66da(%rip), %rdi      # 0xa320
callq 0x3230
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %eax, %edi
callq 0x31e0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x59f5(%rip), %rdi      # 0xa370
leaq 0x28c3(%rip), %rsi      # 0x7245
callq 0x3350
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
jne 0x4a7d
callq 0x3040
movq %rax, %r14
movl (%rax), %r15d
movq 0x5649(%rip), %rbx      # 0x9ff0
leaq 0x289a(%rip), %rsi      # 0x7248
movl $0x29, %edx
movq %rbx, %rdi
callq 0x3330
movq 0x59ae(%rip), %rsi      # 0xa370
movq 0x59af(%rip), %rdx      # 0xa378
movq %rbx, %rdi
callq 0x3330
movq %rax, %rbx
cmpl $0xd, %r15d
jne 0x49e8
leaq 0x2891(%rip), %rsi      # 0x7272
movl $0x14, %edx
jmp 0x4a49
leaq 0x26fa(%rip), %rsi      # 0x70e9
movl $0x2, %edx
movq %rbx, %rdi
callq 0x3330
movl (%r14), %edi
callq 0x3110
testq %rax, %rax
je 0x4a24
movq %rax, %r14
movq %rax, %rdi
callq 0x3150
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3330
jmp 0x4a3d
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %rbx, %rdi
addq %rax, %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x3470
leaq 0x2841(%rip), %rsi      # 0x7285
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3330
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3200
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Lartu[P]coraldb/source/checkpoint.cpp
// Function: checkpoint_handler()
void checkpoint_handler()
{
    /* This function waits until it's time for the checkpoint. When it is,
     * it requests the saving of the checkpoint file.
     */
    while (true)
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(CHECKPOINT_TIME));
        save_datafile();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
leaq -0x18(%rbp), %rbx
movslq 0x5804(%rip), %rax      # 0xa2a0
testq %rax, %rax
jle 0x4ae1
movl %eax, %ecx
imulq $0x10624dd3, %rcx, %rcx # imm = 0x10624DD3
shrq $0x26, %rcx
imulq $-0x3e8, %rcx, %rdx     # imm = 0xFC18
addq %rax, %rdx
imulq $0xf4240, %rdx, %rax    # imm = 0xF4240
movq %rcx, -0x18(%rbp)
movq %rax, -0x10(%rbp)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x30d0
cmpl $-0x1, %eax
jne 0x4ae1
callq 0x3040
cmpl $0x4, (%rax)
je 0x4ac7
callq 0x44c1
jmp 0x4a95
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
callq 0x4ae8
movq 0x5438(%rip), %rbx      # 0x9fd0
leaq 0x2760(%rip), %rsi      # 0x72ff
movl $0x19, %edx
movq %rbx, %rdi
callq 0x3330
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3200
leaq 0x273f(%rip), %rsi      # 0x7319
movl $0x24, %edx
movq %rbx, %rdi
callq 0x3330
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3200
leaq 0x2729(%rip), %rsi      # 0x733e
movl $0x2b, %edx
movq %rbx, %rdi
callq 0x3330
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3200
leaq 0x271a(%rip), %rsi      # 0x736a
movl $0x36, %edx
movq %rbx, %rdi
callq 0x3330
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3200
leaq 0x2716(%rip), %rsi      # 0x73a1
movl $0x3b, %edx
movq %rbx, %rdi
callq 0x3330
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3200
leaq 0x2717(%rip), %rsi      # 0x73dd
movl $0x2b, %edx
movq %rbx, %rdi
callq 0x3330
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3200
leaq 0x2708(%rip), %rsi      # 0x7409
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x3330
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3200
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
callq 0x4d3b
testl %eax, %eax
jne 0x5583
callq 0x4ae8
callq 0x496a
testl %eax, %eax
je 0x558f
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x4761
leaq -0xb13(%rip), %rsi      # 0x4a88
leaq -0x10(%rbp), %rbx
movq %rbx, %rdi
callq 0x578e
movq %rbx, %rdi
callq 0x3490
callq 0x53a4
cmpq $0x0, -0x10(%rbp)
jne 0x55c3
movq %rax, %rdi
callq 0x34a0
callq 0x30b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xa310
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x828f
movl 0xf0(%rax), %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x51e0
movq %rax, %rbx
leaq 0x18e3b(%rip), %rsi     # 0x210de
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x89cc
leaq 0x18e57(%rip), %rsi     # 0x2110e
leaq 0x8(%rsp), %rdi
callq 0x57c0
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x82e2
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x82ef
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x5690
xorl %ebp, %ebp
movq 0x25cc9(%rip), %rsi     # 0x2dfe8
movq 0x25c6a(%rip), %rdx     # 0x2df90
movq %rbx, %rdi
callq 0x56e0
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x8348
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5410
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8363
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5410
testb %bpl, %bpl
jne 0x838d
jmp 0x8395
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x838d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5410
jmp 0x838d
movq %rax, %r14
movq %rbx, %rdi
callq 0x5310
movq %r14, %rdi
callq 0x5720
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xa310
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x83ed
addq $0xd0, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x51e0
movq %rax, %rbx
leaq 0x18d10(%rip), %rsi     # 0x21111
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x89cc
leaq 0x18cf9(%rip), %rsi     # 0x2110e
leaq 0x8(%rsp), %rdi
callq 0x57c0
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x8440
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x844d
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x5690
xorl %ebp, %ebp
movq 0x25b6b(%rip), %rsi     # 0x2dfe8
movq 0x25b0c(%rip), %rdx     # 0x2df90
movq %rbx, %rdi
callq 0x56e0
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x84a6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5410
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x84c1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5410
testb %bpl, %bpl
jne 0x84eb
jmp 0x84f3
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x84eb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5410
jmp 0x84eb
movq %rax, %r14
movq %rbx, %rdi
callq 0x5310
movq %r14, %rdi
callq 0x5720
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
callq 0x83be
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x90dc
movq %rsp, %r15
movq $0x0, (%r15)
movq (%r14), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x5070
movq %rax, %rbx
movq %r15, %rdi
callq 0xb136
movq (%r15), %rax
testq %rax, %rax
sete %cl
movq (%r14), %rdi
cmpq %rdi, %rax
sete %dl
orb %cl, %dl
jne 0x85a2
cmpb $0x0, (%rax)
je 0x85a4
xorl %ebx, %ebx
cmpq %r12, %rdi
je 0x85b6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5410
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
callq 0x83be
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x90dc
movq %rsp, %r15
movq $0x0, (%r15)
movq (%r14), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x5590
movq %rax, %rbx
movq %r15, %rdi
callq 0xb136
movq (%r15), %rax
testq %rax, %rax
sete %cl
movq (%r14), %rdi
cmpq %rdi, %rax
sete %dl
orb %cl, %dl
jne 0x8634
cmpb $0x0, (%rax)
je 0x8636
xorl %ebx, %ebx
cmpq %r12, %rdi
je 0x8648
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5410
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
callq 0x83be
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x90dc
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x5330
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0xb136
movq (%r14), %rax
testq %rax, %rax
sete %cl
movq (%rbx), %rdi
cmpq %rdi, %rax
sete %dl
orb %cl, %dl
jne 0x86c5
cmpb $0x0, (%rax)
je 0x86ee
xorps %xmm0, %xmm0
cmpq %r15, %rdi
je 0x86e4
movq 0x20(%rsp), %rsi
incq %rsi
movsd %xmm0, (%rsp)
callq 0x5410
movsd (%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movsd (%rsp), %xmm0
jmp 0x86c8
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
callq 0xa310
movq %rax, %r15
leaq 0x8(%r14), %rax
cmpq %rax, %r15
je 0x8765
testb %bpl, %bpl
je 0x8742
leaq 0xd0(%r15), %rdi
movq 0xd8(%r15), %rdx
leaq 0x18972(%rip), %rcx     # 0x210aa
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x5630
addq $0x40, %r15
movsbl 0x90(%r14), %edx
movq %r15, %rdi
movq %rbx, %rsi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5b4c
movl $0x10, %edi
callq 0x51e0
movq %rax, %rbx
leaq 0x189c6(%rip), %rsi     # 0x2113f
movq %rsp, %rdi
movq %r12, %rdx
callq 0x89cc
leaq 0x18983(%rip), %rsi     # 0x2110e
movq %rsp, %rdi
callq 0x57c0
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x87b4
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x87c1
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x5690
xorl %ebp, %ebp
movq 0x257f7(%rip), %rsi     # 0x2dfe8
movq 0x25798(%rip), %rdx     # 0x2df90
movq %rbx, %rdi
callq 0x56e0
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x881a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x5410
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8835
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5410
testb %bpl, %bpl
jne 0x885f
jmp 0x8867
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x885f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5410
jmp 0x885f
movq %rax, %r14
movq %rbx, %rdi
callq 0x5310
movq %r14, %rdi
callq 0x5720
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
callq 0xa310
addq $0x8, %rbx
leaq 0x40(%rax), %rdx
xorl %ecx, %ecx
cmpq %rbx, %rax
cmovneq %rdx, %rcx
movq %rcx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movl %esi, %ebx
movq %rdi, %rsi
movq 0x25f47(%rip), %rdi     # 0x2e848
testq %rdi, %rdi
jne 0x8928
movq 0x256a3(%rip), %rdi     # 0x2dfb0
callq 0x53b0
leaq 0x18790(%rip), %rsi     # 0x210a9
movq %rax, %rdi
callq 0x53f0
movl %ebx, %edi
callq 0x54f0
movl %ebx, %edx
callq 0x8890
nop
// File: /workspace/github_cpp_makefile_star2_O3/jovermann[P]streplace/src/MiscUtils.cpp
// Function: ut1::splitString(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)
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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, (%rsp)
movq $0x0, 0x10(%rdi)
cmpq $0x0, 0x8(%rsi)
je 0xac99
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx
xorl %r12d, %r12d
movq %r14, %rdi
xorl %edx, %edx
callq 0x5700
movq %rax, %rbx
cmpq $-0x1, %rax
sete %al
testl %ebp, %ebp
sete %cl
orb %al, %cl
jne 0xac59
decl %ebp
xorl %r12d, %r12d
leaq 0x8(%rsp), %r13
movq %rbx, %rcx
subq %r12, %rcx
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5450
movq (%rsp), %rdi
movq %r13, %rsi
callq 0x9efa
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xac2e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5410
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %rbx, %r12
addq %rcx, %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0x5700
movq %rax, %rbx
addl $-0x1, %ebp
setb %al
cmpq $-0x1, %rbx
je 0xac59
testb %al, %al
jne 0xabf2
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq $-0x1, %rcx
callq 0x5450
leaq 0x8(%rsp), %rsi
movq (%rsp), %rdi
callq 0x9efa
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xac99
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5410
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
jmp 0xacce
jmp 0xacbc
movq %rax, %rbx
jmp 0xace0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xace0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5410
movq (%rsp), %rdi
callq 0x896e
movq %rbx, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O3/jovermann[P]streplace/src/MiscUtils.cpp
// Function: ut1::joinStrings(std::vector<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>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string joinStrings(const std::vector<std::string>& stringList, const std::string& sep)
{
    std::stringstream r;
    if (!stringList.empty())
    {
        r << stringList[0];
        for (size_t i = 1; i < stringList.size(); i++)
        {
            r << sep << stringList[i];
        }
    }
    return r.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x52f0
movq (%r15), %rax
cmpq 0x8(%r15), %rax
je 0xb0cf
leaq 0x10(%rsp), %r12
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r12, %rdi
callq 0x54b0
movq 0x8(%r15), %rax
subq (%r15), %rax
cmpq $0x21, %rax
jb 0xb0cf
movl $0x1, %r13d
movl $0x28, %ebp
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0x54b0
movq (%r15), %rcx
movq -0x8(%rcx,%rbp), %rsi
movq (%rcx,%rbp), %rdx
movq %rax, %rdi
callq 0x54b0
movq 0x8(%r15), %rax
subq (%r15), %rax
incq %r13
sarq $0x5, %rax
addq $0x20, %rbp
cmpq %rax, %r13
jb 0xb095
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x5660
movq 0x22e7d(%rip), %rsi     # 0x2df60
movq %rsp, %rdi
callq 0x5320
leaq 0x80(%rsp), %rdi
callq 0x5130
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb10f
movq %rax, %rbx
movq 0x22e47(%rip), %rsi     # 0x2df60
movq %rsp, %rdi
callq 0x5320
leaq 0x80(%rsp), %rdi
callq 0x5130
movq %rbx, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O3/jovermann[P]streplace/src/MiscUtils.cpp
// Function: ut1::capitalize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string capitalize(std::string s)
{
    s = tolower(s);
    if (!s.empty())
    {
        s[0] = char(std::toupper(unsigned(s[0])));
    }
    return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x90dc
movq (%r15), %r13
movq 0x8(%r15), %r15
testq %r15, %r15
je 0xb2ca
xorl %ebp, %ebp
movzbl (%r13,%rbp), %edi
callq 0x55f0
movb %al, (%r13,%rbp)
incq %rbp
cmpq %rbp, %r15
jne 0xb2ad
movq 0x8(%rsp), %r13
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
cmpq %r12, %r13
je 0xb2e9
movq %r13, 0x28(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0xb2f2
movups (%r12), %xmm0
movups %xmm0, (%rbp)
movq 0x10(%rsp), %rax
leaq 0x28(%rsp), %r15
movq %rax, 0x8(%r15)
movq %r12, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5500
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0xb333
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5410
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xb34a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5410
cmpq $0x0, 0x8(%rbx)
je 0xb360
movq (%rbx), %r15
movsbl (%r15), %edi
callq 0x5770
movb %al, (%r15)
leaq 0x10(%r14), %rcx
movq %rcx, (%r14)
movq (%rbx), %rdx
leaq 0x10(%rbx), %rax
cmpq %rax, %rdx
je 0xb37f
movq %rdx, (%r14)
movq (%rax), %rcx
movq %rcx, 0x10(%r14)
jmp 0xb385
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jovermann[P]streplace/src/MiscUtils.cpp
// Function: ut1::quoteRegexChars(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string quoteRegexChars(const std::string& s)
{
    std::string       r;
    const std::string special = "[](){}^$.*+|?\\";
    for (char c: s)
    {
        if (special.find(c) != std::string::npos)
        {
            r += '\\';
        }
        r += c;
    }
    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x1607e(%rip), %rsi     # 0x21487
leaq 0x16085(%rip), %rdx     # 0x21495
leaq 0x8(%rsp), %rdi
callq 0x9172
movq 0x8(%r14), %r13
testq %r13, %r13
je 0xb464
movq (%r14), %r12
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
movsbl (%r12,%r15), %ebp
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x5570
cmpq $-0x1, %rax
je 0xb452
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x5390
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5390
incq %r15
cmpq %r15, %r13
jne 0xb42e
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb480
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5410
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xb4b6
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb4b6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5410
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0xb4ce
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x5410
movq %r14, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O3/jovermann[P]streplace/src/MiscUtils.cpp
// Function: ut1::toNfd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string toNfd(const std::string& s)
{
    // This only works for german umlauts so far.
    std::string r;
    for (size_t i = 0; i < s.length(); i++)
    {
        if ((s[i] == '\xc3') && (i < s.length() - 1))
        {
            switch (s[i + 1])
            {
            case '\x84': r += "A\xcc\x88"; i++; continue;
            case '\x96': r += "O\xcc\x88"; i++; continue;
            case '\x9c': r += "U\xcc\x88"; i++; continue;
            case '\xa4': r += "a\xcc\x88"; i++; continue;
            case '\xb6': r += "o\xcc\x88"; i++; continue;
            case '\xbc': r += "u\xcc\x88"; i++; continue;
            }
        }
        r += s[i];
    }
    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0xb5c3
movq %rsi, %r14
xorl %r12d, %r12d
leaq 0x15f89(%rip), %r13     # 0x2149a
leaq 0x15f92(%rip), %rbp     # 0x214aa
movq (%r14), %rdx
movb (%rdx,%r12), %al
cmpb $-0x3d, %al
setne %sil
decq %rcx
cmpq %rcx, %r12
setae %cl
orb %sil, %cl
jne 0xb582
movzbl 0x1(%rdx,%r12), %ecx
cmpl $0xa3, %ecx
jg 0xb565
cmpl $0x84, %ecx
je 0xb58f
movq %r13, %rsi
cmpl $0x96, %ecx
je 0xb5a8
cmpl $0x9c, %ecx
jne 0xb582
leaq 0x15f3b(%rip), %rsi     # 0x2149e
jmp 0xb5a8
cmpl $0xa4, %ecx
je 0xb598
cmpl $0xb6, %ecx
je 0xb5a1
cmpl $0xbc, %ecx
jne 0xb582
movq %rbp, %rsi
jmp 0xb5a8
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5390
jmp 0xb5b3
leaq 0x15f00(%rip), %rsi     # 0x21496
jmp 0xb5a8
leaq 0x15f03(%rip), %rsi     # 0x214a2
jmp 0xb5a8
leaq 0x15efe(%rip), %rsi     # 0x214a6
movq %rbx, %rdi
callq 0x57c0
incq %r12
incq %r12
movq 0x8(%r14), %rcx
cmpq %rcx, %r12
jb 0xb518
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xb5eb
movq (%r15), %rsi
incq %rsi
callq 0x5410
movq %r14, %rdi
callq 0x5720