LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
leaq 0x70(%rdi), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x7c26
testq %rax, %rax
je 0x6aa2
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7b24
movq (%r15), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x69f8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x951f(%rip), %rdi      # 0xffc8
leaq 0x3c4a(%rip), %rsi      # 0xa6fa
callq 0x2230
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
pushq $0x8
popq %rdi
callq 0x2100
leaq 0x3c34(%rip), %rcx      # 0xa70d
movq %rcx, (%rax)
movq 0x94d5(%rip), %rsi      # 0xffb8
movq %rax, %rdi
xorl %edx, %edx
callq 0x23e0
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x1390, %rsp           # imm = 0x1390
movq %rdi, %rbx
pushq $0x1
popq %rdi
callq 0x9a76
movq %rax, %r14
movq 0x94b9(%rip), %rdi      # 0xffc8
leaq 0x3c17(%rip), %rsi      # 0xa72d
callq 0x2230
movq %rax, %rdi
movq %r14, %rsi
callq 0x2220
movq %rax, %rdi
callq 0x20f0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5a98
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6b56
addq $0x1390, %rsp           # imm = 0x1390
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/waynebhayes[P]SAHap/src/Haplotype.cpp
// Function: SAHap::Haplotype::subtractMECValuesAt(unsigned long)
void Haplotype::subtractMECValuesAt(dnapos_t pos) {
	for (unsigned i = 0; i < ploidyCount; i++) {
		if ((int)i == solution[pos])
			continue;
		auto mec = weights[pos][i];
		total_mec -= mec;
		assert(total_mec>=0);

		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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
imulq $0x18, %rsi, %r12
xorpd %xmm2, %xmm2
movl 0x68(%r14), %eax
cmpq %rax, %r15
jae 0x6c9d
movq (%r14), %rax
movl (%rax,%rbx,4), %eax
cmpq %rax, %r15
je 0x6c95
movq 0x20(%r14), %rax
movq (%rax,%r12), %rax
movl (%rax,%r15,4), %edi
cvtsi2sd %edi, %xmm1
movsd 0x50(%r14), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x50(%r14)
ucomisd %xmm2, %xmm0
jb 0x6ca9
movsd 0x58(%r14), %xmm0
cmpq %rbx, 0xe0(%r14)
ja 0x6c2d
cmpq %rbx, 0xe8(%r14)
jb 0x6c2d
subsd %xmm1, %xmm0
movsd %xmm0, 0x58(%r14)
ucomisd %xmm0, %xmm2
jbe 0x6c44
ucomisd 0x3a05(%rip), %xmm0     # 0xa640
jbe 0x6c44
andq $0x0, 0x58(%r14)
jmp 0x6c4a
ucomisd %xmm2, %xmm0
jb 0x6cc8
movq 0x38(%r14), %rax
movq (%rax,%r15,8), %rax
testq %rax, %rax
je 0x6c95
movq %rax, %xmm1
punpckldq 0x33bc(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x33c4(%rip), %xmm1     # 0xa030
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x3440(%rip), %xmm0     # 0xa0c0
callq 0x99be
xorpd %xmm2, %xmm2
addsd 0x60(%r14), %xmm0
movsd %xmm0, 0x60(%r14)
incq %r15
jmp 0x6bc5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3a8d(%rip), %rdi      # 0xa73d
leaq 0x3996(%rip), %rsi      # 0xa64d
leaq 0x3a8c(%rip), %rcx      # 0xa74a
movl $0xdd, %edx
callq 0x2180
leaq 0x39d8(%rip), %rdi      # 0xa6a7
leaq 0x3977(%rip), %rsi      # 0xa64d
leaq 0x3a6d(%rip), %rcx      # 0xa74a
movl $0xe2, %edx
callq 0x2180
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
imulq $0x18, %rsi, %r12
xorpd %xmm2, %xmm2
movl 0x68(%r14), %eax
cmpq %rax, %r15
jae 0x6dd3
movq (%r14), %rax
movl (%rax,%rbx,4), %eax
cmpq %rax, %r15
je 0x6dcb
movq 0x20(%r14), %rax
movq (%rax,%r12), %rax
movl (%rax,%r15,4), %edi
cvtsi2sd %edi, %xmm1
movsd 0x50(%r14), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x50(%r14)
movsd 0x58(%r14), %xmm0
cmpq %rbx, 0xe0(%r14)
ja 0x6d5f
cmpq %rbx, 0xe8(%r14)
jb 0x6d5f
addsd %xmm1, %xmm0
movsd %xmm0, 0x58(%r14)
ucomisd %xmm0, %xmm2
jbe 0x6d76
ucomisd 0x38d3(%rip), %xmm0     # 0xa640
jbe 0x6d76
andq $0x0, 0x58(%r14)
jmp 0x6d7c
ucomisd %xmm2, %xmm0
jb 0x6ddf
movq 0x38(%r14), %rax
movq (%rax,%r15,8), %rax
testq %rax, %rax
je 0x6dcb
movq %rax, %xmm1
punpckldq 0x328a(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x3292(%rip), %xmm1     # 0xa030
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x330e(%rip), %xmm0     # 0xa0c0
callq 0x99be
xorpd %xmm2, %xmm2
movsd 0x60(%r14), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x60(%r14)
incq %r15
jmp 0x6d01
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x38c1(%rip), %rdi      # 0xa6a7
leaq 0x3860(%rip), %rsi      # 0xa64d
leaq 0x398b(%rip), %rcx      # 0xa77f
movl $0xf2, %edx
callq 0x2180
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0x10(%rsi), %ecx
movq 0x8(%rsi), %rax
movq 0x20(%rdi), %rdx
imulq $0x18, %rax, %r8
movslq (%rsi), %r9
movq (%rdx,%r8), %r8
addl %ecx, (%r8,%r9,4)
movl (%rsi), %ecx
movq (%rdi), %rdx
movslq (%rdx,%rax,4), %rsi
cmpl %esi, %ecx
je 0x6e35
movslq %ecx, %r9
movl (%r8,%r9,4), %r9d
cmpl (%r8,%rsi,4), %r9d
jle 0x6e35
movl %ecx, (%rdx,%rax,4)
movq 0x38(%rdi), %rcx
incq (%rcx,%rax,8)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x10(%rsi), %eax
movq 0x8(%rsi), %rsi
movq 0x20(%rdi), %rcx
imulq $0x18, %rsi, %rdx
movslq (%r14), %rdi
movq (%rcx,%rdx), %rcx
subl %eax, (%rcx,%rdi,4)
movq (%rbx), %rax
movl (%rax,%rsi,4), %eax
cmpl (%r14), %eax
jne 0x6e78
movq %rbx, %rdi
callq 0x6e88
movq 0x8(%r14), %rsi
movq 0x38(%rbx), %rax
decq (%rax,%rsi,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38ac(%rip), %rsi      # 0xa7e7
callq 0x2230
leaq 0x38a4(%rip), %rsi      # 0xa7eb
movq %rbx, %rdi
callq 0x2230
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x2190
leaq 0x368a(%rip), %r15      # 0xa5ec
movq %rax, %rdi
movq %r15, %rsi
callq 0x2230
leaq 0x387a(%rip), %rsi      # 0xa7ee
movq %rbx, %rdi
callq 0x2230
movq 0x88(%r14), %rsi
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
movq %r15, %rsi
callq 0x2230
leaq 0x3854(%rip), %rsi      # 0xa7f1
movq %rbx, %rdi
callq 0x2230
movsd 0x50(%r14), %xmm0
movq %rax, %rdi
callq 0x23a0
leaq 0x383c(%rip), %rsi      # 0xa7f6
movq %rax, %rdi
callq 0x2230
xorl %r15d, %r15d
cmpq 0x18(%r14), %r15
jae 0x6fdf
movq (%r14), %rax
movl (%rax,%r15,4), %esi
movq %rbx, %rdi
callq 0x23f0
incq %r15
jmp 0x6fc5
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/waynebhayes[P]SAHap/src/InputReader.cpp
// Function: SAHap::WIFInputReader::read(std::basic_ifstream<char, std::char_traits<char>>&)
InputFile WIFInputReader::read(ifstream& file) {
	InputFile result;
	string buf;

	dnacnt_t totalReadLength = 0;
	
	result.ploidy = 0;
	while (!file.eof()) {
		
		getline(file, buf);
		result.ploidy = max(WIFInputReader::getPloidy(buf)+1,result.ploidy);

		
		if (buf.size() == 0 || buf.find("#") == 0) continue;

		Read read = WIFInputReader::parseRead(result.index, buf);
		if (read.range.end - read.range.start < 1)
			continue;
		result.reads.push_back(read);
		totalReadLength += read.range.end - read.range.start + 1;
	}
	result.averageReadLength = totalReadLength / result.reads.size();

	// std::cout << "Total: " << totalReadLength << std::endl;
	// std::cout << "Average Read Length: " << result.averageReadLength << std::endl;
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rdi), %rax
movq %rax, 0x8(%rdi)
movq $0x1, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movl $0x3f800000, 0x28(%rdi) # imm = 0x3F800000
addq $0x30, %rdi
movq $0x0, (%rsp)
movl $0x82, %edx
xorl %esi, %esi
callq 0x2140
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
andq $0x0, (%rbx)
movb $0x0, (%rax)
leaq 0x58(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rbp
leaq 0x88(%rsp), %r13
leaq 0x2b2d(%rip), %r12      # 0xa7f9
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r15,%rax)
jne 0x7d98
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2050
movq %r13, %rdi
movq %rbp, %rsi
callq 0x22e0
movq %r13, %rdi
callq 0x7e26
incq %rax
movq (%rbx), %rcx
cmpq %rcx, %rax
cmovbeq %rcx, %rax
movq %rax, (%rbx)
movq %r13, %rdi
callq 0x20d0
cmpq $0x0, 0x50(%rsp)
je 0x7ccc
movq %rbp, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x2430
testq %rax, %rax
je 0x7ccc
leaq 0x68(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
callq 0x22e0
leaq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x7fa8
movq %r14, %rdi
callq 0x20d0
movq 0x40(%rsp), %rax
cmpq 0x38(%rsp), %rax
je 0x7d89
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x8488
movq (%rsp), %rax
addq 0x40(%rsp), %rax
subq 0x38(%rsp), %rax
incq %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x5a48
jmp 0x7ccc
movq 0x60(%rbx), %rax
subq 0x58(%rbx), %rax
pushq $0x30
popq %rcx
cqto
idivq %rcx
movq %rax, %rcx
movq (%rsp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, 0xa8(%rbx)
leaq 0x48(%rsp), %rdi
callq 0x20d0
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x5a48
jmp 0x7e0c
movq %rax, %r14
leaq 0x68(%rsp), %rdi
jmp 0x7e07
jmp 0x7df7
jmp 0x7df7
movq %rax, %r14
jmp 0x7e0c
movq %rax, %r14
leaq 0x88(%rsp), %rdi
callq 0x20d0
leaq 0x48(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x475e
movq %r14, %rdi
callq 0x2400
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4b8, %rsp            # imm = 0x4B8
movq %rdi, %rsi
leaq 0x38(%rsp), %rdi
pushq $0x8
popq %rbp
movl %ebp, %edx
callq 0x23d0
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %r15d, %r15d
leaq 0x18(%rsp), %r14
leaq 0x338(%rsp), %r12
leaq 0x1b8(%rsp), %rbx
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
pushq $0x3a
popq %rdx
callq 0x2420
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x7f32
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x23d0
movq %r12, %rdi
leaq 0xb(%rsp), %rsi
callq 0x22c0
movb 0xb(%rsp), %r13b
cmpb $0x23, %r13b
je 0x7f20
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x23d0
movq %rbx, %rdi
leaq 0x14(%rsp), %rsi
callq 0x2150
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
pushq $0x20
popq %rdx
callq 0x2170
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
pushq $0x20
popq %rdx
callq 0x2170
movq %rbx, %rdi
leaq 0xc(%rsp), %rsi
callq 0x2150
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0x2150
movl 0xc(%rsp), %eax
cmpl %eax, %r15d
cmovlel %eax, %r15d
movq %rbx, %rdi
callq 0x20e0
movq %r12, %rdi
callq 0x20e0
cmpb $0x23, %r13b
jne 0x7e72
movl %r15d, %ebx
leaq 0x18(%rsp), %rdi
callq 0x20d0
leaq 0x38(%rsp), %rdi
callq 0x20e0
movq %rbx, %rax
addq $0x4b8, %rsp            # imm = 0x4B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7f62
jmp 0x7f6e
movq %rax, %rbx
jmp 0x7f7e
jmp 0x7f69
movq %rax, %rbx
jmp 0x7f8b
movq %rax, %rbx
leaq 0x1b8(%rsp), %rdi
callq 0x20e0
leaq 0x338(%rsp), %rdi
callq 0x20e0
leaq 0x18(%rsp), %rdi
callq 0x20d0
leaq 0x38(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2400
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x23d0
orl $-0x1, (%rbx)
movl $0x1, 0x10(%rbx)
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x2130
leaq 0x8(%rsp), %rdi
pushq $0x20
popq %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x2170
leaq 0x8(%rsp), %rdi
pushq $0x20
popq %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x2170
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x2150
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x2150
movl 0x10(%rbx), %eax
addl $-0x65, %eax
cmpl $-0x65, %eax
jbe 0x844d
movl (%rsp), %eax
movl %eax, (%rbx)
leaq 0x8(%rsp), %rdi
callq 0x20e0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
pushq $0x8
popq %rdi
callq 0x2100
leaq 0x2401(%rip), %rcx      # 0xa85d
movq %rcx, (%rax)
movq 0x7b52(%rip), %rsi      # 0xffb8
movq %rax, %rdi
xorl %edx, %edx
callq 0x23e0
jmp 0x8472
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2400
nop
// File: /workspace/github_c_makefile_star2_O2/waynebhayes[P]SAHap/src/main.cpp
// Function: main
int main(int argc, char *argv[]) {

	if (argc < 2 || argc > 4) {
		cerr << "Usage: " << argv[0] << " <reads> [gt] [millions of iterations = 10]" << endl;
		return 1;
	}

	ifstream file;
	file.open(argv[1]);
	auto parsed = WIFInputReader::read(file); 

	if (argc > 3) {
		ifstream gtruth;
		gtruth.open(argv[2]);

		WIFInputReader::readGroundTruth(gtruth, parsed);
	}




	iteration_t iterations = argc == 4 ?  atoi(argv[3]) * META_ITER : 10 * META_ITER;
	
	try {
		Genome ge(parsed);
		ge.autoSchedule(iterations);
			try {
				ge.optimize(true);
				cout << ge;
			} catch (const char * e) {
				cerr << e << endl;
			}

	} catch (const char* e) {
		cout << e << endl;
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x3fc0, %rsp           # imm = 0x3FC0
movq %rsi, %rbx
movl %edi, %r15d
leal -0x5(%r15), %eax
cmpl $-0x4, %eax
ja 0x9448
movq 0x6bde(%rip), %rdi      # 0xfff0
leaq 0x146a(%rip), %rsi      # 0xa883
callq 0x2230
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x2230
leaq 0x145b(%rip), %rsi      # 0xa88b
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x20f0
pushq $0x1
popq %rax
jmp 0x955d
leaq 0x170(%rsp), %r14
movq %r14, %rdi
callq 0x2270
movq 0x8(%rbx), %rsi
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2160
movq %rsp, %rdi
leaq 0x170(%rsp), %rsi
callq 0x7c44
movl $0x186a0, %r14d         # imm = 0x186A0
cmpl $0x4, %r15d
jb 0x94d3
leaq 0x378(%rsp), %rdi
callq 0x2270
movq 0x10(%rbx), %rsi
leaq 0x378(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x2160
leaq 0x378(%rsp), %rdi
movq %rsp, %rsi
callq 0x8186
leaq 0x378(%rsp), %rdi
callq 0x2060
movq 0x18(%rbx), %rdi
callq 0x2380
imull $0x2710, %eax, %eax     # imm = 0x2710
movslq %eax, %r14
leaq 0xb8(%rsp), %rdi
movq %rsp, %rsi
callq 0x965a
leaq 0x378(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x2658
leaq 0xb8(%rsp), %rdi
callq 0x475e
leaq 0x378(%rsp), %rdi
movq %r14, %rsi
callq 0x434c
leaq 0x378(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x3350
movq 0x6a9c(%rip), %rdi      # 0xffc8
leaq 0x378(%rsp), %rsi
callq 0x453d
leaq 0x378(%rsp), %rdi
callq 0x29ee
movq %rsp, %rdi
callq 0x475e
leaq 0x170(%rsp), %rdi
callq 0x2060
xorl %eax, %eax
addq $0x3fc0, %rsp           # imm = 0x3FC0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x95ad
movq %rdx, %r14
movq %rax, %rbx
jmp 0x9611
movq %rdx, %r14
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x475e
jmp 0x961e
movq %rdx, %r14
movq %rax, %rbx
jmp 0x961e
movq %rax, %rbx
leaq 0x378(%rsp), %rdi
callq 0x2060
movq %rsp, %rdi
callq 0x475e
jmp 0x95bc
jmp 0x95b9
movq %rax, %rbx
leaq 0x170(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2400
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x9611
movq %rbx, %rdi
callq 0x20c0
movq 0x6a04(%rip), %rdi      # 0xfff0
movq %rax, %rsi
callq 0x2230
movq %rax, %rdi
callq 0x20f0
callq 0x23c0
jmp 0x9539
movq %rdx, %r14
movq %rax, %rbx
callq 0x23c0
leaq 0x378(%rsp), %rdi
callq 0x29ee
cmpl $0x1, %r14d
jne 0x95ad
movq %rbx, %rdi
callq 0x20c0
movq 0x6995(%rip), %rdi      # 0xffc8
movq %rax, %rsi
callq 0x2230
movq %rax, %rdi
callq 0x20f0
callq 0x23c0
jmp 0x9546
movq %rax, %rbx
callq 0x23c0
jmp 0x95ad
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movapd %xmm0, %xmm1
movapd 0x6cb(%rip), %xmm0      # 0xa040
movapd %xmm1, 0x10(%rsp)
xorpd %xmm1, %xmm0
movl %edi, %ebx
subl $0x1, %ebx
jb 0x99b8
movl %edi, %eax
cvtsi2sd %rax, %xmm1
movapd %xmm0, (%rsp)
movapd 0x10(%rsp), %xmm0
divsd %xmm1, %xmm0
callq 0x21e0
movapd (%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
movapd (%rsp), %xmm0
movl %ebx, %edi
jmp 0x9981
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
subq $0x28, %rsp
xorpd %xmm1, %xmm1
movsd %xmm0, 0x8(%rsp)
ucomisd %xmm1, %xmm0
jbe 0x9a4f
movl %edi, %ebx
movsd 0xeda(%rip), %xmm1      # 0xa8b8
movsd 0xeda(%rip), %xmm0      # 0xa8c0
movl %edi, %ebp
movapd %xmm0, %xmm2
ucomisd %xmm0, %xmm1
jne 0x99f4
jnp 0x9a15
movsd 0x8(%rsp), %xmm0
movl %ebp, %edi
movapd %xmm2, 0x10(%rsp)
callq 0x9964
movapd 0x10(%rsp), %xmm1
maxsd %xmm1, %xmm0
incl %ebp
jmp 0x99e8
movl %ebx, %eax
cvtsi2sd %rax, %xmm0
movapd %xmm2, %xmm1
divsd 0xea0(%rip), %xmm1      # 0xa8c8
cmpeqsd 0x67f(%rip), %xmm2      # 0xa0b0
andnpd %xmm1, %xmm2
cmpltsd 0x8(%rsp), %xmm0
andpd %xmm0, %xmm2
andnpd %xmm1, %xmm0
orpd %xmm2, %xmm0
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0xe7a(%rip), %rdi       # 0xa8d0
leaq 0xe77(%rip), %rsi       # 0xa8d4
leaq 0xe7e(%rip), %rcx       # 0xa8e2
pushq $0x43
popq %rdx
callq 0x2180
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rdx
movq 0x4b17(%rip), %r15      # 0x5ff8
movq (%r15), %rdi
leaq 0x1b6e(%rip), %rsi      # 0x3059
xorl %eax, %eax
callq 0x10c0
movq (%r15), %rcx
leaq 0x1b7d(%rip), %rdi      # 0x3079
pushq $0xb
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x1140
movq (%r15), %rcx
leaq 0x1b71(%rip), %rdi      # 0x3085
pushq $0x23
popq %r14
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1140
movq (%r15), %rcx
leaq 0x1b7c(%rip), %rdi      # 0x30a9
pushq $0x1f
popq %rsi
movq %rbx, %rdx
callq 0x1140
movq (%r15), %rcx
leaq 0x1b87(%rip), %rdi      # 0x30c9
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1140
movq (%r15), %rcx
leaq 0x1b96(%rip), %rdi      # 0x30ed
pushq $0x3c
popq %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1140
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x1f18(%rip), %r15      # 0x36c9
leaq 0x1a84(%rip), %r12      # 0x323c
testl %esi, %esi
je 0x1870
pushq $0x10
popq %r13
cmpl %r13d, %esi
movl %r13d, %ebp
movl %esi, (%rsp)
cmovbl %esi, %ebp
leaq 0x1a5e(%rip), %rdi      # 0x3235
movl %edx, 0x4(%rsp)
movl %edx, %esi
xorl %eax, %eax
callq 0x1090
movl %ebp, %eax
addl %ebp, %eax
subl %eax, %r13d
xorl %ebx, %ebx
cmpq %rbx, %rbp
je 0x1813
movzbl (%r14,%rbx), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x1090
incq %rbx
incl %r13d
jmp 0x17ed
movq %r15, %rdi
xorl %eax, %eax
callq 0x1090
subl $0x1, %r13d
jae 0x1809
leaq 0x1a22(%rip), %rdi      # 0x3242
xorl %eax, %eax
callq 0x1090
callq 0x1150
movq %rax, %r13
xorl %ebx, %ebx
cmpq %rbx, %rbp
je 0x1855
movq (%r13), %rcx
movzbl (%r14,%rbx), %eax
cmpw $0x0, (%rcx,%rax,2)
pushq $0x20
popq %rdi
jns 0x184b
movl %eax, %edi
callq 0x1040
incq %rbx
jmp 0x1831
pushq $0xa
popq %rdi
callq 0x1040
movl (%rsp), %esi
subl %ebp, %esi
addq %rbp, %r14
movl 0x4(%rsp), %edx
addl %ebp, %edx
jmp 0x17b8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movzwl (%rdi), %ebp
pushq $0x22
popq %rdi
callq 0x1040
rolw $0x8, %bp
movzwl %bp, %r15d
leaq 0x1737(%rip), %r14      # 0x394c
xorl %r12d, %r12d
cmpw %r12w, %r15w
je 0x2256
movzbl 0x2(%rbx,%r12,2), %esi
testl %esi, %esi
setne %al
movb 0x3(%rbx,%r12,2), %cl
movzbl %cl, %edx
cmpb $0x20, %dl
setb %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x224a
movq %r14, %rdi
xorl %eax, %eax
callq 0x1090
jmp 0x2251
movl %edx, %edi
callq 0x1040
incq %r12
jmp 0x2218
pushq $0x22
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x38bb(%rip), %eax      # 0x60cc
testl %eax, %eax
je 0x28b4
movl 0x38b1(%rip), %ecx      # 0x60d0
testl %ecx, %ecx
je 0x28c9
cmpl $0x0, 0x38a6(%rip)      # 0x60d4
je 0x28dc
movq %rdi, %r14
movl 0x3887(%rip), %edx      # 0x60c4
shll $0x9, %edx
imull %eax, %ecx
addl %edx, %ecx
movslq %ecx, %rsi
xorl %edx, %edx
callq 0x1100
testl %eax, %eax
jne 0x28f1
movl 0x3876(%rip), %r15d     # 0x60d4
movl 0x3867(%rip), %r12d     # 0x60cc
movl %r12d, %edi
imull %r15d, %edi
callq 0x10d0
testq %rax, %rax
je 0x28ff
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1070
movl 0x3840(%rip), %esi      # 0x60d4
cmpq %rsi, %rax
jne 0x292c
imull 0x3828(%rip), %esi      # 0x60cc
leaq 0xf3c(%rip), %rdi       # 0x37e7
xorl %eax, %eax
callq 0x1090
jmp 0x291d
movq 0x373d(%rip), %rax      # 0x5ff8
movq (%rax), %rcx
leaq 0xea3(%rip), %rdi       # 0x3768
pushq $0x10
jmp 0x2912
movq 0x3728(%rip), %rax      # 0x5ff8
movq (%rax), %rcx
leaq 0xe9f(%rip), %rdi       # 0x3779
jmp 0x28ed
movq 0x3715(%rip), %rax      # 0x5ff8
movq (%rax), %rcx
leaq 0xea8(%rip), %rdi       # 0x3795
pushq $0x1b
jmp 0x2912
leaq 0x70c(%rip), %rdi       # 0x3004
callq 0x1120
jmp 0x291b
movq 0x36f2(%rip), %rax      # 0x5ff8
movq (%rax), %rcx
leaq 0xea1(%rip), %rdi       # 0x37b1
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
callq 0x1140
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x36c5(%rip), %rax      # 0x5ff8
movq (%rax), %rcx
leaq 0xe8d(%rip), %rdi       # 0x37ca
pushq $0x1c
popq %rsi
pushq $0x1
popq %rdx
callq 0x1140
movq %rbx, %rdi
callq 0x1030
jmp 0x291b
// File: /workspace/github_c_makefile_star2_O2/miniupnp[P]hfsplustools/src/hfscommon.c
// Function: save_catalog
int save_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;
	}
	if(fwrite(catalog, block_size, catalog_block_count, f) != catalog_block_count) {
		fprintf(stderr, "failed to write to file\n");
		return 0;
	}
	if(fflush(f) != 0) {
		perror("fflush");
		return 0;
	}
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x376f(%rip), %eax      # 0x60cc
testl %eax, %eax
je 0x29dd
movl 0x3769(%rip), %ecx      # 0x60d0
testl %ecx, %ecx
je 0x29f2
cmpl $0x0, 0x375e(%rip)      # 0x60d4
je 0x2a05
movq %rsi, %r15
movq %rdi, %r14
movl 0x373c(%rip), %edx      # 0x60c4
shll $0x9, %edx
imull %eax, %ecx
addl %edx, %ecx
movslq %ecx, %rsi
xorl %ebx, %ebx
xorl %edx, %edx
callq 0x1100
testl %eax, %eax
jne 0x2a25
movl 0x3722(%rip), %esi      # 0x60cc
movl 0x3724(%rip), %edx      # 0x60d4
movq %r15, %rdi
movq %r14, %rcx
callq 0x1140
movl 0x3713(%rip), %ecx      # 0x60d4
cmpq %rcx, %rax
jne 0x2a2e
movq %r14, %rdi
callq 0x10e0
testl %eax, %eax
jne 0x2a4c
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x3614(%rip), %rax      # 0x5ff8
movq (%rax), %rcx
leaq 0xd7a(%rip), %rdi       # 0x3768
pushq $0x10
jmp 0x2a18
movq 0x35ff(%rip), %rax      # 0x5ff8
movq (%rax), %rcx
leaq 0xd76(%rip), %rdi       # 0x3779
jmp 0x2a16
movq 0x35ec(%rip), %rax      # 0x5ff8
movq (%rax), %rcx
leaq 0xd7f(%rip), %rdi       # 0x3795
pushq $0x1b
popq %rsi
pushq $0x1
popq %rdx
callq 0x1140
xorl %ebx, %ebx
jmp 0x29d5
leaq 0x5d8(%rip), %rdi       # 0x3004
jmp 0x2a53
movq 0x35c3(%rip), %rax      # 0x5ff8
movq (%rax), %rcx
leaq 0xdbd(%rip), %rdi       # 0x37fc
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
callq 0x1140
jmp 0x29d5
leaq 0xdc2(%rip), %rdi       # 0x3815
callq 0x1120
jmp 0x29d5
// File: /workspace/github_c_makefile_star2_O2/miniupnp[P]hfsplustools/src/hfscommon.c
// Function: read_catalog
int read_catalog(FILE * f)
{
	unsigned char * catalog;
	uint32_t node;
	//struct find_infos infos;

	catalog = load_catalog(f);
	if(catalog == NULL)
		return 0;
	printf("Catalog Header Node :\n");
	if(!print_node(catalog)) {	/* header node */
		free(catalog);
		return 0;
	}
	printf("Catalog Root Node :\n");
	print_node(catalog + catalog_root_node * catalog_node_size);/* root node */
#if 0
	hfs_find(catalog, 1 /* root parent id */, NULL, &infos);
	printf("----\n");
	if(hfs_find(catalog, 2 /* root id */, "fichiers", &infos)) {
		printf("/fichiers found : id=%u\n", infos.folder_id);
		if(hfs_find(catalog, infos.folder_id, "MYRIADE_3E.app", &infos)) {
			printf("found ! flags=%04X\n", readu16(infos.p + 56));
			//found = 1;
		}
	}
#endif
	printf("Catalog Leaf Nodes :\n");
	for(node = catalog_first_leaf_node; node != 0; node = next_node(catalog, node)) {
		print_node(catalog + node * catalog_node_size);
	}
	free(catalog);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
callq 0x2803
xorl %ebp, %ebp
testq %rax, %rax
je 0x2b04
movq %rax, %rbx
leaq 0x10c5(%rip), %rdi      # 0x3b40
callq 0x1060
movq %rbx, %rdi
callq 0x1d7b
testl %eax, %eax
je 0x2afc
leaq 0x10c3(%rip), %rdi      # 0x3b56
callq 0x1060
movl 0x3646(%rip), %edi      # 0x60e4
imull 0x3633(%rip), %edi      # 0x60d8
addq %rbx, %rdi
callq 0x1d7b
leaq 0x10b6(%rip), %rdi      # 0x3b6a
callq 0x1060
movl 0x361c(%rip), %r14d     # 0x60dc
testl %r14d, %r14d
je 0x2aef
movl 0x3619(%rip), %edi      # 0x60e4
imull %r14d, %edi
addq %rbx, %rdi
callq 0x1d7b
imull 0x3605(%rip), %r14d     # 0x60e4
addq %rbx, %r14
movq %r14, %rdi
callq 0x188f
movl %eax, %r14d
jmp 0x2ac0
movq %rbx, %rdi
callq 0x1030
pushq $0x1
popq %rbp
jmp 0x2b04
movq %rbx, %rdi
callq 0x1030
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/miniupnp[P]hfsplustools/src/hfscommon.c
// Function: hfs_uni_to_str
static int hfs_uni_to_str(char * d, int n, const unsigned char * p)
{
	uint16_t len;
	int i, j;
	len = readu16(p);
	p += 2;
	for(i = 0, j = 0; i < len && j < (n - 1); i++) {
		if(p[0] || p[1] < 32) {
			j += snprintf(d + j, 7, "\\u%02x%02x", p[0], p[1]);
		} else {
			d[j++] = p[1];
		}
		p += 2;
	}
	d[j++] = '\0';
	return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzwl (%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %ebp
pushq $0x1
popq %r13
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq %r12d, %rdi
cmpl %ebp, %r15d
jae 0x2dfb
cmpl $0xfe, %r12d
jg 0x2dfb
movzbl 0x2(%r14,%r15,2), %ecx
testl %ecx, %ecx
setne %dl
movb 0x3(%r14,%r15,2), %al
cmpb $0x20, %al
setb %sil
orb %dl, %sil
addq %rbx, %rdi
cmpb $0x1, %sil
jne 0x2dee
movzbl %al, %r8d
pushq $0x7
popq %rsi
leaq 0xb67(%rip), %rdx       # 0x394c
xorl %eax, %eax
callq 0x10a0
jmp 0x2df3
movb %al, (%rdi)
movl %r13d, %eax
addl %eax, %r12d
incq %r15
jmp 0x2da4
movb $0x0, (%rbx,%rdi)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DASmap.c
// Function: init_file_iterator
File_Iterator *init_file_iterator(FILE *input)
{ File_Iterator *it;

  it = Malloc(sizeof(File_Iterator),"Allocating file iterator");
  it->input = input;
  it->lineno = 1;
  rewind(input);
  return (it);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7c4a(%rip), %rsi      # 0x9004
pushq $0x18
popq %rdi
callq 0x1bad
movq %rax, %r14
movq %rbx, (%rax)
movl $0x1, 0x8(%rax)
movq %rbx, %rdi
callq 0x1110
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DASmap.c
// Function: next_read
int next_read(File_Iterator *it)
{ static char nbuffer[MAX_BUFFER];

  char *eol;
  int   x;

  if (fgets(nbuffer,MAX_BUFFER,it->input) == NULL)
    { if (feof(it->input))
        return (1);
      SYSTEM_READ_ERROR;
    }
  if ((eol = index(nbuffer,'\n')) == NULL)
    { fprintf(stderr,"%s: Line %d in read list is longer than %d chars!\n",
                     Prog_Name,it->lineno,MAX_BUFFER-1);
      return (1);
    }
  *eol = '\0';
  x = sscanf(nbuffer," %d %d %d",&(it->read),&(it->beg),&(it->end));
  if (x == 1)
    it->beg = -1;
  else if (x != 3)
    { fprintf(stderr,"%s: Line %d of read list is improperly formatted\n",Prog_Name,it->lineno);
      return (1);
    }
  it->lineno += 1;
  return (0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdx
leaq 0xcddd(%rip), %rdi      # 0xe1d0
movl $0x2711, %esi           # imm = 0x2711
callq 0x1180
testq %rax, %rax
je 0x1452
leaq 0xcdc7(%rip), %rdi      # 0xe1d0
pushq $0xa
popq %rsi
callq 0x1140
testq %rax, %rax
je 0x1468
movb $0x0, (%rax)
leaq 0xc(%rbx), %rdx
leaq 0x10(%rbx), %r14
leaq 0x14(%rbx), %r8
leaq 0xcda4(%rip), %rdi      # 0xe1d0
leaq 0x7c3d(%rip), %rsi      # 0x9070
xorl %ebp, %ebp
movq %r14, %rcx
xorl %eax, %eax
callq 0x1200
cmpl $0x3, %eax
je 0x144d
cmpl $0x1, %eax
jne 0x1495
orl $-0x1, (%r14)
incl 0x8(%rbx)
jmp 0x1461
movq (%rbx), %rdi
callq 0x11b0
testl %eax, %eax
je 0x14bc
pushq $0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0xcb89(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0xf46f(%rip), %rax      # 0x108e8
movq (%rax), %rdx
movl 0x8(%rbx), %ecx
leaq 0x7bb7(%rip), %rsi      # 0x903d
movl $0x2710, %r8d           # imm = 0x2710
xorl %eax, %eax
callq 0x11a0
jmp 0x145e
movq 0xcb5c(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0xf442(%rip), %rax      # 0x108e8
movq (%rax), %rdx
movl 0x8(%rbx), %ecx
leaq 0x7bc7(%rip), %rsi      # 0x907a
xorl %eax, %eax
callq 0x11a0
jmp 0x145e
movq 0xcb35(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0xf41b(%rip), %rax      # 0x108e8
movq (%rax), %rdx
leaq 0x7b46(%rip), %rsi      # 0x901d
xorl %eax, %eax
callq 0x11a0
pushq $0x2
popq %rdi
callq 0x1270
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: Count_Args
int Count_Args(char *var)
{ int   cnt, lev;
  char *s;

  cnt = 1;
  lev = 0;
  for (s = var; *s != '\0'; s++)
    if (*s == ',')
      { if (lev == 0)
          cnt += 1;
      }
    else if (*s == '(')
      lev += 1;
    else if (*s == ')')
      lev -= 1;
  return (cnt);
}

// Assembly:
xorl %ecx, %ecx
pushq $0x1
popq %rax
movzbl (%rdi), %edx
cmpl $0x28, %edx
je 0x1b9d
cmpl $0x29, %edx
je 0x1b99
cmpl $0x2c, %edx
je 0x1ba1
testl %edx, %edx
jne 0x1ba7
jmp 0x1bac
decl %ecx
jmp 0x1ba7
incl %ecx
jmp 0x1ba7
cmpl $0x1, %ecx
adcl $0x0, %eax
incq %rdi
jmp 0x1b81
retq
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: Malloc
void *Malloc(int64 size, char *mesg)
{ void *p;

  if ((p = malloc(size)) == NULL)
    { if (mesg == NULL)
        EPRINTF(EPLACE,"%s: Out of memory\n",Prog_Name);
      else
        EPRINTF(EPLACE,"%s: Out of memory (%s)\n",Prog_Name,mesg);
    }
  return (p);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0x11f0
movq %rax, %rbx
testq %rax, %rax
je 0x1bcc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xc425(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0xed0b(%rip), %rdx      # 0x108e8
testq %r14, %r14
jne 0x1bf2
leaq 0x7667(%rip), %rsi      # 0x9250
xorl %eax, %eax
callq 0x11a0
jmp 0x1bc1
leaq 0x766a(%rip), %rsi      # 0x9263
movq %r14, %rcx
xorl %eax, %eax
callq 0x11a0
jmp 0x1bc1
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: Realloc
void *Realloc(void *p, int64 size, char *mesg)
{ if (size <= 0)
    size = 1;
  if ((p = realloc(p,size)) == NULL)
    { if (mesg == NULL)
        EPRINTF(EPLACE,"%s: Out of memory\n",Prog_Name);
      else
        EPRINTF(EPLACE,"%s: Out of memory (%s)\n",Prog_Name,mesg);
    }
  return (p);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
cmpq $0x2, %rsi
pushq $0x1
popq %rax
cmovlq %rax, %rsi
callq 0x1210
movq %rax, %rbx
testq %rax, %rax
je 0x1c2f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xc3c2(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0xeca8(%rip), %rdx      # 0x108e8
testq %r14, %r14
jne 0x1c55
leaq 0x7604(%rip), %rsi      # 0x9250
xorl %eax, %eax
callq 0x11a0
jmp 0x1c24
leaq 0x7607(%rip), %rsi      # 0x9263
movq %r14, %rcx
xorl %eax, %eax
callq 0x11a0
jmp 0x1c24
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: Strdup
char *Strdup(char *name, char *mesg)
{ char *s;

  if (name == NULL)
    return (NULL);
  if ((s = strdup(name)) == NULL)
    { if (mesg == NULL)
        EPRINTF(EPLACE,"%s: Out of memory\n",Prog_Name);
      else
        EPRINTF(EPLACE,"%s: Out of memory (%s)\n",Prog_Name,mesg);
    }
  return (s);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1ca9
movq %rsi, %r14
callq 0x1290
movq %rax, %rbx
testq %rax, %rax
jne 0x1cab
movq 0xc370(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0xec56(%rip), %rdx      # 0x108e8
testq %r14, %r14
jne 0x1cb6
leaq 0x75b2(%rip), %rsi      # 0x9250
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x11a0
jmp 0x1cab
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x75a6(%rip), %rsi      # 0x9263
xorl %ebx, %ebx
movq %r14, %rcx
xorl %eax, %eax
callq 0x11a0
jmp 0x1cab
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: Fopen
FILE *Fopen(char *name, char *mode)
{ FILE *f;

  if (name == NULL || mode == NULL)
    return (NULL);
  if ((f = fopen(name,mode)) == NULL)
    EPRINTF(EPLACE,"%s: Cannot open %s for '%s'\n",Prog_Name,name,mode);
  return (f);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x1ce5
xorl %r15d, %r15d
jmp 0x1cf8
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1240
movq %rax, %r15
testq %rax, %rax
je 0x1d01
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xc2f0(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0xebd6(%rip), %rdx      # 0x108e8
leaq 0x7562(%rip), %rsi      # 0x927b
xorl %r15d, %r15d
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x11a0
jmp 0x1cf8
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: PathTo
char *PathTo(char *name)
{ char *path, *find;

  if (name == NULL)
    return (NULL);
  if ((find = rindex(name,'/')) != NULL)
    { *find = '\0';
      path = Strdup(name,"Extracting path from");
      *find = '/';
    }
  else
    path = Strdup(".","Allocating default path");
  return (path);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1d5f
movq %rdi, %rbx
pushq $0x2f
popq %rsi
callq 0x1250
testq %rax, %rax
je 0x1d69
movq %rax, %r14
movb $0x0, (%rax)
leaq 0x7547(%rip), %rsi      # 0x9298
movq %rbx, %rdi
callq 0x1c68
movb $0x2f, (%r14)
jmp 0x1d61
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x777e(%rip), %rdi      # 0x94ee
leaq 0x7536(%rip), %rsi      # 0x92ad
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1c68
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: Root
char *Root(char *name, char *suffix)
{ char *path, *find, *dot;
  int   epos;

  if (name == NULL)
    return (NULL);
  find = rindex(name,'/');
  if (find == NULL)
    find = name;
  else
    find += 1;
  if (suffix == NULL)
    { dot = strchr(find,'.');
      if (dot != NULL)
        *dot = '\0';
      path = Strdup(find,"Extracting root from");
      if (dot != NULL)
        *dot = '.';
    }
  else
    { epos  = strlen(find);
      epos -= strlen(suffix);
      if (epos > 0 && strcasecmp(find+epos,suffix) == 0)
        { find[epos] = '\0';
          path = Strdup(find,"Extracting root from");
          find[epos] = suffix[0];
        }
      else
        path = Strdup(find,"Allocating root");
    }
  return (path);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1df3
movq %rsi, %r14
movq %rdi, %r15
pushq $0x2f
popq %rsi
callq 0x1250
leaq 0x1(%rax), %rbx
testq %rax, %rax
cmoveq %r15, %rbx
testq %r14, %r14
je 0x1df7
movq %rbx, %rdi
callq 0x10e0
movq %rax, %r15
movq %r14, %rdi
callq 0x10e0
subq %rax, %r15
testl %r15d, %r15d
jle 0x1ddf
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
addq %rbx, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1050
testl %eax, %eax
je 0x1e28
leaq 0x74f4(%rip), %rsi      # 0x92da
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1c68
xorl %eax, %eax
jmp 0x1e41
pushq $0x2e
popq %rsi
movq %rbx, %rdi
callq 0x10f0
movq %rax, %r14
testq %rax, %rax
je 0x1e0e
movb $0x0, (%r14)
leaq 0x74b0(%rip), %rsi      # 0x92c5
movq %rbx, %rdi
callq 0x1c68
testq %r14, %r14
je 0x1e41
movb $0x2e, (%r14)
jmp 0x1e41
movb $0x0, (%r15)
leaq 0x7492(%rip), %rsi      # 0x92c5
movq %rbx, %rdi
callq 0x1c68
movb (%r14), %cl
movb %cl, (%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: Catenate
char *Catenate(char *path, char *sep, char *root, char *suffix)
{ static char *cat = NULL;
  static int   max = -1;
  int   len;

  if (path == NULL || root == NULL || sep == NULL || suffix == NULL)
    return (NULL);
  len =  strlen(path);
  len += strlen(sep);
  len += strlen(root);
  len += strlen(suffix);
  if (len > max)
    { max = ((int) (1.2*len)) + 100;
      cat = (char *) realloc(cat,max+1);
      if (cat == NULL)
        { EPRINTF(EPLACE,"%s: Out of memory (Making path name for %s)\n",Prog_Name,root);
          return (NULL);
        }
    }
  sprintf(cat,"%s%s%s%s",path,sep,root,suffix);
  return (cat);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %xmm0
movq %rdi, %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
movq %rcx, %xmm0
movq %rsi, %xmm2
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
pxor %xmm0, %xmm0
pcmpeqd %xmm0, %xmm2
pcmpeqd %xmm0, %xmm1
movdqa %xmm1, %xmm0
shufps $0xdd, %xmm2, %xmm0     # xmm0 = xmm0[1,3],xmm2[1,3]
shufps $0x88, %xmm2, %xmm1     # xmm1 = xmm1[0,2],xmm2[0,2]
andps %xmm0, %xmm1
movmskps %xmm1, %eax
testl %eax, %eax
je 0x1e98
xorl %r14d, %r14d
jmp 0x1f35
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
callq 0x10e0
movq %rax, %r13
movq %r15, %rdi
callq 0x10e0
movq %rax, %rbp
addl %r13d, %ebp
movq %rbx, %rdi
callq 0x10e0
movq %rax, %r13
movq %r14, %rdi
callq 0x10e0
addl %r13d, %eax
addl %ebp, %eax
movq 0xea17(%rip), %rdi      # 0x108f0
cmpl %eax, 0xc2c9(%rip)      # 0xe1a8
jge 0x1f14
cvtsi2sd %eax, %xmm0
mulsd 0x735b(%rip), %xmm0     # 0x9248
cvttsd2si %xmm0, %eax
leal 0x64(%rax), %ecx
movl %ecx, 0xc2ae(%rip)      # 0xe1a8
addl $0x65, %eax
movslq %eax, %rsi
callq 0x1210
movq %rax, %rdi
movq %rax, 0xe9e1(%rip)      # 0x108f0
testq %rax, %rax
je 0x1f47
leaq 0x73fc(%rip), %rsi      # 0x9317
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
movq %r14, %r9
xorl %eax, %eax
callq 0x1260
movq 0xe9bb(%rip), %r14      # 0x108f0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xc0aa(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0xe990(%rip), %rdx      # 0x108e8
leaq 0x738b(%rip), %rsi      # 0x92ea
xorl %r14d, %r14d
movq %rbx, %rcx
xorl %eax, %eax
callq 0x11a0
jmp 0x1f35
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: Numbered_Suffix
char *Numbered_Suffix(char *left, int num, char *right)
{ static char *sfx = NULL;
  static int   max = -1;
  int   len;

  if (left == NULL || right == NULL)
    return (NULL);
  len =  strlen(left);
  len += strlen(right) + 40;
  if (len > max)
    { max = ((int) (1.2*len)) + 100;
      sfx = (char *) realloc(sfx,max+1);
      if (sfx == NULL)
        { EPRINTF(EPLACE,"%s: Out of memory (Making number suffix for %d)\n",Prog_Name,num);
          return (NULL);
        }
    }
  sprintf(sfx,"%s%d%s",left,num,right);
  return (sfx);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
je 0x1f8b
xorl %r14d, %r14d
jmp 0x2008
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
callq 0x10e0
movq %rax, %r12
movq %r14, %rdi
callq 0x10e0
addl %r12d, %eax
addl $0x28, %eax
movq 0xe948(%rip), %rdi      # 0x108f8
cmpl %eax, 0xc1f6(%rip)      # 0xe1ac
jge 0x1feb
cvtsi2sd %eax, %xmm0
mulsd 0x7284(%rip), %xmm0     # 0x9248
cvttsd2si %xmm0, %eax
leal 0x64(%rax), %ecx
movl %ecx, 0xc1db(%rip)      # 0xe1ac
addl $0x65, %eax
movslq %eax, %rsi
callq 0x1210
movq %rax, %rdi
movq %rax, 0xe912(%rip)      # 0x108f8
testq %rax, %rax
je 0x2017
leaq 0x735f(%rip), %rsi      # 0x9351
movq %r15, %rdx
movl %ebx, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x1260
movq 0xe8f0(%rip), %r14      # 0x108f8
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xbfda(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0xe8c0(%rip), %rdx      # 0x108e8
leaq 0x72f1(%rip), %rsi      # 0x9320
xorl %r14d, %r14d
movl %ebx, %ecx
xorl %eax, %eax
callq 0x11a0
jmp 0x2008
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: Number_Digits
int  Number_Digits(int64 num)
{ int digit;

  digit = 0;
  while (num >= 1)
    { num /= 10;
      digit += 1;
    }
  return (digit);
}

// Assembly:
movq %rdi, %rax
xorl %ecx, %ecx
pushq $0xa
popq %rsi
testq %rax, %rax
jle 0x22da
xorl %edx, %edx
divq %rsi
incl %ecx
jmp 0x22cc
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: Compress_Read
void Compress_Read(int len, char *s)
{ int   i;
  char  c, d;
  char *s0, *s1, *s2, *s3;

  s0 = s;
  s1 = s0+1;
  s2 = s1+1;
  s3 = s2+1;

  c = s1[len];
  d = s2[len];
  s0[len] = s1[len] = s2[len] = 0;

  for (i = 0; i < len; i += 4)
    *s++ = (char ) ((s0[i] << 6) | (s1[i] << 4) | (s2[i] << 2) | s3[i]);

  s1[len] = c;
  s2[len] = d;
}

// Assembly:
movslq %edi, %rax
movb 0x1(%rsi,%rax), %cl
movb 0x2(%rsi,%rax), %dl
movb $0x0, 0x2(%rsi,%rax)
andw $0x0, (%rsi,%rax)
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %rax, %r8
jge 0x232e
movb (%rsi,%r8), %r9b
movb 0x1(%rsi,%r8), %r10b
shlb $0x6, %r9b
shlb $0x4, %r10b
orb %r9b, %r10b
movb 0x2(%rsi,%r8), %r9b
shlb $0x2, %r9b
orb %r10b, %r9b
orb 0x3(%rsi,%r8), %r9b
movb %r9b, (%rsi,%rdi)
addq $0x4, %r8
incq %rdi
jmp 0x22f7
movb %cl, 0x1(%rsi,%rax)
movb %dl, 0x2(%rsi,%rax)
retq