LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Slexis-Works[P]texture-packing/PPMImage.cpp
// Function: PPMImage::saveRectangle(unsigned int, unsigned int, RGBColor, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void PPMImage::saveRectangle(coord w, coord h, RGBColor col, std::string path) {
	assert(w > 0 && h > 0);

	std::stringstream colStream;
	colStream << (int)col.r << ' ' << (int)col.g << ' ' << (int)col.b << ' ';
	std::string colString = colStream.str();
	std::ofstream file(path);

	file << "P3" << std::endl
		<< w << ' ' << h << std::endl
		<< "255" << std::endl;

	for (coord y=0 ; y<h ; ++y) {
		for (coord x=0 ; x<w ; ++x) {
			file << colString;
		}
		file << std::endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3a8, %rsp            # imm = 0x3A8
testl %edi, %edi
je 0x2cde
movl %esi, %ebx
testl %esi, %esi
je 0x2cde
movq %rcx, %r14
movl %edx, %r15d
movl %edi, %ebp
leaq 0x20(%rsp), %rdi
callq 0x20d0
leaq 0x30(%rsp), %rdi
movzbl %r15b, %esi
callq 0x21d0
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x2170
andl $0xffffff, %r15d        # imm = 0xFFFFFF
movl %r15d, %ecx
shrl $0x8, %ecx
movzbl %cl, %esi
movq %rax, %rdi
callq 0x21d0
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x2170
shrl $0x10, %r15d
movq %rax, %rdi
movl %r15d, %esi
callq 0x21d0
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x2170
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x21b0
leaq 0x1a8(%rsp), %rdi
pushq $0x10
popq %rdx
movq %r14, %rsi
callq 0x2200
leaq 0x2460(%rip), %rsi      # 0x5084
leaq 0x1a8(%rsp), %rdi
callq 0x2140
movq %rax, %rdi
callq 0x2090
movl %ebp, %esi
movq %rax, %rdi
callq 0x20c0
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x2170
movl %ebx, %esi
movq %rax, %rdi
callq 0x20c0
movq %rax, %rdi
callq 0x2090
leaq 0x2419(%rip), %rsi      # 0x5080
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x2090
xorl %r12d, %r12d
leaq 0x1a8(%rsp), %r14
movq %rsp, %r15
movl %ebp, %r13d
cmpl %ebx, %r12d
je 0x2cad
subl $0x1, %r13d
jb 0x2ca0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2130
jmp 0x2c8d
movq %r14, %rdi
callq 0x2090
incl %r12d
jmp 0x2c85
leaq 0x1a8(%rsp), %rdi
callq 0x2180
movq %rsp, %rdi
callq 0x2080
leaq 0x20(%rsp), %rdi
callq 0x20f0
addq $0x3a8, %rsp            # imm = 0x3A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23a2(%rip), %rdi      # 0x5087
leaq 0x2384(%rip), %rsi      # 0x5070
leaq 0x23a3(%rip), %rcx      # 0x5096
pushq $0x43
popq %rdx
callq 0x20b0
movq %rax, %rbx
jmp 0x2d1b
jmp 0x2d02
movq %rax, %rbx
jmp 0x2d23
jmp 0x2d0b
jmp 0x2d0b
movq %rax, %rbx
leaq 0x1a8(%rsp), %rdi
callq 0x2180
movq %rsp, %rdi
callq 0x2080
leaq 0x20(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x21e0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/Slexis-Works[P]texture-packing/Rectangle.cpp
// Function: Rectangle::collides(Rectangle) const
bool Rectangle::collides(const Rectangle o) const {
	return x + w >= o.x
		&& x < o.x + o.w
		&& y + h >= o.y
		&& y < o.y + o.h;
}

// Assembly:
movl (%rdi), %ecx
movl 0x8(%rdi), %eax
addl %ecx, %eax
movl 0x8(%rsp), %edx
cmpl %edx, %eax
jb 0x2e2e
leaq 0x8(%rsp), %rax
addl 0x8(%rax), %edx
cmpl %edx, %ecx
jae 0x2e2e
movl 0x4(%rdi), %ecx
movl 0xc(%rdi), %esi
addl %ecx, %esi
movl 0x4(%rax), %edx
cmpl %edx, %esi
jae 0x2e31
xorl %eax, %eax
retq
addl 0xc(%rax), %edx
cmpl %edx, %ecx
setb %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Slexis-Works[P]texture-packing/Shelf.cpp
// Function: Shelf::putRotatableRect(Rectangle const&)
int Shelf::putRotatableRect(const Rectangle &rect) {
	Rectangle recTest(rect, 0, 0);
	if (putRect(recTest)) {
		return 1;
	}
	recTest.flip();
	if (putRect(recTest)) {
		return 2;
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2d98
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ea0
testb %al, %al
je 0x2f29
pushq $0x1
popq %rax
jmp 0x2f46
leaq 0x4(%rsp), %r14
movq %r14, %rdi
callq 0x2db6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ea0
movzbl %al, %eax
addl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Slexis-Works[P]texture-packing/Shelf.cpp
// Function: Shelf::setY(unsigned int)
void Shelf::setY(coord ny) {
	y = ny;
	std::vector<Rectangle>::iterator it, end;
	it = rects.begin();
	end = rects.end();
	while (it != end) {
		(*it).setY(ny);
		++it;
	}
}

// Assembly:
movl %esi, 0x4(%rdi)
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
cmpq %rcx, %rax
je 0x2f67
movl %esi, 0x4(%rax)
addq $0x14, %rax
jmp 0x2f59
retq
// File: /workspace/github_cpp_makefile_star2_O2/Slexis-Works[P]texture-packing/Shelf.cpp
// Function: Shelf::drawOn(PPMImage&) const
void Shelf::drawOn(PPMImage &img) const {
	std::vector<Rectangle>::const_iterator it, end;
	it = rects.begin();
	end = rects.end();
	while (it != end) {
		(*it).drawOn(img);
		++it;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x2f8e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ddc
addq $0x14, %r14
jmp 0x2f78
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Slexis-Works[P]texture-packing/Bin.cpp
// Function: Bin::importShelf(Shelf const&)
void Bin::importShelf(const Shelf &shelf) {
	std::vector<Rectangle>::const_iterator it = shelf.getRects().begin(), end = shelf.getRects().end();
	while (it != end) {
		addRect(*it, it->getX(), it->getY());
		++it;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movq 0x18(%rsi), %r15
cmpq %r15, %r14
je 0x31ad
movl (%r14), %edx
movl 0x4(%r14), %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3152
addq $0x14, %r14
jmp 0x3190
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Slexis-Works[P]texture-packing/algoFF.cpp
// Function: algoFF(std::vector<Rectangle, std::allocator<Rectangle>> const&, std::vector<Bin, std::allocator<Bin>>&, unsigned int, unsigned int)
void algoFF(const std::vector<Rectangle> &rects, std::vector<Bin> &bins, coord bw, coord by) {
	// Création de tous les étages
	std::vector<Shelf> shelves;
	for (const Rectangle &rect : rects) {
		bool inserted = false;
		for (auto & shelf : shelves) {
			if (shelf.putRect(rect)) {
				inserted = true;
				break;
			}
		}
		if (inserted) {
			continue;
		}
		shelves.push_back(Shelf(bw, 0, rect));
	}

	// Insertion de tous les étages de manière naïve
	coord curY = by;
	for (auto & shelf : shelves) {
		if (curY + shelf.getHeight() > by) {
			bins.push_back(Bin(bw, by));
			curY = 0;
		}
		shelf.setY(curY);
		curY += shelf.getHeight();
		bins.back().importShelf(shelf);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, %r13d
movl %edx, 0x4(%rsp)
movq %rsi, 0x8(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq (%rdi), %r12
movq 0x8(%rdi), %rbx
leaq 0x30(%rsp), %r14
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %rbp
cmpq %rbx, %r12
je 0x3270
cmpq %rbp, %r15
je 0x323f
movq %r15, %rdi
movq %r12, %rsi
callq 0x2ea0
addq $0x28, %r15
testb %al, %al
je 0x3225
jmp 0x326a
movq %r14, %r15
movq %r14, %rdi
movl 0x4(%rsp), %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x2e3c
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x33ac
leaq 0x40(%rsp), %rdi
callq 0x2774
addq $0x14, %r12
jmp 0x3216
leaq 0x30(%rsp), %r14
movl %r13d, %ebx
cmpq %rbp, %r15
je 0x32da
movl (%r15), %eax
addl %ebx, %eax
cmpl %r13d, %eax
jbe 0x32af
movq %r14, %rdi
movl 0x4(%rsp), %esi
movl %r13d, %edx
callq 0x3140
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x35e0
leaq 0x38(%rsp), %rdi
callq 0x2774
xorl %ebx, %ebx
movq %r15, %rdi
movl %ebx, %esi
callq 0x2f4e
movl (%r15), %r12d
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $-0x20, %rdi
movq %r15, %rsi
callq 0x3180
addl %r12d, %ebx
addq $0x28, %r15
jmp 0x3278
leaq 0x10(%rsp), %rdi
callq 0x3328
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3312
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0x3309
jmp 0x3312
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2774
jmp 0x3315
jmp 0x3312
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3328
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Slexis-Works[P]texture-packing/algoFFDH.cpp
// Function: algoFFDH(std::vector<Rectangle, std::allocator<Rectangle>> const&, std::vector<Bin, std::allocator<Bin>>&, unsigned int, unsigned int)
void algoFFDH(const std::vector<Rectangle> &rects, std::vector<Bin> &bins, coord bw, coord by) {
	// Tri des données
	std::vector<Rectangle> sortedRects;
	for (const Rectangle &rect : rects) {
		sortedRects.push_back(rect);
	}
	std::sort(sortedRects.begin(), sortedRects.end(), goesBeforeByHeight);

	// Création de tous les étages
	std::vector<Shelf> shelves;
	for (const Rectangle &rect : sortedRects) {
		bool inserted = false;
		for (auto & shelf : shelves) {
			if (shelf.putRect(rect)) {
				inserted = true;
				break;
			}
		}
		if (inserted) {
			continue;
		}
		shelves.push_back(Shelf(bw, 0, rect));
	}

	// Insertion de tous les étages de manière naïve
	coord curY = by;
	for (auto & shelf : shelves) {
		if (curY + shelf.getHeight() > by) {
			bins.push_back(Bin(bw, by));
			curY = 0;
		}
		shelf.setY(curY);
		curY += shelf.getHeight();
		bins.back().importShelf(shelf);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %ecx, %ebp
movl %edx, 0x4(%rsp)
movq %rsi, 0x8(%rsp)
leaq 0x10(%rsp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
movq (%rdi), %r15
movq 0x8(%rdi), %r12
cmpq %r12, %r15
je 0x382e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3998
addq $0x14, %r15
jmp 0x3818
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x14d(%rip), %rdx       # 0x398c
callq 0x3a92
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq 0x10(%rsp), %r12
movq 0x18(%rsp), %rbx
leaq 0x50(%rsp), %r14
movq 0x30(%rsp), %r15
movq 0x38(%rsp), %r13
cmpq %rbx, %r12
je 0x38bd
cmpq %r13, %r15
je 0x388c
movq %r15, %rdi
movq %r12, %rsi
callq 0x2ea0
addq $0x28, %r15
testb %al, %al
je 0x3872
jmp 0x38b7
movq %r14, %r15
movq %r14, %rdi
movl 0x4(%rsp), %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x2e3c
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x33ac
leaq 0x60(%rsp), %rdi
callq 0x2774
addq $0x14, %r12
jmp 0x3863
leaq 0x50(%rsp), %r14
movl %ebp, %ebx
cmpq %r13, %r15
je 0x3924
movl (%r15), %eax
addl %ebx, %eax
cmpl %ebp, %eax
jbe 0x38f9
movq %r14, %rdi
movl 0x4(%rsp), %esi
movl %ebp, %edx
callq 0x3140
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x35e0
leaq 0x58(%rsp), %rdi
callq 0x2774
xorl %ebx, %ebx
movq %r15, %rdi
movl %ebx, %esi
callq 0x2f4e
movl (%r15), %r12d
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $-0x20, %rdi
movq %r15, %rsi
callq 0x3180
addl %r12d, %ebx
addq $0x28, %r15
jmp 0x38c4
leaq 0x30(%rsp), %rdi
callq 0x3328
leaq 0x10(%rsp), %rdi
callq 0x2774
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3966
jmp 0x396d
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
jmp 0x395f
jmp 0x396d
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x2774
jmp 0x3970
movq %rax, %rbx
jmp 0x397a
jmp 0x396d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3328
leaq 0x10(%rsp), %rdi
callq 0x2774
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/eecs280staff[P]unit_test_framework/test/test_special_asserts.cpp
// Function: main
int main() {
    test_assert_equal();
    test_assert_not_equal();
    test_assert_true();
    test_assert_false();
    test_assert_almost_equal();

    cout << "All tests passed" << endl;
}

// Assembly:
pushq %rax
callq 0x2420
callq 0x2b39
callq 0x3246
callq 0x3319
callq 0x33ed
movq 0x5bd0(%rip), %rdi      # 0x7fd8
leaq 0x2c2d(%rip), %rsi      # 0x503c
callq 0x2140
movq %rax, %rdi
callq 0x2090
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/eecs280staff[P]unit_test_framework/test/test_special_asserts.cpp
// Function: test_assert_almost_equal()
void test_assert_almost_equal() {
    cout << "test_assert_almost_equal" << endl;

    ASSERT_ALMOST_EQUAL(42.1, 42.2, 0.2);
    ASSERT_ALMOST_EQUAL(0.2 + 0.1, 0.3, 0.01);

    ASSERT_TEST_FAILURE_RAISED(ASSERT_ALMOST_EQUAL(42.1, 42.3, 0.1));
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq 0x4bdf(%rip), %rdi      # 0x7fd8
leaq 0x2072(%rip), %rsi      # 0x5472
callq 0x2140
movq %rax, %rdi
callq 0x2090
leaq 0x2077(%rip), %rsi      # 0x548b
movsd 0x1bec(%rip), %xmm0     # 0x5008
movsd 0x1bec(%rip), %xmm1     # 0x5010
movsd 0x1bec(%rip), %xmm2     # 0x5018
movl $0x86, %edi
callq 0x475a
movq 0x4b9b(%rip), %rdi      # 0x7fd8
leaq 0x1cbd(%rip), %rsi      # 0x5101
callq 0x2140
movq %rax, %rdi
callq 0x2090
leaq 0x20be(%rip), %rdi      # 0x5516
leaq 0x1cb9(%rip), %rsi      # 0x5118
leaq 0x204a(%rip), %rcx      # 0x54b0
movl $0x86, %edx
callq 0x20c0
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x34ca
movq %rbx, %rdi
callq 0x2050
movq %rsp, %rdi
movq %rax, %rsi
callq 0x3ad6
movq 0x4b46(%rip), %rdi      # 0x7fd8
movq %rsp, %rsi
callq 0x2130
movq %rax, %rdi
callq 0x2090
movq %rsp, %rdi
callq 0x2080
callq 0x21e0
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
jmp 0x34c5
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2080
callq 0x21e0
movq %rbx, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x3b3c
// File: /workspace/github_cpp_makefile_star2_O2/eecs280staff[P]unit_test_framework/./unit_test_framework.hpp
// Function: void unit_test_framework::Assertions::assert_not_equal<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, int, char const*)
static void assert_not_equal(First&& first, Second&& second,
                                 int line_number,
                                 const char* assertion_text) {
      if (safe_equals<First, Second>::not_equals(first, second)) {
        return;
      }
      std::ostringstream reason;

      reason << "Values unexpectedly equal: ";
      Diagnostic::print(reason, first);
      reason << " == ";
      Diagnostic::print(reason, second);
      throw TestFailure(reason.str(), line_number, assertion_text);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
callq 0x4bf8
testb %al, %al
je 0x3ff7
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x2190
leaq 0x1585(%rip), %rsi      # 0x5590
movq %r12, %rdi
callq 0x2140
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x2130
leaq 0x1585(%rip), %rsi      # 0x55ac
leaq 0x28(%rsp), %rdi
callq 0x2140
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x2130
pushq $0x30
popq %rdi
callq 0x20a0
movq %rax, %r14
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x21c0
movq %r14, %rcx
addq $0x10, %rcx
movq %rcx, (%r14)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
jne 0x4078
movups (%rax), %xmm0
movups %xmm0, (%rcx)
jmp 0x4084
movq %rdx, (%r14)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%r14)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movl %ebp, 0x20(%r14)
movq %rbx, 0x28(%r14)
leaq 0x3cfc(%rip), %rsi      # 0x7da8
leaq 0x96b(%rip), %rdx       # 0x4a1e
movq %r14, %rdi
callq 0x2200
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2080
jmp 0x40da
movq %rax, %rbx
movq %r14, %rdi
callq 0x20e0
jmp 0x40da
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/eecs280staff[P]unit_test_framework/./unit_test_framework.hpp
// Function: unit_test_framework::Assertions::assert_true(bool, int, char const*)
static void assert_true(bool value, int line_number,
                            const char* assertion_text) {
      if (value) {
        return;
      }
      std::ostringstream reason;
      reason << "Expected true, but was false";
      throw TestFailure(reason.str(), line_number, assertion_text);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
testl %edi, %edi
je 0x45a1
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %rbx
movl %esi, %ebp
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x2190
leaq 0xf45(%rip), %rsi       # 0x54ff
movq %r14, %rdi
callq 0x2140
pushq $0x30
popq %rdi
callq 0x20a0
movq %rax, %r14
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x21c0
movq %r14, %rcx
addq $0x10, %rcx
movq %rcx, (%r14)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
jne 0x45fc
movups (%rax), %xmm0
movups %xmm0, (%rcx)
jmp 0x4608
movq %rdx, (%r14)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%r14)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movl %ebp, 0x20(%r14)
movq %rbx, 0x28(%r14)
leaq 0x3778(%rip), %rsi      # 0x7da8
leaq 0x3e7(%rip), %rdx       # 0x4a1e
movq %r14, %rdi
callq 0x2200
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2080
jmp 0x465e
movq %rax, %rbx
movq %r14, %rdi
callq 0x20e0
jmp 0x465e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/eecs280staff[P]unit_test_framework/./unit_test_framework.hpp
// Function: unit_test_framework::Assertions::assert_false(bool, int, char const*)
static void assert_false(bool value, int line_number,
                             const char* assertion_text) {
      if (not value) {
        return;
      }
      std::ostringstream reason;
      reason << "Expected false, but was true";
      throw TestFailure(reason.str(), line_number, assertion_text);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
testl %edi, %edi
jne 0x468b
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %rbx
movl %esi, %ebp
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x2190
leaq 0xe78(%rip), %rsi       # 0x551c
movq %r14, %rdi
callq 0x2140
pushq $0x30
popq %rdi
callq 0x20a0
movq %rax, %r14
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x21c0
movq %r14, %rcx
addq $0x10, %rcx
movq %rcx, (%r14)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
jne 0x46e6
movups (%rax), %xmm0
movups %xmm0, (%rcx)
jmp 0x46f2
movq %rdx, (%r14)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%r14)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movl %ebp, 0x20(%r14)
movq %rbx, 0x28(%r14)
leaq 0x368e(%rip), %rsi      # 0x7da8
leaq 0x2fd(%rip), %rdx       # 0x4a1e
movq %r14, %rdi
callq 0x2200
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2080
jmp 0x4748
movq %rax, %rbx
movq %r14, %rdi
callq 0x20e0
jmp 0x4748
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_convert.cpp
// Function: BamTools::ConvertTool::ConvertToolPrivate::RunPileupConversion(BamTools::BamMultiReader*)
bool ConvertTool::ConvertToolPrivate::RunPileupConversion(BamMultiReader* reader) {
  
    // check for valid BamMultiReader
    if ( reader == 0 ) return false;
  
    // set up our pileup format 'visitor'
    ConvertPileupFormatVisitor* v = new ConvertPileupFormatVisitor(m_references, 
                                                                   m_settings->FastaFilename,
                                                                   m_settings->IsPrintingPileupMapQualities, 
                                                                   &m_out);

    // set up PileupEngine
    PileupEngine pileup;
    pileup.AddVisitor(v);
    
    // iterate through data
    BamAlignment al;
    while ( reader->GetNextAlignment(al) )
        pileup.AddAlignment(al);
    pileup.Flush();
    
    // clean up
    delete v;
    v = 0;
    
    // return success
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %rsi, %rbx
testq %rsi, %rsi
je 0x37cb8
movq %rdi, %r15
pushq $0x38
popq %rdi
callq 0x355d0
movq %rax, %r14
leaq 0x8(%r15), %rsi
movq (%r15), %rdx
movzbl 0x7(%rdx), %ecx
addq $0xa0, %rdx
addq $0x20, %r15
movq %rax, %rdi
movq %r15, %r8
callq 0x3984a
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x66b92
movq %r15, %rdi
movq %r14, %rsi
callq 0x66c10
leaq 0x10(%rsp), %rdi
callq 0x35200
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x352b0
testb %al, %al
je 0x37c91
movq %r12, %rdi
movq %r15, %rsi
callq 0x66c08
jmp 0x37c75
leaq 0x8(%rsp), %rdi
callq 0x66c28
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x10(%rsp), %rdi
callq 0x35940
leaq 0x8(%rsp), %rdi
callq 0x66bca
testq %rbx, %rbx
setne %al
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x37cde
movq %rax, %rbx
movq %r14, %rdi
callq 0x35570
jmp 0x37cfa
jmp 0x37ce3
movq %rax, %rbx
jmp 0x37cf0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x35940
leaq 0x8(%rsp), %rdi
callq 0x66bca
movq %rbx, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_convert.cpp
// Function: BamTools::ConvertTool::ConvertToolPrivate::PrintBed(BamTools::BamAlignment const&)
void ConvertTool::ConvertToolPrivate::PrintBed(const BamAlignment& a) { 
  
    // tab-delimited, 0-based half-open 
    // (e.g. a 50-base read aligned to pos 10 could have BED coordinates (10, 60) instead of BAM coordinates (10, 59) )
    // <chromName> <chromStart> <chromEnd> <readName> <score> <strand>

    m_out << m_references.at(a.RefID).RefName << "\t"
          << a.Position << "\t"
          << a.GetEndPosition() << "\t"
          << a.Name << "\t"
          << a.MapQuality << "\t"
          << (a.IsReverseStrand() ? "-" : "+") << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
leaq 0x20(%rdi), %r14
addq $0x8, %rdi
movslq 0xa8(%rsi), %rsi
callq 0x3a2cc
movq %r14, %rdi
movq %rax, %rsi
callq 0x35510
leaq 0x3eabe(%rip), %r14     # 0x767f6
movq %rax, %rdi
movq %r14, %rsi
callq 0x355b0
movl 0xac(%rbx), %esi
movq %rax, %rdi
callq 0x35b00
movq %rax, %rdi
movq %r14, %rsi
callq 0x355b0
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x35530
movq %r15, %rdi
movl %eax, %esi
callq 0x35b00
movq %rax, %rdi
movq %r14, %rsi
callq 0x355b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x35510
movq %rax, %rdi
movq %r14, %rsi
callq 0x355b0
movzwl 0xb2(%rbx), %esi
movq %rax, %rdi
callq 0x35a90
movq %rax, %rdi
movq %r14, %rsi
callq 0x355b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x35830
leaq 0x39602(%rip), %rcx     # 0x713c4
leaq 0x39531(%rip), %rsi     # 0x712fa
testb %al, %al
cmovneq %rcx, %rsi
movq %r14, %rdi
callq 0x355b0
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x35300
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_convert.cpp
// Function: BamTools::ConvertTool::ConvertToolPrivate::PrintFasta(BamTools::BamAlignment const&)
void ConvertTool::ConvertToolPrivate::PrintFasta(const BamAlignment& a) { 
    
    // >BamAlignment.Name
    // BamAlignment.QueryBases (up to FASTA_LINE_MAX bases per line)
    // ...
    //
    // N.B. - QueryBases are reverse-complemented if aligned to reverse strand
  
    // print header
    m_out << ">" << a.Name << endl;
    
    // handle reverse strand alignment - bases 
    string sequence = a.QueryBases;
    if ( a.IsReverseStrand() )
        Utilities::ReverseComplement(sequence);
    
    // if sequence fits on single line
    if ( sequence.length() <= FASTA_LINE_MAX )
        m_out << sequence << endl;
    
    // else split over multiple lines
    else {
      
        size_t position = 0;
        size_t seqLength = sequence.length(); // handle reverse strand alignment - bases & qualitiesth();
        
        // write subsequences to each line
        while ( position < (seqLength - FASTA_LINE_MAX) ) {
            m_out << sequence.substr(position, FASTA_LINE_MAX) << endl;
            position += FASTA_LINE_MAX;
        }
        
        // write final subsequence
        m_out << sequence.substr(position) << endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x20, %rbx
leaq 0x3b26c(%rip), %rsi     # 0x7306f
movq %rbx, %rdi
callq 0x355b0
movq %rax, %rdi
movq %r14, %rsi
callq 0x35510
movq %rax, %rdi
callq 0x35300
leaq 0x28(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x35810
movq %r14, %rdi
callq 0x35830
testb %al, %al
je 0x37e42
leaq 0x8(%rsp), %rdi
callq 0x67ca8
movq 0x10(%rsp), %rbp
cmpq $0x33, %rbp
jae 0x37e67
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x35510
movq %rax, %rdi
callq 0x35300
jmp 0x37ee7
addq $-0x32, %rbp
xorl %r14d, %r14d
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
pushq $0x32
popq %r13
cmpq %rbp, %r14
jae 0x37eb3
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x35600
movq %rbx, %rdi
movq %r15, %rsi
callq 0x35510
movq %rax, %rdi
callq 0x35300
movq %r15, %rdi
callq 0x35730
addq $0x32, %r14
jmp 0x37e7c
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $-0x1
popq %rcx
movq %r14, %rdx
callq 0x35600
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x35510
movq %rax, %rdi
callq 0x35300
leaq 0x28(%rsp), %rdi
callq 0x35730
leaq 0x8(%rsp), %rdi
callq 0x35730
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x37f13
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x35730
jmp 0x37f25
jmp 0x37f13
movq %rax, %rbx
jmp 0x37f25
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x35730
leaq 0x8(%rsp), %rdi
callq 0x35730
movq %rbx, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198
nop
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_convert.cpp
// Function: BamTools::ConvertTool::ConvertToolPrivate::PrintFastq(BamTools::BamAlignment const&)
void ConvertTool::ConvertToolPrivate::PrintFastq(const BamAlignment& a) { 
  
    // @BamAlignment.Name
    // BamAlignment.QueryBases
    // +
    // BamAlignment.Qualities
    //
    // N.B. - QueryBases are reverse-complemented (& Qualities reversed) if aligned to reverse strand .
    //        Name is appended "/1" or "/2" if paired-end, to reflect which mate this entry is.
  
    // handle paired-end alignments
    string name = a.Name;
    if ( a.IsPaired() )
        name.append( (a.IsFirstMate() ? "/1" : "/2") );
  
    // handle reverse strand alignment - bases & qualities
    string qualities = a.Qualities;
    string sequence  = a.QueryBases;
    if ( a.IsReverseStrand() ) {
        Utilities::Reverse(qualities);
        Utilities::ReverseComplement(sequence);
    }
  
    // write to output stream
    m_out << "@" << name << endl
          << sequence    << endl
          << "+"         << endl
          << qualities   << endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x35810
movq %r14, %rdi
callq 0x35320
testb %al, %al
je 0x37f89
movq %r14, %rdi
callq 0x352c0
leaq 0x3938a(%rip), %rcx     # 0x712fc
leaq 0x39386(%rip), %rsi     # 0x712ff
testb %al, %al
cmovneq %rcx, %rsi
leaq 0x48(%rsp), %rdi
callq 0x35c30
leaq 0x68(%r14), %rsi
leaq 0x28(%rsp), %rdi
callq 0x35810
leaq 0x28(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x35810
movq %r14, %rdi
callq 0x35830
testb %al, %al
je 0x37fc5
leaq 0x28(%rsp), %rdi
callq 0x67c96
leaq 0x8(%rsp), %rdi
callq 0x67ca8
addq $0x20, %rbx
leaq 0x39332(%rip), %rsi     # 0x71302
movq %rbx, %rdi
callq 0x355b0
leaq 0x48(%rsp), %rsi
movq %rax, %rdi
callq 0x35510
movq %rax, %rdi
callq 0x35300
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x35510
movq %rax, %rdi
callq 0x35300
leaq 0x392f1(%rip), %rsi     # 0x712fa
movq %rax, %rdi
callq 0x355b0
movq %rax, %rdi
callq 0x35300
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x35510
movq %rax, %rdi
callq 0x35300
leaq 0x8(%rsp), %rdi
callq 0x35730
leaq 0x28(%rsp), %rdi
callq 0x35730
leaq 0x48(%rsp), %rdi
callq 0x35730
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x3805b
movq %rax, %rbx
jmp 0x3806d
movq %rax, %rbx
jmp 0x38077
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x35730
leaq 0x28(%rsp), %rdi
callq 0x35730
leaq 0x48(%rsp), %rdi
callq 0x35730
movq %rbx, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198
nop
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_convert.cpp
// Function: BamTools::ConvertTool::~ConvertTool()
ConvertTool::~ConvertTool(void) {

    delete m_settings;
    m_settings = 0;
    
    delete m_impl;
    m_impl = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x5ae86(%rip), %rax     # 0x945e0
movq %rax, (%rdi)
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x3976e
movq %rbx, %rdi
callq 0x3a9d4
movq %rbx, %rdi
callq 0x35570
andq $0x0, 0x8(%r14)
movq 0x10(%r14), %rbx
testq %rbx, %rbx
je 0x3978c
movq %rbx, %rdi
callq 0x3aa7c
movq %rbx, %rdi
callq 0x35570
andq $0x0, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x397a3
movq %rax, %r14
movq %rbx, %rdi
callq 0x35570
movq %r14, %rdi
callq 0x35b50
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_convert.cpp
// Function: BamTools::ConvertTool::Run(int, char**)
int ConvertTool::Run(int argc, char* argv[]) {
  
    // parse command line arguments
    Options::Parse(argc, argv, 1);
    
    // initialize ConvertTool with settings
    m_impl = new ConvertToolPrivate(m_settings);
    
    // run ConvertTool, return success/fail
    if ( m_impl->Run() ) 
        return 0;
    else 
        return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rax
movl %esi, %edi
movq %rdx, %rsi
movl %eax, %edx
callq 0x6595a
movl $0x130, %edi            # imm = 0x130
callq 0x355d0
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x3aabe
movq %r14, 0x10(%rbx)
movq %r14, %rdi
callq 0x3766c
xorb $0x1, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x35570
movq %rbx, %rdi
callq 0x35b50
nop
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_convert.cpp
// Function: BamTools::ConvertPileupFormatVisitor::ConvertPileupFormatVisitor(std::vector<BamTools::RefData, std::allocator<BamTools::RefData>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, std::ostream*)
ConvertPileupFormatVisitor::ConvertPileupFormatVisitor(const RefVector& references, 
                                                       const string& fastaFilename,
                                                       const bool isPrintingMapQualities,
                                                       ostream* out)
    : PileupVisitor()
    , m_hasFasta(false)
    , m_isPrintingMapQualities(isPrintingMapQualities)
    , m_out(out)
    , m_references(references)
{ 
    // set up Fasta reader if file is provided
    if ( !fastaFilename.empty() ) {
      
        // check for FASTA index
        string indexFilename = "";
        if ( Utilities::FileExists(fastaFilename + ".fai") ) 
            indexFilename = fastaFilename + ".fai";
      
        // open FASTA file
        if ( m_fasta.Open(fastaFilename, indexFilename) ) 
            m_hasFasta = true;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
leaq 0x5ada3(%rip), %rax     # 0x94610
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x64eee
movb $0x0, 0x10(%r15)
movb %bpl, 0x11(%r15)
movq %r14, 0x18(%r15)
leaq 0x20(%r15), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x3ab18
cmpq $0x0, 0x8(%r12)
je 0x39939
leaq 0x3cf4c(%rip), %rsi     # 0x767f7
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x35280
leaq 0x37dc8(%rip), %rdx     # 0x71689
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x3ab7a
leaq 0x8(%rsp), %rdi
callq 0x67612
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x35730
testb %bpl, %bpl
je 0x39916
leaq 0x37d99(%rip), %rdx     # 0x71689
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x3ab7a
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x35340
leaq 0x8(%rsp), %rdi
callq 0x35730
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x64f8a
testb %al, %al
je 0x3992f
movb $0x1, 0x10(%r15)
leaq 0x28(%rsp), %rdi
callq 0x35730
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x35730
jmp 0x39979
jmp 0x3996c
jmp 0x39976
jmp 0x39976
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x35730
jmp 0x39979
movq %rax, %r15
jmp 0x39983
movq %rax, %r15
jmp 0x3998b
movq %rax, %r15
leaq 0x28(%rsp), %rdi
callq 0x35730
movq %r14, %rdi
callq 0x3a26c
movq %rbx, %rdi
callq 0x64f26
movq %r15, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198
nop
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_convert.cpp
// Function: BamTools::ConvertPileupFormatVisitor::~ConvertPileupFormatVisitor()
ConvertPileupFormatVisitor::~ConvertPileupFormatVisitor(void) { 
    // be sure to close Fasta reader
    if ( m_hasFasta ) {
        m_fasta.Close();
        m_hasFasta = false;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5ac5e(%rip), %rax     # 0x94610
movq %rax, (%rdi)
cmpb $0x1, 0x10(%rdi)
jne 0x399c8
leaq 0x8(%rbx), %rdi
callq 0x64f64
movb $0x0, 0x10(%rbx)
leaq 0x20(%rbx), %rdi
callq 0x3a26c
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x64f26
movq %rax, %r14
leaq 0x20(%rbx), %rdi
callq 0x3a26c
jmp 0x399f5
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x64f26
movq %r14, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198
nop
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/utils/bamtools_variant.h
// Function: BamTools::Variant::operator=(BamTools::Variant const&)
Variant& operator= (const Variant& rhs) {
            if ( rhs.data != NULL ) 
                rhs.data->AddRef();
            if ( data != NULL ) 
                data->Release();
            data = rhs.data;
            return *this;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x3b1cc
incq 0x8(%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3b1dc
callq 0x3b516
movq (%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/utils/bamtools_options.h
// Function: BamTools::OptionValue::OptionValue(BamTools::OptionValue const&)
struct UTILS_EXPORT OptionValue {
  
    // data members
    bool* pFoundArgument;
    void* pValue;
    std::string ValueTypeDescription;
    bool UseVector;
    bool StoreValue;
    bool IsRequired;
    Variant VariantValue;

    // constructor
    OptionValue(void)
        : pFoundArgument(NULL)
        , pValue(NULL)
        , UseVector(false)
        , StoreValue(true)
        , IsRequired(false)
    { } 
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
addq $0x10, %rdi
addq $0x10, %rsi
callq 0x35810
movb 0x32(%r14), %al
movb %al, 0x32(%rbx)
movzwl 0x30(%r14), %eax
movw %ax, 0x30(%rbx)
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x3bcf2
incq 0x8(%rax)
movq %rax, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/utils/bamtools_options.h
// Function: BamTools::Option::~Option()
struct UTILS_EXPORT Option {
  
    // data members
    std::string Argument;
    std::string ValueDescription;
    std::string Description;
    bool StoreValue;
    bool HasDefaultValue;
    Variant DefaultValue;

    // constructor
    Option(void)
        : StoreValue(true)
        , HasDefaultValue(false)
    { }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x68, %rdi
callq 0x3b1ea
leaq 0x40(%rbx), %rdi
callq 0x35730
leaq 0x20(%rbx), %rdi
callq 0x35730
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35730
movq %rax, %r14
jmp 0x3b4a4
movq %rax, %r14
jmp 0x3b49b
movq %rax, %r14
leaq 0x40(%rbx), %rdi
callq 0x35730
leaq 0x20(%rbx), %rdi
callq 0x35730
movq %rbx, %rdi
callq 0x35730
movq %r14, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_count.cpp
// Function: BamTools::CountTool::~CountTool()
CountTool::~CountTool(void) { 

    delete m_settings;
    m_settings = 0;

    delete m_impl;
    m_impl = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5824e(%rip), %rax     # 0x94708
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x3c4ce
movq %r14, %rdi
callq 0x3c5a8
movq %r14, %rdi
callq 0x35570
andq $0x0, 0x8(%rbx)
movq 0x10(%rbx), %rdi
callq 0x35570
andq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x35570
movq %rbx, %rdi
callq 0x35b50
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_count.cpp
// Function: BamTools::CountTool::Run(int, char**)
int CountTool::Run(int argc, char* argv[]) { 

    // parse command line arguments
    Options::Parse(argc, argv, 1);

    // initialize CountTool with settings
    m_impl = new CountToolPrivate(m_settings);

    // run CountTool, return success/fail
    if ( m_impl->Run() )
        return 0;
    else
        return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rax
movl %esi, %edi
movq %rdx, %rsi
movl %eax, %edx
callq 0x6595a
pushq $0x8
popq %rdi
callq 0x355d0
movq 0x8(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x10(%rbx)
movq %rax, %rdi
callq 0x3bd28
xorb $0x1, %al
movzbl %al, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_coverage.cpp
// Function: BamTools::CoverageTool::~CoverageTool()
CoverageTool::~CoverageTool(void) { 

    delete m_settings;
    m_settings = 0;
    
    delete m_impl;
    m_impl = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x57bdc(%rip), %rax     # 0x94750
movq %rax, (%rdi)
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x3cb88
movq %rbx, %rdi
callq 0x3cce4
movq %rbx, %rdi
callq 0x35570
andq $0x0, 0x8(%r14)
movq 0x10(%r14), %rbx
testq %rbx, %rbx
je 0x3cba6
movq %rbx, %rdi
callq 0x3cd26
movq %rbx, %rdi
callq 0x35570
andq $0x0, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x3cbbd
movq %rax, %r14
movq %rbx, %rdi
callq 0x35570
movq %r14, %rdi
callq 0x35b50
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_filter.cpp
// Function: BamTools::FilterTool::FilterToolPrivate::GetScriptContents[abi:cxx11]()
const string FilterTool::FilterToolPrivate::GetScriptContents(void) {
  
    // open script for reading
    FILE* inFile = fopen(m_settings->ScriptFilename.c_str(), "rb");
    if ( !inFile ) {
        cerr << "bamtools filter ERROR: could not open script: "
             << m_settings->ScriptFilename << " for reading" << endl;
        return string();
    }
    
    // read in entire script contents  
    char buffer[1024];
    ostringstream docStream("");
    while ( true ) {
        
        // peek ahead, make sure there is data available
        char ch = fgetc(inFile);
        ungetc(ch, inFile);
        if( feof(inFile) )
            break;
        
        // read next block of data
        if ( fgets(buffer, 1024, inFile) == 0 ) {
            cerr << "bamtools filter ERROR: could not read script contents" << endl;
            return string();
        }
        
        docStream << buffer;
    }
    
    // close script file
    fclose(inFile);
    
    // import buffer contents to document, return
    return docStream.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x5a8, %rsp            # imm = 0x5A8
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rsi), %rax
movq 0x80(%rax), %rdi
leaq 0x349d4(%rip), %rsi     # 0x71c7e
callq 0x35670
testq %rax, %rax
je 0x3d33b
movq %rax, %r14
leaq 0x39535(%rip), %rsi     # 0x767f7
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x35280
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x10
popq %rdx
callq 0x35850
leaq 0x8(%rsp), %rdi
callq 0x35730
leaq 0x1a0(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %r14, %rdi
callq 0x35970
movsbl %al, %edi
movq %r14, %rsi
callq 0x350d0
movq %r14, %rdi
callq 0x35920
testl %eax, %eax
jne 0x3d387
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x359a0
testq %rax, %rax
je 0x3d39e
movq %r12, %rdi
movq %r15, %rsi
callq 0x355b0
jmp 0x3d2fa
movq 0x57c9e(%rip), %rdi     # 0x94fe0
leaq 0x34938(%rip), %rsi     # 0x71c81
callq 0x355b0
movq 0x18(%r15), %rsi
subq $-0x80, %rsi
movq %rax, %rdi
callq 0x35510
leaq 0x38961(%rip), %rsi     # 0x75cc6
movq %rax, %rdi
callq 0x355b0
movq %rax, %rdi
callq 0x35300
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
jmp 0x3d3d3
movq %r14, %rdi
callq 0x355c0
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x359c0
jmp 0x3d3c9
movq 0x57c3b(%rip), %rdi     # 0x94fe0
leaq 0x34904(%rip), %rsi     # 0x71cb0
callq 0x355b0
movq %rax, %rdi
callq 0x35300
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x35160
movq %rbx, %rax
addq $0x5a8, %rsp            # imm = 0x5A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3d3fd
jmp 0x3d3fd
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x35730
jmp 0x3d40a
movq %rax, %rbx
jmp 0x3d40a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x35160
movq %rbx, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_filter.cpp
// Function: BamTools::FilterTool::FilterToolPrivate::SetupFilters()
bool FilterTool::FilterToolPrivate::SetupFilters(void) {
  
    // set up filter engine with supported properties
    InitProperties();
    
    // parse script for filter rules, if given
    if ( m_settings->HasScript )
        return ParseScript();
    
    // otherwise check command line for filters
    else return ParseCommandLine();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3d41a
movq 0x18(%rbx), %rax
cmpb $0x1, 0x4(%rax)
jne 0x3f42a
movq %rbx, %rdi
popq %rbx
jmp 0x3ea6a
movq %rbx, %rdi
popq %rbx
jmp 0x3d5ae
nop
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_filter.cpp
// Function: BamTools::FilterTool::~FilterTool()
FilterTool::~FilterTool(void) {

    delete m_settings;
    m_settings = 0;

    delete m_impl;
    m_impl = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x53858(%rip), %rax     # 0x947d8
movq %rax, (%rdi)
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x40f94
movq %rbx, %rdi
callq 0x439aa
movq %rbx, %rdi
callq 0x35570
andq $0x0, 0x8(%r14)
movq 0x10(%r14), %rbx
testq %rbx, %rbx
je 0x40fb2
movq %rbx, %rdi
callq 0x3ce9e
movq %rbx, %rdi
callq 0x35570
andq $0x0, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x40fc9
movq %rax, %r14
movq %rbx, %rdi
callq 0x35570
movq %r14, %rdi
callq 0x35b50
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_filter.cpp
// Function: BamTools::FilterTool::Run(int, char**)
int FilterTool::Run(int argc, char* argv[]) {

    // parse command line arguments
    Options::Parse(argc, argv, 1);

    // initialize FilterTool with settings
    m_impl = new FilterToolPrivate(m_settings);

    // run FilterTool, return success/fail
    if ( m_impl->Run() )
        return 0;
    else
        return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rax
movl %esi, %edi
movq %rdx, %rsi
movl %eax, %edx
callq 0x6595a
movl $0x148, %edi            # imm = 0x148
callq 0x355d0
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x3ce5c
movq %r14, 0x10(%rbx)
movq %r14, %rdi
callq 0x3ef42
xorb $0x1, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x35570
movq %rbx, %rdi
callq 0x35b50
nop
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/utils/bamtools_filter_engine.h
// Function: BamTools::FilterEngine<BamTools::BamAlignmentChecker>::addProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool FilterEngine<FilterChecker>::addProperty(const std::string& propertyName) {
    const std::vector<std::string> propertyNames = allPropertyNames();
    bool found = std::binary_search( propertyNames.begin(), propertyNames.end(), propertyName );
    if ( found ) return false;
    m_properties.push_back( Property(propertyName) );
    std::sort( m_properties.begin(), m_properties.end() );
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b18e
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r15, %rdx
callq 0x4b200
movl %eax, %ebx
testb %al, %al
jne 0x43328
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x35810
leaq 0x30(%r14), %rdi
leaq 0x18(%rsp), %rsi
movb $0x0, 0x20(%rsi)
callq 0x44710
leaq 0x18(%rsp), %rdi
callq 0x35730
movq 0x30(%r14), %rdi
movq 0x38(%r14), %rsi
callq 0x44e39
xorb $0x1, %bl
movq %rsp, %rdi
callq 0x3abf0
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x35730
jmp 0x43353
jmp 0x43350
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3abf0
movq %rbx, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198
nop
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/utils/bamtools_filter_engine.h
// Function: BamTools::FilterEngine<BamTools::BamAlignmentChecker>::buildDefaultRuleString()
inline void FilterEngine<FilterChecker>::buildDefaultRuleString(void) {
  
    // set up temp string stream 
    std::stringstream ruleStream("");
  
    // get first filterName
    FilterMap::const_iterator mapIter = m_filters.begin();
    ruleStream << (*mapIter).first;
    
    // if there are more filters present
    // iterate over remaining filters, appending compare operator and filter name
    if ( m_filters.size() > 1 ) {        
        for ( ++mapIter ; mapIter != m_filters.end(); ++mapIter )
            ruleStream << ( (m_defaultCompareType == FilterCompareType::AND) ? " & " : " | " ) 
                       << (*mapIter).first;
    }

    // set m_ruleString from temp stream
    m_ruleString = ruleStream.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
leaq 0x30960(%rip), %rsi     # 0x767f7
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x35280
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $0x18
popq %rdx
callq 0x359e0
leaq 0x10(%rsp), %rdi
callq 0x35730
movq 0x18(%rbx), %r15
leaq 0x40(%rsp), %r14
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x35510
cmpq $0x2, 0x28(%rbx)
jb 0x45f30
movq %r15, %rdi
callq 0x356b0
movq %rax, %r15
leaq 0x8(%rbx), %r12
leaq 0x2c634(%rip), %r13     # 0x72528
leaq 0x2c631(%rip), %rbp     # 0x7252c
cmpq %r12, %r15
je 0x45f30
cmpl $0x0, 0xbc(%rbx)
movq %r13, %rsi
je 0x45f0f
movq %rbp, %rsi
movq %r14, %rdi
callq 0x355b0
leaq 0x20(%r15), %rsi
movq %rax, %rdi
callq 0x35510
movq %r15, %rdi
callq 0x356b0
movq %rax, %r15
jmp 0x45efb
leaq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x359c0
addq $0x48, %rbx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x35340
leaq 0x10(%rsp), %rdi
callq 0x35730
leaq 0x30(%rsp), %rdi
callq 0x35490
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x35730
jmp 0x45fa0
jmp 0x45f9d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x35730
jmp 0x45faa
jmp 0x45f9d
movq %rax, %rbx
jmp 0x45faa
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x35490
movq %rbx, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198