LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nvanbenschoten[P]total-order-multicast/include/args.h
// Function: args::Group::Reset()
virtual void Reset() noexcept override {
    for (auto &child : children) {
      child->Reset();
    }
#ifdef ARGS_NOEXCEPT
    error = Error::None;
#endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x206e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20710
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x20740
testb $0x1, %al
jne 0x1f875
jmp 0x1f89a
leaq -0x18(%rbp), %rdi
callq 0x20780
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq -0x18(%rbp), %rdi
callq 0x207a0
jmp 0x1f862
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x209f0
leaq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20a10
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20a30
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x208a8
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
testb $0x1, (%rax)
je 0x20898
movq -0x70(%rbp), %rdi
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x20a70
movb %dl, -0x79(%rbp)
movq %rax, -0x78(%rbp)
jmp 0x20871
movb -0x79(%rbp), %al
movq -0x78(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
jmp 0x20898
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x209d0
jmp 0x208c8
jmp 0x2089a
movq -0x30(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x30(%rbp)
jmp 0x2083d
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x208bb
movq -0x70(%rbp), %rdi
callq 0x209d0
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x21dc0
leaq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20a10
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20a30
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x20999
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
testb $0x1, (%rax)
jne 0x20989
movq -0x70(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x8, %rsi
callq 0x21de0
movb %dl, -0x79(%rbp)
movq %rax, -0x78(%rbp)
jmp 0x20962
movb -0x79(%rbp), %al
movq -0x78(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
jmp 0x20989
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x21e20
jmp 0x209b9
jmp 0x2098b
movq -0x30(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x30(%rbp)
jmp 0x2092d
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x209ac
movq -0x70(%rbp), %rdi
callq 0x21e20
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23870
cmpq $0x0, %rax
je 0x23680
movl $0x10, %edi
callq 0x6230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x25c30
jmp 0x23652
movq -0x28(%rbp), %rdi
leaq 0x2200b(%rip), %rsi     # 0x45668
leaq -0x8a04(%rip), %rdx     # 0x1ac60
callq 0x6770
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x6300
jmp 0x23688
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0x23a30
cmpq $0x0, %rax
je 0x23771
movb $0x1, -0x45(%rbp)
movl $0x10, %edi
callq 0x6230
movq %rax, -0x60(%rbp)
movsbl -0x9(%rbp), %eax
movl %eax, -0x54(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x67b0
movl -0x54(%rbp), %edx
movq -0x50(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x1b420
jmp 0x23706
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x25c30
jmp 0x23715
movq -0x60(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x21f44(%rip), %rsi     # 0x45668
leaq -0x8acb(%rip), %rdx     # 0x1ac60
callq 0x6770
jmp 0x23782
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x23755
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x68c8
leaq -0x31(%rbp), %rdi
callq 0x6490
testb $0x1, -0x45(%rbp)
jne 0x23766
jmp 0x2376f
movq -0x60(%rbp), %rdi
callq 0x6300
jmp 0x23779
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
addq $0x58, %rdi
movq -0x18(%rbp), %rsi
callq 0x250d0
testb $0x1, %al
jne 0x238a4
jmp 0x23a09
movq -0x1d0(%rbp), %rax
testb $0x1, 0x51(%rax)
je 0x239f8
movq -0x1d0(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x239f8
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1e0(%rbp)
callq 0x65e0
movq -0x1e0(%rbp), %rdi
leaq 0xc432(%rip), %rsi      # 0x2fd19
callq 0x6410
movq %rax, -0x1d8(%rbp)
jmp 0x238f5
movq -0x1d8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x63d0
movq %rax, -0x1e8(%rbp)
jmp 0x2390e
movq -0x1e8(%rbp), %rdi
leaq 0xc404(%rip), %rsi      # 0x2fd20
callq 0x6410
jmp 0x23923
movb $0x1, -0x1c1(%rbp)
movl $0x10, %edi
callq 0x6230
movq %rax, -0x1f0(%rbp)
leaq -0x1c0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x6440
jmp 0x23950
movq -0x1f0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x25120
jmp 0x23965
movq -0x1f0(%rbp), %rdi
movb $0x0, -0x1c1(%rbp)
leaq 0x22056(%rip), %rsi     # 0x459d0
leaq 0x17df(%rip), %rdx      # 0x25160
callq 0x6770
jmp 0x23a2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x239ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x239d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x68c8
testb $0x1, -0x1c1(%rbp)
jne 0x239dc
jmp 0x239e8
movq -0x1f0(%rbp), %rdi
callq 0x6300
jmp 0x239ea
leaq -0x190(%rbp), %rdi
callq 0x60f0
jmp 0x23a1e
movq -0x1d0(%rbp), %rax
movb $0x1, 0x8(%rax)
movq %rax, -0x8(%rbp)
jmp 0x23a11
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0x67a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movb $0x0, -0x31(%rbp)
callq 0x205a0
movq -0x70(%rbp), %rsi
movq (%rsi), %rax
movq 0x28(%rax), %rax
leaq -0x58(%rbp), %rdi
callq *%rax
jmp 0x23df2
movq -0x80(%rbp), %rdi
callq 0x23e90
movq %rax, %rdi
leaq -0x58(%rbp), %rsi
movq %rsi, -0x90(%rbp)
callq 0x6520
movq -0x90(%rbp), %rdi
callq 0x68c8
movq -0x70(%rbp), %rax
movq -0x80(%rbp), %rdi
addq $0x10, %rax
movq %rax, -0x88(%rbp)
callq 0x205d0
movq -0x88(%rbp), %rsi
movq %rax, %rdi
callq 0x6040
jmp 0x23e43
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x23e6f
jmp 0x23e66
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x1c860
jmp 0x23e7c
movq -0x80(%rbp), %rdi
callq 0x1c860
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
nop
// File: nvanbenschoten[P]total-order-multicast/include/args.h
// Function: args::FlagBase* args::Group::Match<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
FlagBase *Match(const T &flag) {
    for (Base *child : children) {
      if (FlagBase *flagBase = dynamic_cast<FlagBase *>(child)) {
        if (FlagBase *match = flagBase->Match(flag)) {
          return match;
        }
      } else if (Group *group = dynamic_cast<Group *>(child)) {
        if (FlagBase *match = group->Match(flag)) {
          return match;
        }
      }
    }
    return nullptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x206e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20710
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x20740
testb $0x1, %al
jne 0x277ef
jmp 0x278e9
leaq -0x28(%rbp), %rdi
callq 0x20780
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x2782e
movq -0x60(%rbp), %rdi
leaq 0x1de68(%rip), %rsi     # 0x45680
leaq 0x1de89(%rip), %rdx     # 0x456a8
xorl %eax, %eax
movl %eax, %ecx
callq 0x64d0
movq %rax, -0x68(%rbp)
jmp 0x27836
xorl %eax, %eax
movq %rax, -0x68(%rbp)
jmp 0x27836
movq -0x68(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x2786d
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x30(%rax)
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x2786b
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x278f1
jmp 0x278d9
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x2789c
movq -0x70(%rbp), %rdi
leaq 0x1ddfa(%rip), %rsi     # 0x45680
leaq 0x1de33(%rip), %rdx     # 0x456c0
xorl %eax, %eax
movl %eax, %ecx
callq 0x64d0
movq %rax, -0x78(%rbp)
jmp 0x278a4
xorl %eax, %eax
movq %rax, -0x78(%rbp)
jmp 0x278a4
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x278d7
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x277a0
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x278d5
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x278f1
jmp 0x278d7
jmp 0x278d9
jmp 0x278db
leaq -0x28(%rbp), %rdi
callq 0x207a0
jmp 0x277d9
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nop
// File: nvanbenschoten[P]total-order-multicast/include/args.h
// Function: args::Group::GetNextPositional()
PositionalBase *GetNextPositional() {
    for (Base *child : children) {
      auto next = dynamic_cast<PositionalBase *>(child);
      auto group = dynamic_cast<Group *>(child);
      if (group) {
        next = group->GetNextPositional();
      }
      if (next && next->Ready()) {
        return next;
      }
    }
    return nullptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x206e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20710
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x20740
testb $0x1, %al
jne 0x27bf8
jmp 0x27cca
leaq -0x20(%rbp), %rdi
callq 0x20780
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x27c37
movq -0x48(%rbp), %rdi
leaq 0x1da5f(%rip), %rsi     # 0x45680
leaq 0x1dab0(%rip), %rdx     # 0x456d8
xorl %eax, %eax
movl %eax, %ecx
callq 0x64d0
movq %rax, -0x50(%rbp)
jmp 0x27c3f
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x27c3f
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x27c76
movq -0x58(%rbp), %rdi
leaq 0x1da20(%rip), %rsi     # 0x45680
leaq 0x1da59(%rip), %rdx     # 0x456c0
xorl %eax, %eax
movl %eax, %ecx
callq 0x64d0
movq %rax, -0x60(%rbp)
jmp 0x27c7e
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0x27c7e
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x27c9a
movq -0x40(%rbp), %rdi
callq 0x27bb0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x27cba
movq -0x38(%rbp), %rdi
callq 0x27f80
testb $0x1, %al
jne 0x27cb0
jmp 0x27cba
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x27cd2
jmp 0x27cbc
leaq -0x20(%rbp), %rdi
callq 0x207a0
jmp 0x27be2
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x390, %rsp            # imm = 0x390
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x1a0(%rbp), %rdi
movq %rdi, -0x358(%rbp)
movl $0x8, %edx
callq 0x6730
movq -0x358(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x62a0
jmp 0x2b569
leaq -0x1a0(%rbp), %rdi
callq 0x6150
movq %rax, -0x360(%rbp)
jmp 0x2b57e
movq -0x360(%rbp), %rdi
callq 0x67f0
movq %rax, -0x368(%rbp)
jmp 0x2b593
movq -0x368(%rbp), %rax
cmpq $0x0, %rax
jle 0x2b71d
leaq -0x328(%rbp), %rdi
callq 0x65e0
jmp 0x2b5b2
leaq 0x4921(%rip), %rsi      # 0x2feda
leaq -0x328(%rbp), %rdi
callq 0x6410
movq %rax, -0x370(%rbp)
jmp 0x2b5ce
movq -0x370(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x63d0
movq %rax, -0x378(%rbp)
jmp 0x2b5e7
movq -0x378(%rbp), %rdi
leaq 0x48f0(%rip), %rsi      # 0x2fee5
callq 0x6410
movq %rax, -0x380(%rbp)
jmp 0x2b603
movq -0x380(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x63d0
movq %rax, -0x388(%rbp)
jmp 0x2b61c
movq -0x388(%rbp), %rdi
leaq 0x483e(%rip), %rsi      # 0x2fe68
callq 0x6410
jmp 0x2b631
movb $0x1, -0x349(%rbp)
movl $0x10, %edi
callq 0x6230
movq %rax, -0x390(%rbp)
leaq -0x348(%rbp), %rdi
leaq -0x328(%rbp), %rsi
callq 0x6440
jmp 0x2b65e
movq -0x390(%rbp), %rdi
leaq -0x348(%rbp), %rsi
callq 0x27900
jmp 0x2b673
movq -0x390(%rbp), %rdi
movb $0x0, -0x349(%rbp)
leaq 0x1a330(%rip), %rsi     # 0x459b8
leaq -0x637f(%rip), %rdx     # 0x25310
callq 0x6770
jmp 0x2b74e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x2b736
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x2b70f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x2b6f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x348(%rbp), %rdi
callq 0x68c8
testb $0x1, -0x349(%rbp)
jne 0x2b701
jmp 0x2b70d
movq -0x390(%rbp), %rdi
callq 0x6300
jmp 0x2b70f
leaq -0x328(%rbp), %rdi
callq 0x60f0
jmp 0x2b736
leaq -0x1a0(%rbp), %rdi
callq 0x6220
movb $0x1, %al
andb $0x1, %al
addq $0x390, %rsp            # imm = 0x390
popq %rbp
retq
leaq -0x1a0(%rbp), %rdi
callq 0x6220
movq -0x1a8(%rbp), %rdi
callq 0x67a0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl $0x2, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x6100
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x2b90f
movl $0x180, %edi            # imm = 0x180
callq 0x6230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x2c670
jmp 0x2b8de
movq -0x48(%rbp), %rdi
leaq 0x1a2ef(%rip), %rsi     # 0x45bd8
leaq 0xe00(%rip), %rdx       # 0x2c6f0
callq 0x6770
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x6300
jmp 0x2ba43
movl $0x1, -0x20(%rbp)
movl -0xc(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x20(%rbp), %rcx
movl $0x4, %r8d
callq 0x67c0
cmpl $0x0, %eax
je 0x2b983
movl $0x180, %edi            # imm = 0x180
callq 0x6230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x2c670
jmp 0x2b952
movq -0x50(%rbp), %rdi
leaq 0x1a27b(%rip), %rsi     # 0x45bd8
leaq 0xd8c(%rip), %rdx       # 0x2c6f0
callq 0x6770
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x6300
jmp 0x2ba43
leaq -0x8(%rbp), %rdi
callq 0xd260
cmpq $0x0, %rax
jle 0x2ba3a
leaq -0x8(%rbp), %rdi
callq 0x2c710
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x14140
movq %rax, -0x38(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2c740
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xd260
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %edi
movl $0x1, %esi
movl $0x14, %edx
leaq -0x38(%rbp), %rcx
movl $0x10, %r8d
callq 0x67c0
cmpl $0x0, %eax
je 0x2ba38
movl $0x180, %edi            # imm = 0x180
callq 0x6230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x2c670
jmp 0x2ba0a
movq -0x58(%rbp), %rdi
leaq 0x1a1c3(%rip), %rsi     # 0x45bd8
leaq 0xcd4(%rip), %rdx       # 0x2c6f0
callq 0x6770
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x6300
jmp 0x2ba43
jmp 0x2ba3a
movl -0xc(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x67a0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, %rax
movq -0x60(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0xe2e0
movq %rax, %rdi
callq 0x61a0
movq %rax, %rdi
callq 0x64e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2bb30
movb $0x1, -0x45(%rbp)
movl $0x180, %edi            # imm = 0x180
callq 0x6230
movq -0x58(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0xe2e0
movq %rax, -0x68(%rbp)
jmp 0x2babc
movq -0x68(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x61c0
jmp 0x2bacb
movq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2c7b0
jmp 0x2bada
movq -0x70(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x1a107(%rip), %rsi     # 0x45bf0
leaq 0xd40(%rip), %rdx       # 0x2c830
callq 0x6770
jmp 0x2bb80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2bb1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x68c8
testb $0x1, -0x45(%rbp)
jne 0x2bb25
jmp 0x2bb2e
movq -0x70(%rbp), %rdi
callq 0x6300
jmp 0x2bb77
movq -0x50(%rbp), %rdi
movw $0x2, (%rdi)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rsi
addq $0x4, %rdi
movq -0x18(%rbp), %rax
movslq 0x14(%rax), %rdx
callq 0x66e0
movq -0x58(%rbp), %rdi
callq 0xe310
movzwl %ax, %edi
callq 0x6070
movw %ax, %cx
movq -0x50(%rbp), %rax
movw %cx, 0x2(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x67a0
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
movl $0x4, %esi
movl $0x2, %edx
callq 0x6600
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2bc7c
movb $0x1, -0x4d(%rbp)
movl $0x180, %edi            # imm = 0x180
callq 0x6230
movq %rax, -0x90(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x67b0
movq -0x88(%rbp), %rdx
leaq 0x4094(%rip), %rsi      # 0x2fc8b
leaq -0x38(%rbp), %rdi
callq 0xb990
jmp 0x2bc02
movq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2c7b0
jmp 0x2bc14
movq -0x90(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
leaq 0x19fca(%rip), %rsi     # 0x45bf0
leaq 0xc03(%rip), %rdx       # 0x2c830
callq 0x6770
jmp 0x2bd5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2bc5a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x68c8
leaq -0x39(%rbp), %rdi
callq 0x6490
testb $0x1, -0x4d(%rbp)
jne 0x2bc6b
jmp 0x2bc77
movq -0x90(%rbp), %rdi
callq 0x6300
jmp 0x2bd55
movb $0x0, -0x4e(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
leaq -0x4f(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x67b0
movq -0x80(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
callq 0xb990
jmp 0x2bcb7
leaq -0x4f(%rbp), %rdi
callq 0x6490
movq -0x80(%rbp), %rdi
leaq 0x4481(%rip), %rsi      # 0x3014c
callq 0x2c850
movb %al, -0xa1(%rbp)
jmp 0x2bcd8
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x2bce4
jmp 0x2bd35
leaq -0x70(%rbp), %rdi
callq 0x2dd30
jmp 0x2bcef
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x6520
leaq -0x70(%rbp), %rdi
callq 0x68c8
jmp 0x2bd35
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x4f(%rbp), %rdi
callq 0x6490
jmp 0x2bd55
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x68c8
jmp 0x2bd55
movb $0x1, -0x4e(%rbp)
testb $0x1, -0x4e(%rbp)
jne 0x2bd48
movq -0x80(%rbp), %rdi
callq 0x68c8
movq -0x78(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x67a0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
addq $0x10, %rsi
leaq -0x20(%rbp), %rdi
callq 0x2c880
movq -0x48(%rbp), %rdi
addq $0x3c, %rdi
callq 0x2c8b0
movq %rax, -0x40(%rbp)
jmp 0x2bdbc
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x3c, %rdi
callq 0x2c8c0
movl %eax, -0x4c(%rbp)
jmp 0x2bdd6
movq -0x48(%rbp), %rax
movl -0x4c(%rbp), %ecx
movl %ecx, -0x38(%rbp)
movl 0x38(%rax), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %r8
movl -0x38(%rbp), %r9d
xorl %ecx, %ecx
callq 0x6080
movq %rax, -0x58(%rbp)
jmp 0x2be00
movq -0x58(%rbp), %rax
cmpq $0x0, %rax
jge 0x2be63
movl $0x180, %edi            # imm = 0x180
callq 0x6230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x2c8d0
jmp 0x2be25
movq -0x60(%rbp), %rdi
leaq 0x19dd8(%rip), %rsi     # 0x45c08
leaq 0xb19(%rip), %rdx       # 0x2c950
callq 0x6770
jmp 0x2be84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2be72
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x6300
jmp 0x2be72
leaq -0x20(%rbp), %rdi
callq 0x2c970
addq $0x60, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x2c970
movq -0x30(%rbp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %fs:-0x8, %al
cmpb $0x0, %al
jne 0x2c17e
callq 0x6060
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xaff0
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb010
movq %rax, %rsi
movq %fs:0x0, %rax
leaq -0x10(%rax), %rdi
callq 0xb030
movb $0x1, %fs:-0x8
movl $0xa, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x2cb10
leaq -0x30(%rbp), %rdi
callq 0xd2c0
movq %rax, -0x28(%rbp)
cvtsi2sdq -0x28(%rbp), %xmm0
leaq -0xa0(%rbp), %rdi
callq 0xb0f0
movq %fs:0x0, %rax
leaq -0x10(%rax), %rsi
leaq -0xa0(%rbp), %rdi
callq 0xb130
movl %eax, -0xa4(%rbp)
cmpl $0x0, -0xa4(%rbp)
jg 0x2c1de
jmp 0x2c20d
movl -0xc(%rbp), %eax
imull -0xa4(%rbp), %eax
movl %eax, -0xa4(%rbp)
leaq -0xb0(%rbp), %rdi
leaq -0xa4(%rbp), %rsi
callq 0x2cb10
leaq -0xb0(%rbp), %rdi
callq 0x2cb30
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movw %si, %ax
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2b8a0
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, (%rax)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x6260
movw $0x2, -0x30(%rbp)
xorl %edi, %edi
callq 0x6330
movl %eax, -0x2c(%rbp)
movzwl -0x12(%rbp), %edi
callq 0x6070
movw %ax, %cx
movq -0x48(%rbp), %rax
movw %cx, -0x2e(%rbp)
movl (%rax), %edi
leaq -0x30(%rbp), %rsi
movl $0x10, %edx
callq 0x6090
cmpl $0x0, %eax
jge 0x2c2ea
movl $0x180, %edi            # imm = 0x180
callq 0x6230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x2cbe0
jmp 0x2c2bc
movq -0x50(%rbp), %rdi
leaq 0x19971(%rip), %rsi     # 0x45c38
leaq 0x992(%rip), %rdx       # 0x2cc60
callq 0x6770
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x6300
jmp 0x2c2f0
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x67a0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x27ed(%rip), %rsi      # 0x30258
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x65d0
movq -0x8(%rbp), %rdi
leaq 0x27d7(%rip), %rsi      # 0x30260
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x65d0
movq -0x8(%rbp), %rdi
leaq 0x27c3(%rip), %rsi      # 0x3026b
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x65d0
movq -0x8(%rbp), %rdi
leaq 0x27af(%rip), %rsi      # 0x30276
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x65d0
movq -0x8(%rbp), %rdi
leaq 0x2196(%rip), %rsi      # 0x2fc7c
callq 0x6410
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x273d(%rip), %rsi      # 0x30258
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x65d0
movq -0x8(%rbp), %rdi
leaq 0x2727(%rip), %rsi      # 0x30260
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x65d0
movq -0x8(%rbp), %rdi
leaq 0x2713(%rip), %rsi      # 0x3026b
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x65d0
movq -0x8(%rbp), %rdi
leaq 0x2708(%rip), %rsi      # 0x3027f
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x65d0
movq -0x8(%rbp), %rdi
leaq 0x26fa(%rip), %rsi      # 0x30290
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x65d0
movq -0x8(%rbp), %rdi
leaq 0x20c7(%rip), %rsi      # 0x2fc7c
callq 0x6410
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nvanbenschoten[P]total-order-multicast/src/message.cc
// Function: msg::operator<<(std::ostream&, msg::SeqMessage const&)
std::ostream& operator<<(std::ostream& o, const SeqMessage& seq_msg) {
  o << "{type: " << seq_msg.type;
  o << ", sender: " << seq_msg.sender;
  o << ", msg_id: " << seq_msg.msg_id;
  o << ", final_seq: " << seq_msg.final_seq;
  o << ", final_seq_proposer: " << seq_msg.final_seq_proposer;
  o << "}";
  return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x266d(%rip), %rsi      # 0x30258
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x65d0
movq -0x8(%rbp), %rdi
leaq 0x2657(%rip), %rsi      # 0x30260
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x65d0
movq -0x8(%rbp), %rdi
leaq 0x2643(%rip), %rsi      # 0x3026b
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x65d0
movq -0x8(%rbp), %rdi
leaq 0x2656(%rip), %rsi      # 0x3029d
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x65d0
movq -0x8(%rbp), %rdi
leaq 0x2645(%rip), %rsi      # 0x302ab
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x65d0
movq -0x8(%rbp), %rdi
leaq 0x1ff7(%rip), %rsi      # 0x2fc7c
callq 0x6410
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nvanbenschoten[P]total-order-multicast/src/message.cc
// Function: msg::operator<<(std::ostream&, msg::SeqAckMessage const&)
std::ostream& operator<<(std::ostream& o, const SeqAckMessage& seqack_msg) {
  o << "{type: " << seqack_msg.type;
  o << ", sender: " << seqack_msg.sender;
  o << ", msg_id: " << seqack_msg.msg_id;
  o << "}";
  return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x259d(%rip), %rsi      # 0x30258
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x65d0
movq -0x8(%rbp), %rdi
leaq 0x2587(%rip), %rsi      # 0x30260
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x65d0
movq -0x8(%rbp), %rdi
leaq 0x2573(%rip), %rsi      # 0x3026b
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x65d0
movq -0x8(%rbp), %rdi
leaq 0x1f65(%rip), %rsi      # 0x2fc7c
callq 0x6410
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nvanbenschoten[P]total-order-multicast/src/net.cc
// Function: net::AddressWithDefaultPort(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::experimental::fundamentals_v1::optional<unsigned short>)
Address AddressWithDefaultPort(
    std::string addr, std::experimental::optional<unsigned short> port) {
  size_t found = addr.find(":");
  if (found != std::string::npos) {
    port = std::stoi(addr.substr(found + 1));
    addr = addr.substr(0, found);
  } else if (!port) {
    throw std::invalid_argument(
        "port not specified in address and no default port provided");
  }
  return Address(addr, *port);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdx, -0xb8(%rbp)
movq %rsi, -0xb0(%rbp)
movq %rdi, %rax
movq -0xb0(%rbp), %rdi
movq %rax, -0xa8(%rbp)
movq %rax, %rcx
movq %rcx, -0xa0(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x244b(%rip), %rsi      # 0x302c2
xorl %eax, %eax
movl %eax, %edx
callq 0x68a0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x2df45
movq -0xb0(%rbp), %rsi
movq -0x20(%rbp), %rdx
incq %rdx
leaq -0x48(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
movq $-0x1, %rcx
callq 0x6450
movq -0xc8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x2e040
movl %eax, -0xbc(%rbp)
jmp 0x2ded1
movq -0xb8(%rbp), %rdi
movl -0xbc(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x2e080
jmp 0x2deec
leaq -0x48(%rbp), %rdi
callq 0x68c8
movq -0xb0(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq -0x78(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x6450
movq -0xb0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x6520
leaq -0x78(%rbp), %rdi
callq 0x68c8
jmp 0x2dfb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x68c8
jmp 0x2e02b
movq -0xb8(%rbp), %rdi
callq 0x2e0e0
testb $0x1, %al
jne 0x2dfae
movl $0x10, %edi
callq 0x6230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
leaq 0x2351(%rip), %rsi      # 0x302c4
callq 0x6840
jmp 0x2df7a
movq -0xd0(%rbp), %rdi
movq 0x18040(%rip), %rsi     # 0x45fc8
movq 0x18021(%rip), %rdx     # 0x45fb0
callq 0x6770
movq -0xd0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x6300
jmp 0x2e02b
jmp 0x2dfb0
movq -0xb0(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x61c0
movq -0xb8(%rbp), %rdi
callq 0x2e100
movq %rax, -0xd8(%rbp)
jmp 0x2dfd8
movq -0xa8(%rbp), %rdi
movq -0xd8(%rbp), %rax
movzwl (%rax), %edx
leaq -0x98(%rbp), %rsi
callq 0x2e120
jmp 0x2dff7
leaq -0x98(%rbp), %rdi
callq 0x68c8
movq -0xa0(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x68c8
movq -0x50(%rbp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
nop
// File: lemire[P]backward_multiplication/include/backwardmultiply.h
// Function: backwardmultiply::full_multiplication(unsigned long, unsigned long)
value128 full_multiplication(uint64_t value1, uint64_t value2) {
  value128 answer;
#ifdef _MSC_VER
  // todo: this might fail under visual studio for ARM
  answer.low = _umul128(value1, value2, &answer.high);
#else
  __uint128_t r = ((__uint128_t)value1) * value2;
  answer.low = r;
  answer.high = r >> 64;
#endif
  return answer;
}

// Assembly:
movq %rdi, -0x18(%rsp)
movq %rsi, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq -0x20(%rsp), %rcx
mulq %rcx
movq %rdx, -0x30(%rsp)
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x30(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rdx
retq
// File: lemire[P]backward_multiplication/include/backwardmultiply.h
// Function: backwardmultiply::multiplication(unsigned long, unsigned long const*, unsigned long, unsigned long*)
void multiplication(uint64_t w, const uint64_t *b, size_t n, uint64_t *output) {
  if ((w == 0) || (n == 0)) { // special case
    std::fill(output, output + n + 1, 0);
    return;
  }
  auto p = full_multiplication(w, b[0]);
  output[0] = p.low;
  uint64_t r = p.high;
  for (size_t i = 1; i < n; i++) {
    p = full_multiplication(w, b[i]);
    p.add(r);
    output[i] = p.low;
    r = p.high;
  }
  output[n] = r;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0x12e8
cmpq $0x0, 0x40(%rsp)
jne 0x1319
movq 0x38(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
addq $0x8, %rsi
movl $0x0, 0x34(%rsp)
leaq 0x34(%rsp), %rdx
callq 0x21e0
jmp 0x13e4
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rax
movq (%rax), %rsi
callq 0x1280
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x1, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0x13d1
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1280
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2210
movq 0x20(%rsp), %rdx
movq 0x38(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1355
movq 0x18(%rsp), %rdx
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x58, %rsp
retq
nopl (%rax)
// File: lemire[P]backward_multiplication/include/backwardmultiply.h
// Function: backwardmultiply::multiplication_backward(unsigned long, unsigned long const*, unsigned long, unsigned long*)
void multiplication_backward(uint64_t w, const uint64_t *b, size_t n,
                             uint64_t *output) {
  if ((w == 0) || (n == 0)) { // special case
    std::fill(output, output + n + 1, 0);
    return;
  }
  auto p = full_multiplication(w, b[n - 1]);
  output[n - 1] = p.low;
  output[n] = p.high;
  for (size_t i = n - 2; i != SIZE_MAX; i--) {
    p = full_multiplication(w, b[i]);
    output[i] = p.low;
    bool overflow = (output[i + 1] + p.high < output[i + 1]);
    output[i + 1] += p.high;
    for (size_t j = i + 2; overflow; j++) {
      output[j]++;
      overflow = (output[j] == 0);
    }
  }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
cmpq $0x0, 0x60(%rsp)
je 0x1418
cmpq $0x0, 0x50(%rsp)
jne 0x1449
movq 0x48(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
addq $0x8, %rsi
movl $0x0, 0x44(%rsp)
leaq 0x44(%rsp), %rdx
callq 0x21e0
jmp 0x15a9
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1280
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rdx
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x38(%rsp), %rdx
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x50(%rsp), %rax
subq $0x2, %rax
movq %rax, 0x28(%rsp)
cmpq $-0x1, 0x28(%rsp)
je 0x15a9
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1280
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rdx
movq 0x48(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x48(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rax
addq 0x38(%rsp), %rax
movq 0x48(%rsp), %rcx
movq 0x28(%rsp), %rdx
cmpq 0x8(%rcx,%rdx,8), %rax
setb %al
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x38(%rsp), %rdx
movq 0x48(%rsp), %rax
movq 0x28(%rsp), %rcx
addq 0x8(%rax,%rcx,8), %rdx
movq %rdx, 0x8(%rax,%rcx,8)
movq 0x28(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x17(%rsp)
je 0x1594
movq 0x48(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x48(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
sete %al
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x154f
jmp 0x1596
movq 0x28(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x14a7
addq $0x68, %rsp
retq
nop
// File: lemire[P]backward_multiplication/benchmarks/benchmark.cpp
// Function: rng(unsigned long)
static inline uint64_t rng(uint64_t h) {
  h ^= h >> 33;
  h *= UINT64_C(0xff51afd7ed558ccd);
  h ^= h >> 33;
  h *= UINT64_C(0xc4ceb9fe1a85ec53);
  h ^= h >> 33;
  return h;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x21, %rax
xorq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movabsq $-0xae502812aa7333, %rax # imm = 0xFF51AFD7ED558CCD
imulq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x21, %rax
xorq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movabsq $-0x3b314601e57a13ad, %rax # imm = 0xC4CEB9FE1A85EC53
imulq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x21, %rax
xorq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: t0mm4rx[P]piscine_cpp/day07/ex02/./Array.hpp
// Function: Array<int>::operator=(Array<int> const&)
const Array &operator=(const Array &target)
		{
			if (this->array != nullptr)
				delete [] this->array;
			this->array = new T[target.size()];
			this->n = target.size();
			for (unsigned int i = 0; i < target.size(); i++)
				this->array[i] = target.array[i];
			return (*this);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
je 0x1d6a
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1d68
movq -0x28(%rbp), %rdi
callq 0x10f0
jmp 0x1d6a
movq -0x10(%rbp), %rdi
callq 0x1a80
movl %eax, %eax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x1a80
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a80
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jae 0x1df6
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movl -0x14(%rbp), %edx
movl (%rcx,%rdx,4), %edx
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1db9
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: Baobaobear[P]sort/./sorttest.hpp
// Function: stdsort::sort_element_t_cmp(void const*, void const*)
int sort_element_t_cmp(const void *a, const void *b)
{
#if TEST_TYPE_SIMPLE
    return *(sort_element_t *)a - *(sort_element_t *)b;
#else
    if (*(sort_element_t *)a < *(sort_element_t *)b)
    {
        return -1;
    }
    if (*(sort_element_t *)b < *(sort_element_t *)a)
    {
        return 1;
    }
    return 0;
#endif
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x5a00
testb $0x1, %al
jne 0x24d1
jmp 0x24db
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x2501
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5a00
testb $0x1, %al
jne 0x24ef
jmp 0x24f9
movl $0x1, 0x14(%rsp)
jmp 0x2501
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)