LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq $0x0, 0x30(%rdi)
movq $0x1, 0x28(%rdi)
leaq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0x5530
leaq -0x78(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %r15
movq %r15, %rdi
callq 0xb27a
movq (%r15), %rsi
movq %rbx, %rdi
movl $0x10, %edx
callq 0x5060
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0xa1a4
callq 0x5340
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0xa1c1
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x51b0
movq %rax, %rbx
leaq -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0xb27a
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x10376(%rip), %rsi     # 0x1a56f
leaq 0x10385(%rip), %rdx     # 0x1a585
leaq -0x48(%rbp), %rdi
callq 0xb314
movb $0x1, %r12b
leaq 0x10373(%rip), %rcx     # 0x1a586
leaq -0x68(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0xa392
xorl %r12d, %r12d
leaq 0x18720(%rip), %rsi     # 0x22950
leaq 0xc77(%rip), %rdx       # 0xaeae
movq %rbx, %rdi
callq 0x5660
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0xa258
callq 0x5340
jmp 0xa258
movq %rax, %r14
movb $0x1, %r12b
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0xa26e
callq 0x5340
jmp 0xa26e
movq %rax, %r14
movb $0x1, %r12b
testb %r12b, %r12b
je 0xa291
movq %rbx, %rdi
callq 0x5280
jmp 0xa291
movq %rax, %r14
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0xa291
callq 0x5340
movq %r14, %rdi
callq 0x56a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, (%rdi)
movl 0x10(%rdi), %eax
movl %eax, 0x4(%rdi)
movq 0x14(%rdi), %rax
movq %rax, 0x8(%rdi)
movl $0x4, %eax
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
cmpl $0xb, %eax
jne 0xba96
movq %rbx, %rdi
callq 0xbb3f
movl 0x10(%rbx), %eax
movl 0x14(%rbx), %edx
movl 0xc(%rbx), %ecx
movl (%rbx), %r10d
movl 0x4(%rbx), %r9d
movl 0x8(%rbx), %edi
movl $0x8, %esi
movl %r9d, %r8d
andl $0x7fffffff, %r10d      # imm = 0x7FFFFFFF
xorl %edi, %r9d
xorl %r10d, %r9d
leal (%r9,%r9), %r10d
xorl %r9d, %r10d
movl %ecx, %r9d
shrl %r9d
xorl %r9d, %ecx
xorl %r10d, %ecx
movl %ecx, %r11d
andl $0x1, %r11d
negl %r11d
movl %eax, %r9d
andl %r11d, %r9d
xorl %edi, %r9d
movl %ecx, %edi
shll $0xa, %edi
andl %edx, %r11d
xorl %r10d, %edi
xorl %r11d, %edi
movl %r8d, %r10d
decl %esi
jne 0xbae0
movl %ecx, 0xc(%rbx)
movl %r8d, (%rbx)
movl %r9d, 0x4(%rbx)
movl %edi, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbb48
retq
cmpl $0x0, 0x4(%rdi)
jne 0xbb47
cmpl $0x0, 0x8(%rdi)
jne 0xbb47
cmpl $0x0, 0xc(%rdi)
jne 0xbb47
pushq %rbp
movq %rsp, %rbp
movaps 0xec1b(%rip), %xmm0     # 0x1a780
movups %xmm0, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xcd59
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %r8, %rdx
jbe 0xcd59
leaq (%r8,%r8,2), %rcx
shlq $0x4, %rcx
movq 0x10(%rax,%rcx), %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xdc62(%rip), %rsi      # 0x1a9c2
leaq 0xda39(%rip), %rdx      # 0x1a7a0
leaq -0x810(%rbp), %r14
movq %r14, %rdi
movl $0x7f, %ecx
xorl %eax, %eax
callq 0x5090
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x5730
movq 0x1622c(%rip), %rsi     # 0x22fc8
movq 0x16215(%rip), %rdx     # 0x22fb8
movq %rbx, %rdi
callq 0x5660
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xce0e
movq 0x78(%rdi), %rax
movq 0x80(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x71c71c71c71c71c7, %rdx # imm = 0x8E38E38E38E38E39
imulq %rcx, %rdx
cmpq %r8, %rdx
jbe 0xce0e
leaq (%r8,%r8,8), %rcx
movq 0x30(%rax,%rcx,8), %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xdbc5(%rip), %rsi      # 0x1a9da
leaq 0xd984(%rip), %rdx      # 0x1a7a0
leaq -0x810(%rbp), %r14
movq %r14, %rdi
movl $0x8a, %ecx
xorl %eax, %eax
callq 0x5090
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x5730
movq 0x16177(%rip), %rsi     # 0x22fc8
movq 0x16160(%rip), %rdx     # 0x22fb8
movq %rbx, %rdi
callq 0x5660
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x56a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xcee1
movq 0x78(%rsi), %rax
movq 0x80(%rsi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x71c71c71c71c71c7, %rdx # imm = 0x8E38E38E38E38E39
imulq %rcx, %rdx
cmpq %r8, %rdx
jbe 0xcee1
movq %rdi, %rbx
leaq (%r8,%r8,8), %rcx
movq 0x38(%rax,%rcx,8), %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
callq 0xb27a
movq %rbx, %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xdaf2(%rip), %rsi      # 0x1a9da
leaq 0xd8b1(%rip), %rdx      # 0x1a7a0
leaq -0x810(%rbp), %r14
movq %r14, %rdi
movl $0x95, %ecx
xorl %eax, %eax
callq 0x5090
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x5730
movq 0x160a4(%rip), %rsi     # 0x22fc8
movq 0x1608d(%rip), %rdx     # 0x22fb8
movq %rbx, %rdi
callq 0x5660
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq $0x0, 0x30(%rdi)
movq $0x1, 0x28(%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0xdf90
callq 0x5390
leaq -0x78(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %r15
movq %r15, %rdi
callq 0xb27a
movq (%r15), %rdi
leaq 0xc174(%rip), %rsi      # 0x1a131
callq 0x5450
movq %rax, %rbx
movq %rax, 0x38(%r14)
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xdfd6
callq 0x5340
testq %rbx, %rbx
je 0xdfea
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x51b0
movq %rax, %rbx
leaq -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0xb27a
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0xc54d(%rip), %rsi      # 0x1a56f
leaq 0xc55c(%rip), %rdx      # 0x1a585
leaq -0x48(%rbp), %rdi
callq 0xb314
movb $0x1, %r12b
leaq 0xca28(%rip), %rcx      # 0x1aa64
leaq -0x68(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0xa392
xorl %r12d, %r12d
leaq 0x148f7(%rip), %rsi     # 0x22950
leaq -0x31b2(%rip), %rdx     # 0xaeae
movq %rbx, %rdi
callq 0x5660
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0xe081
callq 0x5340
jmp 0xe081
movq %rax, %r14
movb $0x1, %r12b
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0xe097
callq 0x5340
jmp 0xe097
movq %rax, %r14
movb $0x1, %r12b
testb %r12b, %r12b
je 0xe0a4
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x55b0
testl %eax, %eax
je 0xf35d
xorl %eax, %eax
jmp 0xf42b
movq 0x38(%rbx), %rdi
callq 0x55b0
testl %eax, %eax
jne 0xf41e
movq 0x40(%rbx), %rax
movb $0x0, (%rax)
movq 0x38(%rbx), %rdx
movq 0x40(%rbx), %r15
movl 0x48(%rbx), %esi
movq %r15, %rdi
callq 0x55e0
testq %rax, %rax
je 0xf3ca
movq %r15, %rdi
callq 0x5180
cmpb $0xa, -0x1(%r15,%rax)
je 0xf3ca
movq 0x38(%rbx), %rdi
callq 0x55b0
testl %eax, %eax
jne 0xf3ca
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rsi
addq %rsi, %rsi
movq %rsi, 0x48(%rbx)
callq 0x5620
movq %rax, %r15
movq %rax, 0x40(%rbx)
movq %rax, %rdi
callq 0x5180
addq %rax, %r15
movl 0x48(%rbx), %esi
subl %eax, %esi
movq 0x38(%rbx), %rdx
jmp 0xf36f
movq 0x40(%rbx), %r15
movsbl (%r15), %edi
testl %edi, %edi
sete %r12b
je 0xf400
callq 0x5070
testl %eax, %eax
je 0xf400
leaq 0x1(%r15), %r13
movsbl (%r13), %edi
testl %edi, %edi
sete %r12b
je 0xf400
callq 0x5070
incq %r13
testl %eax, %eax
jne 0xf3e7
andb %r14b, %r12b
cmpb $0x1, %r12b
jne 0xf40d
movb $0x0, (%r15)
incq 0x28(%rbx)
movq 0x40(%rbx), %rax
cmpb $0x0, (%rax)
je 0xf34c
movq 0x40(%rbx), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
cmovneq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/CK7[P]abawaca/src/Dimension.cpp
// Function: Dimension::insert(unsigned long, double)
const Dimension& Dimension::insert(size_t dp, double value)
{
	values.insert(value);
	dp_index.insert(pair<size_t, size_t>(dp, dps.size()));
	dps.push_back(DataPoint(dp, value));

	return *this;
}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x40(%rdi), %rdx
leaq 0x38(%rdi), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0xfab0
movq %rax, %rcx
xorl %r8d, %r8d
cmpq %rsi, 0x20(%rdx)
setb %r8b
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%r8,8), %rdx
testq %rdx, %rdx
jne 0xfa97
movq %rax, %rdx
cmpq %rax, %rcx
je 0xfac3
cmpq %rsi, 0x20(%rcx)
cmovaq %rax, %rcx
movq %rcx, %rdx
cmpq %rax, %rdx
je 0xfadc
movq 0x28(%rdx), %rax
movq 0x60(%rdi), %rcx
shlq $0x4, %rax
movsd 0x8(%rcx,%rax), %xmm0
jmp 0xfae4
movsd 0xb25c(%rip), %xmm0     # 0x1ad40
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
testq %rsi, %rsi
je 0xffcd
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r8, %rcx
jbe 0xffcd
movq (%rax,%r8,8), %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%rdi), %r9
subq (%rdi), %r9
sarq $0x3, %r9
decq %r9
leaq 0xb075(%rip), %rsi      # 0x1b057
leaq 0xadc5(%rip), %rdx      # 0x1adae
leaq -0x810(%rbp), %r14
movq %r14, %rdi
movl $0xbf, %ecx
xorl %eax, %eax
callq 0x5090
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x5730
movq 0x12faa(%rip), %rsi     # 0x22fc8
movq 0x12f93(%rip), %rdx     # 0x22fb8
movq %rbx, %rdi
callq 0x5660
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x828, %rsp            # imm = 0x828
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r12
addq $0x8, %r12
movq 0x8(%r14), %r15
cmpq %r15, %r12
je 0x11134
movq (%r12), %rax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq 0x80(%rax), %rsi
movq 0x88(%rax), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0xb27a
movq -0x40(%rbp), %rdx
movb $0x1, %r13b
cmpq 0x8(%rbx), %rdx
jne 0x11137
testq %rdx, %rdx
je 0x11134
movq (%rbx), %rsi
movq -0x48(%rbp), %rdi
callq 0x53b0
testl %eax, %eax
setne %r13b
jmp 0x11137
xorl %r13d, %r13d
cmpq %r15, %r12
je 0x1114e
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1114e
callq 0x5340
addq $0x8, %r12
testb %r13b, %r13b
jne 0x110df
addq $-0x8, %r12
cmpq 0x8(%r14), %r12
je 0x11177
movq (%r12), %rax
addq $0x828, %rsp            # imm = 0x828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %r8
leaq 0x9eb1(%rip), %rsi      # 0x1b032
leaq 0x9c26(%rip), %rdx      # 0x1adae
leaq -0x850(%rbp), %r14
movq %r14, %rdi
movl $0xb3, %ecx
xorl %eax, %eax
callq 0x5090
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x5730
movq 0x11e0b(%rip), %rsi     # 0x22fc8
movq 0x11df4(%rip), %rdx     # 0x22fb8
movq %rbx, %rdi
callq 0x5660
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x56a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/CK7[P]abawaca/src/ClusterWriter.cpp
// Function: ClusterWriter::write(ClusterData const&, std::set<unsigned long, std::less<unsigned long>, std::allocator<unsigned long>> const&, std::unordered_set<unsigned long, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<unsigned long>> const&, char const*) const
void ClusterWriter::write(const ClusterData& clustering_db, const set<size_t>& scafs, const unordered_set<size_t>& raw_dps, const char* cluster_name) const
{
	char	scaf_stats_file[1024] = {};
	char	scaf_file[1024] = {};

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movq %r8, %rbx
movq %rcx, -0x38(%rbp)
movq %rdx, %r14
movq %rsi, -0x30(%rbp)
movq %rdi, %r15
leaq -0x840(%rbp), %r12
movl $0x400, %edx            # imm = 0x400
movq %r12, %rdi
xorl %esi, %esi
callq 0x51f0
leaq -0x440(%rbp), %r13
movl $0x400, %edx            # imm = 0x400
movq %r13, %rdi
xorl %esi, %esi
callq 0x51f0
movq 0x8(%r15), %rdx
leaq 0x9660(%rip), %rsi      # 0x1b0a0
movq %r12, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x5090
movq 0x8(%r15), %rdx
leaq 0x965d(%rip), %rsi      # 0x1b0b5
movq %r13, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x5090
movq (%r15), %rax
movq %r15, %rdi
movq -0x30(%rbp), %rsi
movq %rbx, %rdx
callq *(%rax)
movq %r15, %rdi
movq %r14, %rdx
movq -0x38(%rbp), %rcx
movq %r12, %r8
callq 0x11aaa
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x11e6c
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_O1/CK7[P]abawaca/src/ClusterWriter.cpp
// Function: ClusterWriter::write_scaffolds(std::set<unsigned long, std::less<unsigned long>, std::allocator<unsigned long>> const&, char const*, char const*) const
void ClusterWriter::write_scaffolds(const set<size_t>& scafs, const char* out_file, const char* cluster_name) const
{
        FILE* fp = fopen(out_file, "w");
	if(fp == NULL) {
		cerr << "Fatal error, " << __FILE__ << " (" << __LINE__ << "): could write to file " << out_file << endl << endl;
		exit(-1);
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
leaq 0x923c(%rip), %rsi      # 0x1b0cc
movq %rdx, %rdi
callq 0x5450
testq %rax, %rax
je 0x11f0f
movq %rax, %r12
movq 0x18(%r14), %r13
addq $0x8, %r14
cmpq %r14, %r13
je 0x11ef8
movq 0x28(%r15), %rsi
movq 0x20(%r13), %rdx
leaq -0x48(%rbp), %rdi
callq 0xce74
movq -0x48(%rbp), %rdx
movq %r12, %rdi
leaq 0x923e(%rip), %rsi      # 0x1b10a
movq %rbx, %rcx
xorl %eax, %eax
callq 0x5540
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x11ee8
callq 0x5340
movq %r13, %rdi
callq 0x5430
movq %rax, %r13
cmpq %r14, %rax
jne 0x11ead
movq %r12, %rdi
callq 0x5390
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x110d2(%rip), %rdi     # 0x22fe8
leaq 0x91b1(%rip), %rsi      # 0x1b0ce
callq 0x5380
leaq 0x91b3(%rip), %rsi      # 0x1b0dc
movq %rax, %rdi
callq 0x5380
leaq 0x9005(%rip), %rsi      # 0x1af3d
movq %rax, %rdi
callq 0x5380
movq %rax, %rdi
movl $0x1a, %esi
callq 0x5670
leaq 0x919e(%rip), %rsi      # 0x1b0f2
movq %rax, %rdi
callq 0x5380
movq %rax, %rdi
movq %r13, %rsi
callq 0x5380
movq %rax, %rdi
callq 0x51a0
movq %rax, %rdi
callq 0x51a0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x5480
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsi, -0x18(%rbp)
movq 0x38(%rdi), %rdi
movq 0x40(%rbx), %r8
xorl %r10d, %r10d
movq %rsi, %rax
xorl %edx, %edx
divq %r8
movq (%rdi,%rdx,8), %rax
testq %rax, %rax
je 0x1239c
movq (%rax), %r9
movq %rax, %r10
cmpq %rsi, 0x8(%r9)
je 0x1239c
movq %rdx, %rcx
movq %r9, %r11
movq (%r9), %r9
testq %r9, %r9
je 0x12399
movq 0x8(%r9), %rdi
movq %rdi, %rax
xorl %edx, %edx
divq %r8
movl $0x0, %r10d
cmpq %rcx, %rdx
jne 0x1239c
movq %r11, %r10
cmpq %rsi, %rdi
jne 0x1236d
jmp 0x1239c
xorl %r10d, %r10d
testq %r10, %r10
je 0x123ab
cmpq $0x0, (%r10)
jne 0x1242e
leaq 0x38(%rbx), %rdi
leaq -0x28(%rbp), %rdx
movq %rdi, (%rdx)
leaq -0x18(%rbp), %r14
movq %r14, %rsi
callq 0x11712
movq (%rbx), %rdi
movq (%r14), %rsi
callq 0xcd08
movq 0x18(%rbx), %rsi
leaq 0x10(%rbx), %rcx
movq %rcx, %rdx
testq %rsi, %rsi
je 0x123f8
movq %rcx, %rdx
xorl %edi, %edi
cmpq %rax, 0x20(%rsi)
setb %dil
cmovaeq %rsi, %rdx
movq 0x10(%rsi,%rdi,8), %rsi
testq %rsi, %rsi
jne 0x123e0
movq %rcx, %rsi
cmpq %rcx, %rdx
je 0x1240b
cmpq 0x20(%rdx), %rax
cmovbq %rcx, %rdx
movq %rdx, %rsi
cmpq %rcx, %rsi
je 0x12416
incq 0x28(%rsi)
jmp 0x1242e
leaq 0x8(%rbx), %rdi
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
movq $0x1, 0x8(%rsi)
callq 0xecce
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x18(%rdi), %rcx
addq $0x10, %rdi
movq %rdi, %rax
testq %rcx, %rcx
je 0x12468
movq %rdi, %rax
xorl %edx, %edx
cmpq %rsi, 0x20(%rcx)
setb %dl
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x12451
movq %rdi, %rcx
cmpq %rdi, %rax
je 0x1247b
cmpq %rsi, 0x20(%rax)
cmovaq %rdi, %rax
movq %rax, %rcx
cmpq %rdi, %rcx
je 0x12486
movq 0x28(%rcx), %rax
jmp 0x12488
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, -0x18(%rbp)
movq 0x38(%rdi), %rdi
movq 0x40(%rbx), %r8
xorl %r10d, %r10d
movq %rsi, %rax
xorl %edx, %edx
divq %r8
movq (%rdi,%rdx,8), %rax
testq %rax, %rax
je 0x124f6
movq (%rax), %r9
movq %rax, %r10
cmpq %rsi, 0x8(%r9)
je 0x124f6
movq %rdx, %rcx
movq %r9, %r11
movq (%r9), %r9
testq %r9, %r9
je 0x124f3
movq 0x8(%r9), %rdi
movq %rdi, %rax
xorl %edx, %edx
divq %r8
movl $0x0, %r10d
cmpq %rcx, %rdx
jne 0x124f6
movq %r11, %r10
cmpq %rsi, %rdi
jne 0x124c7
jmp 0x124f6
xorl %r10d, %r10d
testq %r10, %r10
je 0x12570
cmpq $0x0, (%r10)
je 0x12570
leaq 0x38(%rbx), %rdi
leaq -0x18(%rbp), %r14
movq %r14, %rsi
callq 0x1257c
movq (%rbx), %rdi
movq (%r14), %rsi
callq 0xcd08
movq 0x18(%rbx), %rdx
leaq 0x10(%rbx), %rsi
movq %rsi, %rcx
testq %rdx, %rdx
je 0x12547
movq %rsi, %rcx
xorl %edi, %edi
cmpq %rax, 0x20(%rdx)
setb %dil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x1252f
cmpq %rsi, %rcx
je 0x12554
cmpq 0x20(%rcx), %rax
cmovaeq %rcx, %rsi
movq 0x28(%rsi), %rax
cmpq $0x1, %rax
jne 0x12569
leaq 0x8(%rbx), %rdi
callq 0x12670
jmp 0x12570
decq %rax
movq %rax, 0x28(%rsi)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10d38(%rip), %al      # 0x233f8
testb %al, %al
je 0x12762
xorl %edi, %edi
callq 0x5330
subl 0x10d1f(%rip), %eax     # 0x233f4
cltq
imulq $-0x6e5d4c3b, %rax, %rdx # imm = 0x91A2B3C5
shrq $0x20, %rdx
addl %eax, %edx
movl %edx, %ecx
shrl $0x1f, %ecx
sarl $0xb, %edx
addl %ecx, %edx
imull $0xe10, %edx, %ecx      # imm = 0xE10
movl %eax, %esi
subl %ecx, %esi
movslq %esi, %r8
imulq $-0x77777777, %r8, %rcx # imm = 0x88888889
shrq $0x20, %rcx
addl %ecx, %r8d
movl %r8d, %ecx
shrl $0x1f, %ecx
sarl $0x5, %r8d
addl %ecx, %r8d
imulq $-0x77777777, %rax, %rcx # imm = 0x88888889
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %esi
shrl $0x1f, %esi
sarl $0x5, %ecx
addl %esi, %ecx
imull $0x3c, %ecx, %ecx
subl %ecx, %eax
movl %eax, (%rsp)
leaq 0x10cc4(%rip), %rbx     # 0x23400
leaq 0x8a7d(%rip), %rsi      # 0x1b1c0
movq %rbx, %rdi
movl $0x3a, %ecx
movl $0x3a, %r9d
xorl %eax, %eax
callq 0x5090
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x5846
jmp 0x126c8
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, 0x10d06(%rip)     # 0x23480
jne 0x127d0
movl $0x1c, %edi
callq 0x53a0
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movups %xmm0, 0xc(%rax)
movq %rax, 0x10ce9(%rip)     # 0x23480
movabsq $-0x38700e0708fee12, %rcx # imm = 0xFC78FF1F8F7011EE
movq %rcx, 0x10(%rax)
movl $0x3793fdff, 0x18(%rax) # imm = 0x3793FDFF
xorl %edi, %edi
callq 0x5330
movl %eax, %edi
callq 0x5350
movq 0x10cbf(%rip), %rbx     # 0x23480
callq 0x50d0
movq %rbx, %rdi
movl %eax, %esi
callq 0xba78
movq 0x10ca9(%rip), %rcx     # 0x23480
movl 0xc(%rcx), %eax
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
andl (%rcx), %esi
movl 0x4(%rcx), %edx
movl 0x8(%rcx), %edi
movl %edx, %r9d
xorl %edi, %r9d
xorl %esi, %r9d
leal (%r9,%r9), %r8d
xorl %r9d, %r8d
movl %eax, %esi
shrl %esi
xorl %eax, %esi
xorl %r8d, %esi
movl %edx, (%rcx)
movl %esi, 0xc(%rcx)
movl %esi, %eax
andl $0x1, %eax
negl %eax
movl 0x10(%rcx), %r9d
andl %eax, %r9d
xorl %edi, %r9d
movl %esi, %edi
shll $0xa, %edi
movl %r9d, 0x4(%rcx)
andl 0x14(%rcx), %eax
xorl %r8d, %edi
xorl %edi, %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_O1/CK7[P]abawaca/src/misc.cpp
// Function: MonteCarlo::shuffle(std::vector<unsigned long, std::allocator<unsigned long>>&)
void shuffle(vector<size_t>& values)
{
	for(size_t i=values.size()-1; i>0; i--) {
		size_t j = Random()%i;
		size_t t = values[i];
		values[i] = values[j];
		values[j] = t;
	}  
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
decq %rbx
je 0x128b4
movq %rdi, %r14
callq 0x1276c
xorl %edx, %edx
divq %rbx
movq (%r14,%rbx,8), %rax
movq (%r14,%rdx,8), %rcx
movq %rcx, (%r14,%rbx,8)
movq %rax, (%r14,%rdx,8)
decq %rbx
jne 0x12895
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
incq %rax
cmpq 0x10(%rdi), %rax
jbe 0x1296f
movq 0x10706(%rip), %r15     # 0x22fe8
leaq 0x88e8(%rip), %rsi      # 0x1b1d1
movl $0xc, %edx
movq %r15, %rdi
callq 0x5420
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5360
movsbl %al, %esi
movq %r15, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5250
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
shlq $0x4, %rsi
callq 0x5620
movq %rax, (%rbx)
shlq 0x10(%rbx)
leaq 0x88a3(%rip), %rsi      # 0x1b1de
movl $0x11, %edx
movq %r15, %rdi
callq 0x5420
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5360
movsbl %al, %esi
movq %r15, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5250
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq (%rax,%rcx,8), %rdx
leaq (%rax,%rcx,8), %rsi
addq $-0x8, %rsi
cmpq %rax, %rsi
jb 0x129ad
movq -0x8(%rdx), %rcx
cmpq %r14, %rcx
jbe 0x129a9
movq %rcx, (%rdx)
leaq -0x8(%rdx), %rcx
addq $-0x10, %rdx
cmpq %rax, %rdx
movq %rcx, %rdx
jae 0x12987
leaq -0x8(%rcx), %rsi
jmp 0x129b0
leaq -0x8(%rdx), %rsi
movq %rdx, %rcx
cmpq %rax, %rsi
jne 0x129bc
cmpq %r14, (%rsi)
cmovaeq %rsi, %rcx
movq %r14, (%rcx)
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_O1/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 0x12a8b
movq 0x8(%rdi), %rax
cmpq %rsi, -0x8(%rcx,%rax,8)
jbe 0x12a8c
pushq %rbp
movq %rsp, %rbp
leaq -0x1(%rax), %r9
xorl %r8d, %r8d
movabsq $0x100000000, %rdx      # imm = 0x100000000
movabsq $-0x100000000, %rdi     # imm = 0xFFFFFFFF00000000
leaq (%r9,%r8), %r10
shlq $0x1f, %r10
movq %r10, %r11
sarq $0x1d, %r11
andq $-0x8, %r11
cmpq %rsi, (%rcx,%r11)
ja 0x12a35
addq %rdx, %r10
sarq $0x20, %r10
movq %r10, %r8
jmp 0x12a3f
addq %rdi, %r10
sarq $0x20, %r10
movq %r10, %r9
cmpq %r8, %r9
jae 0x12a10
movq %r8, %xmm1
movq 0x874f(%rip), %xmm2     # 0x1b1a0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x8753(%rip), %xmm3     # 0x1b1b0
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
popq %rbp
retq
movsd 0x8704(%rip), %xmm0     # 0x1b198
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/CK7[P]abawaca/src/ClusterSeparatorBySensitivitySpecificity.cpp
// Function: ClusterSeparatorBySensitivitySpecificity::ClusterStats::add_dp(unsigned long)
const ClusterSeparator::ClusterStats& ClusterSeparatorBySensitivitySpecificity::ClusterStats::add_dp(size_t dp)
{
	size_t	scaf = scaf_db.dp2scaf(dp);

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

	cluster += dp;

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

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xcd08
movq %rax, %r14
movq 0x8(%rbx), %rdi
movq %rax, %rsi
callq 0xcdbe
cmpq $0x2, %rax
jb 0x133cb
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x12330
movq 0x10(%rbx), %rax
movq 0x80(%rax), %rdx
addq $0x78, %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x133ac
movq %rax, %rcx
xorl %esi, %esi
cmpq %r14, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x13394
movq %rax, %rdx
cmpq %rax, %rcx
je 0x133bf
cmpq %r14, 0x20(%rcx)
cmovaq %rax, %rcx
movq %rcx, %rdx
xorl %ecx, %ecx
cmpq %rax, %rdx
sete %cl
incl 0x18(%rbx,%rcx,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/CK7[P]abawaca/src/ClusterSeparatorBySensitivitySpecificity.cpp
// Function: ClusterSeparatorBySensitivitySpecificity::ClusterStats::remove_dp(unsigned long)
const ClusterSeparator::ClusterStats& ClusterSeparatorBySensitivitySpecificity::ClusterStats::remove_dp(size_t dp)
{
	size_t	scaf = scaf_db.dp2scaf(dp);

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

	cluster -= dp;

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

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xcd08
movq %rax, %r14
movq 0x8(%rbx), %rdi
movq %rax, %rsi
callq 0xcdbe
cmpq $0x2, %rax
jb 0x13465
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x1248a
movq 0x10(%rbx), %rax
movq 0x80(%rax), %rdx
addq $0x78, %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x13446
movq %rax, %rcx
xorl %esi, %esi
cmpq %r14, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x1342e
movq %rax, %rdx
cmpq %rax, %rcx
je 0x13459
cmpq %r14, 0x20(%rcx)
cmovaq %rax, %rcx
movq %rcx, %rdx
xorl %ecx, %ecx
cmpq %rax, %rdx
sete %cl
decl 0x18(%rbx,%rcx,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/CK7[P]abawaca/src/ClusterSeparatorBySensitivitySpecificity.cpp
// Function: ClusterSeparatorBySensitivitySpecificity::ClusterStats::assign_scaf(unsigned long)
const ClusterSeparator::ClusterStats& ClusterSeparatorBySensitivitySpecificity::ClusterStats::assign_scaf(size_t scaf)
{
	size_t  scaf_total_ndps = scaf_db.ndps(scaf);

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

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

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

	return *this;
}

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

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

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

	return *this;
}

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

	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7be1(%rip), %rsi      # 0x1b255
movl $0x12, %edx
callq 0x5420
leaq 0x7710(%rip), %rsi      # 0x1ad95
movl $0xa, %edx
movq %rbx, %rdi
callq 0x5420
movq 0xa8(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x5240
movq %rax, %r15
leaq 0x788e(%rip), %rsi      # 0x1af3d
movl $0x2, %edx
movq %rax, %rdi
callq 0x5420
movq 0x18(%r14), %rdi
movq 0xa8(%r14), %rax
movq 0x8(%rax), %rsi
callq 0xff94
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x80(%rax), %rsi
movq 0x88(%rax), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0xb27a
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x5420
movq %rax, %r15
leaq 0x7b58(%rip), %rsi      # 0x1b268
movl $0x2, %edx
movq %rax, %rdi
callq 0x5420
leaq 0x7b47(%rip), %rsi      # 0x1b26b
movl $0x6, %edx
movq %r15, %rdi
callq 0x5420
movq 0xa8(%r14), %rax
movsd 0x10(%rax), %xmm0
movq %r15, %rdi
callq 0x55f0
movq %rax, %r15
leaq 0x7b1a(%rip), %rsi      # 0x1b269
movl $0x1, %edx
movq %rax, %rdi
callq 0x5420
leaq 0x7b0f(%rip), %rsi      # 0x1b272
movl $0xc, %edx
movq %r15, %rdi
callq 0x5420
movq 0xa8(%r14), %rax
movsd 0x20(%rax), %xmm0
movq %r15, %rdi
callq 0x55f0
movq %rax, %r15
leaq 0x7adb(%rip), %rsi      # 0x1b269
movl $0x1, %edx
movq %rax, %rdi
callq 0x5420
leaq 0x7add(%rip), %rsi      # 0x1b27f
movl $0xc, %edx
movq %r15, %rdi
callq 0x5420
movq 0xa8(%r14), %rax
movsd 0x18(%rax), %xmm0
movq %r15, %rdi
callq 0x55f0
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x137d1
callq 0x5340
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x137f4
callq 0x5340
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O1/CK7[P]abawaca/src/ClusterSeparatorSplitScafs.cpp
// Function: operator<<(std::ostream&, ClusterSeparatorSplitScafs&)
ostream& operator << (ostream& os, ClusterSeparatorSplitScafs& cs)
{
        os << " Best separation:\t" << "dimension " << cs.get_separating_dimension() << " ("
                << cs.clustering_db.get_dimension(cs.get_separating_dimension()).get_dimension_name() << ")\t"
                << "Value " << cs.get_separating_value() << "\t"
                << "best split scaf ratio " << cs.get_best_split_scaf_ratio() << endl;

	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6712(%rip), %rsi      # 0x1b255
movl $0x12, %edx
callq 0x5420
leaq 0x6241(%rip), %rsi      # 0x1ad95
movl $0xa, %edx
movq %rbx, %rdi
callq 0x5420
movq 0xa8(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x5240
movq %rax, %r15
leaq 0x63bf(%rip), %rsi      # 0x1af3d
movl $0x2, %edx
movq %rax, %rdi
callq 0x5420
movq 0x18(%r14), %rdi
movq 0xa8(%r14), %rax
movq 0x8(%rax), %rsi
callq 0xff94
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x80(%rax), %rsi
movq 0x88(%rax), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0xb27a
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x5420
movq %rax, %r15
leaq 0x6689(%rip), %rsi      # 0x1b268
movl $0x2, %edx
movq %rax, %rdi
callq 0x5420
leaq 0x6678(%rip), %rsi      # 0x1b26b
movl $0x6, %edx
movq %r15, %rdi
callq 0x5420
movq 0xa8(%r14), %rax
movsd 0x10(%rax), %xmm0
movq %r15, %rdi
callq 0x55f0
movq %rax, %r15
leaq 0x664b(%rip), %rsi      # 0x1b269
movl $0x1, %edx
movq %rax, %rdi
callq 0x5420
leaq 0x675f(%rip), %rsi      # 0x1b391
movl $0x16, %edx
movq %r15, %rdi
callq 0x5420
movq %r14, %rdi
callq 0x15278
movq %r15, %rdi
callq 0x55f0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5360
movsbl %al, %esi
movq %r14, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5250
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x14c87
callq 0x5340
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x14caa
callq 0x5340
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O1/CK7[P]abawaca/src/ClusterSeparatorSplitScafs.h
// Function: ClusterSeparatorSplitScafs::ClusteringResult::is_better(ClusterSeparator::ClusteringResult const&) const
virtual bool		is_better(const ClusterSeparator::ClusteringResult& cr_) const override
		{
			const ClusteringResult& cr = dynamic_cast<const ClusteringResult&>(cr_);
			if(split_scaf_ratio != cr.split_scaf_ratio) return split_scaf_ratio < cr.split_scaf_ratio;
			if(cluster_size_ratio != cr.cluster_size_ratio) return cluster_size_ratio < cr.cluster_size_ratio;
			return ClusterSeparator::ClusteringResult::is_better(cr);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0xd523(%rip), %rsi      # 0x227e0
leaq 0xd9ec(%rip), %rdx      # 0x22cb0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x5410
testq %rax, %rax
je 0x15316
movsd 0x18(%rbx), %xmm0
movsd 0x18(%rax), %xmm1
ucomisd %xmm1, %xmm0
jne 0x152f7
jp 0x152f7
movsd 0x20(%rbx), %xmm0
movsd 0x20(%rax), %xmm1
ucomisd %xmm1, %xmm0
jne 0x152f7
jnp 0x15305
ucomisd %xmm0, %xmm1
seta %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x12aac
callq 0x5720
nop