LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/SeqIOWrite.h
// Function: Bio::SeqIOWrite<Bio::Sequence<Bio::DNAString>>::restart()
void SeqIOWrite<S>::restart()
{
	SeqIO::restart();

	m_fp.close();
	m_fp.open(this->file_name().c_str());

	if(m_fp.fail())
		throw Bio::Bad_file(this->file_name(), "Failed to re-open file", __PRETTY_FUNCTION__);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
andq $0x0, 0x30(%rdi)
movq $0x1, 0x28(%rdi)
leaq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0x4510
addq $0x8, %r14
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x44d0
movq (%r15), %rsi
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x4050
leaq -0x38(%rbp), %rdi
callq 0x4180
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0x7aee
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x41b0
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
movq %r14, %rsi
callq 0x44d0
leaq 0xda51(%rip), %rsi      # 0x1555d
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x4140
movb $0x1, %r15b
leaq 0xda51(%rip), %rcx      # 0x15574
leaq -0x78(%rbp), %rsi
leaq -0x58(%rbp), %rdx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0x7c52
xorl %r15d, %r15d
leaq 0x16e50(%rip), %rsi     # 0x1e990
leaq 0x589(%rip), %rdx       # 0x80d0
movq %rbx, %rdi
callq 0x4620
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x4180
jmp 0x7b63
movq %rax, %r14
movb $0x1, %r15b
leaq -0x78(%rbp), %rdi
callq 0x4180
testb %r15b, %r15b
jne 0x7b76
jmp 0x7b8c
movq %rax, %r14
movq %rbx, %rdi
callq 0x4260
jmp 0x7b8c
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x4180
movq %r14, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/TinyMT-src-1.0.1/tinymt/tinymt32.c
// Function: tinymt32_init(TINYMT32_T*, unsigned int)
void tinymt32_init(tinymt32_t * random, uint32_t seed) {
    random->status[0] = seed;
    random->status[1] = random->mat1;
    random->status[2] = random->mat2;
    random->status[3] = random->tmat;
    for (int i = 1; i < MIN_LOOP; i++) {
	random->status[i & 3] ^= i + UINT32_C(1812433253)
	    * (random->status[(i - 1) & 3]
	       ^ (random->status[(i - 1) & 3] >> 30));
    }
    period_certification(random);
    for (int i = 0; i < PRE_LOOP; i++) {
	tinymt32_next_state(random);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, (%rdi)
movl 0x10(%rdi), %eax
movl %eax, 0x4(%rdi)
movq 0x14(%rdi), %rax
movq %rax, 0x8(%rdi)
pushq $0x4
popq %rax
cmpl $0xb, %eax
je 0x8cb9
leal -0x3(%rax), %ecx
movl %eax, %edx
andl $0x3, %edx
movl (%rbx,%rdx,4), %edx
movl %edx, %esi
shrl $0x1e, %esi
xorl %edx, %esi
imull $0x6c078965, %esi, %edx # imm = 0x6C078965
addl %eax, %edx
addl $-0x3, %edx
andl $0x3, %ecx
xorl %edx, (%rbx,%rcx,4)
incl %eax
jmp 0x8c8d
movq %rbx, %rdi
callq 0x8cda
pushq $0x8
popq %r14
subl $0x1, %r14d
jb 0x8cd5
movq %rbx, %rdi
callq 0x8d05
jmp 0x8cc5
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
testl $0x7fffffff, (%rdi)     # imm = 0x7FFFFFFF
je 0x8ce3
retq
cmpl $0x0, 0x4(%rdi)
jne 0x8ce2
cmpl $0x0, 0x8(%rdi)
jne 0x8ce2
cmpl $0x0, 0xc(%rdi)
jne 0x8ce2
pushq %rbp
movq %rsp, %rbp
movaps 0xca40(%rip), %xmm0     # 0x15740
movups %xmm0, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl 0xc(%rdi), %ecx
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
andl (%rdi), %edx
movl 0x4(%rdi), %esi
movl 0x8(%rdi), %eax
movl %esi, (%rdi)
xorl %eax, %esi
xorl %edx, %esi
leal (%rsi,%rsi), %edx
xorl %esi, %edx
movl %ecx, %esi
shrl %esi
xorl %ecx, %esi
xorl %edx, %esi
movl %esi, %ecx
movl %esi, 0xc(%rdi)
andl $0x1, %esi
negl %esi
movl 0x10(%rdi), %r8d
andl %esi, %r8d
xorl %eax, %r8d
movl %r8d, 0x4(%rdi)
andl 0x14(%rdi), %esi
shll $0xa, %ecx
xorl %edx, %ecx
xorl %esi, %ecx
movl %ecx, 0x8(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rsi, %r8
testq %rsi, %rsi
je 0x9b8b
movq 0x60(%rdi), %rcx
movq 0x68(%rdi), %rax
subq %rcx, %rax
pushq $0x30
popq %rsi
cqto
idivq %rsi
cmpq %r8, %rax
jbe 0x9b8b
imulq $0x30, %r8, %rax
movq 0x10(%rcx,%rax), %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xbdf0(%rip), %rsi      # 0x15982
leaq 0xbbc7(%rip), %rdx      # 0x15760
leaq -0x810(%rbp), %r14
pushq $0x7f
popq %rcx
movq %r14, %rdi
xorl %eax, %eax
callq 0x4080
pushq $0x10
popq %rdi
callq 0x41b0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x46e0
movq 0x153fe(%rip), %rsi     # 0x1efc8
movq 0x153e7(%rip), %rdx     # 0x1efb8
movq %rbx, %rdi
callq 0x4620
movq %rax, %r14
movq %rbx, %rdi
callq 0x4260
movq %r14, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rsi, %r8
testq %rsi, %rsi
je 0x9c32
movq 0x78(%rdi), %rcx
movq 0x80(%rdi), %rax
subq %rcx, %rax
pushq $0x48
popq %rsi
cqto
idivq %rsi
cmpq %r8, %rax
jbe 0x9c32
imulq $0x48, %r8, %rax
movq 0x30(%rcx,%rax), %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xbd61(%rip), %rsi      # 0x1599a
leaq 0xbb20(%rip), %rdx      # 0x15760
leaq -0x810(%rbp), %r14
movq %r14, %rdi
movl $0x8a, %ecx
xorl %eax, %eax
callq 0x4080
pushq $0x10
popq %rdi
callq 0x41b0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x46e0
movq 0x15355(%rip), %rsi     # 0x1efc8
movq 0x1533e(%rip), %rdx     # 0x1efb8
movq %rbx, %rdi
callq 0x4620
movq %rax, %r14
movq %rbx, %rdi
callq 0x4260
movq %r14, %rdi
callq 0x4660
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rdx, %r8
testq %rdx, %rdx
je 0x9ceb
movq 0x78(%rsi), %rcx
movq 0x80(%rsi), %rax
subq %rcx, %rax
pushq $0x48
popq %rsi
cqto
idivq %rsi
cmpq %r8, %rax
jbe 0x9ceb
movq %rdi, %rbx
imulq $0x48, %r8, %rax
movq 0x38(%rcx,%rax), %rsi
addq $0x8, %rsi
callq 0x44d0
movq %rbx, %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xbca8(%rip), %rsi      # 0x1599a
leaq 0xba67(%rip), %rdx      # 0x15760
leaq -0x810(%rbp), %r14
movq %r14, %rdi
movl $0x95, %ecx
xorl %eax, %eax
callq 0x4080
pushq $0x10
popq %rdi
callq 0x41b0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x46e0
movq 0x1529c(%rip), %rsi     # 0x1efc8
movq 0x15285(%rip), %rdx     # 0x1efb8
movq %rbx, %rdi
callq 0x4620
movq %rax, %r14
movq %rbx, %rdi
callq 0x4260
movq %r14, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
andq $0x0, 0x30(%rdi)
movq $0x1, 0x28(%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0xaadd
callq 0x4350
leaq 0x8(%rbx), %r14
leaq -0x80(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x44d0
movq (%r15), %rdi
leaq 0xa637(%rip), %rsi      # 0x15131
callq 0x4400
movq %rax, %r12
movq %rax, 0x38(%rbx)
movq %r15, %rdi
callq 0x4180
testq %r12, %r12
je 0xab20
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x41b0
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0x44d0
leaq 0xaa1f(%rip), %rsi      # 0x1555d
leaq -0x40(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0x4140
movb $0x1, %r15b
leaq 0xaecf(%rip), %rcx      # 0x15a24
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0x7c52
xorl %r15d, %r15d
leaq 0x13e1e(%rip), %rsi     # 0x1e990
leaq -0x2aa9(%rip), %rdx     # 0x80d0
movq %rbx, %rdi
callq 0x4620
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x4180
jmp 0xab95
movq %rax, %r14
movb $0x1, %r15b
leaq -0x60(%rbp), %rdi
callq 0x4180
testb %r15b, %r15b
jne 0xaba8
jmp 0xabb0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4260
movq %r14, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/SeqIORead.h
// Function: Bio::SeqIORead<Bio::Sequence<Bio::DNAString>>::getline(bool)
char* SeqIORead<S>::getline(bool skip_empty/*=false*/)
{
	if(feof(this->m_fp))
		return NULL;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x4570
testl %eax, %eax
je 0xbe77
xorl %r15d, %r15d
jmp 0xbf2c
movq 0x38(%rbx), %rdi
callq 0x4570
testl %eax, %eax
jne 0xbf1e
movq 0x40(%rbx), %rax
movb $0x0, (%rax)
movq 0x40(%rbx), %r15
movq 0x48(%rbx), %rsi
movq 0x38(%rbx), %rdx
movq %r15, %rdi
callq 0x45a0
testq %rax, %rax
je 0xbee3
movq %r15, %rdi
callq 0x4160
cmpb $0xa, -0x1(%r15,%rax)
je 0xbee3
movq 0x38(%rbx), %rdi
callq 0x4570
testl %eax, %eax
jne 0xbee3
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rsi
addq %rsi, %rsi
movq %rsi, 0x48(%rbx)
callq 0x45f0
movq %rax, %r15
movq %rax, 0x40(%rbx)
movq %rax, %rdi
callq 0x4160
addq %rax, %r15
movq 0x48(%rbx), %rsi
subq %rax, %rsi
jmp 0xbe86
movq 0x40(%rbx), %r15
movq %r15, %r12
movsbl (%r12), %edi
testl %edi, %edi
je 0xbf01
callq 0x4060
incq %r12
testl %eax, %eax
jne 0xbeea
jmp 0xbf0e
testb %r14b, %r14b
je 0xbf0e
movb $0x0, (%r15)
movq 0x40(%rbx), %r15
incq 0x28(%rbx)
cmpb $0x0, (%r15)
je 0xbe66
jmp 0xbf2c
movq 0x40(%rbx), %rax
xorl %r15d, %r15d
cmpb $0x0, (%rax)
cmovneq %rax, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/Dimension.cpp
// Function: Dimension::Dimension(std::vector<unsigned long, std::allocator<unsigned long>> const&, std::vector<double, std::allocator<double>> const&, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Dimension::Dimension(const vector<size_t>& dp_ids, const vector<double>& dp_values, size_t _dimension_index, 
	string _dimension_name) : dimension_index(_dimension_index), dimension_name(_dimension_name)
{
	if(dp_values.size() != dp_ids.size()) {
		cerr <<  __FILE__ << " (" << __LINE__ << "): fatal error, number of datapoints (" << dp_ids.size() << ") and values (" 
			<< dp_values.size() << ")for dimension " << dimension_name << " is different" << endl << endl;
		exit(-1);
	}

	vector<size_t>::const_iterator vits = dp_ids.begin();
	vector<double>::const_iterator vitd = dp_values.begin();
	while(vits != dp_ids.end())
		this->insert(*(vits++), *(vitd++));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq %rdx, %r15
andl $0x0, 0x38(%rdi)
movq %rsi, %r12
andq $0x0, 0x40(%rdi)
leaq 0x38(%rdi), %rax
movq %rax, 0x48(%rdi)
movq %rax, 0x50(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x68(%rdi)
movq %rcx, 0x78(%rdi)
addq $0x80, %rdi
movq %rdi, -0x30(%rbp)
movq %r8, %rsi
callq 0x44d0
movq (%r15), %r13
movq 0x8(%r15), %rax
subq %r13, %rax
movq (%r12), %r14
movq 0x8(%r12), %rcx
subq %r14, %rcx
cmpq %rcx, %rax
jne 0xc20c
cmpq 0x8(%r12), %r14
je 0xc1fd
movq (%r14), %rsi
addq $0x8, %r14
movsd (%r13), %xmm0
addq $0x8, %r13
movq %rbx, %rdi
callq 0xc2fa
jmp 0xc1db
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x12dd5(%rip), %rdi     # 0x1efe8
leaq 0x9aee(%rip), %rsi      # 0x15d08
callq 0x4340
leaq 0x9cd7(%rip), %rsi      # 0x15efd
movq %rax, %rdi
callq 0x4340
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x4630
leaq 0x9ada(%rip), %rsi      # 0x15d1a
movq %rax, %rdi
callq 0x4340
movq 0x8(%r12), %rsi
subq (%r12), %rsi
sarq $0x3, %rsi
movq %rax, %rdi
callq 0x4240
leaq 0x9add(%rip), %rsi      # 0x15d41
movq %rax, %rdi
callq 0x4340
movq 0x8(%r15), %rsi
subq (%r15), %rsi
sarq $0x3, %rsi
movq %rax, %rdi
callq 0x4240
leaq 0x9aca(%rip), %rsi      # 0x15d50
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x42d0
leaq 0x9abf(%rip), %rsi      # 0x15d60
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x41a0
movq %rax, %rdi
callq 0x41a0
pushq $-0x1
popq %rdi
callq 0x4430
jmp 0xc2c8
movq %rax, %r15
jmp 0xc2d4
movq %rax, %r15
movq -0x30(%rbp), %rdi
callq 0x4180
leaq 0x60(%rbx), %rdi
leaq 0x30(%rbx), %r14
callq 0xc57e
movq %r14, %rdi
callq 0x76fa
movq %rbx, %rdi
callq 0xc528
movq %r15, %rdi
callq 0x4660
nop
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/Dimension.cpp
// Function: Dimension::insert(unsigned long, double)
const Dimension& Dimension::insert(size_t dp, double value)
{
	values.insert(value);
	dp_index.insert(pair<size_t, size_t>(dp, dps.size()));
	dps.push_back(DataPoint(dp, value));

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x40(%rbp), %r15
movsd %xmm0, (%r15)
movq %r15, %rsi
callq 0xc592
leaq 0x30(%rbx), %rdi
leaq 0x60(%rbx), %r12
movq 0x68(%rbx), %rax
subq 0x60(%rbx), %rax
sarq $0x4, %rax
leaq -0x38(%rbp), %r13
movq %r14, (%r13)
movq %rax, 0x8(%r13)
movq %r13, %rsi
callq 0xb844
movsd (%r15), %xmm0
movq %r14, (%r13)
movsd %xmm0, 0x8(%r13)
leaq -0x38(%rbp), %rsi
movq %r12, %rdi
callq 0xc736
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x10(%rbp), %rax
movq %rsi, (%rax)
addq $0x30, %rdi
movq %rax, %rsi
callq 0xc8a8
leaq 0x38(%rbx), %rcx
cmpq %rcx, %rax
je 0xc48b
movq 0x28(%rax), %rax
movq 0x60(%rbx), %rcx
shlq $0x4, %rax
movsd 0x8(%rcx,%rax), %xmm0
jmp 0xc493
movsd 0x986d(%rip), %xmm0     # 0x15d00
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/ClusterData.cpp
// Function: ClusterData::get_dimension(unsigned long) const
const Dimension& ClusterData::get_dimension(size_t index) const
{
	if((index == 0) || (index >= dimensions.size())) {
		char s[2048];
		sprintf(s, "%s (%d): illegal dimension index %lu, should be in the range of [0, %lu]", __FILE__, __LINE__, index, dimensions.size()-1);
		throw invalid_argument(s);
	}

	return *(dimensions[index]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rsi, %r8
movq (%rdi), %rax
movq 0x8(%rdi), %r9
subq %rax, %r9
sarq $0x3, %r9
testq %rsi, %rsi
je 0xca0b
cmpq %r8, %r9
jbe 0xca0b
movq (%rax,%r8,8), %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %rbp
retq
decq %r9
leaq 0x9602(%rip), %rsi      # 0x16017
leaq 0x9352(%rip), %rdx      # 0x15d6e
leaq -0x810(%rbp), %r14
movq %r14, %rdi
movl $0xbf, %ecx
xorl %eax, %eax
callq 0x4080
pushq $0x10
popq %rdi
callq 0x41b0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x46e0
movq 0x12579(%rip), %rsi     # 0x1efc8
movq 0x12562(%rip), %rdx     # 0x1efb8
movq %rbx, %rdi
callq 0x4620
movq %rax, %r14
movq %rbx, %rdi
callq 0x4260
movq %r14, %rdi
callq 0x4660
nop
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/ClusterData.cpp
// Function: ClusterData::get_dimension(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
const Dimension& ClusterData::get_dimension(string dname) const
{
	auto it=dimensions.begin();
	for(++it; it!=dimensions.end() && ((*it)->get_dimension_name() != dname); it++)
		;

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

	return **it;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r13
addq $0x8, %r13
leaq -0x830(%rbp), %r15
cmpq 0x8(%r14), %r13
je 0xd727
movq (%r13), %rsi
subq $-0x80, %rsi
movq %r15, %rdi
callq 0x44d0
movq %r15, %rdi
movq %rbx, %rsi
callq 0xd7f8
movl %eax, %r12d
movq %r15, %rdi
callq 0x4180
addq $0x8, %r13
testb %r12b, %r12b
jne 0xd6d2
addq $-0x8, %r13
cmpq 0x8(%r14), %r13
je 0xd727
movq (%r13), %rax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %r8
leaq 0x88c1(%rip), %rsi      # 0x15ff2
leaq 0x8636(%rip), %rdx      # 0x15d6e
leaq -0x830(%rbp), %r14
movq %r14, %rdi
movl $0xb3, %ecx
xorl %eax, %eax
callq 0x4080
pushq $0x10
popq %rdi
callq 0x41b0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x46e0
movq 0x1185d(%rip), %rsi     # 0x1efc8
movq 0x11846(%rip), %rdx     # 0x1efb8
movq %rbx, %rdi
callq 0x4620
movq %rax, %r14
movq %rbx, %rdi
callq 0x4260
movq %r14, %rdi
callq 0x4660
nop
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/ClusterWriter.cpp
// Function: ClusterWriter::write(ClusterData const&, std::set<unsigned long, std::less<unsigned long>, std::allocator<unsigned long>> const&, std::unordered_set<unsigned long, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<unsigned long>> const&, char const*) const
void ClusterWriter::write(const ClusterData& clustering_db, const set<size_t>& scafs, const unordered_set<size_t>& raw_dps, const char* cluster_name) const
{
	char	scaf_stats_file[1024] = {};
	char	scaf_file[1024] = {};

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x30(%rbp)
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq 0x7b51(%rip), %rsi      # 0x1608c
movq %rdx, %rdi
callq 0x4400
testq %rax, %rax
je 0xe5b1
movq %rax, %r13
movq 0x18(%r14), %rbx
addq $0x8, %r14
leaq -0x50(%rbp), %r12
cmpq %r14, %rbx
je 0xe59a
movq 0x28(%r15), %rsi
movq 0x20(%rbx), %rdx
movq %r12, %rdi
callq 0x9c96
movq -0x50(%rbp), %rdx
movq %r13, %rdi
leaq 0x7b50(%rip), %rsi      # 0x160ca
movq -0x30(%rbp), %rcx
xorl %eax, %eax
callq 0x4520
movq %r12, %rdi
callq 0x4180
movq %rbx, %rdi
callq 0x43d0
movq %rax, %rbx
jmp 0xe557
movq %r13, %rdi
callq 0x4350
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10a30(%rip), %rdi     # 0x1efe8
leaq 0x7acf(%rip), %rsi      # 0x1608e
callq 0x4340
leaq 0x7ad1(%rip), %rsi      # 0x1609c
movq %rax, %rdi
callq 0x4340
leaq 0x7923(%rip), %rsi      # 0x15efd
movq %rax, %rdi
callq 0x4340
pushq $0x1a
popq %rsi
movq %rax, %rdi
callq 0x4630
leaq 0x7abe(%rip), %rsi      # 0x160b2
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
movq %r12, %rsi
callq 0x4340
movq %rax, %rdi
callq 0x41a0
movq %rax, %rdi
callq 0x41a0
pushq $-0x1
popq %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/Cluster.cpp
// Function: Cluster::operator+=(unsigned long)
const Cluster& Cluster::operator += (size_t dp)
{
	if(dps.find(dp) != dps.end())
		return *this;
	dps.insert(dp);

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

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %rax
movq %rsi, (%rax)
leaq 0x38(%rdi), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xeacc
testq %rax, %rax
jne 0xea06
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xde0e
movq (%rbx), %rdi
movq (%r15), %rsi
callq 0x9b48
leaq -0x20(%rbp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x8adc
leaq 0x10(%rbx), %rcx
cmpq %rcx, %rax
je 0xe9eb
incq 0x28(%rax)
jmp 0xea06
movq -0x20(%rbp), %rax
leaq -0x38(%rbp), %rsi
movq %rax, (%rsi)
movq $0x1, 0x8(%rsi)
movq %r14, %rdi
callq 0xb844
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x10(%rbp), %rax
movq %rsi, (%rax)
addq $0x8, %rdi
movq %rax, %rsi
callq 0xc8a8
addq $0x10, %rbx
cmpq %rbx, %rax
je 0xea3f
movq 0x28(%rax), %rax
jmp 0xea41
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/Cluster.cpp
// Function: Cluster::operator-=(unsigned long)
const Cluster& Cluster::operator -= (size_t dp)
{
	if(dps.find(dp) == dps.end())
		return *this;
	dps.erase(dp);

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

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x20(%rbp), %rax
movq %rsi, (%rax)
leaq 0x38(%rdi), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xeacc
testq %rax, %rax
je 0xeabe
leaq -0x20(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xeaee
movq (%rbx), %rdi
movq (%r15), %rsi
callq 0x9b48
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x8adc
movq 0x28(%rax), %rcx
cmpq $0x1, %rcx
jne 0xeab7
movq %r14, %rdi
movq %rax, %rsi
callq 0xebfe
jmp 0xeabe
decq %rcx
movq %rcx, 0x28(%rax)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/misc.cpp
// Function: get_time()
const char* get_time()
{
	static int epoch = time(NULL);
	static char str[128];
	int t = time(NULL) - epoch;

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

	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movb 0x1077c(%rip), %al      # 0x1f3e8
testb %al, %al
je 0xecd1
xorl %edi, %edi
callq 0x4300
movq %rax, %rsi
subl 0x10764(%rip), %esi     # 0x1f3e4
movl $0xe10, %ecx            # imm = 0xE10
movl %esi, %eax
cltd
idivl %ecx
movl %eax, %ecx
movl %edx, %eax
movw $0x3c, %di
cwtd
idivw %di
movswl %ax, %r8d
pushq $0x3c
popq %rdi
movl %esi, %eax
cltd
idivl %edi
movl %edx, (%rsp)
leaq 0x10743(%rip), %rbx     # 0x1f3f0
leaq 0x74cc(%rip), %rsi      # 0x16180
pushq $0x3a
popq %r9
movq %rbx, %rdi
movl %ecx, %edx
movl %r9d, %ecx
xorl %eax, %eax
callq 0x4080
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x10710(%rip), %rdi     # 0x1f3e8
callq 0x4670
testl %eax, %eax
je 0xec70
xorl %edi, %edi
callq 0x4300
movl %eax, 0x106f6(%rip)     # 0x1f3e4
leaq 0x106f3(%rip), %rdi     # 0x1f3e8
callq 0x4210
jmp 0xec70
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/misc.cpp
// Function: MonteCarlo::Random()
size_t Random()
{
        static tinymt32_t* tinymt = NULL;                               // Random Number Geberator
        if(tinymt == NULL) {
                tinymt = new tinymt32_t();
                tinymt->mat1 = strtoul("8f7011ee", NULL, 16);
                tinymt->mat2 = strtoul("fc78ff1f", NULL, 16);
                tinymt->tmat = strtoul("3793fdff", NULL, 16);
                srand(time(NULL));
                tinymt32_init(tinymt, rand());
        }
        return(tinymt32_generate_uint32(tinymt));
}

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
leaq 0x1(%rsi), %rax
cmpq 0x10(%rdi), %rax
jbe 0xeedc
movq 0x10155(%rip), %r15     # 0x1efe8
leaq 0x72f7(%rip), %rsi      # 0x16191
movq %r15, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x41a0
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
shlq $0x4, %rsi
callq 0x45f0
movq %rax, (%rbx)
shlq 0x10(%rbx)
leaq 0x72d6(%rip), %rsi      # 0x1619e
movq %r15, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x41a0
movq 0x8(%rbx), %rsi
movq (%rbx), %rcx
leaq (%rcx,%rsi,8), %rax
shlq $0x3, %rsi
pushq $0x8
popq %rdx
subq %rsi, %rdx
leaq -0x8(%rax), %rsi
cmpq %rcx, %rsi
jb 0xef0a
movq (%rsi), %rdi
cmpq %r14, %rdi
jbe 0xef0a
movq %rdi, (%rax)
addq $0x8, %rdx
movq %rsi, %rax
jmp 0xeeed
testq %rdx, %rdx
jne 0xef16
cmpq %r14, (%rcx)
cmovaeq %rcx, %rax
movq %r14, (%rax)
incq 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/misc.cpp
// Function: MonteCarlo::Distribution::cdf(unsigned long) const
double Distribution::cdf(size_t val) const
{
	// Easy cases
	if(val < *values)
		return 0;
	else if(val >= values[n-1])
		return 1;

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

// Assembly:
movq (%rdi), %rcx
xorpd %xmm0, %xmm0
cmpq %rsi, (%rcx)
ja 0xefec
movq 0x8(%rdi), %rax
cmpq %rsi, -0x8(%rcx,%rax,8)
jbe 0xef9c
pushq %rbp
movq %rsp, %rbp
leaq -0x1(%rax), %r9
xorl %r8d, %r8d
movabsq $0x100000000, %rdx      # imm = 0x100000000
movabsq $-0x100000000, %rdi     # imm = 0xFFFFFFFF00000000
cmpq %r8, %r9
jb 0xefa5
leaq (%r9,%r8), %r10
shlq $0x1f, %r10
movq %r10, %r11
sarq $0x1d, %r11
andq $-0x8, %r11
cmpq %rsi, (%rcx,%r11)
ja 0xef90
addq %rdx, %r10
sarq $0x20, %r10
movq %r10, %r8
jmp 0xef66
addq %rdi, %r10
sarq $0x20, %r10
movq %r10, %r9
jmp 0xef66
movsd 0x71b4(%rip), %xmm0     # 0x16158
retq
movq %r8, %xmm1
movq 0x71ae(%rip), %xmm2     # 0x16160
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x71b2(%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
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/ClusterSeparator.cpp
// Function: ClusterSeparator::reconstruct_best_clusters()
void ClusterSeparator::reconstruct_best_clusters()
{
	if(!this->is_best_separation_legal())
		return;

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xa8(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0xf13d
movq 0x18(%rbx), %rdi
movq 0xa8(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0xc9d2
movq %rax, %r14
movl $0xa0, %edi
callq 0x4360
movq %rax, %r15
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x6f66
movq %r15, 0x28(%rbx)
movl $0xa0, %edi
callq 0x4360
movq %rax, %r15
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x6f66
movq %r15, 0x30(%rbx)
movq %r14, %r12
movq 0x60(%r14), %r13
movq $0x0, -0x30(%rbp)
xorl %r14d, %r14d
cmpq 0x68(%r12), %r13
je 0xf127
movq 0x8(%rbx), %r15
movq (%r13), %rsi
movq %r15, %rdi
callq 0x9b48
movq %r15, %rdi
movq %rax, %rsi
callq 0x9bec
xorl %r15d, %r15d
cmpq $0x2, %rax
setae %r15b
movq 0xa8(%rbx), %rax
movsd 0x10(%rax), %xmm0
ucomisd 0x8(%r13), %xmm0
movq (%r13), %rsi
jae 0xf115
movq 0x30(%rbx), %rdi
callq 0xe984
addq %r15, -0x30(%rbp)
jmp 0xf121
movq 0x28(%rbx), %rdi
callq 0xe984
addq %r15, %r14
addq $0x10, %r13
jmp 0xf0c1
cmpq %r14, -0x30(%rbp)
jae 0xf13d
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/ClusterSeparatorBySensitivitySpecificity.cpp
// Function: ClusterSeparatorBySensitivitySpecificity::ClusterStats::add_dp(unsigned long)
const ClusterSeparator::ClusterStats& ClusterSeparatorBySensitivitySpecificity::ClusterStats::add_dp(size_t dp)
{
	size_t	scaf = scaf_db.dp2scaf(dp);

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

	cluster += dp;

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

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x9b48
movq %rax, %r15
movq 0x8(%rbx), %rdi
movq %rax, %rsi
callq 0x9bec
cmpq $0x2, %rax
jb 0xf78f
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xe984
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0xf638
xorb $0x1, %al
movzbl %al, %eax
incl 0x18(%rbx,%rax,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/ClusterSeparatorBySensitivitySpecificity.cpp
// Function: ClusterSeparatorBySensitivitySpecificity::ClusterStats::remove_dp(unsigned long)
const ClusterSeparator::ClusterStats& ClusterSeparatorBySensitivitySpecificity::ClusterStats::remove_dp(size_t dp)
{
	size_t	scaf = scaf_db.dp2scaf(dp);

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

	cluster -= dp;

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

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x9b48
movq %rax, %r15
movq 0x8(%rbx), %rdi
movq %rax, %rsi
callq 0x9bec
cmpq $0x2, %rax
jb 0xf7ed
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xea48
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0xf638
xorb $0x1, %al
movzbl %al, %eax
decl 0x18(%rbx,%rax,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/ClusterSeparatorBySensitivitySpecificity.cpp
// Function: ClusterSeparatorBySensitivitySpecificity::ClusterStats::assign_scaf(unsigned long)
const ClusterSeparator::ClusterStats& ClusterSeparatorBySensitivitySpecificity::ClusterStats::assign_scaf(size_t scaf)
{
	size_t  scaf_total_ndps = scaf_db.ndps(scaf);

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

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

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

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x9bec
movq %rax, %r15
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xf638
cmpq $0x2, %r15
jb 0xf865
testb %al, %al
jne 0xf865
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xffb4
movq 0x10(%rbx), %rdi
leaq 0x10(%rdi), %rcx
cmpq %rcx, %rax
je 0xf84e
movl 0x28(%rax), %r12d
jmp 0xf851
xorl %r12d, %r12d
movq %r14, %rsi
callq 0x6fd2
subl %r12d, 0x20(%rbx)
addl %r12d, 0x18(%rbx)
addl %r15d, 0x1c(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/ClusterSeparatorBySensitivitySpecificity.cpp
// Function: ClusterSeparatorBySensitivitySpecificity::ClusterStats::unassign_scaf(unsigned long)
const ClusterSeparator::ClusterStats& ClusterSeparatorBySensitivitySpecificity::ClusterStats::unassign_scaf(size_t scaf)
{
	size_t  scaf_total_ndps = scaf_db.ndps(scaf);
	if(!cluster.assigned(scaf) || (scaf_total_ndps < 2))
		return *this;

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

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

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x9bec
movq %rax, %r15
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xf638
cmpq $0x2, %r15
jb 0xf8db
testb %al, %al
je 0xf8db
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xffb4
movq 0x10(%rbx), %rdi
leaq 0x10(%rdi), %rcx
cmpq %rcx, %rax
je 0xf8c4
movl 0x28(%rax), %r12d
jmp 0xf8c7
xorl %r12d, %r12d
movq %r14, %rsi
callq 0xffd6
addl %r12d, 0x20(%rbx)
subl %r12d, 0x18(%rbx)
subl %r15d, 0x1c(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/CK7[P]abawaca/src/ClusterSeparatorBySensitivitySpecificity.cpp
// Function: operator<<(std::ostream&, ClusterSeparatorBySensitivitySpecificity&)
ostream& operator << (ostream& os, ClusterSeparatorBySensitivitySpecificity& cs)
{
	os << " Best separation:\t" << "dimension " << cs.get_separating_dimension() << " ("
		<< cs.clustering_db.get_dimension(cs.best_separation->get_dimension()).get_dimension_name() << ")\t"
		<< "Value " << cs.best_separation->get_value() << "\t"
		<< "Specificity " << static_cast<ClusterSeparatorBySensitivitySpecificity::ClusteringResult*>(cs.best_separation)->get_specificity() << "\t"
		<< "Sensitivity " << static_cast<ClusterSeparatorBySensitivitySpecificity::ClusteringResult*>(cs.best_separation)->get_sensitivity();

	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6912(%rip), %rsi      # 0x16215
callq 0x4340
leaq 0x6446(%rip), %rsi      # 0x15d55
movq %rax, %rdi
callq 0x4340
movq 0xa8(%r14), %rcx
movq 0x8(%rcx), %rsi
movq %rax, %rdi
callq 0x4240
leaq 0x65cc(%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 0x68b3(%rip), %rsi      # 0x16228
movq %rax, %rdi
callq 0x4340
leaq 0x68a7(%rip), %rsi      # 0x1622b
movq %rax, %rdi
callq 0x4340
movq 0xa8(%r14), %rcx
movsd 0x10(%rcx), %xmm0
movq %rax, %rdi
callq 0x45c0
leaq 0x6882(%rip), %rsi      # 0x16229
movq %rax, %rdi
callq 0x4340
leaq 0x687c(%rip), %rsi      # 0x16232
movq %rax, %rdi
callq 0x4340
movq 0xa8(%r14), %rcx
movsd 0x20(%rcx), %xmm0
movq %rax, %rdi
callq 0x45c0
leaq 0x6850(%rip), %rsi      # 0x16229
movq %rax, %rdi
callq 0x4340
leaq 0x6857(%rip), %rsi      # 0x1623f
movq %rax, %rdi
callq 0x4340
movq 0xa8(%r14), %rcx
movsd 0x18(%rcx), %xmm0
movq %rax, %rdi
callq 0x45c0
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.cpp
// Function: ClusterSeparatorSplitScafs::ClusterStats::operator+=(unsigned long)
const ClusterSeparatorSplitScafs::ClusterStats& ClusterSeparatorSplitScafs::ClusterStats::operator += (size_t dp)
{
	auto	mit = cluster.scafs_find(this->scaf_db.dp2scaf(dp));
	size_t	ndps_in_cluster = (mit != cluster.scafs_end())? mit->second : 0;
	size_t	ndps_in_scaf = scaf_db.ndps(this->scaf_db.dp2scaf(dp));

	if(ndps_in_scaf > 1) {
		this->cluster_useful_ndps++;
		// Is this scaf part of the cluster after the addition of the dp?
		if(is_scaf_part_of(ndps_in_cluster+1, ndps_in_scaf)) {
			// Is this scaf part of the cluster before the addition of the dp?
			if(!is_scaf_part_of(ndps_in_cluster, ndps_in_scaf)) {
				ndps_in_scafs_that_belong += ndps_in_cluster;
				scafs_in++;
			}
			ndps_in_scafs_that_belong++;
		}
	}

	cluster += dp;

	if(ndps_in_scafs_that_belong < 0 || ndps_in_scafs_that_belong > cluster.ndps()) {
		cerr << "Fatal error (1): illegal number of dps in scafs that belong: " << ndps_in_scafs_that_belong << endl;
		throw exception();
	}

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %r15
callq 0x9b48
movq %r15, %rdi
movq %rax, %rsi
callq 0xffb4
movq 0x8(%rbx), %rcx
addq $0x10, %rcx
cmpq %rcx, %rax
je 0x10b7f
movq 0x28(%rax), %r12
jmp 0x10b82
xorl %r12d, %r12d
movq (%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x9b48
movq %r15, %rdi
movq %rax, %rsi
callq 0x9bec
cmpq $0x2, %rax
jb 0x10c32
incl 0x10(%rbx)
movq 0x20(%rbx), %rcx
leaq 0x1(%r12), %rdx
movq %rdx, %xmm0
movq 0x55a2(%rip), %xmm1     # 0x16160
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x55a6(%rip), %xmm2     # 0x16170
subpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
movq %rax, %xmm4
punpckldq %xmm1, %xmm4    # xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1]
subpd %xmm2, %xmm4
movapd %xmm4, %xmm0
unpckhpd %xmm4, %xmm0            # xmm0 = xmm0[1],xmm4[1]
addsd %xmm4, %xmm0
mulsd (%rcx), %xmm0
ucomisd %xmm0, %xmm3
jb 0x10c32
movq %r12, %xmm1
punpckldq 0x5556(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x555e(%rip), %xmm1     # 0x16170
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
movl 0x14(%rbx), %eax
jae 0x10c2d
addl %r12d, %eax
incl 0x18(%rbx)
incl %eax
movl %eax, 0x14(%rbx)
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0xe984
movslq 0x14(%rbx), %rax
testq %rax, %rax
js 0x10c5d
movq 0x8(%rbx), %rcx
cmpq %rax, 0x50(%rcx)
jb 0x10c5d
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xe384(%rip), %rdi      # 0x1efe8
leaq 0x566a(%rip), %rsi      # 0x162d5
callq 0x4340
movl 0x14(%rbx), %esi
movq %rax, %rdi
callq 0x4630
movq %rax, %rdi
callq 0x41a0
pushq $0x8
popq %rdi
callq 0x41b0
movq 0xe316(%rip), %rcx      # 0x1efa8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xe330(%rip), %rsi      # 0x1efd0
movq 0xe349(%rip), %rdx      # 0x1eff0
movq %rax, %rdi
callq 0x4620
nop