LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/gvaumour[P]cache-simulator/src/Cerebron.cc
// Function: CerebronPredictor::openNewTimeFrame()
void
CerebronPredictor::openNewTimeFrame()
{
	stats_nbBPrequests.push_back(0);
	stats_nbDeadLine.push_back(0);
	
	stats_missCounter.push_back( miss_counter );
	stats_nbHits = 0, stats_nbMiss = 0;
	
	if(simu_parameters.perceptron_compute_variance)
	{
		if(stats_variances_buffer.size() != 0)
		{
			double avg = 0;
			for(unsigned i = 0 ; i < stats_variances_buffer.size() ; i++)
				avg += stats_variances_buffer[i];
			avg /= (double)stats_variances_buffer.size();

			stats_variances.push_back(avg);	
			stats_variances_buffer.clear();
		}
	}

	for(auto feature : m_features)
		feature->openNewTimeFrame();
	
	
	Predictor::openNewTimeFrame();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
movq 0x390(%rdi), %rsi
cmpq 0x398(%rdi), %rsi
je 0xbe45
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x390(%rbx)
jmp 0xbe56
leaq 0x388(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0xd538
movq $0x0, 0x8(%rsp)
movq 0x3a8(%rbx), %rsi
cmpq 0x3b0(%rbx), %rsi
je 0xbe83
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x3a8(%rbx)
jmp 0xbe94
leaq 0x3a0(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0xd538
movq 0x3c0(%rbx), %rsi
cmpq 0x3c8(%rbx), %rsi
je 0xbebc
leaq 0x3a2f5(%rip), %rax     # 0x461a0
movl (%rax), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x3c0(%rbx)
jmp 0xbecf
leaq 0x3b8(%rbx), %rdi
leaq 0x3a2d6(%rip), %rdx     # 0x461a0
callq 0xd652
xorpd %xmm0, %xmm0
movupd %xmm0, 0x3d0(%rbx)
leaq 0x3a06e(%rip), %rax     # 0x45f50
cmpb $0x1, 0x1cd(%rax)
jne 0xbf79
movq 0x3e0(%rbx), %rax
movq 0x3e8(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
je 0xbf79
sarq $0x3, %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
addsd (%rax,%rsi,8), %xmm0
incq %rsi
movl %esi, %edi
cmpq %rdi, %rdx
ja 0xbf0f
cvtsi2sd %rdx, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x400(%rbx), %rsi
cmpq 0x408(%rbx), %rsi
je 0xbf4e
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x400(%rbx)
jmp 0xbf6d
leaq 0x3f8(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0xd76a
movq 0x3e0(%rbx), %rax
movq 0x3e8(%rbx), %rcx
cmpq %rax, %rcx
je 0xbf79
movq %rax, 0x3e8(%rbx)
movq 0x270(%rbx), %r14
movq 0x278(%rbx), %r15
cmpq %r15, %r14
je 0xbf9a
movq (%r14), %rdi
callq 0x14a42
addq $0x8, %r14
jmp 0xbf87
movq %rbx, %rdi
callq 0x271b2
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/gvaumour[P]cache-simulator/src/Cerebron.cc
// Function: CerebronPredictor::finishSimu()
void 
CerebronPredictor::finishSimu()
{
	if(simu_parameters.perceptron_drawFeatureMaps)
	{
		drawFeatureMaps();
	}

	CacheEntry* entry = NULL;
	for(int i = 0 ; i < m_nb_set ; i++)
	{
		for(int j = 0 ; j < m_nbNVMways ; j++)
		{
			entry = m_tableNVM[i][j];		

			if(!entry->isValid)
				continue;
				
			allocDecision des = getDecision(entry);
			if(des != ALLOCATE_IN_NVM)				
				stats_wrong_alloc++;
			else
				stats_good_alloc++;
		}
		for(int j = 0 ; j < m_nbSRAMways ; j++)
		{
			entry = m_tableSRAM[i][j];		

			if(!entry->isValid)
				continue;

			allocDecision des = getDecision(entry);
			if(des != ALLOCATE_IN_SRAM)				
				stats_wrong_alloc++;
			else
				stats_good_alloc++;
		}
	}
	
	
	for(auto feature : m_features)
		feature->finishSimu();

	Predictor::finishSimu();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x39f8f(%rip), %r14     # 0x45f50
cmpb $0x1, 0x1cc(%r14)
jne 0xbfd3
movq %rbx, %rdi
callq 0xc108
movslq 0x18(%rbx), %rax
testq %rax, %rax
jle 0xc0d7
movl 0x20(%rbx), %ecx
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rsi
movb 0x226(%r14), %dil
movl 0x24(%rbx), %r8d
movq 0x430(%rbx), %r9
movq 0x438(%rbx), %r10
xorl %r11d, %r11d
xorpd %xmm0, %xmm0
leaq (%r11,%r11,2), %r14
testl %ecx, %ecx
jle 0xc06b
movq (%rsi), %r15
movq (%r15,%r14,8), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %r13
cmpb $0x1, (%r13)
jne 0xc063
testb $0x1, %dil
je 0xc04a
movq 0x138(%r13), %rbp
cmpq 0x140(%r13), %rbp
ja 0xc059
incq %r10
movq %r10, 0x438(%rbx)
jmp 0xc063
movsd 0x130(%r13), %xmm1
ucomisd %xmm0, %xmm1
ja 0xc03e
incq %r9
movq %r9, 0x430(%rbx)
incq %r12
cmpq %r12, %rcx
jne 0xc01d
testl %r8d, %r8d
jle 0xc0cb
movq (%rdx), %r15
movq (%r15,%r14,8), %r14
xorl %r15d, %r15d
movq (%r14,%r15,8), %r12
cmpb $0x1, (%r12)
jne 0xc0c3
testb $0x1, %dil
je 0xc0a9
movq 0x138(%r12), %r13
cmpq 0x140(%r12), %r13
ja 0xc0b9
incq %r9
movq %r9, 0x430(%rbx)
jmp 0xc0c3
movsd 0x130(%r12), %xmm1
ucomisd %xmm0, %xmm1
ja 0xc09d
incq %r10
movq %r10, 0x438(%rbx)
incq %r15
cmpq %r15, %r8
jne 0xc07a
incq %r11
cmpq %rax, %r11
jne 0xc00b
movq 0x270(%rbx), %r14
movq 0x278(%rbx), %rbx
cmpq %rbx, %r14
je 0xc0f8
movq (%r14), %rdi
callq 0x14c0e
addq $0x8, %r14
jmp 0xc0e5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBPredictor::~DBAMBPredictor()
DBAMBPredictor::~DBAMBPredictor()
{
//	myFile.close();
	
	for(auto sets : m_DHPTable)
		for(auto entry : sets)
			delete entry;
	if(simu_parameters.printDebug)
		dataset_file.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x3657f(%rip), %rax     # 0x44670
movq %rax, (%rdi)
movq 0x2e8(%rdi), %r14
movq %rdi, 0x8(%rsp)
movq 0x2f0(%rdi), %rbp
cmpq %rbp, %r14
je 0xe19e
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x11fc2
movq 0x10(%rsp), %r12
movq 0x18(%rsp), %rbx
cmpq %rbx, %r12
je 0xe184
movq (%r12), %r13
testq %r13, %r13
je 0xe16e
movq 0xa0(%r13), %rdi
testq %rdi, %rdi
je 0xe149
callq 0x52b0
leaq 0x58(%r13), %rdi
callq 0x12132
movq 0x40(%r13), %rdi
testq %rdi, %rdi
je 0xe160
callq 0x52b0
movq (%r13), %rdi
testq %rdi, %rdi
je 0xe16e
callq 0x52b0
movq %r13, %rdi
callq 0x52b0
addq $0x8, %r12
cmpq %rbx, %r12
jne 0xe12f
movq 0x10(%rsp), %r12
testq %r12, %r12
je 0xe191
movq %r12, %rdi
callq 0x52b0
addq $0x18, %r14
cmpq %rbp, %r14
jne 0xe115
leaq 0x37dab(%rip), %rax     # 0x45f50
cmpb $0x0, (%rax)
je 0xe1b6
leaq 0x374b7(%rip), %rdi     # 0x45668
callq 0x5430
movq 0x8(%rsp), %rbx
leaq 0x3d0(%rbx), %rdi
callq 0x11f1c
leaq 0x3b8(%rbx), %rdi
callq 0xc5b4
leaq 0x3a0(%rbx), %rdi
callq 0xc5b4
movq 0x388(%rbx), %rdi
testq %rdi, %rdi
je 0xe1f0
callq 0x52b0
leaq 0x2e8(%rbx), %r14
movq 0x340(%rbx), %rdi
testq %rdi, %rdi
je 0xe208
callq 0x52b0
leaq 0x308(%rbx), %rdi
callq 0x12158
movq %r14, %rdi
callq 0x11f7c
movq 0x2d0(%rbx), %rdi
testq %rdi, %rdi
je 0xe22d
callq 0x52b0
movq 0x2b8(%rbx), %rdi
testq %rdi, %rdi
je 0xe23e
callq 0x52b0
movq 0x2a0(%rbx), %rdi
testq %rdi, %rdi
je 0xe24f
callq 0x52b0
movq 0x280(%rbx), %rdi
leaq 0x290(%rbx), %rax
cmpq %rax, %rdi
je 0xe267
callq 0x52b0
movq %rbx, %rdi
callq 0x2819a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe282
jmp 0xe282
movq %rax, %rdi
callq 0xc99c
// File: /workspace/github_cpp_makefile_star2_O3/gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBPredictor::lookup(unsigned long)
DHPEntry*
DBAMBPredictor::lookup(uint64_t signature)
{
	uint64_t set = indexFunction(signature);
	for(unsigned i = 0 ; i < m_RAP_assoc ; i++)
	{
		if(m_DHPTable[set][i]->signature == signature)
			return m_DHPTable[set][i];
	}
	return NULL;
}

// Assembly:
movl 0x338(%rdi), %ecx
testq %rcx, %rcx
je 0xe86d
movl 0x33c(%rdi), %r8d
movq %rsi, %rax
xorl %edx, %edx
divq %r8
movq 0x2e8(%rdi), %rax
leaq (%rdx,%rdx,2), %rdx
movq (%rax,%rdx,8), %rdx
xorl %edi, %edi
movq (%rdx,%rdi,8), %rax
cmpq %rsi, 0x20(%rax)
je 0xe86f
incq %rdi
cmpq %rdi, %rcx
jne 0xe85b
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBPredictor::computeRd(unsigned long, unsigned long, bool)
int
DBAMBPredictor::computeRd(uint64_t set, uint64_t  index , bool inNVM)
{
	vector<CacheEntry*> line;
	int ref_rd;
	
	if(inNVM){
		line = m_tableNVM[set];
		ref_rd = m_tableNVM[set][index]->policyInfo;
	}
	else{
		line = m_tableSRAM[set];
		ref_rd = m_tableSRAM[set][index]->policyInfo;
	}
	
	int position = 0;
	
	/* Determine the position of the cachel line in the LRU stack, the policyInfo is not enough */
	for(unsigned i = 0 ; i < line.size() ; i ++)
	{
		if(ref_rd < line[i]->policyInfo  && line[i]->isValid)
			position++;
	}
	return position;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
testl %ecx, %ecx
je 0xfbdb
movq 0x10(%r15), %rax
leaq (%r14,%r14,2), %rsi
shlq $0x3, %rsi
addq (%rax), %rsi
movq %rsp, %rdi
callq 0xc856
addq $0x10, %r15
jmp 0xfbf6
movq 0x8(%r15), %rax
leaq (%r14,%r14,2), %rsi
shlq $0x3, %rsi
addq (%rax), %rsi
movq %rsp, %rdi
callq 0xc856
addq $0x8, %r15
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
je 0xfc3b
sarq $0x3, %rax
movq (%r15), %rcx
movq (%rcx), %rcx
leaq (%r14,%r14,2), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rcx,%rbx,8), %rcx
movl 0x38(%rcx), %ecx
xorl %edx, %edx
xorl %ebx, %ebx
movq (%rdi,%rdx,8), %rsi
cmpl 0x38(%rsi), %ecx
jge 0xfc2f
movzbl (%rsi), %esi
addl %esi, %ebx
incq %rdx
movl %edx, %esi
cmpq %rsi, %rax
ja 0xfc21
jmp 0xfc42
xorl %ebx, %ebx
testq %rdi, %rdi
je 0xfc47
callq 0x52b0
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xfc64
callq 0x52b0
movq %rbx, %rdi
callq 0x55a0
// File: /workspace/github_cpp_makefile_star2_O3/gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBPredictor::finishSimu()
void 
DBAMBPredictor::finishSimu()
{
	//DPRINTF("RAPPredictor::FINISH SIMU\n");

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x35866(%rip), %rax     # 0x45f50
cmpb $0x0, 0x159(%rax)
jne 0x106fc
cmpb $0x1, 0x15a(%rax)
jne 0x10708
leaq 0x35165(%rip), %rdi     # 0x45868
callq 0x5070
cmpb $0x0, 0x81(%rbx)
jne 0x1083d
movq 0x2e8(%rbx), %r14
movq 0x2f0(%rbx), %rax
movq %rax, 0x10(%rsp)
cmpq %rax, %r14
je 0x1083d
leaq 0x388(%rbx), %r15
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x11fc2
movq 0x20(%rsp), %r12
movq 0x28(%rsp), %rbp
cmpq %rbp, %r12
je 0x10821
movq (%r12), %r13
cmpb $0x1, 0x88(%r13)
jne 0x1080f
movq 0x98(%r13), %rax
movq %rax, (%rsp)
movl 0x8c(%r13), %eax
movl %eax, 0x8(%rsp)
movq 0xa8(%r13), %rsi
cmpq 0xb0(%r13), %rsi
je 0x107a8
movl 0x8(%rsp), %eax
movl %eax, 0x8(%rsi)
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0xc, 0xa8(%r13)
jmp 0x107b7
leaq 0xa0(%r13), %rdi
movq %rsp, %rdx
callq 0x12cc2
movl 0x90(%r13), %eax
movl 0x8c(%r13), %ecx
addl %eax, %ecx
jle 0x1080f
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x390(%rbx), %rsi
cmpq 0x398(%rbx), %rsi
je 0x10802
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x390(%rbx)
jmp 0x1080f
movq %r15, %rdi
leaq 0x18(%rsp), %rdx
callq 0x12e2e
addq $0x8, %r12
cmpq %rbp, %r12
jne 0x10758
movq 0x20(%rsp), %r12
testq %r12, %r12
je 0x1082e
movq %r12, %rdi
callq 0x52b0
addq $0x18, %r14
cmpq 0x10(%rsp), %r14
jne 0x10738
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1084e
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x10860
callq 0x52b0
movq %rbx, %rdi
callq 0x55a0
// File: /workspace/github_cpp_makefile_star2_O3/gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBPredictor::openNewTimeFrame()
void 
DBAMBPredictor::openNewTimeFrame()
{ 

	if(m_isWarmup)
		return;

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
cmpb $0x0, 0x81(%rdi)
jne 0x11a42
movq %rdi, %rbx
movl $0x8, %edi
callq 0x52f0
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x8(%rax), %rcx
movq %rcx, 0x10(%rsi)
movq $0x0, (%rax)
movq %rcx, 0x8(%rsi)
leaq 0x3b8(%rbx), %rdi
callq 0x12594
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x119f4
callq 0x52b0
leaq 0x33c6d(%rip), %r14     # 0x45668
leaq 0x2342b(%rip), %rsi     # 0x34e2d
movl $0x9, %edx
movq %r14, %rdi
callq 0x5360
movq 0x33c52(%rip), %rax     # 0x45668
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x52c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5200
movq %rbx, %rdi
callq 0x271b2
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x11a5b
callq 0x52b0
movq %rbx, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBPredictor::hashingFunction(Access)
uint64_t
DBAMBPredictor::hashingFunction(Access element)
{	
	string total = buildHash( element.m_address , element.m_pc);
	string sig ="";
	for(unsigned i = 0 ; i < m_hashingBytes.size() ; i++)
	{
		assert(m_hashingBytes[i] < 16 && "Error on the hashing function bytes selection");
		sig += string(1, total[m_hashingBytes[i]]);
	}
	return hexToInt(sig);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq 0xc0(%rsp), %rsi
movq 0xd0(%rsp), %rdx
leaq 0x68(%rsp), %rdi
callq 0x2e95c
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x241d1(%rip), %rdx     # 0x35c74
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0xcc6c
movq 0x340(%rbx), %rax
cmpq %rax, 0x348(%rbx)
je 0x11b3e
movl $0x1, %ebp
leaq 0x18(%rsp), %r13
xorl %ecx, %ecx
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
movslq (%rax,%rcx,4), %rax
cmpq $0x10, %rax
jge 0x11bb1
movq 0x68(%rsp), %rcx
movsbl (%rcx,%rax), %edx
movq %r13, 0x8(%rsp)
movl $0x1, %esi
movq %r14, %rdi
callq 0x5380
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x5100
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11b20
callq 0x52b0
movl %ebp, %ecx
movq 0x340(%rbx), %rax
movq 0x348(%rbx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x11ad6
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0xcbd6
leaq 0x48(%rsp), %rdi
callq 0x2e3ec
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x11b7a
callq 0x52b0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x11b89
callq 0x52b0
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11b9c
callq 0x52b0
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2327f(%rip), %rdi     # 0x34e37
leaq 0x22e8d(%rip), %rsi     # 0x34a4c
leaq 0x232bb(%rip), %rcx     # 0x34e81
movl $0x3e3, %edx            # imm = 0x3E3
callq 0x51d0
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
jne 0x11bf8
jmp 0x11bfd
jmp 0x11be6
movq %rax, %rbx
jmp 0x11c0c
movq %rax, %rbx
jmp 0x11bfd
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11bfd
callq 0x52b0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x11c0c
callq 0x52b0
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11c1f
callq 0x52b0
movq %rbx, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBLRUPolicy::evictPolicy(int)
int
DBAMBLRUPolicy::evictPolicy(int set)
{
	for(unsigned i = 0 ; i < m_assoc ; i++){
		if(!m_rap_entries[set][i]->isValid)
			return i;
	}
	
	int smallest_time = m_rap_entries[set][0]->policyInfo , smallest_index = 0;
	for(unsigned i = 0 ; i < m_assoc ; i++){
		if(m_rap_entries[set][i]->policyInfo < smallest_time){
			smallest_time =  m_rap_entries[set][i]->policyInfo;
			smallest_index = i;
		}
	}
	return smallest_index;
}

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x14, %edi
callq 0x52f0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
movq (%rbx), %rdi
movq %rax, (%rbx)
addq $0x14, %rax
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
testq %rdi, %rdi
je 0x12079
callq 0x52b0
xorl %eax, %eax
movl %eax, 0x1c(%rbx)
movq $0x0, 0x20(%rbx)
movq $0x3, 0x28(%rbx)
movl %eax, 0x38(%rbx)
movq 0x40(%rbx), %rcx
cmpq %rcx, 0x48(%rbx)
je 0x1209f
movq %rcx, 0x48(%rbx)
movq 0x58(%rbx), %rcx
movq %rcx, 0x68(%rbx)
movl %eax, 0x70(%rbx)
movq $0x0, 0x80(%rbx)
movb $0x1, 0x88(%rbx)
movl $0x2, 0x9c(%rbx)
movaps 0x228b3(%rip), %xmm0    # 0x34980
movups %xmm0, 0x8c(%rbx)
movl %eax, 0xb8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/gvaumour[P]cache-simulator/src/Directory.cc
// Function: Directory::Directory()
Directory::Directory()
{
	m_nb_set = DIRECTORY_NB_SETS;
	m_assoc = DIRECTORY_ASSOC;

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movabsq $0x4000000800, %rax     # imm = 0x4000000800
movq %rax, 0x20(%rdi)
movl $0x800, %esi            # imm = 0x800
callq 0x136c2
movslq 0x20(%rbx), %r14
testq %r14, %r14
jle 0x12f6a
movq (%rbx), %rax
leaq (,%r14,8), %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
movq (%rax,%rdx), %rsi
cmpq %rsi, 0x8(%rax,%rdx)
je 0x12f61
movq %rsi, 0x8(%rax,%rdx)
addq $0x18, %rdx
cmpq %rdx, %rcx
jne 0x12f51
movl $0x18, %edi
callq 0x52f0
movl 0x24(%rbx), %ecx
movl %ecx, 0x8(%rax)
movl %r14d, 0xc(%rax)
movq %rbx, 0x10(%rax)
movq $0x1, (%rax)
movq %rax, 0x18(%rbx)
movl $0x5, 0x2c(%rbx)
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
callq 0x55b0
addsd 0x21f9f(%rip), %xmm0    # 0x34f48
cvttsd2si %xmm0, %eax
movl %eax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x13744
movq %r14, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15
movq %rdi, %rbx
callq 0x13184
testq %rax, %rax
je 0x130ad
movq %rbx, %rdi
movq %r15, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13184
movq %rbx, %rdi
movq %r15, %rsi
callq 0x131c8
movq %rax, 0x8(%rsp)
movl $0x48, %edi
callq 0x52f0
movq %rax, %r14
addq $0x8, %rax
movl $0x0, 0x8(%r14)
xorl %r13d, %r13d
movq %r13, 0x10(%r14)
movq %rax, 0x18(%r14)
movq %rax, 0x20(%r14)
movw $0x0, 0x3c(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movl $0x8, %r12d
movl %r12d, 0x38(%r14)
movq %r14, %rdi
callq 0x139ec
movq %r14, 0x10(%rsp)
movq %r13, 0x30(%r14)
movb $0x0, 0x3d(%r14)
movl %r12d, 0x38(%r14)
movq %r14, %rdi
callq 0x139ec
movq %r15, 0x30(%r14)
movb $0x1, 0x3c(%r14)
movb %bpl, 0x3d(%r14)
movq 0x18(%rbx), %rax
movq (%rax), %rcx
incq %rcx
movq %rcx, (%rax)
movl %ecx, 0x40(%r14)
movq (%rbx), %rax
movq 0x8(%rsp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x13162
movq %r14, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x13172
leaq 0x10(%rsp), %rbx
movq %rbx, %rdx
callq 0x13be2
movq (%rbx), %r14
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x131c8
movq (%r14), %rdx
leaq (%rax,%rax,2), %rax
movq (%rdx,%rax,8), %rcx
movq 0x8(%rdx,%rax,8), %rdx
cmpq %rdx, %rcx
je 0x131bd
movq (%rcx), %rax
cmpq %rbx, 0x30(%rax)
jne 0x131b7
cmpb $0x0, 0x3c(%rax)
jne 0x131bf
addq $0x8, %rcx
jmp 0x131a3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2e38e
movb 0x2c(%rbx), %cl
incb %cl
shrq %cl, %rax
movl 0x20(%rbx), %ecx
cmpq %rcx, %rax
jae 0x131f3
cltq
popq %rbx
retq
leaq 0x21f25(%rip), %rdi     # 0x3511f
leaq 0x21d4f(%rip), %rsi     # 0x34f50
leaq 0x21f32(%rip), %rcx     # 0x3513a
movl $0xfb, %edx
callq 0x51d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x131c8
movq (%r14), %rdx
leaq (%rax,%rax,2), %rax
movq (%rdx,%rax,8), %rcx
movq 0x8(%rdx,%rax,8), %rdx
subq %rcx, %rdx
je 0x13259
sarq $0x3, %rdx
movl $0x1, %esi
xorl %edi, %edi
movq (%rcx,%rdi,8), %rax
cmpq %rbx, 0x30(%rax)
sete %al
je 0x1325b
movl %esi, %edi
incl %esi
cmpq %rdi, %rdx
ja 0x13241
jmp 0x1325b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13184
testq %rax, %rax
je 0x13295
movq %rax, %rbx
movq %rax, %rdi
callq 0x139ec
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x13cfc
addq $0x10, %rsp
popq %rbx
retq
leaq 0x23918(%rip), %rdi     # 0x36bb4
leaq 0x21cad(%rip), %rsi     # 0x34f50
leaq 0x21cb7(%rip), %rcx     # 0x34f61
movl $0x78, %edx
callq 0x51d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13184
testq %rax, %rax
je 0x1338a
movq %rax, %rbx
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x13375
movq %rbx, %rcx
addq $0x8, %rcx
movq %rcx, %rsi
xorl %edx, %edx
cmpl %ebp, 0x20(%rax)
setl %dl
cmovgeq %rax, %rsi
movq 0x10(%rax,%rdx,8), %rax
testq %rax, %rax
jne 0x1334d
cmpq %rcx, %rsi
je 0x13375
cmpl %ebp, 0x20(%rsi)
jg 0x13375
movq %rbx, %rdi
callq 0x13e0a
cmpq $0x0, 0x28(%rbx)
jne 0x13383
movl $0x6, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x23823(%rip), %rdi     # 0x36bb4
leaq 0x21bb8(%rip), %rsi     # 0x34f50
leaq 0x21c4f(%rip), %rcx     # 0x34fee
movl $0x96, %edx
callq 0x51d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13184
testq %rax, %rax
je 0x133bc
movl %ebx, 0x38(%rax)
popq %rbx
retq
leaq 0x237f1(%rip), %rdi     # 0x36bb4
leaq 0x21b86(%rip), %rsi     # 0x34f50
leaq 0x21c4a(%rip), %rcx     # 0x3501b
movl $0xa8, %edx
callq 0x51d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13184
testq %rax, %rax
je 0x133f0
movq %rax, %rdi
popq %rax
jmp 0x139ec
leaq 0x237bd(%rip), %rdi     # 0x36bb4
leaq 0x21b52(%rip), %rsi     # 0x34f50
leaq 0x21c52(%rip), %rcx     # 0x35057
movl $0xb5, %edx
callq 0x51d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13184
testq %rax, %rax
je 0x1349f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x131c8
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 0x13497
sarq $0x3, %rcx
leaq (%rsi,%rdi,8), %r14
movl $0x1, %esi
xorl %edi, %edi
movq (%rax,%rdi,8), %r8
cmpq %rbx, 0x30(%r8)
jne 0x13467
cmpb $0x1, 0x3c(%r8)
je 0x13472
movl %esi, %edi
incl %esi
cmpq %rdi, %rcx
ja 0x13456
jmp 0x13497
leaq (%rax,%rdi,8), %rsi
addq $0x8, %rsi
cmpq %rdx, %rsi
je 0x1348f
leaq (%rax,%rdi,8), %rdi
subq %rsi, %rdx
callq 0x5520
movq 0x8(%r14), %rdx
addq $-0x8, %rdx
movq %rdx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2370e(%rip), %rdi     # 0x36bb4
leaq 0x21aa3(%rip), %rsi     # 0x34f50
leaq 0x21bd2(%rip), %rcx     # 0x35086
movl $0xcc, %edx
callq 0x51d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13184
testq %rax, %rax
je 0x134dc
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x13cfc
popq %rax
retq
leaq 0x236d1(%rip), %rdi     # 0x36bb4
leaq 0x21a66(%rip), %rsi     # 0x34f50
leaq 0x21bbb(%rip), %rcx     # 0x350ac
movl $0xdf, %edx
callq 0x51d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/gvaumour[P]cache-simulator/src/FeatureTable.hh
// Function: FeatureEntry::initEntry()
void initEntry() {
			if(simu_parameters.Cerebron_RDmodel)
			{
			 	SRAM_seq = std::vector< std::vector<int> >(2, std::vector<int>(2, 0));	
			 	NVM_seq = std::vector< std::vector<int> >(2, std::vector<int>(2, 0));				
			}
			else
			 	cpts =  std::vector< std::vector<int> >(NUM_RW_TYPE, std::vector<int>(NUM_RD_TYPE, 0));

			isValid = true;
			cptWindow = 0;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x30933(%rip), %r15     # 0x45f50
cmpb $0x1, 0x226(%r15)
jne 0x15716
movl $0x8, %edi
callq 0x52f0
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rdx)
movq $0x0, (%rax)
movq %rcx, 0x8(%rdx)
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x2, %esi
callq 0xc524
movq 0x28(%rbx), %rax
leaq 0x20(%rsp), %r14
movaps (%r14), %xmm0
movq 0x10(%r14), %rcx
movq %rcx, 0x28(%rbx)
movups 0x18(%rbx), %xmm1
movups %xmm0, 0x18(%rbx)
leaq 0x40(%rsp), %rdi
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
callq 0xc5b4
movq %r14, %rdi
callq 0xc5b4
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x156bb
callq 0x52b0
movl $0x8, %edi
callq 0x52f0
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rdx)
movq $0x0, (%rax)
movq %rcx, 0x8(%rdx)
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x2, %esi
callq 0xc524
movq 0x40(%rbx), %rax
leaq 0x20(%rsp), %r14
movaps (%r14), %xmm0
movq 0x10(%r14), %rcx
movq %rcx, 0x40(%rbx)
movups 0x30(%rbx), %xmm1
movups %xmm0, 0x30(%rbx)
jmp 0x15774
movl $0xc, %edi
callq 0x52f0
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %rax, %rcx
addq $0xc, %rcx
movq %rcx, 0x10(%rdx)
movl $0x0, 0x8(%rax)
movq $0x0, (%rax)
movq %rcx, 0x8(%rdx)
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x5, %esi
callq 0xc524
movq 0x10(%rbx), %rax
leaq 0x20(%rsp), %r14
movaps (%r14), %xmm0
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rbx)
movups (%rbx), %xmm1
movups %xmm0, (%rbx)
leaq 0x40(%rsp), %rdi
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
callq 0xc5b4
movq %r14, %rdi
callq 0xc5b4
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x157ab
callq 0x52b0
movb $0x1, 0x4c(%rbx)
movl $0x0, 0x48(%rbx)
movl 0x1b0(%r15), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movl %ecx, 0x50(%rbx)
movl $0x3, 0x58(%rbx)
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x157e0
jmp 0x157f6
jmp 0x157e0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x157f9
callq 0x52b0
jmp 0x157f9
jmp 0x157f6
movq %rax, %rbx
movq %rbx, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x15f7f
movl %ecx, %ebx
movl %edx, %eax
shll $0x3, %eax
leal 0x7(,%rdx,8), %edx
movq %rsi, %rdi
movl %eax, %esi
callq 0x2e347
testb %bl, %bl
je 0x15f7d
leaq 0x2fd2b(%rip), %rdx     # 0x45c60
movq 0x10(%rdx), %rdi
movq 0x28(%rdx), %rcx
movq %rdi, %rsi
subq 0x18(%rdx), %rsi
movq %rsi, %rdx
sarq $0x3, %rdx
js 0x15f5c
cmpq $0x40, %rdx
jb 0x15f75
movq %rdx, %rsi
shrq $0x6, %rsi
jmp 0x15f60
sarq $0x9, %rsi
movq %rsi, %rdi
shlq $0x6, %rdi
subq %rdi, %rdx
shlq $0x3, %rdx
addq (%rcx,%rsi,8), %rdx
movq %rdx, %rdi
movzbl (%rdi), %ecx
movzbl %al, %eax
xorl %ecx, %eax
popq %rbx
retq
leaq 0x1f2bf(%rip), %rdi     # 0x35245
leaq 0x1f2c2(%rip), %rsi     # 0x3524f
leaq 0x1f364(%rip), %rcx     # 0x352f8
movl $0x5b, %edx
callq 0x51d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1600c
movl %ecx, %ebx
movl %edx, %esi
shll $0x3, %esi
leal 0x7(,%rdx,8), %edx
callq 0x2e347
testb %bl, %bl
je 0x1600a
leaq 0x2fc9e(%rip), %rdx     # 0x45c60
movq 0x10(%rdx), %rdi
movq 0x28(%rdx), %rcx
movq %rdi, %rsi
subq 0x18(%rdx), %rsi
movq %rsi, %rdx
sarq $0x3, %rdx
js 0x15fe9
cmpq $0x40, %rdx
jb 0x16002
movq %rdx, %rsi
shrq $0x6, %rsi
jmp 0x15fed
sarq $0x9, %rsi
movq %rsi, %rdi
shlq $0x6, %rdi
subq %rdi, %rdx
shlq $0x3, %rdx
addq (%rcx,%rsi,8), %rdx
movq %rdx, %rdi
movzbl (%rdi), %ecx
movzbl %al, %eax
xorl %ecx, %eax
popq %rbx
retq
leaq 0x1f232(%rip), %rdi     # 0x35245
leaq 0x1f235(%rip), %rsi     # 0x3524f
leaq 0x1f308(%rip), %rcx     # 0x35329
movl $0x67, %edx
callq 0x51d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1e6a2(%rip), %rsi     # 0x3541a
movl $0xe, %edx
movq %rbx, %rdi
callq 0x5360
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
movq %rbx, %rdi
callq 0x5360
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x52c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5200
leaq 0x1e663(%rip), %rsi     # 0x35429
movl $0xa, %edx
movq %rbx, %rdi
callq 0x5360
movl 0x30(%r14), %esi
movq %rbx, %rdi
callq 0x51f0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x52c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5200
leaq 0x1e624(%rip), %rsi     # 0x35434
movl $0x9, %edx
movq %rbx, %rdi
callq 0x5360
movl 0x34(%r14), %esi
movq %rbx, %rdi
callq 0x51f0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x52c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5200
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0x16ed4
movl $0x1, %ebp
xorl %r12d, %r12d
leaq 0x1e5d3(%rip), %r15     # 0x3543e
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5360
movq %rbx, %rdi
movq %r12, %rsi
callq 0x51f0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x52c0
movsbl %al, %esi
movq %r13, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5200
movq (%r14), %rax
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
callq 0x1ed0c
movq 0x8(%r14), %rax
subq (%r14), %rax
movl %ebp, %r12d
sarq $0x3, %rax
incl %ebp
cmpq %r12, %rax
ja 0x16e6b
leaq 0x1f0ab(%rip), %rsi     # 0x35f86
movl $0xf, %edx
movq %rbx, %rdi
callq 0x5360
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x52c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5200
leaq 0x1e531(%rip), %rsi     # 0x35447
movl $0x13, %edx
movq %rbx, %rdi
callq 0x5360
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x52c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5200
movq 0x18(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1ed0c
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2dc38(%rip), %r14     # 0x44fd0
leaq 0x1e1b1(%rip), %rsi     # 0x35550
movl $0x22, %edx
movq %r14, %rdi
callq 0x5360
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x52c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5200
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x17403
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdi
callq 0x1eb88
movl %ebp, %ecx
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x173e3
movq 0x18(%rbx), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1eb88
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13184
cmpb $0x1, 0x3c(%rax)
jne 0x17e6d
movq %rax, %r15
cmpl $0x2, 0x38(%rax)
ja 0x17e6d
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1d5ce(%rip), %rsi     # 0x35358
leaq 0x1d5d5(%rip), %rdx     # 0x35366
leaq 0x8(%rsp), %rdi
callq 0xcc6c
leaq 0x2e1ae(%rip), %rbp     # 0x45f50
leaq 0x8(%rbp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1800c
movq %rax, %r12
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x17dc2
callq 0x52b0
addq $0x10, %rbp
cmpq %rbp, %r12
je 0x17ddc
leaq 0x1d8c9(%rip), %rdi     # 0x3569b
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5050
movq %r15, %rdi
callq 0x12f08
movq 0x20(%r14), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0x132b4
movq 0x18(%r15), %r15
leaq 0x10(%rsp), %r12
xorl %ebp, %ebp
cmpq %r12, %r15
je 0x17e36
testb $0x1, %bpl
movb $0x1, %bpl
jne 0x17e26
movslq 0x20(%r15), %rax
movq (%r14), %rcx
movq (%rcx,%rax,8), %rdi
movq %rbx, %rsi
callq 0x1eba8
movl %eax, %ebp
movq %r15, %rdi
callq 0x5370
movq %rax, %r15
cmpq %r12, %rax
jne 0x17e08
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x1ec28
movb %bpl, 0x1(%rax)
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x133dc
movq 0x20(%r14), %rdi
movq %rbx, %rsi
movl $0x6, %edx
callq 0x133aa
leaq 0x8(%rsp), %rdi
callq 0x1380a
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 0x17ea4
callq 0x52b0
jmp 0x17ea4
movq %rax, %rbx
jmp 0x17ea4
jmp 0x17e97
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1380a
movq %rbx, %rdi
callq 0x55a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19939
xorl %r15d, %r15d
cmpl $0x0, 0xa8(%rbx)
leaq (%r15,%r15,2), %r12
jle 0x198ea
xorl %r13d, %r13d
movq 0x20(%rbx), %rax
movq (%rax,%r12,8), %rax
movq (%rax,%r13,8), %r14
testq %r14, %r14
je 0x198d3
movq %r14, %rdi
callq 0x1d0c2
movq %r14, %rdi
callq 0x52b0
incq %r13
movslq 0xa8(%rbx), %rax
cmpq %rax, %r13
jl 0x198ba
cmpl $0x0, 0xa4(%rbx)
jle 0x19926
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rax
movq (%rax,%r13,8), %r14
testq %r14, %r14
je 0x1990f
movq %r14, %rdi
callq 0x1d0c2
movq %r14, %rdi
callq 0x52b0
incq %r13
movslq 0xa4(%rbx), %rax
cmpq %rax, %r13
jl 0x198f6
incq %r15
movslq 0xac(%rbx), %rax
cmpq %rax, %r15
jl 0x198aa
leaq 0x1f0(%rbx), %rdi
callq 0x1d248
movq 0x188(%rbx), %rdi
testq %rdi, %rdi
je 0x19956
callq 0x52b0
movq 0x170(%rbx), %rdi
testq %rdi, %rdi
je 0x19967
callq 0x52b0
movq 0x128(%rbx), %rdi
testq %rdi, %rdi
je 0x19978
callq 0x52b0
movq 0x110(%rbx), %rdi
testq %rdi, %rdi
je 0x19989
callq 0x52b0
movq 0xd8(%rbx), %rdi
testq %rdi, %rdi
je 0x1999a
callq 0x52b0
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x199ab
callq 0x52b0
movq 0x70(%rbx), %rdi
leaq 0x80(%rbx), %rax
cmpq %rax, %rdi
je 0x199c0
callq 0x52b0
leaq 0x38(%rbx), %rdi
callq 0x1d292
leaq 0x20(%rbx), %rdi
callq 0x1ce16
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1ce16
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19a70
xorl %r14d, %r14d
cmpl $0x0, 0xa8(%rbx)
leaq (%r14,%r14,2), %r15
jle 0x19a32
xorl %r12d, %r12d
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rax
movq (%rax,%r12,8), %rsi
movq %rbx, %rdi
callq 0x19ab2
incq %r12
movslq 0xa8(%rbx), %rax
cmpq %rax, %r12
jl 0x19a0f
cmpl $0x0, 0xa4(%rbx)
jle 0x19a61
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movq (%rax,%r12,8), %rsi
movq %rbx, %rdi
callq 0x19ab2
incq %r12
movslq 0xa4(%rbx), %rax
cmpq %rax, %r12
jl 0x19a3e
incq %r14
movslq 0xac(%rbx), %rax
cmpq %rax, %r14
jl 0x199ff
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0x2c4cf(%rip), %rax     # 0x45f50
cmpb $0x1, 0x89(%rax)
jne 0x19aa6
cmpl $-0x1, (%rbx)
jne 0x19aa6
movq 0x2bff2(%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_O3/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 0x1ba52(%rip), %rsi     # 0x3589d
leaq 0x1ba55(%rip), %rdx     # 0x358a7
movq %rsp, %rdi
callq 0xcc6c
leaq 0x2c0ef(%rip), %r13     # 0x45f50
leaq 0x8(%r13), %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1800c
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x19e81
callq 0x52b0
addq $0x10, %r13
cmpq %r13, %r15
je 0x19e9b
movl (%r14), %esi
leaq 0x1bf24(%rip), %rdi     # 0x35db8
xorl %eax, %eax
callq 0x5050
cmpb $0x1, 0x4(%r14)
jne 0x19ee5
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x1b9ee(%rip), %rsi     # 0x3589d
leaq 0x1b9f1(%rip), %rdx     # 0x358a7
callq 0xcc6c
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1800c
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x19ed7
callq 0x52b0
cmpq %r13, %rbx
je 0x19f2d
leaq 0x1bee0(%rip), %rdi     # 0x35dc3
jmp 0x19f26
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x1b9ab(%rip), %rsi     # 0x3589d
leaq 0x1b9ae(%rip), %rdx     # 0x358a7
callq 0xcc6c
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1800c
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x19f1a
callq 0x52b0
cmpq %r13, %rbx
je 0x19f2d
leaq 0x1bea0(%rip), %rdi     # 0x35dc6
xorl %eax, %eax
callq 0x5050
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x19f43
jmp 0x19f43
jmp 0x19f56
jmp 0x19f56
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x19f59
callq 0x52b0
jmp 0x19f59
movq %rax, %rbx
movq %rbx, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2e38e
movl 0x98(%rbx), %esi
movq %rax, %rdi
movl $0x40, %edx
callq 0x2e38e
movb 0x94(%rbx), %cl
incb %cl
shrq %cl, %rax
movl 0xac(%rbx), %ecx
cmpq %rcx, %rax
jae 0x1b0cd
popq %rbx
retq
leaq 0x1a04b(%rip), %rdi     # 0x3511f
leaq 0x1a6a6(%rip), %rsi     # 0x35781
leaq 0x1aa75(%rip), %rcx     # 0x35b57
movl $0x29b, %edx            # imm = 0x29B
callq 0x51d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19f62
testq %rax, %rax
je 0x1b1c1
movq %rax, %r15
movq %r14, %rdi
callq 0x19e2a
leaq 0x48(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1a76d(%rip), %rsi     # 0x3589d
leaq 0x1a770(%rip), %rdx     # 0x358a7
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0xcc6c
leaq 0x2ae05(%rip), %rbp     # 0x45f50
leaq 0x8(%rbp), %rdi
movq %r12, %rsi
callq 0x1800c
movq %rax, %r12
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0x1b169
callq 0x52b0
leaq 0x90(%rsp), %r13
addq $0x10, %rbp
cmpq %rbp, %r12
je 0x1b18c
movq 0x8(%r15), %rsi
leaq 0x1a9ff(%rip), %rdi     # 0x35b84
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 0x1ebdc
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 0x1b1e2
callq 0x52b0
movq %rbx, %rdi
callq 0x55a0