LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Lupo-CalPoly[P]cpe315-thumbsim/execute.cpp
// Function: setCarryOverflow(int, int, OFType)
void setCarryOverflow (int num1, int num2, OFType oftype) {
  switch (oftype) {
    case OF_ADD:
      if (((unsigned long long int)num1 + (unsigned long long int)num2) ==
          ((unsigned int)num1 + (unsigned int)num2)) {
        flags.C = 0;
      }
      else {
        flags.C = 1;
      }
      if (((long long int)num1 + (long long int)num2) ==
          ((int)num1 + (int)num2)) {
        flags.V = 0;
      }
      else {
        flags.V = 1;
      }
      break;
    case OF_SUB:
      if (num1 >= num2) {
        flags.C = 1;
      }
      else if ((long long int)((unsigned long long int)num1 - (unsigned long long int)num2) ==
          (int)((unsigned int)num1 - (unsigned int)num2)) {
        flags.C = 0;
      }
      else {
        flags.C = 1;
      }
      if (((num1==0) && (num2==0)) ||
          (((long long int)num1 - (long long int)num2) ==
           ((int)num1 - (int)num2))) {
        flags.V = 0;
      }
      else {
        flags.V = 1;
      }
      break;
    case OF_SHIFT:
      // C flag unaffected for shifts by zero
      if (num2 != 0) {
        if (((unsigned long long int)num1 << (unsigned long long int)num2) ==
            ((unsigned int)num1 << (unsigned int)num2)) {
          flags.C = 0;
        }
        else {
          flags.C = 1;
        }
      }
      // Shift doesn't set overflow
      break;
    default:
      cerr << "Bad OverFlow Type encountered." << __LINE__ << __FILE__ << endl;
      exit(1);
  }
}

