LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/./args.hxx
// Function: args::Matcher::GetLongOrAny() const
EitherFlag GetLongOrAny() const
            {
                if (!longFlags.empty())
                {
                    return *longFlags.begin();
                }

                if (!shortFlags.empty())
                {
                    return *shortFlags.begin();
                }

                // should be unreachable
                return ' ';
            }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x50(%rsi)
je 0x17251
movq 0x48(%rsi), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x17312
jmp 0x1727d
cmpq $0x0, 0x18(%rsi)
je 0x17267
movq 0x10(%rsi), %rax
movb 0x8(%rax), %al
movb $0x1, (%rbx)
movb %al, 0x1(%rbx)
jmp 0x1726c
movw $0x2001, (%rbx)         # imm = 0x2001
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rsi
testl %edx, %edx
je 0x173aa
movq %rcx, %r14
cmpq $0x0, 0x8(%rcx)
jne 0x173b9
jmp 0x173d3
testb %r8b, %r8b
je 0x173d3
cmpq $0x0, 0x8(%r9)
movq %r9, %r14
je 0x173d3
movq %rbx, %rdi
callq 0x6740
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6740
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
cmpq %r12, %r15
je 0x17428
cmpq $0x0, 0x8(%rbx)
je 0x17417
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6740
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6740
addq $0x20, %r15
jmp 0x17400
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x61f0
movq %r14, %rdi
callq 0x66b0
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x50(%rsi), %rsi
addq 0x18(%r14), %rsi
callq 0x17812
leaq 0x10(%r14), %r12
leaq 0x7(%rsp), %r15
movq (%r12), %r12
testq %r12, %r12
je 0x177b0
movb 0x8(%r12), %al
movb %al, 0x7(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x178a8
jmp 0x17791
addq $0x48, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x177ca
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x178d8
jmp 0x177b4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x177dd
jmp 0x177dd
movq %rax, %r14
movq %rbx, %rdi
callq 0x177f0
movq %r14, %rdi
callq 0x66b0
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x178(%rdi), %rsi
xorl %r15d, %r15d
movq %r14, %rdi
xorl %edx, %edx
callq 0x6770
testq %rax, %rax
je 0x18ba6
leaq 0x198(%rbx), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x6770
testq %rax, %rax
je 0x18bba
pushq $0x2
popq %r15
jmp 0x18bd0
testb %bpl, %bpl
jne 0x18bd0
movq 0x8(%r14), %rax
cmpq 0x180(%rbx), %rax
jbe 0x18b8a
jmp 0x18bd0
pushq $0x1
popq %r15
testb %bpl, %bpl
jne 0x18bd0
movq 0x8(%r14), %rax
cmpq 0x1a0(%rbx), %rax
jbe 0x18ba0
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %r14
cmpq $0x0, 0x8(%rsi)
je 0x19a20
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6770
testq %rax, %rax
jne 0x19a64
movl $0x130, %edi            # imm = 0x130
addq 0x200(%r14), %rdi
leaq 0x94b3(%rip), %rsi      # 0x22ee6
callq 0x192de
testb %al, %al
je 0x19a4d
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x18b62
testl %eax, %eax
je 0x19a73
movl $0x110, %edi            # imm = 0x110
addq 0x200(%r14), %rdi
movq %rbx, %rsi
callq 0x74c4
movb $0x1, %r15b
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1b8(%r14), %r15
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x6770
cmpq $-0x1, %rax
je 0x19a4d
movl $0x110, %r12d           # imm = 0x110
addq 0x200(%r14), %r12
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x6770
leaq 0x1(%rax), %rdx
leaq 0x8(%rsp), %r14
pushq $-0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6440
movq %r12, %rdi
movq %r14, %rsi
callq 0x14ef6
leaq 0x8(%rsp), %rdi
callq 0x61f0
jmp 0x19a61
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x61f0
movq %rbx, %rdi
callq 0x66b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1a06b
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x210(%rdi), %rdx
movq %rsp, %r12
movq %r12, %rdi
callq 0x19aea
movq (%r12), %r15
movq 0x8(%r12), %r12
cmpq %r12, %r15
je 0x1a0a5
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x199f6
addq $0x20, %r15
jmp 0x1a08c
movq %rsp, %rdi
callq 0x739e
pushq $0x10
popq %rdi
callq 0x6220
movq %rax, %r14
movq 0x200(%rbx), %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x19b4c
movb $0x1, %bpl
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19298
xorl %ebp, %ebp
leaq 0x1a9df(%rip), %rsi     # 0x34ac0
movq 0x1aed8(%rip), %rdx     # 0x34fc0
movq %r14, %rdi
callq 0x6680
movq %rax, %rbx
movq %rsp, %rdi
callq 0x739e
jmp 0x1a115
movq %rax, %rbx
movq %rsp, %rdi
callq 0x61f0
testb %bpl, %bpl
je 0x1a115
movq %r14, %rdi
callq 0x62f0
movq %rbx, %rdi
callq 0x66b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1a0(%rsp), %r12
pushq $0x8
popq %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x6660
movq %r12, %rdi
movq %r15, %rsi
callq 0x6290
movq %rax, %rdi
callq 0x6360
leaq 0x1b0(%rsp), %rdi
callq 0x66f0
testq %rax, %rax
jg 0x1cb1c
leaq 0x1a0(%rsp), %rdi
callq 0x6200
movb $0x1, %al
addq $0x320, %rsp            # imm = 0x320
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%rsp), %rdi
callq 0x6560
leaq 0x65a2(%rip), %rsi      # 0x230cf
leaq 0x28(%rsp), %rdi
callq 0x6410
movq %rax, %rdi
movq %r14, %rsi
callq 0x63b0
leaq 0x6591(%rip), %rsi      # 0x230da
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
movq %rbx, %rsi
callq 0x63b0
leaq 0x64f7(%rip), %rsi      # 0x2305a
movq %rax, %rdi
callq 0x6410
pushq $0x10
popq %rdi
callq 0x6220
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x6610
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x191d6
xorl %ebp, %ebp
leaq 0x17802(%rip), %rsi     # 0x343a0
movq 0x1841b(%rip), %rdx     # 0x34fc0
movq %rbx, %rdi
callq 0x6680
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x61f0
testb %bpl, %bpl
jne 0x1cbc4
jmp 0x1cbd1
movq %rax, %r14
movq %rbx, %rdi
callq 0x62f0
jmp 0x1cbd1
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x6100
jmp 0x1cbe2
jmp 0x1cbdf
movq %rax, %r14
leaq 0x1a0(%rsp), %rdi
callq 0x6200
movq %r14, %rdi
callq 0x66b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x0, (%rdi)
jne 0x1ccda
leaq 0x44(%rbx), %rsi
leaq 0x8(%rsp), %r14
pushq $0x8
popq %rbp
movq %r14, %rdi
movl %ebp, %edx
callq 0x1cd00
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 0x18786(%rip), %rsi     # 0x35420
movq %rbx, %rdi
callq 0x1d4d8
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x1d4d8
leaq 0x5c(%rbx), %rdi
leaq 0x4c(%rbx), %rsi
pushq $0x10
popq %rdx
callq 0x1cd00
xorps %xmm0, %xmm0
movups %xmm0, 0x31(%rbx)
movups %xmm0, 0x21(%rbx)
movups %xmm0, 0x11(%rbx)
movups %xmm0, 0x1(%rbx)
andq $0x0, 0x44(%rbx)
movb $0x1, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
addl $0x3, %edx
shrl $0x2, %edx
xorl %eax, %eax
cmpq %rax, %rdx
je 0x1cd30
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
jmp 0x1cd08
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %ecx
movl %ecx, %eax
shrl $0x3, %eax
andl $0x3f, %eax
leal (,%rbx,8), %edx
movl %ebx, %edi
shrl $0x1d, %edi
addl %ecx, %edx
movl %edx, 0x44(%r14)
adcl %edi, 0x48(%r14)
movq %rsi, %r15
pushq $0x40
popq %r13
subl %eax, %r13d
cmpl %ebx, %r13d
jbe 0x1d547
movl %eax, %r12d
xorl %r13d, %r13d
leaq (%r14,%r12), %rdi
incq %rdi
movl %r13d, %eax
addq %rax, %r15
subl %r13d, %ebx
movq %r15, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6350
leaq 0x1(%r14), %r12
leaq (%r14,%rax), %rdi
incq %rdi
movl %r13d, %edx
movq %r15, %rsi
callq 0x6350
movq %r14, %rdi
movq %r12, %rsi
callq 0x1cd32
xorl %r12d, %r12d
leal 0x40(%r13), %ebp
cmpl %ebx, %ebp
ja 0x1d51e
movl %r13d, %esi
addq %r15, %rsi
movq %r14, %rdi
callq 0x1cd32
movl %ebp, %r13d
jmp 0x1d56b
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x40, %rsp
movq %rdi, %rbx
cmpb $0x0, (%rsi)
je 0x1d5cf
movq %rsi, %r14
leaq 0x10(%rsp), %r15
leaq 0x5146(%rip), %r12      # 0x226f0
xorl %r13d, %r13d
cmpq $0x10, %r13
je 0x1d5dd
movzbl 0x5c(%r14,%r13), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x60b0
incq %r13
addq $0x2, %r15
jmp 0x1d5ad
leaq 0x4e03(%rip), %rsi      # 0x223d9
leaq 0x10(%rsp), %rdx
jmp 0x1d5eb
leaq 0x10(%rsp), %rsi
movb $0x0, 0x20(%rsi)
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x61b0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %rcx # imm = 0xC6A4A7935BD1E995
movl %edx, %edx
movslq %esi, %rax
movq %rax, %r8
imulq %rcx, %r8
xorq %rdx, %r8
pushq $0x8
popq %r9
cltd
idivl %r9d
cltq
leaq (,%rax,8), %rdx
xorl %r9d, %r9d
cmpq %r9, %rdx
je 0x1d6e1
movq (%rdi,%r9), %r10
imulq %rcx, %r10
movq %r10, %r11
shrq $0x2f, %r11
xorq %r10, %r11
imulq %rcx, %r11
xorq %r8, %r11
imulq %rcx, %r11
addq $0x8, %r9
movq %r11, %r8
jmp 0x1d6b6
andl $0x7, %esi
leaq 0x5cf5(%rip), %rdx      # 0x233e0
movslq (%rdx,%rsi,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movzbl 0x6(%rdi,%rax,8), %edx
shlq $0x30, %rdx
xorq %rdx, %r8
movzbl 0x5(%rdi,%rax,8), %edx
shlq $0x28, %rdx
xorq %rdx, %r8
movzbl 0x4(%rdi,%rax,8), %edx
shlq $0x20, %rdx
xorq %rdx, %r8
movzbl 0x3(%rdi,%rax,8), %edx
shll $0x18, %edx
xorq %rdx, %r8
movzbl 0x2(%rdi,%rax,8), %edx
shll $0x10, %edx
xorq %rdx, %r8
movzbl 0x1(%rdi,%rax,8), %edx
shll $0x8, %edx
xorq %rdx, %r8
movzbl (%rdi,%rax,8), %eax
xorq %r8, %rax
imulq %rcx, %rax
movq %rax, %r8
movq %r8, %rdx
shrq $0x2f, %rdx
xorq %r8, %rdx
imulq %rcx, %rdx
movq %rdx, %rax
shrq $0x2f, %rax
xorq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1def4
movdqu 0x8(%rsi), %xmm0
movdqa 0x5696(%rip), %xmm1     # 0x23540
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 0x1defc
movl $0x165667b1, %edi       # imm = 0x165667B1
addl 0x10(%rsi), %edi
addl (%rsi), %edi
movl 0x28(%rsi), %edx
addq $0x18, %rsi
jmp 0x1df07
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/hash/xxh3p.h
// Function: XXH3p_len_129to240_64b(unsigned char const*, unsigned long, unsigned char const*, unsigned long, unsigned long)
XXH_NO_INLINE XXH64_hash_t
XXH3p_len_129to240_64b(const xxh_u8* XXH_RESTRICT input, size_t len,
                      const xxh_u8* XXH_RESTRICT secret, size_t secretSize,
                      XXH64_hash_t seed)
{
    XXH_ASSERT(secretSize >= XXH3p_SECRET_SIZE_MIN); (void)secretSize;
    XXH_ASSERT(128 < len && len <= XXH3p_MIDSIZE_MAX);

    #define XXH3p_MIDSIZE_STARTOFFSET 3
    #define XXH3p_MIDSIZE_LASTOFFSET  17

    {   xxh_u64 acc = len * PRIME64_1;
        int const nbRounds = (int)len / 16;
        int i;
        for (i=0; i<8; i++) {
            acc += XXH3p_mix16B(input+(16*i), secret+(16*i), seed);
        }
        acc = XXH3p_avalanche(acc);
        XXH_ASSERT(nbRounds >= 8);
        for (i=8 ; i < nbRounds; i++) {
            acc += XXH3p_mix16B(input+(16*i), secret+(16*(i-8)) + XXH3p_MIDSIZE_STARTOFFSET, seed);
        }
        /* last bytes */
        acc += XXH3p_mix16B(input + len - 16, secret + XXH3p_SECRET_SIZE_MIN - XXH3p_MIDSIZE_LASTOFFSET, seed);
        return XXH3p_avalanche(acc);
    }
}

// Assembly:
movq %rdx, %r8
movabsq $-0x61c8864e7a143579, %r10 # imm = 0x9E3779B185EBCA87
imulq %rsi, %r10
xorl %r9d, %r9d
cmpq $0x80, %r9
je 0x1e7c1
movq (%r8,%r9), %rdx
addq %rcx, %rdx
xorq (%rdi,%r9), %rdx
movq 0x8(%r8,%r9), %rax
subq %rcx, %rax
xorq 0x8(%rdi,%r9), %rax
mulq %rdx
xorq %rax, %rdx
addq %rdx, %r10
addq $0x10, %r9
jmp 0x1e791
pushq %r14
pushq %rbx
movabsq $0x165667b19e3779f9, %r9 # imm = 0x165667B19E3779F9
movl %esi, %r11d
shrl $0x4, %r11d
movq %r10, %rax
shrq $0x25, %rax
xorq %r10, %rax
imulq %r9, %rax
movq %rax, %r10
shrq $0x20, %r10
xorq %rax, %r10
movabsq $0x8, %rbx
xorl %r14d, %r14d
cmpq %r11, %rbx
jae 0x1e831
movq 0x3(%r8,%r14), %rdx
addq %rcx, %rdx
xorq 0x80(%rdi,%r14), %rdx
movq 0xb(%r8,%r14), %rax
subq %rcx, %rax
xorq 0x88(%rdi,%r14), %rax
mulq %rdx
xorq %rax, %rdx
addq %rdx, %r10
incq %rbx
addq $0x10, %r14
jmp 0x1e7fa
movq 0x77(%r8), %rdx
addq %rcx, %rdx
xorq -0x10(%rdi,%rsi), %rdx
movq 0x7f(%r8), %rax
subq %rcx, %rax
xorq -0x8(%rdi,%rsi), %rax
mulq %rdx
xorq %rdx, %rax
addq %r10, %rax
movq %rax, %rcx
shrq $0x25, %rcx
xorq %rcx, %rax
imulq %r9, %rax
movq %rax, %rcx
shrq $0x20, %rcx
xorq %rcx, %rax
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
notl %eax
xorl %ecx, %ecx
leaq 0x2ab5(%rip), %rdx      # 0x236c0
cmpq %rcx, %rsi
je 0x20c40
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
jmp 0x20c0b
notl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
notl %eax
xorl %ecx, %ecx
leaq 0x2ab0(%rip), %rdx      # 0x23700
cmpq %rcx, %rsi
je 0x20c6d
movzbl %al, %r8d
shrl $0x8, %eax
movzbl (%rdi,%rcx), %r9d
xorl %r8d, %r9d
xorl (%rdx,%r9,4), %eax
incq %rcx
jmp 0x20c50
notl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
notl %eax
xorl %ecx, %ecx
movdqa 0x2996(%rip), %xmm0     # 0x23680
movdqa 0x299e(%rip), %xmm1     # 0x23690
movdqa 0x29a6(%rip), %xmm2     # 0x236a0
movdqa 0x29ae(%rip), %xmm3     # 0x236b0
cmpq %rcx, %rsi
je 0x20d56
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
shrl $0x8, %eax
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, %edx
xorl %edx, %eax
incq %rcx
jmp 0x20d02
notl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl %edx, %eax
notl %eax
leaq 0x299c(%rip), %rcx      # 0x23700
movl $0xff, %edx
cmpq $0x3, %rsi
jbe 0x20dbb
xorl (%rdi), %eax
addq $0x4, %rdi
movl %eax, %r8d
shrl $0x18, %r8d
movl %eax, %r9d
shrl $0xe, %r9d
andl $0x3fc, %r9d            # imm = 0x3FC
movl 0x400(%r9,%rcx), %r9d
xorl (%rcx,%r8,4), %r9d
movl %eax, %r8d
shrl $0x8, %r8d
andl %edx, %r8d
xorl 0x800(%rcx,%r8,4), %r9d
andl %edx, %eax
xorl 0xc00(%rcx,%rax,4), %r9d
addq $-0x4, %rsi
movl %r9d, %eax
jmp 0x20d69
xorl %edx, %edx
cmpq %rdx, %rsi
je 0x20dda
movzbl %al, %r8d
shrl $0x8, %eax
movzbl (%rdi,%rdx), %r9d
xorl %r8d, %r9d
xorl (%rcx,%r9,4), %eax
incq %rdx
jmp 0x20dbd
notl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/hash/Crc32.cpp
// Function: crc32_8bytes(void const*, unsigned long, unsigned int)
uint32_t crc32_8bytes(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 eight bytes at once (Slicing-by-8)
  while (length >= 8)
  {
#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 -= 8;
  }

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

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

// Assembly:
movl %edx, %eax
notl %eax
leaq 0x2918(%rip), %rcx      # 0x23700
movl $0x3fc, %edx            # imm = 0x3FC
movl $0xff, %r8d
cmpq $0x7, %rsi
jbe 0x20e8b
xorl (%rdi), %eax
movl 0x4(%rdi), %r10d
movl %r10d, %r11d
shrl $0x18, %r11d
movl %r10d, %r9d
shrl $0xe, %r9d
andl %edx, %r9d
movl 0x400(%r9,%rcx), %r9d
xorl (%rcx,%r11,4), %r9d
movl %r10d, %r11d
shrl $0x8, %r11d
andl %r8d, %r11d
xorl 0x800(%rcx,%r11,4), %r9d
andl %r8d, %r10d
xorl 0xc00(%rcx,%r10,4), %r9d
movl %eax, %r10d
shrl $0x18, %r10d
xorl 0x1000(%rcx,%r10,4), %r9d
movl %eax, %r10d
shrl $0xe, %r10d
andl %edx, %r10d
xorl 0x1400(%r10,%rcx), %r9d
movl %eax, %r10d
shrl $0x8, %r10d
andl %r8d, %r10d
xorl 0x1800(%rcx,%r10,4), %r9d
andl %r8d, %eax
xorl 0x1c00(%rcx,%rax,4), %r9d
addq $-0x8, %rsi
addq $0x8, %rdi
movl %r9d, %eax
jmp 0x20df3
xorl %edx, %edx
cmpq %rdx, %rsi
je 0x20eaa
movzbl %al, %r8d
shrl $0x8, %eax
movzbl (%rdi,%rdx), %r9d
xorl %r8d, %r9d
xorl (%rcx,%r9,4), %eax
incq %rdx
jmp 0x20e8d
notl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movl %edx, %eax
notl %eax
leaq 0x2847(%rip), %rcx      # 0x23700
movl $0x3fc, %edx            # imm = 0x3FC
movl $0xff, %r8d
cmpq $0x20, %rsi
jb 0x20f72
xorl %r9d, %r9d
cmpq $0x4, %r9
je 0x20f65
xorl (%rdi,%r9,8), %eax
movl 0x4(%rdi,%r9,8), %r11d
movl %r11d, %ebx
shrl $0x18, %ebx
movl %r11d, %r10d
shrl $0xe, %r10d
andl %edx, %r10d
movl 0x400(%r10,%rcx), %r10d
xorl (%rcx,%rbx,4), %r10d
movl %r11d, %ebx
shrl $0x8, %ebx
andl %r8d, %ebx
xorl 0x800(%rcx,%rbx,4), %r10d
andl %r8d, %r11d
xorl 0xc00(%rcx,%r11,4), %r10d
movl %eax, %r11d
shrl $0x18, %r11d
xorl 0x1000(%rcx,%r11,4), %r10d
movl %eax, %r11d
shrl $0xe, %r11d
andl %edx, %r11d
xorl 0x1400(%r11,%rcx), %r10d
movl %eax, %r11d
shrl $0x8, %r11d
andl %r8d, %r11d
xorl 0x1800(%rcx,%r11,4), %r10d
andl %r8d, %eax
xorl 0x1c00(%rcx,%rax,4), %r10d
incq %r9
movl %r10d, %eax
jmp 0x20ed1
addq $0x20, %rdi
addq $-0x20, %rsi
jmp 0x20ec4
xorl %edx, %edx
cmpq %rdx, %rsi
je 0x20f91
movzbl %al, %r8d
shrl $0x8, %eax
movzbl (%rdi,%rdx), %r9d
xorl %r8d, %r9d
xorl (%rcx,%r9,4), %eax
incq %rdx
jmp 0x20f74
notl %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x21a10
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 0x21a43
cmpq $0x4, %rsi
jb 0x21a48
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 0x21a8e
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_O2/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 0x21f08
leaq 0x10(%rdi), %rax
addq $-0x10, %rsi
movq (%rdi), %rdx
addq 0x8(%rdi), %rcx
movq %rax, %rdi
jmp 0x21b0c
movabsq $-0x4b6d499041670d8d, %rax # imm = 0xB492B66FBE98F273
movq %rcx, %rdx
movq %rax, %rcx
jmp 0x21b0c
// File: /workspace/github_cpp_makefile_star2_O2/BU-DiSC[P]BF-Shared-Hashing/hash/city.cc
// Function: Mur(unsigned int, unsigned int)
static uint32 Mur(uint32 a, uint32 h) {
  // Helper from Murmur3 for combining two 32-bit values.
  a *= c1;
  a = Rotate32(a, 17);
  a *= c2;
  h ^= a;
  h = Rotate32(h, 19);
  return h * 5 + 0xe6546b64;
}

// Assembly:
imull $0xcc9e2d51, %edi, %eax # imm = 0xCC9E2D51
shrl $0x11, %eax
imull $0x16a88000, %edi, %ecx # imm = 0x16A88000
orl %eax, %ecx
imull $0x1b873593, %ecx, %eax # imm = 0x1B873593
xorl %esi, %eax
roll $0xd, %eax
leal (%rax,%rax,4), %eax
addl $0xe6546b64, %eax       # imm = 0xE6546B64
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe9a8
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0xb622(%rip), %r14      # 0x19fd8
leaq 0x62b3(%rip), %rsi      # 0x14c70
movq %r14, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x2090
leaq 0x62b2(%rip), %rsi      # 0x14c86
movq %r14, %rdi
callq 0x2130
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2110
movq %rax, %rdi
callq 0x2090
pushq $0x1
popq %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0xf19d
movq (%rsi), %rax
movl %edi, %ecx
shlq $0x20, %rdi
decq %rcx
movabsq $-0x100000000, %r8      # imm = 0xFFFFFFFF00000000
movq %rdi, %rdx
testl %ecx, %ecx
js 0xf18c
movl %ecx, %r9d
andl $0x7fffffff, %r9d       # imm = 0x7FFFFFFF
leaq (%rdx,%r8), %rdi
decq %rcx
cmpb $0x2f, (%rax,%r9)
jne 0xf16d
sarq $0x20, %rdx
pushq $-0x1
popq %rcx
movq %rbx, %rdi
callq 0x2170
jmp 0xf1b1
leaq 0x5ee2(%rip), %rsi      # 0x15086
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x2070
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]lodepng/lodepng_benchmark.cpp
// Function: showHelp(int, char**)
void showHelp(int argc, char *argv[]) {
  (void)argc;
  std::cout << "Usage: " << argv[0] << " png_filenames... [OPTIONS...] [--dumpdir directory]" << std::endl;
  std::cout << "Options:" << std::endl;
  std::cout << "  -h: show this help" << std::endl;
  std::cout << "  -v: verbose" << std::endl;
  std::cout << "  -d: decode only" << std::endl;
  std::cout << "  -e: encode only" << std::endl;
  std::cout << "  -o: decode on original images rather than encoded ones (always true if -d without -e)" << std::endl;
  std::cout << "  -m: apply modifications to encoder and decoder settings, the modification itself must be implemented or changed in the benchmark source code (search for apply_mods in the code, for encode and for decode)" << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0xab00(%rip), %rbx      # 0x19fd8
leaq 0x5898(%rip), %rsi      # 0x14d77
movq %rbx, %rdi
callq 0x2130
movq (%r14), %rsi
movq %rax, %rdi
callq 0x2130
leaq 0x5886(%rip), %rsi      # 0x14d7f
movq %rax, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x2090
leaq 0x58a4(%rip), %rsi      # 0x14db4
movq %rbx, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x2090
leaq 0x5896(%rip), %rsi      # 0x14dbd
movq %rbx, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x2090
leaq 0x5894(%rip), %rsi      # 0x14dd2
movq %rbx, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x2090
leaq 0x588b(%rip), %rsi      # 0x14de0
movq %rbx, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x2090
leaq 0x5886(%rip), %rsi      # 0x14df2
movq %rbx, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x2090
leaq 0x5881(%rip), %rsi      # 0x14e04
movq %rbx, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x2090
leaq 0x58c2(%rip), %rsi      # 0x14e5c
movq %rbx, %rdi
callq 0x2130
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2090
// File: /workspace/github_cpp_makefile_star2_O2/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 0x101c3
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x9dfd(%rip), %r14      # 0x19fd8
leaq 0x4eff(%rip), %rsi      # 0x150e1
movq %r14, %rdi
callq 0x2130
movl (%r12), %esi
movq %rax, %rdi
callq 0x2270
leaq 0x4f00(%rip), %rsi      # 0x150fd
movq %rax, %rdi
callq 0x2130
movl (%r15), %esi
movq %rax, %rdi
callq 0x21e0
leaq 0x4a6d(%rip), %rsi      # 0x14c84
movq %rax, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x2090
leaq 0x4a58(%rip), %rsi      # 0x14c86
movq %r14, %rdi
callq 0x2130
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2110
movq %rax, %rdi
callq 0x2090
pushq $0x1
popq %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5bf1(%rip), %rax      # 0x7fc8
movq (%rax), %rdi
movl (%rbx), %edx
leaq 0x2c2d(%rip), %rsi      # 0x5010
xorl %eax, %eax
callq 0x21f0
movq 0x40(%rbx), %rax
movslq (%rax), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x2030
movq %rax, (%rsp)
movslq 0x10(%rbx), %rcx
movq 0x5bc9(%rip), %r14      # 0x7fe0
leaq 0x2c18(%rip), %rbp      # 0x5036
movslq 0x14(%rbx), %rax
cmpq %rax, %rcx
jge 0x24fd
movq 0x30(%rbx), %rax
movq %rcx, 0x8(%rsp)
movl (%rax,%rcx,4), %r15d
imull $0x7, %r15d, %eax
movslq %eax, %r13
shlq $0x3, %r13
addq 0x8(%rbx), %r13
movq (%r14), %rcx
leaq 0x2bd7(%rip), %rdi      # 0x5028
pushq $0xd
popq %rsi
pushq $0x1
popq %rdx
callq 0x22a0
xorl %r12d, %r12d
movq (%r14), %rsi
cmpq $0x7, %r12
je 0x2481
movsd (%r13,%r12,8), %xmm0
movq %rsi, %rdi
movq %rbp, %rsi
movb $0x1, %al
callq 0x21f0
incq %r12
jmp 0x245f
pushq $0xa
popq %rdi
callq 0x21c0
movq 0x28(%rbx), %rsi
movq 0x40(%rbx), %rdi
movq (%rsp), %r12
movq %r12, %rdx
movq %r13, %rcx
movsd 0x2b65(%rip), %xmm0     # 0x5008
callq 0x338e
movq 0x20(%rbx), %rdx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
leaq 0x2b82(%rip), %rsi      # 0x503d
movl %r15d, %ecx
xorl %eax, %eax
callq 0x2050
movq 0x38(%rbx), %rcx
movq 0x40(%rbx), %rax
movl (%rax), %esi
movq %r12, %rdi
movq %r13, %rdx
callq 0x385d
movq (%r14), %rdi
movl (%rbx), %edx
leaq 0x2b5d(%rip), %rsi      # 0x5043
movl %r15d, %ecx
xorl %eax, %eax
callq 0x21f0
movq 0x8(%rsp), %rcx
incq %rcx
jmp 0x241e
movq 0x5ac4(%rip), %rax      # 0x7fc8
movq (%rax), %rdi
movl (%rbx), %edx
leaq 0x2b58(%rip), %rsi      # 0x5068
xorl %eax, %eax
callq 0x21f0
xorl %edi, %edi
callq 0x2260