LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: CK7[P]abawaca/src/TinyMT-src-1.0.1/tinymt/tinymt32.c
// Function: period_certification(TINYMT32_T*)
static void period_certification(tinymt32_t * random) {
    if ((random->status[0] & TINYMT32_MASK) == 0 &&
	random->status[1] == 0 &&
	random->status[2] == 0 &&
	random->status[3] == 0) {
	random->status[0] = 'T';
	random->status[1] = 'I';
	random->status[2] = 'N';
	random->status[3] = 'Y';
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpl $0x0, %eax
jne 0x11e91
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x11e91
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x11e91
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x11e91
movq -0x8(%rbp), %rax
movl $0x54, (%rax)
movq -0x8(%rbp), %rax
movl $0x49, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x4e, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x59, 0xc(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/TinyMT-src-1.0.1/tinymt/tinymt32.h
// Function: tinymt32_next_state(TINYMT32_T*)
inline static void tinymt32_next_state(tinymt32_t * random) {
    uint32_t x;
    uint32_t y;

    y = random->status[3];
    x = (random->status[0] & TINYMT32_MASK)
	^ random->status[1]
	^ random->status[2];
    x ^= (x << TINYMT32_SH0);
    y ^= (y >> TINYMT32_SH0) ^ x;
    random->status[0] = random->status[1];
    random->status[1] = random->status[2];
    random->status[2] = x ^ (y << TINYMT32_SH1);
    random->status[3] = y;
    random->status[1] ^= -((int32_t)(y & 1)) & random->mat1;
    random->status[2] ^= -((int32_t)(y & 1)) & random->mat2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq -0x8(%rbp), %rcx
xorl 0x4(%rcx), %eax
movq -0x8(%rbp), %rcx
xorl 0x8(%rcx), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
shrl %eax
xorl -0xc(%rbp), %eax
xorl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %eax
shll $0xa, %eax
xorl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x10(%rbp), %eax
andl $0x1, %eax
xorl %ecx, %ecx
subl %eax, %ecx
movq -0x8(%rbp), %rax
andl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
xorl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl -0x10(%rbp), %eax
andl $0x1, %eax
xorl %ecx, %ecx
subl %eax, %ecx
movq -0x8(%rbp), %rax
andl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
xorl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/ScafDpData.cpp
// Function: ScafDpData::dp2scaf(unsigned long) const
size_t ScafDpData::dp2scaf(size_t dp) const
{
	if((dp == 0) || (dp >= dps.size())) {
		char s[2048];
		sprintf(s, "%s (%d): Invalid dp %lu", __FILE__, __LINE__, dp);
		throw invalid_argument(s);
	}
	return dps[dp].get_scaf_id();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x840, %rsp            # imm = 0x840
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x828(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13a93
movq -0x828(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x830(%rbp)
addq $0x60, %rdi
callq 0xcab0
movq %rax, %rcx
movq -0x830(%rbp), %rax
cmpq %rcx, %rax
jb 0x13b1e
movq -0x10(%rbp), %r8
leaq 0x21f1b(%rip), %rsi     # 0x359b9
leaq 0x21cf2(%rip), %rdx     # 0x35797
xorl %eax, %eax
leaq -0x810(%rbp), %rdi
movq %rdi, -0x840(%rbp)
movl $0x7f, %ecx
callq 0x50b0
movl $0x10, %edi
callq 0x51e0
movq -0x840(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x838(%rbp)
callq 0x57f0
jmp 0x13ae4
movq -0x838(%rbp), %rdi
movq 0x394d6(%rip), %rsi     # 0x4cfc8
movq 0x394bf(%rip), %rdx     # 0x4cfb8
callq 0x5700
movq -0x838(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x818(%rbp)
movl %eax, -0x81c(%rbp)
callq 0x52d0
jmp 0x13b43
movq -0x828(%rbp), %rdi
addq $0x60, %rdi
movq -0x10(%rbp), %rsi
callq 0x15560
movq %rax, %rdi
callq 0x15450
addq $0x840, %rsp            # imm = 0x840
popq %rbp
retq
movq -0x818(%rbp), %rdi
callq 0x5750
nop
// File: CK7[P]abawaca/src/ScafDpData.cpp
// Function: ScafDpData::ndps(unsigned long) const
size_t ScafDpData::ndps(size_t scaf_id) const
{
	if((scaf_id == 0) || (scaf_id >= scafs.size())) {
		char s[2048];
		sprintf(s, "%s (%d): Invalid scaf_id %lu", __FILE__, __LINE__, scaf_id);
		throw invalid_argument(s);
	}
        return scafs[scaf_id].get_scaf_dps().size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x840, %rsp            # imm = 0x840
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x828(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13ba3
movq -0x828(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x830(%rbp)
addq $0x78, %rdi
callq 0xcae0
movq %rax, %rcx
movq -0x830(%rbp), %rax
cmpq %rcx, %rax
jb 0x13c2e
movq -0x10(%rbp), %r8
leaq 0x21e23(%rip), %rsi     # 0x359d1
leaq 0x21be2(%rip), %rdx     # 0x35797
xorl %eax, %eax
leaq -0x810(%rbp), %rdi
movq %rdi, -0x840(%rbp)
movl $0x8a, %ecx
callq 0x50b0
movl $0x10, %edi
callq 0x51e0
movq -0x840(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x838(%rbp)
callq 0x57f0
jmp 0x13bf4
movq -0x838(%rbp), %rdi
movq 0x393c6(%rip), %rsi     # 0x4cfc8
movq 0x393af(%rip), %rdx     # 0x4cfb8
callq 0x5700
movq -0x838(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x818(%rbp)
movl %eax, -0x81c(%rbp)
callq 0x52d0
jmp 0x13c5b
movq -0x828(%rbp), %rdi
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
callq 0xdd30
movq %rax, %rdi
callq 0x15580
movq %rax, %rdi
callq 0x155a0
addq $0x840, %rsp            # imm = 0x840
popq %rbp
retq
movq -0x818(%rbp), %rdi
callq 0x5750
nopw (%rax,%rax)
// File: CK7[P]abawaca/src/ScafDpData.cpp
// Function: ScafDpData::scaf_id2name[abi:cxx11](unsigned long) const
string ScafDpData::scaf_id2name(size_t scaf_id) const
{
	if((scaf_id == 0) || (scaf_id >= scafs.size())) {
		char s[2048];
		sprintf(s, "%s (%d): Invalid scaf_id %lu", __FILE__, __LINE__, scaf_id);
		throw invalid_argument(s);
	}
        return scafs[scaf_id].get_seq_obj()->display_id();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x860, %rsp            # imm = 0x860
movq %rdi, -0x848(%rbp)
movq %rdi, %rax
movq %rax, -0x840(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x838(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x13cd8
movq -0x838(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x850(%rbp)
addq $0x78, %rdi
callq 0xcae0
movq %rax, %rcx
movq -0x850(%rbp), %rax
cmpq %rcx, %rax
jb 0x13d63
movq -0x18(%rbp), %r8
leaq 0x21cee(%rip), %rsi     # 0x359d1
leaq 0x21aad(%rip), %rdx     # 0x35797
xorl %eax, %eax
leaq -0x820(%rbp), %rdi
movq %rdi, -0x860(%rbp)
movl $0x95, %ecx
callq 0x50b0
movl $0x10, %edi
callq 0x51e0
movq -0x860(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x858(%rbp)
callq 0x57f0
jmp 0x13d29
movq -0x858(%rbp), %rdi
movq 0x39291(%rip), %rsi     # 0x4cfc8
movq 0x3927a(%rip), %rdx     # 0x4cfb8
callq 0x5700
movq -0x858(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x828(%rbp)
movl %eax, -0x82c(%rbp)
callq 0x52d0
jmp 0x13da6
movq -0x838(%rbp), %rdi
addq $0x78, %rdi
movq -0x18(%rbp), %rsi
callq 0xdd30
movq %rax, %rdi
callq 0xa9a0
movq %rax, %rdi
callq 0x11ce0
movq -0x848(%rbp), %rdi
movq %rax, %rsi
callq 0x51a0
movq -0x840(%rbp), %rax
addq $0x860, %rsp            # imm = 0x860
popq %rbp
retq
movq -0x828(%rbp), %rdi
callq 0x5750
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: CK7[P]abawaca/src/SeqIORead.h
// Function: Bio::SeqIORead<Bio::Sequence<Bio::DNAString>>::restart()
void SeqIORead<S>::restart()
{
	SeqIO::restart();

	if(m_fp)
		fclose(m_fp);

	if(!(m_fp = fopen(this->file_name().c_str(), "r")))
		throw Bio::Bad_file(this->file_name(), "Failed to re-open file", __PRETTY_FUNCTION__);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xe2f0
movq -0x88(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x176ad
movq -0x88(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x5400
movq -0x88(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xef70
movq -0x98(%rbp), %rdi
callq 0x5190
movq %rax, %rdi
leaq 0x1da73(%rip), %rsi     # 0x3514d
callq 0x54b0
movq %rax, -0x90(%rbp)
jmp 0x176e8
movq -0x90(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rax, 0x38(%rcx)
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
movb %al, -0x99(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5250
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x17721
jmp 0x17826
movb $0x1, -0x7a(%rbp)
movl $0x28, %edi
callq 0x51e0
movq -0x88(%rbp), %rsi
movq %rax, -0xa8(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xef70
jmp 0x17748
leaq -0x79(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x5760
movq -0xb0(%rbp), %rdx
leaq 0x1de57(%rip), %rsi     # 0x355bd
leaq -0x78(%rbp), %rdi
callq 0x55b0
jmp 0x17771
movq -0xa8(%rbp), %rdi
leaq 0x1e2dc(%rip), %rcx     # 0x35a5b
xorl %eax, %eax
movl %eax, %r8d
leaq -0x58(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0xe310
jmp 0x17793
movq -0xa8(%rbp), %rdi
movb $0x0, -0x7a(%rbp)
leaq 0x351a3(%rip), %rsi     # 0x4c948
leaq -0x8cbc(%rip), %rdx     # 0xeaf0
callq 0x5700
jmp 0x17838
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5250
jmp 0x1782f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x17810
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x177fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x5250
leaq -0x79(%rbp), %rdi
callq 0x5460
leaq -0x58(%rbp), %rdi
callq 0x5250
testb $0x1, -0x7a(%rbp)
jne 0x17818
jmp 0x17824
movq -0xa8(%rbp), %rdi
callq 0x52d0
jmp 0x1782f
addq $0xb0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5750
nopl (%rax,%rax)
// File: CK7[P]abawaca/src/Dimension.cpp
// Function: Dimension::insert(unsigned long, double)
const Dimension& Dimension::insert(size_t dp, double value)
{
	values.insert(value);
	dp_index.insert(pair<size_t, size_t>(dp, dps.size()));
	dps.push_back(DataPoint(dp, value));

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x1cf10
movq -0x68(%rbp), %rdi
movq %rax, -0x28(%rbp)
movb %dl, -0x20(%rbp)
movq %rdi, %rax
addq $0x30, %rax
movq %rax, -0x78(%rbp)
addq $0x60, %rdi
callq 0x1cf60
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x1cf80
movq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x14690
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x50(%rbp)
movb %dl, -0x48(%rbp)
addq $0x60, %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
leaq -0x60(%rbp), %rdi
callq 0x1cfe0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1cfb0
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: CK7[P]abawaca/src/Dimension.cpp
// Function: Dimension::get_value(unsigned long) const
double Dimension::get_value(size_t dp) const
{
	map<size_t, size_t>::const_iterator mit = dp_index.find(dp);
	if(mit == dp_index.end())
		return -1;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x30, %rdi
leaq -0x18(%rbp), %rsi
callq 0x1d010
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x30, %rdi
callq 0x1d070
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1d040
testb $0x1, %al
jne 0x1cb8d
jmp 0x1cb9c
movsd 0x1849b(%rip), %xmm0    # 0x35030
movsd %xmm0, -0x8(%rbp)
jmp 0x1cbc8
movq -0x30(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1d0c0
movq -0x38(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x1d0a0
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/ClusterData.cpp
// Function: ClusterData::get_dimension(unsigned long) const
const Dimension& ClusterData::get_dimension(size_t index) const
{
	if((index == 0) || (index >= dimensions.size())) {
		char s[2048];
		sprintf(s, "%s (%d): illegal dimension index %lu, should be in the range of [0, %lu]", __FILE__, __LINE__, index, dimensions.size()-1);
		throw invalid_argument(s);
	}

	return *(dimensions[index]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x850, %rsp            # imm = 0x850
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x828(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1ea1f
movq -0x828(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x830(%rbp)
callq 0x20c70
movq %rax, %rcx
movq -0x830(%rbp), %rax
cmpq %rcx, %rax
jb 0x1eaca
movq -0x828(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x848(%rbp)
callq 0x20c70
movq -0x848(%rbp), %r8
movq %rax, %r9
decq %r9
leaq 0x175f5(%rip), %rsi     # 0x3603f
leaq 0x17345(%rip), %rdx     # 0x35d96
xorl %eax, %eax
leaq -0x810(%rbp), %rdi
movq %rdi, -0x840(%rbp)
movl $0xbf, %ecx
callq 0x50b0
movl $0x10, %edi
callq 0x51e0
movq -0x840(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x838(%rbp)
callq 0x57f0
jmp 0x1ea90
movq -0x838(%rbp), %rdi
movq 0x2e52a(%rip), %rsi     # 0x4cfc8
movq 0x2e513(%rip), %rdx     # 0x4cfb8
callq 0x5700
movq -0x838(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x818(%rbp)
movl %eax, -0x81c(%rbp)
callq 0x52d0
jmp 0x1eae6
movq -0x828(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x20c90
movq (%rax), %rax
addq $0x850, %rsp            # imm = 0x850
popq %rbp
retq
movq -0x818(%rbp), %rdi
callq 0x5750
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/ClusterData.cpp
// Function: ClusterData::get_dimension(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
const Dimension& ClusterData::get_dimension(string dname) const
{
	auto it=dimensions.begin();
	for(++it; it!=dimensions.end() && ((*it)->get_dimension_name() != dname); it++)
		;

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

	return **it;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8a0, %rsp            # imm = 0x8A0
movq %rsi, -0x880(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x878(%rbp)
callq 0x20aa0
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x20ad0
movq -0x878(%rbp), %rdi
callq 0x20b30
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x20af0
movb %al, %cl
movb $0x0, -0x41(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x881(%rbp)
jne 0x20449
jmp 0x20478
leaq -0x18(%rbp), %rdi
callq 0x20b90
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x20bb0
movq -0x880(%rbp), %rsi
movb $0x1, -0x41(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x20b60
movb %al, -0x881(%rbp)
movb -0x881(%rbp), %al
movb %al, -0x882(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x2048c
jmp 0x20495
leaq -0x40(%rbp), %rdi
callq 0x5250
movb -0x882(%rbp), %al
testb $0x1, %al
jne 0x204a1
jmp 0x204b7
jmp 0x204a3
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x20bf0
movq %rax, -0x50(%rbp)
jmp 0x20417
movq -0x878(%rbp), %rdi
callq 0x20b30
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x20c30
testb $0x1, %al
jne 0x204dd
jmp 0x20573
movq -0x880(%rbp), %rdi
callq 0x5190
movq %rax, %r8
leaq 0x15b27(%rip), %rsi     # 0x3601a
leaq 0x1589c(%rip), %rdx     # 0x35d96
xorl %eax, %eax
leaq -0x860(%rbp), %rdi
movq %rdi, -0x898(%rbp)
movl $0xb3, %ecx
callq 0x50b0
movl $0x10, %edi
callq 0x51e0
movq -0x898(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x890(%rbp)
callq 0x57f0
jmp 0x20539
movq -0x890(%rbp), %rdi
movq 0x2ca81(%rip), %rsi     # 0x4cfc8
movq 0x2ca6a(%rip), %rdx     # 0x4cfb8
callq 0x5700
movq -0x890(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x868(%rbp)
movl %eax, -0x86c(%rbp)
callq 0x52d0
jmp 0x20588
leaq -0x18(%rbp), %rdi
callq 0x20b90
movq (%rax), %rax
addq $0x8a0, %rsp            # imm = 0x8A0
popq %rbp
retq
movq -0x868(%rbp), %rdi
callq 0x5750
nopw %cs:(%rax,%rax)
nop
// File: CK7[P]abawaca/src/ClusterWriter.cpp
// Function: ClusterWriter::write(ClusterData const&, std::set<unsigned long, std::less<unsigned long>, std::allocator<unsigned long>> const&, std::unordered_set<unsigned long, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<unsigned long>> const&, char const*) const
void ClusterWriter::write(const ClusterData& clustering_db, const set<size_t>& scafs, const unordered_set<size_t>& raw_dps, const char* cluster_name) const
{
	char	scaf_stats_file[1024] = {};
	char	scaf_file[1024] = {};

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x850, %rsp            # imm = 0x850
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, -0x838(%rbp)
leaq -0x430(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x5210
leaq -0x830(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x5210
movq -0x838(%rbp), %rdi
leaq -0x430(%rbp), %rax
movq %rax, -0x848(%rbp)
addq $0x8, %rdi
callq 0x5190
movq -0x848(%rbp), %rdi
movq %rax, %rdx
movq -0x28(%rbp), %rcx
leaq 0x128f5(%rip), %rsi     # 0x36088
movb $0x0, %al
callq 0x50b0
movq -0x838(%rbp), %rdi
leaq -0x830(%rbp), %rax
movq %rax, -0x840(%rbp)
addq $0x8, %rdi
callq 0x5190
movq -0x840(%rbp), %rdi
movq %rax, %rdx
movq -0x28(%rbp), %rcx
leaq 0x128d0(%rip), %rsi     # 0x3609d
movb $0x0, %al
callq 0x50b0
movq -0x838(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq (%rdi), %rax
callq *(%rax)
movq -0x838(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x430(%rbp), %r8
callq 0x23830
movq -0x838(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x830(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x23fd0
addq $0x850, %rsp            # imm = 0x850
popq %rbp
retq
nopl (%rax,%rax)
// File: CK7[P]abawaca/src/ClusterWriter.cpp
// Function: ClusterWriter::write_scaffolds(std::set<unsigned long, std::less<unsigned long>, std::allocator<unsigned long>> const&, char const*, char const*) const
void ClusterWriter::write_scaffolds(const set<size_t>& scafs, const char* out_file, const char* cluster_name) const
{
        FILE* fp = fopen(out_file, "w");
	if(fp == NULL) {
		cerr << "Fatal error, " << __FILE__ << " (" << __LINE__ << "): could write to file " << out_file << endl << endl;
		exit(-1);
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x120b6(%rip), %rsi     # 0x360b4
callq 0x54b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x24093
movq 0x28fcf(%rip), %rdi     # 0x4cfe8
leaq 0x12096(%rip), %rsi     # 0x360b6
callq 0x53f0
movq %rax, %rdi
leaq 0x12095(%rip), %rsi     # 0x360c4
callq 0x53f0
movq %rax, %rdi
leaq 0x11ee7(%rip), %rsi     # 0x35f25
callq 0x53f0
movq %rax, %rdi
movl $0x1a, %esi
callq 0x5710
movq %rax, %rdi
leaq 0x12080(%rip), %rsi     # 0x360da
callq 0x53f0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x53f0
movq %rax, %rdi
movq 0x28f1b(%rip), %rsi     # 0x4cf90
callq 0x5440
movq %rax, %rdi
movq 0x28f0c(%rip), %rsi     # 0x4cf90
callq 0x5440
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x54f0
movq -0x10(%rbp), %rdi
callq 0xa8e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa910
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xa3a0
testb $0x1, %al
jne 0x240c0
jmp 0x2412c
movq -0x68(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq 0x28(%rax), %rax
movq %rax, -0x78(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa400
movq -0x78(%rbp), %rsi
movq (%rax), %rdx
leaq -0x58(%rbp), %rdi
callq 0x13c70
leaq -0x58(%rbp), %rdi
callq 0x5190
movq -0x70(%rbp), %rdi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
leaq 0x11fea(%rip), %rsi     # 0x360f2
movb $0x0, %al
callq 0x5610
leaq -0x58(%rbp), %rdi
callq 0x5250
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xa420
movq %rax, -0x60(%rbp)
jmp 0x240a0
movq -0x28(%rbp), %rdi
callq 0x5400
addq $0x80, %rsp
popq %rbp
retq
nop
// File: CK7[P]abawaca/src/Cluster.cpp
// Function: Cluster::operator+=(unsigned long)
const Cluster& Cluster::operator += (size_t dp)
{
	if(dps.find(dp) != dps.end())
		return *this;
	dps.insert(dp);

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

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
addq $0x38, %rdi
leaq -0x18(%rbp), %rsi
callq 0x24ba0
movq -0x80(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x38, %rdi
callq 0x24bd0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa1d0
testb $0x1, %al
jne 0x24850
jmp 0x2485d
movq -0x80(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x24922
movq -0x80(%rbp), %rdi
addq $0x38, %rdi
leaq -0x18(%rbp), %rsi
callq 0x209e0
movq %rax, %rcx
movq -0x80(%rbp), %rax
movq %rcx, -0x38(%rbp)
movb %dl, -0x30(%rbp)
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x13a40
movq -0x80(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x8, %rdi
leaq -0x40(%rbp), %rsi
callq 0xa6e0
movq -0x80(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0x8, %rdi
callq 0xa710
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa6b0
testb $0x1, %al
jne 0x248c5
jmp 0x24905
movq -0x80(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x88(%rbp)
movl $0x1, -0x64(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x64(%rbp), %rdx
callq 0x245f0
movq -0x88(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x14690
movq %rax, -0x78(%rbp)
movb %dl, -0x70(%rbp)
jmp 0x2491a
leaq -0x48(%rbp), %rdi
callq 0x24c00
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x80(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nop
// File: CK7[P]abawaca/src/Cluster.cpp
// Function: Cluster::ndps(unsigned long) const
size_t Cluster::ndps(size_t scaf) const
{
	map<size_t, size_t>::const_iterator mit = scaf2ndps.find(scaf);

	if(mit==scaf2ndps.end())
		return 0;

	return mit->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
leaq -0x18(%rbp), %rsi
callq 0x1d010
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x1d070
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1d040
testb $0x1, %al
jne 0x2497d
jmp 0x24987
movq $0x0, -0x8(%rbp)
jmp 0x24998
leaq -0x20(%rbp), %rdi
callq 0x1d0c0
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/Cluster.cpp
// Function: Cluster::operator-=(unsigned long)
const Cluster& Cluster::operator -= (size_t dp)
{
	if(dps.find(dp) == dps.end())
		return *this;
	dps.erase(dp);

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

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x38, %rdi
leaq -0x18(%rbp), %rsi
callq 0x24ba0
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x38, %rdi
callq 0x24bd0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x24c20
testb $0x1, %al
jne 0x249fd
jmp 0x24a0a
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x24a90
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
leaq -0x18(%rbp), %rsi
callq 0x24c50
movq -0x50(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x13a40
movq -0x50(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0xa6e0
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x24c00
cmpq $0x1, 0x8(%rax)
jne 0x24a73
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x24c80
movq %rax, -0x48(%rbp)
jmp 0x24a88
leaq -0x38(%rbp), %rdi
callq 0x24c00
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: CK7[P]abawaca/src/misc.cpp
// Function: get_time()
const char* get_time()
{
	static int epoch = time(NULL);
	static char str[128];
	int t = time(NULL) - epoch;

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

	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpb $0x0, 0x28349(%rip)     # 0x4d468
jne 0x2514d
leaq 0x28340(%rip), %rdi     # 0x4d468
callq 0x5770
cmpl $0x0, %eax
je 0x2514d
xorl %eax, %eax
movl %eax, %edi
callq 0x5390
movl %eax, 0x28323(%rip)     # 0x4d464
leaq 0x28320(%rip), %rdi     # 0x4d468
callq 0x5270
xorl %eax, %eax
movl %eax, %edi
callq 0x5390
movslq 0x28307(%rip), %rcx     # 0x4d464
subq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl $0xe10, %ecx            # imm = 0xE10
cltd
idivl %ecx
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl $0xe10, %ecx            # imm = 0xE10
cltd
idivl %ecx
movl %edx, %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %eax, %r8d
movl -0x4(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl -0x8(%rbp), %edx
leaq 0x282d0(%rip), %rdi     # 0x4d470
leaq 0x11001(%rip), %rsi     # 0x361a8
movl $0x3a, %r9d
movl %r9d, %ecx
movl %eax, (%rsp)
movb $0x0, %al
callq 0x50b0
leaq 0x282af(%rip), %rax     # 0x4d470
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: CK7[P]abawaca/src/misc.cpp
// Function: MonteCarlo::Random()
size_t Random()
{
        static tinymt32_t* tinymt = NULL;                               // Random Number Geberator
        if(tinymt == NULL) {
                tinymt = new tinymt32_t();
                tinymt->mat1 = strtoul("8f7011ee", NULL, 16);
                tinymt->mat2 = strtoul("fc78ff1f", NULL, 16);
                tinymt->tmat = strtoul("3793fdff", NULL, 16);
                srand(time(NULL));
                tinymt32_init(tinymt, rand());
        }
        return(tinymt32_generate_uint32(tinymt));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x28310(%rip)     # 0x4d4f0
jne 0x2529c
movl $0x1c, %edi
callq 0x5410
movq %rax, %rdi
movq %rdi, -0x10(%rbp)
xorl %esi, %esi
movl $0x1c, %edx
callq 0x5210
movq -0x10(%rbp), %rax
movq %rax, 0x282e2(%rip)     # 0x4d4f0
leaq 0x10fa4(%rip), %rdi     # 0x361b9
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x5150
movl %eax, %ecx
movq 0x282c4(%rip), %rax     # 0x4d4f0
movl %ecx, 0x10(%rax)
leaq 0x10f8c(%rip), %rdi     # 0x361c2
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x5150
movl %eax, %ecx
movq 0x282a3(%rip), %rax     # 0x4d4f0
movl %ecx, 0x14(%rax)
leaq 0x10f74(%rip), %rdi     # 0x361cb
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x5150
movl %eax, %ecx
movq 0x28282(%rip), %rax     # 0x4d4f0
movl %ecx, 0x18(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x5390
movl %eax, %edi
callq 0x53d0
movq 0x28268(%rip), %rax     # 0x4d4f0
movq %rax, -0x8(%rbp)
callq 0x5110
movq -0x8(%rbp), %rdi
movl %eax, %esi
callq 0x11d50
movq 0x2824d(%rip), %rdi     # 0x4d4f0
callq 0x252b0
movl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: CK7[P]abawaca/src/misc.cpp
// Function: MonteCarlo::shuffle(std::vector<unsigned long, std::allocator<unsigned long>>&)
void shuffle(vector<size_t>& values)
{
	for(size_t i=values.size()-1; i>0; i--) {
		size_t j = Random()%i;
		size_t t = values[i];
		values[i] = values[j];
		values[j] = t;
	}  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cce0
subq $0x1, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0x2537b
callq 0x251d0
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x257a0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x257a0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x257a0
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x257a0
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x252fd
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/misc.cpp
// Function: MonteCarlo::shuffle(unsigned long*, unsigned long)
void shuffle(size_t* values, size_t n)
{
	while(--n > 0) {
		size_t j = Random()%n;
		size_t t = values[n];
		values[n] = values[j];
		values[j] = t;
	}  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jbe 0x253fd
callq 0x251d0
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x253a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/misc.cpp
// Function: MonteCarlo::Distribution::operator+=(unsigned long)
const Distribution& Distribution::operator += (size_t val)
{
	// Need to enlarge values
	if(n+1>values_size) {
cerr << "Reallocating" << endl;
		values = (size_t*)realloc(values, 2*values_size*sizeof(size_t));
		values_size *= 2;
cerr << "Done reallocating" << endl;
	}
	
	// values is sorted and we want to keep it that way
	size_t* p;
	for(p=values+n-1; (p >= values) && (val < *p); p--)
		*(p+1) = *p;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rcx), %rax
addq $0x1, %rax
cmpq 0x10(%rcx), %rax
jbe 0x254a6
movq 0x27bab(%rip), %rdi     # 0x4cfe8
leaq 0x10d90(%rip), %rsi     # 0x361d4
callq 0x53f0
movq %rax, %rdi
movq 0x27b3d(%rip), %rsi     # 0x4cf90
callq 0x5440
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq 0x10(%rax), %rsi
shlq %rsi
shlq $0x3, %rsi
callq 0x56d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq 0x10(%rax), %rcx
shlq %rcx
movq %rcx, 0x10(%rax)
movq 0x27b5d(%rip), %rdi     # 0x4cfe8
leaq 0x10d4f(%rip), %rsi     # 0x361e1
callq 0x53f0
movq %rax, %rdi
movq 0x27aef(%rip), %rsi     # 0x4cf90
callq 0x5440
movq -0x20(%rbp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x21(%rbp)
jb 0x254e3
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
setb %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x254ec
jmp 0x25509
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x254c0
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq (%rcx), %rax
jne 0x25523
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x25531
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2553c
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/misc.cpp
// Function: MonteCarlo::Distribution::cdf(unsigned long) const
double Distribution::cdf(size_t val) const
{
	// Easy cases
	if(val < *values)
		return 0;
	else if(val >= values[n-1])
		return 1;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rcx), %rcx
cmpq (%rcx), %rax
jae 0x2558d
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2567e
movq -0x38(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
subq $0x1, %rdx
cmpq (%rcx,%rdx,8), %rax
jb 0x255b8
movsd 0x10bf2(%rip), %xmm0    # 0x361a0
movsd %xmm0, -0x8(%rbp)
jmp 0x2567e
jmp 0x255ba
movq -0x38(%rbp), %rax
movq $0x0, -0x20(%rbp)
movq 0x8(%rax), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x25632
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
addq -0x28(%rbp), %rcx
shrq %rcx
movl %ecx, -0x2c(%rbp)
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
ja 0x2560d
movl -0x2c(%rbp), %eax
addl $0x1, %eax
cltq
movq %rax, -0x20(%rbp)
jmp 0x25630
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jbe 0x2562e
movl -0x2c(%rbp), %eax
subl $0x1, %eax
cltq
movq %rax, -0x28(%rbp)
jmp 0x25630
jmp 0x255d2
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %xmm0
movaps 0x10b3e(%rip), %xmm3    # 0x36180
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x10b42(%rip), %xmm2    # 0x36190
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x8(%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
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/TinyMT-src-1.0.1/tinymt/tinymt32.h
// Function: tinymt32_temper(TINYMT32_T*)
inline static uint32_t tinymt32_temper(tinymt32_t * random) {
    uint32_t t0, t1;
    t0 = random->status[3];
#if defined(LINEARITY_CHECK)
    t1 = random->status[0]
	^ (random->status[2] >> TINYMT32_SH8);
#else
    t1 = random->status[0]
	+ (random->status[2] >> TINYMT32_SH8);
#endif
    t0 ^= t1;
    t0 ^= -((int32_t)(t1 & 1)) & random->tmat;
    return t0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
shrl $0x8, %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %ecx
andl $0x1, %ecx
xorl %eax, %eax
subl %ecx, %eax
movq -0x8(%rbp), %rcx
andl 0x18(%rcx), %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: CK7[P]abawaca/src/ClusterSeparatorBySensitivitySpecificity.cpp
// Function: ClusterSeparatorBySensitivitySpecificity::ClusterStats::add_dp(unsigned long)
const ClusterSeparator::ClusterStats& ClusterSeparatorBySensitivitySpecificity::ClusterStats::add_dp(size_t dp)
{
	size_t	scaf = scaf_db.dp2scaf(dp);

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

	cluster += dp;

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

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x13a40
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x13b50
cmpq $0x2, %rax
jae 0x274ed
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x27539
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rsi
movq 0x10(%rax), %rdi
callq 0x24800
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x26830
testb $0x1, %al
jne 0x27515
jmp 0x27524
movq -0x28(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
jmp 0x27531
movq -0x28(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/ClusterSeparatorBySensitivitySpecificity.cpp
// Function: ClusterSeparatorBySensitivitySpecificity::ClusterStats::remove_dp(unsigned long)
const ClusterSeparator::ClusterStats& ClusterSeparatorBySensitivitySpecificity::ClusterStats::remove_dp(size_t dp)
{
	size_t	scaf = scaf_db.dp2scaf(dp);

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

	cluster -= dp;

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

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x13a40
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x13b50
cmpq $0x2, %rax
jae 0x2759d
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x275e9
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rsi
movq 0x10(%rax), %rdi
callq 0x249b0
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x26830
testb $0x1, %al
jne 0x275c5
jmp 0x275d4
movq -0x28(%rbp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
jmp 0x275e1
movq -0x28(%rbp), %rax
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/ClusterSeparatorBySensitivitySpecificity.cpp
// Function: ClusterSeparatorBySensitivitySpecificity::ClusterStats::assign_scaf(unsigned long)
const ClusterSeparator::ClusterStats& ClusterSeparatorBySensitivitySpecificity::ClusterStats::assign_scaf(size_t scaf)
{
	size_t  scaf_total_ndps = scaf_db.ndps(scaf);

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

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

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

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x13b50
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x26830
testb $0x1, %al
jne 0x27648
cmpq $0x2, -0x20(%rbp)
jae 0x27655
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x276f5
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x28380
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rdi
callq 0x26800
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1d040
testb $0x1, %al
jne 0x27691
jmp 0x27699
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x276aa
leaq -0x28(%rbp), %rdi
callq 0x1d0c0
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xac90
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rdx
movslq 0x20(%rax), %rcx
subq %rdx, %rcx
movl %ecx, 0x20(%rax)
movq -0x30(%rbp), %rdx
movslq 0x18(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x18(%rax)
movq -0x20(%rbp), %rdx
movslq 0x1c(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x1c(%rax)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: CK7[P]abawaca/src/ClusterSeparatorBySensitivitySpecificity.cpp
// Function: ClusterSeparatorBySensitivitySpecificity::ClusterStats::unassign_scaf(unsigned long)
const ClusterSeparator::ClusterStats& ClusterSeparatorBySensitivitySpecificity::ClusterStats::unassign_scaf(size_t scaf)
{
	size_t  scaf_total_ndps = scaf_db.ndps(scaf);
	if(!cluster.assigned(scaf) || (scaf_total_ndps < 2))
		return *this;

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

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

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x13b50
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x26830
testb $0x1, %al
jne 0x27743
jmp 0x2774a
cmpq $0x2, -0x20(%rbp)
jae 0x27757
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x277f7
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x28380
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rdi
callq 0x26800
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1d040
testb $0x1, %al
jne 0x27793
jmp 0x2779b
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x277ac
leaq -0x28(%rbp), %rdi
callq 0x1d0c0
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x283b0
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rdx
movslq 0x20(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x20(%rax)
movq -0x30(%rbp), %rdx
movslq 0x18(%rax), %rcx
subq %rdx, %rcx
movl %ecx, 0x18(%rax)
movq -0x20(%rbp), %rdx
movslq 0x1c(%rax), %rcx
subq %rdx, %rcx
movl %ecx, 0x1c(%rax)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CK7[P]abawaca/src/ClusterSeparatorBySensitivitySpecificity.cpp
// Function: operator<<(std::ostream&, ClusterSeparatorBySensitivitySpecificity&)
ostream& operator << (ostream& os, ClusterSeparatorBySensitivitySpecificity& cs)
{
	os << " Best separation:\t" << "dimension " << cs.get_separating_dimension() << " ("
		<< cs.clustering_db.get_dimension(cs.best_separation->get_dimension()).get_dimension_name() << ")\t"
		<< "Value " << cs.best_separation->get_value() << "\t"
		<< "Specificity " << static_cast<ClusterSeparatorBySensitivitySpecificity::ClusteringResult*>(cs.best_separation)->get_specificity() << "\t"
		<< "Sensitivity " << static_cast<ClusterSeparatorBySensitivitySpecificity::ClusteringResult*>(cs.best_separation)->get_sensitivity();

	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xea2a(%rip), %rsi      # 0x36258
callq 0x53f0
movq %rax, %rdi
leaq 0xe540(%rip), %rsi      # 0x35d7d
callq 0x53f0
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26600
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x50f0
movq %rax, %rdi
leaq 0xe6c0(%rip), %rsi      # 0x35f25
callq 0x53f0
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, -0x60(%rbp)
movq 0xa8(%rax), %rdi
callq 0x268a0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x1e9d0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x20bb0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x5360
movq %rax, -0x48(%rbp)
jmp 0x278b5
movq -0x48(%rbp), %rdi
leaq 0xe9ab(%rip), %rsi      # 0x3626b
callq 0x53f0
movq %rax, -0x70(%rbp)
jmp 0x278cb
movq -0x70(%rbp), %rdi
leaq 0xe998(%rip), %rsi      # 0x3626e
callq 0x53f0
movq %rax, -0x78(%rbp)
jmp 0x278e1
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x268c0
movsd %xmm0, -0x80(%rbp)
jmp 0x278f8
movsd -0x80(%rbp), %xmm0
movq -0x78(%rbp), %rdi
callq 0x5800
movq %rax, -0x88(%rbp)
jmp 0x2790f
movq -0x88(%rbp), %rdi
leaq 0xe94f(%rip), %rsi      # 0x3626c
callq 0x53f0
movq %rax, -0x90(%rbp)
jmp 0x2792b
movq -0x90(%rbp), %rdi
leaq 0xe93c(%rip), %rsi      # 0x36275
callq 0x53f0
movq %rax, -0x98(%rbp)
jmp 0x27947
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x283e0
movsd %xmm0, -0xa0(%rbp)
jmp 0x27961
movsd -0xa0(%rbp), %xmm0
movq -0x98(%rbp), %rdi
callq 0x5800
movq %rax, -0xa8(%rbp)
jmp 0x2797e
movq -0xa8(%rbp), %rdi
leaq 0xe8e0(%rip), %rsi      # 0x3626c
callq 0x53f0
movq %rax, -0xb0(%rbp)
jmp 0x2799a
movq -0xb0(%rbp), %rdi
leaq 0xe8da(%rip), %rsi      # 0x36282
callq 0x53f0
movq %rax, -0xb8(%rbp)
jmp 0x279b6
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x28400
movsd %xmm0, -0xc0(%rbp)
jmp 0x279d0
movsd -0xc0(%rbp), %xmm0
movq -0xb8(%rbp), %rdi
callq 0x5800
jmp 0x279e6
leaq -0x30(%rbp), %rdi
callq 0x5250
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5250
movq -0x38(%rbp), %rdi
callq 0x5750
nopw (%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xb5da(%rip), %rsi      # 0x36258
callq 0x53f0
movq %rax, %rdi
leaq 0xb0f0(%rip), %rsi      # 0x35d7d
callq 0x53f0
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26600
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x50f0
movq %rax, %rdi
leaq 0xb270(%rip), %rsi      # 0x35f25
callq 0x53f0
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq 0x18(%rdi), %rax
movq %rax, -0x60(%rbp)
callq 0x26600
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x1e9d0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x20bb0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x5360
movq %rax, -0x48(%rbp)
jmp 0x2acfe
movq -0x48(%rbp), %rdi
leaq 0xb562(%rip), %rsi      # 0x3626b
callq 0x53f0
movq %rax, -0x70(%rbp)
jmp 0x2ad14
movq -0x70(%rbp), %rdi
leaq 0xb54f(%rip), %rsi      # 0x3626e
callq 0x53f0
movq %rax, -0x78(%rbp)
jmp 0x2ad2a
movq -0x10(%rbp), %rdi
callq 0x26630
movsd %xmm0, -0x80(%rbp)
jmp 0x2ad3a
movsd -0x80(%rbp), %xmm0
movq -0x78(%rbp), %rdi
callq 0x5800
movq %rax, -0x88(%rbp)
jmp 0x2ad51
movq -0x88(%rbp), %rdi
leaq 0xb50d(%rip), %rsi      # 0x3626c
callq 0x53f0
movq %rax, -0x90(%rbp)
jmp 0x2ad6d
movq -0x90(%rbp), %rdi
leaq 0xb629(%rip), %rsi      # 0x363a4
callq 0x53f0
movq %rax, -0x98(%rbp)
jmp 0x2ad89
movq -0x10(%rbp), %rdi
callq 0x2b840
movsd %xmm0, -0xa0(%rbp)
jmp 0x2ad9c
movsd -0xa0(%rbp), %xmm0
movq -0x98(%rbp), %rdi
callq 0x5800
movq %rax, -0xa8(%rbp)
jmp 0x2adb9
movq -0xa8(%rbp), %rdi
movq 0x221c9(%rip), %rsi     # 0x4cf90
callq 0x5440
jmp 0x2adce
leaq -0x30(%rbp), %rdi
callq 0x5250
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5250
movq -0x38(%rbp), %rdi
callq 0x5750
nopw %cs:(%rax,%rax)