LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/gulshan216[P]Perceptron_Based_Reuse_Prediction/replacement_state.cpp
// Function: CACHE_REPLACEMENT_STATE::PrintStats(std::ostream&)
ostream & CACHE_REPLACEMENT_STATE::PrintStats(ostream &out)
{

    out<<"=========================================================="<<endl;
    out<<"=========== Replacement Policy Statistics ================"<<endl;
    out<<"=========================================================="<<endl;

    // CONTESTANTS:  Insert your statistics printing here
    
    return out;

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x183b28(%rip), %r14    # 0x5899b0
movl $0x3a, %edx
movq %rsi, %rdi
movq %r14, %rsi
callq 0x47f990
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x460ae0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x47f490
movq %rax, %rdi
callq 0x47ea60
leaq 0x183b25(%rip), %rsi    # 0x5899eb
movl $0x3a, %edx
movq %rbx, %rdi
callq 0x47f990
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x460ae0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x47f490
movq %rax, %rdi
callq 0x47ea60
movl $0x3a, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x47f990
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x460ae0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x47f490
movq %rax, %rdi
callq 0x47ea60
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/gulshan216[P]Perceptron_Based_Reuse_Prediction/replacement_state.cpp
// Function: init_sampler_cache(sampler_cache*, int, int, int, int)
void init_sampler_cache (sampler_cache *c, int nsets, int assoc, int blocksize, int replacement_policy) {
	int i, j,k,l;
	c->sets = new sampler_set[nsets];
	c->replacement_policy = replacement_policy;
	// c->repl = new CACHE_REPLACEMENT_STATE (nsets, assoc, replacement_policy);
	// c->set_shift = set_shift;
	c->nsets = nsets;
	c->assoc = assoc;
	c->blocksize = blocksize;
	c->offset_bits = log2 (blocksize);
	c->index_bits = log2 (nsets);
	c->tagshiftbits = c->offset_bits + c->index_bits;
	c->index_mask = nsets - 1;
	c->misses = 0;
	c->accesses = 0;
	c->hits = 0;
	c->evictions = 0;
	// memset (c->counts, 0, sizeof (c->counts));
	for (i=0; i<nsets; i++) {
		for (j=0; j<assoc; j++) {
			sampler_block *b = &c->sets[i].blocks[j];
			b->tag = 0;
			b->valid = 0;
			b->Yout = 0;
			for(k=0;k<6;k++)
			{
				b->hash[k]=0;
			}
		}
		c->sets[i].valid = 0;
	}
	for(l=0;l<16;l++)
	{
		memset (PC_History[l], 0, sizeof(PC_History[0]));
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movl %ecx, %ebp
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
movslq %esi, %r13
movl $0x308, %ecx            # imm = 0x308
movq %r13, %rax
mulq %rcx
movq $-0x1, %rdi
cmovnoq %rax, %rdi
callq 0x417c10
testl %r13d, %r13d
je 0x406022
imulq $0x308, %r13, %rdx      # imm = 0x308
movq %rax, %rcx
addq %rdx, %rcx
movq %rax, %rdx
movl $0x14, %esi
movb $0x0, (%rdx,%rsi)
movq $0x0, -0xc(%rdx,%rsi)
movl $0x0, -0x4(%rdx,%rsi)
addq $0x30, %rsi
cmpq $0x314, %rsi            # imm = 0x314
jne 0x405fd9
movb $0x0, 0x300(%rdx)
movq %rdx, %rsi
xorl %edi, %edi
movl %edi, (%rsi)
incq %rdi
addq $0x30, %rsi
cmpq $0x10, %rdi
jne 0x406007
addq $0x308, %rdx            # imm = 0x308
cmpq %rcx, %rdx
jne 0x405fd4
movq %rax, 0x40(%r14)
movl %r12d, 0x14(%r14)
movl %r15d, (%r14)
movl %ebx, 0x4(%r14)
movl %ebp, 0x8(%r14)
movl %ebp, %edi
callq 0x405f3c
movl %eax, 0xc(%r14)
movl %r15d, %edi
callq 0x405f3c
movl %eax, 0x10(%r14)
addl 0xc(%r14), %eax
movl %eax, 0x18(%r14)
leal -0x1(%r15), %eax
movl %eax, 0x1c(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x30(%r14)
testl %r15d, %r15d
jle 0x4060df
movq 0x40(%r14), %rax
movl %r15d, %ecx
movl %ebx, %edx
shlq $0x4, %rdx
leaq (%rdx,%rdx,2), %rdx
movl $0x18, %esi
xorl %edi, %edi
movl $0x308, %r8d            # imm = 0x308
xorl %r9d, %r9d
testl %ebx, %ebx
jle 0x4060c4
movq 0x40(%r14), %r10
addq %rsi, %r10
xorl %r11d, %r11d
movq %rdi, -0x10(%r10,%r11)
movb $0x0, -0x4(%r10,%r11)
movl $0x0, -0x8(%r10,%r11)
movups %xmm0, (%r10,%r11)
movq %rdi, 0x10(%r10,%r11)
addq $0x30, %r11
cmpq %r11, %rdx
jne 0x40609d
imulq $0x308, %r9, %r10       # imm = 0x308
movb $0x0, 0x300(%rax,%r10)
incq %r9
addq %r8, %rsi
cmpq %rcx, %r9
jne 0x40608f
leaq 0x1fb08a(%rip), %rdi    # 0x601170
movl $0x180, %edx            # imm = 0x180
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x401060
// File: /workspace/github_cpp_makefile_star2_O1/gulshan216[P]Perceptron_Based_Reuse_Prediction/replacement_state.cpp
// Function: Update_sampler_LRU(unsigned int, int)
void Update_sampler_LRU(UINT32 setIndex, INT32 updateWayID)
{
	sampler_block *v = &sampler.sets[setIndex].blocks[0];
		// Determine current LRU stack position
	UINT32 currLRUstackposition = v[updateWayID].lru_stack_position;

	// Update the stack position of all lines before the current line
	// Update implies incremeting their stack positions by one

	for(UINT32 way=0; way<SAMPLER_ASSOC; way++) {
		if( v[way].lru_stack_position < currLRUstackposition ) {
			v[way].lru_stack_position++;
		}
	}

	// Set the LRU stack position of new line to be zero
	v[updateWayID].lru_stack_position = 0;
}

// Assembly:
movl %edi, %eax
imulq $0x308, %rax, %rax      # imm = 0x308
addq 0x1f9fa6(%rip), %rax    # 0x600568
movslq %esi, %rcx
leaq (%rcx,%rcx,2), %rdx
shlq $0x4, %rdx
leaq (%rax,%rdx), %rcx
movl (%rdx,%rax), %edx
xorl %esi, %esi
movl (%rax,%rsi), %edi
cmpl %edx, %edi
jae 0x4065e2
incl %edi
movl %edi, (%rax,%rsi)
addq $0x30, %rsi
cmpq $0x300, %rsi            # imm = 0x300
jne 0x4065d6
movl $0x0, (%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/gulshan216[P]Perceptron_Based_Reuse_Prediction/replacement_state.cpp
// Function: CACHE_REPLACEMENT_STATE::GetVictimInSet(unsigned int, unsigned int, LINE_STATE const*, unsigned int, unsigned long long, unsigned long long, unsigned int)
INT32 CACHE_REPLACEMENT_STATE::GetVictimInSet( UINT32 tid, UINT32 setIndex, const LINE_STATE *vicSet, UINT32 assoc, Addr_t PC, Addr_t paddr, UINT32 accessType ) {
    // If no invalid lines, then replace based on replacement policy
    if( replPolicy == CRC_REPL_LRU ) 
    {
        return Get_LRU_Victim( setIndex);
    }
    else if( replPolicy == CRC_REPL_RANDOM )
    {
        return Get_Random_Victim( setIndex );
    }
    else if( replPolicy == CRC_REPL_CONTESTANT )
    {
    	if(accessType ==5)
    	{
    		// Contestants:  ADD YOUR VICTIM SELECTION FUNCTION HERE
			// return Get_My_Victim (tid,setIndex, PC, paddr);
			PC = 0x12345678;
    	}
    	return Get_My_Victim (tid,setIndex, PC, paddr);
    	// else
    	// {
    	// 	return -1;
    	// }
        
    }

    // We should never here here

    assert(0);
    return -1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %eax
cmpl $0x2, %eax
je 0x406668
cmpl $0x1, %eax
je 0x40665a
testl %eax, %eax
jne 0x406687
movl 0xc(%rbx), %ecx
testq %rcx, %rcx
je 0x406656
movq (%rbx), %rax
movl %edx, %edx
movq (%rax,%rdx,8), %rdx
leal -0x1(%rcx), %esi
xorl %eax, %eax
cmpl %esi, (%rdx,%rax,8)
je 0x406666
incq %rax
cmpq %rax, %rcx
jne 0x406649
xorl %eax, %eax
jmp 0x406666
callq 0x4d34a0
xorl %edx, %edx
divl 0xc(%rbx)
movl %edx, %eax
popq %rbx
retq
movq 0x10(%rsp), %r8
cmpl $0x5, 0x18(%rsp)
movl $0x12345678, %eax       # imm = 0x12345678
cmoveq %rax, %r9
movq %rbx, %rdi
movq %r9, %rcx
popq %rbx
jmp 0x4066de
leaq 0x18317b(%rip), %rdi    # 0x589809
leaq 0x183391(%rip), %rsi    # 0x589a26
leaq 0x1833ae(%rip), %rcx    # 0x589a4a
movl $0x148, %edx            # imm = 0x148
callq 0x4cc560
// File: /workspace/github_cpp_makefile_star2_O1/gulshan216[P]Perceptron_Based_Reuse_Prediction/replacement_state.cpp
// Function: CACHE_REPLACEMENT_STATE::UpdateReplacementState(unsigned int, int, LINE_STATE const*, unsigned int, unsigned long long, unsigned int, bool)
void CACHE_REPLACEMENT_STATE::UpdateReplacementState( 
    UINT32 setIndex, INT32 updateWayID, const LINE_STATE *currLine, 
    UINT32 tid, Addr_t PC, UINT32 accessType, bool cacheHit )
{
	//fprintf (stderr, "ain't I a stinker? %lld\n", get_cycle_count ());
	//fflush (stderr);
    // What replacement policy?
    if( replPolicy == CRC_REPL_LRU ) 
    {
        UpdateLRU( setIndex, updateWayID);
    }
    else if( replPolicy == CRC_REPL_RANDOM )
    {
        // Random replacement requires no replacement state update
    }
    else if( replPolicy == CRC_REPL_CONTESTANT )
    {
    	if(accessType ==5)
    	{
    		// Contestants:  ADD YOUR VICTIM SELECTION FUNCTION HERE
			// return Get_My_Victim (tid,setIndex, PC, paddr);
			PC = 0x12345678;
    	}
    	// if(accessType !=5)
    	// {
    		// Contestants:  ADD YOUR UPDATE REPLACEMENT STATE FUNCTION HERE
	        // Feel free to use any of the input parameters to make
	        // updates to your replacement policy
	        UpdateMyPolicy(tid, setIndex, updateWayID, currLine, PC, accessType, cacheHit);
    	// }
        
    }
}

// Assembly:
movq %rcx, %rax
movl %edx, %ecx
movl %esi, %edx
movl 0x10(%rdi), %esi
cmpl $0x2, %esi
je 0x40683a
testl %esi, %esi
jne 0x406839
movq (%rdi), %rax
movl %edx, %edx
movq (%rax,%rdx,8), %rax
movslq %ecx, %rcx
movl 0xc(%rdi), %edx
testq %rdx, %rdx
je 0x406832
movl (%rax,%rcx,8), %esi
xorl %edi, %edi
movl (%rax,%rdi,8), %r8d
cmpl %esi, %r8d
jae 0x40682a
incl %r8d
movl %r8d, (%rax,%rdi,8)
incq %rdi
cmpq %rdi, %rdx
jne 0x40681a
movl $0x0, (%rax,%rcx,8)
retq
cmpl $0x5, 0x8(%rsp)
movl $0x12345678, %esi       # imm = 0x12345678
cmoveq %rsi, %r9
movl %r8d, %esi
movq %rax, %r8
jmp 0x40688e
nop
// File: /workspace/github_cpp_makefile_star2_O1/gulshan216[P]Perceptron_Based_Reuse_Prediction/replacement_state.cpp
// Function: CACHE_REPLACEMENT_STATE::UpdateLRU(unsigned int, int)
void CACHE_REPLACEMENT_STATE::UpdateLRU( UINT32 setIndex, INT32 updateWayID)
{
		// Determine current LRU stack position
	UINT32 currLRUstackposition = repl[ setIndex ][ updateWayID ].LRUstackposition;

	// Update the stack position of all lines before the current line
	// Update implies incremeting their stack positions by one

	for(UINT32 way=0; way<assoc; way++) {
		if( repl[setIndex][way].LRUstackposition < currLRUstackposition ) {
			repl[setIndex][way].LRUstackposition++;
		}
	}

	// Set the LRU stack position of new line to be zero
	repl[ setIndex ][ updateWayID ].LRUstackposition = 0;
	
}

// Assembly:
movq (%rdi), %rax
movl %esi, %ecx
movq (%rax,%rcx,8), %rax
movslq %edx, %rcx
movl 0xc(%rdi), %edx
testq %rdx, %rdx
je 0x406885
movl (%rax,%rcx,8), %esi
xorl %edi, %edi
movl (%rax,%rdi,8), %r8d
cmpl %esi, %r8d
jae 0x40687d
incl %r8d
movl %r8d, (%rax,%rdi,8)
incq %rdi
cmpq %rdi, %rdx
jne 0x40686d
movl $0x0, (%rax,%rcx,8)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/tommyds/test.c
// Function: test_int
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	tommy_hashlin h;
	tommy_hashlin_init(&h);
	for (i = 0, x = x0; i < n; ++i) {
		uint32_t key;
		intcell_t *p;
		x = hash32(x);
		key = get_key(n, x);
		p = tommy_hashlin_search(&h, compare, &key, hash_fn(key));
		if (!p) {
			p = malloc(sizeof(intcell_t));
			p->key = key, p->cnt = 1;
			tommy_hashlin_insert(&h, &p->node, p, hash_fn(key));
			++z;
		} else z += ++p->cnt;
	}
	fprintf(stderr, "# unique keys: %d; checksum: %u\n", tommy_hashlin_count(&h), z);
	x = tommy_hashlin_count(&h);
	tommy_hashlin_done(&h);
	return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movl %esi, %r12d
movl %edi, %r14d
leaq 0x8(%rsp), %rdi
callq 0x31ed
xorl %ebx, %ebx
testl %r14d, %r14d
je 0x1505
movl %r14d, %ebp
shrl $0x2, %ebp
xorl %ebx, %ebx
xorl %r15d, %r15d
movl %r12d, %eax
shll $0xf, %eax
notl %eax
addl %r12d, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
movl %eax, %r12d
shrl $0x10, %r12d
xorl %eax, %r12d
movl %r12d, %eax
xorl %edx, %edx
divl %ebp
movl %edx, %eax
shll $0xf, %eax
notl %eax
addl %edx, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
movl %eax, %r13d
shrl $0x10, %r13d
xorl %eax, %r13d
movl 0x118(%rsp), %eax
andl %r13d, %eax
movl 0x110(%rsp), %ecx
andl %r13d, %ecx
cmpl 0x11c(%rsp), %eax
cmovael %eax, %ecx
movl %ecx, %eax
orl $0x1, %eax
bsrl %eax, %eax
movq 0x8(%rsp,%rax,8), %rax
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x14bd
cmpl %r13d, 0x18(%rax)
jne 0x14b8
movq 0x10(%rax), %rcx
cmpl (%rcx), %r13d
je 0x14bf
movq (%rax), %rax
jmp 0x14a4
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x14ce
movl 0x4(%rcx), %eax
incl %eax
movl %eax, 0x4(%rcx)
jmp 0x14f7
pushq $0x28
popq %rdi
callq 0x1090
movl %r13d, (%rax)
movl $0x1, 0x4(%rax)
leaq 0x8(%rax), %rsi
leaq 0x8(%rsp), %rdi
movq %rax, %rdx
movl %r13d, %ecx
callq 0x32f2
pushq $0x1
popq %rax
addl %eax, %ebx
incl %r15d
cmpl %r14d, %r15d
jne 0x1412
movq 0x5aec(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x8(%rsp), %r14
movl 0x118(%r14), %edx
leaq 0x2b53(%rip), %rsi      # 0x4075
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1080
movl 0x118(%r14), %ebx
movq %r14, %rdi
callq 0x32a6
movl %ebx, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/xdsopl[P]FEC/tables_generator.cc
// Function: main
int main()
{
	std::cout << "/* generated by generator.cc */" << std::endl << std::endl;
	std::cout << "template <int M, int POLY, typename TYPE>" << std::endl;
	std::cout << "struct Tables {};" << std::endl << std::endl;

	// BBC WHP031 RS(15, 11) T=2
	GENERATOR(4, 0b10011, uint8_t);

	// DVB-T RS(255, 239) T=8
	GENERATOR(8, 0b100011101, uint8_t);

	// FUN RS(65535, 65471) T=32
	GENERATOR(16, 0b10001000000001011, uint16_t);

	// DVB-S2 FULL BCH(65535, 65343) T=12
	GENERATOR(16, 0b10000000000101101, uint16_t);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x3dc1(%rip), %rbx      # 0x4fd8
leaq 0x1de6(%rip), %rsi      # 0x3004
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x10a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
leaq 0x1da1(%rip), %rsi      # 0x3024
movl $0x29, %edx
movq %rbx, %rdi
callq 0x10a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
leaq 0x1d90(%rip), %rsi      # 0x304e
movl $0x11, %edx
movq %rbx, %rdi
callq 0x10a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
leaq 0x1d3d(%rip), %rbx      # 0x3060
movq %rbx, %rdi
callq 0x1354
movq %rbx, %rdi
callq 0x15a6
leaq 0x1d2e(%rip), %rbx      # 0x3068
movq %rbx, %rdi
callq 0x1850
movq %rbx, %rdi
callq 0x1b04
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/cpottamus[P]btree_lab/deletedisk.cc
// Function: main
int main(int argc, char *argv[])
{
  if (argc<2) { 
    usage();
    exit(-1);
  }

  remove((string(argv[1])+".data").c_str());
  remove((string(argv[1])+".bitmap").c_str());
  remove((string(argv[1])+".config").c_str());

  cerr << "Done.\n";

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpl $0x1, %edi
jle 0x144f
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x149e
leaq 0xdbd(%rip), %rsi       # 0x2020
leaq 0x30(%rsp), %rdi
callq 0x10e0
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1294
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x129b
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x10(%rsp), %rdi
callq 0x10d0
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x12d4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1070
leaq 0x40(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x12ef
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1070
movq 0x8(%rbx), %rsi
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x149e
leaq 0xd1d(%rip), %rsi       # 0x2026
leaq 0x30(%rsp), %rdi
callq 0x10e0
movq %r14, 0x10(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1336
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x133d
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x10(%rsp), %rdi
callq 0x10d0
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1376
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1070
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x138d
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1070
movq 0x8(%rbx), %rsi
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x149e
leaq 0xc87(%rip), %rsi       # 0x202e
leaq 0x30(%rsp), %rdi
callq 0x10e0
movq %r14, 0x10(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x13d4
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x13db
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x10(%rsp), %rdi
callq 0x10d0
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1414
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1070
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x142b
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1070
movq 0x2bbe(%rip), %rdi      # 0x3ff0
leaq 0xbfd(%rip), %rsi       # 0x2036
movl $0x6, %edx
callq 0x1080
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x121c
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1090
jmp 0x1462
jmp 0x1493
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
jne 0x1484
jmp 0x1496
jmp 0x1493
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1496
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1070
jmp 0x1496
movq %rax, %rbx
movq %rbx, %rdi
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/cpearce[P]OggIndex/src/Decoder.cpp
// Function: SkeletonDecoder::SkeletonDecoder(unsigned int)
SkeletonDecoder::SkeletonDecoder(ogg_uint32_t serial) :
  Decoder(serial),
  mGotAllHeaders(0),
  mVersionMajor(0),
  mVersionMinor(0),
  mVersion(0)
{
  for (ogg_uint32_t i=0; i<mPackets.size(); i++) {
    delete[] mPackets[i]->packet;
    mPackets[i]->packet = 0;
    delete mPackets[i];
  }
  ClearKeyframeIndex(mIndex);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x4aec
leaq 0x11f85(%rip), %rax     # 0x16af0
movq %rax, (%rbx)
leaq 0x1f0(%rbx), %rax
xorl %ecx, %ecx
movl %ecx, 0x1f0(%rbx)
movq %rcx, 0x1f8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1d8(%rbx)
movups %xmm0, 0x1c8(%rbx)
movups %xmm0, 0x1b8(%rbx)
movq %rax, 0x200(%rbx)
movq %rax, 0x208(%rbx)
movq %rcx, 0x210(%rbx)
movb $0x0, 0x218(%rbx)
movl %ecx, 0x21a(%rbx)
movl %ecx, 0x220(%rbx)
movq 0x1d0(%rbx), %rax
cmpq %rax, 0x1d8(%rbx)
je 0x4c31
movl $0x1, %ebp
xorl %r14d, %r14d
movq (%rax,%r14,8), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x4bed
callq 0x4490
movq 0x1d0(%rbx), %rax
movq (%rax,%r14,8), %rcx
movq $0x0, (%rcx)
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x4c12
movl $0x30, %esi
callq 0x43a0
movl %ebp, %r14d
movq 0x1d0(%rbx), %rax
movq 0x1d8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
incl %ebp
cmpq %r14, %rcx
ja 0x4bdc
addq $0x1e8, %rbx            # imm = 0x1E8
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4c44
// File: /workspace/github_cpp_makefile_star2_O1/cpearce[P]OggIndex/src/Decoder.cpp
// Function: ClearKeyframeIndex(std::map<unsigned int, std::vector<KeyFrameInfo, std::allocator<KeyFrameInfo>>*, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, std::vector<KeyFrameInfo, std::allocator<KeyFrameInfo>>*>>>&)
void ClearKeyframeIndex(KeyFrameIndex& index) {
  KeyFrameIndex::iterator itr = index.begin();
  while (itr != index.end()) {
    vector<KeyFrameInfo>* v = itr->second;
    delete v;
    itr++;
  }
  index.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
leaq 0x8(%rdi), %r12
cmpq %r12, %r14
je 0x4c96
movq 0x28(%r14), %r15
testq %r15, %r15
je 0x4c86
movq (%r15), %rdi
testq %rdi, %rdi
je 0x4c79
movq 0x10(%r15), %rsi
subq %rdi, %rsi
callq 0x43a0
movl $0x18, %esi
movq %r15, %rdi
callq 0x43a0
movq %r14, %rdi
callq 0x4260
movq %rax, %r14
cmpq %r12, %rax
jne 0x4c5c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7a1e
nop
// File: /workspace/github_cpp_makefile_star2_O1/cpearce[P]OggIndex/src/Decoder.cpp
// Function: Decoder::Create(ogg_page*)
Decoder* Decoder::Create(ogg_page* page)
{
  assert(ogg_page_bos(page));
  ogg_uint32_t serialno = ogg_page_serialno(page);
  if (page->body_len > 8 &&
      strncmp("theora", (const char*)page->body+1, 6) == 0)
  {
    return new TheoraDecoder(serialno);
  } else if (page->body_len > 8 &&
             strncmp("vorbis", (const char*)page->body+1, 6) == 0)
  {
    return new VorbisDecoder(serialno);
#ifdef HAVE_KATE
  } else if (page->body_len > 8 &&
             memcmp("kate\0\0\0", (const char*)page->body+1, 7) == 0)
  {
    return new KateDecoder(serialno);
#endif
  } else if (page->body_len > 8 &&
             strncmp("fishead", (const char*)page->body, 8) == 0)
  {
    return new SkeletonDecoder(serialno);
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x46f0
testl %eax, %eax
je 0x53e1
movq %r14, %rdi
callq 0x42d0
movq 0x18(%r14), %r15
cmpq $0x9, %r15
jl 0x538a
movl %eax, %ebx
movq 0x10(%r14), %rsi
incq %rsi
leaq 0xb39c(%rip), %rdi      # 0x106d7
movl $0x6, %edx
callq 0x41a0
testl %eax, %eax
je 0x538f
cmpq $0x9, %r15
jl 0x538a
movq 0x10(%r14), %rsi
incq %rsi
leaq 0xb4be(%rip), %rdi      # 0x1081b
movl $0x6, %edx
callq 0x41a0
testl %eax, %eax
je 0x53a8
cmpq $0x9, %r15
jl 0x538a
movq 0x10(%r14), %rsi
leaq 0xae50(%rip), %rdi      # 0x101cc
movl $0x8, %edx
callq 0x41a0
testl %eax, %eax
je 0x53c1
xorl %r14d, %r14d
jmp 0x53d8
movl $0x290, %edi            # imm = 0x290
callq 0x4380
movq %rax, %r14
movq %rax, %rdi
movl %ebx, %esi
callq 0x5438
jmp 0x53d8
movl $0x388, %edi            # imm = 0x388
callq 0x4380
movq %rax, %r14
movq %rax, %rdi
movl %ebx, %esi
callq 0x5516
jmp 0x53d8
movl $0x228, %edi            # imm = 0x228
callq 0x4380
movq %rax, %r14
movq %rax, %rdi
movl %ebx, %esi
callq 0x4b58
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xada5(%rip), %rdi      # 0x1018d
leaq 0xac1e(%rip), %rsi      # 0x1000d
leaq 0xadaa(%rip), %rcx      # 0x101a0
movl $0x3ed, %edx            # imm = 0x3ED
callq 0x4210
movq %rax, %rbx
movl $0x228, %esi            # imm = 0x228
jmp 0x541c
movq %rax, %rbx
movl $0x388, %esi            # imm = 0x388
jmp 0x541c
movq %rax, %rbx
movl $0x290, %esi            # imm = 0x290
movq %r14, %rdi
callq 0x43a0
movq %rbx, %rdi
callq 0x46e0
// File: /workspace/github_cpp_makefile_star2_O1/cpearce[P]OggIndex/src/Decoder.cpp
// Function: TheoraDecoder::GetFisboneInfo()
virtual FisboneInfo GetFisboneInfo() {
    FisboneInfo f;
    f.mGranNumer = mInfo.fps_numerator;
    f.mGranDenom = mInfo.fps_denominator;
    f.mPreroll = 0;
    f.mGranuleShift = mInfo.keyframe_granule_shift;
    f.mRadix = 0;
    f.mContentType = "video/theora";
    f.mRole = "video/main";
    f.mName = "video_1";
    return f;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x20, %rdi
leaq 0x30(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rax, 0x20(%rbx)
movq %rcx, 0x28(%rbx)
movb %cl, 0x30(%rbx)
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
movq %rcx, 0x48(%rbx)
movb %cl, 0x50(%rbx)
leaq 0x70(%rbx), %rax
movq %rax, 0x60(%rbx)
movq %rcx, 0x68(%rbx)
movb %cl, 0x70(%rbx)
movsd 0x1d4(%rsi), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movups %xmm1, (%rbx)
movl %ecx, 0x10(%rbx)
movl 0x1f4(%rsi), %eax
movl %eax, 0x14(%rbx)
movl %ecx, 0x18(%rbx)
leaq 0xa12f(%rip), %rcx      # 0x106d1
movl $0xc, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x45c0
leaq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rdx
leaq 0xa11e(%rip), %rcx      # 0x106de
movl $0xa, %r8d
xorl %esi, %esi
callq 0x45c0
leaq 0x60(%rbx), %rdi
movq 0x68(%rbx), %rdx
leaq 0xa10d(%rip), %rcx      # 0x106e9
movl $0x7, %r8d
xorl %esi, %esi
callq 0x45c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6cf4
movq %r14, %rdi
callq 0x46e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/cpearce[P]OggIndex/src/Decoder.cpp
// Function: TheoraDecoder::DumpPacket(TheoraDecoder::Frame&)
void DumpPacket(Frame& f) {
    if (gOptions.GetDumpPackets() ||
        (f.is_keyframe && gOptions.GetDumpKeyPackets()))
    {
      cout << "[T] " << (f.is_keyframe ? "keyframe" : "frame")
           << " time_ms=[" << StartTime(f.granulepos) << ","
           << EndTime(f.granulepos) << "] granulepos=" << f.granulepos
           << " packetno=" << f.packetno
           << (f.e_o_s ? " eos" : "")
           << endl;
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10e06(%rip), %r15     # 0x17420
movq %r15, %rdi
callq 0x8c4e
testb %al, %al
je 0x67a9
movq 0x1099f(%rip), %r15     # 0x16fd0
leaq 0x9f8d(%rip), %rsi      # 0x105c5
movl $0x4, %edx
movq %r15, %rdi
callq 0x4410
movzbl 0x10(%rbx), %eax
leaq 0x9f7a(%rip), %rcx      # 0x105ca
leaq 0x9f76(%rip), %rsi      # 0x105cd
testq %rax, %rax
cmovneq %rcx, %rsi
leaq (%rax,%rax,2), %rdx
addq $0x5, %rdx
movq %r15, %rdi
callq 0x4410
leaq 0xa147(%rip), %rsi      # 0x107bc
movl $0xa, %edx
movq %r15, %rdi
callq 0x4410
movq 0x8(%rbx), %rsi
movq 0x220(%r14), %rdi
callq 0x40b0
movl 0x1d4(%r14), %ecx
movl 0x1d8(%r14), %edx
imulq %rax, %rdx
imulq $0x3e8, %rdx, %rax      # imm = 0x3E8
cqto
idivq %rcx
movq %r15, %rdi
movq %rax, %rsi
callq 0x4340
movq %rax, %r15
leaq 0xaa59(%rip), %rsi      # 0x1111e
movl $0x1, %edx
movq %rax, %rdi
callq 0x4410
movq 0x8(%rbx), %rsi
movq 0x220(%r14), %rdi
callq 0x40b0
imulq $0x3e8, %rax, %rcx      # imm = 0x3E8
addq $0x3e8, %rcx            # imm = 0x3E8
movl 0x1d4(%r14), %esi
movl 0x1d8(%r14), %eax
imulq %rcx, %rax
cqto
idivq %rsi
movq %r15, %rdi
movq %rax, %rsi
callq 0x4340
movq %rax, %r14
leaq 0x9eb7(%rip), %rsi      # 0x105d3
movl $0xd, %edx
movq %rax, %rdi
callq 0x4410
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x4340
movq %rax, %r14
leaq 0x9ea2(%rip), %rsi      # 0x105e1
movl $0xa, %edx
movq %rax, %rdi
callq 0x4410
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x4340
movq %rax, %r14
movzbl 0x11(%rbx), %edx
leaq 0x9c84(%rip), %rax      # 0x103e9
leaq 0xacbe(%rip), %rsi      # 0x1142a
testl %edx, %edx
cmovneq %rax, %rsi
shll $0x2, %edx
movq %r14, %rdi
callq 0x4410
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4360
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4250
cmpb $0x1, 0x10(%rbx)
jne 0x67ba
cmpb $0x1, 0x1(%r15)
je 0x662a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/cpearce[P]OggIndex/src/Decoder.cpp
// Function: VorbisDecoder::GetFisboneInfo()
virtual FisboneInfo GetFisboneInfo() {
    FisboneInfo f;
    f.mGranNumer = mInfo.rate;
    f.mGranDenom = 1;
    f.mPreroll = 2;
    f.mGranuleShift = 0;
    f.mRadix = 0;
    f.mContentType = "audio/vorbis";
    f.mRole = "audio/main";
    f.mName = "audio_1";
    return f;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x20, %rdi
leaq 0x30(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rax, 0x20(%rbx)
movq %rcx, 0x28(%rbx)
movb %cl, 0x30(%rbx)
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
movq %rcx, 0x48(%rbx)
movb %cl, 0x50(%rbx)
leaq 0x70(%rbx), %rax
movq %rax, 0x60(%rbx)
movq %rcx, 0x68(%rbx)
movb %cl, 0x70(%rbx)
movq 0x1e8(%rsi), %rax
movq %rax, (%rbx)
movq $0x1, 0x8(%rbx)
movq $0x2, 0x10(%rbx)
movl $0x0, 0x18(%rbx)
leaq 0x92ff(%rip), %rcx      # 0x10815
movl $0xc, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x45c0
leaq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rdx
leaq 0x92ee(%rip), %rcx      # 0x10822
movl $0xa, %r8d
xorl %esi, %esi
callq 0x45c0
leaq 0x60(%rbx), %rdi
movq 0x68(%rbx), %rdx
leaq 0x92dd(%rip), %rcx      # 0x1082d
movl $0x7, %r8d
xorl %esi, %esi
callq 0x45c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6cf4
movq %r14, %rdi
callq 0x46e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/cpearce[P]OggIndex/src/Options.cpp
// Function: Options::Parse(int, char**)
bool Options::Parse(int argc, char** argv) {
  const char* error = 0;
  if (!DoParse(argc, argv, &error)) {
    PrintHelp();
    cout << error << endl;
    return false;
  }
  cout << "Writing output to '" << mOutputFilename.c_str() << "'" << endl;
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rcx
movq $0x0, (%rcx)
callq 0x9218
movl %eax, %ebx
testb %al, %al
je 0x9163
movq 0xdea6(%rip), %r15      # 0x16fd0
leaq 0x7d28(%rip), %rsi      # 0x10e59
movl $0x13, %edx
movq %r15, %rdi
callq 0x4410
movq 0x28(%r14), %r14
testq %r14, %r14
je 0x918d
movq %r14, %rdi
callq 0x4170
movq 0xde7a(%rip), %rdi      # 0x16fd0
movq %r14, %rsi
movq %rax, %rdx
callq 0x4410
jmp 0x91a5
callq 0x8c56
movq 0x8(%rsp), %r14
testq %r14, %r14
je 0x91f7
movq %r14, %rdi
callq 0x4170
movq 0xde4b(%rip), %rdi      # 0x16fd0
movq %r14, %rsi
movq %rax, %rdx
jmp 0x91b8
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x4690
movq 0xde24(%rip), %rdi      # 0x16fd0
leaq 0x7cb8(%rip), %rsi      # 0x10e6b
movl $0x1, %edx
callq 0x4410
movq 0xde0c(%rip), %r14      # 0x16fd0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4360
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4250
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0xddd2(%rip), %rax      # 0x16fd0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x4690
jmp 0x91bd
nop
// File: /workspace/github_cpp_makefile_star2_O1/cpearce[P]OggIndex/src/Options.cpp
// Function: IsArgument(char const*)
static bool
IsArgument(const char* s) {
  return strcmp(s, "-v") == 0 ||
         strcmp(s, "-d") == 0 ||
         strcmp(s, "-k") == 0 ||
         strcmp(s, "-p") == 0 ||
         strcmp(s, "-o") == 0 ||
         strcmp(s, "-m") == 0 ||
         strcmp(s, "-i") == 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x7889(%rip), %rsi      # 0x10e6d
callq 0x44f0
movb $0x1, %bl
testl %eax, %eax
je 0x9662
leaq 0x787a(%rip), %rsi      # 0x10e70
movq %r14, %rdi
callq 0x44f0
testl %eax, %eax
je 0x9662
leaq 0x789b(%rip), %rsi      # 0x10ea4
movq %r14, %rdi
callq 0x44f0
testl %eax, %eax
je 0x9662
leaq 0x788b(%rip), %rsi      # 0x10ea7
movq %r14, %rdi
callq 0x44f0
testl %eax, %eax
je 0x9662
leaq 0x787e(%rip), %rsi      # 0x10ead
movq %r14, %rdi
callq 0x44f0
testl %eax, %eax
je 0x9662
leaq 0x7868(%rip), %rsi      # 0x10eaa
movq %r14, %rdi
callq 0x44f0
testl %eax, %eax
je 0x9662
leaq 0x7899(%rip), %rsi      # 0x10eee
movq %r14, %rdi
callq 0x44f0
testl %eax, %eax
sete %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/cpearce[P]OggIndex/src/SkeletonEncoder.cpp
// Function: SkeletonEncoder::SkeletonEncoder(std::map<unsigned int, Decoder*, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, Decoder*>>>&, long, long, unsigned long)
SkeletonEncoder::SkeletonEncoder(DecoderMap& decoders,
                                 ogg_int64_t fileLength,
                                 ogg_int64_t oldSkeletonLength,
                                 ogg_uint64_t contentOffset)
  : mSkeletonDecoder(0),
    mFileLength(fileLength),
    mOldSkeletonLength(oldSkeletonLength),
    mPacketCount(0),
    mContentOffset(contentOffset)
{
  DecoderMap::iterator itr = decoders.begin();
  while (itr != decoders.end()) {
    Decoder* d = itr->second;
    if (IsIndexable(d)) {
      mDecoders.push_back(d);
    }
    if (d->Type() == TYPE_SKELETON) {
      mSkeletonDecoder = (SkeletonDecoder*)d;
    }
    itr++;
  }
  mSerial = mSkeletonDecoder ? mSkeletonDecoder->GetSerial()
                             : GetUniqueSerialNo(mDecoders);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rdx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movups %xmm0, 0x34(%rdi)
movups %xmm0, 0x44(%rdi)
movups %xmm0, 0x54(%rdi)
movl $0x0, 0x64(%rdi)
movq %r8, 0x68(%rdi)
movq 0x18(%rsi), %r12
addq $0x8, %r15
cmpq %r15, %r12
je 0x97ce
leaq 0x38(%rbx), %r14
movq %rsp, %r13
movq 0x28(%r12), %rbp
movq %rbp, (%rsp)
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x28(%rax)
cmpl $0x1, %eax
je 0x9784
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x9784
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x28(%rax)
cmpl $0x3, %eax
jne 0x97a7
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x979c
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x97a7
movq %rbx, %rdi
movq %r13, %rdx
callq 0xbe3a
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x4, %eax
jne 0x97be
movq (%rsp), %rax
movq %rax, 0x18(%rbx)
movq %r12, %rdi
callq 0x4260
movq %rax, %r12
cmpq %r15, %rax
jne 0x974e
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x97df
movl 0x1a0(%rax), %eax
jmp 0x9836
xorl %edi, %edi
callq 0x4330
movl %eax, %edi
callq 0x4350
callq 0x40d0
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sete %dil
je 0x9831
movq (%rcx), %rsi
cmpl %eax, 0x1a0(%rsi)
je 0x97ed
sarq $0x3, %rdx
movl $0x1, %esi
movl %esi, %esi
cmpq %rsi, %rdx
setbe %dil
jbe 0x9831
movq (%rcx,%rsi,8), %rdi
incl %esi
cmpl %eax, 0x1a0(%rdi)
jne 0x9816
jmp 0x97ed
testb %dil, %dil
je 0x97ed
movl %eax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x9860
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x43a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4825
movq %r15, %rdi
callq 0x46e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/cpearce[P]OggIndex/src/SkeletonEncoder.cpp
// Function: SkeletonEncoder::~SkeletonEncoder()
SkeletonEncoder::~SkeletonEncoder() {
  for (ogg_uint32_t i=0; i<mIndexPackets.size(); i++) {
    delete[] mIndexPackets[i]->packet;
    delete mIndexPackets[i];
  }
  ClearIndexPages();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rax
cmpq %rax, 0x40(%rdi)
je 0x98ce
movl $0x1, %ebp
xorl %r14d, %r14d
movq (%rax,%r14,8), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x989e
callq 0x4490
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x98b5
movl $0x30, %esi
callq 0x43a0
movl %ebp, %r14d
movq 0x38(%rbx), %rax
movq 0x40(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
incl %ebp
cmpq %r14, %rcx
ja 0x988d
movq %rbx, %rdi
callq 0x9926
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x98eb
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x43a0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x9900
movq 0x48(%rbx), %rsi
subq %rdi, %rsi
callq 0x43a0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x9918
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x43a0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0x542c
nop
// File: /workspace/github_cpp_makefile_star2_O1/cpearce[P]OggIndex/src/SkeletonEncoder.cpp
// Function: SkeletonEncoder::AddBosPacket()
void
SkeletonEncoder::AddBosPacket()
{
  // Should not call this more than once, this should be the first packet.
  assert(mPacketCount == 0);

  // Allocate packet to return...
  ogg_packet* bos = new ogg_packet();
  memset(bos, 0, sizeof(ogg_packet));
  bos->packet = new unsigned char[SKELETON_4_0_HEADER_LENGTH];
  memset(bos->packet, 0, SKELETON_4_0_HEADER_LENGTH);
  bos->bytes = SKELETON_4_0_HEADER_LENGTH;
  bos->b_o_s = 1;
  
  if (mSkeletonDecoder) {
    // We already have a skeleton track. Use what data we can from its
    // bos packet.
    ogg_packet* original = mSkeletonDecoder->mPackets.front();
    memcpy(bos->packet, original->packet, SKELETON_3_0_HEADER_LENGTH);
  } else {
    // We need to construct the skeleton bos packet...
    memcpy(bos->packet, "fishead", 8);
    
    WriteLEUint64(bos->packet + SKELETON_PRES_TIME_DENOM_OFFSET, 1000);
    WriteLEUint64(bos->packet + SKELETON_BASE_TIME_DENOM_OFFSET, 1000);
  }
  
  // Set the version fields.
  WriteLEUint16(bos->packet + SKELETON_VERSION_MAJOR_OFFSET, SKELETON_VERSION_MAJOR);
  WriteLEUint16(bos->packet + SKELETON_VERSION_MINOR_OFFSET, SKELETON_VERSION_MINOR);
  
  WriteLEUint64(bos->packet + SKELETON_CONTENT_OFFSET, mContentOffset);

  mPacketCount++;

  mIndexPackets.push_back(bos);

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x34(%rdi)
jne 0x9ab8
movq %rdi, %rbx
movl $0x30, %edi
callq 0x4380
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movq %rax, (%rsp)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x50, %edi
callq 0x4030
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movq $0x50, 0x8(%r14)
movq $0x1, 0x10(%r14)
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x9a18
movq 0x1d0(%rcx), %rcx
movq (%rcx), %rcx
movq (%rcx), %rcx
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups 0x30(%rcx), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x9a4b
movabsq $0x64616568736966, %rcx # imm = 0x64616568736966
movq %rcx, (%rax)
addq $0x14, %rax
movl $0x3e8, %esi            # imm = 0x3E8
movq %rax, %rdi
callq 0xcb12
movq (%rsp), %rax
movq (%rax), %rdi
addq $0x24, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0xcb12
movq (%rsp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
movl $0x4, %esi
callq 0xcce1
movq (%rsp), %rax
movq (%rax), %rdi
addq $0xa, %rdi
xorl %esi, %esi
callq 0xcce1
movq (%rsp), %rax
movq (%rax), %rdi
addq $0x48, %rdi
movq 0x68(%rbx), %rsi
callq 0xcb12
incl 0x34(%rbx)
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x9aa1
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x40(%rbx)
jmp 0x9ab0
addq $0x38, %rbx
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xbf76
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x7571(%rip), %rdi      # 0x11030
leaq 0x757c(%rip), %rsi      # 0x11042
leaq 0x758d(%rip), %rcx      # 0x1105a
movl $0x7e, %edx
callq 0x4210
nop
// File: /workspace/github_cpp_makefile_star2_O1/cpearce[P]OggIndex/src/SkeletonEncoder.cpp
// Function: SkeletonEncoder::AddEosPacket()
void
SkeletonEncoder::AddEosPacket() {
  ogg_packet* eos = new ogg_packet();
  memset(eos, 0, sizeof(ogg_packet));
  eos->e_o_s = 1;
  eos->packetno = mPacketCount;
  mPacketCount++;
  mIndexPackets.push_back(eos);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x30, %edi
callq 0x4380
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movq %rax, 0x8(%rsp)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movq $0x1, 0x18(%rax)
movslq 0x34(%rbx), %rcx
movq %rcx, 0x28(%rax)
incl %ecx
movl %ecx, 0x34(%rbx)
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0xa6ed
movq %rax, (%rsi)
addq $0x8, 0x40(%rbx)
jmp 0xa6fe
addq $0x38, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xbf76
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/cpearce[P]OggIndex/src/SkeletonEncoder.cpp
// Function: ReadVariableLength(unsigned char*, long*)
unsigned char*
ReadVariableLength(unsigned char* p, ogg_int64_t* num) {
  *num = 0;
  int shift = 0;
  ogg_int64_t byte = 0;
  do {
    byte = (ogg_int64_t)(*p);
    *num |= ((byte & 0x7f) << shift);
    shift += 7;
    p++;
  } while ((byte & 0x80) != 0x80);
  return p;
}

// Assembly:
movq %rdi, %rax
movq $0x0, (%rsi)
xorl %ecx, %ecx
xorl %edx, %edx
movzbl (%rax), %edi
movl %edi, %r8d
andl $0x7f, %r8d
shlq %cl, %r8
orq %r8, %rdx
movq %rdx, (%rsi)
addq $0x7, %rcx
incq %rax
testb %dil, %dil
jns 0xaf42
retq
// File: /workspace/github_cpp_makefile_star2_O1/cpearce[P]OggIndex/src/SkeletonEncoder.cpp
// Function: SkeletonEncoder::FindTrack(unsigned int)
Decoder*
SkeletonEncoder::FindTrack(ogg_uint32_t serialno) {
  for (unsigned i=0; i<mDecoders.size(); i++) {
    if (mDecoders[i]->GetSerial() == serialno) {
      return mDecoders[i];
    }
  }
  return 0;
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
je 0xb104
sarq $0x3, %rdx
movl $0x1, %edi
xorl %eax, %eax
movq (%rcx,%rax,8), %rax
cmpl %esi, 0x1a0(%rax)
je 0xb106
movl %edi, %eax
incl %edi
cmpq %rax, %rdx
ja 0xb0ef
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cpearce[P]OggIndex/src/Utils.cpp
// Function: Clone(ogg_page*)
ogg_page*
Clone(ogg_page* p)
{
  ogg_page* q = new ogg_page();
  memcpy(q, p, sizeof(ogg_page));
  q->header = new unsigned char[p->header_len + p->body_len];
  q->body = q->header + q->header_len;
  memcpy(q->header, p->header, p->header_len);
  memcpy(q->body, p->body, p->body_len);
  assert(memcmp(p->header, q->header, q->header_len) == 0);
  assert(memcmp(p->body, q->body, q->body_len) == 0);
  assert(q->header_len == p->header_len);
  assert(q->body_len == p->body_len);
  return q;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl $0x20, %edi
callq 0x4380
movq %rax, %rbx
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movq 0x8(%r14), %r13
movq 0x18(%r14), %rbp
movq %rbp, %rdi
addq %r13, %rdi
callq 0x4030
movq %rax, %r15
movq %rax, (%rbx)
movq 0x8(%rbx), %rax
movq %rax, 0x20(%rsp)
addq %r15, %rax
movq %rax, 0x10(%rbx)
movq (%r14), %r12
movq %r15, %rdi
movq %r12, %rsi
movq %r13, 0x10(%rsp)
movq %r13, %rdx
movq %rax, %r13
callq 0x42c0
movq 0x10(%r14), %rsi
movq %r13, %rdi
movq %rsi, 0x18(%rsp)
movq %rbp, 0x8(%rsp)
movq %rbp, %rdx
callq 0x42c0
movq %r12, %rdi
movq %r15, %rsi
movq 0x20(%rsp), %r15
movq %r15, %rdx
callq 0x43b0
testl %eax, %eax
jne 0xc208
movq 0x18(%rbx), %r14
movq 0x18(%rsp), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x43b0
testl %eax, %eax
jne 0xc227
cmpq 0x10(%rsp), %r15
jne 0xc246
cmpq 0x8(%rsp), %r14
jne 0xc265
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x526f(%rip), %rdi      # 0x1147e
leaq 0x5299(%rip), %rsi      # 0x114af
leaq 0x52a0(%rip), %rcx      # 0x114bd
movl $0x39, %edx
callq 0x4210
leaq 0x52ab(%rip), %rdi      # 0x114d9
leaq 0x527a(%rip), %rsi      # 0x114af
leaq 0x5281(%rip), %rcx      # 0x114bd
movl $0x3a, %edx
callq 0x4210
leaq 0x52b7(%rip), %rdi      # 0x11504
leaq 0x525b(%rip), %rsi      # 0x114af
leaq 0x5262(%rip), %rcx      # 0x114bd
movl $0x3b, %edx
callq 0x4210
leaq 0x52b7(%rip), %rdi      # 0x11523
leaq 0x523c(%rip), %rsi      # 0x114af
leaq 0x5243(%rip), %rcx      # 0x114bd
movl $0x3c, %edx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O1/cpearce[P]OggIndex/src/Utils.cpp
// Function: FileLength(char const*)
ogg_int64_t
FileLength(const char* aFileName)
{
  ifstream is;
  is.open (aFileName, ios::binary);
  is.seekg (0, ios::end);
  streampos length = is.tellg();
  is.close();
  return (ogg_int64_t)length;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x4400
movq %r14, %rdi
movq %rbx, %rsi
movl $0x4, %edx
callq 0x4200
movq %rsp, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x44b0
movq %rsp, %rdi
callq 0x46b0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x40a0
movq %rsp, %rdi
callq 0x40c0
movq %rbx, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
jmp 0xc332
movq %rax, %rbx
movq %rsp, %rdi
callq 0x40c0
movq %rbx, %rdi
callq 0x46e0
// File: /workspace/github_cpp_makefile_star2_O1/cpearce[P]OggIndex/src/Utils.cpp
// Function: Clone(ogg_packet*)
ogg_packet*
Clone(ogg_packet* p)
{
  if (!p)
    return 0;
  ogg_packet* q = new ogg_packet();
  memcpy(q, p, sizeof(ogg_packet));
  q->packet = new unsigned char[p->bytes];
  memcpy(q->packet, p->packet, p->bytes);
  return q;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xc397
movq %rdi, %r14
movl $0x30, %edi
callq 0x4380
movq %rax, %rbx
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movups %xmm2, 0x20(%rax)
movq 0x8(%r14), %r15
movq %r15, %rdi
callq 0x4030
movq %rax, (%rbx)
movq (%r14), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x42c0
jmp 0xc399
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/cpearce[P]OggIndex/src/Utils.cpp
// Function: ReadPage(ogg_sync_state*, ogg_page*, std::istream&, unsigned long&)
bool ReadPage(ogg_sync_state* state,
              ogg_page* page,
              istream& stream,
              ogg_uint64_t& bytesRead)
{
  ogg_int32_t bytes = 0;
  ogg_int32_t r = 0;
  ogg_uint64_t intialBytesRead = bytesRead;
  while ((r = ogg_sync_pageout(state, page)) != 1) {
    char* buffer = ogg_sync_buffer(state, FILE_BUFFER_SIZE);
    assert(buffer);
    stream.read(buffer, FILE_BUFFER_SIZE);
    bytes = stream.gcount();
    bytesRead += bytes;
    if (bytes == 0) {
      // End of file
      assert(stream.eof());
      if (intialBytesRead != bytesRead) {
        cerr << "WARNING: Reached end of file, when expecting to find more data! "
             << "Page header may be incorrect!" << endl;
      }
      return false;
    }
    ogg_int32_t ret = ogg_sync_wrote(state, bytes);
    assert(ret == 0);
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rcx), %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x4660
movl %eax, %ebp
cmpl $0x1, %eax
je 0xc4cf
movl $0x100000, %esi         # imm = 0x100000
movq %r12, %rdi
callq 0x45f0
testq %rax, %rax
je 0xc4e4
movl $0x100000, %edx         # imm = 0x100000
movq %r14, %rdi
movq %rax, %rsi
callq 0x4470
movl 0x8(%r14), %r13d
movslq %r13d, %rsi
movq (%rbx), %rax
addq %rsi, %rax
movq %rax, (%rbx)
testq %r13, %r13
je 0xc451
movq %r12, %rdi
callq 0x4460
testl %eax, %eax
je 0xc4c6
jmp 0xc503
movq (%r14), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%r14,%rcx)
je 0xc522
cmpq %rax, 0x10(%rsp)
je 0xc4c6
movl $0x40, %edx
movq 0xab79(%rip), %r15      # 0x16ff0
movq %r15, %rdi
leaq 0x5118(%rip), %rsi      # 0x11599
callq 0x4410
movl $0x1d, %edx
movq %r15, %rdi
leaq 0x5145(%rip), %rsi      # 0x115da
callq 0x4410
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x4360
movsbl %al, %esi
movq %r15, %rdi
movq 0x8(%rsp), %r15
callq 0x4040
movq %rax, %rdi
callq 0x4250
testq %r13, %r13
jne 0xc3ef
cmpl $0x1, %ebp
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5053(%rip), %rdi      # 0x1153e
leaq 0x4fbd(%rip), %rsi      # 0x114af
leaq 0x504c(%rip), %rcx      # 0x11545
movl $0x7e, %edx
callq 0x4210
leaq 0x3afa(%rip), %rdi      # 0x10004
leaq 0x4f9e(%rip), %rsi      # 0x114af
leaq 0x502d(%rip), %rcx      # 0x11545
movl $0x8c, %edx
callq 0x4210
leaq 0x5063(%rip), %rdi      # 0x1158c
leaq 0x4f7f(%rip), %rsi      # 0x114af
leaq 0x500e(%rip), %rcx      # 0x11545
movl $0x84, %edx
callq 0x4210