LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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)
std::vector<std::string> splitString(const std::string& s, const std::string& sep, int maxSplit)
{
    std::vector<std::string> r;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
callq 0xb2d0
movq -0x10(%rbp), %rdi
callq 0x7990
testb $0x1, %al
jne 0x11e83
jmp 0x11e93
movb $0x1, -0x1d(%rbp)
movl $0x1, -0x24(%rbp)
jmp 0x11fb8
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x7b60
movq %rax, -0x38(%rbp)
cmpq $-0x1, -0x38(%rbp)
je 0x11ebd
cmpl $0x0, -0x1c(%rbp)
jne 0x11f22
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x58(%rbp), %rdi
movq $-0x1, %rcx
callq 0x7630
jmp 0x11ed7
movq -0x98(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xc080
jmp 0x11ee9
leaq -0x58(%rbp), %rdi
callq 0x73c0
jmp 0x11fad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x11fda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x73c0
jmp 0x11fda
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
subq %rdx, %rcx
leaq -0x88(%rbp), %rdi
callq 0x7630
jmp 0x11f3f
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xc080
jmp 0x11f54
leaq -0x88(%rbp), %rdi
callq 0x73c0
movq -0x38(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x78e0
movq %rax, %rcx
movq -0xa0(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11e9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x73c0
jmp 0x11fda
movb $0x1, -0x1d(%rbp)
movl $0x1, -0x24(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x11fca
movq -0x98(%rbp), %rdi
callq 0xb3c0
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0xb3c0
movq -0x60(%rbp), %rdi
callq 0x7a30
nop
// File: 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
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1c8(%rbp)
movq %rdi, %rax
movq %rax, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x7470
movq -0x10(%rbp), %rdi
callq 0xc1e0
testb $0x1, %al
jne 0x125c4
leaq -0x190(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13e20
movq -0x1d0(%rbp), %rdi
movq %rax, %rsi
callq 0x7560
jmp 0x12521
movq $0x1, -0x1b8(%rbp)
movq -0x1b8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb550
movq %rax, %rcx
movq -0x1d8(%rbp), %rax
cmpq %rcx, %rax
jae 0x125c2
leaq -0x190(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7560
movq %rax, -0x1e0(%rbp)
jmp 0x1256b
movq -0x10(%rbp), %rdi
movq -0x1b8(%rbp), %rsi
callq 0x13e20
movq -0x1e0(%rbp), %rdi
movq %rax, %rsi
callq 0x7560
jmp 0x1258c
jmp 0x1258e
movq -0x1b8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1b8(%rbp)
jmp 0x1252c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x74b0
jmp 0x125f5
jmp 0x125c4
movq -0x1c8(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x75c0
jmp 0x125d9
leaq -0x1a0(%rbp), %rdi
callq 0x74b0
movq -0x1c0(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0x7a30
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x7280
movq -0x68(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x12660
jmp 0x1289e
movq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7750
leaq -0x30(%rbp), %rdi
callq 0x73c0
leaq -0x50(%rbp), %rdi
callq 0x73c0
movq -0x80(%rbp), %rdi
callq 0x7990
testb $0x1, %al
jne 0x12913
movq -0x80(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7b50
movsbl (%rax), %edi
callq 0x7a90
movq -0x80(%rbp), %rdi
movb %al, -0x81(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x7b50
movb -0x81(%rbp), %cl
movb %cl, (%rax)
jmp 0x12913
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x73c0
jmp 0x1292d
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x73a0
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x7a30
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x7860
leaq -0x39(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x7a50
movq -0x78(%rbp), %rdx
leaq 0x37d5d(%rip), %rsi     # 0x4a71f
leaq -0x38(%rbp), %rdi
callq 0xb310
jmp 0x129cd
leaq -0x39(%rbp), %rdi
callq 0x7670
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x75a0
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x7aa0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x13cf0
testb $0x1, %al
jne 0x12a0e
jmp 0x12a98
leaq -0x60(%rbp), %rdi
callq 0x13d30
movb (%rax), %al
movb %al, -0x69(%rbp)
leaq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl -0x69(%rbp), %esi
callq 0x77f0
cmpq $-0x1, %rax
je 0x12a76
movq -0x88(%rbp), %rdi
movl $0x5c, %esi
callq 0x73f0
jmp 0x12a46
jmp 0x12a76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x7670
jmp 0x12ac4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x73c0
jmp 0x12ac4
movq -0x88(%rbp), %rdi
movsbl -0x69(%rbp), %esi
callq 0x73f0
jmp 0x12a88
jmp 0x12a8a
leaq -0x60(%rbp), %rdi
callq 0x13d80
jmp 0x129f8
movb $0x1, -0x11(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x73c0
testb $0x1, -0x11(%rbp)
jne 0x12ab7
movq -0x88(%rbp), %rdi
callq 0x73c0
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x73c0
movq -0x48(%rbp), %rdi
callq 0x7a30
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x37a48(%rip), %rsi     # 0x4a746
callq 0x75d0
movb $0x1, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbf90
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbfc0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xbff0
testb $0x1, %al
jne 0x12d3f
jmp 0x12dc5
leaq -0x28(%rbp), %rdi
callq 0xc030
movq %rax, -0x38(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x12d64
movq -0x8(%rbp), %rdi
leaq 0x3742c(%rip), %rsi     # 0x4a189
callq 0x75d0
jmp 0x12d68
movb $0x0, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0x22, %ecx
movl %ecx, %edx
callq 0x11660
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x7560
jmp 0x12d97
leaq -0x58(%rbp), %rdi
callq 0x73c0
leaq -0x28(%rbp), %rdi
callq 0xc220
jmp 0x12d29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x73c0
jmp 0x12de2
movq -0x8(%rbp), %rdi
leaq 0x37978(%rip), %rsi     # 0x4a748
callq 0x75d0
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x7a30
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpl $0x0, 0x577d5(%rip)     # 0x6a5d8
jge 0x12e24
movl $0x1, %edi
callq 0x7a10
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x577b4(%rip)     # 0x6a5d8
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x72b0
movq %rax, -0x18(%rbp)
movq 0x57169(%rip), %rax     # 0x69fa8
movq (%rax), %rax
movq 0x5715f(%rip), %rdi     # 0x69fa8
addq -0x18(%rax), %rdi
callq 0x72b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
je 0x12e68
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12e89
cmpl $0x0, 0x57769(%rip)     # 0x6a5d8
je 0x12e81
movq -0x10(%rbp), %rdi
movq 0x57134(%rip), %rsi     # 0x69fb0
callq 0x7650
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x270(%rbp)
movl $0x10, %edi
movl $0x4, %esi
callq 0x13e40
movl %eax, %edi
movl $0x20, %esi
callq 0x13e40
movq -0x270(%rbp), %rsi
movl %eax, %edx
leaq -0x210(%rbp), %rdi
callq 0x7b00
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x72e0
movb %al, -0x262(%rbp)
jmp 0x1323e
movb -0x262(%rbp), %al
testb $0x1, %al
jne 0x1324d
jmp 0x13357
movb $0x1, -0x261(%rbp)
movl $0x10, %edi
callq 0x7310
movq %rax, -0x278(%rbp)
movq -0x8(%rbp), %rdx
leaq 0x3750d(%rip), %rsi     # 0x4a77d
leaq -0x260(%rbp), %rdi
callq 0xb5b0
jmp 0x1327e
leaq 0x37503(%rip), %rdx     # 0x4a788
leaq -0x240(%rbp), %rdi
leaq -0x260(%rbp), %rsi
callq 0xb720
jmp 0x1329a
movq -0x278(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x7950
jmp 0x132af
movq -0x278(%rbp), %rdi
movb $0x0, -0x261(%rbp)
movq 0x56d24(%rip), %rsi     # 0x69fe8
movq 0x56cc5(%rip), %rdx     # 0x69f90
callq 0x79d0
jmp 0x133b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x1339d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x1333e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x13332
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x73c0
leaq -0x260(%rbp), %rdi
callq 0x73c0
testb $0x1, -0x261(%rbp)
jne 0x13349
jmp 0x13355
movq -0x278(%rbp), %rdi
callq 0x74a0
jmp 0x1339d
movq -0x10(%rbp), %rdi
callq 0x77d0
movq %rax, -0x280(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7460
movq -0x280(%rbp), %rsi
movq %rax, %rdx
leaq -0x210(%rbp), %rdi
callq 0x7810
jmp 0x13388
leaq -0x210(%rbp), %rdi
callq 0x78d0
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
leaq -0x210(%rbp), %rdi
callq 0x78d0
movq -0x218(%rbp), %rdi
callq 0x7a30
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13e80
testb $0x1, %al
jne 0x133e3
jmp 0x13404
testb $0x1, -0x11(%rbp)
je 0x133f6
movq -0x10(%rbp), %rdi
callq 0x13ee0
testb $0x1, %al
jne 0x13402
movl $0x2, -0x4(%rbp)
jmp 0x1349b
jmp 0x13404
movq -0x10(%rbp), %rdi
callq 0x13f20
testb $0x1, %al
jne 0x13413
jmp 0x1341c
movl $0x0, -0x4(%rbp)
jmp 0x1349b
movq -0x10(%rbp), %rdi
callq 0x13f50
testb $0x1, %al
jne 0x1342b
jmp 0x13434
movl $0x1, -0x4(%rbp)
jmp 0x1349b
movq -0x10(%rbp), %rdi
callq 0x13f80
testb $0x1, %al
jne 0x13443
jmp 0x1344c
movl $0x3, -0x4(%rbp)
jmp 0x1349b
movq -0x10(%rbp), %rdi
callq 0x13fb0
testb $0x1, %al
jne 0x1345b
jmp 0x13464
movl $0x4, -0x4(%rbp)
jmp 0x1349b
movq -0x10(%rbp), %rdi
callq 0x13fe0
testb $0x1, %al
jne 0x13473
jmp 0x1347c
movl $0x5, -0x4(%rbp)
jmp 0x1349b
movq -0x10(%rbp), %rdi
callq 0x14010
testb $0x1, %al
jne 0x1348b
jmp 0x13494
movl $0x6, -0x4(%rbp)
jmp 0x1349b
movl $0x7, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14040
testb $0x1, %al
jne 0x134d3
jmp 0x134f4
testb $0x1, -0x11(%rbp)
je 0x134e6
movq -0x10(%rbp), %rdi
callq 0x14070
testb $0x1, %al
jne 0x134f2
movl $0x2, -0x4(%rbp)
jmp 0x1358b
jmp 0x134f4
movq -0x10(%rbp), %rdi
callq 0x140a0
testb $0x1, %al
jne 0x13503
jmp 0x1350c
movl $0x0, -0x4(%rbp)
jmp 0x1358b
movq -0x10(%rbp), %rdi
callq 0x140d0
testb $0x1, %al
jne 0x1351b
jmp 0x13524
movl $0x1, -0x4(%rbp)
jmp 0x1358b
movq -0x10(%rbp), %rdi
callq 0x14100
testb $0x1, %al
jne 0x13533
jmp 0x1353c
movl $0x3, -0x4(%rbp)
jmp 0x1358b
movq -0x10(%rbp), %rdi
callq 0x14130
testb $0x1, %al
jne 0x1354b
jmp 0x13554
movl $0x4, -0x4(%rbp)
jmp 0x1358b
movq -0x10(%rbp), %rdi
callq 0x14160
testb $0x1, %al
jne 0x13563
jmp 0x1356c
movl $0x5, -0x4(%rbp)
jmp 0x1358b
movq -0x10(%rbp), %rdi
callq 0x14190
testb $0x1, %al
jne 0x1357b
jmp 0x13584
movl $0x6, -0x4(%rbp)
jmp 0x1358b
movl $0x7, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x142e0
movq %rax, -0x20(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x14370
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x143b0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x14320
movq %rax, -0x28(%rbp)
movq $0x0, -0x60(%rbp)
movq $0x3ffffffe, -0x58(%rbp) # imm = 0x3FFFFFFE
leaq -0x20(%rbp), %rdi
callq 0x143f0
movq %rax, -0x68(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x14410
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x14430
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x141c0
movq %rax, %rdi
callq 0x141d0
movq %rax, %rsi
leaq -0x60(%rbp), %rdx
movb -0x11(%rbp), %dil
movl $0x100, %ecx            # imm = 0x100
xorl %eax, %eax
testb $0x1, %dil
cmovnel %eax, %ecx
movl $0xffffff9c, %edi       # imm = 0xFFFFFF9C
callq 0x7390
addq $0x70, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rsi
callq 0x7280
movq -0x68(%rbp), %rax
movq $0x0, -0x30(%rbp)
addq $0x18, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x1b1c0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x1a940
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1b8f0
testb $0x1, %al
jne 0x1bbac
jmp 0x1bbfe
leaq -0x40(%rbp), %rdi
callq 0x1b6f0
movq -0x68(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdx
callq 0x1cc10
movq %rax, -0x80(%rbp)
jmp 0x1bbd0
movq -0x80(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1b930
jmp 0x1bb99
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x73c0
jmp 0x1bc30
cmpq $0x0, -0x20(%rbp)
je 0x1bc10
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x1bc23
movq -0x78(%rbp), %rdi
callq 0x73c0
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x7a30
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movl $0x10, %edx
callq 0x1d000
movq -0xa0(%rbp), %rax
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x78(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x40(%rbp), %rdi
callq 0x1cd10
jmp 0x1cca4
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x7750
leaq -0x40(%rbp), %rdi
callq 0x73c0
leaq -0x60(%rbp), %rdi
callq 0x1d0b0
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0x40(%rax), %rcx
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1d0b0
movq -0x80(%rbp), %rdi
callq 0x7a30
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x2(%rax)
je 0x47e83
movb $0x0, -0x1(%rbp)
jmp 0x47ef3
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x1b9b0
leaq 0x3f96(%rip), %rsi      # 0x4be2d
leaq -0x68(%rbp), %rdi
movl $0x2, %edx
callq 0x48070
jmp 0x47ea7
leaq -0x40(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x48030
movb %al, -0x75(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x18700
leaq -0x40(%rbp), %rdi
callq 0x18700
movb -0x75(%rbp), %al
testb $0x1, %al
jne 0x47ed2
jmp 0x47eef
movb $0x1, -0x1(%rbp)
jmp 0x47ef3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x18700
jmp 0x47f01
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x7a30
nopw (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x1, 0x10(%rax)
movq 0x8(%rax), %rdi
callq 0x44a0
movq 0x10(%rsp), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
callq 0x4530
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
jne 0x5c92
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq %rax, (%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x46c0
movq 0x8(%rsp), %rdx
leaq 0xd438(%rip), %rsi      # 0x1305c
leaq 0x30(%rsp), %rdi
callq 0x6450
jmp 0x5c30
movq (%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x10f40
jmp 0x5c40
leaq 0x30(%rsp), %rdi
callq 0x4788
leaq 0x2f(%rsp), %rdi
callq 0x4400
movl $0x1, %edi
callq 0x44c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x5c86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4788
leaq 0x2f(%rsp), %rdi
callq 0x4400
jmp 0x5cb8
movq 0x10(%rsp), %rax
movl (%rax), %edx
movq 0x8(%rax), %rcx
movl %edx, (%rcx)
movq 0x8(%rax), %rcx
movw $0x1, 0x4(%rcx)
movq 0x8(%rax), %rax
movw $0x0, 0x6(%rax)
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x5c(%rsp)
jge 0x5f73
jmp 0x60da
movq 0x18(%rsp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq 0x8(%rax), %rdi
movslq 0x10(%rax), %rsi
shlq $0x3, %rsi
callq 0x4660
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
jne 0x6056
movq 0x18(%rsp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x46c0
movq 0x10(%rsp), %rdx
leaq 0xd0b5(%rip), %rsi      # 0x13087
leaq 0x38(%rsp), %rdi
callq 0x6450
jmp 0x5fde
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x10f40
jmp 0x5fef
leaq 0x38(%rsp), %rdi
callq 0x4788
leaq 0x37(%rsp), %rdi
callq 0x4400
movl 0x5c(%rsp), %edi
movl $0x2, %esi
callq 0x4550
movl 0x5c(%rsp), %edi
callq 0x4750
jmp 0x60da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x6047
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x4788
leaq 0x37(%rsp), %rdi
callq 0x4400
jmp 0x60fb
movq 0x18(%rsp), %rcx
movl 0x5c(%rsp), %esi
movq 0x8(%rcx), %rax
movl 0x10(%rcx), %edx
decl %edx
movslq %edx, %rdx
movl %esi, (%rax,%rdx,8)
movq 0x8(%rcx), %rax
movl 0x10(%rcx), %edx
decl %edx
movslq %edx, %rdx
movw $0x1, 0x4(%rax,%rdx,8)
movq 0x8(%rcx), %rax
movl 0x10(%rcx), %ecx
decl %ecx
movslq %ecx, %rcx
movw $0x0, 0x6(%rax,%rcx,8)
movl $0x80, %edi
callq 0x43b0
movq %rax, %rdi
movq 0x18(%rsp), %rax
movq %rdi, %rcx
movq %rcx, (%rsp)
movl 0x5c(%rsp), %esi
movq 0x58(%rax), %rdx
movq 0x60(%rax), %rcx
callq 0x8ab0
jmp 0x60c0
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
leaq 0x5c(%rsp), %rsi
callq 0x6300
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x68, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x80, %esi
callq 0x43c0
movq 0x28(%rsp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x6280
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0x6180
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x14(%rsp), %rcx
leaq (%rax,%rcx,8), %rsi
leaq 0x18(%rsp), %rdi
callq 0x6290
jmp 0x6171
jmp 0x6173
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6145
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x5cd0
jmp 0x6191
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x44a0
leaq 0x18(%rsp), %rdi
callq 0x63f0
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x65d0
addq $0x38, %rsp
retq
movq %rax, %rdi
callq 0x65c0
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x80(%rsp), %rsi
leaq 0x60(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x41b0
movq 0x30(%rsp), %rdi
callq 0xb550
jmp 0xb6ac
movq 0x28(%rsp), %rdi
addq $0x70, %rdi
leaq 0x60(%rsp), %rsi
callq 0xba10
movq %rax, 0x10(%rsp)
jmp 0xb6c6
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
addq $0x70, %rdi
callq 0xba60
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xba40
testb $0x1, %al
jne 0xb6f8
jmp 0xb75d
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x46c0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x7a28(%rip), %rsi      # 0x13140
callq 0x6450
jmp 0xb71f
leaq 0x3f(%rsp), %rdi
callq 0x4400
movl $0x1, 0x38(%rsp)
jmp 0xb782
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0xb799
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x4400
jmp 0xb799
leaq 0x48(%rsp), %rdi
callq 0xb910
movq 0x18(%rsp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x41b0
jmp 0xb77a
movl $0x1, 0x38(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x4788
movq 0x20(%rsp), %rax
addq $0x98, %rsp
retq
leaq 0x60(%rsp), %rdi
callq 0x4788
movq 0x58(%rsp), %rdi
callq 0x46b0
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movb $0x0, 0x67(%rsp)
callq 0x4570
movq 0x68(%rsp), %rdi
callq 0x42a0
cmpq $0x0, %rax
jne 0xd7c7
movb $0x1, 0x67(%rsp)
movl $0x1, 0x60(%rsp)
jmp 0xd915
movq $0x0, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rdi
callq 0x42a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xd908
movq 0x68(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x4420
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0xd8d3
movq 0x68(%rsp), %rdi
callq 0x42a0
movq 0x58(%rsp), %rcx
addq $0x3, %rcx
cmpq %rcx, %rax
jb 0xd8c2
movq 0x68(%rsp), %rsi
movq 0x58(%rsp), %rdx
incq %rdx
leaq 0x38(%rsp), %rdi
movl $0x2, %ecx
callq 0x43d0
jmp 0xd84a
leaq 0x38(%rsp), %rdi
callq 0x4190
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x4580
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
movsbl 0x20(%rsp), %esi
callq 0x4250
jmp 0xd87b
movq 0x58(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x58(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x4788
jmp 0xd8d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0xd930
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x4788
jmp 0xd930
movb $0x1, 0x67(%rsp)
movl $0x1, 0x60(%rsp)
jmp 0xd915
jmp 0xd8f3
movq 0x68(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x4420
movq 0x10(%rsp), %rdi
movsbl (%rax), %esi
callq 0x4250
jmp 0xd8f1
jmp 0xd8f3
jmp 0xd8f5
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0xd7d0
movb $0x1, 0x67(%rsp)
movl $0x1, 0x60(%rsp)
testb $0x1, 0x67(%rsp)
jne 0xd926
movq 0x10(%rsp), %rdi
callq 0x4788
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x4788
movq 0x30(%rsp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x595d(%rip), %rsi      # 0x132c2
callq 0xb7c0
testb $0x1, %al
jne 0xd99a
movq 0x8(%rsp), %rdi
leaq 0x5956(%rip), %rsi      # 0x132d0
callq 0xb7c0
testb $0x1, %al
jne 0xd99a
movq 0x8(%rsp), %rdi
leaq 0x594f(%rip), %rsi      # 0x132de
callq 0xb7c0
testb $0x1, %al
jne 0xd99a
jmp 0xd9a1
movb $0x1, 0x17(%rsp)
jmp 0xd9a6
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x42a0
cmpq $0x0, %rax
jne 0xd9e3
movb $0x0, 0x27(%rsp)
jmp 0xda9b
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4420
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0xda03
movb $0x0, 0x27(%rsp)
jmp 0xda9b
movq 0x18(%rsp), %rdi
leaq 0x58ae(%rip), %rsi      # 0x132bd
xorl %eax, %eax
movl %eax, %edx
callq 0x4770
cmpq $-0x1, %rax
je 0xda25
movb $0x0, 0x27(%rsp)
jmp 0xda9b
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x42a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xda96
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4420
movsbl (%rax), %eax
cmpl $0x20, %eax
jl 0xda7d
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4420
movsbl (%rax), %eax
cmpl $0x7e, %eax
jle 0xda84
movb $0x0, 0x27(%rsp)
jmp 0xda9b
jmp 0xda86
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xda2e
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x40(%rsp)
addq $0x38, %rdi
callq 0x4670
testb $0x1, %al
jne 0xdbed
movq 0x8(%rsp), %rsi
addq $0x38, %rsi
movq 0x48(%rsp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x43d0
movq (%rsp), %rsi
movq 0x50(%rsp), %rdi
callq 0x4740
jmp 0xdb78
leaq 0x20(%rsp), %rdi
callq 0x42a0
movq %rax, %rcx
movq 0x40(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0xdbcd
leaq 0x20(%rsp), %rdi
callq 0x42a0
movq %rax, 0x60(%rsp)
movl $0x1, 0x10(%rsp)
jmp 0xdbd5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4788
jmp 0xdc15
movl $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4788
movl 0x10(%rsp), %eax
testl %eax, %eax
je 0xdbeb
jmp 0xdbe9
jmp 0xdc0b
jmp 0xdbed
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x50(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x46b0
nop
// File: 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:
subq $0xc8, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x4570
movq 0xb8(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x41b0
jmp 0xe284
movq 0xb8(%rsp), %rsi
leaq 0x5062(%rip), %rdx      # 0x132f5
leaq 0x18(%rsp), %rdi
callq 0xebc0
jmp 0xe29f
movq 0xb0(%rsp), %rdx
movq 0xa8(%rsp), %r8
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x88(%rsp), %rcx
callq 0xdee0
jmp 0xe2c8
leaq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x44d0
leaq 0x38(%rsp), %rdi
callq 0x4788
leaq 0x18(%rsp), %rdi
callq 0x4788
leaq 0x68(%rsp), %rdi
callq 0x4670
testb $0x1, %al
jne 0xe34b
movq (%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x4230
movl $0x1, 0x14(%rsp)
jmp 0xe36e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xe39c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xe392
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x4788
jmp 0xe392
movq (%rsp), %rdi
movq 0xb8(%rsp), %rsi
movq 0xb0(%rsp), %rdx
callq 0xe3c0
jmp 0xe366
movl $0x1, 0x14(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x4788
leaq 0x88(%rsp), %rdi
callq 0x4788
movq 0x8(%rsp), %rax
addq $0xc8, %rsp
retq
leaq 0x68(%rsp), %rdi
callq 0x4788
leaq 0x88(%rsp), %rdi
callq 0x4788
movq 0x60(%rsp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movl $0x0, 0x64(%rsp)
movq 0x78(%rsp), %rdi
callq 0x42a0
cmpq $0x0, %rax
je 0xf585
movq 0x78(%rsp), %rsi
movq 0x68(%rsp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x43d0
movq 0x8(%rsp), %rdi
callq 0x42a0
movl %eax, 0x64(%rsp)
movq 0x78(%rsp), %rsi
movslq 0x64(%rsp), %rdx
leaq 0x20(%rsp), %rdi
movq $-0x1, %rcx
callq 0x43d0
jmp 0xf532
movq 0x78(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rsi, (%rsp)
callq 0x44d0
movq (%rsp), %rdi
callq 0x4788
movq 0x70(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x44f0
jmp 0xf55f
leaq 0x40(%rsp), %rdi
callq 0x4788
jmp 0xf585
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4788
jmp 0xf592
movslq 0x64(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x46b0
nopl (%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x9745(%rip), %rcx      # 0x18d08
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x20(%rax)
je 0xf6b7
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x43a0
movl %eax, 0x14(%rsp)
jmp 0xf5e9
movl 0x14(%rsp), %eax
cmpl $0x0, %eax
je 0xf6aa
movq 0x18(%rsp), %rax
movq 0x70(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x4060
movslq (%rax), %rsi
leaq 0x20(%rsp), %rdi
callq 0x10f70
jmp 0xf618
leaq 0x3de8(%rip), %rsi      # 0x13407
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x6230
jmp 0xf630
leaq 0x39db(%rip), %rdx      # 0x13012
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x61e0
jmp 0xf648
callq 0x4060
movl (%rax), %edi
callq 0x4150
movq %rax, %rdx
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x61e0
jmp 0xf66b
movq 0x8(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x10f40
jmp 0xf67f
leaq 0x80(%rsp), %rdi
callq 0x4788
leaq 0x60(%rsp), %rdi
callq 0x4788
leaq 0x40(%rsp), %rdi
callq 0x4788
leaq 0x20(%rsp), %rdi
callq 0x4788
movq 0x18(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x18(%rsp), %rdi
addq $0x50, %rdi
callq 0x4788
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
callq 0x4788
movq 0x18(%rsp), %rdi
callq 0xdec0
addq $0xa8, %rsp
retq
movq %rax, %rdi
callq 0x65c0
nopl (%rax)
// File: tylerkaraszewski[P]Argyle/ErrorReader.cpp
// Function: ErrorReader::read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long)
size_t ErrorReader::read(std::string& buffer, const size_t maxBytesToRead)
{
  if (maxBytesToRead < m_dataBuffer.size())
  {
    buffer.append(m_dataBuffer.substr(0, maxBytesToRead));
    m_dataBuffer = m_dataBuffer.substr(maxBytesToRead);
    m_bytesRead += maxBytesToRead;
    return maxBytesToRead;
  }
  int size = m_dataBuffer.size();
  buffer.append(m_dataBuffer);
  m_dataBuffer.clear();
  m_done = true;
  m_bytesRead += size;
  return size;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq 0x88(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x20, %rdi
callq 0x42a0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x10a0b
movq 0x10(%rsp), %rsi
movq 0x80(%rsp), %rax
movq %rax, (%rsp)
addq $0x20, %rsi
movq 0x78(%rsp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq 0x58(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x43d0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4740
jmp 0x1098a
leaq 0x58(%rsp), %rdi
callq 0x4788
movq 0x10(%rsp), %rsi
addq $0x20, %rsi
movq 0x78(%rsp), %rdx
leaq 0x28(%rsp), %rdi
movq $-0x1, %rcx
callq 0x43d0
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
leaq 0x28(%rsp), %rsi
callq 0x44d0
leaq 0x28(%rsp), %rdi
callq 0x4788
movq 0x10(%rsp), %rax
movq 0x78(%rsp), %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq 0x78(%rsp), %rax
movq %rax, 0x90(%rsp)
jmp 0x10a64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x4788
jmp 0x10a74
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x42a0
movq 0x10(%rsp), %rsi
movl %eax, 0x24(%rsp)
movq 0x80(%rsp), %rdi
addq $0x20, %rsi
callq 0x4740
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x4520
movq 0x10(%rsp), %rax
movb $0x1, 0x11(%rax)
movslq 0x24(%rsp), %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movslq 0x24(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x46b0
nop
// File: tylerkaraszewski[P]Argyle/Logger.cpp
// Function: Logger::open()
bool Logger::open()
{
  string accessFilePath = m_config.getString(Config::S_KEY_ACCESS_FILE_PATH);
  string errorFilePath = m_config.getString(Config::S_KEY_ERROR_FILE_PATH);

  close();
  FILE* access = fopen(accessFilePath.c_str(), "a");
  if (access == NULL)
  {
    return false;
  }
  FILE* error = fopen(errorFilePath.c_str(), "a");
  if (error == NULL)
  {
    return false;
  }
  m_accessFile = access;
  m_errorFile = error;
  return true;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x18(%rsp)
movq (%rax), %rsi
leaq 0x8952(%rip), %rdx      # 0x19498
leaq 0x68(%rsp), %rdi
callq 0x11c60
movq 0x18(%rsp), %rax
movq (%rax), %rsi
leaq 0x8959(%rip), %rdx      # 0x194b8
leaq 0x48(%rsp), %rdi
callq 0x11c60
jmp 0x10b6b
movq 0x18(%rsp), %rdi
callq 0x10ca0
jmp 0x10b77
leaq 0x68(%rsp), %rdi
callq 0x4190
movq %rax, %rdi
leaq 0x2fa7(%rip), %rsi      # 0x13b32
callq 0x4480
movq %rax, 0x10(%rsp)
jmp 0x10b97
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x10bee
movb $0x0, 0x97(%rsp)
movl $0x1, 0x2c(%rsp)
jmp 0x10c59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x10c7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4788
jmp 0x10c7e
leaq 0x48(%rsp), %rdi
callq 0x4190
movq %rax, %rdi
leaq 0x2f30(%rip), %rsi      # 0x13b32
callq 0x4480
movq %rax, 0x8(%rsp)
jmp 0x10c0e
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x10c32
movb $0x0, 0x97(%rsp)
movl $0x1, 0x2c(%rsp)
jmp 0x10c59
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
movb $0x1, 0x97(%rsp)
movl $0x1, 0x2c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4788
leaq 0x68(%rsp), %rdi
callq 0x4788
movb 0x97(%rsp), %al
andb $0x1, %al
addq $0x98, %rsp
retq
leaq 0x68(%rsp), %rdi
callq 0x4788
movq 0x40(%rsp), %rdi
callq 0x46b0
nopw %cs:(%rax,%rax)