LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/SeqIORead.h
// Function: Bio::SeqIORead<Bio::Sequence<Bio::DNAString>>::getline(bool)
char* SeqIORead<S>::getline(bool skip_empty/*=false*/)
{
	if(feof(this->m_fp))
		return NULL;

	do {
		this->m_next_line[0] = 0;
		// We do the following because we don't know whether the size of next_line is sufficient for storing the next line.
		// If not we will increase the size of next_line until we have enough space. Eventually next_line will be able to
		// store the longest line in the file.
		char    *p = this->m_next_line;
		size_t  s = this->m_next_line_size;
		while(fgets(p, s, this->m_fp)) {
			if((*(p+strlen(p)-1) == '\n') || feof(this->m_fp))
				break;
			if(strlen(p) != s-1) {
				// This is weird!
			}
			// Else - we did not read the whole line, need to increase next_line's size and continue reading
			this->m_next_line_size *= 2;
			this->m_next_line = (char*)realloc(this->m_next_line, this->m_next_line_size);
			p = this->m_next_line+strlen(this->m_next_line);
			s = this->m_next_line_size - strlen(this->m_next_line);
		}
		p = this->m_next_line;
		while(*p && isspace(*p))
			p++;
		// If we reached the end of the line and everything we saw is just spaces...
		if(!(*p) && skip_empty)
			this->m_next_line[0] = 0;
		this->m_line_num++;
	} while((this->m_next_line[0] == 0) && !feof(this->m_fp));

	if(m_next_line[0] == 0)
		return NULL;
	return m_next_line;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x55b0
testl %eax, %eax
je 0xf253
xorl %r15d, %r15d
jmp 0xf311
movq 0x38(%rbx), %rdi
callq 0x55b0
testl %eax, %eax
jne 0xf303
movq 0x40(%rbx), %rax
movb $0x0, (%rax)
movq 0x38(%rbx), %rdx
movq 0x40(%rbx), %r15
movl 0x48(%rbx), %esi
movq %r15, %rdi
callq 0x55e0
testq %rax, %rax
je 0xf2c0
movq %r15, %rdi
callq 0x5180
cmpb $0xa, -0x1(%r15,%rax)
je 0xf2c0
movq 0x38(%rbx), %rdi
callq 0x55b0
testl %eax, %eax
jne 0xf2c0
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rsi
addq %rsi, %rsi
movq %rsi, 0x48(%rbx)
callq 0x5620
movq %rax, %r15
movq %rax, 0x40(%rbx)
movq %rax, %rdi
callq 0x5180
addq %rax, %r15
movl 0x48(%rbx), %esi
subl %eax, %esi
movq 0x38(%rbx), %rdx
jmp 0xf265
movq 0x40(%rbx), %r15
movb (%r15), %al
testb %al, %al
je 0xf2e6
leaq 0x1(%r15), %r12
movsbl %al, %edi
callq 0x5070
testl %eax, %eax
je 0xf2f3
movb (%r12), %al
incq %r12
testb %al, %al
jne 0xf2cf
testb %r14b, %r14b
je 0xf2f3
movb $0x0, (%r15)
movq 0x40(%rbx), %r15
incq 0x28(%rbx)
cmpb $0x0, (%r15)
je 0xf242
jmp 0xf311
movq 0x40(%rbx), %rax
xorl %r15d, %r15d
cmpb $0x0, (%rax)
cmovneq %rax, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/Dimension.cpp
// Function: Dimension::insert(unsigned long, double)
const Dimension& Dimension::insert(size_t dp, double value)
{
	values.insert(value);
	dp_index.insert(pair<size_t, size_t>(dp, dps.size()));
	dps.push_back(DataPoint(dp, value));

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %r15
movsd %xmm0, (%r15)
movq %r15, %rsi
callq 0xfaa8
leaq 0x30(%rbx), %rdi
movq 0x68(%rbx), %rax
subq 0x60(%rbx), %rax
sarq $0x4, %rax
leaq -0x30(%rbp), %r12
movq %r14, (%r12)
movq %rax, 0x8(%r12)
movq %r12, %rsi
callq 0xebc8
movsd (%r15), %xmm0
movq %r14, (%r12)
movsd %xmm0, 0x8(%r12)
movq 0x68(%rbx), %rsi
cmpq 0x70(%rbx), %rsi
je 0xf849
movups -0x30(%rbp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x68(%rbx)
jmp 0xf856
leaq 0x60(%rbx), %rdi
leaq -0x30(%rbp), %rdx
callq 0xfbd2
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/Dimension.cpp
// Function: Dimension::get_value(unsigned long) const
double Dimension::get_value(size_t dp) const
{
	map<size_t, size_t>::const_iterator mit = dp_index.find(dp);
	if(mit == dp_index.end())
		return -1;

	return dps[mit->second].value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x40(%rdi), %rcx
movsd 0xa3bc(%rip), %xmm0     # 0x19d30
testq %rcx, %rcx
je 0xf9b6
leaq 0x38(%rdi), %rdx
movq %rdx, %rax
xorl %r8d, %r8d
cmpq %rsi, 0x20(%rcx)
setb %r8b
cmovaeq %rcx, %rax
movq 0x10(%rcx,%r8,8), %rcx
testq %rcx, %rcx
jne 0xf980
cmpq %rdx, %rax
je 0xf9b6
cmpq %rsi, 0x20(%rax)
ja 0xf9b6
movq 0x28(%rax), %rax
movq 0x60(%rdi), %rcx
shlq $0x4, %rax
movsd 0x8(%rcx,%rax), %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/ClusterData.cpp
// Function: ClusterData::get_dimension(unsigned long) const
const Dimension& ClusterData::get_dimension(size_t index) const
{
	if((index == 0) || (index >= dimensions.size())) {
		char s[2048];
		sprintf(s, "%s (%d): illegal dimension index %lu, should be in the range of [0, %lu]", __FILE__, __LINE__, index, dimensions.size()-1);
		throw invalid_argument(s);
	}

	return *(dimensions[index]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rsi, %r8
movq (%rdi), %rax
movq 0x8(%rdi), %r9
subq %rax, %r9
sarq $0x3, %r9
testq %rsi, %rsi
je 0xfe8d
cmpq %r8, %r9
jbe 0xfe8d
movq (%rax,%r8,8), %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %rbp
retq
decq %r9
leaq 0xa1b0(%rip), %rsi      # 0x1a047
leaq 0x9f00(%rip), %rdx      # 0x19d9e
leaq -0x810(%rbp), %r14
movq %r14, %rdi
movl $0xbf, %ecx
xorl %eax, %eax
callq 0x5090
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x5730
movq 0x120f5(%rip), %rsi     # 0x21fc8
movq 0x120de(%rip), %rdx     # 0x21fb8
movq %rbx, %rdi
callq 0x5660
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x56a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/ClusterData.cpp
// Function: ClusterData::get_dimension(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
const Dimension& ClusterData::get_dimension(string dname) const
{
	auto it=dimensions.begin();
	for(++it; it!=dimensions.end() && ((*it)->get_dimension_name() != dname); it++)
		;

	if(it == dimensions.end()) {
		char s[2048];
		sprintf(s, "%s (%d): could not find dimension %s", __FILE__, __LINE__, dname.c_str());
		throw invalid_argument(s);
	}

	return **it;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r13
addq $0x8, %r13
cmpq 0x8(%r14), %r13
je 0x11092
movq (%r13), %rax
leaq -0x820(%rbp), %rcx
movq %rcx, -0x830(%rbp)
movq 0x80(%rax), %rsi
movq 0x88(%rax), %rdx
addq %rsi, %rdx
leaq -0x830(%rbp), %rdi
callq 0xb188
movq -0x828(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x11042
movq -0x830(%rbp), %r12
testq %rdx, %rdx
je 0x1104e
movq (%rbx), %rsi
movq %r12, %rdi
callq 0x53b0
testl %eax, %eax
setne %r15b
jmp 0x11051
movb $0x1, %r15b
movq -0x830(%rbp), %r12
jmp 0x11051
xorl %r15d, %r15d
leaq -0x820(%rbp), %rax
cmpq %rax, %r12
je 0x11065
movq %r12, %rdi
callq 0x5340
addq $0x8, %r13
testb %r15b, %r15b
jne 0x10fdd
addq $-0x8, %r13
cmpq 0x8(%r14), %r13
je 0x11092
movq (%r13), %rax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %r8
leaq 0x8f86(%rip), %rsi      # 0x1a022
leaq 0x8cfb(%rip), %rdx      # 0x19d9e
leaq -0x830(%rbp), %r14
movq %r14, %rdi
movl $0xb3, %ecx
xorl %eax, %eax
callq 0x5090
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x5730
movq 0x10ef0(%rip), %rsi     # 0x21fc8
movq 0x10ed9(%rip), %rdx     # 0x21fb8
movq %rbx, %rdi
callq 0x5660
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/ClusterWriter.cpp
// Function: ClusterWriter::write(ClusterData const&, std::set<unsigned long, std::less<unsigned long>, std::allocator<unsigned long>> const&, std::unordered_set<unsigned long, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<unsigned long>> const&, char const*) const
void ClusterWriter::write(const ClusterData& clustering_db, const set<size_t>& scafs, const unordered_set<size_t>& raw_dps, const char* cluster_name) const
{
	char	scaf_stats_file[1024] = {};
	char	scaf_file[1024] = {};

	sprintf(scaf_stats_file, "%s/%s.scaf-stats.txt", out_dir.c_str(), cluster_name);
	sprintf(scaf_file, "%s/%s.scaf-cluster.txt", out_dir.c_str(), cluster_name);

	this->write_clustering_info_file(clustering_db, cluster_name);
	this->write_scaffold_stats(clustering_db, scafs, raw_dps, scaf_stats_file);
	this->write_scaffolds(scafs, scaf_file, cluster_name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movq %r8, %rbx
movq %rcx, -0x38(%rbp)
movq %rdx, %r14
movq %rsi, -0x30(%rbp)
movq %rdi, %r15
leaq -0x840(%rbp), %r12
movl $0x400, %edx            # imm = 0x400
movq %r12, %rdi
xorl %esi, %esi
callq 0x51f0
leaq -0x440(%rbp), %r13
movl $0x400, %edx            # imm = 0x400
movq %r13, %rdi
xorl %esi, %esi
callq 0x51f0
movq 0x8(%r15), %rdx
leaq 0x87c4(%rip), %rsi      # 0x1a090
movq %r12, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x5090
movq 0x8(%r15), %rdx
leaq 0x87c1(%rip), %rsi      # 0x1a0a5
movq %r13, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x5090
movq (%r15), %rax
movq %r15, %rdi
movq -0x30(%rbp), %rsi
movq %rbx, %rdx
callq *(%rax)
movq %r15, %rdi
movq %r14, %rdx
movq -0x38(%rbp), %rcx
movq %r12, %r8
callq 0x11936
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x11d06
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/ClusterWriter.cpp
// Function: ClusterWriter::write_scaffolds(std::set<unsigned long, std::less<unsigned long>, std::allocator<unsigned long>> const&, char const*, char const*) const
void ClusterWriter::write_scaffolds(const set<size_t>& scafs, const char* out_file, const char* cluster_name) const
{
        FILE* fp = fopen(out_file, "w");
	if(fp == NULL) {
		cerr << "Fatal error, " << __FILE__ << " (" << __LINE__ << "): could write to file " << out_file << endl << endl;
		exit(-1);
	}

	for(auto vit = scafs.begin(); vit != scafs.end(); vit++)
		fprintf(fp, "%s\t%s\n", scaf_db.scaf_id2name(*vit).c_str(), cluster_name);
	fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8392(%rip), %rsi      # 0x1a0bc
movq %rdx, %rdi
callq 0x5450
testq %rax, %rax
je 0x11da9
movq %rax, %r12
movq 0x18(%r14), %r13
addq $0x8, %r14
cmpq %r14, %r13
je 0x11d92
movq 0x28(%r15), %rsi
movq 0x20(%r13), %rdx
leaq -0x48(%rbp), %rdi
callq 0xcd9c
movq -0x48(%rbp), %rdx
movq %r12, %rdi
leaq 0x8394(%rip), %rsi      # 0x1a0fa
movq %rbx, %rcx
xorl %eax, %eax
callq 0x5540
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x11d82
callq 0x5340
movq %r13, %rdi
callq 0x5430
movq %rax, %r13
cmpq %r14, %rax
jne 0x11d47
movq %r12, %rdi
callq 0x5390
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10238(%rip), %rdi     # 0x21fe8
leaq 0x8307(%rip), %rsi      # 0x1a0be
callq 0x5380
leaq 0x8309(%rip), %rsi      # 0x1a0cc
movq %rax, %rdi
callq 0x5380
leaq 0x815b(%rip), %rsi      # 0x19f2d
movq %rax, %rdi
callq 0x5380
movq %rax, %rdi
movl $0x1a, %esi
callq 0x5670
leaq 0x82f4(%rip), %rsi      # 0x1a0e2
movq %rax, %rdi
callq 0x5380
movq %rax, %rdi
movq %r13, %rsi
callq 0x5380
movq %rax, %rdi
callq 0x51a0
movq %rax, %rdi
callq 0x51a0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x5480
nop
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/Cluster.cpp
// Function: Cluster::operator+=(unsigned long)
const Cluster& Cluster::operator += (size_t dp)
{
	if(dps.find(dp) != dps.end())
		return *this;
	dps.insert(dp);

	size_t scaf = scaf_db.dp2scaf(dp);
	map<size_t, size_t>::iterator mit = scaf2ndps.find(scaf);
	if(mit == scaf2ndps.end())
		scaf2ndps.insert(pair<size_t, size_t>(scaf, 1));
	else
		mit->second++;

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x20(%rbp), %rax
movq %rsi, (%rax)
leaq 0x38(%rdi), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1235e
testq %rax, %rax
jne 0x12263
leaq -0x30(%rbp), %rdx
movq %r14, (%rdx)
leaq -0x20(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x115d2
movq (%rbx), %rdi
movq (%r15), %rsi
callq 0xcc30
movq 0x18(%rbx), %rdx
testq %rdx, %rdx
je 0x1224b
leaq 0x10(%rbx), %rsi
movq %rsi, %rcx
xorl %edi, %edi
cmpq %rax, 0x20(%rdx)
setb %dil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x12228
cmpq %rsi, %rcx
je 0x1224b
cmpq 0x20(%rcx), %rax
jae 0x12271
leaq 0x8(%rbx), %rdi
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movq $0x1, 0x8(%rsi)
callq 0xebc8
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
incq 0x28(%rcx)
jmp 0x12263
nop
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/Cluster.cpp
// Function: Cluster::operator-=(unsigned long)
const Cluster& Cluster::operator -= (size_t dp)
{
	if(dps.find(dp) == dps.end())
		return *this;
	dps.erase(dp);

	size_t scaf = scaf_db.dp2scaf(dp);
	map<size_t, size_t>::iterator mit = scaf2ndps.find(scaf);
	if(mit->second == 1)
		scaf2ndps.erase(mit);
	else
		mit->second--;

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x20(%rbp), %rax
movq %rsi, (%rax)
leaq 0x38(%rdi), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1235e
testq %rax, %rax
je 0x1234f
leaq -0x20(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x123c0
movq (%rbx), %rdi
movq (%r15), %rsi
callq 0xcc30
movq 0x18(%rbx), %rcx
leaq 0x10(%rbx), %rsi
testq %rcx, %rcx
je 0x12333
movq %rsi, %rdx
xorl %edi, %edi
cmpq %rax, 0x20(%rcx)
setb %dil
cmovaeq %rcx, %rdx
movq 0x10(%rcx,%rdi,8), %rcx
testq %rcx, %rcx
jne 0x1230e
cmpq %rsi, %rdx
je 0x12333
cmpq 0x20(%rdx), %rax
cmovaeq %rdx, %rsi
movq 0x28(%rsi), %rax
cmpq $0x1, %rax
jne 0x12348
leaq 0x8(%rbx), %rdi
callq 0x124b4
jmp 0x1234f
decq %rax
movq %rax, 0x28(%rsi)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/misc.cpp
// Function: get_time()
const char* get_time()
{
	static int epoch = time(NULL);
	static char str[128];
	int t = time(NULL) - epoch;

	sprintf(str, "%02i%c%02i%c%02i", t/3600, ':', (t%3600)/60, ':', t%60);

	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movb 0xfef4(%rip), %al       # 0x223f8
testb %al, %al
je 0x125a8
xorl %edi, %edi
callq 0x5330
subl 0xfedb(%rip), %eax      # 0x223f4
cltq
imulq $-0x6e5d4c3b, %rax, %rdx # imm = 0x91A2B3C5
shrq $0x20, %rdx
addl %eax, %edx
movl %edx, %ecx
shrl $0x1f, %ecx
sarl $0xb, %edx
addl %ecx, %edx
imull $0xe10, %edx, %ecx      # imm = 0xE10
movl %eax, %esi
subl %ecx, %esi
movswl %si, %ecx
imull $0xffff8889, %ecx, %ecx # imm = 0xFFFF8889
shrl $0x10, %ecx
addl %esi, %ecx
movzwl %cx, %ecx
movswl %cx, %esi
shrl $0xf, %ecx
sarl $0x5, %esi
addl %ecx, %esi
movswl %si, %r8d
imulq $-0x77777777, %rax, %rcx # imm = 0x88888889
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %esi
shrl $0x1f, %esi
sarl $0x5, %ecx
addl %esi, %ecx
imull $0x3c, %ecx, %ecx
subl %ecx, %eax
movl %eax, (%rsp)
leaq 0xfe7e(%rip), %rbx      # 0x22400
leaq 0x7c27(%rip), %rsi      # 0x1a1b0
movq %rbx, %rdi
movl $0x3a, %ecx
movl $0x3a, %r9d
xorl %eax, %eax
callq 0x5090
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x5846
jmp 0x1250c
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/misc.cpp
// Function: MonteCarlo::Random()
size_t Random()
{
        static tinymt32_t* tinymt = NULL;                               // Random Number Geberator
        if(tinymt == NULL) {
                tinymt = new tinymt32_t();
                tinymt->mat1 = strtoul("8f7011ee", NULL, 16);
                tinymt->mat2 = strtoul("fc78ff1f", NULL, 16);
                tinymt->tmat = strtoul("3793fdff", NULL, 16);
                srand(time(NULL));
                tinymt32_init(tinymt, rand());
        }
        return(tinymt32_generate_uint32(tinymt));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0xfec1(%rip), %rcx      # 0x22480
testq %rcx, %rcx
jne 0x1261b
movl $0x1c, %edi
callq 0x53a0
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %rax, 0xfea5(%rip)      # 0x22480
movabsq $-0x38700e0708fee12, %rcx # imm = 0xFC78FF1F8F7011EE
movq %rcx, 0x10(%rax)
movl $0x3793fdff, 0x18(%rax) # imm = 0x3793FDFF
xorl %edi, %edi
callq 0x5330
movl %eax, %edi
callq 0x5350
movq 0xfe7b(%rip), %rbx      # 0x22480
callq 0x50d0
movq %rbx, %rdi
movl %eax, %esi
callq 0xb978
movq 0xfe65(%rip), %rcx      # 0x22480
movl 0xc(%rcx), %eax
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
andl (%rcx), %esi
movl 0x4(%rcx), %edx
movl 0x8(%rcx), %edi
movl %edx, %r8d
xorl %edi, %r8d
xorl %esi, %r8d
leal (%r8,%r8), %r9d
xorl %r8d, %r9d
movl %eax, %esi
shrl %esi
xorl %eax, %esi
xorl %r9d, %esi
movl %edx, (%rcx)
movl %esi, %eax
shll $0xa, %eax
movl %esi, 0xc(%rcx)
movl %esi, %r8d
andl $0x1, %r8d
negl %r8d
movl 0x10(%rcx), %r10d
andl %r8d, %r10d
xorl %edi, %r10d
movl %r10d, 0x4(%rcx)
andl 0x14(%rcx), %r8d
xorl %r9d, %eax
xorl %r8d, %eax
movl %eax, 0x8(%rcx)
shrl $0x8, %eax
addl %edx, %eax
xorl %eax, %esi
andl $0x1, %eax
negl %eax
andl 0x18(%rcx), %eax
xorl %esi, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/misc.cpp
// Function: MonteCarlo::shuffle(std::vector<unsigned long, std::allocator<unsigned long>>&)
void shuffle(vector<size_t>& values)
{
	for(size_t i=values.size()-1; i>0; i--) {
		size_t j = Random()%i;
		size_t t = values[i];
		values[i] = values[j];
		values[j] = t;
	}  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdi), %r14
subq (%rdi), %r14
sarq $0x3, %r14
decq %r14
je 0x126c7
movq %rdi, %rbx
callq 0x125b2
xorl %edx, %edx
divq %r14
movq (%rbx), %rax
movq (%rax,%r14,8), %rcx
movq (%rax,%rdx,8), %rsi
movq %rsi, (%rax,%r14,8)
movq %rcx, (%rax,%rdx,8)
decq %r14
jne 0x126a5
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/misc.cpp
// Function: MonteCarlo::shuffle(unsigned long*, unsigned long)
void shuffle(size_t* values, size_t n)
{
	while(--n > 0) {
		size_t j = Random()%n;
		size_t t = values[n];
		values[n] = values[j];
		values[j] = t;
	}  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
decq %rbx
je 0x126fd
movq %rdi, %r14
callq 0x125b2
xorl %edx, %edx
divq %rbx
movq (%r14,%rbx,8), %rax
movq (%r14,%rdx,8), %rcx
movq %rcx, (%r14,%rbx,8)
movq %rax, (%r14,%rdx,8)
decq %rbx
jne 0x126de
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/misc.cpp
// Function: MonteCarlo::Distribution::operator+=(unsigned long)
const Distribution& Distribution::operator += (size_t val)
{
	// Need to enlarge values
	if(n+1>values_size) {
cerr << "Reallocating" << endl;
		values = (size_t*)realloc(values, 2*values_size*sizeof(size_t));
		values_size *= 2;
cerr << "Done reallocating" << endl;
	}
	
	// values is sorted and we want to keep it that way
	size_t* p;
	for(p=values+n-1; (p >= values) && (val < *p); p--)
		*(p+1) = *p;

	// If we stopped somewhere in the middle or the end, or if we stopped at the beginning but the first 
	// value is smaller than val - insert to *(p+1)
	if(p!=values || val>*p)
		*(p+1) = val;
	else
		*p = val;
	n++;
	
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
leaq 0x1(%rcx), %rax
cmpq 0x10(%rdi), %rax
jbe 0x127bc
movq 0xf8bd(%rip), %r15      # 0x21fe8
leaq 0x7a8f(%rip), %rsi      # 0x1a1c1
movl $0xc, %edx
movq %r15, %rdi
callq 0x5420
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5360
movsbl %al, %esi
movq %r15, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5250
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
shlq $0x4, %rsi
callq 0x5620
movq %rax, (%rbx)
shlq 0x10(%rbx)
leaq 0x7a4a(%rip), %rsi      # 0x1a1ce
movl $0x11, %edx
movq %r15, %rdi
callq 0x5420
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5360
movsbl %al, %esi
movq %r15, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5250
movq 0x8(%rbx), %rcx
movq (%rbx), %rax
leaq (%rax,%rcx,8), %rdx
leaq (%rax,%rcx,8), %rsi
addq $-0x8, %rsi
cmpq %rax, %rsi
jb 0x127f6
movq -0x8(%rdx), %rcx
cmpq %r14, %rcx
jbe 0x127f2
movq %rcx, (%rdx)
leaq -0x8(%rdx), %rcx
addq $-0x10, %rdx
cmpq %rax, %rdx
movq %rcx, %rdx
jae 0x127d0
leaq -0x8(%rcx), %rsi
jmp 0x127f9
leaq -0x8(%rdx), %rsi
movq %rdx, %rcx
cmpq %rax, %rsi
jne 0x12805
cmpq %r14, (%rax)
cmovaeq %rax, %rcx
movq %r14, (%rcx)
incq 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/misc.cpp
// Function: MonteCarlo::Distribution::cdf(unsigned long) const
double Distribution::cdf(size_t val) const
{
	// Easy cases
	if(val < *values)
		return 0;
	else if(val >= values[n-1])
		return 1;

	// We have to search distribution (modified binary search)
	size_t	imin=0, imax=n-1;
	while (imax >= imin)
	{
		/* calculate the midpoint for roughly equal partition */
      		int imid = (imin + imax) / 2;
 
      		// determine which subarray to search
      		if(values[imid] <= val)
		        imin = imid + 1;
     		 else if(values[imid] > val)
		        imax = imid - 1;
	}
	
	// imin must point to the variable before the one we are looking for
	return double(imin)/n;
}

// Assembly:
movq (%rdi), %rcx
xorpd %xmm0, %xmm0
cmpq %rsi, (%rcx)
ja 0x128d3
movq 0x8(%rdi), %rax
cmpq %rsi, -0x8(%rcx,%rax,8)
jbe 0x128d4
pushq %rbp
movq %rsp, %rbp
leaq -0x1(%rax), %r9
xorl %r8d, %r8d
movabsq $0x100000000, %rdx      # imm = 0x100000000
movabsq $-0x100000000, %rdi     # imm = 0xFFFFFFFF00000000
leaq (%r9,%r8), %r10
shlq $0x1f, %r10
movq %r10, %r11
sarq $0x1d, %r11
andq $-0x8, %r11
cmpq %rsi, (%rcx,%r11)
ja 0x1287d
addq %rdx, %r10
sarq $0x20, %r10
movq %r10, %r8
jmp 0x12887
addq %rdi, %r10
sarq $0x20, %r10
movq %r10, %r9
cmpq %r8, %r9
jae 0x12858
movq %r8, %xmm1
movq 0x78f7(%rip), %xmm2     # 0x1a190
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x78fb(%rip), %xmm3     # 0x1a1a0
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
popq %rbp
retq
movsd 0x78ac(%rip), %xmm0     # 0x1a188
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/ClusterSeparator.cpp
// Function: ClusterSeparator::reconstruct_best_clusters()
void ClusterSeparator::reconstruct_best_clusters()
{
	if(!this->is_best_separation_legal())
		return;

	const Dimension& 		dimension = clustering_db.get_dimension(this->get_separating_dimension());

	this->cluster1 = new Cluster(scaf_db);
	this->cluster2 = new Cluster(scaf_db);

	size_t cluster1_useful_ndps=0, cluster2_useful_ndps=0;
	for(vector<Dimension::DataPoint>::const_iterator vit = dimension.begin(); vit!=dimension.end(); vit++) {
		int useful = (scaf_db.ndps(scaf_db.dp2scaf(vit->dp)) > 1)? 1 : 0;

		if(vit->value <= this->get_separating_value()) {
			*(this->cluster1) += vit->dp;
			cluster1_useful_ndps += useful;
		}
		else {
			*(this->cluster2) += vit->dp;
			cluster2_useful_ndps += useful;
		}
	}

	if(cluster2_useful_ndps < cluster1_useful_ndps) {
		Cluster* temp = this->cluster1;
		this->cluster1 = this->cluster2;
		this->cluster2 = temp;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xa8(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x12ae6
movq 0x18(%rbx), %rdi
movq 0xa8(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0xfe54
movq %rax, %r13
movl $0xa0, %edi
callq 0x53a0
movq 0x8(%rbx), %r15
movq %r15, (%rax)
leaq 0x10(%rax), %rcx
xorl %r14d, %r14d
movl %r14d, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rcx, 0x28(%rax)
movq %r14, 0x30(%rax)
leaq 0x68(%rax), %rcx
movq %rcx, 0x38(%rax)
movl $0x1, %ecx
movq %rcx, 0x40(%rax)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x48(%rax)
movl $0x3f800000, %r12d      # imm = 0x3F800000
movl %r12d, 0x58(%rax)
movupd %xmm0, 0x60(%rax)
leaq 0x78(%rax), %rcx
movl %r14d, 0x78(%rax)
movq %r14, 0x80(%rax)
movq %rcx, 0x88(%rax)
movq %rcx, 0x90(%rax)
movq %r14, 0x98(%rax)
movq %rax, 0x28(%rbx)
movl $0xa0, %edi
callq 0x53a0
movq %r15, (%rax)
leaq 0x10(%rax), %rcx
movl %r14d, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rcx, 0x28(%rax)
movq %r14, 0x30(%rax)
leaq 0x68(%rax), %rcx
movq %rcx, 0x38(%rax)
movl $0x1, %ecx
movq %rcx, 0x40(%rax)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x48(%rax)
movl %r12d, 0x58(%rax)
movupd %xmm0, 0x60(%rax)
leaq 0x78(%rax), %rcx
movl %r14d, 0x78(%rax)
movq %r14, 0x80(%rax)
movq %rcx, 0x88(%rax)
movq %rcx, 0x90(%rax)
movq %r14, 0x98(%rax)
movq %rax, 0x30(%rbx)
movq 0x60(%r13), %r12
movq %r13, -0x30(%rbp)
cmpq 0x68(%r13), %r12
je 0x12ae6
xorl %r13d, %r13d
xorl %r14d, %r14d
movq 0x8(%rbx), %r15
movq (%r12), %rsi
movq %r15, %rdi
callq 0xcc30
movq %r15, %rdi
movq %rax, %rsi
callq 0xcce6
xorl %r15d, %r15d
cmpq $0x2, %rax
setae %r15b
movq 0xa8(%rbx), %rax
movsd 0x10(%rax), %xmm0
ucomisd 0x8(%r12), %xmm0
movq (%r12), %rsi
jae 0x12ab7
movq 0x30(%rbx), %rdi
callq 0x121cc
addq %r15, %r14
jmp 0x12ac3
movq 0x28(%rbx), %rdi
callq 0x121cc
addq %r15, %r13
addq $0x10, %r12
movq -0x30(%rbp), %rax
cmpq 0x68(%rax), %r12
jne 0x12a6a
cmpq %r13, %r14
jae 0x12ae6
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/ClusterSeparatorBySensitivitySpecificity.cpp
// Function: ClusterSeparatorBySensitivitySpecificity::ClusterStats::add_dp(unsigned long)
const ClusterSeparator::ClusterStats& ClusterSeparatorBySensitivitySpecificity::ClusterStats::add_dp(size_t dp)
{
	size_t	scaf = scaf_db.dp2scaf(dp);

	if(scaf_db.ndps(scaf) < 2)
		return *this;

	cluster += dp;

	if(cluster.assigned(scaf))
		true_positives++;
	else
		false_positives++;

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xcc30
movq %rax, %r14
movq 0x8(%rbx), %rdi
movq %rax, %rsi
callq 0xcce6
cmpq $0x2, %rax
jb 0x131d5
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x121cc
movq 0x10(%rbx), %rax
movq 0x80(%rax), %rcx
testq %rcx, %rcx
je 0x131cd
addq $0x78, %rax
movq %rax, %rdx
xorl %esi, %esi
cmpq %r14, 0x20(%rcx)
setb %sil
cmovaeq %rcx, %rdx
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x131a5
cmpq %rax, %rdx
je 0x131cd
movl $0x18, %eax
cmpq %r14, 0x20(%rdx)
jbe 0x131d2
movl $0x20, %eax
incl (%rbx,%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/ClusterSeparatorBySensitivitySpecificity.cpp
// Function: ClusterSeparatorBySensitivitySpecificity::ClusterStats::remove_dp(unsigned long)
const ClusterSeparator::ClusterStats& ClusterSeparatorBySensitivitySpecificity::ClusterStats::remove_dp(size_t dp)
{
	size_t	scaf = scaf_db.dp2scaf(dp);

	if(scaf_db.ndps(scaf) < 2)
		return *this;

	cluster -= dp;

	if(cluster.assigned(scaf))
		true_positives--;
	else
		false_positives--;

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xcc30
movq %rax, %r14
movq 0x8(%rbx), %rdi
movq %rax, %rsi
callq 0xcce6
cmpq $0x2, %rax
jb 0x13265
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x122bc
movq 0x10(%rbx), %rax
movq 0x80(%rax), %rcx
testq %rcx, %rcx
je 0x1325d
addq $0x78, %rax
movq %rax, %rdx
xorl %esi, %esi
cmpq %r14, 0x20(%rcx)
setb %sil
cmovaeq %rcx, %rdx
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x13235
cmpq %rax, %rdx
je 0x1325d
movl $0x18, %eax
cmpq %r14, 0x20(%rdx)
jbe 0x13262
movl $0x20, %eax
decl (%rbx,%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/ClusterSeparatorBySensitivitySpecificity.cpp
// Function: ClusterSeparatorBySensitivitySpecificity::ClusterStats::assign_scaf(unsigned long)
const ClusterSeparator::ClusterStats& ClusterSeparatorBySensitivitySpecificity::ClusterStats::assign_scaf(size_t scaf)
{
	size_t  scaf_total_ndps = scaf_db.ndps(scaf);

	if(cluster.assigned(scaf) || (scaf_total_ndps < 2))
		return *this;

	auto    mit = cluster.scafs_find(scaf);
	size_t  cluster_ndps = (mit == cluster.scafs_end())? 0 : mit->second;

	cluster.add_assigned_scaf(scaf);
	false_positives -= cluster_ndps;
	true_positives += cluster_ndps;
	total_dps_for_assigned_scafs += scaf_total_ndps;

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xcce6
movq %rax, %r14
movq 0x10(%rbx), %rdi
movq 0x80(%rdi), %rdx
leaq 0x78(%rdi), %rax
movq %rax, %rsi
testq %rdx, %rdx
je 0x132da
movq %rax, %rcx
xorl %esi, %esi
cmpq %r15, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x132af
movq %rax, %rsi
cmpq %rax, %rcx
je 0x132da
cmpq %r15, 0x20(%rcx)
cmovaq %rax, %rcx
movq %rcx, %rsi
cmpq $0x2, %r14
jb 0x1333b
cmpq %rax, %rsi
jne 0x1333b
movq 0x18(%rdi), %rcx
xorl %r12d, %r12d
testq %rcx, %rcx
je 0x1331f
leaq 0x10(%rdi), %rdx
movq %rdx, %rax
xorl %esi, %esi
cmpq %r15, 0x20(%rcx)
setb %sil
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x132f8
cmpq %rdx, %rax
je 0x1331f
cmpq %r15, 0x20(%rax)
ja 0x1331f
movl 0x28(%rax), %r12d
leaq -0x28(%rbp), %rsi
movq %r15, (%rsi)
addq $0x70, %rdi
callq 0xb066
subl %r12d, 0x20(%rbx)
addl %r12d, 0x18(%rbx)
addl %r14d, 0x1c(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/ClusterSeparatorBySensitivitySpecificity.cpp
// Function: ClusterSeparatorBySensitivitySpecificity::ClusterStats::unassign_scaf(unsigned long)
const ClusterSeparator::ClusterStats& ClusterSeparatorBySensitivitySpecificity::ClusterStats::unassign_scaf(size_t scaf)
{
	size_t  scaf_total_ndps = scaf_db.ndps(scaf);
	if(!cluster.assigned(scaf) || (scaf_total_ndps < 2))
		return *this;

	auto    mit = cluster.scafs_find(scaf);
	size_t  cluster_ndps = (mit == cluster.scafs_end())? 0 : mit->second;

	cluster.remove_assigned_scaf(scaf);
	false_positives += cluster_ndps;
	true_positives -= cluster_ndps;
	total_dps_for_assigned_scafs -= scaf_total_ndps;

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xcce6
movq 0x10(%rbx), %r15
movq 0x80(%r15), %rcx
testq %rcx, %rcx
je 0x13414
movq %rax, %r14
leaq 0x78(%r15), %rdx
movq %rdx, %rax
xorl %esi, %esi
cmpq %r12, 0x20(%rcx)
setb %sil
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x13387
cmpq %rdx, %rax
je 0x13414
cmpq $0x2, %r14
jb 0x13414
cmpq %r12, 0x20(%rax)
ja 0x13414
movq 0x18(%r15), %rcx
xorl %r13d, %r13d
testq %rcx, %rcx
je 0x133ea
leaq 0x10(%r15), %rdx
movq %rdx, %rax
xorl %esi, %esi
cmpq %r12, 0x20(%rcx)
setb %sil
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x133c3
cmpq %rdx, %rax
je 0x133ea
cmpq %r12, 0x20(%rax)
ja 0x133ea
movl 0x28(%rax), %r13d
leaq -0x30(%rbp), %rsi
movq %r12, (%rsi)
addq $0x70, %r15
movq %r15, %rdi
callq 0x13d04
movq %r15, %rdi
movq %rax, %rsi
callq 0x13d8c
addl %r13d, 0x20(%rbx)
subl %r13d, 0x18(%rbx)
subl %r14d, 0x1c(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/ClusterSeparatorBySensitivitySpecificity.cpp
// Function: operator<<(std::ostream&, ClusterSeparatorBySensitivitySpecificity&)
ostream& operator << (ostream& os, ClusterSeparatorBySensitivitySpecificity& cs)
{
	os << " Best separation:\t" << "dimension " << cs.get_separating_dimension() << " ("
		<< cs.clustering_db.get_dimension(cs.best_separation->get_dimension()).get_dimension_name() << ")\t"
		<< "Value " << cs.best_separation->get_value() << "\t"
		<< "Specificity " << static_cast<ClusterSeparatorBySensitivitySpecificity::ClusteringResult*>(cs.best_separation)->get_specificity() << "\t"
		<< "Sensitivity " << static_cast<ClusterSeparatorBySensitivitySpecificity::ClusteringResult*>(cs.best_separation)->get_sensitivity();

	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6e01(%rip), %rsi      # 0x1a245
movl $0x12, %edx
callq 0x5420
leaq 0x6930(%rip), %rsi      # 0x19d85
movl $0xa, %edx
movq %rbx, %rdi
callq 0x5420
movq 0xa8(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x5240
movq %rax, %r15
leaq 0x6aae(%rip), %rsi      # 0x19f2d
movl $0x2, %edx
movq %rax, %rdi
callq 0x5420
movq 0x18(%r14), %rdi
movq 0xa8(%r14), %rax
movq 0x8(%rax), %rsi
callq 0xfe54
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x80(%rax), %rsi
movq 0x88(%rax), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0xb188
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x5420
movq %rax, %r15
leaq 0x6d78(%rip), %rsi      # 0x1a258
movl $0x2, %edx
movq %rax, %rdi
callq 0x5420
leaq 0x6d67(%rip), %rsi      # 0x1a25b
movl $0x6, %edx
movq %r15, %rdi
callq 0x5420
movq 0xa8(%r14), %rax
movsd 0x10(%rax), %xmm0
movq %r15, %rdi
callq 0x55f0
movq %rax, %r15
leaq 0x6d3a(%rip), %rsi      # 0x1a259
movl $0x1, %edx
movq %rax, %rdi
callq 0x5420
leaq 0x6d2f(%rip), %rsi      # 0x1a262
movl $0xc, %edx
movq %r15, %rdi
callq 0x5420
movq 0xa8(%r14), %rax
movsd 0x20(%rax), %xmm0
movq %r15, %rdi
callq 0x55f0
movq %rax, %r15
leaq 0x6cfb(%rip), %rsi      # 0x1a259
movl $0x1, %edx
movq %rax, %rdi
callq 0x5420
leaq 0x6cfd(%rip), %rsi      # 0x1a26f
movl $0xc, %edx
movq %r15, %rdi
callq 0x5420
movq 0xa8(%r14), %rax
movsd 0x18(%rax), %xmm0
movq %r15, %rdi
callq 0x55f0
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x135a1
callq 0x5340
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x135c4
callq 0x5340
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/ClusterSeparatorSplitScafs.cpp
// Function: operator<<(std::ostream&, ClusterSeparatorSplitScafs&)
ostream& operator << (ostream& os, ClusterSeparatorSplitScafs& cs)
{
        os << " Best separation:\t" << "dimension " << cs.get_separating_dimension() << " ("
                << cs.clustering_db.get_dimension(cs.get_separating_dimension()).get_dimension_name() << ")\t"
                << "Value " << cs.get_separating_value() << "\t"
                << "best split scaf ratio " << cs.get_best_split_scaf_ratio() << endl;

	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x594f(%rip), %rsi      # 0x1a245
movl $0x12, %edx
callq 0x5420
leaq 0x547e(%rip), %rsi      # 0x19d85
movl $0xa, %edx
movq %rbx, %rdi
callq 0x5420
movq 0xa8(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x5240
movq %rax, %r15
leaq 0x55fc(%rip), %rsi      # 0x19f2d
movl $0x2, %edx
movq %rax, %rdi
callq 0x5420
movq 0x18(%r14), %rdi
movq 0xa8(%r14), %rax
movq 0x8(%rax), %rsi
callq 0xfe54
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x80(%rax), %rsi
movq 0x88(%rax), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0xb188
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x5420
movq %rax, %r15
leaq 0x58c6(%rip), %rsi      # 0x1a258
movl $0x2, %edx
movq %rax, %rdi
callq 0x5420
leaq 0x58b5(%rip), %rsi      # 0x1a25b
movl $0x6, %edx
movq %r15, %rdi
callq 0x5420
movq 0xa8(%r14), %rax
movsd 0x10(%rax), %xmm0
movq %r15, %rdi
callq 0x55f0
movq %rax, %r15
leaq 0x5888(%rip), %rsi      # 0x1a259
movl $0x1, %edx
movq %rax, %rdi
callq 0x5420
leaq 0x599c(%rip), %rsi      # 0x1a381
movl $0x16, %edx
movq %r15, %rdi
callq 0x5420
movq %r14, %rdi
callq 0x15030
movq %r15, %rdi
callq 0x55f0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5360
movsbl %al, %esi
movq %r14, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5250
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x14a3a
callq 0x5340
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x14a5d
callq 0x5340
movq %rbx, %rdi
callq 0x56a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/ClusterSeparatorSplitScafs.h
// Function: ClusterSeparatorSplitScafs::ClusteringResult::is_better(ClusterSeparator::ClusteringResult const&) const
virtual bool		is_better(const ClusterSeparator::ClusteringResult& cr_) const override
		{
			const ClusteringResult& cr = dynamic_cast<const ClusteringResult&>(cr_);
			if(split_scaf_ratio != cr.split_scaf_ratio) return split_scaf_ratio < cr.split_scaf_ratio;
			if(cluster_size_ratio != cr.cluster_size_ratio) return cluster_size_ratio < cr.cluster_size_ratio;
			return ClusterSeparator::ClusteringResult::is_better(cr);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0xc7db(%rip), %rsi      # 0x21850
leaq 0xcc34(%rip), %rdx      # 0x21cb0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x5410
testq %rax, %rax
je 0x150ce
movsd 0x18(%rbx), %xmm0
movsd 0x18(%rax), %xmm1
ucomisd %xmm1, %xmm0
jne 0x150af
jp 0x150af
movsd 0x20(%rbx), %xmm0
movsd 0x20(%rax), %xmm1
ucomisd %xmm1, %xmm0
jne 0x150af
jnp 0x150bd
ucomisd %xmm0, %xmm1
seta %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x128f4
callq 0x5720
nop
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/SCGdb.cpp
// Function: SCGdb::num_unique_scgs(std::set<unsigned long, std::less<unsigned long>, std::allocator<unsigned long>> const&) const
size_t	SCGdb::num_unique_scgs(const set<size_t>& scafs) const
{
	set<string> scgs_found;

	for(auto it=scafs.begin(); it!=scafs.end(); it++) {
		auto mit = scaf2scgs.find(*it);
		if(mit == scaf2scgs.end())
			continue;
		scgs_found.insert(mit->second.begin(), mit->second.end());
	}

	return scgs_found.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
leaq -0x50(%rbp), %rax
movl $0x0, (%rax)
xorl %r12d, %r12d
movq %r12, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %r12, 0x20(%rax)
movq 0x18(%rsi), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x15230
movq %rdi, %r14
leaq 0x48(%rdi), %r13
leaq -0x58(%rbp), %r12
movq 0x50(%r14), %rcx
testq %rcx, %rcx
je 0x1521c
movq 0x20(%r15), %rax
movq %r13, %rdx
xorl %esi, %esi
cmpq %rax, 0x20(%rcx)
setb %sil
cmovaeq %rcx, %rdx
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x151e9
cmpq %r13, %rdx
je 0x1521c
cmpq 0x20(%rdx), %rax
jb 0x1521c
movq 0x40(%rdx), %rsi
addq $0x30, %rdx
movq %r12, %rdi
callq 0x15aa8
movq %r15, %rdi
callq 0x5430
movq %rax, %r15
cmpq %rbx, %rax
jne 0x151d9
movq -0x30(%rbp), %r12
leaq -0x58(%rbp), %rdi
callq 0x9852
movq %r12, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x9852
movq %rbx, %rdi
callq 0x56a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/SCGdb.cpp
// Function: SCGdb::get_scg2count(std::set<unsigned long, std::less<unsigned long>, std::allocator<unsigned long>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long, std::less<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, unsigned long>>>&) const
void SCGdb::get_scg2count(const set<size_t>& scafs, map<string, size_t>& result) const
{
	result.clear();

	for(auto it=scafs.begin(); it!=scafs.end(); it++) {
		auto mit = scaf2scgs.find(*it);
		if(mit == scaf2scgs.end())
			continue;
		for(auto scgit = mit->second.begin(); scgit!=mit->second.end(); scgit++) {
			auto rit = result.find(*scgit);
			if(rit == result.end()) {
				result.insert(pair<string, size_t>(*scgit, 0));
				rit = result.find(*scgit);
			}
			rit->second++;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, -0x40(%rbp)
movq %rdx, -0x30(%rbp)
movq %rdx, %rdi
callq 0x15dd0
movq 0x18(%r14), %rax
addq $0x8, %r14
movq %r14, -0x50(%rbp)
movq %rax, -0x38(%rbp)
cmpq %r14, %rax
je 0x15391
movq -0x40(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
leaq 0x8(%rax), %rbx
movq -0x40(%rbp), %rax
movq 0x50(%rax), %rcx
testq %rcx, %rcx
je 0x1537a
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x48(%rbp), %r13
xorl %edx, %edx
cmpq %rax, 0x20(%rcx)
setb %dl
cmovaeq %rcx, %r13
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x152ce
cmpq -0x48(%rbp), %r13
je 0x1537a
cmpq 0x20(%r13), %rax
jb 0x1537a
movq 0x40(%r13), %r15
addq $0x30, %r13
cmpq %r13, %r15
je 0x1537a
leaq 0x20(%r15), %r14
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0xf494
cmpq %rbx, %rax
jne 0x15366
leaq -0x68(%rbp), %r12
movq %r12, -0x78(%rbp)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %rdi
callq 0xb188
movq $0x0, -0x58(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xe89c
movq -0x78(%rbp), %rdi
cmpq %r12, %rdi
je 0x1535a
callq 0x5340
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0xf494
incq 0x40(%rax)
movq %r15, %rdi
callq 0x5430
movq %rax, %r15
cmpq %r13, %rax
jne 0x15306
movq -0x38(%rbp), %rdi
callq 0x5430
movq %rax, -0x38(%rbp)
cmpq -0x50(%rbp), %rax
jne 0x152b1
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r12, %rdi
je 0x153b1
callq 0x5340
movq %rbx, %rdi
callq 0x56a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/SCGdb.cpp
// Function: SCGdb::average_num_copies_for_unique_scgs(std::set<unsigned long, std::less<unsigned long>, std::allocator<unsigned long>> const&) const
double	SCGdb::average_num_copies_for_unique_scgs(const set<size_t>& scafs) const
{
	set<string> scgs_found;
	size_t n = 0;

	for(auto it=scafs.begin(); it!=scafs.end(); it++) {
		auto mit = scaf2scgs.find(*it);
		if(mit == scaf2scgs.end())
			continue;
		scgs_found.insert(mit->second.begin(), mit->second.end());
		n += mit->second.size();
	}

	return (n == 0)? 0 : double(n)/scgs_found.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq -0x68(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq 0x18(%rsi), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x154bd
movq %rdi, %r14
leaq 0x48(%rdi), %r13
movq $0x0, -0x40(%rbp)
movq 0x50(%r14), %rcx
testq %rcx, %rcx
je 0x1545d
movq 0x20(%r15), %rax
movq %r13, %r12
xorl %edx, %edx
cmpq %rax, 0x20(%rcx)
setb %dl
cmovaeq %rcx, %r12
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x1541a
cmpq %r13, %r12
je 0x1545d
cmpq 0x20(%r12), %rax
jb 0x1545d
movq 0x40(%r12), %rsi
leaq 0x30(%r12), %rdx
leaq -0x70(%rbp), %rdi
callq 0x15aa8
movq -0x40(%rbp), %rax
addq 0x50(%r12), %rax
movq %rax, -0x40(%rbp)
movq %r15, %rdi
callq 0x5430
movq %rax, %r15
cmpq %rbx, %rax
jne 0x1540a
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x154bd
movsd 0x4d12(%rip), %xmm0     # 0x1a190
movsd -0x48(%rbp), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0x4d12(%rip), %xmm2     # 0x1a1a0
subpd %xmm2, %xmm1
movapd %xmm1, %xmm3
unpckhpd %xmm1, %xmm3            # xmm3 = xmm3[1],xmm1[1]
addsd %xmm1, %xmm3
movq %rax, %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
subpd %xmm2, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
divsd %xmm3, %xmm0
jmp 0x154c1
xorpd %xmm0, %xmm0
movapd %xmm0, -0x40(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x9852
movaps -0x40(%rbp), %xmm0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x9852
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/String.cpp
// Function: Bio::DNAString::DNAString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
DNAString::DNAString(const string& dna_string)
{
	m_str = dna_string;
/*	for(string::iterator it=m_str.begin(); it!=m_str.end(); it++)
	{
		*it = toupper(*it);
	}*/
	this->validate_string();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x51e0
movq %rbx, %rdi
callq 0x160e8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x160e0
callq 0x5340
movq %r14, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/String.cpp
// Function: Bio::DNAString::validate_string()
void DNAString::validate_string()
{
	const char *p, *pstart = m_str.c_str();
	for(p=pstart; *p; p++) {
		if((*p == 'A') || (*p == 'C') || (*p == 'G') || (*p == 'T') || (*p == 'N')) {
			continue;
		}

		m_str[p-pstart] = toupper(m_str[p-pstart]);

		if((*p != 'A') && (*p != 'C') && (*p != 'G') && (*p != 'T') && (*p == 'N')) {
			throw Illegal_DNAString(m_str, __PRETTY_FUNCTION__, "");
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq (%rdi), %rbx
xorl %r15d, %r15d
movl $0x82045, %r12d         # imm = 0x82045
movzbl (%rbx,%r15), %eax
leal -0x41(%rax), %ecx
cmpl $0x13, %ecx
ja 0x16120
btl %ecx, %r12d
jae 0x16120
incq %r15
jmp 0x16108
testl %eax, %eax
je 0x161b8
movq (%r14), %r13
movsbl (%r13,%r15), %edi
callq 0x5710
movb %al, (%r13,%r15)
cmpb $0x4e, (%rbx,%r15)
jne 0x1611b
movl $0x28, %edi
callq 0x51b0
movq %rax, %rbx
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0xb188
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x40e1(%rip), %rdx      # 0x1a25a
leaq -0x68(%rbp), %rdi
movq %rdx, %rsi
callq 0xb226
movb $0x1, %r12b
leaq 0x4374(%rip), %rdx      # 0x1a503
leaq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rcx
movq %rbx, %rdi
callq 0x16606
xorl %r12d, %r12d
leaq 0xbb57(%rip), %rsi      # 0x21d00
leaq -0xb3e8(%rip), %rdx     # 0xadc8
movq %rbx, %rdi
callq 0x5660
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x161d8
callq 0x5340
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x161e6
callq 0x5340
testb %r12b, %r12b
jne 0x16203
jmp 0x1620b
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x16203
callq 0x5340
jmp 0x16203
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x56a0
nop