LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %edx, %edx
leaq 0x1e35(%rip), %r14      # 0x533d
movq (%r12), %rax
leaq 0x3(%rax), %rcx
cmpq %r15, %rcx
jae 0x3565
cmpb $-0x1, 0x4(%rax)
je 0x3565
movzbl (%rax), %esi
movzbl 0x1(%rax), %edx
leaq 0x2(%rax), %rdi
movq %rdi, (%r12)
movzbl 0x2(%rax), %edi
cmpw $0xe0, %di
jb 0x3573
addq $0x4, %rax
movzwl %si, %r8d
shll $0x8, %r8d
movzwl %dx, %esi
orl %r8d, %esi
movzwl %di, %edi
andl $0x1f, %edi
shll $0x8, %edi
movzbl (%rcx), %edx
orl %edi, %edx
movq %rax, (%r12)
movq %rbx, %rdi
callq 0x35b6
movb $0x1, %dl
jmp 0x3508
movb $0x1, %al
testb $0x1, %dl
jne 0x35aa
leaq 0x1de6(%rip), %r14      # 0x5359
movq 0x4a76(%rip), %rdi      # 0x7ff0
leaq 0x1cf1(%rip), %rsi      # 0x5272
callq 0x2110
movq 0x90(%rbx), %rsi
movq %rax, %rdi
callq 0x20a0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2110
movq %rax, %rdi
callq 0x2080
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mmoanis[P]mpegts_demux/MpegTsDemux.cpp
// Function: MpegTsDemuxer::RegisterProgram(unsigned short, unsigned short)
void MpegTsDemuxer::RegisterProgram(PID id, PID pid)
{
    assert(id != MPEGTS_PID_NULL);

    Programs::iterator p = m_programs.find(id);
    if (p == m_programs.end()) {
        cout << "[INFO]: PKT#" << m_pnum << " PROGRAM=" << id << " PMT=" << pid << endl;

        Program P;
        P.id = id;
        P.pid = pid;
        m_programs.insert(make_pair(id, P));

        // expect packet for PMT
        m_filters.insert( make_pair(pid, DEMUXER_EVENT_PMT) );
    } else {
        if (p->second.pid != pid) {
            // Support updating program information
            cout << "[WARNING]: PKT#" << m_pnum << " PROGRAM=" << id << " PMT=" << p->second.pid << " appeared with PMT=" << pid <<  endl;
            p->second.pid = pid;

            // expect packet for PMT
            m_filters.insert( make_pair(pid, DEMUXER_EVENT_PMT) );
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movw %si, 0xe(%rsp)
cmpl $0x1fff, %esi           # imm = 0x1FFF
je 0x374a
movl %edx, %ebp
movq %rdi, %rbx
leaq 0xe(%rsp), %rsi
callq 0x3e6c
movq %rax, %r14
leaq 0x8(%rbx), %rax
cmpq %rax, %r14
je 0x3696
cmpw %bp, 0x24(%r14)
je 0x373f
movq 0x49ce(%rip), %rdi      # 0x7fd0
leaq 0x1da4(%rip), %rsi      # 0x53ad
callq 0x2110
movq 0x90(%rbx), %rsi
movq %rax, %rdi
callq 0x20a0
leaq 0x1e63(%rip), %rsi      # 0x5487
movq %rax, %rdi
callq 0x2110
movzwl 0xe(%rsp), %esi
movq %rax, %rdi
callq 0x21d0
leaq 0x1f9a(%rip), %rsi      # 0x55da
movq %rax, %rdi
callq 0x2110
movzwl 0x24(%r14), %esi
movq %rax, %rdi
callq 0x21d0
leaq 0x1f70(%rip), %rsi      # 0x55cc
movq %rax, %rdi
callq 0x2110
movzwl %bp, %r15d
movq %rax, %rdi
movl %r15d, %esi
callq 0x21d0
movq %rax, %rdi
callq 0x2080
movw %r15w, 0x24(%r14)
addq $0x60, %rbx
btsq $0x20, %r15
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
jmp 0x3737
movq 0x4933(%rip), %rdi      # 0x7fd0
leaq 0x1f1b(%rip), %rsi      # 0x55bf
callq 0x2110
movq 0x90(%rbx), %rsi
movq %rax, %rdi
callq 0x20a0
leaq 0x1dc8(%rip), %rsi      # 0x5487
movq %rax, %rdi
callq 0x2110
movzwl 0xe(%rsp), %esi
movq %rax, %rdi
callq 0x21d0
leaq 0x1eff(%rip), %rsi      # 0x55da
movq %rax, %rdi
callq 0x2110
movzwl %bp, %r14d
movq %rax, %rdi
movl %r14d, %esi
callq 0x21d0
movq %rax, %rdi
callq 0x2080
movzwl 0xe(%rsp), %eax
movl %r14d, %ecx
shll $0x10, %ecx
addl %eax, %ecx
shlq $0x10, %rcx
orq %rax, %rcx
leaq 0x10(%rsp), %r15
movw %bp, 0x4(%r15)
movl %ecx, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3f18
addq $0x60, %rbx
btsq $0x20, %r14
movq %r14, (%r15)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x409c
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e2a(%rip), %rdi      # 0x557b
leaq 0x1a80(%rip), %rsi      # 0x51d8
leaq 0x1e32(%rip), %rcx      # 0x5591
movl $0x1d1, %edx            # imm = 0x1D1
callq 0x2090
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2646
movdqu 0x8(%rsi), %xmm0
movdqa 0x3a34(%rip), %xmm1     # 0x6030
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 0x264e
movl $0x165667b1, %edi       # imm = 0x165667B1
addl 0x10(%rsi), %edi
addl (%rsi), %edi
movl 0x28(%rsi), %edx
addq $0x18, %rsi
jmp 0x2659
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movabsq $-0x3d4d51c2d82b14b1, %r8 # imm = 0xC2B2AE3D27D4EB4F
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
movl %edx, %r9d
andl $0x1f, %r9d
andl $0x18, %edx
movq %r9, %rcx
subq %rdx, %rcx
movabsq $-0x7a1435883d4d519d, %r10 # imm = 0x85EBCA77C2B2AE63
movq %rsi, %r11
cmpq $0x8, %r9
jb 0x2b7b
movq (%r11), %rbx
imulq %r8, %rbx
rolq $0x1f, %rbx
imulq %rax, %rbx
addq $0x8, %r11
xorq %rdi, %rbx
rolq $0x1b, %rbx
imulq %rax, %rbx
addq %r10, %rbx
addq $-0x8, %r9
movq %rbx, %rdi
jmp 0x2b4b
addq %rdx, %rsi
cmpq $0x4, %rcx
jb 0x2baa
movl (%rsi), %edx
imulq %rax, %rdx
xorq %rdi, %rdx
addq $0x4, %rsi
rolq $0x17, %rdx
imulq %r8, %rdx
movabsq $0x165667b19e3779f9, %rdi # imm = 0x165667B19E3779F9
addq %rdx, %rdi
addq $-0x4, %rcx
xorl %edx, %edx
movabsq $0x27d4eb2f165667c5, %r8 # imm = 0x27D4EB2F165667C5
cmpq %rdx, %rcx
je 0x2bd7
movzbl (%rsi,%rdx), %r9d
imulq %r8, %r9
xorq %rdi, %r9
rolq $0xb, %r9
imulq %rax, %r9
incq %rdx
movq %r9, %rdi
jmp 0x2bb6
popq %rbx
jmp 0x43b2
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2190
testq %rax, %rax
je 0x2fdc
movl %eax, %edx
andl $0x3f, %edx
pushq $0x40
popq %rsi
subq %rdx, %rsi
movq %rax, %rcx
addq %rsi, %rcx
negq %rdx
movb %sil, 0x3f(%rax,%rdx)
andq $0x0, 0x228(%rax,%rsi)
jmp 0x2fde
xorl %ecx, %ecx
movq %rcx, %rax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
andq $0x0, 0x210(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x200(%rdi)
movl $0x85ebca77, %eax       # imm = 0x85EBCA77
leaq 0x3cc6e3c6(%rax), %r8
movq %r8, (%rdi)
movabsq $-0x61c8864e7a143579, %r8 # imm = 0x9E3779B185EBCA87
movq %r8, 0x8(%rdi)
movabsq $-0x3d4d51c2d82b14b1, %r8 # imm = 0xC2B2AE3D27D4EB4F
movq %r8, 0x10(%rdi)
movabsq $0x165667b19e3779f9, %r8 # imm = 0x165667B19E3779F9
movq %r8, 0x18(%rdi)
movabsq $-0x7a1435883d4d519d, %r8 # imm = 0x85EBCA77C2B2AE63
movq %r8, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movabsq $0x27d4eb2f165667c5, %r8 # imm = 0x27D4EB2F165667C5
movq %r8, 0x30(%rdi)
addq $0x184baf3a, %rax       # imm = 0x184BAF3A
movq %rax, 0x38(%rdi)
movq %rsi, 0x228(%rdi)
xorl %eax, %eax
testq %rsi, %rsi
setne %al
movl %eax, 0x204(%rdi)
movq %rdx, 0x238(%rdi)
addq $-0x40, %rcx
movq %rcx, 0x220(%rdi)
shrq $0x3, %rcx
movq %rcx, 0x218(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq $0x1
popq %rbx
testq %rdi, %rdi
je 0x3103
movq %rdx, %r14
movq %rsi, %r15
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x302a
testq %r15, %r15
je 0x3103
xorl %ebx, %ebx
cmpq $0x88, %r14
setb %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3156
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x3163
cmpq %rbx, 0x228(%r14)
jne 0x3133
cmpq $0x0, 0x238(%r14)
je 0x313f
leaq 0x40(%r14), %rdi
movq %rbx, %rsi
callq 0x3170
xorl %r15d, %r15d
movl $0xc0, %ecx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x302a
jmp 0x315a
pushq $0x1
popq %r15
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3006
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdx, %rax
movq %rsi, %rdx
movq %rdi, %rbx
testq %rdi, %rdi
sete %sil
testq %rdx, %rdx
sete %dil
orb %sil, %dil
cmpq $0x88, %rax
setb %sil
orb %dil, %sil
je 0x31d0
pushq $0x1
popq %rax
jmp 0x31ea
movq %rbx, %rdi
movq %rcx, %rsi
movq %rax, %rcx
callq 0x302a
movl $0x1, 0x204(%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq 0x210(%rdi), %rsi
movq 0x238(%rdi), %rax
leaq 0x40(%rdi), %rbx
testq %rax, %rax
cmovneq %rax, %rbx
cmpq $0xf1, %rsi
jb 0x3573
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x35b5
addq $0xb, %rbx
movabsq $-0x61c8864e7a143579, %rdx # imm = 0x9E3779B185EBCA87
imulq 0x210(%r14), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x36bd
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x100(%r14), %rdi
cmpl $0x0, 0x204(%r14)
je 0x3599
movq 0x228(%r14), %rdx
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2f20
movq 0x220(%r14), %rcx
addq $0x40, %rcx
movq %rbx, %rdx
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2f01
// File: /workspace/github_cpp_makefile_star2_O2/sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_digest_long(unsigned long*, XXH3_state_s const*, unsigned char const*)
XXH_FORCE_INLINE void
XXH3_digest_long (XXH64_hash_t* acc,
                  const XXH3_state_t* state,
                  const unsigned char* secret)
{
    /*
     * Digest on a local copy. This way, the state remains unaltered, and it can
     * continue ingesting more input afterwards.
     */
    XXH_memcpy(acc, state->acc, sizeof(state->acc));
    if (state->bufferedSize >= XXH_STRIPE_LEN) {
        size_t const nbStripes = (state->bufferedSize - 1) / XXH_STRIPE_LEN;
        size_t nbStripesSoFar = state->nbStripesSoFar;
        XXH3_consumeStripes(acc,
                           &nbStripesSoFar, state->nbStripesPerBlock,
                            state->buffer, nbStripes,
                            secret, state->secretLimit,
                            XXH3_accumulate_512, XXH3_scrambleAcc);
        /* last stripe */
        XXH3_accumulate_512(acc,
                            state->buffer + state->bufferedSize - XXH_STRIPE_LEN,
                            secret + state->secretLimit - XXH_SECRET_LASTACC_START);
    } else {  /* bufferedSize < XXH_STRIPE_LEN */
        xxh_u8 lastStripe[XXH_STRIPE_LEN];
        size_t const catchupSize = XXH_STRIPE_LEN - state->bufferedSize;
        XXH_ASSERT(state->bufferedSize > 0);  /* there is always some input buffered */
        XXH_memcpy(lastStripe, state->buffer + sizeof(state->buffer) - catchupSize, catchupSize);
        XXH_memcpy(lastStripe + catchupSize, state->buffer, state->bufferedSize);
        XXH3_accumulate_512(acc,
                            lastStripe,
                            secret + state->secretLimit - XXH_SECRET_LASTACC_START);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups 0x30(%rsi), %xmm3
movups %xmm3, 0x30(%rdi)
movups %xmm2, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movl 0x200(%rsi), %r12d
cmpq $0x40, %r12
jb 0x365a
decl %r12d
shrl $0x6, %r12d
movq 0x208(%r15), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x100(%r15), %rcx
movq 0x218(%r15), %rdx
movq 0x220(%r15), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r12, %r8
movq %r14, %r9
callq 0x4599
movl 0x200(%r15), %eax
leaq (%r15,%rax), %rsi
addq $0xc0, %rsi
movq 0x220(%r15), %rax
leaq (%r14,%rax), %rdx
addq $-0x7, %rdx
movq %rbx, %rdi
jmp 0x36a9
leaq 0x200(%r15), %rsi
pushq $0x40
popq %r13
subq %r12, %r13
leaq 0x100(%r15), %rbp
subq %r13, %rsi
leaq 0x10(%rsp), %rdi
movq %r13, %rdx
callq 0x2110
leaq (%rsp,%r13), %rdi
addq $0x10, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x2110
movq 0x220(%r15), %rax
leaq (%r14,%rax), %rdx
addq $-0x7, %rdx
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
callq 0x3487
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq 0x210(%rdi), %rsi
movq 0x238(%rdi), %rax
leaq 0x40(%rdi), %rbx
testq %rax, %rax
cmovneq %rax, %rbx
cmpq $0xf1, %rsi
jb 0x3cff
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x35b5
leaq 0xb(%rbx), %rsi
movq 0x210(%r14), %r13
movabsq $-0x61c8864e7a143579, %rdx # imm = 0x9E3779B185EBCA87
imulq %r13, %rdx
movq %r12, %rdi
callq 0x36bd
movq %rax, %r15
movq 0x220(%r14), %rax
leaq (%rbx,%rax), %rsi
addq $-0xb, %rsi
movabsq $-0x3d4d51c2d82b14b1, %rdx # imm = 0xC2B2AE3D27D4EB4F
imulq %r13, %rdx
notq %rdx
movq %r12, %rdi
callq 0x36bd
movq %rax, %rdx
jmp 0x3d2f
movq 0x228(%r14), %rdx
leaq 0x100(%r14), %rdi
testq %rdx, %rdx
je 0x3d19
callq 0x3b98
jmp 0x3d2c
movq 0x220(%r14), %rcx
addq $0x40, %rcx
movq %rbx, %rdx
callq 0x3b79
movq %rax, %r15
movq %r15, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3d91
retq
movq (%rdi), %rcx
xorl %eax, %eax
cmpq (%rsi), %rcx
seta %al
sbbl $0x0, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rdx, %r15
testq %rdi, %rdi
sete %al
cmpq $0x88, %rsi
setb %dl
orb %al, %dl
pushq $0x1
popq %rax
jne 0x3eb1
testq %rcx, %rcx
movl $0xc0, %r13d
cmovneq %rcx, %r13
leaq 0x2284(%rip), %rcx      # 0x6080
cmoveq %rcx, %r15
testq %r15, %r15
je 0x3eb1
movq %rsi, %rbp
movq %rdi, %r14
xorl %ebx, %ebx
movq %rbp, %r12
subq %rbx, %r12
jbe 0x3e34
cmpq %r13, %r12
cmovaeq %r13, %r12
leaq (%r14,%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2110
addq %r12, %rbx
jmp 0x3e11
movq %rbp, %rbx
shrq $0x4, %rbx
xorl %r12d, %r12d
movq %r15, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x3b98
movq %rax, %rcx
movq %rdx, 0x8(%rsp)
movq %rdx, %rax
bswapq %rax
movq %rcx, 0x10(%rsp)
bswapq %rcx
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rdx)
leaq 0x8(%r14), %r13
pushq $0x10
popq %r15
cmpq %r12, %rbx
je 0x3e9b
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3b98
xorq %rax, -0x8(%r13)
xorq %rdx, (%r13)
incq %r12
addq $0x10, %r13
jmp 0x3e75
movq 0x10(%rsp), %rax
xorq %rax, -0x10(%r14,%rbp)
movq 0x8(%rsp), %rax
xorq %rax, -0x8(%r14,%rbp)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movaps 0x1d4c(%rip), %xmm0     # 0x6170
movq %rsp, %r15
movaps %xmm0, 0x30(%r15)
movaps 0x1d2d(%rip), %xmm0     # 0x6160
movaps %xmm0, 0x20(%r15)
movaps 0x1d11(%rip), %xmm0     # 0x6150
movaps %xmm0, 0x10(%r15)
movaps 0x1cf5(%rip), %xmm0     # 0x6140
movaps %xmm0, (%r15)
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x4484
addq $0xb, %rbx
movabsq $-0x61c8864e7a143579, %rdx # imm = 0x9E3779B185EBCA87
imulq %r14, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x36bd
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, (%rsp)
movq %rdx, %rdi
movq %r8, %rsi
movq %r9, %rdx
callq 0x43ed
movq %rax, %rbp
addq (%rsp), %rbp
movq 0x8(%r12), %rax
addq (%r12), %rax
xorq %rax, %rbp
addq $0x10, %r15
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x43ed
movq 0x8(%r13), %rdx
addq (%r13), %rdx
addq %rax, %rbx
xorq %rbx, %rdx
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1ab0(%rip), %xmm0     # 0x6170
movq %rsp, %rbx
movaps %xmm0, 0x30(%rbx)
movaps 0x1a92(%rip), %xmm0     # 0x6160
movaps %xmm0, 0x20(%rbx)
movaps 0x1a77(%rip), %xmm0     # 0x6150
movaps %xmm0, 0x10(%rbx)
movaps 0x1a5c(%rip), %xmm0     # 0x6140
movaps %xmm0, (%rbx)
movq %rbx, %rdi
movq %r14, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x4484
leaq 0xb(%r12), %rsi
movabsq $-0x61c8864e7a143579, %rdx # imm = 0x9E3779B185EBCA87
imulq %r14, %rdx
movq %rbx, %rdi
callq 0x36bd
movq %rax, %r13
leaq (%r12,%r15), %rsi
addq $-0x4b, %rsi
movabsq $-0x3d4d51c2d82b14b1, %rdx # imm = 0xC2B2AE3D27D4EB4F
imulq %r14, %rdx
notq %rdx
movq %rbx, %rdi
callq 0x36bd
movq %rax, %rdx
movq %r13, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x64, %esi
ja 0x47e2
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
pushq $0x64
popq %rbp
cmpl 0x18(%r14), %r15d
jge 0x47d9
movl 0x1c(%r14), %eax
xorl %r12d, %r12d
cmpl %eax, %r12d
jge 0x47d4
callq 0x2030
cltd
idivl %ebp
movl 0x1c(%r14), %eax
movl %r15d, %ecx
imull %eax, %ecx
movslq %ecx, %rcx
addq (%r14), %rcx
cmpl %ebx, %edx
setl (%r12,%rcx)
incq %r12
jmp 0x47ab
incl %r15d
jmp 0x479e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x2090
movq %rax, %rbx
leaq 0x19d7(%rip), %rsi      # 0x61cb
movq %rax, %rdi
callq 0x2060
movq 0x47ed(%rip), %rsi      # 0x8ff0
movq 0x47b6(%rip), %rdx      # 0x8fc0
movq %rbx, %rdi
callq 0x21e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/sgielen[P]clife/multi_indep.cpp
// Function: void print_rgb<SimpleValue<(char)-128, (char)0>>(GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>, GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>, GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>)
void print_rgb(GameOfLifeField<ValueType> red, GameOfLifeField<ValueType> green, GameOfLifeField<ValueType> blue) {
	char on = 0x80;
	char off = 0x00;
	for(int y = 0; y < red.get_height(); ++y) {
		for(int x = 0; x < red.get_width(); ++x) {
			std::cout << (red.is_set(y, x) ? on : off);
			std::cout << (green.is_set(y, x) ? on : off);
			std::cout << (blue.is_set(y, x) ? on : off);
		}
	}
	std::cout << std::flush;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movq 0x4786(%rip), %r12      # 0x8fc8
cmpl 0x18(%r15), %ebp
jge 0x48ba
xorl %r13d, %r13d
cmpl 0x1c(%r15), %r13d
jge 0x48b6
movq %r15, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x4c56
xorb $0x1, %al
movzbl %al, %esi
shll $0x7, %esi
addl $-0x80, %esi
movq %r12, %rdi
callq 0x2170
movq %r14, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x4c56
xorb $0x1, %al
movzbl %al, %esi
shll $0x7, %esi
addl $-0x80, %esi
movq %r12, %rdi
callq 0x2170
movq %rbx, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x4c56
xorb $0x1, %al
movzbl %al, %esi
shll $0x7, %esi
addl $-0x80, %esi
movq %r12, %rdi
callq 0x2170
incl %r13d
jmp 0x484b
incl %ebp
jmp 0x4842
movq 0x4707(%rip), %rdi      # 0x8fc8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x68, %rsp
movq %rdi, %rbx
movslq 0x1c(%rdi), %rax
movslq 0x18(%rdi), %rsi
imulq %rax, %rsi
leaq 0x10(%rsp), %r14
movb $0x0, (%r14)
leaq 0x38(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movq %r14, %rdx
callq 0x4bc4
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
xorl %r15d, %r15d
leaq 0x50(%rsp), %rbp
cmpl 0x18(%rbx), %r15d
jge 0x4a0c
movslq %r15d, %rax
movq %rax, 0x30(%rsp)
xorl %r13d, %r13d
cmpl 0x1c(%rbx), %r13d
jge 0x4a04
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x4970
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
movl %r15d, %esi
movl %r13d, %edx
movq %r14, %rcx
callq 0x4cc6
movl 0x18(%rsp), %r12d
subl 0x10(%rsp), %r12d
movq %rbx, %rdi
movl %r15d, %esi
movl %r13d, %edx
callq 0x4c56
movl %r12d, %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
setne %cl
xorb $0x1, %al
orb %cl, %al
jne 0x49cb
movl 0x1c(%rbx), %eax
imull %r15d, %eax
cltq
movq (%rbx), %rcx
addq %rax, %rcx
addq 0x38(%rsp), %rax
movb (%r13,%rcx), %cl
movb %cl, (%r13,%rax)
jmp 0x49fc
cmpl $0x3, %r12d
jne 0x49fc
movq %rbp, %r12
movq %rbp, %rdi
movq %r14, %rsi
callq 0x4ac2
movslq 0x1c(%rbx), %rax
imulq 0x30(%rsp), %rax
addq 0x38(%rsp), %rax
movb $0x1, (%r13,%rax)
movq %r12, %rdi
callq 0x4b0c
incq %r13
jmp 0x4955
incl %r15d
jmp 0x4940
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x4d82
leaq 0x10(%rsp), %rdi
callq 0x4b0c
leaq 0x38(%rsp), %rdi
callq 0x4b0c
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4a42
jmp 0x4a42
jmp 0x4a42
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4b0c
leaq 0x38(%rsp), %rdi
callq 0x4b0c
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5020
movq %rax, 0x8(%rsp)
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x4aaa
leaq 0x1(%rsi), %rdi
cmpq %rax, (%rcx,%rsi,8)
movq %rdi, %rsi
jne 0x4a8d
movb $0x1, (%r15)
movl $0xa, (%r14)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5092
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sgielen[P]clife/./clife.hpp
// Function: GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>::neighbors_set(int, int, std::vector<SimpleValue<(char)-128, (char)0>, std::allocator<SimpleValue<(char)-128, (char)0>>>&)
void neighbors_set(int y, int x, std::vector<ValueType> &neigh) {
		add_if_inside_or_wrapping_and_set(neigh, y-1, x-1);
		add_if_inside_or_wrapping_and_set(neigh, y-1, x  );
		add_if_inside_or_wrapping_and_set(neigh, y-1, x+1);
		add_if_inside_or_wrapping_and_set(neigh, y  , x-1);
		add_if_inside_or_wrapping_and_set(neigh, y  , x+1);
		add_if_inside_or_wrapping_and_set(neigh, y+1, x-1);
		add_if_inside_or_wrapping_and_set(neigh, y+1, x  );
		add_if_inside_or_wrapping_and_set(neigh, y+1, x+1);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r12d
movl %esi, %r14d
movq %rdi, %r15
leal -0x1(%r14), %ebp
leal -0x1(%r12), %ecx
movl %ecx, 0x4(%rsp)
movq %rbx, %rsi
movl %ebp, %edx
callq 0x4e5c
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %r12d, %ecx
callq 0x4e5c
leal 0x1(%r12), %r13d
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %r13d, %ecx
callq 0x4e5c
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %edx
movl 0x4(%rsp), %ebp
movl %ebp, %ecx
callq 0x4e5c
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %edx
movl %r13d, %ecx
callq 0x4e5c
incl %r14d
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x4e5c
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %edx
movl %r12d, %ecx
callq 0x4e5c
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %edx
movl %r13d, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4e5c
nop
// File: /workspace/github_cpp_makefile_star2_O2/sgielen[P]clife/./clife.hpp
// Function: GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>::add_if_inside_or_wrapping_and_set(std::vector<SimpleValue<(char)-128, (char)0>, std::allocator<SimpleValue<(char)-128, (char)0>>>&, int, int)
void add_if_inside_or_wrapping_and_set(std::vector<ValueType> &vt, int y, int x) {
		if(wrapping) {
			y += height;
			y %= height;
			x += width;
			x %= width;
		}
		return add_if_inside_and_set(vt, y, x);
	}

// Assembly:
movl 0x18(%rdi), %r8d
movl 0x1c(%rdi), %r9d
leal (%rdx,%r8), %eax
cltd
idivl %r8d
movl %edx, %r8d
leal (%rcx,%r9), %eax
cltd
idivl %r9d
movl %edx, %ecx
movl %r8d, %edx
jmp 0x4e82
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
andq $-0x40, %rsp
subq $0x2c0, %rsp            # imm = 0x2C0
movq %rdi, %r14
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x3006
movq (%r14), %r12
movq 0x8(%r14), %r13
leaq 0x3f(%rsp), %r14
pushq $0x1
popq %r15
cmpq %r13, %r12
je 0x5078
movb (%r12), %al
movb %al, 0x3f(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x31ec
incq %r12
jmp 0x5058
leaq 0x40(%rsp), %rdi
callq 0x3509
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x18
popq %rdx
movq %r14, %rdi
callq 0x22a0
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rbx)
movups %xmm0, (%rbx)
leaq 0x18(%rsp), %r12
movsbl %bpl, %ebp
leaq 0x8(%rsp), %r15
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x48(%rsp,%rax)
jne 0x24cb
movq %r12, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x22f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3506
movq %r15, %rdi
callq 0x20c0
jmp 0x2489
leaq 0x28(%rsp), %rdi
callq 0x2150
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x3532
leaq 0x28(%rsp), %rdi
callq 0x2150
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/SaadBazaz[P]RIP-Protocol-Simulation/./RoutingTable.h
// Function: operator==(TableRow&, TableRow&)
bool operator== (TableRow &t1, TableRow &t2)
{
    return ( 
	t1.identifier == t2.identifier && 
	t1.fd == t2.fd && 
	t1.status == t2.status && 
	t1.hop_count == t2.hop_count && 
	t1.type == t2.type && 
	t1.in_use == t2.in_use && 
	t1.send_port == t2.send_port && 
	t1.receive_port == t2.receive_port 
	);
}

// Assembly:
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x256a
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rdi), %eax
cmpl 0x4(%rsi), %eax
jne 0x256d
movzwl 0x8(%r14), %eax
cmpw 0x8(%rbx), %ax
jne 0x256d
movl 0xc(%r14), %eax
cmpl 0xc(%rbx), %eax
jne 0x256d
leaq 0x10(%r14), %rdi
leaq 0x10(%rbx), %rsi
callq 0x3553
testb %al, %al
je 0x256d
movb 0x30(%r14), %al
cmpb 0x30(%rbx), %al
jne 0x256d
movl 0x34(%r14), %eax
cmpl 0x34(%rbx), %eax
jne 0x256d
movl 0x38(%r14), %eax
cmpl 0x38(%rbx), %eax
sete %al
jmp 0x256f
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/SaadBazaz[P]RIP-Protocol-Simulation/./RoutingTable.h
// Function: serialize[abi:cxx11](std::vector<TableRow, std::allocator<TableRow>>&)
std::string serialize (std::vector<TableRow> &table){
	std::string returnTo;
	for (int i=0; i<table.size(); i++){
		returnTo += table[i].toString();
		if (i+1 != table.size())
			returnTo += '\n';
	}
	return returnTo;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
pushq $0x2c
popq %rbp
xorl %r12d, %r12d
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x6, %rax
cmpq %r12, %rax
jbe 0x2600
addq %r13, %rsi
movq %r15, %rdi
movl %ebp, %edx
callq 0x357c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2310
movq %r15, %rdi
callq 0x20c0
incq %r12
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x6, %rax
cmpq %rax, %r12
je 0x25fa
movq %rbx, %rdi
pushq $0xa
popq %rsi
callq 0x2190
addq $0x40, %r13
jmp 0x25a9
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2614
movq %rax, %r14
jmp 0x2626
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/SaadBazaz[P]RIP-Protocol-Simulation/./RoutingTable.h
// Function: deserialize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<TableRow> deserialize (std::string table_string){
	std::vector <std::string> rows = tokenizeData(table_string, '\n');

	std::vector<TableRow> returnTo; 

	for (int i=0; i<rows.size(); i++){
		TableRow new_row (rows[i]);
		returnTo.push_back(new_row);
	}

	return returnTo;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x2250
movq %rsp, %rdi
pushq $0xa
popq %rdx
movq %r14, %rsi
callq 0x244c
leaq 0x18(%rsp), %rdi
callq 0x20c0
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %r13d, %r13d
leaq 0x38(%rsp), %r15
leaq 0x58(%rsp), %r12
pushq $0x2c
popq %rbp
xorl %r14d, %r14d
movq (%rsp), %rsi
movq 0x8(%rsp), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r14, %rax
jbe 0x26e0
addq %r13, %rsi
movq %r15, %rdi
callq 0x2250
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x39e4
movq %r15, %rdi
callq 0x20c0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3b26
leaq 0x68(%rsp), %rdi
callq 0x20c0
incq %r14
addq $0x20, %r13
jmp 0x268d
movq %rsp, %rdi
callq 0x3532
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x18(%rsp), %rdi
callq 0x20c0
jmp 0x2738
movq %rax, %r15
leaq 0x68(%rsp), %rdi
jmp 0x271e
movq %rax, %r15
leaq 0x38(%rsp), %rdi
callq 0x20c0
jmp 0x2728
movq %rax, %r15
movq %rbx, %rdi
callq 0x3b52
movq %rsp, %rdi
callq 0x3532
movq %r15, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/SaadBazaz[P]RIP-Protocol-Simulation/DNS.cpp
// Function: SearchDomain(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Directory, std::allocator<Directory>>)
int SearchDomain(string Dom,vector<Directory> List){
    for(int i = 0;i < List.size();i++){
        
        cout<<"Matching '"<<Dom<<"' with "<<List[i].DomainName<<endl;
        if (Dom == List[i].DomainName)
        {
            return i;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
leaq 0x25c3(%rip), %r13      # 0x5423
leaq 0x25c7(%rip), %rbp      # 0x542e
xorl %r12d, %r12d
movq 0x8(%r14), %rax
subq (%r14), %rax
cqto
movl $0xa0, %ecx
idivq %rcx
cmpq %r12, %rax
jbe 0x2ed9
movq 0x5141(%rip), %rdi      # 0x7fc8
movq %r13, %rsi
callq 0x21c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
movq %rax, %rdi
movq %rbp, %rsi
callq 0x21c0
movq (%r14), %rsi
addq %rbx, %rsi
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x20d0
movq (%r14), %rsi
addq %rbx, %rsi
movq %r15, %rdi
callq 0x3553
testb %al, %al
jne 0x2ede
incq %r12
addq $0xa0, %rbx
jmp 0x2e6a
pushq $-0x1
popq %rax
jmp 0x2ee1
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq