LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::NamedBase::AddDescriptionPostfix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, 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&) const
void AddDescriptionPostfix(std::string &dest, const bool isManual, const std::string &manual, bool isGenerated, const std::string &generated, const std::string &str) const
            {
                if (isManual && !manual.empty())
                {
                    dest += str;
                    dest += manual;
                }
                else if (!isManual && isGenerated && !generated.empty())
                {
                    dest += str;
                    dest += generated;
                }
            }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x20(%rsp), %rax
testl %edx, %edx
je 0x1be86
movq %rcx, %r14
cmpq $0x0, 0x8(%rcx)
jne 0x1be95
jmp 0x1beba
testb %r8b, %r8b
je 0x1beba
cmpq $0x0, 0x8(%r9)
movq %r9, %r14
je 0x1beba
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x5150
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5150
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> args::detail::Join<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>>>>>(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 Join(const T& array, const std::string &delimiter)
        {
            std::string res;
            for (auto &element : array)
            {
                if (!res.empty())
                {
                    res += delimiter;
                }

                res += element;
            }

            return res;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
cmpq %r13, %r12
je 0x1bf20
movq %rdx, %r14
cmpq $0x0, 0x8(%rbx)
je 0x1bf06
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x5150
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x5150
addq $0x20, %r12
cmpq %r13, %r12
jne 0x1bef0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1bf3d
callq 0x53d0
movq %r14, %rdi
callq 0x56b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::Matcher::GetFlagStrings() const
std::vector<EitherFlag> GetFlagStrings() const
            {
                std::vector<EitherFlag> flagStrings;
                flagStrings.reserve(shortFlags.size() + longFlags.size());
                for (const char flag: shortFlags)
                {
                    flagStrings.emplace_back(flag);
                }
                for (const std::string &flag: longFlags)
                {
                    flagStrings.emplace_back(flag);
                }
                return flagStrings;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x50(%rsi), %rsi
addq 0x18(%r14), %rsi
callq 0x1c426
movq 0x10(%r14), %r12
testq %r12, %r12
je 0x1c39c
leaq 0x7(%rsp), %r15
movb 0x8(%r12), %al
movb %al, 0x7(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1c4f4
movq (%r12), %r12
testq %r12, %r12
jne 0x1c37f
addq $0x48, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x1c3b6
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x1c528
jmp 0x1c3a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1c3c9
jmp 0x1c3c9
movq %rax, %r14
movq %rbx, %rdi
callq 0x1c3dc
movq %r14, %rdi
callq 0x56b0
// File: /workspace/github_cpp_makefile_star2_O3/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::ArgumentParser::ParseOption(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
OptionType ParseOption(const std::string &s, bool allowEmpty = false)
            {
                if (s.find(longprefix) == 0 && (allowEmpty || s.length() > longprefix.length()))
                {
                    return OptionType::LongFlag;
                }

                if (s.find(shortprefix) == 0 && (allowEmpty || s.length() > shortprefix.length()))
                {
                    return OptionType::ShortFlag;
                }

                return OptionType::Positional;
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x178(%rdi), %rsi
movq 0x180(%rdi), %rcx
xorl %r15d, %r15d
movq %r14, %rdi
xorl %edx, %edx
callq 0x5690
testq %rax, %rax
je 0x1dc64
movq 0x198(%rbx), %rsi
movq 0x1a0(%rbx), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x5690
testq %rax, %rax
je 0x1dc78
movl $0x2, %r15d
jmp 0x1dc90
testb %bpl, %bpl
jne 0x1dc90
movq 0x8(%r14), %rax
cmpq 0x180(%rbx), %rax
jbe 0x1dc3f
jmp 0x1dc90
movl $0x1, %r15d
testb %bpl, %bpl
jne 0x1dc90
movq 0x8(%r14), %rax
cmpq 0x1a0(%rbx), %rax
jbe 0x1dc5c
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::ArgumentParser::AddCompletionReply(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool AddCompletionReply(const std::string &cur, const std::string &choice)
            {
                if (cur.empty() || choice.find(cur) == 0)
                {
                    if (completion->syntax == "bash" && ParseOption(choice) == OptionType::LongFlag && choice.find(longseparator) != std::string::npos)
                    {
                        completion->reply.push_back(choice.substr(choice.find(longseparator) + 1));
                    } else
                    {
                        completion->reply.push_back(choice);
                    }
                    return true;
                }

                return false;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x1ed69
movq (%rsi), %rsi
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5690
testq %rax, %rax
jne 0x1edad
movl $0x130, %edi            # imm = 0x130
addq 0x200(%r14), %rdi
leaq 0xb17a(%rip), %rsi      # 0x29ef6
callq 0x5120
testl %eax, %eax
jne 0x1ed96
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1dc10
testl %eax, %eax
je 0x1edba
movl $0x110, %edi            # imm = 0x110
addq 0x200(%r14), %rdi
movq %rbx, %rsi
callq 0x6b8a
movb $0x1, %r15b
movl %r15d, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x1b8(%r14), %rsi
movq 0x1c0(%r14), %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5690
cmpq $-0x1, %rax
je 0x1ed96
movl $0x110, %r15d           # imm = 0x110
addq 0x200(%r14), %r15
movq 0x1b8(%r14), %rsi
movq 0x1c0(%r14), %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5690
leaq 0x1(%rax), %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x5440
movq %r15, %rdi
movq %r14, %rsi
callq 0x192a6
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1edaa
callq 0x53d0
jmp 0x1edaa
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ee53
callq 0x53d0
movq %rbx, %rdi
callq 0x56b0
// File: /workspace/github_cpp_makefile_star2_O3/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: bool args::ArgumentParser::Complete<__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, 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>>>>>>(args::FlagBase&, __gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, 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>>>>>, __gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, 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>>>>>)
bool Complete(FlagBase &flag, It it, It end)
            {
                auto nextIt = it;
                if (!readCompletion || (++nextIt != end))
                {
                    return false;
                }

                const auto &chunk = *it;
                for (auto &choice : flag.HelpChoices(helpParams))
                {
                    AddCompletionReply(chunk, choice);
                }

#ifndef ARGS_NOEXCEPT
                throw Completion(completion->Get());
#else
                return true;
#endif
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x20(%rdx), %rax
cmpq %rcx, %rax
sete %al
testb %al, 0x208(%rdi)
jne 0x1f591
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movq %rdi, %rbx
cmpb $0x1, 0x98(%rsi)
jne 0x1f5ae
subq $-0x80, %rsi
movq %rsp, %rdi
callq 0x690a
jmp 0x1f5c1
leaq 0x210(%rbx), %rdx
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x80(%rax)
movq (%rsp), %r15
movq 0x8(%rsp), %r12
cmpq %r12, %r15
je 0x1f5e3
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1ed3c
addq $0x20, %r15
jmp 0x1f5ca
movq %rsp, %rdi
callq 0x698e
movl $0x10, %edi
callq 0x51f0
movq %rax, %r14
movq 0x200(%rbx), %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1eebc
movb $0x1, %bpl
movq %r14, %rdi
movq %rbx, %rsi
callq 0x54d0
leaq 0x19571(%rip), %rax     # 0x38b90
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x1953d(%rip), %rsi     # 0x38b68
movq 0x19996(%rip), %rdx     # 0x38fc8
movq %r14, %rdi
callq 0x5670
movq %rax, %rbx
movq %rsp, %rdi
callq 0x698e
jmp 0x1f66a
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f65d
callq 0x53d0
testb %bpl, %bpl
je 0x1f66a
movq %r14, %rdi
callq 0x52e0
movq %rbx, %rdi
callq 0x56b0
// File: /workspace/github_cpp_makefile_star2_O3/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: std::enable_if<!std::is_assignable<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::value, bool>::type args::ValueReader::operator()<int>(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&)
typename std::enable_if<!std::is_assignable<T, std::string>::value, bool>::type
        operator ()(const std::string &name, const std::string &value, T &destination)
        {
            std::istringstream ss(value);
            ss >> destination >> std::ws;

            if (ss.rdbuf()->in_avail() > 0)
            {
#ifdef ARGS_NOEXCEPT
                (void)name;
                return false;
#else
                std::ostringstream problem;
                problem << "Argument '" << name << "' received invalid value type '" << value << "'";
                throw ParseError(problem.str());
#endif
            }
            return true;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x320, %rsp            # imm = 0x320
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
movl $0x8, %edx
callq 0x5650
movq %r12, %rdi
movq %r15, %rsi
callq 0x5270
movq %rax, %rdi
callq 0x5340
movq 0x50(%rsp), %rax
subq 0x48(%rsp), %rax
jne 0x22b39
leaq 0x38(%rsp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testq %rax, %rax
jg 0x22b6e
movq 0x16473(%rip), %rsi     # 0x38fb8
leaq 0x28(%rsp), %rdi
callq 0x5580
leaq 0xa0(%rsp), %rdi
callq 0x5160
movb $0x1, %al
addq $0x320, %rsp            # imm = 0x320
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a8(%rsp), %rdi
callq 0x5540
leaq 0x75a1(%rip), %rsi      # 0x2a123
leaq 0x1a8(%rsp), %rdi
movl $0xa, %edx
callq 0x5470
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x1a8(%rsp), %rdi
callq 0x5470
movq %rax, %r14
leaq 0x757c(%rip), %rsi      # 0x2a12e
movl $0x1f, %edx
movq %rax, %rdi
callq 0x5470
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x5470
leaq 0x74d9(%rip), %rsi      # 0x2a0ae
movl $0x1, %edx
movq %rax, %rdi
callq 0x5470
movl $0x10, %edi
callq 0x51f0
movq %rax, %r14
leaq 0x1b0(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x5610
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x54d0
leaq 0x15f38(%rip), %rax     # 0x38b50
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x1584c(%rip), %rsi     # 0x38470
movq 0x1639d(%rip), %rdx     # 0x38fc8
movq %r14, %rdi
callq 0x5670
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22c49
callq 0x53d0
testb %bpl, %bpl
jne 0x22c53
jmp 0x22c60
movq %rax, %rbx
movq %r14, %rdi
callq 0x52e0
jmp 0x22c60
movq %rax, %rbx
movq 0x16359(%rip), %rsi     # 0x38fc0
leaq 0x1a8(%rsp), %rdi
callq 0x5220
leaq 0x218(%rsp), %rdi
callq 0x5160
jmp 0x22c88
jmp 0x22c85
movq %rax, %rbx
movq 0x16329(%rip), %rsi     # 0x38fb8
leaq 0x28(%rsp), %rdi
callq 0x5580
leaq 0xa0(%rsp), %rdi
callq 0x5160
movq %rbx, %rdi
callq 0x56b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/BU-DiSC[P]BF-Shared-Hashing/hash/md5.cpp
// Function: MD5::finalize()
MD5& MD5::finalize()
{
  static unsigned char padding[64] = {
    0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  };
 
  if (!finalized) {
    // Save number of bits
    unsigned char bits[8];
    encode(bits, count, 8);
 
    // pad out to 56 mod 64.
    size_type index = count[0] / 8 % 64;
    size_type padLen = (index < 56) ? (56 - index) : (120 - index);
    update(padding, padLen);
 
    // Append length (before padding)
    update(bits, 8);
 
    // Store state in digest
    encode(digest, state, 16);
 
    // Zeroize sensitive information.
    memset(buffer, 0, sizeof buffer);
    memset(count, 0, sizeof count);
 
    finalized=true;
  }
 
  return *this;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x0, (%rdi)
jne 0x22d9d
xorl %eax, %eax
movl 0x44(%rbx,%rax,4), %ecx
movl %ecx, 0x8(%rsp,%rax,4)
incq %rax
cmpq $0x2, %rax
jne 0x22d1f
movl 0x44(%rbx), %eax
shrl $0x3, %eax
andl $0x3f, %eax
xorl %edx, %edx
cmpl $0x38, %eax
setae %dl
shll $0x6, %edx
orl $0x38, %edx
subl %eax, %edx
leaq 0x166c0(%rip), %rsi     # 0x39410
movq %rbx, %rdi
callq 0x23746
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl $0x8, %edx
callq 0x23746
movl $0x13, %eax
movl (%rbx,%rax,4), %ecx
movl %ecx, 0x10(%rbx,%rax,4)
incq %rax
cmpq $0x17, %rax
jne 0x22d6f
xorps %xmm0, %xmm0
movups %xmm0, 0x31(%rbx)
movups %xmm0, 0x21(%rbx)
movups %xmm0, 0x11(%rbx)
movups %xmm0, 0x1(%rbx)
movq $0x0, 0x44(%rbx)
movb $0x1, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/BU-DiSC[P]BF-Shared-Hashing/hash/md5.cpp
// Function: MD5::encode(unsigned char*, unsigned int const*, unsigned int)
void MD5::encode(uint1 output[], const uint4 input[], size_type len)
{
  for (size_type i = 0, j = 0; j < len; i++, j += 4) {
    output[j] = input[i] & 0xff;
    output[j+1] = (input[i] >> 8) & 0xff;
    output[j+2] = (input[i] >> 16) & 0xff;
    output[j+3] = (input[i] >> 24) & 0xff;
  }
}

// Assembly:
testl %edx, %edx
je 0x22df5
decl %edx
shrl $0x2, %edx
incl %edx
xorl %eax, %eax
movb (%rsi,%rax,4), %cl
movb %cl, (%rdi,%rax,4)
movb 0x1(%rsi,%rax,4), %cl
movb %cl, 0x1(%rdi,%rax,4)
movb 0x2(%rsi,%rax,4), %cl
movb %cl, 0x2(%rdi,%rax,4)
movb 0x3(%rsi,%rax,4), %cl
movb %cl, 0x3(%rdi,%rax,4)
incq %rax
cmpq %rax, %rdx
jne 0x22dcf
retq
// File: /workspace/github_cpp_makefile_star2_O3/BU-DiSC[P]BF-Shared-Hashing/hash/md5.cpp
// Function: MD5::update(unsigned char const*, unsigned int)
void MD5::update(const unsigned char input[], size_type length)
{
  // compute number of bytes mod 64
  size_type index = count[0] / 8 % blocksize;
 
  // Update number of bits
  if ((count[0] += (length << 3)) < (length << 3))
    count[1]++;
  count[1] += (length >> 29);
 
  // number of bytes we need to fill in buffer
  size_type firstpart = 64 - index;
 
  size_type i;
 
  // transform as many times as possible.
  if (length >= firstpart)
  {
    // fill buffer first, transform
    memcpy(&buffer[index], input, firstpart);
    transform(buffer);
 
    // transform chunks of blocksize (64 bytes)
    for (i = firstpart; i + blocksize <= length; i += blocksize)
      transform(&input[i]);
 
    index = 0;
  }
  else
    i = 0;
 
  // buffer remaining input
  memcpy(&buffer[index], &input[i], length-i);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movl 0x44(%rdi), %eax
movl %eax, %r13d
shrl $0x3, %r13d
andl $0x3f, %r13d
leal (,%rbx,8), %ecx
shrl $0x1d, %edx
addl %eax, %ecx
movl %ecx, 0x44(%rdi)
adcl %edx, 0x48(%rdi)
movq %rsi, %r15
movl $0x40, %ebp
subl %r13d, %ebp
cmpl %ebx, %ebp
jbe 0x2378c
movl %r13d, %r12d
xorl %ebp, %ebp
jmp 0x237d8
leaq 0x1(%r14), %r12
leaq (%r14,%r13), %rdi
incq %rdi
movl %ebp, %edx
movq %r15, %rsi
callq 0x5330
movq %r14, %rdi
movq %r12, %rsi
callq 0x22df6
movl $0x80, %eax
subl %r13d, %eax
xorl %r12d, %r12d
cmpl %ebx, %eax
ja 0x237d8
movl %ebp, %r13d
movl %ebp, %esi
addq %r15, %rsi
movq %r14, %rdi
callq 0x22df6
leal 0x40(%r13), %ebp
subl $-0x80, %r13d
cmpl %ebx, %r13d
jbe 0x237bb
leaq (%r14,%r12), %rdi
incq %rdi
movl %ebp, %eax
addq %rax, %r15
subl %ebp, %ebx
movq %r15, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O3/BU-DiSC[P]BF-Shared-Hashing/hash/md5.cpp
// Function: MD5::hexdigest[abi:cxx11]() const
std::string MD5::hexdigest() const
{
  if (!finalized)
    return "";
 
  char buf[33];
  for (int i=0; i<16; i++)
    sprintf(buf+i*2, "%02x", digest[i]);
  buf[32]=0;
 
  return std::string(buf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpb $0x0, (%rsi)
je 0x23868
movq %rsi, %r14
movq %rsp, %r15
leaq 0x5ede(%rip), %r12      # 0x29700
xorl %r13d, %r13d
movzbl 0x5c(%r14,%r13), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x50c0
incq %r13
addq $0x2, %r15
cmpq $0x10, %r13
jne 0x23825
movq %rsp, %r14
movb $0x0, 0x20(%r14)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x51d0
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x2387c
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x5be3(%rip), %rdx      # 0x29459
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xf95c
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/BU-DiSC[P]BF-Shared-Hashing/hash/murmurhash.cc
// Function: MurmurHash64A(void const*, int, unsigned int)
uint64_t MurmurHash64A ( const void * key, int len, unsigned int seed )
{
    const uint64_t m = 0xc6a4a7935bd1e995;
    const int r = 47;

    uint64_t h = seed ^ (len * m);

    const uint64_t * data = (const uint64_t *)key;
    const uint64_t * end = data + (len/8);

    while(data != end)
    {
        uint64_t k = *data++;

        k *= m;
        k ^= k >> r;
        k *= m;

        h ^= k;
        h *= m;
    }

    const unsigned char * data2 = (const unsigned char*)data;

    switch(len & 7)
    {
    case 7: h ^= ((uint64_t)data2[6]) << 48;
    case 6: h ^= ((uint64_t)data2[5]) << 40;
    case 5: h ^= ((uint64_t)data2[4]) << 32;
    case 4: h ^= ((uint64_t)data2[3]) << 24;
    case 3: h ^= ((uint64_t)data2[2]) << 16;
    case 2: h ^= ((uint64_t)data2[1]) << 8; 
    case 1: h ^= ((uint64_t)data2[0]);
        h *= m;
    };

    h ^= h >> r;
    h *= m;
    h ^= h >> r;

    return h;
}

// Assembly:
movabsq $-0x395b586ca42e166b, %rax # imm = 0xC6A4A7935BD1E995
movl %edx, %edx
movslq %esi, %r8
movq %r8, %rcx
imulq %rax, %rcx
xorq %rdx, %rcx
leal 0x7(%r8), %r9d
testl %r8d, %r8d
movl %esi, %edx
cmovsl %r9d, %edx
cmpl $0xf, %r9d
jb 0x23992
sarl $0x3, %edx
movslq %edx, %r8
leaq (%rdi,%r8,8), %rdx
shlq $0x3, %r8
xorl %r9d, %r9d
movq (%rdi,%r9), %r10
imulq %rax, %r10
movq %r10, %r11
shrq $0x2f, %r11
xorq %r10, %r11
imulq %rax, %r11
xorq %r11, %rcx
imulq %rax, %rcx
addq $0x8, %r9
cmpq %r9, %r8
jne 0x23969
movq %rdx, %rdi
andl $0x7, %esi
leaq 0x6a94(%rip), %rdx      # 0x2a430
movslq (%rdx,%rsi,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movzbl 0x6(%rdi), %edx
shlq $0x30, %rdx
xorq %rdx, %rcx
movzbl 0x5(%rdi), %edx
shlq $0x28, %rdx
xorq %rdx, %rcx
movzbl 0x4(%rdi), %edx
shlq $0x20, %rdx
xorq %rdx, %rcx
movzbl 0x3(%rdi), %edx
shll $0x18, %edx
xorq %rdx, %rcx
movzbl 0x2(%rdi), %edx
shll $0x10, %edx
xorq %rdx, %rcx
movzbl 0x1(%rdi), %edx
shll $0x8, %edx
xorq %rdx, %rcx
movzbl (%rdi), %edx
xorq %rcx, %rdx
imulq %rax, %rdx
movq %rdx, %rcx
movq %rcx, %rdx
shrq $0x2f, %rdx
xorq %rcx, %rdx
imulq %rax, %rdx
movq %rdx, %rax
shrq $0x2f, %rax
xorq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/BU-DiSC[P]BF-Shared-Hashing/hash/xxhash.cc
// Function: ROCKSDB_XXH32_digest
XXH_PUBLIC_API XXH32_hash_t XXH32_digest (const XXH32_state_t* state)
{
    xxh_u32 h32;

    if (state->large_len) {
        h32 = XXH_rotl32(state->v1, 1)
            + XXH_rotl32(state->v2, 7)
            + XXH_rotl32(state->v3, 12)
            + XXH_rotl32(state->v4, 18);
    } else {
        h32 = state->v3 /* == seed */ + PRIME32_5;
    }

    h32 += state->total_len_32;

    return XXH32_finalize(h32, (const xxh_u8*)state->mem32, state->memsize, XXH_aligned);
}

// Assembly:
movq %rdi, %rsi
cmpl $0x0, 0x4(%rdi)
je 0x241d5
movdqu 0x8(%rsi), %xmm0
movdqa 0x6405(%rip), %xmm1     # 0x2a590
pshufd $0xf5, %xmm0, %xmm2     # xmm2 = xmm0[1,1,3,3]
pmuludq %xmm1, %xmm0
pshufd $0xed, %xmm0, %xmm3     # xmm3 = xmm0[1,3,2,3]
pshufd $0xf5, %xmm1, %xmm1     # xmm1 = xmm1[1,1,3,3]
pmuludq %xmm2, %xmm1
pshufd $0xed, %xmm1, %xmm2     # xmm2 = xmm1[1,3,2,3]
punpckldq %xmm2, %xmm3    # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
pshufd $0xe8, %xmm1, %xmm1     # xmm1 = xmm1[0,2,2,3]
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
por %xmm3, %xmm0
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddd %xmm0, %xmm1
pshufd $0x55, %xmm1, %xmm0     # xmm0 = xmm1[1,1,1,1]
paddd %xmm1, %xmm0
movd %xmm0, %edi
jmp 0x241dd
movl $0x165667b1, %edi       # imm = 0x165667B1
addl 0x10(%rsi), %edi
addl (%rsi), %edi
movl 0x28(%rsi), %edx
addq $0x18, %rsi
jmp 0x241e8
// File: /workspace/github_cpp_makefile_star2_O3/BU-DiSC[P]BF-Shared-Hashing/hash/Crc32.cpp
// Function: crc32_halfbyte(void const*, unsigned long, unsigned int)
uint32_t crc32_halfbyte(const void* data, size_t length, uint32_t previousCrc32)
{
  uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF
  const uint8_t* current = (const uint8_t*) data;

  /// look-up table for half-byte, same as crc32Lookup[0][16*i]
  static const uint32_t Crc32Lookup16[16] =
  {
    0x00000000,0x1DB71064,0x3B6E20C8,0x26D930AC,0x76DC4190,0x6B6B51F4,0x4DB26158,0x5005713C,
    0xEDB88320,0xF00F9344,0xD6D6A3E8,0xCB61B38C,0x9B64C2B0,0x86D3D2D4,0xA00AE278,0xBDBDF21C
  };

  while (length-- != 0)
  {
    crc = Crc32Lookup16[(crc ^  *current      ) & 0x0F] ^ (crc >> 4);
    crc = Crc32Lookup16[(crc ^ (*current >> 4)) & 0x0F] ^ (crc >> 4);
    current++;
  }

  return ~crc; // same as crc ^ 0xFFFFFFFF
}

// Assembly:
movl %edx, %eax
testq %rsi, %rsi
je 0x2703c
notl %eax
xorl %ecx, %ecx
leaq 0x3709(%rip), %rdx      # 0x2a710
movzbl (%rdi,%rcx), %r8d
movl %eax, %r9d
xorl %r8d, %r9d
andl $0xf, %r9d
shrl $0x4, %eax
xorl (%rdx,%r9,4), %eax
shrl $0x4, %r8d
movl %eax, %r9d
andl $0xf, %r9d
xorl %r8d, %r9d
shrl $0x4, %eax
xorl (%rdx,%r9,4), %eax
incq %rcx
cmpq %rcx, %rsi
jne 0x27007
notl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/BU-DiSC[P]BF-Shared-Hashing/hash/Crc32.cpp
// Function: crc32_1byte(void const*, unsigned long, unsigned int)
uint32_t crc32_1byte(const void* data, size_t length, uint32_t previousCrc32)
{
  uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF
  const uint8_t* current = (const uint8_t*) data;

  while (length-- != 0)
    crc = (crc >> 8) ^ Crc32Lookup[0][(crc & 0xFF) ^ *current++];

  return ~crc; // same as crc ^ 0xFFFFFFFF
}

// Assembly:
movl %edx, %eax
testq %rsi, %rsi
je 0x2706c
notl %eax
xorl %ecx, %ecx
leaq 0x3701(%rip), %rdx      # 0x2a750
movzbl %al, %r8d
shrl $0x8, %eax
movzbl (%rdi,%rcx), %r9d
xorl %r8d, %r9d
xorl (%rdx,%r9,4), %eax
incq %rcx
cmpq %rcx, %rsi
jne 0x2704f
notl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/BU-DiSC[P]BF-Shared-Hashing/hash/Crc32.cpp
// Function: crc32_1byte_tableless2(void const*, unsigned long, unsigned int)
uint32_t crc32_1byte_tableless2(const void* data, size_t length, uint32_t previousCrc32)
{
  int32_t crc = ~previousCrc32; // note: signed integer, right shift distributes sign bit into lower bits
  const uint8_t* current = (const uint8_t*) data;

  while (length-- != 0)
  {
    crc = crc ^ *current++;

    uint32_t c = (((crc << 31) >> 31) & ((Polynomial >> 7)  ^ (Polynomial >> 1))) ^
                 (((crc << 30) >> 31) & ((Polynomial >> 6)  ^  Polynomial)) ^
                 (((crc << 29) >> 31) &  (Polynomial >> 5)) ^
                 (((crc << 28) >> 31) &  (Polynomial >> 4)) ^
                 (((crc << 27) >> 31) &  (Polynomial >> 3)) ^
                 (((crc << 26) >> 31) &  (Polynomial >> 2)) ^
                 (((crc << 25) >> 31) &  (Polynomial >> 1)) ^
                 (((crc << 24) >> 31) &   Polynomial);

    crc = ((uint32_t)crc >> 8) ^ c; // convert to unsigned integer before right shift
  }

  return ~crc; // same as crc ^ 0xFFFFFFFF
}

// Assembly:
movl %edx, %eax
testq %rsi, %rsi
je 0x2715f
notl %eax
xorl %ecx, %ecx
movdqa 0x35cf(%rip), %xmm0     # 0x2a6c0
movdqa 0x35d7(%rip), %xmm1     # 0x2a6d0
movdqa 0x35df(%rip), %xmm2     # 0x2a6e0
movdqa 0x35e7(%rip), %xmm3     # 0x2a6f0
movzbl (%rdi,%rcx), %edx
xorl %eax, %edx
movd %edx, %xmm4
pshufd $0x0, %xmm4, %xmm4      # xmm4 = xmm4[0,0,0,0]
movdqa %xmm4, %xmm5
pand %xmm0, %xmm5
pand %xmm1, %xmm4
pcmpeqd %xmm1, %xmm4
pand %xmm2, %xmm4
pcmpeqd %xmm0, %xmm5
pand %xmm3, %xmm5
pxor %xmm4, %xmm5
movl %eax, %edx
shrl $0x8, %edx
pshufd $0xee, %xmm5, %xmm4     # xmm4 = xmm5[2,3,2,3]
pxor %xmm5, %xmm4
pshufd $0x55, %xmm4, %xmm5     # xmm5 = xmm4[1,1,1,1]
pxor %xmm4, %xmm5
movd %xmm5, %eax
xorl %edx, %eax
incq %rcx
cmpq %rcx, %rsi
jne 0x27109
notl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/BU-DiSC[P]BF-Shared-Hashing/hash/Crc32.cpp
// Function: crc32_4bytes(void const*, unsigned long, unsigned int)
uint32_t crc32_4bytes(const void* data, size_t length, uint32_t previousCrc32)
{
  uint32_t  crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF
  const uint32_t* current = (const uint32_t*) data;

  // process four bytes at once (Slicing-by-4)
  while (length >= 4)
  {
#if __BYTE_ORDER == __BIG_ENDIAN
    uint32_t one = *current++ ^ swap(crc);
    crc = Crc32Lookup[0][ one      & 0xFF] ^
          Crc32Lookup[1][(one>> 8) & 0xFF] ^
          Crc32Lookup[2][(one>>16) & 0xFF] ^
          Crc32Lookup[3][(one>>24) & 0xFF];
#else
    uint32_t one = *current++ ^ crc;
    crc = Crc32Lookup[0][(one>>24) & 0xFF] ^
          Crc32Lookup[1][(one>>16) & 0xFF] ^
          Crc32Lookup[2][(one>> 8) & 0xFF] ^
          Crc32Lookup[3][ one      & 0xFF];
#endif

    length -= 4;
  }

  const uint8_t* currentChar = (const uint8_t*) current;
  // remaining 1 to 3 bytes (standard algorithm)
  while (length-- != 0)
    crc = (crc >> 8) ^ Crc32Lookup[0][(crc & 0xFF) ^ *currentChar++];

  return ~crc; // same as crc ^ 0xFFFFFFFF
}

// Assembly:
notl %edx
cmpq $0x4, %rsi
jb 0x271c2
leaq 0x35e1(%rip), %rax      # 0x2a750
movl $0xff, %r8d
xorl (%rdi), %edx
movl %edx, %r9d
shrl $0x18, %r9d
movl %edx, %ecx
shrl $0xe, %ecx
andl $0x3fc, %ecx            # imm = 0x3FC
movl 0x400(%rcx,%rax), %ecx
xorl (%rax,%r9,4), %ecx
movl %edx, %r9d
shrl $0x8, %r9d
andl %r8d, %r9d
xorl 0x800(%rax,%r9,4), %ecx
andl %r8d, %edx
xorl 0xc00(%rax,%rdx,4), %ecx
addq $0x4, %rdi
addq $-0x4, %rsi
movl %ecx, %edx
cmpq $0x3, %rsi
ja 0x27175
jmp 0x271c4
movl %edx, %ecx
testq %rsi, %rsi
je 0x271f2
xorl %edx, %edx
leaq 0x357e(%rip), %r8       # 0x2a750
movl %ecx, %eax
shrl $0x8, %eax
movzbl %cl, %ecx
movzbl (%rdi,%rdx), %r9d
xorl %ecx, %r9d
xorl (%r8,%r9,4), %eax
incq %rdx
movl %eax, %ecx
cmpq %rdx, %rsi
jne 0x271d4
jmp 0x271f4
movl %ecx, %eax
notl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/BU-DiSC[P]BF-Shared-Hashing/hash/Crc32.cpp
// Function: crc32_4x8bytes(void const*, unsigned long, unsigned int)
uint32_t crc32_4x8bytes(const void* data, size_t length, uint32_t previousCrc32)
{
  uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF
  const uint32_t* current = (const uint32_t*) data;

  // enabling optimization (at least -O2) automatically unrolls the inner for-loop
  const size_t Unroll = 4;
  const size_t BytesAtOnce = 8 * Unroll;

  // process 4x eight bytes at once (Slicing-by-8)
  while (length >= BytesAtOnce)
  {
    for (size_t unrolling = 0; unrolling < Unroll; unrolling++)
    {
#if __BYTE_ORDER == __BIG_ENDIAN
      uint32_t one = *current++ ^ swap(crc);
      uint32_t two = *current++;
      crc = Crc32Lookup[0][ two      & 0xFF] ^
            Crc32Lookup[1][(two>> 8) & 0xFF] ^
            Crc32Lookup[2][(two>>16) & 0xFF] ^
            Crc32Lookup[3][(two>>24) & 0xFF] ^
            Crc32Lookup[4][ one      & 0xFF] ^
            Crc32Lookup[5][(one>> 8) & 0xFF] ^
            Crc32Lookup[6][(one>>16) & 0xFF] ^
            Crc32Lookup[7][(one>>24) & 0xFF];
#else
      uint32_t one = *current++ ^ crc;
      uint32_t two = *current++;
      crc = Crc32Lookup[0][(two>>24) & 0xFF] ^
            Crc32Lookup[1][(two>>16) & 0xFF] ^
            Crc32Lookup[2][(two>> 8) & 0xFF] ^
            Crc32Lookup[3][ two      & 0xFF] ^
            Crc32Lookup[4][(one>>24) & 0xFF] ^
            Crc32Lookup[5][(one>>16) & 0xFF] ^
            Crc32Lookup[6][(one>> 8) & 0xFF] ^
            Crc32Lookup[7][ one      & 0xFF];
#endif

    }

    length -= BytesAtOnce;
  }

  const uint8_t* currentChar = (const uint8_t*) current;
  // remaining 1 to 31 bytes (standard algorithm)
  while (length-- != 0)
    crc = (crc >> 8) ^ Crc32Lookup[0][(crc & 0xFF) ^ *currentChar++];

  return ~crc; // same as crc ^ 0xFFFFFFFF
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
notl %edx
leaq 0x3463(%rip), %rcx      # 0x2a750
cmpq $0x20, %rsi
jb 0x273a2
movl $0x3fc, %eax            # imm = 0x3FC
movl $0xff, %r8d
xorl %r9d, %r9d
xorl (%rdi,%r9,8), %edx
movl 0x4(%rdi,%r9,8), %r10d
movl %r10d, %r11d
shrl $0x18, %r11d
movl %r10d, %ebx
shrl $0xe, %ebx
andl %eax, %ebx
movl %edx, %r14d
movl %edx, %r15d
movl %edx, %r12d
movl 0x400(%rbx,%rcx), %ebx
xorl (%rcx,%r11,4), %ebx
movl %r10d, %r11d
shrl $0x8, %r11d
andl %r8d, %r11d
xorl 0x800(%rcx,%r11,4), %ebx
andl %r8d, %r10d
xorl 0xc00(%rcx,%r10,4), %ebx
shrl $0x18, %edx
xorl 0x1000(%rcx,%rdx,4), %ebx
shrl $0xe, %r14d
andl %eax, %r14d
xorl 0x1400(%r14,%rcx), %ebx
shrl $0x8, %r15d
andl %r8d, %r15d
xorl 0x1800(%rcx,%r15,4), %ebx
andl %r8d, %r12d
movl %ebx, %edx
xorl 0x1c00(%rcx,%r12,4), %edx
incq %r9
cmpq $0x4, %r9
jne 0x27305
addq $0x20, %rdi
addq $-0x20, %rsi
cmpq $0x1f, %rsi
ja 0x27302
testq %rsi, %rsi
je 0x273ca
xorl %r8d, %r8d
movl %edx, %eax
shrl $0x8, %eax
movzbl %dl, %edx
movzbl (%rdi,%r8), %r9d
xorl %edx, %r9d
xorl (%rcx,%r9,4), %eax
incq %r8
movl %eax, %edx
cmpq %r8, %rsi
jne 0x273ac
jmp 0x273cc
movl %edx, %eax
notl %eax
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/BU-DiSC[P]BF-Shared-Hashing/hash/city.cc
// Function: HashLen0to16(char const*, unsigned long)
static uint64 HashLen0to16(const char *s, size_t len) {
  if (len >= 8) {
    uint64 mul = k2 + len * 2;
    uint64 a = Fetch64(s) + k2;
    uint64 b = Fetch64(s + len - 8);
    uint64 c = Rotate(b, 37) * mul + a;
    uint64 d = (Rotate(a, 25) + b) * mul;
    return HashLen16(c, d, mul);
  }
  if (len >= 4) {
    uint64 mul = k2 + len * 2;
    uint64 a = Fetch32(s);
    return HashLen16(len + (a << 3), Fetch32(s + len - 4), mul);
  }
  if (len > 0) {
    uint8 a = s[0];
    uint8 b = s[len >> 1];
    uint8 c = s[len - 1];
    uint32 y = static_cast<uint32>(a) + (static_cast<uint32>(b) << 8);
    uint32 z = len + (static_cast<uint32>(c) << 2);
    return ShiftMix(y * k2 ^ z * k0) * k2;
  }
  return k2;
}

// Assembly:
movabsq $-0x651e95c4d06fbfb1, %rax # imm = 0x9AE16A3B2F90404F
cmpq $0x8, %rsi
jb 0x28132
leaq (%rax,%rsi,2), %rcx
addq (%rdi), %rax
movq -0x8(%rdi,%rsi), %rdx
movq %rdx, %rsi
rolq $0x1b, %rsi
imulq %rcx, %rsi
addq %rax, %rsi
rolq $0x27, %rax
addq %rdx, %rax
imulq %rcx, %rax
xorq %rax, %rsi
imulq %rcx, %rsi
xorq %rsi, %rax
shrq $0x2f, %rsi
xorq %rax, %rsi
imulq %rcx, %rsi
movq %rsi, %rax
shrq $0x2f, %rax
xorq %rsi, %rax
jmp 0x28165
cmpq $0x4, %rsi
jb 0x2816a
leaq (%rax,%rsi,2), %rcx
movl (%rdi), %eax
leaq (%rsi,%rax,8), %rdx
movl -0x4(%rdi,%rsi), %eax
xorq %rax, %rdx
imulq %rcx, %rdx
xorq %rdx, %rax
shrq $0x2f, %rdx
xorq %rax, %rdx
imulq %rcx, %rdx
movq %rdx, %rax
shrq $0x2f, %rax
xorq %rdx, %rax
imulq %rcx, %rax
retq
testq %rsi, %rsi
je 0x281b0
movzbl (%rdi), %ecx
movq %rsi, %rdx
shrq %rdx
movzbl (%rdi,%rdx), %edx
movzbl -0x1(%rdi,%rsi), %edi
shll $0x8, %edx
orq %rcx, %rdx
shll $0x2, %edi
orq %rsi, %rdi
imulq %rax, %rdx
movabsq $-0x3c5a37a36834ced9, %rcx # imm = 0xC3A5C85C97CB3127
imulq %rdi, %rcx
xorq %rdx, %rcx
movq %rcx, %rdx
shrq $0x2f, %rdx
xorq %rcx, %rdx
imulq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/BU-DiSC[P]BF-Shared-Hashing/hash/city.cc
// Function: CityHash128(char const*, unsigned long)
uint128 CityHash128(const char *s, size_t len) {
  return len >= 16 ?
      CityHash128WithSeed(s + 16, len - 16,
                          uint128(Fetch64(s), Fetch64(s + 8) + k0)) :
      CityHash128WithSeed(s, len, uint128(k0, k1));
}

// Assembly:
movabsq $-0x3c5a37a36834ced9, %rcx # imm = 0xC3A5C85C97CB3127
cmpq $0x10, %rsi
jb 0x28714
leaq 0x10(%rdi), %rax
addq $-0x10, %rsi
movq (%rdi), %rdx
addq 0x8(%rdi), %rcx
movq %rax, %rdi
jmp 0x2823d
movabsq $-0x4b6d499041670d8d, %rax # imm = 0xB492B66FBE98F273
movq %rcx, %rdx
movq %rax, %rcx
jmp 0x2823d
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_benchmark.cpp
// Function: assertTrue(bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void assertTrue(bool value, const std::string& message = "") {
  if(!value) {
    std::cout << "Error: expected true." << std::endl;
    std::cout << "Message: " << message << std::endl;
    std::exit(1);
  }
}

// Assembly:
testl %edi, %edi
je 0x10a3c
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0xc58e(%rip), %r14      # 0x1cfd8
leaq 0x731f(%rip), %rsi      # 0x17d70
movq %r14, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
leaq 0x731e(%rip), %rsi      # 0x17d86
movq %r14, %rdi
callq 0x21a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2170
movq %rax, %rdi
callq 0x20c0
movl $0x1, %edi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_benchmark.cpp
// Function: getFilePart(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string getFilePart(const std::string& path) {
  if(path.empty()) return "";
  int slash = path.size() - 1;
  while(slash >= 0 && path[(size_t)slash] != '/') slash--;
  return path.substr((size_t)(slash + 1));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x11379
movq (%rsi), %rcx
leal -0x1(%rax), %edi
cmpl $-0x1, %edi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmovll %edi, %edx
movl %eax, %edi
incl %edx
incl %eax
decq %rdi
testl %edi, %edi
js 0x11394
movl %edi, %r8d
andl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
decl %eax
decq %rdi
cmpb $0x2f, (%rcx,%r8)
jne 0x1135d
jmp 0x11396
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x6dff(%rip), %rdx      # 0x18186
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x12d56
jmp 0x113a8
movl %edx, %eax
movslq %eax, %rdx
movq %rbx, %rdi
movq $-0x1, %rcx
callq 0x21e0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_benchmark.cpp
// Function: void assertEquals<int, unsigned int>(int const&, unsigned int const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void assertEquals(const T& expected, const U& actual, const std::string& message = "") {
  if(expected != (T)actual) {
    std::cout << "Error: Not equal! Expected " << expected << " got " << actual << "." << std::endl;
    std::cout << "Message: " << message << std::endl;
    std::exit(1);
  }
}

// Assembly:
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x129eb
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0xa5d5(%rip), %r14      # 0x1cfd8
leaq 0x57d7(%rip), %rsi      # 0x181e1
movq %r14, %rdi
callq 0x21a0
movl (%r12), %esi
movq %rax, %rdi
callq 0x22f0
leaq 0x57d8(%rip), %rsi      # 0x181fd
movq %rax, %rdi
callq 0x21a0
movl (%r15), %esi
movq %rax, %rdi
callq 0x2250
leaq 0x5345(%rip), %rsi      # 0x17d84
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
leaq 0x5330(%rip), %rsi      # 0x17d86
movq %r14, %rdi
callq 0x21a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2170
movq %rax, %rdi
callq 0x20c0
movl $0x1, %edi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/wenleix[P]EdgePPR/src/ParamPPR.cpp
// Function: WorkerThread(void*)
void *WorkerThread(void *__conf) {
	ThreadConfig* conf = (ThreadConfig*)__conf;

	fprintf(stdout, "INFO: Thread %d start!\n", conf->threadId);

	double *value = new double[conf->g->numVertex];
	for (int i = conf->start; i < conf->end; i++) {
		int paramId = conf->paramIdx[i];
		double *curParam = conf->params + ParamGraph_NumEdgeTypes * paramId;
		fprintf(stderr, "DEBUG: Param:");
		for (int j = 0; j < ParamGraph_NumEdgeTypes; j++)
			fprintf(stderr, " %.2lf", curParam[j]);
		fprintf(stderr, "\n");

		ParamJacobiSolver(conf->g, conf->pref, value, curParam);

		//	Print out the useful vertices
		char filenameBuf[1000];
		sprintf(filenameBuf, "%s-%d", conf->outputPrefix, paramId);
		WriteVector(value, conf->g->numVertex, filenameBuf, conf->outputFormat);
		fprintf(stderr, "DEBUG: Thread %d finished param %d!\n", conf->threadId, paramId);
	}

	fprintf(stdout, "INFO: Thread %d done!\n", conf->threadId);
	pthread_exit(NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3f8, %rsp            # imm = 0x3F8
movq %rdi, %rbx
movq 0x5691(%rip), %rax      # 0x7fc8
movq (%rax), %rdi
movl (%rbx), %edx
leaq 0x26fd(%rip), %rsi      # 0x5040
xorl %eax, %eax
callq 0x21e0
movq 0x40(%rbx), %rax
movslq (%rax), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x2030
movq %rax, (%rsp)
movslq 0x10(%rbx), %rbp
cmpl 0x14(%rbx), %ebp
jge 0x2a6b
movq 0x565c(%rip), %r14      # 0x7fe0
leaq 0x26db(%rip), %r12      # 0x5066
movq 0x30(%rbx), %rax
movl (%rax,%rbp,4), %ecx
leal (,%rcx,8), %eax
movq %rcx, 0x8(%rsp)
subl %ecx, %eax
movslq %eax, %r15
shlq $0x3, %r15
addq 0x8(%rbx), %r15
movq (%r14), %rcx
movl $0xd, %esi
movl $0x1, %edx
leaq 0x2699(%rip), %rdi      # 0x5058
callq 0x2290
xorl %r13d, %r13d
movq (%r14), %rdi
movsd (%r15,%r13,8), %xmm0
movq %r12, %rsi
movb $0x1, %al
callq 0x21e0
incq %r13
cmpq $0x7, %r13
jne 0x29c7
movq (%r14), %rsi
movl $0xa, %edi
callq 0x21b0
movq 0x28(%rbx), %rsi
movq 0x40(%rbx), %rdi
movq (%rsp), %r13
movq %r13, %rdx
movq %r15, %rcx
movsd 0x25fe(%rip), %xmm0     # 0x5008
callq 0x256a
movq 0x20(%rbx), %rdx
leaq 0x10(%rsp), %rdi
leaq 0x264e(%rip), %rsi      # 0x506d
movq 0x8(%rsp), %r15
movl %r15d, %ecx
xorl %eax, %eax
callq 0x2050
movq 0x38(%rbx), %rcx
movq 0x40(%rbx), %rax
movl (%rax), %esi
movq %r13, %rdi
leaq 0x10(%rsp), %rdx
callq 0x3b16
movq (%r14), %rdi
movl (%rbx), %edx
leaq 0x2622(%rip), %rsi      # 0x5073
movl %r15d, %ecx
xorl %eax, %eax
callq 0x21e0
incq %rbp
movslq 0x14(%rbx), %rax
cmpq %rax, %rbp
jl 0x298b
movq 0x5556(%rip), %rax      # 0x7fc8
movq (%rax), %rdi
movl (%rbx), %edx
leaq 0x261a(%rip), %rsi      # 0x5098
xorl %eax, %eax
callq 0x21e0
xorl %edi, %edi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/wenleix[P]EdgePPR/src/ParamGraph.cpp
// Function: ParamGraph::SetWeight(double*)
void ParamGraph::SetWeight(double param[7]) {
	for (int i = 0; i < numVertex; i++) {
		ParamVertex *v = GetVertex(i);
		for (int j = 0; j < v->outDeg; j++) {
			ParamEdge *e = &(v->outEdge[j]);
			int etype = e->GetIntEType();
			e->weight = param[etype] / v->outEdgeTypeCount[etype];
		}
	}
}

// Assembly:
movslq (%rdi), %rax
testq %rax, %rax
jle 0x3801
movq 0x8(%rdi), %rcx
xorl %edx, %edx
leaq (%rdx,%rdx,2), %rdi
shlq $0x5, %rdi
movslq 0x30(%rcx,%rdi), %r8
testq %r8, %r8
jle 0x37f9
addq %rcx, %rdi
movq 0x38(%rdi), %r9
shlq $0x4, %r8
xorl %r10d, %r10d
movslq 0x4(%r9,%r10), %r11
movsd (%rsi,%r11,8), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl 0x40(%rdi,%r11,4), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%r9,%r10)
addq $0x10, %r10
cmpq %r10, %r8
jne 0x37d0
incq %rdx
cmpq %rax, %rdx
jne 0x37b0
retq
// File: /workspace/github_cpp_makefile_star2_O3/wenleix[P]EdgePPR/src/PPRCommon.cpp
// Function: WriteVector(double*, int, char*, char*)
void WriteVector(double *pprValue, int size, char* filename, char* suffix) {
	char fullname[1000];
	sprintf(fullname, "%s.%s", filename, suffix);

	if (strcmp(suffix, "txt") == 0) {
		FILE *f = fopen(fullname, "w");
		fprintf(f, "%d\n", size);
		for (int i = 0; i < size; i++)
			fprintf(f, "%.8lf\n", pprValue[i]);
		fclose(f);
	} else if (strcmp(suffix, "bin") == 0) {
		FILE *f = fopen(fullname, "wb");
		fwrite(&size, sizeof(int), 1, f);
		fwrite(pprValue, sizeof(double), size, f);
		fclose(f);
	} else {
		assert(false);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3f8, %rsp            # imm = 0x3F8
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
leaq 0x19f2(%rip), %rsi      # 0x552c
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x2050
leaq 0x15d0(%rip), %rsi      # 0x511d
movq %r14, %rdi
callq 0x21d0
testl %eax, %eax
je 0x3bb3
leaq 0x15b9(%rip), %rsi      # 0x5119
movq %r14, %rdi
callq 0x21d0
testl %eax, %eax
jne 0x3c1f
leaq 0x1a6b(%rip), %rsi      # 0x55e2
leaq 0x10(%rsp), %rdi
callq 0x2190
movq %rax, %r14
leaq 0xc(%rsp), %r15
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rax, %rcx
callq 0x2290
movslq (%r15), %rdx
movl $0x8, %esi
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2290
jmp 0x3c06
leaq 0x1a1f(%rip), %rsi      # 0x55d9
leaq 0x10(%rsp), %rdi
callq 0x2190
movq %rax, %r14
leaq 0x190a(%rip), %rsi      # 0x54d8
movq %rax, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x21e0
testl %ebp, %ebp
jle 0x3c06
movl %ebp, %r12d
xorl %r13d, %r13d
leaq 0x19f0(%rip), %r15      # 0x55db
movsd (%rbx,%r13,8), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x21e0
incq %r13
cmpq %r13, %r12
jne 0x3beb
movq %r14, %rdi
addq $0x3f8, %rsp            # imm = 0x3F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2130
leaq 0x19ad(%rip), %rdi      # 0x55d3
leaq 0x1927(%rip), %rsi      # 0x5554
leaq 0x19b1(%rip), %rcx      # 0x55e5
movl $0xc5, %edx
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/wenleix[P]EdgePPR/src/PPRCommon.cpp
// Function: L1(double*, double*, int)
double L1(double *trueprv, double *estprv, int n) {
	double diff = 0.0, sum = 0.0;
	for (int i = 0; i < n; i++) {
		diff += fabs(trueprv[i] - estprv[i]);
		sum += trueprv[i];
	}

	return diff / sum;
}

// Assembly:
testl %edx, %edx
jle 0x3c79
movl %edx, %eax
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
movapd 0x17fe(%rip), %xmm2     # 0x5450
xorpd %xmm0, %xmm0
movsd (%rdi,%rcx,8), %xmm3
addsd %xmm3, %xmm1
subsd (%rsi,%rcx,8), %xmm3
andpd %xmm2, %xmm3
addsd %xmm3, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x3c56
divsd %xmm1, %xmm0
retq
movsd 0x17b7(%rip), %xmm0     # 0x5438
retq
// File: /workspace/github_cpp_makefile_star2_O3/lhydave[P]SysYCompilerLab/front/symtab.cpp
// Function: sysY_AST::inc_blk()
void inc_blk()
{
	if (create)
	{
		blk_id++;
		var_stack.push_back(var_table_t());
	}
	create = true;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
cmpb $0x1, 0x206b3(%rip)     # 0x352b4
jne 0x14c4f
incl 0x207cf(%rip)           # 0x353d8
leaq 0x38(%rsp), %rax
movq $0x0, -0x10(%rax)
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
leaq 0x2072d(%rip), %rdi     # 0x35368
leaq 0x8(%rsp), %rsi
callq 0x15bb0
leaq 0x8(%rsp), %rdi
callq 0x156a6
movb $0x1, 0x2065e(%rip)     # 0x352b4
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x156a6
movq %rbx, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O3/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: yyerror(char const*, int)
void yyerror(const char *msg, int lineno)
{
	has_err = true;
	++err_cnt;
	if (err_cnt > err_max)
	{
		fprintf(stderr, "Too many errors, aborted.\n");
		exit(1);
	}
	fprintf(stderr, "error happens near line %d: %s\n", lineno, msg);
}

// Assembly:
movl %esi, %edx
movq %rdi, %rcx
leaq 0x2d3b4(%rip), %rax     # 0x353f0
movb $0x1, (%rax)
movl 0x2d2fb(%rip), %eax     # 0x35340
leal 0x1(%rax), %esi
movl %esi, 0x2d2f2(%rip)     # 0x35340
movq 0x2cf83(%rip), %rsi     # 0x34fd8
movq (%rsi), %rdi
cmpl $0x28, %eax
jge 0x806b
leaq 0x20877(%rip), %rsi     # 0x288db
xorl %eax, %eax
jmp 0x53a0
pushq %rax
callq 0x5540
// File: /workspace/github_cpp_makefile_star2_O3/lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::str2op(char const*)
op_t str2op(const char *s)
{
	switch (s[0])
	{
	case '+': return ADD;
	case '-': return SUB;
	case '*': return MUL;
	case '/': return DIV;
	case '%': return MOD;
	case '&': return AND;
	case '|': return OR;
	case '<':
		if (s[1] == '=')
			return LE;
		return L;
	case '>':
		if (s[1] == '=')
			return GE;
		return G;
	case '!':
		if (s[1] == '=')
			return NE;
		return NOT;
	default: return NONE;
	}
}

// Assembly:
movzbl (%rdi), %eax
cmpl $0x3b, %eax
jg 0x80c1
addl $-0x21, %eax
cmpl $0xe, %eax
ja 0x811c
leaq 0x205c2(%rip), %rcx     # 0x28668
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x3d, 0x1(%rdi)
movl $0x2, %ecx
movl $0xf, %eax
cmovel %ecx, %eax
retq
cmpl $0x3c, %eax
je 0x80fa
cmpl $0x3e, %eax
je 0x810b
cmpl $0x7c, %eax
jne 0x811c
movl $0xe, %eax
retq
movl $0xb, %eax
retq
movl $0xa, %eax
retq
movl $0x8, %eax
retq
movl $0xd, %eax
retq
movl $0xc, %eax
retq
movl $0x7, %eax
retq
xorl %eax, %eax
cmpb $0x3d, 0x1(%rdi)
setne %al
leal 0x4(,%rax,2), %eax
retq
xorl %eax, %eax
cmpb $0x3d, 0x1(%rdi)
setne %al
leal 0x3(,%rax,2), %eax
retq
xorl %eax, %eax
retq