LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x20e15(%rip), %rsi     # 0x4c7d8
leaq 0x212de(%rip), %rdx     # 0x4cca8
xorl %eax, %eax
movl %eax, %ecx
callq 0x5480
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x2b9e2
callq 0x57e0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movsd 0x18(%rax), %xmm0
movq -0x20(%rbp), %rax
ucomisd 0x18(%rax), %xmm0
jne 0x2ba02
jp 0x2ba02
jmp 0x2ba22
movq -0x30(%rbp), %rax
movsd 0x18(%rax), %xmm1
movq -0x20(%rbp), %rax
movsd 0x18(%rax), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2ba6c
movq -0x30(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x20(%rbp), %rax
ucomisd 0x20(%rax), %xmm0
jne 0x2ba3a
jp 0x2ba3a
jmp 0x2ba5a
movq -0x30(%rbp), %rax
movsd 0x20(%rax), %xmm1
movq -0x20(%rbp), %rax
movsd 0x20(%rax), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2ba6c
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x257f0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2ca50
movq -0x10(%rbp), %rdi
callq 0xa8e0
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa910
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa3a0
testb $0x1, %al
jne 0x2bcb7
jmp 0x2bda0
movq -0x90(%rbp), %rax
addq $0x40, %rax
movq %rax, -0xa0(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xa400
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
callq 0x2ca70
movq %rax, -0x98(%rbp)
jmp 0x2bcea
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x40, %rdi
callq 0x2cad0
movq %rax, -0x70(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2caa0
testb $0x1, %al
jne 0x2bd1c
jmp 0x2bd38
jmp 0x2bd89
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xb300
jmp 0x2bdc9
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x2cb40
movq %rax, %rdi
addq $0x8, %rdi
callq 0x2cb60
movq -0xa8(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x2cb40
movq %rax, %rdi
addq $0x8, %rdi
callq 0x2cb90
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x2cb00
jmp 0x2bd87
jmp 0x2bd89
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0xa420
movq %rax, -0x88(%rbp)
jmp 0x2bc94
leaq -0x40(%rbp), %rdi
callq 0x2cbc0
movq %rax, -0xb0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xb300
movq -0xb0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x5750
nopw %cs:(%rax,%rax)
// File: 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
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2ca50
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa8e0
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa910
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa3a0
testb $0x1, %al
jne 0x2c0bf
jmp 0x2c1cc
movq -0x98(%rbp), %rax
addq $0x40, %rax
movq %rax, -0xa8(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa400
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
callq 0x2ca70
movq %rax, -0xa0(%rbp)
jmp 0x2c0f2
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x40, %rdi
callq 0x2cad0
movq %rax, -0x78(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2caa0
testb $0x1, %al
jne 0x2c124
jmp 0x2c143
jmp 0x2c1b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xb300
jmp 0x2c28d
leaq -0x60(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x2cb40
movq %rax, %rdi
addq $0x8, %rdi
callq 0x2cb60
movq -0xb0(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0x2cb40
movq %rax, %rdi
addq $0x8, %rdi
callq 0x2cb90
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x2cb00
jmp 0x2c198
leaq -0x60(%rbp), %rdi
callq 0x2cb40
movq %rax, %rdi
addq $0x8, %rdi
callq 0x2cbc0
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0xa420
movq %rax, -0x90(%rbp)
jmp 0x2c09c
cmpq $0x0, -0x48(%rbp)
jne 0x2c1e3
xorps %xmm0, %xmm0
movsd %xmm0, -0xb8(%rbp)
jmp 0x2c263
movq -0x48(%rbp), %xmm0
movaps 0x9f91(%rip), %xmm1     # 0x36180
movaps %xmm1, -0xe0(%rbp)
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x9f8e(%rip), %xmm1     # 0x36190
movaps %xmm1, -0xd0(%rbp)
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0xc0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2cbc0
movaps -0xe0(%rbp), %xmm3
movaps -0xd0(%rbp), %xmm2
movsd -0xc0(%rbp), %xmm0
movq %rax, %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0xb8(%rbp)
movsd -0xb8(%rbp), %xmm0
movsd %xmm0, -0xe8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xb300
movsd -0xe8(%rbp), %xmm0
addq $0xf0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x5750
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x5190
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2f074
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x41, %eax
je 0x2eef1
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x43, %eax
je 0x2eef1
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x47, %eax
je 0x2eef1
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x54, %eax
je 0x2eef1
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4e, %eax
jne 0x2eef6
jmp 0x2f063
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
subq %rax, %rsi
callq 0x5840
movsbl (%rax), %edi
callq 0x57c0
movq -0x78(%rbp), %rdi
movb %al, -0x79(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
subq %rax, %rsi
callq 0x5840
movb -0x79(%rbp), %cl
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x41, %eax
je 0x2f061
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x43, %eax
je 0x2f061
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x47, %eax
je 0x2f061
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x54, %eax
je 0x2f061
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4e, %eax
jne 0x2f061
movb $0x1, -0x6a(%rbp)
movl $0x28, %edi
callq 0x51e0
movq -0x78(%rbp), %rsi
movq %rax, -0x88(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x51a0
jmp 0x2efa2
leaq -0x69(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x5760
movq -0x90(%rbp), %rdx
leaq 0x72ad(%rip), %rsi      # 0x3626d
leaq -0x68(%rbp), %rdi
callq 0x55b0
jmp 0x2efcb
movq -0x88(%rbp), %rdi
leaq 0x759f(%rip), %rdx      # 0x36578
leaq -0x38(%rbp), %rsi
leaq -0x68(%rbp), %rcx
callq 0x2f6f0
jmp 0x2efe8
movq -0x88(%rbp), %rdi
movb $0x0, -0x6a(%rbp)
leaq 0x1dcfe(%rip), %rsi     # 0x4ccf8
leaq 0xc5f(%rip), %rdx       # 0x2fc60
callq 0x5700
jmp 0x2f086
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2f04b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2f039
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5250
leaq -0x69(%rbp), %rdi
callq 0x5460
leaq -0x38(%rbp), %rdi
callq 0x5250
testb $0x1, -0x6a(%rbp)
jne 0x2f053
jmp 0x2f05f
movq -0x88(%rbp), %rdi
callq 0x52d0
jmp 0x2f07d
jmp 0x2f063
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2eea8
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x5750
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/String.cpp
// Function: Bio::DNAString::reverse_complement() const
DNAString DNAString::reverse_complement() const
{
	DNAString rc_str(::reverse(m_str));
	for(int i=rc_str.size()-1; i>=0; i--)
	{
		switch(rc_str.get(i)) 
		{
			case 'A':
				rc_str.set(i, 'T');
				break;
			case 'C':
				rc_str.set(i, 'G');
				break;
			case 'G':
				rc_str.set(i, 'C');
				break;
			case 'T':
				rc_str.set(i, 'A');
				break;
			// Else - N, leave as is
		}
	}
	return rc_str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movb $0x0, -0x11(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x51a0
movq -0x70(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x30c60
jmp 0x2f232
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2ee10
jmp 0x2f241
leaq -0x38(%rbp), %rdi
callq 0x5250
leaq -0x58(%rbp), %rdi
callq 0x5250
movq -0x80(%rbp), %rdi
callq 0xac00
movq %rax, -0x88(%rbp)
jmp 0x2f265
movq -0x88(%rbp), %rax
subq $0x1, %rax
movl %eax, -0x68(%rbp)
cmpl $0x0, -0x68(%rbp)
jl 0x2f37a
movq -0x80(%rbp), %rdi
movslq -0x68(%rbp), %rsi
callq 0x30280
movb %al, -0x89(%rbp)
jmp 0x2f292
movb -0x89(%rbp), %al
movsbl %al, %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x98(%rbp)
subl $0x13, %eax
ja 0x2f36a
movq -0x98(%rbp), %rax
leaq 0x726a(%rip), %rcx      # 0x36528
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x2f2ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5250
leaq -0x58(%rbp), %rdi
callq 0x5250
jmp 0x2f39a
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x1c280
jmp 0x2f39a
movq -0x80(%rbp), %rdi
movslq -0x68(%rbp), %rsi
movl $0x54, %edx
callq 0x302b0
jmp 0x2f326
jmp 0x2f36a
movq -0x80(%rbp), %rdi
movslq -0x68(%rbp), %rsi
movl $0x47, %edx
callq 0x302b0
jmp 0x2f33c
jmp 0x2f36a
movq -0x80(%rbp), %rdi
movslq -0x68(%rbp), %rsi
movl $0x43, %edx
callq 0x302b0
jmp 0x2f352
jmp 0x2f36a
movq -0x80(%rbp), %rdi
movslq -0x68(%rbp), %rsi
movl $0x41, %edx
callq 0x302b0
jmp 0x2f368
jmp 0x2f36a
jmp 0x2f36c
movl -0x68(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x2f273
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2f38d
movq -0x80(%rbp), %rdi
callq 0x1c280
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x5750
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/String.cpp
// Function: Bio::gc(Bio::DNAString const&)
double gc(const DNAString& dna_str)
{
	size_t gc = 0, Ns = 0;

	DNAString::const_iterator end=dna_str.end();
	for(DNAString::const_iterator it=dna_str.begin(); it!=end; it++) 
	{
		if(*it == 'N')
			Ns++;
		else if((*it == 'C') || (*it == 'G'))
			gc++;
	}
	if(dna_str.size() == Ns) {
		return 0;
	}

	return double(gc)/(dna_str.size()-Ns);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30380
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x303b0
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x303e0
testb $0x1, %al
jne 0x2f569
jmp 0x2f5cb
leaq -0x30(%rbp), %rdi
callq 0x30420
movsbl (%rax), %eax
cmpl $0x4e, %eax
jne 0x2f588
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2f5b8
leaq -0x30(%rbp), %rdi
callq 0x30420
movsbl (%rax), %eax
cmpl $0x43, %eax
je 0x2f5aa
leaq -0x30(%rbp), %rdi
callq 0x30420
movsbl (%rax), %eax
cmpl $0x47, %eax
jne 0x2f5b6
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2f5b8
jmp 0x2f5ba
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x30440
movq %rax, -0x38(%rbp)
jmp 0x2f556
movq -0x10(%rbp), %rdi
callq 0xac00
cmpq -0x20(%rbp), %rax
jne 0x2f5e4
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2f656
movq -0x18(%rbp), %xmm0
movaps 0x6b90(%rip), %xmm1     # 0x36180
movaps %xmm1, -0x60(%rbp)
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x6b90(%rip), %xmm1     # 0x36190
movaps %xmm1, -0x50(%rbp)
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xac00
movaps -0x60(%rbp), %xmm3
movaps -0x50(%rbp), %xmm2
movsd -0x40(%rbp), %xmm0
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movq %rax, %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/String.cpp
// Function: Bio::Ns(Bio::DNAString const&)
size_t Ns(const DNAString& dna_str)
{
	size_t Ns = 0;

	DNAString::const_iterator end=dna_str.end();
	for(DNAString::const_iterator it=dna_str.begin(); it!=end; it++) 
	{
		if(*it == 'N')
			Ns++;
	}

	return Ns;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30380
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x303b0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x303e0
testb $0x1, %al
jne 0x2f6b1
jmp 0x2f6e1
leaq -0x20(%rbp), %rdi
callq 0x30420
movsbl (%rax), %eax
cmpl $0x4e, %eax
jne 0x2f6ce
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2f6d0
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x30440
movq %rax, -0x28(%rbp)
jmp 0x2f69e
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: CK7[P]abawaca/src/common.cpp
// Function: time_since_epoch[abi:cxx11]()
string	time_since_epoch()
{
	char			str[32];
	unsigned int	t = time(NULL)-epoch;
	sprintf(str, "[%02d:%02d:%02d]\t", (unsigned int)(t/3600), (unsigned int)((t%3600)/60), (unsigned int)(t%60));
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, -0x64(%rbp)
movl %eax, %edi
callq 0x5390
movq %rax, %rcx
movl -0x64(%rbp), %eax
movl 0x1cfc9(%rip), %edx     # 0x4d508
subl %edx, %ecx
movl %ecx, -0x34(%rbp)
movl -0x34(%rbp), %ecx
movl %ecx, %esi
movl %esi, %r8d
movl $0x91a2b3c5, %edx       # imm = 0x91A2B3C5
movq %rsi, %rcx
imulq %rdx, %rcx
shrq $0x2b, %rcx
movl %ecx, %edx
imull $0xe10, %edx, %edi      # imm = 0xE10
movl %r8d, %ecx
subl %edi, %ecx
imulq $0x4444445, %rcx, %rcx  # imm = 0x4444445
shrq $0x20, %rcx
movl $0x88888889, %edi       # imm = 0x88888889
imulq %rdi, %rsi
shrq $0x25, %rsi
imull $0x3c, %esi, %esi
subl %esi, %r8d
leaq 0x61fa(%rip), %rsi      # 0x36788
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x50b0
leaq -0x35(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5760
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x55b0
jmp 0x305bb
leaq -0x35(%rbp), %rdi
callq 0x5460
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x35(%rbp), %rdi
callq 0x5460
movq -0x40(%rbp), %rdi
callq 0x5750
nopl (%rax)
// File: CK7[P]abawaca/src/common.cpp
// Function: chomp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void chomp(string& line)
{
	string::reverse_iterator it = line.rbegin();
	while((it != line.rend()) && ((*it == '\n') || (*it == '\r'))) {
		line.erase(line.size()-1);
		it = line.rbegin();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x5730
movq -0x8(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x54c0
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x31370
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x30631
jmp 0x30662
leaq -0x10(%rbp), %rdi
callq 0x313a0
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x22(%rbp)
je 0x3065c
leaq -0x10(%rbp), %rdi
callq 0x313a0
movsbl (%rax), %eax
cmpl $0xd, %eax
sete %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x3066b
jmp 0x306ad
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x52c0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
movq $-0x1, %rdx
callq 0x50e0
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x5730
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x30609
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/common.cpp
// Function: chomp(char*)
void chomp(char* line)
{
	char* p = line+strlen(line);
	if(p == line)
		return;

	for(p--; ((*p == '\n') || (*p == '\r')); p--) {
		*p = 0;
		if(p == line)
			break;
	} 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x51b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x306f7
jmp 0x30750
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x19(%rbp)
je 0x30724
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x3072d
jmp 0x30750
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x30740
jmp 0x30750
jmp 0x30742
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x30703
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/common.cpp
// Function: remove_white_spaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void remove_white_spaces(string& line)
{
	string::iterator it1 = line.begin(), it2 = line.begin();
	while(it2 != line.end()) {
		if(!isspace(*it2))
			*(it1++) = *it2;
		it2++;
	}
	line.erase(it2, line.end());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5340
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5340
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5220
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x313d0
testb $0x1, %al
jne 0x307a6
jmp 0x307f8
leaq -0x18(%rbp), %rdi
callq 0x31410
movsbl (%rax), %edi
callq 0x5090
cmpl $0x0, %eax
jne 0x307e7
leaq -0x18(%rbp), %rdi
callq 0x31410
movb (%rax), %al
movb %al, -0x51(%rbp)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x31430
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x31410
movb -0x51(%rbp), %cl
movb %cl, (%rax)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x31430
movq %rax, -0x30(%rbp)
jmp 0x30786
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x31470
movq -0x8(%rbp), %rdi
callq 0x5220
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x31470
movq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x50d0
movq %rax, -0x50(%rbp)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/common.cpp
// Function: trim_front(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void trim_front(string& line)
{
	string::iterator it1 = line.begin(), it2 = line.begin();
	if(it2 == line.end())
		return;
	if(!isspace(*(it2++)))
		return;

	while((it2 != line.end()) && isspace(*it2))
		it1++, it2++;

	line.erase(line.begin(), it1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5340
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5340
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5220
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x314b0
testb $0x1, %al
jne 0x30896
jmp 0x3089b
jmp 0x3097f
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x31430
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x31410
movsbl (%rax), %edi
callq 0x5090
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x308c9
jmp 0x308ce
jmp 0x3097f
jmp 0x308d0
movq -0x8(%rbp), %rdi
callq 0x5220
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x313d0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x61(%rbp)
jne 0x308f8
jmp 0x30912
leaq -0x18(%rbp), %rdi
callq 0x31410
movsbl (%rax), %edi
callq 0x5090
cmpl $0x0, %eax
setne %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x3091b
jmp 0x3093b
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x31430
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x31430
movq %rax, -0x40(%rbp)
jmp 0x308d0
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5340
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x31470
leaq -0x58(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x31470
movq -0x70(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x50d0
movq %rax, -0x60(%rbp)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/common.cpp
// Function: trim_back(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void trim_back(string& line)
{
	string::reverse_iterator	it2 = line.rbegin();
	size_t			start_erase = line.size()-1;
	if(it2 == line.rend())
		return;
	if(!isspace(*(it2++)))
		return;

	while((it2 != line.rend()) && isspace(*it2))
		start_erase--, it2++;

	line.erase(start_erase);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x5730
movq -0x8(%rbp), %rdi
callq 0x52c0
subq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x54c0
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x314f0
testb $0x1, %al
jne 0x309da
jmp 0x309df
jmp 0x30a8d
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x31530
leaq -0x28(%rbp), %rdi
callq 0x313a0
movsbl (%rax), %edi
callq 0x5090
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x30a0d
jmp 0x30a0f
jmp 0x30a8d
jmp 0x30a11
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x54c0
leaq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x31370
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x39(%rbp)
jne 0x30a39
jmp 0x30a53
leaq -0x10(%rbp), %rdi
callq 0x313a0
movsbl (%rax), %edi
callq 0x5090
cmpl $0x0, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x30a5c
jmp 0x30a79
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x31530
jmp 0x30a11
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq $-0x1, %rdx
callq 0x50e0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/common.cpp
// Function: split(char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
long split(char delimiter, string line, vector<string>& destination)
{
	destination.clear();
	if(line.size() == 0)
		return 0;

	size_t p1 = 0, p2 = 0;
	while((p1 < line.size()) && ((p2 = line.find(delimiter, p1)) != string::npos)) {
		destination.push_back(line.substr(p1, p2-p1));
		p1 = p2+1;
	}
	destination.push_back(line.substr(p1));
	return destination.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x88(%rbp)
movb %dil, %al
movb %al, -0x9(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x31570
movq -0x88(%rbp), %rdi
callq 0x52c0
cmpq $0x0, %rax
jne 0x30ae8
movq $0x0, -0x8(%rbp)
jmp 0x30c3d
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x88(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x52c0
movq -0x98(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x89(%rbp)
jae 0x30b4d
movq -0x88(%rbp), %rdi
movb -0x9(%rbp), %al
movq -0x28(%rbp), %rdx
movsbl %al, %esi
callq 0x5560
movq %rax, -0x30(%rbp)
cmpq $-0x1, %rax
setne %al
movb %al, -0x89(%rbp)
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x30b59
jmp 0x30bcc
movq -0x88(%rbp), %rsi
movq -0x20(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
subq %rdx, %rcx
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x5420
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x31590
jmp 0x30b9b
leaq -0x50(%rbp), %rdi
callq 0x5250
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x30af8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5250
jmp 0x30c4a
movq -0x88(%rbp), %rsi
movq -0x20(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x28(%rbp), %rdx
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movq $-0x1, %rcx
callq 0x5420
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x31590
jmp 0x30c0e
leaq -0x80(%rbp), %rdi
callq 0x5250
movq -0x20(%rbp), %rdi
callq 0x315c0
movq %rax, -0x8(%rbp)
jmp 0x30c3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x5250
jmp 0x30c4a
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x5750
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/common.cpp
// Function: reverse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string reverse(string str)
{
	string reverse_str;
	reverse_str.reserve(str.size()+1);
	for(string::reverse_iterator it = str.rbegin(); it != str.rend(); it++)
		reverse_str += *it;

	return reverse_str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x55d0
movq -0x50(%rbp), %rdi
callq 0x52c0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
incq %rsi
callq 0x5680
jmp 0x30ca2
movq -0x50(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5730
movq -0x50(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x54c0
movq -0x68(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x31370
movb %al, -0x59(%rbp)
jmp 0x30cd2
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x30cdb
jmp 0x30d28
leaq -0x30(%rbp), %rdi
callq 0x313a0
movq %rax, -0x70(%rbp)
jmp 0x30cea
movq -0x48(%rbp), %rdi
movq -0x70(%rbp), %rax
movsbl (%rax), %esi
callq 0x5260
jmp 0x30cfc
jmp 0x30cfe
leaq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x31530
jmp 0x30d0f
jmp 0x30caf
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5250
jmp 0x30d45
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x30d3b
movq -0x48(%rbp), %rdi
callq 0x5250
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5750
nop
// File: CK7[P]abawaca/src/common.cpp
// Function: read_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, _IO_FILE*)
bool read_line(string& line, FILE* fp)
{
	char str[1024];

	line.resize(0);
	while(fgets(str, 1024, fp)) {
		line += string(str);
		if(strchr(str, '\n'))
			break;
	}

	return !feof(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp            # imm = 0x450
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x55c0
leaq -0x410(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x5690
cmpq $0x0, %rax
je 0x30f06
leaq -0x431(%rbp), %rdi
movq %rdi, -0x450(%rbp)
callq 0x5760
movq -0x450(%rbp), %rdx
leaq -0x430(%rbp), %rdi
leaq -0x410(%rbp), %rsi
callq 0x55b0
jmp 0x30e7e
movq -0x8(%rbp), %rdi
leaq -0x430(%rbp), %rsi
callq 0x5520
jmp 0x30e90
leaq -0x430(%rbp), %rdi
callq 0x5250
leaq -0x431(%rbp), %rdi
callq 0x5460
leaq -0x410(%rbp), %rdi
movl $0xa, %esi
callq 0x5170
cmpq $0x0, %rax
je 0x30f01
jmp 0x30f06
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x440(%rbp)
movl %eax, -0x444(%rbp)
jmp 0x30ef3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x440(%rbp)
movl %eax, -0x444(%rbp)
leaq -0x430(%rbp), %rdi
callq 0x5250
leaq -0x431(%rbp), %rdi
callq 0x5460
jmp 0x30f22
jmp 0x30e30
movq -0x10(%rbp), %rdi
callq 0x5660
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
addq $0x450, %rsp            # imm = 0x450
popq %rbp
retq
movq -0x440(%rbp), %rdi
callq 0x5750
nop
// File: CK7[P]abawaca/src/common.cpp
// Function: reverse_complement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string reverse_complement(const string& dna_seq) 
{
	string rc_dna_seq = reverse(dna_seq);
	for(string::iterator it=rc_dna_seq.begin(); it!=rc_dna_seq.end(); it++) {
		switch(*it) {
			case 'A':
			case 'a':
				*it = 'T';
				break;
			case 'C':
			case 'c':
				*it = 'G';
				break;
			case 'G':
			case 'g':
				*it = 'C';
				break;
			case 'T':
			case 't':
				*it = 'A';
				break;
                }
        }
        return rc_dna_seq;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x51a0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x30c60
jmp 0x30f72
leaq -0x38(%rbp), %rdi
callq 0x5250
movq -0x70(%rbp), %rdi
callq 0x5340
movq %rax, -0x50(%rbp)
movq -0x70(%rbp), %rdi
callq 0x5220
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x313d0
testb $0x1, %al
jne 0x30fab
jmp 0x3103c
leaq -0x50(%rbp), %rdi
callq 0x31410
movsbl (%rax), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x80(%rbp)
subl $0x33, %eax
ja 0x31026
movq -0x80(%rbp), %rax
leaq 0x56e8(%rip), %rcx      # 0x366b8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5250
jmp 0x3105c
leaq -0x50(%rbp), %rdi
callq 0x31410
movb $0x54, (%rax)
jmp 0x31026
leaq -0x50(%rbp), %rdi
callq 0x31410
movb $0x47, (%rax)
jmp 0x31026
leaq -0x50(%rbp), %rdi
callq 0x31410
movb $0x43, (%rax)
jmp 0x31026
leaq -0x50(%rbp), %rdi
callq 0x31410
movb $0x41, (%rax)
jmp 0x31028
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x31430
movq %rax, -0x60(%rbp)
jmp 0x30f88
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3104f
movq -0x70(%rbp), %rdi
callq 0x5250
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x5750
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/common.cpp
// Function: filesize(char const*)
uint64_t filesize(const char* filename)
{
	std::ifstream in(filename, std::ifstream::in | std::ifstream::binary);
	in.seekg(0, std::ifstream::end);
//	return (unsigned int64_t)(in.tellg()); 
	return (int64_t)(in.tellg()); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x240(%rbp)
movl $0x8, %edi
movl $0x4, %esi
callq 0x315e0
movq -0x240(%rbp), %rsi
movl %eax, %edx
leaq -0x210(%rbp), %rdi
movq %rdi, -0x238(%rbp)
callq 0x5790
movq -0x238(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x5590
jmp 0x310cc
leaq -0x210(%rbp), %rdi
callq 0x5720
movq %rdx, -0x250(%rbp)
movq %rax, -0x248(%rbp)
jmp 0x310e8
movq -0x250(%rbp), %rax
movq -0x248(%rbp), %rcx
movq %rcx, -0x230(%rbp)
movq %rax, -0x228(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x31600
movq %rax, -0x258(%rbp)
jmp 0x31119
leaq -0x210(%rbp), %rdi
callq 0x5100
movq -0x258(%rbp), %rax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x5100
movq -0x218(%rbp), %rdi
callq 0x5750
nop
// File: CK7[P]abawaca/src/common.cpp
// Function: print_percent(unsigned long, unsigned long, std::ostream&)
void print_percent(size_t old_p, size_t new_p, ostream& os)
{
	if(new_p == 0) {
		os << "0 %";
		return;
	}

	os << char(8) << char(8);
	if(old_p == 0)
		os << char(8);
	else {
		while(old_p > 0) {
			os << char(8);
			old_p /= 10;
		}
	}
	os << new_p << " %";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3118d
movq -0x18(%rbp), %rdi
leaq 0x5614(%rip), %rsi      # 0x3679a
callq 0x53f0
jmp 0x31208
movq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x54a0
movq %rax, %rdi
movl $0x8, %esi
callq 0x54a0
cmpq $0x0, -0x8(%rbp)
jne 0x311bf
movq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x54a0
jmp 0x311ec
jmp 0x311c1
cmpq $0x0, -0x8(%rbp)
jbe 0x311ea
movq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x54a0
movq -0x8(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x8(%rbp)
jmp 0x311c1
jmp 0x311ec
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x50f0
movq %rax, %rdi
leaq 0x5598(%rip), %rsi      # 0x3679b
callq 0x53f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: CK7[P]abawaca/src/common.cpp
// Function: glob(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
vector<string> glob(const string& pat)
{
	glob_t glob_result;
	glob(pat.c_str(),GLOB_TILDE,NULL,&glob_result);
	vector<string> ret;

	for(unsigned int i=0;i<glob_result.gl_pathc;++i){
		ret.push_back(string(glob_result.gl_pathv[i]));
	}
	globfree(&glob_result);

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5190
movq %rax, %rdi
movl $0x1000, %esi           # imm = 0x1000
xorl %eax, %eax
movl %eax, %edx
leaq -0x58(%rbp), %rcx
callq 0x5450
movq -0xa0(%rbp), %rdi
movb $0x0, -0x59(%rbp)
callq 0x31620
movl $0x0, -0x60(%rbp)
movl -0x60(%rbp), %eax
cmpq -0x58(%rbp), %rax
jae 0x3132f
movq -0x50(%rbp), %rax
movl -0x60(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0xb8(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x5760
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
leaq -0x80(%rbp), %rdi
callq 0x55b0
jmp 0x312b4
movq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x31590
jmp 0x312c6
leaq -0x80(%rbp), %rdi
callq 0x5250
leaq -0x81(%rbp), %rdi
callq 0x5460
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x31269
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x31315
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x5250
leaq -0x81(%rbp), %rdi
callq 0x5460
movq -0xa0(%rbp), %rdi
callq 0x31640
jmp 0x3135e
leaq -0x58(%rbp), %rdi
callq 0x50c0
movb $0x1, -0x59(%rbp)
testb $0x1, -0x59(%rbp)
jne 0x3134e
movq -0xa0(%rbp), %rdi
callq 0x31640
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x5750
nopw (%rax,%rax)
// File: CK7[P]abawaca/src/ClusterQuality.cpp
// Function: ClusterQuality::dimension(Cluster const&, double&, double&, Dimension const&) const
void ClusterQuality::dimension(const Cluster& cluster, double& avg, double& stdev, const Dimension& dimension) const
{
	vector<pair<size_t, double> >   d;

	for(auto it=cluster.assigned_scafs_begin(); it!=cluster.assigned_scafs_end(); it++) {
		const set<const ScafDpData::DataPoint*>& scaf_dps = scaf_db.get_scaf(*it)->get_scaf_dps();
		for(auto sit=scaf_dps.begin(); sit!=scaf_dps.end(); sit++) {
			d.push_back(pair<size_t, double>(1, dimension.get_value((*sit)->get_iid())));
		}
	}
	standard_deviation(d, avg, stdev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x33360
movq -0x10(%rbp), %rdi
callq 0xa370
movq %rax, -0xc8(%rbp)
jmp 0x324c5
movq -0xc8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa3d0
movq %rax, -0xd8(%rbp)
jmp 0x324e2
movq -0xd8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xa3a0
testb $0x1, %al
jne 0x32503
jmp 0x32659
movq -0xd0(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xe8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xa400
movq -0xe8(%rbp), %rdi
movq (%rax), %rsi
callq 0xa940
movq %rax, -0xe0(%rbp)
jmp 0x32536
movq -0xe0(%rbp), %rdi
callq 0x15580
movq %rax, -0xf0(%rbp)
jmp 0x3254b
movq -0xf0(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x16120
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
callq 0x16150
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x16410
testb $0x1, %al
jne 0x32586
jmp 0x32640
movl $0x1, -0x8c(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x100(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x166b0
movq (%rax), %rdi
callq 0x14710
movq %rax, -0xf8(%rbp)
jmp 0x325b5
movq -0xf8(%rbp), %rsi
movq -0x100(%rbp), %rdi
callq 0x1cb40
movsd %xmm0, -0x108(%rbp)
jmp 0x325d2
movsd -0x108(%rbp), %xmm0
movsd %xmm0, -0x98(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x8c(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x333b0
jmp 0x325fe
leaq -0x40(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x33380
jmp 0x32610
jmp 0x32612
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
callq 0x16490
movq %rax, -0xa0(%rbp)
jmp 0x32563
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x334d0
jmp 0x3269d
jmp 0x32642
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0xa420
movq %rax, -0xa8(%rbp)
jmp 0x324d0
leaq -0xc0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x333e0
jmp 0x3266b
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0xc0(%rbp), %rdi
callq 0x32210
leaq -0xc0(%rbp), %rdi
callq 0x334d0
leaq -0x40(%rbp), %rdi
callq 0x334d0
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x5750
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/ClusterQuality.cpp
// Function: ClusterQuality::gc(Cluster const&, double&, double&) const
void ClusterQuality::gc(const Cluster& cluster, double& avg_gc, double& gc_stdev) const
{
	vector<pair<size_t, double> >	gc;

	for(auto it=cluster.assigned_scafs_begin(); it!=cluster.assigned_scafs_end(); it++) {
		const ScafDpData::Seq* seq_obj = scaf_db.get_scaf(*it);
		if(seq_obj != NULL)
			gc.push_back(pair<size_t, double>(seq_obj->get_seq_obj()->seq().size(), seq_obj->get_gc()));
	}
	standard_deviation(gc, avg_gc, gc_stdev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x33360
movq -0x10(%rbp), %rdi
callq 0xa370
movq %rax, -0xa8(%rbp)
jmp 0x32791
movq -0xa8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa3d0
movq %rax, -0xb8(%rbp)
jmp 0x327ae
movq -0xb8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa3a0
testb $0x1, %al
jne 0x327cf
jmp 0x328d3
movq -0xb0(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xc8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa400
movq -0xc8(%rbp), %rdi
movq (%rax), %rsi
callq 0xa940
movq %rax, -0xc0(%rbp)
jmp 0x32802
movq -0xc0(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0x328ba
movq -0x60(%rbp), %rdi
callq 0xa9a0
movq %rax, -0xd0(%rbp)
jmp 0x3282a
movq -0xd0(%rbp), %rdi
callq 0xabe0
movq %rax, -0xd8(%rbp)
jmp 0x3283f
movq -0xd8(%rbp), %rdi
callq 0xac00
movq %rax, -0xe0(%rbp)
jmp 0x32854
movq -0xe0(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x60(%rbp), %rdi
callq 0x33530
movsd %xmm0, -0xe8(%rbp)
jmp 0x32872
movsd -0xe8(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x33560
jmp 0x32892
leaq -0x38(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x33380
jmp 0x328a1
jmp 0x328ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x334d0
jmp 0x32917
jmp 0x328bc
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0xa420
movq %rax, -0x88(%rbp)
jmp 0x3279c
leaq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x333e0
jmp 0x328e5
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
callq 0x32210
leaq -0xa0(%rbp), %rdi
callq 0x334d0
leaq -0x38(%rbp), %rdi
callq 0x334d0
addq $0xf0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5750
// File: CK7[P]abawaca/src/ClusterQuality.cpp
// Function: ClusterQuality::cvg(Cluster const&, double&, double&) const
void ClusterQuality::cvg(const Cluster& cluster, double& avg_cvg, double& cvg_stdev) const
{
	vector<pair<size_t, double> >	cvg;

	for(auto it=cluster.assigned_scafs_begin(); it!=cluster.assigned_scafs_end(); it++) {
		const ScafDpData::Seq* seq_obj = scaf_db.get_scaf(*it);
		if(seq_obj != NULL) {
			cvg.push_back(pair<size_t, double>(seq_obj->get_seq_obj()->seq().size(), seq_obj->get_cvg()));
		}
	}
	standard_deviation(cvg, avg_cvg, cvg_stdev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x33360
movq -0x10(%rbp), %rdi
callq 0xa370
movq %rax, -0xa8(%rbp)
jmp 0x32961
movq -0xa8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa3d0
movq %rax, -0xb8(%rbp)
jmp 0x3297e
movq -0xb8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa3a0
testb $0x1, %al
jne 0x3299f
jmp 0x32aa3
movq -0xb0(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xc8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa400
movq -0xc8(%rbp), %rdi
movq (%rax), %rsi
callq 0xa940
movq %rax, -0xc0(%rbp)
jmp 0x329d2
movq -0xc0(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0x32a8a
movq -0x60(%rbp), %rdi
callq 0xa9a0
movq %rax, -0xd0(%rbp)
jmp 0x329fa
movq -0xd0(%rbp), %rdi
callq 0xabe0
movq %rax, -0xd8(%rbp)
jmp 0x32a0f
movq -0xd8(%rbp), %rdi
callq 0xac00
movq %rax, -0xe0(%rbp)
jmp 0x32a24
movq -0xe0(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x60(%rbp), %rdi
callq 0x33590
movsd %xmm0, -0xe8(%rbp)
jmp 0x32a42
movsd -0xe8(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x33560
jmp 0x32a62
leaq -0x38(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x33380
jmp 0x32a71
jmp 0x32a8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x334d0
jmp 0x32ae7
jmp 0x32a8c
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0xa420
movq %rax, -0x88(%rbp)
jmp 0x3296c
leaq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x333e0
jmp 0x32ab5
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
callq 0x32210
leaq -0xa0(%rbp), %rdi
callq 0x334d0
leaq -0x38(%rbp), %rdi
callq 0x334d0
addq $0xf0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5750
// File: CK7[P]abawaca/src/ClusterQuality.cpp
// Function: ClusterQuality::total_size(Cluster const&) const
size_t ClusterQuality::total_size(const Cluster& cluster) const
{
	size_t ts = 0;
	for(auto it=cluster.assigned_scafs_begin(); it!=cluster.assigned_scafs_end(); it++) {
		const Bio::DNASequence* seq_obj =  scaf_db.get_scaf(*it)->get_seq_obj();
		if(seq_obj != NULL)
			ts += seq_obj->seq().size();
	}
	return ts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa370
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa3d0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa3a0
testb $0x1, %al
jne 0x32b3d
jmp 0x32b9d
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa400
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
callq 0xa940
movq %rax, %rdi
callq 0xa9a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x32b8a
movq -0x30(%rbp), %rdi
callq 0xabe0
movq %rax, %rdi
callq 0xac00
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x32b8c
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xa420
movq %rax, -0x38(%rbp)
jmp 0x32b1d
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: superblocks[P]superblocks/list-sxc.cpp
// Function: main
int main() {
	cout << "[SXC] Sexcoin - Superblock list" << endl << endl;
	cout << "BLOCK, REWARD" << endl;
	for (int nHeight = 0; nHeight <= list_length; nHeight++) {
		random::mt19937 gen(nHeight);
		random::uniform_int_distribution<> dist(1, 100000);
		int rand = dist(gen);
		if(rand > 99990)
			cout << nHeight << ", 5000" << endl;
		else if (rand < 2001) 
			cout << nHeight << ", 500" << endl;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x9e0, %rsp            # imm = 0x9E0
movl $0x0, -0x4(%rbp)
movq 0x2def(%rip), %rdi      # 0x3fd8
leaq 0xe14(%rip), %rsi       # 0x2004
callq 0x1050
movq %rax, %rdi
movq 0x2dc9(%rip), %rsi      # 0x3fc8
callq 0x1060
movq %rax, %rdi
movq 0x2dba(%rip), %rsi      # 0x3fc8
callq 0x1060
movq 0x2dbe(%rip), %rdi      # 0x3fd8
leaq 0xe03(%rip), %rsi       # 0x2024
callq 0x1050
movq %rax, %rdi
movq 0x2d98(%rip), %rsi      # 0x3fc8
callq 0x1060
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x2e13(%rip), %eax      # 0x4058
jg 0x131c
movl -0x8(%rbp), %eax
movl %eax, -0x9d4(%rbp)
leaq -0x9d0(%rbp), %rdi
leaq -0x9d4(%rbp), %rsi
callq 0x1330
leaq -0x9dc(%rbp), %rdi
movl $0x1, %esi
movl $0x186a0, %edx          # imm = 0x186A0
callq 0x1360
leaq -0x9dc(%rbp), %rdi
leaq -0x9d0(%rbp), %rsi
callq 0x13b0
movl %eax, -0x9e0(%rbp)
cmpl $0x18696, -0x9e0(%rbp)  # imm = 0x18696
jle 0x12d1
movl -0x8(%rbp), %esi
movq 0x2d2c(%rip), %rdi      # 0x3fd8
callq 0x1080
movq %rax, %rdi
leaq 0xd77(%rip), %rsi       # 0x2032
callq 0x1050
movq %rax, %rdi
movq 0x2cfe(%rip), %rsi      # 0x3fc8
callq 0x1060
jmp 0x130c
cmpl $0x7d1, -0x9e0(%rbp)    # imm = 0x7D1
jge 0x130a
movl -0x8(%rbp), %esi
movq 0x2cf1(%rip), %rdi      # 0x3fd8
callq 0x1080
movq %rax, %rdi
leaq 0xd43(%rip), %rsi       # 0x2039
callq 0x1050
movq %rax, %rdi
movq 0x2cc3(%rip), %rsi      # 0x3fc8
callq 0x1060
jmp 0x130c
jmp 0x130e
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x123c
xorl %eax, %eax
addq $0x9e0, %rsp            # imm = 0x9E0
popq %rbp
retq
nopw (%rax,%rax)