// Assembly:
cmpl $0x2, %edx
je 0x5756
cmpl $0x1, %edx
je 0x5718
testl %edx, %edx
jne 0x5784
movslq %edi, %rax
movslq %esi, %rcx
addq %rax, %rcx
addl %edi, %esi
cmpq %rsi, %rcx
setne 0x3b1f(%rip)            # 0x9232
movslq %esi, %rax
jmp 0x5749
movb $0x1, %cl
movl %edi, %eax
subl %esi, %eax
jge 0x5732
movslq %edi, %rcx
movslq %esi, %rdx
subq %rdx, %rcx
movslq %eax, %rdx
cmpq %rdx, %rcx
setne %cl
movb %cl, 0x3afa(%rip)       # 0x9232
movl %esi, %ecx
orl %edi, %ecx
je 0x574e
movslq %edi, %rcx
movslq %esi, %rdx
subq %rdx, %rcx
cltq
cmpq %rax, %rcx
jne 0x5774
movb $0x0, 0x3ade(%rip)      # 0x9233
retq
testl %esi, %esi
je 0x5783
movslq %edi, %rax
movq %rax, %rdx
movl %esi, %ecx
shlq %cl, %rdx
shll %cl, %eax
cmpq %rax, %rdx
jne 0x577c
movb $0x0, 0x3abf(%rip)      # 0x9232
retq
movb $0x1, 0x3ab8(%rip)      # 0x9233
retq
movb $0x1, 0x3aaf(%rip)      # 0x9232
retq
pushq %rbp
movq %rsp, %rbp
movq 0x3861(%rip), %rdi      # 0x8ff0
leaq 0xd62(%rip), %rsi       # 0x64f8
callq 0x2130
movq %rax, %rdi
movl $0x57, %esi
callq 0x2210
leaq 0xd68(%rip), %rsi       # 0x6517
movq %rax, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x2090
movl $0x1, %edi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O3/amukherj[P]concurrencyts/future.cc
// Function: basic_future_state()
void basic_future_state() {
  std::experimental::future_state<int> f;

  std::thread t([&f]() {
    auto val = f.get();
    std::cout << val << '\n';
  });

  std::thread t0([&f]() {
    f.wait();
    std::cout << "Done\n";
  });

  std::thread t1([&f]() {
    auto val = f.get();
    std::cout << val << '\n';
  });

  std::this_thread::sleep_for(std::chrono::seconds(2));
  f.emplace(10);

  t.join();
  t0.join();
  t1.join();
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x3200
xorl %eax, %eax
movq %rax, 0x50(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movw $0x0, 0x5c(%rbx)
movups %xmm0, 0x60(%rbx)
movq %rax, 0x28(%rsp)
movl $0x10, %edi
callq 0x31a0
leaq 0xa2e6(%rip), %rcx      # 0xd738
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x28(%rsp), %rdi
xorl %edx, %edx
callq 0x3180
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x347d
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x20(%rsp)
movl $0x10, %edi
callq 0x31a0
leaq 0xa2e1(%rip), %rcx      # 0xd778
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x20(%rsp), %rdi
xorl %edx, %edx
callq 0x3180
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x34c2
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x18(%rsp)
movl $0x10, %edi
callq 0x31a0
leaq 0xa2dc(%rip), %rcx      # 0xd7b8
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x18(%rsp), %rdi
xorl %edx, %edx
callq 0x3180
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3507
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x8(%rsp), %rbx
movq $0x2, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x3070
cmpl $-0x1, %eax
jne 0x3535
callq 0x3030
cmpl $0x4, (%rax)
je 0x351b
leaq 0x8(%rsp), %rsi
movl $0xa, (%rsi)
leaq 0x30(%rsp), %rdi
callq 0x6132
leaq 0x28(%rsp), %rdi
callq 0x3250
leaq 0x20(%rsp), %rdi
callq 0x3250
leaq 0x18(%rsp), %rdi
callq 0x3250
cmpq $0x0, 0x18(%rsp)
jne 0x361e
cmpq $0x0, 0x20(%rsp)
jne 0x361e
cmpq $0x0, 0x28(%rsp)
jne 0x361e
leaq 0x30(%rsp), %rdi
callq 0x61e0
addq $0xa0, %rsp
popq %rbx
retq
jmp 0x35f1
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x35fc
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x35fc
movq %rax, %rbx
jmp 0x35fc
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3604
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x3604
movq %rax, %rbx
jmp 0x3604
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x360c
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x360c
movq %rax, %rbx
jmp 0x360c
jmp 0x35f1
movq %rax, %rbx
cmpq $0x0, 0x18(%rsp)
jne 0x361e
cmpq $0x0, 0x20(%rsp)
jne 0x361e
cmpq $0x0, 0x28(%rsp)
jne 0x361e
leaq 0x30(%rsp), %rdi
callq 0x61e0
movq %rbx, %rdi
callq 0x3280
callq 0x3050
// File: /workspace/github_cpp_makefile_star2_O3/amukherj[P]concurrencyts/future.cc
// Function: main
int main() {
  basic_future_state();
  promise_to_future();
  async_to_promise();
  when_all();
  when_any();
}

// Assembly:
pushq %rax
callq 0x340c
callq 0x3623
callq 0x378e
callq 0x3dbf
callq 0x4142
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/amukherj[P]concurrencyts/./future.h
// Function: void concurrencyts::future_state<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::emplace<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&)
void emplace(Args&&... args) {
    std::unique_lock<std::mutex> ul(mtx);
    assert(!is_available && !is_complete);
    try {
      new (reinterpret_cast<T*>(&data)) T{std::forward<Args&&>(args)...};
      is_available = true;
    } catch (...) {
      eptr = std::current_exception();
    }
    is_complete = true;
    ul.unlock();

    completed.notify_all();
    notify_wait_queue();
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rsp, %r15
movq %rax, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0x6800
movb $0x1, 0x8(%r15)
cmpb $0x0, 0x78(%rbx)
jne 0x6cac
cmpb $0x1, 0x79(%rbx)
je 0x6cac
leaq 0x68(%rbx), %rcx
movq %rcx, 0x58(%rbx)
movq (%r14), %rdx
leaq 0x10(%r14), %rax
cmpq %rax, %rdx
je 0x6c4c
movq %rdx, 0x58(%rbx)
movq (%rax), %rcx
movq %rcx, 0x68(%rbx)
jmp 0x6c52
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r14), %rcx
movq %rcx, 0x60(%rbx)
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
movw $0x101, 0x78(%rbx)      # imm = 0x101
movq %rsp, %rdi
callq 0x683c
movq %rbx, %rdi
callq 0x3240
movq 0x80(%rbx), %rbx
testq %rbx, %rbx
je 0x6c9a
movq 0x8(%rbx), %rdi
callq 0x3240
movq (%rbx), %rbx
jmp 0x6c87
movq %rsp, %rdi
callq 0x67ea
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x136f(%rip), %rdi      # 0x8022
leaq 0x1386(%rip), %rsi      # 0x8040
leaq 0x1438(%rip), %rcx      # 0x80f9
movl $0x27, %edx
callq 0x3100
movq %rax, %rbx
movq %rsp, %rdi
callq 0x67ea
movq %rbx, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O3/amukherj[P]concurrencyts/./future.h
// Function: concurrencyts::future_state<int>::get()
T& get() {
    std::unique_lock<std::mutex> ul(mtx);
    completed.wait(ul, [this]()->bool { return is_complete; });

    if (eptr) {
      std::rethrow_exception(eptr);
    }

    return *(reinterpret_cast<T*>(&data));
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x6800
movb $0x1, 0x8(%r14)
cmpb $0x0, 0x5d(%rbx)
jne 0x678e
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3060
cmpb $0x1, 0x5d(%rbx)
jne 0x677d
movq 0x68(%rbx), %rax
testq %rax, %rax
jne 0x67b0
addq $0x58, %rbx
leaq 0x8(%rsp), %rdi
callq 0x67ea
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rsp, %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x3040
movq %rbx, %rdi
callq 0x31c0
movq %rax, %rbx
cmpq $0x0, (%rsp)
je 0x67d8
movq %rsp, %rdi
callq 0x3160
leaq 0x8(%rsp), %rdi
callq 0x67ea
movq %rbx, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O3/amukherj[P]concurrencyts/./future.h
// Function: concurrencyts::future_state<int>::wait()
void wait() {
    std::unique_lock<std::mutex> ul(mtx);
    completed.wait(ul, [this]()->bool { return is_complete; });

    if (eptr) {
      std::rethrow_exception(eptr);
    }
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x6800
movb $0x1, 0x8(%r14)
cmpb $0x0, 0x5d(%rbx)
jne 0x68a8
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3060
cmpb $0x1, 0x5d(%rbx)
jne 0x6897
movq 0x68(%rbx), %rax
testq %rax, %rax
jne 0x68c3
leaq 0x8(%rsp), %rdi
callq 0x67ea
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rsp, %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x3040
movq %rbx, %rdi
callq 0x31c0
movq %rax, %rbx
cmpq $0x0, (%rsp)
je 0x68eb
movq %rsp, %rdi
callq 0x3160
leaq 0x8(%rsp), %rdi
callq 0x67ea
movq %rbx, %rdi
callq 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O3/amukherj[P]concurrencyts/./future.h
// Function: void concurrencyts::future_state<int>::set_exception<std::exception&>(std::exception&)
void set_exception(E&& exc) {
    std::unique_lock<std::mutex> ul(mtx);
    assert(!is_available && !is_complete);
    eptr = std::make_exception_ptr(std::forward<E>(exc));
    is_complete = true;
    ul.unlock();

    completed.notify_all();
    notify_wait_queue();
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x6800
movb $0x1, 0x8(%r14)
cmpb $0x0, 0x5c(%rbx)
jne 0x6a36
cmpb $0x1, 0x5d(%rbx)
je 0x6a36
movq 0x761f(%rip), %rax      # 0xdfc0
addq $0x10, %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %r14
movq %r14, %rdi
callq 0x6a6a
movq (%r14), %rax
movq $0x0, (%r14)
movq 0x68(%rbx), %rcx
movq %rcx, 0x20(%rsp)
movq %rax, 0x68(%rbx)
testq %rcx, %rcx
je 0x69ed
leaq 0x20(%rsp), %rdi
callq 0x3160
cmpq $0x0, (%rsp)
je 0x69ed
movq %rsp, %rdi
callq 0x3160
leaq 0x8(%rsp), %rdi
callq 0x32c0
movb $0x1, 0x5d(%rbx)
leaq 0x10(%rsp), %rdi
callq 0x683c
movq %rbx, %rdi
callq 0x3240
movq 0x60(%rbx), %rbx
testq %rbx, %rbx
je 0x6a24
movq 0x8(%rbx), %rdi
callq 0x3240
movq (%rbx), %rbx
jmp 0x6a11
leaq 0x10(%rsp), %rdi
callq 0x67ea
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x15e5(%rip), %rdi      # 0x8022
leaq 0x15fc(%rip), %rsi      # 0x8040
leaq 0x1653(%rip), %rcx      # 0x809e
movl $0x38, %edx
callq 0x3100
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x67ea
movq %rbx, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O3/amukherj[P]concurrencyts/./future.h
// Function: concurrencyts::when_any_result<std::vector<std::iterator_traits<__gnu_cxx::__normal_iterator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::vector<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>::value_type, std::allocator<std::iterator_traits<__gnu_cxx::__normal_iterator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::vector<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>::value_type>>> concurrencyts::make_when_any_result<__gnu_cxx::__normal_iterator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::vector<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>(unsigned long, __gnu_cxx::__normal_iterator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::vector<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>, __gnu_cxx::__normal_iterator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::vector<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<concurrencyts::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>)
auto make_when_any_result(size_t index, InputIt begin, InputIt end)
  -> when_any_result<std::vector<typename std::iterator_traits<InputIt>::value_type>>
{
  using ret_type = typename std::iterator_traits<InputIt>::value_type; 
  when_any_result<std::vector<ret_type>> result;

  for (auto it = begin; it != end; ++it) {
    result.futures.push_back(std::move(*it));
  }
  result.index = index;

  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
cmpq %rcx, %rdx
je 0x7829
movq %rcx, %r15
movq %rdx, %r12
leaq 0x8(%rbx), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x6ee4
addq $0x10, %r12
cmpq %r15, %r12
jne 0x7815
movq %r14, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r13, %rdi
callq 0x63b0
movq %rbx, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/test4.cpp
// Function: main
int main(int argc, char** argv)
{

	parseOptions(argc,argv);

	cout << "for string we got : " << _stringTest<< endl
		 << "for bool B we got : " << _boolTestB << endl
		 << "for bool A we got : " << _boolTestA << endl;

}

// Assembly:
pushq %rbx
callq 0x4ae0
movq 0xe5e8(%rip), %rbx      # 0x12fd0
leaq 0x96c4(%rip), %rsi      # 0xe0b3
movl $0x14, %edx
movq %rbx, %rdi
callq 0x4250
movq 0xe85d(%rip), %rsi      # 0x13260
movq 0xe85e(%rip), %rdx      # 0x13268
movq %rbx, %rdi
callq 0x4250
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x41d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4160
movq %rax, %rbx
leaq 0x9682(%rip), %rsi      # 0xe0c8
movl $0x14, %edx
movq %rax, %rdi
callq 0x4250
movzbl 0xe7ff(%rip), %esi      # 0x13259
movq %rbx, %rdi
callq 0x4360
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x41d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4160
movq %rax, %rbx
leaq 0x9647(%rip), %rsi      # 0xe0dd
movl $0x14, %edx
movq %rax, %rdi
callq 0x4250
movzbl 0xe7b0(%rip), %esi      # 0x1325a
movq %rbx, %rdi
callq 0x4360
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x41d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4160
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/ZshCompletionOutput.h
// Function: TCLAP::ZshCompletionOutput::printArg(TCLAP::Arg*)
inline void ZshCompletionOutput::printArg(Arg* a)
{
	static int count = 1;

	std::cout << " \\" << std::endl << "  '";
	if ( a->acceptsMultipleValues() )
		std::cout << '*';
	else
		std::cout << count++;
	std::cout << ':';
	if ( !a->isRequired() )
		std::cout << ':';

	std::cout << a->getName() << ':';
	std::map<std::string, std::string>::iterator compArg = common.find(a->getName());
	if ( compArg != common.end() )
	{
		std::cout << compArg->second;
	}
	else
	{
		std::cout << "_guard \"^-*\" " << a->getName();
	}
	std::cout << '\'';
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0xbcba(%rip), %r15      # 0x12fd0
leaq 0x6ece(%rip), %rsi      # 0xe1eb
movl $0x2, %edx
movq %r15, %rdi
callq 0x4250
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x41d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4160
leaq 0x6e96(%rip), %rsi      # 0xe1ee
movl $0x3, %edx
movq %rax, %rdi
callq 0x4250
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
testb %al, %al
je 0x738d
leaq 0xb(%rsp), %rsi
movb $0x2a, (%rsi)
movq 0xbc4f(%rip), %rdi      # 0x12fd0
movl $0x1, %edx
callq 0x4250
jmp 0x73a8
movl 0xbe99(%rip), %esi      # 0x1322c
leal 0x1(%rsi), %eax
movl %eax, 0xbe90(%rip)      # 0x1322c
movq 0xbc2d(%rip), %rdi      # 0x12fd0
callq 0x4390
leaq 0xc(%rsp), %rsi
movb $0x3a, (%rsi)
movq 0xbc19(%rip), %rdi      # 0x12fd0
movl $0x1, %edx
callq 0x4250
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
jne 0x73e7
leaq 0xd(%rsp), %rsi
movb $0x3a, (%rsi)
movq 0xbbf3(%rip), %rdi      # 0x12fd0
movl $0x1, %edx
callq 0x4250
leaq 0x28(%rbx), %r15
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
movq 0xbbd6(%rip), %rdi      # 0x12fd0
callq 0x4250
leaq 0xe(%rsp), %rsi
movb $0x3a, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x4250
leaq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0xa796
addq $0x10, %r14
cmpq %r14, %rax
je 0x7433
leaq 0x40(%rax), %r15
addq $0x48, %rax
jmp 0x7452
addq $0x30, %rbx
movq 0xbb92(%rip), %rdi      # 0x12fd0
leaq 0x6dad(%rip), %rsi      # 0xe1f2
movl $0xd, %edx
callq 0x4250
movq %rbx, %rax
movq (%r15), %rsi
movq (%rax), %rdx
movq 0xbb71(%rip), %rbx      # 0x12fd0
movq %rbx, %rdi
callq 0x4250
leaq 0xf(%rsp), %rsi
movb $0x27, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4250
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/test4.cpp
// Function: MyOutput::usage(TCLAP::CmdLineInterface&)
virtual void usage(CmdLineInterface& c)
		{
			cout << "my usage message:" << endl;
			list<Arg*> args = c.getArgList();
			for (ArgListIterator it = args.begin(); it != args.end(); it++)
				cout << (*it)->longID()
					 << "  (" << (*it)->getDescription() << ")" << endl;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq 0x8090(%rip), %r14      # 0x12fd0
leaq 0x3399(%rip), %rsi      # 0xe2e0
movl $0x11, %edx
movq %r14, %rdi
callq 0x4250
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x41d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4160
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6c7c
movq (%rbx), %r14
cmpq %rbx, %r14
je 0xb0c6
leaq 0x50(%rsp), %rbp
leaq 0x40(%rsp), %r13
leaq 0x3288(%rip), %r15      # 0xe239
movq 0x10(%r14), %r12
movq %rbp, 0x40(%rsp)
movq %r13, %rdi
leaq 0x30eb(%rip), %rsi      # 0xe0af
leaq 0x30e7(%rip), %rdx      # 0xe0b2
callq 0x9f22
movq (%r12), %rax
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq *0x48(%rax)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x7fdd(%rip), %rdi      # 0x12fd0
callq 0x4250
movq %rax, %r12
movl $0x3, %edx
movq %rax, %rdi
leaq 0x32e8(%rip), %rsi      # 0xe2f2
callq 0x4250
movq 0x10(%r14), %rsi
movq %rsp, %rdi
callq 0xa53e
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0x4250
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x4250
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x41d0
movsbl %al, %esi
movq %r12, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4160
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xb082
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4200
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xb09e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4200
movq 0x40(%rsp), %rdi
cmpq %rbp, %rdi
je 0xb0b5
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x4200
movq (%r14), %r14
cmpq %rbx, %r14
jne 0xafb1
movq 0x60(%rsp), %r14
cmpq %rbx, %r14
je 0xb0e3
movq (%r14), %r15
movl $0x18, %esi
movq %r14, %rdi
callq 0x4200
movq %r15, %r14
cmpq %rbx, %r15
jne 0xb0cb
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xb154
movq %rax, %r14
jmp 0xb13d
jmp 0xb0fe
movq %rax, %r14
jmp 0xb121
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xb121
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4200
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xb13d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4200
movq 0x40(%rsp), %rdi
cmpq %rbp, %rdi
je 0xb154
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x4200
movq 0x60(%rsp), %rdi
cmpq %rbx, %rdi
je 0xb173
movq (%rdi), %r15
movl $0x18, %esi
callq 0x4200
movq %r15, %rdi
cmpq %rbx, %r15
jne 0xb15e
movq %r14, %rdi
callq 0x43b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/test4.cpp
// Function: MyOutput::failure(TCLAP::CmdLineInterface&, TCLAP::ArgException&)
virtual void failure(CmdLineInterface& c, ArgException& e)
		{
			static_cast<void>(c); // Ignore input, don't warn
			cerr << "my failure message: " << endl
			     << e.what() << endl;
			exit(1);
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x7e22(%rip), %rdi      # 0x12ff0
leaq 0x3139(%rip), %rsi      # 0xe30e
callq 0x41e0
movq %rax, %rdi
callq 0x4100
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x41e0
movq %rax, %rdi
callq 0x4100
movl $0x1, %edi
callq 0x4270
nop
// File: /workspace/github_cpp_makefile_star2_O3/planaria[P]cb_tree/./include/cb_tree/detail/cb_node.hpp
// Function: cb_tree::detail::cb_node<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>>>>::next_leaf() const
node_pointer next_leaf() const
			{
				node_pointer node = std::pointer_traits<node_pointer>::pointer_to(const_cast<cb_node&>(*this));

				do
				{
					if (node->right())
						return node->right()->min_leaf();

					while(!node->is_left_child())
						node = node->parent();

					node = node->parent();
				} while (!node->leaf());

				return node;
			}

// Assembly:
pushq %rax
movq 0x10(%rdi), %rax
testq %rax, %rax
jne 0xc672
movq %rdi, %rax
movq 0x18(%rdi), %rdi
cmpq %rax, (%rdi)
jne 0xc65e
cmpb $0x1, 0x8(%rdi)
jne 0xc655
jmp 0xc683
movq %rax, %rdi
movq (%rax), %rax
testq %rax, %rax
jne 0xc672
cmpb $0x0, 0x8(%rdi)
je 0xc688
movq %rdi, %rax
popq %rcx
retq
leaq 0x40430(%rip), %rdi     # 0x4cabf
leaq 0x3fe65(%rip), %rsi     # 0x4c4fb
leaq 0x4042f(%rip), %rcx     # 0x4cacc
movl $0xd5, %edx
callq 0xa240
nop
// File: /workspace/github_cpp_makefile_star2_O3/planaria[P]cb_tree/./include/cb_tree/detail/cb_node.hpp
// Function: cb_tree::detail::cb_node<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>>>>::destroy(std::allocator<cb_tree::detail::cb_node<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>>>>>&, cb_tree::detail::cb_node<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>>>>*)
static void destroy(node_allocator_type& allocator, node_pointer p)
			{
				if (p->leaf())
					node_allocator_traits::destroy(allocator, std::addressof(p->value_));
				node_allocator_traits::destroy(allocator, std::addressof(p->left_));
				node_allocator_traits::destroy(allocator, std::addressof(p->leaf_));
				node_allocator_traits::destroy(allocator, std::addressof(p->right_));
				node_allocator_traits::destroy(allocator, std::addressof(p->parent_));
				node_allocator_traits::destroy(allocator, std::addressof(p->index_));
				node_allocator_traits::deallocate(allocator, p, 1);
			}

// Assembly:
pushq %rbx
movq %rsi, %rbx
cmpb $0x1, 0x8(%rsi)
jne 0xc6ca
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0xc6ca
movq (%rax), %rsi
incq %rsi
callq 0xa3c0
movl $0x48, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xa3c0
// File: /workspace/github_cpp_makefile_star2_O3/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, 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>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::operator=(cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, 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>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
cb_tree_base& operator =(const cb_tree_base& other)
			{
				if (&other != this)
				{
					cb_tree_base temp;
					temp.copy_assign_allocator(other);
					temp.copy_impl(other);
					swap(temp);
				}

				return *this;
			}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0xc716
leaq 0x8(%rsp), %rax
movb $0x1, 0x8(%rax)
movq %rax, -0x8(%rax)
xorl %ecx, %ecx
movq %rcx, (%rax)
movq %rcx, 0x10(%rax)
movq %rsp, %rdi
callq 0xc73c
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xc770
movq %rsp, %rdi
callq 0xc8d8
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
jmp 0xc734
movq %rax, %rbx
movq %rsp, %rdi
callq 0xc8d8
movq %rbx, %rdi
callq 0xa690
movq %rax, %rdi
callq 0xbda8
// File: /workspace/github_cpp_makefile_star2_O3/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, 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>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::swap(cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, 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>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void swap(cb_tree_base& other)
			{
				if (&other == this)
					return;

				swap_allocator(other);

				std::swap(begin_node(), other.begin_node());
				std::swap(root_node(), other.root_node());
				std::swap(size_, other.size_);

				fix_swapped();
				other.fix_swapped();
			}

// Assembly:
cmpq %rdi, %rsi
je 0xc7d1
movq (%rdi), %rax
movq (%rsi), %rcx
movq %rcx, (%rdi)
movq %rax, (%rsi)
leaq 0x8(%rdi), %rcx
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rdx
movq %rdx, 0x8(%rdi)
movq %rax, 0x8(%rsi)
movq 0x18(%rdi), %rax
movq 0x18(%rsi), %rdx
movq %rdx, 0x18(%rdi)
movq %rax, 0x18(%rsi)
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0xc7b2
movq %rcx, 0x18(%rdx)
leaq 0x8(%rsi), %rdx
cmpq $0x0, 0x18(%rdi)
jne 0xc7c0
movq %rcx, (%rdi)
movq (%rdx), %rcx
testq %rcx, %rcx
je 0xc7cc
movq %rdx, 0x18(%rcx)
testq %rax, %rax
je 0xc7d2
retq
movq %rdx, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, 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>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::destroy_impl()
void destroy_impl()
			{
				node_pointer node = begin_node();

				while (node != end_node())
				{
					if (node->right())
					{
						node = node->right();
					}
					else if (node->left())
					{
						node = node->left();
					}
					else
					{
						if (node->is_left_child())
						{
							node = node->parent();
							destroy_node(node->left());
							node->left() = nullptr;
						}
						else
						{
							node = node->parent();
							destroy_node(node->right());
							node->right() = nullptr;
						}
					}
				}
			}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
leaq 0x8(%rdi), %r14
cmpq %r14, %rax
je 0xc92f
movq %rdi, %rbx
movq 0x10(%rax), %r15
testq %r15, %r15
jne 0xc927
movq (%rax), %r15
testq %r15, %r15
jne 0xc927
movq 0x18(%rax), %r15
movq (%r15), %rsi
movq %r15, %r12
cmpq %rax, %rsi
je 0xc917
leaq 0x10(%r15), %r12
movq 0x10(%r15), %rsi
movq %rbx, %rdi
callq 0xc6a8
movq $0x0, (%r12)
movq %r15, %rax
cmpq %r14, %r15
jne 0xc8ef
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::operator==(cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
bool operator ==(const derived_type& lhs, const derived_type& rhs)
			{
				if (&lhs == &rhs)
					return true;

				if (lhs.size() != rhs.size())
					return false;

				return std::equal(lhs.begin(), lhs.end(), rhs.begin());
			}

// Assembly:
pushq %rax
cmpq %rsi, %rdi
je 0xcadb
movq %rdi, %rax
movq 0x18(%rdi), %rcx
cmpq 0x18(%rsi), %rcx
jne 0xcadf
movq (%rax), %rdi
testq %rdi, %rdi
je 0xcae3
movq (%rsi), %rdx
testq %rdx, %rdx
je 0xcae3
addq $0x8, %rax
movq %rax, %rsi
popq %rax
jmp 0xcb02
movb $0x1, %al
jmp 0xcae1
xorl %eax, %eax
popq %rcx
retq
leaq 0x3fafd(%rip), %rdi     # 0x4c5e7
leaq 0x3fafb(%rip), %rsi     # 0x4c5ec
leaq 0x40a28(%rip), %rcx     # 0x4d520
movl $0x38, %edx
callq 0xa240
// File: /workspace/github_cpp_makefile_star2_O3/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, 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>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::operator=(cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, 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>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&&)
cb_tree_base& operator =(cb_tree_base&& other)
			{
				if (&other != this)
				{
					destroy_impl();
					move_assign_allocator(other);
					move_impl(std::move(other));
				}

				return *this;
			}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0xcc0d
movq %rsi, %r14
movq %rbx, %rdi
callq 0xc8d8
movq (%r14), %rax
movq %rax, (%rbx)
leaq 0x8(%r14), %rcx
movq 0x8(%r14), %rdx
leaq 0x8(%rbx), %rax
movq %rdx, 0x8(%rbx)
movq 0x18(%r14), %rdx
movq %rdx, 0x18(%rbx)
movq %rcx, (%r14)
xorl %ecx, %ecx
movq %rcx, 0x8(%r14)
movq %rcx, 0x18(%r14)
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0xcc03
movq %rax, 0x18(%rcx)
cmpq $0x0, 0x18(%rbx)
jne 0xcc0d
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::unique_ptr<counter, std::default_delete<counter>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::unique_ptr<counter, std::default_delete<counter>>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::unique_ptr<counter, std::default_delete<counter>>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::unique_ptr<counter, std::default_delete<counter>>>>>::erase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
size_type erase(const key_type& key)
			{
				auto it = find(key);
				if (it == end())
					return 0;

				erase(it);
				return 1;
			}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xf678
testq %rax, %rax
je 0xf04d
leaq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0xf049
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf6c0
movl $0x1, %eax
jmp 0xf04b
xorl %eax, %eax
popq %rbx
retq
leaq 0x3db49(%rip), %rdi     # 0x4cb9d
leaq 0x3d591(%rip), %rsi     # 0x4c5ec
leaq 0x3fa50(%rip), %rcx     # 0x4eab2
movl $0x6d, %edx
callq 0xa240
// File: /workspace/github_cpp_makefile_star2_O3/planaria[P]cb_tree/./include/cb_tree/detail/cb_node.hpp
// Function: cb_tree::detail::cb_node<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>>>>* cb_tree::detail::cb_node<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>>>>::construct<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::allocator<cb_tree::detail::cb_node<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>>&&)
static node_pointer construct(node_allocator_type& allocator, Value_&& value)
			{
				node_pointer p = node_allocator_traits::allocate(allocator, 1);
				node_allocator_traits::construct(allocator, std::addressof(p->left_), nullptr);
				node_allocator_traits::construct(allocator, std::addressof(p->leaf_), true);
				node_allocator_traits::construct(allocator, std::addressof(p->right_), nullptr);
				node_allocator_traits::construct(allocator, std::addressof(p->parent_), nullptr);
				node_allocator_traits::construct(allocator, std::addressof(p->index_), 0);
				node_allocator_traits::construct(allocator, std::addressof(p->value_), std::forward<Value_>(value));
				return p;
			}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movl $0x48, %edi
callq 0xa3a0
xorl %ecx, %ecx
movq %rcx, (%rax)
movb $0x1, 0x8(%rax)
leaq 0x38(%rax), %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %rcx, 0x20(%rax)
movq %rdx, 0x28(%rax)
movq (%rbx), %rsi
leaq 0x10(%rbx), %rcx
cmpq %rcx, %rsi
je 0x1569b
movq %rsi, 0x28(%rax)
movq (%rcx), %rdx
movq %rdx, 0x38(%rax)
jmp 0x156a1
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rbx), %rdx
movq %rdx, 0x30(%rax)
movq %rcx, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::unique_ptr<counter, std::default_delete<counter>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::unique_ptr<counter, std::default_delete<counter>>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::unique_ptr<counter, std::default_delete<counter>>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::unique_ptr<counter, std::default_delete<counter>>>>>::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
iterator find(const key_type& key)
			{
				node_pointer node = find_branch(key);
				if (node == end_node() || !node->leaf())
					return end();

				if (!traits_type::equal(derived().key(node->value()), key))
					return end();

				return iterator(node);
			}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
shlq $0x4, %rdx
incq %rdx
callq 0xf3c0
addq $0x8, %rbx
cmpq %rbx, %rax
je 0xf6b7
movq %rax, %r15
cmpb $0x1, 0x8(%rax)
jne 0xf6b7
leaq 0x28(%r15), %rdi
movq %r14, %rsi
callq 0xf7f8
testb %al, %al
cmovneq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, 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>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cb_tree::cb_key_traits<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::upper_bound(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
iterator upper_bound(const key_type& key)
			{
				auto it = lower_bound(key);
				if (it == end())
					return it;

				if (!traits_type::equal(derived().key(*it), key))
					return it;

				++it;
				return it;
			}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1510a
movq %rax, (%rsp)
testq %rax, %rax
je 0x152b8
addq $0x8, %r14
cmpq %r14, %rax
je 0x152ac
movq %rsp, %rdi
callq 0x15a02
movq %rax, %rdi
movq %rbx, %rsi
callq 0xf7f8
testb %al, %al
je 0x152ac
movq %rsp, %rdi
callq 0xc61c
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x378de(%rip), %rdi     # 0x4cb9d
leaq 0x37326(%rip), %rsi     # 0x4c5ec
leaq 0x378e3(%rip), %rcx     # 0x4cbb0
movl $0x6d, %edx
callq 0xa240
nop
// File: /workspace/github_cpp_makefile_star2_O3/planaria[P]cb_tree/./include/cb_tree/detail/cb_tree_base.hpp
// Function: cb_tree::detail::cb_tree_base<cb_tree::cb_set<unsigned short, cb_tree::cb_key_traits<unsigned short, void>, std::allocator<unsigned short>>, unsigned short, unsigned short, cb_tree::cb_key_traits<unsigned short, void>, std::allocator<unsigned short>>::find_branch(unsigned short const&, unsigned long) const
node_pointer find_branch(const key_type& key, size_type size) const
			{
				assert(traits_type::size(key) == size);
				node_pointer node = root_node();

				if (!node)
					return end_node();

				while (true)
				{
					if (size <= node->index())
						break;

					if (!node->left() && !node->right())
						break;

					if (traits_type::test(key, node->index()))
					{
						if (!node->right())
							break;

						node = node->right();
					}
					else
					{
						if (!node->left())
							break;

						node = node->left();
					}
				}

				return node;
			}

// Assembly:
pushq %rax
cmpq $0x10, %rdx
jne 0x1a783
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1a77a
movq 0x20(%rax), %rdx
cmpq $0xf, %rdx
ja 0x1a781
movzwl (%rsi), %ecx
movq (%rax), %rsi
testq %rsi, %rsi
je 0x1a74c
movb $0xf, %dil
subb %dl, %dil
movzbl %dil, %edx
btl %edx, %ecx
jb 0x1a762
jmp 0x1a76b
cmpq $0x0, 0x10(%rax)
je 0x1a781
movb $0xf, %sil
subb %dl, %sil
movzbl %sil, %edx
btl %edx, %ecx
jae 0x1a781
movq 0x10(%rax), %rsi
testq %rsi, %rsi
je 0x1a781
movq 0x20(%rsi), %rdx
movq %rsi, %rax
cmpq $0x10, %rdx
jb 0x1a733
jmp 0x1a781
addq $0x8, %rdi
movq %rdi, %rax
popq %rcx
retq
leaq 0x31b5d(%rip), %rdi     # 0x4c2e7
leaq 0x31918(%rip), %rsi     # 0x4c0a9
leaq 0x37b39(%rip), %rcx     # 0x522d1
movl $0x2a8, %edx            # imm = 0x2A8
callq 0xa240
// File: /workspace/github_cpp_makefile_star2_O3/planaria[P]cb_tree/./include/cb_tree/cb_key_traits.hpp
// Function: cb_tree::cb_key_traits<float, void>::test(float, unsigned long)
static bool test(value_type value, std::size_t index)
		{
			assert(index < size(value));
			unsigned_value_type unsigned_value = to_unsigned(value);
			if (unsigned_value & 0x80000000)
				unsigned_value = ~unsigned_value;
			else
				unsigned_value ^= 0x80000000;
			return (unsigned_value & (static_cast<unsigned_value_type>(1) << static_cast<unsigned_value_type>(num_bits - index - 1))) != 0;
		}

// Assembly:
cmpq $0x20, %rdi
jae 0x1704e
movd %xmm0, %ecx
movl %ecx, %eax
orl $0x80000000, %eax       # imm = 0x80000000
testl %ecx, %ecx
notl %ecx
cmovsl %ecx, %eax
movl %edi, %ecx
shll %cl, %eax
shrl $0x1f, %eax
retq
pushq %rax
leaq 0x3a30c(%rip), %rdi     # 0x51362
leaq 0x35db4(%rip), %rsi     # 0x4ce11
leaq 0x3a312(%rip), %rcx     # 0x51376
movl $0xbb, %edx
callq 0xa240
// File: /workspace/github_cpp_makefile_star2_O3/planaria[P]cb_tree/./include/cb_tree/cb_key_traits.hpp
// Function: cb_tree::cb_key_traits<double, void>::test(double, unsigned long)
static bool test(value_type value, std::size_t index)
		{
			assert(index < size(value));
			unsigned_value_type unsigned_value = to_unsigned(value);
			if (unsigned_value & 0x8000000000000000)
				unsigned_value = ~unsigned_value;
			else
				unsigned_value ^= 0x8000000000000000;
			return (unsigned_value & (static_cast<unsigned_value_type>(1) << static_cast<unsigned_value_type>(num_bits - index - 1))) != 0;
		}

// Assembly:
cmpq $0x40, %rdi
jae 0x17b87
movq %xmm0, %rcx
movq %rcx, %rax
btsq $0x3f, %rax
testq %rcx, %rcx
notq %rcx
cmovsq %rcx, %rax
movl %edi, %ecx
shlq %cl, %rax
shrq $0x3f, %rax
retq
pushq %rax
leaq 0x397d3(%rip), %rdi     # 0x51362
leaq 0x3527b(%rip), %rsi     # 0x4ce11
leaq 0x3a1e8(%rip), %rcx     # 0x51d85
movl $0xf6, %edx
callq 0xa240
nop