LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/src/process.cc
// Function: process::DataMsgFromBuf(char*, unsigned long)
std::experimental::optional<msg::DataMessage> DataMsgFromBuf(char* buf,
                                                             size_t n) {
  // Check to make sure the size of the buffer is correct.
  if (n != sizeof(msg::DataMessage)) {
    return {};
  }

  msg::DataMessage* buf_msg = reinterpret_cast<msg::DataMessage*>(buf);
  msg::DataMessage msg;
  msg.type = ntohl(buf_msg->type);
  msg.sender = ntohl(buf_msg->sender);
  msg.msg_id = ntohl(buf_msg->msg_id);
  msg.data = ntohl(buf_msg->data);
  return msg;
}

// Assembly:
movq %rdi, %rax
cmpq $0x10, %rdx
jne 0x60d7
movl (%rsi), %ecx
movl 0x4(%rsi), %edx
bswapl %ecx
bswapl %edx
movl 0x8(%rsi), %edi
bswapl %edi
movl 0xc(%rsi), %esi
bswapl %esi
movl %ecx, (%rax)
movl %edx, 0x4(%rax)
movl %edi, 0x8(%rax)
movl %esi, 0xc(%rax)
movb $0x1, 0x10(%rax)
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/src/process.cc
// Function: process::AckMsgFromBuf(char*, unsigned long)
std::experimental::optional<msg::AckMessage> AckMsgFromBuf(char* buf,
                                                           size_t n) {
  // Check to make sure the size of the buffer is correct.
  if (n != sizeof(msg::AckMessage)) {
    return {};
  }

  msg::AckMessage* buf_msg = reinterpret_cast<msg::AckMessage*>(buf);
  msg::AckMessage msg;
  msg.type = ntohl(buf_msg->type);
  msg.sender = ntohl(buf_msg->sender);
  msg.msg_id = ntohl(buf_msg->msg_id);
  msg.proposed_seq = ntohl(buf_msg->proposed_seq);
  msg.proposer = ntohl(buf_msg->proposer);
  return msg;
}

// Assembly:
movq %rdi, %rax
cmpq $0x14, %rdx
jne 0x611c
movl (%rsi), %ecx
movl 0x4(%rsi), %edx
bswapl %ecx
bswapl %edx
movl 0x8(%rsi), %edi
bswapl %edi
movl 0xc(%rsi), %r8d
bswapl %r8d
movl 0x10(%rsi), %esi
bswapl %esi
movl %ecx, (%rax)
movl %edx, 0x4(%rax)
movl %edi, 0x8(%rax)
movl %r8d, 0xc(%rax)
movl %esi, 0x10(%rax)
movb $0x1, 0x14(%rax)
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/src/process.cc
// Function: process::SeqAckMsgFromBuf(char*, unsigned long)
std::experimental::optional<msg::SeqAckMessage> SeqAckMsgFromBuf(char* buf,
                                                                 size_t n) {
  // Check to make sure the size of the buffer is correct.
  if (n != sizeof(msg::SeqAckMessage)) {
    return {};
  }

  msg::SeqAckMessage* buf_msg = reinterpret_cast<msg::SeqAckMessage*>(buf);
  msg::SeqAckMessage msg;
  msg.type = ntohl(buf_msg->type);
  msg.sender = ntohl(buf_msg->sender);
  msg.msg_id = ntohl(buf_msg->msg_id);
  return msg;
}

// Assembly:
movq %rdi, %rax
cmpq $0xc, %rdx
jne 0x6195
movl (%rsi), %ecx
movl 0x4(%rsi), %edx
bswapl %ecx
bswapl %edx
movl 0x8(%rsi), %esi
bswapl %esi
movl %ecx, (%rax)
movl %edx, 0x4(%rax)
movl %esi, 0x8(%rax)
movb $0x1, 0xc(%rax)
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/src/process.cc
// Function: process::SendDataMsg(std::shared_ptr<udp::Client>, std::function<udp::ServerAction (std::shared_ptr<udp::Client>, char*, unsigned long)>, msg::DataMessage)
void SendDataMsg(const udp::ClientPtr client, const udp::OnReceiveFn handle_ack,
                 msg::DataMessage data_msg) {
  data_msg.type = htonl(msg::kDataMessageType);
  data_msg.sender = htonl(data_msg.sender);
  data_msg.msg_id = htonl(data_msg.msg_id);
  data_msg.data = htonl(data_msg.data);

  char* buf = reinterpret_cast<char*>(&data_msg);
  client->SendWithAck(buf, sizeof(data_msg), udp::kUnlimitedAttempts,
                      handle_ack);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x20(%rsp), %rbx
movq %rdx, (%rbx)
movq %rcx, 0x8(%rbx)
movl $0x1000000, (%rbx)      # imm = 0x1000000
movl 0x4(%rbx), %eax
bswapl %eax
movl %eax, 0x4(%rbx)
bswapl %ecx
movl %ecx, 0x8(%rbx)
movl 0xc(%rbx), %eax
bswapl %eax
movl %eax, 0xc(%rbx)
movq (%rdi), %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x7720
movl $0x10, %edx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
movq %r15, %r8
callq 0x126dc
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x6206
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x6234
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x622c
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x5650
movq %rax, %rdi
callq 0x792b
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/src/process.cc
// Function: process::SendAckMsg(std::shared_ptr<udp::Client>, msg::AckMessage)
void SendAckMsg(const udp::ClientPtr client, msg::AckMessage ack_msg) {
  ack_msg.type = htonl(msg::kAckMessageType);
  ack_msg.sender = htonl(ack_msg.sender);
  ack_msg.msg_id = htonl(ack_msg.msg_id);
  ack_msg.proposed_seq = htonl(ack_msg.proposed_seq);
  ack_msg.proposer = htonl(ack_msg.proposer);

  char* buf = reinterpret_cast<char*>(&ack_msg);
  client->Send(buf, sizeof(ack_msg));
}

// Assembly:
pushq %rax
leaq 0x10(%rsp), %rsi
movl $0x2000000, (%rsi)      # imm = 0x2000000
movl 0x4(%rsi), %eax
movl 0x8(%rsi), %ecx
bswapl %eax
movl %eax, 0x4(%rsi)
bswapl %ecx
movl %ecx, 0x8(%rsi)
movl 0xc(%rsi), %eax
bswapl %eax
movl %eax, 0xc(%rsi)
movl 0x10(%rsi), %eax
bswapl %eax
movl %eax, 0x10(%rsi)
movq (%rdi), %rdi
movl $0x14, %edx
callq 0x12632
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/src/process.cc
// Function: process::SendSeqMsg(std::shared_ptr<udp::Client>, msg::SeqMessage)
void SendSeqMsg(const udp::ClientPtr client, msg::SeqMessage seq_msg) {
  msg::SeqMessage orig_seq_msg = seq_msg;

  seq_msg.type = htonl(msg::kSeqMessageType);
  seq_msg.sender = htonl(seq_msg.sender);
  seq_msg.msg_id = htonl(seq_msg.msg_id);
  seq_msg.final_seq = htonl(seq_msg.final_seq);
  seq_msg.final_seq_proposer = htonl(seq_msg.final_seq_proposer);

  // Passed to SendWithAck to verify that any acknowledgement we hear is valid.
  auto isValidAck = [&orig_seq_msg](udp::ClientPtr _, char* buf, size_t n) {
    auto seqack_msg = SeqAckMsgFromBuf(buf, n);
    bool valid = seqack_msg && ValidSeqAckMsg(*seqack_msg, orig_seq_msg);
    if (!valid) return udp::ServerAction::Continue;
    return udp::ServerAction::Stop;
  };

  char* buf = reinterpret_cast<char*>(&seq_msg);
  client->SendWithAck(buf, sizeof(seq_msg), udp::kUnlimitedAttempts,
                      isValidAck);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
leaq 0x50(%rsp), %rsi
movl 0x10(%rsi), %eax
leaq 0x20(%rsp), %rcx
movl %eax, 0x10(%rcx)
movaps (%rsi), %xmm0
movaps %xmm0, (%rcx)
movl $0x3000000, (%rsi)      # imm = 0x3000000
movl 0x4(%rsi), %edx
bswapl %edx
movl %edx, 0x4(%rsi)
movl 0x8(%rsi), %edx
bswapl %edx
movl %edx, 0x8(%rsi)
movl 0xc(%rsi), %edx
bswapl %edx
movl %edx, 0xc(%rsi)
bswapl %eax
movl %eax, 0x10(%rsi)
movq (%rdi), %rdi
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
movaps %xmm0, 0x10(%r8)
movq %rcx, (%r8)
leaq 0xa95(%rip), %rax       # 0x6d66
movq %rax, 0x18(%r8)
leaq 0xaf8(%rip), %rax       # 0x6dd4
movq %rax, 0x10(%r8)
movl $0x14, %edx
xorl %ecx, %ecx
callq 0x126dc
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x6303
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x40, %rsp
popq %rbx
retq
jmp 0x632d
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x6325
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x5650
movq %rax, %rdi
callq 0x792b
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/src/process.cc
// Function: process::SendSeqAckMsg(std::shared_ptr<udp::Client>, msg::SeqAckMessage)
void SendSeqAckMsg(const udp::ClientPtr client, msg::SeqAckMessage seqack_msg) {
  seqack_msg.type = htonl(msg::kSeqAckMessageType);
  seqack_msg.sender = htonl(seqack_msg.sender);
  seqack_msg.msg_id = htonl(seqack_msg.msg_id);

  char* buf = reinterpret_cast<char*>(&seqack_msg);
  client->Send(buf, sizeof(seqack_msg));
}

// Assembly:
subq $0x18, %rsp
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movl $0x4000000, (%rax)      # imm = 0x4000000
movl 0x4(%rax), %ecx
bswapl %ecx
movl %ecx, 0x4(%rax)
bswapl %edx
movl %edx, 0x8(%rax)
movq (%rdi), %rdi
movl $0xc, %edx
movq %rax, %rsi
callq 0x12632
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/src/process.cc
// Function: process::HoldBackQueue::Lookup(msg::DataMessage const&)
std::experimental::optional<msg::AckMessage> HoldBackQueue::Lookup(
    const msg::DataMessage& data_msg) {
  PendingMessageKey pmk;
  pmk.sender = data_msg.sender;
  pmk.msg_id = data_msg.msg_id;

  auto old_pms_it = pending_seqs_.find(pmk);
  if (old_pms_it == pending_seqs_.end()) {
    // The message is not already in the queue.
    return {};
  }

  // Create the msg::AckMessage
  msg::AckMessage old_ack_msg;
  old_ack_msg.sender = data_msg.sender;
  old_ack_msg.msg_id = data_msg.msg_id;
  old_ack_msg.proposed_seq = old_pms_it->second.seq;
  old_ack_msg.proposer = old_pms_it->second.seq_proposer;
  return old_ack_msg;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
movl 0x4(%rdx), %ecx
movq %rsp, %rsi
movl %ecx, (%rsi)
movl 0x8(%rdx), %ecx
movl %ecx, 0x4(%rsi)
movq %rax, %rdi
callq 0x895e
testq %rax, %rax
je 0x6428
movq 0x4(%r14), %rcx
movq 0x10(%rax), %rax
movq %rcx, 0x4(%rbx)
movq %rax, 0xc(%rbx)
movb $0x1, 0x14(%rbx)
jmp 0x6436
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/src/process.cc
// Function: process::HoldBackQueue::InsertUndeliverable(msg::AckMessage const&, unsigned int)
void HoldBackQueue::InsertUndeliverable(const msg::AckMessage& ack_msg,
                                        uint32_t data) {
  // Insert into the sequence map so that we can index into this later in
  // constant time, allowing us to find the entry in the ordered set in log time
  // instead of linear time.
  PendingMessageKey pmk;
  pmk.sender = ack_msg.sender;
  pmk.msg_id = ack_msg.msg_id;
  if (pending_seqs_.count(pmk)) {
    throw std::invalid_argument("existing pending message in HoldBackQueue");
  }

  PendingMessageSeq pms;
  pms.seq = ack_msg.proposed_seq;
  pms.seq_proposer = ack_msg.proposer;
  pending_seqs_[pmk] = pms;

  // Insert into the ordered set, initially with the "deliverable" flag set to
  // false. All messages that sort after this message will have to wait to be
  // delivered, even if they themselves are "deliverable".
  PendingMessage pm;
  pm.pmk = pmk;
  pm.pms = pms;
  pm.data = data;
  pm.deliverable = false;
  if (ordering_.count(pm)) {
    throw std::invalid_argument("existing pending message in HoldBackQueue");
  }
  ordering_.insert(pm);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rsi), %eax
movq %rsp, %rsi
movl %eax, (%rsi)
movl 0x8(%r14), %eax
movl %eax, 0x4(%rsi)
callq 0x89e8
testq %rax, %rax
jne 0x64d5
movl 0xc(%r14), %r15d
movl 0x10(%r14), %r12d
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a1a
movl %r15d, (%rax)
movl %r12d, 0x4(%rax)
movq (%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl %r15d, 0x8(%rsi)
movl %r12d, 0xc(%rsi)
movl %ebp, 0x10(%rsi)
movb $0x0, 0x14(%rsi)
leaq 0x38(%rbx), %r14
movq %r14, %rdi
callq 0x8c9e
addq $0x40, %rbx
cmpq %rbx, %rax
jne 0x64f3
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x8d06
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0xdd97(%rip), %rsi      # 0x14280
movq %rax, %rdi
callq 0x56a0
jmp 0x650f
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0xdd79(%rip), %rsi      # 0x14280
movq %rax, %rdi
callq 0x56a0
movq 0x15ab2(%rip), %rsi     # 0x1bfc8
movq 0x15a93(%rip), %rdx     # 0x1bfb0
movq %rbx, %rdi
callq 0x5610
jmp 0x6527
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/src/process.cc
// Function: process::Process::MaybeDelaySend()
void Process::MaybeDelaySend() {
  if (!delays_) {
    return;
  }

  // Static thread local to avoid expensive initialization cost on every call,
  // while maintaining thread safety.
  static thread_local std::default_random_engine random_engine(
      std::chrono::system_clock::now().time_since_epoch().count());

  // Only delay about half of the messages.
  std::uniform_real_distribution<double> distribution(0.0, 1.0);
  if (distribution(random_engine) < 0.50) {
    return;
  }

  // Delay for a random duration based on a selection from a poisson
  // distribution centered at half the round timeout, at intervals of 1/10th a
  // second.
  typedef std::chrono::duration<int, std::deci> deciseconds;
  std::poisson_distribution<int> poisson(deciseconds{5}.count());
  int delay = poisson(random_engine);
  if (delay <= 0) {
    return;
  }
  std::this_thread::sleep_for(deciseconds{delay});
  return;
}

// Assembly:
cmpb $0x1, 0x58(%rdi)
jne 0x6d4e
pushq %r14
pushq %rbx
subq $0x78, %rsp
cmpb $0x0, %fs:-0x18
je 0x6d4f
movq %fs:0x0, %rax
leaq -0x20(%rax), %rbx
movq %rbx, %rdi
callq 0x917e
movsd 0xd3b0(%rip), %xmm1     # 0x14060
ucomisd %xmm0, %xmm1
ja 0x6d47
movabsq $0x4014000000000000, %rax # imm = 0x4014000000000000
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
movq %r14, %rdi
callq 0x92c8
xorl %eax, %eax
movq %rax, 0x48(%r14)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x50(%r14)
movq %rax, 0x58(%r14)
movb $0x0, 0x60(%r14)
movq %r14, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x9492
testl %eax, %eax
jle 0x6d47
movl %eax, %eax
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
imulq %rax, %rcx
shrq $0x23, %rcx
leal (%rcx,%rcx), %edx
leaq (%rdx,%rdx,4), %rdx
subq %rdx, %rax
imulq $0x5f5e100, %rax, %rax  # imm = 0x5F5E100
movq %rsp, %rbx
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x5100
cmpl $-0x1, %eax
jne 0x6d47
callq 0x5040
cmpl $0x4, (%rax)
je 0x6d2d
addq $0x78, %rsp
popq %rbx
popq %r14
retq
callq 0x5812
jmp 0x6c90
nop
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/src/main.cc
// Function: CheckProcessId(std::vector<net::Address, std::allocator<net::Address>> const&, int)
void CheckProcessId(const process::ProcessList& processes, int my_id) {
  // Check if the id is within bounds.
  if (my_id < 0 || (uint)my_id >= processes.size()) {
    throw args::ValidationError("--id value not found in hostfile");
  }

  // Check if the process is on this host.
  if (processes.at(my_id).hostname() != net::GetHostname()) {
    throw args::ValidationError("--id value is not the hostname of this host");
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
testl %esi, %esi
js 0xa3e1
movl %esi, %eax
movq (%rdi), %r14
movq 0x8(%rdi), %rcx
subq %r14, %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cmpq %rax, %rdx
jbe 0xa3e1
leaq (%rax,%rax,4), %r15
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x13420
movq 0x8(%r14,%r15,8), %rdx
movb $0x1, %bpl
cmpq 0x8(%rbx), %rdx
jne 0xa3b6
testq %rdx, %rdx
je 0xa3b4
leaq (%r14,%r15,8), %rax
movq 0x8(%rsp), %rsi
movq (%rax), %rdi
callq 0x5390
testl %eax, %eax
setne %bpl
jmp 0xa3b6
xorl %ebp, %ebp
leaq 0x18(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0xa3d1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
testb %bpl, %bpl
jne 0xa443
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa740(%rip), %rsi      # 0x14b3e
leaq 0xa759(%rip), %rdx      # 0x14b5e
leaq 0x8(%rsp), %rdi
callq 0x7a00
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5440
leaq 0x1138a(%rip), %rax     # 0x1b7b0
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x112a6(%rip), %rsi     # 0x1b6d8
movq 0x11b57(%rip), %rdx     # 0x1bf90
movq %rbx, %rdi
callq 0x5610
jmp 0xa49d
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0xa700(%rip), %rsi      # 0x14b5f
leaq 0xa724(%rip), %rdx      # 0x14b8a
callq 0x7a00
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5440
leaq 0x1132e(%rip), %rax     # 0x1b7b0
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1124a(%rip), %rsi     # 0x1b6d8
movq 0x11afb(%rip), %rdx     # 0x1bf90
movq %rbx, %rdi
callq 0x5610
jmp 0xa4a1
jmp 0xa4bd
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xa4c3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
jmp 0xa4c3
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xa4d0
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/src/main.cc
// Function: GetProcessId(std::vector<net::Address, std::allocator<net::Address>> const&)
int GetProcessId(const process::ProcessList& processes) {
  int found = -1;
  auto hostname = net::GetHostname();
  for (std::size_t i = 0; i < processes.size(); ++i) {
    if (processes.at(i).hostname() == hostname) {
      if (found >= 0) {
        // Multiple processes are set to use our host.
        throw args::UsageError(
            "when running multiple processes on the same host, use the --id "
            "flag");
      }
      found = i;
    }
  }
  if (found == -1) {
    // Our process is not in the file, throw an error
    throw args::ValidationError("current hostname not found in hostfile");
  }
  return found;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x13420
movq (%rbx), %r15
movq 0x8(%rbx), %rax
subq %r15, %rax
je 0xa55f
sarq $0x3, %rax
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %r12
movq 0x28(%rsp), %r14
cmpq $0x1, %r12
adcq $0x0, %r12
movq 0x30(%rsp), %r13
addq $0x8, %r15
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
xorl %ebp, %ebp
movq (%r15), %rdx
cmpq %r13, %rdx
jne 0xa551
testq %rdx, %rdx
je 0xa54b
movq -0x8(%r15), %rdi
movq %r14, %rsi
callq 0x5390
testl %eax, %eax
jne 0xa551
testl %ebx, %ebx
jns 0xa599
movl %ebp, %ebx
incq %rbp
addq $0x28, %r15
cmpq %rbp, %r12
jne 0xa52e
jmp 0xa564
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $-0x1, %ebx
je 0xa5fb
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa588
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5370
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa5d5(%rip), %rsi      # 0x14b8b
leaq 0xa611(%rip), %rdx      # 0x14bce
leaq 0x8(%rsp), %rdi
callq 0x7a00
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5440
leaq 0x111aa(%rip), %rax     # 0x1b788
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x110d6(%rip), %rsi     # 0x1b6c0
movq 0x1199f(%rip), %rdx     # 0x1bf90
movq %rbx, %rdi
callq 0x5610
jmp 0xa65b
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa5b7(%rip), %rsi      # 0x14bcf
leaq 0xa5d6(%rip), %rdx      # 0x14bf5
leaq 0x8(%rsp), %rdi
callq 0x7a00
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5440
leaq 0x11170(%rip), %rax     # 0x1b7b0
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1108c(%rip), %rsi     # 0x1b6d8
movq 0x1193d(%rip), %rdx     # 0x1bf90
movq %rbx, %rdi
callq 0x5610
jmp 0xa65f
jmp 0xa67b
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xa681
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
jmp 0xa681
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xa68e
movq %rbx, %rdi
callq 0x5280
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa6a9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5370
movq %r14, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/include/args.h
// Function: args::ArgumentParser::ParseCLI(int, char const* const*)
bool ParseCLI(const int argc, const char *const *argv) {
    if (prog.empty()) {
      prog.assign(argv[0]);
    }
    const std::vector<std::string> args(argv + 1, argv + argc);
    return ParseArgs(args) == std::end(args);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq 0x70(%rdi), %r15
testq %r15, %r15
jne 0xcd93
leaq 0x68(%rbx), %r12
movq (%r14), %r13
movq %r13, %rdi
callq 0x5180
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r13, %rcx
movq %rax, %r8
callq 0x5570
movslq %ebp, %rax
leaq (%r14,%rax,8), %rdx
addq $0x8, %r14
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0xfd4a
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0xfec2
leaq 0x10(%rsp), %rdi
cmpq 0x8(%rdi), %rax
sete %bl
callq 0xba98
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xba98
movq %rbx, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/include/args.h
// Function: args::Group::GetPosNames[abi:cxx11]() const
std::vector<std::string> GetPosNames() const {
    std::vector<std::string> names;
    for (const auto &child : children) {
      if (const Group *group = dynamic_cast<Group *>(child)) {
        auto groupNames = group->GetPosNames();
        names.insert(std::end(names),
                     std::make_move_iterator(std::begin(groupNames)),
                     std::make_move_iterator(std::end(groupNames)));
      } else if (const PositionalBase *pos =
                     dynamic_cast<PositionalBase *>(child)) {
        names.emplace_back(pos->Name());
      }
    }
    return names;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x30(%rsi), %r12
movq 0x38(%rsi), %r13
cmpq %r13, %r12
je 0xd21d
leaq 0x8(%rsp), %r14
leaq 0xe59c(%rip), %r15      # 0x1b708
movq (%r12), %rbp
testq %rbp, %rbp
je 0xd18b
movq %rbp, %rdi
movq %r15, %rsi
leaq 0xe5c6(%rip), %rdx      # 0x1b748
xorl %ecx, %ecx
callq 0x53d0
jmp 0xd18d
xorl %eax, %eax
testq %rax, %rax
je 0xd1c6
movq %r14, %rdi
movq %rax, %rsi
callq 0xd130
movq 0x8(%rbx), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rbx, %rdi
callq 0x11250
movq %r14, %rdi
callq 0xba98
addq $0x8, %r12
cmpq %r13, %r12
jne 0xd16c
jmp 0xd21d
testq %rbp, %rbp
je 0xd1e1
movq %rbp, %rdi
movq %r15, %rsi
leaq 0xe588(%rip), %rdx      # 0x1b760
xorl %ecx, %ecx
callq 0x53d0
jmp 0xd1e3
xorl %eax, %eax
testq %rax, %rax
je 0xd1bb
movq (%rax), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq *0x28(%rcx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd484
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xd1bb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
jmp 0xd1bb
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xd264
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
jmp 0xd264
jmp 0xd252
movq %rax, %r14
jmp 0xd264
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xba98
movq %rbx, %rdi
callq 0xba98
movq %r14, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/include/args.h
// Function: args::Group::Validators::AllChildGroups(args::Group const&)
static bool AllChildGroups(const Group &group) {
      return std::find_if(std::begin(group.Children()),
                          std::end(group.Children()),
                          [](const Base *child) -> bool {
                            return dynamic_cast<const Group *>(child) &&
                                   !child->Matched();
                          }) == std::end(group.Children());
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
movq 0x38(%rbx), %rsi
callq 0xe1fa
cmpq 0x38(%rbx), %rax
sete %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/include/args.h
// Function: args::EitherFlag::GetShort(std::initializer_list<args::EitherFlag>)
static std::unordered_set<char> GetShort(
      std::initializer_list<EitherFlag> flags) {
    std::unordered_set<char> shortFlags;
    for (const EitherFlag &flag : flags) {
      if (flag.isShort) {
        shortFlags.insert(flag.shortFlag);
      }
    }
    return shortFlags;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movups %xmm0, 0x28(%rdi)
testq %rdx, %rdx
je 0xe519
movq %rsi, %r14
incq %r14
shlq $0x3, %rdx
leaq (%rdx,%rdx,4), %r12
movq %rsp, %r15
cmpb $0x1, -0x1(%r14)
jne 0xe50f
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe5c4
addq $0x28, %r14
addq $-0x28, %r12
jne 0xe4f6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xed12
movq %r14, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/include/args.h
// Function: args::EitherFlag::GetLong[abi:cxx11](std::initializer_list<args::EitherFlag>)
static std::unordered_set<std::string> GetLong(
      std::initializer_list<EitherFlag> flags) {
    std::unordered_set<std::string> longFlags;
    for (const EitherFlag &flag : flags) {
      if (!flag.isShort) {
        longFlags.insert(flag.longFlag);
      }
    }
    return longFlags;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movups %xmm0, 0x28(%rdi)
testq %rdx, %rdx
je 0xe5a2
movq %rsi, %r14
addq $0x8, %r14
shlq $0x3, %rdx
leaq (%rdx,%rdx,4), %r12
movq %rsp, %r15
cmpb $0x0, -0x8(%r14)
jne 0xe598
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe88c
addq $0x28, %r14
addq $-0x28, %r12
jne 0xe57f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xec9e
movq %r14, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/include/args.h
// Function: args::FlagBase::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);
    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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rsi
movq %rsi, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x58(%r14), %rsi
movq %rsp, %rdi
callq 0xfa00
leaq 0x38(%rsp), %rdi
callq 0x5490
movq (%rsp), %r13
cmpq 0x8(%rsp), %r13
je 0xee2d
leaq 0x38(%rsp), %r15
leaq 0x5f46(%rip), %r12      # 0x14d42
cmpq (%rsp), %r13
je 0xee12
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x53f0
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r15, %rdi
callq 0x53f0
addq $0x20, %r13
cmpq 0x8(%rsp), %r13
jne 0xedfc
leaq 0x40(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x5580
leaq 0x20(%rbx), %rdi
leaq 0x18(%rsp), %r15
movq %r15, %rsi
callq 0x5420
movq (%r15), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0xee67
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x5370
addq $0x10, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51e0
movq 0xd10b(%rip), %rsi      # 0x1bf88
leaq 0x38(%rsp), %rdi
callq 0x51d0
leaq 0xa8(%rsp), %rdi
callq 0x5120
movq %rsp, %rdi
callq 0xba98
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xeebe
jmp 0xeebe
movq %rax, %r14
jmp 0xeedf
movq %rax, %r14
jmp 0xeee7
movq %rax, %r14
movq 0xd0c0(%rip), %rsi      # 0x1bf88
leaq 0x38(%rsp), %rdi
callq 0x51d0
leaq 0xa8(%rsp), %rdi
callq 0x5120
movq %rsp, %rdi
callq 0xba98
movq %rbx, %rdi
callq 0xd770
movq %r14, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/include/args.h
// Function: args::HelpFlag::Match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
virtual FlagBase *Match(const std::string &arg) override {
    if (FlagBase::Match(arg)) {
#ifdef ARGS_NOEXCEPT
      error = Error::Help;
#else
      throw Help(arg);
#endif
      return this;
    }
    return nullptr;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0xf08a
testq %rax, %rax
jne 0xef37
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51a0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xfd1c
leaq 0xc79a(%rip), %rsi      # 0x1b6f0
movq 0xd033(%rip), %rdx      # 0x1bf90
movq %r14, %rdi
callq 0x5610
movq %rax, %rbx
movq %r14, %rdi
callq 0x5280
movq %rbx, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/include/args.h
// Function: args::HelpFlag::Match(char)
virtual FlagBase *Match(const char arg) override {
    if (FlagBase::Match(arg)) {
#ifdef ARGS_NOEXCEPT
      error = Error::Help;
#else
      throw Help(std::string(1, arg));
#endif
      return this;
    }
    return nullptr;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
callq 0xf1c6
testq %rax, %rax
jne 0xef9b
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movsbl %bpl, %edx
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x5410
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5440
leaq 0xcacd(%rip), %rax      # 0x1baa8
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xc709(%rip), %rsi      # 0x1b6f0
movq 0xcfa2(%rip), %rdx      # 0x1bf90
movq %rbx, %rdi
callq 0x5610
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xf018
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
jmp 0xf018
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xf025
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/include/args.h
// Function: args::FlagBase::Match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
virtual FlagBase *Match(const std::string &flag) {
    if (matcher.Match(flag)) {
      if (extraError && matched) {
#ifdef ARGS_NOEXCEPT
        error = Error::Extra;
#else
        std::ostringstream problem;
        problem << "Flag '" << flag << "' was passed multiple times, but is "
                                       "only allowed to be passed once";
        throw ExtraError(problem.str());
#endif
      }
      matched = true;
      return this;
    }
    return nullptr;
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %rbx
movq %rdi, %r14
addq $0x90, %rdi
callq 0xf92c
testq %rax, %rax
je 0xf0c1
cmpb $0x1, 0x51(%r14)
jne 0xf0ba
cmpb $0x1, 0x8(%r14)
je 0xf0d3
movb $0x1, 0x8(%r14)
jmp 0xf0c4
xorl %r14d, %r14d
movq %r14, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x5490
leaq 0x5c11(%rip), %rsi      # 0x14cf8
movl $0x6, %edx
movq %r14, %rdi
callq 0x53f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq 0x28(%rsp), %rdi
callq 0x53f0
leaq 0x5bf3(%rip), %rsi      # 0x14cff
movl $0x42, %edx
movq %rax, %rdi
callq 0x53f0
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x5580
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5440
leaq 0xc90c(%rip), %rax      # 0x1ba58
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xc8d8(%rip), %rsi      # 0x1ba30
movq 0xce31(%rip), %rdx      # 0x1bf90
movq %rbx, %rdi
callq 0x5610
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf18d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
jmp 0xf18d
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xf19f
movq %rbx, %rdi
callq 0x5280
jmp 0xf19f
movq %rax, %r14
movq 0xcde2(%rip), %rsi      # 0x1bf88
leaq 0x28(%rsp), %rdi
callq 0x51d0
leaq 0x98(%rsp), %rdi
callq 0x5120
movq %r14, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/include/args.h
// Function: args::NamedBase::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 &longPrefi,
      const std::string &shortSeparator,
      const std::string &longSeparator) const override {
    std::tuple<std::string, std::string> description;
    std::get<0>(description) = Name();
    std::get<1>(description) = help;
    return description;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x28(%rax)
leaq 0x20(%rbx), %rdi
movq %rsp, %r15
movq %r15, %rsi
callq 0x5420
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xf506
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5370
addq $0x10, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51e0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xf524
movq %rax, %r14
movq %rbx, %rdi
callq 0xd770
movq %r14, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O1/nvanbenschoten[P]total-order-multicast/include/args.h
// Function: args::Matcher::GetFlagStrings(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
std::vector<std::string> GetFlagStrings(const std::string &shortPrefix,
                                          const std::string &longPrefix) const {
    std::vector<std::string> flagStrings;
    flagStrings.reserve(shortFlags.size() + longFlags.size());
    for (const char flag : shortFlags) {
      flagStrings.emplace_back(shortPrefix + std::string(1, flag));
    }
    for (const std::string &flag : longFlags) {
      flagStrings.emplace_back(longPrefix + flag);
    }
    return flagStrings;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, 0x30(%rsp)
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x50(%rsi), %rsi
addq 0x18(%r14), %rsi
callq 0xfbda
movq %r14, 0x28(%rsp)
movq 0x10(%r14), %rbp
testq %rbp, %rbp
je 0xfb0d
leaq 0x48(%rsp), %r15
leaq 0x18(%rsp), %r14
leaq 0x38(%rsp), %r13
movsbl 0x8(%rbp), %edx
movq %r15, 0x38(%rsp)
movl $0x1, %esi
movq %r13, %rdi
callq 0x5410
movq (%r12), %rcx
movq 0x8(%r12), %r8
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x53c0
movq %r14, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xfaa6
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0xfaad
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0xd484
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xfae9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0xfb00
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x5370
movq (%rbp), %rbp
testq %rbp, %rbp
jne 0xfa58
movq 0x28(%rsp), %rax
movq 0x48(%rax), %r12
testq %r12, %r12
movq 0x30(%rsp), %r13
je 0xfb65
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x8(%r12), %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0xfcc1
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd484
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xfb5c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
movq (%r12), %r12
testq %r12, %r12
jne 0xfb2a
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xfb8f
jmp 0xfb8f
movq %rax, %r12
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xfbca
movq 0x18(%rsp), %rsi
jmp 0xfbc2
movq %rax, %r12
jmp 0xfbca
movq %rax, %r12
jmp 0xfbb3
movq %rax, %r12
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xfbb3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0xfbca
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x5370
movq %rbx, %rdi
callq 0xba98
movq %r12, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O1/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 0x28(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
movl $0x8, %edx
callq 0x55d0
movq %r12, %rdi
movq %r15, %rsi
callq 0x5220
movq 0x50(%rsp), %rax
subq 0x48(%rsp), %rax
jne 0x1216f
leaq 0x38(%rsp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testq %rax, %rax
jg 0x121a4
movq 0x9dfd(%rip), %rsi      # 0x1bf78
leaq 0x28(%rsp), %rdi
callq 0x54e0
leaq 0xa0(%rsp), %rdi
callq 0x5120
movb $0x1, %al
addq $0x320, %rsp            # imm = 0x320
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a8(%rsp), %rdi
callq 0x5490
leaq 0x2d01(%rip), %rsi      # 0x14eb9
leaq 0x1a8(%rsp), %rdi
movl $0xa, %edx
callq 0x53f0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x1a8(%rsp), %rdi
callq 0x53f0
movq %rax, %r14
leaq 0x2cdc(%rip), %rsi      # 0x14ec4
movl $0x1f, %edx
movq %rax, %rdi
callq 0x53f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x53f0
leaq 0x2c3c(%rip), %rsi      # 0x14e47
movl $0x1, %edx
movq %rax, %rdi
callq 0x53f0
movl $0x10, %edi
callq 0x51a0
movq %rax, %r14
leaq 0x1b0(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x5580
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5440
leaq 0x9832(%rip), %rax      # 0x1ba80
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x97be(%rip), %rsi      # 0x1ba18
movq 0x9d2f(%rip), %rdx      # 0x1bf90
movq %r14, %rdi
callq 0x5610
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1228f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
jmp 0x1228f
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x122a1
movq %r14, %rdi
callq 0x5280
jmp 0x122a1
movq %rax, %rbx
movq 0x9ce0(%rip), %rsi      # 0x1bf88
leaq 0x1a8(%rsp), %rdi
callq 0x51d0
leaq 0x218(%rsp), %rdi
callq 0x5120
jmp 0x122c9
jmp 0x122c6
movq %rax, %rbx
movq 0x9ca8(%rip), %rsi      # 0x1bf78
leaq 0x28(%rsp), %rdi
callq 0x54e0
leaq 0xa0(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x2, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x50c0
testl %eax, %eax
js 0x123af
movl %eax, %ebx
leaq 0x4(%rsp), %rcx
movl $0x1, (%rcx)
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x5660
testl %eax, %eax
jne 0x123c6
testq %r14, %r14
jle 0x123a5
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
movq %r14, %rax
mulq %rcx
shrq $0x12, %rdx
leaq 0x8(%rsp), %rcx
movq %rdx, (%rcx)
imulq $-0xf4240, %rdx, %rax   # imm = 0xFFF0BDC0
addq %r14, %rax
movq %rax, 0x8(%rcx)
movl %ebx, %edi
movl $0x1, %esi
movl $0x14, %edx
movl $0x10, %r8d
callq 0x5660
testl %eax, %eax
jne 0x123dd
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl $0x180, %edi            # imm = 0x180
callq 0x51a0
movq %rax, %r14
movq %rax, %rdi
callq 0x12bd0
jmp 0x123f2
movl $0x180, %edi            # imm = 0x180
callq 0x51a0
movq %rax, %r14
movq %rax, %rdi
callq 0x12bd0
jmp 0x123f2
movl $0x180, %edi            # imm = 0x180
callq 0x51a0
movq %rax, %r14
movq %rax, %rdi
callq 0x12bd0
leaq 0x97e7(%rip), %rsi      # 0x1bbe0
leaq 0xa0c(%rip), %rdx       # 0x12e0c
movq %r14, %rdi
callq 0x5610
jmp 0x1240c
jmp 0x1240c
movq %rax, %rbx
movq %r14, %rdi
callq 0x5280
movq %rbx, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x53e0
testq %rax, %rax
je 0x1246e
movw $0x2, (%rbx)
movq 0x18(%rax), %rcx
movq (%rcx), %rsi
leaq 0x4(%rbx), %rdi
movslq 0x14(%rax), %rdx
callq 0x55a0
movzwl 0x20(%r14), %eax
rolw $0x8, %ax
movw %ax, 0x2(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x180, %edi            # imm = 0x180
callq 0x51a0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x7de6
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x12c42
xorl %ebp, %ebp
leaq 0x9747(%rip), %rsi      # 0x1bbf8
leaq 0x954(%rip), %rdx       # 0x12e0c
movq %rbx, %rdi
callq 0x5610
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x124e2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
jmp 0x124e2
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x124ef
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x4(%rsi), %rdi
movl $0x4, %esi
movl $0x2, %edx
callq 0x54a0
testq %rax, %rax
je 0x12582
movq (%rax), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xc744
leaq 0x2c03(%rip), %rsi      # 0x15137
movq %rbx, %rdi
callq 0x50f0
testl %eax, %eax
jne 0x12574
leaq 0x8(%rsp), %rdi
callq 0x13420
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5420
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x12574
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x180, %edi            # imm = 0x180
callq 0x51a0
movq %rax, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x26cb(%rip), %rdx      # 0x14c6a
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x7a00
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x12c42
xorl %ebp, %ebp
leaq 0x9633(%rip), %rsi      # 0x1bbf8
leaq 0x840(%rip), %rdx       # 0x12e0c
movq %rbx, %rdi
callq 0x5610
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x1261f
movq (%rbx), %rsi
incq %rsi
callq 0x5370
jmp 0x1261f
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x12612
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5370
jmp 0x12612
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1261f
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r12
movq %rdi, %r15
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x5510
testl %eax, %eax
jne 0x12689
movl 0x38(%r15), %edi
addq $0x3c, %r15
movq %r12, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
movq %r15, %r8
movl $0x10, %r9d
callq 0x5060
testq %rax, %rax
js 0x12690
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x52a0
movl %eax, %edi
callq 0x5230
movl $0x180, %edi            # imm = 0x180
callq 0x51a0
movq %rax, %r14
movq %rax, %rdi
callq 0x12cb6
leaq 0x9564(%rip), %rsi      # 0x1bc10
leaq 0x759(%rip), %rdx       # 0x12e0c
movq %r14, %rdi
callq 0x5610
movq %rax, %r15
movq %r14, %rdi
callq 0x5280
jmp 0x126cb
movq %rax, %r15
movq %rbx, %rdi
callq 0x52a0
movq %r15, %rdi
callq 0x5650
nop