LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
testb $0x1, (%rax)
jne 0x4bd6d
leaq 0x67(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x6860
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x18690(%rip), %rsi     # 0x643ca
callq 0x66f0
jmp 0x4bd41
leaq 0x67(%rsp), %rdi
callq 0x6570
jmp 0x4be05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x67(%rsp), %rdi
callq 0x6570
jmp 0x4be0f
movl $0x0, 0x2c(%rsp)
cmpl $0x10, 0x2c(%rsp)
jge 0x4bdb7
movq 0x20(%rsp), %rax
leaq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %ecx
shll %ecx
movslq %ecx, %rcx
addq %rcx, %rdi
movslq 0x2c(%rsp), %rcx
movzbl 0x5c(%rax,%rcx), %edx
leaq 0x1894d(%rip), %rsi     # 0x646f0
movb $0x0, %al
callq 0x6100
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x4bd75
movb $0x0, 0x50(%rsp)
leaq 0x2b(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x6860
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x30(%rsp), %rsi
callq 0x66f0
jmp 0x4bddf
leaq 0x2b(%rsp), %rdi
callq 0x6570
jmp 0x4be05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x2b(%rsp), %rdi
callq 0x6570
jmp 0x4be0f
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x6850
nopl (%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/hash/murmurhash.cc
// Function: MurmurHashNeutral2(void const*, int, unsigned int)
unsigned int MurmurHashNeutral2 ( const void * key, int len, unsigned int seed )
{
    const unsigned int m = 0x5bd1e995;
    const int r = 24;

    unsigned int h = seed ^ len;

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

    while(len >= 4)
    {
        unsigned int k;

        k  = data[0];
        k |= data[1] << 8;
        k |= data[2] << 16;
        k |= data[3] << 24;

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

        h *= m;
        h ^= k;

        data += 4;
        len -= 4;
    }

    switch(len)
    {
    case 3: h ^= data[2] << 16;
    case 2: h ^= data[1] << 8;
    case 1: h ^= data[0];
        h *= m;
    };

    h ^= h >> 13;
    h *= m;
    h ^= h >> 15;

    return h;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl $0x5bd1e995, -0x14(%rsp) # imm = 0x5BD1E995
movl $0x18, -0x18(%rsp)
movl -0x10(%rsp), %eax
xorl -0xc(%rsp), %eax
movl %eax, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
cmpl $0x4, -0xc(%rsp)
jl 0x4c5d3
movq -0x28(%rsp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rsp)
movq -0x28(%rsp), %rax
movzbl 0x1(%rax), %eax
shll $0x8, %eax
orl -0x2c(%rsp), %eax
movl %eax, -0x2c(%rsp)
movq -0x28(%rsp), %rax
movzbl 0x2(%rax), %eax
shll $0x10, %eax
orl -0x2c(%rsp), %eax
movl %eax, -0x2c(%rsp)
movq -0x28(%rsp), %rax
movzbl 0x3(%rax), %eax
shll $0x18, %eax
orl -0x2c(%rsp), %eax
movl %eax, -0x2c(%rsp)
imull $0x5bd1e995, -0x2c(%rsp), %eax # imm = 0x5BD1E995
movl %eax, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
shrl $0x18, %eax
xorl -0x2c(%rsp), %eax
movl %eax, -0x2c(%rsp)
imull $0x5bd1e995, -0x2c(%rsp), %eax # imm = 0x5BD1E995
movl %eax, -0x2c(%rsp)
imull $0x5bd1e995, -0x1c(%rsp), %eax # imm = 0x5BD1E995
movl %eax, -0x1c(%rsp)
movl -0x2c(%rsp), %eax
xorl -0x1c(%rsp), %eax
movl %eax, -0x1c(%rsp)
movq -0x28(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rsp)
movl -0xc(%rsp), %eax
subl $0x4, %eax
movl %eax, -0xc(%rsp)
jmp 0x4c523
movl -0xc(%rsp), %eax
movl %eax, -0x30(%rsp)
subl $0x1, %eax
je 0x4c620
jmp 0x4c5e2
movl -0x30(%rsp), %eax
subl $0x2, %eax
je 0x4c60c
jmp 0x4c5ed
movl -0x30(%rsp), %eax
subl $0x3, %eax
jne 0x4c63c
jmp 0x4c5f8
movq -0x28(%rsp), %rax
movzbl 0x2(%rax), %eax
shll $0x10, %eax
xorl -0x1c(%rsp), %eax
movl %eax, -0x1c(%rsp)
movq -0x28(%rsp), %rax
movzbl 0x1(%rax), %eax
shll $0x8, %eax
xorl -0x1c(%rsp), %eax
movl %eax, -0x1c(%rsp)
movq -0x28(%rsp), %rax
movzbl (%rax), %eax
xorl -0x1c(%rsp), %eax
movl %eax, -0x1c(%rsp)
imull $0x5bd1e995, -0x1c(%rsp), %eax # imm = 0x5BD1E995
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
shrl $0xd, %eax
xorl -0x1c(%rsp), %eax
movl %eax, -0x1c(%rsp)
imull $0x5bd1e995, -0x1c(%rsp), %eax # imm = 0x5BD1E995
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
shrl $0xf, %eax
xorl -0x1c(%rsp), %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
retq
nopl (%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/hash/sha-256.c
// Function: init_buf_state(buffer_state*, void const*, unsigned long)
static void init_buf_state(struct buffer_state * state, const void * input, size_t len)
{
	// state->p = input;
	state->p = static_cast<uint8_t const*>(input);
	state->len = len;
	state->total_len = len;
	state->single_one_delivered = 0;
	state->total_len_delivered = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x1c(%rax)
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x4(%rax)
je 0x4d7bb
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
roll %eax
movq 0x10(%rsp), %rcx
movl 0xc(%rcx), %ecx
roll $0x7, %ecx
addl %ecx, %eax
movq 0x10(%rsp), %rcx
movl 0x10(%rcx), %ecx
roll $0xc, %ecx
addl %ecx, %eax
movq 0x10(%rsp), %rcx
movl 0x14(%rcx), %ecx
roll $0x12, %ecx
addl %ecx, %eax
movl %eax, 0xc(%rsp)
jmp 0x4d7cc
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
addl $0x165667b1, %eax       # imm = 0x165667B1
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
addq $0x18, %rsi
movq 0x10(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x4d800
addq $0x18, %rsp
retq
nop
// File: BU-DiSC[P]BF-Shared-Hashing/hash/xxhash.cc
// Function: ROCKSDB_XXH64_reset
XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, XXH64_hash_t seed)
{
    XXH64_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
    memset(&state, 0, sizeof(state));
    state.v1 = seed + PRIME64_1 + PRIME64_2;
    state.v2 = seed + PRIME64_2;
    state.v3 = seed + 0;
    state.v4 = seed - PRIME64_1;
     /* do not write into reserved64, might be removed in a future version */
    memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved64));
    return XXH_OK;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x62e0
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
addq 0x58(%rsp), %rax
movabsq $-0x3d4d51c2d82b14b1, %rcx # imm = 0xC2B2AE3D27D4EB4F
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movabsq $-0x3d4d51c2d82b14b1, %rax # imm = 0xC2B2AE3D27D4EB4F
addq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rax
addq $0x0, %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
subq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rdi
movq %rsp, %rsi
movl $0x50, %edx
callq 0x6440
xorl %eax, %eax
addq $0x68, %rsp
retq
// File: BU-DiSC[P]BF-Shared-Hashing/hash/xxhash.cc
// Function: XXH64_round(unsigned long, unsigned long)
static xxh_u64 XXH64_round(xxh_u64 acc, xxh_u64 input)
{
    acc += input * PRIME64_2;
    acc  = XXH_rotl64(acc, 31);
    acc *= PRIME64_1;
    return acc;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movabsq $-0x3d4d51c2d82b14b1, %rax # imm = 0xC2B2AE3D27D4EB4F
imulq -0x10(%rsp), %rax
addq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
rolq $0x1f, %rax
movq %rax, -0x8(%rsp)
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
imulq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/hash/xxhash.cc
// Function: ROCKSDB_XXH64_digest
XXH_PUBLIC_API XXH64_hash_t XXH64_digest (const XXH64_state_t* state)
{
    xxh_u64 h64;

    if (state->total_len >= 32) {
        xxh_u64 const v1 = state->v1;
        xxh_u64 const v2 = state->v2;
        xxh_u64 const v3 = state->v3;
        xxh_u64 const v4 = state->v4;

        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
        h64 = XXH64_mergeRound(h64, v1);
        h64 = XXH64_mergeRound(h64, v2);
        h64 = XXH64_mergeRound(h64, v3);
        h64 = XXH64_mergeRound(h64, v4);
    } else {
        h64  = state->v3 /*seed*/ + PRIME64_5;
    }

    h64 += (xxh_u64) state->total_len;

    return XXH64_finalize(h64, (const xxh_u8*)state->mem64, (size_t)state->total_len, XXH_aligned);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x20, (%rax)
jb 0x4eb83
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
rolq %rax
movq 0x18(%rsp), %rcx
rolq $0x7, %rcx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
rolq $0xc, %rcx
addq %rcx, %rax
movq 0x8(%rsp), %rcx
rolq $0x12, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x4ebd0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4ebd0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4ebd0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4ebd0
movq %rax, 0x28(%rsp)
jmp 0x4eb9b
movq 0x30(%rsp), %rcx
movabsq $0x27d4eb2f165667c5, %rax # imm = 0x27D4EB2F165667C5
addq 0x18(%rcx), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x28, %rsi
movq 0x30(%rsp), %rax
movq (%rax), %rdx
xorl %ecx, %ecx
callq 0x4ec30
addq $0x38, %rsp
retq
nop
// File: BU-DiSC[P]BF-Shared-Hashing/hash/xxhash.cc
// Function: XXH64_mergeRound(unsigned long, unsigned long)
static xxh_u64 XXH64_mergeRound(xxh_u64 acc, xxh_u64 val)
{
    val  = XXH64_round(0, val);
    acc ^= val;
    acc  = acc * PRIME64_1 + PRIME64_4;
    return acc;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x4ea60
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
xorq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
imulq 0x10(%rsp), %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/hash/xxhash.cc
// Function: XXH_swap64(unsigned long)
static xxh_u64 XXH_swap64 (xxh_u64 x)
{
    return  ((x << 56) & 0xff00000000000000ULL) |
            ((x << 40) & 0x00ff000000000000ULL) |
            ((x << 24) & 0x0000ff0000000000ULL) |
            ((x << 8)  & 0x000000ff00000000ULL) |
            ((x >> 8)  & 0x00000000ff000000ULL) |
            ((x >> 24) & 0x0000000000ff0000ULL) |
            ((x >> 40) & 0x000000000000ff00ULL) |
            ((x >> 56) & 0x00000000000000ffULL);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
shlq $0x38, %rax
movabsq $-0x100000000000000, %rcx # imm = 0xFF00000000000000
andq %rcx, %rax
movq -0x8(%rsp), %rcx
shlq $0x28, %rcx
movabsq $0xff000000000000, %rdx # imm = 0xFF000000000000
andq %rdx, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
shlq $0x18, %rcx
movabsq $0xff0000000000, %rdx   # imm = 0xFF0000000000
andq %rdx, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
shlq $0x8, %rcx
movabsq $0xff00000000, %rdx     # imm = 0xFF00000000
andq %rdx, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
shrq $0x8, %rcx
movabsq $0xff000000, %rdx       # imm = 0xFF000000
andq %rdx, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
shrq $0x18, %rcx
andq $0xff0000, %rcx         # imm = 0xFF0000
orq %rcx, %rax
movq -0x8(%rsp), %rcx
shrq $0x28, %rcx
andq $0xff00, %rcx           # imm = 0xFF00
orq %rcx, %rax
movq -0x8(%rsp), %rcx
shrq $0x38, %rcx
andq $0xff, %rcx
orq %rcx, %rax
retq
nopl (%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/hash/xxh3p.h
// Function: ROCKSDB_XXH128_canonicalFromHash
XXH_PUBLIC_API void
XXH128_canonicalFromHash(XXH128_canonical_t* dst, XXH128_hash_t hash)
{
    XXH_STATIC_ASSERT(sizeof(XXH128_canonical_t) == sizeof(XXH128_hash_t));
    if (XXH_CPU_LITTLE_ENDIAN) {
        hash.high64 = XXH_swap64(hash.high64);
        hash.low64  = XXH_swap64(hash.low64);
    }
    memcpy(dst, &hash.high64, sizeof(hash.high64));
    memcpy((char*)dst + sizeof(hash.high64), &hash.low64, sizeof(hash.low64));
}

// Assembly:
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x508b0
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
callq 0x508b0
movq %rax, 0x8(%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
nop
// File: BU-DiSC[P]BF-Shared-Hashing/hash/xxhash.cc
// Function: XXH32_avalanche(unsigned int)
static xxh_u32 XXH32_avalanche(xxh_u32 h32)
{
    h32 ^= h32 >> 15;
    h32 *= PRIME32_2;
    h32 ^= h32 >> 13;
    h32 *= PRIME32_3;
    h32 ^= h32 >> 16;
    return(h32);
}

// Assembly:
movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0xf, %eax
xorl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
imull $0x85ebca77, -0x4(%rsp), %eax # imm = 0x85EBCA77
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0xd, %eax
xorl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
imull $0xc2b2ae3d, -0x4(%rsp), %eax # imm = 0xC2B2AE3D
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x10, %eax
xorl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: BU-DiSC[P]BF-Shared-Hashing/hash/xxhash.cc
// Function: XXH64_avalanche(unsigned long)
static xxh_u64 XXH64_avalanche(xxh_u64 h64)
{
    h64 ^= h64 >> 33;
    h64 *= PRIME64_2;
    h64 ^= h64 >> 29;
    h64 *= PRIME64_3;
    h64 ^= h64 >> 32;
    return h64;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x21, %rax
xorq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movabsq $-0x3d4d51c2d82b14b1, %rax # imm = 0xC2B2AE3D27D4EB4F
imulq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x1d, %rax
xorq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movabsq $0x165667b19e3779f9, %rax # imm = 0x165667B19E3779F9
imulq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x20, %rax
xorq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: BU-DiSC[P]BF-Shared-Hashing/hash/xxh3p.h
// Function: XXH3p_avalanche(unsigned long)
static XXH64_hash_t XXH3p_avalanche(xxh_u64 h64)
{
    h64 ^= h64 >> 37;
    h64 *= PRIME64_3;
    h64 ^= h64 >> 32;
    return h64;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x25, %rax
xorq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movabsq $0x165667b19e3779f9, %rax # imm = 0x165667B19E3779F9
imulq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x20, %rax
xorq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/hash/Crc32.cpp
// Function: crc32_bitwise(void const*, unsigned long, unsigned int)
uint32_t crc32_bitwise(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 ^= *current++;

    for (int j = 0; j < 8; j++)
    {
      // branch-free
      crc = (crc >> 1) ^ (-int32_t(crc & 1) & Polynomial);

      // branching, much slower:
      //if (crc & 1)
      //  crc = (crc >> 1) ^ Polynomial;
      //else
      //  crc =  crc >> 1;
    }
  }

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

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %eax
xorl $-0x1, %eax
movl %eax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rsp)
cmpq $0x0, %rax
je 0x5ffc1
movq -0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rsp)
movzbl (%rax), %eax
xorl -0x18(%rsp), %eax
movl %eax, -0x18(%rsp)
movl $0x0, -0x24(%rsp)
cmpl $0x8, -0x24(%rsp)
jge 0x5ffbf
movl -0x18(%rsp), %eax
shrl %eax
movl -0x18(%rsp), %edx
andl $0x1, %edx
xorl %ecx, %ecx
subl %edx, %ecx
andl $0xedb88320, %ecx       # imm = 0xEDB88320
xorl %ecx, %eax
movl %eax, -0x18(%rsp)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x5ff8e
jmp 0x5ff53
movl -0x18(%rsp), %eax
xorl $-0x1, %eax
retq
nopl (%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %eax
xorl $-0x1, %eax
movl %eax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rsp)
cmpq $0x0, %rax
je 0x60078
movl -0x18(%rsp), %eax
movq -0x20(%rsp), %rcx
movzbl (%rcx), %ecx
xorl %ecx, %eax
andl $0xf, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x576a(%rip), %rax      # 0x65790
movl (%rax,%rcx,4), %eax
movl -0x18(%rsp), %ecx
shrl $0x4, %ecx
xorl %ecx, %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
movq -0x20(%rsp), %rcx
movzbl (%rcx), %ecx
sarl $0x4, %ecx
xorl %ecx, %eax
andl $0xf, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x573b(%rip), %rax      # 0x65790
movl (%rax,%rcx,4), %eax
movl -0x18(%rsp), %ecx
shrl $0x4, %ecx
xorl %ecx, %eax
movl %eax, -0x18(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x5fff3
movl -0x18(%rsp), %eax
xorl $-0x1, %eax
retq
// File: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %eax
xorl $-0x1, %eax
movl %eax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rsp)
cmpq $0x0, %rax
je 0x600f5
movl -0x18(%rsp), %eax
shrl $0x8, %eax
movl -0x18(%rsp), %ecx
andl $0xff, %ecx
movq -0x20(%rsp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rsp)
movzbl (%rdx), %edx
xorl %edx, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x56e4(%rip), %rcx      # 0x657d0
xorl (%rcx,%rdx,4), %eax
movl %eax, -0x18(%rsp)
jmp 0x600a3
movl -0x18(%rsp), %eax
xorl $-0x1, %eax
retq
nopl (%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/hash/Crc32.cpp
// Function: crc32_1byte_tableless(void const*, unsigned long, unsigned int)
uint32_t crc32_1byte_tableless(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)
  {
    uint8_t s = uint8_t(crc) ^ *current++;

    // Hagai Gold made me aware of this table-less algorithm and send me code

    // polynomial 0xEDB88320 can be written in binary as 11101101101110001000001100100000b
    // reverse the bits (or just assume bit 0 is the first one)
    // and we have bits set at position 0, 1, 2, 4, 5, 7, 8, 10, 11, 12, 16, 22, 23, 26
    // => those are the shift offsets:
    //crc = (crc >> 8) ^
    //       t ^
    //      (t >>  1) ^ (t >>  2) ^ (t >>  4) ^ (t >>  5) ^  // == y
    //      (t >>  7) ^ (t >>  8) ^ (t >> 10) ^ (t >> 11) ^  // == y >> 6
    //      (t >> 12) ^ (t >> 16) ^                          // == z
    //      (t >> 22) ^ (t >> 26) ^                          // == z >> 10
    //      (t >> 23);

    // the fastest I can come up with:
    uint32_t low = (s ^ (s << 6)) & 0xFF;
    uint32_t a   = (low * ((1 << 23) + (1 << 14) + (1 << 2)));
    crc = (crc >> 8) ^
          (low * ((1 << 24) + (1 << 16) + (1 << 8))) ^
           a ^
          (a >> 1) ^
          (low * ((1 << 20) + (1 << 12)           )) ^
          (low << 19) ^
          (low << 17) ^
          (low >>  2);

    // Hagai's code:
    /*uint32_t t = (s ^ (s << 6)) << 24;

    // some temporaries to optimize XOR
    uint32_t x = (t >> 1) ^ (t >> 2);
    uint32_t y = x ^ (x >> 3);
    uint32_t z = (t >> 12) ^ (t >> 16);

    crc = (crc >> 8) ^
           t ^ (t >> 23) ^
           y ^ (y >>  6) ^
           z ^ (z >> 10);*/
  }

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

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %eax
xorl $-0x1, %eax
movl %eax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rsp)
cmpq $0x0, %rax
je 0x601ce
movl -0x18(%rsp), %eax
movzbl %al, %eax
movq -0x20(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rsp)
movzbl (%rcx), %ecx
xorl %ecx, %eax
movb %al, -0x21(%rsp)
movzbl -0x21(%rsp), %eax
movzbl -0x21(%rsp), %ecx
shll $0x6, %ecx
xorl %ecx, %eax
andl $0xff, %eax
movl %eax, -0x28(%rsp)
imull $0x804004, -0x28(%rsp), %eax # imm = 0x804004
movl %eax, -0x2c(%rsp)
movl -0x18(%rsp), %eax
shrl $0x8, %eax
imull $0x1010100, -0x28(%rsp), %ecx # imm = 0x1010100
xorl %ecx, %eax
xorl -0x2c(%rsp), %eax
movl -0x2c(%rsp), %ecx
shrl %ecx
xorl %ecx, %eax
imull $0x101000, -0x28(%rsp), %ecx # imm = 0x101000
xorl %ecx, %eax
movl -0x28(%rsp), %ecx
shll $0x13, %ecx
xorl %ecx, %eax
movl -0x28(%rsp), %ecx
shll $0x11, %ecx
xorl %ecx, %eax
movl -0x28(%rsp), %ecx
shrl $0x2, %ecx
xorl %ecx, %eax
movl %eax, -0x18(%rsp)
jmp 0x60123
movl -0x18(%rsp), %eax
xorl $-0x1, %eax
retq
nopw %cs:(%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %eax
xorl $-0x1, %eax
movl %eax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rsp)
cmpq $0x0, %rax
je 0x602e1
movl -0x18(%rsp), %eax
movq -0x20(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rsp)
movzbl (%rcx), %ecx
xorl %ecx, %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
shll $0x1f, %eax
sarl $0x1f, %eax
andl $0x77073096, %eax       # imm = 0x77073096
movl -0x18(%rsp), %ecx
shll $0x1e, %ecx
sarl $0x1f, %ecx
andl $0xee0e612c, %ecx       # imm = 0xEE0E612C
xorl %ecx, %eax
movl -0x18(%rsp), %ecx
shll $0x1d, %ecx
sarl $0x1f, %ecx
andl $0x76dc419, %ecx        # imm = 0x76DC419
xorl %ecx, %eax
movl -0x18(%rsp), %ecx
shll $0x1c, %ecx
sarl $0x1f, %ecx
andl $0xedb8832, %ecx        # imm = 0xEDB8832
xorl %ecx, %eax
movl -0x18(%rsp), %ecx
shll $0x1b, %ecx
sarl $0x1f, %ecx
andl $0x1db71064, %ecx       # imm = 0x1DB71064
xorl %ecx, %eax
movl -0x18(%rsp), %ecx
shll $0x1a, %ecx
sarl $0x1f, %ecx
andl $0x3b6e20c8, %ecx       # imm = 0x3B6E20C8
xorl %ecx, %eax
movl -0x18(%rsp), %ecx
shll $0x19, %ecx
sarl $0x1f, %ecx
andl $0x76dc4190, %ecx       # imm = 0x76DC4190
xorl %ecx, %eax
movl -0x18(%rsp), %ecx
shll $0x18, %ecx
sarl $0x1f, %ecx
andl $0xedb88320, %ecx       # imm = 0xEDB88320
xorl %ecx, %eax
movl %eax, -0x24(%rsp)
movl -0x18(%rsp), %eax
shrl $0x8, %eax
xorl -0x24(%rsp), %eax
movl %eax, -0x18(%rsp)
jmp 0x60203
movl -0x18(%rsp), %eax
xorl $-0x1, %eax
retq
nopl (%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x14(%rsp), %eax
xorl $-0x1, %eax
movl %eax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpq $0x4, -0x10(%rsp)
jb 0x603c5
movq -0x20(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x20(%rsp)
movl (%rax), %eax
xorl -0x18(%rsp), %eax
movl %eax, -0x24(%rsp)
movl -0x24(%rsp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x547f(%rip), %rax      # 0x657d0
movl (%rax,%rcx,4), %eax
movl -0x24(%rsp), %ecx
shrl $0x10, %ecx
andl $0xff, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x5464(%rip), %rcx      # 0x657d0
xorl 0x400(%rcx,%rdx,4), %eax
movl -0x24(%rsp), %ecx
shrl $0x8, %ecx
andl $0xff, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x5445(%rip), %rcx      # 0x657d0
xorl 0x800(%rcx,%rdx,4), %eax
movl -0x24(%rsp), %ecx
andl $0xff, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x5429(%rip), %rcx      # 0x657d0
xorl 0xc00(%rcx,%rdx,4), %eax
movl %eax, -0x18(%rsp)
movq -0x10(%rsp), %rax
subq $0x4, %rax
movq %rax, -0x10(%rsp)
jmp 0x60313
movq -0x20(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rsp)
cmpq $0x0, %rax
je 0x60421
movl -0x18(%rsp), %eax
shrl $0x8, %eax
movl -0x18(%rsp), %ecx
andl $0xff, %ecx
movq -0x30(%rsp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rsp)
movzbl (%rdx), %edx
xorl %edx, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x53b8(%rip), %rcx      # 0x657d0
xorl (%rcx,%rdx,4), %eax
movl %eax, -0x18(%rsp)
jmp 0x603cf
movl -0x18(%rsp), %eax
xorl $-0x1, %eax
retq
nopl (%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/hash/city.cc
// Function: Hash32Len0to4(char const*, unsigned long)
static uint32 Hash32Len0to4(const char *s, size_t len) {
  uint32 b = 0;
  uint32 c = 9;
  for (size_t i = 0; i < len; i++) {
    signed char v = s[i];
    b = b * c1 + v;
    c ^= b;
  }
  return fmix(Mur(b, Mur(len, c)));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x9, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x61773
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x7(%rsp)
imull $0xcc9e2d51, 0x14(%rsp), %eax # imm = 0xCC9E2D51
movsbl 0x7(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
xorl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x61727
movl 0x14(%rsp), %eax
movl %eax, (%rsp)
movq 0x18(%rsp), %rax
movl %eax, %edi
movl 0x10(%rsp), %esi
callq 0x63490
movl (%rsp), %edi
movl %eax, %esi
callq 0x63490
movl %eax, %edi
callq 0x63440
addq $0x28, %rsp
retq
// File: BU-DiSC[P]BF-Shared-Hashing/hash/city.cc
// Function: Hash32Len5to12(char const*, unsigned long)
static uint32 Hash32Len5to12(const char *s, size_t len) {
  uint32 a = len, b = len * 5, c = 9, d = b;
  a += Fetch32(s);
  b += Fetch32(s + len - 4);
  c += Fetch32(s + ((len >> 1) & 4));
  return fmix(Mur(c, Mur(b, Mur(a, d))));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl %eax, 0x14(%rsp)
imulq $0x5, 0x18(%rsp), %rax
movl %eax, 0x10(%rsp)
movl $0x9, 0xc(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x619c0
addl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
addq 0x18(%rsp), %rdi
addq $-0x4, %rdi
callq 0x619c0
addl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
shrq %rax
andq $0x4, %rax
addq %rax, %rdi
callq 0x619c0
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x10(%rsp), %eax
movl %eax, (%rsp)
movl 0x14(%rsp), %edi
movl 0x8(%rsp), %esi
callq 0x63490
movl (%rsp), %edi
movl %eax, %esi
callq 0x63490
movl 0x4(%rsp), %edi
movl %eax, %esi
callq 0x63490
movl %eax, %edi
callq 0x63440
addq $0x28, %rsp
retq
nopl (%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/hash/city.cc
// Function: Hash32Len13to24(char const*, unsigned long)
static uint32 Hash32Len13to24(const char *s, size_t len) {
  uint32 a = Fetch32(s - 4 + (len >> 1));
  uint32 b = Fetch32(s + 4);
  uint32 c = Fetch32(s + len - 8);
  uint32 d = Fetch32(s + (len >> 1));
  uint32 e = Fetch32(s);
  uint32 f = Fetch32(s + len - 4);
  uint32 h = len;

  return fmix(Mur(f, Mur(e, Mur(d, Mur(c, Mur(b, Mur(a, h)))))));
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
addq $-0x4, %rdi
movq 0x38(%rsp), %rax
shrq %rax
addq %rax, %rdi
callq 0x619c0
movl %eax, 0x34(%rsp)
movq 0x40(%rsp), %rdi
addq $0x4, %rdi
callq 0x619c0
movl %eax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
addq 0x38(%rsp), %rdi
addq $-0x8, %rdi
callq 0x619c0
movl %eax, 0x2c(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rax
shrq %rax
addq %rax, %rdi
callq 0x619c0
movl %eax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0x619c0
movl %eax, 0x24(%rsp)
movq 0x40(%rsp), %rdi
addq 0x38(%rsp), %rdi
addq $-0x4, %rdi
callq 0x619c0
movl %eax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movl %eax, 0x1c(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x34(%rsp), %edi
movl 0x1c(%rsp), %esi
callq 0x63490
movl 0x8(%rsp), %edi
movl %eax, %esi
callq 0x63490
movl 0xc(%rsp), %edi
movl %eax, %esi
callq 0x63490
movl 0x10(%rsp), %edi
movl %eax, %esi
callq 0x63490
movl 0x14(%rsp), %edi
movl %eax, %esi
callq 0x63490
movl 0x18(%rsp), %edi
movl %eax, %esi
callq 0x63490
movl %eax, %edi
callq 0x63440
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
cmpq $0x8, 0x50(%rsp)
jb 0x61fb4
movq 0x50(%rsp), %rax
shlq %rax
movabsq $-0x651e95c4d06fbfb1, %rcx # imm = 0x9AE16A3B2F90404F
addq %rcx, %rax
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rdi
callq 0x62490
movabsq $-0x651e95c4d06fbfb1, %rcx # imm = 0x9AE16A3B2F90404F
addq %rcx, %rax
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rdi
addq 0x50(%rsp), %rdi
addq $-0x8, %rdi
callq 0x62490
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x25, %esi
callq 0x62570
imulq 0x48(%rsp), %rax
addq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movl $0x19, %esi
callq 0x62570
addq 0x38(%rsp), %rax
imulq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x63510
movq %rax, 0x60(%rsp)
jmp 0x620e6
cmpq $0x4, 0x50(%rsp)
jb 0x6202b
movq 0x50(%rsp), %rax
shlq %rax
movabsq $-0x651e95c4d06fbfb1, %rcx # imm = 0x9AE16A3B2F90404F
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
callq 0x619c0
movl %eax, %eax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rax
movq 0x18(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rdi
addq 0x50(%rsp), %rdi
addq $-0x4, %rdi
callq 0x619c0
movq (%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
movq 0x20(%rsp), %rdx
callq 0x63510
movq %rax, 0x60(%rsp)
jmp 0x620e6
cmpq $0x0, 0x50(%rsp)
jbe 0x620d7
movq 0x58(%rsp), %rax
movb (%rax), %al
movb %al, 0x17(%rsp)
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rcx
shrq %rcx
movb (%rax,%rcx), %al
movb %al, 0x16(%rsp)
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rcx
subq $0x1, %rcx
movb (%rax,%rcx), %al
movb %al, 0x15(%rsp)
movzbl 0x17(%rsp), %eax
movzbl 0x16(%rsp), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movl %eax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movzbl 0x15(%rsp), %ecx
shll $0x2, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
movl %eax, %edi
movabsq $-0x651e95c4d06fbfb1, %rax # imm = 0x9AE16A3B2F90404F
imulq %rax, %rdi
movl 0xc(%rsp), %eax
movabsq $-0x3c5a37a36834ced9, %rcx # imm = 0xC3A5C85C97CB3127
imulq %rcx, %rax
xorq %rax, %rdi
callq 0x625c0
movabsq $-0x651e95c4d06fbfb1, %rcx # imm = 0x9AE16A3B2F90404F
imulq %rcx, %rax
movq %rax, 0x60(%rsp)
jmp 0x620e6
movabsq $-0x651e95c4d06fbfb1, %rax # imm = 0x9AE16A3B2F90404F
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
// File: BU-DiSC[P]BF-Shared-Hashing/hash/city.cc
// Function: HashLen17to32(char const*, unsigned long)
static uint64 HashLen17to32(const char *s, size_t len) {
  uint64 mul = k2 + len * 2;
  uint64 a = Fetch64(s) * k1;
  uint64 b = Fetch64(s + 8);
  uint64 c = Fetch64(s + len - 8) * mul;
  uint64 d = Fetch64(s + len - 16) * k2;
  return HashLen16(Rotate(a + b, 43) + Rotate(c, 30) + d,
                   a + Rotate(b + k2, 18) + c, mul);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rax
shlq %rax
movabsq $-0x651e95c4d06fbfb1, %rcx # imm = 0x9AE16A3B2F90404F
addq %rcx, %rax
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rdi
callq 0x62490
movabsq $-0x4b6d499041670d8d, %rcx # imm = 0xB492B66FBE98F273
imulq %rcx, %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rdi
addq $0x8, %rdi
callq 0x62490
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rdi
addq 0x48(%rsp), %rdi
addq $-0x8, %rdi
callq 0x62490
imulq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
addq 0x48(%rsp), %rdi
addq $-0x10, %rdi
callq 0x62490
movabsq $-0x651e95c4d06fbfb1, %rcx # imm = 0x9AE16A3B2F90404F
imulq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
addq 0x30(%rsp), %rdi
movl $0x2b, %esi
callq 0x62570
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1e, %esi
callq 0x62570
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
addq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movabsq $-0x651e95c4d06fbfb1, %rdi # imm = 0x9AE16A3B2F90404F
addq 0x30(%rsp), %rdi
movl $0x12, %esi
callq 0x62570
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdi
addq %rax, %rsi
addq 0x28(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x63510
addq $0x58, %rsp
retq
nopl (%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/hash/city.cc
// Function: HashLen33to64(char const*, unsigned long)
static uint64 HashLen33to64(const char *s, size_t len) {
  uint64 mul = k2 + len * 2;
  uint64 a = Fetch64(s) * k2;
  uint64 b = Fetch64(s + 8);
  uint64 c = Fetch64(s + len - 24);
  uint64 d = Fetch64(s + len - 32);
  uint64 e = Fetch64(s + 16) * k2;
  uint64 f = Fetch64(s + 24) * 9;
  uint64 g = Fetch64(s + len - 8);
  uint64 h = Fetch64(s + len - 16) * mul;
  uint64 u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9;
  uint64 v = ((a + g) ^ d) + f + 1;
  uint64 w = bswap_64((u + v) * mul) + h;
  uint64 x = Rotate(e + f, 42) + c;
  uint64 y = (bswap_64((v + w) * mul) + g) * mul;
  uint64 z = e + f + c;
  a = bswap_64((x + z) * mul + y) + b;
  b = ShiftMix((z + a) * mul + d + h) * mul;
  return b + x;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x88(%rsp), %rax
shlq %rax
movabsq $-0x651e95c4d06fbfb1, %rcx # imm = 0x9AE16A3B2F90404F
addq %rcx, %rax
movq %rax, 0x80(%rsp)
movq 0x90(%rsp), %rdi
callq 0x62490
movabsq $-0x651e95c4d06fbfb1, %rcx # imm = 0x9AE16A3B2F90404F
imulq %rcx, %rax
movq %rax, 0x78(%rsp)
movq 0x90(%rsp), %rdi
addq $0x8, %rdi
callq 0x62490
movq %rax, 0x70(%rsp)
movq 0x90(%rsp), %rdi
addq 0x88(%rsp), %rdi
addq $-0x18, %rdi
callq 0x62490
movq %rax, 0x68(%rsp)
movq 0x90(%rsp), %rdi
addq 0x88(%rsp), %rdi
addq $-0x20, %rdi
callq 0x62490
movq %rax, 0x60(%rsp)
movq 0x90(%rsp), %rdi
addq $0x10, %rdi
callq 0x62490
movabsq $-0x651e95c4d06fbfb1, %rcx # imm = 0x9AE16A3B2F90404F
imulq %rcx, %rax
movq %rax, 0x58(%rsp)
movq 0x90(%rsp), %rdi
addq $0x18, %rdi
callq 0x62490
imulq $0x9, %rax, %rax
movq %rax, 0x50(%rsp)
movq 0x90(%rsp), %rdi
addq 0x88(%rsp), %rdi
addq $-0x8, %rdi
callq 0x62490
movq %rax, 0x48(%rsp)
movq 0x90(%rsp), %rdi
addq 0x88(%rsp), %rdi
addq $-0x10, %rdi
callq 0x62490
imulq 0x80(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x78(%rsp), %rdi
addq 0x48(%rsp), %rdi
movl $0x2b, %esi
callq 0x62570
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rdi
movl $0x1e, %esi
callq 0x62570
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq 0x68(%rsp), %rcx
imulq $0x9, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x38(%rsp)
movq 0x78(%rsp), %rax
addq 0x48(%rsp), %rax
xorq 0x60(%rsp), %rax
addq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
addq 0x30(%rsp), %rdi
imulq 0x80(%rsp), %rdi
callq 0x63590
addq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rdi
addq 0x50(%rsp), %rdi
movl $0x2a, %esi
callq 0x62570
addq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
addq 0x28(%rsp), %rdi
imulq 0x80(%rsp), %rdi
callq 0x63590
addq 0x48(%rsp), %rax
imulq 0x80(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
addq 0x50(%rsp), %rax
addq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
addq 0x10(%rsp), %rdi
imulq 0x80(%rsp), %rdi
addq 0x18(%rsp), %rdi
callq 0x63590
addq 0x70(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x10(%rsp), %rdi
addq 0x78(%rsp), %rdi
imulq 0x80(%rsp), %rdi
addq 0x60(%rsp), %rdi
addq 0x40(%rsp), %rdi
callq 0x625c0
imulq 0x80(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq 0x20(%rsp), %rax
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/hash/city.cc
// Function: WeakHashLen32WithSeeds(char const*, unsigned long, unsigned long)
static pair<uint64, uint64> WeakHashLen32WithSeeds(
    const char* s, uint64 a, uint64 b) {
  return WeakHashLen32WithSeeds(Fetch64(s),
                                Fetch64(s + 8),
                                Fetch64(s + 16),
                                Fetch64(s + 24),
                                a,
                                b);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x62490
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
callq 0x62490
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
addq $0x10, %rdi
callq 0x62490
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
addq $0x18, %rdi
callq 0x62490
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rcx
movq 0x28(%rsp), %r8
movq 0x20(%rsp), %r9
callq 0x63660
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x48, %rsp
retq
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
cmpq $0x10, 0x58(%rsp)
jb 0x633de
movq 0x60(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
subq $0x10, %rax
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rdi
callq 0x62490
movq %rax, 0x40(%rsp)
movq 0x60(%rsp), %rdi
addq $0x8, %rdi
callq 0x62490
movabsq $-0x3c5a37a36834ced9, %rcx # imm = 0xC3A5C85C97CB3127
addq %rcx, %rax
movq %rax, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x63830
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x50(%rsp), %rcx
callq 0x62660
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
jmp 0x6342d
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x63d2(%rip), %rsi      # 0x697d0
leaq 0x63d3(%rip), %rdx      # 0x697d8
callq 0x63860
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
callq 0x62660
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x68(%rsp), %rax
movq 0x70(%rsp), %rdx
addq $0x78, %rsp
retq
nopl (%rax)
// File: 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:
pushq %rax
movl %edi, 0x4(%rsp)
movl %esi, (%rsp)
imull $0xcc9e2d51, 0x4(%rsp), %eax # imm = 0xCC9E2D51
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %edi
movl $0x11, %esi
callq 0x61980
movl %eax, 0x4(%rsp)
imull $0x1b873593, 0x4(%rsp), %eax # imm = 0x1B873593
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
xorl (%rsp), %eax
movl %eax, (%rsp)
movl (%rsp), %edi
movl $0x13, %esi
callq 0x61980
movl %eax, (%rsp)
imull $0x5, (%rsp), %eax
addl $0xe6546b64, %eax       # imm = 0xE6546B64
popq %rcx
retq
nopw (%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/hash/city.cc
// Function: HashLen16(unsigned long, unsigned long, unsigned long)
static uint64 HashLen16(uint64 u, uint64 v, uint64 mul) {
  // Murmur-inspired hashing.
  uint64 a = (u ^ v) * mul;
  a ^= (a >> 47);
  uint64 b = (v ^ a) * mul;
  b ^= (b >> 47);
  b *= mul;
  return b;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
xorq -0x10(%rsp), %rax
imulq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
shrq $0x2f, %rax
xorq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
xorq -0x20(%rsp), %rax
imulq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
shrq $0x2f, %rax
xorq -0x28(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
imulq -0x28(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/hash/city.cc
// Function: WeakHashLen32WithSeeds(unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long)
static pair<uint64, uint64> WeakHashLen32WithSeeds(
    uint64 w, uint64 x, uint64 y, uint64 z, uint64 a, uint64 b) {
  a += w;
  b = Rotate(b + a + z, 21);
  uint64 c = a;
  a += x;
  a += y;
  b += Rotate(a, 44);
  return make_pair(a + z, b + c);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rcx
movq 0x20(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
addq %rax, %rdi
movq 0x28(%rsp), %rax
addq %rax, %rdi
movl $0x15, %esi
callq 0x62570
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rcx
movq 0x20(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2c, %esi
callq 0x62570
movq %rax, %rcx
movq 0x18(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
addq %rcx, %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x63980
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rdx
addq $0x58, %rsp
retq
nop
// File: BU-DiSC[P]BF-Shared-Hashing/hash/city.h
// Function: Hash128to64(std::pair<unsigned long, unsigned long> const&)
inline uint64 Hash128to64(const uint128& x) {
  // Murmur-inspired hashing.
  const uint64 kMul = 0x9ddfea08eb382d69ULL;
  uint64 a = (Uint128Low64(x) ^ Uint128High64(x)) * kMul;
  a ^= (a >> 47);
  uint64 b = (Uint128High64(x) ^ a) * kMul;
  b ^= (b >> 47);
  b *= kMul;
  return b;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movabsq $-0x622015f714c7d297, %rax # imm = 0x9DDFEA08EB382D69
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x63810
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x63820
movq %rax, %rcx
movq (%rsp), %rax
xorq %rcx, %rax
movabsq $-0x622015f714c7d297, %rcx # imm = 0x9DDFEA08EB382D69
imulq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
shrq $0x2f, %rax
xorq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x63820
xorq 0x10(%rsp), %rax
movabsq $-0x622015f714c7d297, %rcx # imm = 0x9DDFEA08EB382D69
imulq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
shrq $0x2f, %rax
xorq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $-0x622015f714c7d297, %rax # imm = 0x9DDFEA08EB382D69
imulq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop