LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/Genome.cpp
// Function: SAHap::Genome::findPbad(double, unsigned long long)
double Genome::findPbad(double temperature, iteration_t iterations) {
	this->shuffle();

	this->t = temperature;
	this->ResetBuffers();

	double sumPbad = 0.0, prevSumPbad;
	int i = 0;
	do {
		this->iteration();
		// cout << "[simann] temp=" << this->t << ", mec=" << this->mec() << endl;
		double newPbad = this->pBad.getAverage();
		prevSumPbad = sumPbad;
		sumPbad += newPbad;
		++i;
		// below, we compute the previous and current average and demand they agree to some precision
	} while (i < 30 || fabs(prevSumPbad/(i-1) / (sumPbad/i) - 1) > 1e-3); // stabilize to at least this relative precision

	cout << "temperature " << temperature << " gives Pbad " << this->pBad.getAverage() << " after " << i << " iterations\n";

	return this->pBad.getAverage();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x2b30
movq -0x40(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x3bc0(%rdi)
callq 0x3be0
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3700
movq -0x40(%rbp), %rdi
addq $0x408, %rdi            # imm = 0x408
callq 0x4200
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x38(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movb $0x1, %al
cmpl $0x1e, -0x2c(%rbp)
movb %al, -0x41(%rbp)
jl 0x5110
movsd -0x28(%rbp), %xmm0
movl -0x2c(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd -0x20(%rbp), %xmm1
cvtsi2sdl -0x2c(%rbp), %xmm2
divsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd 0x16f51(%rip), %xmm1    # 0x1c040
subsd %xmm1, %xmm0
movaps 0x16f36(%rip), %xmm1    # 0x1c030
pand %xmm1, %xmm0
movsd 0x16fca(%rip), %xmm1    # 0x1c0d0
ucomisd %xmm1, %xmm0
seta %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x5077
movq 0x25ea6(%rip), %rdi     # 0x2afc8
leaq 0x172f5(%rip), %rsi     # 0x1c41e
callq 0x2230
movq %rax, %rdi
movsd -0x10(%rbp), %xmm0
callq 0x2460
movq %rax, %rdi
leaq 0x172e6(%rip), %rsi     # 0x1c42b
callq 0x2230
movq -0x40(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x408, %rdi            # imm = 0x408
callq 0x4200
movq -0x50(%rbp), %rdi
callq 0x2460
movq %rax, %rdi
leaq 0x172c7(%rip), %rsi     # 0x1c438
callq 0x2230
movq %rax, %rdi
movl -0x2c(%rbp), %esi
callq 0x2400
movq %rax, %rdi
leaq 0x172b5(%rip), %rsi     # 0x1c440
callq 0x2230
movq -0x40(%rbp), %rdi
addq $0x408, %rdi            # imm = 0x408
callq 0x4200
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/Genome.cpp
// Function: SAHap::Genome::compareGroundTruth(SAHap::Haplotype const&, std::vector<int, std::allocator<int>> const&)
dnacnt_t Genome::compareGroundTruth(const Haplotype& ch, const vector<int>& truth) {
	dnacnt_t loss = 0;
	for (size_t i = 0; i < ch.size(); ++i) {
		if (ch.solution[i] != truth[i]) {
			loss++;
		}
	}
	return loss;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10860
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x5446
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6280
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6280
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl (%rcx), %eax
je 0x5436
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5438
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x53e4
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/Genome.cpp
// Function: SAHap::operator<<(std::ostream&, SAHap::Genome const&)
ostream& operator << (ostream& stream, const Genome& ge) {
	int blockNum = 1;
	for (Range r : ge.blocks) {
		stream << "BLOCK " << blockNum++ << endl;
		for (size_t i = 0; i < ge.haplotypes.size(); ++i) {
			for (size_t j = 0; j < ge.haplotypes[i].size(); ++j) {
				if (j >= r.start && j <= r.end) {
					if (ge.haplotypes[i].solution[j] < 0)
						stream << 'X';
					else
						stream << ge.haplotypes[i].solution[j];
				}
				else
					stream << '-';
			}
			stream << endl;
		}
	}
	return stream;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x3c30, %rax           # imm = 0x3C30
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x62a0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x62d0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6300
testb $0x1, %al
jne 0x54a5
jmp 0x562b
leaq -0x28(%rbp), %rdi
callq 0x6340
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x17070(%rip), %rsi     # 0x1c538
callq 0x2230
movq %rax, %rdi
movl -0x14(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
callq 0x2400
movq %rax, %rdi
movq 0x25ac6(%rip), %rsi     # 0x2afb0
callq 0x2270
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
addq $0x2368, %rdi           # imm = 0x2368
callq 0x5ae0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x561b
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
addq $0x2368, %rdi           # imm = 0x2368
movq -0x48(%rbp), %rsi
callq 0x6360
movq %rax, %rdi
callq 0x10860
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x55fa
movq -0x50(%rbp), %rax
cmpq -0x40(%rbp), %rax
jb 0x55d9
movq -0x50(%rbp), %rax
cmpq -0x38(%rbp), %rax
ja 0x55d9
movq -0x10(%rbp), %rdi
addq $0x2368, %rdi           # imm = 0x2368
movq -0x48(%rbp), %rsi
callq 0x6360
movq %rax, %rdi
movq -0x50(%rbp), %rsi
callq 0x6280
cmpl $0x0, (%rax)
jge 0x55a4
movq -0x8(%rbp), %rdi
movl $0x58, %esi
callq 0x2290
jmp 0x55d7
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
addq $0x2368, %rdi           # imm = 0x2368
movq -0x48(%rbp), %rsi
callq 0x6360
movq %rax, %rdi
movq -0x50(%rbp), %rsi
callq 0x6280
movq -0x68(%rbp), %rdi
movl (%rax), %esi
callq 0x2400
jmp 0x55e7
movq -0x8(%rbp), %rdi
movl $0x2d, %esi
callq 0x2290
jmp 0x55e9
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x5527
movq -0x8(%rbp), %rdi
movq 0x259ab(%rip), %rsi     # 0x2afb0
callq 0x2270
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x54f7
jmp 0x561d
leaq -0x28(%rbp), %rdi
callq 0x6380
jmp 0x548f
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/Haplotype.cpp
// Function: SAHap::Haplotype::meanCoverage()
double Haplotype::meanCoverage() {
    double result = 0.0;
    for (dnapos_t i = 0; i < this->length; ++i) {
		result += this->siteCoverages[i];
    }
    return result/this->length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0x10821
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0x11df0
movq (%rax), %xmm0
movaps 0xb822(%rip), %xmm1     # 0x1c010
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xb826(%rip), %xmm1     # 0x1c020
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x107c4
movq -0x20(%rbp), %rax
movsd -0x10(%rbp), %xmm0
movq 0x18(%rax), %xmm1
movaps 0xb7da(%rip), %xmm2     # 0x1c010
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0xb7de(%rip), %xmm2     # 0x1c020
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/Haplotype.cpp
// Function: SAHap::Haplotype::pickReads(unsigned int)
void Haplotype::pickReads(unsigned overlap) {
	this->reads.clear();
	
	for (auto r : this->saved_reads) {
		if (r->range.end > this->window.start + overlap && r->range.start <= this->window.end) {
			this->reads.insert(r);
		}
	}
	//cout << "MIN START: " << mx << endl;
	for (auto r : this->reads)
		this->saved_reads.erase(r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x70, %rdi
callq 0x12190
movq -0x68(%rbp), %rax
addq $0xa8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12060
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12090
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x120c0
testb $0x1, %al
jne 0x10c1b
jmp 0x10c83
leaq -0x20(%rbp), %rdi
callq 0x120f0
movq -0x68(%rbp), %rcx
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq 0xe0(%rcx), %rcx
movl -0xc(%rbp), %edx
addq %rdx, %rcx
cmpq %rcx, %rax
jbe 0x10c76
movq -0x68(%rbp), %rcx
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
cmpq 0xe8(%rcx), %rax
ja 0x10c76
movq -0x68(%rbp), %rdi
addq $0x70, %rdi
leaq -0x30(%rbp), %rsi
callq 0x12120
movq %rax, -0x40(%rbp)
movb %dl, -0x38(%rbp)
jmp 0x10c78
leaq -0x20(%rbp), %rdi
callq 0x12160
jmp 0x10c08
movq -0x68(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x12060
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x12090
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x120c0
testb $0x1, %al
jne 0x10cbc
jmp 0x10ceb
leaq -0x50(%rbp), %rdi
callq 0x120f0
movq -0x68(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x60(%rbp)
addq $0xa8, %rdi
leaq -0x60(%rbp), %rsi
callq 0x121b0
leaq -0x50(%rbp), %rdi
callq 0x12160
jmp 0x10ca9
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/Haplotype.cpp
// Function: SAHap::Haplotype::initializeWindow(unsigned int, unsigned int)
void Haplotype::initializeWindow(unsigned windowSize, unsigned incrementBy) {
	this->window.start = 0;
	this->window.end = windowSize;
	this->increment_window_by = incrementBy;
	this->saved_reads = this->reads;

	this->pickReads(0);

	this->window_mec = mec(this->window.start, this->window.end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq $0x0, 0xe0(%rdi)
movl -0xc(%rbp), %eax
movq %rax, 0xe8(%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0xf0(%rdi)
movq %rdi, %rsi
addq $0x70, %rsi
addq $0xa8, %rdi
callq 0x121e0
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x10bc0
movq -0x18(%rbp), %rdi
movq 0xe0(%rdi), %rsi
movq 0xe8(%rdi), %rdx
callq 0x108c0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x58(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/Haplotype.cpp
// Function: SAHap::Haplotype::incrementWindow()
void Haplotype::incrementWindow() {
	dnapos_t old_end = this->window.end;

	this->window.start += this->increment_window_by;
	this->window.end = min(this->window.end + this->increment_window_by, this->length);

	this->saveReads();
	this->pickReads(old_end - this->window.start);
	
	this->window_mec = mec(this->window.start, this->window.end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x20(%rbp)
movq 0xe8(%rsi), %rax
movq %rax, -0x10(%rbp)
movl 0xf0(%rsi), %eax
addq 0xe0(%rsi), %rax
movq %rax, 0xe0(%rsi)
movq 0xe8(%rsi), %rax
movl 0xf0(%rsi), %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
addq $0x18, %rsi
leaq -0x18(%rbp), %rdi
callq 0x6010
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, 0xe8(%rdi)
callq 0x10b20
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
subq 0xe0(%rdi), %rax
movl %eax, %esi
callq 0x10bc0
movq -0x20(%rbp), %rdi
movq 0xe0(%rdi), %rsi
movq 0xe8(%rdi), %rdx
callq 0x108c0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x58(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/Haplotype.cpp
// Function: SAHap::Haplotype::windowTotalCoverage()
double Haplotype::windowTotalCoverage() {
    double result = 0.0;
    for (dnapos_t i = this->window.start; i < this->window.end; ++i) {
		result += this->siteCoverages[i];
    }
    return result;//(this->window.end - this->window.start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq 0xe0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0xe8(%rcx), %rax
jae 0x10eb7
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0x11df0
movq (%rax), %xmm0
movaps 0xb18c(%rip), %xmm1     # 0x1c010
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xb190(%rip), %xmm1     # 0x1c020
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x10e57
movsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/Haplotype.cpp
// Function: SAHap::Haplotype::add(SAHap::Read*)
void Haplotype::add(Read * r) {
	if (this->reads.find(r) != this->reads.end()) {
		throw "Haplotype already contains read";
	}
	// std::cout << "adding\n";
	this->reads.insert(r);
	this->vote(*r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x70, %rdi
leaq -0x10(%rbp), %rsi
callq 0x12290
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x70, %rdi
callq 0x12090
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x120c0
testb $0x1, %al
jne 0x10fdd
jmp 0x11004
movl $0x8, %edi
callq 0x2100
movq %rax, %rdi
leaq 0xb6c9(%rip), %rax      # 0x1c6ba
movq %rax, (%rdi)
movq 0x19fbd(%rip), %rsi     # 0x2afb8
xorl %eax, %eax
movl %eax, %edx
callq 0x23f0
movq -0x38(%rbp), %rdi
addq $0x70, %rdi
leaq -0x10(%rbp), %rsi
callq 0x12120
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
movb %dl, -0x28(%rbp)
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x11040
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/Haplotype.cpp
// Function: SAHap::Haplotype::vote(SAHap::Read&, bool)
void Haplotype::vote(Read& read, bool retract) {
#if SAHAP_CHROMOSOME_ALT_MEC
	// TODO: Alternative MEC
#else
	for (const Site& site : read.sites) {
		dnapos_t i = site.pos;

		subtractMECValuesAt(i);

		if (!retract) // enter
			addSite(site);
		else // leave
			removeSite(site);

		addMECValuesAt(i);
	}
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9f40
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9f70
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x12350
testb $0x1, %al
jne 0x11094
jmp 0x110f4
leaq -0x28(%rbp), %rdi
callq 0x12390
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x11340
testb $0x1, -0x11(%rbp)
jne 0x110cf
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x11720
jmp 0x110dc
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x11840
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x11550
leaq -0x28(%rbp), %rdi
callq 0x123b0
jmp 0x11081
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/Haplotype.cpp
// Function: SAHap::Haplotype::remove(SAHap::Read*)
void Haplotype::remove(Read * r) {
	if (this->reads.find(r) == this->reads.end()) {
		cout << "Offending read is " << r << endl;
		// cout << "Offending read has #sites=" << r->sites.size();
		throw "Haplotype does not contain read";
	}

	this->reads.erase(r);
	this->vote(*r, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x70, %rdi
leaq -0x10(%rbp), %rsi
callq 0x12290
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x70, %rdi
callq 0x12090
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x122c0
testb $0x1, %al
jne 0x1114d
jmp 0x111a2
movq 0x19e74(%rip), %rdi     # 0x2afc8
leaq 0xb57f(%rip), %rsi      # 0x1c6da
callq 0x2230
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x21d0
movq %rax, %rdi
movq 0x19e3a(%rip), %rsi     # 0x2afb0
callq 0x2270
movl $0x8, %edi
callq 0x2100
movq %rax, %rdi
leaq 0xb55e(%rip), %rax      # 0x1c6ed
movq %rax, (%rdi)
movq 0x19e1f(%rip), %rsi     # 0x2afb8
xorl %eax, %eax
movl %eax, %edx
callq 0x23f0
movq -0x28(%rbp), %rdi
addq $0x70, %rdi
leaq -0x10(%rbp), %rsi
callq 0x121b0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x11040
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/Haplotype.cpp
// Function: SAHap::Haplotype::randomRead()
Read * Haplotype::randomRead() {
	long int seed = GetFancySeed(true);
	cout << "Haplotype seed " << seed << endl;
	mt19937 engine(seed);

	return this->randomRead(engine);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x13a0, %rsp           # imm = 0x13A0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x13a0(%rbp)
movl $0x1, %edi
callq 0x1bac0
movq %rax, -0x10(%rbp)
movq 0x19dc9(%rip), %rdi     # 0x2afc8
leaq 0xb507(%rip), %rsi      # 0x1c70d
callq 0x2230
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x2430
movq %rax, %rdi
movq 0x19d8f(%rip), %rsi     # 0x2afb0
callq 0x2270
movq -0x10(%rbp), %rsi
leaq -0x1398(%rbp), %rdi
callq 0x57b0
movq -0x13a0(%rbp), %rdi
leaq -0x1398(%rbp), %rsi
callq 0x11260
addq $0x13a0, %rsp           # imm = 0x13A0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/Haplotype.cpp
// Function: SAHap::Haplotype::randomRead(std::mersenne_twister_engine<unsigned long, 32ul, 624ul, 397ul, 31ul, 2567483615ul, 11ul, 4294967295ul, 7ul, 2636928640ul, 15ul, 4022730752ul, 18ul, 1812433253ul>&)
Read * Haplotype::randomRead(mt19937& engine) {
	if (this->reads.size()==0) return nullptr;

	uniform_int_distribution<size_t> distribution(0, this->reads.size() - 1);
	size_t rd = distribution(engine);
	return *next(begin(this->reads), rd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x70, %rdi
callq 0x12040
cmpq $0x0, %rax
jne 0x11291
movq $0x0, -0x8(%rbp)
jmp 0x112f5
movq -0x48(%rbp), %rdi
addq $0x70, %rdi
callq 0x12040
movq %rax, %rdx
subq $0x1, %rdx
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5b30
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x5c40
movq -0x48(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x70, %rdi
callq 0x12320
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x122f0
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x120f0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/Haplotype.cpp
// Function: SAHap::Haplotype::addMECValuesAt(unsigned long)
void Haplotype::addMECValuesAt(dnapos_t pos) {
	for (unsigned i = 0; i < ploidyCount; i++) {
		if ((int)i == solution[pos])
			continue;
		auto mec = weights[pos][i];
		total_mec += mec;

		if (isInRangeOf(window, pos))
			window_mec += mec;
		if(window_mec < 0 && window_mec > -SMALL_ENOUGH_TO_IGNORE) window_mec = 0;
		assert(window_mec>=0);

		if(siteCoverages[i]) isitecost += -log_poisson_1_cdf(READ_ERROR_RATE * siteCoverages[i], mec);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x68(%rcx), %eax
jae 0x11714
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rsi
callq 0x6160
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl (%rcx), %eax
jne 0x115a1
jmp 0x11706
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0x6090
movq %rax, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x6160
movq -0x30(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x18(%rbp)
cvtsi2sdl -0x18(%rbp), %xmm0
addsd 0x50(%rdi), %xmm0
movsd %xmm0, 0x50(%rdi)
movq 0xe0(%rdi), %rax
movq %rax, -0x28(%rbp)
movq 0xe8(%rdi), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x11300
testb $0x1, %al
jne 0x11604
jmp 0x11617
movq -0x30(%rbp), %rax
cvtsi2sdl -0x18(%rbp), %xmm0
addsd 0x58(%rax), %xmm0
movsd %xmm0, 0x58(%rax)
movq -0x30(%rbp), %rax
xorps %xmm0, %xmm0
ucomisd 0x58(%rax), %xmm0
jbe 0x11648
movq -0x30(%rbp), %rax
movsd 0x58(%rax), %xmm0
movsd 0xafea(%rip), %xmm1     # 0x1c620
ucomisd %xmm1, %xmm0
jbe 0x11648
movq -0x30(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x58(%rax)
movq -0x30(%rbp), %rax
movsd 0x58(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1165c
jmp 0x1167b
leaq 0xb024(%rip), %rdi      # 0x1c687
leaq 0xafc3(%rip), %rsi      # 0x1c62d
movl $0xf2, %edx
leaq 0xb0e9(%rip), %rcx      # 0x1c75f
callq 0x2180
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x11df0
cmpq $0x0, (%rax)
je 0x11704
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x11df0
movq (%rax), %xmm1
movaps 0xa960(%rip), %xmm0     # 0x1c010
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0xa964(%rip), %xmm0     # 0x1c020
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd 0xa97d(%rip), %xmm0     # 0x1c050
mulsd %xmm1, %xmm0
movl -0x18(%rbp), %edi
callq 0x1b960
movq -0x30(%rbp), %rax
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
addsd 0x60(%rax), %xmm0
movsd %xmm0, 0x60(%rax)
jmp 0x11706
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1156f
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/Haplotype.cpp
// Function: SAHap::Haplotype::addSite(SAHap::Site const&)
void Haplotype::addSite(const Site &s) {
	weights[s.pos][s.value] += s.weight;

	if (s.value != solution[s.pos] && weights[s.pos][s.value] > weights[s.pos][solution[s.pos]])
		solution[s.pos] = s.value;
	
	siteCoverages[s.pos]++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x24(%rbp)
addq $0x20, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x6090
movq %rax, %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
callq 0x6160
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rdi
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x6160
movq %rax, %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
je 0x11819
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x6090
movq %rax, %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
callq 0x6160
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x28(%rbp)
addq $0x20, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x6090
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x6160
movq -0x30(%rbp), %rdi
movslq (%rax), %rsi
callq 0x6160
movq %rax, %rcx
movl -0x28(%rbp), %eax
cmpl (%rcx), %eax
jle 0x11819
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x6160
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x11df0
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/Haplotype.cpp
// Function: SAHap::Haplotype::removeSite(SAHap::Site const&)
void Haplotype::removeSite(const Site &s) {
	weights[s.pos][s.value] -= s.weight;

	if (solution[s.pos] == s.value)
		findSolution(s.pos);

	siteCoverages[s.pos]--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
addq $0x20, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x6090
movq %rax, %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
callq 0x6160
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rdi
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x6160
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x118b7
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x118e0
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x11df0
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/Haplotype.cpp
// Function: SAHap::Haplotype::VoteInfo::vote(SAHap::Allele)
dnacnt_t& Haplotype::VoteInfo::vote(Allele allele) {
	if (allele == Allele::REF) {
		return this->ref_c;
	} else if (allele == Allele::ALT) {
		return this->alt_c;
	}
	throw "vote: Invalid allele value";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpb $0x0, -0x11(%rbp)
jne 0x119ca
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11a07
cmpb $0x1, -0x11(%rbp)
jne 0x119de
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x11a07
jmp 0x119e0
movl $0x8, %edi
callq 0x2100
movq %rax, %rdi
leaq 0xad9b(%rip), %rax      # 0x1c78f
movq %rax, (%rdi)
movq 0x195ba(%rip), %rsi     # 0x2afb8
xorl %eax, %eax
movl %eax, %edx
callq 0x23f0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/Haplotype.cpp
// Function: SAHap::Haplotype::VoteInfo::weight(SAHap::Allele)
int& Haplotype::VoteInfo::weight(Allele allele) {
	if (allele == Allele::REF) {
		return this->ref_w;
	} else if (allele == Allele::ALT) {
		return this->alt_w;
	}
	throw "weight: Invalid allele value";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpb $0x0, -0x11(%rbp)
jne 0x11a4e
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x11a8b
cmpb $0x1, -0x11(%rbp)
jne 0x11a62
movq -0x20(%rbp), %rax
addq $0x14, %rax
movq %rax, -0x8(%rbp)
jmp 0x11a8b
jmp 0x11a64
movl $0x8, %edi
callq 0x2100
movq %rax, %rdi
leaq 0xad32(%rip), %rax      # 0x1c7aa
movq %rax, (%rdi)
movq 0x19536(%rip), %rsi     # 0x2afb8
xorl %eax, %eax
movl %eax, %edx
callq 0x23f0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/Haplotype.cpp
// Function: SAHap::operator<<(std::ostream&, SAHap::Haplotype&)
ostream & operator << (ostream& stream, Haplotype& ch) {
	stream << "ch[";
	stream << "m=" << ch.length << ", ";
	stream << "n=" << ch.reads.size() << ", ";
	stream << "mec=" << ch.mec() << "] ";
	for (dnapos_t i = 0; i < ch.size(); ++i) {
		stream << ch.solution[i];
	}
	return stream;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xad0c(%rip), %rsi      # 0x1c7c7
callq 0x2230
movq -0x8(%rbp), %rdi
leaq 0xad00(%rip), %rsi      # 0x1c7cb
callq 0x2230
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x2060
movq %rax, %rdi
leaq 0xaae4(%rip), %rsi      # 0x1c5ce
callq 0x2230
movq -0x8(%rbp), %rdi
leaq 0xacd4(%rip), %rsi      # 0x1c7ce
callq 0x2230
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
callq 0x12040
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x2060
movq %rax, %rdi
leaq 0xaaa8(%rip), %rsi      # 0x1c5ce
callq 0x2230
movq -0x8(%rbp), %rdi
leaq 0xac9b(%rip), %rsi      # 0x1c7d1
callq 0x2230
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x108a0
movq -0x20(%rbp), %rdi
callq 0x2460
movq %rax, %rdi
leaq 0xac7b(%rip), %rsi      # 0x1c7d6
callq 0x2230
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10860
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x11bb3
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6160
movq -0x38(%rbp), %rdi
movl (%rax), %esi
callq 0x2400
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x11b68
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/InputReader.cpp
// Function: SAHap::WIFInputReader::getPloidy(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
dnacnt_t WIFInputReader::getPloidy(string line) {
	int result = 0;
	istringstream iss(line);
	string buf;
	while (getline(iss, buf, ':')) {
		istringstream siss(buf);
		char a;
		siss >> a;
		if (a == '#') break;

		int throwaway;

		istringstream onesite(buf);
		onesite >> throwaway;

		onesite.ignore(256, ' ');
		onesite.ignore(256, ' ');

		int weight, value;
		onesite >> value >> weight;
		result = max(result,value);

	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x500, %rsp            # imm = 0x500
movq %rdi, %rsi
movq %rsi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq -0x190(%rbp), %rdi
movl $0x8, %edx
callq 0x23e0
leaq -0x1b0(%rbp), %rdi
callq 0x2300
leaq -0x190(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
movl $0x3a, %edx
callq 0x2450
movq %rax, -0x4e0(%rbp)
jmp 0x159c7
movq -0x4e0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x22c0
movb %al, -0x4e1(%rbp)
jmp 0x159e5
movb -0x4e1(%rbp), %al
testb $0x1, %al
jne 0x159f4
jmp 0x15b82
leaq -0x340(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
movl $0x8, %edx
callq 0x23e0
jmp 0x15a0e
leaq -0x340(%rbp), %rdi
leaq -0x341(%rbp), %rsi
callq 0x22e0
jmp 0x15a23
movsbl -0x341(%rbp), %eax
cmpl $0x23, %eax
jne 0x15a6c
movl $0x3, -0x348(%rbp)
jmp 0x15b37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x15bbf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x15b74
leaq -0x4d0(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
movl $0x8, %edx
callq 0x23e0
jmp 0x15a86
leaq -0x4d0(%rbp), %rdi
leaq -0x34c(%rbp), %rsi
callq 0x2140
jmp 0x15a9b
leaq -0x4d0(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x20, %edx
callq 0x2170
jmp 0x15ab3
leaq -0x4d0(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x20, %edx
callq 0x2170
jmp 0x15acb
leaq -0x4d0(%rbp), %rdi
leaq -0x4d8(%rbp), %rsi
callq 0x2140
movq %rax, -0x4f0(%rbp)
jmp 0x15ae7
movq -0x4f0(%rbp), %rdi
leaq -0x4d4(%rbp), %rsi
callq 0x2140
jmp 0x15afc
leaq -0xc(%rbp), %rdi
leaq -0x4d8(%rbp), %rsi
callq 0x16bd0
movq %rax, -0x4f8(%rbp)
jmp 0x15b15
movq -0x4f8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
leaq -0x4d0(%rbp), %rdi
callq 0x20f0
movl $0x0, -0x348(%rbp)
leaq -0x340(%rbp), %rdi
callq 0x20f0
movl -0x348(%rbp), %eax
testl %eax, %eax
je 0x15b51
jmp 0x15b4f
jmp 0x15b82
jmp 0x159a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x4d0(%rbp), %rdi
callq 0x20f0
leaq -0x340(%rbp), %rdi
callq 0x20f0
jmp 0x15bbf
movslq -0xc(%rbp), %rax
movq %rax, -0x500(%rbp)
movl $0x1, -0x348(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x2150
leaq -0x190(%rbp), %rdi
callq 0x20f0
movq -0x500(%rbp), %rax
addq $0x500, %rsp            # imm = 0x500
popq %rbp
retq
leaq -0x1b0(%rbp), %rdi
callq 0x2150
leaq -0x190(%rbp), %rdi
callq 0x20f0
movq -0x1b8(%rbp), %rdi
callq 0x2410
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/InputReader.cpp
// Function: SAHap::WIFInputReader::parseSNP(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Site WIFInputReader::parseSNP(string snp) {
	istringstream iss(snp);
	Site s;
	iss >> s.pos;

	iss.ignore(256, ' ');
	iss.ignore(256, ' ');

	int weight, value;
	iss >> value >> weight;

	if (s.weight <= 0 || s.weight > 100) {
	// 	s.weight = (double)weight/100;
	// } else 
		throw "Invalid weight value";
	}
	//s.weight = 1; // HACK
	s.value = value;
	// if (value == 0) {
	// 	s.value = Allele::REF;
	// } else if (value == 1) {
	// 	s.value = Allele::ALT;
	// } else {
	// 	cout << value << endl;
	// 	throw "Invalid allele value";
	// }
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x1b0(%rbp)
movq %rdi, -0x1b8(%rbp)
movq %rsi, -0x8(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
movl $0x8, %edx
callq 0x23e0
movq -0x1b0(%rbp), %rdi
callq 0x16a10
movq -0x1b0(%rbp), %rsi
movq -0x1a8(%rbp), %rdi
addq $0x8, %rsi
callq 0x2330
jmp 0x1645a
leaq -0x188(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x20, %edx
callq 0x2170
jmp 0x16472
leaq -0x188(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x20, %edx
callq 0x2170
jmp 0x1648a
leaq -0x188(%rbp), %rdi
leaq -0x19c(%rbp), %rsi
callq 0x2140
movq %rax, -0x1c0(%rbp)
jmp 0x164a6
movq -0x1c0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x2140
jmp 0x164bb
movq -0x1b0(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x164d5
movq -0x1b0(%rbp), %rax
cmpl $0x64, 0x10(%rax)
jle 0x1651e
movl $0x8, %edi
callq 0x2100
movq %rax, %rdi
leaq 0x6354(%rip), %rax      # 0x1c83d
movq %rax, (%rdi)
movq 0x14ac5(%rip), %rsi     # 0x2afb8
xorl %eax, %eax
movl %eax, %edx
callq 0x23f0
jmp 0x16555
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x20f0
jmp 0x16549
movq -0x1b0(%rbp), %rax
movl -0x19c(%rbp), %ecx
movl %ecx, (%rax)
leaq -0x188(%rbp), %rdi
callq 0x20f0
movq -0x1b8(%rbp), %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0x2410
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/utils.cpp
// Function: log_poisson_pmf
double log_poisson_pmf(double l, unsigned k) {
  double r = -l;

  for (auto i = k; i > 0; i--) {
    r += log(l/i);
  }

  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movsd -0x8(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jbe 0x1b948
movsd -0x8(%rbp), %xmm0
movl -0x1c(%rbp), %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
callq 0x21e0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1b917
movsd -0x18(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waynebhayes[P]SAHap/src/utils.cpp
// Function: log_poisson_1_cdf
double log_poisson_1_cdf(double l, unsigned k) {
#if 0
  if (log_poisson_1_cdf_l != l) {
    fill(log_poisson_1_cdf_memo, log_poisson_1_cdf_memo + 1000, 10);
    log_poisson_1_cdf_l = l;
  }

  if (k < 1000 && log_poisson_1_cdf_memo[k] < 0) {
    return log_poisson_1_cdf_memo[k];
  }
#endif
  // cout << "log_poisson_1_cdf(" << l << ", " << k << ")" << endl;

  assert(l>0);
  double pmax = 2, max = -1e30;
  for (unsigned i = k; pmax != max; ++i) {
    pmax = max;
    double logpmf = log_poisson_pmf(l, i);
    if (logpmf > max) {
      max = logpmf;
    }
  }

  double r = (max == 1 && k < l) ? 0 : max / .894;

  /*
  if (k < 1000) {
    log_poisson_1_cdf_memo[k] = r;
  }

  cout << "k = " << k << ", r = " << r << endl;
  */

  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movsd -0x8(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1b980
jmp 0x1b99f
leaq 0xf21(%rip), %rdi       # 0x1c8a8
leaq 0xf1e(%rip), %rsi       # 0x1c8ac
movl $0x43, %edx
leaq 0xf20(%rip), %rcx       # 0x1c8ba
callq 0x2180
movsd 0x741(%rip), %xmm0      # 0x1c0e8
movsd %xmm0, -0x18(%rbp)
movsd 0xee4(%rip), %xmm0      # 0x1c898
movsd %xmm0, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movsd -0x18(%rbp), %xmm0
ucomisd -0x20(%rbp), %xmm0
jne 0x1b9cf
jp 0x1b9cf
jmp 0x1ba0e
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movl -0x24(%rbp), %edi
callq 0x1b8e0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0x1ba01
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x1ba03
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1b9bf
movsd -0x20(%rbp), %xmm0
movsd 0x625(%rip), %xmm1      # 0x1c040
ucomisd %xmm1, %xmm0
jne 0x1ba40
jp 0x1ba40
movl -0xc(%rbp), %eax
cvtsi2sd %rax, %xmm1
movsd -0x8(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1ba40
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x1ba56
movsd -0x20(%rbp), %xmm0
movsd 0xe53(%rip), %xmm1      # 0x1c8a0
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/miniupnp[P]hfsplustools/src/hfspatchnoautofolder.c
// Function: writeu32
void writeu32(unsigned char * p, uint32_t i)
{
	p[0] = (i >> 24) & 0xff;
	p[1] = (i >> 16) & 0xff;
	p[2] = (i >> 8) & 0xff;
	p[3] = i & 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/miniupnp[P]hfsplustools/src/hfspatchnoautofolder.c
// Function: usage
void usage(const char * progname)
{
	fprintf(stderr, "usage: %s <command> <file.iso>\n", progname);
	fprintf(stderr, "commands :\n");
	fprintf(stderr, "  show : only display informations\n");
	fprintf(stderr, "  disable : disable autofolder\n");
	fprintf(stderr, "  setroot : set autofolder to root\n");
	fprintf(stderr, "  setfolderid <id> : set autofolder to id * USE WITH CARE *\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x5a15(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x2a9c(%rip), %rsi      # 0x408d
movb $0x0, %al
callq 0x10c0
movq 0x59f9(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x2aa4(%rip), %rsi      # 0x40ad
movb $0x0, %al
callq 0x10c0
movq 0x59e1(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x2a98(%rip), %rsi      # 0x40b9
movb $0x0, %al
callq 0x10c0
movq 0x59c9(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x2aa4(%rip), %rsi      # 0x40dd
movb $0x0, %al
callq 0x10c0
movq 0x59b1(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x2aac(%rip), %rsi      # 0x40fd
movb $0x0, %al
callq 0x10c0
movq 0x5999(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x2ab8(%rip), %rsi      # 0x4121
movb $0x0, %al
callq 0x10c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/miniupnp[P]hfsplustools/src/hfscommon.c
// Function: hexdump
void hexdump(const unsigned char * p, unsigned int n, unsigned int a)
{
	unsigned int i, j;

	while (n > 0) {
		i = (n >= 16) ? 16 : n;
		printf("%08x: ", a);
		for (j = 0; j < i; j++) {
			printf("%02x ", (unsigned)p[j]);
		}
		for (; j < 16; j++)
			printf("   ");
		printf ("| ");
		for (j = 0; j < i; j++) {
			if (isgraph(p[j]))
				putchar(p[j]);
			else
				putchar(' ');
		}
		putchar('\n');
		n -= i;
		p += i;
		a += i;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jbe 0x1aaa
cmpl $0x10, -0xc(%rbp)
jb 0x199c
movl $0x10, %eax
movl %eax, -0x1c(%rbp)
jmp 0x19a2
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %esi
leaq 0x2887(%rip), %rdi      # 0x4239
movb $0x0, %al
callq 0x1080
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x19ec
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movzbl (%rax,%rcx), %esi
leaq 0x2866(%rip), %rdi      # 0x4240
movb $0x0, %al
callq 0x1080
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x19c0
jmp 0x19ee
cmpl $0x10, -0x18(%rbp)
jae 0x1a0d
leaq 0x2d65(%rip), %rdi      # 0x4760
movb $0x0, %al
callq 0x1080
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x19ee
leaq 0x2832(%rip), %rdi      # 0x4246
movb $0x0, %al
callq 0x1080
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x1a77
callq 0x1140
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl -0x18(%rbp), %edx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x1a60
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movzbl (%rax,%rcx), %edi
callq 0x1040
jmp 0x1a6a
movl $0x20, %edi
callq 0x1040
jmp 0x1a6c
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1a22
movl $0xa, %edi
callq 0x1040
movl -0x14(%rbp), %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x1982
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/miniupnp[P]hfsplustools/src/hfscommon.c
// Function: print_hfs_uni
static void print_hfs_uni(const unsigned char * p)
{
	uint16_t len;
	len = readu16(p);
	p += 2;
	putchar('"');
	while(len > 0) {
		if(p[0] || p[1] < 32) {
			printf("\\u%02x%02x", p[0], p[1]);
		} else {
			putchar(p[1]);
		}
		p += 2;
		len--;
	}
	putchar('"');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ab0
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movl $0x22, %edi
callq 0x1040
movzwl -0xa(%rbp), %eax
cmpl $0x0, %eax
jle 0x2867
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2821
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x20, %eax
jge 0x2840
movq -0x8(%rbp), %rax
movzbl (%rax), %esi
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %edx
leaq 0x2251(%rip), %rdi      # 0x4a88
movb $0x0, %al
callq 0x1080
jmp 0x284d
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %edi
callq 0x1040
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movw -0xa(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0xa(%rbp)
jmp 0x27ff
movl $0x22, %edi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/miniupnp[P]hfsplustools/src/hfscommon.c
// Function: load_catalog
unsigned char * load_catalog(FILE * f)
{
	unsigned char * catalog;
	int offset;
	if(block_size == 0) {
		fprintf(stderr, "block_size==0 !\n");
		return 0;
	}
	if(catalog_start_block == 0) {
		fprintf(stderr, "catalog_start_block == 0 !\n");
		return 0;
	}
	if(catalog_block_count == 0) {
		fprintf(stderr, "catalog_block_count == 0 !\n");
		return 0;
	}
	offset = hfs_part_sector * SECTOR_SIZE;
	offset += block_size * catalog_start_block;
	if(fseek(f, offset, SEEK_SET) != 0) {
		perror("fseek");
		return 0;
	}
	catalog = malloc(catalog_block_count * block_size);
	if(!catalog) {
		fprintf(stderr, "memory allocation error\n");
		return 0;
	}
	if(fread(catalog, block_size, catalog_block_count, f) != catalog_block_count) {
		fprintf(stderr, "failed to read catalog file\n");
		free(catalog);
		return 0;
	}
	printf("%u bytes in catalog\n", catalog_block_count * block_size);
	return catalog;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpl $0x0, 0x3ea1(%rip)      # 0x70c4
jne 0x324a
movq 0x3dcc(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x15c9(%rip), %rsi      # 0x47ff
movb $0x0, %al
callq 0x10c0
movq $0x0, -0x8(%rbp)
jmp 0x33ab
cmpl $0x0, 0x3e77(%rip)      # 0x70c8
jne 0x3278
movq 0x3d9e(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x15ac(%rip), %rsi      # 0x4810
movb $0x0, %al
callq 0x10c0
movq $0x0, -0x8(%rbp)
jmp 0x33ab
cmpl $0x0, 0x3e4d(%rip)      # 0x70cc
jne 0x32a6
movq 0x3d70(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x159a(%rip), %rsi      # 0x482c
movb $0x0, %al
callq 0x10c0
movq $0x0, -0x8(%rbp)
jmp 0x33ab
movl 0x3e10(%rip), %eax      # 0x70bc
shll $0x9, %eax
movl %eax, -0x1c(%rbp)
movl 0x3e0c(%rip), %eax      # 0x70c4
imull 0x3e09(%rip), %eax      # 0x70c8
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
xorl %edx, %edx
callq 0x10f0
cmpl $0x0, %eax
je 0x32f2
leaq 0xd24(%rip), %rdi       # 0x4004
callq 0x1110
movq $0x0, -0x8(%rbp)
jmp 0x33ab
movl 0x3dd4(%rip), %eax      # 0x70cc
imull 0x3dc5(%rip), %eax      # 0x70c4
movl %eax, %eax
movl %eax, %edi
callq 0x10d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3335
movq 0x3cde(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x1524(%rip), %rsi      # 0x4848
movb $0x0, %al
callq 0x10c0
movq $0x0, -0x8(%rbp)
jmp 0x33ab
movq -0x18(%rbp), %rdi
movl 0x3d85(%rip), %eax      # 0x70c4
movl %eax, %esi
movl 0x3d85(%rip), %eax      # 0x70cc
movl %eax, %edx
movq -0x10(%rbp), %rcx
callq 0x1060
movl 0x3d74(%rip), %ecx      # 0x70cc
cmpq %rcx, %rax
je 0x3388
movq 0x3c94(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x14f3(%rip), %rsi      # 0x4861
movb $0x0, %al
callq 0x10c0
movq -0x18(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x33ab
movl 0x3d3e(%rip), %esi      # 0x70cc
imull 0x3d2f(%rip), %esi      # 0x70c4
leaq 0x14e2(%rip), %rdi      # 0x487e
movb $0x0, %al
callq 0x1080
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)