LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb5e0
movq %rsi, %r14
xorl %r12d, %r12d
leaq 0x15f6c(%rip), %r13     # 0x2149a
leaq 0x15f75(%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 0xb59f
movzbl 0x1(%rdx,%r12), %ecx
cmpl $0xa3, %ecx
jg 0xb582
cmpl $0x84, %ecx
je 0xb5ac
movq %r13, %rsi
cmpl $0x96, %ecx
je 0xb5c5
cmpl $0x9c, %ecx
jne 0xb59f
leaq 0x15f1e(%rip), %rsi     # 0x2149e
jmp 0xb5c5
cmpl $0xa4, %ecx
je 0xb5b5
cmpl $0xb6, %ecx
je 0xb5be
cmpl $0xbc, %ecx
jne 0xb59f
movq %rbp, %rsi
jmp 0xb5c5
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5390
jmp 0xb5d0
leaq 0x15ee3(%rip), %rsi     # 0x21496
jmp 0xb5c5
leaq 0x15ee6(%rip), %rsi     # 0x214a2
jmp 0xb5c5
leaq 0x15ee1(%rip), %rsi     # 0x214a6
movq %rbx, %rdi
callq 0x57c0
incq %r12
incq %r12
movq 0x8(%r14), %rcx
cmpq %rcx, %r12
jb 0xb535
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 0xb608
movq (%r15), %rsi
incq %rsi
callq 0x5410
movq %r14, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O1/jovermann[P]streplace/src/MiscUtils.cpp
// Function: ut1::operator<<(std::ostream&, 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::ostream& operator<<(std::ostream& s, const std::vector<std::string>& v)
{
    s << "{";
    bool first = true;
    for (const auto& elem: v)
    {
        if (!first)
        {
            s << ", ";
        }
        else
        {
            first = false;
        }
        s << expandUnprintable(elem, '"', '"');
    }
    s << "}";
    return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x15e83(%rip), %rsi     # 0x214ae
movl $0x1, %edx
callq 0x54b0
movq (%r15), %r14
movq 0x8(%r15), %r13
cmpq %r13, %r14
je 0xb6b4
movb $0x1, %r12b
leaq 0x18(%rsp), %rbp
leaq 0x8(%rsp), %r15
testb $0x1, %r12b
je 0xb659
xorl %r12d, %r12d
jmp 0xb66d
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x15b3d(%rip), %rsi     # 0x211a5
callq 0x54b0
movq %r15, %rdi
movq %r14, %rsi
movl $0x22, %edx
movl $0x22, %ecx
callq 0xa4a5
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x54b0
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xb6ab
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5410
addq $0x20, %r14
cmpq %r13, %r14
jne 0xb64e
leaq 0x15df5(%rip), %rsi     # 0x214b0
movl $0x1, %edx
movq %rbx, %rdi
callq 0x54b0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xb6f4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5410
movq %rbx, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O1/jovermann[P]streplace/src/MiscUtils.cpp
// Function: ut1::flushTty(std::ostream&)
std::ostream& flushTty(std::ostream& os)
{
    static int stdoutIsATty = -1;
    if (stdoutIsATty < 0)
    {
        stdoutIsATty = !!isatty(1);
    }

    // Do not flush stdout if os is not stdout.
    if (os.rdbuf() != std::cout.rdbuf())
    {
        return os;
    }

    // Flush stdout only if it is connected to a terminal.
    if (stdoutIsATty)
    {
        os << std::flush;
    }

    return os;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x22d21(%rip)     # 0x2e428
jns 0xb720
movl $0x1, %edi
callq 0x5710
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movl %ecx, 0x22d08(%rip)     # 0x2e428
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rbx,%rax), %rax
movq 0x22882(%rip), %rcx     # 0x2dfb8
movq (%rcx), %rdx
movq -0x18(%rdx), %rdx
cmpq 0xe8(%rcx,%rdx), %rax
jne 0xb758
cmpl $0x0, 0x22cda(%rip)     # 0x2e428
je 0xb758
movq %rbx, %rdi
callq 0x52d0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/jovermann[P]streplace/src/MiscUtils.cpp
// Function: ut1::readFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string readFile(const std::string& filename)
{
    std::ifstream is(filename, std::ios::in | std::ios::binary | std::ios::ate);
    if (!is)
    {
        throw std::runtime_error("readFile(" + filename + "): Error while opening file for reading.");
    }
    size_t size = is.tellg();
    is.seekg(0, is.beg);
    std::string r(size, '\0');
    is.read(&r[0], size);
    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movl $0xe, %edx
callq 0x5680
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x60(%rsp,%rax)
jne 0xb7ea
leaq 0x40(%rsp), %rdi
callq 0x56f0
movq %rax, %r14
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x55b0
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x54e0
movq (%rbx), %rsi
leaq 0x40(%rsp), %rdi
movq %r14, %rdx
callq 0x5530
leaq 0x40(%rsp), %rdi
callq 0x50b0
movq %rbx, %rax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x51e0
movq %rax, %rbx
leaq 0x15cb4(%rip), %rsi     # 0x214b2
leaq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x8929
leaq 0x15caa(%rip), %rsi     # 0x214bc
leaq 0x20(%rsp), %rdi
callq 0x57c0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xb83d
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0xb849
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x5690
xorl %ebp, %ebp
movq 0x22779(%rip), %rsi     # 0x2dff0
movq 0x2271a(%rip), %rdx     # 0x2df98
movq %rbx, %rdi
callq 0x56e0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xb8a7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5410
jmp 0xb8a7
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb8ca
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x5410
jmp 0xb8ca
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xb8f8
movq %rbx, %rdi
callq 0x5310
jmp 0xb8f8
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xb8f8
movq (%r15), %rsi
incq %rsi
callq 0x5410
jmp 0xb8f8
jmp 0xb8f5
jmp 0xb8f5
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x50b0
movq %r14, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O1/jovermann[P]streplace/src/MiscUtils.cpp
// Function: ut1::writeFile(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 writeFile(const std::string& filename, const std::string& data)
{
    std::ofstream os(filename, std::ios::out | std::ios::binary | std::ios::trunc);
    if (!os)
    {
        throw std::runtime_error("writeFile(" + filename + "): Error while opneing file for writing.");
    }
    os.write(data.data(), data.size());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x34, %edx
callq 0x57e0
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x68(%rsp,%rax)
jne 0xb991
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq 0x48(%rsp), %rdi
callq 0x5580
movq 0x22630(%rip), %rax     # 0x2df88
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x50(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x48(%rsp,%rcx)
callq 0x5380
leaq 0x140(%rsp), %rdi
callq 0x5130
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x51e0
movq %rax, %rbx
leaq 0x15b40(%rip), %rsi     # 0x214e5
leaq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0x8929
leaq 0x15b37(%rip), %rsi     # 0x214f0
leaq 0x28(%rsp), %rdi
callq 0x57c0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xb9e4
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0xb9f1
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%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 0x225cf(%rip), %rsi     # 0x2dff0
movq 0x22570(%rip), %rdx     # 0x2df98
movq %rbx, %rdi
callq 0x56e0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xba52
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5410
jmp 0xba52
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xba75
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5410
jmp 0xba75
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xba87
movq %rbx, %rdi
callq 0x5310
jmp 0xba87
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x5610
movq %r14, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O1/jovermann[P]streplace/src/MiscUtils.cpp
// Function: ut1::getFileType(std::filesystem::__cxx11::directory_entry const&, bool)
FileType getFileType(const std::filesystem::directory_entry& entry, bool followSymlinks)
{
    // First check for symlink.
    // is_symlink() never follows symlinks, while all other is_*() functions follow symlinks.
    if (entry.is_symlink())
    {
        // Report broken symlinks as symlink, even  when when following symlinks.
        if ((!followSymlinks) || (!entry.exists()))
        {
            return FT_SYMLINK;
        }
    }
    if (entry.is_regular_file())
    {
        return FT_REGULAR;
    }
    else if (entry.is_directory())
    {
        return FT_DIR;
    }
    else if (entry.is_fifo())
    {
        return FT_FIFO;
    }
    else if (entry.is_block_file())
    {
        return FT_BLOCK;
    }
    else if (entry.is_character_file())
    {
        return FT_CHAR;
    }
    else if (entry.is_socket())
    {
        return FT_SOCKET;
    }
    else
    {
        return FT_NON_EXISTING;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movb 0x28(%rdi), %al
testb %al, %al
jne 0xbab2
movq %rbx, %rdi
callq 0x56d0
cmpb $0x3, %al
jne 0xbae3
movl $0x2, %ebp
testb %r14b, %r14b
je 0xbb9a
movzbl 0x28(%rbx), %eax
cmpl $0x3, %eax
je 0xbad1
testl %eax, %eax
jne 0xbad9
movq %rbx, %rdi
callq 0x5180
decb %al
cmpb $-0x3, %al
ja 0xbb9a
movzbl 0x28(%rbx), %eax
cmpl $0x3, %eax
je 0xbaf0
testl %eax, %eax
jne 0xbaf8
movq %rbx, %rdi
callq 0x5180
xorl %ebp, %ebp
cmpb $0x1, %al
je 0xbb9a
movzbl 0x28(%rbx), %eax
cmpl $0x3, %eax
je 0xbb0f
testl %eax, %eax
jne 0xbb17
movq %rbx, %rdi
callq 0x5180
movl $0x1, %ebp
cmpb $0x2, %al
je 0xbb9a
movzbl 0x28(%rbx), %eax
cmpl $0x3, %eax
je 0xbb2d
testl %eax, %eax
jne 0xbb35
movq %rbx, %rdi
callq 0x5180
movl $0x3, %ebp
cmpb $0x6, %al
je 0xbb9a
movzbl 0x28(%rbx), %eax
cmpl $0x3, %eax
je 0xbb4b
testl %eax, %eax
jne 0xbb53
movq %rbx, %rdi
callq 0x5180
movl $0x4, %ebp
cmpb $0x4, %al
je 0xbb9a
movzbl 0x28(%rbx), %eax
cmpl $0x3, %eax
je 0xbb69
testl %eax, %eax
jne 0xbb71
movq %rbx, %rdi
callq 0x5180
movl $0x5, %ebp
cmpb $0x5, %al
je 0xbb9a
movzbl 0x28(%rbx), %eax
cmpl $0x3, %eax
je 0xbb87
testl %eax, %eax
jne 0xbb8f
movq %rbx, %rdi
callq 0x5180
xorl %ebp, %ebp
cmpb $0x7, %al
sete %bpl
xorl $0x7, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jovermann[P]streplace/src/MiscUtils.cpp
// Function: ut1::getFileType(std::filesystem::__cxx11::path const&, bool)
FileType getFileType(const std::filesystem::path& entry, bool followSymlinks)
{
    // First check for symlink.
    // is_symlink() never follows symlinks, while all other is_*() functions follow symlinks.
    if (std::filesystem::is_symlink(entry))
    {
        // Report broken symlinks as symlink, even when following symlinks.
        if ((!followSymlinks) || (!std::filesystem::exists(entry)))
        {
            return FT_SYMLINK;
        }
    }
    if (std::filesystem::is_regular_file(entry))
    {
        return FT_REGULAR;
    }
    else if (std::filesystem::is_directory(entry))
    {
        return FT_DIR;
    }
    else if (std::filesystem::is_fifo(entry))
    {
        return FT_FIFO;
    }
    else if (std::filesystem::is_block_file(entry))
    {
        return FT_BLOCK;
    }
    else if (std::filesystem::is_character_file(entry))
    {
        return FT_CHAR;
    }
    else if (std::filesystem::is_socket(entry))
    {
        return FT_SOCKET;
    }
    else
    {
        return FT_NON_EXISTING;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
callq 0x56d0
cmpb $0x3, %al
jne 0xbbd4
movl $0x2, %ebp
testb %r14b, %r14b
je 0xbc39
movq %rbx, %rdi
callq 0x5180
testb %al, %al
je 0xbc39
movzbl %al, %eax
cmpl $0xff, %eax
je 0xbc39
movq %rbx, %rdi
callq 0x5180
xorl %ebp, %ebp
cmpb $0x1, %al
je 0xbc39
movq %rbx, %rdi
callq 0x5180
movl $0x1, %ebp
cmpb $0x2, %al
je 0xbc39
movq %rbx, %rdi
callq 0x5180
movl $0x3, %ebp
cmpb $0x6, %al
je 0xbc39
movq %rbx, %rdi
callq 0x5180
movl $0x4, %ebp
cmpb $0x4, %al
je 0xbc39
movq %rbx, %rdi
callq 0x5180
movl $0x5, %ebp
cmpb $0x5, %al
je 0xbc39
movq %rbx, %rdi
callq 0x5180
xorl %ebp, %ebp
cmpb $0x7, %al
sete %bpl
xorl $0x7, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jovermann[P]streplace/src/MiscUtils.cpp
// Function: ut1::getFileTypeStr[abi:cxx11](ut1::FileType)
std::string getFileTypeStr(FileType fileType)
{
    switch (fileType)
    {
    case FT_REGULAR: return "file";
    case FT_DIR: return "dir";
    case FT_SYMLINK: return "symlink";
    case FT_FIFO: return "fifo";
    case FT_BLOCK: return "block-device";
    case FT_CHAR: return "char-device";
    case FT_SOCKET: return "socket";
    case FT_NON_EXISTING: return "non-existing";
    }
    return "unknown-file-type";
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x7, %esi
ja 0xbd03
movl %esi, %eax
leaq 0x1577e(%rip), %rcx     # 0x213f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x16eb0(%rip), %rsi     # 0x22b3a
leaq 0x16ead(%rip), %rdx     # 0x22b3e
jmp 0xbd11
leaq 0x15884(%rip), %rsi     # 0x2151e
leaq 0x15889(%rip), %rdx     # 0x2152a
jmp 0xbd11
leaq 0x16ea0(%rip), %rsi     # 0x22b4a
leaq 0x16ea0(%rip), %rdx     # 0x22b51
jmp 0xbd11
leaq 0x1585f(%rip), %rsi     # 0x21519
leaq 0x1585c(%rip), %rdx     # 0x2151d
jmp 0xbd11
leaq 0x15874(%rip), %rsi     # 0x2153e
leaq 0x15879(%rip), %rdx     # 0x2154a
jmp 0xbd11
leaq 0x16e82(%rip), %rsi     # 0x22b5c
leaq 0x16e7e(%rip), %rdx     # 0x22b5f
jmp 0xbd11
leaq 0x15841(%rip), %rsi     # 0x2152b
leaq 0x15845(%rip), %rdx     # 0x21536
jmp 0xbd11
leaq 0x1583d(%rip), %rsi     # 0x21537
leaq 0x1583c(%rip), %rdx     # 0x2153d
jmp 0xbd11
leaq 0x15841(%rip), %rsi     # 0x2154b
leaq 0x1584b(%rip), %rdx     # 0x2155c
movq %rbx, %rdi
callq 0x90b2
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/jovermann[P]streplace/src/MiscUtils.cpp
// Function: ut1::setLastWriteTime(std::filesystem::__cxx11::directory_entry const&, std::chrono::time_point<std::filesystem::__file_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>, bool)
void setLastWriteTime(const std::filesystem::directory_entry& entry, std::filesystem::file_time_type newTime, bool followSymlinks)
{
    auto sec = std::chrono::time_point_cast<std::chrono::seconds>(newTime);
    auto nsec = std::chrono::time_point_cast<std::chrono::nanoseconds>(newTime) - std::chrono::time_point_cast<std::chrono::nanoseconds>(sec);

    struct timespec t[2];
    t[0].tv_sec = 0;
    t[0].tv_nsec = UTIME_OMIT;
    t[1].tv_sec = sec.time_since_epoch().count();
    t[1].tv_nsec = nsec.count();

    utimensat(AT_FDCWD, entry.path().c_str(), t, followSymlinks ? 0 : AT_SYMLINK_NOFOLLOW);
}

// Assembly:
subq $0x28, %rsp
movl %edx, %ecx
movabsq $0x112e0be826d694b3, %rdx # imm = 0x112E0BE826D694B3
movq %rsi, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1a, %rdx
addq %rax, %rdx
imulq $-0x3b9aca00, %rdx, %r8 # imm = 0xC4653600
addq %rsi, %r8
movq %rsp, %rax
movq $0x0, (%rax)
movq $0x3ffffffe, 0x8(%rax)  # imm = 0x3FFFFFFE
movq %rdx, 0x10(%rax)
movq %r8, 0x18(%rax)
movq (%rdi), %rsi
xorb $0x1, %cl
movzbl %cl, %ecx
shll $0x8, %ecx
movl $0xffffff9c, %edi       # imm = 0xFFFFFF9C
movq %rax, %rdx
callq 0x5250
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jovermann[P]streplace/src/streplace.cpp
// Function: Streplace::applyAllRules(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long*)
std::string applyAllRules(const std::string& input, size_t* numMatchesOut = nullptr)
    {
        std::string r = input;
        size_t numMatches = 0;
        for (Rule& rule: rules)
        {
            numMatches += applyRule(r, rule);
        }
        if (numMatchesOut)
        {
            *numMatchesOut = numMatches;
        }
        return r;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rbp
movq %rbp, (%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x9022
movq 0x18(%r15), %r12
movq 0x20(%r15), %r13
cmpq %r13, %r12
je 0x11159
movq %rbp, (%rsp)
xorl %ebp, %ebp
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x11c1e
addq %rax, %rbp
addq $0x48, %r12
cmpq %r13, %r12
jne 0x1113d
jmp 0x1115b
xorl %ebp, %ebp
testq %r14, %r14
je 0x11163
movq %rbp, (%r14)
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 (%rsp), %rdi
je 0x11190
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x5410
movq %r14, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O1/jovermann[P]streplace/src/streplace.cpp
// Function: Streplace::applyRule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, Rule&)
uint64_t applyRule(std::string& s, Rule& rule)
    {
        size_t numMatches = 0;

        s = ut1::regex_replace(s, std::regex(rule.lhs), [&](const std::smatch& match)
            { return replaceMatch(match, rule, numMatches); });

        rule.numMatches += numMatches;
        return numMatches;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rsp), %r13
movq $0x0, (%r13)
leaq 0x60(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
movl $0x10, %edx
callq 0x12054
movq %r15, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
movq %r13, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x28(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x11cee
leaq 0x40(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5500
movq (%r15), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x11cb5
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x5410
leaq 0x60(%rsp), %rdi
callq 0x120b8
movq 0x20(%rsp), %rax
addq %rax, 0x40(%rbx)
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x120b8
movq %rbx, %rdi
callq 0x5720
// File: /workspace/github_cpp_makefile_star2_O1/jovermann[P]streplace/src/streplace.cpp
// Function: Streplace::skipDir(std::filesystem::__cxx11::path const&)
bool skipDir(const std::filesystem::path& dir)
    {
        if (all)
        {
            return false;
        }

        if (dir.filename() == ".git")
        {
            return true;
        }

        return false;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpb $0x0, 0x2(%rdi)
je 0x20986
xorl %ebx, %ebx
jmp 0x20a2e
movq %rsi, %rbx
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x209e8
movq 0x20(%rbx), %rax
testb $0x3, %al
je 0x209af
andl $0x3, %eax
cmpl $0x3, %eax
jne 0x209e8
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x110aa
jmp 0x209f0
movq (%rbx), %rdx
cmpb $0x2f, -0x1(%rdx,%rcx)
je 0x209e8
testb $0x3, %al
je 0x209c1
xorl %eax, %eax
jmp 0x209ca
leaq 0x20(%rbx), %rdi
callq 0x5290
leaq -0x30(%rax), %rsi
testb $0x3, 0x20(%rbx)
cmovneq %rax, %rsi
cmovneq %rbx, %rsi
movl 0x20(%rsi), %eax
notl %eax
testb $0x3, %al
jne 0x209e8
movq %rsp, %rdi
jmp 0x209a8
movq %rsp, %rdi
callq 0x11bf6
leaq 0x20f6(%rip), %rsi      # 0x22aed
leaq 0x28(%rsp), %rdi
movl $0x2, %edx
callq 0x20a4e
movq %rsp, %r14
leaq 0x28(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x53e0
testl %eax, %eax
sete %bl
movq %r15, %rdi
callq 0xe0dc
movq %r14, %rdi
callq 0xe0dc
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xe0dc
movq %rbx, %rdi
callq 0x5720
nop
// File: /workspace/github_cpp_makefile_star2_O1/jovermann[P]streplace/src/streplace.cpp
// Function: Streplace::getFileTypeStr(std::filesystem::__cxx11::directory_entry const&)
std::string getFileTypeStr(const std::filesystem::directory_entry& directoryEntry)
    {
        if ((!followLinks) && directoryEntry.is_symlink())
        {
            return "symlink";
        }
        else if (directoryEntry.is_regular_file())
        {
            return "file";
        }
        else if (directoryEntry.is_directory())
        {
            return "directory";
        }
        else if (directoryEntry.is_block_file())
        {
            return "block device";
        }
        else if (directoryEntry.is_character_file())
        {
            return "characters device";
        }
        else if (directoryEntry.is_fifo())
        {
            return "fifo";
        }
        else if (directoryEntry.is_socket())
        {
            return "socket";
        }
        else
        {
            // Will never get here.
            return "unknown file type";
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
cmpb $0x0, 0x1(%rsi)
jne 0x20b14
movb 0x28(%r14), %al
testb %al, %al
jne 0x20af6
movq %r14, %rdi
callq 0x56d0
cmpb $0x3, %al
jne 0x20b14
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2042(%rip), %rsi      # 0x22b4a
leaq 0x2042(%rip), %rdx      # 0x22b51
jmp 0x20c51
movzbl 0x28(%r14), %eax
cmpl $0x3, %eax
je 0x20b22
testl %eax, %eax
jne 0x20b2a
movq %r14, %rdi
callq 0x5180
cmpb $0x1, %al
jne 0x20b48
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1ffe(%rip), %rsi      # 0x22b3a
leaq 0x1ffb(%rip), %rdx      # 0x22b3e
jmp 0x20c51
movzbl 0x28(%r14), %eax
cmpl $0x3, %eax
je 0x20b56
testl %eax, %eax
jne 0x20b5e
movq %r14, %rdi
callq 0x5180
cmpb $0x2, %al
jne 0x20b7c
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1f8c(%rip), %rsi      # 0x22afc
leaq 0x1f8e(%rip), %rdx      # 0x22b05
jmp 0x20c51
movzbl 0x28(%r14), %eax
cmpl $0x3, %eax
je 0x20b8a
testl %eax, %eax
jne 0x20b92
movq %r14, %rdi
callq 0x5180
cmpb $0x4, %al
jne 0x20bb0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1f62(%rip), %rsi      # 0x22b06
leaq 0x1f67(%rip), %rdx      # 0x22b12
jmp 0x20c51
movzbl 0x28(%r14), %eax
cmpl $0x3, %eax
je 0x20bbe
testl %eax, %eax
jne 0x20bc6
movq %r14, %rdi
callq 0x5180
cmpb $0x5, %al
jne 0x20be1
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1f3b(%rip), %rsi      # 0x22b13
leaq 0x1f45(%rip), %rdx      # 0x22b24
jmp 0x20c51
movzbl 0x28(%r14), %eax
cmpl $0x3, %eax
je 0x20bef
testl %eax, %eax
jne 0x20bf7
movq %r14, %rdi
callq 0x5180
cmpb $0x6, %al
jne 0x20c12
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x910(%rip), %rsi       # 0x21519
leaq 0x90d(%rip), %rdx       # 0x2151d
jmp 0x20c51
movzbl 0x28(%r14), %eax
cmpl $0x3, %eax
je 0x20c20
testl %eax, %eax
jne 0x20c28
movq %r14, %rdi
callq 0x5180
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
cmpb $0x7, %al
jne 0x20c43
leaq 0x8fd(%rip), %rsi       # 0x21537
leaq 0x8fc(%rip), %rdx       # 0x2153d
jmp 0x20c51
leaq 0x1edb(%rip), %rsi      # 0x22b25
leaq 0x1ee5(%rip), %rdx      # 0x22b36
movq %rbx, %rdi
callq 0x90b2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tylerkaraszewski[P]Argyle/Server.cpp
// Function: Server::initSocketList()
void Server::initSocketList()
{
  m_socketCount = 1;
  free(m_sockets);
  m_sockets = (struct pollfd*)malloc(sizeof(struct pollfd) * m_socketCount);
  if (m_sockets == 0)
  {
    m_logger.logError("InitSocketList malloc error: Out of Memory");
    exit(1);
  }
  m_sockets[0].fd = m_mainSocket;
  m_sockets[0].events = POLLIN;
  m_sockets[0].revents = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x1, 0x10(%rdi)
movq 0x8(%rdi), %rdi
callq 0x3330
movslq 0x10(%rbx), %rdi
shlq $0x3, %rdi
callq 0x3380
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x499b
movl (%rbx), %ecx
movl %ecx, (%rax)
movl $0x1, 0x4(%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x58(%rbx), %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x76c9(%rip), %rsi      # 0xc078
leaq 0x76ec(%rip), %rdx      # 0xc0a2
movq %rsp, %r14
movq %r14, %rdi
callq 0x513e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xac26
movq %rsp, %rdi
callq 0x35a8
movl $0x1, %edi
callq 0x3350
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x49f7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O1/tylerkaraszewski[P]Argyle/Server.cpp
// Function: Server::watchSocket(int)
void Server::watchSocket(int socket)
{
  if (socket < 0)
  {
    // not a real socket, do nothing.
    return;
  }


  m_socketCount++;
  m_sockets = (struct pollfd*)realloc(m_sockets, sizeof(struct pollfd) * m_socketCount);
  if (m_sockets == 0)
  {
    // Try and log the error and close the socket. Maybe someone will free some RAM.
    // In all likelihood, we're hosed if we even get here, though.
    m_logger.logError("InitSocketList realloc error: Out of Memory");
    shutdown(socket, SHUT_RDWR);
    close(socket);
    return;
  }
  m_sockets[m_socketCount - 1].fd = socket;
  m_sockets[m_socketCount - 1].events = POLLIN;
  m_sockets[m_socketCount - 1].revents = 0;
  m_connections[socket] = new Connection(socket, m_logger, m_config);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, 0xc(%rsp)
testl %esi, %esi
js 0x4c45
movq %rdi, %rbx
movslq 0x10(%rdi), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x10(%rdi)
movq 0x8(%rdi), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x34d0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x4be5
movl 0xc(%rsp), %ebp
movslq 0x10(%rbx), %rcx
movl %ebp, -0x8(%rax,%rcx,8)
movl $0x1, -0x4(%rax,%rcx,8)
movl $0x80, %edi
callq 0x3280
movq %rax, %r14
movq 0x58(%rbx), %rdx
movq 0x60(%rbx), %rcx
movq %rax, %rdi
movl %ebp, %esi
callq 0x52ec
addq $0x18, %rbx
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x4d3c
movq %r14, (%rax)
jmp 0x4c45
movq 0x58(%rbx), %rbx
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x74aa(%rip), %rsi      # 0xc0a3
leaq 0x74ce(%rip), %rdx      # 0xc0ce
leaq 0x10(%rsp), %rdi
callq 0x513e
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xac26
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x4c2e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3290
movl 0xc(%rsp), %edi
movl $0x2, %esi
callq 0x33a0
movl 0xc(%rsp), %edi
callq 0x3580
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x4c7a
movq 0x20(%rsp), %rsi
incq %rsi
jmp 0x4c75
movq %rax, %rbx
jmp 0x4c7a
movq %rax, %rbx
movl $0x80, %esi
movq %r14, %rdi
callq 0x3290
movq %rbx, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O1/tylerkaraszewski[P]Argyle/Server.cpp
// Function: Server::~Server()
Server::~Server()
{
  vector<int> socketsToUnwatch;
  for (int i = 0; i < m_socketCount; ++i)
  {
    socketsToUnwatch.push_back(m_sockets[i].fd);
  }
  unwatchSockets(socketsToUnwatch);
  free(m_sockets);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
cmpl $0x0, 0x10(%rdi)
jle 0x4cef
xorl %r15d, %r15d
movq %rsp, %r14
xorl %r12d, %r12d
movq 0x8(%rbx), %rdx
addq %r15, %rdx
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x4cd7
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x4cdf
movq %r14, %rdi
callq 0x4dfc
incq %r12
movslq 0x10(%rbx), %rax
addq $0x8, %r15
cmpq %rax, %r12
jl 0x4cb5
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4a00
movq 0x8(%rbx), %rdi
callq 0x3330
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4d19
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3290
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x4dac
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4d33
movq %rax, %rdi
callq 0x4da0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tylerkaraszewski[P]Argyle/main.cpp
// Function: main
int main(int argc, char *argv[])
{
  signal(SIGPIPE, SIG_IGN);
  signal(SIGINT, sigHandler);
  signal(SIGTERM, sigHandler);

  if (daemon(0, 0) == -1)
  {
    return 5; // No logfiles yet.
  }

  Config config(configPath);
  Logger logger(config);
  logger.open();
  
  server = new Server(80, logger, config);
  if (!server->bindPort())
  {
    return 1;
  }
  if (!logger.open())
  {
    return 2;
  }
  else if (!setUser(config.getString(Config::S_KEY_RUN_AS_USERNAME).c_str(), logger))
  {
    return 3;
  }
  else if (!server->start())
  {
    return 4;
  }
  //@TODO: Set user back to root so Server destructor can clean up effectively (may not be nessecary?).
  delete server;
  server = NULL;
  logger.close();
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl $0x1, %esi
movl $0xd, %edi
callq 0x3320
leaq -0x792(%rip), %rbx      # 0x61d0
movl $0x2, %edi
movq %rbx, %rsi
callq 0x3320
movl $0xf, %edi
movq %rbx, %rsi
callq 0x3320
xorl %edi, %edi
xorl %esi, %esi
callq 0x3340
cmpl $-0x1, %eax
je 0x6af5
movq 0x9953(%rip), %rsi      # 0x102e8
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x6b6e
leaq 0x38(%rsp), %rdi
movq %rsp, %rsi
callq 0xae40
leaq 0x10(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x69ca
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3290
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xa8ac
leaq 0x20(%rsp), %rdi
callq 0xa8b8
movl $0x68, %edi
callq 0x3280
movq %rax, %r14
leaq 0x20(%rsp), %rdx
leaq 0x38(%rsp), %rcx
movq %rax, %rdi
movl $0x50, %esi
callq 0x3a3c
movq %r14, 0x98f2(%rip)      # 0x10300
movq %r14, %rdi
callq 0x3a80
movl $0x1, %ebx
testb %al, %al
je 0x6acb
leaq 0x20(%rsp), %rdi
callq 0xa8b8
movl $0x2, %ebx
testb %al, %al
je 0x6acb
leaq 0x99a7(%rip), %rdx      # 0x103e8
movq %rsp, %rdi
leaq 0x38(%rsp), %rsi
callq 0xb59a
movq (%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x61e1
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6a74
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3290
movl $0x3, %ebx
testb %bpl, %bpl
je 0x6acb
movq 0x987b(%rip), %rdi      # 0x10300
callq 0x4076
movl $0x4, %ebx
testb %al, %al
je 0x6acb
movq 0x9866(%rip), %rbx      # 0x10300
testq %rbx, %rbx
je 0x6ab4
movq %rbx, %rdi
callq 0x4c88
movl $0x68, %esi
movq %rbx, %rdi
callq 0x3290
movq $0x0, 0x9841(%rip) # 0x10300
xorl %ebx, %ebx
leaq 0x20(%rsp), %rdi
callq 0xa99a
leaq 0x58(%rsp), %r14
movq %r14, %rdi
callq 0x613e
movq -0x20(%r14), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x6afa
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3290
jmp 0x6afa
movl $0x5, %ebx
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6b5c
movq 0x10(%rsp), %rsi
incq %rsi
jmp 0x6b2d
jmp 0x6b59
movq %rax, %rbx
movl $0x68, %esi
movq %r14, %rdi
callq 0x3290
jmp 0x6b5c
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b66
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3290
jmp 0x6b66
movq %rax, %rbx
jmp 0x6b66
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x6bac
movq %rbx, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O1/tylerkaraszewski[P]Argyle/HttpRequest.cpp
// Function: HttpRequest::getHeader(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
string HttpRequest::getHeader(const string& headerName) const
{
  string lcHeader = headerName;
  toLower(lcHeader);
  HeaderMap::const_iterator it = m_headers.find(lcHeader);
  if (it == m_headers.end())
  {
    return "";
  }
  else
  {
    return it->second;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x773e
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x760b
movq 0x8(%rsp), %r13
xorl %ebp, %ebp
movsbl (%r13,%rbp), %edi
callq 0x33d0
movb %al, (%r13,%rbp)
incq %rbp
cmpq %rbp, %r15
jne 0x75f3
leaq 0x70(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x7a14
addq $0x78, %r14
cmpq %r14, %rax
je 0x763e
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x773e
jmp 0x7657
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4b14(%rip), %rdx      # 0xc160
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x513e
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x766e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3290
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7682
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x769c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O1/tylerkaraszewski[P]Argyle/HttpResponse.cpp
// Function: HttpResponse::unescapeUri(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string HttpResponse::unescapeUri(const string& escapedUri)
{
  string unescaped;
  if (escapedUri.size() == 0)
  {
    return unescaped;
  }
  for (size_t i = 0; i < escapedUri.size(); i++)
  {
    if (escapedUri[i] == '%')
    {
      if (escapedUri.size() >= (i + 3))
      {
        string escapedChar = escapedUri.substr(i + 1, 2);
        long value = strtol(escapedChar.c_str(), NULL, 16);
        unescaped += static_cast<unsigned char>(value);
        i += 2; // skip the encoded block now.
      }
      else
      {
        return unescaped; // Error, return what we've got.
      }
    }
    else
    {
      unescaped += escapedUri[i];
    }
  }
  return unescaped;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpq $0x0, 0x8(%rsi)
je 0x8781
movq %rsi, %r14
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x8781
leaq 0x18(%rsp), %r13
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq (%r14), %rcx
movb (%rcx,%rbp), %cl
cmpb $0x25, %cl
jne 0x876a
leaq 0x3(%rbp), %rcx
cmpq %rcx, %rax
jb 0x8781
leaq 0x1(%rbp), %rdx
movl $0x2, %ecx
movq %r15, %rdi
movq %r14, %rsi
callq 0x32b0
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x33c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3220
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x8764
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3290
addq $0x2, %rbp
jmp 0x8775
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x3220
incq %rbp
movq 0x8(%r14), %rax
cmpq %rax, %rbp
jb 0x8709
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x87b4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3290
jmp 0x87b4
jmp 0x87b1
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x87c8
movq (%r12), %rsi
incq %rsi
callq 0x3290
movq %r14, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O1/tylerkaraszewski[P]Argyle/HttpResponse.cpp
// Function: HttpResponse::isGone(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool HttpResponse::isGone(const string& path)
{
  if (
    (path == "/boat/rss.xml") ||
    (path == "/Sparrow.html") ||
    (path == "/atom.xml"))
  {
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3afe(%rip), %rsi      # 0xc2db
callq 0x30d0
movb $0x1, %bpl
testl %eax, %eax
je 0x8811
leaq 0x3af9(%rip), %rsi      # 0xc2e9
movq %rbx, %rdi
callq 0x30d0
testl %eax, %eax
je 0x8811
leaq 0x3af4(%rip), %rsi      # 0xc2f7
movq %rbx, %rdi
callq 0x30d0
testl %eax, %eax
sete %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tylerkaraszewski[P]Argyle/HttpResponse.cpp
// Function: HttpResponse::pathLooksSafe(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool HttpResponse::pathLooksSafe(const string& path)
{
  if (path.size() == 0)
  {
    return false;
  }
  if (path[0] != '/')
  {
    return false;
  }
  if (path.find("/../") != path.npos)
  {
    return false;
  }
  for (size_t i = 0; i < path.size(); ++i)
  {
    if ((path[i] < 32) || (path[i] > 126))
    {
      return false;
    }
  }
  return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
je 0x888e
movq %rdi, %r14
movq (%rdi), %rax
cmpb $0x2f, (%rax)
jne 0x888e
leaq 0x3a9f(%rip), %rsi      # 0xc2d6
xorl %ebx, %ebx
movl $0x4, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x3500
cmpq $-0x1, %rax
jne 0x8890
movq 0x8(%r14), %rax
testq %rax, %rax
sete %bl
je 0x8890
movq (%r14), %rcx
movb (%rcx), %dl
addb $-0x7f, %dl
cmpb $-0x5f, %dl
jb 0x8890
movl $0x1, %esi
movq %rsi, %rdx
cmpq %rsi, %rax
je 0x8886
movb (%rcx,%rdx), %dil
addb $-0x7f, %dil
leaq 0x1(%rdx), %rsi
cmpb $-0x60, %dil
ja 0x886c
cmpq %rax, %rdx
setae %bl
jmp 0x8890
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tylerkaraszewski[P]Argyle/HttpResponse.cpp
// Function: HttpResponse::read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long)
size_t HttpResponse::read(string& buffer, const size_t maxBytesToRead)
{
  size_t remaining = maxBytesToRead;
  if (!m_headerBuffer.empty())
  {
    string temp = m_headerBuffer.substr(0, maxBytesToRead);
    buffer.append(temp);
    remaining -= temp.size();
    if (remaining == 0)
    {
      return temp.size();
    }
  }
  return m_reader->read(buffer, remaining);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x40(%rdi)
je 0x8935
leaq 0x38(%r15), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x32b0
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r14, %rdi
callq 0x30f0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
movq -0x8(%rax), %r12
subq %r12, %rbx
cmpq %rax, %rdi
je 0x8930
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3290
testq %rbx, %rbx
je 0x8948
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%rax)
movq %rax, %r12
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8975
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O1/tylerkaraszewski[P]Argyle/FilenameResolver.cpp
// Function: FilenameResolver::resolveDir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Config const&, long*)
string FilenameResolver::resolveDir(const string& dirPath, const Config& config, time_t* mtime)
{
  string temp;
  string rPath = dirPath;
  rPath = resolve(dirPath + "/main.html", config, temp, mtime);
  if (!rPath.empty())
  {
    return rPath;
  }

  return findNewestInDir(dirPath, config);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x773e
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x773e
leaq 0x358c(%rip), %rsi      # 0xc30e
leaq 0x28(%rsp), %rdi
callq 0x3560
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rcx
movq %r14, %rdx
movq %r12, %r8
callq 0x8a8c
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %r12
movq %r12, %rsi
callq 0x3360
movq (%r12), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x8dd3
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x3290
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x8dea
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3290
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x8e13
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x8(%rsp), %rdx
cmpq %rbp, %rdx
je 0x8e23
movq %rdx, (%rbx)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x8e2a
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x8eec
jmp 0x8e41
movups (%rbp), %xmm0
movups %xmm0, (%rcx)
movq %rax, 0x8(%rbx)
movq %rbp, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x8e58
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3290
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x8e74
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3290
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8ea9
jmp 0x8e8d
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x8eac
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3290
jmp 0x8eac
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x8ec8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3290
jmp 0x8ec8
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x8ee4
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x3520
// File: /workspace/github_cpp_makefile_star2_O1/tylerkaraszewski[P]Argyle/FileReader.cpp
// Function: FileReader::readFromInternalBufferString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long)
size_t FileReader::readFromInternalBufferString(string& internalBuffer, string& externalBuffer, const size_t maxBytes)
{
  int bytesRead = 0;
  if (internalBuffer.size() != 0)
  {
    string temp = internalBuffer.substr(0, maxBytes);
    bytesRead = temp.size();
    internalBuffer = internalBuffer.substr(bytesRead);
    externalBuffer += temp;
  }
  return bytesRead;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpq $0x0, 0x8(%rsi)
je 0x9e32
movq %rdx, %r14
movq %rsi, %r15
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x32b0
movslq 0x8(%rbx), %rbx
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq $-0x1, %rcx
callq 0x32b0
leaq 0x28(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x3360
movq (%r12), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x9e03
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3290
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x30f0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9e34
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3290
jmp 0x9e34
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x9e45
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9e63
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x3520
nop
// File: /workspace/github_cpp_makefile_star2_O1/tylerkaraszewski[P]Argyle/FileReader.cpp
// Function: FileReader::~FileReader()
FileReader::~FileReader()
{
  if (m_file)
  {
    if (fclose(m_file))
    {
      m_logger.logError("FileReader fclose error(" + Utils::llToString(errno) + "): " + strerror(errno));
    }
    m_file = NULL;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x5e99(%rip), %rax      # 0xfd20
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0xa047
callq 0x3270
testl %eax, %eax
je 0xa03f
movq 0x70(%rbx), %r14
callq 0x3040
movq %rax, %r15
movslq (%rax), %rsi
leaq 0x68(%rsp), %rdi
callq 0xac34
leaq 0x255c(%rip), %rcx      # 0xc420
leaq 0x68(%rsp), %rdi
movl $0x18, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x32e0
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x9eff
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x9f07
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x2104(%rip), %rsi      # 0xc02e
callq 0x3560
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x9f56
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x9f5d
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %r12
movq %rdx, 0x8(%r12)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl (%r15), %edi
callq 0x3120
movq %r12, %rdi
movq %rax, %rsi
callq 0x3560
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x9fb4
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x9fbb
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r14, %rdi
callq 0xac26
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x9ff6
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3290
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0xa00d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3290
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xa024
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3290
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa03f
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x3290
movq $0x0, 0x20(%rbx)
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0xa05f
movq (%rax), %rsi
incq %rsi
callq 0x3290
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0xa077
movq (%rax), %rsi
incq %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x8a86
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x4da0
nop