LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/nvanbenschoten[P]total-order-multicast/include/args.h
// Function: args::FlagBase* args::Group::Match<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&)
FlagBase *Match(const T &flag) {
    for (Base *child : children) {
      if (FlagBase *flagBase = dynamic_cast<FlagBase *>(child)) {
        if (FlagBase *match = flagBase->Match(flag)) {
          return match;
        }
      } else if (Group *group = dynamic_cast<Group *>(child)) {
        if (FlagBase *match = group->Match(flag)) {
          return match;
        }
      }
    }
    return nullptr;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x30(%rdi), %rbx
movq 0x38(%rdi), %r13
leaq 0xc51d(%rip), %r15      # 0x1b690
leaq 0xc53e(%rip), %r12      # 0x1b6b8
cmpq %r13, %rbx
je 0xf1d9
movq (%rbx), %rbp
testq %rbp, %rbp
je 0xf1d3
movq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x53a0
testq %rax, %rax
je 0xf1aa
movq (%rax), %rcx
movq %rax, %rdi
movq %r14, %rsi
callq *0x30(%rcx)
jmp 0xf1ce
movq %rbp, %rdi
movq %r15, %rsi
leaq 0xc519(%rip), %rdx      # 0x1b6d0
xorl %ecx, %ecx
callq 0x53a0
testq %rax, %rax
je 0xf1d3
movq %rax, %rdi
movq %r14, %rsi
callq 0xf156
testq %rax, %rax
jne 0xf1db
addq $0x8, %rbx
jmp 0xf17a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nvanbenschoten[P]total-order-multicast/include/args.h
// Function: args::ValueFlagBase::GetDescription(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&, 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&) const
virtual std::tuple<std::string, std::string> GetDescription(
      const std::string &shortPrefix, const std::string &longPrefix,
      const std::string &shortSeparator,
      const std::string &longSeparator) const override {
    std::tuple<std::string, std::string> description;
    const auto flagStrings = matcher.GetFlagStrings(
        shortPrefix, longPrefix, Name(), shortSeparator, longSeparator);
    std::ostringstream flagstream;
    for (auto it = std::begin(flagStrings); it != std::end(flagStrings); ++it) {
      if (it != std::begin(flagStrings)) {
        flagstream << ", ";
      }
      flagstream << *it;
    }
    std::get<0>(description) = flagstream.str();
    std::get<1>(description) = help;
    return description;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %r9, %r13
movq %r8, 0x10(%rsp)
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rcx, %r12
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq %rdx, %rbp
movq %rsi, %r14
movb %al, 0x30(%rdi)
movq (%rsi), %rax
leaq 0x70(%rsp), %rdi
callq *0x28(%rax)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x5490
leaq 0x58(%r14), %rsi
movq %r15, (%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x70(%rsp), %r8
movq %rbp, %rdx
movq %r12, %rcx
movq 0x10(%rsp), %r9
callq 0xfda2
leaq 0x30(%rsp), %rdi
callq 0x56f8
leaq 0x70(%rsp), %rdi
callq 0x56f8
leaq 0x70(%rsp), %rdi
callq 0x5470
leaq 0x20(%rbx), %r15
movq 0x18(%rsp), %r12
leaq 0x70(%rsp), %r13
leaq 0x30b1(%rip), %rbp      # 0x12d57
cmpq 0x20(%rsp), %r12
je 0xfcd0
cmpq 0x18(%rsp), %r12
je 0xfcbf
movq %r13, %rdi
movq %rbp, %rsi
callq 0x5340
movq %r13, %rdi
movq %r12, %rsi
callq 0x5310
addq $0x20, %r12
jmp 0xfca6
leaq 0x78(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x5540
leaq 0x50(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x53f0
movq %r12, %rdi
callq 0x56f8
addq $0x10, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51e0
leaq 0x70(%rsp), %rdi
callq 0x50b0
leaq 0x18(%rsp), %rdi
callq 0xad04
movq %rbx, %rax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xfd5b
jmp 0xfd5b
movq %rax, %r14
jmp 0xfd68
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x56f8
jmp 0xfd4a
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x56f8
jmp 0xfd72
movq %rax, %r14
jmp 0xfd72
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x50b0
leaq 0x18(%rsp), %rdi
callq 0xad04
movq %rbx, %rdi
callq 0xc2e6
movq %r14, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O2/nvanbenschoten[P]total-order-multicast/include/args.h
// Function: args::ValueReader<int>::operator()(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&, int&)
bool operator()(const std::string &name, const std::string &value,
                  T &destination) {
    std::istringstream ss(value);
    ss >> destination;

    if (ss.rdbuf()->in_avail() > 0) {
#ifdef ARGS_NOEXCEPT
      return false;
#else
      std::ostringstream problem;
      problem << "Argument '" << name << "' received invalid value type '"
              << value << "'";
      throw ParseError(problem.str());
#endif
    }
    return true;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x320, %rsp            # imm = 0x320
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x1a0(%rsp), %r12
pushq $0x8
popq %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x55b0
movq %r12, %rdi
movq %r15, %rsi
callq 0x5220
leaq 0x1b0(%rsp), %rdi
callq 0x5660
testq %rax, %rax
jg 0x100b0
leaq 0x1a0(%rsp), %rdi
callq 0x5190
movb $0x1, %al
addq $0x320, %rsp            # imm = 0x320
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%rsp), %rdi
callq 0x5470
leaq 0x2e0d(%rip), %rsi      # 0x12ece
leaq 0x28(%rsp), %rdi
callq 0x5340
movq %rax, %rdi
movq %r14, %rsi
callq 0x5310
leaq 0x2dfc(%rip), %rsi      # 0x12ed9
movq %rax, %rdi
callq 0x5340
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5310
leaq 0x2d65(%rip), %rsi      # 0x12e5c
movq %rax, %rdi
callq 0x5340
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x5540
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xf1ea
xorl %ebp, %ebp
leaq 0xb896(%rip), %rsi      # 0x1b9c8
movq 0xbe4f(%rip), %rdx      # 0x1bf88
movq %rbx, %rdi
callq 0x55f0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x56f8
testb %bpl, %bpl
jne 0x10158
jmp 0x10165
movq %rax, %r14
movq %rbx, %rdi
callq 0x5270
jmp 0x10165
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x50b0
jmp 0x10176
jmp 0x10173
movq %rax, %r14
leaq 0x1a0(%rsp), %rdi
callq 0x5190
movq %r14, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/nvanbenschoten[P]total-order-multicast/src/udp_conn.cc
// Function: udp::CreateSocket(std::chrono::duration<long, std::ratio<1l, 1000000l>>)
Socket CreateSocket(const std::chrono::microseconds timeout) {
  // Create the socket.
  Socket sockfd = socket(AF_INET, SOCK_DGRAM, 0);
  if (sockfd < 0) {
    throw net::SocketException();
  }

  // Resuse the port immediately after the socket is killed.
  int optval = 1;
  if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const void *)&optval,
                 sizeof(int))) {
    throw net::SocketException();
  }

  // Set socket timeout if provided.
  if (timeout.count() > 0) {
    // Truncate to integer number of seconds.
    const auto secs = std::chrono::duration_cast<std::chrono::seconds>(timeout);

    struct timeval timeval;
    timeval.tv_sec = secs.count();
    timeval.tv_usec = (timeout - secs).count();
    if (setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeval,
                   sizeof(timeval))) {
      throw net::SocketException();
    }
  }

  return sockfd;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
pushq $0x2
popq %rdi
movl %edi, %esi
xorl %edx, %edx
callq 0x50c0
testl %eax, %eax
js 0x10233
movl %eax, %ebx
leaq 0x4(%rsp), %rcx
movl $0x1, (%rcx)
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
pushq $0x4
popq %r8
movl %eax, %edi
callq 0x5630
testl %eax, %eax
jne 0x1024a
testq %r14, %r14
jle 0x10229
movl $0xf4240, %ecx          # imm = 0xF4240
movq %r14, %rax
xorl %edx, %edx
divq %rcx
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
imulq $-0xf4240, %rax, %rax   # imm = 0xFFF0BDC0
addq %r14, %rax
movq %rax, 0x8(%rcx)
pushq $0x1
popq %rsi
pushq $0x14
popq %rdx
pushq $0x10
popq %r8
movl %ebx, %edi
callq 0x5630
testl %eax, %eax
jne 0x10261
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl $0x180, %edi            # imm = 0x180
callq 0x51b0
movq %rax, %r14
movq %rax, %rdi
callq 0x10912
jmp 0x10276
movl $0x180, %edi            # imm = 0x180
callq 0x51b0
movq %rax, %r14
movq %rax, %rdi
callq 0x10912
jmp 0x10276
movl $0x180, %edi            # imm = 0x180
callq 0x51b0
movq %rax, %r14
movq %rax, %rdi
callq 0x10912
leaq 0xb96b(%rip), %rsi      # 0x1bbe8
leaq 0x8d4(%rip), %rdx       # 0x10b58
movq %r14, %rdi
callq 0x55f0
jmp 0x10290
jmp 0x10290
movq %rax, %rbx
movq %r14, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/nvanbenschoten[P]total-order-multicast/src/udp_conn.cc
// Function: udp::SocketAddress::SocketAddress(net::Address)
SocketAddress::SocketAddress(net::Address addr) {
  // Get the remote server's DNS entry.
  struct hostent *server = gethostbyname(addr.hostname().c_str());
  if (server == nullptr) {
    throw net::HostNotFoundException(addr.hostname());
  }

  // Build the server's Internet address.
  addr_.sin_family = AF_INET;
  bcopy((char *)server->h_addr, (char *)&addr_.sin_addr.s_addr,
        server->h_length);
  addr_.sin_port = htons(addr.port());
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x53b0
testq %rax, %rax
je 0x102ee
movw $0x2, (%rbx)
movq 0x18(%rax), %rcx
movq (%rcx), %rsi
leaq 0x4(%rbx), %rdi
movslq 0x14(%rax), %rdx
callq 0x5570
movzwl 0x20(%r14), %eax
rolw $0x8, %ax
movw %ax, 0x2(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x180, %edi            # imm = 0x180
callq 0x51b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x5490
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x10966
xorl %ebp, %ebp
leaq 0xb8e3(%rip), %rsi      # 0x1bc00
leaq 0x834(%rip), %rdx       # 0x10b58
movq %rbx, %rdi
callq 0x55f0
movq %rax, %r14
movq %rsp, %rdi
callq 0x56f8
testb %bpl, %bpl
jne 0x10341
jmp 0x10349
movq %rax, %r14
movq %rbx, %rdi
callq 0x5270
movq %r14, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/nvanbenschoten[P]total-order-multicast/src/udp_conn.cc
// Function: udp::SocketAddress::Hostname[abi:cxx11]() const
std::string SocketAddress::Hostname() const {
  struct hostent *hostp = gethostbyaddr((const char *)&addr_.sin_addr.s_addr,
                                        sizeof(addr_.sin_addr.s_addr), AF_INET);
  if (hostp == nullptr) {
    throw net::HostNotFoundException("");
  }

  std::string hostname(hostp->h_name);
  if (hostname == "localhost") {
    hostname = net::GetHostname();
  }
  return hostname;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x4(%rsi), %rdi
pushq $0x4
popq %rsi
pushq $0x2
popq %rdx
callq 0x5480
testq %rax, %rax
je 0x103bc
movq (%rax), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x71e8
leaq 0x2dd1(%rip), %rsi      # 0x13157
movq %rbx, %rdi
callq 0x109b5
testb %al, %al
je 0x103b0
movq %rsp, %rdi
callq 0x110c4
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53f0
movq %r14, %rdi
callq 0x56f8
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x180, %edi            # imm = 0x180
callq 0x51b0
movq %rax, %rbx
leaq 0x28af(%rip), %rsi      # 0x12c7f
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x71e8
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x10966
xorl %ebp, %ebp
leaq 0xb80a(%rip), %rsi      # 0x1bc00
leaq 0x75b(%rip), %rdx       # 0x10b58
movq %rbx, %rdi
callq 0x55f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x56f8
jmp 0x10431
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x56f8
testb %bpl, %bpl
jne 0x10429
jmp 0x10431
movq %rax, %r14
movq %rbx, %rdi
callq 0x5270
movq %r14, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/nvanbenschoten[P]total-order-multicast/src/udp_conn.cc
// Function: udp::Client::Send(char const*, unsigned long)
void Client::Send(const char *buf, size_t size) {
  std::lock_guard<std::recursive_mutex> guard(sockfd_mutex_);
  auto addr = remote_address_.addr();
  auto addrlen = remote_address_.addr_len();
  if (sendto(sockfd_, buf, size, 0, addr, addrlen) < 0) {
    throw net::SendException();
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x10c9a
movl 0x38(%r12), %edi
addq $0x3c, %r12
pushq $0x10
popq %r9
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
movq %r12, %r8
callq 0x5050
testq %rax, %rax
js 0x10496
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5290
movl $0x180, %edi            # imm = 0x180
callq 0x51b0
movq %rax, %r14
movq %rax, %rdi
callq 0x109c2
leaq 0xb766(%rip), %rsi      # 0x1bc18
leaq 0x69f(%rip), %rdx       # 0x10b58
movq %r14, %rdi
callq 0x55f0
movq %rax, %r15
movq %r14, %rdi
callq 0x5270
jmp 0x104d1
movq %rax, %r15
movq %rbx, %rdi
callq 0x5290
movq %r15, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/nvanbenschoten[P]total-order-multicast/src/udp_conn.cc
// Function: udp::Client::WaitBackoff(unsigned int) const
void Client::WaitBackoff(unsigned int multiplier) const {
  static thread_local std::default_random_engine random_engine(
      std::chrono::system_clock::now().time_since_epoch().count());

  // Wait on the order of 10 ms * multiplier.
  auto delay_base = std::chrono::milliseconds{10}.count();
  std::poisson_distribution<int> poisson(delay_base);
  int delay = poisson(random_engine);
  if (delay <= 0) {
    return;
  }
  delay *= multiplier;
  std::this_thread::sleep_for(std::chrono::milliseconds{delay});
  return;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebx
cmpb $0x0, %fs:-0x8
je 0x106cb
leaq 0x10(%rsp), %r14
movsd 0x2a6b(%rip), %xmm0     # 0x130f8
movq %r14, %rdi
callq 0x7012
movq %fs:0x0, %rax
leaq -0x10(%rax), %rsi
movq %r14, %rdi
callq 0x7038
testl %eax, %eax
jle 0x106c3
imull %ebx, %eax
cltq
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x10aae
addq $0x78, %rsp
popq %rbx
popq %r14
retq
callq 0x5040
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %rcx
cmpq $0x1, %rdx
adcq $0x0, %rdx
movq %rdx, %fs:-0x10
movb $0x1, %fs:-0x8
jmp 0x10680
// File: /workspace/github_cpp_makefile_star2_O2/nvanbenschoten[P]total-order-multicast/src/udp_conn.cc
// Function: udp::Server::Server(unsigned short, std::chrono::duration<long, std::ratio<1l, 1000000l>>)
Server::Server(unsigned short port, std::chrono::microseconds timeout)
    : sockfd_(CreateSocket(timeout)) {
  // Create a socket and associate the it with the port
  struct sockaddr_in server_address = {};
  server_address.sin_family = AF_INET;
  server_address.sin_addr.s_addr = htonl(INADDR_ANY);
  server_address.sin_port = htons(port);

  if (bind(sockfd_, (struct sockaddr *)&server_address,
           sizeof(server_address)) < 0) {
    throw net::BindException();
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x101b0
movl %eax, (%r14)
leaq 0x8(%rsp), %rsi
andq $0x0, 0x8(%rsi)
movw $0x2, (%rsi)
andl $0x0, 0x4(%rsi)
rolw $0x8, %bx
movw %bx, 0x2(%rsi)
pushq $0x10
popq %rdx
movl %eax, %edi
callq 0x5060
testl %eax, %eax
js 0x1073e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl $0x180, %edi            # imm = 0x180
callq 0x51b0
movq %rax, %rbx
movq %rax, %rdi
callq 0x10b04
leaq 0xb4ee(%rip), %rsi      # 0x1bc48
leaq 0x3f7(%rip), %rdx       # 0x10b58
movq %rbx, %rdi
callq 0x55f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5270
movq %r14, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O2/nvanbenschoten[P]total-order-multicast/src/message.cc
// Function: msg::operator<<(std::ostream&, msg::DataMessage const&)
std::ostream& operator<<(std::ostream& o, const DataMessage& data_msg) {
  o << "{type: " << data_msg.type;
  o << ", sender: " << data_msg.sender;
  o << ", msg_id: " << data_msg.msg_id;
  o << ", data: " << data_msg.data;
  o << "}";
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x23ce(%rip), %rsi      # 0x13257
callq 0x5340
movl (%r14), %esi
movq %rax, %rdi
callq 0x5240
leaq 0x23bf(%rip), %rsi      # 0x1325f
movq %rbx, %rdi
callq 0x5340
movl 0x4(%r14), %esi
movq %rax, %rdi
callq 0x5240
leaq 0x23af(%rip), %rsi      # 0x1326a
movq %rbx, %rdi
callq 0x5340
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x5240
leaq 0x239f(%rip), %rsi      # 0x13275
movq %rbx, %rdi
callq 0x5340
movl 0xc(%r14), %esi
movq %rax, %rdi
callq 0x5240
leaq 0x1d7f(%rip), %rsi      # 0x12c70
movq %rbx, %rdi
callq 0x5340
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/nvanbenschoten[P]total-order-multicast/src/message.cc
// Function: msg::operator<<(std::ostream&, msg::AckMessage const&)
std::ostream& operator<<(std::ostream& o, const AckMessage& ack_msg) {
  o << "{type: " << ack_msg.type;
  o << ", sender: " << ack_msg.sender;
  o << ", msg_id: " << ack_msg.msg_id;
  o << ", proposed_seq: " << ack_msg.proposed_seq;
  o << ", proposer: " << ack_msg.proposer;
  o << "}";
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2342(%rip), %rsi      # 0x13257
callq 0x5340
movl (%r14), %esi
movq %rax, %rdi
callq 0x5240
leaq 0x2333(%rip), %rsi      # 0x1325f
movq %rbx, %rdi
callq 0x5340
movl 0x4(%r14), %esi
movq %rax, %rdi
callq 0x5240
leaq 0x2323(%rip), %rsi      # 0x1326a
movq %rbx, %rdi
callq 0x5340
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x5240
leaq 0x231c(%rip), %rsi      # 0x1327e
movq %rbx, %rdi
callq 0x5340
movl 0xc(%r14), %esi
movq %rax, %rdi
callq 0x5240
leaq 0x2312(%rip), %rsi      # 0x1328f
movq %rbx, %rdi
callq 0x5340
movl 0x10(%r14), %esi
movq %rax, %rdi
callq 0x5240
leaq 0x1cd8(%rip), %rsi      # 0x12c70
movq %rbx, %rdi
callq 0x5340
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/nvanbenschoten[P]total-order-multicast/src/message.cc
// Function: msg::operator<<(std::ostream&, msg::SeqMessage const&)
std::ostream& operator<<(std::ostream& o, const SeqMessage& seq_msg) {
  o << "{type: " << seq_msg.type;
  o << ", sender: " << seq_msg.sender;
  o << ", msg_id: " << seq_msg.msg_id;
  o << ", final_seq: " << seq_msg.final_seq;
  o << ", final_seq_proposer: " << seq_msg.final_seq_proposer;
  o << "}";
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x229b(%rip), %rsi      # 0x13257
callq 0x5340
movl (%r14), %esi
movq %rax, %rdi
callq 0x5240
leaq 0x228c(%rip), %rsi      # 0x1325f
movq %rbx, %rdi
callq 0x5340
movl 0x4(%r14), %esi
movq %rax, %rdi
callq 0x5240
leaq 0x227c(%rip), %rsi      # 0x1326a
movq %rbx, %rdi
callq 0x5340
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x5240
leaq 0x2293(%rip), %rsi      # 0x1329c
movq %rbx, %rdi
callq 0x5340
movl 0xc(%r14), %esi
movq %rax, %rdi
callq 0x5240
leaq 0x2286(%rip), %rsi      # 0x132aa
movq %rbx, %rdi
callq 0x5340
movl 0x10(%r14), %esi
movq %rax, %rdi
callq 0x5240
leaq 0x1c31(%rip), %rsi      # 0x12c70
movq %rbx, %rdi
callq 0x5340
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/nvanbenschoten[P]total-order-multicast/src/message.cc
// Function: msg::operator<<(std::ostream&, msg::SeqAckMessage const&)
std::ostream& operator<<(std::ostream& o, const SeqAckMessage& seqack_msg) {
  o << "{type: " << seqack_msg.type;
  o << ", sender: " << seqack_msg.sender;
  o << ", msg_id: " << seqack_msg.msg_id;
  o << "}";
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x21f4(%rip), %rsi      # 0x13257
callq 0x5340
movl (%r14), %esi
movq %rax, %rdi
callq 0x5240
leaq 0x21e5(%rip), %rsi      # 0x1325f
movq %rbx, %rdi
callq 0x5340
movl 0x4(%r14), %esi
movq %rax, %rdi
callq 0x5240
leaq 0x21d5(%rip), %rsi      # 0x1326a
movq %rbx, %rdi
callq 0x5340
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x5240
leaq 0x1bc0(%rip), %rsi      # 0x12c70
movq %rbx, %rdi
callq 0x5340
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nvanbenschoten[P]total-order-multicast/src/net.cc
// Function: net::AddressWithDefaultPort(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::experimental::fundamentals_v1::optional<unsigned short>)
Address AddressWithDefaultPort(
    std::string addr, std::experimental::optional<unsigned short> port) {
  size_t found = addr.find(":");
  if (found != std::string::npos) {
    port = std::stoi(addr.substr(found + 1));
    addr = addr.substr(0, found);
  } else if (!port) {
    throw std::invalid_argument(
        "port not specified in address and no default port provided");
  }
  return Address(addr, *port);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x2171(%rip), %rsi      # 0x132c1
movq %r15, %rdi
xorl %edx, %edx
callq 0x56d0
cmpq $-0x1, %rax
je 0x111cb
movq %rax, %r12
leaq 0x1(%rax), %rdx
leaq 0x8(%rsp), %r13
pushq $-0x1
popq %rcx
movq %r13, %rdi
movq %r15, %rsi
callq 0x5380
pushq $0xa
popq %rdx
movq %r13, %rdi
xorl %esi, %esi
callq 0x1126d
cmpb $0x0, 0x2(%r14)
jne 0x11193
movb $0x1, 0x2(%r14)
movw %ax, (%r14)
leaq 0x8(%rsp), %rdi
callq 0x56f8
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %r12, %rcx
callq 0x5380
movq %r15, %rdi
movq %r13, %rsi
callq 0x53f0
movq %r13, %rdi
callq 0x56f8
jmp 0x111d2
cmpb $0x0, 0x2(%r14)
je 0x11211
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5490
movzwl (%r14), %ebp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5490
movw %bp, 0x20(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x56f8
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %r14
leaq 0x20a0(%rip), %rsi      # 0x132c3
movq %rax, %rdi
callq 0x5680
movq 0xad96(%rip), %rsi      # 0x1bfc8
movq 0xad77(%rip), %rdx      # 0x1bfb0
movq %r14, %rdi
callq 0x55f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x5270
jmp 0x11265
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x11260
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x56f8
movq %rbx, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O2/lemire[P]backward_multiplication/include/backwardmultiply.h
// Function: backwardmultiply::multiplication(unsigned long, unsigned long const*, unsigned long, unsigned long*)
void multiplication(uint64_t w, const uint64_t *b, size_t n, uint64_t *output) {
  if ((w == 0) || (n == 0)) { // special case
    std::fill(output, output + n + 1, 0);
    return;
  }
  auto p = full_multiplication(w, b[0]);
  output[0] = p.low;
  uint64_t r = p.high;
  for (size_t i = 1; i < n; i++) {
    p = full_multiplication(w, b[i]);
    p.add(r);
    output[i] = p.low;
    r = p.high;
  }
  output[n] = r;
}

// Assembly:
movq %rdx, %r8
testq %rdi, %rdi
setne %al
testq %rdx, %rdx
setne %dl
testb %dl, %al
jne 0x12a0
leaq 0x8(,%r8,8), %rax
xorl %edx, %edx
cmpq %rdx, %rax
je 0x12d3
andq $0x0, (%rcx,%rdx)
addq $0x8, %rdx
jmp 0x1290
movq %rdi, %rax
mulq (%rsi)
movq %rdx, %r9
movq %rax, (%rcx)
pushq $0x1
popq %r10
cmpq %r10, %r8
je 0x12cf
movq %rdi, %rax
mulq (%rsi,%r10,8)
addq %rax, %r9
adcq $0x0, %rdx
movq %r9, (%rcx,%r10,8)
incq %r10
movq %rdx, %r9
jmp 0x12b0
movq %r9, (%rcx,%r8,8)
retq
// File: /workspace/github_cpp_makefile_star2_O2/lemire[P]backward_multiplication/include/backwardmultiply.h
// Function: backwardmultiply::multiplication_backward(unsigned long, unsigned long const*, unsigned long, unsigned long*)
void multiplication_backward(uint64_t w, const uint64_t *b, size_t n,
                             uint64_t *output) {
  if ((w == 0) || (n == 0)) { // special case
    std::fill(output, output + n + 1, 0);
    return;
  }
  auto p = full_multiplication(w, b[n - 1]);
  output[n - 1] = p.low;
  output[n] = p.high;
  for (size_t i = n - 2; i != SIZE_MAX; i--) {
    p = full_multiplication(w, b[i]);
    output[i] = p.low;
    bool overflow = (output[i + 1] + p.high < output[i + 1]);
    output[i + 1] += p.high;
    for (size_t j = i + 2; overflow; j++) {
      output[j]++;
      overflow = (output[j] == 0);
    }
  }
}

// Assembly:
movq %rdx, %r8
testq %rdi, %rdi
setne %al
testq %rdx, %rdx
setne %dl
testb %dl, %al
jne 0x1301
leaq 0x8(,%r8,8), %rax
xorl %edx, %edx
cmpq %rdx, %rax
je 0x134e
andq $0x0, (%rcx,%rdx)
addq $0x8, %rdx
jmp 0x12f1
movq %rdi, %rax
mulq -0x8(%rsi,%r8,8)
leaq (%rcx,%r8,8), %r9
movq %rax, -0x8(%r9)
movq %rdx, (%r9)
addq $-0x2, %r8
cmpq $-0x1, %r8
je 0x134e
movq %rdi, %rax
mulq (%rsi,%r8,8)
movq %rax, (%rcx,%r8,8)
addq %rdx, 0x8(%rcx,%r8,8)
setb %dl
movq %r9, %rax
testb $0x1, %dl
je 0x1345
incq (%rax)
sete %dl
addq $0x8, %rax
jmp 0x1334
decq %r8
addq $-0x8, %r9
jmp 0x1318
retq
// File: /workspace/github_cpp_makefile_star2_O2/lemire[P]backward_multiplication/include/backwardmultiply.h
// Function: backwardmultiply::multiplication_backward_limit(unsigned long, unsigned long const*, unsigned long, unsigned long*, unsigned long)
size_t multiplication_backward_limit(uint64_t w, const uint64_t *b, size_t n,
                                     uint64_t *output, size_t minexactwords) {
  if ((w == 0) || (n == 0)) { // special case
    std::fill(output, output + n + 1, 0);
    return n + 1;
  }

  auto p = full_multiplication(w, b[n - 1]);
  output[n - 1] = p.low;
  output[n] = p.high;
  if (minexactwords <= 1) {
    // check if addition overflows
    if (p.low + w - 1 >= p.low) {
      // we are good at output[n]
      return 1;
    }
  }
  for (size_t i = n - 2; i != SIZE_MAX; i--) {
    p = full_multiplication(w, b[i]);
    output[i] = p.low;
    bool overflow = (output[i + 1] + p.high < output[i + 1]);
    output[i + 1] += p.high;
    for (size_t j = i + 2; overflow; j++) {
      output[j]++;
      overflow = (output[j] == 0);
    }
    if (minexactwords <= n - i) {
      // check if addition overflows
      if (p.low + w - 1 >= p.low) {
        // we are good at output[n], ..., output[i+1], so we have
        // n - (i+1) + 1 = n - i good words
        return n - i;
      }
      if (minexactwords < n - i) {
        // then the only way we could overflow is if the following is true
        if (output[i + 1] != 0xFFFFFFFFFFFFFFFF) {
          // we are good at output[n], ..., output[i+2], so we have
          // n - (i+2) + 1 = n - i - 1 good words

          return n - i - 1;
        }
      }
    }
  }
  return n + 1;
}

// Assembly:
movq %rdx, %r9
testq %rdi, %rdi
setne %al
testq %rdx, %rdx
setne %dl
testb %dl, %al
jne 0x137c
leaq 0x8(,%r9,8), %rax
xorl %edx, %edx
cmpq %rdx, %rax
je 0x13aa
andq $0x0, (%rcx,%rdx)
addq $0x8, %rdx
jmp 0x136c
movq %rdi, %rax
mulq -0x8(%rsi,%r9,8)
movq %rax, -0x8(%rcx,%r9,8)
movq %rdx, (%rcx,%r9,8)
movq %rdi, %r10
negq %r10
cmpq $0x1, %r8
ja 0x13af
cmpq %r10, %rax
ja 0x13af
movabsq $0x1, %r9
jmp 0x1429
incq %r9
jmp 0x1429
pushq %rbp
pushq %rbx
leaq -0x2(%r9), %r11
leaq (%rcx,%r9,8), %rbx
cmpq $-0x1, %r11
je 0x140f
movq %rdi, %rax
mulq (%rsi,%r11,8)
movq %rax, (%rcx,%r11,8)
addq %rdx, 0x8(%rcx,%r11,8)
setb %bpl
movq %rbx, %rdx
testb $0x1, %bpl
je 0x13e9
incq (%rdx)
sete %bpl
addq $0x8, %rdx
jmp 0x13d6
movq %r9, %rdx
subq %r11, %rdx
cmpq %r8, %rdx
jb 0x1406
cmpq %r10, %rax
jbe 0x1414
cmpq %r8, %rdx
jbe 0x1406
cmpq $-0x1, 0x8(%rcx,%r11,8)
jne 0x1421
decq %r11
addq $-0x8, %rbx
jmp 0x13b9
incq %r9
jmp 0x1427
incq %r9
cmpq $-0x1, %r11
cmovneq %rdx, %r9
jmp 0x1427
decq %rdx
movq %rdx, %r9
popq %rbx
popq %rbp
movq %r9, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day07/ex02/./Array.hpp
// Function: Array<int>::operator=(Array<int> const&)
const Array &operator=(const Array &target)
		{
			if (this->array != nullptr)
				delete [] this->array;
			this->array = new T[target.size()];
			this->n = target.size();
			for (unsigned int i = 0; i < target.size(); i++)
				this->array[i] = target.array[i];
			return (*this);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x17c9
callq 0x1100
movl 0x8(%r14), %r15d
leaq (,%r15,4), %rdi
callq 0x1030
movq %rax, (%rbx)
movl %r15d, 0x8(%rbx)
movq (%r14), %rcx
xorl %edx, %edx
cmpq %r15, %rdx
jae 0x17f6
movl (%rcx,%rdx,4), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
jmp 0x17e6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Baobaobear[P]sort/sorttest.cpp
// Function: data_shuffle_shellsort(baobao::TestClass*, unsigned long)
static void data_shuffle_shellsort(sort_element_t arr[], size_t n)
{
    baobao::random_shuffle(arr, arr + n);

    sort_element_t *beg = arr, *end = arr + n;
    size_t incre = 1;
    while (incre < (size_t)(end - beg) / 3)
        incre = incre * 3 + 1; // A003462, Pratt, 1971, Knuth, 1973
    for (; incre >= 10; incre /= 3)
    {
        sort_element_t *bound = beg + incre;
        for (sort_element_t *i = bound; i < end; ++i)
        {
            sort_element_t *p = i;
            sort_element_t val = *i;
            for (; p >= bound && val < *(p - incre); p -= incre)
                *p = *(p - incre);
            *p = val;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
shlq $0x5, %rsi
addq %rdi, %rsi
movq %rdi, (%rsp)
movq %rsi, 0x10(%rsp)
callq 0x40c3
pushq $0x3
popq %rcx
movq %r15, %rax
xorl %edx, %edx
divq %rcx
pushq $0x1
popq %r15
cmpq %rax, %r15
jae 0x36f8
leaq (%r15,%r15,2), %r15
incq %r15
jmp 0x36ea
leaq 0x18(%rsp), %rbp
cmpq $0xa, %r15
jb 0x377a
movq %r15, 0x8(%rsp)
shlq $0x5, %r15
movq (%rsp), %r12
leaq (%r12,%r15), %r13
movq %r15, %r14
negq %r14
movq %r13, %rbx
cmpq 0x10(%rsp), %rbx
jae 0x3768
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x4144
movq %r12, %rbp
leaq (%r15,%rbp), %rdi
cmpq %r13, %rdi
jb 0x3751
movl 0x18(%rsp), %eax
cmpl (%rbp), %eax
jge 0x3751
movq %rbp, %rsi
callq 0x4164
addq %r14, %rbp
jmp 0x3732
leaq 0x18(%rsp), %rbp
movq %rbp, %rsi
callq 0x4164
addq $0x20, %rbx
addq $0x20, %r12
jmp 0x371d
movq 0x8(%rsp), %rax
xorl %edx, %edx
pushq $0x3
popq %rcx
divq %rcx
movq %rax, %r15
jmp 0x36fd
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Baobaobear[P]sort/./sortlib.hpp
// Function: void baobao::internal::q_insert_sort<baobao::internal::indirect_sort_iter_warp<baobao::TestClass*>*, baobao::internal::indirect_sort_comp_warp<baobao::TestClass*, std::less<baobao::TestClass>>>(baobao::internal::indirect_sort_iter_warp<baobao::TestClass*>*, baobao::internal::indirect_sort_iter_warp<baobao::TestClass*>*, baobao::internal::indirect_sort_comp_warp<baobao::TestClass*, std::less<baobao::TestClass>>)
void q_insert_sort(RandomAccessIterator beg, RandomAccessIterator end, Comp compare)
{
    const int incre = 13;
    for (RandomAccessIterator i = beg + incre, j = beg; i < end; ++i, ++j)
    {
        if (compare(*i, *j))
        {
            std::swap(*i, *j);
        }
    }

    for (RandomAccessIterator i = beg + 1; i < end; ++i)
    {
        if (compare(*i, *(i - 1)))
        {
            typename std::iterator_traits<RandomAccessIterator>::value_type val = *i;
            RandomAccessIterator j = i - 1;
            *i = *j;
            for (;j != beg && compare(val, *(j - 1)); --j)
            {
                *j = *(j - 1);
            }
            *j = val;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdi, %r12
leaq 0xd0(%r12), %r13
cmpq %r14, %r13
jae 0x85f2
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x8b7a
testb %al, %al
je 0x85ec
movups (%r13), %xmm0
movaps %xmm0, (%rsp)
movups (%r12), %xmm0
movups %xmm0, (%r13)
movaps (%rsp), %xmm0
movups %xmm0, (%r12)
addq $0x10, %r12
jmp 0x85b1
xorl %ebp, %ebp
movq %r15, %r13
leaq 0x10(%r13), %r12
cmpq %r14, %r12
jae 0x8676
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x8b7a
testb %al, %al
je 0x866d
movq 0x10(%r13), %rax
movq 0x18(%r13), %rcx
movups (%r13), %xmm0
movups %xmm0, (%r12)
movq %rbp, %rdx
testq %rdx, %rdx
je 0x865e
leaq (%r15,%rdx), %rsi
leaq (%r15,%rdx), %rdi
addq $-0x10, %rdi
movq 0x8(%rdi), %r8
movl (%rcx), %r9d
movl (%r8), %r8d
cmpl %r8d, %r9d
jl 0x864e
jg 0x8666
cmpq (%rdi), %rax
jae 0x8663
addq $-0x10, %r13
movups (%rdi), %xmm0
movups %xmm0, (%rsi)
addq $-0x10, %rdx
jmp 0x8627
movq %r15, %rsi
jmp 0x8666
movq %r13, %rsi
movq %rax, (%rsi)
movq %rcx, 0x8(%rsi)
addq $0x10, %rbp
movq %r12, %r13
jmp 0x85f7
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Baobaobear[P]sort/./sorttest.hpp
// Function: bool baobao::check_sorted<__gnu_cxx::__normal_iterator<baobao::TestClass*, std::vector<baobao::TestClass, std::allocator<baobao::TestClass>>>, std::less<baobao::TestClass>>(__gnu_cxx::__normal_iterator<baobao::TestClass*, std::vector<baobao::TestClass, std::allocator<baobao::TestClass>>>, __gnu_cxx::__normal_iterator<baobao::TestClass*, std::vector<baobao::TestClass, std::allocator<baobao::TestClass>>>, std::less<baobao::TestClass>)
bool check_sorted(RandomAccessIterator beg, RandomAccessIterator end, Comp compare)
{
    for (RandomAccessIterator i = beg + 1; i != end; ++i)
        if (compare(*i, *(i - 1)))
            return false;
    return true;
}

// Assembly:
addq $0x20, %rdi
movq %rdi, %rax
cmpq %rsi, %rdi
je 0x3b41
movl (%rax), %ecx
leaq 0x20(%rax), %rdi
cmpl -0x20(%rax), %ecx
jge 0x3b2e
cmpq %rsi, %rax
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/Baobaobear[P]sort/./sorttest.hpp
// Function: bool baobao::check_sorted_stable<__gnu_cxx::__normal_iterator<baobao::TestClass*, std::vector<baobao::TestClass, std::allocator<baobao::TestClass>>>, std::less<baobao::TestClass>>(__gnu_cxx::__normal_iterator<baobao::TestClass*, std::vector<baobao::TestClass, std::allocator<baobao::TestClass>>>, __gnu_cxx::__normal_iterator<baobao::TestClass*, std::vector<baobao::TestClass, std::allocator<baobao::TestClass>>>, std::less<baobao::TestClass>)
bool check_sorted_stable(RandomAccessIterator beg, RandomAccessIterator end, Comp compare)
{
    for (RandomAccessIterator i = beg + 1; i != end; ++i)
    {
        if (compare(*i, *(i - 1)))
            return false;
        if (!compare(*(i - 1), *i))
        {
            if ((*(i - 1)).index > (*i).index)
            {
                return false;
            }
        }
    }
    return true;
}

// Assembly:
addq $0x20, %rdi
cmpq %rsi, %rdi
je 0x3b64
movl -0x20(%rdi), %eax
movl (%rdi), %ecx
cmpl %eax, %ecx
jl 0x3b64
jg 0x3b48
movl -0x1c(%rdi), %eax
cmpl 0x4(%rdi), %eax
jle 0x3b48
cmpq %rsi, %rdi
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Baobaobear[P]sort/./sortlib.hpp
// Function: baobao::util::taus88::init(unsigned int, unsigned int, unsigned int)
void init (uint32_t seed1, uint32_t seed2, uint32_t seed3)
    {
        s[0] = seed1;
        s[1] = seed2;
        s[2] = seed3;
        for (int i = 0; i < init_iter; ++i) (*this)();
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
pushq $0x10
popq %rbp
subl $0x1, %ebp
jb 0x3dd2
movq %rbx, %rdi
callq 0x3dda
jmp 0x3dc3
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Baobaobear[P]sort/./sorttest.hpp
// Function: void baobao::random_shuffle<baobao::TestClass*>(baobao::TestClass*, baobao::TestClass*)
void random_shuffle(RandomAccessIterator beg, RandomAccessIterator end)
{
    typename std::iterator_traits<RandomAccessIterator>::difference_type n;
    n = end - beg;
    while (--n >= 1)
    {
        std::swap(*(beg + n), *(beg + random_int((uint32_t)n)));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %r15
subq %rdi, %r15
sarq $0x5, %r15
addq $-0x20, %rbx
cmpq $0x2, %r15
jl 0x4100
decq %r15
movl %r15d, %edi
callq 0x23c6
movl %eax, %esi
shlq $0x5, %rsi
addq %r14, %rsi
movq %rbx, %rdi
callq 0x4106
jmp 0x40d8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Baobaobear[P]sort/./sorttest.hpp
// Function: baobao::TestClass::operator=(baobao::TestClass const&)
TestClass& operator = (const TestClass& v)
    {
        val = v.val;
        index = v.index;
        for (int i = 0; i < data_len; ++i)
        {
            data[i] = v.data[i];
        }
        return *this;
    }

// Assembly:
movq %rdi, %rax
movl (%rsi), %ecx
movl %ecx, (%rdi)
movl 0x4(%rsi), %ecx
movl %ecx, 0x4(%rdi)
pushq $0x2
popq %rcx
cmpq $0x8, %rcx
je 0x4185
movl (%rsi,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
jmp 0x4174
retq
// File: /workspace/github_cpp_makefile_star2_O2/Baobaobear[P]sort/./sortlib.hpp
// Function: baobao::util::uint32_distributor<baobao::util::taus88>::i8(unsigned int)
uint32_t i8(uint32_t n) {
        ++n;
        if (r8s == 0) {
            r8 = eg(); r8s = 4;
        }
        if ((n & -n) == n) {
            --r8s;
            uint32_t r = r8 & 0xff;
            r8 >>= 8;
            return r & (n - 1);
        }
        uint32_t m = n;
        while (m & (m - 1)) m += m & -m;
        --m;
        for (;;) {
            --r8s;
            uint32_t r = r8 & 0xff;
            r8 >>= 8;
            r &= m;
            if (r < n) return r;
            if (r8s == 0) {
                r8 = eg(); r8s = 4;
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leal 0x1(%r14), %ebp
movl 0x14(%rdi), %edx
testl %edx, %edx
jne 0x4580
movq (%rbx), %rdi
callq 0x3dda
movl %eax, 0x10(%rbx)
pushq $0x4
popq %rdx
testl %r14d, %ebp
je 0x45d4
pushq $0x4
popq %r14
movl %ebp, %eax
leal -0x1(%rax), %ecx
testl %ecx, %eax
je 0x459e
movl %eax, %ecx
negl %ecx
andl %eax, %ecx
addl %eax, %ecx
movl %ecx, %eax
jmp 0x458b
movzbl %cl, %r15d
movl 0x10(%rbx), %eax
decl %edx
movl %edx, 0x14(%rbx)
movl %r15d, %ecx
andl %eax, %ecx
shrl $0x8, %eax
movl %eax, 0x10(%rbx)
cmpl %ebp, %ecx
jb 0x45e9
testl %edx, %edx
jne 0x45a5
movq (%rbx), %rdi
callq 0x3dda
movl %eax, 0x10(%rbx)
movl $0x4, 0x14(%rbx)
movl %r14d, %edx
jmp 0x45a5
decl %edx
movl %edx, 0x14(%rbx)
movl 0x10(%rbx), %eax
andl %eax, %r14d
shrl $0x8, %eax
movl %eax, 0x10(%rbx)
movzbl %r14b, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Baobaobear[P]sort/./sortlib.hpp
// Function: baobao::util::uint32_distributor<baobao::util::taus88>::i16(unsigned int)
uint32_t i16(uint32_t n) {
        ++n;
        if (r16s == 0) {
            r16 = eg(); r16s = 2;
        }
        if ((n & -n) == n) {
            --r16s;
            uint32_t r = r16 & 0xffff;
            r16 >>= 16;
            return r & (n - 1);
        }
        uint32_t m = n;
        while (m & (m - 1)) m += m & -m;
        --m;
        for (;;) {
            --r16s;
            uint32_t r = r16 & 0xffff;
            r16 >>= 16;
            r &= m;
            if (r < n) return r;
            if (r16s == 0) {
                r16 = eg(); r16s = 2;
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leal 0x1(%r14), %ebp
movl 0xc(%rdi), %edx
testl %edx, %edx
jne 0x461c
movq (%rbx), %rdi
callq 0x3dda
movl %eax, 0x8(%rbx)
pushq $0x2
popq %rdx
testl %r14d, %ebp
je 0x4670
pushq $0x2
popq %r14
movl %ebp, %eax
leal -0x1(%rax), %ecx
testl %ecx, %eax
je 0x463a
movl %eax, %ecx
negl %ecx
andl %eax, %ecx
addl %eax, %ecx
movl %ecx, %eax
jmp 0x4627
movzwl %cx, %r15d
movl 0x8(%rbx), %eax
decl %edx
movl %edx, 0xc(%rbx)
movl %r15d, %ecx
andl %eax, %ecx
shrl $0x10, %eax
movl %eax, 0x8(%rbx)
cmpl %ebp, %ecx
jb 0x4685
testl %edx, %edx
jne 0x4641
movq (%rbx), %rdi
callq 0x3dda
movl %eax, 0x8(%rbx)
movl $0x2, 0xc(%rbx)
movl %r14d, %edx
jmp 0x4641
decl %edx
movl %edx, 0xc(%rbx)
movl 0x8(%rbx), %eax
andl %eax, %r14d
shrl $0x10, %eax
movl %eax, 0x8(%rbx)
movzwl %r14w, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Baobaobear[P]sort/./sortlib.hpp
// Function: baobao::util::uint32_distributor<baobao::util::taus88>::i32(unsigned int)
uint32_t i32(uint32_t n) {
        ++n;
        if ((n & -n) == n) {
            uint32_t r = (uint32_t)eg();
            return r & (n - 1);
        }
        uint32_t m = n;
        while (m & (m - 1)) m += m & -m;
        --m;
        for (;;) {
            uint32_t r = (uint32_t)eg();
            r &= m;
            if (r < n) return r;
        }
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leal 0x1(%r14), %ebp
testl %esi, %ebp
je 0x46cc
movl %ebp, %eax
leal -0x1(%rax), %r14d
testl %r14d, %eax
je 0x46bb
movl %eax, %ecx
negl %ecx
andl %eax, %ecx
addl %eax, %ecx
movl %ecx, %eax
jmp 0x46a6
movq (%rbx), %rdi
callq 0x3dda
andl %r14d, %eax
cmpl %ebp, %eax
jae 0x46bb
jmp 0x46d7
movq (%rbx), %rdi
callq 0x3dda
andl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Baobaobear[P]sort/./sortlib.hpp
// Function: void baobao::internal::insert_sort<baobao::internal::indirect_sort_iter_warp<baobao::TestClass*>*, baobao::internal::indirect_sort_comp_warp<baobao::TestClass*, std::less<baobao::TestClass>>>(baobao::internal::indirect_sort_iter_warp<baobao::TestClass*>*, baobao::internal::indirect_sort_iter_warp<baobao::TestClass*>*, baobao::internal::indirect_sort_comp_warp<baobao::TestClass*, std::less<baobao::TestClass>>)
void insert_sort(RandomAccessIterator beg, RandomAccessIterator end, Comp compare)
{
    for (RandomAccessIterator i = beg + 1; i < end; ++i)
    {
        if (compare(*i, *(i - 1)))
        {
            typename std::iterator_traits<RandomAccessIterator>::value_type val = *i;
            RandomAccessIterator j = i - 1;
            *i = *j;
            for (;j != beg && compare(val, *(j - 1)); --j)
            {
                *j = *(j - 1);
            }
            *j = val;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movq %rdi, %r13
leaq 0x10(%r13), %r12
cmpq %r14, %r12
jae 0x8df2
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x8b7a
testb %al, %al
je 0x8de9
movq 0x10(%r13), %rax
movq 0x18(%r13), %rcx
movups (%r13), %xmm0
movups %xmm0, (%r12)
movq %rbp, %rdx
testq %rdx, %rdx
je 0x8dda
leaq (%r15,%rdx), %rsi
leaq (%r15,%rdx), %rdi
addq $-0x10, %rdi
movq 0x8(%rdi), %r8
movl (%rcx), %r9d
movl (%r8), %r8d
cmpl %r8d, %r9d
jl 0x8dca
jg 0x8de2
cmpq (%rdi), %rax
jae 0x8ddf
addq $-0x10, %r13
movups (%rdi), %xmm0
movups %xmm0, (%rsi)
addq $-0x10, %rdx
jmp 0x8da3
movq %r15, %rsi
jmp 0x8de2
movq %r13, %rsi
movq %rax, (%rsi)
movq %rcx, 0x8(%rsi)
addq $0x10, %rbp
movq %r12, %r13
jmp 0x8d73
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Baobaobear[P]sort/./sortlib.hpp
// Function: void baobao::internal::heap_sort_p<baobao::TestClass*, std::less<baobao::TestClass>>(baobao::TestClass*, baobao::TestClass*, std::less<baobao::TestClass>)
void heap_sort_p(RandomAccessIterator beg, RandomAccessIterator end, Comp compare)
{
    if (end - beg > 1)
    {
        for (RandomAccessIterator i = beg + (end - beg) / 2; i >= beg; --i)
            max_heapify_p(beg, i, end - 1, compare);
        for (--end; end > beg; )
        {
            std::swap(*beg, *end--);
            max_heapify_p(beg, beg, end, compare);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
subq %rdi, %r15
sarq $0x5, %r15
cmpq $0x2, %r15
jl 0x58de
movq %rsi, %rbx
movq %rdi, %r14
shlq $0x4, %r15
andq $-0x20, %r15
addq %rdi, %r15
leaq -0x20(%rsi), %r12
cmpq %r14, %r15
jb 0x58b5
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x58ea
addq $-0x20, %r15
jmp 0x589c
addq $-0x40, %rbx
leaq 0x20(%rbx), %rsi
cmpq %r14, %rsi
jbe 0x58de
movq %r14, %rdi
callq 0x4106
movq %r14, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x58ea
addq $-0x20, %rbx
jmp 0x58b9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Baobaobear[P]sort/./sortlib.hpp
// Function: void baobao::internal::max_heapify_p<baobao::TestClass*, std::less<baobao::TestClass>>(baobao::TestClass*, baobao::TestClass*, baobao::TestClass*, std::less<baobao::TestClass>)
void max_heapify_p(RandomAccessIterator first, RandomAccessIterator target, RandomAccessIterator last, Comp compare)
{
    typename std::iterator_traits<RandomAccessIterator>::value_type temp = *target;
    --first;
    RandomAccessIterator son;
    for (; (son = target + (target - first)) <= last; target = son)
    {
        if (son < last && compare(*son, *(son + 1)))
            ++son;
        if (compare(temp, *son))
            *target = *son;
        else
            break;
    }
    *target = temp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
callq 0x4144
addq $-0x20, %r15
movq %r14, %r12
subq %r15, %r12
addq %r14, %r12
cmpq %rbx, %r12
ja 0x594f
jae 0x5935
leaq 0x20(%r12), %rcx
movl (%r12), %edx
movl 0x20(%r12), %eax
cmpl %eax, %edx
cmovgl %edx, %eax
cmovlq %rcx, %r12
jmp 0x5939
movl (%r12), %eax
cmpl %eax, 0x8(%rsp)
jge 0x594f
movq %r14, %rdi
movq %r12, %rsi
callq 0x4164
movq %r12, %r14
jmp 0x590f
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x4164
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Baobaobear[P]sort/./sortlib.hpp
// Function: baobao::internal::indirect_sort_iter_warp<baobao::TestClass*>* baobao::internal::insert_sort_limit<baobao::internal::indirect_sort_iter_warp<baobao::TestClass*>*, baobao::internal::indirect_sort_comp_warp<baobao::TestClass*, std::less<baobao::TestClass>>>(baobao::internal::indirect_sort_iter_warp<baobao::TestClass*>*, baobao::internal::indirect_sort_iter_warp<baobao::TestClass*>*, baobao::internal::indirect_sort_comp_warp<baobao::TestClass*, std::less<baobao::TestClass>>, int)
RandomAccessIterator insert_sort_limit(RandomAccessIterator beg, RandomAccessIterator end, Comp compare, int limit)
{
    for (RandomAccessIterator i = beg + 1; i < end; ++i)
    {
        if (!compare(*i, *(i - 1)))
        {
            ++limit;
            continue;
        }
        typename std::iterator_traits<RandomAccessIterator>::value_type val = *i;
        RandomAccessIterator j = i - 1;
        *i = *j;
        for (;j != beg && compare(val, *(j - 1)); --j)
        {
            if (--limit <= 0)
            {
                *j = val;
                return i;
            }
            *j = *(j - 1);
        }
        *j = val;
    }
    return end;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r12d
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r14d, %r14d
movq %rdi, %rbp
leaq 0x10(%rbp), %r13
cmpq 0x8(%rsp), %r13
jae 0x8c7f
movq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x8b7a
testb %al, %al
je 0x8c3e
movq 0x10(%rbp), %rcx
movq 0x18(%rbp), %rax
movups (%rbp), %xmm0
movups %xmm0, (%r13)
leal (%r12,%r14), %edx
movq %r15, %rsi
testq %rsi, %rsi
je 0x8c43
leaq (%rbx,%rsi), %rdi
leaq (%rbx,%rsi), %r8
addq $-0x10, %r8
movq 0x8(%r8), %r9
movl (%rax), %r10d
movl (%r9), %r9d
cmpl %r9d, %r10d
jl 0x8c24
jg 0x8c4b
cmpq (%r8), %rcx
jae 0x8c4e
cmpl $0x2, %r12d
jl 0x8c64
addq $-0x10, %rbp
decl %r12d
movups (%r8), %xmm0
movups %xmm0, (%rdi)
addq $-0x10, %rsi
jmp 0x8bfd
incl %r12d
jmp 0x8c55
movl %edx, %r12d
movq %rbx, %rdi
jmp 0x8c4e
movq %rbp, %rdi
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
decl %r14d
addq $0x10, %r15
movq %r13, %rbp
jmp 0x8bc2
movq %rcx, (%rbx,%rsi)
movq %rax, 0x8(%rbx,%rsi)
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %r13
jmp 0x8c6d