LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sile[P]mphf/./generator.hh
// Function: MPHF::Generator::check_and_sort_graph()
bool check_and_sort_graph() {
      unsigned beg=0;
      unsigned prev=0;
      unsigned side=0;
      for(; beg < key_count; side=(side+1)%2) {
	VertexLessThan vtl(side);
	std::sort(graph+beg, graph+key_count, vtl);
	
	for(unsigned i=beg; i < key_count; i++)
	  if(graph[i][side] != graph[i+1][side])
	    std::swap(graph[beg++], graph[i]);   // leaf vertex
	  else
	    for(i++; graph[i][side] == graph[i+1][side]; i++);
	
	if(prev==beg)
	  return false;
	prev=beg;
      }
      std::reverse(graph, graph+key_count);
      return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x28(%rcx), %eax
jae 0x393d
movl -0x1c(%rbp), %esi
leaq -0x20(%rbp), %rdi
callq 0x3af0
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rdi
movq 0x10(%rax), %rsi
movl 0x28(%rax), %eax
shlq $0x3, %rax
addq %rax, %rsi
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edx
callq 0x3b10
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpl 0x28(%rcx), %eax
jae 0x3918
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x28(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0x3a10
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x34(%rbp)
movq 0x10(%rax), %rdi
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0x3a10
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl (%rcx), %eax
je 0x38a5
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movl %ecx, %ecx
shlq $0x3, %rcx
addq %rcx, %rdi
movq 0x10(%rax), %rsi
movl -0x28(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x3b60
jmp 0x3908
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x28(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0x3a10
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x38(%rbp)
movq 0x10(%rax), %rdi
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0x3a10
movq %rax, %rcx
movl -0x38(%rbp), %eax
cmpl (%rcx), %eax
jne 0x3906
jmp 0x38fb
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x38ae
jmp 0x3908
jmp 0x390a
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3819
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x3926
movb $0x0, -0x1(%rbp)
jmp 0x395c
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
andl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x37c9
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rax), %rsi
movl 0x28(%rax), %eax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x3ba0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sile[P]mphf/./hash_impl.hh
// Function: MPHF::HashImpl::hash(char const*, unsigned int) const
unsigned hash(const char* key, unsigned size) const {
      const unsigned* u = (const unsigned*)(key);
      unsigned h = param.ini;
      unsigned i = sizeof(unsigned);
      for(; i <= size; i += sizeof(unsigned), u++) 
	h = h*param.mul ^ *u + (h>>ui_size_minus8);
      
      if((i-=sizeof(unsigned)) != size)
	for(; i < size; i++)
	  h = h*param.mul ^ key[i] + (h>>ui_size_minus8);
      
      return h;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x4, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
ja 0x3a99
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
imull 0x4(%rcx), %eax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movl -0x24(%rbp), %edx
shrl $0x18, %edx
addl %edx, %ecx
xorl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addq $0x4, %rax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x3a5b
movl -0x28(%rbp), %eax
subq $0x4, %rax
movl %eax, -0x28(%rbp)
cmpl -0x14(%rbp), %eax
je 0x3ae2
jmp 0x3aaa
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x3ae0
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
imull 0x4(%rcx), %eax
movq -0x10(%rbp), %rcx
movl -0x28(%rbp), %edx
movsbl (%rcx,%rdx), %ecx
movl -0x24(%rbp), %edx
shrl $0x18, %edx
addl %edx, %ecx
xorl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3aaa
jmp 0x3ae2
movl -0x24(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq 0x10(%rdi), %rax
movq %rax, -0x10(%rbp)
callq 0x5ed0
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x5ebc
movl -0x18(%rbp), %edx
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x5eaf
movl $0x0, -0x20(%rbp)
cmpl $0x8, -0x20(%rbp)
jae 0x5ead
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
shll $0x3, %ecx
addl -0x20(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %edi
callq 0x5ef0
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5e7b
jmp 0x5eaf
jmp 0x5eb1
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5e52
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: sile[P]mphf/./bit_vector.hh
// Function: MPHF::BitVector::log_count(unsigned int)
static unsigned log_count(unsigned n) {
      n = ((n & 0xAAAAAAAA) >> 1) + (n & 0x55555555);
      n = ((n & 0xCCCCCCCC) >> 2) + (n & 0x33333333);
      n = ((n >> 4) + n) & 0x0F0F0F0F;
      n = (n>>8) + n;
      return ((n>>16) + n) & 0x3F;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xaaaaaaaa, %eax       # imm = 0xAAAAAAAA
shrl %eax
movl -0x4(%rbp), %ecx
andl $0x55555555, %ecx       # imm = 0x55555555
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xcccccccc, %eax       # imm = 0xCCCCCCCC
shrl $0x2, %eax
movl -0x4(%rbp), %ecx
andl $0x33333333, %ecx       # imm = 0x33333333
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x4, %eax
addl -0x4(%rbp), %eax
andl $0xf0f0f0f, %eax        # imm = 0xF0F0F0F
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x8, %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x10, %eax
addl -0x4(%rbp), %eax
andl $0x3f, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jge 0x136d
movq (%rsp), %rdi
addq $0x8, %rdi
movslq 0xc(%rsp), %rsi
callq 0x1690
movq %rax, %rdi
callq 0x16b0
testb $0x1, %al
jne 0x1320
jmp 0x132f
movq 0x18(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x1700
movq (%rsp), %rdi
addq $0x20, %rdi
movslq 0xc(%rsp), %rsi
callq 0x1690
movq %rax, %rdi
callq 0x16b0
testb $0x1, %al
jne 0x134f
jmp 0x135e
movq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x1700
jmp 0x1360
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x12f4
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl (%rcx), %eax
jge 0x1456
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %edx
leaq 0x2c43(%rip), %rsi      # 0x4004
movb $0x0, %al
callq 0x10f0
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x20, %rdi
movslq 0x24(%rsp), %rsi
callq 0x1690
movq 0x8(%rsp), %rdi
movq %rax, %rsi
leaq 0x2c15(%rip), %rdx      # 0x4009
leaq 0x2c11(%rip), %rcx      # 0x400c
leaq 0x2c0c(%rip), %r8       # 0x400e
callq 0x1770
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
movslq 0x24(%rsp), %rsi
callq 0x1690
movq 0x10(%rsp), %rdi
movq %rax, %rsi
leaq 0x2bd6(%rip), %rdx      # 0x4009
leaq 0x2bd2(%rip), %rcx      # 0x400c
leaq 0x2bd0(%rip), %r8       # 0x4011
callq 0x1770
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x13a0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x8, %rdi
movslq 0x5c(%rsp), %rsi
callq 0x18a0
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x1900
testb $0x1, %al
jne 0x149e
jmp 0x14a3
jmp 0x1581
movq (%rsp), %rdi
addq $0x8, %rdi
movslq 0x5c(%rsp), %rsi
callq 0x18a0
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x1930
movq (%rsp), %rax
movq (%rax), %rdi
movl 0x5c(%rsp), %esi
callq 0x1980
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x19b0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x19e0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1a10
testb $0x1, %al
jne 0x1516
jmp 0x156f
leaq 0x28(%rsp), %rdi
callq 0x1a50
movq (%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
addq $0x8, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x18a0
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x1900
xorb $-0x1, %al
testb $0x1, %al
jne 0x1554
jmp 0x1561
movq (%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x1460
jmp 0x1563
leaq 0x28(%rsp), %rdi
callq 0x1a60
jmp 0x1501
movq (%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0x5c(%rsp), %rsi
callq 0x1700
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x1a80
movl %eax, 0x54(%rsp)
movq 0x58(%rsp), %rdi
movslq 0x54(%rsp), %rsi
callq 0x1a90
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
leaq 0x18(%rsp), %rdi
callq 0x1ba0
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x54(%rsp), %eax
jge 0x161a
movl 0x14(%rsp), %esi
leaq 0x18(%rsp), %rdi
callq 0x1460
jmp 0x15f1
jmp 0x15f3
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x15d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x8(%rsp)
movl %eax, 0x4(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x1c50
jmp 0x1629
leaq 0x18(%rsp), %rdi
callq 0x1c50
addq $0x68, %rsp
retq
movq 0x8(%rsp), %rdi
callq 0x1140
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq 0x60(%rsp), %rdi
movq 0x48(%rsp), %rdx
leaq 0x2890(%rip), %rsi      # 0x402e
movb $0x0, %al
callq 0x10f0
movq 0x58(%rsp), %rdi
callq 0x2920
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
jle 0x1876
movq 0x58(%rsp), %rdi
callq 0x19b0
movq %rax, 0x30(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x2cc0
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1a50
movq 0x10(%rsp), %rdi
movl (%rax), %edx
leaq 0x284c(%rip), %rsi      # 0x404c
movb $0x0, %al
callq 0x10f0
movq 0x58(%rsp), %rdi
callq 0x19e0
movq %rax, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1a10
testb $0x1, %al
jne 0x182b
jmp 0x1874
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x2cc0
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x1a50
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movl (%rax), %ecx
leaq 0x27c6(%rip), %rsi      # 0x4031
movb $0x0, %al
callq 0x10f0
jmp 0x1807
jmp 0x1876
movq 0x60(%rsp), %rdi
movq 0x40(%rsp), %rdx
leaq 0x27a7(%rip), %rsi      # 0x402e
movb $0x0, %al
callq 0x10f0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x98, %rsp
movl $0x0, 0x94(%rsp)
leaq 0xfed(%rip), %rdi       # 0x4046
leaq 0x90(%rsp), %rsi
leaq 0x8c(%rsp), %rdx
movb $0x0, %al
callq 0x10e0
movl 0x90(%rsp), %esi
leaq 0x50(%rsp), %rdi
callq 0x31e0
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0x8c(%rsp), %eax
jge 0x30e6
leaq 0xfa9(%rip), %rdi       # 0x4046
xorl %eax, %eax
leaq 0x48(%rsp), %rsi
leaq 0x44(%rsp), %rdx
callq 0x10e0
jmp 0x30b0
movl 0x48(%rsp), %esi
movl 0x44(%rsp), %edx
leaq 0x50(%rsp), %rdi
callq 0x32d0
jmp 0x30c4
jmp 0x30c6
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x3089
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x31cc
leaq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3330
movq 0x8(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x1640
jmp 0x3106
xorl %eax, %eax
movl %eax, 0x4(%rsp)
movl %eax, %esi
leaq 0x18(%rsp), %rdi
callq 0x3340
movq %rax, %rcx
movl 0x4(%rsp), %eax
movl (%rcx), %esi
leaq 0xf24(%rip), %rdi       # 0x404c
callq 0x1030
jmp 0x312f
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x90(%rsp), %eax
jge 0x318e
movslq 0x14(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x3340
movl (%rax), %esi
leaq 0xeef(%rip), %rdi       # 0x404b
xorl %eax, %eax
callq 0x1030
jmp 0x3165
jmp 0x3167
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3137
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x3360
jmp 0x31cc
leaq 0xe7d(%rip), %rdi       # 0x4012
xorl %eax, %eax
callq 0x1030
jmp 0x319e
movl $0x0, 0x94(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x3360
leaq 0x50(%rsp), %rdi
callq 0x33c0
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
leaq 0x50(%rsp), %rdi
callq 0x33c0
movq 0x38(%rsp), %rdi
callq 0x1140
// File: thuydx55[P]C-Number-to-Word/NumberRepresentation/Number.cpp
// Function: Number::isValid()
bool Number::isValid() {
    short startIdx = 0;
    if (mNumStr[0] == '-')
        startIdx++;

    for(short i = startIdx; i < mNumStr.size(); i++ ) {
        if(mNumStr[i] < '0' || mNumStr[i] > '9')
            return false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movw $0x0, -0x12(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3330
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x6b57
movw -0x12(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x12(%rbp)
movw -0x12(%rbp), %ax
movw %ax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movswq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x3110
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x6bbf
movq -0x20(%rbp), %rdi
movswq -0x14(%rbp), %rsi
callq 0x3330
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x6ba9
movq -0x20(%rbp), %rdi
movswq -0x14(%rbp), %rsi
callq 0x3330
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0x6baf
movb $0x0, -0x1(%rbp)
jmp 0x6bc3
jmp 0x6bb1
movw -0x14(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x14(%rbp)
jmp 0x6b5f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: thuydx55[P]C-Number-to-Word/NumberRepresentation/Number.cpp
// Function: Number::divideStringToBigGroup(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
stack<string> Number::divideStringToBigGroup(const string &numStr) {
    stack<string> groups;

    short length = 12;
    for (short i = numStr.length()-1; i >= 0;) {
        string str = "";
        if (i >= length-1) {
            str = numStr.substr(i-(length-1), length);
            i -= length;
            length = 9;
        }
        else {
            str = numStr.substr(0, i+1);
            i -= length;
        }

        if (str.length() < 12 && groups.size() > 0)
            str = str + "000";
        groups.push(str);
    }

    return groups;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x8280
movw $0xc, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3270
subq $0x1, %rax
movw %ax, -0x1e(%rbp)
movswl -0x1e(%rbp), %eax
cmpl $0x0, %eax
jl 0x798a
leaq -0x41(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x32e0
movq -0xd0(%rbp), %rdx
leaq 0x480a(%rip), %rsi      # 0xc01d
leaq -0x40(%rbp), %rdi
callq 0x6750
jmp 0x781e
leaq -0x41(%rbp), %rdi
callq 0x31f0
movswl -0x1e(%rbp), %eax
movswl -0x1c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jl 0x78bb
movq -0x18(%rbp), %rsi
movswl -0x1e(%rbp), %eax
movswq -0x1c(%rbp), %rcx
movl %ecx, %edx
subl %edx, %eax
incl %eax
movslq %eax, %rdx
leaq -0x78(%rbp), %rdi
callq 0x31b0
jmp 0x785b
leaq -0x40(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x3220
leaq -0x78(%rbp), %rdi
callq 0x3348
movswl -0x1c(%rbp), %ecx
movswl -0x1e(%rbp), %eax
subl %ecx, %eax
movw %ax, -0x1e(%rbp)
movw $0x9, -0x1c(%rbp)
jmp 0x7904
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x31f0
jmp 0x79b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3348
jmp 0x79b0
movq -0x18(%rbp), %rsi
movswl -0x1e(%rbp), %eax
incl %eax
movslq %eax, %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x98(%rbp), %rdi
callq 0x31b0
jmp 0x78da
leaq -0x40(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x3220
leaq -0x98(%rbp), %rdi
callq 0x3348
movswl -0x1c(%rbp), %ecx
movswl -0x1e(%rbp), %eax
subl %ecx, %eax
movw %ax, -0x1e(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3270
cmpq $0xc, %rax
jae 0x796a
movq -0xc8(%rbp), %rdi
callq 0x7ec0
movq %rax, -0xd8(%rbp)
jmp 0x7928
movq -0xd8(%rbp), %rax
cmpq $0x0, %rax
jbe 0x796a
leaq 0x4721(%rip), %rdx      # 0xc05d
leaq -0xb8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x8200
jmp 0x794e
leaq -0x40(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x3220
leaq -0xb8(%rbp), %rdi
callq 0x3348
movq -0xc8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x82b0
jmp 0x797c
leaq -0x40(%rbp), %rdi
callq 0x3348
jmp 0x77e8
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x79a0
movq -0xc8(%rbp), %rdi
callq 0x7f40
movq -0xc0(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0xc8(%rbp), %rdi
callq 0x7f40
movq -0x50(%rbp), %rdi
callq 0x32d0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x8280
movq -0x18(%rbp), %rdi
callq 0x3270
subq $0x1, %rax
movw %ax, -0x1c(%rbp)
movswl -0x1c(%rbp), %eax
cmpl $0x0, %eax
jl 0x7ae1
movswl -0x1c(%rbp), %eax
cmpl $0x2, %eax
jl 0x7a82
movq -0x18(%rbp), %rsi
movswl -0x1c(%rbp), %eax
addl $-0x2, %eax
movslq %eax, %rdx
leaq -0x40(%rbp), %rdi
movl $0x3, %ecx
callq 0x31b0
jmp 0x7a40
movq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x82e0
jmp 0x7a4f
leaq -0x40(%rbp), %rdi
callq 0x3348
jmp 0x7acf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x7b01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3348
jmp 0x7b01
movq -0x18(%rbp), %rsi
movswl -0x1c(%rbp), %eax
incl %eax
movslq %eax, %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x70(%rbp), %rdi
callq 0x31b0
jmp 0x7a9e
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x82e0
jmp 0x7aad
leaq -0x70(%rbp), %rdi
callq 0x3348
jmp 0x7acf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3348
jmp 0x7b01
jmp 0x7ad1
movswl -0x1c(%rbp), %eax
subl $0x3, %eax
movw %ax, -0x1c(%rbp)
jmp 0x7a0c
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x7af4
movq -0x80(%rbp), %rdi
callq 0x7f40
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x7f40
movq -0x48(%rbp), %rdi
callq 0x32d0
nopw %cs:(%rax,%rax)
// File: mmoanis[P]mpegts_demux/mpegts_demux.cpp
// Function: main
int main(int argc, char *argv[])
{
    print_banner(cout);

    /// CMD LINE OPTIONS
    const char  *filename = NULL;
    bool info = false;
    switch(argc) {
        case 2:
            filename = argv[1];
            break;
        case 3:
            if (strncmp(argv[1], "-i", 3) == 0) {
                info = true;
                filename = argv[2];
                break;
            }
            // fall through
        default:
            print_usage(cerr);
            return -1;
    }

    MpegTsBitStream bitStream(filename);
    MpegTsDemuxer demuxer(info);
    Packet packet;

    while (bitStream.good() && bitStream.GetPacket(packet)) {
        if (!demuxer.DecodePacket(packet))
            break;
    }
}

// Assembly:
subq $0x1a8, %rsp            # imm = 0x1A8
movl $0x0, 0x1a4(%rsp)
movl %edi, 0x1a0(%rsp)
movq %rsi, 0x198(%rsp)
movq 0xabb8(%rip), %rdi      # 0xcfd0
callq 0x25f0
movq $0x0, 0x190(%rsp)
movb $0x0, 0x18f(%rsp)
movl 0x1a0(%rsp), %eax
movl %eax, 0xc(%rsp)
subl $0x2, %eax
je 0x244e
jmp 0x2443
movl 0xc(%rsp), %eax
subl $0x3, %eax
je 0x2464
jmp 0x24a6
movq 0x198(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x190(%rsp)
jmp 0x24c2
movq 0x198(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x6b8d(%rip), %rsi      # 0x9004
movl $0x3, %edx
callq 0x20a0
cmpl $0x0, %eax
jne 0x24a4
movb $0x1, 0x18f(%rsp)
movq 0x198(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x190(%rsp)
jmp 0x24c2
jmp 0x24a6
movq 0xab43(%rip), %rdi      # 0xcff0
callq 0x2620
movl $0xffffffff, 0x1a4(%rsp) # imm = 0xFFFFFFFF
jmp 0x25bf
movq 0x190(%rsp), %rsi
leaq 0x178(%rsp), %rdi
callq 0x2720
movzbl 0x18f(%rsp), %esi
andl $0x1, %esi
leaq 0xd8(%rsp), %rdi
callq 0x2c70
jmp 0x24f1
jmp 0x24f3
leaq 0x178(%rsp), %rdi
callq 0x26f0
movb %al, 0xb(%rsp)
jmp 0x2506
movb 0xb(%rsp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xa(%rsp)
jne 0x2517
jmp 0x2539
leaq 0x178(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2820
movb %al, 0x9(%rsp)
jmp 0x252f
movb 0x9(%rsp), %al
movb %al, 0xa(%rsp)
jmp 0x2539
movb 0xa(%rsp), %al
testb $0x1, %al
jne 0x2543
jmp 0x25a5
leaq 0xd8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2ee0
movb %al, 0x8(%rsp)
jmp 0x255b
movb 0x8(%rsp), %al
testb $0x1, %al
jne 0x25a0
jmp 0x2565
jmp 0x25a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x25ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0xd8(%rsp), %rdi
callq 0x2e30
jmp 0x25ce
jmp 0x24f3
leaq 0xd8(%rsp), %rdi
callq 0x2e30
leaq 0x178(%rsp), %rdi
callq 0x27e0
movl 0x1a4(%rsp), %eax
addq $0x1a8, %rsp            # imm = 0x1A8
retq
leaq 0x178(%rsp), %rdi
callq 0x27e0
movq 0xd0(%rsp), %rdi
callq 0x2220
nopl (%rax,%rax)
// File: mmoanis[P]mpegts_demux/mpegts_demux.cpp
// Function: print_usage(std::ostream&)
static void print_usage(ostream& out)
{
    out << "usage: mpegts_demux [-i] input_file" << endl;
    out << "    Read MPEG-TS files and dump all video/audio streams to disk." << endl;
    out << "    Each stream dumped to disk, will be named [video|audio]_streamid" << endl;
    out << "Options:" << endl;
    out << " -i Read PAT/PMT data to identify programs." << endl;
    out << "    Default is to just read PES." << endl;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
leaq 0x69e9(%rip), %rsi      # 0x9019
callq 0x2140
movq %rax, %rdi
movq 0xa981(%rip), %rsi      # 0xcfc0
callq 0x2180
movq (%rsp), %rdi
leaq 0x69ee(%rip), %rsi      # 0x903d
callq 0x2140
movq %rax, %rdi
movq 0xa962(%rip), %rsi      # 0xcfc0
callq 0x2180
movq (%rsp), %rdi
leaq 0x6a10(%rip), %rsi      # 0x907e
callq 0x2140
movq %rax, %rdi
movq 0xa943(%rip), %rsi      # 0xcfc0
callq 0x2180
movq (%rsp), %rdi
leaq 0x6a36(%rip), %rsi      # 0x90c3
callq 0x2140
movq %rax, %rdi
movq 0xa924(%rip), %rsi      # 0xcfc0
callq 0x2180
movq (%rsp), %rdi
leaq 0x6a20(%rip), %rsi      # 0x90cc
callq 0x2140
movq %rax, %rdi
movq 0xa905(%rip), %rsi      # 0xcfc0
callq 0x2180
movq (%rsp), %rdi
leaq 0x6a2d(%rip), %rsi      # 0x90f8
callq 0x2140
movq %rax, %rdi
movq 0xa8e6(%rip), %rsi      # 0xcfc0
callq 0x2180
popq %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq $0x0, (%rax)
movb $0x0, 0x8(%rax)
movb $0x1, 0x9(%rax)
cmpq $0x0, 0x8(%rsp)
je 0x2750
jmp 0x276f
leaq 0x69c2(%rip), %rdi      # 0x9119
leaq 0x69cc(%rip), %rsi      # 0x912a
movl $0x9, %edx
leaq 0x69d4(%rip), %rcx      # 0x913e
callq 0x20c0
movq 0x8(%rsp), %rdi
leaq 0x69f2(%rip), %rsi      # 0x916d
callq 0x2190
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x27d0
movq 0xa859(%rip), %rdi      # 0xcff0
leaq 0x69d2(%rip), %rsi      # 0x9170
callq 0x2140
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x2140
movq %rax, %rdi
leaq 0x6a80(%rip), %rsi      # 0x923a
callq 0x2140
movq %rax, %rdi
movq 0xa7f7(%rip), %rsi      # 0xcfc0
callq 0x2180
jmp 0x27d8
movq (%rsp), %rax
movb $0x0, 0x9(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, (%rax)
je 0x284c
movq 0x10(%rsp), %rdi
callq 0x26f0
testb $0x1, %al
jne 0x2856
movb $0x0, 0x47(%rsp)
jmp 0x29d8
movq 0x30(%rsp), %rdi
callq 0x2a00
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq $0x1, 0x20(%rsp)
movq (%rax), %rdi
callq 0x21e0
movl %eax, 0x1c(%rsp)
cmpl $-0x1, 0x1c(%rsp)
jne 0x289c
movq 0x10(%rsp), %rax
movb $0x1, 0x8(%rax)
movb $0x0, 0x47(%rsp)
jmp 0x29d8
movl 0x1c(%rsp), %eax
movb %al, 0x1b(%rsp)
movzbl 0x1b(%rsp), %eax
cmpl $0x47, %eax
je 0x28e3
movq 0xa73b(%rip), %rdi      # 0xcff0
leaq 0x68cf(%rip), %rsi      # 0x918b
callq 0x2140
movq %rax, %rdi
movq 0xa6f5(%rip), %rsi      # 0xcfc0
callq 0x2180
movq 0x10(%rsp), %rax
movb $0x1, 0x9(%rax)
movb $0x0, 0x47(%rsp)
jmp 0x29d8
movb 0x1b(%rsp), %cl
movq 0x28(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x28(%rsp)
movb %cl, (%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x2a10
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0x296d
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x21e0
movl %eax, 0x1c(%rsp)
cmpl $-0x1, 0x1c(%rsp)
jne 0x293e
movq 0x10(%rsp), %rax
movb $0x1, 0x8(%rax)
jmp 0x296d
movl 0x1c(%rsp), %eax
movb %al, 0x1b(%rsp)
movb 0x1b(%rsp), %cl
movq 0x28(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x28(%rsp)
movb %cl, (%rax)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x28fa
cmpq $0xbc, 0x20(%rsp)
je 0x29d3
movq 0xa671(%rip), %rdi      # 0xcff0
leaq 0x6823(%rip), %rsi      # 0x91a9
callq 0x2140
movq %rax, %rdi
movl $0xbc, %esi
callq 0x2210
movq %rax, %rdi
leaq 0x681a(%rip), %rsi      # 0x91bc
callq 0x2140
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x2040
movq %rax, %rdi
movq 0xa602(%rip), %rsi      # 0xcfc0
callq 0x2180
movq 0x10(%rsp), %rax
movb $0x1, 0x9(%rax)
movb $0x0, 0x47(%rsp)
jmp 0x29d8
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movw %cx, %ax
movw %dx, %cx
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movw %cx, 0x16(%rsp)
movw %ax, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, (%rax)
movw 0x16(%rsp), %cx
movw %cx, 0x8(%rax)
movw 0x14(%rsp), %cx
movw %cx, 0xa(%rax)
cmpq $0x0, 0x18(%rsp)
je 0x2a7b
jmp 0x2a9a
leaq 0x6697(%rip), %rdi      # 0x9119
leaq 0x6753(%rip), %rsi      # 0x91dc
movl $0x1d, %edx
leaq 0x6757(%rip), %rcx      # 0x91ec
callq 0x20c0
movq 0x18(%rsp), %rdi
leaq 0x676d(%rip), %rsi      # 0x9213
callq 0x2190
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x2b3a
movq 0xa52d(%rip), %rdi      # 0xcff0
leaq 0x674c(%rip), %rsi      # 0x9216
callq 0x2140
movq %rax, %rdi
movq 0x8(%rsp), %rax
movzwl 0x8(%rax), %esi
callq 0x2200
movq %rax, %rdi
leaq 0x676b(%rip), %rsi      # 0x9255
callq 0x2140
movq %rax, %rdi
movq 0x8(%rsp), %rax
movzwl 0xa(%rax), %esi
callq 0x2200
movq %rax, %rdi
leaq 0x671d(%rip), %rsi      # 0x9227
callq 0x2140
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x2140
movq %rax, %rdi
leaq 0x6714(%rip), %rsi      # 0x923a
callq 0x2140
movq %rax, %rdi
movq 0xa48b(%rip), %rsi      # 0xcfc0
callq 0x2180
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rax)
jne 0x2ba7
jmp 0x2c60
jmp 0x2ba9
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x2c60
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rsp)
movzbl (%rcx), %edi
movq (%rax), %rsi
callq 0x21a0
movl %eax, 0xc(%rsp)
cmpl $-0x1, 0xc(%rsp)
jne 0x2c5b
movq 0xa405(%rip), %rdi      # 0xcff0
leaq 0x6624(%rip), %rsi      # 0x9216
callq 0x2140
movq %rax, %rdi
movq (%rsp), %rax
movzwl 0x8(%rax), %esi
callq 0x2200
movq %rax, %rdi
leaq 0x6644(%rip), %rsi      # 0x9255
callq 0x2140
movq %rax, %rdi
movq (%rsp), %rax
movzwl 0xa(%rax), %esi
callq 0x2200
movq %rax, %rdi
leaq 0x660c(%rip), %rsi      # 0x923c
callq 0x2140
movq %rax, %rdi
movq 0xa381(%rip), %rsi      # 0xcfc0
callq 0x2180
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x2150
movq (%rsp), %rax
movq $0x0, (%rax)
jmp 0x2ba9
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mmoanis[P]mpegts_demux/MpegTsDemux.cpp
// Function: MpegTsDemuxer::MpegTsDemuxer(bool)
MpegTsDemuxer::MpegTsDemuxer(bool info)
    : m_pnum(0), m_info(info)
{
    // Ignore all packets except PES by default, except when requested.
    if (m_info) {
        // List know PIDs in the filters.
        m_filters.insert(make_pair(MPEGTS_PID_NULL, DEMUXER_EVENT_NIL));
        m_filters.insert(make_pair(MPEGTS_PID_PAT, DEMUXER_EVENT_PAT));
    }
}

// Assembly:
subq $0xb8, %rsp
movb %sil, %al
movq %rdi, 0xb0(%rsp)
andb $0x1, %al
movb %al, 0xaf(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x50(%rsp)
callq 0x5590
movq 0x50(%rsp), %rdi
addq $0x30, %rdi
movq %rdi, 0x40(%rsp)
callq 0x55a0
movq 0x50(%rsp), %rdi
addq $0x60, %rdi
movq %rdi, 0x48(%rsp)
callq 0x55b0
movq 0x50(%rsp), %rax
movq $0x0, 0x90(%rax)
movb 0xaf(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x98(%rax)
testb $0x1, 0x98(%rax)
je 0x2e0f
movq 0x50(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x30(%rsp)
movl $0x1fff, 0xa0(%rsp) # imm = 0x1FFF
movl $0x4, 0x9c(%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0x9c(%rsp), %rsi
callq 0x5610
movq %rax, 0x38(%rsp)
jmp 0x2d30
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0xa4(%rsp)
leaq 0xa4(%rsp), %rsi
callq 0x55c0
movb %dl, 0x27(%rsp)
movq %rax, 0x28(%rsp)
jmp 0x2d5a
movq 0x50(%rsp), %rax
movb 0x27(%rsp), %cl
movq 0x28(%rsp), %rdx
movq %rdx, 0x78(%rsp)
movb %cl, 0x80(%rsp)
addq $0x60, %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x6c(%rsp)
movl $0x3, 0x68(%rsp)
leaq 0x6c(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x5610
movq %rax, 0x18(%rsp)
jmp 0x2da3
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x70(%rsp), %rsi
callq 0x55c0
movb %dl, 0x7(%rsp)
movq %rax, 0x8(%rsp)
jmp 0x2dc7
movb 0x7(%rsp), %al
movq 0x8(%rsp), %rcx
movq %rcx, 0x58(%rsp)
movb %al, 0x60(%rsp)
jmp 0x2e0f
movq 0x48(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
callq 0x5640
movq 0x40(%rsp), %rdi
callq 0x5650
movq 0x50(%rsp), %rdi
callq 0x5660
jmp 0x2e17
addq $0xb8, %rsp
retq
movq 0x90(%rsp), %rdi
callq 0x2220
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
addq $0x4, %rax
cmpq 0x18(%rsp), %rax
jb 0x4524
movq 0x8b14(%rip), %rdi      # 0xcff0
leaq 0x4d93(%rip), %rsi      # 0x9276
callq 0x2140
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq 0x90(%rax), %rsi
callq 0x2040
movq %rax, %rdi
leaq 0x505b(%rip), %rsi      # 0x9561
callq 0x2140
movq %rax, %rdi
movq 0x8aab(%rip), %rsi      # 0xcfc0
callq 0x2180
movb $0x0, 0x37(%rsp)
jmp 0x4647
movq 0x20(%rsp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
shll $0x8, %eax
movzwl %ax, %eax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movzbl 0x1(%rcx), %ecx
movzwl %cx, %ecx
orl %ecx, %eax
movw %ax, %cx
movq 0x10(%rsp), %rax
movw %cx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
andl $0xc0, %eax
sarl $0x6, %eax
cmpl $0x3, %eax
je 0x45c7
movq 0x8a71(%rip), %rdi      # 0xcff0
leaq 0x4cf0(%rip), %rsi      # 0x9276
callq 0x2140
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq 0x90(%rax), %rsi
callq 0x2040
movq %rax, %rdi
leaq 0x4fd9(%rip), %rsi      # 0x9582
callq 0x2140
movq %rax, %rdi
movq 0x8a08(%rip), %rsi      # 0xcfc0
callq 0x2180
movb $0x0, 0x37(%rsp)
jmp 0x4647
movq 0x20(%rsp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
andl $0x3e, %eax
sarl %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, 0x2(%rax)
movq 0x20(%rsp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %cl
movq 0x10(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x3(%rax)
movq 0x20(%rsp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb (%rax), %cl
movq 0x10(%rsp), %rax
movb %cl, 0x4(%rax)
movq 0x20(%rsp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb (%rax), %cl
movq 0x10(%rsp), %rax
movb %cl, 0x5(%rax)
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x17(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
addq $0x3, %rax
cmpq 0x18(%rsp), %rax
jae 0x47a8
movq 0x20(%rsp), %rax
movq (%rax), %rax
movzbl 0x4(%rax), %eax
cmpl $0xff, %eax
jne 0x46b1
jmp 0x47a8
movq 0x20(%rsp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
shll $0x8, %eax
movzwl %ax, %eax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movzbl 0x1(%rcx), %ecx
movzwl %cx, %ecx
orl %ecx, %eax
movw %ax, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
andl $0xe0, %eax
sarl $0x5, %eax
cmpl $0x7, %eax
je 0x474e
movq 0x88ea(%rip), %rdi      # 0xcff0
leaq 0x4b69(%rip), %rsi      # 0x9276
callq 0x2140
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq 0x90(%rax), %rsi
callq 0x2040
movq %rax, %rdi
leaq 0x4c34(%rip), %rsi      # 0x9364
callq 0x2140
movq %rax, %rdi
movq 0x8881(%rip), %rsi      # 0xcfc0
callq 0x2180
movb $0x0, 0x37(%rsp)
jmp 0x47fe
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
andl $0x1f, %eax
shll $0x8, %eax
movzwl %ax, %eax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movzbl 0x1(%rcx), %ecx
movzwl %cx, %ecx
orl %ecx, %eax
movw %ax, 0x12(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movw 0x14(%rsp), %ax
movzwl %ax, %esi
movzwl 0x12(%rsp), %edx
callq 0x4810
movb $0x1, 0x17(%rsp)
jmp 0x4682
testb $0x1, 0x17(%rsp)
jne 0x47f4
movq 0x883a(%rip), %rdi      # 0xcff0
leaq 0x4ab9(%rip), %rsi      # 0x9276
callq 0x2140
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq 0x90(%rax), %rsi
callq 0x2040
movq %rax, %rdi
leaq 0x4ba0(%rip), %rsi      # 0x9380
callq 0x2140
movq %rax, %rdi
movq 0x87d1(%rip), %rsi      # 0xcfc0
callq 0x2180
movb 0x17(%rsp), %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: mmoanis[P]mpegts_demux/MpegTsDemux.cpp
// Function: GetFileName[abi:cxx11](bool, unsigned short, unsigned short)
static string GetFileName(bool video, PID id, PID prog)
{
    stringstream ss;
    ss << (video? "video" : "audio") << "_id_";
    ss << id;
    //ss << "_prog_";
    //ss << prog;
    return ss.str();
}

// Assembly:
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, 0x18(%rsp)
movw %cx, %ax
movw %dx, %cx
movb %sil, %dl
movq %rdi, %rsi
movq %rsi, 0x20(%rsp)
movq %rdi, 0x1d0(%rsp)
andb $0x1, %dl
movb %dl, 0x1cf(%rsp)
movw %cx, 0x1cc(%rsp)
movw %ax, 0x1ca(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x20e0
leaq 0x40(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x28(%rsp)
testb $0x1, 0x1cf(%rsp)
je 0x54ef
leaq 0x4192(%rip), %rax      # 0x967a
movq %rax, 0x10(%rsp)
jmp 0x54fd
leaq 0x418a(%rip), %rax      # 0x9680
movq %rax, 0x10(%rsp)
jmp 0x54fd
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2140
movq %rax, 0x8(%rsp)
jmp 0x5513
movq 0x8(%rsp), %rdi
leaq 0x4167(%rip), %rsi      # 0x9686
callq 0x2140
jmp 0x5526
leaq 0x50(%rsp), %rdi
movzwl 0x1cc(%rsp), %esi
callq 0x2200
jmp 0x553a
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2130
jmp 0x554b
leaq 0x40(%rsp), %rdi
callq 0x20f0
movq 0x20(%rsp), %rax
addq $0x1d8, %rsp            # imm = 0x1D8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x20f0
movq 0x38(%rsp), %rdi
callq 0x2220
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x20b0
movl -0xc(%rbp), %ecx
addl $0x9e3779b1, %ecx       # imm = 0x9E3779B1
addl $0x85ebca77, %ecx       # imm = 0x85EBCA77
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %ecx
addl $0x85ebca77, %ecx       # imm = 0x85EBCA77
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0xc(%rbp), %ecx
addl $0x0, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0xc(%rbp), %ecx
subl $0x9e3779b1, %ecx       # imm = 0x9E3779B1
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x2a48
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
roll %eax
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %ecx
roll $0x7, %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
roll $0xc, %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movl 0x14(%rcx), %ecx
roll $0x12, %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x2a57
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x165667b1, %eax       # imm = 0x165667B1
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x2a90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x20b0
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
addq -0x10(%rbp), %rcx
movabsq $-0x3d4d51c2d82b14b1, %rax # imm = 0xC2B2AE3D27D4EB4F
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movabsq $-0x3d4d51c2d82b14b1, %rcx # imm = 0xC2B2AE3D27D4EB4F
addq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
addq $0x0, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
subq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH64_round(unsigned long, unsigned long)
static xxh_u64 XXH64_round(xxh_u64 acc, xxh_u64 input)
{
    acc += input * XXH_PRIME64_2;
    acc  = XXH_rotl64(acc, 31);
    acc *= XXH_PRIME64_1;
    return acc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movabsq $-0x3d4d51c2d82b14b1, %rax # imm = 0xC2B2AE3D27D4EB4F
imulq -0x10(%rbp), %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
rolq $0x1f, %rax
movq %rax, -0x8(%rbp)
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
imulq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)