LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/sile[P]mphf/./bit_vector.hh
// Function: MPHF::BitVector::build_rank_index()
void build_rank_index() {
      unsigned* ri = const_cast<unsigned*>(rank_index);
      unsigned limit = rank_index_size();
      unsigned acc_1bit_count=0;
      for(unsigned i=0; i < limit; i++) {
	ri[i] = acc_1bit_count;
	if(i != limit-1)
	  for(unsigned j=0; j < BR_TIMES; j++)
	    acc_1bit_count += log_count(blocks[i*BR_TIMES+j]);
      }
    }

// Assembly:
movl $0xff, %eax
addl (%rdi), %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x3b41
pushq %rbp
pushq %rbx
movq 0x10(%rdi), %rcx
shrl $0x8, %eax
leal -0x1(%rax), %edx
movq 0x8(%rdi), %rsi
xorl %edi, %edi
movl $0x55555555, %r8d       # imm = 0x55555555
movl $0x33333333, %r9d       # imm = 0x33333333
xorl %r10d, %r10d
movl %r10d, (%rcx,%rdi,4)
cmpq %rdx, %rdi
je 0x3b33
xorl %r11d, %r11d
movl (%rsi,%r11,4), %ebx
movl %ebx, %ebp
shrl %ebp
andl %r8d, %ebp
andl %r8d, %ebx
addl %ebp, %ebx
movl %ebx, %ebp
shrl $0x2, %ebp
andl %r9d, %ebp
andl %r9d, %ebx
addl %ebp, %ebx
movl %ebx, %ebp
shrl $0x4, %ebp
addl %ebx, %ebp
andl $0xf0f0f0f, %ebp        # imm = 0xF0F0F0F
movl %ebp, %ebx
shrl $0x8, %ebx
addl %ebp, %ebx
movl %ebx, %ebp
shrl $0x10, %ebp
addl %ebx, %ebp
movzbl %bpl, %ebx
addl %ebx, %r10d
incq %r11
cmpq $0x8, %r11
jne 0x3aeb
incq %rdi
addq $0x20, %rsi
cmpq %rax, %rdi
jne 0x3adf
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ddos-on-anycast/src/lib/dag.cpp
// Function: Graph::get_sources_and_sinks(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&) const
void Graph::get_sources_and_sinks(ivec& sources, ivec& sinks) const {
    for(int u=0; u<n; ++u) {
        if(_preds[u].empty()) {
            sources.push_back(u);
        }
        if(_succs[u].empty()) {
            sinks.push_back(u);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x0, 0x4(%rsp)
cmpl $0x0, (%rdi)
jle 0x13b4
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %eax, %eax
leaq 0x4(%rsp), %r12
movslq %eax, %rcx
movq 0x8(%r15), %rdx
leaq (%rcx,%rcx,2), %rcx
movq (%rdx,%rcx,8), %rsi
cmpq 0x8(%rdx,%rcx,8), %rsi
jne 0x136c
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x1361
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0x136c
movq %r14, %rdi
movq %r12, %rdx
callq 0x18b8
movslq 0x4(%rsp), %rax
movq 0x20(%r15), %rcx
leaq (%rax,%rax,2), %rdx
movq (%rcx,%rdx,8), %rsi
cmpq 0x8(%rcx,%rdx,8), %rsi
jne 0x13a5
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x139a
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x13a5
movq %rbx, %rdi
movq %r12, %rdx
callq 0x18b8
movl 0x4(%rsp), %eax
incl %eax
movl %eax, 0x4(%rsp)
cmpl (%r15), %eax
jl 0x1335
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ddos-on-anycast/src/lib/dag.cpp
// Function: Graph::print(_IO_FILE*) const
void Graph::print(FILE* fp) const {
    for(int u=0; u<n; ++u) {
        fprintf(fp, "%d: ", u);
        print_icont(fp, _succs[u], ", ", "[", "] ");
        print_icont(fp, _preds[u], ", ", "[", "]\n");
    }
}

// Assembly:
cmpl $0x0, (%rdi)
jle 0x1455
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc28(%rip), %r12       # 0x2009
leaq 0xc24(%rip), %r13       # 0x200c
xorl %r15d, %r15d
xorl %ebp, %ebp
movq %rbx, %rdi
leaq 0xc0d(%rip), %rsi       # 0x2004
movl %ebp, %edx
xorl %eax, %eax
callq 0x1100
movq 0x20(%r14), %rsi
addq %r15, %rsi
movq %rbx, %rdi
movq %r12, %rdx
movq %r13, %rcx
leaq 0xbf7(%rip), %r8        # 0x200e
callq 0x165e
movq 0x8(%r14), %rsi
addq %r15, %rsi
movq %rbx, %rdi
movq %r12, %rdx
movq %r13, %rcx
leaq 0xbde(%rip), %r8        # 0x2011
callq 0x165e
incq %rbp
movslq (%r14), %rax
addq $0x18, %r15
cmpq %rax, %rbp
jl 0x13ed
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ddos-on-anycast/src/lib/dag.cpp
// Function: DFSHelper::do_dfs(int)
void DFSHelper::do_dfs(int u) {
    if(visited[u]) {
        return;
    }
    visited[u] = true;
    for(int v: graph.succs(u)) {
        if(!visited[v]) {
            do_dfs(v);
        }
    }
    topolist.push_back(u);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movslq %esi, %rcx
leaq 0x3f(%rcx), %rax
testq %rcx, %rcx
cmovnsq %rcx, %rax
sarq $0x6, %rax
shlq $0x3, %rax
addq 0x8(%rdi), %rax
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
leaq 0x3f(%r14), %rsi
andq %rcx, %rsi
xorl %edx, %edx
cmpq %r14, %rsi
setbe %dl
movl $0x1, %esi
shlq %cl, %rsi
movq -0x8(%rax,%rdx,8), %rdi
btq %rcx, %rdi
jb 0x154c
leaq -0x8(,%rdx,8), %rdx
orq %rsi, %rdi
movq %rdi, (%rax,%rdx)
movq (%rbx), %rax
movq 0x20(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %r15
movq 0x8(%rax,%rcx,8), %r12
cmpq %r12, %r15
je 0x1524
leaq 0x3f(%r14), %r13
movslq (%r15), %rsi
leaq 0x3f(%rsi), %rax
testq %rsi, %rsi
cmovnsq %rsi, %rax
sarq $0x6, %rax
shlq $0x3, %rax
addq 0x8(%rbx), %rax
movq %rsi, %rcx
andq %r13, %rcx
xorl %edx, %edx
cmpq %r14, %rcx
setbe %dl
movq -0x8(%rax,%rdx,8), %rax
btq %rsi, %rax
jb 0x151b
movq %rbx, %rdi
callq 0x1456
addq $0x4, %r15
cmpq %r12, %r15
jne 0x14e0
movq 0x30(%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x1542
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x154c
leaq 0xc(%rsp), %rdx
callq 0x18b8
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ddos-on-anycast/src/lib/dag.cpp
// Function: rtoposort(Graph const&, std::vector<int, std::allocator<int>>&)
void rtoposort(const Graph& graph, ivec& output) {
    int n = graph.order();
    output.reserve(n);
    DFSHelper dfs_helper(graph, output);
    for(int u=0; u<n; ++u) {
        dfs_helper.do_dfs(u);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %r12
movslq (%rdi), %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x16f2
leaq 0x10(%rsp), %rbx
movq %r12, -0x8(%rbx)
movslq (%r12), %rsi
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x6(%rsp), %rcx
movq %rbx, %rdi
callq 0x1780
movq %r15, 0x28(%rbx)
testq %r14, %r14
jle 0x15bd
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0x1456
incl %ebp
cmpl %ebp, %r14d
jne 0x15ac
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x15e5
callq 0x10b0
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movl %eax, 0x28(%rsp)
movq %rax, 0x30(%rsp)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x160c
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x1150
movq %r14, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ddos-on-anycast/src/lib/util.hpp
// Function: void print_icont<std::vector<int, std::allocator<int>>>(_IO_FILE*, std::vector<int, std::allocator<int>> const&, char const*, char const*, char const*)
void print_icont(FILE* fp, const C& c, const char* sep, const char* begs, const char* ends) {
    fprintf(fp, "%s", begs);
    int n = c.size();
    if(n > 0) {
        typename C::const_iterator it = c.begin();
        fprintf(fp, "%d", *(it++));
        while(it != c.end()) {
            fprintf(fp, "%s%d", sep, *(it++));
        }
    }
    fprintf(fp, "%s", ends);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rcx, %rdi
movq %r14, %rsi
callq 0x10d0
movq (%r12), %rbp
movq 0x8(%r12), %rax
subq %rbp, %rax
shrq $0x2, %rax
testl %eax, %eax
jle 0x16d8
movl (%rbp), %edx
leaq 0x9ab(%rip), %rsi       # 0x2049
movq %r14, %rdi
xorl %eax, %eax
callq 0x1100
addq $0x4, %rbp
cmpq 0x8(%r12), %rbp
je 0x16d8
leaq 0x974(%rip), %r13       # 0x202e
movl (%rbp), %ecx
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1100
addq $0x4, %rbp
cmpq 0x8(%r12), %rbp
jne 0x16ba
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ddos-on-anycast/src/dag.cpp
// Function: main
int main() {
    int n, m;
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-result"
    scanf("%d%d", &n, &m);
#pragma GCC diagnostic pop
    Graph graph(n);
    for(int i=0; i<m; ++i) {
        int u, v;
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-result"
        scanf("%d%d", &u, &v);
#pragma GCC diagnostic pop
        graph.add_edge(u, v);
    }
    ivec topolist;
    toposort(graph, topolist);
    printf("%d", topolist[0]);
    for(int i=1; i<n; ++i) {
        printf(" %d", topolist[i]);
    }
    printf("\n");
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
leaq 0x644(%rip), %rdi       # 0x2043
leaq 0x4(%rsp), %rbx
leaq 0xc(%rsp), %r14
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x10e0
movl (%rbx), %esi
leaq 0x28(%rsp), %rdi
callq 0x1b3e
cmpl $0x0, (%r14)
jle 0x1a68
leaq 0x614(%rip), %rbx       # 0x2043
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x10e0
movl 0x10(%rsp), %esi
movl 0x8(%rsp), %edx
movq %r12, %rdi
callq 0x1b94
incl %ebp
cmpl 0xc(%rsp), %ebp
jl 0x1a40
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
leaq 0x28(%rsp), %rdi
callq 0x1614
movq 0x10(%rsp), %rax
movl (%rax), %esi
leaq 0x5b6(%rip), %rdi       # 0x2049
xorl %eax, %eax
callq 0x1030
cmpl $0x2, 0x4(%rsp)
jl 0x1ace
movl $0x1, %r14d
leaq 0x59a(%rip), %rbx       # 0x2048
movq 0x10(%rsp), %rax
movl (%rax,%r14,4), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1030
incq %r14
movslq 0x4(%rsp), %rax
cmpq %rax, %r14
jl 0x1aae
movl $0xa, %edi
callq 0x10f0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1ae7
callq 0x10b0
leaq 0x48(%rsp), %rdi
callq 0x1c96
leaq 0x30(%rsp), %rdi
callq 0x1c96
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b21
callq 0x10b0
jmp 0x1b21
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1c96
leaq 0x30(%rsp), %rdi
callq 0x1c96
movq %rbx, %rdi
callq 0x1130
nop
// File: /workspace/github_cpp_makefile_star2_O1/thuydx55[P]C-Number-to-Word/NumberRepresentation/Number.cpp
// Function: Number::divideStringToSmallGroup(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
stack<string> Number::divideStringToSmallGroup(const string &numStr) {
    stack<string> groups;

    for (short i = numStr.length()-1; i >= 0; i -= 3) {
        if (i >= 2)
            groups.push(numStr.substr(i-2, 3));
        else
            groups.push(numStr.substr(0, i+1));
    }

    return groups;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %esi, %esi
callq 0x4f0e
movl 0x8(%r14), %eax
decl %eax
movswl %ax, %r13d
testl %r13d, %r13d
js 0x4431
leaq 0x10(%rsp), %r12
movq %rsp, %r15
cmpl $0x2, %r13d
jl 0x43f2
leal -0x2(%r13), %edx
movl $0x3, %ecx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2140
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5320
jmp 0x440e
leal 0x1(%r13), %ecx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2140
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5320
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4424
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2130
addl $-0x3, %r13d
movswl %r13w, %r13d
testl %r13d, %r13d
jns 0x43cb
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4444
movq %rax, %r14
jmp 0x4464
jmp 0x444b
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4464
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x4724
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/mmoanis[P]mpegts_demux/MpegTsBitStream.cpp
// Function: MpegTsBitStream::MpegTsBitStream(char const*)
MpegTsBitStream::MpegTsBitStream(const char * filename) : m_file(NULL), m_eof(false), m_bad(true)
{
    assert(filename != NULL);

    m_file = fopen(filename, "rb");
    if (!m_file) {
        cerr << "[ERROR]: can't open file \'" << filename << "\'" << endl;
    } else {
        m_bad = false;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq $0x0, (%rdi)
movw $0x100, 0x8(%rdi)       # imm = 0x100
testq %rsi, %rsi
je 0x26ea
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2b12(%rip), %rsi      # 0x516d
movq %r14, %rdi
callq 0x2180
movq %rax, (%rbx)
testq %rax, %rax
je 0x2677
movb $0x0, 0x9(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x5972(%rip), %rbx      # 0x7ff0
leaq 0x2aeb(%rip), %rsi      # 0x5170
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x2080
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2170
leaq 0x2b8b(%rip), %rsi      # 0x523a
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2170
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20d0
leaq 0x2a28(%rip), %rdi      # 0x5119
leaq 0x2a32(%rip), %rsi      # 0x512a
leaq 0x2a3f(%rip), %rcx      # 0x513e
movl $0x9, %edx
callq 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2832
xorl %eax, %eax
cmpb $0x0, 0x8(%rbx)
jne 0x2834
testb $0x1, 0x9(%rbx)
jne 0x2834
movq %rsi, %r15
callq 0x21c0
cmpl $-0x1, %eax
je 0x2782
cmpb $0x47, %al
jne 0x278b
movb $0x47, (%r15)
movl $0x1, %r14d
movq (%rbx), %rdi
callq 0x21c0
cmpl $-0x1, %eax
je 0x27ab
movb %al, (%r15,%r14)
incq %r14
cmpq $0xbc, %r14
jne 0x275d
movl $0xbc, %r14d
jmp 0x27af
movb $0x1, 0x8(%rbx)
jmp 0x2832
movq 0x585e(%rip), %r14      # 0x7ff0
leaq 0x29f2(%rip), %rsi      # 0x518b
movl $0x1d, %edx
movq %r14, %rdi
callq 0x2170
movq (%r14), %rax
jmp 0x280a
movb $0x1, 0x8(%rbx)
movb $0x1, %al
cmpq $0xbc, %r14
je 0x2834
movq 0x582f(%rip), %r15      # 0x7ff0
leaq 0x29e1(%rip), %rsi      # 0x51a9
movl $0x12, %edx
movq %r15, %rdi
callq 0x2170
movq %r15, %rdi
movl $0xbc, %esi
callq 0x21f0
movq %rax, %r15
leaq 0x29d0(%rip), %rsi      # 0x51bc
movl $0xe, %edx
movq %rax, %rdi
callq 0x2170
movq %r15, %rdi
movq %r14, %rsi
callq 0x20c0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movb $0x1, 0x9(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2935
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x29ad(%rip), %rsi      # 0x5213
movq %rbx, %rdi
callq 0x2180
movq %rax, (%r14)
testq %rax, %rax
je 0x287c
popq %rbx
popq %r14
popq %r15
retq
movq 0x576d(%rip), %r15      # 0x7ff0
leaq 0x298c(%rip), %rsi      # 0x5216
movl $0x10, %edx
movq %r15, %rdi
callq 0x2170
movzwl 0x8(%r14), %esi
movq %r15, %rdi
callq 0x20c0
movq %rax, %r15
leaq 0x29a7(%rip), %rsi      # 0x5255
movl $0x5, %edx
movq %rax, %rdi
callq 0x2170
movzwl 0xa(%r14), %esi
movq %r15, %rdi
callq 0x20c0
movq %rax, %r14
leaq 0x2955(%rip), %rsi      # 0x5227
movl $0x14, %edx
movq %rax, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2080
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2170
leaq 0x293e(%rip), %rsi      # 0x523a
movl $0x1, %edx
movq %r14, %rdi
callq 0x2170
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20d0
leaq 0x27dd(%rip), %rdi      # 0x5119
leaq 0x2899(%rip), %rsi      # 0x51dc
leaq 0x28a2(%rip), %rcx      # 0x51ec
movl $0x1d, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a57
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x565e(%rip), %r12      # 0x7ff0
leaq 0x28a3(%rip), %r13      # 0x523c
movzbl (%r14), %edi
movq (%r15), %rsi
callq 0x2190
cmpl $-0x1, %eax
jne 0x2a3d
movl $0x10, %edx
movq %r12, %rdi
leaq 0x2859(%rip), %rsi      # 0x5216
callq 0x2170
movzwl 0x8(%r15), %esi
movq %r12, %rdi
callq 0x20c0
movq %rax, %rbp
movl $0x5, %edx
movq %rax, %rdi
leaq 0x2874(%rip), %rsi      # 0x5255
callq 0x2170
movzwl 0xa(%r15), %esi
movq %rbp, %rdi
callq 0x20c0
movq %rax, %rbp
movl $0xe, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2170
movq (%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbp, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq (%r15), %rdi
callq 0x2140
movq $0x0, (%r15)
incq %r14
cmpq %rbx, %r14
jne 0x2999
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2df3
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 0x2e5e
leaq 0x5(%rax), %rcx
movq %rcx, (%rsi)
movzbl 0x4(%rax), %ecx
addq %rcx, %rax
addq $0x5, %rax
movq %rax, (%rsi)
jmp 0x2e5e
movq %rdi, %rbx
movq 0x51f3(%rip), %r14      # 0x7ff0
leaq 0x2472(%rip), %rsi      # 0x5276
movl $0xd, %edx
movq %r14, %rdi
callq 0x2170
movq 0x90(%rbx), %rsi
movq %r14, %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x2369(%rip), %rsi      # 0x5193
movl $0x15, %edx
movq %rax, %rdi
callq 0x2170
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
cmpb $0x47, %bpl
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3b7f
movzwl (%rax), %edx
rolw $0x8, %dx
movw %dx, (%rcx)
leaq 0x2(%rax), %rdx
movq %rdx, (%rsi)
movb 0x2(%rax), %dl
cmpb $-0x41, %dl
jbe 0x3bba
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 0x3c24
movq 0x446a(%rip), %r14      # 0x7ff0
leaq 0x16e9(%rip), %rsi      # 0x5276
movl $0xd, %edx
movq %r14, %rdi
callq 0x2170
movq 0x90(%rbx), %rsi
movq %r14, %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x198b(%rip), %rsi      # 0x553e
movl $0x20, %edx
jmp 0x3bf3
movq 0x442f(%rip), %r14      # 0x7ff0
leaq 0x16ae(%rip), %rsi      # 0x5276
movl $0xd, %edx
movq %r14, %rdi
callq 0x2170
movq 0x90(%rbx), %rsi
movq %r14, %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x1971(%rip), %rsi      # 0x555f
movl $0x1f, %edx
movq %rax, %rdi
callq 0x2170
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %r13d, %r13d
movq (%r15), %rax
leaq 0x3(%rax), %rcx
cmpq %r14, %rcx
jae 0x3d1e
cmpb $-0x1, 0x4(%rax)
je 0x3d1e
movzbl (%rax), %esi
movzbl 0x1(%rax), %edx
leaq 0x2(%rax), %rdi
movq %rdi, (%r15)
movzbl 0x2(%rax), %r12d
movzwl %r12w, %edi
cmpl $0xdf, %edi
jbe 0x3ca9
addq $0x4, %rax
movzwl %si, %r8d
shll $0x8, %r8d
movzwl %dx, %esi
orl %r8d, %esi
andl $0x1f, %edi
shll $0x8, %edi
movzbl (%rcx), %edx
orl %edi, %edx
movq %rax, (%r15)
movq %rbx, %rdi
callq 0x3da6
movb $0x1, %r13b
jmp 0x3d12
movl $0xd, %edx
movq 0x433b(%rip), %rbp      # 0x7ff0
movq %rbp, %rdi
leaq 0x15b7(%rip), %rsi      # 0x5276
callq 0x2170
movq 0x90(%rbx), %rsi
movq %rbp, %rdi
callq 0x20c0
movq %rax, %rbp
movl $0x1b, %edx
movq %rax, %rdi
leaq 0x165c(%rip), %rsi      # 0x5341
callq 0x2170
movq (%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbp, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
cmpb $-0x21, %r12b
ja 0x3c43
jmp 0x3d8c
testb $0x1, %r13b
jne 0x3d8f
movq 0x42c5(%rip), %r14      # 0x7ff0
leaq 0x1544(%rip), %rsi      # 0x5276
movl $0xd, %edx
movq %r14, %rdi
callq 0x2170
movq 0x90(%rbx), %rsi
movq %r14, %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x1605(%rip), %rsi      # 0x535d
movl $0x19, %edx
movq %rax, %rdi
callq 0x2170
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
xorl %r13d, %r13d
andb $0x1, %r13b
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH32
XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t len, XXH32_hash_t seed)
{
#if !defined(XXH_NO_STREAM) && XXH_SIZE_OPT >= 2
    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
    XXH32_state_t state;
    XXH32_reset(&state, seed);
    XXH32_update(&state, (const xxh_u8*)input, len);
    return XXH32_digest(&state);
#else
    if (XXH_FORCE_ALIGN_CHECK) {
        if ((((size_t)input) & 3) == 0) {   /* Input is 4-bytes aligned, leverage the speed benefit */
            return XXH32_endian_align((const xxh_u8*)input, len, seed, XXH_aligned);
    }   }

    return XXH32_endian_align((const xxh_u8*)input, len, seed, XXH_unaligned);
#endif
}

// Assembly:
movl %edx, %eax
movq %rsi, %rdx
movq %rdi, %rsi
cmpq $0x10, %rdx
jb 0x2405
pushq %rbx
leaq (%rsi,%rdx), %rcx
addq $-0xf, %rcx
leal 0x24234428(%rax), %r9d
leal -0x7a143589(%rax), %r8d
leal 0x61c8864f(%rax), %edi
imull $0x85ebca77, (%rsi), %r10d # imm = 0x85EBCA77
addl %r9d, %r10d
roll $0xd, %r10d
imull $0x85ebca77, 0x4(%rsi), %r11d # imm = 0x85EBCA77
addl %r8d, %r11d
roll $0xd, %r11d
imull $0x9e3779b1, %r10d, %r9d # imm = 0x9E3779B1
imull $0x85ebca77, 0x8(%rsi), %r10d # imm = 0x85EBCA77
addl %eax, %r10d
roll $0xd, %r10d
imull $0x85ebca77, 0xc(%rsi), %ebx # imm = 0x85EBCA77
imull $0x9e3779b1, %r11d, %r8d # imm = 0x9E3779B1
addl %edi, %ebx
roll $0xd, %ebx
imull $0x9e3779b1, %r10d, %eax # imm = 0x9E3779B1
imull $0x9e3779b1, %ebx, %edi # imm = 0x9E3779B1
addq $0x10, %rsi
cmpq %rcx, %rsi
jb 0x2391
roll %r9d
roll $0x7, %r8d
addl %r9d, %r8d
roll $0xc, %eax
roll $0x12, %edi
addl %eax, %edi
addl %r8d, %edi
popq %rbx
jmp 0x240c
addl $0x165667b1, %eax       # imm = 0x165667B1
movl %eax, %edi
addl %edx, %edi
andl $0xf, %edx
jmp 0x2647
// File: /workspace/github_cpp_makefile_star2_O1/sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH32_reset
XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, XXH32_hash_t seed)
{
    XXH_ASSERT(statePtr != NULL);
    memset(statePtr, 0, sizeof(*statePtr));
    statePtr->v[0] = seed + XXH_PRIME32_1 + XXH_PRIME32_2;
    statePtr->v[1] = seed + XXH_PRIME32_2;
    statePtr->v[2] = seed + 0;
    statePtr->v[3] = seed - XXH_PRIME32_1;
    return XXH_OK;
}

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
leal 0x24234428(%rsi), %eax
movl %eax, 0x8(%rdi)
leal -0x7a143589(%rsi), %eax
movl %eax, 0xc(%rdi)
movl %esi, 0x10(%rdi)
addl $0x61c8864f, %esi       # imm = 0x61C8864F
movl %esi, 0x14(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2634
movl 0x8(%rsi), %eax
roll %eax
movl 0xc(%rsi), %ecx
roll $0x7, %ecx
addl %eax, %ecx
movl 0x10(%rsi), %eax
roll $0xc, %eax
movl 0x14(%rsi), %edi
roll $0x12, %edi
addl %eax, %edi
addl %ecx, %edi
jmp 0x263c
movl $0x165667b1, %edi       # imm = 0x165667B1
addl 0x10(%rsi), %edi
addl (%rsi), %edi
movl 0x28(%rsi), %edx
addq $0x18, %rsi
jmp 0x2647
// File: /workspace/github_cpp_makefile_star2_O1/sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH64_reset
XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, XXH64_hash_t seed)
{
    XXH_ASSERT(statePtr != NULL);
    memset(statePtr, 0, sizeof(*statePtr));
    statePtr->v[0] = seed + XXH_PRIME64_1 + XXH_PRIME64_2;
    statePtr->v[1] = seed + XXH_PRIME64_2;
    statePtr->v[2] = seed + 0;
    statePtr->v[3] = seed - XXH_PRIME64_1;
    return XXH_OK;
}

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movq $0x0, 0x50(%rdi)
movabsq $0x60ea27eeadc0b5d6, %rax # imm = 0x60EA27EEADC0B5D6
addq %rsi, %rax
movq %rax, 0x8(%rdi)
movabsq $-0x3d4d51c2d82b14b1, %rax # imm = 0xC2B2AE3D27D4EB4F
addq %rsi, %rax
movq %rax, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
movabsq $0x61c8864e7a143579, %rax # imm = 0x61C8864E7A143579
addq %rsi, %rax
movq %rax, 0x20(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH64_digest
XXH_PUBLIC_API XXH64_hash_t XXH64_digest(const XXH64_state_t* state)
{
    xxh_u64 h64;

    if (state->total_len >= 32) {
        h64 = XXH_rotl64(state->v[0], 1) + XXH_rotl64(state->v[1], 7) + XXH_rotl64(state->v[2], 12) + XXH_rotl64(state->v[3], 18);
        h64 = XXH64_mergeRound(h64, state->v[0]);
        h64 = XXH64_mergeRound(h64, state->v[1]);
        h64 = XXH64_mergeRound(h64, state->v[2]);
        h64 = XXH64_mergeRound(h64, state->v[3]);
    } else {
        h64  = state->v[2] /*seed*/ + XXH_PRIME64_5;
    }

    h64 += (xxh_u64) state->total_len;

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

// Assembly:
movq %rdi, %rsi
movq (%rdi), %rdx
cmpq $0x20, %rdx
jb 0x2afb
movq 0x8(%rsi), %r10
movq 0x10(%rsi), %rcx
movq %r10, %rax
rolq %rax
movq %rcx, %r8
rolq $0x7, %r8
addq %rax, %r8
movq 0x18(%rsi), %rax
movq %rax, %r9
rolq $0xc, %r9
movq 0x20(%rsi), %rdi
movq %rdi, %r11
rolq $0x12, %r11
addq %r9, %r11
movabsq $-0x3d4d51c2d82b14b1, %r9 # imm = 0xC2B2AE3D27D4EB4F
imulq %r9, %r10
rolq $0x1f, %r10
addq %r8, %r11
movabsq $-0x61c8864e7a143579, %r8 # imm = 0x9E3779B185EBCA87
imulq %r8, %r10
xorq %r11, %r10
imulq %r8, %r10
movabsq $-0x7a1435883d4d519d, %r11 # imm = 0x85EBCA77C2B2AE63
addq %r11, %r10
imulq %r9, %rcx
rolq $0x1f, %rcx
imulq %r8, %rcx
xorq %r10, %rcx
imulq %r8, %rcx
imulq %r9, %rax
rolq $0x1f, %rax
addq %r11, %rcx
imulq %r8, %rax
xorq %rcx, %rax
imulq %r8, %rax
addq %r11, %rax
imulq %r9, %rdi
rolq $0x1f, %rdi
imulq %r8, %rdi
xorq %rax, %rdi
imulq %r8, %rdi
addq %r11, %rdi
jmp 0x2b09
movabsq $0x27d4eb2f165667c5, %rdi # imm = 0x27D4EB2F165667C5
addq 0x18(%rsi), %rdi
addq %rdx, %rdi
addq $0x28, %rsi
jmp 0x2b12
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2b69
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 0x2b39
jmp 0x2b6c
movq %rdi, %r8
movabsq $0x165667b19e3779f9, %rdi # imm = 0x165667B19E3779F9
cmpq $0x4, %rdx
jb 0x2b9c
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 0x2bcf
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 0x2bae
jmp 0x2bd2
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_O1/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 0x313b
movq %rax, %rcx
movl %ecx, %edx
andl $0x3f, %edx
movl $0x40, %esi
subq %rdx, %rsi
addq %rsi, %rax
negq %rdx
movb %sil, 0x3f(%rcx,%rdx)
jmp 0x313d
xorl %eax, %eax
testq %rax, %rax
je 0x314f
movq $0x0, 0x228(%rax)
jmp 0x3151
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32f7
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)
movl $0x0, 0x204(%rdi)
movq %rsi, 0x238(%rdi)
leaq -0x40(%rdx), %rcx
movq %rcx, 0x220(%rdi)
shrq $0x3, %rcx
movq %rcx, 0x218(%rdi)
testq %rsi, %rsi
je 0x32f7
xorl %eax, %eax
cmpq $0x88, %rdx
setb %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33df
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 0x33e5
cmpq %rsi, 0x228(%rdi)
jne 0x3354
cmpq $0x0, 0x238(%rdi)
je 0x338e
pushq %r15
pushq %r14
pushq %rbx
xorl %r11d, %r11d
leaq 0x2cdd(%rip), %rbx      # 0x6040
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 0x3363
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, %esi
xorl %eax, %eax
jmp 0x3432
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 0x2c0e(%rip), %rax      # 0x6040
movl %esi, 0x204(%rdi)
movq %rax, 0x238(%rdi)
movq $0x80, 0x220(%rdi)
movq $0x10, 0x218(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %r8b
orb %al, %r8b
cmpq $0x88, %rdx
setb %al
orb %r8b, %al
movl $0x1, %eax
jne 0x3528
xorps %xmm0, %xmm0
movups %xmm0, 0x200(%rdi)
movq $0x0, 0x210(%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 %rcx, 0x228(%rdi)
movq %rsi, 0x238(%rdi)
addq $-0x40, %rdx
movq %rdx, 0x220(%rdi)
shrq $0x3, %rdx
movq %rdx, 0x218(%rdi)
movl $0x1, 0x204(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x397c
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x39cf
addq $0xb, %rbx
movabsq $-0x61c8864e7a143579, %rdx # imm = 0x9E3779B185EBCA87
imulq 0x210(%r14), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3b3c
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x100(%r14), %rdi
cmpl $0x0, 0x204(%r14)
je 0x39aa
movq 0x228(%r14), %rdx
leaq 0x26a5(%rip), %rcx      # 0x6040
leaq -0x9f4(%rip), %r9       # 0x2fae
movl $0xc0, %r8d
jmp 0x39c1
movq 0x220(%r14), %r8
addq $0x40, %r8
leaq -0xa9d(%rip), %r9       # 0x2f1f
xorl %edx, %edx
movq %rbx, %rcx
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2c1f
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4138
subq $0xc8, %rsp
movl $0x8, %eax
leaq 0x1f41(%rip), %rcx      # 0x6040
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 0x40ff
movq %rsp, %rdx
movl $0xc0, %ecx
callq 0x52a6
addq $0xc8, %rsp
retq
leaq 0x1f01(%rip), %rdx      # 0x6040
movl $0xc0, %ecx
jmp 0x52a6
// File: /workspace/github_cpp_makefile_star2_O1/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 0x42f3
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x39cf
leaq 0xb(%rbx), %rsi
movq 0x210(%r14), %r13
movabsq $-0x61c8864e7a143579, %rdx # imm = 0x9E3779B185EBCA87
imulq %r13, %rdx
movq %r12, %rdi
callq 0x3b3c
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 0x3b3c
movq %rax, %rdx
jmp 0x433b
movq 0x228(%r14), %rdx
leaq 0x100(%r14), %rdi
testq %rdx, %rdx
je 0x431c
leaq 0x1d33(%rip), %rcx      # 0x6040
leaq -0x22d(%rip), %r9       # 0x40e7
movl $0xc0, %r8d
jmp 0x4333
movq 0x220(%r14), %r8
addq $0x40, %r8
leaq -0x26b(%rip), %r9       # 0x40c3
xorl %edx, %edx
movq %rbx, %rcx
callq 0x3ba2
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_O1/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 0x439d
retq
movq (%rdi), %rcx
xorl %eax, %eax
cmpq (%rsi), %rcx
seta %al
sbbl $0x0, %eax
retq