LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: gvaumour[P]cache-simulator/src/Predictor.cc
// Function: Predictor::hitInSRAMMissingTags(unsigned long, int)
bool 
Predictor::hitInSRAMMissingTags(uint64_t block_addr, int id_set)
{
	/* Check if the block is in the missing tag array */ 
	if(m_trackError && !m_isWarmup){
		//An error in the SRAM part is a block that miss in the SRAM array 
		//but not in the MT array
		for(unsigned i = 0 ; i < m_SRAM_missing_tags[id_set].size() ; i++)
		{
			if(m_SRAM_missing_tags[id_set][i]->addr == block_addr && m_SRAM_missing_tags[id_set][i]->isValid)
			{
				////DPRINTF("BasePredictor::checkMissingTags Found SRAM error as %#lx is present in MT tag %i \n", block_addr ,i);  
				return true;
			}
		}	
	}
	return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0x80(%rax)
je 0x56cb0
movq 0x10(%rsp), %rax
testb $0x1, 0x81(%rax)
jne 0x56cb0
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movq %rax, 0x8(%rsp)
addq $0x88, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x58920
movq %rax, %rdi
callq 0x58940
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x56cae
movq 0x10(%rsp), %rdi
addq $0x88, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x58920
movq %rax, %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x58860
movq (%rax), %rax
movq (%rax), %rax
cmpq 0x20(%rsp), %rax
jne 0x56c9c
movq 0x10(%rsp), %rdi
addq $0x88, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x58920
movq %rax, %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x58860
movq (%rax), %rax
testb $0x1, 0x14(%rax)
je 0x56c9c
movb $0x1, 0x37(%rsp)
jmp 0x56cb5
jmp 0x56c9e
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x56c03
jmp 0x56cb0
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
// File: gvaumour[P]cache-simulator/src/Predictor.cc
// Function: Predictor::hitInNVMMissingTags(unsigned long, int)
bool 
Predictor::hitInNVMMissingTags(uint64_t block_addr, int id_set)
{
	/* Check if the block is in the missing tag array */ 
	if(m_trackError && !m_isWarmup){
		//An error in the NVM part is a block that miss in the NVM array 
		//but not in the MT array
		for(unsigned i = 0 ; i < m_NVM_missing_tags[id_set].size() ; i++)
		{
			if(m_NVM_missing_tags[id_set][i]->addr == block_addr && m_NVM_missing_tags[id_set][i]->isValid)
			{
				return true;
			}
		}	
	}
	return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0x80(%rax)
je 0x56db0
movq 0x10(%rsp), %rax
testb $0x1, 0x81(%rax)
jne 0x56db0
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movq %rax, 0x8(%rsp)
addq $0xa0, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x58920
movq %rax, %rdi
callq 0x58940
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x56dae
movq 0x10(%rsp), %rdi
addq $0xa0, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x58920
movq %rax, %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x58860
movq (%rax), %rax
movq (%rax), %rax
cmpq 0x20(%rsp), %rax
jne 0x56d9c
movq 0x10(%rsp), %rdi
addq $0xa0, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x58920
movq %rax, %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x58860
movq (%rax), %rax
testb $0x1, 0x14(%rax)
je 0x56d9c
movb $0x1, 0x37(%rsp)
jmp 0x56db5
jmp 0x56d9e
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x56d03
jmp 0x56db0
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
// File: gvaumour[P]cache-simulator/src/Predictor.cc
// Function: Predictor::openNewTimeFrame()
void
Predictor::openNewTimeFrame()
{
	if(m_isWarmup)
		return;
		
	//DPRINTF("BasePredictor::openNewTimeFrame New Time Frame Start\n");  
	stats_NVM_errors.push_back(0);
	stats_SRAM_errors.push_back(0);
	stats_BP_errors.push_back(0);
	stats_MigrationErrors.push_back(0);
	stats_nbLLCaccessPerFrame = 0;

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x81(%rax)
je 0x56de1
jmp 0x56e66
movq 0x8(%rsp), %rdi
addq $0x1e0, %rdi            # imm = 0x1E0
movl $0x0, 0x1c(%rsp)
leaq 0x1c(%rsp), %rsi
callq 0x20450
movq 0x8(%rsp), %rdi
addq $0x1f8, %rdi            # imm = 0x1F8
movl $0x0, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x20450
movq 0x8(%rsp), %rdi
addq $0x210, %rdi            # imm = 0x210
movl $0x0, 0x14(%rsp)
leaq 0x14(%rsp), %rsi
callq 0x20450
movq 0x8(%rsp), %rdi
addq $0x228, %rdi            # imm = 0x228
movl $0x0, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x20450
movq 0x8(%rsp), %rax
movq $0x0, 0x78(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: gvaumour[P]cache-simulator/src/Predictor.cc
// Function: Predictor::updatePolicy(unsigned long, unsigned long, bool, Access, bool)
void
Predictor::updatePolicy(uint64_t set, uint64_t index, bool inNVM, Access element , bool isWBrequest = false)
{	
	updateCachePressure();
	
	uint64_t block_addr = bitRemove(element.m_address , 0 , log2(BLOCK_SIZE));
	updateFUcaches(block_addr , inNVM);

	if(m_trackError)
	{
		CacheEntry* current = inNVM ? m_tableNVM[set][index] : m_tableSRAM[set][index];
		updateBypassTag( current , set , inNVM);
	}

	if(!m_isWarmup)
	{	
		stats_nbLLCaccessPerFrame++;
		//An error in the NVM side is when handling a write 
		if(inNVM && element.isWrite()){
			stats_NVM_errors[stats_NVM_errors.size()-1]++;

			if(isWBrequest)
				stats_WBerrors++;
			else
				stats_COREerrors++;
		}
	}
}

// Assembly:
subq $0x58, %rsp
movb %r8b, %al
leaq 0x60(%rsp), %r8
movq %r8, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
andb $0x1, %cl
movb %cl, 0x3f(%rsp)
andb $0x1, %al
movb %al, 0x3e(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x55f00
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x40, %edi
callq 0x284e0
movq 0x18(%rsp), %rdi
cvttsd2si %xmm0, %rax
movl %eax, %edx
xorl %esi, %esi
callq 0x655b0
movq 0x20(%rsp), %rdi
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rsi
movb 0x3f(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x55330
movq 0x20(%rsp), %rax
testb $0x1, 0x80(%rax)
je 0x56fe7
testb $0x1, 0x3f(%rsp)
je 0x56f96
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x48(%rsp), %rsi
callq 0xf9a0
movq %rax, %rdi
movq 0x40(%rsp), %rsi
callq 0xf9c0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x56fbe
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x48(%rsp), %rsi
callq 0xf9a0
movq %rax, %rdi
movq 0x40(%rsp), %rsi
callq 0xf9c0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
movq 0x48(%rsp), %rax
movl %eax, %edx
movb 0x3f(%rsp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x560c0
movq 0x20(%rsp), %rax
testb $0x1, 0x81(%rax)
jne 0x57091
movq 0x20(%rsp), %rax
movq 0x78(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x78(%rax)
testb $0x1, 0x3f(%rsp)
je 0x5708f
movq 0x10(%rsp), %rdi
callq 0xf7c0
testb $0x1, %al
jne 0x57021
jmp 0x5708f
movq 0x20(%rsp), %rdi
movq %rdi, %rax
addq $0x1e0, %rax            # imm = 0x1E0
movq %rax, (%rsp)
addq $0x1e0, %rdi            # imm = 0x1E0
callq 0x11020
movq (%rsp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0xef90
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
testb $0x1, 0x3e(%rsp)
je 0x57076
movq 0x20(%rsp), %rax
movq 0x258(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x258(%rax)
jmp 0x5708d
movq 0x20(%rsp), %rax
movq 0x260(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x260(%rax)
jmp 0x5708f
jmp 0x57091
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gvaumour[P]cache-simulator/src/Predictor.cc
// Function: Predictor::isHitInBPtags(unsigned long, int)
bool 
Predictor::isHitInBPtags(uint64_t block_addr , int set)
{
	for(unsigned i = 0 ; i < BP_missing_tags[set].size(); i++)
	{
		if( block_addr == BP_missing_tags[set][i]->addr && BP_missing_tags[set][i]->isValid)
			return true;
	}
	return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movq %rax, 0x8(%rsp)
addq $0x140, %rdi            # imm = 0x140
movslq 0x1c(%rsp), %rsi
callq 0x58920
movq %rax, %rdi
callq 0x58940
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x574ce
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
addq $0x140, %rdi            # imm = 0x140
movslq 0x1c(%rsp), %rsi
callq 0x58920
movq %rax, %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x58860
movq %rax, %rcx
movq (%rsp), %rax
movq (%rcx), %rcx
cmpq (%rcx), %rax
jne 0x574bc
movq 0x10(%rsp), %rdi
addq $0x140, %rdi            # imm = 0x140
movslq 0x1c(%rsp), %rsi
callq 0x58920
movq %rax, %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x58860
movq (%rax), %rax
testb $0x1, 0x14(%rax)
je 0x574bc
movb $0x1, 0x37(%rsp)
jmp 0x574d3
jmp 0x574be
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x57414
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: gvaumour[P]cache-simulator/src/Predictor.cc
// Function: Predictor::getMissPCfromBPtags(unsigned long, int)
uint64_t 
Predictor::getMissPCfromBPtags(uint64_t block_addr , int set)
{
	for(unsigned i = 0 ; i < BP_missing_tags[set].size(); i++)
	{
		if( block_addr == BP_missing_tags[set][i]->addr && BP_missing_tags[set][i]->isValid)
			return BP_missing_tags[set][i]->missPC;
	}
	assert(false);
	return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movl 0x20(%rsp), %eax
movq %rax, 0x10(%rsp)
addq $0x140, %rdi            # imm = 0x140
movslq 0x24(%rsp), %rsi
callq 0x58920
movq %rax, %rdi
callq 0x58940
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x575e9
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x140, %rdi            # imm = 0x140
movslq 0x24(%rsp), %rsi
callq 0x58920
movq %rax, %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0x58860
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rcx
cmpq (%rcx), %rax
jne 0x575d7
movq 0x18(%rsp), %rdi
addq $0x140, %rdi            # imm = 0x140
movslq 0x24(%rsp), %rsi
callq 0x58920
movq %rax, %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0x58860
movq (%rax), %rax
testb $0x1, 0x14(%rax)
je 0x575d7
movq 0x18(%rsp), %rdi
addq $0x140, %rdi            # imm = 0x140
movslq 0x24(%rsp), %rsi
callq 0x58920
movq %rax, %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0x58860
movq (%rax), %rax
movq 0x18(%rax), %rax
addq $0x38, %rsp
retq
jmp 0x575d9
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x57504
leaq 0x1af2e(%rip), %rdi     # 0x7251e
leaq 0x1c13c(%rip), %rsi     # 0x73733
movl $0x2e3, %edx            # imm = 0x2E3
leaq 0x1c238(%rip), %rcx     # 0x7383b
callq 0x5260
nopl (%rax,%rax)
// File: gvaumour[P]cache-simulator/src/Predictor.cc
// Function: Predictor::getAllocSitefromBPtags(unsigned long, int)
bool 
Predictor::getAllocSitefromBPtags( uint64_t addr , int set)
{
	for(unsigned i = 0 ; i < BP_missing_tags[set].size(); i++)
	{
		if( addr == BP_missing_tags[set][i]->addr && BP_missing_tags[set][i]->isValid)
			return BP_missing_tags[set][i]->allocSite;
	}
	assert(false);
	return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movl 0x20(%rsp), %eax
movq %rax, 0x10(%rsp)
addq $0x140, %rdi            # imm = 0x140
movslq 0x24(%rsp), %rsi
callq 0x58920
movq %rax, %rdi
callq 0x58940
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x5771a
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x140, %rdi            # imm = 0x140
movslq 0x24(%rsp), %rsi
callq 0x58920
movq %rax, %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0x58860
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rcx
cmpq (%rcx), %rax
jne 0x57708
movq 0x18(%rsp), %rdi
addq $0x140, %rdi            # imm = 0x140
movslq 0x24(%rsp), %rsi
callq 0x58920
movq %rax, %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0x58860
movq (%rax), %rax
testb $0x1, 0x14(%rax)
je 0x57708
movq 0x18(%rsp), %rdi
addq $0x140, %rdi            # imm = 0x140
movslq 0x24(%rsp), %rsi
callq 0x58920
movq %rax, %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0x58860
movq (%rax), %rax
movb 0x16(%rax), %al
andb $0x1, %al
addq $0x38, %rsp
retq
jmp 0x5770a
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x57634
leaq 0x1adfd(%rip), %rdi     # 0x7251e
leaq 0x1c00b(%rip), %rsi     # 0x73733
movl $0x2ef, %edx            # imm = 0x2EF
leaq 0x1c13e(%rip), %rcx     # 0x73872
callq 0x5260
nopl (%rax)
// File: gvaumour[P]cache-simulator/src/Predictor.cc
// Function: Predictor::printConfig(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void 
Predictor::printConfig(std::ostream& out, std::string entete)
{
//	out << entete << ":Predictor" << endl;
	out << entete << ":Predictor:SizeSRAM_MTarray:\t" << m_SRAMassoc_MT_size << endl;	
	out << entete << ":Predictor:SizeNVM_MTarray:\t" << m_NVMassoc_MT_size << endl;	
	out << entete << ":Predictor:MT_counter_th:\t" << simu_parameters.MT_counter_th << endl;	
	out << entete << ":Predictor:MT_timeframe:\t" << simu_parameters.MT_timeframe << endl;	
	out << entete << ":Predictor:MT_sampling_sets:\t" << simu_parameters.nb_MTcouters_sampling << endl;	

//	else
//		out << entete << ":Predictor:TrackingEnabled\tFALSE" << endl;

	out << entete << ":Predictor:SampledSets\t" << simu_parameters.nb_sampled_sets << endl;
	out << entete << ":Predictor:MediumRDdef\t" << simu_parameters.mediumrd_def << endl;
}

// Assembly:
subq $0x38, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %rax
movq 0x8(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movq %rdi, 0x30(%rsp)
movq %rax, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x5330
movq %rax, %rdi
leaq 0x1be75(%rip), %rsi     # 0x738a8
callq 0x5380
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl 0x28(%rax), %esi
callq 0x5680
movq %rax, %rdi
movq 0x3b566(%rip), %rsi     # 0x92fb8
callq 0x53d0
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0x5330
movq %rax, %rdi
leaq 0x1be56(%rip), %rsi     # 0x738c6
callq 0x5380
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl 0x2c(%rax), %esi
callq 0x5680
movq %rax, %rdi
movq 0x3b529(%rip), %rsi     # 0x92fb8
callq 0x53d0
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0x5330
movq %rax, %rdi
leaq 0x1be36(%rip), %rsi     # 0x738e3
callq 0x5380
movq %rax, %rdi
leaq 0x3c534(%rip), %rax     # 0x93ff0
movl 0xc8(%rax), %esi
callq 0x5510
movq %rax, %rdi
movq 0x3b4e7(%rip), %rsi     # 0x92fb8
callq 0x53d0
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0x5330
movq %rax, %rdi
leaq 0x1be0f(%rip), %rsi     # 0x738fe
callq 0x5380
movq %rax, %rdi
leaq 0x3c4f2(%rip), %rax     # 0x93ff0
movq 0xd0(%rax), %rsi
callq 0x50f0
movq %rax, %rdi
movq 0x3b4a4(%rip), %rsi     # 0x92fb8
callq 0x53d0
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0x5330
movq %rax, %rdi
leaq 0x1bde6(%rip), %rsi     # 0x73918
callq 0x5380
movq %rax, %rdi
leaq 0x3c4af(%rip), %rax     # 0x93ff0
movl 0xd8(%rax), %esi
callq 0x5680
movq %rax, %rdi
movq 0x3b462(%rip), %rsi     # 0x92fb8
callq 0x53d0
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0x5330
movq %rax, %rdi
leaq 0x1bdc2(%rip), %rsi     # 0x73936
callq 0x5380
movq %rax, %rdi
leaq 0x3c46d(%rip), %rax     # 0x93ff0
movl 0x48(%rax), %esi
callq 0x5680
movq %rax, %rdi
movq 0x3b423(%rip), %rsi     # 0x92fb8
callq 0x53d0
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0x5330
movq %rax, %rdi
leaq 0x1bd9b(%rip), %rsi     # 0x7394e
callq 0x5380
movq %rax, %rdi
leaq 0x3c42e(%rip), %rax     # 0x93ff0
movl 0x1fc(%rax), %esi
callq 0x5680
movq %rax, %rdi
movq 0x3b3e1(%rip), %rsi     # 0x92fb8
callq 0x53d0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gvaumour[P]cache-simulator/src/Predictor.cc
// Function: LRUPredictor::updatePolicy(unsigned long, unsigned long, bool, Access, bool)
void
LRUPredictor::updatePolicy(uint64_t set, uint64_t index, bool inNVM, Access element , bool isWBrequest = false)
{
	if(inNVM)
		m_replacementPolicyNVM_ptr->updatePolicy(set, index , element);
	else
		m_replacementPolicySRAM_ptr->updatePolicy(set, index , element);

	Predictor::updatePolicy(set , index , inNVM , element);
	m_cpt++;
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movb %r8b, %al
leaq 0x160(%rsp), %r8
movq %r8, 0x80(%rsp)
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
movq %rdx, 0x140(%rsp)
andb $0x1, %cl
movb %cl, 0x13f(%rsp)
andb $0x1, %al
movb %al, 0x13e(%rsp)
movq 0x150(%rsp), %rax
movq %rax, 0x88(%rsp)
testb $0x1, 0x13f(%rsp)
je 0x581d7
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x68(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x140(%rsp), %rax
movq %rax, 0x78(%rsp)
leaq 0x100(%rsp), %rdi
movl $0x38, %edx
callq 0x52f0
movq 0x68(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq 0x130(%rsp), %r8
movq %rsp, %rcx
movq %r8, 0x30(%rcx)
movups 0x100(%rsp), %xmm0
movups 0x110(%rsp), %xmm1
movups 0x120(%rsp), %xmm2
movups %xmm2, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
callq *%rax
jmp 0x58266
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rax
movq 0x68(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x140(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0xc8(%rsp), %rdi
movl $0x38, %edx
callq 0x52f0
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq 0xf8(%rsp), %r8
movq %rsp, %rcx
movq %r8, 0x30(%rcx)
movups 0xc8(%rsp), %xmm0
movups 0xd8(%rsp), %xmm1
movups 0xe8(%rsp), %xmm2
movups %xmm2, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
callq *%rax
movq 0x80(%rsp), %rsi
movq 0x148(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x140(%rsp), %rax
movq %rax, 0x48(%rsp)
movb 0x13f(%rsp), %al
movb %al, 0x3f(%rsp)
leaq 0x90(%rsp), %rdi
movl $0x38, %edx
callq 0x52f0
movb 0x3f(%rsp), %al
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x88(%rsp), %rdi
xorl %ecx, %ecx
movq 0xc0(%rsp), %r8
movq %rsp, %rcx
movq %r8, 0x30(%rcx)
movups 0x90(%rsp), %xmm0
movups 0xa0(%rsp), %xmm1
movups 0xb0(%rsp), %xmm2
movups %xmm2, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
movzbl %al, %ecx
andl $0x1, %ecx
xorl %r8d, %r8d
callq 0x56ed0
movq 0x88(%rsp), %rax
movq 0x270(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x270(%rax)
addq $0x158, %rsp            # imm = 0x158
retq
nop
// File: gvaumour[P]cache-simulator/src/Predictor.cc
// Function: LRUPredictor::insertionPolicy(unsigned long, unsigned long, bool, Access)
void
LRUPredictor::insertionPolicy(uint64_t set, uint64_t index, bool inNVM, Access element)
{	
	if(inNVM)
		m_replacementPolicyNVM_ptr->insertionPolicy(set, index , element);
	else
		m_replacementPolicySRAM_ptr->insertionPolicy(set, index , element);
	
	
	Predictor::insertionPolicy(set, index , inNVM , element);
	m_cpt++;
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movb %cl, %al
leaq 0x160(%rsp), %rcx
movq %rcx, 0x80(%rsp)
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
movq %rdx, 0x140(%rsp)
andb $0x1, %al
movb %al, 0x13f(%rsp)
movq 0x150(%rsp), %rax
movq %rax, 0x88(%rsp)
testb $0x1, 0x13f(%rsp)
je 0x5840c
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x68(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x140(%rsp), %rax
movq %rax, 0x78(%rsp)
leaq 0x100(%rsp), %rdi
movl $0x38, %edx
callq 0x52f0
movq 0x68(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq (%rdi), %rax
movq 0x18(%rax), %rax
movq 0x130(%rsp), %r8
movq %rsp, %rcx
movq %r8, 0x30(%rcx)
movups 0x100(%rsp), %xmm0
movups 0x110(%rsp), %xmm1
movups 0x120(%rsp), %xmm2
movups %xmm2, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
callq *%rax
jmp 0x5849b
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rax
movq 0x68(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x140(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0xc8(%rsp), %rdi
movl $0x38, %edx
callq 0x52f0
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq (%rdi), %rax
movq 0x18(%rax), %rax
movq 0xf8(%rsp), %r8
movq %rsp, %rcx
movq %r8, 0x30(%rcx)
movups 0xc8(%rsp), %xmm0
movups 0xd8(%rsp), %xmm1
movups 0xe8(%rsp), %xmm2
movups %xmm2, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
callq *%rax
movq 0x80(%rsp), %rsi
movq 0x148(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x140(%rsp), %rax
movq %rax, 0x48(%rsp)
movb 0x13f(%rsp), %al
movb %al, 0x3f(%rsp)
leaq 0x90(%rsp), %rdi
movl $0x38, %edx
callq 0x52f0
movb 0x3f(%rsp), %al
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x88(%rsp), %rdi
movq 0xc0(%rsp), %r8
movq %rsp, %rcx
movq %r8, 0x30(%rcx)
movups 0x90(%rsp), %xmm0
movups 0xa0(%rsp), %xmm1
movups 0xb0(%rsp), %xmm2
movups %xmm2, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
movzbl %al, %ecx
andl $0x1, %ecx
callq 0x55140
movq 0x88(%rsp), %rax
movq 0x270(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x270(%rax)
addq $0x158, %rsp            # imm = 0x158
retq
nop
// File: gvaumour[P]cache-simulator/src/Predictor.cc
// Function: LRUPredictor::evictPolicy(int, bool)
int
LRUPredictor::evictPolicy(int set, bool inNVM)
{
	int assoc_victim;
	
	if(inNVM)
		assoc_victim = m_replacementPolicyNVM_ptr->evictPolicy(set);
	else
		assoc_victim =  m_replacementPolicySRAM_ptr->evictPolicy(set);
	
	evictRecording(set , assoc_victim , inNVM);
	return assoc_victim;
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
andb $0x1, %al
movb %al, 0x1b(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x1b(%rsp)
je 0x5858f
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rdi
movl 0x1c(%rsp), %esi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, 0x14(%rsp)
jmp 0x585a6
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rdi
movl 0x1c(%rsp), %esi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x14(%rsp), %edx
movb 0x1b(%rsp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x58dd0
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: gvaumour[P]cache-simulator/src/Predictor.cc
// Function: PreemptivePredictor::allocateInNVM(unsigned long, Access)
allocDecision
PreemptivePredictor::allocateInNVM(uint64_t set, Access element)
{

	if( m_nbSRAMways == 0 )
		return ALLOCATE_IN_NVM;
	else if(m_nbNVMways == 0)
		return ALLOCATE_IN_SRAM;


	if(element.isWrite())
		return ALLOCATE_IN_SRAM;
	else
		return ALLOCATE_IN_NVM;
}

// Assembly:
subq $0x28, %rsp
leaq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x24(%rax)
jne 0x58601
movl $0x1, 0x24(%rsp)
jmp 0x58639
movq 0x8(%rsp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x58616
movl $0x0, 0x24(%rsp)
jmp 0x58639
jmp 0x58618
movq (%rsp), %rdi
callq 0xf7c0
testb $0x1, %al
jne 0x58627
jmp 0x58631
movl $0x0, 0x24(%rsp)
jmp 0x58639
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: gvaumour[P]cache-simulator/src/Predictor.hh
// Function: MissingTagEntry::initFeaturesHash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void initFeaturesHash(std::string policy)
		{
			if( policy == "Cerebron")	
				features_hash = std::vector<int>( simu_parameters.PHC_features.size() , 0);
			//else if (policy == "SimplePerceptron")
			//	features_hash = std::vector<int>( simu_parameters.simple_perceptron_features.size() , 0);
		}

// Assembly:
subq $0x68, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %rax
movq 0x18(%rsp), %rdi
movq %rax, 0x60(%rsp)
movq %rdi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x19e5c(%rip), %rsi     # 0x727e8
callq 0xfa60
testb $0x1, %al
jne 0x5899a
jmp 0x58a27
leaq 0x3b64f(%rip), %rdi     # 0x93ff0
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0xf190
movq %rax, 0x8(%rsp)
movl $0x0, 0x3c(%rsp)
leaq 0x3b(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xed30
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rcx
leaq 0x40(%rsp), %rdi
leaq 0x3c(%rsp), %rdx
callq 0xed40
jmp 0x589e4
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
leaq 0x40(%rsp), %rsi
callq 0xf150
leaq 0x40(%rsp), %rdi
callq 0xef00
leaq 0x3b(%rsp), %rdi
callq 0xef60
jmp 0x58a27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3b(%rsp), %rdi
callq 0xef60
jmp 0x58a2c
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x5690
nopw %cs:(%rax,%rax)
// File: gvaumour[P]cache-simulator/src/ReplacementPolicy.cc
// Function: LRUPolicy::evictPolicy(int)
int
LRUPolicy::evictPolicy(int set)
{
	int smallest_time = m_cache_entries[set][0]->policyInfo , smallest_index = 0;

	for(int i = 0 ; i < m_assoc ; i++){
		if(!m_cache_entries[set][i]->isValid) 
			return i;
	}
	
	for(int i = 0 ; i < m_assoc ; i++){
		if(m_cache_entries[set][i]->policyInfo < smallest_time){
			smallest_time =  m_cache_entries[set][i]->policyInfo;
			smallest_index = i;
		}
	}
	return smallest_index;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
movslq 0x24(%rsp), %rsi
callq 0xf9a0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xf9c0
movq (%rax), %rax
movl 0x38(%rax), %eax
movl %eax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl 0x24(%rcx), %eax
jge 0x5d20d
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movslq 0x24(%rsp), %rsi
callq 0xf9a0
movq %rax, %rdi
movslq 0x18(%rsp), %rsi
callq 0xf9c0
movq (%rax), %rax
testb $0x1, (%rax)
jne 0x5d1fe
movl 0x18(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x5d298
jmp 0x5d200
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x5d1bb
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x24(%rcx), %eax
jge 0x5d290
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movslq 0x24(%rsp), %rsi
callq 0xf9a0
movq %rax, %rdi
movslq 0x14(%rsp), %rsi
callq 0xf9c0
movq (%rax), %rax
movl 0x38(%rax), %eax
cmpl 0x20(%rsp), %eax
jge 0x5d281
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movslq 0x24(%rsp), %rsi
callq 0xf9a0
movq %rax, %rdi
movslq 0x14(%rsp), %rsi
callq 0xf9c0
movq (%rax), %rax
movl 0x38(%rax), %eax
movl %eax, 0x20(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x5d283
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x5d215
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gvaumour[P]cache-simulator/src/SaturationPredictor.cc
// Function: SaturationCounter::insertionPolicy(unsigned long, unsigned long, bool, Access)
void SaturationCounter::insertionPolicy(uint64_t set, uint64_t index, bool inNVM, Access element)
{

	if(inNVM){
		m_tableNVM[set][index]->policyInfo = m_cpt;
		m_tableNVM[set][index]->saturation_counter = 0;		
	}
	else{
		m_tableSRAM[set][index]->policyInfo = m_cpt;
		m_tableSRAM[set][index]->saturation_counter = 0;	
	
	}
	
	Predictor::insertionPolicy(set , index , inNVM , element);
	m_cpt++;
}

// Assembly:
subq $0xc8, %rsp
movb %cl, %al
leaq 0xd0(%rsp), %rcx
movq %rcx, 0x60(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
andb $0x1, %al
movb %al, 0xaf(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x68(%rsp)
testb $0x1, 0xaf(%rsp)
je 0x5dc50
movq 0x68(%rsp), %rax
movl 0x270(%rax), %ecx
movl %ecx, 0x5c(%rsp)
movq 0x10(%rax), %rdi
movq 0xb8(%rsp), %rsi
callq 0xf9a0
movq %rax, %rdi
movq 0xb0(%rsp), %rsi
callq 0xf9c0
movl 0x5c(%rsp), %edx
movq %rax, %rcx
movq 0x68(%rsp), %rax
movq (%rcx), %rcx
movl %edx, 0x38(%rcx)
movq 0x10(%rax), %rdi
movq 0xb8(%rsp), %rsi
callq 0xf9a0
movq %rax, %rdi
movq 0xb0(%rsp), %rsi
callq 0xf9c0
movq (%rax), %rax
movl $0x0, 0x128(%rax)
jmp 0x5dcc0
movq 0x68(%rsp), %rax
movl 0x270(%rax), %ecx
movl %ecx, 0x58(%rsp)
movq 0x8(%rax), %rdi
movq 0xb8(%rsp), %rsi
callq 0xf9a0
movq %rax, %rdi
movq 0xb0(%rsp), %rsi
callq 0xf9c0
movl 0x58(%rsp), %edx
movq %rax, %rcx
movq 0x68(%rsp), %rax
movq (%rcx), %rcx
movl %edx, 0x38(%rcx)
movq 0x8(%rax), %rdi
movq 0xb8(%rsp), %rsi
callq 0xf9a0
movq %rax, %rdi
movq 0xb0(%rsp), %rsi
callq 0xf9c0
movq (%rax), %rax
movl $0x0, 0x128(%rax)
movq 0x60(%rsp), %rsi
movq 0xb8(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x50(%rsp)
movb 0xaf(%rsp), %al
movb %al, 0x47(%rsp)
leaq 0x70(%rsp), %rdi
movl $0x38, %edx
callq 0x52f0
movb 0x47(%rsp), %al
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x68(%rsp), %rdi
movq 0xa0(%rsp), %r8
movq %rsp, %rcx
movq %r8, 0x30(%rcx)
movups 0x70(%rsp), %xmm0
movups 0x80(%rsp), %xmm1
movups 0x90(%rsp), %xmm2
movups %xmm2, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
movzbl %al, %ecx
andl $0x1, %ecx
callq 0x55140
movq 0x68(%rsp), %rax
movl 0x270(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x270(%rax)
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gvaumour[P]cache-simulator/src/SaturationPredictor.cc
// Function: SaturationCounter::printStats(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SaturationCounter::printStats(std::ostream& out, string entete)
{	
	
	double migrationNVM = (double) stats_nbMigrationsFromNVM[0];
	double migrationSRAM = (double) stats_nbMigrationsFromNVM[1];
	double total = migrationNVM+migrationSRAM;

	if(total > 0){
		out << entete << ":PredictorStats:" << endl;
		out << entete << ":NBMigration\t" << total << endl;
		out << entete << ":MigrationFromNVM\t" << migrationNVM*100/total << "%" << endl;
		out << entete << ":MigrationFromSRAM\t" << migrationSRAM*100/total << "%" << endl;	
	}
	Predictor::printStats(out, entete);
}

// Assembly:
subq $0x88, %rsp
movq %rdx, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0x278, %rdi            # imm = 0x278
xorl %eax, %eax
movl %eax, %esi
callq 0xef90
movq 0x20(%rsp), %rdi
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, 0x68(%rsp)
addq $0x278, %rdi            # imm = 0x278
movl $0x1, %esi
callq 0xef90
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x68(%rsp), %xmm0
addsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
movsd 0x58(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x5dff2
movq 0x18(%rsp), %rsi
movq 0x78(%rsp), %rdi
callq 0x5330
movq %rax, %rdi
leaq 0x15cff(%rip), %rsi     # 0x73bf2
callq 0x5380
movq %rax, %rdi
movq 0x350b6(%rip), %rsi     # 0x92fb8
callq 0x53d0
movq 0x18(%rsp), %rsi
movq 0x78(%rsp), %rdi
callq 0x5330
movq %rax, %rdi
leaq 0x13ea8(%rip), %rsi     # 0x71dc8
callq 0x5380
movq %rax, %rdi
movsd 0x58(%rsp), %xmm0
callq 0x56f0
movq %rax, %rdi
movq 0x3507b(%rip), %rsi     # 0x92fb8
callq 0x53d0
movq 0x18(%rsp), %rsi
movq 0x78(%rsp), %rdi
callq 0x5330
movq %rax, %rdi
leaq 0x13e8a(%rip), %rsi     # 0x71de5
callq 0x5380
movq %rax, %rdi
movsd 0x13a15(%rip), %xmm0    # 0x71980
mulsd 0x68(%rsp), %xmm0
divsd 0x58(%rsp), %xmm0
callq 0x56f0
movq %rax, %rdi
leaq 0x13e72(%rip), %rsi     # 0x71df8
callq 0x5380
movq %rax, %rdi
movq 0x35023(%rip), %rsi     # 0x92fb8
callq 0x53d0
movq 0x18(%rsp), %rsi
movq 0x78(%rsp), %rdi
callq 0x5330
movq %rax, %rdi
leaq 0x13e56(%rip), %rsi     # 0x71e09
callq 0x5380
movq %rax, %rdi
movsd 0x139bd(%rip), %xmm0    # 0x71980
mulsd 0x60(%rsp), %xmm0
divsd 0x58(%rsp), %xmm0
callq 0x56f0
movq %rax, %rdi
leaq 0x13e1a(%rip), %rsi     # 0x71df8
callq 0x5380
movq %rax, %rdi
movq 0x34fcb(%rip), %rsi     # 0x92fb8
callq 0x53d0
movq 0x18(%rsp), %rsi
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x51b0
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x57bf0
jmp 0x5e026
leaq 0x38(%rsp), %rdi
callq 0x5768
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5768
movq 0x30(%rsp), %rdi
callq 0x5690
nopw (%rax,%rax)
// File: gvaumour[P]cache-simulator/src/SaturationPredictor.cc
// Function: SaturationCounter::evictPolicy(int, bool)
int SaturationCounter::evictPolicy(int set, bool inNVM)
{	
	int assoc_victim;
	if(inNVM)
		assoc_victim = m_replacementPolicyNVM_ptr->evictPolicy(set);
	else
		assoc_victim = m_replacementPolicySRAM_ptr->evictPolicy(set);

	evictRecording(set, assoc_victim, inNVM);
	return assoc_victim;
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
andb $0x1, %al
movb %al, 0x1b(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x1b(%rsp)
je 0x5e09f
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rdi
movl 0x1c(%rsp), %esi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, 0x14(%rsp)
jmp 0x5e0b6
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rdi
movl 0x1c(%rsp), %esi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x14(%rsp), %edx
movb 0x1b(%rsp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x5e0e0
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: gvaumour[P]cache-simulator/src/SimpleFeatureTable.cc
// Function: SimpleFeatureTable::decreaseCounter(int)
void
SimpleFeatureTable::decreaseCounter(int hash)
{
	SimpleFeatureEntry* entry = lookup(hash);
	entry->counter--;
	if(entry->counter < -m_counter_size)
		entry->counter = -m_counter_size;	
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x1c(%rsp), %esi
callq 0x5e580
movq 0x8(%rsp), %rdx
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rax
movl 0x4(%rax), %eax
xorl %ecx, %ecx
subl 0x28(%rdx), %ecx
cmpl %ecx, %eax
jge 0x5e67b
movq 0x8(%rsp), %rax
xorl %ecx, %ecx
subl 0x28(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
// File: gvaumour[P]cache-simulator/src/SimpleFeatureTable.cc
// Function: SimpleFeatureTable::increaseCounter(int)
void
SimpleFeatureTable::increaseCounter(int hash)
{
	SimpleFeatureEntry* entry = lookup(hash);
	entry->counter++;
	if(entry->counter > m_counter_size)
		entry->counter = m_counter_size;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x1c(%rsp), %esi
callq 0x5e580
movq 0x8(%rsp), %rcx
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x4(%rax), %edx
addl $0x1, %edx
movl %edx, 0x4(%rax)
movq 0x10(%rsp), %rax
movl 0x4(%rax), %eax
cmpl 0x28(%rcx), %eax
jle 0x5e6d5
movq 0x8(%rsp), %rax
movl 0x28(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: gvaumour[P]cache-simulator/src/SimpleFeatureTable.cc
// Function: SimpleFeatureTable::getCounter(int)
int
SimpleFeatureTable::getCounter(int hash)
{
	SimpleFeatureEntry* entry = lookup(hash);
	if(simu_parameters.perceptron_drawFeatureMaps)
		stats_counter_buffer[hash].push_back( entry->counter );

	return  entry->counter;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x1c(%rsp), %esi
callq 0x5e580
movq %rax, 0x10(%rsp)
leaq 0x358e4(%rip), %rax     # 0x93ff0
testb $0x1, 0x1cc(%rax)
je 0x5e739
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
movslq 0x1c(%rsp), %rsi
callq 0xef70
movq %rax, %rdi
movq 0x10(%rsp), %rsi
addq $0x4, %rsi
callq 0xfb70
movq 0x10(%rsp), %rax
movl 0x4(%rax), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gvaumour[P]cache-simulator/src/SimpleFeatureTable.cc
// Function: SimpleFeatureTable::openNewTimeFrame()
void 
SimpleFeatureTable::openNewTimeFrame()
{
	if(!simu_parameters.perceptron_drawFeatureMaps)
		return;
		
	int avg = 0;
	for(unsigned i = 0; i < stats_counter_buffer.size() ; i++)
	{
		int sum = 0;
		if(stats_counter_buffer[i].size() != 0)
		{
			for(unsigned j = 0 ; j < stats_counter_buffer[i].size() ; j++)
				sum += stats_counter_buffer[i][j];


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

		stats_heatmap_counter[i].push_back(avg);
		stats_counter_buffer[i].clear();
	}

}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x35866(%rip), %rax     # 0x93ff0
testb $0x1, 0x1cc(%rax)
jne 0x5e798
jmp 0x5e943
movl $0x0, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movq 0x18(%rsp), %rdi
movl 0x28(%rsp), %eax
movq %rax, 0x10(%rsp)
addq $0x60, %rdi
callq 0xfb20
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x5e943
movq 0x18(%rsp), %rdi
movl $0x0, 0x24(%rsp)
addq $0x60, %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0xef70
movq %rax, %rdi
callq 0x11020
cmpq $0x0, %rax
je 0x5e8a5
movl $0x0, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movl 0x20(%rsp), %eax
movq %rax, 0x8(%rsp)
addq $0x60, %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0xef70
movq %rax, %rdi
callq 0x11020
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x5e871
movq 0x18(%rsp), %rdi
addq $0x60, %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0xef70
movq %rax, %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0xef90
movl (%rax), %eax
addl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x5e806
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
addq $0x60, %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0xef70
movq %rax, %rdi
callq 0x11020
movq %rax, %rcx
movl 0x4(%rsp), %eax
cltd
idivl %ecx
movl %eax, 0x2c(%rsp)
jmp 0x5e8f6
movq 0x18(%rsp), %rdi
addq $0x48, %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0xef70
movq %rax, %rdi
callq 0x2e960
testb $0x1, %al
jne 0x5e8c7
jmp 0x5e8ce
xorl %eax, %eax
movl %eax, (%rsp)
jmp 0x5e8ef
movq 0x18(%rsp), %rdi
addq $0x48, %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0xef70
movq %rax, %rdi
callq 0x20eb0
movl (%rax), %eax
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, 0x2c(%rsp)
movq 0x18(%rsp), %rdi
addq $0x48, %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0xef70
movq %rax, %rdi
leaq 0x2c(%rsp), %rsi
callq 0xfb70
movq 0x18(%rsp), %rdi
addq $0x60, %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0xef70
movq %rax, %rdi
callq 0x2e9b0
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x5e7a8
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: gvaumour[P]cache-simulator/src/SimplePerceptron.cc
// Function: SimplePerceptronPredictor::initFeatures()
void
SimplePerceptronPredictor::initFeatures()
{
	vector<string>* criterias_name = &m_feature_names;
	vector<params_hash>* features_hash = &m_features_hash;
	vector<SimpleFeatureTable*>* features = &m_features;		

	for(auto feature : *criterias_name)
	{
		features->push_back( new SimpleFeatureTable(m_tableSize, feature, false));
		features_hash->push_back( parseFeatureName(feature) );
	}	
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x100(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rax, %rcx
addq $0x2a0, %rcx            # imm = 0x2A0
movq %rcx, 0xf8(%rsp)
movq %rax, %rcx
addq $0x288, %rcx            # imm = 0x288
movq %rcx, 0xf0(%rsp)
addq $0x270, %rax            # imm = 0x270
movq %rax, 0xe8(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0xe0(%rsp), %rdi
callq 0xebf0
movq %rax, 0xd8(%rsp)
movq 0xe0(%rsp), %rdi
callq 0xec20
movq %rax, 0xd0(%rsp)
leaq 0xd8(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0xec50
testb $0x1, %al
jne 0x603e6
jmp 0x605b8
leaq 0xd8(%rsp), %rdi
callq 0xec90
movq %rax, %rsi
leaq 0xb0(%rsp), %rdi
callq 0x51b0
movq 0xe8(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x78, %edi
callq 0x53a0
movq %rax, 0x18(%rsp)
jmp 0x60421
movq 0x20(%rsp), %rax
movb $0x1, 0x77(%rsp)
movl 0x2b8(%rax), %eax
movl %eax, 0xc(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x51b0
jmp 0x60449
movl 0xc(%rsp), %esi
movq 0x18(%rsp), %rdi
leaq 0x78(%rsp), %rdx
xorl %ecx, %ecx
callq 0x5e140
jmp 0x60460
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movb $0x0, 0x77(%rsp)
movq %rax, 0xa8(%rsp)
leaq 0xa8(%rsp), %rsi
callq 0x64a40
jmp 0x60486
leaq 0x78(%rsp), %rdi
callq 0x5768
movq 0xf0(%rsp), %rax
movq %rax, (%rsp)
leaq 0x28(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x51b0
jmp 0x604b0
movq 0x20(%rsp), %rsi
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x60720
jmp 0x604c6
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xf780
jmp 0x604d6
leaq 0x48(%rsp), %rdi
callq 0xf7b0
leaq 0x28(%rsp), %rdi
callq 0x5768
leaq 0xb0(%rsp), %rdi
callq 0x5768
leaq 0xd8(%rsp), %rdi
callq 0xeca0
jmp 0x603c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x605a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x60556
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x5768
testb $0x1, 0x77(%rsp)
jne 0x6055f
jmp 0x60569
movq 0x18(%rsp), %rdi
callq 0x5340
jmp 0x605a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x6059f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xf7b0
leaq 0x28(%rsp), %rdi
callq 0x5768
leaq 0xb0(%rsp), %rdi
callq 0x5768
jmp 0x605c0
addq $0x108, %rsp            # imm = 0x108
retq
movq 0xa0(%rsp), %rdi
callq 0x5690
nopl (%rax)
// File: gvaumour[P]cache-simulator/src/SimplePerceptron.cc
// Function: SimplePerceptronPredictor::allocateInNVM(unsigned long, Access)
allocDecision
SimplePerceptronPredictor::allocateInNVM(uint64_t set, Access element)
{	
	Predictor::update_globalPChistory(element.m_pc);
	
	if(isHitInBPtags(element.block_addr , set))
		element.m_pc = getMissPCfromBPtags(element.block_addr , set);
	
	/*
	if( hitInSRAMMissingTags( element.block_addr, set) )
		element.m_pc = missingTagMissPC( element.block_addr , set);
	*/
	
	// All the set is a learning/sampled set independantly of its way or SRAM/NVM alloc
	//bool isLearning = m_tableSRAM[set][0]->isLearning; 
	allocDecision des =  activationFunction(element);
	return des;
}

// Assembly:
subq $0x98, %rsp
leaq 0xa0(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x40(%rsp)
movq 0x10(%rax), %rsi
callq 0x573a0
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdi
movq 0x30(%rax), %rsi
movq 0x88(%rsp), %rax
movl %eax, %edx
callq 0x573f0
testb $0x1, %al
jne 0x6090d
jmp 0x60936
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdi
movq 0x30(%rax), %rsi
movq 0x88(%rsp), %rax
movl %eax, %edx
callq 0x574e0
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x38(%rsp), %rsi
leaq 0x48(%rsp), %rdi
movl $0x38, %edx
callq 0x52f0
movq 0x40(%rsp), %rdi
movq 0x78(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x30(%rax)
movups 0x48(%rsp), %xmm0
movups 0x58(%rsp), %xmm1
movups 0x68(%rsp), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x60990
movl %eax, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x98, %rsp
retq
// File: gvaumour[P]cache-simulator/src/SimplePerceptron.cc
// Function: SimplePerceptronPredictor::activationFunction(Access)
allocDecision
SimplePerceptronPredictor::activationFunction(Access element)
{

	int yout = 0;
	for(unsigned i = 0 ; i < m_features.size() ; i++)
	{
		int hash = hashing_function1( m_features_hash[i] , element.block_addr , element.m_pc);
		int pred = m_features[i]->getCounter(hash);
		yout += pred;
	}
	return getDecision(yout , element.isWrite());
}

// Assembly:
subq $0x88, %rsp
leaq 0x90(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x7c(%rsp)
movl $0x0, 0x78(%rsp)
movq 0x30(%rsp), %rdi
movl 0x78(%rsp), %eax
movq %rax, 0x20(%rsp)
addq $0x270, %rdi            # imm = 0x270
callq 0x64a70
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x60aa9
movq 0x30(%rsp), %rdi
addq $0x288, %rdi            # imm = 0x288
movl 0x78(%rsp), %eax
movl %eax, %esi
callq 0xf860
movq %rax, %rsi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xf880
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x10(%rax), %rdx
movq 0x30(%rax), %rsi
callq 0x2ff40
movl %eax, 0x1c(%rsp)
jmp 0x60a3a
leaq 0x48(%rsp), %rdi
callq 0xf7b0
movl 0x1c(%rsp), %eax
movq 0x30(%rsp), %rdi
movl %eax, 0x74(%rsp)
addq $0x270, %rdi            # imm = 0x270
movl 0x78(%rsp), %eax
movl %eax, %esi
callq 0x64a90
movq (%rax), %rdi
movl 0x74(%rsp), %esi
callq 0x5e6e0
movl %eax, 0x38(%rsp)
movl 0x38(%rsp), %eax
addl 0x7c(%rsp), %eax
movl %eax, 0x7c(%rsp)
movl 0x78(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x78(%rsp)
jmp 0x609c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xf7b0
jmp 0x60ad7
movq 0x28(%rsp), %rdi
movl 0x7c(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0xf7c0
movq 0x30(%rsp), %rdi
movl 0xc(%rsp), %esi
movzbl %al, %edx
andl $0x1, %edx
callq 0x63810
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x5690
nopw %cs:(%rax,%rax)
// File: gvaumour[P]cache-simulator/src/SimplePerceptron.cc
// Function: SimplePerceptronPredictor::correctBPerror(CacheEntry*, Access, int)
void
SimplePerceptronPredictor::correctBPerror(CacheEntry* entry , Access element , int set)
{
	bool wasInNVM = getAllocSitefromBPtags(element.block_addr, set);

	for(unsigned i = 0 ; i < m_features.size() ; i++)
	{
		int hash = hashing_function1( m_features_hash[i] , entry->address , entry->missPC);		
		
		if( wasInNVM )
		{
			m_features[i]->decreaseCounter(hash);		
			m_features[i]->decreaseCounter(hash);		
		}
		else
		{
			m_features[i]->increaseCounter(hash);		
			m_features[i]->increaseCounter(hash);		
		}
	}
}

// Assembly:
subq $0x78, %rsp
leaq 0x80(%rsp), %rax
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x30(%rax), %rsi
movl 0x64(%rsp), %edx
callq 0x57610
andb $0x1, %al
movb %al, 0x63(%rsp)
movl $0x0, 0x5c(%rsp)
movq 0x18(%rsp), %rdi
movl 0x5c(%rsp), %eax
movq %rax, 0x10(%rsp)
addq $0x270, %rdi            # imm = 0x270
callq 0x64a70
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x61151
movq 0x18(%rsp), %rdi
addq $0x288, %rdi            # imm = 0x288
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0xf860
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xf880
movq (%rsp), %rdi
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x20(%rax), %rdx
callq 0x2ff40
movl %eax, 0xc(%rsp)
jmp 0x6107e
leaq 0x30(%rsp), %rdi
callq 0xf7b0
movl 0xc(%rsp), %eax
movl %eax, 0x58(%rsp)
testb $0x1, 0x63(%rsp)
je 0x610f9
movq 0x18(%rsp), %rdi
addq $0x270, %rdi            # imm = 0x270
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x64a90
movq (%rax), %rdi
movl 0x58(%rsp), %esi
callq 0x5e620
movq 0x18(%rsp), %rdi
addq $0x270, %rdi            # imm = 0x270
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x64a90
movq (%rax), %rdi
movl 0x58(%rsp), %esi
callq 0x5e620
jmp 0x6113f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xf7b0
jmp 0x61156
movq 0x18(%rsp), %rdi
addq $0x270, %rdi            # imm = 0x270
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x64a90
movq (%rax), %rdi
movl 0x58(%rsp), %esi
callq 0x5e680
movq 0x18(%rsp), %rdi
addq $0x270, %rdi            # imm = 0x270
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x64a90
movq (%rax), %rdi
movl 0x58(%rsp), %esi
callq 0x5e680
jmp 0x61141
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x6100f
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x5690