LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x13236
testq %rax, %rax
je 0x13155
movq %rbx, %rdi
movq %r14, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13236
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1328c
movq %rax, 0x10(%rsp)
movl $0x48, %edi
callq 0x52e0
movq %rax, %r12
addq $0x8, %rax
movl $0x0, 0x8(%r12)
xorl %r13d, %r13d
movq %r13, 0x10(%r12)
movq %rax, 0x18(%r12)
movq %rax, 0x20(%r12)
movw $0x0, 0x3c(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r12)
movl $0x8, %r15d
movl %r15d, 0x38(%r12)
movq %r12, %rdi
callq 0x13ab8
movq %r12, 0x8(%rsp)
movq %r13, 0x30(%r12)
movb $0x0, 0x3d(%r12)
movl %r15d, 0x38(%r12)
movq %r12, %rdi
callq 0x13ab8
movq 0x8(%rsp), %rax
movq %r14, 0x30(%rax)
movb $0x1, 0x3c(%rax)
movb %bpl, 0x3d(%rax)
movq 0x18(%rbx), %rcx
movq (%rcx), %rdx
incq %rdx
movq %rdx, (%rcx)
movl %edx, 0x40(%rax)
movq (%rbx), %rcx
movq 0x10(%rsp), %rdx
leaq (%rdx,%rdx,2), %rdx
leaq (%rcx,%rdx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x13217
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x13221
leaq 0x8(%rsp), %rdx
callq 0x13cae
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1328c
movq (%r14), %rdx
leaq (%rax,%rax,2), %rax
movq (%rdx,%rax,8), %rcx
movq 0x8(%rdx,%rax,8), %rdx
cmpq %rdx, %rcx
je 0x13281
movq (%rcx), %rsi
cmpq %rbx, 0x30(%rsi)
jne 0x13270
cmpb $0x0, 0x3c(%rsi)
je 0x13270
xorl %edi, %edi
movq %rsi, %rax
jmp 0x13273
movb $0x1, %dil
testb %dil, %dil
je 0x13283
addq $0x8, %rcx
cmpq %rdx, %rcx
jne 0x1325a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rax, %rdi
movl $0x40, %edx
callq 0x2e70a
movb 0x2c(%rbx), %cl
incb %cl
shrq %cl, %rax
movl 0x20(%rbx), %ecx
cmpq %rcx, %rax
jae 0x132b7
cltq
popq %rbx
retq
leaq 0x21e91(%rip), %rdi     # 0x3514f
leaq 0x21cbb(%rip), %rsi     # 0x34f80
leaq 0x21e9e(%rip), %rcx     # 0x3516a
movl $0xfb, %edx
callq 0x51d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1328c
movq (%r14), %rdx
leaq (%rax,%rax,2), %rax
movq (%rdx,%rax,8), %rcx
movq 0x8(%rdx,%rax,8), %rdx
subq %rcx, %rdx
setne %al
je 0x13325
movq (%rcx), %rsi
cmpq %rbx, 0x30(%rsi)
je 0x13325
sarq $0x3, %rdx
movl $0x1, %esi
movl %esi, %esi
cmpq %rsi, %rdx
seta %al
jbe 0x13325
movq (%rcx,%rsi,8), %rdi
incl %esi
cmpq %rbx, 0x30(%rdi)
jne 0x1330f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13236
testq %rax, %rax
je 0x1335f
movq %rax, %rbx
movq %rax, %rdi
callq 0x13ab8
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x13dc8
addq $0x10, %rsp
popq %rbx
retq
leaq 0x23856(%rip), %rdi     # 0x36bbc
leaq 0x21c13(%rip), %rsi     # 0x34f80
leaq 0x21c1d(%rip), %rcx     # 0x34f91
movl $0x78, %edx
callq 0x51d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
callq 0x13236
testq %rax, %rax
je 0x13462
movq %rax, %rbx
movq 0x10(%rax), %rdx
addq $0x8, %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x1342e
movq %rax, %rcx
xorl %esi, %esi
cmpl %ebp, 0x20(%rdx)
setl %sil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x13417
movq %rax, %rsi
cmpq %rax, %rcx
je 0x13440
cmpl %ebp, 0x20(%rcx)
cmovgq %rax, %rcx
movq %rcx, %rsi
cmpq %rax, %rsi
je 0x1344d
movq %rbx, %rdi
callq 0x13ed8
cmpq $0x0, 0x28(%rbx)
jne 0x1345b
movl $0x6, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x23753(%rip), %rdi     # 0x36bbc
leaq 0x21b10(%rip), %rsi     # 0x34f80
leaq 0x21ba7(%rip), %rcx     # 0x3501e
movl $0x96, %edx
callq 0x51d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13236
testq %rax, %rax
je 0x13494
movl %ebx, 0x38(%rax)
popq %rbx
retq
leaq 0x23721(%rip), %rdi     # 0x36bbc
leaq 0x21ade(%rip), %rsi     # 0x34f80
leaq 0x21ba2(%rip), %rcx     # 0x3504b
movl $0xa8, %edx
callq 0x51d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13236
testq %rax, %rax
je 0x134c8
movq %rax, %rdi
popq %rax
jmp 0x13ab8
leaq 0x236ed(%rip), %rdi     # 0x36bbc
leaq 0x21aaa(%rip), %rsi     # 0x34f80
leaq 0x21baa(%rip), %rcx     # 0x35087
movl $0xb5, %edx
callq 0x51d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13236
testq %rax, %rax
je 0x13570
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1328c
movq (%r14), %rsi
leaq (%rax,%rax,2), %rdi
movq (%rsi,%rdi,8), %rax
movq 0x8(%rsi,%rdi,8), %rdx
movq %rdx, %rcx
subq %rax, %rcx
je 0x13568
sarq $0x3, %rcx
leaq (%rsi,%rdi,8), %r14
movl $0x1, %esi
xorl %edi, %edi
movq (%rax,%rdi,8), %r8
cmpq %rbx, 0x30(%r8)
jne 0x1353f
cmpb $0x1, 0x3c(%r8)
je 0x1354a
movl %esi, %edi
incl %esi
cmpq %rdi, %rcx
ja 0x1352e
jmp 0x13568
leaq (%rax,%rdi,8), %rsi
addq $0x8, %rsi
cmpq %rdx, %rsi
je 0x13563
leaq (%rax,%rdi,8), %rdi
subq %rsi, %rdx
callq 0x5520
addq $-0x8, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x23645(%rip), %rdi     # 0x36bbc
leaq 0x21a02(%rip), %rsi     # 0x34f80
leaq 0x21b31(%rip), %rcx     # 0x350b6
movl $0xcc, %edx
callq 0x51d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13236
testq %rax, %rax
je 0x135ae
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x13dc8
popq %rax
retq
leaq 0x23607(%rip), %rdi     # 0x36bbc
leaq 0x219c4(%rip), %rsi     # 0x34f80
leaq 0x21b19(%rip), %rcx     # 0x350dc
movl $0xdf, %edx
callq 0x51d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
cmpl %esi, (%rdi)
jle 0x14af2
movslq %esi, %rcx
movq 0x30(%rdi), %rax
movq (%rax,%rcx,8), %rax
movl 0x50(%rax), %eax
movl %eax, 0x4(%rsp)
leaq 0x3149e(%rip), %rsi     # 0x45f50
andb 0x1cc(%rsi), %dl
cmpb $0x1, %dl
jne 0x14aec
movq 0x90(%rdi), %rdx
leaq (%rcx,%rcx,2), %rcx
leaq (%rdx,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x14ae2
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x14aec
leaq 0x4(%rsp), %rdx
callq 0xd68c
movl 0x4(%rsp), %eax
popq %rcx
retq
leaq 0x206f7(%rip), %rdi     # 0x351f0
leaq 0x20720(%rip), %rsi     # 0x35220
leaq 0x2072d(%rip), %rcx     # 0x35234
movl $0x5d, %edx
callq 0x51d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
cmpl $0x8, %edx
jge 0x161d9
movl %ecx, %ebx
movl %edx, %eax
shll $0x3, %eax
leal 0x7(,%rdx,8), %edx
movq %rsi, %rdi
movl %eax, %esi
callq 0x2e6c3
testb %bl, %bl
je 0x161d7
leaq 0x2fada(%rip), %rdx     # 0x45c60
movq 0x10(%rdx), %rsi
movq %rsi, %rcx
subq 0x18(%rdx), %rcx
sarq $0x3, %rcx
cmpq $0x40, %rcx
jb 0x161cf
movq %rcx, %rsi
shrq $0x6, %rsi
movabsq $-0x400000000000000, %rdi # imm = 0xFC00000000000000
orq %rsi, %rdi
testq %rcx, %rcx
cmovgq %rsi, %rdi
movq 0x28(%rdx), %rdx
movq %rdi, %rsi
shlq $0x6, %rsi
subq %rsi, %rcx
shlq $0x3, %rcx
addq (%rdx,%rdi,8), %rcx
movq %rcx, %rsi
movzbl (%rsi), %ecx
movzbl %al, %eax
xorl %ecx, %eax
popq %rbx
retq
leaq 0x1f095(%rip), %rdi     # 0x35275
leaq 0x1f098(%rip), %rsi     # 0x3527f
leaq 0x1f13a(%rip), %rcx     # 0x35328
movl $0x5b, %edx
callq 0x51d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
cmpl $0x8, %edx
jge 0x1626f
movl %ecx, %ebx
movl %edx, %esi
shll $0x3, %esi
leal 0x7(,%rdx,8), %edx
callq 0x2e6c3
testb %bl, %bl
je 0x1626d
leaq 0x2fa44(%rip), %rdx     # 0x45c60
movq 0x10(%rdx), %rsi
movq %rsi, %rcx
subq 0x18(%rdx), %rcx
sarq $0x3, %rcx
cmpq $0x40, %rcx
jb 0x16265
movq %rcx, %rsi
shrq $0x6, %rsi
movabsq $-0x400000000000000, %rdi # imm = 0xFC00000000000000
orq %rsi, %rdi
testq %rcx, %rcx
cmovgq %rsi, %rdi
movq 0x28(%rdx), %rdx
movq %rdi, %rsi
shlq $0x6, %rsi
subq %rsi, %rcx
shlq $0x3, %rcx
addq (%rdx,%rdi,8), %rcx
movq %rcx, %rsi
movzbl (%rsi), %ecx
movzbl %al, %eax
xorl %ecx, %eax
popq %rbx
retq
leaq 0x1efff(%rip), %rdi     # 0x35275
leaq 0x1f002(%rip), %rsi     # 0x3527f
leaq 0x1f0d5(%rip), %rcx     # 0x35359
movl $0x67, %edx
callq 0x51d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1e41e(%rip), %rsi     # 0x3544a
movl $0xe, %edx
movq %rbx, %rdi
callq 0x5350
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
movq %rbx, %rdi
callq 0x5350
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x52b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x51f0
leaq 0x1e3df(%rip), %rsi     # 0x35459
movl $0xa, %edx
movq %rbx, %rdi
callq 0x5350
movl 0x30(%r14), %esi
movq %rbx, %rdi
callq 0x51e0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x52b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x51f0
leaq 0x1e3a0(%rip), %rsi     # 0x35464
movl $0x9, %edx
movq %rbx, %rdi
callq 0x5350
movl 0x34(%r14), %esi
movq %rbx, %rdi
callq 0x51e0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x52b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x51f0
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0x17188
movl $0x1, %ebp
xorl %r12d, %r12d
leaq 0x1e34f(%rip), %r15     # 0x3546e
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5350
movq %rbx, %rdi
movq %r12, %rsi
callq 0x51e0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x52b0
movsbl %al, %esi
movq %r13, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x51f0
movq (%r14), %rax
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
callq 0x1ee42
movq 0x8(%r14), %rax
subq (%r14), %rax
movl %ebp, %r12d
sarq $0x3, %rax
incl %ebp
cmpq %r12, %rax
ja 0x1711f
leaq 0x1edff(%rip), %rsi     # 0x35f8e
movl $0xf, %edx
movq %rbx, %rdi
callq 0x5350
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x52b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x51f0
leaq 0x1e2ad(%rip), %rsi     # 0x35477
movl $0x13, %edx
movq %rbx, %rdi
callq 0x5350
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x52b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x51f0
movq 0x18(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1ee42
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x2d984(%rip), %r14     # 0x44fd0
leaq 0x1df2d(%rip), %rsi     # 0x35580
movl $0x22, %edx
movq %r14, %rdi
callq 0x5350
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x52b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x51f0
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x176b7
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdi
callq 0x1ecbe
movl %ebp, %ecx
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x17697
movq 0x18(%rbx), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1ecbe
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13236
cmpb $0x1, 0x3c(%rax)
jne 0x18125
movq %rax, %r15
cmpl $0x2, 0x38(%rax)
ja 0x18125
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1d346(%rip), %rsi     # 0x35388
leaq 0x1d34d(%rip), %rdx     # 0x35396
leaq 0x8(%rsp), %rdi
callq 0xccac
leaq 0x2def6(%rip), %rbp     # 0x45f50
leaq 0x8(%rbp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x182c0
movq %rax, %r12
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1807a
callq 0x52a0
addq $0x10, %rbp
cmpq %rbp, %r12
je 0x18094
leaq 0x1d641(%rip), %rdi     # 0x356cb
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5050
movq %r15, %rdi
callq 0x12fb0
movq 0x20(%r14), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1337e
movq 0x18(%r15), %r15
leaq 0x10(%rsp), %r12
xorl %ebp, %ebp
cmpq %r12, %r15
je 0x180ee
testb $0x1, %bpl
movb $0x1, %bpl
jne 0x180de
movslq 0x20(%r15), %rax
movq (%r14), %rcx
movq (%rcx,%rax,8), %rdi
movq %rbx, %rsi
callq 0x1ecde
movl %eax, %ebp
movq %r15, %rdi
callq 0x5360
movq %rax, %r15
cmpq %r12, %rax
jne 0x180c0
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x1ed5e
movb %bpl, 0x1(%rax)
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x134b4
movq 0x20(%r14), %rdi
movq %rbx, %rsi
movl $0x6, %edx
callq 0x13482
leaq 0x8(%rsp), %rdi
callq 0x138d6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1815c
callq 0x52a0
jmp 0x1815c
movq %rax, %rbx
jmp 0x1815c
jmp 0x1814f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x138d6
movq %rbx, %rdi
callq 0x55a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0xac(%rdi)
jle 0x19c4d
xorl %r15d, %r15d
cmpl $0x0, 0xa8(%rbx)
leaq (%r15,%r15,2), %r12
jle 0x19bfe
xorl %r13d, %r13d
movq 0x20(%rbx), %rax
movq (%rax,%r12,8), %rax
movq (%rax,%r13,8), %r14
testq %r14, %r14
je 0x19bef
movq %r14, %rdi
callq 0x1d200
movq %r14, %rdi
callq 0x52a0
incq %r13
movslq 0xa8(%rbx), %rax
cmpq %rax, %r13
jl 0x19bce
cmpl $0x0, 0xa4(%rbx)
jle 0x19c3a
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rax
movq (%rax,%r13,8), %r14
testq %r14, %r14
je 0x19c2b
movq %r14, %rdi
callq 0x1d200
movq %r14, %rdi
callq 0x52a0
incq %r13
movslq 0xa4(%rbx), %rax
cmpq %rax, %r13
jl 0x19c0a
incq %r15
movslq 0xac(%rbx), %rax
cmpq %rax, %r15
jl 0x19bbe
leaq 0x1f0(%rbx), %rdi
callq 0x1d386
movq 0x188(%rbx), %rdi
testq %rdi, %rdi
je 0x19c6a
callq 0x52a0
movq 0x170(%rbx), %rdi
testq %rdi, %rdi
je 0x19c7b
callq 0x52a0
movq 0x128(%rbx), %rdi
testq %rdi, %rdi
je 0x19c8c
callq 0x52a0
movq 0x110(%rbx), %rdi
testq %rdi, %rdi
je 0x19c9d
callq 0x52a0
movq 0xd8(%rbx), %rdi
testq %rdi, %rdi
je 0x19cae
callq 0x52a0
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x19cbf
callq 0x52a0
movq 0x70(%rbx), %rdi
leaq 0x80(%rbx), %rax
cmpq %rax, %rdi
je 0x19cd4
callq 0x52a0
leaq 0x38(%rbx), %rdi
callq 0x1d3d0
leaq 0x20(%rbx), %rdi
callq 0x1d066
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1d066
nop
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/HybridCache.cc
// Function: HybridCache::finishSimu()
void 
HybridCache::finishSimu()
{
	for (int i = 0; i < m_nb_set; i++) {
		for (int j = 0; j < m_nbSRAMways; j++) {
		    updateStatsDeallocate(m_tableSRAM[i][j]);
		}
		for (int j = 0; j < m_nbNVMways; j++) {
		    updateStatsDeallocate(m_tableNVM[i][j]);
		}
	}
	m_predictor->finishSimu();
	
	if(simu_parameters.traceLLC && m_ID == -1)
	{
		gzclose(LLC_trace);
	}

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xac(%rdi)
jle 0x19d84
xorl %r14d, %r14d
cmpl $0x0, 0xa8(%rbx)
leaq (%r14,%r14,2), %r15
jle 0x19d46
xorl %r12d, %r12d
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rax
movq (%rax,%r12,8), %rsi
movq %rbx, %rdi
callq 0x19dc6
incq %r12
movslq 0xa8(%rbx), %rax
cmpq %rax, %r12
jl 0x19d23
cmpl $0x0, 0xa4(%rbx)
jle 0x19d75
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movq (%rax,%r12,8), %rsi
movq %rbx, %rdi
callq 0x19dc6
incq %r12
movslq 0xa4(%rbx), %rax
cmpq %rax, %r12
jl 0x19d52
incq %r14
movslq 0xac(%rbx), %rax
cmpq %rax, %r14
jl 0x19d13
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0x2c1bb(%rip), %rax     # 0x45f50
cmpb $0x1, 0x89(%rax)
jne 0x19dba
cmpl $-0x1, (%rbx)
jne 0x19dba
movq 0x2bcde(%rip), %rdi     # 0x45a88
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5550
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/HybridCache.cc
// Function: HybridCache::entete_debug()
void
HybridCache::entete_debug()
{
	DPRINTF(DebugCache , "CACHE[%d]-", m_ID);
	if(m_isInstructionCache){
		DPRINTF(DebugCache , "I:");	
	}
	else{	
		DPRINTF(DebugCache , "D:");
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1b72c(%rip), %rsi     # 0x358a5
leaq 0x1b72f(%rip), %rdx     # 0x358af
movq %rsp, %rdi
callq 0xccac
leaq 0x2bdc1(%rip), %r13     # 0x45f50
leaq 0x8(%r13), %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x182c0
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1a1af
callq 0x52a0
addq $0x10, %r13
cmpq %r13, %r15
je 0x1a1c9
movl (%r14), %esi
leaq 0x1bbfe(%rip), %rdi     # 0x35dc0
xorl %eax, %eax
callq 0x5050
cmpb $0x1, 0x4(%r14)
jne 0x1a213
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x1b6c8(%rip), %rsi     # 0x358a5
leaq 0x1b6cb(%rip), %rdx     # 0x358af
callq 0xccac
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x182c0
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1a205
callq 0x52a0
cmpq %r13, %rbx
je 0x1a25b
leaq 0x1bbba(%rip), %rdi     # 0x35dcb
jmp 0x1a254
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x1b685(%rip), %rsi     # 0x358a5
leaq 0x1b688(%rip), %rdx     # 0x358af
callq 0xccac
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x182c0
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1a248
callq 0x52a0
cmpq %r13, %rbx
je 0x1a25b
leaq 0x1bb7a(%rip), %rdi     # 0x35dce
xorl %eax, %eax
callq 0x5050
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1a271
jmp 0x1a271
jmp 0x1a284
jmp 0x1a284
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1a287
callq 0x52a0
jmp 0x1a287
movq %rax, %rbx
movq %rbx, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/HybridCache.cc
// Function: HybridCache::getEntry(unsigned long)
CacheEntry*
HybridCache::getEntry(uint64_t block_addr)
{
//	uint64_t block_addr =  bitRemove(addr , 0 , m_start_index+1);

	map<uint64_t,HybridLocation>::iterator p = m_tag_index.find(block_addr);
	
	if (p != m_tag_index.end()){
	
		int id_set = addressToCacheSet(block_addr);
		HybridLocation loc = p->second;
		if(loc.m_inNVM)
			return m_tableNVM[id_set][loc.m_way];
		else 
			return m_tableSRAM[id_set][loc.m_way];	
	

	}
	else{
		return NULL;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdx
leaq 0x40(%rdi), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x1a2c2
movq %rax, %rcx
xorl %edi, %edi
cmpq %rsi, 0x20(%rdx)
setb %dil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x1a2aa
movq %rax, %r14
cmpq %rax, %rcx
je 0x1a2d5
cmpq %rsi, 0x20(%rcx)
cmovaq %rax, %rcx
movq %rcx, %r14
cmpq %rax, %r14
je 0x1a30a
movq %rbx, %rdi
callq 0x1b2e6
movslq 0x28(%r14), %rcx
cltq
leaq 0x20(%rbx), %rdx
addq $0x8, %rbx
testb $0x1, 0x2c(%r14)
cmoveq %rdx, %rbx
movq (%rbx), %rdx
leaq (%rax,%rax,2), %rax
movq (%rdx,%rax,8), %rax
movq (%rax,%rcx,8), %rax
jmp 0x1a30c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/HybridCache.cc
// Function: HybridCache::addressToCacheSet(unsigned long)
int 
HybridCache::addressToCacheSet(uint64_t address) 
{
	uint64_t a = address;
	a = bitRemove(a , 0, m_start_index);
	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 %rdi, %rbx
movl 0x94(%rdi), %edx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x2e70a
movl 0x98(%rbx), %esi
movq %rax, %rdi
movl $0x40, %edx
callq 0x2e70a
movb 0x94(%rbx), %cl
incb %cl
shrq %cl, %rax
movl 0xac(%rbx), %ecx
cmpq %rcx, %rax
jae 0x1b325
popq %rbx
retq
leaq 0x19e23(%rip), %rdi     # 0x3514f
leaq 0x1a456(%rip), %rsi     # 0x35789
leaq 0x1a825(%rip), %rcx     # 0x35b5f
movl $0x29b, %edx            # imm = 0x29B
callq 0x51d0
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/HybridCache.cc
// Function: HybridCache::signalWB(Access, bool)
void
HybridCache::signalWB(Access wb_request, bool isKept)
{
	CacheEntry* entry = getEntry(wb_request.m_address);
	if(entry != NULL)
	{
		entete_debug();
		DPRINTF(DebugCache , "Invalidation of the block [%#lx]\n" , entry->address);
		m_system->signalWB(wb_request , isKept);		
	}
	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq 0x90(%rsp), %rsi
callq 0x1a290
testq %rax, %rax
je 0x1b419
movq %rax, %r15
movq %r14, %rdi
callq 0x1a158
leaq 0x48(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1a51d(%rip), %rsi     # 0x358a5
leaq 0x1a520(%rip), %rdx     # 0x358af
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0xccac
leaq 0x2abad(%rip), %rbp     # 0x45f50
leaq 0x8(%rbp), %rdi
movq %r12, %rsi
callq 0x182c0
movq %rax, %r12
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0x1b3c1
callq 0x52a0
leaq 0x90(%rsp), %r13
addq $0x10, %rbp
cmpq %rbp, %r12
je 0x1b3e4
movq 0x8(%r15), %rsi
leaq 0x1a7af(%rip), %rdi     # 0x35b8c
xorl %eax, %eax
callq 0x5050
movq 0xb8(%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)
movzbl %bl, %esi
callq 0x1ed12
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0x1b43a
callq 0x52a0
movq %rbx, %rdi
callq 0x55a0
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/HybridCache.cc
// Function: HybridCache::deallocate(CacheEntry*)
void 
HybridCache::deallocate(CacheEntry* destination_entry)
{
	uint64_t addr = destination_entry->address;
	updateStatsDeallocate(destination_entry);

	map<uint64_t,HybridLocation>::iterator it = m_tag_index.find(addr);	
	if(it != m_tag_index.end()){
		m_tag_index.erase(it);	
	}	

	destination_entry->initEntry();
	
	
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %r15
callq 0x19dc6
movq 0x48(%r14), %rdx
leaq 0x40(%r14), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x1b481
movq %rax, %rcx
xorl %esi, %esi
cmpq %r15, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x1b469
movq %rax, %rsi
cmpq %rax, %rcx
je 0x1b494
cmpq 0x20(%rcx), %r15
cmovbq %rax, %rcx
movq %rcx, %rsi
leaq 0x8(%rbx), %r15
cmpq %rax, %rsi
je 0x1b4a9
addq $0x38, %r14
movq %r14, %rdi
callq 0x1d99a
xorl %eax, %eax
movw %ax, (%rbx)
movw %ax, 0x14b(%rbx)
movl $0x0, 0x128(%rbx)
movq %rax, 0x130(%rbx)
movq %rax, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq %rax, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
movq %rax, 0x118(%rbx)
movq %rax, 0x11d(%rbx)
movl $0x3, 0x168(%rbx)
movq %rax, 0x20(%rbx)
movups %xmm0, 0x138(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/HybridCache.cc
// Function: HybridCache::allocate(unsigned long, int, int, bool, unsigned long, bool)
void 
HybridCache::allocate(uint64_t address , int id_set , int id_assoc, bool inNVM, uint64_t pc, bool isPrefetch)
{

	uint64_t block_addr = bitRemove(address , 0 , m_start_index+1);
	
	if(inNVM){
	 	assert(!m_tableNVM[id_set][id_assoc]->isValid);

		m_tableNVM[id_set][id_assoc]->isValid = true;	
		m_tableNVM[id_set][id_assoc]->address = block_addr;
		m_tableNVM[id_set][id_assoc]->policyInfo = 0;
		m_tableNVM[id_set][id_assoc]->m_pc = pc;
		m_tableNVM[id_set][id_assoc]->isPrefetch = isPrefetch;
	}
	else
	{
	 	assert(!m_tableSRAM[id_set][id_assoc]->isValid);

		m_tableSRAM[id_set][id_assoc]->isValid = true;	
		m_tableSRAM[id_set][id_assoc]->address = block_addr;
		m_tableSRAM[id_set][id_assoc]->policyInfo = 0;		
		m_tableSRAM[id_set][id_assoc]->m_pc = pc;		
		m_tableSRAM[id_set][id_assoc]->isPrefetch = isPrefetch;
	}
	
	if(!m_isWarmup)
		stats_nbFetchedLines++;	
		
	HybridLocation loc(id_assoc, inNVM);
	m_tag_index.insert(pair<uint64_t , HybridLocation>(block_addr , loc));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r9, %r15
movl %r8d, %r14d
movl %ecx, %ebp
movl %edx, %r12d
movq %rdi, %rbx
movl 0x94(%rdi), %edx
incl %edx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x2e70a
movslq %r12d, %rdx
movslq %ebp, %rcx
testl %r14d, %r14d
je 0x1b56d
movq 0x8(%rbx), %rsi
leaq (%rdx,%rdx,2), %rdx
movq (%rsi,%rdx,8), %rdx
movq (%rdx,%rcx,8), %rcx
cmpb $0x1, (%rcx)
jne 0x1b582
leaq 0x1a4ee(%rip), %rdi     # 0x35a43
leaq 0x1a22d(%rip), %rsi     # 0x35789
leaq 0x1a507(%rip), %rcx     # 0x35a6a
movl $0x23d, %edx            # imm = 0x23D
callq 0x51d0
movq 0x20(%rbx), %rsi
leaq (%rdx,%rdx,2), %rdx
movq (%rsi,%rdx,8), %rdx
movq (%rdx,%rcx,8), %rcx
cmpb $0x1, (%rcx)
je 0x1b5de
movb 0x40(%rsp), %dl
movb $0x1, (%rcx)
movq %rax, 0x8(%rcx)
movl $0x0, 0x38(%rcx)
movq %r15, 0x10(%rcx)
movb %dl, 0x14b(%rcx)
cmpb $0x0, 0x91(%rbx)
jne 0x1b5ae
incq 0x1a0(%rbx)
addq $0x38, %rbx
movq %rsp, %rsi
movq %rax, (%rsi)
movzbl %r14b, %eax
shlq $0x20, %rax
movl %ebp, %ecx
orq %rax, %rcx
movq %rcx, 0x8(%rsi)
movq %rbx, %rdi
callq 0x1dc6e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a4ca(%rip), %rdi     # 0x35aaf
leaq 0x1a19d(%rip), %rsi     # 0x35789
leaq 0x1a477(%rip), %rcx     # 0x35a6a
movl $0x247, %edx            # imm = 0x247
callq 0x51d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/HybridCache.cc
// Function: HybridCache::deallocate(unsigned long)
void
HybridCache::deallocate(uint64_t block_addr)
{
	entete_debug();
	DPRINTF(DebugCache , "DEALLOCATE %#lx\n", block_addr);
	map<uint64_t,HybridLocation>::iterator it = m_tag_index.find(block_addr);	
	
	if(it != m_tag_index.end()){

		int id_set = blockAddressToCacheSet(block_addr);

		HybridLocation loc = it->second;
		CacheEntry* current = NULL; 

		if(loc.m_inNVM)
			current = m_tableNVM[id_set][loc.m_way]; 		
		else
			current = m_tableSRAM[id_set][loc.m_way]; 		

		updateStatsDeallocate(current);
		current->initEntry();
				
		m_tag_index.erase(it);	

	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1a158
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1a1de(%rip), %rsi     # 0x358a5
leaq 0x1a1e1(%rip), %rdx     # 0x358af
movq %rsp, %r15
movq %r15, %rdi
callq 0xccac
leaq 0x2a870(%rip), %r13     # 0x45f50
leaq 0x8(%r13), %rdi
movq %r15, %rsi
callq 0x182c0
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1b6fd
callq 0x52a0
addq $0x10, %r13
cmpq %r13, %r15
je 0x1b717
leaq 0x1a325(%rip), %rdi     # 0x35a32
movq %r14, %rsi
xorl %eax, %eax
callq 0x5050
movq 0x48(%rbx), %rdx
leaq 0x40(%rbx), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x1b742
movq %rax, %rcx
xorl %esi, %esi
cmpq %r14, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x1b72a
movq %rax, %r15
cmpq %rax, %rcx
je 0x1b755
cmpq %r14, 0x20(%rcx)
cmovaq %rax, %rcx
movq %rcx, %r15
cmpq %rax, %r15
je 0x1b800
leaq 0x38(%rbx), %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b828
movslq 0x28(%r15), %rcx
cltq
leaq 0x20(%rbx), %rdx
leaq 0x8(%rbx), %rsi
testb $0x1, 0x2c(%r15)
cmoveq %rdx, %rsi
movq (%rsi), %rdx
leaq (%rax,%rax,2), %rax
movq (%rdx,%rax,8), %rax
movq (%rax,%rcx,8), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19dc6
xorl %eax, %eax
movw %ax, (%r14)
movw %ax, 0x14b(%r14)
movl $0x0, 0x128(%r14)
movq %rax, 0x130(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movups %xmm0, 0x18(%r14)
movups %xmm0, 0x28(%r14)
movq %rax, 0x38(%r14)
movq %rax, 0x118(%r14)
movq %rax, 0x11d(%r14)
movl $0x3, 0x168(%r14)
movups %xmm0, 0x138(%r14)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1d99a
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1b81f
callq 0x52a0
movq %rbx, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/HybridCache.cc
// Function: HybridCache::blockAddressToCacheSet(unsigned long)
int 
HybridCache::blockAddressToCacheSet(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 0x98(%rdi), %esi
movq %rax, %rdi
movl $0x40, %edx
callq 0x2e70a
movb 0x94(%rbx), %cl
incb %cl
shrq %cl, %rax
movl 0xac(%rbx), %ecx
cmpq %rcx, %rax
jae 0x1b85a
popq %rbx
retq
leaq 0x198ee(%rip), %rdi     # 0x3514f
leaq 0x19f21(%rip), %rsi     # 0x35789
leaq 0x1a3a7(%rip), %rcx     # 0x35c16
movl $0x2e7, %edx            # imm = 0x2E7
callq 0x51d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/Cache.hh
// Function: CacheEntry::~CacheEntry()
CacheEntry() { 
			isNVM = false;
			isLearning_policy = false;
			isLearning_weight = false;
			isLearning = false;
			initEntry();
		}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x150(%rdi), %rdi
testq %rdi, %rdi
je 0x1d215
callq 0x52a0
movq 0x100(%rbx), %rdi
testq %rdi, %rdi
je 0x1d226
callq 0x52a0
movq 0xe8(%rbx), %rdi
testq %rdi, %rdi
je 0x1d237
callq 0x52a0
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x1d248
callq 0x52a0
leaq 0xa8(%rbx), %rdi
callq 0x121dc
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x1d265
callq 0x52a0
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x1d273
callq 0x52a0
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x1d281
callq 0x52a0
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x1d290
popq %rbx
jmp 0x52a0
popq %rbx
retq
movq %rax, %rdi
callq 0xc9f0
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/Cache.hh
// Function: CacheEntry::copyCL(CacheEntry*)
void copyCL(CacheEntry* a)
		{
			address = a->address;
			isDirty = a->isDirty;
			nbWrite = a->nbWrite;
			nbRead = a->nbRead;
			lastWrite = a->lastWrite;
			m_compilerHints = a->m_compilerHints;
			isLearning = a->isLearning;
			m_pc = a->m_pc;
			coherence_state = a->coherence_state; 
			isPrefetch = a->isPrefetch;
			pc_history = a->pc_history;
			missPC = a->missPC;
			signature = a->signature;
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movb 0x1(%rsi), %al
movb %al, 0x1(%rdi)
movq 0x11c(%rsi), %rax
movq %rax, 0x11c(%rdi)
movb 0x124(%rsi), %al
movb %al, 0x124(%rdi)
movl 0x3c(%rsi), %eax
movl %eax, 0x3c(%rdi)
movb 0x148(%rsi), %al
movb %al, 0x148(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
movl 0x168(%rsi), %eax
movl %eax, 0x168(%rdi)
movb 0x14b(%rsi), %al
movb %al, 0x14b(%rdi)
movl $0x150, %edi            # imm = 0x150
addq %rdi, %rsi
addq %r14, %rdi
callq 0x1d41a
movups 0x18(%rbx), %xmm0
movups %xmm0, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/InstructionPredictor.cc
// Function: InstructionPredictor::allocateInNVM(unsigned long, Access)
allocDecision
InstructionPredictor::allocateInNVM(uint64_t set, Access element)
{
	//DPRINTF("InstructionPredictor::allocateInNVM\n");
	
	if(element.isInstFetch())
		return ALLOCATE_IN_NVM;

	if(pc_counters.count(element.m_pc) == 0){
		//New PC to track		
		pc_counters.insert(pair<uint64_t,int>(element.m_pc, 1));	

		if(!m_isWarmup)
			stats_PCwrites.insert(pair<uint64_t,pair<int,int> >(element.m_pc, pair<int,int>(0,0) ));
		
		map<uint64_t, pair<int,int> > my_tab = map<uint64_t, pair<int,int> >();
	}

	if(pc_counters[element.m_pc] < 2)
		return ALLOCATE_IN_NVM; 
	else
		return ALLOCATE_IN_SRAM;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl $0x1, %eax
cmpl $0x2, 0x6c(%rsp)
jb 0x1df68
movq %rdi, %r15
leaq 0x50(%rsp), %rbx
leaq 0x280(%rdi), %r14
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e600
testq %rax, %rax
jne 0x1df52
movq (%rbx), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movl $0x1, 0x8(%rsi)
movq %r14, %rdi
callq 0xd8dc
cmpb $0x0, 0x81(%r15)
jne 0x1df26
addq $0x2b0, %r15            # imm = 0x2B0
movq (%rbx), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
movq %r15, %rdi
callq 0x1e75a
leaq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x8(%rax)
movaps %xmm0, 0x18(%rax)
movaps %xmm0, -0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq %rsp, %rdi
callq 0x1e710
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e64e
movq %rax, %rcx
xorl %eax, %eax
cmpl $0x2, (%rcx)
setl %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/InstructionPredictor.cc
// Function: InstructionPredictor::updatePolicy(unsigned long, unsigned long, bool, Access, bool)
void
InstructionPredictor::updatePolicy(uint64_t set, uint64_t index, bool inNVM, Access element, bool isWBrequest = false)
{
	//DPRINTF("InstructionPredictor::updatePolicy\n");
	
	CacheEntry* current;

	if(inNVM){
		current = m_tableNVM[set][index];
		m_replacementPolicyNVM_ptr->updatePolicy(set, index , element);
	}		
	else{
		current = m_tableSRAM[set][index];
		m_replacementPolicySRAM_ptr->updatePolicy(set, index , element);
	}
		
	current->policyInfo = m_cpt;
	if(element.isWrite()){
		current->cost_value+= WRITE_VALUE;
	}
	else{ 
		current->cost_value += READ_VALUE;	
	} 	
	Predictor::updatePolicy(set, index, inNVM, element , isWBrequest);

	m_cpt++;
	//DPRINTF("InstructionPredictor:: End updatePolicy\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl %ecx, %eax
xorb $0x1, %cl
movzbl %cl, %ecx
movq 0x8(%rdi,%rax,8), %rax
movq (%rax), %rax
leaq (%rsi,%rsi,2), %rdx
movq (%rax,%rdx,8), %rax
movq (%rax,%r15,8), %r13
movq 0x60(%rdi,%rcx,8), %rdi
movq (%rdi), %rax
movq 0xa0(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movaps 0x70(%rsp), %xmm0
movaps 0x80(%rsp), %xmm1
movaps 0x90(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdx
callq *0x10(%rax)
movl 0x270(%r14), %eax
movl %eax, 0x38(%r13)
movl 0x8c(%rsp), %edx
xorl %eax, %eax
cmpl $0x3, %edx
sete %cl
cmpl $0x6, %edx
je 0x1e017
movb %cl, %al
leaq 0x17e00(%rip), %rcx     # 0x35e10
movsd (%rcx,%rax,8), %xmm0
jmp 0x1e01f
movsd 0x17e01(%rip), %xmm0    # 0x35e20
addsd 0x130(%r13), %xmm0
movsd %xmm0, 0x130(%r13)
movq 0xa0(%rsp), %rax
movq %rax, 0x30(%rsp)
movaps 0x70(%rsp), %xmm0
movaps 0x80(%rsp), %xmm1
movaps 0x90(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x275be
incq 0x270(%r14)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/InstructionPredictor.cc
// Function: InstructionPredictor::insertionPolicy(unsigned long, unsigned long, bool, Access)
void InstructionPredictor::insertionPolicy(uint64_t set, uint64_t index, bool inNVM, Access element)
{
	//DPRINTF("InstructionPredictor::insertionPolicy\n");
	
	CacheEntry* current;
	if(inNVM){
		current = m_tableNVM[set][index];
	}		
	else{
		current = m_tableSRAM[set][index];
	}
	
	current->policyInfo = m_cpt;

	if(element.isWrite())
		current->cost_value = WRITE_VALUE;
	else
		current->cost_value = READ_VALUE;
	
	Predictor::insertionPolicy(set , index , inNVM , element);
	m_cpt++;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movl %ecx, %eax
movq 0x8(%rdi,%rax,8), %rax
movq (%rax), %rax
leaq (%rsi,%rsi,2), %rdi
movq (%rax,%rdi,8), %rax
movq (%rax,%rdx,8), %rax
movl 0x270(%rbx), %edi
movl %edi, 0x38(%rax)
movl 0x6c(%rsp), %r9d
xorl %edi, %edi
cmpl $0x3, %r9d
sete %r8b
cmpl $0x6, %r9d
je 0x1e0d8
movb %r8b, %dil
leaq 0x17d40(%rip), %r8      # 0x35e10
movsd (%r8,%rdi,8), %xmm0
jmp 0x1e0e0
movsd 0x17d40(%rip), %xmm0    # 0x35e20
movsd %xmm0, 0x130(%rax)
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
movaps 0x50(%rsp), %xmm0
movaps 0x60(%rsp), %xmm1
movaps 0x70(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x26892
incq 0x270(%rbx)
addq $0x40, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/InstructionPredictor.cc
// Function: InstructionPredictor::printStats(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void 
InstructionPredictor::printStats(std::ostream& out, string entete)
{	
	int totalWrite = 0;
	for(auto p : stats_PCwrites)
	{
		pair<int,int> current = p.second;
		totalWrite += current.first;
	}
	
	out << entete << ":InstructionPredictor Parameters:" << endl;
	out << entete << ":Total Write\t" << totalWrite << endl;
	
	/*
	ofstream output_file;
	output_file.open(OUTPUT_PREDICTOR_FILE , std::ofstream::app);
	if(totalWrite > 0){
		output_file << "Write Intensity Per Instruction "<< endl;
		for(auto p : stats_PCwrites)
		{
			pair<int,int> current = p.second;
			output_file << p.first << "\t" << current.first << "\t" << current.second << endl;
		}
	}
	output_file.close();
	*/
	Predictor::printStats(out,entete);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2c8(%rdi), %rax
leaq 0x2b8(%rdi), %r12
xorl %ebp, %ebp
cmpq %r12, %rax
je 0x1e3a1
addl 0x28(%rax), %ebp
movq %rax, %rdi
callq 0x5200
jmp 0x1e38f
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x5350
movq %rax, %r12
leaq 0x17abd(%rip), %rsi     # 0x35e77
movl $0x21, %edx
movq %rax, %rdi
callq 0x5350
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x52b0
movsbl %al, %esi
movq %r12, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x51f0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x5350
movq %rax, %r12
leaq 0x17a91(%rip), %rsi     # 0x35e99
movl $0xd, %edx
movq %rax, %rdi
callq 0x5350
movq %r12, %rdi
movl %ebp, %esi
callq 0x5580
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x52b0
movsbl %al, %esi
movq %r12, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x51f0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0xcc1c
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x27d9c
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1e484
callq 0x52a0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1e4a2
callq 0x52a0
movq %rbx, %rdi
callq 0x55a0
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/InstructionPredictor.cc
// Function: InstructionPredictor::evictPolicy(int, bool)
int
InstructionPredictor::evictPolicy(int set, bool inNVM)
{	
	//DPRINTF("InstructionPredictor::evictPolicy set %d\n" , set);
	int assoc_victim = -1;
	assert(m_replacementPolicyNVM_ptr != NULL);
	assert(m_replacementPolicySRAM_ptr != NULL);
	

	if(inNVM)
		assoc_victim = m_replacementPolicyNVM_ptr->evictPolicy(set);
	else
		assoc_victim = m_replacementPolicySRAM_ptr->evictPolicy(set);


	/* Update the status of the instruction */ 
	CacheEntry* current;
	if(inNVM)
		current = m_tableNVM[set][assoc_victim];
	else
		current = m_tableSRAM[set][assoc_victim];

	if(current->isValid){
		//DPRINTF("InstructionPredictor::evictPolicy is Valid\n");
		if( current->cost_value >= simu_parameters.cost_threshold)
		{
			pc_counters[current->m_pc]++;
			if(pc_counters[current->m_pc] == 3)
				pc_counters[current->m_pc] = 3;
		
		}
		else
		{
			pc_counters[current->m_pc]--;
			if(pc_counters[current->m_pc] < 0)
				pc_counters[current->m_pc] = 0;
		}	
	}
	
	evictRecording(set , assoc_victim , inNVM);
	
	return assoc_victim;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x60(%rdi), %rax
testq %rax, %rax
je 0x1e5c2
movq %rdi, %r14
movq 0x68(%rdi), %rdi
testq %rdi, %rdi
je 0x1e5e1
movl %edx, %r15d
movl %esi, %ebx
testb %r15b, %r15b
cmovneq %rax, %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, %ebp
movzbl %r15b, %r15d
movq 0x8(%r14,%r15,8), %rax
movslq %ebx, %rcx
movq (%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movslq %ebp, %rdx
movq (%rax,%rcx,8), %rax
movq (%rax,%rdx,8), %r12
cmpb $0x1, (%r12)
jne 0x1e5a2
movsd 0x130(%r12), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x27a27(%rip), %rax     # 0x45f50
xorps %xmm0, %xmm0
cvtsi2sdl 0xbc(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x280(%r14), %r13
addq $0x10, %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x1e64e
movsd 0x10(%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
movl (%rax), %ecx
jae 0x1e578
decl %ecx
movl %ecx, (%rax)
movq %r13, %rdi
movq %r12, %rsi
callq 0x1e64e
cmpl $0x0, (%rax)
jns 0x1e5a2
xorl %ecx, %ecx
jmp 0x1e591
incl %ecx
movl %ecx, (%rax)
movq %r13, %rdi
movq %r12, %rsi
callq 0x1e64e
movl $0x3, %ecx
cmpl $0x3, (%rax)
jne 0x1e5a2
movq %r13, %rdi
movq %r12, %rsi
movl %ecx, %r12d
callq 0x1e64e
movl %r12d, (%rax)
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
movl %r15d, %ecx
callq 0x2671a
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15bd8(%rip), %rdi     # 0x341a1
leaq 0x178d7(%rip), %rsi     # 0x35ea7
leaq 0x178ec(%rip), %rcx     # 0x35ec3
movl $0x90, %edx
callq 0x51d0
leaq 0x15c12(%rip), %rdi     # 0x341fa
leaq 0x178b8(%rip), %rsi     # 0x35ea7
leaq 0x178cd(%rip), %rcx     # 0x35ec3
movl $0x91, %edx
callq 0x51d0