LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH64_digest
XXH_PUBLIC_API XXH64_hash_t XXH64_digest(const XXH64_state_t* state)
{
    xxh_u64 h64;

    if (state->total_len >= 32) {
        h64 = XXH_rotl64(state->v[0], 1) + XXH_rotl64(state->v[1], 7) + XXH_rotl64(state->v[2], 12) + XXH_rotl64(state->v[3], 18);
        h64 = XXH64_mergeRound(h64, state->v[0]);
        h64 = XXH64_mergeRound(h64, state->v[1]);
        h64 = XXH64_mergeRound(h64, state->v[2]);
        h64 = XXH64_mergeRound(h64, state->v[3]);
    } else {
        h64  = state->v[2] /*seed*/ + XXH_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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x20, (%rax)
jb 0x33ac
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
rolq %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
rolq $0x7, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
rolq $0xc, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
rolq $0x12, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3400
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3400
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x3400
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x3400
movq %rax, -0x10(%rbp)
jmp 0x33c2
movq -0x8(%rbp), %rcx
movabsq $0x27d4eb2f165667c5, %rax # imm = 0x27D4EB2F165667C5
addq 0x18(%rcx), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
xorl %ecx, %ecx
callq 0x3460
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH64_finalize(unsigned long, unsigned char const*, unsigned long, XXH_alignment)
static XXH_PUREF xxh_u64
XXH64_finalize(xxh_u64 hash, const xxh_u8* ptr, size_t len, XXH_alignment align)
{
    if (ptr==NULL) XXH_ASSERT(len == 0);
    len &= 31;
    while (len >= 8) {
        xxh_u64 const k1 = XXH64_round(0, XXH_get64bits(ptr));
        ptr += 8;
        hash ^= k1;
        hash  = XXH_rotl64(hash,27) * XXH_PRIME64_1 + XXH_PRIME64_4;
        len -= 8;
    }
    if (len >= 4) {
        hash ^= (xxh_u64)(XXH_get32bits(ptr)) * XXH_PRIME64_1;
        ptr += 4;
        hash = XXH_rotl64(hash, 23) * XXH_PRIME64_2 + XXH_PRIME64_3;
        len -= 4;
    }
    while (len > 0) {
        hash ^= (*ptr++) * XXH_PRIME64_5;
        hash = XXH_rotl64(hash, 11) * XXH_PRIME64_1;
        --len;
    }
    return  XXH64_avalanche(hash);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3480
jmp 0x3480
movq -0x18(%rbp), %rax
andq $0x1f, %rax
movq %rax, -0x18(%rbp)
cmpq $0x8, -0x18(%rbp)
jb 0x34fc
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x5d30
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x3290
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
subq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x348c
cmpq $0x4, -0x18(%rbp)
jb 0x3566
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x5c90
movl %eax, %eax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
rolq $0x17, %rax
movabsq $-0x3d4d51c2d82b14b1, %rcx # imm = 0xC2B2AE3D27D4EB4F
imulq %rcx, %rax
movabsq $0x165667b19e3779f9, %rcx # imm = 0x165667B19E3779F9
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
subq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x3568
cmpq $0x0, -0x18(%rbp)
jbe 0x35bf
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
movabsq $0x27d4eb2f165667c5, %rcx # imm = 0x27D4EB2F165667C5
imulq %rcx, %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
rolq $0xb, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3568
movq -0x8(%rbp), %rdi
callq 0x5d90
addq $0x30, %rsp
popq %rbp
retq
nop
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_64bits_internal(void const*, unsigned long, unsigned long, void const*, unsigned long, unsigned long (*)(void const*, unsigned long, unsigned long, unsigned char const*, unsigned long))
XXH_FORCE_INLINE XXH64_hash_t
XXH3_64bits_internal(const void* XXH_RESTRICT input, size_t len,
                     XXH64_hash_t seed64, const void* XXH_RESTRICT secret, size_t secretLen,
                     XXH3_hashLong64_f f_hashLong)
{
    XXH_ASSERT(secretLen >= XXH3_SECRET_SIZE_MIN);
    /*
     * If an action is to be taken if `secretLen` condition is not respected,
     * it should be done here.
     * For now, it's a contract pre-condition.
     * Adding a check and a branch here would cost performance at every hash.
     * Also, note that function signature doesn't offer room to return an error.
     */
    if (len <= 16)
        return XXH3_len_0to16_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, seed64);
    if (len <= 128)
        return XXH3_len_17to128_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64);
    if (len <= XXH3_MIDSIZE_MAX)
        return XXH3_len_129to240_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64);
    return f_hashLong(input, len, seed64, (const xxh_u8*)secret, secretLen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x10, -0x18(%rbp)
ja 0x37a2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x5e00
movq %rax, -0x8(%rbp)
jmp 0x3812
cmpq $0x80, -0x18(%rbp)
ja 0x37cb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x5ed0
movq %rax, -0x8(%rbp)
jmp 0x3812
cmpq $0xf0, -0x18(%rbp)
ja 0x37f4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x6040
movq %rax, -0x8(%rbp)
jmp 0x3812
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_createState
XXH_PUBLIC_API XXH3_state_t* XXH3_createState(void)
{
    XXH3_state_t* const state = (XXH3_state_t*)XXH_alignedMalloc(sizeof(XXH3_state_t), 64);
    if (state==NULL) return NULL;
    XXH3_INITSTATE(state);
    return state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x240, %edi            # imm = 0x240
movl $0x40, %esi
callq 0x3a60
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3a3c
movq $0x0, -0x8(%rbp)
jmp 0x3a53
movq -0x10(%rbp), %rax
movq $0x0, 0x228(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH_alignedMalloc(unsigned long, unsigned long)
static XXH_MALLOCF void* XXH_alignedMalloc(size_t s, size_t align)
{
    XXH_ASSERT(align <= 128 && align >= 8); /* range check */
    XXH_ASSERT((align & (align-1)) == 0);   /* power of 2 */
    XXH_ASSERT(s != 0 && s < (s + align));  /* empty/overflow */
    {   /* Overallocate to make room for manual realignment and an offset byte */
        xxh_u8* base = (xxh_u8*)XXH_malloc(s + align);
        if (base != NULL) {
            /*
             * Get the offset needed to align this pointer.
             *
             * Even if the returned pointer is aligned, there will always be
             * at least one byte to store the offset to the original pointer.
             */
            size_t offset = align - ((size_t)base & (align - 1)); /* base % align */
            /* Add the offset for the now-aligned pointer */
            xxh_u8* ptr = base + offset;

            XXH_ASSERT((size_t)ptr % align == 0);

            /* Store the offset immediately before the returned pointer. */
            ptr[-1] = (xxh_u8)offset;
            return ptr;
        }
        return NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq -0x18(%rbp), %rdi
callq 0x2540
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3ac5
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
andq %rdx, %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, -0x1(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3acd
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH_alignedFree(void*)
static void XXH_alignedFree(void* p)
{
    if (p != NULL) {
        xxh_u8* ptr = (xxh_u8*)p;
        /* Get the offset byte we added in XXH_malloc. */
        xxh_u8 offset = ptr[-1];
        /* Free the original malloc'd pointer */
        xxh_u8* base = ptr - offset;
        XXH_free(base);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3b45
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb -0x1(%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movzbl -0x11(%rbp), %ecx
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2580
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_reset_internal(XXH3_state_s*, unsigned long, void const*, unsigned long)
static void
XXH3_reset_internal(XXH3_state_t* statePtr,
                    XXH64_hash_t seed,
                    const void* secret, size_t secretSize)
{
    size_t const initStart = offsetof(XXH3_state_t, bufferedSize);
    size_t const initLength = offsetof(XXH3_state_t, nbStripesPerBlock) - initStart;
    XXH_ASSERT(offsetof(XXH3_state_t, nbStripesPerBlock) > initStart);
    XXH_ASSERT(statePtr != NULL);
    /* set members from bufferedSize to nbStripesPerBlock (excluded) to 0 */
    memset((char*)statePtr + initStart, 0, initLength);
    statePtr->acc[0] = XXH_PRIME32_3;
    statePtr->acc[1] = XXH_PRIME64_1;
    statePtr->acc[2] = XXH_PRIME64_2;
    statePtr->acc[3] = XXH_PRIME64_3;
    statePtr->acc[4] = XXH_PRIME64_4;
    statePtr->acc[5] = XXH_PRIME32_2;
    statePtr->acc[6] = XXH_PRIME64_5;
    statePtr->acc[7] = XXH_PRIME32_1;
    statePtr->seed = seed;
    statePtr->useSeed = (seed != 0);
    statePtr->extSecret = (const unsigned char*)secret;
    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN);
    statePtr->secretLimit = secretSize - XXH_STRIPE_LEN;
    statePtr->nbStripesPerBlock = statePtr->secretLimit / XXH_SECRET_CONSUME_RATE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x200, -0x28(%rbp)     # imm = 0x200
movq $0x18, -0x30(%rbp)
movq -0x8(%rbp), %rdi
addq $0x200, %rdi            # imm = 0x200
xorl %esi, %esi
movl $0x18, %edx
callq 0x20b0
movq -0x8(%rbp), %rax
movl $0xc2b2ae3d, %ecx       # imm = 0xC2B2AE3D
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movabsq $-0x3d4d51c2d82b14b1, %rcx # imm = 0xC2B2AE3D27D4EB4F
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movabsq $0x165667b19e3779f9, %rcx # imm = 0x165667B19E3779F9
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x85ebca77, %ecx       # imm = 0x85EBCA77
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movabsq $0x27d4eb2f165667c5, %rcx # imm = 0x27D4EB2F165667C5
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x9e3779b1, %ecx       # imm = 0x9E3779B1
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x228(%rax)
cmpq $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x204(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x238(%rax)
movq -0x20(%rbp), %rcx
subq $0x40, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x220(%rax)
movq -0x8(%rbp), %rax
movq 0x220(%rax), %rcx
shrq $0x3, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x218(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_64bits_reset_withSecret
XXH_PUBLIC_API XXH_errorcode
XXH3_64bits_reset_withSecret(XXH3_state_t* statePtr, const void* secret, size_t secretSize)
{
    if (statePtr == NULL) return XXH_ERROR;
    XXH3_reset_internal(statePtr, 0, secret, secretSize);
    if (secret == NULL) return XXH_ERROR;
    if (secretSize < XXH3_SECRET_SIZE_MIN) return XXH_ERROR;
    return XXH_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3d24
movl $0x1, -0x4(%rbp)
jmp 0x3d63
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x3bd0
cmpq $0x0, -0x18(%rbp)
jne 0x3d49
movl $0x1, -0x4(%rbp)
jmp 0x3d63
cmpq $0x88, -0x20(%rbp)
jae 0x3d5c
movl $0x1, -0x4(%rbp)
jmp 0x3d63
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_64bits_reset_withSeed
XXH_PUBLIC_API XXH_errorcode
XXH3_64bits_reset_withSeed(XXH3_state_t* statePtr, XXH64_hash_t seed)
{
    if (statePtr == NULL) return XXH_ERROR;
    if (seed==0) return XXH3_64bits_reset(statePtr);
    if ((seed != statePtr->seed) || (statePtr->extSecret != NULL))
        XXH3_initCustomSecret(statePtr->customSecret, seed);
    XXH3_reset_internal(statePtr, seed, NULL, XXH_SECRET_DEFAULT_SIZE);
    return XXH_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3d90
movl $0x1, -0x4(%rbp)
jmp 0x3df2
cmpq $0x0, -0x18(%rbp)
jne 0x3da5
movq -0x10(%rbp), %rdi
callq 0x3b80
movl %eax, -0x4(%rbp)
jmp 0x3df2
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x228(%rcx), %rax
jne 0x3dc4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x238(%rax)
je 0x3dd5
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rsi
callq 0x3e00
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0xc0, %ecx
callq 0x3bd0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_initCustomSecret_sse2(void*, unsigned long)
XXH_FORCE_INLINE XXH_TARGET_SSE2 void XXH3_initCustomSecret_sse2(void* XXH_RESTRICT customSecret, xxh_u64 seed64)
{
    XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE & 15) == 0);
    (void)(&XXH_writeLE64);
    {   int const nbRounds = XXH_SECRET_DEFAULT_SIZE / sizeof(__m128i);

#       if defined(_MSC_VER) && defined(_M_IX86) && _MSC_VER < 1900
        /* MSVC 32bit mode does not support _mm_set_epi64x before 2015 */
        XXH_ALIGN(16) const xxh_i64 seed64x2[2] = { (xxh_i64)seed64, (xxh_i64)(0U - seed64) };
        __m128i const seed = _mm_load_si128((__m128i const*)seed64x2);
#       else
        __m128i const seed = _mm_set_epi64x((xxh_i64)(0U - seed64), (xxh_i64)seed64);
#       endif
        int i;

        const void* const src16 = XXH3_kSecret;
        __m128i* dst16 = (__m128i*) customSecret;
#       if defined(__GNUC__) || defined(__clang__)
        /*
         * On GCC & Clang, marking 'dest' as modified will cause the compiler:
         *   - do not extract the secret from sse registers in the internal loop
         *   - use less common registers, and avoid pushing these reg into stack
         */
        XXH_COMPILER_GUARD(dst16);
#       endif
        XXH_ASSERT(((size_t)src16 & 15) == 0); /* control alignment */
        XXH_ASSERT(((size_t)dst16 & 15) == 0);

        for (i=0; i < nbRounds; ++i) {
            dst16[i] = _mm_add_epi64(_mm_load_si128((const __m128i *)src16+i), seed);
    }   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x58(%rbp)
movq %rsi, -0x60(%rbp)
jmp 0x3e12
movl $0xc, -0x64(%rbp)
movq -0x60(%rbp), %rax
movq %rax, %rcx
negq %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %xmm1
movq -0x40(%rbp), %xmm0
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
movdqa %xmm0, -0x50(%rbp)
movdqa -0x50(%rbp), %xmm0
movdqa %xmm0, -0x80(%rbp)
leaq 0x71f1(%rip), %rax      # 0xb040
movq %rax, -0x90(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0x0, -0x84(%rbp)
cmpl $0xc, -0x84(%rbp)
jge 0x3ee6
movslq -0x84(%rbp), %rcx
leaq 0x71b0(%rip), %rax      # 0xb040
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movdqa (%rax), %xmm1
movdqa -0x80(%rbp), %xmm0
movdqa %xmm1, -0x20(%rbp)
movdqa %xmm0, -0x30(%rbp)
movdqa -0x20(%rbp), %xmm0
paddq -0x30(%rbp), %xmm0
movq -0x98(%rbp), %rax
movslq -0x84(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movdqa %xmm0, (%rax)
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0x3e79
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_64bits_reset_withSecretandSeed
XXH_PUBLIC_API XXH_errorcode
XXH3_64bits_reset_withSecretandSeed(XXH3_state_t* statePtr, const void* secret, size_t secretSize, XXH64_hash_t seed64)
{
    if (statePtr == NULL) return XXH_ERROR;
    if (secret == NULL) return XXH_ERROR;
    if (secretSize < XXH3_SECRET_SIZE_MIN) return XXH_ERROR;
    XXH3_reset_internal(statePtr, seed64, secret, secretSize);
    statePtr->useSeed = 1; /* always, even if seed64==0 */
    return XXH_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3f18
movl $0x1, -0x4(%rbp)
jmp 0x3f65
cmpq $0x0, -0x18(%rbp)
jne 0x3f28
movl $0x1, -0x4(%rbp)
jmp 0x3f65
cmpq $0x88, -0x20(%rbp)
jae 0x3f3b
movl $0x1, -0x4(%rbp)
jmp 0x3f65
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3bd0
movq -0x10(%rbp), %rax
movl $0x1, 0x204(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_64bits_digest
XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_digest (const XXH3_state_t* state)
{
    const unsigned char* const secret = (state->extSecret == NULL) ? state->customSecret : state->extSecret;
    if (state->totalLen > XXH3_MIDSIZE_MAX) {
        XXH_ALIGN(XXH_ACC_ALIGN) XXH64_hash_t acc[XXH_ACC_NB];
        XXH3_digest_long(acc, state, secret);
        return XXH3_mergeAccs(acc,
                              secret + XXH_SECRET_MERGEACCS_START,
                              (xxh_u64)state->totalLen * XXH_PRIME64_1);
    }
    /* totalLen <= XXH3_MIDSIZE_MAX: digesting a short input */
    if (state->useSeed)
        return XXH3_64bits_withSeed(state->buffer, (size_t)state->totalLen, state->seed);
    return XXH3_64bits_withSecret(state->buffer, (size_t)(state->totalLen),
                                  secret, state->secretLimit + XXH_STRIPE_LEN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x238(%rax)
jne 0x4878
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x68(%rbp)
jmp 0x4887
movq -0x10(%rbp), %rax
movq 0x238(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0xf0, 0x210(%rax)
jbe 0x48de
leaq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4960
leaq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0xb, %rsi
movq -0x10(%rbp), %rax
movabsq $-0x61c8864e7a143579, %rdx # imm = 0x9E3779B185EBCA87
imulq 0x210(%rax), %rdx
callq 0x4ae0
movq %rax, -0x8(%rbp)
jmp 0x4949
movq -0x10(%rbp), %rax
cmpl $0x0, 0x204(%rax)
je 0x4917
movq -0x10(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movq -0x10(%rbp), %rax
movq 0x210(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x228(%rax), %rdx
callq 0x3900
movq %rax, -0x8(%rbp)
jmp 0x4949
movq -0x10(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movq -0x10(%rbp), %rax
movq 0x210(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x220(%rax), %rcx
addq $0x40, %rcx
callq 0x3870
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_mergeAccs(unsigned long const*, unsigned char const*, unsigned long)
static XXH64_hash_t
XXH3_mergeAccs(const xxh_u64* XXH_RESTRICT acc, const xxh_u8* XXH_RESTRICT secret, xxh_u64 start)
{
    xxh_u64 result64 = start;
    size_t i = 0;

    for (i = 0; i < 4; i++) {
        result64 += XXH3_mix2Accs(acc+2*i, secret + 16*i);
#if defined(__clang__)                                /* Clang */ \
    && (defined(__arm__) || defined(__thumb__))       /* ARMv7 */ \
    && (defined(__ARM_NEON) || defined(__ARM_NEON__)) /* NEON */  \
    && !defined(XXH_ENABLE_AUTOVECTORIZE)             /* Define to disable */
        /*
         * UGLY HACK:
         * Prevent autovectorization on Clang ARMv7-a. Exact same problem as
         * the one in XXH3_len_129to240_64b. Speeds up shorter keys > 240b.
         * XXH3_64bits, len == 256, Snapdragon 835:
         *   without hack: 2063.7 MB/s
         *   with hack:    2560.7 MB/s
         */
        XXH_COMPILER_GUARD(result64);
#endif
    }

    return XXH3_avalanche(result64);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x4, -0x28(%rbp)
jae 0x4b4f
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
shlq %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
callq 0x69f0
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4b0c
movq -0x20(%rbp), %rdi
callq 0x6400
addq $0x30, %rsp
popq %rbp
retq
nop
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_128bits_internal(void const*, unsigned long, unsigned long, void const*, unsigned long, XXH128_hash_t (*)(void const*, unsigned long, unsigned long, void const*, unsigned long))
XXH_FORCE_INLINE XXH128_hash_t
XXH3_128bits_internal(const void* input, size_t len,
                      XXH64_hash_t seed64, const void* XXH_RESTRICT secret, size_t secretLen,
                      XXH3_hashLong128_f f_hl128)
{
    XXH_ASSERT(secretLen >= XXH3_SECRET_SIZE_MIN);
    /*
     * If an action is to be taken if `secret` conditions are not respected,
     * it should be done here.
     * For now, it's a contract pre-condition.
     * Adding a check and a branch here would cost performance at every hash.
     */
    if (len <= 16)
        return XXH3_len_0to16_128b((const xxh_u8*)input, len, (const xxh_u8*)secret, seed64);
    if (len <= 128)
        return XXH3_len_17to128_128b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64);
    if (len <= XXH3_MIDSIZE_MAX)
        return XXH3_len_129to240_128b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64);
    return f_hl128(input, len, seed64, secret, secretLen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
cmpq $0x10, -0x20(%rbp)
ja 0x4bf6
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6a60
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x4c72
cmpq $0x80, -0x20(%rbp)
ja 0x4c23
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x6b80
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x4c72
cmpq $0xf0, -0x20(%rbp)
ja 0x4c50
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x6dd0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x4c72
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
callq *%rax
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_128bits_digest
XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_digest (const XXH3_state_t* state)
{
    const unsigned char* const secret = (state->extSecret == NULL) ? state->customSecret : state->extSecret;
    if (state->totalLen > XXH3_MIDSIZE_MAX) {
        XXH_ALIGN(XXH_ACC_ALIGN) XXH64_hash_t acc[XXH_ACC_NB];
        XXH3_digest_long(acc, state, secret);
        XXH_ASSERT(state->secretLimit + XXH_STRIPE_LEN >= sizeof(acc) + XXH_SECRET_MERGEACCS_START);
        {   XXH128_hash_t h128;
            h128.low64  = XXH3_mergeAccs(acc,
                                         secret + XXH_SECRET_MERGEACCS_START,
                                         (xxh_u64)state->totalLen * XXH_PRIME64_1);
            h128.high64 = XXH3_mergeAccs(acc,
                                         secret + state->secretLimit + XXH_STRIPE_LEN
                                                - sizeof(acc) - XXH_SECRET_MERGEACCS_START,
                                         ~((xxh_u64)state->totalLen * XXH_PRIME64_2));
            return h128;
        }
    }
    /* len <= XXH3_MIDSIZE_MAX : short code */
    if (state->seed)
        return XXH3_128bits_withSeed(state->buffer, (size_t)state->totalLen, state->seed);
    return XXH3_128bits_withSecret(state->buffer, (size_t)(state->totalLen),
                                   secret, state->secretLimit + XXH_STRIPE_LEN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x238(%rax)
jne 0x5038
movq -0x18(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x68(%rbp)
jmp 0x5047
movq -0x18(%rbp), %rax
movq 0x238(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0xf0, 0x210(%rax)
jbe 0x50e4
leaq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4960
leaq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0xb, %rsi
movq -0x18(%rbp), %rax
movabsq $-0x61c8864e7a143579, %rdx # imm = 0x9E3779B185EBCA87
imulq 0x210(%rax), %rdx
callq 0x4ae0
movq %rax, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
addq 0x220(%rax), %rsi
addq $0x40, %rsi
addq $-0x40, %rsi
addq $-0xb, %rsi
movq -0x18(%rbp), %rax
movabsq $-0x3d4d51c2d82b14b1, %rdx # imm = 0xC2B2AE3D27D4EB4F
imulq 0x210(%rax), %rdx
xorq $-0x1, %rdx
callq 0x4ae0
movq %rax, -0x8(%rbp)
jmp 0x5158
movq -0x18(%rbp), %rax
cmpq $0x0, 0x228(%rax)
je 0x5122
movq -0x18(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movq -0x18(%rbp), %rax
movq 0x210(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x228(%rax), %rdx
callq 0x4d90
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x5158
movq -0x18(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movq -0x18(%rbp), %rax
movq 0x210(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x220(%rax), %rcx
addq $0x40, %rcx
callq 0x4ce0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH128_cmp
XXH_PUBLIC_API int XXH128_cmp(const void* h128_1, const void* h128_2)
{
    XXH128_hash_t const h1 = *(const XXH128_hash_t*)h128_1;
    XXH128_hash_t const h2 = *(const XXH128_hash_t*)h128_2;
    int const hcmp = (h1.high64 > h2.high64) - (h2.high64 > h1.high64);
    /* note : bets that, in most cases, hash values are different */
    if (hcmp) return hcmp;
    return (h1.low64 > h2.low64) - (h2.low64 > h1.low64);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x30(%rbp), %rcx
cmpq -0x20(%rbp), %rcx
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x5216
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x523c
movq -0x28(%rbp), %rax
cmpq -0x38(%rbp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x38(%rbp), %rcx
cmpq -0x28(%rbp), %rcx
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: 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);
    }
    XXH_memcpy(dst, &hash.high64, sizeof(hash.high64));
    XXH_memcpy((char*)dst + sizeof(hash.high64), &hash.low64, sizeof(hash.low64));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
jmp 0x5266
movq -0x8(%rbp), %rdi
callq 0x3610
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3610
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
addq $0x8, %rsi
movl $0x8, %edx
callq 0x25d0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x25d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_len_0to16_64b(unsigned char const*, unsigned long, unsigned char const*, unsigned long)
XXH_FORCE_INLINE XXH_PUREF XXH64_hash_t
XXH3_len_0to16_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
{
    XXH_ASSERT(len <= 16);
    {   if (XXH_likely(len >  8)) return XXH3_len_9to16_64b(input, len, secret, seed);
        if (XXH_likely(len >= 4)) return XXH3_len_4to8_64b(input, len, secret, seed);
        if (len) return XXH3_len_1to3_64b(input, len, secret, seed);
        return XXH64_avalanche(seed ^ (XXH_readLE64(secret+56) ^ XXH_readLE64(secret+64)));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x8, -0x18(%rbp)
jbe 0x5e3d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6160
movq %rax, -0x8(%rbp)
jmp 0x5ec1
cmpq $0x4, -0x18(%rbp)
jb 0x5e5f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6250
movq %rax, -0x8(%rbp)
jmp 0x5ec1
cmpq $0x0, -0x18(%rbp)
je 0x5e81
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6310
movq %rax, -0x8(%rbp)
jmp 0x5ec1
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0x32e0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
callq 0x32e0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x30(%rbp), %rax
xorq %rcx, %rax
xorq %rax, %rdi
callq 0x5d90
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_len_9to16_64b(unsigned char const*, unsigned long, unsigned char const*, unsigned long)
XXH_FORCE_INLINE XXH_PUREF XXH64_hash_t
XXH3_len_9to16_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
{
    XXH_ASSERT(input != NULL);
    XXH_ASSERT(secret != NULL);
    XXH_ASSERT(9 <= len && len <= 16);
    {   xxh_u64 const bitflip1 = (XXH_readLE64(secret+24) ^ XXH_readLE64(secret+32)) + seed;
        xxh_u64 const bitflip2 = (XXH_readLE64(secret+40) ^ XXH_readLE64(secret+48)) - seed;
        xxh_u64 const input_lo = XXH_readLE64(input)           ^ bitflip1;
        xxh_u64 const input_hi = XXH_readLE64(input + len - 8) ^ bitflip2;
        xxh_u64 const acc = len
                          + XXH_swap64(input_lo) + input_hi
                          + XXH3_mul128_fold64(input_lo, input_hi);
        return XXH3_avalanche(acc);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x32e0
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x32e0
movq %rax, %rcx
movq -0x68(%rbp), %rax
xorq %rcx, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x32e0
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x32e0
movq %rax, %rcx
movq -0x60(%rbp), %rax
xorq %rcx, %rax
subq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x32e0
xorq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
addq -0x10(%rbp), %rdi
addq $-0x8, %rdi
callq 0x32e0
xorq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3610
movq %rax, %rcx
movq -0x58(%rbp), %rax
addq %rcx, %rax
addq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x63c0
movq %rax, %rcx
movq -0x50(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x6400
addq $0x70, %rsp
popq %rbp
retq
nop
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_len_4to8_64b(unsigned char const*, unsigned long, unsigned char const*, unsigned long)
XXH_FORCE_INLINE XXH_PUREF XXH64_hash_t
XXH3_len_4to8_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
{
    XXH_ASSERT(input != NULL);
    XXH_ASSERT(secret != NULL);
    XXH_ASSERT(4 <= len && len <= 8);
    seed ^= (xxh_u64)XXH_swap32((xxh_u32)seed) << 32;
    {   xxh_u32 const input1 = XXH_readLE32(input);
        xxh_u32 const input2 = XXH_readLE32(input + len - 4);
        xxh_u64 const bitflip = (XXH_readLE64(secret+8) ^ XXH_readLE64(secret+16)) - seed;
        xxh_u64 const input64 = input2 + (((xxh_u64)input1) << 32);
        xxh_u64 const keyed = input64 ^ bitflip;
        return XXH3_rrmxmx(keyed, len);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl %eax, %edi
callq 0x2ba0
movl %eax, %eax
shlq $0x20, %rax
xorq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x29e0
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
addq -0x10(%rbp), %rdi
addq $-0x4, %rdi
callq 0x29e0
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x32e0
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x32e0
movq %rax, %rcx
movq -0x48(%rbp), %rax
xorq %rcx, %rax
subq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %eax
movl -0x24(%rbp), %ecx
shlq $0x20, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
xorq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x64c0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_len_1to3_64b(unsigned char const*, unsigned long, unsigned char const*, unsigned long)
XXH_FORCE_INLINE XXH_PUREF XXH64_hash_t
XXH3_len_1to3_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
{
    XXH_ASSERT(input != NULL);
    XXH_ASSERT(1 <= len && len <= 3);
    XXH_ASSERT(secret != NULL);
    /*
     * len = 1: combined = { input[0], 0x01, input[0], input[0] }
     * len = 2: combined = { input[1], 0x02, input[0], input[1] }
     * len = 3: combined = { input[2], 0x03, input[0], input[1] }
     */
    {   xxh_u8  const c1 = input[0];
        xxh_u8  const c2 = input[len >> 1];
        xxh_u8  const c3 = input[len - 1];
        xxh_u32 const combined = ((xxh_u32)c1 << 16) | ((xxh_u32)c2  << 24)
                               | ((xxh_u32)c3 <<  0) | ((xxh_u32)len << 8);
        xxh_u64 const bitflip = (XXH_readLE32(secret) ^ XXH_readLE32(secret+4)) + seed;
        xxh_u64 const keyed = (xxh_u64)combined ^ bitflip;
        return XXH64_avalanche(keyed);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq %rcx
movb (%rax,%rcx), %al
movb %al, -0x22(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
movb (%rax,%rcx), %al
movb %al, -0x23(%rbp)
movzbl -0x21(%rbp), %eax
shll $0x10, %eax
movzbl -0x22(%rbp), %ecx
shll $0x18, %ecx
orl %ecx, %eax
movzbl -0x23(%rbp), %ecx
shll $0x0, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x29e0
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rdi
addq $0x4, %rdi
callq 0x29e0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
xorl %ecx, %eax
movl %eax, %eax
addq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %eax
xorq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x5d90
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_avalanche(unsigned long)
static XXH64_hash_t XXH3_avalanche(xxh_u64 h64)
{
    h64 = XXH_xorshift64(h64, 37);
    h64 *= 0x165667919E3779F9ULL;
    h64 = XXH_xorshift64(h64, 32);
    return h64;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x25, %esi
callq 0x6490
movq %rax, -0x8(%rbp)
movabsq $0x165667919e3779f9, %rax # imm = 0x165667919E3779F9
imulq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x6490
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_rrmxmx(unsigned long, unsigned long)
static XXH64_hash_t XXH3_rrmxmx(xxh_u64 h64, xxh_u64 len)
{
    /* this mix is inspired by Pelle Evensen's rrmxmx */
    h64 ^= XXH_rotl64(h64, 49) ^ XXH_rotl64(h64, 24);
    h64 *= 0x9FB21C651E98DF25ULL;
    h64 ^= (h64 >> 35) + len ;
    h64 *= 0x9FB21C651E98DF25ULL;
    return XXH_xorshift64(h64, 28);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
rolq $0x31, %rax
movq -0x8(%rbp), %rcx
rolq $0x18, %rcx
xorq %rcx, %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movabsq $-0x604de39ae16720db, %rax # imm = 0x9FB21C651E98DF25
imulq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x23, %rax
addq -0x10(%rbp), %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movabsq $-0x604de39ae16720db, %rax # imm = 0x9FB21C651E98DF25
imulq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1c, %esi
callq 0x6490
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_mix16B(unsigned char const*, unsigned char const*, unsigned long)
XXH_FORCE_INLINE xxh_u64 XXH3_mix16B(const xxh_u8* XXH_RESTRICT input,
                                     const xxh_u8* XXH_RESTRICT secret, xxh_u64 seed64)
{
#if defined(__GNUC__) && !defined(__clang__) /* GCC, not Clang */ \
  && defined(__i386__) && defined(__SSE2__)  /* x86 + SSE2 */ \
  && !defined(XXH_ENABLE_AUTOVECTORIZE)      /* Define to disable like XXH32 hack */
    /*
     * UGLY HACK:
     * GCC for x86 tends to autovectorize the 128-bit multiply, resulting in
     * slower code.
     *
     * By forcing seed64 into a register, we disrupt the cost model and
     * cause it to scalarize. See `XXH32_round()`
     *
     * FIXME: Clang's output is still _much_ faster -- On an AMD Ryzen 3600,
     * XXH3_64bits @ len=240 runs at 4.6 GB/s with Clang 9, but 3.3 GB/s on
     * GCC 9.2, despite both emitting scalar code.
     *
     * GCC generates much better scalar code than Clang for the rest of XXH3,
     * which is why finding a more optimal codepath is an interest.
     */
    XXH_COMPILER_GUARD(seed64);
#endif
    {   xxh_u64 const input_lo = XXH_readLE64(input);
        xxh_u64 const input_hi = XXH_readLE64(input+8);
        return XXH3_mul128_fold64(
            input_lo ^ (XXH_readLE64(secret)   + seed64),
            input_hi ^ (XXH_readLE64(secret+8) - seed64)
        );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x32e0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x32e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x32e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq -0x18(%rbp), %rcx
xorq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x32e0
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
subq -0x18(%rbp), %rax
xorq %rax, %rsi
callq 0x63c0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_hashLong_64b_internal(void const*, unsigned long, void const*, unsigned long, void (*)(void*, void const*, void const*), void (*)(void*, void const*))
XXH_FORCE_INLINE XXH64_hash_t
XXH3_hashLong_64b_internal(const void* XXH_RESTRICT input, size_t len,
                           const void* XXH_RESTRICT secret, size_t secretSize,
                           XXH3_f_accumulate_512 f_acc512,
                           XXH3_f_scrambleAcc f_scramble)
{
    XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[XXH_ACC_NB] = XXH3_INIT_ACC;

    XXH3_hashLong_internal_loop(acc, (const xxh_u8*)input, len, (const xxh_u8*)secret, secretSize, f_acc512, f_scramble);

    /* converge into final hash */
    XXH_STATIC_ASSERT(sizeof(acc) == 64);
    /* do not align on 8, so that the secret is different from the accumulator */
#define XXH_SECRET_MERGEACCS_START 11
    XXH_ASSERT(secretSize >= sizeof(acc) + XXH_SECRET_MERGEACCS_START);
    return XXH3_mergeAccs(acc, (const xxh_u8*)secret + XXH_SECRET_MERGEACCS_START, (xxh_u64)len * XXH_PRIME64_1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x70(%rbp), %rdi
leaq 0x4b02(%rip), %rsi      # 0xb100
movl $0x40, %edx
callq 0x2110
leaq -0x70(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %rax
movq %rax, (%rsp)
callq 0x6660
jmp 0x662f
leaq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0xb, %rsi
movabsq $-0x61c8864e7a143579, %rdx # imm = 0x9E3779B185EBCA87
imulq -0x10(%rbp), %rdx
callq 0x4ae0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_hashLong_64b_withSeed_internal(void const*, unsigned long, unsigned long, void (*)(void*, void const*, void const*), void (*)(void*, void const*), void (*)(void*, unsigned long))
XXH_FORCE_INLINE XXH64_hash_t
XXH3_hashLong_64b_withSeed_internal(const void* input, size_t len,
                                    XXH64_hash_t seed,
                                    XXH3_f_accumulate_512 f_acc512,
                                    XXH3_f_scrambleAcc f_scramble,
                                    XXH3_f_initCustomSecret f_initSec)
{
#if XXH_SIZE_OPT <= 0
    if (seed == 0)
        return XXH3_hashLong_64b_internal(input, len,
                                          XXH3_kSecret, sizeof(XXH3_kSecret),
                                          f_acc512, f_scramble);
#endif
    {   XXH_ALIGN(XXH_SEC_ALIGN) xxh_u8 secret[XXH_SECRET_DEFAULT_SIZE];
        f_initSec(secret, seed);
        return XXH3_hashLong_64b_internal(input, len, secret, sizeof(secret),
                                          f_acc512, f_scramble);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6861
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq 0x47ef(%rip), %rdx      # 0xb040
movl $0xc0, %ecx
callq 0x65d0
movq %rax, -0x8(%rbp)
jmp 0x6897
movq -0x38(%rbp), %rax
leaq -0x100(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x100(%rbp), %rdx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movl $0xc0, %ecx
callq 0x65d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_len_0to16_128b(unsigned char const*, unsigned long, unsigned char const*, unsigned long)
XXH_FORCE_INLINE XXH_PUREF XXH128_hash_t
XXH3_len_0to16_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
{
    XXH_ASSERT(len <= 16);
    {   if (len > 8) return XXH3_len_9to16_128b(input, len, secret, seed);
        if (len >= 4) return XXH3_len_4to8_128b(input, len, secret, seed);
        if (len) return XXH3_len_1to3_128b(input, len, secret, seed);
        {   XXH128_hash_t h128;
            xxh_u64 const bitflipl = XXH_readLE64(secret+64) ^ XXH_readLE64(secret+72);
            xxh_u64 const bitfliph = XXH_readLE64(secret+80) ^ XXH_readLE64(secret+88);
            h128.low64 = XXH64_avalanche(seed ^ bitflipl);
            h128.high64 = XXH64_avalanche( seed ^ bitfliph);
            return h128;
    }   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
cmpq $0x8, -0x20(%rbp)
jbe 0x6aa1
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x7040
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x6b6a
cmpq $0x4, -0x20(%rbp)
jb 0x6aca
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x71d0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x6b6a
cmpq $0x0, -0x20(%rbp)
je 0x6af0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x7310
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x6b6a
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
callq 0x32e0
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
addq $0x48, %rdi
callq 0x32e0
movq %rax, %rcx
movq -0x50(%rbp), %rax
xorq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
addq $0x50, %rdi
callq 0x32e0
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
addq $0x58, %rdi
callq 0x32e0
movq %rax, %rcx
movq -0x48(%rbp), %rax
xorq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
xorq -0x38(%rbp), %rdi
callq 0x5d90
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
xorq -0x40(%rbp), %rdi
callq 0x5d90
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)