LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/nvanbenschoten[P]total-order-multicast/src/process.cc
// Function: process::MessageTypeFromBuf(char*, unsigned long)
std::experimental::optional<uint32_t> MessageTypeFromBuf(char* buf, size_t n) {
  // Check to make sure the size of the buffer is at least the size of the type
  // field.
  if (n < sizeof(uint32_t)) {
    return {};
  }

  // Read the first 32-bits and convert to host endianness.
  uint32_t* buf_type = reinterpret_cast<uint32_t*>(buf);
  return ntohl(*buf_type);
}

// Assembly:
movq %rdi, %rax
cmpq $0x3, %rdx
ja 0x5ccc
andq $0x0, (%rax)
xorl %ecx, %ecx
jmp 0x5cd4
movl (%rsi), %ecx
bswapl %ecx
movl %ecx, (%rax)
movb $0x1, %cl
movb %cl, 0x4(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5d15
movdqu (%rsi), %xmm0
pxor %xmm1, %xmm1
movdqa %xmm0, %xmm2
punpckhbw %xmm1, %xmm2    # xmm2 = xmm2[8],xmm1[8],xmm2[9],xmm1[9],xmm2[10],xmm1[10],xmm2[11],xmm1[11],xmm2[12],xmm1[12],xmm2[13],xmm1[13],xmm2[14],xmm1[14],xmm2[15],xmm1[15]
pshuflw $0x1b, %xmm2, %xmm2     # xmm2 = xmm2[3,2,1,0,4,5,6,7]
pshufhw $0x1b, %xmm2, %xmm2     # xmm2 = xmm2[0,1,2,3,7,6,5,4]
punpcklbw %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3],xmm0[4],xmm1[4],xmm0[5],xmm1[5],xmm0[6],xmm1[6],xmm0[7],xmm1[7]
pshuflw $0x1b, %xmm0, %xmm0     # xmm0 = xmm0[3,2,1,0,4,5,6,7]
pshufhw $0x1b, %xmm0, %xmm0     # xmm0 = xmm0[0,1,2,3,7,6,5,4]
packuswb %xmm2, %xmm0
movdqu %xmm0, (%rax)
movb $0x1, %cl
jmp 0x5d23
pxor %xmm0, %xmm0
movdqu %xmm0, (%rax)
andl $0x0, 0x10(%rax)
xorl %ecx, %ecx
movb %cl, 0x10(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5d6c
movl 0x10(%rsi), %ecx
bswapl %ecx
movdqu (%rsi), %xmm0
pxor %xmm1, %xmm1
movdqa %xmm0, %xmm2
punpckhbw %xmm1, %xmm2    # xmm2 = xmm2[8],xmm1[8],xmm2[9],xmm1[9],xmm2[10],xmm1[10],xmm2[11],xmm1[11],xmm2[12],xmm1[12],xmm2[13],xmm1[13],xmm2[14],xmm1[14],xmm2[15],xmm1[15]
pshuflw $0x1b, %xmm2, %xmm2     # xmm2 = xmm2[3,2,1,0,4,5,6,7]
pshufhw $0x1b, %xmm2, %xmm2     # xmm2 = xmm2[0,1,2,3,7,6,5,4]
punpcklbw %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3],xmm0[4],xmm1[4],xmm0[5],xmm1[5],xmm0[6],xmm1[6],xmm0[7],xmm1[7]
pshuflw $0x1b, %xmm0, %xmm0     # xmm0 = xmm0[3,2,1,0,4,5,6,7]
pshufhw $0x1b, %xmm0, %xmm0     # xmm0 = xmm0[0,1,2,3,7,6,5,4]
packuswb %xmm2, %xmm0
movdqu %xmm0, (%rax)
movl %ecx, 0x10(%rax)
movb $0x1, %cl
jmp 0x5d7b
pxor %xmm0, %xmm0
movdqu %xmm0, (%rax)
andq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movb %cl, 0x14(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5dfa
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, %cl
jmp 0x5e02
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %ecx, %ecx
movb %cl, 0xc(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl $0x1000000, (%rbx)      # imm = 0x1000000
shrq $0x20, %rdx
bswapl %edx
movl %edx, 0x4(%rbx)
movl %ecx, %eax
bswapl %eax
movl %eax, 0x8(%rbx)
shrq $0x20, %rcx
bswapl %ecx
movl %ecx, 0xc(%rbx)
movq (%rdi), %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x6ea4
pushq $0x10
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
movq %r15, %r8
callq 0x104e2
movq %rsp, %rdi
callq 0x6fee
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6fee
movq %rbx, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O2/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
pxor %xmm0, %xmm0
movdqu 0x4(%rsi), %xmm1
movdqa %xmm1, %xmm2
punpckhbw %xmm0, %xmm2    # xmm2 = xmm2[8],xmm0[8],xmm2[9],xmm0[9],xmm2[10],xmm0[10],xmm2[11],xmm0[11],xmm2[12],xmm0[12],xmm2[13],xmm0[13],xmm2[14],xmm0[14],xmm2[15],xmm0[15]
pshuflw $0x1b, %xmm2, %xmm2     # xmm2 = xmm2[3,2,1,0,4,5,6,7]
pshufhw $0x1b, %xmm2, %xmm2     # xmm2 = xmm2[0,1,2,3,7,6,5,4]
punpcklbw %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3],xmm1[4],xmm0[4],xmm1[5],xmm0[5],xmm1[6],xmm0[6],xmm1[7],xmm0[7]
pshuflw $0x1b, %xmm1, %xmm0     # xmm0 = xmm1[3,2,1,0,4,5,6,7]
pshufhw $0x1b, %xmm0, %xmm0     # xmm0 = xmm0[0,1,2,3,7,6,5,4]
packuswb %xmm2, %xmm0
movdqu %xmm0, 0x4(%rsi)
movq (%rdi), %rdi
pushq $0x14
popq %rdx
callq 0x10444
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
movdqa (%rsi), %xmm0
movdqa %xmm0, (%rcx)
movl $0x3000000, (%rsi)      # imm = 0x3000000
pxor %xmm0, %xmm0
movdqu 0x4(%rsi), %xmm1
movdqa %xmm1, %xmm2
punpckhbw %xmm0, %xmm2    # xmm2 = xmm2[8],xmm0[8],xmm2[9],xmm0[9],xmm2[10],xmm0[10],xmm2[11],xmm0[11],xmm2[12],xmm0[12],xmm2[13],xmm0[13],xmm2[14],xmm0[14],xmm2[15],xmm0[15]
pshuflw $0x1b, %xmm2, %xmm2     # xmm2 = xmm2[3,2,1,0,4,5,6,7]
pshufhw $0x1b, %xmm2, %xmm2     # xmm2 = xmm2[0,1,2,3,7,6,5,4]
punpcklbw %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3],xmm1[4],xmm0[4],xmm1[5],xmm0[5],xmm1[6],xmm0[6],xmm1[7],xmm0[7]
pshuflw $0x1b, %xmm1, %xmm0     # xmm0 = xmm1[3,2,1,0,4,5,6,7]
pshufhw $0x1b, %xmm0, %xmm0     # xmm0 = xmm0[0,1,2,3,7,6,5,4]
packuswb %xmm2, %xmm0
movdqu %xmm0, 0x4(%rsi)
movq (%rdi), %rdi
movq %rsp, %r8
andq $0x0, 0x8(%r8)
movq %rcx, (%r8)
leaq 0x82e(%rip), %rax       # 0x675c
movq %rax, 0x18(%r8)
leaq 0x877(%rip), %rax       # 0x67b0
movq %rax, 0x10(%r8)
pushq $0x14
popq %rdx
xorl %ecx, %ecx
callq 0x104e2
movq %rsp, %rdi
callq 0x6fee
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6fee
movq %rbx, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc(%rsp), %rax
movl $0x4000000, (%rax)      # imm = 0x4000000
shrq $0x20, %rsi
bswapl %esi
movl %esi, 0x4(%rax)
bswapl %edx
movl %edx, 0x8(%rax)
movq (%rdi), %rdi
pushq $0xc
popq %rdx
movq %rax, %rsi
callq 0x10444
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x4(%rdx), %rcx
movq %rsp, %rsi
movq %rcx, (%rsi)
movq %rax, %rdi
callq 0x815c
testq %rax, %rax
je 0x6052
movsd 0x10(%rax), %xmm0
movsd 0x4(%r14), %xmm1
movlhps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movups %xmm1, 0x4(%rbx)
movb $0x1, %al
jmp 0x605f
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
xorl %eax, %eax
movb %al, 0x14(%rbx)
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/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
movq 0x4(%rsi), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
callq 0x81f6
testq %rax, %rax
jne 0x60f8
movl 0xc(%r14), %r15d
movl 0x10(%r14), %r12d
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x822c
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)
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x6eea
testq %rax, %rax
jne 0x6114
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x85ac
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0xc17e(%rip), %rsi      # 0x12288
movq %rax, %rdi
callq 0x5680
jmp 0x612e
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0xc162(%rip), %rsi      # 0x12288
movq %rax, %rdi
callq 0x5680
movq 0x15e93(%rip), %rsi     # 0x1bfc8
movq 0x15e74(%rip), %rdx     # 0x1bfb0
movq %rbx, %rdi
callq 0x55f0
jmp 0x6146
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/process.cc
// Function: process::HoldBackQueue::SetDeliverable(msg::SeqMessage const&, std::function<void (msg::SeqMessage&)>)
void HoldBackQueue::SetDeliverable(const msg::SeqMessage& seq_msg,
                                   const deliverMsgFn deliver) {
  // Look up the messages old sequence information in the sequence map using the
  // messages uniquely defining information. This allows us to find the pending
  // message in the ordered set faster.
  PendingMessageKey pmk;
  pmk.sender = seq_msg.sender;
  pmk.msg_id = seq_msg.msg_id;

  auto old_pms_it = pending_seqs_.find(pmk);
  if (old_pms_it == pending_seqs_.end()) {
    // Return without error to permit message replays.
    logging::out << "Unknown SeqMessage " << seq_msg << "...\n";
    return;
  }

  // Remove the message from the sequence cache.
  PendingMessageSeq old_pms = old_pms_it->second;
  pending_seqs_.erase(old_pms_it);

  // Remove old pending message.
  PendingMessage pm;
  pm.pmk = pmk;
  pm.pms = old_pms;
  pm.deliverable = false;
  ordering_.erase(pm);

  // Update with the new information and reinsert.
  PendingMessageSeq pms;
  pms.seq = seq_msg.final_seq;
  pms.seq_proposer = seq_msg.final_seq_proposer;

  pm.pms = pms;
  pm.deliverable = true;
  ordering_.insert(pm);

  // Iterate through map and deliver messages that can be delivered.
  for (auto it = ordering_.begin(); it != ordering_.end() /* not hoisted */;) {
    if (!it->deliverable) {
      break;
    }
    // Deliver and delete for as long as the head of the queue is deliverable.
    msg::SeqMessage to_deliver;
    to_deliver.sender = it->pmk.sender;
    to_deliver.msg_id = it->pmk.msg_id;
    to_deliver.final_seq = it->pms.seq;
    to_deliver.final_seq_proposer = it->pms.seq_proposer;
    deliver(to_deliver);

    // Erase and move to next message in ordered map.
    it = ordering_.erase(it);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x4(%rsi), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
callq 0x815c
testq %rax, %rax
je 0x6216
movq 0x10(%rax), %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x8740
movq 0x8(%rsp), %rax
leaq 0x28(%rsp), %r13
movq %rax, (%r13)
movq %r15, 0x8(%r13)
movb $0x0, 0x14(%r13)
leaq 0x38(%r14), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x8842
movq 0xc(%r12), %rax
movq %rax, 0x8(%r13)
movb $0x1, 0x14(%r13)
movq %r15, %rdi
movq %r13, %rsi
callq 0x85ac
movq 0x50(%r14), %r13
addq $0x40, %r14
leaq 0x14(%rsp), %r12
cmpq %r14, %r13
je 0x6243
cmpb $0x1, 0x34(%r13)
jne 0x6243
movups 0x20(%r13), %xmm0
movups %xmm0, 0x18(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6f4c
movq %r15, %rdi
movq %r13, %rsi
callq 0x8a88
movq %rax, %r13
jmp 0x61e5
leaq 0x162f3(%rip), %rdi     # 0x1c510
leaq 0xc08e(%rip), %rsi      # 0x122b2
callq 0x6f04
movq %rax, %rdi
movq %r12, %rsi
callq 0x6f1c
leaq 0xc08b(%rip), %rsi      # 0x122c6
movq %rax, %rdi
callq 0x6f34
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nvanbenschoten[P]total-order-multicast/src/process.cc
// Function: process::Process::TotalOrder(unsigned int, std::function<void (msg::SeqMessage&)>)
void Process::TotalOrder(unsigned int send_count, deliverMsgFn deliver) {
  // Launch a multicast sender for each message.
  for (unsigned int i = 0; i < send_count; ++i) {
    LaunchMulticastSender();
  }

  // Launch a server, which will block indefinitely.
  server_.Listen(
      // Called on all incoming Data Messages.
      [this, deliver](udp::ClientPtr client, char* buf, size_t n) {
        auto data_type = MessageTypeFromBuf(buf, n);
        if (!data_type) {
          // We didn't even get a full data type message. Drop it on the floor.
          logging::out << "Received message with incomplete type\n";
          return udp::ServerAction::Continue;
        }

        // Delegate message handling based on the message type.
        switch (*data_type) {
          case msg::kDataMessageType:
            HandleDataMsg(client, buf, n);
            break;
          case msg::kSeqMessageType:
            HandleSeqMsg(client, buf, n, deliver);
            break;
          case msg::kAckMessageType:
          case msg::kSeqAckMessageType:
            logging::out << "Received ack message when one was not expected\n";
            break;
          default:
            logging::out << "Received message with unknown type: " << *data_type
                         << "\n";
            break;
        }
        return udp::ServerAction::Continue;
      });
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
subl $0x1, %ebx
jb 0x6272
movq %r14, %rdi
callq 0x6360
jmp 0x6263
leaq 0x30(%rsp), %rbx
movq %r14, -0x8(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6f60
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
pushq $0x28
popq %rdi
callq 0x5350
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
andq $0x0, 0x18(%rax)
movq 0x48(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq 0x40(%rsp), %rcx
testq %rcx, %rcx
je 0x62dd
movq %rax, %rdx
addq $0x8, %rdx
leaq 0x40(%rsp), %rsi
movups (%rbx), %xmm0
movups %xmm0, (%rdx)
movq %rcx, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x4ec(%rip), %rax       # 0x67d6
movq %rax, 0x18(%rsi)
leaq 0x665(%rip), %rax       # 0x695a
movq %rax, 0x10(%rsi)
addq $0x54, %r14
leaq 0x50(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movq %r14, %rdi
callq 0x1077c
leaq 0x50(%rsp), %rdi
callq 0x6fee
movq %rsp, %rdi
callq 0x6fee
movq %rbx, %rdi
callq 0x6fee
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x6fee
jmp 0x6347
movq %rax, %r14
movq %rsp, %rdi
callq 0x6fee
movq %rbx, %rdi
callq 0x6fee
movq %r14, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/nvanbenschoten[P]total-order-multicast/src/process.cc
// Function: process::Process::HandleDataMsg(std::shared_ptr<udp::Client>, char*, unsigned long)
void Process::HandleDataMsg(const udp::ClientPtr client, char* buf, size_t n) {
  auto data_msg = DataMsgFromBuf(buf, n);
  if (!data_msg || !ValidDataMsg(*data_msg, processes_.size())) {
    // If the data message was not valid, return without trying to use it.
    return;
  }
  logging::out << "Received message " << *data_msg << "\n";

  // If we have already seen this message, send back the old ack so that the
  // sequence number does not change.
  auto ack_msg = hold_back_queue_.Lookup(*data_msg);
  if (!ack_msg) {
    // We have not already seen this message, so insert it into the
    // HoldBackQueue.
    ack_msg->sender = data_msg->sender;
    ack_msg->msg_id = data_msg->msg_id;
    ack_msg->proposed_seq = NextSeqNum();
    ack_msg->proposer = id_;

    hold_back_queue_.InsertUndeliverable(*ack_msg, data_msg->data);
  }

  // Respond to the sender.
  SendAckMsg(client, *ack_msg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x24(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x5cd8
cmpb $0x1, 0x10(%r15)
jne 0x650b
movq 0x8(%r14), %rax
subq (%r14), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
cmpl $0x1, 0x24(%rsp)
jne 0x650b
movl 0x28(%rsp), %ecx
cmpq %rcx, %rax
jbe 0x650b
leaq 0x160b5(%rip), %rdi     # 0x1c510
leaq 0xbe69(%rip), %rsi      # 0x122cb
callq 0x6fa6
leaq 0x24(%rsp), %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x6fbe
leaq 0xc800(%rip), %rsi      # 0x12c7e
movq %rax, %rdi
callq 0x6fd6
leaq 0x60(%r14), %r15
leaq 0x48(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6018
cmpb $0x0, 0x14(%r13)
jne 0x64d8
movq 0x28(%rsp), %rax
leaq 0x48(%rsp), %rsi
movq %rax, 0x4(%rsi)
movl 0xc8(%r14), %eax
incl %eax
movl %eax, 0xc8(%r14)
movl %eax, 0xc(%rsi)
movl 0x50(%r14), %eax
movl %eax, 0x10(%rsi)
movl 0x30(%rsp), %edx
movq %r15, %rdi
callq 0x606e
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x72ee
movl 0x58(%rsp), %eax
movl %eax, 0x10(%rsp)
movups 0x48(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x5e79
leaq 0x40(%rsp), %rdi
callq 0x708e
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x708e
movq %rbx, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O2/nvanbenschoten[P]total-order-multicast/src/process.cc
// Function: process::Process::HandleSeqMsg(std::shared_ptr<udp::Client>, char*, unsigned long, std::function<void (msg::SeqMessage&)>)
void Process::HandleSeqMsg(const udp::ClientPtr client, char* buf, size_t n,
                           const deliverMsgFn deliver) {
  auto seq_msg = SeqMsgFromBuf(buf, n);
  if (!seq_msg || !ValidSeqMsg(*seq_msg, processes_.size())) {
    // If the seq message was not valid, return without trying to use it.
    return;
  }
  logging::out << "Received message " << *seq_msg << "\n";

  // Forward our sequence number so that it is always larger than any other
  // we have seen.
  ForwardSeqNum(seq_msg->final_seq);

  // Respond to the sender.
  msg::SeqAckMessage seqack_msg;
  seqack_msg.sender = seq_msg->sender;
  seqack_msg.msg_id = seq_msg->msg_id;
  SendSeqAckMsg(client, seqack_msg);

  // Set the message as deliverable in the HoldBackQueue. This may result in one
  // or more messages being delivered.
  hold_back_queue_.SetDeliverable(*seq_msg, deliver);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x5d7f
cmpb $0x1, 0x14(%r12)
jne 0x6648
movq 0x8(%rbx), %rax
subq (%rbx), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
cmpl $0x3, (%rsp)
jne 0x6648
movl 0x4(%rsp), %ecx
cmpq %rcx, %rax
jbe 0x6648
movl 0x10(%rsp), %ecx
cmpq %rcx, %rax
jbe 0x6648
leaq 0x15f64(%rip), %rdi     # 0x1c510
leaq 0xbd18(%rip), %rsi      # 0x122cb
callq 0x6fa6
movq %rsp, %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x6f1c
leaq 0xc6b1(%rip), %rsi      # 0x12c7e
movq %rax, %rdi
callq 0x6fd6
movl 0xc(%r12), %eax
cmpl %eax, 0xc8(%rbx)
jae 0x65e8
movl %eax, 0xc8(%rbx)
movl 0x4(%rsp), %r12d
movl 0x8(%rsp), %ebp
shlq $0x20, %r12
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x72ee
movq %r13, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x5f68
leaq 0x20(%rsp), %rdi
callq 0x708e
addq $0x60, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6f60
movq %rsp, %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x615a
leaq 0x28(%rsp), %rdi
callq 0x6fee
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6fee
jmp 0x6673
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x708e
movq %rbx, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6720
pushq %r14
pushq %rbx
subq $0x88, %rsp
cmpb $0x0, %fs:-0x18
je 0x6721
xorpd %xmm0, %xmm0
movhpd 0xb9a9(%rip), %xmm0     # xmm0 = xmm0[0],mem[0]
leaq 0x10(%rsp), %rdi
movapd %xmm0, (%rdi)
movq %fs:0x0, %rax
leaq -0x20(%rax), %rbx
movq %rbx, %rsi
callq 0x700a
movsd 0xb988(%rip), %xmm1     # 0x12068
ucomisd %xmm0, %xmm1
ja 0x6716
leaq 0x20(%rsp), %r14
movsd 0xb97d(%rip), %xmm0     # 0x12070
movq %r14, %rdi
callq 0x7012
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7038
testl %eax, %eax
jle 0x6716
leaq 0xc(%rsp), %rdi
movl %eax, (%rdi)
callq 0x7040
addq $0x88, %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:-0x20
movb $0x1, %fs:-0x18
jmp 0x66ab
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
testl %esi, %esi
js 0x9caa
movl %esi, %esi
movq 0x8(%rdi), %rax
subq (%rdi), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
cmpq %rsi, %rax
jbe 0x9caa
callq 0x95e6
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x110c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb6cf
movl %eax, %ebx
movq %r14, %rdi
callq 0x56f8
testb %bl, %bl
jne 0x9cf5
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0x8e97(%rip), %rsi      # 0x12b53
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x71e8
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xb6ba
xorl %ebp, %ebp
leaq 0x1197c(%rip), %rsi     # 0x1b660
movq 0x1229d(%rip), %rdx     # 0x1bf88
movq %rbx, %rdi
callq 0x55f0
jmp 0x9d3e
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0x8e6d(%rip), %rsi      # 0x12b74
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x71e8
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xb6ba
xorl %ebp, %ebp
leaq 0x11931(%rip), %rsi     # 0x1b660
movq 0x12252(%rip), %rdx     # 0x1bf88
movq %rbx, %rdi
callq 0x55f0
jmp 0x9d42
jmp 0x9d56
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x56f8
testb %bpl, %bpl
jne 0x9d59
jmp 0x9d61
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/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 %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x110c4
pushq $-0x1
popq %rbp
xorl %r15d, %r15d
pushq $0x28
popq %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %r12
cmpq %rax, %r15
jae 0x9dc6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x95e6
movq %rax, %rdi
movq %r14, %rsi
callq 0x7a97
testb %al, %al
je 0x9dc1
testl %ebp, %ebp
jns 0x9de4
movl %r15d, %ebp
incq %r15
jmp 0x9d8f
cmpl $-0x1, %ebp
je 0x9e2f
leaq 0x30(%rsp), %rdi
callq 0x56f8
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0x8daa(%rip), %rsi      # 0x12ba0
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x71e8
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xb682
xorl %ebp, %ebp
leaq 0x1182a(%rip), %rsi     # 0x1b648
movq 0x12163(%rip), %rdx     # 0x1bf88
movq %rbx, %rdi
callq 0x55f0
jmp 0x9e78
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0x8da3(%rip), %rsi      # 0x12be4
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x71e8
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xb6ba
xorl %ebp, %ebp
leaq 0x117f7(%rip), %rsi     # 0x1b660
movq 0x12118(%rip), %rdx     # 0x1bf88
movq %rbx, %rdi
callq 0x55f0
jmp 0x9e7c
jmp 0x9e90
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x56f8
testb %bpl, %bpl
jne 0x9e93
jmp 0x9ea0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5270
jmp 0x9ea0
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x56f8
movq %r14, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpq $0x0, 0x70(%rdi)
jne 0xbaa5
leaq 0x68(%rbx), %rdi
movq (%r14), %rsi
callq 0x56a0
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 0xe51e
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe550
leaq 0x10(%rsp), %rdi
cmpq 0x8(%rdi), %rax
sete %bl
callq 0xad04
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xad04
movq %rbx, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x30(%rsi), %r12
movq 0x38(%rsi), %r15
leaq 0xf923(%rip), %r14      # 0x1b690
leaq 0x8(%rsp), %r13
cmpq %r15, %r12
je 0xbe09
movq (%r12), %rbp
testq %rbp, %rbp
je 0xbe00
movq %rbp, %rdi
movq %r14, %rsi
leaq 0xf93f(%rip), %rdx      # 0x1b6d0
xorl %ecx, %ecx
callq 0x53a0
testq %rax, %rax
je 0xbdc8
movq %r13, %rdi
movq %rax, %rsi
callq 0xbd42
movq 0x8(%rbx), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rbx, %rdi
callq 0xace4
movq %r13, %rdi
callq 0xad04
jmp 0xbe00
movq %rbp, %rdi
movq %r14, %rsi
leaq 0xf913(%rip), %rdx      # 0x1b6e8
xorl %ecx, %ecx
callq 0x53a0
testq %rax, %rax
je 0xbe00
movq (%rax), %rcx
movq %r13, %rdi
movq %rax, %rsi
callq *0x28(%rcx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xc058
movq %r13, %rdi
callq 0x56f8
addq $0x8, %r12
jmp 0xbd72
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x56f8
jmp 0xbe3e
jmp 0xbe3b
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xad04
jmp 0xbe3e
movq %rax, %r14
movq %rbx, %rdi
callq 0xad04
movq %r14, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O2/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 0xcc5a
cmpq 0x38(%rbx), %rax
sete %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %r14
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)
incq %r14
imulq $0x28, %rdx, %r15
testq %r15, %r15
je 0xcf34
cmpb $0x1, -0x1(%r14)
jne 0xcf2a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xcfc2
addq $0x28, %r14
addq $-0x28, %r15
jmp 0xcf13
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xd7e0
movq %r14, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %r14
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)
addq $0x8, %r14
imulq $0x28, %rdx, %r15
testq %r15, %r15
je 0xcfa5
cmpb $0x0, -0x8(%r14)
jne 0xcf9b
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd334
addq $0x28, %r14
addq $-0x28, %r15
jmp 0xcf84
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xd762
movq %r14, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
addq $0x30, %rdi
movq %rdi, 0x20(%rbx)
andq $0x0, 0x28(%rbx)
movq %rsi, %r14
movb %al, 0x30(%rbx)
addq $0x58, %rsi
leaq 0x8(%rsp), %rdi
callq 0xe2ea
leaq 0x40(%rsp), %rdi
callq 0x5470
leaq 0x20(%rbx), %r15
movq 0x8(%rsp), %r12
leaq 0x40(%rsp), %r13
leaq 0x5478(%rip), %rbp      # 0x12d57
cmpq 0x10(%rsp), %r12
je 0xd909
cmpq 0x8(%rsp), %r12
je 0xd8f8
movq %r13, %rdi
movq %rbp, %rsi
callq 0x5340
movq %r13, %rdi
movq %r12, %rsi
callq 0x5310
addq $0x20, %r12
jmp 0xd8df
leaq 0x48(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x5540
leaq 0x20(%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 0x40(%rsp), %rdi
callq 0x50b0
leaq 0x8(%rsp), %rdi
callq 0xad04
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd976
jmp 0xd976
movq %rax, %r14
jmp 0xd983
movq %rax, %r14
jmp 0xd98d
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x50b0
leaq 0x8(%rsp), %rdi
callq 0xad04
movq %rbx, %rdi
callq 0xc2e6
movq %r14, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xdb0a
testq %rax, %rax
jne 0xd9cb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe4f2
leaq 0xdc90(%rip), %rsi      # 0x1b678
movq 0xe599(%rip), %rdx      # 0x1bf88
movq %r14, %rdi
callq 0x55f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
callq 0xdbfe
testq %rax, %rax
jne 0xda29
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movsbl %bpl, %edx
movq %rsp, %rdi
pushq $0x1
popq %rsi
callq 0x53d0
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xe4f2
xorl %ebp, %ebp
leaq 0xdc15(%rip), %rsi      # 0x1b678
movq 0xe51e(%rip), %rdx      # 0x1bf88
movq %rbx, %rdi
callq 0x55f0
movq %rax, %r14
movq %rsp, %rdi
callq 0x56f8
testb %bpl, %bpl
jne 0xda87
jmp 0xda8f
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/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 $0x58, %rdi
callq 0xe230
testb %al, %al
je 0xdb3d
cmpb $0x1, 0x51(%r14)
jne 0xdb36
cmpb $0x1, 0x8(%r14)
je 0xdb4f
movb $0x1, 0x8(%r14)
jmp 0xdb40
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 0x5470
leaq 0x51aa(%rip), %rsi      # 0x12d0d
movq %r14, %rdi
callq 0x5340
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5310
leaq 0x5197(%rip), %rsi      # 0x12d14
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 0xe242
xorl %ebp, %ebp
leaq 0xde28(%rip), %rsi      # 0x1b9e0
movq 0xe3c9(%rip), %rdx      # 0x1bf88
movq %rbx, %rdi
callq 0x55f0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x56f8
testb %bpl, %bpl
jne 0xdbde
jmp 0xdbeb
movq %rax, %r14
movq %rbx, %rdi
callq 0x5270
jmp 0xdbeb
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x50b0
movq %r14, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq %rsi, %r14
movb %al, 0x30(%rdi)
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x28(%rax)
leaq 0x20(%rbx), %rdi
movq %rsp, %r15
movq %r15, %rsi
callq 0x53f0
movq %r15, %rdi
callq 0x56f8
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 0xde2e
movq %rax, %r14
movq %rbx, %rdi
callq 0xc2e6
movq %r14, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rcx, (%rsp)
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x50(%rsi), %rsi
addq 0x18(%r15), %rsi
callq 0xe402
leaq 0x10(%r15), %r14
leaq 0x8(%rsp), %r13
leaq 0x28(%rsp), %rbp
movq (%r14), %r14
testq %r14, %r14
je 0xe378
movsbl 0x8(%r14), %edx
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r13, %rdi
pushq $0x1
popq %rsi
callq 0x53d0
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xe496
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xc058
movq %rbp, %rdi
callq 0x56f8
movq %r13, %rdi
callq 0x56f8
jmp 0xe32b
addq $0x48, %r15
leaq 0x28(%rsp), %r12
movq (%rsp), %r14
movq (%r15), %r15
testq %r15, %r15
je 0xe3b1
leaq 0x8(%r15), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0xe4ba
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc058
movq %r12, %rdi
callq 0x56f8
jmp 0xe385
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe3d1
jmp 0xe3d1
movq %rax, %r14
leaq 0x28(%rsp), %rdi
jmp 0xe3ed
movq %rax, %r14
jmp 0xe3f2
movq %rax, %r14
jmp 0xe3e8
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x56f8
leaq 0x8(%rsp), %rdi
callq 0x56f8
movq %rbx, %rdi
callq 0xad04
movq %r14, %rdi
callq 0x5620