LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/mmoanis[P]mpegts_demux/MpegTsBitStream.cpp
// Function: MpegTsBitStream::GetPacket(Packet&)
bool MpegTsBitStream::GetPacket(Packet& packet)
{
    // Fast exit
    if (!m_file || !good()) return false;

    Packet::iterator p = packet.begin();

    size_t count = 1;
    int C = fgetc(m_file);

    if (C == EOF) {
        /// No More packets in stream
        m_eof = true;
        return false;
    }

    uint8_t c = static_cast<uint8_t> (C);
    if (c != MPEGTS_SYNC_BYTE) {
        cerr << "[ERROR]: Sync byte not found." << endl;
        m_bad = true;
        return false;
    }

    *p++ = c;
    while (p != packet.end()) {
        C = fgetc(m_file);
        if (C == EOF) {
            m_eof = true;
            break;
        }
        c = static_cast<uint8_t> (C);
        *p++ = c;
        ++count;
    }

    if (count != PACKET_SIZE) {
        cerr << "[ERROR]: Expected " << PACKET_SIZE << " bytes, found " << count << endl;
        m_bad = true;
        return false;
    }

    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x281d
xorl %eax, %eax
cmpb $0x0, 0x8(%rbx)
jne 0x281f
testb $0x1, 0x9(%rbx)
jne 0x281f
movq %rsi, %r15
callq 0x21b0
cmpl $-0x1, %eax
je 0x276d
cmpb $0x47, %al
jne 0x2776
movb $0x47, (%r15)
movl $0x1, %r14d
movq (%rbx), %rdi
callq 0x21b0
cmpl $-0x1, %eax
je 0x2796
movb %al, (%r15,%r14)
incq %r14
cmpq $0xbc, %r14
jne 0x2749
movb $0x1, %al
jmp 0x281f
movb $0x1, 0x8(%rbx)
jmp 0x281d
movq 0x5873(%rip), %r14      # 0x7ff0
leaq 0x2a04(%rip), %rsi      # 0x5188
movl $0x1d, %edx
movq %r14, %rdi
callq 0x2160
movq (%r14), %rax
jmp 0x27f5
movb $0x1, 0x8(%rbx)
movb $0x1, %al
cmpq $0xbc, %r14
je 0x281f
movq 0x5844(%rip), %r15      # 0x7ff0
leaq 0x29f3(%rip), %rsi      # 0x51a6
movl $0x12, %edx
movq %r15, %rdi
callq 0x2160
movq %r15, %rdi
movl $0xbc, %esi
callq 0x21e0
movq %rax, %r15
leaq 0x29e2(%rip), %rsi      # 0x51b9
movl $0xe, %edx
movq %rax, %rdi
callq 0x2160
movq %r15, %rdi
movq %r14, %rsi
callq 0x20b0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movb $0x1, 0x9(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/mmoanis[P]mpegts_demux/MpegTsDemux.cpp
// Function: Stream::Stream(char const*, unsigned short, unsigned short)
Stream::Stream(const char *filename, PID id, PID pid)
    : m_file(NULL), m_id(id), m_pid(pid)
{
    assert(filename != NULL);
    m_file = fopen(filename, "wb");
    if (!m_file) {
        cerr << "[ERROR]: STREAM=" << m_id << " PID=" << m_pid << " : can't open file \'" << filename << "\'" << endl;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq $0x0, (%rdi)
movw %dx, 0x8(%rdi)
movw %cx, 0xa(%rdi)
testq %rsi, %rsi
je 0x2921
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x29bd(%rip), %rsi      # 0x520f
movq %rbx, %rdi
callq 0x2170
movq %rax, (%r14)
testq %rax, %rax
je 0x2868
popq %rbx
popq %r14
popq %r15
retq
movq 0x5781(%rip), %r15      # 0x7ff0
leaq 0x299c(%rip), %rsi      # 0x5212
movl $0x10, %edx
movq %r15, %rdi
callq 0x2160
movzwl 0x8(%r14), %esi
movq %r15, %rdi
callq 0x20b0
movq %rax, %r15
leaq 0x29b7(%rip), %rsi      # 0x5251
movl $0x5, %edx
movq %rax, %rdi
callq 0x2160
movzwl 0xa(%r14), %esi
movq %r15, %rdi
callq 0x20b0
movq %rax, %r14
leaq 0x2965(%rip), %rsi      # 0x5223
movl $0x14, %edx
movq %rax, %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x2080
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2160
leaq 0x294e(%rip), %rsi      # 0x5236
movl $0x1, %edx
movq %r14, %rdi
callq 0x2160
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20c0
leaq 0x27ee(%rip), %rdi      # 0x5116
leaq 0x28a9(%rip), %rsi      # 0x51d8
leaq 0x28b2(%rip), %rcx      # 0x51e8
movl $0x1d, %edx
callq 0x20a0
// File: /workspace/github_cpp_makefile_star2_O3/mmoanis[P]mpegts_demux/MpegTsDemux.cpp
// Function: Stream::Write(unsigned char const*, unsigned char const*)
void Stream::Write(Packet::const_iterator b, Packet::const_iterator e)
{
    if (!m_file) return; // Failed to create stream. Exit quietly

    while (b != e) {
        int r = fputc(*b++, m_file);
        if (r == EOF) {
            cerr << "[ERROR]: STREAM=" << m_id << " PID=" << m_pid << " Write failed." << endl;
            fclose(m_file);
            m_file = NULL;
        }
    }
}

// Assembly:
cmpq $0x0, (%rdi)
sete %al
cmpq %rdx, %rsi
sete %cl
orb %al, %cl
jne 0x2a43
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x5672(%rip), %r12      # 0x7ff0
leaq 0x28b3(%rip), %r13      # 0x5238
movzbl (%r14), %edi
movq (%r15), %rsi
callq 0x2180
cmpl $-0x1, %eax
jne 0x2a29
movl $0x10, %edx
movq %r12, %rdi
leaq 0x2869(%rip), %rsi      # 0x5212
callq 0x2160
movzwl 0x8(%r15), %esi
movq %r12, %rdi
callq 0x20b0
movq %rax, %rbp
movl $0x5, %edx
movq %rax, %rdi
leaq 0x2884(%rip), %rsi      # 0x5251
callq 0x2160
movzwl 0xa(%r15), %esi
movq %rbp, %rdi
callq 0x20b0
movq %rax, %rbp
movl $0xe, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2160
movq (%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbp, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movq (%r15), %rdi
callq 0x2130
movq $0x0, (%r15)
incq %r14
cmpq %rbx, %r14
jne 0x2985
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mmoanis[P]mpegts_demux/MpegTsDemux.cpp
// Function: MpegTsDemuxer::ReadHeader(unsigned char const*&, unsigned char const*, PacketHeader&)
bool MpegTsDemuxer::ReadHeader(Packet::const_iterator &p, Packet::const_iterator e, PacketHeader& header)
{
    if (*p != MPEGTS_SYNC_BYTE) {
        cerr << "[ERROR]: PKT#" << m_pnum << " Sync byte not found." << endl;
        return false;
    }
    p++;

    header.tei = static_cast<bool> (*p&0x80);
    header.pusi = static_cast<bool> (*p&0x40);
    header.tp = static_cast<bool> (*p&0x20);

    header.id = PID((p[0]&0x1F)<<8) | PID(p[1]);
    p += 2;

    header.afc = (((*p&0x30)>>4) == 0x2) || (((*p&0x30)>>4) == 0x3);
    header.payload = (((*p&0x30)>>4) == 0x1) || (((*p&0x30)>>4) == 0x3);
    header.cc = *p&0xF;
    p++;

    // Greedy, just escape the adaptation control field
    if (header.afc) {
        const uint8_t l = *p++;
        p += l;
    }

    return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq (%rsi), %rax
movb (%rax), %bpl
cmpb $0x47, %bpl
jne 0x2dab
leaq 0x1(%rax), %rdx
movq %rdx, (%rsi)
movb 0x1(%rax), %dl
shrb $0x7, %dl
movb %dl, (%rcx)
movb 0x1(%rax), %dl
shrb $0x6, %dl
andb $0x1, %dl
movb %dl, 0x1(%rcx)
movb 0x1(%rax), %dl
shrb $0x5, %dl
andb $0x1, %dl
movb %dl, 0x2(%rcx)
movzbl 0x1(%rax), %edx
andl $0x1f, %edx
shll $0x8, %edx
movzbl 0x2(%rax), %edi
orl %edx, %edi
movw %di, 0x4(%rcx)
leaq 0x3(%rax), %rdx
movq %rdx, (%rsi)
movb 0x3(%rax), %dl
shrb $0x5, %dl
movl %edx, %edi
andb $0x1, %dil
movb %dil, 0x6(%rcx)
movb 0x3(%rax), %dil
shrb $0x4, %dil
andb $0x1, %dil
movb %dil, 0x7(%rcx)
movb 0x3(%rax), %dil
andb $0xf, %dil
leaq 0x4(%rax), %r8
movb %dil, 0x8(%rcx)
movq %r8, (%rsi)
andb $0x1, %dl
je 0x2e16
leaq 0x5(%rax), %rcx
movq %rcx, (%rsi)
movzbl 0x4(%rax), %ecx
addq %rcx, %rax
addq $0x5, %rax
movq %rax, (%rsi)
jmp 0x2e16
movq %rdi, %rbx
movq 0x523b(%rip), %r14      # 0x7ff0
leaq 0x24b6(%rip), %rsi      # 0x5272
movl $0xd, %edx
movq %r14, %rdi
callq 0x2160
movq 0x90(%rbx), %rsi
movq %r14, %rdi
callq 0x20b0
movq %rax, %rbx
leaq 0x23ae(%rip), %rsi      # 0x5190
movl $0x15, %edx
movq %rax, %rdi
callq 0x2160
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
cmpb $0x47, %bpl
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mmoanis[P]mpegts_demux/MpegTsDemux.cpp
// Function: MpegTsDemuxer::ReadSection(unsigned char const*&, unsigned char const*, PacketSection&)
bool MpegTsDemuxer::ReadSection(Packet::const_iterator &p, Packet::const_iterator e, PacketSection& section)
{
    if (p + 4 >= e) {
        cerr << "[ERROR]: PKT#" << m_pnum << " not enough data in PSI section." << endl;
        return false;
    }

    section.id = uint16_t(p[0]<<8) | uint16_t(p[1]);
    p+= 2;

    if (((*p&0xC0)>>6) != 0x03) {
        cerr << "[ERROR]: PKT#" << m_pnum <<" Section reserved bits not set." << endl;
        return false;
    }
    section.version = (*p&0x3E)>>1;
    section.cni = static_cast<bool> (*p++&0x1);

    section.sn = *p++;
    section.lsn = *p++;
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x4(%rax), %rdi
cmpq %rdx, %rdi
jae 0x3a69
movzwl (%rax), %edx
rolw $0x8, %dx
movw %dx, (%rcx)
leaq 0x2(%rax), %rdx
movq %rdx, (%rsi)
movb 0x2(%rax), %dl
cmpb $-0x41, %dl
jbe 0x3aa4
shrb %dl
andb $0x1f, %dl
movb %dl, 0x2(%rcx)
leaq 0x3(%rax), %rdx
movq %rdx, (%rsi)
movb 0x2(%rax), %dl
andb $0x1, %dl
movb %dl, 0x3(%rcx)
movq %rdi, (%rsi)
movb 0x3(%rax), %dl
movb %dl, 0x4(%rcx)
leaq 0x5(%rax), %rdx
movq %rdx, (%rsi)
movb 0x4(%rax), %al
movb %al, 0x5(%rcx)
movb $0x1, %al
jmp 0x3b0e
movq 0x4580(%rip), %r14      # 0x7ff0
leaq 0x17fb(%rip), %rsi      # 0x5272
movl $0xd, %edx
movq %r14, %rdi
callq 0x2160
movq 0x90(%rbx), %rsi
movq %r14, %rdi
callq 0x20b0
movq %rax, %rbx
leaq 0x1a9d(%rip), %rsi      # 0x553a
movl $0x20, %edx
jmp 0x3add
movq 0x4545(%rip), %r14      # 0x7ff0
leaq 0x17c0(%rip), %rsi      # 0x5272
movl $0xd, %edx
movq %r14, %rdi
callq 0x2160
movq 0x90(%rbx), %rsi
movq %r14, %rdi
callq 0x20b0
movq %rax, %rbx
leaq 0x1a83(%rip), %rsi      # 0x555b
movl $0x1f, %edx
movq %rax, %rdi
callq 0x2160
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mmoanis[P]mpegts_demux/MpegTsDemux.cpp
// Function: MpegTsDemuxer::ReadPrograms(unsigned char const*&, unsigned char const*)
bool MpegTsDemuxer::ReadPrograms(Packet::const_iterator &p, Packet::const_iterator e)
{
    bool done = false;
    // Read PAT table till end of packet (CRC)
    while (p + 3 < e) {
        if (p[4] == MPEGTS_STUFFING_BYTE) {
            // Read PAT table till end of packet (CRC+STUFFING)
            break;
        }

        uint16_t pnum = uint16_t(p[0]<<8) | uint16_t(p[1]);
        p+=2;

        if (((*p&0xE0)>>5) != 0x07) {
            cerr << "[ERROR]: PKT#" << m_pnum <<" PAT reserved bits not set." << endl;
            return false;
        }
        uint16_t pmid = uint16_t((p[0]&0x1F)<<8) | uint16_t(p[1]);
        p+=2;

        RegisterProgram(pnum, pmid);
        //cout << "PNUM: " << pnum << " PMAP PID: " << pmid << endl;
        done = true;
    }

    if (!done) {
        cerr << "[ERROR]: PKT#" << m_pnum << " PAT can't find programs." << endl;
    }
    return done;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %rdx
leaq 0x3(%rdx), %rcx
cmpq %r14, %rcx
jae 0x3ba1
movb 0x4(%rdx), %bpl
cmpb $-0x1, %bpl
je 0x3ba1
movq %rsi, %r15
leaq 0x4(%rdx), %rdi
movzbl (%rdx), %r8d
movzbl 0x1(%rdx), %esi
leaq 0x2(%rdx), %rax
movq %rax, (%r15)
movzbl 0x2(%rdx), %eax
movzwl %ax, %eax
cmpl $0xdf, %eax
jbe 0x3c16
movzwl %r8w, %edx
shll $0x8, %edx
movzwl %si, %esi
orl %edx, %esi
andl $0x1f, %eax
shll $0x8, %eax
movzbl (%rcx), %edx
orl %eax, %edx
movq %rdi, (%r15)
movq %rbx, %rdi
callq 0x3c52
movq (%r15), %rdx
leaq 0x3(%rdx), %rcx
movb $0x1, %al
cmpq %r14, %rcx
jae 0x3c0b
leaq 0x4(%rdx), %rdi
cmpb $-0x1, 0x4(%rdx)
jne 0x3b40
cmpb $-0x1, %bpl
jne 0x3c0b
movq 0x4448(%rip), %r14      # 0x7ff0
leaq 0x16c3(%rip), %rsi      # 0x5272
movl $0xd, %edx
movq %r14, %rdi
callq 0x2160
movq 0x90(%rbx), %rsi
movq %r14, %rdi
callq 0x20b0
movq %rax, %rbx
leaq 0x1784(%rip), %rsi      # 0x5359
movl $0x19, %edx
movq %rax, %rdi
callq 0x2160
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x43d3(%rip), %r14      # 0x7ff0
leaq 0x164e(%rip), %rsi      # 0x5272
movl $0xd, %edx
movq %r14, %rdi
callq 0x2160
movq 0x90(%rbx), %rsi
movq %r14, %rdi
callq 0x20b0
movq %rax, %rbx
leaq 0x16f3(%rip), %rsi      # 0x533d
movl $0x1b, %edx
jmp 0x3bda
nop
// File: /workspace/github_cpp_makefile_star2_O3/sgielen[P]clife/./xxhash/xxhash.h
// Function: 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->v[0], 1)
            + XXH_rotl32(state->v[1], 7)
            + XXH_rotl32(state->v[2], 12)
            + XXH_rotl32(state->v[3], 18);
    } else {
        h32 = state->v[2] /* == seed */ + XXH_PRIME32_5;
    }

    h32 += state->total_len_32;

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

// Assembly:
movq %rdi, %rsi
cmpl $0x0, 0x4(%rdi)
je 0x267f
movdqu 0x8(%rsi), %xmm0
movdqa 0x49fb(%rip), %xmm1     # 0x7030
pshufd $0xf5, %xmm0, %xmm2     # xmm2 = xmm0[1,1,3,3]
pmuludq %xmm1, %xmm0
pshufd $0xed, %xmm0, %xmm3     # xmm3 = xmm0[1,3,2,3]
pshufd $0xf5, %xmm1, %xmm1     # xmm1 = xmm1[1,1,3,3]
pmuludq %xmm2, %xmm1
pshufd $0xed, %xmm1, %xmm2     # xmm2 = xmm1[1,3,2,3]
punpckldq %xmm2, %xmm3    # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
pshufd $0xe8, %xmm1, %xmm1     # xmm1 = xmm1[0,2,2,3]
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
por %xmm3, %xmm0
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddd %xmm0, %xmm1
pshufd $0x55, %xmm1, %xmm0     # xmm0 = xmm1[1,1,1,1]
paddd %xmm1, %xmm0
movd %xmm0, %edi
jmp 0x2687
movl $0x165667b1, %edi       # imm = 0x165667B1
addl 0x10(%rsi), %edi
addl (%rsi), %edi
movl 0x28(%rsi), %edx
addq $0x18, %rsi
jmp 0x2692
// File: /workspace/github_cpp_makefile_star2_O3/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:
movabsq $-0x3d4d51c2d82b14b1, %rax # imm = 0xC2B2AE3D27D4EB4F
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
andl $0x1f, %edx
cmpq $0x8, %rdx
jb 0x2bb4
movabsq $-0x7a1435883d4d519d, %r9 # imm = 0x85EBCA77C2B2AE63
movq (%rsi), %r8
imulq %rax, %r8
rolq $0x1f, %r8
imulq %rcx, %r8
xorq %rdi, %r8
addq $0x8, %rsi
rolq $0x1b, %r8
imulq %rcx, %r8
addq %r9, %r8
addq $-0x8, %rdx
movq %r8, %rdi
cmpq $0x7, %rdx
ja 0x2b84
jmp 0x2bb7
movq %rdi, %r8
movabsq $0x165667b19e3779f9, %rdi # imm = 0x165667B19E3779F9
cmpq $0x4, %rdx
jb 0x2be7
movl (%rsi), %r9d
imulq %rcx, %r9
xorq %r8, %r9
addq $0x4, %rsi
rolq $0x17, %r9
imulq %rax, %r9
addq %rdi, %r9
addq $-0x4, %rdx
movq %r9, %r8
testq %rdx, %rdx
je 0x2c1a
xorl %r9d, %r9d
movabsq $0x27d4eb2f165667c5, %r11 # imm = 0x27D4EB2F165667C5
movzbl (%rsi,%r9), %r10d
imulq %r11, %r10
xorq %r8, %r10
rolq $0xb, %r10
imulq %rcx, %r10
incq %r9
movq %r10, %r8
cmpq %r9, %rdx
jne 0x2bf9
jmp 0x2c1d
movq %r8, %r10
movq %r10, %rcx
shrq $0x21, %rcx
xorq %r10, %rcx
imulq %rax, %rcx
movq %rcx, %rdx
shrq $0x1d, %rdx
xorq %rcx, %rdx
imulq %rdi, %rdx
movq %rdx, %rax
shrq $0x20, %rax
xorq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
movl $0x280, %edi            # imm = 0x280
callq 0x21a0
testq %rax, %rax
je 0x321d
movl %eax, %edx
andl $0x3f, %edx
movl $0x40, %esi
subq %rdx, %rsi
movq %rax, %rcx
addq %rsi, %rcx
negq %rdx
movb %sil, 0x3f(%rax,%rdx)
movq $0x0, 0x228(%rax,%rsi)
jmp 0x321f
xorl %ecx, %ecx
movq %rcx, %rax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl $0x1, %eax
testq %rdi, %rdi
je 0x33b4
xorps %xmm0, %xmm0
movups %xmm0, 0x200(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x210(%rdi)
movl $0x85ebca77, %r8d       # imm = 0x85EBCA77
leaq 0x3cc6e3c6(%r8), %r9
movq %r9, (%rdi)
movabsq $-0x61c8864e7a143579, %r9 # imm = 0x9E3779B185EBCA87
movq %r9, 0x8(%rdi)
movabsq $-0x3d4d51c2d82b14b1, %r9 # imm = 0xC2B2AE3D27D4EB4F
movq %r9, 0x10(%rdi)
movabsq $0x165667b19e3779f9, %r9 # imm = 0x165667B19E3779F9
movq %r9, 0x18(%rdi)
movabsq $-0x7a1435883d4d519d, %r9 # imm = 0x85EBCA77C2B2AE63
movq %r9, 0x20(%rdi)
movq %r8, 0x28(%rdi)
movabsq $0x27d4eb2f165667c5, %r9 # imm = 0x27D4EB2F165667C5
movq %r9, 0x30(%rdi)
addq $0x184baf3a, %r8        # imm = 0x184BAF3A
movq %r8, 0x38(%rdi)
movq %rcx, 0x228(%rdi)
movq %rsi, 0x238(%rdi)
leaq -0x40(%rdx), %rcx
movq %rcx, 0x220(%rdi)
shrq $0x3, %rcx
movq %rcx, 0x218(%rdi)
testq %rsi, %rsi
je 0x33b4
xorl %eax, %eax
cmpq $0x88, %rdx
setb %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x34a1
movabsq $-0x3d4d51c2d82b14b1, %r8 # imm = 0xC2B2AE3D27D4EB4F
movabsq $-0x61c8864e7a143579, %r10 # imm = 0x9E3779B185EBCA87
movabsq $-0x7a1435883d4d519d, %rdx # imm = 0x85EBCA77C2B2AE63
movabsq $0x27d4eb2f165667c5, %rcx # imm = 0x27D4EB2F165667C5
movabsq $0x165667b19e3779f9, %r9 # imm = 0x165667B19E3779F9
movl $0x85ebca77, %eax       # imm = 0x85EBCA77
testq %rsi, %rsi
je 0x34a7
cmpq %rsi, 0x228(%rdi)
jne 0x3411
cmpq $0x0, 0x238(%rdi)
je 0x344b
pushq %r15
pushq %r14
pushq %rbx
xorl %r11d, %r11d
leaq 0x3c60(%rip), %rbx      # 0x7080
movq (%r11,%rbx), %r14
addq %rsi, %r14
movq 0x8(%r11,%rbx), %r15
subq %rsi, %r15
movq %r14, 0x40(%rdi,%r11)
movq %r15, 0x48(%rdi,%r11)
addq $0x10, %r11
cmpq $0xc0, %r11
jne 0x3420
popq %rbx
popq %r14
popq %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x200(%rdi)
movq $0x0, 0x210(%rdi)
leaq 0x3cc6e3c6(%rax), %r11
movq %r11, (%rdi)
movq %r10, 0x8(%rdi)
movq %r8, 0x10(%rdi)
movq %r9, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
addq $0x184baf3a, %rax       # imm = 0x184BAF3A
movq %rax, 0x38(%rdi)
movq %rsi, 0x228(%rdi)
movl $0x1, 0x204(%rdi)
xorl %eax, %eax
jmp 0x34f4
movl $0x1, %eax
retq
xorps %xmm0, %xmm0
movups %xmm0, 0x200(%rdi)
xorl %esi, %esi
movq %rsi, 0x210(%rdi)
leaq 0x3cc6e3c6(%rax), %r11
movq %r11, (%rdi)
movq %r10, 0x8(%rdi)
movq %r8, 0x10(%rdi)
movq %r9, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
addq $0x184baf3a, %rax       # imm = 0x184BAF3A
movq %rax, 0x38(%rdi)
movq %rsi, 0x228(%rdi)
leaq 0x3b8c(%rip), %rax      # 0x7080
movq %rax, 0x238(%rdi)
movq $0x80, 0x220(%rdi)
movq $0x10, 0x218(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rsi
movq 0x210(%rdi), %rbx
movq 0x238(%rdi), %rax
leaq 0x40(%rdi), %r14
testq %rax, %rax
cmovneq %rax, %r14
cmpq $0xf1, %rbx
jb 0x3a34
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x3a8c
addq $0xb, %r14
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
imulq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3bf9
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x100(%rsi), %rdi
cmpl $0x0, 0x204(%rsi)
je 0x3a64
movq 0x228(%rsi), %rdx
leaq 0x362e(%rip), %rcx      # 0x7080
leaq -0x9d5(%rip), %r9       # 0x3084
movl $0xc0, %r8d
movq %rbx, %rsi
jmp 0x3a7e
movq 0x220(%rsi), %r8
addq $0x40, %r8
leaq -0xa81(%rip), %r9       # 0x2ff5
movq %rbx, %rsi
xorl %edx, %edx
movq %r14, %rcx
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2c6a
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq %rdx, %xmm0
xorl %r9d, %r9d
movdqu (%rdi,%r9), %xmm1
movdqu 0x10(%rdi,%r9), %xmm2
movdqu (%rsi,%r9), %xmm3
movdqu 0x10(%rsi,%r9), %xmm4
movdqa %xmm3, %xmm5
punpcklqdq %xmm4, %xmm5    # xmm5 = xmm5[0],xmm4[0]
movdqa %xmm1, %xmm6
punpcklqdq %xmm2, %xmm6    # xmm6 = xmm6[0],xmm2[0]
pxor %xmm5, %xmm6
punpckhqdq %xmm4, %xmm3    # xmm3 = xmm3[1],xmm4[1]
punpckhqdq %xmm2, %xmm1    # xmm1 = xmm1[1],xmm2[1]
pxor %xmm3, %xmm1
pshufd $0xee, %xmm6, %xmm2     # xmm2 = xmm6[2,3,2,3]
movq %xmm2, %r10
movq %xmm6, %rcx
pshufd $0xee, %xmm1, %xmm2     # xmm2 = xmm1[2,3,2,3]
movq %xmm1, %rax
mulq %rcx
movq %rax, %rcx
movq %rdx, %r8
movq %xmm2, %rax
mulq %r10
xorq %rax, %rdx
xorq %rcx, %r8
movq %r8, %xmm1
movq %rdx, %xmm2
punpcklqdq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0]
paddq %xmm1, %xmm0
addq $0x20, %r9
cmpq $0x40, %r9
jne 0x3c01
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddq %xmm0, %xmm1
movq %xmm1, %rax
movq %rax, %rcx
shrq $0x25, %rcx
xorq %rax, %rcx
movabsq $0x165667919e3779f9, %rdx # imm = 0x165667919E3779F9
imulq %rcx, %rdx
movq %rdx, %rax
shrq $0x20, %rax
xorq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_hashLong_128b_withSeed(void const*, unsigned long, unsigned long, void const*, unsigned long)
XXH_FORCE_INLINE XXH128_hash_t
XXH3_hashLong_128b_withSeed_internal(const void* XXH_RESTRICT input, size_t len,
                                XXH64_hash_t seed64,
                                XXH3_f_accumulate_512 f_acc512,
                                XXH3_f_scrambleAcc f_scramble,
                                XXH3_f_initCustomSecret f_initSec)
{
    if (seed64 == 0)
        return XXH3_hashLong_128b_internal(input, len,
                                           XXH3_kSecret, sizeof(XXH3_kSecret),
                                           f_acc512, f_scramble);
    {   XXH_ALIGN(XXH_SEC_ALIGN) xxh_u8 secret[XXH_SECRET_DEFAULT_SIZE];
        f_initSec(secret, seed64);
        return XXH3_hashLong_128b_internal(input, len, (const xxh_u8*)secret, sizeof(secret),
                                           f_acc512, f_scramble);
    }
}

// Assembly:
testq %rdx, %rdx
je 0x42b1
subq $0xc8, %rsp
movl $0x8, %eax
leaq 0x2e08(%rip), %rcx      # 0x7080
movq -0x8(%rax,%rcx), %r8
addq %rdx, %r8
movq (%rax,%rcx), %r9
subq %rdx, %r9
movq %r8, -0x8(%rsp,%rax)
movq %r9, (%rsp,%rax)
addq $0x10, %rax
cmpq $0xc8, %rax
jne 0x4278
movq %rsp, %rdx
movl $0xc0, %ecx
callq 0x53fb
addq $0xc8, %rsp
retq
leaq 0x2dc8(%rip), %rdx      # 0x7080
movl $0xc0, %ecx
jmp 0x53fb
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r15
movq 0x210(%rdi), %rbx
movq 0x238(%rdi), %rax
leaq 0x40(%rdi), %r14
testq %rax, %rax
cmovneq %rax, %r14
cmpq $0xf1, %rbx
jb 0x445b
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3a8c
leaq 0xb(%r14), %rsi
movabsq $-0x61c8864e7a143579, %rdx # imm = 0x9E3779B185EBCA87
imulq %rbx, %rdx
movq %r13, %rdi
callq 0x3bf9
movq %rax, %r12
movq 0x220(%r15), %rax
leaq (%r14,%rax), %rsi
addq $-0xb, %rsi
movabsq $-0x3d4d51c2d82b14b1, %rdx # imm = 0xC2B2AE3D27D4EB4F
imulq %rbx, %rdx
notq %rdx
movq %r13, %rdi
callq 0x3bf9
movq %rax, %rdx
jmp 0x44a9
movq 0x228(%r15), %rdx
leaq 0x100(%r15), %rdi
testq %rdx, %rdx
je 0x4487
leaq 0x2c0b(%rip), %rcx      # 0x7080
leaq -0x21c(%rip), %r9       # 0x4260
movl $0xc0, %r8d
movq %rbx, %rsi
jmp 0x44a1
movq 0x220(%r15), %r8
addq $0x40, %r8
leaq -0x25d(%rip), %r9       # 0x423c
movq %rbx, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0x3cd4
movq %rax, %r12
movq %r12, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rdx
xorl %eax, %eax
xorl %r8d, %r8d
cmpq %rdx, %rcx
seta %al
setb %r8b
subl %r8d, %eax
je 0x450b
retq
movq (%rdi), %rcx
xorl %eax, %eax
cmpq (%rsi), %rcx
seta %al
sbbl $0x0, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_generateSecret
XXH_PUBLIC_API XXH_errorcode
XXH3_generateSecret(void* secretBuffer, size_t secretSize, const void* customSeed, size_t customSeedSize)
{
#if (XXH_DEBUGLEVEL >= 1)
    XXH_ASSERT(secretBuffer != NULL);
    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN);
#else
    /* production mode, assert() are disabled */
    if (secretBuffer == NULL) return XXH_ERROR;
    if (secretSize < XXH3_SECRET_SIZE_MIN) return XXH_ERROR;
#endif

    if (customSeedSize == 0) {
        customSeed = XXH3_kSecret;
        customSeedSize = XXH_SECRET_DEFAULT_SIZE;
    }
#if (XXH_DEBUGLEVEL >= 1)
    XXH_ASSERT(customSeed != NULL);
#else
    if (customSeed == NULL) return XXH_ERROR;
#endif

    /* Fill secretBuffer with a copy of customSeed - repeat as needed */
    {   size_t pos = 0;
        while (pos < secretSize) {
            size_t const toCopy = XXH_MIN((secretSize - pos), customSeedSize);
            memcpy((char*)secretBuffer + pos, customSeed, toCopy);
            pos += toCopy;
    }   }

    {   size_t const nbSeg16 = secretSize / 16;
        size_t n;
        XXH128_canonical_t scrambler;
        XXH128_canonicalFromHash(&scrambler, XXH128(customSeed, customSeedSize, 0));
        for (n=0; n<nbSeg16; n++) {
            XXH128_hash_t const h128 = XXH128(&scrambler, sizeof(scrambler), n);
            XXH3_combine16((char*)secretBuffer + n*16, h128);
        }
        /* last segment */
        XXH3_combine16((char*)secretBuffer + secretSize - 16, XXH128_hashFromCanonical(&scrambler));
    }
    return XXH_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
testq %rdi, %rdi
sete %al
cmpq $0x88, %rsi
setb %dl
orb %al, %dl
movl $0x1, %eax
jne 0x4646
testq %rcx, %rcx
movl $0xc0, %r12d
cmovneq %rcx, %r12
leaq 0x2b08(%rip), %rcx      # 0x7080
cmoveq %rcx, %r15
testq %r15, %r15
je 0x4646
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
movq %rbx, %r13
subq %rbp, %r13
cmpq %r12, %r13
cmovaeq %r12, %r13
leaq (%r14,%rbp), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2120
addq %r13, %rbp
cmpq %rbx, %rbp
jb 0x458d
movq %rbx, %r13
shrq $0x4, %r13
leaq 0x2ac1(%rip), %rcx      # 0x7080
leaq -0x366(%rip), %r9       # 0x4260
xorl %ebp, %ebp
movl $0xc0, %r8d
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3cd4
bswapq %rdx
bswapq %rax
leaq 0x8(%rsp), %r15
movq %rdx, (%r15)
movq %rax, 0x8(%r15)
leaq 0x8(%r14), %r12
movl $0x10, %esi
movl $0xc0, %r8d
movq %r15, %rdi
movq %rbp, %rdx
leaq 0x2a77(%rip), %rcx      # 0x7080
leaq -0x3b0(%rip), %r9       # 0x4260
callq 0x3cd4
xorq %rax, -0x8(%r12)
xorq %rdx, (%r12)
incq %rbp
addq $0x10, %r12
cmpq %rbp, %r13
jne 0x45f1
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
bswapq %rax
bswapq %rcx
xorq %rcx, -0x10(%r14,%rbx)
xorq %rax, -0x8(%r14,%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_generateSecret_fromSeed
XXH_PUBLIC_API void
XXH3_generateSecret_fromSeed(void* secretBuffer, XXH64_hash_t seed)
{
    XXH_ALIGN(XXH_SEC_ALIGN) xxh_u8 secret[XXH_SECRET_DEFAULT_SIZE];
    XXH3_initCustomSecret(secret, seed);
    XXH_ASSERT(secretBuffer != NULL);
    memcpy(secretBuffer, secret, XXH_SECRET_DEFAULT_SIZE);
}

// Assembly:
subq $0xc8, %rsp
movl $0x8, %eax
leaq 0x2a18(%rip), %rcx      # 0x7080
movq -0x8(%rax,%rcx), %rdx
addq %rsi, %rdx
movq (%rax,%rcx), %r8
subq %rsi, %r8
movq %rdx, -0x8(%rsp,%rax)
movq %r8, (%rsp,%rax)
addq $0x10, %rax
cmpq $0xc8, %rax
jne 0x4668
movq %rsp, %rsi
movl $0xc0, %edx
callq 0x2120
addq $0xc8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_len_4to8_64b(unsigned char const*, unsigned long, unsigned char const*, unsigned long)
static xxh_u32 XXH_swap32 (xxh_u32 x)
{
    return  ((x << 24) & 0xff000000 ) |
            ((x <<  8) & 0x00ff0000 ) |
            ((x >>  8) & 0x0000ff00 ) |
            ((x >> 24) & 0x000000ff );
}

// Assembly:
movl %r8d, %eax
bswapl %eax
shlq $0x20, %rax
xorq %r8, %rax
movl -0x4(%rdi,%rsi), %r8d
xorq %rcx, %rdx
subq %rax, %rdx
movl (%rdi), %eax
shlq $0x20, %rax
orq %r8, %rax
xorq %rdx, %rax
movq %rax, %rcx
rolq $0x31, %rcx
movq %rax, %rdx
rolq $0x18, %rdx
xorq %rcx, %rdx
xorq %rax, %rdx
movabsq $-0x604de39ae16720db, %rax # imm = 0x9FB21C651E98DF25
imulq %rax, %rdx
movq %rdx, %rcx
shrq $0x23, %rcx
addq %rsi, %rcx
xorq %rdx, %rcx
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x1c, %rax
xorq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movzbl (%rdi), %eax
movq %rsi, %r9
shrq %r9
movzbl -0x1(%rdi,%rsi), %r10d
shll $0x10, %eax
movzbl (%rdi,%r9), %edi
shll $0x18, %edi
shll $0x8, %esi
orl %eax, %esi
orl %edi, %esi
xorl %ecx, %edx
leaq (%rdx,%r8), %rax
orq %rsi, %r10
movq %rax, %rcx
shrq $0x21, %rcx
xorq %rax, %rcx
xorq %r10, %rcx
movabsq $-0x3d4d51c2d82b14b1, %rax # imm = 0xC2B2AE3D27D4EB4F
imulq %rcx, %rax
movq %rax, %rcx
shrq $0x1d, %rcx
xorq %rax, %rcx
movabsq $0x165667b19e3779f9, %rdx # imm = 0x165667B19E3779F9
imulq %rcx, %rdx
movq %rdx, %rax
shrq $0x20, %rax
xorq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH128_mix32B(XXH128_hash_t, unsigned char const*, unsigned char const*, unsigned char const*, unsigned long)
XXH_FORCE_INLINE XXH128_hash_t
XXH128_mix32B(XXH128_hash_t acc, const xxh_u8* input_1, const xxh_u8* input_2,
              const xxh_u8* secret, XXH64_hash_t seed)
{
    acc.low64  += XXH3_mix16B (input_1, secret+0, seed);
    acc.low64  ^= XXH_readLE64(input_2) + XXH_readLE64(input_2 + 8);
    acc.high64 += XXH3_mix16B (input_2, secret+16, seed);
    acc.high64 ^= XXH_readLE64(input_1) + XXH_readLE64(input_1 + 8);
    return acc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r10
movq 0x20(%rsp), %r15
movq 0x28(%rsp), %r14
movq (%r15), %rdx
addq %r14, %rdx
xorq %r10, %rdx
movq 0x8(%r15), %rax
movq 0x18(%r15), %rbx
subq %r14, %rax
xorq %rcx, %rax
mulq %rdx
movq %rax, %r11
xorq %rdx, %r11
addq %rdi, %r11
leaq (%r9,%r8), %rax
xorq %rax, %r11
subq %r14, %rbx
addq 0x10(%r15), %r14
xorq %r8, %r14
xorq %r9, %rbx
movq %rbx, %rax
mulq %r14
xorq %rax, %rdx
addq %rsi, %rdx
addq %rcx, %r10
xorq %r10, %rdx
movq %r11, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_hashLong_128b_internal(void const*, unsigned long, unsigned char const*, unsigned long, void (*)(void*, void const*, void const*), void (*)(void*, void const*))
XXH_FORCE_INLINE XXH128_hash_t
XXH3_hashLong_128b_internal(const void* XXH_RESTRICT input, size_t len,
                            const xxh_u8* 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, secret, secretSize, f_acc512, f_scramble);

    /* converge into final hash */
    XXH_STATIC_ASSERT(sizeof(acc) == 64);
    XXH_ASSERT(secretSize >= sizeof(acc) + XXH_SECRET_MERGEACCS_START);
    {   XXH128_hash_t h128;
        h128.low64  = XXH3_mergeAccs(acc,
                                     secret + XXH_SECRET_MERGEACCS_START,
                                     (xxh_u64)len * XXH_PRIME64_1);
        h128.high64 = XXH3_mergeAccs(acc,
                                     secret + secretSize
                                            - sizeof(acc) - XXH_SECRET_MERGEACCS_START,
                                     ~((xxh_u64)len * XXH_PRIME64_2));
        return h128;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rsi
movaps 0x1d55(%rip), %xmm0     # 0x7170
movq %rsp, %rbx
movaps %xmm0, 0x30(%rbx)
movaps 0x1d37(%rip), %xmm0     # 0x7160
movaps %xmm0, 0x20(%rbx)
movaps 0x1d1c(%rip), %xmm0     # 0x7150
movaps %xmm0, 0x10(%rbx)
movaps 0x1d01(%rip), %xmm0     # 0x7140
movaps %xmm0, (%rbx)
movq %rbx, %rdi
movq %r14, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x5049
leaq 0xb(%r12), %rsi
movabsq $-0x61c8864e7a143579, %rdx # imm = 0x9E3779B185EBCA87
imulq %r14, %rdx
movq %rbx, %rdi
callq 0x3bf9
movq %rax, %r13
leaq (%r12,%r15), %rsi
addq $-0x4b, %rsi
movabsq $-0x3d4d51c2d82b14b1, %rdx # imm = 0xC2B2AE3D27D4EB4F
imulq %r14, %rdx
notq %rdx
movq %rbx, %rdi
callq 0x3bf9
movq %rax, %rdx
movq %r13, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/sgielen[P]clife/./clife.hpp
// Function: GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>::generateRandom(int)
void generateRandom(int chance_set) {
		if(chance_set < 0 || chance_set > 100) {
			throw std::runtime_error("Out of bounds");
		}
		for(int i = 0; i < height; ++i) {
			for(int j = 0; j < width; ++j) {
				field[i * width + j] = ValueType(rand() % 100 < chance_set ? true : false);
			}
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x64, %esi
ja 0x5525
movq %rdi, %r14
movl 0x18(%rdi), %ecx
testl %ecx, %ecx
jle 0x5519
movl %esi, %ebx
movl 0x1c(%r14), %eax
xorl %r15d, %r15d
testl %eax, %eax
jle 0x5511
xorl %r12d, %r12d
callq 0x2040
movslq %eax, %rcx
imulq $0x51eb851f, %rcx, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %eax
subl %eax, %ecx
movl 0x1c(%r14), %eax
movl %r15d, %edx
imull %eax, %edx
movslq %edx, %rdx
addq (%r14), %rdx
cmpl %ebx, %ecx
setl (%r12,%rdx)
incq %r12
cmpl %eax, %r12d
jl 0x54cd
movl 0x18(%r14), %ecx
incl %r15d
cmpl %ecx, %r15d
jl 0x54c6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x2090
movq %rax, %rbx
leaq 0x1c92(%rip), %rsi      # 0x71cb
movq %rax, %rdi
callq 0x2070
movq 0x4aa8(%rip), %rsi      # 0x9ff0
movq 0x4a71(%rip), %rdx      # 0x9fc0
movq %rbx, %rdi
callq 0x2200
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/sgielen[P]clife/./clife.hpp
// Function: GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>::nextState()
void nextState() {
		std::vector<ValueType> new_field(width * height, ValueType());
		std::vector<ValueType> neighbors;
		for(int y = 0; y < height; ++y) {
			for(int x = 0; x < width; ++x) {
				neighbors.clear();
				neighbors_set(y, x, neighbors);
				int num = neighbors.size();
				bool set = is_set(y, x);
				if(set && (num == 2 || num == 3)) {
					new_field[y * width + x] = field[y * width + x];
					new_field[y * width + x].age_once();
				} else if(num == 3) {
					new_field[y * width + x] = ValueType(neighbors);
				}
			}
		}
		field = new_field;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movslq 0x1c(%rdi), %rax
movslq 0x18(%rdi), %rsi
imulq %rax, %rsi
leaq 0x10(%rsp), %r14
movb $0x0, (%r14)
leaq 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movq %r14, %rdx
callq 0x5912
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movl 0x18(%rbx), %ecx
testl %ecx, %ecx
jle 0x5784
movl 0x1c(%rbx), %eax
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
testl %eax, %eax
jle 0x5778
movslq %r14d, %rbp
xorl %r13d, %r13d
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x56ce
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
movl %r14d, %esi
movl %r13d, %edx
movq %r15, %rcx
callq 0x59e4
movl 0x18(%rsp), %r12d
subl 0x10(%rsp), %r12d
movq %rbx, %rdi
movl %r14d, %esi
movl %r13d, %edx
callq 0x5972
movl %r12d, %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
setne %cl
xorb $0x1, %al
orb %cl, %al
jne 0x5729
movl 0x1c(%rbx), %eax
imull %r14d, %eax
cltq
movq (%rbx), %rcx
addq %rax, %rcx
addq 0x28(%rsp), %rax
movb (%r13,%rcx), %cl
movb %cl, (%r13,%rax)
jmp 0x5766
cmpl $0x3, %r12d
jne 0x5766
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0x588c
movslq 0x1c(%rbx), %rax
imulq %rbp, %rax
addq 0x28(%rsp), %rax
movb $0x1, (%r13,%rax)
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x5766
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movl 0x1c(%rbx), %eax
incq %r13
cmpl %eax, %r13d
jl 0x56bd
movl 0x18(%rbx), %ecx
incl %r14d
cmpl %ecx, %r14d
jl 0x56af
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x5b60
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x57a8
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x57bf
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x57d4
jmp 0x57d4
jmp 0x57d4
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x57ee
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x5805
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/sgielen[P]clife/multi_indep.cpp
// Function: void check_stop_condition<GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>>(GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>, std::vector<unsigned long, std::allocator<unsigned long>>&, bool&, int&)
void check_stop_condition(FieldType field, std::vector<uint64_t> &earlier_hashes, bool &done, int &repeats_to_do) {
	uint64_t hash = field.field_hash();
	for(size_t i = 0; i < earlier_hashes.size(); ++i) {
		if(earlier_hashes[i] == hash) {
			done = true;
			repeats_to_do = 10;
			break;
		}
	}
	earlier_hashes.push_back(hash);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
callq 0x5df0
movq %rax, 0x8(%rsp)
movq (%rbx), %rcx
movq 0x8(%rbx), %rsi
movq %rsi, %rdx
subq %rcx, %rdx
je 0x5861
sarq $0x3, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %edi, %edi
cmpq %rax, (%rcx,%rdi,8)
je 0x5856
incq %rdi
cmpq %rdi, %rdx
jne 0x5846
jmp 0x5861
movb $0x1, (%r15)
movl $0xa, (%r14)
cmpq 0x10(%rbx), %rsi
je 0x5874
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x5881
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x5f04
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sgielen[P]clife/./clife.hpp
// Function: GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>::field_hash() const
uint64_t field_hash() const {
                XXH3_state_t state;
                XXH3_64bits_reset(&state);
                for(auto const &cell : field) {
                        bool value = bool(cell);
                        XXH3_64bits_update(&state, &value, sizeof(value));
                }
                return XXH3_64bits_digest(&state);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
andq $-0x40, %rsp
subq $0x2c0, %rsp            # imm = 0x2C0
xorps %xmm0, %xmm0
movaps %xmm0, 0x240(%rsp)
xorl %eax, %eax
movq %rax, 0x250(%rsp)
movl $0x85ebca77, %ecx       # imm = 0x85EBCA77
leaq 0x3cc6e3c6(%rcx), %rdx
movq %rdx, 0x40(%rsp)
movabsq $-0x61c8864e7a143579, %rdx # imm = 0x9E3779B185EBCA87
movq %rdx, 0x48(%rsp)
movabsq $-0x3d4d51c2d82b14b1, %rdx # imm = 0xC2B2AE3D27D4EB4F
movq %rdx, 0x50(%rsp)
movabsq $0x165667b19e3779f9, %rdx # imm = 0x165667B19E3779F9
movq %rdx, 0x58(%rsp)
movabsq $-0x7a1435883d4d519d, %rdx # imm = 0x85EBCA77C2B2AE63
movq %rdx, 0x60(%rsp)
movq %rcx, 0x68(%rsp)
movabsq $0x27d4eb2f165667c5, %rdx # imm = 0x27D4EB2F165667C5
movq %rdx, 0x70(%rsp)
addq $0x184baf3a, %rcx       # imm = 0x184BAF3A
movq %rcx, 0x78(%rsp)
movq %rax, 0x268(%rsp)
leaq 0x11e9(%rip), %rax      # 0x7080
movq %rax, 0x278(%rsp)
movq $0x80, 0x260(%rsp)
movq $0x10, 0x258(%rsp)
movq (%rdi), %r15
movq 0x8(%rdi), %r12
cmpq %r12, %r15
je 0x5eec
leaq 0x40(%rsp), %rbx
leaq 0x3f(%rsp), %r14
movb (%r15), %al
movb %al, 0x3f(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35ef
incq %r15
cmpq %r12, %r15
jne 0x5ecd
leaq 0x40(%rsp), %rdi
callq 0x39ce
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/SaadBazaz[P]RIP-Protocol-Simulation/./RoutingTable.h
// Function: tokenizeData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
std::vector<std::string> tokenizeData (std::string buffer, char delimiter = ','){
		std::stringstream ss(buffer); 
	    std::vector<std::string> v; 
	  
		while (ss.good()) { 
		    std::string substr; 
		    getline(ss, substr, delimiter); 
		    v.push_back(substr); 
		} 
		
		return v;		
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x22c0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x48(%rsp,%rax)
jne 0x2543
leaq 0x18(%rsp), %r12
movsbl %bpl, %ebp
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %r12, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x2300
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4360
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2533
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x48(%rsp,%rax)
je 0x24f1
movq 0x7a6e(%rip), %rsi      # 0x9fb8
leaq 0x28(%rsp), %rdi
callq 0x2170
leaq 0xa8(%rsp), %rdi
callq 0x20a0
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x258e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x439e
movq 0x7a1b(%rip), %rsi      # 0x9fb8
leaq 0x28(%rsp), %rdi
callq 0x2170
leaq 0xa8(%rsp), %rdi
callq 0x20a0
movq %r14, %rdi
callq 0x22e0