LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpl $0x5, %esi
ja 0x27e4d
movl %esi, %eax
leaq 0x7b2a(%rip), %rcx      # 0x2f878
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x68(%rdi), %rax
subq 0x60(%rdi), %rax
jmp 0x27df5
movq 0x50(%rdi), %rax
movq 0x68(%rdi), %rcx
subq 0x60(%rdi), %rcx
shrq $0x3, %rcx
subq 0x48(%rdi), %rax
shrq $0x3, %rax
addl %ecx, %eax
retq
leaq 0x1d65e(%rip), %rax     # 0x453e4
movl (%rax), %eax
movq 0xa8(%rdi), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
imulq $0x18, %rax, %rsi
xorl %eax, %eax
cmpq %rdx, %rsi
je 0x27d7e
movq 0x8(%rcx,%rdx), %rdi
subq (%rcx,%rdx), %rdi
shrq $0x3, %rdi
addl %edi, %eax
addq $0x18, %rdx
jmp 0x27d9c
leaq 0x1d627(%rip), %rax     # 0x453e4
movl (%rax), %eax
movq 0xb0(%rdi), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
imulq $0x18, %rax, %rsi
xorl %eax, %eax
cmpq %rdx, %rsi
je 0x27d7e
movq 0x8(%rcx,%rdx), %rdi
subq (%rcx,%rdx), %rdi
shrq $0x3, %rdi
addl %edi, %eax
addq $0x18, %rdx
jmp 0x27dd3
movq 0x50(%rdi), %rax
subq 0x48(%rdi), %rax
shrq $0x3, %rax
retq
leaq 0x1d5e3(%rip), %rax     # 0x453e4
movl (%rax), %eax
movq 0xa8(%rdi), %rcx
movq 0xb0(%rdi), %rdx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
imulq $0x18, %rax, %rdi
xorl %eax, %eax
cmpq %rsi, %rdi
je 0x27d7e
movq 0x8(%rcx,%rsi), %r8
subq (%rcx,%rsi), %r8
shrq $0x3, %r8
movq 0x8(%rdx,%rsi), %r9
subq (%rdx,%rsi), %r9
shrq $0x3, %r9
addl %r8d, %r9d
addl %r9d, %eax
addq $0x18, %rsi
jmp 0x27e1e
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
movq 0x50(%rdi), %r15
movq 0x68(%rdi), %r12
subq 0x48(%rdi), %r15
subq 0x60(%rdi), %r12
shrq $0x3, %r15
addq $0x60, %rbx
shrq $0x3, %r12
addl %r15d, %r12d
leaq 0x1dbeb(%rip), %rdi     # 0x45a70
callq 0xb2e2
cvtsi2sd %r15d, %xmm1
cvtsi2sd %r12d, %xmm2
divsd %xmm2, %xmm1
ucomisd %xmm0, %xmm1
cmovaeq %r14, %rbx
movq 0x8(%rbx), %rdi
subq (%rbx), %rdi
je 0x27ed7
shrq $0x3, %rdi
callq 0x25c49
movslq %eax, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x232b2
movq (%rax), %r14
shlq $0x3, %r15
addq (%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x295da
jmp 0x27eda
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsi, (%rsp)
testq %rsi, %rsi
je 0x27f2e
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22c28
movq %rbx, %rdi
callq 0x20c92
leaq 0x90(%r14), %rcx
addq $0x78, %r14
testl %eax, %eax
cmovneq %rcx, %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2320e
jmp 0x27f3a
leaq 0x7c9e(%rip), %rdi      # 0x2fbd3
callq 0x75c0
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
xorl %r8d, %r8d
callq 0x281c2
pushq $0x1
popq %r8
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x281c2
movq %rbp, %rdi
movq %r14, %rsi
callq 0x282da
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x28430
addq $0x1d8, %rbp            # imm = 0x1D8
movq %rbp, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29614
nop
// File: /workspace/github_cpp_makefile_star2_O2/melop[P]admixem/Population.cpp
// Function: Population::fnSample(std::basic_ofstream<char, std::char_traits<char>>&, std::basic_ofstream<char, std::char_traits<char>>&, std::basic_ofstream<char, std::char_traits<char>>&, Individual::Sex)
void Population::fnSample(ofstream &fMarkerOutFile, ofstream &fGeneOutFile,  ofstream &fPhenotypeOutFile, Individual::Sex bSex) {

	bool bWriteMarkers = !(SimulConfig.GetConfig("MarkerOutput") == "Off");
	
	vector< Individual *> * pMpIndividuals = (bSex == Individual::Male)? &this->_mpMales : &this->_mpFemales;
	
	

	int i=0;

	for (vector< Individual *>::iterator itInd=pMpIndividuals->begin(); itInd!=pMpIndividuals->end(); ++ itInd) {

		if (bWriteMarkers) {
			this->fnWriteIndividualMarkers(fMarkerOutFile, *itInd);
		}
		this->fnWriteIndividualGenes(fGeneOutFile, *itInd);

		if (i==0) {
				// phenotype file needs header.
				fPhenotypeOutFile << "id\tpop\tsex\tFatherId\tMotherId\t";
				(*itInd)->WritePhenotypeHeader(fPhenotypeOutFile);
				fPhenotypeOutFile << endl;
		}

		this->fnWriteIndividualPhenotypes(fPhenotypeOutFile, *itInd);

		i++;
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r8d, %r14d
movq %rcx, %rbx
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %r12
leaq 0x791e(%rip), %rsi      # 0x2fb08
leaq 0x18(%rsp), %rbp
leaq 0x7(%rsp), %rdx
movq %rbp, %rdi
callq 0x9512
leaq 0x1d735(%rip), %rsi     # 0x45938
leaq 0x38(%rsp), %rdi
movq %rbp, %rdx
callq 0xf118
leaq 0x78fe(%rip), %rsi      # 0x2fb15
leaq 0x38(%rsp), %r13
movq %r13, %rdi
callq 0x954d
movl %eax, %ebp
movq %r13, %rdi
callq 0x71a0
leaq 0x18(%rsp), %rdi
callq 0x71a0
testl %r14d, %r14d
pushq $0x48
popq %rax
pushq $0x60
popq %r13
cmoveq %rax, %r13
movq (%r12,%r13), %r15
xorl %r14d, %r14d
cmpq 0x8(%r12,%r13), %r15
je 0x282b5
testb %bpl, %bpl
jne 0x28269
movq (%r15), %rdx
movq %r12, %rdi
movq 0x8(%rsp), %rsi
callq 0x292c0
movq (%r15), %rdx
movq %r12, %rdi
movq 0x10(%rsp), %rsi
callq 0x29312
subl $0x1, %r14d
jae 0x282a1
movq %rbx, %rdi
leaq 0x7890(%rip), %rsi      # 0x2fb19
callq 0x73d0
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x22e02
movq %rbx, %rdi
callq 0x71c0
movq (%r15), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x29364
addq $0x8, %r15
jmp 0x2824d
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x71a0
movq %rbx, %rdi
callq 0x76d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0xd0(%rdi), %r15
movq 0x100(%rdi), %r12
movq 0x130(%rdi), %rbp
movq %rdi, 0x8(%rsp)
leaq 0xc0(%rdi), %rax
movq %rax, 0x10(%rsp)
pushq $0x5b
popq %r13
cmpq 0x10(%rsp), %r15
je 0x28421
movq 0x8(%rsp), %rax
movl 0x20(%rax), %esi
movq %rbx, %rdi
callq 0x76b0
movq %rax, %rdi
pushq $0x9
popq %r14
movl %r14d, %esi
callq 0x7490
leaq 0x20(%r15), %rsi
movq %rax, %rdi
callq 0x7370
movq %rax, %rdi
movl %r14d, %esi
callq 0x7490
movsd 0x40(%r15), %xmm0
movq %rbx, %rdi
callq 0x7620
movq %rax, %rdi
movl %r13d, %esi
callq 0x7490
movsd 0x48(%r15), %xmm0
movq %rax, %rdi
callq 0x7620
movq %rax, %rdi
leaq 0x777e(%rip), %r14      # 0x2fb05
movq %r14, %rsi
callq 0x73d0
movsd 0x40(%r12), %xmm0
movq %rax, %rdi
callq 0x7620
movq %rax, %rdi
movl %r13d, %esi
callq 0x7490
movsd 0x48(%r12), %xmm0
movq %rax, %rdi
callq 0x7620
movq %rax, %rdi
movq %r14, %rsi
callq 0x73d0
movsd 0x40(%rbp), %xmm0
movq %rax, %rdi
callq 0x7620
movq %rax, %rdi
movl %r13d, %esi
callq 0x7490
movsd 0x48(%rbp), %xmm0
movq %rax, %rdi
callq 0x7620
movq %rax, %rdi
pushq $0x5d
popq %rsi
callq 0x7490
movq %rax, %rdi
callq 0x71c0
movq %r12, %rdi
callq 0x72d0
movq %rax, %r12
movq %rbp, %rdi
callq 0x72d0
movq %rax, %rbp
movq %r15, %rdi
callq 0x72d0
movq %rax, %r15
jmp 0x28315
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpb $0x1, 0x41(%rdi)
jne 0x284d3
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x76e7(%rip), %rsi      # 0x2fb37
movq %rbx, %rdi
callq 0x73d0
movl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x76b0
leaq 0x7708(%rip), %rsi      # 0x2fb73
movq %rax, %rdi
callq 0x73d0
movq %rax, %rdi
callq 0x71c0
movq 0x1d8(%r14), %r12
leaq 0x5b5f(%rip), %r15      # 0x2dfe8
cmpq 0x1e0(%r14), %r12
je 0x284ca
movq (%r12), %r13
cmpq 0x8(%r12), %r13
je 0x284bc
movsd (%r13), %xmm0
movq %rbx, %rdi
callq 0x7620
movq %rax, %rdi
movq %r15, %rsi
callq 0x73d0
addq $0x8, %r13
jmp 0x28496
movq %rbx, %rdi
callq 0x71c0
addq $0x18, %r12
jmp 0x28489
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2938e
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x22c40
movq %rbx, %rdi
callq 0x71c0
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2938e
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22c40
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x71c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2938e
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x22cec
movq %rbx, %rdi
callq 0x71c0
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2938e
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22cec
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x71c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %rdi
callq 0x20c96
movq %rbx, %rdi
movq %rax, %rsi
callq 0x72a0
pushq $0x9
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0x7490
movl 0x20(%r15), %esi
movq %rbx, %rdi
callq 0x76b0
movq %rax, %rdi
movl %ebp, %esi
callq 0x7490
movq %r14, %rdi
callq 0x20c92
testl %eax, %eax
leaq 0x6f5e(%rip), %rax      # 0x30343
leaq 0x55de(%rip), %rsi      # 0x2e9ca
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x73d0
movq %rax, %rdi
movl %ebp, %esi
callq 0x7490
movq %r14, %rdi
callq 0x22c36
movq %rbx, %rdi
movq %rax, %rsi
callq 0x72a0
movq %rax, %rdi
movl %ebp, %esi
callq 0x7490
movq %r14, %rdi
callq 0x22c3a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x72a0
movq %rax, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7490
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, 0x48(%rsp)
movsd %xmm1, 0x40(%rsp)
movsd %xmm2, 0x38(%rsp)
movsd %xmm3, 0x30(%rsp)
movsd %xmm4, 0x28(%rsp)
movsd %xmm5, 0x20(%rsp)
movsd %xmm6, 0x18(%rsp)
cmpb $0x1, 0x41(%rdi)
jne 0x29528
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x48(%rsp), %rsi
callq 0x170a2
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x170a2
movq %rsp, %rdi
leaq 0x38(%rsp), %rsi
callq 0x170a2
movq %rsp, %rdi
leaq 0x30(%rsp), %rsi
callq 0x170a2
movq %rsp, %rdi
leaq 0x28(%rsp), %rsi
callq 0x170a2
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x170a2
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
callq 0x170a2
testb %bpl, %bpl
jne 0x294f5
xorps %xmm0, %xmm0
jmp 0x294fd
movsd 0x3b13(%rip), %xmm0     # 0x2d010
leaq 0x50(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %rsp, %rdi
callq 0x1a60c
addq $0x1d8, %rbx            # imm = 0x1D8
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2961c
movq %rsp, %rdi
callq 0x181e8
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
jmp 0x29531
movq %rax, %rbx
movq %rsp, %rdi
callq 0x181e8
movq %rbx, %rdi
callq 0x76d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
callq 0x299fe
callq 0x7290
movq %rax, %rbx
callq 0x29b08
callq 0x7290
subq %rbx, %rax
cvtsi2ss %rax, %xmm0
divss 0x621d(%rip), %xmm0     # 0x2fc08
cvtss2sd %xmm0, %xmm0
leaq 0x6216(%rip), %rdi      # 0x2fc0c
movb $0x1, %al
popq %rbx
jmp 0x7050
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movl %esi, %r14d
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x7530
leal -0x1(%r14), %eax
cmpl $0x1, %eax
ja 0x2b4cc
leaq 0x4766(%rip), %rsi      # 0x2fc28
movq %rsp, %rdi
callq 0x73d0
jmp 0x2b4f6
cmpl $0x3, %r14d
jne 0x2b4e3
leaq 0x4753(%rip), %rsi      # 0x2fc2c
movq %rsp, %rdi
callq 0x73d0
jmp 0x2b501
leaq 0x4742(%rip), %rsi      # 0x2fc2c
movq %rsp, %rdi
callq 0x73d0
addl $-0x3, %r14d
movq %rax, %rdi
movl %r14d, %esi
callq 0x76b0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x75f0
movq %rsp, %rdi
callq 0x70e0
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x70e0
movq %rbx, %rdi
callq 0x76d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x4c72(%rip), %rsi      # 0x301f7
leaq 0x68(%rsp), %r14
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x9512
leaq 0x4b49(%rip), %rdx      # 0x300e7
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x22ff5
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %rbx, %rdx
callq 0x948c
leaq 0x4b23(%rip), %rdx      # 0x300e7
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x948c
movq 0x8(%rsp), %rdi
callq 0x7350
leaq 0x8(%rsp), %rdi
callq 0x71a0
leaq 0x48(%rsp), %rdi
callq 0x71a0
leaq 0x28(%rsp), %rdi
callq 0x71a0
leaq 0x68(%rsp), %rdi
callq 0x71a0
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x71a0
jmp 0x2b622
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x71a0
jmp 0x2b631
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x71a0
jmp 0x2b640
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x71a0
movq %rbx, %rdi
callq 0x76d0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r12
movq %rdi, %r15
leaq 0xd117(%rip), %rax      # 0x10d10
movq %rax, (%rdi)
leaq 0x58(%rdi), %rbx
leaq 0x68(%rdi), %rax
movq %rax, 0x58(%rdi)
andq $0x0, 0x60(%rdi)
movb $0x0, 0x68(%rdi)
leaq 0x80(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rdi)
andq $0x0, 0x90(%rdi)
movups 0x50(%rsi), %xmm0
movups %xmm0, 0x10(%rdi)
movups 0x60(%rsi), %xmm0
movups %xmm0, 0x20(%rdi)
movups 0x70(%rsi), %xmm0
movups %xmm0, 0x30(%rdi)
movupd 0x80(%rsi), %xmm0
movupd %xmm0, 0x40(%rdi)
movb 0x98(%rsi), %al
movb %al, 0x50(%rdi)
movb 0x9a(%rsi), %al
movb %al, 0x51(%rdi)
addq $0xa0, %rsi
movq %rbx, %rdi
callq 0x3160
movb 0xc0(%r12), %al
movb %al, 0x78(%r15)
pushq $0x78
popq %rdi
callq 0x32b0
movl 0x94(%r12), %ecx
movq %rax, %rdx
addq $0x30, %rdx
movq %rdx, (%rax)
movq $0x1, 0x8(%rax)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%rax)
movl $0x3f800000, 0x20(%rax) # imm = 0x3F800000
movupd %xmm0, 0x28(%rax)
movupd %xmm0, 0x50(%rax)
movupd %xmm0, 0x60(%rax)
andq $0x0, 0x70(%rax)
movl %ecx, 0x38(%rax)
movupd 0x40(%r12), %xmm0
shufpd $0x1, %xmm0, %xmm0      # xmm0 = xmm0[1,0]
movupd %xmm0, 0x40(%rax)
movq %rax, 0x8(%r15)
movl $0x1388, %esi           # imm = 0x1388
movq %r14, %rdi
callq 0x5d10
xorl %r12d, %r12d
movl $0x1388, %ebp           # imm = 0x1388
leaq 0x8(%rsp), %r15
subl $0x1, %ebp
jb 0x3d29
leal 0x2(%r12), %eax
cvtsi2sd %eax, %xmm0
callq 0x3420
movsd 0x7301(%rip), %xmm1     # 0xb010
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x7a5c
incl %r12d
jmp 0x3cf4
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3d38
movq %rax, %r15
movq %r14, %rdi
callq 0x7496
movq %rbx, %rdi
callq 0x3468
movq %r15, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
pushq $0x18
popq %r12
xorl %r13d, %r13d
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
cqto
idivq %r12
cmpq %r13, %rax
jbe 0x3da6
addq %r15, %rsi
cmpb $0x1, 0x78(%r14)
jne 0x3d95
movq %r14, %rdi
callq 0x3db0
jmp 0x3d9d
movq %r14, %rdi
callq 0x42fc
incq %r13
addq $0x18, %r15
jmp 0x3d6d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/CastellanZhang[P]lambdaFM/./src/FTRL/ftrl_trainer.h
// Function: ftrl_trainer::trainGroup(std::vector<fm_sample, std::allocator<fm_sample>>&)
void ftrl_trainer::trainGroup(vector<fm_sample>& sampleGrp)
{
    int size = sampleGrp.size();
    variable_NDCG v_NDCG;
    if("ndcg" == rank)
    {
        v_NDCG.init(size);
        calcVariables4NDCG(sampleGrp, v_NDCG);
    }
    for(int i = 0; i < size - 1; ++i)
    {
        for(int j = i + 1; j < size; ++j)
        {
            if(sampleGrp[i].y == sampleGrp[j].y)
            {
                continue;
            }
            double deltaNDCG = 1.0;
            if("ndcg" == rank)
            {
                deltaNDCG = calcDeltaNDCG(i, j, v_NDCG);
            }
            if(sampleGrp[i].y > sampleGrp[j].y)
            {
                trainPair(sampleGrp[i], sampleGrp[j], deltaNDCG);
            }
            else if(sampleGrp[i].y < sampleGrp[j].y)
            {
                trainPair(sampleGrp[j], sampleGrp[i], deltaNDCG);
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
subq (%rsi), %rax
pushq $0x60
popq %rbp
cqto
idivq %rbp
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
andq $0x0, 0x70(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
leaq 0x58(%rdi), %rsi
leaq 0x6d25(%rip), %rdi      # 0xb072
movq %rsi, 0x28(%rsp)
callq 0x5d9f
testb %al, %al
je 0x4378
leaq 0x30(%rsp), %rdi
movl %r15d, %esi
callq 0x5db6
leaq 0x30(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x447a
cmpl $0x2, %r15d
pushq $0x1
popq %r13
movl %r13d, %eax
cmovgel %r15d, %eax
decl %eax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
cmpq 0x8(%rsp), %rax
je 0x4447
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x20(%rsp)
imulq $0x60, %rax, %r12
movl %r13d, 0x4(%rsp)
movq %rbp, 0x18(%rsp)
cmpl %r15d, %r13d
jge 0x442c
movq (%rbx), %rax
movl (%rax,%r12), %ecx
cmpl (%rax,%rbp), %ecx
je 0x4423
leaq 0x6ca3(%rip), %rdi      # 0xb072
movq 0x28(%rsp), %rsi
callq 0x5d9f
movsd 0x6c2f(%rip), %xmm0     # 0xb010
testb %al, %al
je 0x43fa
movq %r14, %rdi
movq 0x20(%rsp), %rsi
movl %r13d, %edx
leaq 0x30(%rsp), %rcx
callq 0x5dea
movq (%rbx), %rcx
leaq (%rcx,%r12), %rdx
leaq (%rcx,%rbp), %rax
movl (%rcx,%rbp), %esi
cmpl %esi, (%rcx,%r12)
jle 0x4416
movq %rdx, %rsi
movq %rax, %rdx
jmp 0x441b
movq %rax, %rsi
jge 0x4423
movq %r14, %rdi
callq 0x4566
addq $0x60, %rbp
incl %r13d
jmp 0x43b7
movq 0x18(%rsp), %rbp
addq $0x60, %rbp
movl 0x4(%rsp), %r13d
incl %r13d
movq 0x10(%rsp), %rax
jmp 0x4390
leaq 0x30(%rsp), %rdi
callq 0x5e78
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4465
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5e78
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq 0x8(%rsi), %rax
subq (%rsi), %rax
movq %rdx, %rbx
pushq $0x60
popq %rcx
cqto
idivq %rcx
movq %rax, %r14
andq $0x0, 0x48(%rbx)
movq %rdi, %r15
xorl %ebp, %ebp
testl %r14d, %r14d
cmovlel %ebp, %r14d
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x4503
movq (%r12), %rax
movb (%rax,%rbp), %cl
pushq $-0x1
popq %rax
shll %cl, %eax
notl %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, (%rsp)
movq (%rbx), %rax
movsd %xmm0, (%rax,%r13,8)
movq %r15, %rdi
movl %r13d, %esi
callq 0x6076
mulsd (%rsp), %xmm0
movq 0x18(%rbx), %rax
movsd %xmm0, (%rax,%r13,8)
addsd 0x48(%rbx), %xmm0
movsd %xmm0, 0x48(%rbx)
incq %r13
addq $0x60, %rbp
jmp 0x44b1
leaq 0x30(%rbx), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x8168
andq $0x0, 0x50(%rbx)
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
callq 0x827b
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x4557
movq %r15, %rdi
movl %r12d, %esi
callq 0x6076
movq 0x30(%rbx), %rax
mulsd (%rax,%r12,8), %xmm0
movsd %xmm0, (%rax,%r12,8)
addsd 0x50(%rbx), %xmm0
movsd %xmm0, 0x50(%rbx)
incq %r12
jmp 0x4528
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
pushq $0x2
popq %rbx
movl %ebx, %edi
callq 0x2160
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, 0x70(%r14)
movaps %xmm0, 0x60(%r14)
movaps %xmm0, 0x50(%r14)
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
pushq $0x7f
popq %r15
leaq 0x14c3(%rip), %r12      # 0x4018
pushq $0xa
popq %rbp
movl 0x4676(%rip), %edi      # 0x71d4
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x2070
movq %r12, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2040
movl %ebp, %edi
callq 0x2260
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x70(%rsp)
movl %ebx, %edi
callq 0x2160
jmp 0x2b58
// File: /workspace/github_cpp_makefile_star2_O2/muk343[P]pmml/GraphGenerator.cpp
// Function: GraphGenerator::subGenerateGraph(TiXmlNode*)
Node* GraphGenerator::subGenerateGraph(TiXmlNode* pParent)
    {
        //if ( !pParent ) return;

        TiXmlNode* pChild;
        TiXmlText* pText;
        int t = pParent->Type();
        int num;
         
        Node* rootNode = getNodeDataFromThisNode(pParent->ToElement()); 

        string nodeTag = "Node";
        //if(pParent->FirstChild)
        for ( pChild = pParent->FirstChild(); pChild != 0; pChild = pChild->NextSibling()) 
        {
            if(nodeTag.compare(pChild->Value()) == 0) {
                rootNode->addChildNode(subGenerateGraph(pChild));
            }
            
        }

        return rootNode;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x58(%rax)
movq %rax, %rsi
callq 0x8b34
movq %rax, %r15
leaq 0x2fe5(%rip), %rsi      # 0xbd71
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0x90b6
addq $0x28, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x8dda
movq 0x38(%rbx), %rsi
addq $0x10, %rsi
movq %r12, %rdi
callq 0x40d0
testl %eax, %eax
jne 0x8dd4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8d60
movq %r15, %rdi
movq %rax, %rsi
callq 0x9ee2
addq $0x48, %rbx
jmp 0x8da2
leaq 0x8(%rsp), %rdi
callq 0x4120
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4120
movq %rbx, %rdi
callq 0x43e0
// File: /workspace/github_cpp_makefile_star2_O2/muk343[P]pmml/GraphGenerator.cpp
// Function: GraphGenerator::dump_to_stdout(char const*)
Node* GraphGenerator::dump_to_stdout(const char* pFilename)
    {
        TiXmlDocument doc(pFilename);
        bool loadOkay = doc.LoadFile();
        if (loadOkay)
        {
            return dump_to_stdout( &doc ); // defined later in the tutorial
        }
        else
        {
            printf("Failed to load file \"%s\"\n", pFilename);
            return NULL;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x57a8
movq %r15, %rdi
xorl %esi, %esi
callq 0x591a
testb %al, %al
je 0x8f36
movq %rsp, %rsi
movq %r14, %rdi
callq 0x8e08
movq %rax, %r14
jmp 0x8f4a
leaq 0x2e6b(%rip), %rdi      # 0xbda8
xorl %r14d, %r14d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4070
movq %rsp, %rdi
callq 0x8872
movq %r14, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8872
movq %rbx, %rdi
callq 0x43e0
// File: /workspace/github_cpp_makefile_star2_O2/muk343[P]pmml/GraphGenerator.cpp
// Function: GraphGenerator::traverse(Node*)
void GraphGenerator::traverse(Node* rootNode) {
        
        stack<Node *> node_stack;
        Node *curr = rootNode;

        node_stack.push(curr);

        while(!node_stack.empty()) {

            Node* temp = node_stack.top();
            node_stack.pop();
            cout<<"Score is: "<<temp->score<<" recordCount is: "<<temp->node_record_count<<endl;
            if (temp->childNodes.size() == 1) {
                cout<<"This has only one child";
                exit(-1);
            }

            if (temp->childNodes.size() == 2) {
                node_stack.push(temp->childNodes[0]);
                node_stack.push(temp->childNodes[1]);
            }
        }

    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x9208
movq %rsp, %rsi
movq %rbx, (%rsi)
movq %r14, %rdi
callq 0x9896
movl $0x200, %r13d           # imm = 0x200
leaq 0x8(%rsp), %rbx
movq 0x9010(%rip), %r14      # 0x11fc0
leaq 0x2e0b(%rip), %r15      # 0xbdc2
leaq 0x2e0f(%rip), %r12      # 0xbdcd
movq 0x38(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x9063
cmpq 0x40(%rsp), %rax
jne 0x8fe1
movq 0x50(%rsp), %rax
movq -0x8(%rax), %rax
addq %r13, %rax
movq -0x8(%rax), %rbp
movq %rbx, %rdi
callq 0x9aca
movq %r14, %rdi
movq %r15, %rsi
callq 0x4200
movsd (%rbp), %xmm0
movq %rax, %rdi
callq 0x43a0
movq %rax, %rdi
movq %r12, %rsi
callq 0x4200
movsd 0x20(%rbp), %xmm0
movq %rax, %rdi
callq 0x43a0
movq %rax, %rdi
callq 0x4150
movq 0x70(%rbp), %rsi
movq 0x78(%rbp), %rax
subq %rsi, %rax
sarq $0x3, %rax
cmpq $0x2, %rax
je 0x9046
cmpq $0x1, %rax
jne 0x8fbe
jmp 0x907c
movq %rbx, %rdi
callq 0x9896
movq 0x70(%rbp), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x9896
jmp 0x8fbe
leaq 0x8(%rsp), %rdi
callq 0x92d8
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8f3d(%rip), %rdi      # 0x11fc0
leaq 0x2d55(%rip), %rsi      # 0xbddf
callq 0x4200
pushq $-0x1
popq %rdi
callq 0x4290
jmp 0x909b
jmp 0x909b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x92d8
movq %rbx, %rdi
callq 0x43e0
// File: /workspace/github_cpp_makefile_star2_O2/muk343[P]pmml/PMMLNode.cpp
// Function: Node::Node(int, std::vector<double, std::allocator<double>>, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
Node::Node(int score, vector<double> score_distribution, double node_record_count, string predicate_feature, string predicate_operator, double predicate_value) {
	this->score = score;
	this->score_distribution = score_distribution;
	this->node_record_count = node_record_count;
	this->predicate_feature = predicate_feature;
	this->predicate_operator = predicate_operator;
	this->predicate_value = predicate_value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x8(%rsp)
movq %r8, %r12
movq %rcx, %rbp
movsd %xmm0, 0x10(%rsp)
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
leaq 0x28(%rdi), %r14
leaq 0x38(%rdi), %rax
movq %rax, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
xorl %eax, %eax
movb %al, 0x38(%rdi)
leaq 0x48(%rdi), %r13
leaq 0x58(%rdi), %rcx
movq %rcx, 0x48(%rdi)
andq $0x0, 0x50(%rdi)
movb %al, 0x58(%rdi)
leaq 0x70(%rdi), %rax
movq %rax, (%rsp)
andq $0x0, 0x80(%rdi)
movups %xmm0, 0x70(%rdi)
cvtsi2sd %esi, %xmm0
movsd %xmm0, (%rdi)
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x913e
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x20(%r15)
movq %r14, %rdi
movq %rbp, %rsi
callq 0x4170
movq %r13, %rdi
movq %r12, %rsi
callq 0x4170
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x68(%r15)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%rsp), %rdi
callq 0x9f52
movq %r13, %rdi
callq 0x4120
movq %r14, %rdi
callq 0x4120
movq %rbx, %rdi
callq 0x93c6
movq %r15, %rdi
callq 0x43e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/muk343[P]pmml/pmml_score.cpp
// Function: Score::generateProb(Node*)
vector<double> generateProb(Node* root) {
		
		vector<double> result;
		if(root == NULL) {
			result.resize(5,0.0);
			return result;
		}
		
		getScore(root);
		
		if(resPMMLNode == NULL) {
			resPMMLNode = root;
		}
		
		for(int i=0; i<5; i++) {
			double prob = (resPMMLNode->score_distribution[i])/(resPMMLNode->node_record_count);
			result.push_back(prob);
		}

		return result;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
testq %rdx, %rdx
je 0xa44e
movq %rdx, %r15
movq %rsi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xa9c2
cmpq $0x0, (%r14)
jne 0xa41b
movq %r15, (%r14)
xorl %r12d, %r12d
movq %rsp, %r15
cmpq $0x5, %r12
je 0xa460
movq (%r14), %rax
movq 0x8(%rax), %rcx
movsd (%rcx,%r12,8), %xmm0
divsd 0x20(%rax), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaa30
incq %r12
jmp 0xa421
movq %rsp, %rdx
andq $0x0, (%rdx)
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x910a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xa473
jmp 0xa473
movq %rax, %r14
movq %rbx, %rdi
callq 0x93c6
movq %r14, %rdi
callq 0x43e0
// File: /workspace/github_cpp_makefile_star2_O2/muk343[P]pmml/pmml_score.cpp
// Function: Score::getScore(Node*)
void getScore(Node *parent) {
		if(resPMMLNode != NULL) return;
		for(int i=0; i< parent -> childNodes.size(); i++) {
			Node *currPMMLNode = parent -> childNodes.at(i);
			if(isPredicateTrue(currPMMLNode)) {
				//cout << "predicate true " <<currPMMLNode-> node_record_count << endl;
				getScore(currPMMLNode);
			}
		}
		if(resPMMLNode == NULL) {
			resPMMLNode = parent;
		}
		//cout << "resPMML node record count " << resPMMLNode->node_record_count << endl;
	}

// Assembly:
cmpq $0x0, (%rdi)
je 0xa9c9
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x70(%rsi), %r15
xorl %r12d, %r12d
movq 0x78(%rbx), %rax
subq 0x70(%rbx), %rax
sarq $0x3, %rax
cmpq %r12, %rax
jbe 0xaa1d
movq %r15, %rdi
movq %r12, %rsi
callq 0xaa52
movq (%rax), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0xaa74
testb %al, %al
je 0xaa18
movq %r14, %rdi
movq %r13, %rsi
callq 0xa9c2
incq %r12
jmp 0xa9df
cmpq $0x0, (%r14)
jne 0xaa26
movq %rbx, (%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/muk343[P]pmml/pmml_score.cpp
// Function: Score::isPredicateTrue(Node*)
bool isPredicateTrue(Node *node) {
		int feature_idx = getFeatureIndex(node -> predicate_feature);
		if(predicateMap[node->predicate_operator](node -> predicate_value, input_vec[feature_idx])) {
			return true;
		} 
		return false;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x28, %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x42e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xab0e
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x4120
leaq 0x20(%rbx), %rdi
leaq 0x48(%r14), %rsi
callq 0xab2e
movsd 0x68(%r14), %xmm0
movslq %ebp, %rcx
movq 0x8(%rbx), %rdx
movsd (%rdx,%rcx,8), %xmm1
callq *(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4120
movq %rbx, %rdi
callq 0x43e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/main.cpp
// Function: startWorker(void*)
void *startWorker(void *arg) {
  Server *serv = ((Worker*)arg)->serv_;
  int id = ((Worker*)arg)->id_;
  serv->run(id);
  return NULL;
}

// Assembly:
pushq %rax
movq (%rdi), %rax
movl 0x8(%rdi), %esi
movq %rax, %rdi
callq 0x14352
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/Config/Config.cpp
// Function: Config::Config(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Config::Config(std::string &path) : path_(path) {
  workers_ = 0;
  fd_ = open(path_.c_str(), O_RDONLY);
  if (fd_ < 0)
    throw webserv_exception("could not open configuration file : %", 0, path_);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
callq 0x45e0
leaq 0x38(%rbx), %rax
movq %rax, 0x28(%rbx)
andq $0x0, 0x30(%rbx)
movb $0x0, 0x38(%rbx)
andl $0x0, 0x24(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq (%rbx), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x4320
movl %eax, 0x20(%rbx)
testl %eax, %eax
js 0x56c8
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x30
popq %rdi
callq 0x41e0
movq %rax, %r14
leaq 0x16990(%rip), %rsi     # 0x1c06a
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5328
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x45e0
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x5e96
xorl %ebp, %ebp
leaq 0x255fa(%rip), %rsi     # 0x2ad10
leaq 0x935(%rip), %rdx       # 0x6052
movq %r14, %rdi
callq 0x4730
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x4898
jmp 0x573a
movq %rax, %r15
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
callq 0x4898
testb %bpl, %bpl
jne 0x574e
jmp 0x575b
movq %rax, %r15
movq %r14, %rdi
callq 0x4310
jmp 0x575b
movq %rax, %r15
leaq 0x28(%rbx), %r14
leaq 0x48(%rbx), %r12
leaq 0x60(%rbx), %rdi
callq 0x606c
movq %r12, %rdi
callq 0x608e
movq %r14, %rdi
callq 0x4898
movq %rbx, %rdi
callq 0x4898
movq %r15, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/Config/Config.cpp
// Function: Config::clear()
void Config::clear() {
  if (fd_ > 0) {
    close(fd_);
    fd_ = 0;
  }
  tokens_.clear();
  file_content_.clear();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x20(%rdi), %edi
testl %edi, %edi
jle 0x57d6
callq 0x4850
andl $0x0, 0x20(%rbx)
leaq 0x48(%rbx), %rdi
callq 0x60b0
andq $0x0, 0x30(%rbx)
movq 0x28(%rbx), %rax
movb $0x0, (%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/includes/Utils/Utils.hpp
// Function: webserv_exception::webserv_exception(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
webserv_exception(std::string msg, int err_num = 0, std::string arg = "") : errno_(err_num) {
    error_msg_ = msg;
    if (error_msg_.find('%') != std::string::npos)
      error_msg_.replace(error_msg_.find('%'), 1, arg);
    if (errno_) {
      error_msg_ = error_msg_ + " (" + ft::to_string(errno_) + ": " + strerror(errno_) + ")";
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rcx, %r15
movq %rdi, %rbx
leaq 0x24eb1(%rip), %rax     # 0x2ad60
movq %rax, (%rdi)
movl %edx, 0x8(%rdi)
leaq 0x10(%rdi), %r14
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
movq %r14, %rdi
callq 0x4240
pushq $0x25
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x45a0
cmpq $-0x1, %rax
je 0x5f03
pushq $0x25
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x45a0
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rcx
callq 0x4160
cmpl $0x0, 0x8(%rbx)
je 0x5fdb
leaq 0x16238(%rip), %rdx     # 0x1c14c
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x60d3
movl 0x8(%rbx), %esi
movq %rsp, %rdi
callq 0x6118
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
callq 0x61d5
leaq 0x16abb(%rip), %rdx     # 0x1ca00
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x5292
movl 0x8(%rbx), %edi
callq 0x4130
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movq %rax, %rdx
callq 0x5292
leaq 0x16205(%rip), %rdx     # 0x1c17d
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x5292
leaq 0xa0(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4560
movq %rbx, %rdi
callq 0x4898
leaq 0x80(%rsp), %rdi
callq 0x4898
leaq 0x60(%rsp), %rdi
callq 0x4898
leaq 0x40(%rsp), %rdi
callq 0x4898
movq %rsp, %rdi
callq 0x4898
leaq 0x20(%rsp), %rdi
callq 0x4898
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
leaq 0x80(%rsp), %rdi
callq 0x4898
jmp 0x5ffd
movq %rax, %r15
leaq 0x60(%rsp), %rdi
callq 0x4898
jmp 0x600c
movq %rax, %r15
leaq 0x40(%rsp), %rdi
callq 0x4898
jmp 0x601b
movq %rax, %r15
movq %rsp, %rdi
callq 0x4898
jmp 0x6028
movq %rax, %r15
leaq 0x20(%rsp), %rdi
callq 0x4898
jmp 0x6039
jmp 0x6036
movq %rax, %r15
movq %r14, %rdi
callq 0x4898
movq %rbx, %rdi
callq 0x47e0
movq %r15, %rdi
callq 0x4750
nop
// File: /workspace/github_cpp_makefile_star2_O2/solaldunckel[P]webserv/srcs/Config/InputArgs.cpp
// Function: InputArgs::InputArgs(int, char**)
InputArgs::InputArgs(int argc, char **argv) : argc_(argc), argv_(argv), path_("./config/default.conf"), log_level_(INFO) {
  options_["h"];
  options_["-help"];
  options_["t"];
  options_["-test"];
  options_["u"];
  options_["-uri"];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r15
movl %esi, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x14918(%rip), %rsi     # 0x1c1ad
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x5328
movl $0x1, 0x30(%r15)
leaq 0x38(%r15), %r14
leaq 0x40(%r15), %rax
andl $0x0, 0x40(%r15)
andq $0x0, 0x48(%r15)
movq %rax, 0x50(%r15)
movq %rax, 0x58(%r15)
andq $0x0, 0x60(%r15)
leaq 0x15cc2(%rip), %rsi     # 0x1d592
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5328
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x8168
leaq 0x10(%rsp), %rdi
callq 0x4898
leaq 0x148c6(%rip), %rsi     # 0x1c1c3
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5328
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x8168
leaq 0x10(%rsp), %rdi
callq 0x4898
leaq 0x15deb(%rip), %rsi     # 0x1d715
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5328
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x8168
leaq 0x10(%rsp), %rdi
callq 0x4898
leaq 0x14872(%rip), %rsi     # 0x1c1c9
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5328
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x8168
leaq 0x10(%rsp), %rdi
callq 0x4898
leaq 0x1484b(%rip), %rsi     # 0x1c1cf
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5328
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x8168
leaq 0x10(%rsp), %rdi
callq 0x4898
leaq 0x14820(%rip), %rsi     # 0x1c1d1
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5328
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x8168
leaq 0x10(%rsp), %rdi
callq 0x4898
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x79f5
jmp 0x7a04
jmp 0x79f5
jmp 0x7a04
jmp 0x79f5
jmp 0x7a04
jmp 0x79f5
jmp 0x7a04
jmp 0x79f5
jmp 0x7a04
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x4898
jmp 0x7a07
movq %rax, %r15
movq %r14, %rdi
callq 0x8258
movq %rbx, %rdi
callq 0x4898
movq %r15, %rdi
callq 0x4750
nop