LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: gvaumour[P]cache-simulator/src/SimplePerceptron.cc
// Function: SimplePerceptronPredictor::updateCostModel(CacheEntry*, unsigned long, int, bool)
void 
SimplePerceptronPredictor::updateCostModel(CacheEntry* entry , uint64_t block_addr , int set, bool isWrite)
{
	bool hitSRAM = false, hitNVM = false;
	hitNVM = getHitPerDataArray( block_addr , set , true);
	hitSRAM = getHitPerDataArray( block_addr , set , false);
	
	entry->e_sram += m_costParameters.costSRAM[isWrite];
	entry->e_sram +=  !hitSRAM ? m_costParameters.costDRAM[isWrite] : 0;

	entry->e_nvm += m_costParameters.costNVM[isWrite];
	entry->e_nvm += !hitNVM ? m_costParameters.costDRAM[isWrite] : 0;
}

// Assembly:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
andb $0x1, %al
movb %al, 0x1b(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movb $0x0, 0x1a(%rsp)
movb $0x0, 0x19(%rsp)
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movl $0x1, %ecx
callq 0x57740
movq 0x10(%rsp), %rdi
andb $0x1, %al
movb %al, 0x19(%rsp)
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
xorl %ecx, %ecx
callq 0x57740
movq 0x10(%rsp), %rdi
andb $0x1, %al
movb %al, 0x1a(%rsp)
addq $0x2c8, %rdi            # imm = 0x2C8
addq $0x18, %rdi
movb 0x1b(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, %esi
callq 0xef90
movslq (%rax), %rcx
movq 0x28(%rsp), %rax
addq 0x138(%rax), %rcx
movq %rcx, 0x138(%rax)
testb $0x1, 0x1a(%rsp)
jne 0x6122d
movq 0x10(%rsp), %rdi
addq $0x2c8, %rdi            # imm = 0x2C8
addq $0x30, %rdi
movb 0x1b(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, %esi
callq 0xef90
movl (%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x61235
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x61235
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movslq %eax, %rcx
movq 0x28(%rsp), %rax
addq 0x138(%rax), %rcx
movq %rcx, 0x138(%rax)
addq $0x2c8, %rdi            # imm = 0x2C8
movb 0x1b(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, %esi
callq 0xef90
movslq (%rax), %rcx
movq 0x28(%rsp), %rax
addq 0x140(%rax), %rcx
movq %rcx, 0x140(%rax)
testb $0x1, 0x19(%rsp)
jne 0x612b0
movq 0x10(%rsp), %rdi
addq $0x2c8, %rdi            # imm = 0x2C8
addq $0x30, %rdi
movb 0x1b(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, %esi
callq 0xef90
movl (%rax), %eax
movl %eax, 0x8(%rsp)
jmp 0x612b8
xorl %eax, %eax
movl %eax, 0x8(%rsp)
jmp 0x612b8
movl 0x8(%rsp), %eax
movslq %eax, %rcx
movq 0x28(%rsp), %rax
addq 0x140(%rax), %rcx
movq %rcx, 0x140(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: gvaumour[P]cache-simulator/src/SimplePerceptron.cc
// Function: SimplePerceptronPredictor::setPrediction(CacheEntry*, Access)
void 
SimplePerceptronPredictor::setPrediction(CacheEntry* entry, Access element)
{
	int sum_pred = 0;
	for(unsigned i = 0 ; i < m_features.size() ; i++)
	{
		int hash = hashing_function1(m_features_hash[i] , element.block_addr , entry->missPC);
		int counter = m_features[i]->getCounter(hash);
		sum_pred += counter;
		entry->simple_perceptron_hash[i] = hash;
		if(simu_parameters.simple_perceptron_independantLearning)
			entry->simple_perceptron_pred[i] = getDecision(counter , element.isWrite());
	}
	
	if(!simu_parameters.simple_perceptron_independantLearning)
		entry->simple_perceptron_pred[0] = getDecision(sum_pred , element.isWrite());

}

// Assembly:
subq $0x98, %rsp
leaq 0xa0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x84(%rsp)
movl $0x0, 0x80(%rsp)
movq 0x38(%rsp), %rdi
movl 0x80(%rsp), %eax
movq %rax, 0x28(%rsp)
addq $0x270, %rdi            # imm = 0x270
callq 0x64a70
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0x616d0
movq 0x38(%rsp), %rdi
addq $0x288, %rdi            # imm = 0x288
movl 0x80(%rsp), %eax
movl %eax, %esi
callq 0xf860
movq %rax, %rsi
leaq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xf880
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x30(%rax), %rsi
movq 0x88(%rsp), %rax
movq 0x20(%rax), %rdx
callq 0x2ff40
movl %eax, 0x24(%rsp)
jmp 0x615c6
leaq 0x50(%rsp), %rdi
callq 0xf7b0
movl 0x24(%rsp), %eax
movq 0x38(%rsp), %rdi
movl %eax, 0x7c(%rsp)
addq $0x270, %rdi            # imm = 0x270
movl 0x80(%rsp), %eax
movl %eax, %esi
callq 0x64a90
movq (%rax), %rdi
movl 0x7c(%rsp), %esi
callq 0x5e6e0
movl %eax, 0x40(%rsp)
movl 0x40(%rsp), %eax
addl 0x84(%rsp), %eax
movl %eax, 0x84(%rsp)
movl 0x7c(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x88(%rsp), %rdi
addq $0x100, %rdi            # imm = 0x100
movl 0x80(%rsp), %eax
movl %eax, %esi
callq 0xef90
movl 0x14(%rsp), %ecx
movl %ecx, (%rax)
leaq 0x329aa(%rip), %rax     # 0x93ff0
testb $0x1, 0x24d(%rax)
je 0x616b8
movq 0x30(%rsp), %rdi
movl 0x40(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0xf7c0
movq 0x38(%rsp), %rdi
movl 0xc(%rsp), %esi
movzbl %al, %edx
andl $0x1, %edx
callq 0x63810
movl %eax, 0x10(%rsp)
movq 0x88(%rsp), %rdi
addq $0xe8, %rdi
movl 0x80(%rsp), %eax
movl %eax, %esi
callq 0x64ab0
movl 0x10(%rsp), %ecx
movl %ecx, (%rax)
jmp 0x616b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xf7b0
jmp 0x61733
jmp 0x616ba
movl 0x80(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x80(%rsp)
jmp 0x61547
leaq 0x32919(%rip), %rax     # 0x93ff0
testb $0x1, 0x24d(%rax)
jne 0x6172b
movq 0x30(%rsp), %rdi
movl 0x84(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0xf7c0
movq 0x38(%rsp), %rdi
movl 0x4(%rsp), %esi
movzbl %al, %edx
andl $0x1, %edx
callq 0x63810
movl %eax, 0x8(%rsp)
movq 0x88(%rsp), %rdi
addq $0xe8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x64ab0
movl 0x8(%rsp), %ecx
movl %ecx, (%rax)
addq $0x98, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x5690
nopl (%rax)
// File: gvaumour[P]cache-simulator/src/SimplePerceptron.cc
// Function: SimplePerceptronPredictor::evictPolicy(int, bool)
int SimplePerceptronPredictor::evictPolicy(int set, bool inNVM)
{
	int assoc_victim = -1;

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

	CacheEntry* entry = inNVM ? m_tableNVM[set][assoc_victim] : m_tableSRAM[set][assoc_victim];

	if(entry->isValid)
	{	
		reportEviction(entry, inNVM);
			
		if(entry->isLearning && !simu_parameters.simple_perceptron_fastLearning)
			doLearning(entry);
	
		if( (entry->e_sram > entry->e_nvm && inNVM) || (entry->e_nvm > entry->e_sram && !inNVM) )
			stats_good_alloc++;
		else
			stats_wrong_alloc++;		
	}
	evictRecording(set , assoc_victim , inNVM);	
	return assoc_victim;
}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
andb $0x1, %al
movb %al, 0x2b(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
testb $0x1, 0x2b(%rsp)
je 0x62d27
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rdi
movl 0x2c(%rsp), %esi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, 0x24(%rsp)
jmp 0x62d3e
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rdi
movl 0x2c(%rsp), %esi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, 0x24(%rsp)
testb $0x1, 0x2b(%rsp)
je 0x62d6f
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xf9a0
movq %rax, %rdi
movslq 0x24(%rsp), %rsi
callq 0xf9c0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x62d97
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xf9a0
movq %rax, %rdi
movslq 0x24(%rsp), %rsi
callq 0xf9c0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
testb $0x1, (%rax)
je 0x62e68
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movb 0x2b(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x62e90
movq 0x18(%rsp), %rax
testb $0x1, 0x148(%rax)
je 0x62df4
leaq 0x31214(%rip), %rax     # 0x93ff0
testb $0x1, 0x24c(%rax)
jne 0x62df4
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x612e0
movq 0x18(%rsp), %rax
movq 0x138(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x140(%rcx), %rax
jbe 0x62e15
testb $0x1, 0x2b(%rsp)
jne 0x62e36
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x138(%rcx), %rax
jbe 0x62e4f
testb $0x1, 0x2b(%rsp)
jne 0x62e4f
movq 0x10(%rsp), %rax
movq 0x328(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x328(%rax)
jmp 0x62e66
movq 0x10(%rsp), %rax
movq 0x330(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x330(%rax)
jmp 0x62e68
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x24(%rsp), %edx
movb 0x2b(%rsp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x637d0
movl 0x24(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: gvaumour[P]cache-simulator/src/SimplePerceptron.cc
// Function: SimplePerceptronPredictor::getDecision(int, bool)
allocDecision
SimplePerceptronPredictor::getDecision(int counter, bool isWrite)
{
	allocDecision des = ALLOCATE_IN_SRAM;
	/* If we are not sure enough , we go preemptive */ 

	if( abs(counter) > simu_parameters.simple_perceptron_learningTreshold)
	{

		if(counter > 0)
			des = ALLOCATE_IN_NVM;
		else
			des = ALLOCATE_IN_SRAM;
	}
	else
	{
		if(isWrite)
			des = ALLOCATE_IN_SRAM;
		else
			des = ALLOCATE_IN_NVM;
	}

	return des;
}

// Assembly:
movb %dl, %al
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
andb $0x1, %al
movb %al, -0xd(%rsp)
movl $0x0, -0x14(%rsp)
movl -0xc(%rsp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
leaq 0x307b5(%rip), %rcx     # 0x93ff0
cmpl 0x248(%rcx), %eax
jle 0x6385e
cmpl $0x0, -0xc(%rsp)
jle 0x63854
movl $0x1, -0x14(%rsp)
jmp 0x6385c
movl $0x0, -0x14(%rsp)
jmp 0x63879
testb $0x1, -0xd(%rsp)
je 0x6386f
movl $0x0, -0x14(%rsp)
jmp 0x63877
movl $0x1, -0x14(%rsp)
jmp 0x63879
movl -0x14(%rsp), %eax
retq
nop
// File: gvaumour[P]cache-simulator/src/SimplePerceptron.cc
// Function: SimplePerceptronPredictor::finishSimu()
void 
SimplePerceptronPredictor::finishSimu()
{

	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;
				
			if( entry->e_sram > entry->e_nvm)
				stats_good_alloc++;
			else
				stats_wrong_alloc++;		

		}
		for(int j = 0 ; j < m_nbSRAMways ; j++)
		{
			entry = m_tableSRAM[i][j];		
			if(!entry->isValid)	
				continue;

			if( entry->e_sram < entry->e_nvm)
				stats_good_alloc++;
			else
				stats_wrong_alloc++;		
		}
	}
	
	for(auto feature : m_features)
		feature->finishSimu();
	Predictor::finishSimu();


}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq $0x0, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movq (%rsp), %rcx
movl 0x34(%rsp), %eax
cmpl 0x18(%rcx), %eax
jge 0x64882
movl $0x0, 0x30(%rsp)
movq (%rsp), %rcx
movl 0x30(%rsp), %eax
cmpl 0x20(%rcx), %eax
jge 0x647ca
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movslq 0x34(%rsp), %rsi
callq 0xf9a0
movq %rax, %rdi
movslq 0x30(%rsp), %rsi
callq 0xf9c0
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
testb $0x1, (%rax)
jne 0x64770
jmp 0x647ba
movq 0x38(%rsp), %rax
movq 0x138(%rax), %rax
movq 0x38(%rsp), %rcx
cmpq 0x140(%rcx), %rax
jbe 0x647a2
movq (%rsp), %rax
movq 0x328(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x328(%rax)
jmp 0x647b8
movq (%rsp), %rax
movq 0x330(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x330(%rax)
jmp 0x647ba
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x6472c
movl $0x0, 0x2c(%rsp)
movq (%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x24(%rcx), %eax
jge 0x64870
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movslq 0x34(%rsp), %rsi
callq 0xf9a0
movq %rax, %rdi
movslq 0x2c(%rsp), %rsi
callq 0xf9c0
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
testb $0x1, (%rax)
jne 0x64816
jmp 0x64860
movq 0x38(%rsp), %rax
movq 0x138(%rax), %rax
movq 0x38(%rsp), %rcx
cmpq 0x140(%rcx), %rax
jae 0x64848
movq (%rsp), %rax
movq 0x328(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x328(%rax)
jmp 0x6485e
movq (%rsp), %rax
movq 0x330(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x330(%rax)
jmp 0x64860
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x647d2
jmp 0x64872
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x64713
movq (%rsp), %rax
addq $0x270, %rax            # imm = 0x270
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x64970
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x649a0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x649d0
testb $0x1, %al
jne 0x648c4
jmp 0x648ec
leaq 0x18(%rsp), %rdi
callq 0x64a10
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x5e950
leaq 0x18(%rsp), %rdi
callq 0x64a20
jmp 0x648af
movq (%rsp), %rdi
callq 0xfcb0
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: gvaumour[P]cache-simulator/src/common.cc
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
vector<string> 
split(string s, char delimiter){
  vector<string> result;
  std::istringstream ss( s );
  while (!ss.eof())
  {
		string field;
		getline( ss, field, delimiter );
		if (field.empty()) continue;
		result.push_back( field );
  }
  return result;
}

// Assembly:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rsi, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x18(%rsp)
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movb %al, 0x1e7(%rsp)
movb $0x0, 0x1e6(%rsp)
callq 0xe850
movq 0x20(%rsp), %rsi
leaq 0x60(%rsp), %rdi
movl $0x8, %edx
callq 0x5640
jmp 0x65405
jmp 0x65407
movq 0x60(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x60(%rsp,%rax), %rdi
callq 0x56c0
movb %al, 0xf(%rsp)
jmp 0x65420
movb 0xf(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x6542f
jmp 0x654e3
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x5540
movq (%rsp), %rsi
movsbl 0x1e7(%rsp), %edx
leaq 0x60(%rsp), %rdi
callq 0x56d0
jmp 0x65455
leaq 0x30(%rsp), %rdi
callq 0x5630
testb $0x1, %al
jne 0x65465
jmp 0x654ac
movl $0x2, 0x2c(%rsp)
jmp 0x654c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x6552c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x65509
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5768
jmp 0x65509
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x67700
jmp 0x654bd
movl $0x0, 0x2c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5768
movl 0x2c(%rsp), %eax
testl %eax, %eax
je 0x654de
jmp 0x654d9
jmp 0x65407
jmp 0x65407
movb $0x1, 0x1e6(%rsp)
movl $0x1, 0x2c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x51e0
testb $0x1, 0x1e6(%rsp)
jne 0x6551f
jmp 0x65515
leaq 0x60(%rsp), %rdi
callq 0x51e0
jmp 0x6552c
movq 0x10(%rsp), %rdi
callq 0xf560
movq 0x18(%rsp), %rax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq 0x10(%rsp), %rdi
callq 0xf560
movq 0x58(%rsp), %rdi
callq 0x5690
// File: gvaumour[P]cache-simulator/src/common.cc
// Function: bitSelect(unsigned long, unsigned int, unsigned int)
uint64_t 
bitSelect(uint64_t address , unsigned small , unsigned big)
{
	std::bitset<64> b(address);
	for(int i = big+1 ; i < 64 ; i++)
		b.reset(i);
	
	b >>= small;
	
	return b.to_ullong();	
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x67770
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
cmpl $0x40, 0xc(%rsp)
jge 0x6558e
movslq 0xc(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x677c0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x6556b
movl 0x1c(%rsp), %eax
movl %eax, %esi
leaq 0x10(%rsp), %rdi
callq 0x67800
leaq 0x10(%rsp), %rdi
callq 0x67850
addq $0x28, %rsp
retq
nopl (%rax)
// File: gvaumour[P]cache-simulator/src/common.cc
// Function: bitRemove(unsigned long, unsigned int, unsigned int)
uint64_t
bitRemove(uint64_t address , unsigned int small, unsigned int big){
    uint64_t mask;
    assert(big >= small);

	if (small == 0) {
		mask = (uint64_t)~0 << big;
		return (address & mask);
	} 
	else {
		mask = ~((uint64_t)~0 << small);
		uint64_t lower_bits = address & mask;
		mask = (uint64_t)~0 << (big + 1);
		uint64_t higher_bits = address & mask;

		higher_bits = higher_bits >> (big - small + 1);
		return (higher_bits | lower_bits);
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x24(%rsp), %eax
jb 0x655cd
jmp 0x655ec
leaq 0xeb20(%rip), %rdi      # 0x740f4
leaq 0xeb26(%rip), %rsi      # 0x74101
movl $0x46, %edx
leaq 0xeb28(%rip), %rcx      # 0x7410f
callq 0x5260
cmpl $0x0, 0x24(%rsp)
jne 0x65619
movl 0x20(%rsp), %eax
movl %eax, %ecx
movq $-0x1, %rax
shlq %cl, %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
andq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x65693
movl 0x24(%rsp), %eax
movl %eax, %ecx
movq $-0x1, %rax
shlq %cl, %rax
xorq $-0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
andq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
movq $-0x1, %rax
shlq %cl, %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
andq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x20(%rsp), %ecx
subl 0x24(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
orq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: gvaumour[P]cache-simulator/src/common.cc
// Function: hexToInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
uint64_t
hexToInt(string adresse_hex){
	char * p;
	uint64_t n = strtoul( adresse_hex.c_str(), & p, 16 ); 

	if ( * p != 0 ) {  
		cout << "not a number" << endl;
		return 0;
	}    
	else   
		return n;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
callq 0x51a0
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
movl $0x10, %edx
callq 0x5150
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x656ff
movq 0x2d8f7(%rip), %rdi     # 0x92fd0
leaq 0xea68(%rip), %rsi      # 0x74148
callq 0x5380
movq %rax, %rdi
movq 0x2d8c9(%rip), %rsi     # 0x92fb8
callq 0x53d0
movq $0x0, 0x20(%rsp)
jmp 0x65709
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gvaumour[P]cache-simulator/src/common.cc
// Function: hexToInt1(char const*)
uint64_t
hexToInt1(const char* adresse_hex){
	uint64_t n = strtoul( adresse_hex, &mydummy_var, 16 ); 

	if ( *mydummy_var != 0 ) {  
		cout << "not a number" << endl;
		return 0;
	}    
	else   
		return n;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x2eb13(%rip), %rsi     # 0x94248
movl $0x10, %edx
callq 0x5150
movq %rax, (%rsp)
movq 0x2eafe(%rip), %rax     # 0x94248
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x6577f
movq 0x2d877(%rip), %rdi     # 0x92fd0
leaq 0xe9e8(%rip), %rsi      # 0x74148
callq 0x5380
movq %rax, %rdi
movq 0x2d849(%rip), %rsi     # 0x92fb8
callq 0x53d0
movq $0x0, 0x10(%rsp)
jmp 0x65788
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gvaumour[P]cache-simulator/src/common.cc
// Function: readInputArgs(int, char**, int&, int&, int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool
readInputArgs(int argc , char* argv[] , int& sizeCache , int& assoc , int& blocksize, std::string& filename, std::string& policy)
{
	
	if(argc == 1){
		sizeCache = 512;
		assoc = 4;
		blocksize = 64;
		filename = "test.txt";		
		policy = "LRU";

	}
	else if(argc == 3){
		sizeCache = 16384;
		assoc = 4;
		blocksize = 64;
		filename = argv[1];	
		policy = argv[2];	
	}
	else if(argc == 6){
		sizeCache = atoi(argv[1]);
		assoc = atoi(argv[2]);
		blocksize = atoi(argv[3]);
		policy = argv[4];
		filename = argv[5];		
	}
	else{
		return false;
	}		
	return true;
}

// Assembly:
subq $0x38, %rsp
movq 0x40(%rsp), %rax
movl %edi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
cmpl $0x1, 0x30(%rsp)
jne 0x65815
movq 0x20(%rsp), %rax
movl $0x200, (%rax)          # imm = 0x200
movq 0x18(%rsp), %rax
movl $0x4, (%rax)
movq 0x10(%rsp), %rax
movl $0x40, (%rax)
movq 0x8(%rsp), %rdi
leaq 0xe95b(%rip), %rsi      # 0x74155
callq 0x5520
movq 0x40(%rsp), %rdi
leaq 0xcb9f(%rip), %rsi      # 0x723aa
callq 0x5520
jmp 0x658e4
cmpl $0x3, 0x30(%rsp)
jne 0x65865
movq 0x20(%rsp), %rax
movl $0x4000, (%rax)         # imm = 0x4000
movq 0x18(%rsp), %rax
movl $0x4, (%rax)
movq 0x10(%rsp), %rax
movl $0x40, (%rax)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdi
callq 0x5520
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x40(%rsp), %rdi
callq 0x5520
jmp 0x658e2
cmpl $0x6, 0x30(%rsp)
jne 0x658d9
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x55b0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x55b0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x55b0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rsi
movq 0x40(%rsp), %rdi
callq 0x5520
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rsi
movq 0x8(%rsp), %rdi
callq 0x5520
jmp 0x658e0
movb $0x0, 0x37(%rsp)
jmp 0x658e9
jmp 0x658e2
jmp 0x658e4
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gvaumour[P]cache-simulator/src/common.cc
// Function: StripPath(char const*)
const char *
StripPath(const char * path)
{
    const char * file = strrchr(path,'/');
    if (file)
        return file+1;
    else
        return path;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x2f, %esi
callq 0x5400
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x66162
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x6616c
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gvaumour[P]cache-simulator/src/common.cc
// Function: convertBool[abi:cxx11](bool)
string
convertBool(bool a)
{
	if(a)
		return "TRUE";
	else
		return "FALSE";
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x18(%rsp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, 0x20(%rsp)
movq %rdi, 0x40(%rsp)
andb $0x1, %al
movb %al, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
je 0x664e3
leaq 0x3e(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x56a0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0xb022(%rip), %rsi      # 0x714d8
callq 0x5530
jmp 0x664bd
leaq 0x3e(%rsp), %rdi
callq 0x53e0
jmp 0x66530
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3e(%rsp), %rdi
callq 0x53e0
jmp 0x6653a
leaq 0x2b(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x56a0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0xafda(%rip), %rsi      # 0x714dd
callq 0x5530
jmp 0x6650a
leaq 0x2b(%rsp), %rdi
callq 0x53e0
jmp 0x66530
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x2b(%rsp), %rdi
callq 0x53e0
jmp 0x6653a
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x5690
nopw %cs:(%rax,%rax)
// File: gvaumour[P]cache-simulator/src/Cache.hh
// Function: EnergyParameters::EnergyParameters()
EnergyParameters() {

			costSRAM = std::vector<int>(2 ,0);
			costSRAM[READ_ACCESS] = 271;
			costSRAM[WRITE_ACCESS] = 257;

			costNVM = std::vector<int>(2 ,0);
			costNVM[READ_ACCESS] = 236;
			costNVM[WRITE_ACCESS] = 652;

			costDRAM = std::vector<int>(2 ,0);
			costDRAM[READ_ACCESS] = 4088;
			costDRAM[WRITE_ACCESS] = 4102;

		}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xe880
movl $0x0, 0x94(%rsp)
leaq 0x93(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0xed30
movq 0x38(%rsp), %rcx
leaq 0x98(%rsp), %rdi
movl $0x2, %esi
leaq 0x94(%rsp), %rdx
callq 0xed40
jmp 0x6797f
movq 0x30(%rsp), %rdi
addq $0x18, %rdi
movq %rdi, 0x20(%rsp)
leaq 0x98(%rsp), %rsi
movq %rsi, 0x18(%rsp)
callq 0xf150
movq 0x18(%rsp), %rdi
callq 0xef00
leaq 0x93(%rsp), %rdi
callq 0xef60
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xef90
movq 0x20(%rsp), %rdi
movl $0x10f, (%rax)          # imm = 0x10F
movl $0x1, %esi
callq 0xef90
movl $0x101, (%rax)          # imm = 0x101
movl $0x0, 0x64(%rsp)
leaq 0x63(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xed30
movq 0x28(%rsp), %rcx
leaq 0x68(%rsp), %rdi
movl $0x2, %esi
leaq 0x64(%rsp), %rdx
callq 0xed40
jmp 0x67a11
movq 0x30(%rsp), %rdi
leaq 0x68(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0xf150
movq 0x8(%rsp), %rdi
callq 0xef00
leaq 0x63(%rsp), %rdi
callq 0xef60
movq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xef90
movq 0x30(%rsp), %rdi
movl $0xec, (%rax)
movl $0x1, %esi
callq 0xef90
movl $0x28c, (%rax)          # imm = 0x28C
movl $0x0, 0x44(%rsp)
leaq 0x43(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xed30
movq 0x10(%rsp), %rcx
leaq 0x48(%rsp), %rdi
movl $0x2, %esi
leaq 0x44(%rsp), %rdx
callq 0xed40
jmp 0x67a94
movq 0x30(%rsp), %rdi
addq $0x30, %rdi
leaq 0x48(%rsp), %rsi
callq 0xf150
leaq 0x48(%rsp), %rdi
callq 0xef00
leaq 0x43(%rsp), %rdi
callq 0xef60
movq 0x30(%rsp), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xef90
movq 0x30(%rsp), %rdi
movl $0xff8, (%rax)          # imm = 0xFF8
addq $0x30, %rdi
movl $0x1, %esi
callq 0xef90
movl $0x1006, (%rax)         # imm = 0x1006
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x93(%rsp), %rdi
callq 0xef60
jmp 0x67b55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x63(%rsp), %rdi
callq 0xef60
jmp 0x67b55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x43(%rsp), %rdi
callq 0xef60
movq 0x30(%rsp), %rdi
callq 0xf520
movq 0x88(%rsp), %rdi
callq 0x5690
nopl (%rax)
// File: gvaumour[P]cache-simulator/src/main.cc
// Function: my_handler(int)
void my_handler(int s){
	cout << endl;
	cout << "Ctrl+C event caught, printing results and exiting" << endl;
	
	printResults(false , 1);
	exit(1); 

}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
movq 0x22e14(%rip), %rdi     # 0x92fd0
movq 0x22df5(%rip), %rsi     # 0x92fb8
callq 0x53d0
movq 0x22e01(%rip), %rdi     # 0x92fd0
leaq 0x478a(%rip), %rsi      # 0x74960
callq 0x5380
movq %rax, %rdi
movq 0x22dd3(%rip), %rsi     # 0x92fb8
callq 0x53d0
xorl %edi, %edi
movl $0x1, %esi
callq 0x70200
movl $0x1, %edi
callq 0x5490
// File: gvaumour[P]cache-simulator/src/Cache.hh
// Function: PerfParameters::PerfParameters()
PerfParameters() {

			costSRAM = std::vector<int>(2 ,0);
			costSRAM[READ_ACCESS] = 10;
			costSRAM[WRITE_ACCESS] = 10;

			costNVM = std::vector<int>(2 ,0);
			costNVM[READ_ACCESS] = 10;
			costNVM[WRITE_ACCESS] = 37;

			costDRAM = std::vector<int>(2 ,0);
			costDRAM[READ_ACCESS] = 100;
			costDRAM[WRITE_ACCESS] = 100;
		}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xe880
movl $0x0, 0x94(%rsp)
leaq 0x93(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0xed30
movq 0x38(%rsp), %rcx
leaq 0x98(%rsp), %rdi
movl $0x2, %esi
leaq 0x94(%rsp), %rdx
callq 0xed40
jmp 0x706ef
movq 0x30(%rsp), %rdi
addq $0x18, %rdi
movq %rdi, 0x20(%rsp)
leaq 0x98(%rsp), %rsi
movq %rsi, 0x18(%rsp)
callq 0xf150
movq 0x18(%rsp), %rdi
callq 0xef00
leaq 0x93(%rsp), %rdi
callq 0xef60
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xef90
movq 0x20(%rsp), %rdi
movl $0xa, (%rax)
movl $0x1, %esi
callq 0xef90
movl $0xa, (%rax)
movl $0x0, 0x64(%rsp)
leaq 0x63(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xed30
movq 0x28(%rsp), %rcx
leaq 0x68(%rsp), %rdi
movl $0x2, %esi
leaq 0x64(%rsp), %rdx
callq 0xed40
jmp 0x70781
movq 0x30(%rsp), %rdi
leaq 0x68(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0xf150
movq 0x8(%rsp), %rdi
callq 0xef00
leaq 0x63(%rsp), %rdi
callq 0xef60
movq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xef90
movq 0x30(%rsp), %rdi
movl $0xa, (%rax)
movl $0x1, %esi
callq 0xef90
movl $0x25, (%rax)
movl $0x0, 0x44(%rsp)
leaq 0x43(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xed30
movq 0x10(%rsp), %rcx
leaq 0x48(%rsp), %rdi
movl $0x2, %esi
leaq 0x44(%rsp), %rdx
callq 0xed40
jmp 0x70804
movq 0x30(%rsp), %rdi
addq $0x30, %rdi
leaq 0x48(%rsp), %rsi
callq 0xf150
leaq 0x48(%rsp), %rdi
callq 0xef00
leaq 0x43(%rsp), %rdi
callq 0xef60
movq 0x30(%rsp), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xef90
movq 0x30(%rsp), %rdi
movl $0x64, (%rax)
addq $0x30, %rdi
movl $0x1, %esi
callq 0xef90
movl $0x64, (%rax)
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x93(%rsp), %rdi
callq 0xef60
jmp 0x708c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x63(%rsp), %rdi
callq 0xef60
jmp 0x708c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x43(%rsp), %rdi
callq 0xef60
movq 0x30(%rsp), %rdi
callq 0xf520
movq 0x88(%rsp), %rdi
callq 0x5690
nopl (%rax)
// File: asdfz1346[P]MyServer/MyServer.cpp
// Function: MyServer::link_startou(char const*, short)
void MyServer::link_startou(const char *ip,short port){
	if(!server_listen(ip,port)){
		printf("	server_listen error\n");	
	}
	struct ARG arg;
	arg.p = this;
	std::cout << "main threadid = "<<pthread_self()<<std::endl;
	pthread_create(&accept_thread,NULL,accept_thread_proc,&arg);
	
	for(int i=0;i<THREAD_NUM;i++){
		pthread_create(&worker_thread[i],NULL,worker_thread_proc,&arg);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movswl -0x12(%rbp), %edx
callq 0x3910
testb $0x1, %al
jne 0x386e
leaq 0x57a5(%rip), %rdi      # 0x900c
movb $0x0, %al
callq 0x3040
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x975b(%rip), %rdi      # 0xcfd8
leaq 0x579e(%rip), %rsi      # 0x9022
callq 0x32c0
movq %rax, -0x38(%rbp)
callq 0x32a0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x30a0
movq %rax, %rdi
movq 0x9720(%rip), %rsi      # 0xcfc8
callq 0x3330
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x1f4(%rip), %rdx       # 0x3ab0
leaq -0x20(%rbp), %rcx
callq 0x34d0
movl $0x0, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jge 0x3904
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movslq -0x24(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x3c0(%rip), %rdx       # 0x3cb0
leaq -0x20(%rbp), %rcx
callq 0x34d0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x38cc
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: asdfz1346[P]MyServer/MyServer.cpp
// Function: MyServer::server_listen(char const*, short)
bool MyServer::server_listen(const char *ip,short port){
	//socket
	listenfd = socket(AF_INET,SOCK_STREAM|SOCK_NONBLOCK,0);
	if(listenfd==-1){
		printf("soket error\n");
		return false;
	}
	int on =1;
	setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof on);
	setsockopt(listenfd,SOL_SOCKET,SO_REUSEPORT,&on,sizeof on);

	//bind
	struct sockaddr_in serveraddr;
	memset(&serveraddr,0,sizeof serveraddr);
	serveraddr.sin_family= AF_INET;
	serveraddr.sin_addr.s_addr = inet_addr(ip);//点分十进制ip转换成一个长整数
	serveraddr.sin_port = htons(port);//转换为网络字节序
	if(bind(listenfd,(struct sockaddr*)&serveraddr,sizeof(serveraddr))==-1){
		printf("bind error\n");
		return false;
	}
	//listen
	if(listen(listenfd,LISTEN_NUM)==-1){//待测试
		printf("listen() error\n");
		return false;
	}
	//epoll
	epollfd = epoll_create(1);

	struct epoll_event e;
	memset(&e,0,sizeof e);
	e.events = EPOLLIN;
	e.data.fd = listenfd;
	if(epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd,&e)==-1){
		printf("epoll_ctl error;\n");
		return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movw %dx, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x2, %edi
movl $0x801, %esi            # imm = 0x801
xorl %edx, %edx
callq 0x30b0
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x18(%rax)
cmpl $-0x1, 0x18(%rax)
jne 0x3966
leaq 0x56dd(%rip), %rdi      # 0x9033
movb $0x0, %al
callq 0x3040
movb $0x0, -0x1(%rbp)
jmp 0x3a9f
movq -0x48(%rbp), %rax
movl $0x1, -0x20(%rbp)
movl 0x18(%rax), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x20(%rbp), %rcx
movl $0x4, %r8d
callq 0x34b0
movq -0x48(%rbp), %rax
movl 0x18(%rax), %edi
movl $0x1, %esi
movl $0xf, %edx
leaq -0x20(%rbp), %rcx
movl $0x4, %r8d
callq 0x34b0
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x31a0
movw $0x2, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x32e0
movl %eax, -0x2c(%rbp)
movzwl -0x1a(%rbp), %edi
callq 0x3050
movw %ax, %cx
movq -0x48(%rbp), %rax
movw %cx, -0x2e(%rbp)
movl 0x18(%rax), %edi
leaq -0x30(%rbp), %rsi
movl $0x10, %edx
callq 0x3070
cmpl $-0x1, %eax
jne 0x3a10
leaq 0x5640(%rip), %rdi      # 0x9040
movb $0x0, %al
callq 0x3040
movb $0x0, -0x1(%rbp)
jmp 0x3a9f
movq -0x48(%rbp), %rax
movl 0x18(%rax), %edi
movl $0x5, %esi
callq 0x3380
cmpl $-0x1, %eax
jne 0x3a3a
leaq 0x561f(%rip), %rdi      # 0x904c
movb $0x0, %al
callq 0x3040
movb $0x0, -0x1(%rbp)
jmp 0x3a9f
movl $0x1, %edi
callq 0x34e0
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x1c(%rax)
leaq -0x3c(%rbp), %rdi
xorl %esi, %esi
movl $0xc, %edx
callq 0x31a0
movq -0x48(%rbp), %rax
movl $0x1, -0x3c(%rbp)
movl 0x18(%rax), %ecx
movl %ecx, -0x38(%rbp)
movl 0x1c(%rax), %edi
movl 0x18(%rax), %edx
movl $0x1, %esi
leaq -0x3c(%rbp), %rcx
callq 0x3410
cmpl $-0x1, %eax
jne 0x3a9b
leaq 0x55ce(%rip), %rdi      # 0x905c
movb $0x0, %al
callq 0x3040
movb $0x0, -0x1(%rbp)
jmp 0x3a9f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: asdfz1346[P]MyServer/MyServer.cpp
// Function: MyServer::main_loop()
void MyServer::main_loop(){	
	while(nstop){
		struct 	epoll_event ev[1024];
		int n = epoll_wait(epollfd,ev,1024,10);
		if(n<=0)
			continue;	
		int m = std::min(n,1024);
		for(int i=0;i<m;i++){
			if(ev[i].data.fd == listenfd)
				pthread_cond_signal(&accept_cond);
			else if(ev[i].events&(EPOLLIN | EPOLLERR)){
				pthread_mutex_lock(&clientset_mutex);
				if(clientset.find(ev[i].data.fd) != clientset.end()){
					pthread_mutex_unlock(&clientset_mutex);
					pthread_mutex_lock(&clientlist_mutex);
					clientlist.push_back(ev[i].data.fd);
					pthread_mutex_unlock(&clientlist_mutex);
				}else
					pthread_mutex_unlock(&clientset_mutex);	
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3040, %rsp           # imm = 0x3040
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x3038(%rbp)
movq -0x3038(%rbp), %rax
testb $0x1, 0x118(%rax)
je 0x5f48
movq -0x3038(%rbp), %rax
movl 0x1c(%rax), %edi
leaq -0x3010(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
movl $0xa, %ecx
callq 0x3160
movl %eax, -0x3014(%rbp)
cmpl $0x0, -0x3014(%rbp)
jg 0x5d9f
jmp 0x5d5a
movl $0x400, -0x301c(%rbp)   # imm = 0x400
leaq -0x3014(%rbp), %rdi
leaq -0x301c(%rbp), %rsi
callq 0x6030
movl (%rax), %eax
movl %eax, -0x3018(%rbp)
movl $0x0, -0x3020(%rbp)
movl -0x3020(%rbp), %eax
cmpl -0x3018(%rbp), %eax
jge 0x5f43
movq -0x3038(%rbp), %rcx
movslq -0x3020(%rbp), %rdx
leaq -0x3010(%rbp), %rax
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl 0x4(%rax), %eax
cmpl 0x18(%rcx), %eax
jne 0x5e1c
movq -0x3038(%rbp), %rdi
addq $0xe8, %rdi
callq 0x3030
jmp 0x5f2d
movslq -0x3020(%rbp), %rcx
leaq -0x3010(%rbp), %rax
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
andl $0x9, %eax
cmpl $0x0, %eax
je 0x5f2b
movq -0x3038(%rbp), %rdi
addq $0x98, %rdi
callq 0x3430
movq -0x3038(%rbp), %rdi
addq $0x40, %rdi
movslq -0x3020(%rbp), %rax
leaq -0x3010(%rbp), %rsi
imulq $0xc, %rax, %rax
addq %rax, %rsi
addq $0x4, %rsi
callq 0x60a0
movq -0x3038(%rbp), %rdi
movq %rax, -0x3028(%rbp)
addq $0x40, %rdi
callq 0x60e0
movq %rax, -0x3030(%rbp)
leaq -0x3028(%rbp), %rdi
leaq -0x3030(%rbp), %rsi
callq 0x6070
testb $0x1, %al
jne 0x5eb2
jmp 0x5f16
movq -0x3038(%rbp), %rdi
addq $0x98, %rdi
callq 0x3240
movq -0x3038(%rbp), %rdi
addq $0xc0, %rdi
callq 0x3430
movq -0x3038(%rbp), %rdi
addq $0x28, %rdi
movslq -0x3020(%rbp), %rax
leaq -0x3010(%rbp), %rsi
imulq $0xc, %rax, %rax
addq %rax, %rsi
addq $0x4, %rsi
callq 0x6110
movq -0x3038(%rbp), %rdi
addq $0xc0, %rdi
callq 0x3240
jmp 0x5f29
movq -0x3038(%rbp), %rdi
addq $0x98, %rdi
callq 0x3240
jmp 0x5f2b
jmp 0x5f2d
jmp 0x5f2f
movl -0x3020(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3020(%rbp)
jmp 0x5dce
jmp 0x5d5a
addq $0x3040, %rsp           # imm = 0x3040
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: jespinosa94[P]PED16/lib/tporo.cpp
// Function: TPoro::TPoro(int, int, double)
TPoro::TPoro(int x, int y, double vol) {
	this->x = x;
	this->y = y;
	volumen = vol;
	color = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jespinosa94[P]PED16/lib/tporo.cpp
// Function: TPoro::TPoro(int, int, double, char*)
TPoro::TPoro(int x, int y, double vol, char* c) {
	VerifyLowerCase(c);
	this->x = x;
	this->y = y;
	volumen = vol;
	if(c == NULL)
		color = NULL;
	else{
		color = new char[strlen(c) + 1];
		strcpy(color, c);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x4f50
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x4f1a
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x4f47
movq -0x20(%rbp), %rdi
callq 0x1070
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x10c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: jespinosa94[P]PED16/lib/tporo.cpp
// Function: TPoro::VerifyLowerCase(char*&)
void TPoro::VerifyLowerCase(char *&c){
	char* aux;
	if(c==NULL)
		aux = NULL;
	else
	{
		aux = new char[strlen(c) + 1];
		for(int i=0; i<strlen(c); i++)
			aux[i] = tolower(c[i]);
		c = new char[strlen(aux) +1];
		strcpy(c, aux);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x4f77
movq $0x0, -0x18(%rbp)
jmp 0x5015
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1070
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1030
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1070
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x4fe6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x1120
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4f9a
movq -0x18(%rbp), %rdi
callq 0x1070
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x10c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jespinosa94[P]PED16/lib/tporo.cpp
// Function: TPoro::Copy(TPoro const&)
void TPoro::Copy(const TPoro& p) {
	x = p.x;
	y = p.y;
	volumen = p.volumen;
	if(p.color == NULL)
		color = NULL;
	else
	{
		color = new char[strlen(p.color) + 1];
		strcpy(color, p.color);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x50a1
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x50d6
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1070
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x10c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jespinosa94[P]PED16/lib/tporo.cpp
// Function: TPoro::~TPoro()
TPoro::~TPoro() {
	x = y = volumen = 0;
	if(color != NULL){
		delete color;	//Se libera la memoria
		color = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movl $0x0, 0x4(%rax)
movl $0x0, (%rax)
cmpq $0x0, 0x10(%rax)
je 0x513c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x5130
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x10f0
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jespinosa94[P]PED16/lib/tporo.cpp
// Function: TPoro::operator=(TPoro const&)
TPoro& TPoro::operator =(const TPoro &p) {
	if(this != &p)
	{
		(*this).~TPoro();
		Copy(p);
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x5184
movq -0x18(%rbp), %rdi
callq 0x50e0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5050
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: jespinosa94[P]PED16/lib/tporo.cpp
// Function: TPoro::operator==(TPoro const&) const
bool TPoro::operator ==(const TPoro &p) const {
	bool temp = false;
	if((*this).EsVacio() && p.EsVacio())
		temp = true;
	else if(!(*this).EsVacio() && !p.EsVacio())
	{
		if(color==NULL && p.color==NULL && x==p.x && y==p.y && volumen==p.volumen)
			temp = true;
		else if(color!=NULL && p.color!=NULL && x==p.x && y==p.y && volumen==p.volumen)
		{
			if(!strcmp(color, p.color))
				temp = true;
		}
	}
	return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x52c0
testb $0x1, %al
jne 0x51b7
jmp 0x51cf
movq -0x10(%rbp), %rdi
callq 0x52c0
testb $0x1, %al
jne 0x51c6
jmp 0x51cf
movb $0x1, -0x11(%rbp)
jmp 0x52b1
movq -0x20(%rbp), %rdi
callq 0x52c0
testb $0x1, %al
jne 0x52af
movq -0x10(%rbp), %rdi
callq 0x52c0
testb $0x1, %al
jne 0x52af
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x5241
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x5241
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x5241
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x5241
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jne 0x5241
jp 0x5241
movb $0x1, -0x11(%rbp)
jmp 0x52ad
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x52ab
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x52ab
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x52ab
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x52ab
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jne 0x52ab
jp 0x52ab
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x1110
cmpl $0x0, %eax
jne 0x52a9
movb $0x1, -0x11(%rbp)
jmp 0x52ab
jmp 0x52ad
jmp 0x52af
jmp 0x52b1
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jespinosa94[P]PED16/lib/tporo.cpp
// Function: TPoro::Color(char*)
void TPoro::Color(char *newColor) {
	VerifyLowerCase(newColor);
	if(newColor == NULL)
		color = NULL;
	else
	{
		color = new char[strlen(newColor) + 1];
		strcpy(color, newColor);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x4f50
cmpq $0x0, -0x10(%rbp)
jne 0x53c6
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x53f3
movq -0x10(%rbp), %rdi
callq 0x1070
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jespinosa94[P]PED16/lib/tporo.cpp
// Function: operator<<(std::ostream&, TPoro const&)
ostream& operator<<(ostream &os, const TPoro &p){
	if(!p.EsVacio()){
		os.setf(ios::fixed);
		os.precision(2);
		os << "(" << p.x << ", " << p.y << ") " << p.volumen << " ";
		if(p.color != NULL)
			os << p.color;
		else
			os << "-";
	}
	else
		os << "()";

	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x52c0
testb $0x1, %al
jne 0x5556
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x4, %esi
callq 0x5570
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x2, %esi
callq 0x55a0
movq -0x8(%rbp), %rdi
leaq 0x6d39(%rip), %rsi      # 0xc1ff
callq 0x10d0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x1170
movq %rax, %rdi
leaq 0x6d1e(%rip), %rsi      # 0xc201
callq 0x10d0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x1170
movq %rax, %rdi
leaq 0x6d03(%rip), %rsi      # 0xc204
callq 0x10d0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x11a0
movq %rax, %rdi
leaq 0x6ce4(%rip), %rsi      # 0xc205
callq 0x10d0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x5544
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x10d0
jmp 0x5554
movq -0x8(%rbp), %rdi
leaq 0x6cb8(%rip), %rsi      # 0xc207
callq 0x10d0
jmp 0x5566
movq -0x8(%rbp), %rdi
leaq 0x6cd9(%rip), %rsi      # 0xc23a
callq 0x10d0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: jespinosa94[P]PED16/lib/tvectorporo.cpp
// Function: TVectorPoro::TVectorPoro(int)
TVectorPoro::TVectorPoro(int creaDim) {
	if(creaDim <= 0)
	{
		dimension = 0;
		datos = NULL;
	}
	else
	{
		dimension = creaDim;
		datos = new TPoro[dimension];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x10, %rdi
movq %rdi, -0x28(%rbp)
callq 0x4e50
cmpl $0x0, -0xc(%rbp)
jg 0x56a4
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, 0x8(%rax)
jmp 0x57a5
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movslq (%rax), %rax
movq %rax, -0x48(%rbp)
movl $0x18, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
movq $-0x1, %rax
cmovbq %rax, %rdi
testb %cl, %cl
cmovneq %rax, %rdi
movq %rdi, -0x40(%rbp)
callq 0x1030
movq %rax, -0x38(%rbp)
jmp 0x56e6
movq -0x48(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x50(%rbp)
cmpq $0x0, %rax
je 0x573d
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
imulq $0x18, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4e50
jmp 0x5728
movq -0x60(%rbp), %rcx
movq -0x68(%rbp), %rax
addq $0x18, %rax
cmpq %rcx, %rax
movq %rax, -0x58(%rbp)
jne 0x5719
movq -0x30(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x57a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x57ae
movq -0x50(%rbp), %rcx
movq %rax, %rsi
movq -0x68(%rbp), %rax
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq %rax, %rcx
movq %rax, -0x70(%rbp)
je 0x5796
movq -0x70(%rbp), %rdi
addq $-0x18, %rdi
movq %rdi, -0x78(%rbp)
callq 0x50e0
movq -0x50(%rbp), %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x70(%rbp)
jne 0x5774
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x11b0
jmp 0x57ae
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x50e0
movq -0x18(%rbp), %rdi
callq 0x1180