LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: iamlouk[P]asbi/src/events/utils.hh
// Function: asbi::evts::SortedQueue<asbi::evts::Timer, std::less<asbi::evts::Timer>>::insert(asbi::evts::Timer)
void insert(T in) {
			Comp cmp = Comp();

			/*int s1 = size();
			Node **p = &head;
			while (*p != nullptr && cmp((*p)->value, in))
				p = &((*p)->next);

			if (*p == nullptr) {
				*p = node;
			} else {
			 	node->next = (*p)->next;
				*p = node;
			}
			assert(s1 + 1 == size());*/



			Node *drag = nullptr, *curr = head;
			while (curr != nullptr && cmp(curr->value, in)) {
				drag = curr;
				curr = curr->next;
			}

			if (drag == nullptr)
				head = new Node(in, head);
			else
				drag->next = new Node(in, curr);

		}

// Assembly:
subq $0x88, %rsp
movq %rsi, 0x78(%rsp)
movsd %xmm0, 0x80(%rsp)
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x6f(%rsp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x6250
movq 0x18(%rsp), %rax
movq $0x0, 0x60(%rsp)
movq (%rax), %rax
movq %rax, 0x58(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x58(%rsp)
movb %al, 0x17(%rsp)
je 0x31a61
movq 0x58(%rsp), %rsi
leaq 0x6f(%rsp), %rdi
leaq 0x78(%rsp), %rdx
callq 0x35f00
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x31a6b
jmp 0x31a85
movq 0x58(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x58(%rsp)
jmp 0x31a3b
cmpq $0x0, 0x60(%rsp)
jne 0x31af7
movl $0x18, %edi
callq 0x6460
movq %rax, %rdi
movq 0x18(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x8(%rsp)
movups 0x78(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
movq (%rax), %rdx
movq 0x40(%rsp), %rsi
movsd 0x48(%rsp), %xmm0
callq 0x35f30
jmp 0x31ac6
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x31b59
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x18, %esi
callq 0x6470
jmp 0x31b61
movl $0x18, %edi
callq 0x6460
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movups 0x78(%rsp), %xmm0
movaps %xmm0, 0x20(%rsp)
movq 0x58(%rsp), %rdx
movq 0x20(%rsp), %rsi
movsd 0x28(%rsp), %xmm0
callq 0x35f30
jmp 0x31b2c
movq (%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x31b59
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x18, %esi
callq 0x6470
jmp 0x31b61
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x67a0
nopl (%rax,%rax)
// File: iamlouk[P]asbi/src/tests.cc
// Function: tests::test(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, asbi::Value)
void test(const std::string code, Value expected) {
		Context ctx;
		std::cout << "test(\'" << code << "\'): " << std::flush;
		Value res = ctx.run(code);
		assert(res == expected);
		std::cout << "SUCCESS\n";
	}

// Assembly:
subq $0x5d8, %rsp            # imm = 0x5D8
movq %rdi, 0x28(%rsp)
movl %esi, 0x5c8(%rsp)
movq %rdx, 0x5d0(%rsp)
movq %rdi, 0x5c0(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x26480
movq 0x15fdc(%rip), %rdi     # 0x4bfb0
leaq 0x38ad(%rip), %rsi      # 0x39888
callq 0x6450
movq %rax, 0x30(%rsp)
jmp 0x35fe7
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdi
callq 0x63d0
movq %rax, 0x20(%rsp)
jmp 0x35ffd
movq 0x20(%rsp), %rdi
leaq 0x3886(%rip), %rsi      # 0x3988f
callq 0x6450
movq %rax, 0x18(%rsp)
jmp 0x36015
movq 0x18(%rsp), %rdi
movq 0x15f97(%rip), %rsi     # 0x4bfb8
callq 0x64a0
jmp 0x36028
movq 0x28(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x26be0
movq %rdx, 0x8(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x36042
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0x38(%rsp)
movq %rax, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x5c8(%rsp), %rsi
callq 0x21de0
movb %al, 0x7(%rsp)
jmp 0x3606c
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x36076
jmp 0x36078
jmp 0x360b1
leaq 0x3815(%rip), %rdi      # 0x39894
leaq 0x381e(%rip), %rsi      # 0x398a4
movl $0x17, %edx
leaq 0x381b(%rip), %rcx      # 0x398ad
callq 0x62b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x268b0
jmp 0x360d8
movq 0x15ef8(%rip), %rdi     # 0x4bfb0
leaq 0x3819(%rip), %rsi      # 0x398d8
callq 0x6450
jmp 0x360c6
leaq 0x58(%rsp), %rdi
callq 0x268b0
addq $0x5d8, %rsp            # imm = 0x5D8
retq
movq 0x50(%rsp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
// File: knei-knurow[P]lidar-visualizations/src/main.cpp
// Function: main
int main(int argc, char** argv) {
  std::vector<std::string> args;
  for (int i = 1; i < argc; i++) {
    args.push_back(std::string(argv[i]));
  }
  return App(args).run();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4a90
movl $0x1, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x49fb
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x98(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x4620
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x4ae0
jmp 0x49a1
leaq -0x28(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4ab0
jmp 0x49b0
leaq -0x50(%rbp), %rdi
callq 0x4230
leaq -0x51(%rbp), %rdi
callq 0x43c0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4959
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x49f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4230
leaq -0x51(%rbp), %rdi
callq 0x43c0
jmp 0x4a71
leaq -0x88(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5a40
jmp 0x4a0d
leaq -0x88(%rbp), %rdi
callq 0x6b50
movl %eax, -0x9c(%rbp)
jmp 0x4a21
movl -0x9c(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x6b10
leaq -0x28(%rbp), %rdi
callq 0x4b90
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x4a71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x6b10
leaq -0x28(%rbp), %rdi
callq 0x4b90
movq -0x60(%rbp), %rdi
callq 0x4610
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: knei-knurow[P]lidar-visualizations/src/app.cpp
// Function: App::run()
int App::run() {
  Cloud cloud;

  while (running_) {
    // Grab cloud
    if (running_ && cloud_grabber_) {
      if (!cloud_grabber_->read(cloud)) {
        running_ = false;
      }
    }

    // Do some additional things, depending on the selected scenario
    if (running_ && scenario_) {
      if (!scenario_->update(cloud)) {
        running_ = false;
      }
    }

    // Update the GUI with new data
    // Save output files on user's request
    if (running_ && gui_) {
      if (!gui_->update(cloud)) {
        running_ = false;
      }
    }
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x8040
movq -0x70(%rbp), %rax
testb $0x1, (%rax)
je 0x6c8d
movq -0x70(%rbp), %rax
testb $0x1, (%rax)
je 0x6be9
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
callq 0x80a0
testb $0x1, %al
jne 0x6b99
jmp 0x6be9
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
callq 0x80d0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0x58(%rbp), %rsi
callq *%rax
movb %al, -0x71(%rbp)
jmp 0x6bbb
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x6be7
jmp 0x6bc4
movq -0x70(%rbp), %rax
movb $0x0, (%rax)
jmp 0x6be7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x8190
jmp 0x6ca1
jmp 0x6be9
movq -0x70(%rbp), %rax
testb $0x1, (%rax)
je 0x6c39
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
callq 0x80f0
testb $0x1, %al
jne 0x6c05
jmp 0x6c39
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
callq 0x8120
movq %rax, %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0x58(%rbp), %rsi
callq *%rax
movb %al, -0x72(%rbp)
jmp 0x6c27
movb -0x72(%rbp), %al
testb $0x1, %al
jne 0x6c37
jmp 0x6c30
movq -0x70(%rbp), %rax
movb $0x0, (%rax)
jmp 0x6c39
movq -0x70(%rbp), %rax
testb $0x1, (%rax)
je 0x6c88
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
callq 0x8140
testb $0x1, %al
jne 0x6c55
jmp 0x6c88
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
callq 0x8170
movq %rax, %rdi
movq (%rdi), %rax
movq (%rax), %rax
leaq -0x58(%rbp), %rsi
callq *%rax
movb %al, -0x73(%rbp)
jmp 0x6c76
movb -0x73(%rbp), %al
testb $0x1, %al
jne 0x6c86
jmp 0x6c7f
movq -0x70(%rbp), %rax
movb $0x0, (%rax)
jmp 0x6c88
jmp 0x6b70
leaq -0x58(%rbp), %rdi
callq 0x8190
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x4610
nopw (%rax,%rax)
// File: knei-knurow[P]lidar-visualizations/src/app.cpp
// Function: App::check_arg(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, 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&)
bool App::check_arg(std::vector<std::string>& all_args,
                    const std::string& short_arg,
                    const std::string& long_arg) {
  auto it = std::find_if(
      all_args.begin(), all_args.end(),
      [short_arg, long_arg](const std::string& s) { return s == short_arg || s == long_arg; });

  if (it == all_args.end()) {
    return false;
  }

  all_args.erase(it);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5530
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5370
movq %rax, -0x40(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movq -0x20(%rbp), %rsi
callq 0x4170
leaq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4170
jmp 0x6eb8
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x6fb0
movq %rax, -0xb8(%rbp)
jmp 0x6ed2
movq -0xb8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x70a0
movq -0x18(%rbp), %rdi
callq 0x5370
movq %rax, -0x98(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x81c0
testb $0x1, %al
jne 0x6f0c
jmp 0x6f4f
movb $0x0, -0x1(%rbp)
jmp 0x6f88
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
callq 0x4230
jmp 0x6f96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x70a0
jmp 0x6f96
movq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8270
movq -0xc0(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x8200
movq %rax, -0xa8(%rbp)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x4610
nopw %cs:(%rax,%rax)
// File: knei-knurow[P]lidar-visualizations/src/cloud-grabbers.cpp
// Function: CloudFileGrabber::CloudFileGrabber(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, float)
CloudFileGrabber::CloudFileGrabber(const std::string& filename, float rot_angle) {
  filename_ = filename;
  rot_angle_ = rot_angle;
  status_ = std::ifstream(filename_).good();
  if (!status_) {
    std::cerr << "Error: File does not contain a valid cloud." << std::endl;
    status_ = false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x248(%rbp)
callq 0xc1c0
movq -0x248(%rbp), %rdi
leaq 0x11732(%rip), %rax     # 0x1cad8
movq %rax, (%rdi)
addq $0x10, %rdi
movq %rdi, -0x238(%rbp)
callq 0x44c0
movq -0x248(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x240(%rbp)
callq 0x8040
movq -0x238(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4040
jmp 0xb3e2
movq -0x248(%rbp), %rsi
movss -0x14(%rbp), %xmm0
movss %xmm0, 0x30(%rsi)
addq $0x10, %rsi
leaq -0x230(%rbp), %rdi
movl $0x8, %edx
callq 0x4570
jmp 0xb40a
movq -0x230(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x230(%rbp,%rax), %rdi
callq 0x45c0
movb %al, -0x249(%rbp)
jmp 0xb42a
movq -0x248(%rbp), %rax
movb -0x249(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x8(%rax)
leaq -0x230(%rbp), %rdi
callq 0x40e0
movq -0x248(%rbp), %rax
testb $0x1, 0x8(%rax)
jne 0xb4bc
movq 0x11b93(%rip), %rdi     # 0x1cff0
leaq 0x80c0(%rip), %rsi      # 0x13524
callq 0x4360
movq %rax, -0x258(%rbp)
jmp 0xb472
movq -0x258(%rbp), %rdi
movq 0x11b40(%rip), %rsi     # 0x1cfc0
callq 0x43a0
jmp 0xb487
movq -0x248(%rbp), %rax
movb $0x0, 0x8(%rax)
jmp 0xb4bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xb4c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x40e0
jmp 0xb4c5
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x240(%rbp), %rdi
callq 0x8190
movq -0x238(%rbp), %rdi
callq 0x4230
movq -0x248(%rbp), %rdi
callq 0xc700
movq -0x20(%rbp), %rdi
callq 0x4610
nopw %cs:(%rax,%rax)
// File: knei-knurow[P]lidar-visualizations/src/cloud-grabbers.cpp
// Function: CloudFileSeriesGrabber::CloudFileSeriesGrabber(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
CloudFileSeriesGrabber::CloudFileSeriesGrabber(const std::string& filename) {
  filename_ = filename;
  clouds_cnt_ = 0;
  file_.open(filename_);
  open();
  next_cloud_time_ = std::chrono::steady_clock::now();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xc1c0
movq -0x38(%rbp), %rdi
leaq 0x110f0(%rip), %rax     # 0x1cb08
movq %rax, (%rdi)
addq $0x10, %rdi
movq %rdi, -0x40(%rbp)
callq 0x44c0
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x30(%rbp)
callq 0x43f0
jmp 0xba3b
movq -0x38(%rbp), %rdi
addq $0x240, %rdi            # imm = 0x240
callq 0xc370
jmp 0xba4d
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rdi
callq 0x4040
jmp 0xba60
movq -0x38(%rbp), %rsi
movq $0x0, 0x238(%rsi)
movq %rsi, %rdi
addq $0x30, %rdi
addq $0x10, %rsi
movl $0x8, %edx
callq 0x4310
jmp 0xba86
movq -0x38(%rbp), %rdi
callq 0xbaf0
jmp 0xba91
callq 0x44a0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x240(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xbad5
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x40e0
movq -0x40(%rbp), %rdi
callq 0x4230
movq -0x38(%rbp), %rdi
callq 0xc700
movq -0x18(%rbp), %rdi
callq 0x4610
// File: knei-knurow[P]lidar-visualizations/src/cloud-grabbers.cpp
// Function: CloudFileSeriesGrabber::open()
bool CloudFileSeriesGrabber::open() {
  while (file_.good()) {
    std::string line;
    std::getline(file_, line);
    if (line.empty() || line[0] == '!') {
      break;
    }
  }

  if (!file_.good()) {
    std::cerr << "Error: File does not contain a valid cloud series." << std::endl;
    status_ = false;
  }
  return status_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movq 0x30(%rax), %rax
addq -0x18(%rax), %rdi
callq 0x45c0
testb $0x1, %al
jne 0xbb25
jmp 0xbbb1
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x44c0
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x30, %rdi
callq 0x4080
jmp 0xbb45
leaq -0x28(%rbp), %rdi
callq 0x45a0
testb $0x1, %al
jne 0xbb71
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x46a0
movq %rax, -0x50(%rbp)
jmp 0xbb65
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x21, %eax
jne 0xbb91
movl $0x3, -0x38(%rbp)
jmp 0xbb98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4230
jmp 0xbc06
movl $0x0, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4230
movl -0x38(%rbp), %eax
testl %eax, %eax
je 0xbbac
jmp 0xbbaa
jmp 0xbbb1
jmp 0xbb04
movq -0x40(%rbp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movq 0x30(%rax), %rax
addq -0x18(%rax), %rdi
callq 0x45c0
testb $0x1, %al
jne 0xbbf7
movq 0x1141c(%rip), %rdi     # 0x1cff0
leaq 0x7987(%rip), %rsi      # 0x13562
callq 0x4360
movq %rax, %rdi
movq 0x113d6(%rip), %rsi     # 0x1cfc0
callq 0x43a0
movq -0x40(%rbp), %rax
movb $0x0, 0x8(%rax)
movq -0x40(%rbp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x4610
nop
// File: knei-knurow[P]lidar-visualizations/src/guis.cpp
// Function: TerminalGUI::update(Cloud const&)
bool TerminalGUI::update(const Cloud& cloud) {
  std::cout << "!\t" << ++count_ << std::endl;
  if (verbose_) {
    for (const auto& pt : cloud.pts_cyl) {
      std::cout << pt.angle << "\t" << pt.dist << std::endl;
    }
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0xb5e1(%rip), %rdi      # 0x1cfd0
leaq 0x1f03(%rip), %rsi      # 0x138f9
callq 0x4360
movq %rax, %rdi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0x1, %rsi
movq %rsi, 0x10(%rax)
callq 0x40b0
movq %rax, %rdi
movq 0xb5a3(%rip), %rsi      # 0x1cfc0
callq 0x43a0
movq -0x38(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x11ac2
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xccd0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xcd00
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xd100
testb $0x1, %al
jne 0x11a65
jmp 0x11ac0
leaq -0x20(%rbp), %rdi
callq 0xd160
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movss (%rax), %xmm0
movq 0xb54f(%rip), %rdi      # 0x1cfd0
callq 0x42b0
movq %rax, %rdi
leaq 0x1e6a(%rip), %rsi      # 0x138fa
callq 0x4360
movq %rax, %rdi
movq -0x30(%rbp), %rax
movss 0x4(%rax), %xmm0
callq 0x42b0
movq %rax, %rdi
movq 0xb510(%rip), %rsi      # 0x1cfc0
callq 0x43a0
leaq -0x20(%rbp), %rdi
callq 0xd180
jmp 0x11a52
jmp 0x11ac2
movb $0x1, %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/ebwt_search.cpp
// Function: increment_thread_counter()
void increment_thread_counter() {
#if (__cplusplus >= 201103)
	thread_counter.fetch_add(1);
#else
	ThreadSafe ts(&thread_counter_mutex);
	thread_counter++;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x999e1(%rip), %rax     # 0xab35c
movq %rax, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl $0x5, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
movl %ecx, -0x14(%rbp)
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x4, %eax
ja 0x119bf
movq -0x20(%rbp), %rax
leaq 0x7765a(%rip), %rcx     # 0x89010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
lock
xaddl %eax, (%rcx)
movl %eax, -0x18(%rbp)
jmp 0x11a0d
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
lock
xaddl %eax, (%rcx)
movl %eax, -0x18(%rbp)
jmp 0x11a0d
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
lock
xaddl %eax, (%rcx)
movl %eax, -0x18(%rbp)
jmp 0x11a0d
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
lock
xaddl %eax, (%rcx)
movl %eax, -0x18(%rbp)
jmp 0x11a0d
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
lock
xaddl %eax, (%rcx)
movl %eax, -0x18(%rbp)
popq %rbp
retq
nop
// File: BenLangmead[P]bowtie/ebwt_search.cpp
// Function: decrement_thread_counter()
void decrement_thread_counter() {
#if (__cplusplus >= 201103)
	thread_counter.fetch_sub(1);
#else
	ThreadSafe ts(&thread_counter_mutex);
	thread_counter--;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x99941(%rip), %rax     # 0xab35c
movq %rax, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl $0x5, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
movl %ecx, -0x14(%rbp)
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x4, %eax
ja 0x11a5f
movq -0x20(%rbp), %rax
leaq 0x775ce(%rip), %rcx     # 0x89024
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
negl %eax
lock
xaddl %eax, (%rcx)
movl %eax, -0x18(%rbp)
jmp 0x11ab7
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
negl %eax
lock
xaddl %eax, (%rcx)
movl %eax, -0x18(%rbp)
jmp 0x11ab7
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
negl %eax
lock
xaddl %eax, (%rcx)
movl %eax, -0x18(%rbp)
jmp 0x11ab7
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
negl %eax
lock
xaddl %eax, (%rcx)
movl %eax, -0x18(%rbp)
jmp 0x11ab7
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
negl %eax
lock
xaddl %eax, (%rcx)
movl %eax, -0x18(%rbp)
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/ebwt_search.cpp
// Function: del_pid(char const*, int)
void del_pid(const char* dirname,int pid) {
	struct stat finfo;
	char* fname = (char*) calloc(FNAME_SIZE,sizeof(char));
	sprintf(fname,"%s/%d",dirname,pid);
	if(stat( fname, &finfo) != 0) {
		free(fname);
		return;
	}
	unlink(fname);
	free(fname);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq 0x99887(%rip), %rdi     # 0xab360
movl $0x1, %esi
callq 0xa390
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
leaq 0x78425(%rip), %rsi     # 0x89f24
movb $0x0, %al
callq 0xa100
movq -0xa8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xab20
cmpl $0x0, %eax
je 0x11b2c
movq -0xa8(%rbp), %rdi
callq 0xa730
jmp 0x11b44
movq -0xa8(%rbp), %rdi
callq 0xa280
movq -0xa8(%rbp), %rdi
callq 0xa730
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./tokenize.h
// Function: tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, EList<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 128>&)
static inline void tokenize(
	const std::string& s,
    char delim,
    EList<std::string>& ss)
{
	std::string token;
	std::istringstream iss(s);
	while(getline(iss, token, delim)) {
		ss.push_back(token);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa850
movq -0x8(%rbp), %rsi
leaq -0x1b8(%rbp), %rdi
movl $0x8, %edx
callq 0xaac0
jmp 0x18219
jmp 0x1821b
movsbl -0x9(%rbp), %edx
leaq -0x1b8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xabe0
movq %rax, -0x1d0(%rbp)
jmp 0x18238
movq -0x1d0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xa790
movb %al, -0x1d1(%rbp)
jmp 0x18256
movb -0x1d1(%rbp), %al
testb $0x1, %al
jne 0x18262
jmp 0x182a7
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x26380
jmp 0x18271
jmp 0x1821b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x182c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0xa270
jmp 0x182c5
leaq -0x1b8(%rbp), %rdi
callq 0xa270
leaq -0x38(%rbp), %rdi
callq 0xacd8
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0xacd8
movq -0x1c0(%rbp), %rdi
callq 0xab60
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/ebwt_search.cpp
// Function: parseInt(int, int, char const*, char const*)
static int parseInt(int lower, int upper, const char *errmsg, const char *arg) {
	long l;
	char *endPtr= NULL;
	l = strtol(arg, &endPtr, 10);
	if (endPtr != NULL) {
		if (l < lower || l > upper) {
			cerr << errmsg << endl;
			printUsage(cerr);
			throw 1;
		}
		return (int32_t)l;
	}
	cerr << errmsg << endl;
	printUsage(cerr);
	throw 1;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0xa, %edx
callq 0xa8a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1838d
movq -0x20(%rbp), %rax
movslq -0x4(%rbp), %rcx
cmpq %rcx, %rax
jl 0x18335
movq -0x20(%rbp), %rax
movslq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jle 0x18383
movq -0x10(%rbp), %rsi
movq 0x8fcb0(%rip), %rdi     # 0xa7ff0
callq 0xa5d0
movq %rax, %rdi
movq 0x8fc19(%rip), %rsi     # 0xa7f68
callq 0xa640
movq 0x8fc95(%rip), %rdi     # 0xa7ff0
callq 0x14950
movl $0x4, %edi
callq 0xa290
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x8fbd6(%rip), %rsi     # 0xa7f50
xorl %eax, %eax
movl %eax, %edx
callq 0xab10
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rsi
movq 0x8fc58(%rip), %rdi     # 0xa7ff0
callq 0xa5d0
movq %rax, %rdi
movq 0x8fbc1(%rip), %rsi     # 0xa7f68
callq 0xa640
movq 0x8fc3d(%rip), %rdi     # 0xa7ff0
callq 0x14950
movl $0x4, %edi
callq 0xa290
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x8fb7e(%rip), %rsi     # 0xa7f50
xorl %eax, %eax
movl %eax, %edx
callq 0xab10
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/ebwt_search.cpp
// Function: write_pid(char const*, int)
static void write_pid(const char* dirname,int pid) {
	struct stat dinfo;
	if(stat(dirname, &dinfo) != 0) {
		mkdir(dirname,0755);
	}
	char* fname = (char*) calloc(FNAME_SIZE,sizeof(char));
	sprintf(fname,"%s/%d",dirname,pid);
	FILE* f = fopen(fname,"w");
	fclose(f);
	free(fname);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xab20
cmpl $0x0, %eax
je 0x1c7f5
movq -0x8(%rbp), %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0xa260
movslq 0x8eb64(%rip), %rdi     # 0xab360
movl $0x1, %esi
callq 0xa390
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
leaq 0x6d702(%rip), %rsi     # 0x89f24
movb $0x0, %al
callq 0xa100
movq -0xa8(%rbp), %rdi
leaq 0x6cf5a(%rip), %rsi     # 0x89791
callq 0xa6e0
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rdi
callq 0xa5e0
movq -0xa8(%rbp), %rdi
callq 0xa730
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/ebwt_search.cpp
// Function: steal_thread(int, int)
static bool steal_thread(int pid, int orig_nthreads) {
	int ncpu = thread_ceiling;
	if(thread_ceiling <= nthreads) {
		return false;
	}
	int num_pids = 0;
	int lowest_pid = read_dir(thread_stealing_dir.c_str(), &num_pids);
	if(lowest_pid != pid) {
		return false;
	}
	int in_use = ((num_pids-1) * orig_nthreads) + nthreads; //in_use is now baseline + ours
	float spare = ncpu - in_use;
	int spare_r = floor(spare);
	float r = rand() % 100/100.0;
	if(r <= (spare - spare_r)) {
		spare_r = ceil(spare);
	}
	return spare_r > 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl 0x8bcb4(%rip), %eax     # 0xab3f8
movl %eax, -0x10(%rbp)
movl 0x8bcab(%rip), %eax     # 0xab3f8
cmpl 0x8bc9d(%rip), %eax     # 0xab3f0
jg 0x1f75e
movb $0x0, -0x1(%rbp)
jmp 0x1f81f
movl $0x0, -0x14(%rbp)
leaq 0x8ba7c(%rip), %rdi     # 0xab1e8
callq 0xa210
movq %rax, %rdi
leaq -0x14(%rbp), %rsi
callq 0x1fe60
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x8(%rbp), %eax
je 0x1f791
movb $0x0, -0x1(%rbp)
jmp 0x1f81f
movl -0x14(%rbp), %eax
subl $0x1, %eax
imull -0xc(%rbp), %eax
addl 0x8bc4f(%rip), %eax     # 0xab3f0
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %eax
subl -0x1c(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
callq 0x6cd50
cvttss2si %xmm0, %eax
movl %eax, -0x24(%rbp)
callq 0xa160
movl $0x64, %ecx
cltd
idivl %ecx
cvtsi2sd %edx, %xmm0
movsd 0x69f33(%rip), %xmm1    # 0x89710
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm1
movss -0x20(%rbp), %xmm0
cvtsi2ssl -0x24(%rbp), %xmm2
subss %xmm2, %xmm0
ucomiss %xmm1, %xmm0
jb 0x1f813
movss -0x20(%rbp), %xmm0
callq 0x6cd70
cvttss2si %xmm0, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/ebwt_search.cpp
// Function: createPatsrcFactory(PatternComposer&, int, unsigned int)
static PatternSourcePerThreadFactory*
createPatsrcFactory(PatternComposer& _patsrc, int tid, uint32_t max_buf) {
	PatternSourcePerThreadFactory *patsrcFact;
	patsrcFact = new PatternSourcePerThreadFactory(_patsrc, max_buf, skipReads, seed);
	assert(patsrcFact != NULL);
	return patsrcFact;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x20, %edi
callq 0xa5f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rsi
movl -0x10(%rbp), %edx
movl 0x8bb99(%rip), %ecx     # 0xab45c
movl 0x8bae6(%rip), %r8d     # 0xab3b0
callq 0x34580
jmp 0x1f8d1
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x20, %esi
callq 0xa600
movq -0x20(%rbp), %rdi
callq 0xab60
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./qual.h
// Function: mmPenalty(bool, unsigned char)
static inline uint8_t mmPenalty(bool maq, uint8_t qual) {
	if(maq) {
		return MaqPhredPenalty::mmPenalty(qual);
	} else {
		return SimplePhredPenalty::mmPenalty(qual);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movb %dil, %cl
andb $0x1, %cl
movb %cl, -0x2(%rbp)
movb %al, -0x3(%rbp)
testb $0x1, -0x2(%rbp)
je 0x1fafb
movzbl -0x3(%rbp), %edi
callq 0x46bc0
movb %al, -0x1(%rbp)
jmp 0x1fb07
movzbl -0x3(%rbp), %edi
callq 0x46be0
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
// File: BenLangmead[P]bowtie/ebwt_search.cpp
// Function: read_dir(char const*, int*)
static int read_dir(const char* dirname,int* num_pids) {
	DIR *dir;
	struct dirent *ent;
	char* fname = (char*) calloc(FNAME_SIZE,sizeof(char));
	int lowest_pid = -1;
	if ((dir = opendir (dirname)) != NULL) {
		while ((ent = readdir (dir)) != NULL) {
			if(ent->d_name[0] == '.')
				continue;
			int pid = atoi(ent->d_name);
			sprintf(fname,"/proc/%s", ent->d_name);
			if(kill(pid, 0) != 0) {
				//deleting pids can lead to race conditions if
				//2 or more BT2 processes both try to delete
				//so just skip instead
				//del_pid(dirname,pid);
				continue;
			}
			(*num_pids)++;
			if(pid < lowest_pid || lowest_pid == -1)
				lowest_pid = pid;
		}
		closedir (dir);
	} else {
		perror (""); // could not open directory
	}
	free(fname);
	return lowest_pid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movslq 0x8b4e9(%rip), %rdi     # 0xab360
movl $0x1, %esi
callq 0xa390
movq %rax, -0x28(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
callq 0xa960
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1ff2e
jmp 0x1fea5
movq -0x18(%rbp), %rdi
callq 0xa320
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1ff23
movq -0x20(%rbp), %rax
movsbl 0x13(%rax), %eax
cmpl $0x2e, %eax
jne 0x1fec7
jmp 0x1fea5
movq -0x20(%rbp), %rdi
addq $0x13, %rdi
callq 0xa9b0
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
addq $0x13, %rdx
leaq 0x6d528(%rip), %rsi     # 0x8d412
movb $0x0, %al
callq 0xa100
movl -0x30(%rbp), %edi
xorl %esi, %esi
callq 0xa8b0
cmpl $0x0, %eax
je 0x1ff02
jmp 0x1fea5
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jl 0x1ff1b
cmpl $-0x1, -0x2c(%rbp)
jne 0x1ff21
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x1fea5
movq -0x18(%rbp), %rdi
callq 0xaa40
jmp 0x1ff3a
leaq 0x6e966(%rip), %rdi     # 0x8e89b
callq 0xa4e0
movq -0x28(%rbp), %rdi
callq 0xa730
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/ebwt_search.cpp
// Function: std::pair<unsigned long, unsigned long> parsePair<unsigned long>(char const*, char)
pair<T, T> parsePair(const char *str, char delim) {
	string s(str);
	EList<string> ss;
	tokenize(s, delim, ss);
	pair<T, T> ret;
	ret.first = parse<T>(ss[0].c_str());
	ret.second = parse<T>(ss[1].c_str());
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %sil, %al
movq %rdi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xab70
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x24c10
jmp 0x27e83
leaq -0x41(%rbp), %rdi
callq 0xa670
leaq -0x78(%rbp), %rdi
callq 0x27220
jmp 0x27e97
movsbl -0x19(%rbp), %esi
leaq -0x40(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x181e0
jmp 0x27eaa
leaq -0x10(%rbp), %rdi
callq 0x281e0
jmp 0x27eb5
xorl %eax, %eax
movl %eax, %esi
leaq -0x78(%rbp), %rdi
callq 0x27460
movq %rax, -0x90(%rbp)
jmp 0x27ecb
movq -0x90(%rbp), %rdi
callq 0xa210
movq %rax, %rdi
callq 0x28200
movq %rax, -0x98(%rbp)
jmp 0x27ee8
movq -0x98(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x78(%rbp), %rdi
movl $0x1, %esi
callq 0x27460
movq %rax, -0xa0(%rbp)
jmp 0x27f0a
movq -0xa0(%rbp), %rdi
callq 0xa210
movq %rax, %rdi
callq 0x28200
movq %rax, -0xa8(%rbp)
jmp 0x27f27
movq -0xa8(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x27260
leaq -0x40(%rbp), %rdi
callq 0xacd8
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0xa670
jmp 0x27f98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x27f8f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x27260
leaq -0x40(%rbp), %rdi
callq 0xacd8
movq -0x50(%rbp), %rdi
callq 0xab60
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: BenLangmead[P]bowtie/ebwt_search.cpp
// Function: int parse<int>(char const*)
T parse(const char *s) {
	T tmp;
	stringstream ss(s);
	ss >> tmp;
	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1e0(%rbp)
leaq -0x1b9(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0xab70
movq -0x1e0(%rbp), %rsi
movq -0x1d8(%rbp), %rdx
leaq -0x1b8(%rbp), %rdi
callq 0x24c10
jmp 0x28059
movl $0x10, %edi
movl $0x8, %esi
callq 0x28340
movl %eax, %edx
leaq -0x198(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xaa00
jmp 0x2807f
leaq -0x1b8(%rbp), %rdi
callq 0xacd8
leaq -0x1b9(%rbp), %rdi
callq 0xa670
leaq -0x198(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0xa350
jmp 0x280a9
movl -0xc(%rbp), %eax
movl %eax, -0x1e4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xa440
movl -0x1e4(%rbp), %eax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
jmp 0x280ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0xacd8
leaq -0x1b9(%rbp), %rdi
callq 0xa670
jmp 0x2812b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xa440
movq -0x1c8(%rbp), %rdi
callq 0xab60
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/./pat.h
// Function: DualPatternComposer::DualPatternComposer(EList<PatternSource*, 128> const&, EList<PatternSource*, 128> const&)
DualPatternComposer(const EList<PatternSource*>& srca,
	                        const EList<PatternSource*>& srcb) :
		PatternComposer(),
		cur_(0),
		srca_(srca),
		srcb_(srcb)
	{
		// srca_ and srcb_ must be parallel
		assert_eq(srca_.size(), srcb_.size());
		for(size_t i = 0; i < srca_.size(); i++) {
			// Can't have NULL first-mate sources.  Second-mate sources
			// can be NULL, in the case when the corresponding first-
			// mate source is unpaired.
			assert(srca_[i] != NULL);
			for(size_t j = 0; j < srcb_.size(); j++) {
				assert_neq(srca_[i], srcb_[j]);
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2c6a0
movq -0x48(%rbp), %rdi
leaq 0x7f28c(%rip), %rax     # 0xa7c18
addq $0x10, %rax
movq %rax, (%rdi)
movl $0x0, 0xc(%rdi)
addq $0x10, %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rsi
callq 0x2c6d0
jmp 0x289ad
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x50(%rbp)
movq -0x18(%rbp), %rsi
callq 0x2c6d0
jmp 0x289c4
movq $0x0, -0x30(%rbp)
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x10, %rdi
callq 0x29fa0
movq %rax, -0x58(%rbp)
jmp 0x289e7
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
cmpq %rcx, %rax
jae 0x28a7e
movq $0x0, -0x38(%rbp)
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x30, %rdi
callq 0x29fa0
movq %rax, -0x68(%rbp)
jmp 0x28a1b
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rcx
cmpq %rcx, %rax
jae 0x28a6b
jmp 0x28a2a
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x28a00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x28a8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x28a84
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2a020
jmp 0x28a84
jmp 0x28a6d
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x289cc
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2a020
movq -0x48(%rbp), %rdi
callq 0x2c720
movq -0x20(%rbp), %rdi
callq 0xab60
nop
// File: BenLangmead[P]bowtie/./filebuf.h
// Function: OutFileBuf::OutFileBuf(char const*, bool)
OutFileBuf(const char *out, bool binary = false) :
		name_(out), cur_(0), closed_(false)
	{
		assert(out != NULL);
		out_ = fopen(out, binary ? "wb" : "w");
		if(out_ == NULL) {
			std::cerr << "Error: Could not open alignment output file " << out << std::endl;
			throw 1;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq $0x0, 0x10(%rax)
movb $0x0, 0x4018(%rax)
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %cl
leaq 0x60cae(%rip), %rsi     # 0x89791
leaq 0x63bc7(%rip), %rax     # 0x8c6b1
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0xa6e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
jne 0x28b59
movq 0x7f4e1(%rip), %rdi     # 0xa7ff0
leaq 0x63b9e(%rip), %rsi     # 0x8c6b4
callq 0xa5d0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xa5d0
movq %rax, %rdi
movq 0x7f437(%rip), %rsi     # 0xa7f68
callq 0xa640
movl $0x4, %edi
callq 0xa290
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x7f400(%rip), %rsi     # 0xa7f50
xorl %eax, %eax
movl %eax, %edx
callq 0xab10
addq $0x20, %rsp
popq %rbp
retq
nop
// File: BenLangmead[P]bowtie/./ds.h
// Function: EList<bool, 128>::fill(unsigned long, unsigned long, bool const&)
void fill(size_t begin, size_t end, const T& v) {
		assert_leq(begin, end);
		assert_leq(end, cur_);
		for(size_t i = begin; i < end; i++) {
			list_[i] = v;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2bf74
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rcx), %dl
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2bf44
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BenLangmead[P]bowtie/./pat.h
// Function: CFilePatternSource::~CFilePatternSource()
virtual ~CFilePatternSource() {
		if(is_open_) {
			if (compressed_) {
				gzclose(zfp_);
				zfp_ = NULL;
			}
			else if (fp_ != stdin) {
				fclose(fp_);
				fp_ = NULL;
			}
			if(qfp_ != NULL && qfp_ != stdin) {
				fclose(qfp_);
				qfp_ = NULL;
			}
			assert(zfp_ == NULL);
			assert(fp_ == NULL || fp_ == stdin);
			assert(qfp_ == NULL || qfp_ == stdin);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x7b3b5(%rip), %rcx     # 0xa7950
addq $0x10, %rcx
movq %rcx, (%rax)
testb $0x1, 0xa0(%rax)
je 0x2c661
movq -0x10(%rbp), %rax
testb $0x1, 0x200a2(%rax)
je 0x2c5df
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0xaad0
jmp 0x2c5ce
movq -0x10(%rbp), %rax
movq $0x0, 0x98(%rax)
jmp 0x2c619
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq 0x7b9a7(%rip), %rcx     # 0xa7f98
cmpq (%rcx), %rax
je 0x2c617
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0xa5e0
jmp 0x2c608
movq -0x10(%rbp), %rax
movq $0x0, 0x88(%rax)
jmp 0x2c619
movq -0x10(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x2c65f
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movq 0x7b95f(%rip), %rcx     # 0xa7f98
cmpq (%rcx), %rax
je 0x2c65f
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0xa5e0
jmp 0x2c650
movq -0x10(%rbp), %rax
movq $0x0, 0x90(%rax)
jmp 0x2c661
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0x2bf80
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x27260
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x27260
movq -0x10(%rbp), %rdi
callq 0x2bfe0
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x24d00
nop
// File: BenLangmead[P]bowtie/./hit.h
// Function: HitSink::initDumps()
void initDumps() {
		dumpAl_       = dumpAl_1_     = dumpAl_2_     = NULL;
		dumpUnal_     = dumpUnal_1_   = dumpUnal_2_   = NULL;
		dumpMax_      = dumpMax_1_    = dumpMax_2_    = NULL;
		dumpAlignFlag_   = !dumpAlBase_.empty();
		dumpUnalignFlag_ = !dumpUnalBase_.empty();
		dumpMaxedFlag_   = !dumpMaxBase_.empty();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq $0x0, 0x180(%rdi)
movq $0x0, 0x178(%rdi)
movq $0x0, 0x170(%rdi)
movq $0x0, 0x198(%rdi)
movq $0x0, 0x190(%rdi)
movq $0x0, 0x188(%rdi)
movq $0x0, 0x1b0(%rdi)
movq $0x0, 0x1a8(%rdi)
movq $0x0, 0x1a0(%rdi)
addq $0x108, %rdi            # imm = 0x108
callq 0xaa90
movq -0x10(%rbp), %rdi
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x1be(%rdi)
addq $0x128, %rdi            # imm = 0x128
callq 0xaa90
movq -0x10(%rbp), %rdi
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x1bf(%rdi)
addq $0x148, %rdi            # imm = 0x148
callq 0xaa90
movb %al, %cl
movq -0x10(%rbp), %rax
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, 0x1c0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: BenLangmead[P]bowtie/./hit.h
// Function: HitSink::~HitSink()
virtual ~HitSink() {
		if(ptNumAligned_ != NULL) {
			delete[] ptNumAligned_;
			ptNumAligned_ = NULL;
		}
		closeOuts();
		destroyDumps();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x793d5(%rip), %rcx     # 0xa6880
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x1c8(%rax)
je 0x2d4e9
movq -0x10(%rbp), %rax
movq 0x1c8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2d4da
movq -0x18(%rbp), %rdi
callq 0xa7c0
movq -0x10(%rbp), %rax
movq $0x0, 0x1c8(%rax)
movq -0x10(%rbp), %rdi
callq 0x2fae0
jmp 0x2d4f4
movq -0x10(%rbp), %rdi
callq 0x2fb00
jmp 0x2d4ff
movq -0x10(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0xacd8
movq -0x10(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
callq 0xacd8
movq -0x10(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0xacd8
movq -0x10(%rbp), %rdi
addq $0xc8, %rdi
callq 0x2d420
movq -0x10(%rbp), %rdi
addq $0x80, %rdi
callq 0x2d450
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x2a450
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x2d470
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x24d00
nopw (%rax,%rax)
// File: BenLangmead[P]bowtie/./sstring.h
// Function: SStringExpandable<char, 25, 2, 0>::~SStringExpandable()
virtual ~SStringExpandable() {
		if(cs_ != NULL) {
			delete[] cs_;
			cs_ = NULL;
		}
		if(printcs_ != NULL) {
			delete[] printcs_;
			printcs_ = NULL;
		}
		sz_ = len_ = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x784d5(%rip), %rcx     # 0xa6990
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x8(%rax)
je 0x2e4f0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2e4e4
movq -0x18(%rbp), %rdi
callq 0xa7c0
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2e522
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x2e516
movq -0x20(%rbp), %rdi
callq 0xa7c0
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: BenLangmead[P]bowtie/./sstring.h
// Function: SStringExpandable<char, 25, 2, 0>::toZBuf() const
virtual const T* toZBuf() const {
		if(empty()) {
			const_cast<T&>(zeroT_) = 0;
			return &zeroT_;
		}
		assert_leq(len_, sz_);
		const_cast<T*>(cs_)[len_] = 0;
		return cs_;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x2e700
testb $0x1, %al
jne 0x2e5ff
jmp 0x2e611
movq -0x18(%rbp), %rax
movb $0x0, 0x19(%rax)
addq $0x19, %rax
movq %rax, -0x8(%rbp)
jmp 0x2e629
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x20(%rax), %rdx
movb $0x0, (%rcx,%rdx)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: BenLangmead[P]bowtie/./sstring.h
// Function: SStringExpandable<char, 25, 2, 0>::expandNoCopy(unsigned long)
void expandNoCopy(size_t sz) {
		if(sz_ >= sz) return; // done!
		if(cs_      != NULL) delete[] cs_;
		if(printcs_ != NULL) delete[] printcs_;
		cs_ = new T[sz + 1];
		printcs_ = new char[sz + 1];
		sz_ = sz;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x28(%rax), %rax
cmpq -0x10(%rbp), %rax
jb 0x2e667
jmp 0x2e6ef
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2e68f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x2e68d
movq -0x20(%rbp), %rdi
callq 0xa7c0
jmp 0x2e68f
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2e6b7
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2e6b5
movq -0x28(%rbp), %rdi
callq 0xa7c0
jmp 0x2e6b7
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0xa040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0xa040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: BenLangmead[P]bowtie/./filebuf.h
// Function: void OutFileBuf::writeString<SStringExpandable<char, 25, 2, 0>>(SStringExpandable<char, 25, 2, 0> const&)
void writeString(const T& s) {
		assert(!closed_);
		size_t slen = s.length();
		if(cur_ + slen > BUF_SZ) {
			if(cur_ > 0) flush();
			if(slen >= BUF_SZ) {
				if (slen != fwrite(s.toZBuf(), 1, slen, out_)) {
					std::cerr << "Error outputting data" << std::endl;
					throw 1;
				}
			} else {
				memcpy(&buf_[cur_], s.toZBuf(), slen);
				assert_eq(0, cur_);
				cur_ = slen;
			}
		} else {
			memcpy(&buf_[cur_], s.toZBuf(), slen);
			cur_ += slen;
		}
		assert_leq(cur_, BUF_SZ);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2ef90
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x10(%rax), %rax
addq -0x18(%rbp), %rax
cmpq $0x4000, %rax           # imm = 0x4000
jbe 0x2ee37
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jbe 0x2ed74
movq -0x20(%rbp), %rdi
callq 0x2efb0
cmpq $0x4000, -0x18(%rbp)    # imm = 0x4000
jb 0x2edfc
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdx
movq 0x8(%rax), %rcx
movl $0x1, %esi
callq 0xac70
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0x2edfa
movq 0x79234(%rip), %rdi     # 0xa7ff0
leaq 0x5d92b(%rip), %rsi     # 0x8c6ee
callq 0xa5d0
movq %rax, %rdi
movq 0x79196(%rip), %rsi     # 0xa7f68
callq 0xa640
movl $0x4, %edi
callq 0xa290
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x7915f(%rip), %rsi     # 0xa7f50
xorl %eax, %eax
movl %eax, %edx
callq 0xab10
jmp 0x2ee35
movq -0x20(%rbp), %rcx
movq %rcx, %rax
addq $0x18, %rax
addq 0x10(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0xa4c0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x2ee74
movq -0x20(%rbp), %rcx
movq %rcx, %rax
addq $0x18, %rax
addq 0x10(%rcx), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0xa4c0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)