LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/xukmin[P]rase/routing-builders.cc
// Function: SecondNearestFirstParentSelector::SelectParent(int, std::vector<int, std::allocator<int>> const&, SensorNetwork const&)
int SecondNearestFirstParentSelector::SelectParent(
    int sensor,
    const std::vector<int>& candidates,
    const SensorNetwork& network) {
  assert(!candidates.empty());
  if (candidates.size() == 1) {
    return candidates[0];
  }

  int min_sensor = candidates[0];
  double min_distance = network.GetDistance(sensor, min_sensor);
  int second_min_sensor = candidates[1];
  double second_min_distance = network.GetDistance(sensor, second_min_sensor);
  if (min_distance > second_min_sensor) {
    std::swap(min_sensor, second_min_sensor);
    std::swap(min_distance, second_min_distance);
  }
  for (int i = 2; i < candidates.size(); i++) {
    double distance = network.GetDistance(sensor, candidates[i]);
    if (distance < min_distance) {
      second_min_sensor = min_sensor;
      second_min_distance = min_distance;
      min_sensor = candidates[i];
      min_distance = distance;
    } else if (distance < second_min_distance) {
      second_min_sensor = candidates[i];
      second_min_distance = distance;
    }
  }

  return second_min_sensor;
}

// Assembly:
pushq %rax
movq (%rdx), %rdi
movq 0x8(%rdx), %rdx
cmpq %rdx, %rdi
je 0x717d
subq %rdi, %rdx
movl (%rdi), %r8d
cmpq $0x4, %rdx
je 0x7178
sarq $0x2, %rdx
movslq %r8d, %rax
movslq %esi, %rsi
movq 0x78(%rcx), %rcx
leaq (%rsi,%rsi,2), %rsi
movq (%rcx,%rsi,8), %rcx
movsd (%rcx,%rax,8), %xmm0
movslq 0x4(%rdi), %rax
movsd (%rcx,%rax,8), %xmm2
cvtsi2sd %eax, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x7114
movl %eax, %r9d
movapd %xmm2, %xmm1
jmp 0x7122
movl %r8d, %r9d
movapd %xmm0, %xmm1
movl %eax, %r8d
movapd %xmm2, %xmm0
cmpq $0x3, %rdx
jb 0x7178
movl $0x2, %esi
movslq (%rdi,%rsi,4), %rax
movsd (%rcx,%rax,8), %xmm2
ucomisd %xmm2, %xmm1
jbe 0x714c
movl %eax, %r10d
movapd %xmm2, %xmm3
movl %r9d, %eax
movapd %xmm1, %xmm2
jmp 0x7160
movl %r9d, %r10d
movapd %xmm1, %xmm3
ucomisd %xmm2, %xmm0
ja 0x7160
movl %r8d, %eax
movapd %xmm0, %xmm2
incq %rsi
movapd %xmm2, %xmm0
movl %eax, %r8d
movapd %xmm3, %xmm1
movl %r10d, %r9d
cmpq %rsi, %rdx
jne 0x712d
jmp 0x717b
movl %r8d, %eax
popq %rcx
retq
leaq 0x242b(%rip), %rdi      # 0x95af
leaq 0x2301(%rip), %rsi      # 0x948c
leaq 0x26a3(%rip), %rcx      # 0x9835
movl $0xdf, %edx
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O1/xukmin[P]rase/routing-builders.cc
// Function: FarthestFirstParentSelector::SelectParent(int, std::vector<int, std::allocator<int>> const&, SensorNetwork const&)
int FarthestFirstParentSelector::SelectParent(int sensor,
                                              const std::vector<int>& candidates,
                                              const SensorNetwork& network) {
  assert(!candidates.empty());
  int parent = candidates[0];
  double max_distance = network.GetDistance(sensor, parent);
  for (int i = 1; i < candidates.size(); i++) {
    double distance = network.GetDistance(sensor, candidates[i]);
    if (distance > max_distance) {
      parent = candidates[i];
      max_distance = distance;
    }
  }

  return parent;
}

// Assembly:
pushq %rax
movq (%rdx), %rdi
movq 0x8(%rdx), %rdx
cmpq %rdx, %rdi
je 0x72eb
movl (%rdi), %eax
subq %rdi, %rdx
sarq $0x2, %rdx
cmpq $0x2, %rdx
jb 0x72e9
movslq %eax, %r8
movslq %esi, %rsi
movq 0x78(%rcx), %rcx
leaq (%rsi,%rsi,2), %rsi
movq (%rcx,%rsi,8), %rcx
movsd (%rcx,%r8,8), %xmm0
movl $0x1, %esi
movslq (%rdi,%rsi,4), %r8
movsd (%rcx,%r8,8), %xmm1
ucomisd %xmm0, %xmm1
cmoval %r8d, %eax
maxsd %xmm0, %xmm1
incq %rsi
movapd %xmm1, %xmm0
cmpq %rsi, %rdx
jne 0x72c7
popq %rcx
retq
leaq 0x22bd(%rip), %rdi      # 0x95af
leaq 0x2193(%rip), %rsi      # 0x948c
leaq 0x25d8(%rip), %rcx      # 0x98d8
movl $0x10c, %edx            # imm = 0x10C
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O1/xukmin[P]rase/svg-printer.cc
// Function: SvgPrinter::SvgPrinter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Region const&, double)
SvgPrinter::SvgPrinter(const std::string& filename,
                       const std::string& title,
                       const Region& region,
                       double scale)
    : filename_(filename), title_(title), region_(region), scale_(scale) {
  file_ = std::fopen(filename_.c_str(), "w");
  if (!file_) {
    fprintf(stderr, "Failed to open file %s!\n", filename_.c_str());
    exit(1);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x798c
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x798c
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x50(%rbx)
movups %xmm0, 0x40(%rbx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x60(%rbx)
movq (%rbx), %rdi
leaq 0x1ee9(%rip), %rsi      # 0x9ca8
callq 0x31c0
movq %rax, 0x68(%rbx)
testq %rax, %rax
je 0x7dd9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x33ed
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x7df8
movq (%r12), %rsi
incq %rsi
callq 0x3180
movq %r14, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O1/Slexis-Works[P]texture-packing/PPMImage.cpp
// Function: PPMImage::PPMImage(unsigned int, unsigned int, RGBColor)
PPMImage::PPMImage(coord width, coord height, RGBColor bgc)
: width(width)
, height(height)
, length(width*height)
, map(NULL)
{
	map = new RGBColor[length];
	assert(map);
	for (size_t i=0 ; i<length ; ++i)
		map[i] = bgc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
movl %edx, %r15d
movq %rdi, %r14
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
imull %esi, %r15d
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
leaq (%r15,%r15,2), %rdi
callq 0x2030
movq %rax, 0x10(%r14)
testl %r15d, %r15d
je 0x2a32
xorl %eax, %eax
movl %ebx, %ecx
shrl $0x10, %ecx
xorl %edx, %edx
movq 0x10(%r14), %rsi
movw %bx, (%rsi,%rax)
movb %cl, 0x2(%rsi,%rax)
incq %rdx
addq $0x3, %rax
cmpq 0x8(%r14), %rdx
jb 0x2a19
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Slexis-Works[P]texture-packing/PPMImage.cpp
// Function: PPMImage::saveImage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void PPMImage::saveImage(std::string path) {
	std::ofstream file(path);

	file << "P6" << std::endl
		<< width << ' ' << height << std::endl
		<< "255" << std::endl;

	for (coord y=0 ; y<height ; ++y) {
		for (coord x=0 ; x<width ; ++x) {
			RGBColor curp = map[y*width + x];
			file << curp.r << curp.g << curp.b;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x10, %edx
callq 0x21e0
leaq 0x3584(%rip), %rsi      # 0x607d
movl $0x2, %edx
movq %r14, %rdi
callq 0x2150
movq 0x8(%rsp), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
leaq 0x8(%rsp), %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
movl (%rbx), %esi
movq %rax, %rdi
callq 0x2090
leaq 0x7(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2150
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x2090
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
movq %rax, %r14
leaq 0x34f1(%rip), %rsi      # 0x6080
movl $0x3, %edx
movq %rax, %rdi
callq 0x2150
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
cmpl $0x0, 0x4(%rbx)
je 0x2c45
xorl %ebp, %ebp
leaq 0x7(%rsp), %r15
movl (%rbx), %eax
testl %eax, %eax
je 0x2c3e
xorl %r12d, %r12d
movq 0x10(%rbx), %rcx
imull %ebp, %eax
addl %r12d, %eax
leaq (%rax,%rax,2), %rax
movb (%rcx,%rax), %dl
movb 0x1(%rcx,%rax), %r14b
movb 0x2(%rcx,%rax), %r13b
movb %dl, 0x7(%rsp)
movl $0x1, %edx
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x2150
movb %r14b, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2150
movb %r13b, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2150
incl %r12d
movl (%rbx), %eax
cmpl %eax, %r12d
jb 0x2bd9
incl %ebp
cmpl 0x4(%rbx), %ebp
jb 0x2bd0
movq 0x6384(%rip), %rax      # 0x8fd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x2100
leaq 0x100(%rsp), %rdi
callq 0x2050
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c8b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/Slexis-Works[P]texture-packing/PPMImage.cpp
// Function: PPMImage::saveImageASCII(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void PPMImage::saveImageASCII(std::string path) {
	std::ofstream file(path);

	file << "P3" << std::endl
		<< width << ' ' << height << std::endl
		<< "255" << std::endl;

	for (coord y=0 ; y<height ; ++y) {
		for (coord x=0 ; x<width ; ++x) {
			RGBColor curp = map[y*width + x];
			file << (int)curp.r << ' ' << (int)curp.g << ' ' << (int)curp.b << ' ';
		}
		file << std::endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x10, %edx
callq 0x21e0
leaq 0x33b7(%rip), %rsi      # 0x6084
movl $0x2, %edx
movq %r14, %rdi
callq 0x2150
movq 0x8(%rsp), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
leaq 0x8(%rsp), %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
movl (%rbx), %esi
movq %rax, %rdi
callq 0x2090
leaq 0x7(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2150
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x2090
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
movq %rax, %r15
leaq 0x331d(%rip), %rsi      # 0x6080
movl $0x3, %edx
movq %rax, %rdi
callq 0x2150
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
cmpl $0x0, 0x4(%rbx)
je 0x2e7d
xorl %r13d, %r13d
leaq 0x7(%rsp), %r15
movl (%rbx), %eax
testl %eax, %eax
je 0x2e40
xorl %r14d, %r14d
movq 0x10(%rbx), %rcx
imull %r13d, %eax
addl %r14d, %eax
leaq (%rax,%rax,2), %rax
movzbl (%rcx,%rax), %esi
movzbl 0x1(%rcx,%rax), %r12d
movzbl 0x2(%rcx,%rax), %ebp
leaq 0x8(%rsp), %rdi
callq 0x21b0
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2150
movq %rax, %rdi
movl %r12d, %esi
callq 0x21b0
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2150
movq %rax, %rdi
movl %ebp, %esi
callq 0x21b0
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2150
incl %r14d
movl (%rbx), %eax
cmpl %eax, %r14d
jb 0x2db6
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rdi
leaq 0x8(%rsp), %rax
addq %rax, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
leaq 0x8(%rsp), %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
incl %r13d
cmpl 0x4(%rbx), %r13d
jb 0x2da9
movq 0x614c(%rip), %rax      # 0x8fd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x2100
leaq 0x100(%rsp), %rdi
callq 0x2050
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2ec5
jmp 0x2ec5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32c4
leaq 0x8(%rsp), %rax
addl 0x8(%rax), %edx
cmpl %edx, %ecx
jae 0x32c4
movl 0x4(%rdi), %ecx
movl 0xc(%rdi), %esi
addl %ecx, %esi
movl 0x4(%rax), %edx
cmpl %edx, %esi
jae 0x32c7
xorl %eax, %eax
retq
addl 0xc(%rax), %edx
cmpl %edx, %ecx
setb %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3236
movq %rbx, %rdi
movq %r14, %rsi
callq 0x336a
movl %eax, %ecx
movl $0x1, %eax
testb %cl, %cl
jne 0x3426
leaq 0x4(%rsp), %r14
movq %r14, %rdi
callq 0x3256
movq %rbx, %rdi
movq %r14, %rsi
callq 0x336a
movzbl %al, %eax
addl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3447
movl %esi, 0x4(%rax)
addq $0x14, %rax
jmp 0x3439
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x68, %rsp
movl %ecx, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq %rsi, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq (%rdi), %r15
movq 0x8(%rdi), %rax
movq %rax, 0x38(%rsp)
cmpq %rax, %r15
je 0x3798
leaq 0x40(%rsp), %rbp
movl $0x1, %r12d
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %r14
cmpq %r14, %r13
je 0x3758
xorl %ebx, %ebx
movq %r13, %rdi
movq %r15, %rsi
callq 0x336a
movzbl %bl, %ebx
testb %al, %al
cmovnel %r12d, %ebx
addq $0x28, %r13
cmpq %r14, %r13
sete %cl
orb %al, %cl
je 0x3731
testb $0x1, %bl
jne 0x378d
movq %rbp, %rdi
movl 0x8(%rsp), %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x32d0
leaq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x38d6
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x378d
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
addq $0x14, %r15
cmpq 0x38(%rsp), %r15
jne 0x3720
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %rbp
cmpq %rbp, %r15
movl 0xc(%rsp), %r14d
je 0x3824
leaq 0x40(%rsp), %r12
movl %r14d, %r13d
movl (%r15), %eax
addl %r13d, %eax
cmpl %r14d, %eax
jbe 0x37f5
movq %r12, %rdi
movl 0x8(%rsp), %esi
movl %r14d, %edx
callq 0x360c
movq 0x30(%rsp), %rdi
movq %r12, %rsi
callq 0x3b16
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x37f2
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
xorl %r13d, %r13d
movq %r15, %rdi
movl %r13d, %esi
callq 0x342e
movl (%r15), %ebx
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
addq $-0x20, %rdi
movq %r15, %rsi
callq 0x366c
addl %ebx, %r13d
addq $0x28, %r15
cmpq %rbp, %r15
jne 0x37b4
leaq 0x10(%rsp), %rdi
callq 0x3888
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3873
movq %rax, %rbx
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x3876
movq 0x58(%rsp), %rsi
jmp 0x3867
jmp 0x3873
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x3876
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
jmp 0x3876
jmp 0x3873
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3888
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
callq 0x247c
callq 0x2d5f
callq 0x363d
callq 0x37b8
callq 0x3936
movq 0x6b9b(%rip), %rbx      # 0x8fd8
leaq 0x3bf8(%rip), %rsi      # 0x603c
movl $0x10, %edx
movq %rbx, %rdi
callq 0x2190
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5688
testb %al, %al
je 0x483f
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x21b0
leaq 0x1d3d(%rip), %rsi      # 0x6590
movl $0x1b, %edx
movq %r12, %rdi
callq 0x2190
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x28(%rsp), %rdi
callq 0x2190
leaq 0x1d34(%rip), %rsi      # 0x65ac
leaq 0x28(%rsp), %rdi
movl $0x4, %edx
callq 0x2190
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x28(%rsp), %rdi
callq 0x2190
movl $0x30, %edi
callq 0x2090
movq %rax, %r14
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x21e0
movq %r14, %rax
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x18(%rsp), %r15
movq -0x10(%r15), %rcx
cmpq %r15, %rcx
jne 0x48d5
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0x48e1
movq %rcx, (%r14)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%r14)
movq %r15, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movl %ebp, 0x20(%r14)
movq %rbx, 0x28(%r14)
leaq 0x4494(%rip), %rsi      # 0x8da0
leaq 0xb5d(%rip), %rdx       # 0x5470
movq %r14, %rdi
callq 0x2230
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4935
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2170
xorl %eax, %eax
jmp 0x493e
movq %rax, %rbx
movb $0x1, %al
testb %al, %al
je 0x494f
movq %r14, %rdi
callq 0x20f0
jmp 0x494f
movq %rax, %rbx
movq 0x467a(%rip), %rsi      # 0x8fd0
leaq 0x28(%rsp), %rdi
callq 0x20a0
leaq 0x98(%rsp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
testl %edi, %edi
je 0x4f1d
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movl %esi, %ebp
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x21b0
leaq 0x15c9(%rip), %rsi      # 0x64ff
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x2190
movl $0x30, %edi
callq 0x2090
movq %rax, %rbx
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x21e0
movq %rbx, %rax
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x10(%rsp), %r15
movq -0x10(%r15), %rcx
cmpq %r15, %rcx
jne 0x4f7e
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0x4f8a
movq %rcx, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movl %ebp, 0x20(%rbx)
movq %r14, 0x28(%rbx)
leaq 0x3ded(%rip), %rsi      # 0x8da0
leaq 0x4b6(%rip), %rdx       # 0x5470
movq %rbx, %rdi
callq 0x2230
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4fdb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2170
xorl %eax, %eax
jmp 0x4fe4
movq %rax, %r14
movb $0x1, %al
testb %al, %al
je 0x4ff5
movq %rbx, %rdi
callq 0x20f0
jmp 0x4ff5
movq %rax, %r14
movq 0x3fd4(%rip), %rsi      # 0x8fd0
leaq 0x20(%rsp), %rdi
callq 0x20a0
leaq 0x90(%rsp), %rdi
callq 0x2050
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
testl %edi, %edi
jne 0x503b
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movl %esi, %ebp
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x21b0
leaq 0x14c8(%rip), %rsi      # 0x651c
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x2190
movl $0x30, %edi
callq 0x2090
movq %rax, %rbx
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x21e0
movq %rbx, %rax
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x10(%rsp), %r15
movq -0x10(%r15), %rcx
cmpq %r15, %rcx
jne 0x509c
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0x50a8
movq %rcx, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movl %ebp, 0x20(%rbx)
movq %r14, 0x28(%rbx)
leaq 0x3ccf(%rip), %rsi      # 0x8da0
leaq 0x398(%rip), %rdx       # 0x5470
movq %rbx, %rdi
callq 0x2230
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x50f9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2170
xorl %eax, %eax
jmp 0x5102
movq %rax, %r14
movb $0x1, %al
testb %al, %al
je 0x5113
movq %rbx, %rdi
callq 0x20f0
jmp 0x5113
movq %rax, %r14
movq 0x3eb6(%rip), %rsi      # 0x8fd0
leaq 0x20(%rsp), %rdi
callq 0x20a0
leaq 0x90(%rsp), %rdi
callq 0x2050
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2b1ce
movq %rdi, %r15
movl $0x38, %edi
callq 0x275c0
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 0x2d590
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x658e6
movq %r15, %rdi
movq %r14, %rsi
callq 0x6596a
leaq 0x10(%rsp), %rdi
callq 0x27220
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x272d0
testb %al, %al
je 0x2b1a7
movq %r12, %rdi
movq %r15, %rsi
callq 0x65962
jmp 0x2b18b
leaq 0x8(%rsp), %rdi
callq 0x65998
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x10(%rsp), %rdi
callq 0x27930
leaq 0x8(%rsp), %rdi
callq 0x65920
testq %rbx, %rbx
setne %al
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2b1f4
movq %rax, %rbx
movq %r14, %rdi
callq 0x27560
jmp 0x2b210
jmp 0x2b1f9
movq %rax, %rbx
jmp 0x2b206
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x27930
leaq 0x8(%rsp), %rdi
callq 0x65920
movq %rbx, %rdi
callq 0x27b20
movq %rax, %rdi
callq 0x2e1ed
// File: /workspace/github_cpp_makefile_star2_O1/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
movslq 0xa8(%rsi), %rsi
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x2b368
addq $0x20, %rdi
leaq (%rsi,%rsi,4), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x8(%rax,%rcx,8), %rdx
callq 0x276c0
movq %rax, %r15
leaq 0x4c5a5(%rip), %r14     # 0x7781a
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x276c0
movl 0xac(%rbx), %esi
movq %r15, %rdi
callq 0x27ac0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x276c0
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x27520
movq %r15, %rdi
movl %eax, %esi
callq 0x27ac0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x276c0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x276c0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x276c0
movzwl 0xb2(%rbx), %esi
movq %r15, %rdi
callq 0x27400
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x276c0
movq %rbx, %rdi
callq 0x27800
leaq 0x47098(%rip), %rcx     # 0x723ba
leaq 0x46fc7(%rip), %rsi     # 0x722f0
testb %al, %al
cmovneq %rcx, %rsi
movl $0x1, %edx
movq %r15, %rdi
callq 0x276c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x27590
movsbl %al, %esi
movq %r15, %rdi
callq 0x27040
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x27410
leaq 0x473f7(%rip), %rdi     # 0x72766
xorl %eax, %eax
callq 0x278c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x62186(%rip), %rax     # 0x8f5b8
movq %rax, (%rdi)
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x2d4b5
movq 0xa0(%rbx), %rdi
leaq 0xb0(%rbx), %rax
cmpq %rax, %rdi
je 0x2d456
callq 0x27560
movq 0x80(%rbx), %rdi
leaq 0x90(%rbx), %rax
cmpq %rax, %rdi
je 0x2d46e
callq 0x27560
movq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0x2d480
callq 0x27560
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x2d492
callq 0x27560
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x2d4a4
callq 0x27560
leaq 0x8(%rbx), %rdi
callq 0x2f0de
movq %rbx, %rdi
callq 0x27560
movq $0x0, 0x8(%r14)
movq 0x10(%r14), %rbx
testq %rbx, %rbx
je 0x2d4d6
movq %rbx, %rdi
callq 0x2efae
movq %rbx, %rdi
callq 0x27560
movq $0x0, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x2d4e8
movq %rax, %r14
movq %rbx, %rdi
callq 0x27560
movq %r14, %rdi
callq 0x27b20
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %esi, %edi
movq %rdx, %rsi
movl $0x1, %edx
callq 0x64002
movl $0x130, %edi            # imm = 0x130
callq 0x275c0
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x2eff0
movq %r14, 0x10(%rbx)
movq %r14, %rdi
callq 0x2a9ac
xorb $0x1, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x27560
movq %rbx, %rdi
callq 0x27b20
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x62035(%rip), %rax     # 0x8f5e8
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x6339e
movb $0x0, 0x10(%r15)
movb %bpl, 0x11(%r15)
movq %r14, 0x18(%r15)
leaq 0x20(%r15), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x2f04c
cmpq $0x0, 0x8(%r12)
je 0x2d6cc
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x4a221(%rip), %rdx     # 0x7781b
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x2f1b2
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x2f122
leaq 0x45052(%rip), %rsi     # 0x7267f
leaq 0x8(%rsp), %rdi
callq 0x27c10
leaq 0x8(%rsp), %rdi
callq 0x665de
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d652
callq 0x27560
testb %bpl, %bpl
je 0x2d69f
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
callq 0x2f122
leaq 0x45008(%rip), %rsi     # 0x7267f
leaq 0x8(%rsp), %rdi
callq 0x27c10
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x27350
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d69f
callq 0x27560
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x63440
testb %al, %al
je 0x2d6b8
movb $0x1, 0x10(%r15)
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2d6cc
callq 0x27560
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d6e5
jmp 0x2d6e5
jmp 0x2d6f9
jmp 0x2d6f9
jmp 0x2d6e5
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d6fc
callq 0x27560
jmp 0x2d6fc
movq %rax, %r15
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2d715
callq 0x27560
jmp 0x2d715
movq %rax, %r15
movq %r14, %rdi
callq 0x2e378
jmp 0x2d722
movq %rax, %r15
movq %rbx, %rdi
callq 0x633d8
movq %r15, %rdi
callq 0x27b20
movq %rax, %rdi
callq 0x2e1ed
// File: /workspace/github_cpp_makefile_star2_O1/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 0x61ea0(%rip), %rax     # 0x8f5e8
movq %rax, (%rdi)
cmpb $0x1, 0x10(%rdi)
jne 0x2d75e
leaq 0x8(%rbx), %rdi
callq 0x6341a
movb $0x0, 0x10(%rbx)
leaq 0x20(%rbx), %rdi
callq 0x2e378
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x633d8
movq %rax, %r14
leaq 0x20(%rbx), %rdi
callq 0x2e378
jmp 0x2d78b
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x633d8
movq %r14, %rdi
callq 0x27b20
movq %rax, %rdi
callq 0x2e1ed
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2f77c
incq 0x8(%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2f790
decq 0x8(%rdi)
jne 0x2f790
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/zeeev[P]DASVC/bamtools/src/utils/bamtools_options.h
// Function: BamTools::OptionValue::~OptionValue()
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 %rdi, %rbx
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x2fab0
decq 0x8(%rdi)
jne 0x2fab0
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
addq $0x8, %rsp
cmpq %rbx, %rdi
je 0x2fac9
popq %rbx
popq %r14
jmp 0x27560
popq %rbx
popq %r14
retq
movq %rax, %r14
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x2fae2
callq 0x27560
movq %r14, %rdi
callq 0x27b20
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x68(%rdi), %rdi
testq %rdi, %rdi
je 0x2fb06
decq 0x8(%rdi)
jne 0x2fb06
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x2fb18
callq 0x27560
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x2fb2a
callq 0x27560
movq (%rbx), %rdi
addq $0x10, %rbx
addq $0x8, %rsp
cmpq %rbx, %rdi
je 0x2fb42
popq %rbx
popq %r14
jmp 0x27560
popq %rbx
popq %r14
retq
movq %rax, %r14
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x2fb5b
callq 0x27560
movq %rbx, %rdi
callq 0x27c8b
movq %r14, %rdi
callq 0x27b20
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5e9cc(%rip), %rax     # 0x8f700
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x30d75
movq 0x40(%r14), %rdi
leaq 0x50(%r14), %rax
cmpq %rax, %rdi
je 0x30d52
callq 0x27560
movq 0x20(%r14), %rdi
leaq 0x30(%r14), %rax
cmpq %rax, %rdi
je 0x30d64
callq 0x27560
leaq 0x8(%r14), %rdi
callq 0x2f0de
movq %r14, %rdi
callq 0x27560
movq $0x0, 0x8(%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x30d8b
callq 0x27560
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x27560
movq %rbx, %rdi
callq 0x27b20
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %esi, %edi
movq %rdx, %rsi
movl $0x1, %edx
callq 0x64002
movl $0x8, %edi
callq 0x275c0
movq 0x8(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x10(%rbx)
movq %rax, %rdi
callq 0x30478
xorb $0x1, %al
movzbl %al, %eax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
leaq 0x5e252(%rip), %rax     # 0x8f748
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x3152e
movq 0x28(%r14), %rdi
leaq 0x38(%r14), %rax
cmpq %rax, %rdi
je 0x31514
callq 0x27560
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x31526
callq 0x27560
movq %r14, %rdi
callq 0x27560
movq $0x0, 0x8(%rbx)
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x3154f
movq %r14, %rdi
callq 0x316a4
movq %r14, %rdi
callq 0x27560
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x27560
movq %rbx, %rdi
callq 0x27b20
// File: /workspace/github_cpp_makefile_star2_O1/zeeev[P]DASVC/bamtools/src/toolkit/bamtools_coverage.cpp
// Function: BamTools::CoverageTool::Run(int, char**)
int CoverageTool::Run(int argc, char* argv[]) { 

    // parse command line arguments
    Options::Parse(argc, argv, 1);
    
    // initialize CoverageTool with settings
    m_impl = new CoverageToolPrivate(m_settings);
    
    // run CoverageTool, return success/fail
    if ( m_impl->Run() ) 
        return 0;
    else 
        return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %edi
movq %rdx, %rsi
movl $0x1, %edx
callq 0x64002
movl $0x130, %edi            # imm = 0x130
callq 0x275c0
movq %rax, %r14
movq 0x8(%rbx), %rax
movq %rax, (%r14)
leaq 0x8(%r14), %rdi
movq 0x5e9b1(%rip), %rax     # 0x8ff90
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq 0xe8(%rax,%rcx), %rsi
callq 0x27290
xorps %xmm0, %xmm0
movups %xmm0, 0x118(%r14)
movq $0x0, 0x128(%r14)
movq %r14, 0x10(%rbx)
movq %r14, %rdi
callq 0x30e20
xorb $0x1, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x27560
movq %rbx, %rdi
callq 0x27b20
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31fa4
movq 0x18(%rbx), %rax
cmpb $0x1, 0x4(%rax)
jne 0x34b76
movq %rbx, %rdi
popq %rbx
jmp 0x33f02
movq %rbx, %rdi
popq %rbx
jmp 0x3213c
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x58aac(%rip), %rax     # 0x8f7d0
movq %rax, (%rdi)
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x36d40
movq %rbx, %rdi
callq 0x3a3a8
movq %rbx, %rdi
callq 0x27560
movq $0x0, 0x8(%r14)
movq 0x10(%r14), %rbx
testq %rbx, %rbx
je 0x36d61
movq %rbx, %rdi
callq 0x3182e
movq %rbx, %rdi
callq 0x27560
movq $0x0, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x36d73
movq %rax, %r14
movq %rbx, %rdi
callq 0x27560
movq %r14, %rdi
callq 0x27b20
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %esi, %edi
movq %rdx, %rsi
movl $0x1, %edx
callq 0x64002
movl $0x148, %edi            # imm = 0x148
callq 0x275c0
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x317e8
movq %r14, 0x10(%rbx)
movq %r14, %rdi
callq 0x34548
xorb $0x1, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x27560
movq %rbx, %rdi
callq 0x27b20
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x38(%rbx), %rax
subq 0x30(%rbx), %rax
movq %rsi, %r14
sarq $0x3, %rax
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
imulq %r13, %rax
movq %rax, %rsi
callq 0x425d8
movq 0x30(%rbx), %r15
movq 0x38(%rbx), %rbp
cmpq %rbp, %r15
je 0x39991
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2e1b0
addq $0x28, %r15
cmpq %rbp, %r15
jne 0x3997d
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x425a7
movl %eax, %ebp
testb %al, %al
jne 0x39a24
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x2f122
leaq 0x30(%rbx), %rdi
leaq 0x20(%rsp), %rsi
movb $0x0, 0x20(%rsi)
callq 0x3b06c
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x399e6
callq 0x27560
movq 0x30(%rbx), %r14
movq 0x38(%rbx), %rbx
cmpq %rbx, %r14
je 0x39a24
movq %rbx, %rax
subq %r14, %rax
sarq $0x3, %rax
imulq %r13, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b7b2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b88f
xorb $0x1, %bpl
movq %rsp, %rdi
callq 0x2f0de
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x39a5c
callq 0x27560
jmp 0x39a5c
jmp 0x39a59
jmp 0x39a68
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2f0de
jmp 0x39a73
jmp 0x39a7b
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2f0de
movq %rbx, %rdi
callq 0x27b20
movq %rax, %rdi
callq 0x2e1ed
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3ad0f(%rip), %rdx     # 0x7781b
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x2f1b2
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movl $0x18, %edx
callq 0x279c0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3cb37
callq 0x27560
movq 0x18(%rbx), %r15
leaq 0x30(%rsp), %r14
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq %r14, %rdi
callq 0x276c0
cmpq $0x2, 0x28(%rbx)
jb 0x3cbb4
movq %r15, %rdi
callq 0x276d0
leaq 0x8(%rbx), %r13
cmpq %r13, %rax
je 0x3cbb4
movq %rax, %r15
leaq 0x36a29(%rip), %rbp     # 0x7359b
leaq 0x36a26(%rip), %r12     # 0x7359f
cmpl $0x0, 0xbc(%rbx)
movq %r12, %rsi
cmoveq %rbp, %rsi
movl $0x3, %edx
movq %r14, %rdi
callq 0x276c0
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq %r14, %rdi
callq 0x276c0
movq %r15, %rdi
callq 0x276d0
movq %rax, %r15
cmpq %r13, %rax
jne 0x3cb79
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x279a0
addq $0x48, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
leaq 0x10(%rsp), %r14
callq 0x27350
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3cbe3
callq 0x27560
leaq 0x20(%rsp), %rdi
callq 0x27490
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3cc31
callq 0x27560
jmp 0x3cc31
jmp 0x3cc2e
jmp 0x3cc2e
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3cc3b
callq 0x27560
jmp 0x3cc3b
movq %rax, %rbx
jmp 0x3cc3b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x27490
movq %rbx, %rdi
callq 0x27b20
movq %rax, %rdi
callq 0x2e1ed
nop