LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/simonrharris[P]SKA/src/general.cpp
// Function: fileToVector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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 fileToVector(const std::string & filename, std::vector < std::string > & fileargs){
	std::ifstream fileStream;
	fileStream.open(filename, std::ios::in);
	if (fileStream.fail()) {
		std::cerr << "Failed to open " << filename << std::endl << std::endl;
		return 1;
	}
	std::string word;
	while (fileStream >> word){
		if (word.length()>500){
			std::cerr << "Names > 500 characters are not allowed" << std::endl;
			return 1;
		}
		else if (word.length()>0){
			fileargs.push_back(word);
		}
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x5410
movq %r15, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x5350
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
je 0x824a
movq 0x38e28(%rip), %rdi     # 0x40ff0
leaq 0x2b268(%rip), %rsi     # 0x33437
movl $0xf, %edx
callq 0x5420
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x38e09(%rip), %rdi     # 0x40ff0
callq 0x5420
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5250
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movl $0x1, %ebx
movq %rax, %rdi
callq 0x5250
jmp 0x8307
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x20(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5490
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x82a2
movq 0x8(%rsp), %rax
cmpq $0x1f5, %rax            # imm = 0x1F5
jae 0x82a6
testq %rax, %rax
je 0x826a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x855c
jmp 0x826a
xorl %ebx, %ebx
jmp 0x82f1
movq 0x38d43(%rip), %rbx     # 0x40ff0
leaq 0x2afd0(%rip), %rsi     # 0x33284
movl $0x26, %edx
movq %rbx, %rdi
callq 0x5420
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x53a0
movsbl %al, %esi
movq 0x38d11(%rip), %rdi     # 0x40ff0
callq 0x5030
movl $0x1, %ebx
movq %rax, %rdi
callq 0x5250
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x8307
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
leaq 0x20(%rsp), %rdi
callq 0x50d0
movl %ebx, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x8329
movq %rax, %rbx
jmp 0x8342
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x8342
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
leaq 0x20(%rsp), %rdi
callq 0x50d0
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O1/simonrharris[P]SKA/src/general.cpp
// Function: printDuration(std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>)
void printDuration(const std::chrono::high_resolution_clock::time_point start){
	std::chrono::high_resolution_clock::time_point finish = std::chrono::high_resolution_clock::now();
	std::chrono::duration<double> elapsed = finish - start;
	std::cout << "Done" << std::endl;
	std::cout << "Total time required: " << elapsed.count() << "s" << std::endl;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x5060
subq %rbx, %rax
cvtsi2sd %rax, %xmm0
divsd 0x2aee7(%rip), %xmm0    # 0x33258
movsd %xmm0, 0x8(%rsp)
movq 0x38c42(%rip), %rbx     # 0x40fc0
leaq 0x2af26(%rip), %rsi     # 0x332ab
movl $0x4, %edx
movq %rbx, %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
callq 0x5250
leaq 0x2aef0(%rip), %rsi     # 0x332b0
movl $0x15, %edx
movq %rbx, %rdi
callq 0x5420
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x5610
movq %rax, %rbx
leaq 0x2cfd3(%rip), %rsi     # 0x353b8
movl $0x1, %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
addq $0x10, %rsp
popq %rbx
jmp 0x5250
// File: /workspace/github_cpp_makefile_star2_O1/simonrharris[P]SKA/src/general.cpp
// Function: calculateMissedSNPs(float, float, int)
int calculateMissedSNPs(float totalSiteCount, const float variantSiteCount, const int kmerSize){

	if (variantSiteCount==0){
		std::cout << "Expected number of missed alignments = 0" << std::endl;
		return 0;
	}
	if (totalSiteCount<variantSiteCount){
		std::cout << "Error in calculateMissedSNPs. More variants than sites." << std::endl;
		return 1;
	}

	double nonvariantSiteCount=totalSiteCount-variantSiteCount;
	totalSiteCount--;//as we are assuming the kmer includes one snp
	double snpprobability=nonvariantSiteCount/totalSiteCount;

	for (int i=0; i<kmerSize*2; ++i){
		totalSiteCount--;
		nonvariantSiteCount--;
		snpprobability*=nonvariantSiteCount/totalSiteCount;
	}

	std::cout << "Expected number of missed alignments = " << (1.0-snpprobability)*variantSiteCount << std::endl;
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm1
jne 0x844e
jp 0x844e
movq 0x38b8b(%rip), %rbx     # 0x40fc0
leaq 0x2ae8a(%rip), %rsi     # 0x332c6
movl $0x28, %edx
movq %rbx, %rdi
callq 0x5420
jmp 0x8529
ucomiss %xmm0, %xmm1
jbe 0x8478
movq 0x38b66(%rip), %rbx     # 0x40fc0
leaq 0x2ae8e(%rip), %rsi     # 0x332ef
movl $0x37, %edx
movq %rbx, %rdi
callq 0x5420
movl $0x1, %ebp
jmp 0x852b
movaps %xmm0, %xmm2
movss %xmm1, 0xc(%rsp)
subss %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtss2sd %xmm2, %xmm1
addss 0x2addc(%rip), %xmm0    # 0x33270
xorps %xmm2, %xmm2
cvtss2sd %xmm0, %xmm2
movaps %xmm1, %xmm6
divsd %xmm2, %xmm6
testl %edi, %edi
jle 0x84e2
addl %edi, %edi
cmpl $0x2, %edi
movl $0x1, %eax
cmovgel %edi, %eax
movss 0x2adb5(%rip), %xmm2    # 0x33270
movsd 0x2ad9d(%rip), %xmm3    # 0x33260
addss %xmm2, %xmm0
addsd %xmm3, %xmm1
xorps %xmm4, %xmm4
cvtss2sd %xmm0, %xmm4
movapd %xmm1, %xmm5
divsd %xmm4, %xmm5
mulsd %xmm5, %xmm6
decl %eax
jne 0x84c3
movsd %xmm6, 0x10(%rsp)
movq 0x38ad1(%rip), %rbx     # 0x40fc0
leaq 0x2ae31(%rip), %rsi     # 0x33327
movl $0x27, %edx
movq %rbx, %rdi
callq 0x5420
movsd 0x2ad5d(%rip), %xmm1    # 0x33268
subsd 0x10(%rsp), %xmm1
xorps %xmm0, %xmm0
cvtss2sd 0xc(%rsp), %xmm0
mulsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x5610
movq %rax, %rbx
xorl %ebp, %ebp
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
callq 0x5250
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/simonrharris[P]SKA/src/kmers.cpp
// Function: ascii_bitstring(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void ascii_bitstring(std::string & mybits){
	int myremainder=::fmod(int(mybits.length()),6);
	if (myremainder>0){
		for (int i = 0; i<(6-myremainder); ++i){
			mybits.push_back('0');
		}
	}
	for (std::string::size_type i = 0; i<mybits.length(); i+=6){
		assert((i+5)<mybits.length());
		mybits[i/6] = ((int(mybits[i])-'0')+((int(mybits[i+1])-'0')*2)+((int(mybits[i+2])-'0')*4)+((int(mybits[i+3])-'0')*8)+((int(mybits[i+4])-'0')*16)+((int(mybits[i+5])-'0')*32))+33;
	}
	mybits.erase(mybits.length()/6);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cvtsi2sdl 0x8(%rdi), %xmm0
movsd 0x2aa85(%rip), %xmm1    # 0x33398
callq 0x54d0
cvttsd2si %xmm0, %ebp
testl %ebp, %ebp
jle 0x8939
cmpl $0x5, %ebp
jg 0x8939
addl $-0x6, %ebp
movq %rbx, %rdi
movl $0x30, %esi
callq 0x5340
incl %ebp
jne 0x8928
movq 0x8(%rbx), %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
testq %rax, %rax
je 0x89b7
movl $0x5, %esi
cmpq %rax, %rsi
jae 0x89d0
leaq -0x5(%rsi), %rax
movq (%rbx), %rdi
movb -0x4(%rdi,%rsi), %r8b
movb -0x3(%rdi,%rsi), %dl
addb %r8b, %r8b
shlb $0x2, %dl
movb -0x2(%rdi,%rsi), %r9b
shlb $0x3, %r9b
addb %dl, %r9b
movb -0x1(%rdi,%rsi), %dl
shlb $0x4, %dl
addb %r9b, %dl
movb (%rdi,%rsi), %r9b
shlb $0x5, %r9b
addb %dl, %r9b
addb -0x5(%rdi,%rsi), %r8b
addb %r9b, %r8b
addb $0x51, %r8b
mulq %rcx
shrq $0x2, %rdx
movb %r8b, (%rdi,%rdx)
movq 0x8(%rbx), %rax
leaq 0x6(%rsi), %rdx
incq %rsi
cmpq %rax, %rsi
movq %rdx, %rsi
jb 0x8951
mulq %rcx
shrq $0x2, %rdx
movq %rdx, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax,%rdx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2a9f9(%rip), %rdi     # 0x333d0
leaq 0x2aa08(%rip), %rsi     # 0x333e6
leaq 0x2aa0f(%rip), %rcx     # 0x333f4
movl $0x17, %edx
callq 0x5230
// File: /workspace/github_cpp_makefile_star2_O1/simonrharris[P]SKA/src/kmers.cpp
// Function: vectorbool_from_ascii(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::vector<bool, std::allocator<bool>>&)
void vectorbool_from_ascii(std::string & myascii, std::vector < bool > & mybits){
	mybits.resize(myascii.length()*6, false);
	for (std::string::size_type i = 0; i<myascii.length(); ++i){
		int bits=int(myascii[i])-33;
		for (int j=5; j>=0; --j){
			int power=int(pow(2,j));
			mybits[j+(6*i)]=int(bits/power);
			bits=bits%power;
		}
	}
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
addq %rax, %rax
leaq (%rax,%rax,2), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xaae2
cmpq $0x0, 0x8(%r14)
je 0x8ad8
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
xorl %r12d, %r12d
leaq 0x3f(%r15), %r13
xorl %ecx, %ecx
movq %r14, 0x8(%rsp)
movq (%r14), %rax
movq %rcx, 0x10(%rsp)
movsbl (%rax,%rcx), %ebp
addl $-0x21, %ebp
movl $0x5, %r14d
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
callq 0x5370
cvttsd2si %xmm0, %ecx
movl %ebp, %eax
cltd
idivl %ecx
movq %r12, %rcx
addq %r14, %rcx
leaq 0x3f(%r12,%r14), %rsi
cmovnsq %rcx, %rsi
sarq $0x6, %rsi
shlq $0x3, %rsi
addq (%rbx), %rsi
movq %rcx, %rdi
andq %r13, %rdi
xorl %r8d, %r8d
cmpq %r15, %rdi
setbe %r8b
movl $0x1, %edi
shlq %cl, %rdi
leaq -0x8(,%r8,8), %rcx
movl %edx, %ebp
testl %eax, %eax
je 0x8aac
orq (%rsi,%rcx), %rdi
jmp 0x8ab3
notq %rdi
andq (%rsi,%rcx), %rdi
movq %rdi, (%rsi,%rcx)
addq $-0x1, %r14
jb 0x8a50
movq 0x10(%rsp), %rcx
incq %rcx
addq $0x6, %r12
movq 0x8(%rsp), %r14
cmpq 0x8(%r14), %rcx
jb 0x8a3b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a890(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x2a898(%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 0x8b85
movaps (%rsp), %xmm0
cvttss2si %xmm0, %rax
movq %rax, %rcx
cvttss2si %xmm0, %rsi
subss 0x2a4aa(%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_O1/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 0x981f
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 0x97e6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x855c
jmp 0x97c0
movq 0x377cb(%rip), %rsi     # 0x40fb8
leaq 0x40(%rsp), %rdi
callq 0x5540
leaq 0xb8(%rsp), %rdi
callq 0x5120
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x981b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x53c0
xorl %ebx, %ebx
jmp 0x9824
movl $0x1, %ebx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x983a
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 0x984f
movq %rax, %rbx
jmp 0x987a
movq %rax, %rbx
jmp 0x9891
movq %rax, %rbx
movq 0x37755(%rip), %rsi     # 0x40fb8
leaq 0x40(%rsp), %rdi
callq 0x5540
leaq 0xb8(%rsp), %rdi
callq 0x5120
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x9891
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x53c0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x98a7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbbe0
testq %rax, %rax
je 0xa2bf
movsbq %bl, %rcx
leaq 0x3718c(%rip), %rdx     # 0x41440
movsbq (%rdx,%rcx), %rcx
incl 0x28(%rax,%rcx,4)
jmp 0xa32d
testb %bpl, %bpl
je 0xa32d
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 0x859a
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r15)
movups %xmm0, 0x20(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0xbcdc
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xa314
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
movsbq %bl, %rax
leaq 0x37121(%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 0xa353
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53c0
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x36c53(%rip), %r15     # 0x40fc0
leaq 0x29232(%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 0xa3fc
movl $0x28, %ecx
xorl %eax, %eax
addl (%rsi,%rcx), %eax
addq $0x4, %rcx
cmpq $0x38, %rcx
jne 0xa3b8
cmpl (%r14), %eax
jge 0xa3da
movq (%rsi), %r15
movq %rbx, %rdi
callq 0xc01e
movq %r15, %rsi
jmp 0xa3ac
movl $0xe, %eax
movl -0x10(%rsi,%rax,4), %ecx
addl %ecx, (%rsi,%rax,4)
movl $0x0, -0x10(%rsi,%rax,4)
incq %rax
cmpq $0x12, %rax
jne 0xa3df
movq (%rsi), %rsi
jmp 0xa3ac
movq 0x18(%rbx), %rsi
movq 0x36bb9(%rip), %rdi     # 0x40fc0
callq 0x5240
movq %rax, %rbx
leaq 0x291b2(%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_O1/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 0xb71e
testq %rax, %rax
je 0xe5be
movslq %ebp, %rcx
movq 0x28(%rax), %rax
movb (%rax,%rcx), %dl
cmpb $0x2d, %dl
jne 0xe655
movb %bl, (%rax,%rcx)
jmp 0xe65d
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 0xad2a
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0xb836
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe617
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x53c0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe632
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53c0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xe649
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53c0
movslq %ebp, %rax
movq 0x28(%r14), %rcx
movb %bl, (%rcx,%rax)
jmp 0xe65d
cmpb %bl, %dl
je 0xe65d
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 0xab50
jmp 0xe67e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xe695
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53c0
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d14b(%rip), %rsi     # 0x41540
movq 0x2d14c(%rip), %rcx     # 0x41548
movq %rcx, 0x8(%rdi)
movq %rax, 0x10(%rdi)
movq 0x2d14d(%rip), %rcx     # 0x41558
movq %rcx, 0x18(%rdi)
movups 0x2d14a(%rip), %xmm0    # 0x41560
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
movq %rsp, %rdx
movq %rdi, (%rdx)
callq 0x18770
cmpl $0x4, %ebp
jne 0x14447
leaq 0x1f8a1(%rip), %rax     # 0x33cd6
movq %rsp, %rsi
movq %rax, (%rsi)
movb $0x57, 0x8(%rsi)
movq %rbx, %rdi
callq 0x18bb8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x10158
movq %r14, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, 0x8(%rsp)
callq 0x18ee8
testq %rax, %rax
je 0x1bb5e
movq 0x30(%rax), %rsi
cmpq 0x38(%rax), %rsi
je 0x1bc11
movl 0x8(%rsp), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x30(%rax)
jmp 0x1bc22
movl 0x8(%rsp), %eax
leaq 0x34(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
callq 0x1d986
leaq 0x48(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %rdi
callq 0x859a
movq 0x10(%rsp), %rax
leaq 0x38(%rsp), %rsi
movq %rax, 0x20(%rsi)
movups 0x18(%rsp), %xmm0
movups %xmm0, 0x28(%rsi)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq %rbx, %rdi
callq 0x18fe4
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x1bbe1
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x1bbf8
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x53c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bc22
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
jmp 0x1bc22
addq $0x28, %rax
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
callq 0xe01e
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x18442
jmp 0x1bc3e
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bc55
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x53c0
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26114
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0xe8f8(%rip), %rsi      # 0x34a20
movq %rax, %rdi
callq 0x5700
movq 0x1aea1(%rip), %rsi     # 0x40fd8
movq 0x1ae8a(%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_O1/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 0x26178
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0xe8a9(%rip), %rsi      # 0x34a35
movq %rax, %rdi
callq 0x5700
movq 0x1ae3d(%rip), %rsi     # 0x40fd8
movq 0x1ae26(%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_O1/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 0x3e1d
movq %rax, %rbp
leaq 0x10(%rbx), %r15
xorl %r14d, %r14d
leaq 0x44b7(%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 0x3e07
movq %r15, %rdi
leaq 0x447a(%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 0x3dbf
jmp 0x3e20
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_O1/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, 0x8(%r14)
leaq 0x10(%r14), %r15
leaq 0x4404(%rip), %r12      # 0x8276
movq 0x8(%r14), %rdi
callq 0x3400
movq %rax, %rbp
movq %rax, (%r14)
testq %rax, %rax
je 0x3ed8
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 0x3e72
movq %r15, %rdi
leaq 0x43b3(%rip), %rsi      # 0x8275
callq 0x30d0
testl %eax, %eax
je 0x3e72
movq %rbx, %rdi
movq %r15, %rsi
callq 0x409e
jmp 0x3e72
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 0x40dc
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x8(%r14)
leaq 0x10(%r14), %r15
leaq 0x4336(%rip), %r12      # 0x8276
leaq 0x8(%rsp), %rbp
movq 0x8(%r14), %rdi
callq 0x3400
movq %rax, %r13
movq %rax, (%r14)
testq %rax, %rax
je 0x3fef
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 0x3f45
movq %r15, %rdi
leaq 0x42dc(%rip), %rsi      # 0x8275
callq 0x30d0
testl %eax, %eax
je 0x3f45
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 0x3fde
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3300
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x409e
jmp 0x3f45
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 0x400d
movq %rax, %r14
movq (%rsp), %rdi
callq 0x40dc
movq %r14, %rdi
callq 0x34a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorps %xmm0, %xmm0
movups %xmm0, 0x410(%rdi)
movw $0x2, 0x410(%rdi)
rolw $0x8, %si
movw %si, 0x412(%rdi)
movl $0x0, 0x414(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movups %xmm0, 0x410(%rdi)
movw $0x2, 0x410(%rdi)
rolw $0x8, %dx
movw %dx, 0x412(%rdi)
leaq 0x414(%rdi), %rsi
movq %rax, %rdi
jmp 0x3220
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4784
movq 0x695d(%rip), %r14      # 0xafd8
leaq 0x3a8f(%rip), %rsi      # 0x8111
movl $0x16, %edx
movq %r14, %rdi
callq 0x3350
movl 0x424(%rbx), %edi
callq 0x3160
testq %rax, %rax
je 0x46be
movq %rax, %r15
movq %rax, %rdi
callq 0x3150
movq 0x6927(%rip), %rdi      # 0xafd8
movq %r15, %rsi
movq %rax, %rdx
callq 0x3350
jmp 0x46d6
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x3470
movq 0x68fb(%rip), %r14      # 0xafd8
leaq 0x3a44(%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 0x3a04(%rip), %xmm0     # 0x8140
movups %xmm0, 0x10(%rbx)
movups 0x3a09(%rip), %xmm0     # 0x8150
movups %xmm0, 0x20(%rbx)
movups 0x3a0e(%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 0x4789
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_O1/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 0x479c
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 0x47c6
cmpl $-0x1, %eax
je 0x47d8
cltq
movb $0x0, 0x10(%rbx,%rax)
jmp 0x47cd
leaq 0x39a4(%rip), %r14      # 0x8171
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x35c4
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x480d
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 0x482c
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 0x4833
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x35ee
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7500
leaq 0xb61(%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 0x7524
leaq 0xb3d(%rip), %rdi       # 0x805c
callq 0x33b0
testl %ecx, %ecx
jne 0x752b
movl %r12d, (%r14)
leaq -0x4b8(%rbp), %rdi
movl %eax, %esi
callq 0x44a8
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x754b
callq 0x32c0
leaq -0x4b8(%rbp), %rdi
callq 0x4502
leaq -0x4b8(%rbp), %rdi
callq 0x4606
leaq -0x4b8(%rbp), %r14
movq %r14, %rdi
callq 0x4628
movq 0x3a5f(%rip), %rdi      # 0xafd8
leaq 0xcdd(%rip), %rsi       # 0x825d
movl $0x1a, %edx
callq 0x3350
movq 0x3a47(%rip), %rdi      # 0xafd8
callq 0x3190
addq $0x10, %r13
leaq -0x58(%rbp), %r12
leaq -0x38(%rbp), %rbx
leaq -0x2c(%rbp), %r15
movq %r14, %rdi
callq 0x464c
movl %eax, -0x2c(%rbp)
movq %r14, -0x38(%rbp)
movq %r12, %rdi
leaq -0x2d73(%rip), %rsi     # 0x484c
leaq -0x88(%rbp), %rdx
movq %rbx, %rcx
movq %r15, %r8
movq %r13, %r9
callq 0x7730
movq %r12, %rdi
callq 0x3490
cmpq $0x0, -0x58(%rbp)
je 0x75a6
jmp 0x75ec
cmpq $0x0, -0x58(%rbp)
je 0x75f7
callq 0x30c0
jmp 0x75f7
jmp 0x75f7
jmp 0x75f7
movq %rax, %rbx
leaq -0x4b8(%rbp), %rdi
callq 0x4838
jmp 0x7632
movq %rax, %rbx
jmp 0x7619
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x7619
movl %r12d, (%r14)
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7632
callq 0x32c0
jmp 0x7632
jmp 0x762f
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x4044
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1fdc
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_O1/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 0x168f
leaq -0x8(%r12), %r14
movq -0x8(%r12), %r15
testq %r15, %r15
je 0x1674
addq $-0x20, %r12
movq %r15, %r13
shlq $0x5, %r13
leaq (%r12,%r13), %rdi
callq 0x202e
addq $-0x20, %r13
jne 0x1665
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 0x16a5
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_O1/razimantv[P]DancingLinks/dominosa/../DancingLinks/DancingLinksColumn.cpp
// Function: DancingLinksColumn::DancingLinksColumn()
DancingLinksColumn::DancingLinksColumn() {
  left_ptr_ = right_ptr_ = NULL;
  dummycell_ = new DancingLinksCell;
  size_ = 0;
  essential_ = true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movl $0x30, %edi
callq 0x10c0
movq %rax, %r14
movq %rax, %rdi
callq 0x1f60
movq %r14, 0x10(%rbx)
movl $0x0, 0x18(%rbx)
movb $0x1, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x30, %esi
movq %r14, %rdi
callq 0x10d0
movq %rbx, %rdi
callq 0x1150
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8(%rdi), %rcx
movq %rax, (%rcx)
movq 0x10(%rdi), %rax
movq 0x18(%rax), %r15
cmpq %rax, %r15
je 0x208a
movq %rdi, %rbx
movq 0x8(%r15), %r14
cmpq %r15, %r14
je 0x2080
movq %r14, %rdi
callq 0x1f7a
movq 0x8(%r14), %r14
jmp 0x206d
movq 0x18(%r15), %r15
cmpq 0x10(%rbx), %r15
jne 0x2069
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x20c4
movq (%r15), %r14
cmpq %r15, %r14
je 0x20ba
movq %r14, %rdi
callq 0x1f96
movq (%r14), %r14
jmp 0x20a8
movq 0x10(%r15), %r15
cmpq 0x10(%rbx), %r15
jne 0x20a5
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_O1/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 0x3c95
movq %rbx, %rdi
callq 0x4244
movl $0x400, %edi            # imm = 0x400
callq 0x32e0
movq %rax, 0x176d1(%rip)     # 0x1b290
leaq 0x17692(%rip), %r14     # 0x1b258
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31e0
leaq 0x17738(%rip), %rdi     # 0x1b310
movq %r14, %rsi
callq 0x13433
testq %rax, %rax
jne 0x3c85
cmpl $0x0, 0x17748(%rip)     # 0x1b338
je 0x3bf9
callq 0x4663
jmp 0x3c3c
callq 0x3120
leaq 0x1770b(%rip), %rdi     # 0x1b310
leaq 0x1764c(%rip), %rsi     # 0x1b258
callq 0x79bf
movq %rax, 0x17718(%rip)     # 0x1b330
callq 0x3120
movq 0x1770c(%rip), %rsi     # 0x1b330
movq %rsp, %rdi
callq 0x12b67
testl %eax, %eax
jne 0x3c8d
leaq 0x176f9(%rip), %rdi     # 0x1b330
callq 0x1290c
leaq 0x17615(%rip), %rdi     # 0x1b258
callq 0x1340a
movq 0x176c9(%rip), %rdi     # 0x1b318
callq 0x3280
movq 0x176c5(%rip), %rdi     # 0x1b320
callq 0x3280
movq 0x176a1(%rip), %rdi     # 0x1b308
callq 0x3280
movq 0x176d5(%rip), %rdi     # 0x1b348
callq 0x3280
xorl %eax, %eax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x3470
movq %rsp, %rdi
callq 0x3494