LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/simonrharris[P]SKA/src/kmers.cpp
// Function: extractMiddleBase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char&)
int extractMiddleBase(std::string & myString, char & myChar){
	float stringlen=(myString.length()-1)/2;
	float myremainder=::fmod((myString.length()-1),stringlen);
	if (myremainder>0){
		return 1;
	}
	myChar=myString[stringlen];
	myString.erase(myString.begin()+stringlen);
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
decq %rax
movq %rax, %xmm1
shrq %rax
cvtsi2ss %rax, %xmm2
punpckldq 0x2a8ec(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x2a8f4(%rip), %xmm1    # 0x333b0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movaps %xmm2, (%rsp)
xorps %xmm1, %xmm1
cvtss2sd %xmm2, %xmm1
callq 0x54d0
cvtsd2ss %xmm0, %xmm0
movl $0x1, %eax
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
ja 0x8b29
movaps (%rsp), %xmm0
cvttss2si %xmm0, %rax
movq %rax, %rcx
cvttss2si %xmm0, %rsi
subss 0x2a506(%rip), %xmm0    # 0x33008
sarq $0x3f, %rcx
cvttss2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq (%rbx), %rax
movb (%rax,%rdx), %al
movb %al, (%r14)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x5450
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/simonrharris[P]SKA/src/kmers.cpp
// Function: readKmerHeader(std::basic_ifstream<char, std::char_traits<char>>&, int&, 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>>>>&)
int readKmerHeader(std::ifstream & fileStream, int & kmersize, std::vector < std::string > & names){
	
	std::string line;
	std::getline(fileStream, line);
	fileStream >> kmersize;
	if (kmersize==0){
		return 1;
	}

	std::string name;
	std::getline(fileStream, line);
	std::getline(fileStream, line);

	std::istringstream ss(line);
	while(ss >> name){
		names.push_back(name);
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %edx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x56c0
movq %r14, %rdi
movq %r15, %rsi
callq 0x5210
cmpl $0x0, (%r15)
je 0x97c1
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %edx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x56c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %edx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x56c0
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
movl $0x8, %edx
callq 0x5650
leaq 0x40(%rsp), %r14
leaq 0x20(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5490
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x9788
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8528
jmp 0x9762
movq 0x37829(%rip), %rsi     # 0x40fb8
leaq 0x40(%rsp), %rdi
callq 0x5540
leaq 0xb8(%rsp), %rdi
callq 0x5120
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x97bd
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x53c0
xorl %ebx, %ebx
jmp 0x97c6
movl $0x1, %ebx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x97dc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
movl %ebx, %eax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x97f1
movq %rax, %rbx
jmp 0x981c
movq %rax, %rbx
jmp 0x9833
movq %rax, %rbx
movq 0x377b3(%rip), %rsi     # 0x40fb8
leaq 0x40(%rsp), %rdi
callq 0x5540
leaq 0xb8(%rsp), %rdi
callq 0x5120
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x9833
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x53c0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x9849
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O3/simonrharris[P]SKA/src/kmers.cpp
// Function: addKmerToBaseArrayMap(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::array<int, 8ul>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::array<int, 8ul>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, bool)
void addKmerToBaseArrayMap(std::unordered_map < std::string, std::array < int, 8 > > & kmerMap, const std::string & kmer, const char base, const bool firstFile){

	std::unordered_map < std::string, std::array < int, 8 > >::iterator it = kmerMap.find(kmer);//check if the kmer is in the hash
	if ( it != kmerMap.end() ){//if the kmer is in the hash
		it->second[base_score[int(base)]]++;//increment the count of the base for the kmer
	}
	else if (firstFile) {//if the kmers isn't in the hash and we are adding from the first fastq file
		std::pair < std::unordered_map < std::string, std::array < int, 8 > >::iterator,bool>  ret = kmerMap.insert(std::make_pair(kmer, std::array < int, 8 > ()));//insert the kmer into the hash
		ret.first->second[base_score[int(base)]]=1;//increment the count of the base for the kmer
	}
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0xbb8c
testq %rax, %rax
je 0xa254
movsbq %bl, %rcx
leaq 0x371f7(%rip), %rdx     # 0x41440
movsbq (%rdx,%rcx), %rcx
incl 0x28(%rax,%rcx,4)
jmp 0xa2c2
testb %bpl, %bpl
je 0xa2c2
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x8566
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r15)
movups %xmm0, 0x20(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0xbc88
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xa2a9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
movsbq %bl, %rax
leaq 0x3718c(%rip), %rcx     # 0x41440
movsbq (%rcx,%rax), %rax
movl $0x1, 0x28(%r14,%rax,4)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xa2e8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O3/simonrharris[P]SKA/src/kmers.cpp
// Function: applyFileKmerArrayMapFilters(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::array<int, 8ul>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::array<int, 8ul>>>>&, int const&)
void applyFileKmerArrayMapFilters(std::unordered_map < std::string, std::array < int, 8 > > & kmerMap, const int & userfilecutoff){

	std::cout << "Filtering kmers for file coverage" << std::endl;

	int filebasecoverage;
	int maxfilebasecoverage;
	float filecovcutoff;

	std::unordered_map < std::string, std::array < int, 8 > >::iterator it = kmerMap.begin();
	std::unordered_map < std::string, std::array < int, 8 > >::iterator endIter = kmerMap.end();
	for (; it!=endIter; ){

		//calculate the total file kmer coverage and remove the kmer if it is below the minimum cutoff
		filebasecoverage=0;
		maxfilebasecoverage=0;
		for (std::array < int, 8 >::iterator it2=it->second.begin(); it2!=it->second.begin()+4; ++it2){
			filebasecoverage+=*it2;
			if (*it2>maxfilebasecoverage){
				maxfilebasecoverage=*it2;
			}
		}

		if (filebasecoverage<userfilecutoff){
			kmerMap.erase(it++);
		}
		else {
			int j=4;
			for (int i=0; i<4; ++i, ++j){
				it->second[j]+=it->second[i];
				it->second[i]=0;
			}
			++it;
		}

	}
	std::cout << kmerMap.size() << " unique kmers in map after filtering" << std::endl;
	//return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x36cbe(%rip), %r15     # 0x40fc0
leaq 0x2929d(%rip), %rsi     # 0x335a6
movl $0x21, %edx
movq %r15, %rdi
callq 0x5420
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5250
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0xa397
movdqu 0x28(%rsi), %xmm0
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddd %xmm0, %xmm1
pshufd $0x55, %xmm1, %xmm0     # xmm0 = xmm1[1,1,1,1]
paddd %xmm1, %xmm0
movd %xmm0, %eax
cmpl (%r14), %eax
jge 0xa376
movq (%rsi), %r15
movq %rbx, %rdi
callq 0xbfc6
movq %r15, %rsi
jmp 0xa341
movdqu 0x28(%rsi), %xmm0
movdqu 0x38(%rsi), %xmm1
paddd %xmm0, %xmm1
movdqu %xmm1, 0x38(%rsi)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x28(%rsi)
movq (%rsi), %rsi
jmp 0xa341
movq 0x18(%rbx), %rsi
movq 0x36c1e(%rip), %rdi     # 0x40fc0
callq 0x5240
movq %rax, %rbx
leaq 0x29217(%rip), %rsi     # 0x335c8
movl $0x24, %edx
movq %rax, %rdi
callq 0x5420
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5250
// File: /workspace/github_cpp_makefile_star2_O3/simonrharris[P]SKA/src/sk_alleles.cpp
// Function: addKmerToStringMap(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, int, int)
void addKmerToStringMap(std::unordered_map < std::string, std::string > & myKmerMap, const std::string & myKmer, const char myBase, const int alleleNumber, const int alleleCount){
	std::unordered_map < std::string, std::string >::iterator kmit = myKmerMap.find(myKmer);//check if the kmer is in the hash				
	if ( kmit != myKmerMap.end() ){//if the kmer is in the hash
		if (kmit->second[alleleNumber]=='-'){
			kmit->second[alleleNumber]=myBase;//add the base to the correct sample
		}
		else if (kmit->second[alleleNumber]!=myBase){
			kmit->second[alleleNumber]='N';//change to N if it's a repeat
		}
	}
	else {//if the kmers isn't in the hash
		std::pair < std::unordered_map < std::string, std::string >::iterator, bool > ret = myKmerMap.insert(std::make_pair(myKmer, std::string(alleleCount , '-')));//insert the kmer into the hash
		ret.first->second[alleleNumber]=myBase;//add the base to the correct sample
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %r12d
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0xb6d2
testq %rax, %rax
je 0xe3fa
movslq %ebp, %rcx
movq 0x28(%rax), %rax
movb (%rax,%rcx), %dl
cmpb $0x2d, %dl
jne 0xe491
movb %bl, (%rax,%rcx)
jmp 0xe499
movslq %r12d, %rsi
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movl $0x2d, %edx
callq 0x5440
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xaccc
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0xb7ea
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe453
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x53c0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe46e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53c0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xe485
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53c0
movslq %ebp, %rax
movq 0x28(%r14), %rcx
movb %bl, (%rcx,%rax)
jmp 0xe499
cmpb %bl, %dl
je 0xe499
movb $0x4e, (%rax,%rcx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xaaf0
jmp 0xe4ba
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xe4d1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53c0
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O3/simonrharris[P]SKA/src/sk_find.cpp
// Function: getGeneticCode[abi:cxx11](int)
std::unordered_map < std::string, char > getGeneticCode(int translationTable){

	std::unordered_map < std::string, char > myGeneticCode=geneticCode;

	if (translationTable==4){
		myGeneticCode.insert(std::make_pair( "TGA", 'W' ));
		
	}
	return myGeneticCode;


}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, (%rdi)
leaq 0x2d2e3(%rip), %rsi     # 0x41540
movq 0x2d2e4(%rip), %rcx     # 0x41548
movq %rcx, 0x8(%rdi)
movq %rax, 0x10(%rdi)
movq 0x2d2e5(%rip), %rcx     # 0x41558
movq %rcx, 0x18(%rdi)
movups 0x2d2e2(%rip), %xmm0    # 0x41560
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
movq %rsp, %rdx
movq %rdi, (%rdx)
callq 0x185b4
cmpl $0x4, %ebp
jne 0x142af
leaq 0x1fa29(%rip), %rax     # 0x33cc6
movq %rsp, %rsi
movq %rax, (%rsi)
movb $0x57, 0x8(%rsi)
movq %rbx, %rdi
callq 0x189f4
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x10058
movq %r14, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O3/simonrharris[P]SKA/src/sk_refalign.cpp
// Function: addKmerToBasePositionMap(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<int, std::allocator<int>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<int, std::allocator<int>>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void addKmerToBasePositionMap(std::unordered_map < std::string, std::vector <int> > & myKmerMap, const std::string & myKmer, const int myPosition){
	std::unordered_map < std::string, std::vector <int> >::iterator it = myKmerMap.find(myKmer);//check if the kmer is in the hash
	if ( it != myKmerMap.end() ){//if the kmer is in the hash
		it->second.push_back(myPosition);//add the location of the match to the map
	}
	else {
		myKmerMap.insert(std::make_pair(myKmer, std::vector < int > {myPosition}));
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, 0xc(%rsp)
callq 0x18d28
testq %rax, %rax
je 0x1b8bd
movq 0x30(%rax), %rsi
cmpq 0x38(%rax), %rsi
je 0x1b96c
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x30(%rax)
jmp 0x1b97d
leaq 0x2c(%rsp), %rsi
movl %ebp, (%rsi)
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rcx
movl $0x1, %edx
callq 0x1d66a
leaq 0x40(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %rdi
callq 0x8566
movaps 0x10(%rsp), %xmm0
leaq 0x30(%rsp), %rsi
movups %xmm0, 0x20(%rsi)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsi)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq %rbx, %rdi
callq 0x18e24
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1b93c
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x1b953
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b97d
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
jmp 0x1b97d
addq $0x28, %rax
leaq 0xc(%rsp), %rdx
movq %rax, %rdi
callq 0xdeae
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x18280
jmp 0x1b99a
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b9b1
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O3/simonrharris[P]SKA/src/ska.cpp
// Function: getint(char*)
long int getint(char * arg){
	long int i;
	char * pEnd;i=strtol(arg, &pEnd, 10);
	if(*pEnd != '\0'){
    	throw std::invalid_argument( "received non integer" );
  	}
  	return i;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsp, %rbx
movq %rbx, %rsi
movl $0xa, %edx
callq 0x5510
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
jne 0x25d20
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0xecdc(%rip), %rsi      # 0x34a10
movq %rax, %rdi
callq 0x5700
movq 0x1b295(%rip), %rsi     # 0x40fd8
movq 0x1b27e(%rip), %rdx     # 0x40fc8
movq %rbx, %rdi
callq 0x5680
movq %rax, %r14
movq %rbx, %rdi
callq 0x52b0
movq %r14, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O3/simonrharris[P]SKA/src/ska.cpp
// Function: getfloat(char*)
float getfloat(char * arg){
	float f;
	char * pEnd;f=strtof(arg, &pEnd);
	if(*pEnd != '\0'){
    	throw std::invalid_argument( "received non float" );
  	}
  	return f;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x54c0
movq (%rbx), %rax
cmpb $0x0, (%rax)
jne 0x25d84
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0xec8d(%rip), %rsi      # 0x34a25
movq %rax, %rdi
callq 0x5700
movq 0x1b231(%rip), %rsi     # 0x40fd8
movq 0x1b21a(%rip), %rdx     # 0x40fc8
movq %rbx, %rdi
callq 0x5680
movq %rax, %r14
movq %rbx, %rdi
callq 0x52b0
movq %r14, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O3/PepiJK[P]Mail-Server-Client/src/myhelper/myhelper.cpp
// Function: MyHelper::filesInDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int MyHelper::filesInDirectory(string fullDir)
{
    int amountOfFiles = 0;
    dir = opendir(fullDir.c_str());

    while ((dirent = readdir(dir)) != NULL)
    {
        buffer = dirent->d_name;
        if (buffer != "." && buffer != "..")
        {
            amountOfFiles++;
        }
    }
    closedir(dir);
    return amountOfFiles;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x33f0
movq %rax, 0x8(%rbx)
movq %rax, %rdi
callq 0x3400
movq %rax, (%rbx)
testq %rax, %rax
je 0x3de3
movq %rax, %rbp
leaq 0x10(%rbx), %r15
xorl %r14d, %r14d
leaq 0x44f1(%rip), %r12      # 0x8276
addq $0x13, %rbp
movq 0x18(%rbx), %r13
movq %rbp, %rdi
callq 0x3150
movq %r15, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %rbp, %rcx
movq %rax, %r8
callq 0x3420
movq %r15, %rdi
movq %r12, %rsi
callq 0x30d0
testl %eax, %eax
je 0x3dcd
movq %r15, %rdi
leaq 0x44b4(%rip), %rsi      # 0x8275
callq 0x30d0
cmpl $0x1, %eax
sbbl $-0x1, %r14d
movq 0x8(%rbx), %rdi
callq 0x3400
movq %rax, %rbp
movq %rax, (%rbx)
testq %rax, %rax
jne 0x3d85
jmp 0x3de6
xorl %r14d, %r14d
movq 0x8(%rbx), %rdi
callq 0x3440
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/PepiJK[P]Mail-Server-Client/src/myhelper/myhelper.cpp
// Function: MyHelper::filenamesInDirecotry(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> MyHelper::filenamesInDirecotry(string fullDir)
{
    vector<string> files;
    dir = opendir(fullDir.c_str());

    while ((dirent = readdir(dir)) != NULL)
    {
        buffer = dirent->d_name;
        if (buffer != "." && buffer != "..")
        {
            files.push_back(buffer);
        }
    }
    closedir(dir);
    return files;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rdi
callq 0x33f0
movq %rax, %rdi
movq %rax, 0x8(%r14)
leaq 0x10(%r14), %r15
leaq 0x443b(%rip), %r12      # 0x8276
callq 0x3400
movq %rax, %rbp
movq %rax, (%r14)
testq %rax, %rax
je 0x3ea1
addq $0x13, %rbp
movq 0x18(%r14), %r13
movq %rbp, %rdi
callq 0x3150
movq %r15, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %rbp, %rcx
movq %rax, %r8
callq 0x3420
movq %r15, %rdi
movq %r12, %rsi
callq 0x30d0
testl %eax, %eax
je 0x3e9b
movq %r15, %rdi
leaq 0x43ee(%rip), %rsi      # 0x8275
callq 0x30d0
testl %eax, %eax
je 0x3e9b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x406a
movq 0x8(%r14), %rdi
jmp 0x3e3b
movq 0x8(%r14), %rdi
callq 0x3440
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x40a8
movq %r14, %rdi
callq 0x34a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/PepiJK[P]Mail-Server-Client/src/myhelper/myhelper.cpp
// Function: MyHelper::subjectsInDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> MyHelper::subjectsInDirectory(string fullDir)
{
    vector<string> files;
    dir = opendir(fullDir.c_str());

    while ((dirent = readdir(dir)) != NULL)
    {
        buffer = dirent->d_name;
        if (buffer != "." && buffer != "..")
        {
            buffer = buffer.substr(0, buffer.length() - 4);
            files.push_back(buffer);
        }
    }
    closedir(dir);
    return files;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, (%rsp)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rdi
callq 0x33f0
movq %rax, %rdi
movq %rax, 0x8(%r14)
leaq 0x10(%r14), %r15
leaq 0x4369(%rip), %r12      # 0x8276
leaq 0x8(%rsp), %rbp
callq 0x3400
movq %rax, %r13
movq %rax, (%r14)
testq %rax, %rax
je 0x3fbc
addq $0x13, %r13
movq 0x18(%r14), %rbx
movq %r13, %rdi
callq 0x3150
movq %r15, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r13, %rcx
movq %rax, %r8
callq 0x3420
movq %r15, %rdi
movq %r12, %rsi
callq 0x30d0
testl %eax, %eax
je 0x3fb3
movq %r15, %rdi
leaq 0x4313(%rip), %rsi      # 0x8275
callq 0x30d0
testl %eax, %eax
je 0x3fb3
movq 0x18(%r14), %rcx
addq $-0x4, %rcx
movq %rbp, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3310
movq %r15, %rdi
movq %rbp, %rsi
callq 0x3380
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3fa7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3300
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x406a
movq 0x8(%r14), %rdi
jmp 0x3f12
movq 0x8(%r14), %rdi
callq 0x3440
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3fda
movq %rax, %r14
movq (%rsp), %rdi
callq 0x40a8
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O3/PepiJK[P]Mail-Server-Client/src/mysocket/mysocket.cpp
// Function: MySocket::MySocket(int)
MySocket::MySocket(int port)
{
    memset(&address, 0, sizeof(address));
    address.sin_family = AF_INET;
    address.sin_port = htons(port);
    address.sin_addr.s_addr = INADDR_ANY;
}

// Assembly:
movq $0x0, 0x418(%rdi)
movw $0x2, 0x410(%rdi)
rolw $0x8, %si
movw %si, 0x412(%rdi)
movl $0x0, 0x414(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/PepiJK[P]Mail-Server-Client/src/mysocket/mysocket.cpp
// Function: MySocket::MySocket(char const*, int)
MySocket::MySocket(const char *addr, int port)
{
    memset(&address, 0, sizeof(address));
    address.sin_family = AF_INET;
    address.sin_port = htons(port);
    inet_aton(addr, &address.sin_addr);
}

// Assembly:
movq %rsi, %rax
leaq 0x414(%rdi), %rsi
movl $0x0, 0x41c(%rdi)
movq $0x0, 0x414(%rdi)
rolw $0x8, %dx
movw $0x2, 0x410(%rdi)
movw %dx, 0x412(%rdi)
movq %rax, %rdi
jmp 0x3220
nop
// File: /workspace/github_cpp_makefile_star2_O3/PepiJK[P]Mail-Server-Client/src/mysocket/mysocket.cpp
// Function: MySocket::acceptNewConnection()
int MySocket::acceptNewConnection()
{
    new_socket = accept(create_socket, (struct sockaddr *)&cliaddress, &addrlen);
    if (new_socket == -1)
    {
        socketError("accept error");
    }
    cout << "Client connected from " << inet_ntoa(cliaddress.sin_addr) << ":" << ntohs(cliaddress.sin_port) << endl;
    strcpy(buffer, "Welcome to myserver, Please enter your command:\0");
    if (send(new_socket, buffer, strlen(buffer), 0) == -1)
    {
        socketError("send error");
    }
    return new_socket;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
leaq 0x420(%rbx), %rsi
leaq 0xc(%rbx), %rdx
callq 0x30f0
movl %eax, 0x4(%rbx)
cmpl $-0x1, %eax
je 0x4734
movq 0x69ad(%rip), %r14      # 0xafd8
leaq 0x3adf(%rip), %rsi      # 0x8111
movl $0x16, %edx
movq %r14, %rdi
callq 0x3350
movl 0x424(%rbx), %edi
callq 0x3160
testq %rax, %rax
je 0x466e
movq %rax, %r15
movq %rax, %rdi
callq 0x3150
movq 0x6977(%rip), %rdi      # 0xafd8
movq %r15, %rsi
movq %rax, %rdx
callq 0x3350
jmp 0x4686
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x3470
movq 0x694b(%rip), %r14      # 0xafd8
leaq 0x3a94(%rip), %rsi      # 0x8128
movl $0x1, %edx
movq %r14, %rdi
callq 0x3350
movzwl 0x422(%rbx), %eax
rolw $0x8, %ax
movzwl %ax, %esi
movq %r14, %rdi
callq 0x31f0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3200
leaq 0x10(%rbx), %r14
movups 0x3a54(%rip), %xmm0     # 0x8140
movups %xmm0, 0x10(%rbx)
movups 0x3a59(%rip), %xmm0     # 0x8150
movups %xmm0, 0x20(%rbx)
movups 0x3a5e(%rip), %xmm0     # 0x8160
movups %xmm0, 0x30(%rbx)
movl 0x4(%rbx), %ebp
movq %r14, %rdi
callq 0x3150
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31a0
cmpq $-0x1, %rax
je 0x4739
movl 0x4(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x35af
callq 0x359a
// File: /workspace/github_cpp_makefile_star2_O3/PepiJK[P]Mail-Server-Client/src/mysocket/mysocket.cpp
// Function: MySocket::recvMessage(int)
const char *MySocket::recvMessage(int socket)
{
    if (socket == -1)
    {
        // client
        size = recv(create_socket, buffer, BUF - 1, 0);
    }
    else
    {
        // server
        size = recv(socket, buffer, BUF - 1, 0);
    }

    if (size == -1)
    {
        socketError("recv error");
    }
    else if (size == 0)
    {
        return "QUIT\n\0";
    }
    buffer[size] = '\0';
    return buffer;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $-0x1, %esi
jne 0x474c
movl (%rbx), %esi
leaq 0x10(%rbx), %r14
movl $0x3ff, %edx            # imm = 0x3FF
movl %esi, %edi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3100
movl %eax, 0x8(%rbx)
testl %eax, %eax
je 0x4776
cmpl $-0x1, %eax
je 0x4788
cltq
movb $0x0, 0x10(%rbx,%rax)
jmp 0x477d
leaq 0x39f4(%rip), %r14      # 0x8171
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x35c4
nop
// File: /workspace/github_cpp_makefile_star2_O3/PepiJK[P]Mail-Server-Client/src/mysocket/mysocket.cpp
// Function: MySocket::sendMessage(char const*, int)
void MySocket::sendMessage(const char *message, int socket)
{
    if (socket == -1)
    {
        // client
        if (send(create_socket, message, strlen(message), 0) == -1)
        {
            socketError("send error");
        }
    }
    else
    {
        // server
        if (send(socket, message, strlen(message), 0) == -1)
        {
            socketError("send error");
        }
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $-0x1, %edx
je 0x47bd
movl %edx, %ebp
movq %rbx, %rdi
callq 0x3150
movl %ebp, %edi
movq %rbx, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31a0
cmpq $-0x1, %rax
jne 0x47dc
callq 0x35d9
movl (%rdi), %ebp
movq %rbx, %rdi
callq 0x3150
movl %ebp, %edi
movq %rbx, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31a0
cmpq $-0x1, %rax
je 0x47e3
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x35ee
// File: /workspace/github_cpp_makefile_star2_O3/PepiJK[P]Mail-Server-Client/src/myserver.cpp
// Function: main
int main(int argc, char *argv[])
{
   MyHelper helper;
   helper.checkServerArguments(argc, argv);

   MySocket serverSocket(stoi(argv[1]));
   serverSocket.createSocket();
   serverSocket.bindSocket();
   serverSocket.listenSocket();

   int new_socket;

   cout << "Waiting for connections..." << endl;
   while (1)
   {
      new_socket = serverSocket.acceptNewConnection();
      // create a new thread everytime a new client connects to the server
      // detach because we allow the execution of the thread to continue independently
      thread(serverThread, helper, ref(serverSocket), new_socket, argv[2]).detach();
   }
   return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x498, %rsp            # imm = 0x498
movq %rsi, %r13
movl %edi, %ebx
leaq -0x88(%rbp), %r14
movq %r14, %rdi
callq 0x377c
movq %r14, %rdi
movl %ebx, %esi
movq %r13, %rdx
callq 0x3792
movq 0x8(%r13), %rsi
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x3130
movq -0x58(%rbp), %rbx
callq 0x3040
movq %rax, %r14
movl (%rax), %r12d
movl $0x0, (%rax)
leaq -0x4b8(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x3390
cmpq %rbx, (%r15)
jne 0x7474
leaq 0xbed(%rip), %rdi       # 0x805c
callq 0x31c0
movl (%r14), %ecx
cmpl $0x22, %ecx
setne %dl
movslq %eax, %rsi
cmpq %rax, %rsi
sete %sil
testb %dl, %sil
jne 0x7498
leaq 0xbc9(%rip), %rdi       # 0x805c
callq 0x33b0
testl %ecx, %ecx
jne 0x749f
movl %r12d, (%r14)
leaq -0x4b8(%rbp), %rdi
movl %eax, %esi
callq 0x444c
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x74bf
callq 0x32c0
leaq -0x4b8(%rbp), %rdi
callq 0x44b2
leaq -0x4b8(%rbp), %rdi
callq 0x45b6
leaq -0x4b8(%rbp), %r14
movq %r14, %rdi
callq 0x45d8
movq 0x3aeb(%rip), %rdi      # 0xafd8
leaq 0xd69(%rip), %rsi       # 0x825d
movl $0x1a, %edx
callq 0x3350
movq 0x3ad3(%rip), %rdi      # 0xafd8
callq 0x3190
addq $0x10, %r13
leaq -0x58(%rbp), %r12
leaq -0x38(%rbp), %rbx
leaq -0x2c(%rbp), %r15
movq %r14, %rdi
callq 0x45fc
movl %eax, -0x2c(%rbp)
movq %r14, -0x38(%rbp)
movq %r12, %rdi
leaq -0x2d37(%rip), %rsi     # 0x47fc
leaq -0x88(%rbp), %rdx
movq %rbx, %rcx
movq %r15, %r8
movq %r13, %r9
callq 0x76a4
movq %r12, %rdi
callq 0x3490
cmpq $0x0, -0x58(%rbp)
je 0x751a
jmp 0x7560
cmpq $0x0, -0x58(%rbp)
je 0x756b
callq 0x30c0
jmp 0x756b
jmp 0x756b
jmp 0x756b
movq %rax, %rbx
leaq -0x4b8(%rbp), %rdi
callq 0x47e8
jmp 0x75a6
movq %rax, %rbx
jmp 0x758d
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x758d
movl %r12d, (%r14)
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x75a6
callq 0x32c0
jmp 0x75a6
jmp 0x75a3
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x4010
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O3/razimantv[P]DancingLinks/sudoku/../DancingLinks/DancingLinks.cpp
// Function: DancingLinks::DancingLinks()
DancingLinks::DancingLinks() {
  dummycolumn_ = new DancingLinksColumn;
  dummycolumn_->set_essential(false);
  columns_ = NULL;
  cells_ = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x20, %edi
callq 0x10c0
movq %rax, %r14
movq %rax, %rdi
callq 0x1fcc
movq %r14, (%rbx)
movb $0x0, 0x1c(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x10d0
movq %rbx, %rdi
callq 0x1150
nop
// File: /workspace/github_cpp_makefile_star2_O3/razimantv[P]DancingLinks/sudoku/../DancingLinks/DancingLinks.cpp
// Function: DancingLinks::Destroy()
void DancingLinks::Destroy() {
  // Delete memory allocated to the children at the header
  // Of course, use this only at the header and only after allocation has
  //  been done. Don't blame me if you screw up
  if (columns_ != NULL) {
    delete[] columns_;
    columns_ = NULL;
  }
  if (cells_ != NULL) {
    delete[] cells_;
    cells_ = NULL;
  }
  dummycolumn_->set_left_ptr(NULL);
  dummycolumn_->set_right_ptr(NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r12
testq %r12, %r12
je 0x16b1
leaq -0x8(%r12), %r14
movq -0x8(%r12), %r15
testq %r15, %r15
je 0x1696
addq $-0x20, %r12
movq %r15, %r13
shlq $0x5, %r13
leaq (%r12,%r13), %rdi
callq 0x201e
addq $-0x20, %r13
jne 0x1687
shlq $0x5, %r15
orq $0x8, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1160
movq $0x0, 0x8(%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x16c7
callq 0x10f0
movq $0x0, 0x10(%rbx)
movq (%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/razimantv[P]DancingLinks/dominosa/../DancingLinks/DancingLinksColumn.cpp
// Function: DancingLinksColumn::RemoveColumn()
void DancingLinksColumn::RemoveColumn() {
  // Remove the column from the column list
  left_ptr_->set_right_ptr(right_ptr_);
  right_ptr_->set_left_ptr(left_ptr_);

  // Find the 1-cells in the column and remove the other 1-cells in those rows
  //  from their respective columns
  for (DancingLinksCell *ptr = dummycell_->down_ptr(); ptr != dummycell_;
       ptr = ptr->down_ptr()) {
    // Found a 1-cell in the column
    // Erase the row by finding its row neighbours and removing their
    //  vertical links
    for (DancingLinksCell *ptr2 = ptr->right_ptr(); ptr2 != ptr;
         ptr2 = ptr2->right_ptr()) {
      // 1-cell in the row
      // Remove vertical links
      ptr2->RemoveCell();
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
movq 0x10(%rdi), %rax
movq 0x18(%rax), %r15
cmpq %rax, %r15
je 0x2076
movq %rdi, %rbx
movq 0x8(%r15), %r14
cmpq %r15, %r14
je 0x206d
movq %r14, %rdi
callq 0x1f76
movq 0x8(%r14), %r14
cmpq %r15, %r14
jne 0x2058
movq 0x10(%rbx), %rax
movq 0x18(%r15), %r15
cmpq %rax, %r15
jne 0x204f
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/razimantv[P]DancingLinks/dominosa/../DancingLinks/DancingLinksColumn.cpp
// Function: DancingLinksColumn::UnremoveColumn()
void DancingLinksColumn::UnremoveColumn() {
  // Put back the cells in the reverse order as they were removed
  for (DancingLinksCell *ptr = dummycell_->up_ptr(); ptr != dummycell_;
       ptr = ptr->up_ptr()) {
    for (DancingLinksCell *ptr2 = ptr->left_ptr(); ptr2 != ptr;
         ptr2 = ptr2->left_ptr()) {
      ptr2->UnremoveCell();
    }
  }

  // Insert the column to the column list
  left_ptr_->set_right_ptr(this);
  right_ptr_->set_left_ptr(this);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x10(%rax), %r15
cmpq %rax, %r15
je 0x20b3
movq (%r15), %r14
cmpq %r15, %r14
je 0x20ad
movq %r14, %rdi
callq 0x1f8e
movq (%r14), %r14
cmpq %r15, %r14
jne 0x2099
movq 0x10(%rbx), %rax
movq 0x10(%r15), %r15
jmp 0x208c
movq (%rbx), %rax
movq %rbx, 0x8(%rax)
movq 0x8(%rbx), %rax
movq %rbx, (%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/train.c
// Function: main
int main(int argc, char **argv)
{
	char input_file_name[1024];
	char model_file_name[1024];
	const char *error_msg;

	parse_command_line(argc, argv, input_file_name, model_file_name);
	read_problem(input_file_name);
	param.train_file = Malloc(char,1024);
	strcpy(param.train_file, input_file_name);
	error_msg = check_parameter(&prob,&param);

	if(error_msg)
	{
		fprintf(stderr,"ERROR: %s\n",error_msg);
		exit(1);
	}

	if(flag_cross_validation)
	{
		do_cross_validation();
	}
	else
	{
		clock_t start_cpu, end_cpu;
		double cpu_time_used;
     	start_cpu = clock();
		model_=train(&prob, &param);
		end_cpu = clock();
     	cpu_time_used = ((double) (end_cpu - start_cpu)) / CLOCKS_PER_SEC;
		if(save_model(model_file_name, model_))
		{
			fprintf(stderr,"can't save model to file %s\n",model_file_name);
			exit(1);
		}
		free_and_destroy_model(&model_);
	}
	destroy_param(&param);
	free(prob.y);
	free(prob.x);
	free(x_space);
	free(line);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
leaq 0x400(%rsp), %rbx
movq %rsp, %rcx
movq %rbx, %rdx
callq 0x3ca5
movq %rbx, %rdi
callq 0x41ec
movl $0x400, %edi            # imm = 0x400
callq 0x32f0
movq %rax, 0x1a6c9(%rip)     # 0x1e298
leaq 0x1a68a(%rip), %r14     # 0x1e260
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31f0
leaq 0x1a730(%rip), %rdi     # 0x1e318
movq %r14, %rsi
callq 0x1507c
testq %rax, %rax
jne 0x3c95
cmpl $0x0, 0x1a740(%rip)     # 0x1e340
je 0x3c09
callq 0x4606
jmp 0x3c4c
callq 0x3130
leaq 0x1a703(%rip), %rdi     # 0x1e318
leaq 0x1a644(%rip), %rsi     # 0x1e260
callq 0x7bfc
movq %rax, 0x1a710(%rip)     # 0x1e338
callq 0x3130
movq 0x1a704(%rip), %rsi     # 0x1e338
movq %rsp, %rdi
callq 0x14764
testl %eax, %eax
jne 0x3c9d
leaq 0x1a6f1(%rip), %rdi     # 0x1e338
callq 0x1450f
leaq 0x1a60d(%rip), %rdi     # 0x1e260
callq 0x15053
movq 0x1a6c1(%rip), %rdi     # 0x1e320
callq 0x3290
movq 0x1a6bd(%rip), %rdi     # 0x1e328
callq 0x3290
movq 0x1a699(%rip), %rdi     # 0x1e310
callq 0x3290
movq 0x1a6cd(%rip), %rdi     # 0x1e350
callq 0x3290
xorl %eax, %eax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x3480
movq %rsp, %rdi
callq 0x34a4
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/train.c
// Function: readline(_IO_FILE*, int)
static char* readline(FILE *input, int max_idx) 
{
	int len;
	
	if(fgets(line,max_line_len,input) == NULL)
		return NULL;

	while(strrchr(line,'\n') == NULL)
	{
		max_line_len *= 2;
		line = (char *) realloc(line,max_line_len);
		len = (int) strlen(line);
		if(fgets(line+len,max_line_len-len,input) == NULL)
			break;
	}

	if(max_idx>0 && (param.structured_w=='s' || param.structured_w=='a' || param.structured_w=='f')) 
	{
		int y;
		double * read_line = (double*) malloc(sizeof(double)*(max_idx+1));
		memset(read_line, 0, sizeof(double)*(max_idx+1));
		split(line, read_line, &y);
		transform_line(read_line,y,max_idx,line, param.structured_w,param.transform_matrix,param.tmx_r,param.tmx_c);
		free(read_line);
	}
	
	return line;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x1991d(%rip), %rdi     # 0x1e350
movl 0x1991f(%rip), %esi     # 0x1e358
movq %r14, %rdx
callq 0x3390
testq %rax, %rax
je 0x4b43
movq 0x198ff(%rip), %r15     # 0x1e350
movq %r15, %rdi
movl $0xa, %esi
callq 0x3240
testq %rax, %rax
jne 0x4aac
movslq 0x198ee(%rip), %r12     # 0x1e358
addq %r12, %r12
movl %r12d, 0x198e4(%rip)    # 0x1e358
movq %r15, %rdi
movq %r12, %rsi
callq 0x33d0
movq %rax, %r15
movq %rax, 0x198c7(%rip)     # 0x1e350
movq %rax, %rdi
callq 0x30e0
cltq
addq %rax, %r15
subl %eax, %r12d
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x3390
testq %rax, %rax
jne 0x4a4a
testl %ebx, %ebx
jle 0x4b3a
movzbl 0x19811(%rip), %eax     # 0x1e2cc
addl $-0x61, %eax
cmpl $0x12, %eax
ja 0x4b3a
movl $0x40021, %ecx          # imm = 0x40021
btl %eax, %ecx
jae 0x4b3a
movl %ebx, %eax
leaq 0x8(,%rax,8), %rsi
movl $0x1, %edi
callq 0x3120
movq %rax, %r14
movq 0x19865(%rip), %rdi     # 0x1e350
leaq 0x4(%rsp), %r15
movq %rax, %rsi
movq %r15, %rdx
callq 0x16bde
movl (%r15), %esi
movq 0x1984b(%rip), %rcx     # 0x1e350
movsbl 0x197bf(%rip), %r8d     # 0x1e2cc
movq 0x197bc(%rip), %r9      # 0x1e2d0
movl 0x197be(%rip), %eax     # 0x1e2d8
movl 0x197bb(%rip), %r10d    # 0x1e2dc
movq %r14, %rdi
movl %ebx, %edx
pushq %r10
pushq %rax
callq 0x16daa
addq $0x10, %rsp
movq %r14, %rdi
callq 0x3290
movq 0x1980f(%rip), %rax     # 0x1e350
jmp 0x4b45
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/train.c
// Function: endofline(_IO_FILE*)
int endofline(FILE *ifp)
{
	int c = fgetc(ifp);
	int d = c;
    int eol = (c == '\r' || c == '\n');
    if (c == '\r')
    {
        c = getc(ifp);
        if (c != '\n' && c != EOF)
            ungetc(c, ifp);
    }
    return(eol);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x3380
movl %eax, %ebx
cmpl $0xd, %eax
jne 0x4b80
movq %r14, %rdi
callq 0x30b0
cmpl $-0x1, %eax
je 0x4b80
cmpl $0xa, %eax
je 0x4b80
movl %eax, %edi
movq %r14, %rsi
callq 0x3080
cmpl $0xd, %ebx
sete %al
cmpl $0xa, %ebx
sete %cl
orb %al, %cl
movzbl %cl, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/tron.cpp
// Function: TRON::TRON(function const*, double, int)
TRON::TRON(const function *fun_obj, double eps, int max_iter)
{
	this->fun_obj=const_cast<function *>(fun_obj);
	this->eps=eps;
	this->max_iter=max_iter;
	tron_print_string = default_print;
}

// Assembly:
movq %rsi, 0x10(%rdi)
movsd %xmm0, (%rdi)
movl %edx, 0x8(%rdi)
leaq 0x5(%rip), %rax         # 0x4d91
movq %rax, 0x18(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/tron.cpp
// Function: TRON::norm_inf(int, double*)
double TRON::norm_inf(int n, double *x)
{
	double dmax = fabs(x[0]);
	for (int i=1; i<n; i++)
		if (fabs(x[i]) >= dmax)
			dmax = fabs(x[i]);
	return(dmax);
}

// Assembly:
movsd (%rdx), %xmm1
andpd 0x137d6(%rip), %xmm1    # 0x19120
cmpl $0x2, %esi
jl 0x5989
movl %esi, %eax
movl $0x1, %ecx
movapd 0x137c2(%rip), %xmm2    # 0x19120
movapd %xmm1, %xmm0
movsd (%rdx,%rcx,8), %xmm3
andpd %xmm2, %xmm3
cmplesd %xmm3, %xmm0
andpd %xmm0, %xmm3
andnpd %xmm1, %xmm0
orpd %xmm3, %xmm0
incq %rcx
movapd %xmm0, %xmm1
cmpq %rcx, %rax
jne 0x5962
retq
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::fun(double*)
double l2r_lr_fun::fun(double *w)
{
	int i;
	double f=0;
	double *y=prob->y;
	int l=prob->l;
	int w_size=get_nr_variable();

	Xv(w, z);

	for(i=0;i<w_size;i++)
		f += w[i]*w[i];
	f /= 2.0;
	for(i=0;i<l;i++)
	{
		double yz = y[i]*z[i];
		if (yz >= 0)
			f += C[i]*log(1 + exp(-yz));
		else
			f += C[i]*(-yz+log(1 + exp(yz)));
	}

	return(f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%rdi), %rcx
movq 0x8(%rcx), %r15
movl (%rcx), %r12d
callq *0x18(%rax)
movl %eax, %ebp
movq 0x10(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5b3c
testl %ebp, %ebp
jle 0x5a8e
movl %ebp, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movsd (%r14,%rcx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x5a6e
mulsd 0x13674(%rip), %xmm0    # 0x19100
jmp 0x5a92
xorpd %xmm0, %xmm0
testl %r12d, %r12d
jle 0x5b2e
xorl %r14d, %r14d
movsd %xmm0, 0x8(%rsp)
movsd (%r15,%r14,8), %xmm1
movq 0x10(%rbx), %rax
mulsd (%rax,%r14,8), %xmm1
movq 0x8(%rbx), %rax
ucomisd 0x12580(%rip), %xmm1    # 0x18040
movsd (%rax,%r14,8), %xmm0
movsd %xmm0, (%rsp)
jae 0x5af1
movapd %xmm1, %xmm0
movapd %xmm1, 0x10(%rsp)
callq 0x3400
addsd 0x137b4(%rip), %xmm0    # 0x19298
callq 0x31a0
subsd 0x10(%rsp), %xmm0
jmp 0x5b0f
xorpd 0x13637(%rip), %xmm1    # 0x19130
movapd %xmm1, %xmm0
callq 0x3400
addsd 0x1378e(%rip), %xmm0    # 0x19298
callq 0x31a0
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
incq %r14
cmpq %r14, %r12
jne 0x5a9e
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::Xv(double*, double*)
void l2r_lr_fun::Xv(double *v, double *Xv)
{
	int i;
	int l=prob->l;
	feature_node **x=prob->x;

	for(i=0;i<l;i++)
	{
		feature_node *s=x[i];
		Xv[i]=0;
		while(s->index!=-1)
		{
			Xv[i]+=v[s->index-1]*s->value;
			s++;
		}
	}
}

// Assembly:
movq 0x20(%rdi), %rcx
movslq (%rcx), %rax
testq %rax, %rax
jle 0x5b99
movq 0x10(%rcx), %rcx
xorl %edi, %edi
movq (%rcx,%rdi,8), %r8
movq $0x0, (%rdx,%rdi,8)
movl (%r8), %r9d
cmpl $-0x1, %r9d
je 0x5b91
addq $0x10, %r8
xorpd %xmm0, %xmm0
movslq %r9d, %r9
movsd -0x8(%rsi,%r9,8), %xmm1
mulsd -0x8(%r8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rdx,%rdi,8)
movl (%r8), %r9d
addq $0x10, %r8
cmpl $-0x1, %r9d
jne 0x5b6b
incq %rdi
cmpq %rax, %rdi
jne 0x5b4e
retq
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::grad(double*, double*)
void l2r_lr_fun::grad(double *w, double *g)
{
	int i;
	double *y=prob->y;
	int l=prob->l;
	int w_size=get_nr_variable();

	for(i=0;i<l;i++)
	{
		z[i] = 1/(1 + exp(-y[i]*z[i]));
		D[i] = z[i]*(1-z[i]);
		z[i] = C[i]*(z[i]-1)*y[i];
	}
	XTv(z, g);

	for(i=0;i<w_size;i++)
		g[i] = w[i] + g[i];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq 0x20(%rdi), %rcx
movq 0x8(%rcx), %r12
movslq (%rcx), %r13
callq *0x18(%rax)
testq %r13, %r13
movl %eax, 0x4(%rsp)
jle 0x5c43
movq 0x10(%r15), %rsi
xorl %ebp, %ebp
movsd (%r12,%rbp,8), %xmm0
xorpd 0x13554(%rip), %xmm0    # 0x19130
mulsd (%rsi,%rbp,8), %xmm0
callq 0x3400
movsd 0x136aa(%rip), %xmm2    # 0x19298
addsd %xmm2, %xmm0
movapd %xmm2, %xmm1
divsd %xmm0, %xmm1
movq 0x10(%r15), %rsi
movsd %xmm1, (%rsi,%rbp,8)
movapd %xmm2, %xmm0
subsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movq 0x18(%r15), %rax
movsd %xmm0, (%rax,%rbp,8)
movq 0x8(%r15), %rax
movsd (%rsi,%rbp,8), %xmm0
addsd 0x13677(%rip), %xmm0    # 0x192a0
mulsd (%rax,%rbp,8), %xmm0
mulsd (%r12,%rbp,8), %xmm0
movsd %xmm0, (%rsi,%rbp,8)
incq %rbp
cmpq %rbp, %r13
jne 0x5bce
jmp 0x5c47
movq 0x10(%r15), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x5c86
movl 0x4(%rsp), %eax
testl %eax, %eax
jle 0x5c76
movl %eax, %eax
xorl %ecx, %ecx
movsd (%r14,%rcx,8), %xmm0
addsd (%rbx,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x5c5e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::XTv(double*, double*)
void l2r_lr_fun::XTv(double *v, double *XTv)
{
	int i;
	int l=prob->l;
	int w_size=get_nr_variable();
	feature_node **x=prob->x;

	for(i=0;i<w_size;i++)
		XTv[i]=0;
	for(i=0;i<l;i++)
	{
		feature_node *s=x[i];
		while(s->index!=-1)
		{
			XTv[s->index-1]+=v[i]*s->value;
			s++;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq 0x20(%rdi), %rcx
movl (%rcx), %r12d
callq *0x18(%rax)
movq 0x20(%r15), %rcx
movq 0x10(%rcx), %r15
testl %eax, %eax
jle 0x5cc0
movl %eax, %edx
shlq $0x3, %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3110
testl %r12d, %r12d
jle 0x5d03
xorl %eax, %eax
movq (%r15,%rax,8), %rcx
movl (%rcx), %edx
cmpl $-0x1, %edx
je 0x5cfb
addq $0x10, %rcx
movsd (%r14,%rax,8), %xmm0
movslq %edx, %rdx
mulsd -0x8(%rcx), %xmm0
addsd -0x8(%rbx,%rdx,8), %xmm0
movsd %xmm0, -0x8(%rbx,%rdx,8)
movl (%rcx), %edx
addq $0x10, %rcx
cmpl $-0x1, %edx
jne 0x5cd6
incq %rax
cmpq %r12, %rax
jne 0x5cc7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/linear.cpp
// Function: l2r_lr_fun::Hv(double*, double*)
void l2r_lr_fun::Hv(double *s, double *Hs)
{
	int i;
	int l=prob->l;
	int w_size=get_nr_variable();
	double *wa = new double[l];

	Xv(s, wa);
	for(i=0;i<l;i++)
		wa[i] = C[i]*D[i]*wa[i];

	XTv(wa, Hs);
	for(i=0;i<w_size;i++)
		Hs[i] = s[i] + Hs[i];
	delete[] wa;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq (%rdi), %rax
movq 0x20(%rdi), %rcx
movslq (%rcx), %r13
callq *0x18(%rax)
movl %eax, %ebp
leaq (,%r13,8), %rax
testq %r13, %r13
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, %r15
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x5b3c
testq %r13, %r13
jle 0x5d96
movq 0x8(%r12), %rax
movq 0x18(%r12), %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm0
mulsd (%rcx,%rdx,8), %xmm0
mulsd (%r15,%rdx,8), %xmm0
movsd %xmm0, (%r15,%rdx,8)
incq %rdx
cmpq %rdx, %r13
jne 0x5d78
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x5c86
testl %ebp, %ebp
jle 0x5dc4
movl %ebp, %eax
xorl %ecx, %ecx
movsd (%r14,%rcx,8), %xmm0
addsd (%rbx,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x5dac
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x32d0