LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: melop[P]admixem/Individual.cpp
// Function: Individual::Die()
void Individual::Die() {
	if (this->_bDead) {
		throw(new Exception("Individual is already dead, cannot die again!"));
	}
	else {
		this->_bDead = true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x2d(%rax)
je 0x5b518
movl $0x8, %edi
callq 0x8230
movq %rax, -0x30(%rbp)
movl $0x1, %edi
callq 0x84c0
movq %rax, -0x28(%rbp)
jmp 0x5b4b8
movq -0x28(%rbp), %rdi
leaq 0x1ccde(%rip), %rsi     # 0x781a1
callq 0x129a0
jmp 0x5b4ca
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, (%rdi)
leaq 0x4e7ec(%rip), %rsi     # 0xa9cc8
xorl %eax, %eax
movl %eax, %edx
callq 0x8820
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x5b50d
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x1, %esi
callq 0x84d0
movq -0x30(%rbp), %rdi
callq 0x8370
jmp 0x5b526
movq -0x20(%rbp), %rax
movb $0x1, 0x2d(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x8860
nop
// File: melop[P]admixem/main.cpp
// Function: main
int main (int argc, char * const argv[]) {

	if (argc == 2) {
		string sConfig = argv[1];
		SimulConfig.LoadFromFile(sConfig);
		UISimulation();
		return 0;
	}

    // insert code here...
    //std::cout << "Hello, World!\n";
	
	int nProgramMode;
	
	/*
	string sTest = "";
	
	getline(cin , sTest);
	
	std::cout << "Length: " << sTest << endl;
	
	if (sTest.length() > 0 )  {
		cout << "lalala" << endl;
	
	}
	*/

	cout << floor(-0.1) <<endl;
	
	
	while(true)
	{
		std::cout << "\nWhat do you want to do? 0 - Cancel,  1 - Generate markers, 2 - Export simulated results, 3 - Simulation: ";
	
		std::cin >>  nProgramMode;
		
		switch(nProgramMode) {
		
			case 0: return 0;
			
			case 1: UIMakeNewMarkerFile(); continue; //if user wants to create a new marker file

			case 4: UITestExpression(); continue;

			case 3: UISimulation(); continue;

			case 2: UIExportResults(); continue;
		
		}
		
		break;
	
	}

	

	
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jne 0x627a9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x8870
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0xcb30
jmp 0x6270f
leaq -0x31(%rbp), %rdi
callq 0x8540
leaq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x81f0
jmp 0x62727
leaq 0x4832a(%rip), %rdi     # 0xaaa58
leaq -0x68(%rbp), %rsi
callq 0x26fc0
jmp 0x62739
leaq -0x68(%rbp), %rdi
callq 0x82e0
callq 0x6e0f0
jmp 0x62749
movl $0x0, -0x4(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x82e0
jmp 0x62844
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x8540
jmp 0x62850
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x6279b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x82e0
leaq -0x30(%rbp), %rdi
callq 0x82e0
jmp 0x62850
movsd 0x13ee7(%rip), %xmm0    # 0x76698
movq 0x477d0(%rip), %rdi     # 0xa9f88
callq 0x88c0
movq %rax, %rdi
movq 0x47769(%rip), %rsi     # 0xa9f30
callq 0x8520
movq 0x477b5(%rip), %rdi     # 0xa9f88
leaq 0x15a22(%rip), %rsi     # 0x781fc
callq 0x84a0
movq 0x477ea(%rip), %rdi     # 0xa9fd0
leaq -0x6c(%rbp), %rsi
callq 0x82d0
movl -0x6c(%rbp), %eax
movq %rax, -0x88(%rbp)
subq $0x4, %rax
ja 0x6283b
movq -0x88(%rbp), %rax
leaq 0x159db(%rip), %rcx     # 0x781e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x62844
callq 0x62860
jmp 0x627cc
callq 0x74c90
jmp 0x627cc
callq 0x6e0f0
jmp 0x627cc
callq 0x70f40
jmp 0x627cc
jmp 0x6283d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x8860
nopl (%rax)
// File: melop[P]admixem/maths.cpp
// Function: fnSum(double*, int)
double fnSum( double * pNums, int nSize ) {

	double nRet = 0;
	for (int i=0; i< nSize; i++) {
		nRet += pNums[i];
	 } 
	 
	return nRet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x65de4
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x65dba
movsd -0x18(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: melop[P]admixem/maths.cpp
// Function: fnGetRandIndex(int)
int fnGetRandIndex(int nSizeOfArray) {
	int nRet;
	
	do {
		
			nRet = (int)floor(UniformGen.Next() * (double)nSizeOfArray - 0.01);
		
		nRet = nRet>=0? nRet:0;
	}
	while(nRet >= nSizeOfArray);
	
	/*
	const unsigned long n = nSizeOfArray;
    const unsigned long divisor = (RAND_MAX + 1) / n;

    unsigned long nRet;
    do { nRet = rand() / divisor; } while (nRet >= n);
	*/
	return nRet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x44d2e(%rip), %rdi     # 0xaab90
callq 0x19e20
cvtsi2sdl -0x4(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x12c98(%rip), %xmm1    # 0x78b10
addsd %xmm1, %xmm0
callq 0x8950
cvttsd2si %xmm0, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x65e96
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x65e9d
xorl %eax, %eax
movl %eax, -0xc(%rbp)
jmp 0x65e9d
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x65e5b
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: melop[P]admixem/maths.cpp
// Function: round
double round(double nNum) {
	double nIntegral = (double)((int)nNum);
	if (nNum - nIntegral < 0.5) {
		return nIntegral; 
	}
	else {
		return nIntegral + 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
cvttsd2si -0x10(%rbp), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm1
subsd -0x18(%rbp), %xmm1
movsd 0x107a7(%rip), %xmm0    # 0x76690
ucomisd %xmm1, %xmm0
jbe 0x65efb
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x65f0d
movsd 0x1010d(%rip), %xmm0    # 0x76010
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: melop[P]admixem/Population.cpp
// Function: Population::Population()
Population::Population(void)
{
	this->_nCurrMales=0;
	this->_nCurrFemales = 0;
	this->_bBred = false;
	this->_bRecordNatSelProb = (SimulConfig.GetConfig("DumpNatSelProb") == "On");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
callq 0x86b0
movq -0x70(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0xc8(%rbp)
callq 0x5b570
movq -0x70(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0xc0(%rbp)
callq 0x5b570
movq -0x70(%rbp), %rdi
addq $0x78, %rdi
movq %rdi, -0xb8(%rbp)
callq 0x5b570
movq -0x70(%rbp), %rdi
addq $0x90, %rdi
movq %rdi, -0xb0(%rbp)
callq 0x5b570
movq -0x70(%rbp), %rdi
addq $0xb8, %rdi
movq %rdi, -0xa8(%rbp)
callq 0x6c930
movq -0x70(%rbp), %rdi
addq $0xe8, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x6c930
movq -0x70(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
movq %rdi, -0x98(%rbp)
callq 0x6c930
movq -0x70(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
movq %rdi, -0x90(%rbp)
callq 0x6c930
movq -0x70(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
movq %rdi, -0x88(%rbp)
callq 0x6c930
movq -0x70(%rbp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
movq %rdi, -0x80(%rbp)
callq 0x6c930
movq -0x70(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
movq %rdi, -0x78(%rbp)
callq 0x2f6e0
movq -0x70(%rbp), %rax
movl $0x0, 0x30(%rax)
movl $0x0, 0x34(%rax)
movb $0x0, 0x40(%rax)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x8870
movq -0x68(%rbp), %rdx
leaq 0x12a36(%rip), %rsi     # 0x78b38
leaq -0x48(%rbp), %rdi
callq 0xcb30
jmp 0x6610d
leaq 0x44944(%rip), %rsi     # 0xaaa58
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x1c190
jmp 0x66123
leaq 0x12a1d(%rip), %rsi     # 0x78b47
leaq -0x28(%rbp), %rdi
callq 0xcbe0
movb %al, -0xd1(%rbp)
jmp 0x6613b
movq -0xd0(%rbp), %rax
movb -0xd1(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x41(%rax)
leaq -0x28(%rbp), %rdi
callq 0x82e0
leaq -0x48(%rbp), %rdi
callq 0x82e0
leaq -0x49(%rbp), %rdi
callq 0x8540
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x661ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x661a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x82e0
leaq -0x48(%rbp), %rdi
callq 0x82e0
leaq -0x49(%rbp), %rdi
callq 0x8540
movq -0x78(%rbp), %rdi
callq 0x2f700
movq -0x80(%rbp), %rdi
callq 0x6c950
movq -0x88(%rbp), %rdi
callq 0x6c950
movq -0x90(%rbp), %rdi
callq 0x6c950
movq -0x98(%rbp), %rdi
callq 0x6c950
movq -0xa0(%rbp), %rdi
callq 0x6c950
movq -0xa8(%rbp), %rdi
callq 0x6c950
movq -0xb0(%rbp), %rdi
callq 0x5b590
movq -0xb8(%rbp), %rdi
callq 0x5b590
movq -0xc0(%rbp), %rdi
callq 0x5b590
movq -0xc8(%rbp), %rdi
callq 0x5b590
movq -0x70(%rbp), %rdi
callq 0x82e0
movq -0x58(%rbp), %rdi
callq 0x8860
nopw %cs:(%rax,%rax)
// File: melop[P]admixem/Population.cpp
// Function: Population::GetPopSize(int)
int Population::GetPopSize(int nMode) {
	switch(nMode) {
		case 0: return _mpFemales.size();
		case 1: return _mpMales.size();
		case 2: {int nCount=0; for( int nCpu=0;nCpu<nTotalCPUCore;nCpu++) {nCount+= _mpvNewGenMales[nCpu].size();} return nCount;};
		case 3: {int nCount=0; for( int nCpu=0;nCpu<nTotalCPUCore;nCpu++) {nCount+= _mpvNewGenFemales[nCpu].size();} return nCount;};
		case 4: return _mpFemales.size()+_mpMales.size();
		case 5: {int nCount=0; for( int nCpu=0;nCpu<nTotalCPUCore;nCpu++) {nCount+=_mpvNewGenMales[nCpu].size()+ _mpvNewGenFemales[nCpu].size();} return nCount;};
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x38(%rbp)
subq $0x5, %rax
ja 0x69c67
movq -0x38(%rbp), %rax
leaq 0xf04d(%rip), %rcx      # 0x78b20
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
callq 0x5c320
movl %eax, -0x4(%rbp)
jmp 0x69c6e
movq -0x40(%rbp), %rdi
addq $0x48, %rdi
callq 0x5c320
movl %eax, -0x4(%rbp)
jmp 0x69c6e
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0x409de(%rip), %rcx     # 0xaa4fc
cmpl (%rcx), %eax
jge 0x69b55
movq -0x40(%rbp), %rax
movq 0xa8(%rax), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x5c320
movq %rax, %rcx
movslq -0x18(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x69b14
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x69c6e
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
leaq 0x40984(%rip), %rcx     # 0xaa4fc
cmpl (%rcx), %eax
jge 0x69baf
movq -0x40(%rbp), %rax
movq 0xb0(%rax), %rdi
movslq -0x24(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x5c320
movq %rax, %rcx
movslq -0x20(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x69b6e
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x69c6e
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
callq 0x5c320
movq -0x40(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0x48, %rdi
callq 0x5c320
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x4(%rbp)
jmp 0x69c6e
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
leaq 0x408fa(%rip), %rcx     # 0xaa4fc
cmpl (%rcx), %eax
jge 0x69c5f
movq -0x40(%rbp), %rax
movq 0xa8(%rax), %rdi
movslq -0x2c(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x5c320
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq 0xb0(%rax), %rdi
movslq -0x2c(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x5c320
movq -0x50(%rbp), %rcx
addq %rax, %rcx
movslq -0x28(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x69bf8
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x69c6e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: melop[P]admixem/Population.cpp
// Function: Population::Emigrate()
Individual * Population::Emigrate() {
	int nMales = _mpMales.size();
	int nFemales = _mpFemales.size();
	int nTotal = nMales + nFemales;
	bool bWhichSex = (UniformGen.Next() <= (double)nMales / (double)nTotal)? true:false;
	vector< Individual *> * pIndividuals = bWhichSex? &_mpMales:&_mpFemales;

	if (pIndividuals->size() == 0) { // no more individuals to return
		return NULL;
	}

	int nEmigrant = fnGetRandIndex(pIndividuals->size());
	//printf("1\n");
	Individual * pEmigrant = pIndividuals->at(nEmigrant);
	//printf("2\n");
	pIndividuals->erase(pIndividuals->begin() + nEmigrant);
	//printf("3\n");
	return pEmigrant;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x48, %rdi
callq 0x5c320
movq -0x60(%rbp), %rdi
movl %eax, -0x14(%rbp)
addq $0x60, %rdi
callq 0x5c320
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
leaq 0x40ece(%rip), %rdi     # 0xaab90
callq 0x19e20
movaps %xmm0, %xmm1
cvtsi2sdl -0x14(%rbp), %xmm0
cvtsi2sdl -0x1c(%rbp), %xmm2
divsd %xmm2, %xmm0
xorl %eax, %eax
ucomisd %xmm1, %xmm0
adcb $-0x1, %al
andb $0x1, %al
movb %al, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
je 0x69cf9
movq -0x60(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x68(%rbp)
jmp 0x69d05
movq -0x60(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5c320
cmpq $0x0, %rax
jne 0x69d26
movq $0x0, -0x8(%rbp)
jmp 0x69d99
movq -0x28(%rbp), %rdi
callq 0x5c320
movl %eax, %edi
callq 0x65e50
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x5c340
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rdi
callq 0x60a70
movq %rax, -0x50(%rbp)
movslq -0x2c(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x6cd90
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6cdd0
movq -0x70(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x6cd20
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: melop[P]admixem/Population.cpp
// Function: Population::Immigrate(Individual*)
bool Population::Immigrate(Individual * pImmigrant) { // Force current members to die or not if exceeding population limits
	
	if (!pImmigrant) {
		printf("Immigrant cannot be NULL\n");
		return false;
	}
	//printf("1\n");
	pImmigrant->ChangePopulation(this);
	Individual::Sex bWhichSex = pImmigrant->GetSex();
	//printf("2\n");
	vector< Individual *> * pIndividuals = (bWhichSex==Individual::Male)?  &_mpImCacheMales : &_mpImCacheFemales; //&_mpMales:&_mpFemales;
	//printf("3\n");

		pIndividuals->push_back(pImmigrant); //add this individual to the population.


	return true; // already full, cannot accept any more.

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x69de3
leaq 0xefb4(%rip), %rdi      # 0x78d8a
movb $0x0, %al
callq 0x8080
movb $0x0, -0x1(%rbp)
jmp 0x69e37
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x5b0a0
movq -0x18(%rbp), %rdi
callq 0x570f0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x69e10
movq -0x30(%rbp), %rax
addq $0x78, %rax
movq %rax, -0x38(%rbp)
jmp 0x69e1e
movq -0x30(%rbp), %rax
addq $0x90, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x5c0f0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: melop[P]admixem/Population.cpp
// Function: Population::Sample(std::basic_ofstream<char, std::char_traits<char>>&, std::basic_ofstream<char, std::char_traits<char>>&, std::basic_ofstream<char, std::char_traits<char>>&, std::basic_ofstream<char, std::char_traits<char>>&, std::basic_ofstream<char, std::char_traits<char>>&)
void Population::Sample(ofstream &fMarkerOutFile, ofstream &fGeneOutFile,  ofstream &fPhenotypeOutFile,  ofstream &fPhenoSumOutFile, ofstream &fOffSpringNatSelProb ) {
	// now dump all the males:
	this->fnSample(fMarkerOutFile, fGeneOutFile,  fPhenotypeOutFile , Individual::Male);
	// dump all females:
	this->fnSample(fMarkerOutFile, fGeneOutFile,  fPhenotypeOutFile , Individual::Female);

	this->fnSamplePhenotypeStats(fPhenoSumOutFile);

	this->fnDumpNaturalProb(fOffSpringNatSelProb);

	this->_mpOffSpringNaturalProb.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
xorl %r8d, %r8d
callq 0x6a290
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %r8d
callq 0x6a290
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6a520
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6a720
movq -0x38(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x6ce10
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: melop[P]admixem/Population.cpp
// Function: Population::fnSamplePhenotypeStats(std::basic_ofstream<char, std::char_traits<char>>&)
void Population::fnSamplePhenotypeStats(ofstream &fPhenoSumOutFile) {

	map< string , pair< double, double> >::iterator itMale = this->_mpSumPhenotypeMale.begin();
	map< string , pair< double, double> >::iterator itFemale = this->_mpSumPhenotypeFemale.begin();

	for ( map< string , pair< double, double> >::iterator itAll = this->_mpSumPhenotype.begin(); itAll != _mpSumPhenotype.end(); ++itAll) {

		fPhenoSumOutFile << this->GetPopId() << '\t' << itAll->first << '\t';
		
		fPhenoSumOutFile << itAll->second.first << '[' << itAll->second.second << "]\t"
			<< itMale->second.first << '[' << itMale->second.second << "]\t"
			<< itFemale->second.first << '[' << itFemale->second.second << ']' << endl;

		++itMale;
		++itFemale;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0xe8, %rdi
callq 0x6ce30
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x118, %rdi            # imm = 0x118
callq 0x6ce30
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0xb8, %rdi
callq 0x6ce30
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
addq $0xb8, %rdi
callq 0x5c1c0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6ce60
testb $0x1, %al
jne 0x6a59d
jmp 0x6a713
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x6c530
movq -0x78(%rbp), %rdi
movl %eax, %esi
callq 0x8840
movq %rax, %rdi
movl $0x9, %esi
callq 0x85d0
movq %rax, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6ce90
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x8410
movq %rax, %rdi
movl $0x9, %esi
callq 0x85d0
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6ce90
movq -0x68(%rbp), %rdi
movsd 0x20(%rax), %xmm0
callq 0x88c0
movq %rax, %rdi
movl $0x5b, %esi
callq 0x85d0
movq %rax, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6ce90
movq -0x60(%rbp), %rdi
movsd 0x28(%rax), %xmm0
callq 0x88c0
movq %rax, %rdi
leaq 0xe7e3(%rip), %rsi      # 0x78e20
callq 0x84a0
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6ce90
movq -0x58(%rbp), %rdi
movsd 0x20(%rax), %xmm0
callq 0x88c0
movq %rax, %rdi
movl $0x5b, %esi
callq 0x85d0
movq %rax, -0x50(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6ce90
movq -0x50(%rbp), %rdi
movsd 0x28(%rax), %xmm0
callq 0x88c0
movq %rax, %rdi
leaq 0xe791(%rip), %rsi      # 0x78e20
callq 0x84a0
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6ce90
movq -0x48(%rbp), %rdi
movsd 0x20(%rax), %xmm0
callq 0x88c0
movq %rax, %rdi
movl $0x5b, %esi
callq 0x85d0
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6ce90
movq -0x40(%rbp), %rdi
movsd 0x28(%rax), %xmm0
callq 0x88c0
movq %rax, %rdi
movl $0x5d, %esi
callq 0x85d0
movq %rax, %rdi
movq 0x3f842(%rip), %rsi     # 0xa9f30
callq 0x8520
leaq -0x18(%rbp), %rdi
callq 0x61d30
leaq -0x20(%rbp), %rdi
callq 0x61d30
leaq -0x28(%rbp), %rdi
callq 0x61d30
jmp 0x6a573
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: melop[P]admixem/Population.cpp
// Function: Population::fnDumpNaturalProb(std::basic_ofstream<char, std::char_traits<char>>&)
void Population::fnDumpNaturalProb(ofstream &fNaturalProbOutFile) {
	if (!_bRecordNatSelProb) {
		return;
	}
	fNaturalProbOutFile << "Rule\tIndID\tDadID\tDadPrevPop\tMomID\tMomPrevPop\tNatSelProb_Pop" << this->GetPopId() << "\tSurvived" << endl;
	for (vector< vector< double > >::iterator itInd=this->_mpOffSpringNaturalProb.begin(); itInd!=this->_mpOffSpringNaturalProb.end(); ++ itInd) {
		for(vector< double >::iterator itFields=itInd->begin(); itFields!=itInd->end(); ++ itFields) {
			fNaturalProbOutFile << *itFields << "\t";
		}
		fNaturalProbOutFile << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, 0x41(%rax)
jne 0x6a743
jmp 0x6a85a
movq -0x10(%rbp), %rdi
leaq 0xe704(%rip), %rsi      # 0x78e52
callq 0x84a0
movq -0x38(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x6c530
movq -0x40(%rbp), %rdi
movl %eax, %esi
callq 0x8840
movq %rax, %rdi
leaq 0xe719(%rip), %rsi      # 0x78e8e
callq 0x84a0
movq %rax, %rdi
movq 0x3f7ac(%rip), %rsi     # 0xa9f30
callq 0x8520
movq -0x38(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x6ceb0
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x6cf20
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6cee0
testb $0x1, %al
jne 0x6a7c7
jmp 0x6a85a
leaq -0x18(%rbp), %rdi
callq 0x6cf50
movq %rax, %rdi
callq 0x2a6e0
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6cf50
movq %rax, %rdi
callq 0x2a710
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2a7e0
testb $0x1, %al
jne 0x6a804
jmp 0x6a83c
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2a8a0
movq -0x48(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x88c0
movq %rax, %rdi
leaq 0xca91(%rip), %rsi      # 0x772bd
callq 0x84a0
leaq -0x28(%rbp), %rdi
callq 0x396b0
jmp 0x6a7dc
movq -0x10(%rbp), %rdi
movq 0x3f6e9(%rip), %rsi     # 0xa9f30
callq 0x8520
leaq -0x18(%rbp), %rdi
callq 0x6cf70
jmp 0x6a79d
addq $0x50, %rsp
popq %rbp
retq
// File: melop[P]admixem/Population.cpp
// Function: Population::fnWriteIndividualMarkers(std::basic_ofstream<char, std::char_traits<char>>&, Individual*)
void Population::fnWriteIndividualMarkers(ofstream &fOutFile, Individual * pInd) {

	this->fnWriteIndividualID(fOutFile , pInd);
	pInd->DumpMarkers(fOutFile, 0);
	fOutFile << endl;

	this->fnWriteIndividualID(fOutFile , pInd);
	pInd->DumpMarkers(fOutFile, 1);
	fOutFile << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x6c6c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x5b110
movq -0x10(%rbp), %rdi
movq 0x3d99d(%rip), %rsi     # 0xa9f30
callq 0x8520
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x6c6c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x5b110
movq -0x10(%rbp), %rdi
movq 0x3d96a(%rip), %rsi     # 0xa9f30
callq 0x8520
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: melop[P]admixem/Population.cpp
// Function: Population::fnWriteIndividualGenes(std::basic_ofstream<char, std::char_traits<char>>&, Individual*)
void Population::fnWriteIndividualGenes(ofstream &fOutFile, Individual * pInd) {

	this->fnWriteIndividualID(fOutFile , pInd);
	pInd->DumpGenes(fOutFile, 0);
	fOutFile << endl;

	this->fnWriteIndividualID(fOutFile , pInd);
	pInd->DumpGenes(fOutFile, 1);
	fOutFile << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x6c6c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x5b220
movq -0x10(%rbp), %rdi
movq 0x3d90d(%rip), %rsi     # 0xa9f30
callq 0x8520
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x6c6c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x5b220
movq -0x10(%rbp), %rdi
movq 0x3d8da(%rip), %rsi     # 0xa9f30
callq 0x8520
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: melop[P]admixem/Population.cpp
// Function: Population::fnWriteIndividualID(std::basic_ofstream<char, std::char_traits<char>>&, Individual*)
void Population::fnWriteIndividualID(ofstream &fOutFile, Individual * pInd) {
	fOutFile << pInd->GetID() << '\t';
	fOutFile << this->_nPopId << '\t';
	fOutFile << ((pInd->GetSex() == Individual::Male)? "1":"0") << '\t';
	fOutFile << pInd->GetFatherId() << '\t';
	fOutFile << pInd->GetMotherId() << '\t';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x57110
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x8440
movq %rax, %rdi
movl $0x9, %esi
callq 0x85d0
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x20(%rax), %esi
callq 0x8840
movq %rax, %rdi
movl $0x9, %esi
callq 0x85d0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x570f0
cmpl $0x0, %eax
jne 0x6c746
leaq 0xcefd(%rip), %rax      # 0x7963d
movq %rax, -0x38(%rbp)
jmp 0x6c753
leaq 0xb5ae(%rip), %rax      # 0x77cfb
movq %rax, -0x38(%rbp)
jmp 0x6c753
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x84a0
movq %rax, %rdi
movl $0x9, %esi
callq 0x85d0
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5b0d0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x8440
movq %rax, %rdi
movl $0x9, %esi
callq 0x85d0
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5b0f0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x8440
movq %rax, %rdi
movl $0x9, %esi
callq 0x85d0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: melop[P]admixem/Population.cpp
// Function: Population::fnAddNatSelProb(double, double, double, double, double, double, double, bool)
void Population::fnAddNatSelProb(double nParserCount, double nIndID, double nDadID, double nDadPop, double nMomID, double nMomPop, double nProb, bool bSurvived) {
	if (!_bRecordNatSelProb) {
		return;
	}
	#pragma omp critical 
	{
		vector< double > vRecord;
		vRecord.push_back(nParserCount);
		vRecord.push_back(nIndID);
		vRecord.push_back(nDadID);
		vRecord.push_back(nDadPop);
		vRecord.push_back(nMomID);
		vRecord.push_back(nMomPop);
		vRecord.push_back(nProb);
		vRecord.push_back(bSurvived? 1.0:0.0);
		_mpOffSpringNaturalProb.push_back(vRecord);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd %xmm4, -0x30(%rbp)
movsd %xmm5, -0x38(%rbp)
movsd %xmm6, -0x40(%rbp)
andb $0x1, %al
movb %al, -0x41(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
testb $0x1, 0x41(%rax)
jne 0x6c81d
jmp 0x6c906
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2ad80
movq -0x88(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x2aea0
jmp 0x6c83f
leaq -0x60(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2aea0
jmp 0x6c84e
leaq -0x60(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2aea0
jmp 0x6c85d
leaq -0x60(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2aea0
jmp 0x6c86c
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2aea0
jmp 0x6c87b
leaq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2aea0
jmp 0x6c88a
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2aea0
jmp 0x6c899
movb -0x41(%rbp), %al
testb $0x1, %al
movsd 0x976a(%rip), %xmm0     # 0x76010
xorps %xmm1, %xmm1
movsd %xmm1, -0x98(%rbp)
movsd %xmm0, -0x90(%rbp)
jne 0x6c8cb
movsd -0x98(%rbp), %xmm0
movsd %xmm0, -0x90(%rbp)
movsd -0x90(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2b090
jmp 0x6c8e7
movq -0x80(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
leaq -0x60(%rbp), %rsi
callq 0x6cf90
jmp 0x6c8fd
leaq -0x60(%rbp), %rdi
callq 0x2aff0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2aff0
movq -0x68(%rbp), %rdi
callq 0x8860
nopl (%rax)
// File: melop[P]admixem/simulation.cpp
// Function: UISimulation()
void UISimulation() {


		UILoadConfig();


		clock_t t;
		t = clock();
		PerformSimulation();
		t = clock() - t;
		printf ("Execution time %f seconds.\n",((float)t)/CLOCKS_PER_SEC);


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x6e150
callq 0x8310
movq %rax, -0x8(%rbp)
callq 0x6e280
callq 0x8310
subq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
cvtsi2ssq -0x8(%rbp), %xmm0
movss 0xad8a(%rip), %xmm1     # 0x78eb0
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xad7f(%rip), %rdi      # 0x78eb4
movb $0x1, %al
callq 0x8080
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: melop[P]admixem/simulation.cpp
// Function: UILoadConfig()
void UILoadConfig() {
		string szFilename;
		
		if (SimulConfig.GetConfigFileName() == "") {

	
		while(true) { //Get random seed from user
		
			std::cout << "\n Enter simulation configuration file name: ";
			std::cin >> szFilename;
			
			if (szFilename.size() == 0 ) {
				std::cout << "\n Please enter file name! ";
				continue; // 
			}
			else {
				break;
			}
			
			
			
		}

		SimulConfig.LoadFromFile(szFilename);
		//printf("%s\n", szFilename.c_str());
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x20(%rbp), %rdi
callq 0x86b0
leaq 0x3c8ed(%rip), %rsi     # 0xaaa58
leaq -0x40(%rbp), %rdi
callq 0x28180
jmp 0x6e176
leaq 0x9141(%rip), %rsi      # 0x772be
leaq -0x40(%rbp), %rdi
callq 0xcbe0
movb %al, -0x71(%rbp)
jmp 0x6e18b
leaq -0x40(%rbp), %rdi
callq 0x82e0
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x6e1a0
jmp 0x6e25b
jmp 0x6e1a2
jmp 0x6e1a4
movq 0x3bddd(%rip), %rdi     # 0xa9f88
leaq 0xb3d9(%rip), %rsi      # 0x7958b
callq 0x84a0
jmp 0x6e1b9
movq 0x3be10(%rip), %rdi     # 0xa9fd0
leaq -0x20(%rbp), %rsi
callq 0x8630
jmp 0x6e1cb
leaq -0x20(%rbp), %rdi
callq 0x8340
cmpq $0x0, %rax
jne 0x6e216
movq 0x3bda7(%rip), %rdi     # 0xa9f88
leaq 0xb3d0(%rip), %rsi      # 0x795b8
callq 0x84a0
jmp 0x6e1ef
jmp 0x6e1a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x6e26d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x82e0
jmp 0x6e26d
jmp 0x6e218
leaq -0x70(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x81f0
jmp 0x6e227
leaq 0x3c82a(%rip), %rdi     # 0xaaa58
leaq -0x70(%rbp), %rsi
callq 0x26fc0
jmp 0x6e239
leaq -0x70(%rbp), %rdi
callq 0x82e0
jmp 0x6e25b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x82e0
jmp 0x6e26d
leaq -0x20(%rbp), %rdi
callq 0x82e0
addq $0x80, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x82e0
movq -0x48(%rbp), %rdi
callq 0x8860
nop
// File: melop[P]admixem/simulation.cpp
// Function: PopId2PopString[abi:cxx11](int)
string PopId2PopString(int nId) {
	ostringstream sRet;
	if (nId == 1 || nId == 2) {
		sRet << "pop" << nId;
	}
	else if (nId == 3) {
		sRet << "hybrid";
	}
	else {
		sRet << "hybrid" << (nId - 3);
	}

	return sRet.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x1a8(%rbp)
movq %rdi, %rax
movq %rax, -0x1a0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x8680
cmpl $0x1, -0xc(%rbp)
je 0x70c7b
cmpl $0x2, -0xc(%rbp)
jne 0x70ccd
leaq 0x824e(%rip), %rsi      # 0x78ed0
leaq -0x188(%rbp), %rdi
callq 0x84a0
movq %rax, -0x1b0(%rbp)
jmp 0x70c97
movq -0x1b0(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x8840
jmp 0x70ca8
jmp 0x70d1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x8120
jmp 0x70d4f
cmpl $0x3, -0xc(%rbp)
jne 0x70cea
leaq 0x81fa(%rip), %rsi      # 0x78ed4
leaq -0x188(%rbp), %rdi
callq 0x84a0
jmp 0x70ce8
jmp 0x70d1c
leaq 0x81e3(%rip), %rsi      # 0x78ed4
leaq -0x188(%rbp), %rdi
callq 0x84a0
movq %rax, -0x1b8(%rbp)
jmp 0x70d06
movq -0x1b8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $-0x3, %esi
callq 0x8840
jmp 0x70d1a
jmp 0x70d1c
jmp 0x70d1e
movq -0x1a8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x84e0
jmp 0x70d33
leaq -0x188(%rbp), %rdi
callq 0x8120
movq -0x1a0(%rbp), %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0x8860
nopl (%rax,%rax)
// File: melop[P]admixem/simulation.cpp
// Function: fnMakeDir(char const*)
void fnMakeDir(const char * sPath)
{
	#ifdef _WIN32
	_mkdir(sPath);
	#elif __linux__
	string szCmd("mkdir -m 777 -p ");
	system((szCmd + "\"" + sPath + "\"").c_str());
	#else
	string szCmd("mkdir -m 777 -p ");
	system((szCmd + "\"" + sPath + "\"").c_str());
	#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x8870
movq -0xa8(%rbp), %rdx
leaq 0x87b6(%rip), %rsi      # 0x795d3
leaq -0x28(%rbp), %rdi
callq 0xcb30
jmp 0x70e28
leaq -0x29(%rbp), %rdi
callq 0x8540
leaq 0x866d(%rip), %rdx      # 0x794a5
leaq -0xa0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5bbc0
jmp 0x70e4a
movq -0x8(%rbp), %rdx
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xca00
jmp 0x70e60
leaq 0x863e(%rip), %rdx      # 0x794a5
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xca00
jmp 0x70e76
leaq -0x60(%rbp), %rdi
callq 0x81d0
movq %rax, %rdi
callq 0x83f0
jmp 0x70e89
leaq -0x60(%rbp), %rdi
callq 0x82e0
leaq -0x80(%rbp), %rdi
callq 0x82e0
leaq -0xa0(%rbp), %rdi
callq 0x82e0
leaq -0x28(%rbp), %rdi
callq 0x82e0
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x8540
jmp 0x70f2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x70f24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x70f18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x70f0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x82e0
leaq -0x80(%rbp), %rdi
callq 0x82e0
leaq -0xa0(%rbp), %rdi
callq 0x82e0
leaq -0x28(%rbp), %rdi
callq 0x82e0
movq -0x38(%rbp), %rdi
callq 0x8860
nopw %cs:(%rax,%rax)
// File: CastellanZhang[P]lambdaFM/./src/FTRL/ftrl_trainer.h
// Function: ftrl_trainer::ftrl_trainer(trainer_option const&)
ftrl_trainer::ftrl_trainer(const trainer_option& opt)
{
    w_alpha = opt.w_alpha;
    w_beta = opt.w_beta;
    w_l1 = opt.w_l1;
    w_l2 = opt.w_l2;
    v_alpha = opt.v_alpha;
    v_beta = opt.v_beta;
    v_l1 = opt.v_l1;
    v_l2 = opt.v_l2;
    k1 = opt.k1;
    force_v_sparse = opt.force_v_sparse;
    rank = opt.rank;
    fast_mode = opt.fast_mode;
    pModel = new ftrl_model(opt.factor_num, opt.init_mean, opt.init_stdev);
    vecDiscount.reserve(cacheSize);
    for(int i = 0; i < cacheSize; ++i)
    {
        vecDiscount.push_back(1.0/log2(i + 2.0));// discount(i) = 1/log2(i+1), i from 1 to ... 
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x8d50
movq 0x20(%rsp), %rdi
leaq 0x208df(%rip), %rax     # 0x24ce8
movq %rax, (%rdi)
addq $0x58, %rdi
movq %rdi, 0x28(%rsp)
callq 0x33a0
movq 0x20(%rsp), %rdi
subq $-0x80, %rdi
movq %rdi, 0x18(%rsp)
callq 0x8d70
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rcx
movsd 0x50(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
movq 0x48(%rsp), %rcx
movsd 0x58(%rcx), %xmm0
movsd %xmm0, 0x18(%rax)
movq 0x48(%rsp), %rcx
movsd 0x60(%rcx), %xmm0
movsd %xmm0, 0x20(%rax)
movq 0x48(%rsp), %rcx
movsd 0x68(%rcx), %xmm0
movsd %xmm0, 0x28(%rax)
movq 0x48(%rsp), %rcx
movsd 0x70(%rcx), %xmm0
movsd %xmm0, 0x30(%rax)
movq 0x48(%rsp), %rcx
movsd 0x78(%rcx), %xmm0
movsd %xmm0, 0x38(%rax)
movq 0x48(%rsp), %rcx
movsd 0x80(%rcx), %xmm0
movsd %xmm0, 0x40(%rax)
movq 0x48(%rsp), %rcx
movsd 0x88(%rcx), %xmm0
movsd %xmm0, 0x48(%rax)
movq 0x48(%rsp), %rcx
movb 0x98(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x50(%rax)
movq 0x48(%rsp), %rcx
movb 0x9a(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x51(%rax)
movq 0x48(%rsp), %rsi
addq $0xa0, %rsi
callq 0x3040
jmp 0x44ea
movq 0x20(%rsp), %rax
movq 0x48(%rsp), %rcx
movb 0xc0(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x78(%rax)
movl $0x78, %edi
callq 0x32e0
movq %rax, 0x10(%rsp)
jmp 0x4511
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rax
cvtsi2sdl 0x94(%rax), %xmm0
movsd 0x40(%rax), %xmm1
movsd 0x48(%rax), %xmm2
callq 0x3900
jmp 0x4534
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rdi)
subq $-0x80, %rdi
movl $0x1388, %esi           # imm = 0x1388
callq 0x8d80
jmp 0x4552
movl $0x0, 0x38(%rsp)
cmpl $0x1388, 0x38(%rsp)     # imm = 0x1388
jge 0x45ec
movq 0x20(%rsp), %rax
subq $-0x80, %rax
movq %rax, 0x8(%rsp)
cvtsi2sdl 0x38(%rsp), %xmm0
movsd 0x16a8c(%rip), %xmm1    # 0x1b010
addsd %xmm1, %xmm0
callq 0x34b0
movq 0x8(%rsp), %rdi
movaps %xmm0, %xmm1
movsd 0x16a7b(%rip), %xmm0    # 0x1b018
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x8e90
jmp 0x45b3
jmp 0x45b5
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x455a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x45f1
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x32b0
jmp 0x45f1
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x8ec0
movq 0x28(%rsp), %rdi
callq 0x3518
movq 0x40(%rsp), %rdi
callq 0x3490
nop
// File: CastellanZhang[P]lambdaFM/./src/FTRL/ftrl_trainer.h
// Function: ftrl_trainer::run_task(std::vector<std::vector<fm_sample, std::allocator<fm_sample>>, std::allocator<std::vector<fm_sample, std::allocator<fm_sample>>>>&)
void ftrl_trainer::run_task(vector<vector<fm_sample> >& dataBuffer)
{
    for(int i = 0; i < dataBuffer.size(); ++i)
    {
        if(fast_mode)
        {
            trainGroupFastMode(dataBuffer[i]);
        }
        else
        {
            trainGroup(dataBuffer[i]);
        }
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movslq 0x14(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x8f20
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x46a3
movq 0x8(%rsp), %rax
testb $0x1, 0x78(%rax)
je 0x4678
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x8f40
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x46b0
jmp 0x4694
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x8f40
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x5290
jmp 0x4696
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4630
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: CastellanZhang[P]lambdaFM/./src/FTRL/ftrl_trainer.h
// Function: ftrl_trainer::calcVariables4NDCG(std::vector<fm_sample, std::allocator<fm_sample>>&, variable_NDCG&)
void ftrl_trainer::calcVariables4NDCG(vector<fm_sample>& sampleGrp, variable_NDCG& v_NDCG)
{
    int size = sampleGrp.size();
    v_NDCG.DCG = 0;
    for(int i = 0; i < size; ++i)
    {
        v_NDCG.vecGain[i] = gain(sampleGrp[i].y);
        v_NDCG.vecDCG[i] = v_NDCG.vecGain[i] * discount(i);
        v_NDCG.DCG += v_NDCG.vecDCG[i];
    }
    v_NDCG.vecIdealDCG.assign(v_NDCG.vecGain.begin(), v_NDCG.vecGain.end());
    v_NDCG.idealDCG = 0;
    sort(v_NDCG.vecIdealDCG.begin(), v_NDCG.vecIdealDCG.end(),greater<double>());
    for(int i = 0; i < size; ++i)
    {
        v_NDCG.vecIdealDCG[i] *= discount(i);
        v_NDCG.idealDCG += v_NDCG.vecIdealDCG[i];
    }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rdi
callq 0x8f60
movl %eax, 0x5c(%rsp)
movq 0x60(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x48(%rax)
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x5c(%rsp), %eax
jge 0x5665
movq 0x68(%rsp), %rdi
movslq 0x58(%rsp), %rsi
callq 0x9040
movq 0x28(%rsp), %rdi
movl (%rax), %esi
callq 0x96b0
movsd %xmm0, 0x10(%rsp)
movq 0x60(%rsp), %rdi
movslq 0x58(%rsp), %rsi
callq 0x8790
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x60(%rsp), %rdi
movslq 0x58(%rsp), %rsi
callq 0x8790
movq 0x28(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x58(%rsp), %esi
callq 0x96d0
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x60(%rsp), %rdi
addq $0x18, %rdi
movslq 0x58(%rsp), %rsi
callq 0x8790
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x60(%rsp), %rdi
addq $0x18, %rdi
movslq 0x58(%rsp), %rsi
callq 0x8790
movsd (%rax), %xmm0
movq 0x60(%rsp), %rax
addsd 0x48(%rax), %xmm0
movsd %xmm0, 0x48(%rax)
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x5590
movq 0x60(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
callq 0x9790
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rdi
callq 0x97c0
movq 0x8(%rsp), %rdi
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x9750
movq 0x60(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rax)
movq 0x60(%rsp), %rdi
addq $0x30, %rdi
callq 0x9790
movq %rax, 0x40(%rsp)
movq 0x60(%rsp), %rdi
addq $0x30, %rdi
callq 0x97c0
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x97f0
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x5c(%rsp), %eax
jge 0x575f
movq 0x28(%rsp), %rdi
movl 0x30(%rsp), %esi
callq 0x96d0
movsd %xmm0, (%rsp)
movq 0x60(%rsp), %rdi
addq $0x30, %rdi
movslq 0x30(%rsp), %rsi
callq 0x8790
movsd (%rsp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq 0x60(%rsp), %rdi
addq $0x30, %rdi
movslq 0x30(%rsp), %rsi
callq 0x8790
movsd (%rax), %xmm0
movq 0x60(%rsp), %rax
addsd 0x50(%rax), %xmm0
movsd %xmm0, 0x50(%rax)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x56ef
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: AndreyVV-100[P]GachiLang/Compiler.cpp
// Function: main
int main (int argc, char** argv)
{
    const size_t buf_size = 256;
    char frontend_call[buf_size] = "./Frontend.out ";
    strcat (frontend_call, (argc > 1) ? argv[1] : "Examples/SqrtTripleDick.gcm");
    
    printf ("Calling frontend...\n");
    system (frontend_call);

    printf ("Calling backend...\n");
    system ("./Backend.out");

    printf ("Compiling was ended!\n");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x100, -0x18(%rbp)     # imm = 0x100
leaq -0x120(%rbp), %rdi
leaq 0xe71(%rip), %rsi       # 0x2010
movl $0x100, %edx            # imm = 0x100
callq 0x1040
leaq -0x120(%rbp), %rax
movq %rax, -0x128(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x11ce
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x130(%rbp)
jmp 0x11de
leaq 0xf3b(%rip), %rax       # 0x2110
movq %rax, -0x130(%rbp)
jmp 0x11de
movq -0x128(%rbp), %rdi
movq -0x130(%rbp), %rsi
callq 0x1060
leaq 0xf34(%rip), %rdi       # 0x212c
movb $0x0, %al
callq 0x1030
leaq -0x120(%rbp), %rdi
callq 0x1050
leaq 0xf2f(%rip), %rdi       # 0x2141
movb $0x0, %al
callq 0x1030
leaq 0xf35(%rip), %rdi       # 0x2155
callq 0x1050
leaq 0xf37(%rip), %rdi       # 0x2163
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
// File: SaadBazaz[P]RIP-Protocol-Simulation/Client.cpp
// Function: messageListener(void*)
void *messageListener(void *Args)
{
	sleep(2); // Give it some time to start
	char msg_buff[128] = {0};
	do
	{
		recv(sockfd, msg_buff, 127, 0);
		printf("Received a message: %s\n", msg_buff);
		printf("\n");
		memset(msg_buff, 0, 128);
		sleep(2);
	} while (strcmp(msg_buff, "close") != 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl $0x2, %edi
callq 0x3200
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x3150
movl 0x8072(%rip), %edi      # 0xc274
leaq -0x90(%rbp), %rsi
movl $0x7f, %edx
xorl %ecx, %ecx
callq 0x30b0
leaq -0x90(%rbp), %rsi
leaq 0x3df5(%rip), %rdi      # 0x8018
movb $0x0, %al
callq 0x3060
leaq 0x3f2a(%rip), %rdi      # 0x815b
movb $0x0, %al
callq 0x3060
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x3150
movl $0x2, %edi
callq 0x3200
leaq -0x90(%rbp), %rdi
leaq 0x3dcd(%rip), %rsi      # 0x8030
callq 0x3370
cmpl $0x0, %eax
jne 0x41fc
ud2
nop
// File: muk343[P]pmml/GraphGenerator.cpp
// Function: GraphGenerator::getScoreDistribution(TiXmlElement*)
pair<double, double> GraphGenerator::getScoreDistribution(TiXmlElement* pElement) 
    {
        TiXmlAttribute* pAttribFirst=pElement->FirstAttribute();
        TiXmlAttribute* pAttribLast=pElement->LastAttribute();

        double score;
        double recordCount;

        if (pAttribFirst->QueryDoubleValue(&score)!=TIXML_SUCCESS) 
        {
         cout<<"Problem extracting the score value from the node";   
         exit(-1);
        } 
        if (pAttribLast->QueryDoubleValue(&recordCount)!=TIXML_SUCCESS) 
        {
         cout<<"Problem extracting the score value from the node";   
         exit(-1);
        } 

        pair<double, double> scoreDistribution = make_pair(score, recordCount);
        return scoreDistribution;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xdf90
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xdfb0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5e40
cmpl $0x0, %eax
je 0xd279
movq 0x12d65(%rip), %rdi     # 0x1ffc8
leaq 0x9ba5(%rip), %rsi      # 0x16e0f
callq 0x4270
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x4340
movq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5e40
cmpl $0x0, %eax
je 0xd2a8
movq 0x12d36(%rip), %rdi     # 0x1ffc8
leaq 0x9b76(%rip), %rsi      # 0x16e0f
callq 0x4270
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x4340
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xdfd0
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x40, %rsp
popq %rbp
retq
nop