LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x53d9(%rip), %rsi      # 0x16215
callq 0x4340
leaq 0x4f0d(%rip), %rsi      # 0x15d55
movq %rax, %rdi
callq 0x4340
movq 0xa8(%r14), %rcx
movq 0x8(%rcx), %rsi
movq %rax, %rdi
callq 0x4240
leaq 0x5093(%rip), %rsi      # 0x15efd
movq %rax, %rdi
callq 0x4340
movq %rax, %r15
movq 0x18(%r14), %rdi
movq 0xa8(%r14), %rax
movq 0x8(%rax), %rsi
callq 0xc9d2
leaq 0x80(%rax), %rsi
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x44d0
movq %r15, %rdi
movq %r12, %rsi
callq 0x42d0
leaq 0x537a(%rip), %rsi      # 0x16228
movq %rax, %rdi
callq 0x4340
leaq 0x536e(%rip), %rsi      # 0x1622b
movq %rax, %rdi
callq 0x4340
movq 0xa8(%r14), %rcx
movsd 0x10(%rcx), %xmm0
movq %rax, %rdi
callq 0x45c0
leaq 0x5349(%rip), %rsi      # 0x16229
movq %rax, %rdi
callq 0x4340
leaq 0x5462(%rip), %rsi      # 0x16351
movq %rax, %rdi
callq 0x4340
movq %rax, %r15
movq %r14, %rdi
callq 0x1143c
movq %r15, %rdi
callq 0x45c0
movq %rax, %rdi
callq 0x41a0
leaq -0x40(%rbp), %rdi
callq 0x4180
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4180
movq %rbx, %rdi
callq 0x4660
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd3d7(%rip), %rsi      # 0x1e858
leaq 0xd830(%rip), %rdx      # 0x1ecb8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x43c0
testq %rax, %rax
je 0x114da
movsd 0x18(%rbx), %xmm0
movsd 0x18(%rax), %xmm1
ucomisd %xmm1, %xmm0
jne 0x114bb
jp 0x114bb
movsd 0x20(%rbx), %xmm0
movsd 0x20(%rax), %xmm1
ucomisd %xmm1, %xmm0
jne 0x114bb
jnp 0x114c9
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 0xf004
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x50(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rsi, %rbx
movq %rdi, %r14
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq 0x18(%rsi), %r12
addq $0x8, %rbx
leaq 0x40(%rdi), %r15
addq $0x48, %r14
leaq -0x58(%rbp), %r13
cmpq %rbx, %r12
je 0x11613
leaq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x11cde
cmpq %r14, %rax
je 0x11606
movq 0x40(%rax), %rsi
addq $0x30, %rax
movq %r13, %rdi
movq %rax, %rdx
callq 0x11d3a
movq %r12, %rdi
callq 0x43d0
movq %rax, %r12
jmp 0x115dc
leaq -0x58(%rbp), %rdi
movq 0x28(%rdi), %rbx
callq 0x725c
movq %rbx, %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 0x725c
movq %rbx, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x120aa
movq 0x18(%r14), %rcx
addq $0x8, %r14
movq %r14, -0x40(%rbp)
leaq 0x40(%r15), %rax
movq %rax, -0x30(%rbp)
addq $0x48, %r15
movq %r15, -0x38(%rbp)
leaq 0x8(%rbx), %r12
cmpq -0x40(%rbp), %rcx
je 0x1172f
movq %rcx, -0x48(%rbp)
leaq 0x20(%rcx), %rsi
movq -0x30(%rbp), %rdi
callq 0x11cde
cmpq -0x38(%rbp), %rax
je 0x1171e
movq %rax, %r15
movq 0x40(%rax), %r14
addq $0x30, %r15
movq %r15, -0x50(%rbp)
cmpq %r15, %r14
je 0x1171e
leaq 0x20(%r14), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0xc044
cmpq %r12, %rax
jne 0x1170d
movq %r12, %r15
leaq -0x78(%rbp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x44d0
andq $0x0, -0x58(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb50a
movq %r12, %rdi
callq 0x4180
movq %rbx, %rdi
movq %r13, %rsi
callq 0xc044
movq %r15, %r12
movq -0x50(%rbp), %r15
incq 0x40(%rax)
movq %r14, %rdi
callq 0x43d0
movq %rax, %r14
jmp 0x116b8
movq -0x48(%rbp), %rdi
callq 0x43d0
movq %rax, %rcx
jmp 0x11688
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x4180
movq %rbx, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x68(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r12
addq $0x8, %rbx
leaq 0x40(%rdi), %rax
movq %rax, -0x40(%rbp)
addq $0x48, %r14
xorl %r15d, %r15d
cmpq %rbx, %r12
je 0x117d9
leaq 0x20(%r12), %rsi
movq -0x40(%rbp), %rdi
callq 0x11cde
movq %rax, %r13
cmpq %r14, %rax
je 0x117cc
movq 0x40(%r13), %rsi
movq %r13, %rdx
addq $0x30, %rdx
leaq -0x70(%rbp), %rdi
callq 0x11d3a
addq 0x50(%r13), %r15
movq %r12, %rdi
callq 0x43d0
movq %rax, %r12
jmp 0x11799
xorpd %xmm3, %xmm3
testq %r15, %r15
je 0x11828
movq %r15, %xmm0
movq 0x4971(%rip), %xmm1     # 0x16160
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x4975(%rip), %xmm2     # 0x16170
subpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
movq -0x48(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
subpd %xmm2, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd %xmm1, %xmm3
movapd %xmm3, -0x40(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x725c
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 0x725c
movq %rbx, %rdi
callq 0x4660
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x41e0
movq %rbx, %rdi
callq 0x1243c
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4180
movq %r14, %rdi
callq 0x4660
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x12474
btl %ecx, %r12d
jae 0x12474
incq %r15
jmp 0x1245c
testl %eax, %eax
je 0x124f0
movq (%r14), %r13
movsbl (%r13,%r15), %edi
callq 0x46c0
movb %al, (%r13,%r15)
cmpb $0x4e, (%rbx,%r15)
jne 0x1246f
pushq $0x28
popq %rdi
callq 0x41b0
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
movq %r14, %rsi
callq 0x44d0
leaq 0x3d7a(%rip), %rsi      # 0x1622a
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x4140
movb $0x1, %r15b
leaq 0x400c(%rip), %rdx      # 0x164d3
leaq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rcx
movq %rbx, %rdi
callq 0x12840
xorl %r15d, %r15d
leaq 0xc827(%rip), %rsi      # 0x1ed08
leaq -0xa418(%rip), %rdx     # 0x80d0
movq %rbx, %rdi
callq 0x4620
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x4180
jmp 0x12513
movq %rax, %r14
movb $0x1, %r15b
leaq -0x70(%rbp), %rdi
callq 0x4180
testb %r15b, %r15b
jne 0x12526
jmp 0x1252e
movq %rax, %r14
movq %rbx, %rdi
callq 0x4260
movq %r14, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x44d0
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x131e4
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x123fc
leaq -0x38(%rbp), %rdi
callq 0x4180
leaq -0x58(%rbp), %rdi
callq 0x4180
movl 0x8(%rbx), %r15d
decq %r15
testl %r15d, %r15d
js 0x12697
movl %r15d, %r14d
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12e1c
cmpb $0x41, %al
je 0x12685
movzbl %al, %eax
cmpl $0x54, %eax
je 0x1267d
cmpl $0x47, %eax
je 0x12681
cmpl $0x43, %eax
jne 0x12646
movb $0x47, %al
jmp 0x12687
movb $0x41, %al
jmp 0x12687
movb $0x43, %al
jmp 0x12687
movb $0x54, %al
movzbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12e2a
jmp 0x12646
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x4180
jmp 0x126b6
movq %rax, %r14
leaq -0x58(%rbp), %rdi
jmp 0x126c2
movq %rax, %r14
movq %rbx, %rdi
callq 0x4180
movq %r14, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O2/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
movq (%rdi), %rdx
movq 0x8(%rdi), %rax
xorl %edi, %edi
xorl %ecx, %ecx
xorl %esi, %esi
cmpq %rdi, %rax
je 0x127c7
movzbl (%rdx,%rdi), %r8d
cmpl $0x43, %r8d
je 0x127bf
cmpl $0x47, %r8d
je 0x127bf
cmpl $0x4e, %r8d
jne 0x127c2
incq %rsi
jmp 0x127c2
incq %rcx
incq %rdi
jmp 0x1279e
xorpd %xmm0, %xmm0
subq %rsi, %rax
je 0x12816
movq %rcx, %xmm1
movq 0x3983(%rip), %xmm2     # 0x16160
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x3987(%rip), %xmm3     # 0x16170
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
// File: /workspace/github_cpp_makefile_star2_O2/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
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
xorl %esi, %esi
xorl %eax, %eax
cmpq %rsi, %rdx
je 0x1283e
xorl %edi, %edi
cmpb $0x4e, (%rcx,%rsi)
sete %dil
addq %rdi, %rax
incq %rsi
jmp 0x12827
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x4300
movq %rax, %rsi
subl 0xc5a6(%rip), %esi      # 0x1f488
movl $0xe10, %ecx            # imm = 0xE10
movl %esi, %eax
xorl %edx, %edx
divl %ecx
movl %eax, %r8d
movl %edx, %eax
movw $0x3c, %cx
xorl %edx, %edx
divw %cx
movzwl %ax, %ecx
pushq $0x3c
popq %rdi
movl %esi, %eax
xorl %edx, %edx
divl %edi
movl %edx, %eax
leaq 0x3700(%rip), %rsi      # 0x16610
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movl %r8d, %edx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4080
leaq -0x11(%rbp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4140
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $-0x1
popq %r14
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x12f78
movq (%rbx), %rax
movzbl -0x1(%rax,%rsi), %eax
cmpl $0xd, %eax
je 0x12f68
cmpl $0xa, %eax
jne 0x12f78
decq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x40b0
jmp 0x12f4d
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4160
testq %rax, %rax
je 0x12fa9
movzbl -0x1(%rbx,%rax), %ecx
cmpl $0xd, %ecx
je 0x12f9f
cmpl $0xa, %ecx
jne 0x12fa9
movb $0x0, -0x1(%rbx,%rax)
decq %rax
jne 0x12f90
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r12
movq %r12, %r14
movq %r12, %r15
movq 0x8(%rbx), %rdx
addq %r12, %rdx
cmpq %rdx, %r14
je 0x12ff4
movb (%r14), %r13b
movsbl %r13b, %edi
callq 0x4060
testl %eax, %eax
jne 0x12fef
movb %r13b, (%r15)
incq %r15
movq (%rbx), %r12
incq %r14
jmp 0x12fca
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x40a0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r12
testq %r12, %r12
je 0x13060
movq %rdi, %rbx
movq (%rdi), %r14
movsbl (%r14), %edi
callq 0x4060
testl %eax, %eax
je 0x13060
leaq (%r14,%r12), %r13
decq %r13
leaq -0x1(%r14), %r15
decq %r12
testq %r12, %r12
je 0x1306f
movsbl 0x2(%r15), %edi
callq 0x4060
incq %r15
decq %r12
testl %eax, %eax
jne 0x13045
jmp 0x13072
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x40a0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x130d0
movq %rdi, %rbx
movq (%rdi), %r15
movsbl -0x1(%r15,%r14), %edi
callq 0x4060
testl %eax, %eax
je 0x130d0
cmpq $0x1, %r14
je 0x130db
movsbl -0x2(%r15,%r14), %edi
decq %r14
callq 0x4060
testl %eax, %eax
jne 0x130b6
jmp 0x130de
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x40b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
movq %rdx, %rdi
callq 0x135d6
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x131bd
movq %rbx, -0x30(%rbp)
xorl %ebx, %ebx
movsbl %r15b, %r15d
leaq -0x50(%rbp), %r12
cmpq %rax, %rbx
jae 0x13183
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x44a0
cmpq $-0x1, %rax
je 0x13183
movq %rax, %r13
movq %rax, %rcx
subq %rbx, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4380
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x13666
movq %r12, %rdi
callq 0x4180
incq %r13
movq 0x8(%r14), %rax
movq %r13, %rbx
jmp 0x13133
leaq -0x50(%rbp), %r15
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4380
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13666
leaq -0x50(%rbp), %rdi
callq 0x4180
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x5, %rax
jmp 0x131bf
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x131d0
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4180
movq %rbx, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
incq %rsi
callq 0x4590
movq (%r14), %r15
addq 0x8(%r14), %r15
cmpq (%r14), %r15
je 0x1322e
movsbl -0x1(%r15), %esi
decq %r15
movq %rbx, %rdi
callq 0x42b0
jmp 0x13217
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1323e
movq %rax, %r14
movq %rbx, %rdi
callq 0x4180
movq %r14, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0x44e0
leaq -0x450(%rbp), %r15
leaq -0x50(%rbp), %r12
pushq $0xa
popq %r13
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x45a0
testq %rax, %rax
je 0x13346
movq %r12, %rdi
movq %r15, %rsi
leaq -0x29(%rbp), %rdx
callq 0x4140
movq %r14, %rdi
movq %r12, %rsi
callq 0x4730
movq %r12, %rdi
callq 0x4180
movq %r15, %rdi
movl %r13d, %esi
callq 0x4130
testq %rax, %rax
je 0x132ff
movq %rbx, %rdi
callq 0x4570
testl %eax, %eax
sete %al
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4180
movq %rbx, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x44d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x131e4
leaq -0x30(%rbp), %rdi
callq 0x4180
movq (%rbx), %rcx
movq %rcx, %rax
addq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x133f7
movzbl (%rax), %edx
movb $0x54, %cl
cmpl $0x41, %edx
je 0x133ed
cmpl $0x43, %edx
je 0x133e3
cmpl $0x47, %edx
je 0x133e7
cmpl $0x54, %edx
je 0x133eb
cmpl $0x61, %edx
je 0x133ed
cmpl $0x74, %edx
je 0x133eb
cmpl $0x67, %edx
je 0x133e7
cmpl $0x63, %edx
jne 0x133ef
movb $0x47, %cl
jmp 0x133ed
movb $0x43, %cl
jmp 0x133ed
movb $0x41, %cl
movb %cl, (%rax)
incq %rax
movq (%rbx), %rcx
jmp 0x133ad
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x4180
movq %rbx, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
testq %rsi, %rsi
je 0x134e2
movq %rsi, %r14
movq %rdi, %r15
pushq $0x8
popq %r12
movq %rbx, %rdi
movl %r12d, %esi
callq 0x43f0
movq %rax, %rdi
movl %r12d, %esi
callq 0x43f0
testq %r15, %r15
je 0x134ee
pushq $0xa
popq %r13
testq %r15, %r15
je 0x134f9
movq %rbx, %rdi
movl %r12d, %esi
callq 0x43f0
movq %r15, %rax
xorl %edx, %edx
divq %r13
movq %rax, %r15
jmp 0x134c5
leaq 0x3139(%rip), %rsi      # 0x16622
movq %rbx, %rdi
jmp 0x1350e
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x43f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4240
leaq 0x3118(%rip), %rsi      # 0x16623
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4340
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
xorl %r12d, %r12d
leaq -0x90(%rbp), %rcx
movl $0x1000, %esi           # imm = 0x1000
xorl %edx, %edx
callq 0x43a0
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq -0x48(%rbp), %r14
leaq -0x21(%rbp), %r15
movl %r12d, %r12d
cmpq %r12, -0x90(%rbp)
jbe 0x13599
movq -0x88(%rbp), %rax
movq (%rax,%r12,8), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x4140
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13666
movq %r14, %rdi
callq 0x4180
incl %r12d
jmp 0x1355f
leaq -0x90(%rbp), %rdi
callq 0x4090
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x4180
jmp 0x135c6
movq %rax, %r14
movq %rbx, %rdi
callq 0x135e4
movq %r14, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/ClusterQuality.cpp
// Function: standard_deviation(std::vector<std::pair<unsigned long, double>, std::allocator<std::pair<unsigned long, double>>>, double&, double&)
void standard_deviation(vector<pair<size_t, double> > data, double& mean, double& stdev)
{
	if(data.size() == 0) {
		mean = stdev = -1;
		return;
	}

	size_t	total_size = 0;
	mean=0;
	stdev=0;

	for(auto it=data.begin(); it!=data.end(); it++) {
		mean += it->first*it->second;
		total_size += it->first;
	}
	mean /= total_size;

	for(auto it=data.begin(); it!=data.end(); it++)
		stdev += it->first*(it->second-mean)*(it->second-mean);

	stdev = sqrt(stdev/(total_size-1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq %rax, %rcx
je 0x1396a
andq $0x0, (%rsi)
andq $0x0, (%rbx)
movsd (%rsi), %xmm2
xorl %edx, %edx
movq 0x28d9(%rip), %xmm0     # 0x16160
movapd 0x28e1(%rip), %xmm1     # 0x16170
movq %rax, %rdi
cmpq %rcx, %rdi
je 0x138c9
movq (%rdi), %r8
movq %r8, %xmm3
punpckldq %xmm0, %xmm3    # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1]
subpd %xmm1, %xmm3
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
addsd %xmm3, %xmm4
mulsd 0x8(%rdi), %xmm4
addsd %xmm4, %xmm2
movsd %xmm2, (%rsi)
addq %r8, %rdx
addq $0x10, %rdi
jmp 0x13892
movq %rdx, %xmm3
punpckldq 0x288a(%rip), %xmm3 # xmm3 = xmm3[0],mem[0],xmm3[1],mem[1]
subpd 0x2892(%rip), %xmm3     # 0x16170
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
addsd %xmm3, %xmm4
divsd %xmm4, %xmm2
movsd %xmm2, (%rsi)
cmpq %rcx, %rax
je 0x1392e
movq (%rax), %xmm2
punpckldq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
subpd %xmm1, %xmm2
movapd %xmm2, %xmm3
unpckhpd %xmm2, %xmm3            # xmm3 = xmm3[1],xmm2[1]
addsd %xmm2, %xmm3
movsd 0x8(%rax), %xmm2
subsd (%rsi), %xmm2
mulsd %xmm2, %xmm3
mulsd %xmm2, %xmm3
addsd (%rbx), %xmm3
movsd %xmm3, (%rbx)
addq $0x10, %rax
jmp 0x138f2
decq %rdx
movq %rdx, %xmm1
punpckldq 0x2822(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x282a(%rip), %xmm1     # 0x16170
movsd (%rbx), %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1397c
sqrtsd %xmm0, %xmm0
jmp 0x13981
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, (%rbx)
movq %rax, (%rsi)
jmp 0x13985
callq 0x4290
movsd %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, %r15
movq %rcx, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq %rdi, -0x40(%rbp)
xorps %xmm0, %xmm0
leaq -0x80(%rbp), %rbx
movaps %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq 0x88(%rsi), %rcx
addq $0x78, %rsi
movq %rsi, -0x48(%rbp)
leaq -0x60(%rbp), %r13
cmpq -0x48(%rbp), %rcx
je 0x13a64
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, -0x50(%rbp)
movq 0x20(%rcx), %rcx
movq 0x78(%rax), %rsi
movq 0x80(%rax), %rax
subq %rsi, %rax
cqto
pushq $0x48
popq %rdi
idivq %rdi
imulq $0x48, %rcx, %r14
addq %rsi, %r14
cmpq %rcx, %rax
movl $0x0, %eax
cmovbeq %rax, %r14
movq 0x20(%r14), %r12
addq $0x10, %r14
cmpq %r14, %r12
je 0x13a53
movq 0x20(%r12), %rax
movq (%rax), %rsi
movq %r15, %rdi
callq 0xc452
movq $0x1, -0x60(%rbp)
movsd %xmm0, -0x58(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x14310
movq %r12, %rdi
callq 0x43d0
movq %rax, %r12
jmp 0x13a19
movq -0x50(%rbp), %rdi
callq 0x43d0
movq %rax, %rcx
jmp 0x139ce
leaq -0x98(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x140f4
leaq -0x98(%rbp), %rbx
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x13858
movq %rbx, %rdi
callq 0x142fc
leaq -0x80(%rbp), %rdi
callq 0x142fc
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13aad
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x142fc
movq %rbx, %rdi
callq 0x4660
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq %rsi, %r15
movq %rdi, %r12
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq 0x88(%rsi), %rbx
addq $0x78, %r15
pushq $0x48
popq %r14
cmpq %r15, %rbx
je 0x13bcb
movq 0x8(%r12), %rax
movq 0x78(%rax), %rcx
movq 0x80(%rax), %rax
subq %rcx, %rax
cqto
idivq %r14
testq %rcx, %rcx
je 0x13bbe
movq 0x20(%rbx), %rdx
cmpq %rdx, %rax
jbe 0x13bbe
imulq $0x48, %rdx, %rax
leaq (%rcx,%rax), %rdi
movq 0x38(%rcx,%rax), %rax
movq 0x50(%rax), %r13
callq 0x14144
movq %r13, -0x60(%rbp)
movsd %xmm0, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x14310
movq %rbx, %rdi
callq 0x43d0
movq %rax, %rbx
jmp 0x13b67
leaq -0x78(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x140f4
leaq -0x78(%rbp), %rbx
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x13858
movq %rbx, %rdi
callq 0x142fc
leaq -0x50(%rbp), %rdi
callq 0x142fc
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13c0e
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x142fc
movq %rbx, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq %rsi, %r15
movq %rdi, %r12
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %r13
movaps %xmm0, (%r13)
andq $0x0, 0x10(%r13)
movq 0x88(%rsi), %rbx
addq $0x78, %r15
pushq $0x48
popq %r14
cmpq %r15, %rbx
je 0x13cc1
movq 0x8(%r12), %rax
movq 0x78(%rax), %rcx
movq 0x80(%rax), %rax
subq %rcx, %rax
cqto
idivq %r14
testq %rcx, %rcx
je 0x13cb4
movq 0x20(%rbx), %rdx
cmpq %rdx, %rax
jbe 0x13cb4
imulq $0x48, %rdx, %rax
movq 0x38(%rcx,%rax), %rdx
movq 0x50(%rdx), %rdx
movsd 0x40(%rcx,%rax), %xmm0
movq %rdx, -0x48(%rbp)
movsd %xmm0, -0x40(%rbp)
movq %r13, %rdi
leaq -0x48(%rbp), %rsi
callq 0x14310
movq %rbx, %rdi
callq 0x43d0
movq %rax, %rbx
jmp 0x13c61
leaq -0x78(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x140f4
leaq -0x78(%rbp), %rbx
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x13858
movq %rbx, %rdi
callq 0x142fc
leaq -0x60(%rbp), %rdi
callq 0x142fc
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13d04
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x142fc
movq %rbx, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq 0x88(%rsi), %rcx
addq $0x78, %rbx
movq 0x8(%rdi), %r15
xorl %r14d, %r14d
pushq $0x48
popq %r12
cmpq %rbx, %rcx
je 0x13d82
movq 0x20(%rcx), %rdi
movq 0x78(%r15), %rsi
movq 0x80(%r15), %rax
subq %rsi, %rax
cqto
idivq %r12
cmpq %rdi, %rax
ja 0x13d61
xorl %esi, %esi
jmp 0x13d68
imulq $0x48, %rdi, %rax
addq %rax, %rsi
movq 0x38(%rsi), %rax
testq %rax, %rax
je 0x13d75
addq 0x50(%rax), %r14
movq %rcx, %rdi
callq 0x43d0
movq %rax, %rcx
jmp 0x13d3c
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x9d8, %rsp            # imm = 0x9D8
movq 0x2e01(%rip), %rbx      # 0x3fd8
leaq 0xe26(%rip), %rsi       # 0x2004
movq %rbx, %rdi
callq 0x1050
movq %rax, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1030
leaq 0xe27(%rip), %rsi       # 0x2024
movq %rbx, %rdi
callq 0x1050
movq %rax, %rdi
callq 0x1030
xorl %r14d, %r14d
leaq -0x9f8(%rbp), %r15
leaq -0x30(%rbp), %r12
leaq 0xe10(%rip), %rbx       # 0x2032
cmpl 0x2e27(%rip), %r14d     # 0x4050
jg 0x1292
movl %r14d, -0x30(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x12bc
movabsq $0x186a000000001, %rax  # imm = 0x186A000000001
movq %rax, -0x30(%rbp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x12a6
movq %rbx, %r13
cmpl $0x18696, %eax          # imm = 0x18696
jg 0x126b
leaq 0xdd5(%rip), %r13       # 0x2039
cmpl $0x7d0, %eax            # imm = 0x7D0
jg 0x128d
movq 0x2d66(%rip), %rdi      # 0x3fd8
movl %r14d, %esi
callq 0x1070
movq %rax, %rdi
movq %r13, %rsi
callq 0x1050
movq %rax, %rdi
callq 0x1030
incl %r14d
jmp 0x1222
xorl %eax, %eax
addq $0x9d8, %rsp            # imm = 0x9D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tdv[P]boss/boss/examples/multy_object/main.cpp
// Function: FuncForIFace1(MyNs::IFaces::IFace1*)
void FuncForIFace1(MyNs::IFaces::IFace1 *obj)
{
  if (!obj)
  {
    std::cerr << "No object." << std::endl;
    return;
  }
  if (obj->Method1() != Boss::Status::Ok)
    std::cout << "Failed to call IFace1::Method1" << std::endl;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x17083
movq (%rdi), %rax
callq *0x28(%rax)
testl %eax, %eax
je 0x1709f
leaq 0xe0386(%rip), %rdi     # 0xf7400
leaq 0xa3f8e(%rip), %rsi     # 0xbb00f
jmp 0x17091
leaq 0xe0256(%rip), %rdi     # 0xf72e0
leaq 0xa3f73(%rip), %rsi     # 0xbb004
callq 0x81cf0
movq %rax, %rdi
popq %rax
jmp 0x815d0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/tdv[P]boss/boss/examples/multy_object/main.cpp
// Function: FuncForIFace2(MyNs::IFaces::IFace2*)
void FuncForIFace2(MyNs::IFaces::IFace2 *obj)
{
  if (!obj)
  {
    std::cerr << "No object." << std::endl;
    return;
  }
  if (obj->Method2() != Boss::Status::Ok)
    std::cout << "Failed to call IFace2::Method2" << std::endl;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x170c1
movq (%rdi), %rax
callq *0x28(%rax)
testl %eax, %eax
je 0x170dd
leaq 0xe0348(%rip), %rdi     # 0xf7400
leaq 0xa3f6f(%rip), %rsi     # 0xbb02e
jmp 0x170cf
leaq 0xe0218(%rip), %rdi     # 0xf72e0
leaq 0xa3f35(%rip), %rsi     # 0xbb004
callq 0x81cf0
movq %rax, %rdi
popq %rax
jmp 0x815d0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/tdv[P]boss/boss/examples/multy_object/main.cpp
// Function: FuncForIFace3(MyNs::IFaces::IFace3*)
void FuncForIFace3(MyNs::IFaces::IFace3 *obj)
{
  if (!obj)
  {
    std::cerr << "No object." << std::endl;
    return;
  }
  if (obj->Method3() != Boss::Status::Ok)
    std::cout << "Failed to call IFace3::Method3" << std::endl;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x170ff
movq (%rdi), %rax
callq *0x30(%rax)
testl %eax, %eax
je 0x1711b
leaq 0xe030a(%rip), %rdi     # 0xf7400
leaq 0xa3f50(%rip), %rsi     # 0xbb04d
jmp 0x1710d
leaq 0xe01da(%rip), %rdi     # 0xf72e0
leaq 0xa3ef7(%rip), %rsi     # 0xbb004
callq 0x81cf0
movq %rax, %rdi
popq %rax
jmp 0x815d0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/tdv[P]boss/boss/examples/multy_object/main.cpp
// Function: FuncForIFace4(MyNs::IFaces::IFace4*)
void FuncForIFace4(MyNs::IFaces::IFace4 *obj)
{
  if (!obj)
  {
    std::cerr << "No object." << std::endl;
    return;
  }
  if (obj->Method4() != Boss::Status::Ok)
    std::cout << "Failed to call IFace4::Method4" << std::endl;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1713d
movq (%rdi), %rax
callq *0x28(%rax)
testl %eax, %eax
je 0x17159
leaq 0xe02cc(%rip), %rdi     # 0xf7400
leaq 0xa3f31(%rip), %rsi     # 0xbb06c
jmp 0x1714b
leaq 0xe019c(%rip), %rdi     # 0xf72e0
leaq 0xa3eb9(%rip), %rsi     # 0xbb004
callq 0x81cf0
movq %rax, %rdi
popq %rax
jmp 0x815d0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/tdv[P]boss/boss/examples/multy_object/main.cpp
// Function: main
int main()
{
  try
  {
    auto Obj = Boss::Base<MyNs::Impl::Face_1_2_3_4>::Create();
    FuncForIFace1(Boss::RefObjQIPtr<MyNs::IFaces::IFace1>(Obj).Get());
    FuncForIFace2(Boss::RefObjQIPtr<MyNs::IFaces::IFace2>(Obj).Get());
    FuncForIFace3(Boss::RefObjQIPtr<MyNs::IFaces::IFace3>(Obj).Get());
    FuncForIFace4(Boss::RefObjQIPtr<MyNs::IFaces::IFace4>(Obj).Get());
  }
  catch (std::exception const &e)
  {
    std::cerr << "Error: " << e.what() << std::endl;
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rsp), %rdi
callq 0x172d8
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1734a
movq 0x8(%rsp), %rdi
callq 0x17063
leaq 0x8(%rsp), %rdi
callq 0x17364
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x17374
movq 0x8(%rsp), %rdi
callq 0x170a1
leaq 0x8(%rsp), %rdi
callq 0x1738e
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1739e
movq 0x8(%rsp), %rdi
callq 0x170df
leaq 0x8(%rsp), %rdi
callq 0x173b8
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x173c8
movq 0x8(%rsp), %rdi
callq 0x1711d
leaq 0x8(%rsp), %rdi
callq 0x173e2
leaq 0x10(%rsp), %rdi
callq 0x173f2
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %r14
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x173e2
jmp 0x17260
jmp 0x1725a
movq %rdx, %r14
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x173b8
jmp 0x17260
jmp 0x1725a
movq %rdx, %r14
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1738e
jmp 0x17260
jmp 0x1725a
movq %rdx, %r14
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x17364
jmp 0x17260
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x173f2
cmpl $0x1, %r14d
jne 0x172bf
movq %rbx, %rdi
callq 0x17d20
movq %rax, %rbx
leaq 0xe005e(%rip), %rdi     # 0xf72e0
leaq 0xa3e02(%rip), %rsi     # 0xbb08b
callq 0x81cf0
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x81cf0
movq %rax, %rdi
callq 0x815d0
callq 0x17d90
jmp 0x17202
movq %rax, %rbx
callq 0x17d90
movq %rbx, %rdi
callq 0xb86a0
movq %rax, %rdi
callq 0x17402
movq %rdx, %r14
movq %rax, %rbx
jmp 0x1726a
nop
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/docker.cpp
// Function: Docker::requestAndParseJson(Method, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>&)
JSON_DOCUMENT Docker::requestAndParseJson(Method method, const std::string& path, unsigned success_code, JSON_DOCUMENT& param){
    auto result_obj = requestAndParse(method,path,success_code,param,true);
    bool result = (result_obj.HasMember("success") && result_obj["success"].IsBool() && result_obj["success"].GetBool());
    if(result){
        JSON_DOCUMENT doc(rapidjson::kObjectType);

        JSON_DOCUMENT data(&doc.GetAllocator());
        data.Parse(result_obj["data"].GetString());

        doc.AddMember("success", true, doc.GetAllocator());
        doc.AddMember("data", data, doc.GetAllocator());
        return doc;
    }else{
        return result_obj;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
movl $0x1, (%rsp)
leaq -0xe0(%rbp), %r14
movq %r14, %rdi
callq 0x9940
leaq 0x7298(%rip), %rsi      # 0x11258
movq %r14, %rdi
callq 0x9a00
testb %al, %al
je 0xa0e6
leaq 0x7281(%rip), %rsi      # 0x11258
leaq -0xe0(%rbp), %rdi
callq 0x90a0
testb $0x8, 0xe(%rax)
je 0xa0e6
leaq 0x7264(%rip), %r14      # 0x11258
leaq -0xe0(%rbp), %rdi
movq %r14, %rsi
callq 0x90a0
movq %rax, %rdi
callq 0x9b70
testb %al, %al
je 0xa0e6
pushq $0x3
popq %rsi
movl $0x400, %ecx            # imm = 0x400
movq %rbx, %rdi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x9130
movq %rbx, %rdi
callq 0x9350
xorps %xmm0, %xmm0
movaps %xmm0, -0x80(%rbp)
movq %rax, -0x70(%rbp)
movups %xmm0, -0x68(%rbp)
movups %xmm0, -0x58(%rbp)
movups %xmm0, -0x48(%rbp)
movq $0x400, -0x38(%rbp)     # imm = 0x400
andl $0x0, -0x30(%rbp)
andq $0x0, -0x28(%rbp)
leaq 0x7201(%rip), %r15      # 0x11260
leaq -0xe0(%rbp), %rdi
movq %r15, %rsi
callq 0x90a0
movq %rax, %rdi
callq 0x90d0
leaq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x9930
leaq -0x100(%rbp), %r12
movq %r14, (%r12)
movl $0x7, 0x8(%r12)
movq %rbx, %rdi
callq 0x9350
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rcx
callq 0x9c30
leaq -0xf0(%rbp), %r14
movq %r15, (%r14)
movl $0x4, 0x8(%r14)
movq %rbx, %rdi
callq 0x9350
leaq -0x80(%rbp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rcx
callq 0x9540
leaq -0x80(%rbp), %rdi
callq 0x9d48
jmp 0xa0f5
leaq -0xe0(%rbp), %rsi
movq %rbx, %rdi
callq 0x9ae0
leaq -0xe0(%rbp), %rdi
callq 0x9d48
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x80(%rbp), %rdi
callq 0x9d48
movq %rbx, %rdi
callq 0x9d48
jmp 0xa12d
movq %rax, %r14
leaq -0xe0(%rbp), %rdi
callq 0x9d48
movq %r14, %rdi
callq 0x9be0
nop
// File: /workspace/github_cpp_makefile_star2_O2/cqbqdd11519[P]DockerClient/docker.cpp
// Function: param(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
std::string param( const std::string& param_name, bool param_value){
    std::string ret;
    ret = "&" + param_name + "=";
    if(param_value){
        return ret + "true";
    }
    else{
        return ret + "false";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %edx, %r14d
movq %rsi, %rdx
movq %rdi, %rbx
leaq -0x50(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x6d9b(%rip), %rsi      # 0x1126a
leaq -0x40(%rbp), %rdi
callq 0x94c0
leaq 0x6c71(%rip), %rdx      # 0x11150
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x90b0
leaq -0x60(%rbp), %r15
leaq -0x80(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x97b0
movq %r12, %rdi
callq 0x9240
leaq -0x40(%rbp), %rdi
callq 0x9240
leaq 0x6d55(%rip), %rax      # 0x1126c
leaq 0x6d53(%rip), %rdx      # 0x11271
testb %r14b, %r14b
cmovneq %rax, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9830
leaq -0x60(%rbp), %rdi
callq 0x9240
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa559
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x9240
jmp 0xa55c
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x9240
movq %rbx, %rdi
callq 0x9be0