LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2cf8e
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xacab(%rip), %rsi      # 0x37b5f
movl $0x3b, %edx
movq %rbx, %rdi
callq 0x7400
movl 0x20(%r14), %esi
movq %rbx, %rdi
callq 0x7670
movq %rax, %r15
leaq 0xacc4(%rip), %rsi      # 0x37b9b
movl $0x9, %edx
movq %rax, %rdi
callq 0x7400
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x7350
movsbl %al, %esi
movq %r15, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7260
movq 0x1d8(%r14), %r12
cmpq 0x1e0(%r14), %r12
je 0x2cf85
leaq 0x90f6(%rip), %r15      # 0x36018
movq (%r12), %r13
cmpq 0x8(%r12), %r13
je 0x2cf51
movsd (%r13), %xmm0
movq %rbx, %rdi
callq 0x75c0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x7400
addq $0x8, %r13
jmp 0x2cf26
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7350
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7260
addq $0x18, %r12
cmpq 0x1e0(%r14), %r12
jne 0x2cf22
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e4ba
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x263dc
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7350
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7260
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2e4ba
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x263dc
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7350
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x7260
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x23620
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7240
movb $0x9, %bpl
leaq 0x3(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x7400
movl 0x20(%r15), %esi
movq %rbx, %rdi
callq 0x7670
leaq 0x4(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x7400
movq %r14, %rdi
callq 0x2361c
testl %eax, %eax
leaq 0x9e44(%rip), %rax      # 0x3836b
leaq 0x84cc(%rip), %rsi      # 0x369fa
cmoveq %rax, %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x7400
leaq 0x5(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x7400
movq %r14, %rdi
callq 0x263d2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7240
leaq 0x6(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x7400
movq %r14, %rdi
callq 0x263d6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7240
leaq 0x7(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x7400
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x50(%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 0x2e7a1
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm1, %xmm1
movaps %xmm1, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x2e618
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x2e625
movq %rsp, %rdi
leaq 0x50(%rsp), %rdx
callq 0x1cf54
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x2e646
movsd 0x40(%rsp), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x2e653
movq %rsp, %rdi
leaq 0x40(%rsp), %rdx
callq 0x1cf54
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x2e674
movsd 0x38(%rsp), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x2e681
movq %rsp, %rdi
leaq 0x38(%rsp), %rdx
callq 0x1cf54
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x2e6a2
movsd 0x30(%rsp), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x2e6af
movq %rsp, %rdi
leaq 0x30(%rsp), %rdx
callq 0x1cf54
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x2e6d0
movsd 0x28(%rsp), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x2e6dd
movq %rsp, %rdi
leaq 0x28(%rsp), %rdx
callq 0x1cf54
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x2e6fe
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x2e70b
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x1cf54
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x2e72c
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x2e739
movq %rsp, %rdi
leaq 0x18(%rsp), %rdx
callq 0x1cf54
testb %bpl, %bpl
jne 0x2e743
xorps %xmm0, %xmm0
jmp 0x2e74b
movsd 0x68cd(%rip), %xmm0     # 0x35018
movsd %xmm0, 0x48(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x2e76c
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x2e779
movq %rsp, %rdi
leaq 0x48(%rsp), %rdx
callq 0x1d110
addq $0x1d8, %rbx            # imm = 0x1D8
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2e862
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2e7a1
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x7390
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
jmp 0x2e7aa
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2e7c3
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x7390
movq %rbx, %rdi
callq 0x76a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ece6
callq 0x7230
movq %rax, %rbx
callq 0x2ee55
callq 0x7230
subq %rbx, %rax
cvtsi2ss %rax, %xmm0
divss 0x8f5d(%rip), %xmm0     # 0x37c30
cvtss2sd %xmm0, %xmm0
leaq 0x8f56(%rip), %rdi      # 0x37c34
movb $0x1, %al
popq %rbx
jmp 0x7060
// File: /workspace/github_cpp_makefile_star2_O1/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 0x74c0
leal -0x1(%r14), %eax
cmpl $0x1, %eax
ja 0x31f2c
leaq 0x5d33(%rip), %rsi      # 0x37c50
movq %rsp, %rdi
movl $0x3, %edx
callq 0x7400
jmp 0x31f60
cmpl $0x3, %r14d
jne 0x31f48
leaq 0x5d1b(%rip), %rsi      # 0x37c54
movq %rsp, %rdi
movl $0x6, %edx
callq 0x7400
jmp 0x31f6b
leaq 0x5d05(%rip), %rsi      # 0x37c54
movq %rsp, %rdi
movl $0x6, %edx
callq 0x7400
addl $-0x3, %r14d
movq %rsp, %rdi
movl %r14d, %esi
callq 0x7670
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x75a0
movq 0x17009(%rip), %rsi     # 0x48f88
movq %rsp, %rdi
callq 0x71c0
leaq 0x70(%rsp), %rdi
callq 0x7120
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x16fdf(%rip), %rsi     # 0x48f88
movq %rsp, %rdi
callq 0x71c0
leaq 0x70(%rsp), %rdi
callq 0x7120
movq %rbx, %rdi
callq 0x76a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x61fd(%rip), %rsi      # 0x3821f
leaq 0x6206(%rip), %rdx      # 0x3822f
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0xa886
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xa916
leaq 0x60b6(%rip), %rsi      # 0x3810f
movq %rsp, %rdi
callq 0x76f0
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x76f0
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x32093
movq %rdx, 0x40(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x50(%rsp)
jmp 0x3209a
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x40(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x6052(%rip), %rsi      # 0x3810f
callq 0x76f0
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x320e9
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x320f1
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x28(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x20(%rsp), %rdi
callq 0x7300
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x3212a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7390
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x32141
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x7390
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x32157
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7390
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x3216e
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x7390
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x3219e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7390
jmp 0x3219e
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x321bc
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x7390
jmp 0x321bc
jmp 0x321b9
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x321d7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7390
jmp 0x321d7
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x321ee
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x7390
movq %rbx, %rdi
callq 0x76a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r15
leaq 0xce80(%rip), %rax      # 0x10d18
movq %rax, (%rdi)
leaq 0x58(%rdi), %rbx
leaq 0x68(%rdi), %r13
movq %r13, 0x58(%rdi)
xorl %eax, %eax
movq %rax, 0x60(%rdi)
movb $0x0, 0x68(%rdi)
leaq 0x80(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rdi)
movq %rax, 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)
movl $0x78, %edi
callq 0x32e0
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)
movq $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 0x6990
movl $0x2, %ebp
movq %rsp, %r12
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
callq 0x3480
movsd 0x8069(%rip), %xmm1     # 0xc010
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movq 0x88(%r15), %rsi
cmpq 0x90(%r15), %rsi
je 0x3fd1
movsd %xmm1, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x88(%r15)
jmp 0x3fdc
movq %r14, %rdi
movq %r12, %rdx
callq 0x8aaa
incl %ebp
cmpl $0x138a, %ebp           # imm = 0x138A
jne 0x3f93
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ff7
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4007
callq 0x32a0
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x4014
callq 0x32a0
movq %r15, %rdi
callq 0x3470
// File: /workspace/github_cpp_makefile_star2_O1/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 (%rsi), %rsi
cmpq %rsi, 0x8(%rbx)
je 0x407e
movq %rdi, %r14
xorl %r15d, %r15d
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
xorl %r13d, %r13d
addq %r15, %rsi
cmpb $0x1, 0x78(%r14)
jne 0x4058
movq %r14, %rdi
callq 0x4088
jmp 0x4060
movq %r14, %rdi
callq 0x47f2
incq %r13
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x3, %rax
imulq %r12, %rax
addq $0x18, %r15
cmpq %r13, %rax
ja 0x4044
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, 0x8(%rsp)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x5, %rax
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r13
movq $0x0, 0x48(%rdx)
testl %r13d, %r13d
jle 0x4b7f
movq %rsi, %r15
movl %r13d, %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %ebp, %ebp
xorl %r14d, %r14d
movq (%r15), %rax
movb (%rax,%rbp), %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq (%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
cmpq $0x1387, %r14           # imm = 0x1387
ja 0x4b2e
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rax
movsd (%rax,%r14,8), %xmm1
jmp 0x4b57
leal 0x2(%r14), %eax
movsd %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
callq 0x3480
movsd 0x74c3(%rip), %xmm1     # 0xc010
divsd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm0, %xmm1
movq 0x18(%rbx), %rax
movsd %xmm1, (%rax,%r14,8)
addsd 0x48(%rbx), %xmm1
movsd %xmm1, 0x48(%rbx)
incq %r14
addq $0x60, %rbp
cmpq %r14, %r12
jne 0x4af2
leaq 0x30(%rbx), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x8f90
movq $0x0, 0x50(%rbx)
movq 0x30(%rbx), %r15
movq 0x38(%rbx), %r12
cmpq %r12, %r15
je 0x4bd1
movq %r12, %rax
subq %r15, %rax
sarq $0x3, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x9081
movq %r15, %rdi
movq %r12, %rsi
callq 0x917a
testl %r13d, %r13d
jle 0x4c3c
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
cmpq $0x1387, %r14           # imm = 0x1387
ja 0x4bfd
movq 0x8(%rsp), %rax
movq 0x80(%rax), %rax
movsd (%rax,%r14,8), %xmm1
jmp 0x4c1a
leal 0x2(%r14), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
callq 0x3480
movsd 0x73fa(%rip), %xmm1     # 0xc010
divsd %xmm0, %xmm1
movq 0x30(%rbx), %rax
mulsd (%rax,%r14,8), %xmm1
movsd %xmm1, (%rax,%r14,8)
addsd 0x50(%rbx), %xmm1
movsd %xmm1, 0x50(%rbx)
incq %r14
cmpq %r14, %r13
jne 0x4be0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %rbx
movl %edi, %r14d
leaq 0xe89(%rip), %rsi       # 0x2010
leaq -0x110(%rbp), %rdi
movl $0x100, %edx            # imm = 0x100
callq 0x1030
cmpl $0x2, %r14d
jl 0x11a4
movq 0x8(%rbx), %rsi
jmp 0x11ab
leaq 0xf65(%rip), %rsi       # 0x2110
leaq -0x110(%rbp), %rbx
movq %rbx, %rdi
callq 0x1060
leaq 0xf79(%rip), %rdi       # 0x213a
callq 0x1050
movq %rbx, %rdi
callq 0x1040
leaq 0xf79(%rip), %rdi       # 0x214e
callq 0x1050
leaq 0xf4b(%rip), %rdi       # 0x212c
callq 0x1040
leaq 0xf74(%rip), %rdi       # 0x2161
callq 0x1050
xorl %eax, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x88, %rsp
movl $0x2, %edi
callq 0x2170
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, 0x70(%rbx)
movaps %xmm0, 0x60(%rbx)
movaps %xmm0, 0x50(%rbx)
movaps %xmm0, 0x40(%rbx)
movaps %xmm0, 0x30(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
leaq 0x2d25(%rip), %r14      # 0x6018
movl 0x4edb(%rip), %edi      # 0x81d4
movl $0x7f, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x2090
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2050
movl $0xa, %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 $0x2, %edi
callq 0x2170
jmp 0x32f3
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x58(%rax)
movq %rax, %rsi
callq 0x9fd8
movq %rax, %rbx
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x3aa2(%rip), %rsi      # 0xdd3b
leaq 0x3a9f(%rip), %rdx      # 0xdd3f
movq %rsp, %rdi
callq 0xa888
movq 0x28(%r15), %r15
testq %r15, %r15
je 0xa2e7
movq %rsp, %r12
movq 0x38(%r15), %rsi
addq $0x10, %rsi
movq %r12, %rdi
callq 0x40d0
testl %eax, %eax
jne 0xa2de
movq %r14, %rdi
movq %r15, %rsi
callq 0xa262
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb33e
movq 0x48(%r15), %r15
testq %r15, %r15
jne 0xa2b4
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xa2fd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4250
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xa327
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4250
movq %rbx, %rdi
callq 0x4410
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5f10
movq %r15, %rdi
xorl %esi, %esi
callq 0x6174
testb %al, %al
je 0xa47e
movq %rsp, %rsi
movq %r14, %rdi
callq 0xa330
movq %rax, %r14
jmp 0xa492
leaq 0x38ed(%rip), %rdi      # 0xdd72
xorl %r14d, %r14d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4080
movq %rsp, %rdi
callq 0x9bac
movq %r14, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9bac
movq %rbx, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movsd %xmm1, 0x18(%rsp)
movq %r8, %r12
movq %rcx, %rbp
movsd %xmm0, 0x20(%rsp)
movq %rdi, %rbx
addq $0x8, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x18(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rcx
movq %rcx, (%rsp)
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movb %al, 0x38(%rbx)
leaq 0x48(%rbx), %r13
leaq 0x58(%rbx), %r14
movq %r14, 0x48(%rbx)
movq %rax, 0x50(%rbx)
movb %al, 0x58(%rbx)
leaq 0x70(%rbx), %rcx
movq %rcx, 0x8(%rsp)
movups %xmm0, 0x70(%rbx)
movq %rax, 0x80(%rbx)
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
movsd %xmm0, (%rbx)
movq %rdi, 0x10(%rsp)
movq %rdx, %rsi
callq 0xa762
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rbx)
movq %r15, %rdi
movq %rbp, %rsi
callq 0x4160
movq %r13, %rdi
movq %r12, %rsi
callq 0x4160
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x68(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq 0x8(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb2f0
movq 0x80(%rbx), %rsi
subq %rdi, %rsi
callq 0x4250
movq (%r13), %rdi
cmpq %r14, %rdi
je 0xb304
movq (%r14), %rsi
incq %rsi
callq 0x4250
movq (%r15), %rdi
cmpq (%rsp), %rdi
je 0xb31c
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4250
movq 0x10(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb335
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x4250
movq %r12, %rdi
callq 0x4410
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x10(%rdi)
testq %rdx, %rdx
je 0xba9d
movq %rdx, %r15
movq %rsi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xbffa
cmpq $0x0, (%r14)
jne 0xba52
movq %r15, (%r14)
xorl %r12d, %r12d
movq %rsp, %r15
movq (%r14), %rax
movq 0x8(%rax), %rcx
movsd (%rcx,%r12,8), %xmm0
divsd 0x20(%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xba87
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xba92
movq %rbx, %rdi
movq %r15, %rdx
callq 0xc3b6
incq %r12
cmpq $0x5, %r12
jne 0xba58
jmp 0xbab4
movq %rsp, %rdx
movq $0x0, (%rdx)
movl $0x5, %esi
movq %rbx, %rdi
callq 0xa72e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xbac7
jmp 0xbac7
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xbade
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x4250
movq %r14, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc001
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x70(%rsi), %rax
cmpq %rax, 0x78(%rsi)
je 0xc051
xorl %r12d, %r12d
movq (%rax,%r12,8), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xc066
testb %al, %al
je 0xc03a
movq %r14, %rdi
movq %r15, %rsi
callq 0xbffa
incq %r12
movq 0x70(%rbx), %rax
movq 0x78(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
ja 0xc01c
cmpq $0x0, (%r14)
jne 0xc05a
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x28(%rsi), %rsi
movq 0x30(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0xc212
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc10a
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xc0bb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4250
leaq 0x20(%rbx), %rdi
leaq 0x48(%r14), %rsi
callq 0xc196
movsd 0x68(%r14), %xmm0
movslq %ebp, %rcx
movq 0x8(%rbx), %rdx
movsd (%rdx,%rcx,8), %xmm1
callq *(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xc102
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4250
movq %rbx, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a1cc
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x6bac
leaq 0x38(%rbx), %r13
movq %r13, 0x28(%rbx)
movq $0x0, 0x30(%rbx)
movb $0x0, 0x38(%rbx)
movl $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 0x4310
movl %eax, 0x20(%rbx)
testl %eax, %eax
js 0x5a82
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x41d0
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x1f5e1(%rip), %rsi     # 0x25080
leaq 0x1f5ff(%rip), %rdx     # 0x250a5
leaq 0x28(%rsp), %rdi
callq 0x578e
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x6bac
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x6542
xorl %ebp, %ebp
leaq 0x2c213(%rip), %rsi     # 0x31d00
leaq 0xe68(%rip), %rdx       # 0x695c
movq %r14, %rdi
callq 0x4750
movq %rax, %r15
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5b23
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4460
jmp 0x5b23
movq %rax, %r15
movb $0x1, %bpl
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x5b47
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4460
jmp 0x5b47
movq %rax, %r15
movb $0x1, %bpl
testb %bpl, %bpl
je 0x5b59
movq %r14, %rdi
callq 0x4300
jmp 0x5b59
movq %rax, %r15
leaq 0x48(%rbx), %r14
leaq 0x60(%rbx), %rdi
callq 0x6976
movq %r14, %rdi
callq 0x69ba
movq 0x28(%rbx), %rdi
cmpq %r13, %rdi
je 0x5b83
movq (%r13), %rsi
incq %rsi
callq 0x4460
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x5b97
movq (%r12), %rsi
incq %rsi
callq 0x4460
movq %r15, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5c0d
callq 0x4840
movl $0x0, 0x20(%rbx)
leaq 0x48(%rbx), %rdi
movq 0x48(%rbx), %rsi
callq 0x6c7c
movq $0x0, 0x30(%rbx)
movq 0x28(%rbx), %rax
movb $0x0, (%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r15
movl %esi, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %r12
movq %r12, 0x10(%rdi)
leaq 0x1cde2(%rip), %rsi     # 0x251c3
leaq 0x1cdf0(%rip), %rdx     # 0x251d8
movq %rbx, %rdi
callq 0x578e
movl $0x1, 0x30(%r15)
leaq 0x38(%r15), %r14
leaq 0x40(%r15), %rax
movl $0x0, 0x40(%r15)
xorl %ecx, %ecx
movq %rcx, 0x48(%r15)
movq %rax, 0x50(%r15)
movq %rax, 0x58(%r15)
movq %rcx, 0x60(%r15)
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1e1b8(%rip), %rsi     # 0x265e2
leaq 0x1e1b2(%rip), %rdx     # 0x265e3
movq %rsp, %rdi
callq 0x578e
movq %rsp, %rsi
movq %r14, %rdi
callq 0x9024
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x845a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
movq %rsp, %rdi
movq %r13, (%rdi)
leaq 0x1cd72(%rip), %rsi     # 0x251d9
leaq 0x1cd70(%rip), %rdx     # 0x251de
callq 0x578e
movq %rsp, %rsi
movq %r14, %rdi
callq 0x9024
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x8494
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
movq %rsp, %rdi
movq %r13, (%rdi)
leaq 0x1e2c4(%rip), %rsi     # 0x26765
leaq 0x1e2be(%rip), %rdx     # 0x26766
callq 0x578e
movq %rsp, %rsi
movq %r14, %rdi
callq 0x9024
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x84ce
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
movq %rsp, %rdi
movq %r13, (%rdi)
leaq 0x1cd04(%rip), %rsi     # 0x251df
leaq 0x1cd02(%rip), %rdx     # 0x251e4
callq 0x578e
movq %rsp, %rsi
movq %r14, %rdi
callq 0x9024
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x8508
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
movq %rsp, %rdi
movq %r13, (%rdi)
leaq 0x1ccd0(%rip), %rsi     # 0x251e5
leaq 0x1ccca(%rip), %rdx     # 0x251e6
callq 0x578e
movq %rsp, %rsi
movq %r14, %rdi
callq 0x9024
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x8542
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
movq %rsp, %rdi
movq %r13, (%rdi)
leaq 0x1cc98(%rip), %rsi     # 0x251e7
leaq 0x1cc95(%rip), %rdx     # 0x251eb
callq 0x578e
movq %rsp, %rsi
movq %r14, %rdi
callq 0x9024
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x857c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x859e
jmp 0x85b9
jmp 0x859e
jmp 0x85b9
jmp 0x859e
jmp 0x85b9
jmp 0x859e
jmp 0x85b9
jmp 0x859e
jmp 0x85b9
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x85bc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4460
jmp 0x85bc
movq %rax, %r15
movq %r14, %rdi
callq 0x923c
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x85d8
movq (%r12), %rsi
incq %rsi
callq 0x4460
movq %r15, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/Config/InputArgs.cpp
// Function: InputArgs::helpText[abi:cxx11]()
std::string InputArgs::helpText() {
  std::string text = "";

  text += "Usage: webserv [options] [config_file]\n";
  text += "\nOptions: \n";
  text += "  -h, --help         : this help text\n";
  text += "  -l, --log [LEVEL]  : set log level (between 0 and 2)\n";
  text += "  -t, --test         : test config and exit\n";
  text += "  -u, --uri          : keep location uri on rooting (similar to nginx)";

  return text;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x1cde8(%rip), %rdx     # 0x25a78
movq %rdx, %rsi
callq 0x578e
leaq 0x1c599(%rip), %rsi     # 0x25238
movq %rbx, %rdi
callq 0x4830
leaq 0x1c5b2(%rip), %rsi     # 0x25260
movq %rbx, %rdi
callq 0x4830
leaq 0x1c5af(%rip), %rsi     # 0x2526c
movq %rbx, %rdi
callq 0x4830
leaq 0x1c5c7(%rip), %rsi     # 0x25293
movq %rbx, %rdi
callq 0x4830
leaq 0x1c5f0(%rip), %rsi     # 0x252cb
movq %rbx, %rdi
callq 0x4830
leaq 0x1c60e(%rip), %rsi     # 0x252f8
movq %rbx, %rdi
callq 0x4830
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x8d11
movq (%r15), %rsi
incq %rsi
callq 0x4460
movq %r14, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/Config/RequestConfig.cpp
// Function: RequestConfig::setup(InputArgs&)
void RequestConfig::setup(InputArgs &options) {
  ServerConfig *server = getServerForRequest(servers_);
  ServerConfig *location = NULL;

  if (request_.getStatus() > 2)
    location = getLocationForRequest(server, request_.target_);

  server_ = server;
  location_ = server;

  target_ = request_.target_;

  if (location) {
    location_ = location;
    if (!options.location() && request_.target_.find(location->uri_) != std::string::npos)
      target_.erase(0, location_->uri_.length());
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
callq 0x9824
movq %rax, %r15
movq (%rbx), %rdi
callq 0x122e8
cmpl $0x3, %eax
jl 0x97aa
movq (%rbx), %rdx
addq $0x40, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9b30
movq %rax, %r12
jmp 0x97ad
xorl %r12d, %r12d
movq %r15, 0x20(%rbx)
movq %r15, 0x28(%rbx)
movq (%rbx), %rsi
addq $0x40, %rsi
leaq 0x30(%rbx), %r15
movq %r15, %rdi
callq 0x4230
testq %r12, %r12
je 0x9818
movq %r12, 0x28(%rbx)
movq %r14, %rdi
callq 0x8f24
testb %al, %al
jne 0x9818
movq (%rbx), %rdi
addq $0x40, %rdi
movq 0x50(%r12), %rsi
movq 0x58(%r12), %rcx
xorl %edx, %edx
callq 0x4770
cmpq $-0x1, %rax
je 0x9818
movq 0x28(%rbx), %rax
movq 0x58(%rax), %rdx
movq %r15, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/Config/RequestConfig.cpp
// Function: RequestConfig::redirectLocation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void RequestConfig::redirectLocation(std::string target) {
  ServerConfig *location = NULL;

  if (request_.getStatus() > 2)
    location = getLocationForRequest(server_, target);

  target_ = target;
  if (location) {
    location_ = location;
    if (target_.find(location->uri_) != std::string::npos)
      target_.erase(0, location_->uri_.length());
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x122e8
cmpl $0x3, %eax
jl 0x9cff
movq 0x20(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x9b30
movq %rax, %r12
jmp 0x9d02
xorl %r12d, %r12d
leaq 0x30(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x4230
testq %r12, %r12
je 0x9d51
movq %r12, 0x28(%rbx)
movq 0x50(%r12), %rsi
movq 0x58(%r12), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x4770
cmpq $-0x1, %rax
je 0x9d51
movq 0x28(%rbx), %rax
movq 0x58(%rax), %rdx
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/Config/RequestConfig.cpp
// Function: RequestConfig::methodAccepted(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool RequestConfig::methodAccepted(std::string &method) {
  std::vector<std::string> methods = location_->methods_;

  if (methods.empty())
    return true;
  if (std::find(methods.begin(), methods.end(), method) != methods.end())
    return true;
  return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl $0xe8, %esi
addq 0x28(%rdi), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x799c
movq (%r14), %rdi
movq 0x8(%r14), %rsi
cmpq %rsi, %rdi
je 0x9e2c
movq %rbx, %rdx
callq 0xaf9b
cmpq 0x8(%rsp), %rax
setne %bl
jmp 0x9e2e
movb $0x1, %bl
movq %rsp, %rdi
callq 0x69ba
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x69ba
movq %rbx, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/Config/ServerConfig.cpp
// Function: ServerConfig::operator=(ServerConfig const&)
ServerConfig	&ServerConfig::operator=(const ServerConfig &copy) {
  client_max_body_size_ = copy.client_max_body_size_;
  root_ = copy.root_;
  error_codes_ = copy.error_codes_;
  index_ = copy.index_;
  cgi_ = copy.cgi_;
  cgi_bin_ = copy.cgi_bin_;
  autoindex_ = copy.autoindex_;
  credentials_ = copy.credentials_;
  return (*this);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0xa0(%rsi), %rax
movq %rax, 0xa0(%rdi)
movl $0xa8, %edi
addq %rdi, %rsi
addq %rbx, %rdi
callq 0x4230
movl $0x100, %edi            # imm = 0x100
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0xcf04
movl $0x130, %edi            # imm = 0x130
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0xcbac
movl $0x148, %edi            # imm = 0x148
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0xd1ce
movl $0x178, %edi            # imm = 0x178
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x4230
movb 0x98(%r14), %al
movb %al, 0x98(%rbx)
addq $0x78, %r14
leaq 0x78(%rbx), %rdi
movq %r14, %rsi
callq 0x4230
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/Config/ServerConfig.cpp
// Function: ServerConfig::error_page(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
void ServerConfig::error_page(std::vector<std::string>::iterator &it) {
  std::vector<int> codes;

  while (it->find_first_not_of("0123456789") == std::string::npos) {
    codes.push_back(ft::stoi(*it++));
  }
  for (std::vector<int>::iterator it2 = codes.begin(); it2 != codes.end(); it2++) {
    error_codes_[*it2] = *it;
  }
  if (*++it != ";")
    throw std::runtime_error("double value in 'listen'");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq (%rsi), %rdi
leaq 0x19142(%rip), %rsi     # 0x251f1
movl $0xa, %ecx
xorl %edx, %edx
callq 0x4720
cmpq $-0x1, %rax
jne 0xc126
movq %rsp, %r15
leaq 0x1c(%rsp), %r12
leaq 0x19121(%rip), %r13     # 0x251f1
movq (%rbx), %rdi
leaq 0x20(%rdi), %rax
movq %rax, (%rbx)
xorl %esi, %esi
movl $0xa, %edx
callq 0x244f4
movl %eax, 0x1c(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0xc103
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rsp)
jmp 0xc10e
movq %r15, %rdi
movq %r12, %rdx
callq 0xde44
movq (%rbx), %rdi
movl $0xa, %ecx
movq %r13, %rsi
xorl %edx, %edx
callq 0x4720
cmpq $-0x1, %rax
je 0xc0d0
movq (%rsp), %r15
cmpq 0x8(%rsp), %r15
je 0xc15c
addq $0x100, %r14            # imm = 0x100
movq (%rbx), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0xce24
movq %rax, %rdi
movq %r12, %rsi
callq 0x4230
addq $0x4, %r15
cmpq 0x8(%rsp), %r15
jne 0xc138
movq (%rbx), %rdi
addq $0x20, %rdi
movq %rdi, (%rbx)
leaq 0x1981e(%rip), %rsi     # 0x2598b
callq 0x40f0
testl %eax, %eax
jne 0xc19a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc18c
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4460
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x41d0
movq %rax, %r14
leaq 0x19292(%rip), %rsi     # 0x25440
movq %rax, %rdi
callq 0x4170
movq 0x25e33(%rip), %rsi     # 0x31ff0
movq 0x25de4(%rip), %rdx     # 0x31fa8
movq %r14, %rdi
callq 0x4750
jmp 0xc1dd
movq %rax, %rbx
movq %r14, %rdi
callq 0x4300
jmp 0xc1e0
jmp 0xc1dd
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc1f6
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4460
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/Config/ServerConfig.cpp
// Function: ServerConfig::client_max_body_size(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
void ServerConfig::client_max_body_size(std::vector<std::string>::iterator &it) {
  if (it->find_first_not_of("0123456789") != std::string::npos)
      throw std::runtime_error("unexpected symbols in client_max_body_size");
  client_max_body_size_ = ft::stoi(*it);
  if (*++it != ";")
    throw std::runtime_error("double value in 'client_max_body_size_'");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
leaq 0x18f65(%rip), %rsi     # 0x251f1
movl $0xa, %ecx
xorl %edx, %edx
callq 0x4720
cmpq $-0x1, %rax
jne 0xc2d8
movq (%rbx), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x244f4
cltq
movq %rax, 0xa0(%r14)
movq (%rbx), %rdi
addq $0x20, %rdi
movq %rdi, (%rbx)
leaq 0x196c4(%rip), %rsi     # 0x2598b
callq 0x40f0
testl %eax, %eax
jne 0xc2f6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x41d0
movq %rax, %rbx
leaq 0x1916d(%rip), %rsi     # 0x25459
movq %rax, %rdi
callq 0x4170
jmp 0xc312
movl $0x10, %edi
callq 0x41d0
movq %rax, %rbx
leaq 0x1917a(%rip), %rsi     # 0x25484
movq %rax, %rdi
callq 0x4170
movq 0x25cd7(%rip), %rsi     # 0x31ff0
movq 0x25c88(%rip), %rdx     # 0x31fa8
movq %rbx, %rdi
callq 0x4750
jmp 0xc32a
movq %rax, %r14
movq %rbx, %rdi
callq 0x4300
movq %r14, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O1/solaldunckel[P]webserv/srcs/Config/ServerConfig.cpp
// Function: ServerConfig::autoindex(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
void ServerConfig::autoindex(std::vector<std::string>::iterator &it) {
  if (*it == "on")
    autoindex_ = true;
  else if (*it == "off")
    autoindex_ = false;
  else
    throw std::runtime_error("unknown value in 'autoindex'");

  if (*++it != ";")
    throw std::runtime_error("double value in 'autoindex'");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
leaq 0x19cba(%rip), %rsi     # 0x260de
callq 0x40f0
testl %eax, %eax
je 0xc444
movq (%rbx), %rdi
leaq 0x19ce0(%rip), %rsi     # 0x26117
callq 0x40f0
testl %eax, %eax
jne 0xc48d
xorl %eax, %eax
jmp 0xc446
movb $0x1, %al
movb %al, 0x98(%r14)
movq (%rbx), %rdi
addq $0x20, %rdi
movq %rdi, (%rbx)
leaq 0x1952d(%rip), %rsi     # 0x2598b
callq 0x40f0
testl %eax, %eax
jne 0xc46f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x41d0
movq %rax, %rbx
leaq 0x19074(%rip), %rsi     # 0x254f7
movq %rax, %rdi
callq 0x4170
jmp 0xc4a9
movl $0x10, %edi
callq 0x41d0
movq %rax, %rbx
leaq 0x19039(%rip), %rsi     # 0x254da
movq %rax, %rdi
callq 0x4170
movq 0x25b40(%rip), %rsi     # 0x31ff0
movq 0x25af1(%rip), %rdx     # 0x31fa8
movq %rbx, %rdi
callq 0x4750
jmp 0xc4c1
movq %rax, %r14
movq %rbx, %rdi
callq 0x4300
movq %r14, %rdi
callq 0x4780