LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
movq $0x0, 0x8(%r8)
movq %rcx, (%r8)
leaq 0xa63(%rip), %rax       # 0x6d9c
movq %rax, 0x18(%r8)
leaq 0xaa4(%rip), %rax       # 0x6de8
movq %rax, 0x10(%r8)
movl $0x14, %edx
xorl %ecx, %ecx
callq 0x12508
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x636b
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x40, %rsp
popq %rbx
retq
jmp 0x6395
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x638d
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x5650
movq %rax, %rdi
callq 0x791b
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0xc, %edx
movq %rax, %rsi
callq 0x1245e
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8946
testq %rax, %rax
je 0x648a
movsd 0x10(%rax), %xmm0
movsd 0x4(%r14), %xmm1
movlhps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movups %xmm1, 0x4(%rbx)
movb $0x1, %al
jmp 0x649a
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
xorl %eax, %eax
movb %al, 0x14(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x89dc
testq %rax, %rax
jne 0x6536
movl 0xc(%r14), %r15d
movl 0x10(%r14), %r12d
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a0e
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 0x8c84
addq $0x40, %rbx
cmpq %rbx, %rax
jne 0x6554
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x8ce8
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0xdd36(%rip), %rsi      # 0x14280
movq %rax, %rdi
callq 0x56a0
jmp 0x6570
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0xdd18(%rip), %rsi      # 0x14280
movq %rax, %rdi
callq 0x56a0
movq 0x15a51(%rip), %rsi     # 0x1bfc8
movq 0x15a32(%rip), %rdx     # 0x1bfb0
movq %rbx, %rdi
callq 0x5610
jmp 0x6588
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6d84
pushq %r14
pushq %rbx
subq $0x78, %rsp
cmpb $0x0, %fs:-0x18
je 0x6d85
movq %fs:0x0, %rax
leaq -0x20(%rax), %rbx
movq %rbx, %rdi
callq 0x9158
movsd 0xd37c(%rip), %xmm1     # 0x14060
ucomisd %xmm0, %xmm1
ja 0x6d7d
movabsq $0x4014000000000000, %rax # imm = 0x4014000000000000
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
movq %r14, %rdi
callq 0x92a2
xorpd %xmm0, %xmm0
movhpd 0xd354(%rip), %xmm0     # xmm0 = xmm0[0],mem[0]
movupd %xmm0, 0x48(%r14)
movq $0x0, 0x58(%r14)
movb $0x0, 0x60(%r14)
movq %r14, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x946c
testl %eax, %eax
jle 0x6d7d
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 0x6d7d
callq 0x5040
cmpl $0x4, (%rax)
je 0x6d63
addq $0x78, %rsp
popq %rbx
popq %r14
retq
callq 0x5810
jmp 0x6cc4
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa3f7
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 0xa3f7
leaq (%rax,%rax,4), %r15
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x13240
movq 0x8(%r14,%r15,8), %rdx
cmpq 0x8(%rbx), %rdx
jne 0xa3c1
movq 0x8(%rsp), %rbx
testq %rdx, %rdx
je 0xa3cb
leaq (%r14,%r15,8), %rax
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x5390
testl %eax, %eax
setne %bpl
jmp 0xa3cd
movb $0x1, %bpl
movq 0x8(%rsp), %rbx
jmp 0xa3cd
xorl %ebp, %ebp
leaq 0x18(%rsp), %r15
cmpq %r15, %rbx
je 0xa3e7
movq 0x18(%rsp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x5370
testb %bpl, %bpl
jne 0xa459
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 0xa72a(%rip), %rsi      # 0x14b3e
leaq 0xa743(%rip), %rdx      # 0x14b5e
leaq 0x8(%rsp), %rdi
callq 0x79f0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5440
leaq 0x11374(%rip), %rax     # 0x1b7b0
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x11290(%rip), %rsi     # 0x1b6d8
movq 0x11b41(%rip), %rdx     # 0x1bf90
movq %rbx, %rdi
callq 0x5610
jmp 0xa4b3
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0xa6ea(%rip), %rsi      # 0x14b5f
leaq 0xa70e(%rip), %rdx      # 0x14b8a
callq 0x79f0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5440
leaq 0x11318(%rip), %rax     # 0x1b7b0
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x11234(%rip), %rsi     # 0x1b6d8
movq 0x11ae5(%rip), %rdx     # 0x1bf90
movq %rbx, %rdi
callq 0x5610
jmp 0xa4b7
jmp 0xa4d8
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xa4d1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
testb %bpl, %bpl
jne 0xa4db
jmp 0xa4e3
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13240
movq (%rbx), %r12
movq 0x8(%rbx), %rax
subq %r12, %rax
je 0xa60d
sarq $0x3, %rax
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %r13
movq 0x28(%rsp), %r14
cmpq $0x1, %r13
adcq $0x0, %r13
movq 0x30(%rsp), %r15
addq $0x8, %r12
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
xorl %ebp, %ebp
cmpq %r15, (%r12)
jne 0xa56a
testq %r15, %r15
je 0xa564
movq -0x8(%r12), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5390
testl %eax, %eax
jne 0xa56a
testl %ebx, %ebx
jns 0xa5ab
movl %ebp, %ebx
incq %rbp
addq $0x28, %r12
cmpq %rbp, %r13
jne 0xa545
cmpl $-0x1, %ebx
je 0xa60d
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa59a
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 0xa5c3(%rip), %rsi      # 0x14b8b
leaq 0xa5ff(%rip), %rdx      # 0x14bce
leaq 0x8(%rsp), %rdi
callq 0x79f0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5440
leaq 0x11198(%rip), %rax     # 0x1b788
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x110c4(%rip), %rsi     # 0x1b6c0
movq 0x1198d(%rip), %rdx     # 0x1bf90
movq %rbx, %rdi
callq 0x5610
jmp 0xa66d
movl $0x10, %edi
callq 0x51a0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa5a5(%rip), %rsi      # 0x14bcf
leaq 0xa5c4(%rip), %rdx      # 0x14bf5
leaq 0x8(%rsp), %rdi
callq 0x79f0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5440
leaq 0x1115e(%rip), %rax     # 0x1b7b0
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1107a(%rip), %rsi     # 0x1b6d8
movq 0x1192b(%rip), %rdx     # 0x1bf90
movq %rbx, %rdi
callq 0x5610
jmp 0xa671
jmp 0xa692
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xa68b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
testb %bpl, %bpl
jne 0xa695
jmp 0xa69d
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa6b8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5370
movq %r14, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpq $0x0, 0x70(%rdi)
jne 0xcda4
leaq 0x68(%rbx), %r15
movq (%r14), %r12
movq %r12, %rdi
callq 0x5180
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r12, %rcx
movq %rax, %r8
callq 0x5570
movslq %ebp, %rax
leaq (%r14,%rax,8), %rdx
addq $0x8, %r14
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0xfd18
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0xfe90
leaq 0x8(%rsp), %rdi
cmpq 0x8(%rdi), %rax
sete %bl
callq 0xbaa0
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbaa0
movq %rbx, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O3/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), %r15
cmpq %r15, %r12
je 0xd216
leaq 0xe59b(%rip), %r14      # 0x1b708
leaq 0x8(%rsp), %r13
movq (%r12), %rbp
testq %rbp, %rbp
je 0xd1bd
movq %rbp, %rdi
movq %r14, %rsi
leaq 0xe5c0(%rip), %rdx      # 0x1b748
xorl %ecx, %ecx
callq 0x53d0
testq %rax, %rax
je 0xd1c8
movq %r13, %rdi
movq %rax, %rsi
callq 0xd136
movq 0x8(%rbx), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rbx, %rdi
callq 0x110c0
movq %r13, %rdi
callq 0xbaa0
addq $0x8, %r12
cmpq %r15, %r12
jne 0xd172
jmp 0xd216
movq %rbp, %rdi
movq %r14, %rsi
leaq 0xe58b(%rip), %rdx      # 0x1b760
xorl %ecx, %ecx
callq 0x53d0
testq %rax, %rax
je 0xd1bd
movq (%rax), %rcx
movq %r13, %rdi
movq %rax, %rsi
callq *0x28(%rcx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xd480
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xd1bd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
jmp 0xd1bd
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 0xd25d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
jmp 0xd25d
jmp 0xd25a
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xbaa0
jmp 0xd25d
movq %rax, %r14
movq %rbx, %rdi
callq 0xbaa0
movq %r14, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe21a
cmpq 0x38(%rbx), %rax
sete %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe52d
movq %rsi, %r14
incq %r14
shlq $0x3, %rdx
leaq (%rdx,%rdx,4), %r12
movq %rsp, %r15
cmpb $0x1, -0x1(%r14)
jne 0xe523
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe5d8
addq $0x28, %r14
addq $-0x28, %r12
jne 0xe50a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xecee
movq %r14, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe5b6
movq %rsi, %r14
addq $0x8, %r14
shlq $0x3, %rdx
leaq (%rdx,%rdx,4), %r12
movq %rsp, %r15
cmpb $0x0, -0x8(%r14)
jne 0xe5ac
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe86a
addq $0x28, %r14
addq $-0x28, %r12
jne 0xe593
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xec7a
movq %r14, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf9ce
leaq 0x38(%rsp), %rdi
callq 0x5490
movq (%rsp), %r13
cmpq 0x8(%rsp), %r13
je 0xee09
leaq 0x38(%rsp), %r15
leaq 0x5f6a(%rip), %r12      # 0x14d42
cmpq (%rsp), %r13
je 0xedee
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 0xedd8
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 0xee43
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x5370
addq $0x10, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51e0
movq 0xd12f(%rip), %rsi      # 0x1bf88
leaq 0x38(%rsp), %rdi
callq 0x51d0
leaq 0xa8(%rsp), %rdi
callq 0x5120
movq %rsp, %rdi
callq 0xbaa0
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xee9a
jmp 0xee9a
movq %rax, %r14
jmp 0xeebb
movq %rax, %r14
jmp 0xeec3
movq %rax, %r14
movq 0xd0e4(%rip), %rsi      # 0x1bf88
leaq 0x38(%rsp), %rdi
callq 0x51d0
leaq 0xa8(%rsp), %rdi
callq 0x5120
movq %rsp, %rdi
callq 0xbaa0
movq %rbx, %rdi
callq 0xd780
movq %r14, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf062
testq %rax, %rax
jne 0xef13
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 0xfcea
leaq 0xc7be(%rip), %rsi      # 0x1b6f0
movq 0xd057(%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_O3/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 0xf19a
testq %rax, %rax
jne 0xef77
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 0xcaf1(%rip), %rax      # 0x1baa8
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xc72d(%rip), %rsi      # 0x1b6f0
movq 0xcfc6(%rip), %rdx      # 0x1bf90
movq %rbx, %rdi
callq 0x5610
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xefec
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
testb %bpl, %bpl
jne 0xeff6
jmp 0xeffe
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf906
testq %rax, %rax
je 0xf099
cmpb $0x1, 0x51(%r14)
jne 0xf092
cmpb $0x1, 0x8(%r14)
je 0xf0ab
movb $0x1, 0x8(%r14)
jmp 0xf09c
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 0x5c39(%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 0x5c1b(%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 0xc934(%rip), %rax      # 0x1ba58
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xc900(%rip), %rsi      # 0x1ba30
movq 0xce59(%rip), %rdx      # 0x1bf90
movq %rbx, %rdi
callq 0x5610
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf15d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
testb %bpl, %bpl
jne 0xf167
jmp 0xf174
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
jmp 0xf174
movq %rax, %r14
movq 0xce0d(%rip), %rsi      # 0x1bf88
leaq 0x28(%rsp), %rdi
callq 0x51d0
leaq 0x98(%rsp), %rdi
callq 0x5120
movq %r14, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf4de
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 0xf4fc
movq %rax, %r14
movq %rbx, %rdi
callq 0xd780
movq %r14, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfba8
movq %r14, 0x28(%rsp)
movq 0x10(%r14), %rbp
testq %rbp, %rbp
je 0xfadb
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 0xfa74
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0xfa7b
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 0xd480
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xfab7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0xface
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x5370
movq (%rbp), %rbp
testq %rbp, %rbp
jne 0xfa26
movq 0x28(%rsp), %rax
movq 0x48(%rax), %r12
testq %r12, %r12
movq 0x30(%rsp), %r13
je 0xfb33
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x8(%r12), %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0xfc8f
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd480
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xfb2a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
movq (%r12), %r12
testq %r12, %r12
jne 0xfaf8
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xfb5d
jmp 0xfb5d
movq %rax, %r12
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xfb98
movq 0x18(%rsp), %rsi
jmp 0xfb90
movq %rax, %r12
jmp 0xfb98
movq %rax, %r12
jmp 0xfb81
movq %rax, %r12
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xfb81
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0xfb98
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x5370
movq %rbx, %rdi
callq 0xbaa0
movq %r12, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11fa5
leaq 0x38(%rsp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testq %rax, %rax
jg 0x11fda
movq 0x9fc7(%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 0x2ecb(%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 0x2ea6(%rip), %rsi      # 0x14ec4
movl $0x1f, %edx
movq %rax, %rdi
callq 0x53f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x53f0
leaq 0x2e06(%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 0x99fc(%rip), %rax      # 0x1ba80
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x9988(%rip), %rsi      # 0x1ba18
movq 0x9ef9(%rip), %rdx      # 0x1bf90
movq %r14, %rdi
callq 0x5610
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x120bd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
testb %bpl, %bpl
jne 0x120c7
jmp 0x120d4
movq %rax, %rbx
movq %r14, %rdi
callq 0x5280
jmp 0x120d4
movq %rax, %rbx
movq 0x9ead(%rip), %rsi      # 0x1bf88
leaq 0x1a8(%rsp), %rdi
callq 0x51d0
leaq 0x218(%rsp), %rdi
callq 0x5120
jmp 0x120fc
jmp 0x120f9
movq %rax, %rbx
movq 0x9e75(%rip), %rsi      # 0x1bf78
leaq 0x28(%rsp), %rdi
callq 0x54e0
leaq 0xa0(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O3/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 0x121e3
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 0x121fa
testq %r14, %r14
jle 0x121d9
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 0x12211
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 0x129ee
jmp 0x12226
movl $0x180, %edi            # imm = 0x180
callq 0x51a0
movq %rax, %r14
movq %rax, %rdi
callq 0x129ee
jmp 0x12226
movl $0x180, %edi            # imm = 0x180
callq 0x51a0
movq %rax, %r14
movq %rax, %rdi
callq 0x129ee
leaq 0x99b3(%rip), %rsi      # 0x1bbe0
leaq 0x9f6(%rip), %rdx       # 0x12c2a
movq %r14, %rdi
callq 0x5610
jmp 0x12240
jmp 0x12240
movq %rax, %rbx
movq %r14, %rdi
callq 0x5280
movq %rbx, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x122a2
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 0x7dce
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x12a60
xorl %ebp, %ebp
leaq 0x9913(%rip), %rsi      # 0x1bbf8
leaq 0x93e(%rip), %rdx       # 0x12c2a
movq %rbx, %rdi
callq 0x5610
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1230e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5370
testb %bpl, %bpl
jne 0x12318
jmp 0x12320
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O3/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 0x123b2
movq (%rax), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xc752
leaq 0x2dd3(%rip), %rsi      # 0x15137
movq %rbx, %rdi
callq 0x50f0
testl %eax, %eax
jne 0x123a4
leaq 0x8(%rsp), %rdi
callq 0x13240
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5420
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x123a4
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 0x289b(%rip), %rdx      # 0x14c6a
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x79f0
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x12a60
xorl %ebp, %ebp
leaq 0x9803(%rip), %rsi      # 0x1bbf8
leaq 0x82e(%rip), %rdx       # 0x12c2a
movq %rbx, %rdi
callq 0x5610
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x1244c
movq (%rbx), %rsi
incq %rsi
callq 0x5370
jmp 0x1244c
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x1243a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5370
testb %bpl, %bpl
jne 0x12444
jmp 0x1244c
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O3/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 0x124b5
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 0x124bc
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 0x12ad4
leaq 0x9738(%rip), %rsi      # 0x1bc10
leaq 0x74b(%rip), %rdx       # 0x12c2a
movq %r14, %rdi
callq 0x5610
movq %rax, %r15
movq %r14, %rdi
callq 0x5280
jmp 0x124f7
movq %rax, %r15
movq %rbx, %rdi
callq 0x52a0
movq %r15, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]total-order-multicast/src/udp_conn.cc
// Function: udp::Client::WaitBackoff(unsigned int) const
void Client::WaitBackoff(unsigned int multiplier) const {
  static thread_local std::default_random_engine random_engine(
      std::chrono::system_clock::now().time_since_epoch().count());

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebx
cmpb $0x0, %fs:-0x8
je 0x12784
movabsq $0x4024000000000000, %rax # imm = 0x4024000000000000
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
movq %r14, %rdi
callq 0x92a2
xorps %xmm0, %xmm0
movhps 0x1966(%rip), %xmm0     # xmm0 = xmm0[0,1],mem[0,1]
movups %xmm0, 0x48(%r14)
movq $0x0, 0x58(%r14)
movb $0x0, 0x60(%r14)
movq %fs:0x0, %rax
leaq -0x10(%rax), %rsi
movq %r14, %rdi
movq %r14, %rdx
callq 0x946c
testl %eax, %eax
jle 0x1277c
imull %ebx, %eax
testl %eax, %eax
jle 0x1277c
movl %eax, %eax
imulq $0x10624dd3, %rax, %rcx # imm = 0x10624DD3
shrq $0x26, %rcx
imulq $-0x3e8, %rcx, %rdx     # imm = 0xFC18
addq %rax, %rdx
imulq $0xf4240, %rdx, %rax    # imm = 0xF4240
movq %rsp, %rbx
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x5100
cmpl $-0x1, %eax
jne 0x1277c
callq 0x5040
cmpl $0x4, (%rax)
je 0x12762
addq $0x78, %rsp
popq %rbx
popq %r14
retq
callq 0x58d9
jmp 0x126de
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]total-order-multicast/src/udp_conn.cc
// Function: udp::Server::Server(unsigned short, std::chrono::duration<long, std::ratio<1l, 1000000l>>)
Server::Server(unsigned short port, std::chrono::microseconds timeout)
    : sockfd_(CreateSocket(timeout)) {
  // Create a socket and associate the it with the port
  struct sockaddr_in server_address = {};
  server_address.sin_family = AF_INET;
  server_address.sin_addr.s_addr = htonl(INADDR_ANY);
  server_address.sin_port = htons(port);

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x12148
movl %eax, (%r14)
leaq 0x8(%rsp), %rsi
movq $0x0, 0x8(%rsi)
movw $0x2, (%rsi)
movl $0x0, 0x4(%rsi)
rolw $0x8, %bx
movw %bx, 0x2(%rsi)
movl %eax, %edi
movl $0x10, %edx
callq 0x5070
testl %eax, %eax
js 0x127de
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl $0x180, %edi            # imm = 0x180
callq 0x51a0
movq %rax, %rbx
movq %rax, %rdi
callq 0x12bb8
leaq 0x9446(%rip), %rsi      # 0x1bc40
leaq 0x429(%rip), %rdx       # 0x12c2a
movq %rbx, %rdi
callq 0x5610
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]total-order-multicast/src/message.cc
// Function: msg::operator<<(std::ostream&, msg::DataMessage const&)
std::ostream& operator<<(std::ostream& o, const DataMessage& data_msg) {
  o << "{type: " << data_msg.type;
  o << ", sender: " << data_msg.sender;
  o << ", msg_id: " << data_msg.msg_id;
  o << ", data: " << data_msg.data;
  o << "}";
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x229a(%rip), %rsi      # 0x15237
movl $0x7, %edx
callq 0x53f0
movl (%r14), %esi
movq %rbx, %rdi
callq 0x5240
leaq 0x2286(%rip), %rsi      # 0x1523f
movl $0xa, %edx
movq %rbx, %rdi
callq 0x53f0
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0x5240
leaq 0x2271(%rip), %rsi      # 0x1524a
movl $0xa, %edx
movq %rbx, %rdi
callq 0x53f0
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x5240
leaq 0x225c(%rip), %rsi      # 0x15255
movl $0x8, %edx
movq %rbx, %rdi
callq 0x53f0
movl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0x5240
leaq 0x1c42(%rip), %rsi      # 0x14c5b
movl $0x1, %edx
movq %rbx, %rdi
callq 0x53f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/nvanbenschoten[P]total-order-multicast/src/message.cc
// Function: msg::operator<<(std::ostream&, msg::AckMessage const&)
std::ostream& operator<<(std::ostream& o, const AckMessage& ack_msg) {
  o << "{type: " << ack_msg.type;
  o << ", sender: " << ack_msg.sender;
  o << ", msg_id: " << ack_msg.msg_id;
  o << ", proposed_seq: " << ack_msg.proposed_seq;
  o << ", proposer: " << ack_msg.proposer;
  o << "}";
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x21f5(%rip), %rsi      # 0x15237
movl $0x7, %edx
callq 0x53f0
movl (%r14), %esi
movq %rbx, %rdi
callq 0x5240
leaq 0x21e1(%rip), %rsi      # 0x1523f
movl $0xa, %edx
movq %rbx, %rdi
callq 0x53f0
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0x5240
leaq 0x21cc(%rip), %rsi      # 0x1524a
movl $0xa, %edx
movq %rbx, %rdi
callq 0x53f0
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x5240
leaq 0x21c0(%rip), %rsi      # 0x1525e
movl $0x10, %edx
movq %rbx, %rdi
callq 0x53f0
movl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0x5240
leaq 0x21b1(%rip), %rsi      # 0x1526f
movl $0xc, %edx
movq %rbx, %rdi
callq 0x53f0
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0x5240
leaq 0x1b7d(%rip), %rsi      # 0x14c5b
movl $0x1, %edx
movq %rbx, %rdi
callq 0x53f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq