LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/xukmin[P]rase/sensor-network.cc
// Function: SensorNetwork::AddSensors(std::vector<Position, std::allocator<Position>> const&)
void SensorNetwork::AddSensors(const std::vector<Position>& positions) {
  RemoveSensors();
  for (int i = 0; i < positions.size(); i++) {
    AddSensor(positions[i]);
  }

  CalculateDistances(positions, &distances_);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4a82
movq (%rbx), %rsi
cmpq %rsi, 0x8(%rbx)
je 0x4a6b
xorl %r15d, %r15d
xorl %r12d, %r12d
addq %r15, %rsi
movq %r14, %rdi
callq 0x4348
incq %r12
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x4, %rax
addq $0x10, %r15
cmpq %r12, %rax
ja 0x4a46
addq $0x78, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4ad3
// File: /workspace/github_cpp_makefile_star2_O3/xukmin[P]rase/sensor-network.cc
// Function: (anonymous namespace)::CalculateDistances(std::vector<Position, std::allocator<Position>> const&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>*)
void CalculateDistances(const std::vector<Position>& positions,
                        std::vector<std::vector<double> >* distances) {
  distances->clear();
  distances->resize(positions.size());
  for (int i = 0; i < distances->size(); i++) {
    (*distances)[i].resize(positions.size());
  }

  for (int i = 0; i < positions.size(); i++) {
    for (int j = i + 1; j < positions.size(); j++) {
      (*distances)[i][j] = (*distances)[j][i] =
          Distance(positions[i], positions[j]);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r12
movq %rdi, %r13
movq (%rsi), %rsi
movq %r12, %rdi
callq 0x549e
movq 0x8(%r13), %rsi
subq (%r13), %rsi
sarq $0x4, %rsi
movq %r12, %rdi
callq 0x5430
movq (%r12), %rdi
cmpq %rdi, 0x8(%r12)
je 0x4b54
xorl %ebx, %ebx
movabsq $-0x5555555555555555, %r14 # imm = 0xAAAAAAAAAAAAAAAB
xorl %r15d, %r15d
addq %rbx, %rdi
movq 0x8(%r13), %rsi
subq (%r13), %rsi
sarq $0x4, %rsi
callq 0x546c
incq %r15
movq (%r12), %rdi
movq 0x8(%r12), %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %r14, %rax
addq $0x18, %rbx
cmpq %r15, %rax
ja 0x4b20
movq %r12, 0x18(%rsp)
movq (%r13), %rsi
movq %r13, 0x10(%rsp)
movq 0x8(%r13), %rax
cmpq %rsi, %rax
je 0x4c47
movl $0x1, %r14d
movl $0x3, %ebx
movl $0x10, %r13d
xorl %ecx, %ecx
movq 0x18(%rsp), %r15
movq 0x10(%rsp), %r12
movq %rcx, 0x8(%rsp)
leaq 0x1(%rcx), %rdx
movq %rax, %rcx
subq %rsi, %rcx
sarq $0x4, %rcx
movq %rdx, 0x20(%rsp)
cmpq %rdx, %rcx
movq %r14, 0x38(%rsp)
movq %rbx, 0x30(%rsp)
movq %r13, 0x28(%rsp)
jbe 0x4c1c
movq 0x8(%rsp), %rax
movq %rax, %rbp
shlq $0x4, %rbp
leaq (%rax,%rax,2), %rax
movq %rax, 0x40(%rsp)
leaq (%rsi,%rbp), %rdi
addq %r13, %rsi
callq 0x666b
movq (%r15), %rax
movq (%rax,%rbx,8), %rcx
movq 0x8(%rsp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movq 0x40(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
movq (%r12), %rsi
movq 0x8(%r12), %rax
movq %rax, %rcx
subq %rsi, %rcx
sarq $0x4, %rcx
addq $0x3, %rbx
addq $0x10, %r13
cmpq %r14, %rcx
ja 0x4bcd
movq 0x38(%rsp), %r14
incq %r14
movq 0x30(%rsp), %rbx
addq $0x3, %rbx
movq 0x28(%rsp), %r13
addq $0x10, %r13
movq 0x20(%rsp), %rdx
cmpq %rdx, %rcx
movq %rdx, %rcx
ja 0x4b8c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xukmin[P]rase/routing-builders.cc
// Function: RoutingBuilder::BuildRouting(SensorNetwork*)
void RoutingBuilder::BuildRouting(SensorNetwork* network) {
  network->RemoveParents();
  std::vector<std::vector<int> > candidates;
  bool succeeded = GenerateParentCandidates(network, &candidates);
  assert(succeeded);

  // Base station does not need to and cannot select parent.
  for (int i = 1; i < network->num_sensors(); i++) {
    network->SetParent(i, selector_->SelectParent(i, candidates[i], *network));
  }
  // Make sure the routing generator works as expected.
  assert(network->IsConnectedWithRoutings());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x4f3e
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %rbx, %rdi
callq 0x6690
testb %al, %al
je 0x6b07
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0x38e38e39, %eax, %eax # imm = 0x38E38E39
cmpl $0x2, %eax
jl 0x6ae5
movl $0x1, %r15d
movl $0x18, %r12d
movl $0x8c, %r13d
movq 0x48(%r14), %rdi
movq (%rsp), %rdx
addq %r12, %rdx
movq (%rdi), %rax
movl %r15d, %esi
movq %rbx, %rcx
callq *0x10(%rax)
movq (%rbx), %rcx
movl %eax, (%rcx,%r13)
incq %r15
movq 0x8(%rbx), %rax
subq %rcx, %rax
shrq $0x3, %rax
imull $0x38e38e39, %eax, %eax # imm = 0x38E38E39
cltq
addq $0x18, %r12
addq $0x48, %r13
cmpq %rax, %r15
jl 0x6aa4
movq %rbx, %rdi
callq 0x5068
testb %al, %al
je 0x6b26
movq %rsp, %rdi
callq 0x77a0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2a91(%rip), %rdi      # 0x959f
leaq 0x29c7(%rip), %rsi      # 0x94dc
leaq 0x2a8d(%rip), %rcx      # 0x95a9
movl $0x57, %edx
callq 0x30e0
leaq 0x2aaf(%rip), %rdi      # 0x95dc
leaq 0x29a8(%rip), %rsi      # 0x94dc
leaq 0x2a6e(%rip), %rcx      # 0x95a9
movl $0x5e, %edx
callq 0x30e0
jmp 0x6b47
movq %rax, %rbx
movq %rsp, %rdi
callq 0x77a0
movq %rbx, %rdi
callq 0x3270
// File: /workspace/github_cpp_makefile_star2_O3/xukmin[P]rase/routing-builders.cc
// Function: NearestFirstParentSelector::SelectParent(int, std::vector<int, std::allocator<int>> const&, SensorNetwork const&)
int NearestFirstParentSelector::SelectParent(int sensor,
                                             const std::vector<int>& candidates,
                                             const SensorNetwork& network) {
  assert(!candidates.empty());
  int parent = candidates[0];
  double min_distance = network.GetDistance(sensor, parent);
  for (int i = 1; i < candidates.size(); i++) {
    double distance = network.GetDistance(sensor, candidates[i]);
    if (distance < min_distance) {
      parent = candidates[i];
      min_distance = distance;
    }
  }

  return parent;
}

// Assembly:
pushq %rax
movq (%rdx), %rdi
movq 0x8(%rdx), %rdx
cmpq %rdx, %rdi
je 0x7061
movl (%rdi), %eax
subq %rdi, %rdx
sarq $0x2, %rdx
cmpq $0x2, %rdx
jb 0x705f
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 %xmm1, %xmm0
cmoval %r8d, %eax
minsd %xmm0, %xmm1
incq %rsi
movapd %xmm1, %xmm0
cmpq %rsi, %rdx
jne 0x703d
popq %rcx
retq
leaq 0x2597(%rip), %rdi      # 0x95ff
leaq 0x246d(%rip), %rsi      # 0x94dc
leaq 0x27a4(%rip), %rcx      # 0x981a
movl $0xc0, %edx
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7233
subq %rdi, %rdx
movl (%rdi), %r8d
cmpq $0x4, %rdx
je 0x722e
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 0x71ca
movl %eax, %r9d
movapd %xmm2, %xmm1
jmp 0x71d8
movl %r8d, %r9d
movapd %xmm0, %xmm1
movl %eax, %r8d
movapd %xmm2, %xmm0
cmpq $0x3, %rdx
jb 0x722e
movl $0x2, %esi
movslq (%rdi,%rsi,4), %rax
movsd (%rcx,%rax,8), %xmm2
ucomisd %xmm2, %xmm1
jbe 0x7202
movl %eax, %r10d
movapd %xmm2, %xmm3
movl %r9d, %eax
movapd %xmm1, %xmm2
jmp 0x7216
movl %r9d, %r10d
movapd %xmm1, %xmm3
ucomisd %xmm2, %xmm0
ja 0x7216
movl %r8d, %eax
movapd %xmm0, %xmm2
incq %rsi
movapd %xmm2, %xmm0
movl %eax, %r8d
movapd %xmm3, %xmm1
movl %r10d, %r9d
cmpq %rsi, %rdx
jne 0x71e3
jmp 0x7231
movl %r8d, %eax
popq %rcx
retq
leaq 0x23c5(%rip), %rdi      # 0x95ff
leaq 0x229b(%rip), %rsi      # 0x94dc
leaq 0x263d(%rip), %rcx      # 0x9885
movl $0xdf, %edx
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x73a1
movl (%rdi), %eax
subq %rdi, %rdx
sarq $0x2, %rdx
cmpq $0x2, %rdx
jb 0x739f
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 0x737d
popq %rcx
retq
leaq 0x2257(%rip), %rdi      # 0x95ff
leaq 0x212d(%rip), %rsi      # 0x94dc
leaq 0x2572(%rip), %rcx      # 0x9928
movl $0x10c, %edx            # imm = 0x10C
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7a1c
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x7a1c
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 0x1e99(%rip), %rsi      # 0x9cf8
callq 0x31b0
movq %rax, 0x68(%rbx)
testq %rax, %rax
je 0x7e79
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x33dd
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x7e98
movq (%r12), %rsi
incq %rsi
callq 0x3170
movq %r14, %rdi
callq 0x3270
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3586(%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 0x34f3(%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
movl 0x4(%rbx), %ecx
testl %ecx, %ecx
je 0x2c53
movl (%rbx), %eax
xorl %ebp, %ebp
leaq 0x7(%rsp), %r15
movl $0x0, %edx
testl %eax, %eax
je 0x2c4b
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 0x2be1
movl 0x4(%rbx), %ecx
movl %eax, %edx
incl %ebp
movl %edx, %eax
cmpl %ecx, %ebp
jb 0x2bd5
movq 0x6376(%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 0x2c99
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x33a9(%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 0x330f(%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 0x2e8b
xorl %r13d, %r13d
leaq 0x7(%rsp), %r15
movl (%rbx), %eax
testl %eax, %eax
je 0x2e4e
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 0x2dc4
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 0x2db7
movq 0x613e(%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 0x2ed3
jmp 0x2ed3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x32dc
leaq 0x8(%rsp), %rax
addl 0x8(%rax), %edx
cmpl %edx, %ecx
jae 0x32dc
movl 0x4(%rdi), %ecx
movl 0xc(%rdi), %esi
addl %ecx, %esi
movl 0x4(%rax), %edx
cmpl %edx, %esi
jae 0x32df
xorl %eax, %eax
retq
addl 0xc(%rax), %edx
cmpl %edx, %ecx
setb %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3246
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3382
movl %eax, %ecx
movl $0x1, %eax
testb %cl, %cl
jne 0x343e
leaq 0x4(%rsp), %r14
movq %r14, %rdi
callq 0x3264
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3382
movzbl %al, %eax
addl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %rcx
movq 0x18(%rdi), %rax
cmpq %rax, %rcx
je 0x355d
subq %rcx, %rax
addq $-0x14, %rax
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
mulq %rdx
movq %rdx, %xmm0
shrq $0x4, %rdx
addq $0x4, %rdx
andq $-0x4, %rdx
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
psrlq $0x4, %xmm0
addq $0x40, %rcx
xorl %eax, %eax
movdqa 0x2c49(%rip), %xmm1     # 0x60e0
movdqa 0x2c51(%rip), %xmm2     # 0x60f0
movdqa 0x2c59(%rip), %xmm3     # 0x6100
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rax, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edi
notl %edi
testb $0x1, %dil
je 0x34f5
movl %esi, -0x3c(%rcx)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0x3507
movl %esi, -0x28(%rcx)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %edi
testb $0x1, %dil
je 0x353f
movl %esi, -0x14(%rcx)
pextrw $0x4, %xmm5, %edi
testb $0x1, %dil
je 0x354c
movl %esi, (%rcx)
addq $0x4, %rax
addq $0x50, %rcx
cmpq %rax, %rdx
jne 0x34af
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0xc(%rsp)
movq %rsi, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq (%rdi), %r15
movq 0x8(%rdi), %r14
cmpq %r14, %r15
je 0x3910
movl %edx, %ebp
leaq 0x30(%rsp), %r12
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %rbx
cmpq %rbx, %r13
je 0x384b
movq %r13, %rdi
movq %r15, %rsi
callq 0x3382
testb %al, %al
jne 0x387e
addq $0x28, %r13
jmp 0x3831
movq %r12, %rdi
movl %ebp, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x32e8
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x39c8
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x387e
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
addq $0x14, %r15
cmpq %r14, %r15
jne 0x3827
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %r12
cmpq %r12, %r15
je 0x3910
leaq 0x30(%rsp), %r14
movl 0xc(%rsp), %r13d
movl (%r15), %eax
addl %r13d, %eax
cmpl 0xc(%rsp), %eax
jbe 0x38e1
movq %r14, %rdi
movl %ebp, %esi
movl 0xc(%rsp), %edx
callq 0x3720
movq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x3bee
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x38de
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
xorl %r13d, %r13d
movq %r15, %rdi
movl %r13d, %esi
callq 0x3446
movl (%r15), %ebx
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
addq $-0x20, %rdi
movq %r15, %rsi
callq 0x3780
addl %ebx, %r13d
addq $0x28, %r15
cmpq %r12, %r15
jne 0x38a0
leaq 0x10(%rsp), %rdi
callq 0x3974
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x395f
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x3962
movq 0x48(%rsp), %rsi
jmp 0x3953
jmp 0x395f
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x3962
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
jmp 0x3962
jmp 0x395f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3974
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d5e
callq 0x363b
callq 0x37b6
callq 0x3934
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_O3/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 0x5604
testb %al, %al
je 0x47f5
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 0x1d87(%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 0x1d7e(%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 0x488b
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0x4897
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 0x44de(%rip), %rsi      # 0x8da0
leaq 0xb1d(%rip), %rdx       # 0x53e6
movq %r14, %rdi
callq 0x2230
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x48fd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x48fd
movq %rax, %rbx
movq %r14, %rdi
callq 0x20f0
jmp 0x48fd
movq %rax, %rbx
movq 0x46cc(%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_O3/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 0x4eab
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %rbx
movl %esi, %ebp
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x21b0
leaq 0x163b(%rip), %rsi      # 0x64ff
movl $0x1c, %edx
movq %r14, %rdi
callq 0x2190
movl $0x30, %edi
callq 0x2090
movq %rax, %r14
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x21e0
movq %r14, %rax
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x10(%rsp), %r15
movq -0x10(%r15), %rcx
cmpq %r15, %rcx
jne 0x4f0c
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0x4f18
movq %rcx, (%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r14)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%r14)
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movl %ebp, 0x20(%r14)
movq %rbx, 0x28(%r14)
leaq 0x3e5e(%rip), %rsi      # 0x8da0
leaq 0x49d(%rip), %rdx       # 0x53e6
movq %r14, %rdi
callq 0x2230
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4f7c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x4f7c
movq %rax, %rbx
movq %r14, %rdi
callq 0x20f0
jmp 0x4f7c
movq %rax, %rbx
movq 0x404d(%rip), %rsi      # 0x8fd0
leaq 0x20(%rsp), %rdi
callq 0x20a0
leaq 0x90(%rsp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4fc1
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %rbx
movl %esi, %ebp
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x21b0
leaq 0x1542(%rip), %rsi      # 0x651c
movl $0x1c, %edx
movq %r14, %rdi
callq 0x2190
movl $0x30, %edi
callq 0x2090
movq %rax, %r14
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x21e0
movq %r14, %rax
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x10(%rsp), %r15
movq -0x10(%r15), %rcx
cmpq %r15, %rcx
jne 0x5022
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0x502e
movq %rcx, (%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r14)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%r14)
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movl %ebp, 0x20(%r14)
movq %rbx, 0x28(%r14)
leaq 0x3d48(%rip), %rsi      # 0x8da0
leaq 0x387(%rip), %rdx       # 0x53e6
movq %r14, %rdi
callq 0x2230
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5092
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x5092
movq %rax, %rbx
movq %r14, %rdi
callq 0x20f0
jmp 0x5092
movq %rax, %rbx
movq 0x3f37(%rip), %rsi      # 0x8fd0
leaq 0x20(%rsp), %rdi
callq 0x20a0
leaq 0x90(%rsp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2b1a6
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 0x2d55a
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6533c
movq %r15, %rdi
movq %r14, %rsi
callq 0x653c0
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 0x2b17f
movq %r12, %rdi
movq %r15, %rsi
callq 0x653b8
jmp 0x2b163
leaq 0x8(%rsp), %rdi
callq 0x653ee
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x10(%rsp), %rdi
callq 0x27920
leaq 0x8(%rsp), %rdi
callq 0x65376
testq %rbx, %rbx
setne %al
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2b1cc
movq %rax, %rbx
movq %r14, %rdi
callq 0x27560
jmp 0x2b1e8
jmp 0x2b1d1
movq %rax, %rbx
jmp 0x2b1de
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x27920
leaq 0x8(%rsp), %rdi
callq 0x65376
movq %rbx, %rdi
callq 0x27b10
movq %rax, %rdi
callq 0x2e1cd
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2b340
addq $0x20, %rdi
leaq (%rsi,%rsi,4), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x8(%rax,%rcx,8), %rdx
callq 0x276b0
movq %rax, %r15
leaq 0x4b5c9(%rip), %r14     # 0x76816
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x276b0
movl 0xac(%rbx), %esi
movq %r15, %rdi
callq 0x27ab0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x276b0
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x27520
movq %r15, %rdi
movl %eax, %esi
callq 0x27ab0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x276b0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x276b0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x276b0
movzwl 0xb2(%rbx), %esi
movq %r15, %rdi
callq 0x27400
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x276b0
movq %rbx, %rdi
callq 0x277f0
leaq 0x460c0(%rip), %rcx     # 0x713ba
leaq 0x45fef(%rip), %rsi     # 0x712f0
testb %al, %al
cmovneq %rcx, %rsi
movl $0x1, %edx
movq %r15, %rdi
callq 0x276b0
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 0x4641f(%rip), %rdi     # 0x71766
xorl %eax, %eax
callq 0x278b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x611dc(%rip), %rax     # 0x8e5d8
movq %rax, (%rdi)
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x2d477
movq 0xa0(%rbx), %rdi
leaq 0xb0(%rbx), %rax
cmpq %rax, %rdi
je 0x2d420
callq 0x27560
movq 0x80(%rbx), %rdi
leaq 0x90(%rbx), %rax
cmpq %rax, %rdi
je 0x2d438
callq 0x27560
movq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0x2d44a
callq 0x27560
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x2d45c
callq 0x27560
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x2d46e
callq 0x27560
leaq 0x8(%rbx), %rdi
callq 0x2f0c0
movq %rbx, %rdi
callq 0x27560
movq $0x0, 0x8(%r14)
movq 0x10(%r14), %rbx
testq %rbx, %rbx
je 0x2d498
movq %rbx, %rdi
callq 0x2ef90
movq %rbx, %rdi
callq 0x27560
movq $0x0, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x2d4b2
movq %rax, %r14
movq %rbx, %rdi
callq 0x27560
movq %r14, %rdi
callq 0x27b10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x63ac2
movl $0x130, %edi            # imm = 0x130
callq 0x275c0
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x2efd2
movq %r14, 0x10(%rbx)
movq %r14, %rdi
callq 0x2a99c
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 0x27b10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6108b(%rip), %rax     # 0x8e608
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x62e5c
movb $0x0, 0x10(%r15)
movb %bpl, 0x11(%r15)
movq %r14, 0x18(%r15)
leaq 0x20(%r15), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x2f02e
cmpq $0x0, 0x8(%r12)
je 0x2d696
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x49253(%rip), %rdx     # 0x76817
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x2f1a0
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x2f10a
leaq 0x44088(%rip), %rsi     # 0x7167f
leaq 0x8(%rsp), %rdi
callq 0x27c00
leaq 0x8(%rsp), %rdi
callq 0x66056
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d61c
callq 0x27560
testb %bpl, %bpl
je 0x2d669
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
callq 0x2f10a
leaq 0x4403e(%rip), %rsi     # 0x7167f
leaq 0x8(%rsp), %rdi
callq 0x27c00
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x27350
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d669
callq 0x27560
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x62efe
testb %al, %al
je 0x2d682
movb $0x1, 0x10(%r15)
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2d696
callq 0x27560
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d6af
jmp 0x2d6af
jmp 0x2d6c3
jmp 0x2d6c3
jmp 0x2d6af
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d6c6
callq 0x27560
jmp 0x2d6c6
movq %rax, %r15
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2d6df
callq 0x27560
jmp 0x2d6df
movq %rax, %r15
movq %r14, %rdi
callq 0x2e37a
jmp 0x2d6ec
movq %rax, %r15
movq %rbx, %rdi
callq 0x62e96
movq %r15, %rdi
callq 0x27b10
movq %rax, %rdi
callq 0x2e1cd
// File: /workspace/github_cpp_makefile_star2_O3/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 0x60ef6(%rip), %rax     # 0x8e608
movq %rax, (%rdi)
cmpb $0x1, 0x10(%rdi)
jne 0x2d728
leaq 0x8(%rbx), %rdi
callq 0x62ed8
movb $0x0, 0x10(%rbx)
leaq 0x20(%rbx), %rdi
callq 0x2e37a
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x62e96
movq %rax, %r14
leaq 0x20(%rbx), %rdi
callq 0x2e37a
jmp 0x2d755
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x62e96
movq %r14, %rdi
callq 0x27b10
movq %rax, %rdi
callq 0x2e1cd
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f770
incq 0x8(%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2f787
decq 0x8(%rdi)
jne 0x2f787
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_O3/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 0x2faa0
decq 0x8(%rdi)
jne 0x2faa0
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
addq $0x8, %rsp
cmpq %rbx, %rdi
je 0x2fab9
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 0x2fad2
callq 0x27560
movq %r14, %rdi
callq 0x27b10
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2faf6
decq 0x8(%rdi)
jne 0x2faf6
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x2fb08
callq 0x27560
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x2fb1a
callq 0x27560
movq (%rbx), %rdi
addq $0x10, %rbx
addq $0x8, %rsp
cmpq %rbx, %rdi
je 0x2fb32
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 0x2fb4b
callq 0x27560
movq %rbx, %rdi
callq 0x27c7b
movq %r14, %rdi
callq 0x27b10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5d9da(%rip), %rax     # 0x8e700
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x30d5f
movq 0x40(%r14), %rdi
leaq 0x50(%r14), %rax
cmpq %rax, %rdi
je 0x30d44
callq 0x27560
movq 0x20(%r14), %rdi
leaq 0x30(%r14), %rax
cmpq %rax, %rdi
je 0x30d56
callq 0x27560
leaq 0x8(%r14), %rdi
callq 0x2f0c0
movq %r14, %rdi
callq 0x27560
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
movq 0x10(%rbx), %rdi
callq 0x27560
movq %r14, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x27560
movq %rbx, %rdi
callq 0x27b10
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5d26a(%rip), %rax     # 0x8e748
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x3150e
movq 0x28(%r14), %rdi
leaq 0x38(%r14), %rax
cmpq %rax, %rdi
je 0x314fc
callq 0x27560
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x3150e
callq 0x27560
movq %r14, %rdi
callq 0x27560
movq $0x0, 0x8(%rbx)
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x3152f
movq %r14, %rdi
callq 0x3168c
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 0x27b10
// File: /workspace/github_cpp_makefile_star2_O3/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 0x63ac2
movl $0x130, %edi            # imm = 0x130
callq 0x275c0
movq %rax, %r14
movq 0x8(%rbx), %rax
movq %rax, (%r14)
leaq 0x8(%r14), %rdi
movq 0x5d9c9(%rip), %rax     # 0x8ef90
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 0x30e08
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 0x27b10
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x31f6a
movq 0x18(%rbx), %rax
cmpb $0x1, 0x4(%rax)
jne 0x34b3e
movq %rbx, %rdi
popq %rbx
jmp 0x33ec8
movq %rbx, %rdi
popq %rbx
jmp 0x32102
nop