LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBPredictor::reportMigration(DHPEntry*, CacheEntry*, bool)
void
DBAMBPredictor::reportMigration(DHPEntry* rap_current, CacheEntry* current, bool fromNVM)
{
	string cl_location = fromNVM ? "from NVM" : "from SRAM";
	
	if(simu_parameters.printDebug)
	{
		dataset_file << "Migration:Dataset n°" << rap_current->id << ": [" << \
		str_RW_status[rap_current->state_rw] << ","  << str_RD_status[rap_current->state_rd] << "], Migration " << cl_location << \
		" Cl 0x" << std::hex << current->address << std::dec << " allocated in " << cl_location << endl;	
	}
	
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x1c2e9(%rip), %rax     # 0x297f7
leaq 0x1c2eb(%rip), %rsi     # 0x29800
testl %ecx, %ecx
cmovneq %rax, %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5140
leaq 0x30a1f(%rip), %rax     # 0x3df50
cmpb $0x1, (%rax)
jne 0xd630
leaq 0x30127(%rip), %rdi     # 0x3d668
leaq 0x1c2c2(%rip), %rsi     # 0x2980a
callq 0x52c0
movl 0x18(%r14), %esi
movq %rax, %rdi
callq 0x5560
leaq 0x1c5bd(%rip), %rsi     # 0x29b1d
movq %rax, %rdi
callq 0x52c0
movl 0x98(%r14), %ecx
leaq 0x2fe8a(%rip), %rdx     # 0x3d400
movq (%rdx,%rcx,8), %rsi
movq %rax, %rdi
callq 0x52c0
leaq 0x1baa9(%rip), %rsi     # 0x29032
movq %rax, %rdi
callq 0x52c0
movl 0x9c(%r14), %ecx
leaq 0x2fe91(%rip), %rdx     # 0x3d430
movq (%rdx,%rcx,8), %rsi
movq %rax, %rdi
callq 0x52c0
leaq 0x1c5e3(%rip), %rsi     # 0x29b95
movq %rax, %rdi
callq 0x52c0
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x5290
leaq 0x1c52c(%rip), %rsi     # 0x29afa
movq %rax, %rdi
callq 0x52c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x5200
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
leaq 0x1bc16(%rip), %rsi     # 0x29229
movq %rax, %rdi
callq 0x52c0
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x5290
movq %rax, %rdi
callq 0x5190
leaq 0x8(%rsp), %rdi
callq 0x5618
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5618
movq %rbx, %rdi
callq 0x5570
nop
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBPredictor::finishSimu()
void 
DBAMBPredictor::finishSimu()
{
	//DPRINTF("RAPPredictor::FINISH SIMU\n");

	if(simu_parameters.readDatasetFile || simu_parameters.writeDatasetFile)	
		firstAlloc_dataset_file.close();
	
	if(m_isWarmup)
		return;
		
	for(auto lines : m_DHPTable)
	{
		for(auto entry : lines)
		{		
			if(entry->isValid)
			{
				HistoEntry current = {entry->state_rw , entry->state_rd , entry->nbKeepState};
				entry->stats_history.push_back(current);

				if(entry->nbKeepState + entry->nbSwitchState  > 0)
					stats_nbSwitchDst.push_back((double)entry->nbSwitchState / \
					  (double) (entry->nbKeepState + entry->nbSwitchState) );
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x30680(%rip), %rax     # 0x3df50
cmpb $0x0, 0x159(%rax)
jne 0xd8e2
cmpb $0x1, 0x15a(%rax)
jne 0xd8ee
leaq 0x2ff7f(%rip), %rdi     # 0x3d868
callq 0x5060
cmpb $0x0, 0x81(%rbx)
je 0xd906
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2e8(%rbx), %rsi
movq 0x2f0(%rbx), %rax
movq %rax, 0x8(%rsp)
addq $0x388, %rbx            # imm = 0x388
leaq 0x30(%rsp), %r14
leaq 0x20(%rsp), %r12
leaq 0x18(%rsp), %r13
cmpq 0x8(%rsp), %rsi
je 0xd8f7
movq %r14, %rdi
movq %rsi, 0x10(%rsp)
callq 0xe812
movq 0x30(%rsp), %r15
movq 0x38(%rsp), %rbp
cmpq %rbp, %r15
je 0xd9ba
movq (%r15), %r14
cmpb $0x1, 0x88(%r14)
jne 0xd9b4
movq 0x98(%r14), %rax
movq %rax, 0x20(%rsp)
movl 0x8c(%r14), %eax
movl %eax, 0x28(%rsp)
leaq 0xa0(%r14), %rdi
movq %r12, %rsi
callq 0xe988
movl 0x90(%r14), %eax
movl 0x8c(%r14), %ecx
addl %eax, %ecx
jle 0xd9b4
cvtsi2sd %eax, %xmm0
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xf960
addq $0x8, %r15
jmp 0xd94d
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0xf1a4
movq 0x10(%rsp), %rsi
addq $0x18, %rsi
jmp 0xd92f
jmp 0xd9d7
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xf1a4
movq %rbx, %rdi
callq 0x5570
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBPredictor::openNewTimeFrame()
void 
DBAMBPredictor::openNewTimeFrame()
{ 

	if(m_isWarmup)
		return;

	stats_nbMigrationsFromNVM.push_back(vector<int>(2,0));
	dataset_file << "TimeFrame" << endl;
	Predictor::openNewTimeFrame();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, 0x81(%rdi)
jne 0xe44a
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x10(%rsp), %r14
pushq $0x2
popq %rsi
leaq 0xb(%rsp), %rcx
movq %r14, %rdi
callq 0x9c8a
leaq 0x3b8(%rbx), %rdi
movq %r14, %rsi
callq 0xf004
leaq 0x10(%rsp), %rdi
callq 0xa49a
leaq 0x2f23a(%rip), %rdi     # 0x3d668
leaq 0x1b9d8(%rip), %rsi     # 0x29e0d
callq 0x52c0
movq %rax, %rdi
callq 0x5190
movq %rbx, %rdi
callq 0x1fdb6
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xa49a
movq %rbx, %rdi
callq 0x5570
nop
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBPredictor::hashingFunction(Access)
uint64_t
DBAMBPredictor::hashingFunction(Access element)
{	
	string total = buildHash( element.m_address , element.m_pc);
	string sig ="";
	for(unsigned i = 0 ; i < m_hashingBytes.size() ; i++)
	{
		assert(m_hashingBytes[i] < 16 && "Error on the hashing function bytes selection");
		sig += string(1, total[m_hashingBytes[i]]);
	}
	return hexToInt(sig);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq 0xc0(%rsp), %rsi
movq 0xd0(%rsp), %rdx
leaq 0x68(%rsp), %rdi
callq 0x25345
leaq 0x1c787(%rip), %rsi     # 0x2ac24
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x5140
xorl %r13d, %r13d
leaq 0x18(%rsp), %rbp
leaq 0x8(%rsp), %r14
pushq $0x1
popq %r15
leaq 0x28(%rsp), %r12
movl %r13d, %r13d
movq 0x340(%rbx), %rax
movq 0x348(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0xe51e
movslq (%rax,%r13,4), %rax
cmpq $0x10, %rax
jge 0xe56d
movq 0x68(%rsp), %rcx
movsbl (%rcx,%rax), %edx
movq %rbp, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5350
movq %r12, %rdi
movq %r14, %rsi
callq 0x55f0
movq %r14, %rdi
callq 0x5618
incl %r13d
jmp 0xe4c2
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x5410
leaq 0x48(%rsp), %rdi
callq 0x24fc9
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5618
leaq 0x28(%rsp), %rdi
callq 0x5618
leaq 0x68(%rsp), %rdi
callq 0x5618
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b8a3(%rip), %rdi     # 0x29e17
leaq 0x1b4b1(%rip), %rsi     # 0x29a2c
leaq 0x1b8df(%rip), %rcx     # 0x29e61
movl $0x3e3, %edx            # imm = 0x3E3
callq 0x51e0
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0xe5a5
jmp 0xe5ac
movq %rax, %rbx
jmp 0xe5b9
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5618
jmp 0xe5af
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5618
leaq 0x68(%rsp), %rdi
callq 0x5618
movq %rbx, %rdi
callq 0x5570
nop
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBLRUPolicy::evictPolicy(int)
int
DBAMBLRUPolicy::evictPolicy(int set)
{
	for(unsigned i = 0 ; i < m_assoc ; i++){
		if(!m_rap_entries[set][i]->isValid)
			return i;
	}
	
	int smallest_time = m_rap_entries[set][0]->policyInfo , smallest_index = 0;
	for(unsigned i = 0 ; i < m_assoc ; i++){
		if(m_rap_entries[set][i]->policyInfo < smallest_time){
			smallest_time =  m_rap_entries[set][i]->policyInfo;
			smallest_index = i;
		}
	}
	return smallest_index;
}

// Assembly:
movl 0x18(%rdi), %ecx
movq 0x8(%rdi), %rax
movslq %esi, %rdx
movq (%rax), %rax
imulq $0x18, %rdx, %rdx
movq (%rax,%rdx), %rdx
xorl %eax, %eax
cmpq %rax, %rcx
je 0xe650
movq (%rdx,%rax,8), %rsi
cmpb $0x1, 0x88(%rsi)
jne 0xe676
incq %rax
jmp 0xe639
movq (%rdx), %rax
movl 0x2c(%rax), %esi
xorl %edi, %edi
xorl %eax, %eax
cmpq %rdi, %rcx
je 0xe676
movq (%rdx,%rdi,8), %r8
movl 0x2c(%r8), %r8d
cmpl %esi, %r8d
cmovll %r8d, %esi
cmovll %edi, %eax
incq %rdi
jmp 0xe65a
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/DBAMBPredictor.hh
// Function: DHPEntry::initEntry(Access)
void initEntry(Access element) {
		 	cpts =  std::vector<int>(NUM_RW_TYPE,0);
		 	lastWrite = 0;
		 	signature = 0;
		 	des = ALLOCATE_PREEMPTIVELY;
		 	
		 	policyInfo = 0;
			cptBypassLearning = 0;
			rd_history.clear();
			rw_history.clear();
			nbAccess = 0;
			isValid = true;
			
			state_rw = RW_NOT_ACCURATE;
			state_rd = RD_NOT_ACCURATE;
			
			nbKeepCurrentState = 0;
			nbKeepState = 0;
			nbSwitchState = 0;
			cptWindow = 0;
			
			dead_counter = 0;
		 }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x10(%rsp), %r14
pushq $0x5
popq %rsi
leaq 0xb(%rsp), %rcx
movq %r14, %rdi
callq 0x9c8a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa52e
movq %r14, %rdi
callq 0xa49a
andl $0x0, 0x1c(%rbx)
andq $0x0, 0x20(%rbx)
movq $0x3, 0x28(%rbx)
andl $0x0, 0x38(%rbx)
movq 0x40(%rbx), %rax
cmpq %rax, 0x48(%rbx)
je 0xe8e9
movq %rax, 0x48(%rbx)
movq 0x58(%rbx), %rax
movq %rax, 0x68(%rbx)
andl $0x0, 0x70(%rbx)
andq $0x0, 0x80(%rbx)
movb $0x1, 0x88(%rbx)
movl $0x2, 0x9c(%rbx)
movaps 0x1b04b(%rip), %xmm0    # 0x29960
movups %xmm0, 0x8c(%rbx)
andl $0x0, 0xb8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/Directory.cc
// Function: Directory::Directory()
Directory::Directory()
{
	m_nb_set = DIRECTORY_NB_SETS;
	m_assoc = DIRECTORY_ASSOC;

	//DPRINTF("DIRECTORY::Constructor , assoc=%d , m_nb_set=%d\n", m_assoc , m_nb_set);

	m_table.resize(m_nb_set);
	for(int i = 0  ; i < m_nb_set ; i++){
//		m_table[i].resize(m_assoc);
		m_table[i].clear();
		/*
		for(int j = 0 ; j < m_assoc ; j++){
			m_table[i][j] = new DirectoryEntry();
		}*/
	}
		
	m_policy = new DirectoryReplacementPolicy(m_assoc , m_nb_set , m_table);
	m_start_index = log2(BLOCK_SIZE)-1;
	m_end_index = log2(BLOCK_SIZE) + log2(m_nb_set);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movabsq $0x4000000800, %rax     # imm = 0x4000000800
movq %rax, 0x20(%rdi)
movl $0x800, %esi            # imm = 0x800
callq 0x10096
movl 0x20(%rbx), %ebp
movq (%rbx), %rax
xorl %ecx, %ecx
testl %ebp, %ebp
movl $0x0, %edx
cmovgl %ebp, %edx
imulq $0x18, %rdx, %rdx
cmpq %rcx, %rdx
je 0xfaa7
movq (%rax,%rcx), %rsi
cmpq %rsi, 0x8(%rax,%rcx)
je 0xfaa1
movq %rsi, 0x8(%rax,%rcx)
addq $0x18, %rcx
jmp 0xfa8c
pushq $0x18
popq %rdi
callq 0x52e0
movl 0x24(%rbx), %ecx
movl %ecx, 0x8(%rax)
movl %ebp, 0xc(%rax)
movq %rbx, 0x10(%rax)
movq $0x1, (%rax)
movq %rax, 0x18(%rbx)
movl $0x5, 0x2c(%rbx)
movl %ebp, %edi
callq 0x100cb
addsd 0x1a44b(%rip), %xmm0    # 0x29f28
cvttsd2si %xmm0, %eax
movl %eax, 0x28(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x100d4
movq %r14, %rdi
callq 0x5570
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/Directory.cc
// Function: Directory::addEntry(unsigned long, bool)
DirectoryEntry*
Directory::addEntry(uint64_t addr , bool isInst)
{
	if(getEntry(addr) != NULL)
		return getEntry(addr);	
	
	uint64_t id_set = indexFunction(addr);
//	int assoc_victim = m_policy->evictPolicy(id_set);
		
	DirectoryEntry* entry = new DirectoryEntry();
	
	/*if(entry->isValid)
	{
	
//		cout << "ID SET =" << id_set << endl;
		//DPRINTF("DIRECTORY::Eviction of dir entry, Block_addr[%#lx] \n", entry->block_addr);
		cout << "Assoc victim =" << assoc_victim << endl;
//		entry->print();	
//		for(int i  = 0 ; i < m_table[id_set].size(); i++)
//		{
//			cout << "\t Way " << i << endl;
//			m_table[id_set][i]->print();
//		}
	}*/
	
	entry->initEntry();
	entry->block_addr = addr;
	entry->isValid = true;
	entry->isInst = isInst;
	m_policy->insertionPolicy(entry);

	m_table[id_set].push_back(entry);

	return entry;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xfc52
testq %rax, %rax
je 0xfbca
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfc52
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfc96
movq %rax, %r15
pushq $0x48
popq %rdi
callq 0x52e0
movq %rax, %r12
movq %rax, %rdi
callq 0x10144
movq %rsp, %r13
movq %r12, (%r13)
movq %r12, %rdi
callq 0x10168
movq %r14, 0x30(%r12)
movb $0x1, 0x3c(%r12)
movb %bpl, 0x3d(%r12)
movq 0x18(%rbx), %rax
movq (%rax), %rcx
incq %rcx
movq %rcx, (%rax)
movl %ecx, 0x40(%r12)
imulq $0x18, %r15, %rdi
addq (%rbx), %rdi
movq %r13, %rsi
callq 0x1017e
movq (%r13), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5570
nop
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/Directory.cc
// Function: Directory::getEntry(unsigned long)
DirectoryEntry*
Directory::getEntry(uint64_t addr)
{
	int id_set = indexFunction(addr);
	for(auto entry : m_table[id_set])
	{
		if(entry->block_addr == addr && entry->isValid)
			return entry;
	}
	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xfc96
movq (%r14), %rdx
imulq $0x18, %rax, %rax
movq (%rdx,%rax), %rcx
movq 0x8(%rdx,%rax), %rdx
cmpq %rdx, %rcx
je 0xfc8b
movq (%rcx), %rax
cmpq %rbx, 0x30(%rax)
jne 0xfc85
cmpb $0x0, 0x3c(%rax)
jne 0xfc8d
addq $0x8, %rcx
jmp 0xfc71
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/Directory.cc
// Function: Directory::indexFunction(unsigned long)
uint64_t 
Directory::indexFunction(uint64_t block_addr)
{
	uint64_t a =block_addr;
	a = bitRemove(a , m_end_index,64);	
	a = a >> (m_start_index+1);
	assert(a < (unsigned int)m_nb_set);
	
	return (int)a;
}

// Assembly:
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movl 0x28(%rdi), %esi
pushq $0x40
popq %rdx
movq %rax, %rdi
callq 0x24f70
movb 0x2c(%rbx), %cl
incb %cl
shrq %cl, %rax
movl 0x20(%rbx), %ecx
cmpq %rcx, %rax
jae 0xfcbf
cltq
popq %rbx
retq
leaq 0x1a439(%rip), %rdi     # 0x2a0ff
leaq 0x1a263(%rip), %rsi     # 0x29f30
leaq 0x1a446(%rip), %rcx     # 0x2a11a
movl $0xfb, %edx
callq 0x51e0
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/Directory.cc
// Function: Directory::lookup(unsigned long)
bool
Directory::lookup(uint64_t addr)
{
	
	uint64_t id_set = indexFunction(addr);
	for(unsigned i = 0 ; i < m_table[id_set].size() ; i++)
	{
		if(m_table[id_set][i]->block_addr == addr)
			return true;
	}	
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xfc96
movq (%r14), %rdx
imulq $0x18, %rax, %rax
movq (%rdx,%rax), %rcx
movq 0x8(%rdx,%rax), %rax
subq %rcx, %rax
sarq $0x3, %rax
xorl %esi, %esi
movl %esi, %edx
cmpq %rdx, %rax
jbe 0xfd1a
movq (%rcx,%rdx,8), %rdi
leal 0x1(%rdx), %esi
cmpq %rbx, 0x30(%rdi)
jne 0xfd06
cmpq %rdx, %rax
seta %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/Directory.cc
// Function: Directory::setTrackerToEntry(unsigned long, int)
void 
Directory::setTrackerToEntry(uint64_t addr , int node)
{
	DirectoryEntry* entry = getEntry(addr);
	assert(entry != NULL);

	entry->nodeTrackers.clear();
	entry->nodeTrackers.insert(node);

//	m_policy->updatePolicy(entry);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edx, 0xc(%rsp)
callq 0xfc52
testq %rax, %rax
je 0xfd59
movq %rax, %rbx
movq %rax, %rdi
callq 0x10412
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x10816
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1be04(%rip), %rdi     # 0x2bb64
leaq 0x1a1c9(%rip), %rsi     # 0x29f30
leaq 0x1a1d3(%rip), %rcx     # 0x29f41
pushq $0x78
popq %rdx
callq 0x51e0
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/Directory.cc
// Function: Directory::removeTracker(unsigned long, int)
void 
Directory::removeTracker(uint64_t addr, int node)
{
	DirectoryEntry* entry = getEntry(addr);
	assert(entry != NULL);

	//DPRINTF("DIRECTORY::removeTracker Addr %#lx, Node %d\n", addr, node );	

	set<int>::iterator it = entry->nodeTrackers.find(node);
	if(it != entry->nodeTrackers.end())
		entry->nodeTrackers.erase(it);

	//if the cl is no longer in a L1 cache
	if(entry->nodeTrackers.empty())
		entry->coherence_state = CLEAN_LLC;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edx, 0xc(%rsp)
callq 0xfc52
testq %rax, %rax
je 0xfe38
movq %rax, %rbx
leaq 0xc(%rsp), %rsi
movq %rax, %rdi
callq 0x1090c
movq %rbx, %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0xfe24
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1095e
cmpq $0x0, 0x28(%rbx)
jne 0xfe32
movl $0x6, 0x38(%rbx)
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1bd25(%rip), %rdi     # 0x2bb64
leaq 0x1a0ea(%rip), %rsi     # 0x29f30
leaq 0x1a181(%rip), %rcx     # 0x29fce
movl $0x96, %edx
callq 0x51e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/Directory.cc
// Function: Directory::setCoherenceState(unsigned long, DirectoryState)
void
Directory::setCoherenceState(uint64_t addr, DirectoryState dir_state)
{

	DirectoryEntry* entry = getEntry(addr);
	assert(entry != NULL);
	entry->coherence_state = dir_state;
	entry->print();
//	m_policy->updatePolicy(entry);
}

// Assembly:
pushq %rbx
movl %edx, %ebx
callq 0xfc52
testq %rax, %rax
je 0xfe6a
movl %ebx, 0x38(%rax)
popq %rbx
retq
leaq 0x1bcf3(%rip), %rdi     # 0x2bb64
leaq 0x1a0b8(%rip), %rsi     # 0x29f30
leaq 0x1a17c(%rip), %rcx     # 0x29ffb
movl $0xa8, %edx
callq 0x51e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/Directory.cc
// Function: Directory::resetTrackersToEntry(unsigned long)
void
Directory::resetTrackersToEntry(uint64_t addr)
{
	//DPRINTF("DIRECTORY::resetTrackersToEntry Addr %#lx\n", addr );

	DirectoryEntry* entry = getEntry(addr);
	assert(entry != NULL);

	entry->resetTrackers();	
//	m_policy->updatePolicy(entry);
}

// Assembly:
pushq %rax
callq 0xfc52
testq %rax, %rax
je 0xfe9e
movq %rax, %rdi
popq %rax
jmp 0x10412
leaq 0x1bcbf(%rip), %rdi     # 0x2bb64
leaq 0x1a084(%rip), %rsi     # 0x29f30
leaq 0x1a184(%rip), %rcx     # 0x2a037
movl $0xb5, %edx
callq 0x51e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/Directory.cc
// Function: Directory::removeEntry(unsigned long)
void
Directory::removeEntry(uint64_t addr)
{
	DirectoryEntry* entry = getEntry(addr);
	assert(entry != NULL);
	//DPRINTF("DIRECTORY::removeEntry Addr %#lx\n" , addr);
	int id_set = indexFunction(addr);
	for(unsigned i = 0 ; i < m_table[id_set].size(); i++)
	{
		if(addr == m_table[id_set][i]->block_addr && m_table[id_set][i]->isValid){
			m_table[id_set].erase(m_table[id_set].begin() + i);
			break;
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xfc52
testq %rax, %rax
je 0xff2d
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfc96
movq (%r14), %rcx
imulq $0x18, %rax, %rdx
leaq (%rcx,%rdx), %rdi
movq (%rcx,%rdx), %rax
movq 0x8(%rcx,%rdx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorl %edx, %edx
movl %edx, %edx
cmpq %rdx, %rcx
jbe 0xff15
movq (%rax,%rdx,8), %rsi
cmpq %rbx, 0x30(%rsi)
jne 0xff11
cmpb $0x1, 0x3c(%rsi)
je 0xff1d
incl %edx
jmp 0xfefa
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq (%rax,%rdx,8), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1019c
leaq 0x1bc30(%rip), %rdi     # 0x2bb64
leaq 0x19ff5(%rip), %rsi     # 0x29f30
leaq 0x1a124(%rip), %rcx     # 0x2a066
movl $0xcc, %edx
callq 0x51e0
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/Directory.cc
// Function: Directory::addTrackerToEntry(unsigned long, int)
void 
Directory::addTrackerToEntry(uint64_t addr, int node)
{
	//DPRINTF("DIRECTORY::addTrackerToEntry Addr %#lx, node %d\n" , addr, node );

	DirectoryEntry* entry = getEntry(addr);
	assert(entry != NULL);	
	entry->nodeTrackers.insert(node);
//	m_policy->updatePolicy(entry);
}

// Assembly:
pushq %rax
movl %edx, 0x4(%rsp)
callq 0xfc52
testq %rax, %rax
je 0xff6a
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x10816
popq %rax
retq
leaq 0x1bbf3(%rip), %rdi     # 0x2bb64
leaq 0x19fb8(%rip), %rsi     # 0x29f30
leaq 0x1a10d(%rip), %rcx     # 0x2a08c
movl $0xdf, %edx
callq 0x51e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/FeatureTable.cc
// Function: FeatureTable::recordAccess(int, bool, RD_TYPE)
void 
FeatureTable::recordAccess(int index, bool isWrite, RD_TYPE rd)
{
	FeatureEntry* feature_entry = lookup(index);
	
	if(!feature_entry->isValid)
	{	
		//Init the feature entry
		feature_entry->cpts = vector< vector<int> >(NUM_RW_TYPE, vector<int>(NUM_RD_TYPE, 0));
		feature_entry->cptWindow = 0;
		feature_entry->isValid = true;
	}

	if( isWrite ) 
		feature_entry->cpts[WRITE_ACCESS][rd]++;
	else
		feature_entry->cpts[READ_ACCESS][rd]++;
	
	feature_entry->cptWindow++;

	if(feature_entry->cptWindow >= simu_parameters.perceptron_windowSize)
		feature_entry->updateDatasetState();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebp
movl %edx, %r14d
callq 0x10ea4
movq %rax, %rbx
cmpb $0x0, 0x4c(%rax)
jne 0x10f4b
leaq 0x4(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x8(%rsp), %r15
pushq $0x3
popq %rsi
leaq 0x3(%rsp), %rcx
movq %r15, %rdi
callq 0x9c8a
leaq 0x20(%rsp), %rdi
pushq $0x5
popq %rsi
leaq 0x2(%rsp), %rcx
movq %r15, %rdx
callq 0x9ce0
leaq 0x20(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa710
movq %r15, %rdi
callq 0x9d36
leaq 0x8(%rsp), %rdi
callq 0xa49a
andl $0x0, 0x48(%rbx)
movb $0x1, 0x4c(%rbx)
movq (%rbx), %rax
xorl %ecx, %ecx
testb %r14b, %r14b
pushq $0x18
popq %rdx
cmoveq %rcx, %rdx
movl %ebp, %ecx
movq (%rax,%rdx), %rax
incl (%rax,%rcx,4)
movl 0x48(%rbx), %eax
incl %eax
movl %eax, 0x48(%rbx)
leaq 0x2cfde(%rip), %rcx     # 0x3df50
cmpl 0x1b4(%rcx), %eax
jl 0x10f82
movq %rbx, %rdi
callq 0x109ac
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa49a
movq %rbx, %rdi
callq 0x5570
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/FeatureTable.cc
// Function: FeatureTable::recordAccess(int, bool, bool, bool)
void
FeatureTable::recordAccess(int index, bool isWrite, bool isHitSRAM, bool isHitNVM)
{
	FeatureEntry* feature_entry = lookup(index);
	
	if(!feature_entry->isValid)
	{	
		//Init the feature entry
		feature_entry->cpts = vector< vector<int> >(NUM_RW_TYPE, vector<int>(NUM_RD_TYPE, 0));
		feature_entry->cptWindow = 0;
		feature_entry->isValid = true;
	}

	feature_entry->SRAM_seq[isWrite][isHitSRAM]++;
	feature_entry->NVM_seq[isWrite][isHitNVM]++;
	
	feature_entry->cptWindow++;

	if(feature_entry->cptWindow >= simu_parameters.perceptron_windowSize)
		feature_entry->updateDatasetState();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
callq 0x10ea4
movq %rax, %rbx
cmpb $0x0, 0x4c(%rax)
jne 0x11021
leaq 0xc(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x10(%rsp), %r12
pushq $0x3
popq %rsi
leaq 0xb(%rsp), %rcx
movq %r12, %rdi
callq 0x9c8a
leaq 0x28(%rsp), %rdi
pushq $0x5
popq %rsi
leaq 0xa(%rsp), %rcx
movq %r12, %rdx
callq 0x9ce0
leaq 0x28(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa710
movq %r12, %rdi
callq 0x9d36
leaq 0x10(%rsp), %rdi
callq 0xa49a
andl $0x0, 0x48(%rbx)
movb $0x1, 0x4c(%rbx)
movzbl %r15b, %eax
movq 0x18(%rbx), %rcx
imulq $0x18, %rax, %rax
movq (%rcx,%rax), %rcx
movzbl %r14b, %edx
incl (%rcx,%rdx,4)
movq 0x30(%rbx), %rcx
movq (%rcx,%rax), %rax
movzbl %bpl, %ecx
incl (%rax,%rcx,4)
movl 0x48(%rbx), %eax
incl %eax
movl %eax, 0x48(%rbx)
leaq 0x2cefa(%rip), %rcx     # 0x3df50
cmpl 0x1b4(%rcx), %eax
jl 0x11066
movq %rbx, %rdi
callq 0x109ac
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xa49a
movq %rbx, %rdi
callq 0x5570
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/FeatureTable.cc
// Function: FeatureTable::getAllocDecision(int, bool)
allocDecision
FeatureTable::getAllocDecision(int index, bool isWrite)
{
	FeatureEntry* entry = lookup(index);
	allocDecision result = entry->des;
	
	if(result == ALLOCATE_PREEMPTIVELY)
	{
		if(isWrite)
			result = ALLOCATE_IN_SRAM;
		else 
			result = ALLOCATE_IN_NVM;
	}

	if(simu_parameters.perceptron_drawFeatureMaps)
	{
		int sign = result == ALLOCATE_IN_NVM ? -1 : +1;
		stats_allocation_buffer[index].push_back( sign * 32);
	}


	return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x10ea4
movl 0x58(%rax), %eax
xorb $0x1, %bl
cmpl $0x3, %eax
movzbl %bl, %ebx
cmovnel %eax, %ebx
leaq 0x2ce9e(%rip), %rax     # 0x3df50
cmpb $0x1, 0x1cc(%rax)
jne 0x110e0
xorl %eax, %eax
cmpl $0x1, %ebx
setne %al
movslq %ebp, %rcx
imulq $0x18, %rcx, %rdi
addq 0x78(%r14), %rdi
shll $0x6, %eax
addl $-0x20, %eax
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
callq 0xeef4
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/FeatureTable.cc
// Function: FeatureTable::getConfidence(int, bool)
int
FeatureTable::getConfidence(int index, bool isLegal)
{
	int result = lookup(index)->weight;
	
	if(simu_parameters.perceptron_drawFeatureMaps && isLegal)
		stats_weight_buffer[index].push_back(result);
			
	return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
callq 0x10ea4
movl 0x50(%rax), %eax
movl %eax, 0xc(%rsp)
leaq 0x2cdfb(%rip), %rcx     # 0x3df50
andb 0x1cc(%rcx), %r14b
cmpb $0x1, %r14b
jne 0x1117f
movslq %ebp, %rax
imulq $0x18, %rax, %rdi
addq 0x90(%rbx), %rdi
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x9f84
movl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/FeatureTable.cc
// Function: FeatureTable::openNewTimeFrame()
void 
FeatureTable::openNewTimeFrame()
{
	if(!simu_parameters.perceptron_drawFeatureMaps)
		return;
	int avg = 0;
	for(unsigned i = 0; i < stats_allocation_buffer.size() ; i++)
	{
		int sum = 0;
		if(stats_allocation_buffer[i].size() != 0)
		{
			for(unsigned j = 0 ; j < stats_allocation_buffer[i].size() ; j++)
				sum += stats_allocation_buffer[i][j];


			avg = sum / (int)stats_allocation_buffer[i].size();		
		}
		else 
			avg = stats_heatmap_allocation[i].empty() ? 0 : stats_heatmap_allocation[i].back() ;

		stats_heatmap_allocation[i].push_back(avg);

		stats_allocation_buffer[i].clear();
	}

	
	for(unsigned i = 0; i < stats_weight_buffer.size() ; i++)
	{
		int sum = 0;
		if(stats_weight_buffer[i].size() != 0)
		{
			for(unsigned j = 0 ; j < stats_weight_buffer[i].size() ; j++)
				sum += stats_weight_buffer[i][j];


			avg = sum / (int)stats_weight_buffer[i].size();		
		}
		else 
			avg = stats_heatmap_weight[i].empty() ? 16 : stats_heatmap_weight[i].back() ;

		stats_heatmap_weight[i].push_back(avg);

		stats_weight_buffer[i].clear();
	}


}

// Assembly:
leaq 0x2cd75(%rip), %rax     # 0x3df50
cmpb $0x1, 0x1cc(%rax)
jne 0x11343
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
andl $0x0, (%r14)
movq 0x78(%rdi), %rcx
xorl %r12d, %r12d
pushq $0x18
popq %r15
movl %r12d, %r12d
movq 0x80(%rbx), %rax
subq %rcx, %rax
cqto
idivq %r15
cmpq %r12, %rax
jbe 0x11295
imulq $0x18, %r12, %r13
movq (%rcx,%r13), %rdx
movq 0x8(%rcx,%r13), %rcx
subq %rdx, %rcx
je 0x11252
sarq $0x2, %rcx
xorl %eax, %eax
xorl %esi, %esi
movl %esi, %esi
cmpq %rsi, %rcx
jbe 0x11249
addl (%rdx,%rsi,4), %eax
incl %esi
jmp 0x1123b
cltd
idivl %ecx
movq 0x60(%rbx), %rdi
jmp 0x11268
movq 0x60(%rbx), %rdi
movq 0x8(%rdi,%r13), %rax
cmpq %rax, (%rdi,%r13)
je 0x11266
movl -0x4(%rax), %eax
jmp 0x11268
xorl %eax, %eax
movl %eax, 0x4(%rsp)
addq %r13, %rdi
movq %r14, %rsi
callq 0x9f84
movq 0x78(%rbx), %rcx
movq (%rcx,%r13), %rax
cmpq %rax, 0x8(%rcx,%r13)
je 0x1128d
addq %rcx, %r13
movq %rax, 0x8(%r13)
incl %r12d
jmp 0x1120a
movq 0x90(%rbx), %rcx
xorl %r12d, %r12d
pushq $0x10
popq %rbp
leaq 0x4(%rsp), %r14
movl %r12d, %r12d
movq 0x98(%rbx), %rax
subq %rcx, %rax
cqto
idivq %r15
cmpq %r12, %rax
jbe 0x11335
imulq $0x18, %r12, %r13
movq (%rcx,%r13), %rdx
movq 0x8(%rcx,%r13), %rcx
subq %rdx, %rcx
je 0x112ef
sarq $0x2, %rcx
xorl %eax, %eax
xorl %esi, %esi
movl %esi, %esi
cmpq %rsi, %rcx
jbe 0x112e6
addl (%rdx,%rsi,4), %eax
incl %esi
jmp 0x112d8
cltd
idivl %ecx
movq 0x48(%rbx), %rdi
jmp 0x11305
movq 0x48(%rbx), %rdi
movq 0x8(%rdi,%r13), %rax
cmpq %rax, (%rdi,%r13)
je 0x11303
movl -0x4(%rax), %eax
jmp 0x11305
movl %ebp, %eax
movl %eax, 0x4(%rsp)
addq %r13, %rdi
movq %r14, %rsi
callq 0x9f84
movq 0x90(%rbx), %rcx
movq (%rcx,%r13), %rax
cmpq %rax, 0x8(%rcx,%r13)
je 0x1132d
addq %rcx, %r13
movq %rax, 0x8(%r13)
incl %r12d
jmp 0x112a7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/FeatureTable.hh
// Function: FeatureEntry::initEntry()
void initEntry() {
			if(simu_parameters.Cerebron_RDmodel)
			{
			 	SRAM_seq = std::vector< std::vector<int> >(2, std::vector<int>(2, 0));	
			 	NVM_seq = std::vector< std::vector<int> >(2, std::vector<int>(2, 0));				
			}
			else
			 	cpts =  std::vector< std::vector<int> >(NUM_RW_TYPE, std::vector<int>(NUM_RD_TYPE, 0));

			isValid = true;
			cptWindow = 0;

			weight = simu_parameters.perceptron_counter_size/2;
			des = ALLOCATE_PREEMPTIVELY;
		 }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x2c4cd(%rip), %r15     # 0x3df50
cmpb $0x1, 0x226(%r15)
jne 0x11b21
leaq 0xc(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x10(%rsp), %rdi
pushq $0x2
popq %rsi
leaq 0xb(%rsp), %rcx
callq 0x9c8a
leaq 0x28(%rsp), %rdi
pushq $0x2
popq %rsi
leaq 0x10(%rsp), %rdx
leaq 0xa(%rsp), %rcx
callq 0x9ce0
leaq 0x18(%rbx), %rdi
leaq 0x28(%rsp), %r14
movq %r14, %rsi
callq 0xa710
movq %r14, %rdi
callq 0x9d36
leaq 0x10(%rsp), %rdi
callq 0xa49a
leaq 0xc(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x10(%rsp), %rdi
pushq $0x2
popq %rsi
leaq 0xb(%rsp), %rcx
callq 0x9c8a
leaq 0x28(%rsp), %rdi
pushq $0x2
popq %rsi
leaq 0x10(%rsp), %rdx
leaq 0xa(%rsp), %rcx
callq 0x9ce0
leaq 0x30(%rbx), %rdi
leaq 0x28(%rsp), %r14
jmp 0x11b5a
leaq 0xc(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x10(%rsp), %rdi
pushq $0x3
popq %rsi
leaq 0xb(%rsp), %rcx
callq 0x9c8a
leaq 0x28(%rsp), %rdi
pushq $0x5
popq %rsi
leaq 0x10(%rsp), %rdx
leaq 0xa(%rsp), %rcx
callq 0x9ce0
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa710
movq %r14, %rdi
callq 0x9d36
leaq 0x10(%rsp), %rdi
callq 0xa49a
movb $0x1, 0x4c(%rbx)
andl $0x0, 0x48(%rbx)
movl 0x1b0(%r15), %eax
pushq $0x2
popq %rcx
cltd
idivl %ecx
movl %eax, 0x50(%rbx)
movl $0x3, 0x58(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x11ba3
jmp 0x11bb4
jmp 0x11ba3
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xa49a
jmp 0x11bb7
jmp 0x11bb4
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5570
nop
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/FeaturesFunction.cc
// Function: hashing_function1(params_hash, unsigned long, unsigned long)
int hashing_function1(params_hash a , uint64_t addr , uint64_t missPC)
{
	string index = a.index;
	bool hash_with_PC = a.xorWithPC;
	int block = a.nbBlock;
	//string b = hash_with_PC ? "TRUE" : "FALSE";
	//cout << "index = " << index << " block = " << block << " hash_with_PC = " << b << endl;
	assert( block < 8);
	uint64_t tag = 0;
	
	if( index == "MissPC")
		tag = bitSelect( missPC , 8*block , 8*block+7);
	else if( index == "Addr")
		tag = bitSelect( addr , 8*block , 8*block+7);
	else if( index == "currentPC")
		tag = bitSelect( Predictor::m_global_PChistory[0] , 8*block , 8*block+7);
	else if( index == "currentPC1")
		tag = bitSelect( Predictor::m_global_PChistory[1] , 8*block , 8*block+7);
	else if( index == "currentPC2")
		tag = bitSelect( Predictor::m_global_PChistory[2] , 8*block , 8*block+7);
	else if( index == "currentPC3")
		tag = bitSelect( Predictor::m_global_PChistory[3] , 8*block , 8*block+7);
	else
		assert(false && "Hashing Function failed");
	
	if( hash_with_PC)
		tag = (tag ^ Predictor::m_global_PChistory[0])%256;

	return tag;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %rdi
movq %r15, %rsi
callq 0x5410
movl 0x24(%r15), %r12d
cmpl $0x8, %r12d
jge 0x11f08
movb 0x20(%r15), %bpl
leaq 0x18429(%rip), %rsi     # 0x2a24a
movq %rsp, %rdi
callq 0x9f59
testb %al, %al
jne 0x11eb9
leaq 0x18419(%rip), %rsi     # 0x2a251
movq %rsp, %rdi
callq 0x9f59
movq %r14, %rbx
testb %al, %al
jne 0x11eb9
leaq 0x18408(%rip), %rsi     # 0x2a256
movq %rsp, %rdi
callq 0x9f59
testb %al, %al
je 0x11e5e
xorl %esi, %esi
jmp 0x11ea6
leaq 0x183fb(%rip), %rsi     # 0x2a260
movq %rsp, %rdi
callq 0x9f59
testb %al, %al
je 0x11e75
pushq $0x1
jmp 0x11ea5
leaq 0x183ef(%rip), %rsi     # 0x2a26b
movq %rsp, %rdi
callq 0x9f59
testb %al, %al
je 0x11e8c
pushq $0x2
jmp 0x11ea5
leaq 0x183e3(%rip), %rsi     # 0x2a276
movq %rsp, %rdi
callq 0x9f59
testb %al, %al
je 0x11f25
pushq $0x3
popq %rsi
leaq 0x2bdb3(%rip), %rdi     # 0x3dc60
addq $0x10, %rdi
callq 0x12218
movq (%rax), %rbx
movl %r12d, %esi
shll $0x3, %esi
leal 0x7(,%r12,8), %edx
movq %rbx, %rdi
callq 0x24f25
movq %rax, %rbx
testb %bpl, %bpl
je 0x11ef1
leaq 0x2bd82(%rip), %rdi     # 0x3dc60
addq $0x10, %rdi
xorl %esi, %esi
callq 0x12218
movzbl (%rax), %eax
movzbl %bl, %ebx
xorl %eax, %ebx
movq %rsp, %rdi
callq 0x5618
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x182e2(%rip), %rdi     # 0x2a1f1
leaq 0x182e5(%rip), %rsi     # 0x2a1fb
leaq 0x182f6(%rip), %rcx     # 0x2a213
pushq $0x12
popq %rdx
callq 0x51e0
leaq 0x18355(%rip), %rdi     # 0x2a281
leaq 0x182c8(%rip), %rsi     # 0x2a1fb
leaq 0x182d9(%rip), %rcx     # 0x2a213
pushq $0x22
jmp 0x11f1f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5618
movq %rbx, %rdi
callq 0x5570
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/FeaturesFunction.cc
// Function: hashingMissPC(unsigned long, unsigned long, int, bool)
int
hashingMissPC(uint64_t addr , uint64_t missPC, int block, bool hash_with_PC)
{
	assert( block < 8);
	
	uint64_t tag = bitSelect( missPC , 8*block , 8*block+7);
	if( hash_with_PC)
		tag = (tag ^ Predictor::m_global_PChistory[0])%256;

	return tag;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x8, %edx
jge 0x1208c
movl %ecx, %ebp
movl %edx, %eax
shll $0x3, %eax
leal 0x7(,%rdx,8), %edx
movq %rsi, %rdi
movl %eax, %esi
callq 0x24f25
movq %rax, %rbx
testb %bpl, %bpl
je 0x12083
leaq 0x2bbf0(%rip), %rdi     # 0x3dc60
addq $0x10, %rdi
xorl %esi, %esi
callq 0x12218
movzbl (%rax), %eax
movzbl %bl, %ebx
xorl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1815e(%rip), %rdi     # 0x2a1f1
leaq 0x18161(%rip), %rsi     # 0x2a1fb
leaq 0x18203(%rip), %rcx     # 0x2a2a4
pushq $0x5b
popq %rdx
callq 0x51e0
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/FeaturesFunction.cc
// Function: hashingAddr(unsigned long, unsigned long, int, bool)
int
hashingAddr(uint64_t addr , uint64_t missPC, int block, bool hash_with_PC)
{
	assert( block < 8);
	
	uint64_t tag = bitSelect( addr , 8*block , 8*block+7);
	if( hash_with_PC)
		tag = (tag ^ Predictor::m_global_PChistory[0])%256;

	return tag;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x8, %edx
jge 0x120ef
movl %ecx, %ebp
movl %edx, %esi
shll $0x3, %esi
leal 0x7(,%rdx,8), %edx
callq 0x24f25
movq %rax, %rbx
testb %bpl, %bpl
je 0x120e6
leaq 0x2bb8d(%rip), %rdi     # 0x3dc60
addq $0x10, %rdi
xorl %esi, %esi
callq 0x12218
movzbl (%rax), %eax
movzbl %bl, %ebx
xorl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x180fb(%rip), %rdi     # 0x2a1f1
leaq 0x180fe(%rip), %rsi     # 0x2a1fb
leaq 0x181d1(%rip), %rcx     # 0x2a2d5
pushq $0x67
popq %rdx
callq 0x51e0
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/Hierarchy.cc
// Function: Hierarchy::printResults(std::ostream&)
void
Hierarchy::printResults(ostream& out)
{
//	out << "***************" << endl;
	for(unsigned j = 0 ; j < m_private_caches.size() ; j++)
	{
//		out << "Core n°" << j << endl;		
		m_private_caches[j]->printResults(out);
	}
//	out << "***************" << endl;
//	out << "Last Level Cache : " << endl;
	m_LLC->printResults(out);
	out << "***************" << endl;

	out << "Prefetcher:Stats" << endl;
	out << "Prefetcher:issuedPrefetch\t"<< stats_issuedPrefetchs << endl;
	out << "Prefetcher:hitPrefecth\t"<< stats_hitsPrefetch << endl;
	out << "Prefetcher:prefetchErrors\t"<< stats_issuedPrefetchs - stats_hitsPrefetch << endl;


//	out << "MainMem" << endl;
	out << "MainMem:ReadFetch\t" << stats_readMainMem << endl;
	out << "MainMem:WriteFetch\t" << stats_writeMainMem << endl;
	out << "MainMem:CleanWB\t" << stats_cleanWB_MainMem << endl;
	out << "MainMem:DirtyWB\t" << stats_dirtyWB_MainMem << endl;
	
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, %r15d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x128bf
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x195d8
leal 0x1(%r15), %eax
jmp 0x12897
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x195d8
leaq 0x18664(%rip), %rsi     # 0x2af36
movq %r14, %rdi
callq 0x52c0
movq %rax, %rdi
callq 0x5190
leaq 0x17a35(%rip), %rsi     # 0x2a31e
movq %r14, %rdi
callq 0x52c0
movq %rax, %rdi
callq 0x5190
leaq 0x17a2f(%rip), %rsi     # 0x2a32f
movq %r14, %rdi
callq 0x52c0
movq 0x90(%rbx), %rsi
movq %rax, %rdi
callq 0x5200
movq %rax, %rdi
callq 0x5190
leaq 0x17a24(%rip), %rsi     # 0x2a34a
movq %r14, %rdi
callq 0x52c0
movq 0x98(%rbx), %rsi
movq %rax, %rdi
callq 0x5200
movq %rax, %rdi
callq 0x5190
leaq 0x17a16(%rip), %rsi     # 0x2a362
movq %r14, %rdi
callq 0x52c0
movq 0x90(%rbx), %rsi
subq 0x98(%rbx), %rsi
movq %rax, %rdi
callq 0x5200
movq %rax, %rdi
callq 0x5190
leaq 0x17a04(%rip), %rsi     # 0x2a37d
movq %r14, %rdi
callq 0x52c0
movq 0x80(%rbx), %rsi
movq %rax, %rdi
callq 0x5200
movq %rax, %rdi
callq 0x5190
leaq 0x179f1(%rip), %rsi     # 0x2a390
movq %r14, %rdi
callq 0x52c0
movq 0x88(%rbx), %rsi
movq %rax, %rdi
callq 0x5200
movq %rax, %rdi
callq 0x5190
leaq 0x179df(%rip), %rsi     # 0x2a3a4
movq %r14, %rdi
callq 0x52c0
movq 0x70(%rbx), %rsi
movq %rax, %rdi
callq 0x5200
movq %rax, %rdi
callq 0x5190
leaq 0x179cd(%rip), %rsi     # 0x2a3b5
movq %r14, %rdi
callq 0x52c0
movq 0x78(%rbx), %rsi
movq %rax, %rdi
callq 0x5200
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5190
nop
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/Hierarchy.cc
// Function: Hierarchy::printConfig(std::ostream&)
void
Hierarchy::printConfig(ostream& out)
{
	out << "ConfigCache : " << m_configFile << endl;
	out << "NbLevel : " << m_nbLevel << endl;
	out << "NbCore : " << m_nbCores << endl;
	
	for(unsigned j = 0 ; j < m_private_caches.size() ; j++)
	{
		out << "Core n°" << j << endl;		
		m_private_caches[j]->printConfig(out);
	}
	out << "***************" << endl;
	out << "Last Level Cache : " << endl;
	m_LLC->printConfig(out);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x179a7(%rip), %rsi     # 0x2a3c6
movq %rbx, %rdi
callq 0x52c0
leaq 0x38(%r14), %rsi
movq %rax, %rdi
callq 0x5290
movq %rax, %rdi
callq 0x5190
leaq 0x17993(%rip), %rsi     # 0x2a3d5
movq %rbx, %rdi
callq 0x52c0
movl 0x30(%r14), %esi
movq %rax, %rdi
callq 0x5200
movq %rax, %rdi
callq 0x5190
leaq 0x1797b(%rip), %rsi     # 0x2a3e0
movq %rbx, %rdi
callq 0x52c0
movl 0x34(%r14), %esi
movq %rax, %rdi
callq 0x5200
movq %rax, %rdi
callq 0x5190
xorl %eax, %eax
leaq 0x17960(%rip), %r15     # 0x2a3ea
movl %eax, %r12d
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x3, %rax
cmpq %r12, %rax
jbe 0x12ad1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x52c0
movq %rax, %rdi
movq %r12, %rsi
callq 0x5200
movq %rax, %rdi
callq 0x5190
movq (%r14), %rax
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
callq 0x1963a
leal 0x1(%r12), %eax
jmp 0x12a8a
leaq 0x1845e(%rip), %rsi     # 0x2af36
movq %rbx, %rdi
callq 0x52c0
movq %rax, %rdi
callq 0x5190
leaq 0x17904(%rip), %rsi     # 0x2a3f3
movq %rbx, %rdi
callq 0x52c0
movq %rax, %rdi
callq 0x5190
movq 0x18(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1963a
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/Hierarchy.cc
// Function: Hierarchy::finishSimu()
void 
Hierarchy::finishSimu()
{
	cout << "\tSimulation done, finishing up ..." << endl;
	for(unsigned j = 0 ; j < m_private_caches.size() ; j++)
	{
		m_private_caches[j]->finishSimu();
	}
	m_LLC->finishSimu();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2a120(%rip), %rdi     # 0x3cfd0
leaq 0x17645(%rip), %rsi     # 0x2a4fc
callq 0x52c0
movq %rax, %rdi
callq 0x5190
xorl %eax, %eax
movl %eax, %r14d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x12eeb
movq (%rax,%r14,8), %rdi
callq 0x194fe
leal 0x1(%r14), %eax
jmp 0x12ec6
movq 0x18(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x194fe
nop
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/Hierarchy.cc
// Function: Hierarchy::prefetchAddress(Access)
void 
Hierarchy::prefetchAddress(Access element)
{
	uint64_t addr = element.m_address;
	uint64_t block_addr = bitRemove(addr , 0 , m_start_index+1);
	

	DPRINTF(DebugHierarchy, "HIERARCHY::Prefetching of block %#lx\n", block_addr);

		
	DirectoryEntry* entry = m_directory->getEntry(block_addr);
	if(entry == NULL){
		entry = m_directory->addEntry(block_addr, element.isInstFetch());
	}
	assert(entry != NULL);

	DirectoryState dir_state = m_directory->getEntry(block_addr)->coherence_state;

	entry->print();
	
	if(dir_state == NOT_PRESENT)
	{
		m_LLC->handleAccess(element);
		m_directory->updateEntry(block_addr);
		m_directory->setCoherenceState(block_addr, CLEAN_LLC);	
		stats_issuedPrefetchs++;
	}
	else
	{
		DPRINTF(DebugHierarchy, "HIERARCHY::Prefetcher Block %#lx already present\n", block_addr);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq 0xa0(%rsp), %rdi
movl 0x60(%r14), %edx
incl %edx
xorl %esi, %esi
callq 0x24f70
movq %rax, %rbx
leaq 0x173d8(%rip), %rsi     # 0x2a304
leaq 0x48(%rsp), %rdi
leaq 0x47(%rsp), %rdx
callq 0x5140
leaq 0x2b00e(%rip), %r15     # 0x3df50
addq $0x8, %r15
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0x138f8
movq %rax, %r12
leaq 0x48(%rsp), %rdi
callq 0x5618
testq %r12, %r12
je 0x12f76
leaq 0x175b3(%rip), %rdi     # 0x2a51f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5040
leaq 0xa0(%rsp), %r13
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0xfc52
testq %rax, %rax
jne 0x12fae
movq 0x20(%r14), %rdi
xorl %edx, %edx
cmpl $0x2, 0x1c(%r13)
setb %dl
movq %rbx, %rsi
callq 0xfb94
testq %rax, %rax
je 0x13075
movq %rax, %r12
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0xfc52
movl 0x38(%rax), %ebp
movq %r12, %rdi
callq 0xfa48
cmpl $0x8, %ebp
jne 0x13020
movq 0x18(%r14), %rdi
movq 0x30(%r13), %rax
movq %rax, 0x30(%rsp)
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x19476
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x10032
movq 0x20(%r14), %rdi
pushq $0x6
popq %rdx
movq %rbx, %rsi
callq 0xfe58
incq 0x90(%r14)
jmp 0x13066
leaq 0x172dd(%rip), %rsi     # 0x2a304
leaq 0x48(%rsp), %rdi
leaq 0x47(%rsp), %rdx
callq 0x5140
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0x138f8
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x5618
testq %r14, %r14
je 0x13066
leaq 0x17511(%rip), %rdi     # 0x2a56d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5040
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18ae8(%rip), %rdi     # 0x2bb64
leaq 0x173bb(%rip), %rsi     # 0x2a43e
leaq 0x174bb(%rip), %rcx     # 0x2a545
movl $0xfa, %edx
callq 0x51e0
jmp 0x13098
jmp 0x130a7
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5618
jmp 0x130aa
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5570
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/Hierarchy.cc
// Function: Hierarchy::L1sdeallocate(unsigned long)
void
Hierarchy::L1sdeallocate(uint64_t addr)
{
	
	//Invalidation of a cache line in LLC, need to invalidate all trackers in L1s
	DirectoryEntry* entry = m_directory->getEntry(addr);
	if( entry->isInL1() )
	{
		DPRINTF(DebugHierarchy, "Hierarchy::Deallocation of the block[%#lx] from LLC, invalidation of L1s\n" , addr);
		entry->print();
		
		set<int> nodes = m_directory->getTrackers(addr);

		bool isDirty = false;
		for(auto node : nodes)
			isDirty = isDirty || m_private_caches[node]->receiveInvalidation(addr);
		
		m_LLC->getEntry(addr)->isDirty = isDirty;
		
		m_directory->resetTrackersToEntry(addr);
		m_directory->setCoherenceState(addr , CLEAN_LLC);
	}		
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0xfc52
cmpb $0x1, 0x3c(%rax)
jne 0x138ae
movq %rax, %r15
cmpl $0x2, 0x38(%rax)
ja 0x138ae
leaq 0x16b31(%rip), %rsi     # 0x2a304
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5140
leaq 0x2a767(%rip), %rdi     # 0x3df50
addq $0x8, %rdi
leaq 0x8(%rsp), %rsi
callq 0x138f8
movq %rax, %r12
leaq 0x8(%rsp), %rdi
callq 0x5618
testq %r12, %r12
je 0x1381a
leaq 0x16e37(%rip), %rdi     # 0x2a647
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5040
movq %r15, %rdi
callq 0xfa48
movq 0x20(%r14), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0xfd76
movq 0x18(%r15), %r15
leaq 0x10(%rsp), %r12
xorl %r13d, %r13d
cmpq %r12, %r15
je 0x13875
movb $0x1, %bpl
testb $0x1, %r13b
jne 0x13865
movslq 0x20(%r15), %rax
movq (%r14), %rcx
movq (%rcx,%rax,8), %rdi
movq %rbx, %rsi
callq 0x1951e
movl %eax, %ebp
movq %r15, %rdi
callq 0x5340
movq %rax, %r15
movl %ebp, %r13d
jmp 0x13842
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x1959e
andb $0x1, %r13b
movb %r13b, 0x1(%rax)
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0xfe8a
movq 0x20(%r14), %rdi
pushq $0x6
popq %rdx
movq %rbx, %rsi
callq 0xfe58
leaq 0x8(%rsp), %rdi
callq 0x101d6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5618
jmp 0x138e0
movq %rax, %rbx
jmp 0x138e0
jmp 0x138d3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x101d6
movq %rbx, %rdi
callq 0x5570
// File: /workspace/github_cpp_makefile_star2_O2/gvaumour[P]cache-simulator/src/HybridCache.cc
// Function: HybridCache::~HybridCache()
HybridCache::~HybridCache(){
	for (int i = 0; i < m_nb_set; i++) {
		for (int j = 0; j < m_nbSRAMways; j++) {
		    delete m_tableSRAM[i][j];
		}
		for (int j = 0; j < m_nbNVMways; j++) {
		    delete m_tableNVM[i][j];
		}
	}
//	delete m_predictor;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x20(%rdi), %r14
leaq 0x8(%rdi), %rbx
xorl %ecx, %ecx
movslq 0xac(%r15), %rax
cmpq %rax, %rcx
jge 0x14e9a
movq %rcx, (%rsp)
imulq $0x18, %rcx, %rbp
xorl %r13d, %r13d
movslq 0xa8(%r15), %rax
cmpq %rax, %r13
jge 0x14e5a
movq (%r14), %rax
movq (%rax,%rbp), %rax
movq (%rax,%r13,8), %r12
testq %r12, %r12
je 0x14e4d
movq %r12, %rdi
callq 0x17642
movq %r12, %rdi
callq 0x52a0
incq %r13
jmp 0x14e29
xorl %r13d, %r13d
movslq 0xa4(%r15), %rax
cmpq %rax, %r13
jge 0x14e8e
movq (%rbx), %rax
movq (%rax,%rbp), %rax
movq (%rax,%r13,8), %r12
testq %r12, %r12
je 0x14e81
movq %r12, %rdi
callq 0x17642
movq %r12, %rdi
callq 0x52a0
incq %r13
jmp 0x14e5d
movq (%rsp), %rcx
incq %rcx
jmp 0x14e12
leaq 0x1f0(%r15), %rdi
callq 0x178ba
leaq 0x188(%r15), %rdi
callq 0xa4a8
leaq 0x170(%r15), %rdi
callq 0xa4a8
leaq 0x128(%r15), %rdi
callq 0xa4a8
leaq 0x110(%r15), %rdi
callq 0xa4a8
leaq 0xd8(%r15), %rdi
callq 0xa4a8
leaq 0xc0(%r15), %rdi
callq 0xa4a8
leaq 0x70(%r15), %rdi
callq 0x5618
addq $0x38, %r15
movq %r15, %rdi
callq 0x17902
movq %r14, %rdi
callq 0x174be
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x174be
nop