LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nvanbenschoten[P]byzantine-agreement/src/message.cc
// Function: msg::operator<<(std::ostream&, msg::Message const&)
std::ostream& operator<<(std::ostream& o, const Message& m) {
  o << "{round: " << m.round << ", order: " << OrderString(m.order)
    << ", ids: <";
  for (size_t i = 0; i < m.ids.size(); ++i) {
    if (i > 0) o << ' ';
    o << m.ids[i];
  }
  o << ">}";
  return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x123de(%rip), %rsi     # 0x37389
callq 0x63e0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x65b0
movq %rax, %rdi
leaq 0x123ca(%rip), %rsi     # 0x37392
callq 0x63e0
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x24d80
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x63b0
movq %rax, -0x50(%rbp)
jmp 0x24ff8
movq -0x50(%rbp), %rdi
leaq 0x12399(%rip), %rsi     # 0x3739c
callq 0x63e0
jmp 0x2500a
leaq -0x30(%rbp), %rdi
callq 0x6878
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x25170
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x2509f
cmpq $0x0, -0x48(%rbp)
jbe 0x2506a
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x64e0
jmp 0x2506a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6878
jmp 0x250b9
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x48(%rbp), %rsi
callq 0x25190
movq -0x70(%rbp), %rdi
movl (%rax), %esi
callq 0x65b0
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x2501b
movq -0x8(%rbp), %rdi
leaq 0x122fb(%rip), %rsi     # 0x373a5
callq 0x63e0
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nvanbenschoten[P]byzantine-agreement/src/general.cc
// Function: generals::ByzantineMsgFromBuf(char*, unsigned long)
std::experimental::optional<msg::Message> ByzantineMsgFromBuf(char* buf,
                                                              size_t n) {
  // Check to make sure the size of the buffer is correct.
  if (n < sizeof(msg::ByzantineMessage)) {
    return {};
  }

  // Copy out the message part.
  msg::Message msg;
  msg::ByzantineMessage* c_msg = reinterpret_cast<msg::ByzantineMessage*>(buf);
  msg.round = ntohl(c_msg->round);
  msg.order = static_cast<msg::Order>(ntohl(c_msg->order));

  msg.ids.resize((n - sizeof(*c_msg)) / sizeof(uint32_t));
  uint32_t* id_buf = reinterpret_cast<uint32_t*>(buf + sizeof(*c_msg));
  for (size_t i = 0; i < msg.ids.size(); ++i) {
    msg.ids[i] = ntohl(id_buf[i]);
  }

  return msg;
}

// 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, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x10, -0x18(%rbp)
jae 0x25857
movq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x6270
movq -0x70(%rbp), %rdi
callq 0x28e90
jmp 0x25938
leaq -0x38(%rbp), %rdi
callq 0x28eb0
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x6540
movl %eax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x6540
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $-0x10, %rsi
shrq $0x2, %rsi
callq 0x28ed0
jmp 0x2589d
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x25170
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x25920
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x6540
movl %eax, -0x7c(%rbp)
leaq -0x38(%rbp), %rdi
addq $0x8, %rdi
movq -0x60(%rbp), %rsi
callq 0x28f60
movl -0x7c(%rbp), %ecx
movl %ecx, (%rax)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x258b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28fb0
jmp 0x25945
movq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x28f80
jmp 0x2592f
leaq -0x38(%rbp), %rdi
callq 0x28fb0
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x6750
nop
// File: nvanbenschoten[P]byzantine-agreement/src/general.cc
// Function: generals::RoundOfAck(char*, unsigned long)
std::experimental::optional<unsigned int> RoundOfAck(char* buf, size_t n) {
  // Check to make sure the size of the buffer is correct.
  if (n != sizeof(msg::Ack)) {
    return {};
  }

  msg::Ack* ack = reinterpret_cast<msg::Ack*>(buf);
  return ntohl(ack->round);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0xc, -0x18(%rbp)
je 0x25991
movq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x6270
movq -0x38(%rbp), %rdi
callq 0x28fd0
jmp 0x259b5
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x6540
movq -0x38(%rbp), %rdi
movl %eax, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x28ff0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: nvanbenschoten[P]byzantine-agreement/src/general.cc
// Function: generals::SendAckForRound(std::shared_ptr<udp::Client const>, unsigned int)
void SendAckForRound(udp::ClientPtr client, unsigned int round) {
  msg::Ack ack = {};
  ack.type = htonl(kAckType);
  ack.size = htonl(sizeof(ack));
  ack.round = htonl(round);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0xc, %edx
callq 0x6270
movl $0x2, %edi
callq 0x6320
movl %eax, -0x18(%rbp)
movl $0xc, %edi
callq 0x6320
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %edi
callq 0x6320
movq -0x28(%rbp), %rdi
movl %eax, -0x10(%rbp)
leaq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x29060
movq %rax, %rdi
movq -0x20(%rbp), %rsi
movl $0xc, %edx
callq 0x22b60
addq $0x30, %rsp
popq %rbp
retq
// File: nvanbenschoten[P]byzantine-agreement/src/general.cc
// Function: generals::StringToMaliciousBehavior(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
MaliciousBehavior StringToMaliciousBehavior(std::string str) {
  if (str == "silent") return MaliciousBehavior::SILENT;
  if (str == "delay_send") return MaliciousBehavior::DELAY_SEND;
  if (str == "partial_send") return MaliciousBehavior::PARTIAL_SEND;
  if (str == "wrong_order") return MaliciousBehavior::WRONG_ORDER;
  throw std::invalid_argument(
      "malicious behavior can one of {\"silent\", \"delay_send\", "
      "\"partial_send\", \"wrong_order\"}");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x117c9(%rip), %rsi     # 0x37660
callq 0x23360
testb $0x1, %al
jne 0x25ea2
jmp 0x25eae
movl $0x1, -0x4(%rbp)
jmp 0x25f5e
movq -0x28(%rbp), %rdi
leaq 0x117ae(%rip), %rsi     # 0x37667
callq 0x23360
testb $0x1, %al
jne 0x25ec4
jmp 0x25ed0
movl $0x2, -0x4(%rbp)
jmp 0x25f5e
movq -0x28(%rbp), %rdi
leaq 0x11797(%rip), %rsi     # 0x37672
callq 0x23360
testb $0x1, %al
jne 0x25ee6
jmp 0x25eef
movl $0x4, -0x4(%rbp)
jmp 0x25f5e
movq -0x28(%rbp), %rdi
leaq 0x11785(%rip), %rsi     # 0x3767f
callq 0x23360
testb $0x1, %al
jne 0x25f05
jmp 0x25f0e
movl $0x8, -0x4(%rbp)
jmp 0x25f5e
movl $0x10, %edi
callq 0x6240
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x11762(%rip), %rsi     # 0x3768b
callq 0x67f0
jmp 0x25f30
movq -0x30(%rbp), %rdi
movq 0x2d08d(%rip), %rsi     # 0x52fc8
movq 0x2d066(%rip), %rdx     # 0x52fa8
callq 0x6730
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x6300
jmp 0x25f67
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6750
// File: nvanbenschoten[P]byzantine-agreement/src/general.cc
// Function: generals::MaliciousBehaviorString[abi:cxx11](generals::MaliciousBehavior)
std::string MaliciousBehaviorString(MaliciousBehavior m) {
  switch (m) {
    case MaliciousBehavior::SILENT:
      return "silent";
    case MaliciousBehavior::DELAY_SEND:
      return "delay_send";
    case MaliciousBehavior::PARTIAL_SEND:
      return "partial_send";
    case MaliciousBehavior::WRONG_ORDER:
      return "wrong_order";
    default:
      throw std::invalid_argument("unexpected MaliciousBehavior value");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x7, %eax
ja 0x260d8
movq -0x28(%rbp), %rax
leaq 0x113ff(%rip), %rcx     # 0x373a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0xd(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x6760
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x11692(%rip), %rsi     # 0x37660
callq 0xc850
jmp 0x25fd5
leaq -0xd(%rbp), %rdi
callq 0x6460
jmp 0x26128
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xd(%rbp), %rdi
callq 0x6460
jmp 0x26132
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x6760
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x1164e(%rip), %rsi     # 0x37667
callq 0xc850
jmp 0x26020
leaq -0x1d(%rbp), %rdi
callq 0x6460
jmp 0x26128
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x6460
jmp 0x26132
leaq -0x1e(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x6760
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x1160e(%rip), %rsi     # 0x37672
callq 0xc850
jmp 0x2606b
leaq -0x1e(%rbp), %rdi
callq 0x6460
jmp 0x26128
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1e(%rbp), %rdi
callq 0x6460
jmp 0x26132
leaq -0x1f(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x6760
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x115d0(%rip), %rsi     # 0x3767f
callq 0xc850
jmp 0x260b6
leaq -0x1f(%rbp), %rdi
callq 0x6460
jmp 0x26128
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1f(%rbp), %rdi
callq 0x6460
jmp 0x26132
movl $0x10, %edi
callq 0x6240
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq 0x115ee(%rip), %rsi     # 0x376e1
callq 0x67f0
jmp 0x260fa
movq -0x60(%rbp), %rdi
movq 0x2cec3(%rip), %rsi     # 0x52fc8
movq 0x2ce9c(%rip), %rdx     # 0x52fa8
callq 0x6730
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x6300
jmp 0x26132
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6750
nopl (%rax,%rax)
// File: nvanbenschoten[P]byzantine-agreement/src/general.cc
// Function: generals::General::ShouldSendMsg()
bool General::ShouldSendMsg() {
  if (ExhibitsBehavior(MaliciousBehavior::SILENT)) {
    return false;
  }
  if (ExhibitsBehavior(MaliciousBehavior::PARTIAL_SEND)) {
    // Send message 75% of the time.
    static thread_local std::default_random_engine random_engine(
        std::chrono::system_clock::now().time_since_epoch().count());

    std::uniform_real_distribution<double> distribution(0.0, 1.0);
    return distribution(random_engine) < 0.75;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl $0x1, %esi
callq 0x291f0
testb $0x1, %al
jne 0x26164
jmp 0x2616d
movb $0x0, -0x1(%rbp)
jmp 0x2621a
movq -0x38(%rbp), %rdi
movl $0x4, %esi
callq 0x291f0
testb $0x1, %al
jne 0x26184
jmp 0x26216
movb %fs:-0x28, %al
cmpb $0x0, %al
jne 0x261d0
callq 0x6060
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x29220
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x29240
movq %rax, %rsi
movq %fs:0x0, %rax
leaq -0x30(%rax), %rdi
callq 0x29260
movb $0x1, %fs:-0x28
leaq -0x30(%rbp), %rdi
xorps %xmm0, %xmm0
movsd 0x113b9(%rip), %xmm1    # 0x37598
callq 0x29290
movq %fs:0x0, %rax
leaq -0x30(%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0x292c0
movaps %xmm0, %xmm1
movsd 0x11388(%rip), %xmm0    # 0x37590
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2621a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nvanbenschoten[P]byzantine-agreement/src/general.cc
// Function: generals::General::MaybeDelaySend()
void General::MaybeDelaySend() {
  if (!ExhibitsBehavior(MaliciousBehavior::DELAY_SEND)) {
    return;
  }

  // Here and above, 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());

  // 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;
  auto timeout_deci = std::chrono::duration_cast<deciseconds>(kRoundTimeout);
  std::poisson_distribution<int> poisson(timeout_deci.count() / 2);
  int delay = poisson(random_engine);
  if (delay <= 0) {
    return;
  }
  std::this_thread::sleep_for(deciseconds{delay});
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x291f0
testb $0x1, %al
jne 0x26256
jmp 0x26318
movb %fs:-0x18, %al
cmpb $0x0, %al
jne 0x262a2
callq 0x6060
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x29220
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x29240
movq %rax, %rsi
movq %fs:0x0, %rax
leaq -0x20(%rax), %rdi
callq 0x29260
movb $0x1, %fs:-0x18
movl 0x11378(%rip), %eax     # 0x37620
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x292f0
movl $0x2, %ecx
cltd
idivl %ecx
cvtsi2sd %eax, %xmm0
leaq -0x88(%rbp), %rdi
callq 0x29300
movq %fs:0x0, %rax
leaq -0x20(%rax), %rsi
leaq -0x88(%rbp), %rdi
callq 0x29340
movl %eax, -0x8c(%rbp)
cmpl $0x0, -0x8c(%rbp)
jg 0x262f9
jmp 0x26318
leaq -0x90(%rbp), %rdi
leaq -0x8c(%rbp), %rsi
callq 0x29420
leaq -0x90(%rbp), %rdi
callq 0x29370
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nvanbenschoten[P]byzantine-agreement/src/general.cc
// Function: generals::Commander::OrderForMsg() const
msg::Order Commander::OrderForMsg() const {
  if (ExhibitsBehavior(MaliciousBehavior::WRONG_ORDER)) {
    // Send wrong order 30% of the time.
    static thread_local std::default_random_engine random_engine(
        std::chrono::system_clock::now().time_since_epoch().count());

    std::uniform_real_distribution<double> distribution(0.0, 1.0);
    if (distribution(random_engine) < 0.30) {
      return order_ == msg::Order::ATTACK ? msg::Order::RETREAT
                                          : msg::Order::ATTACK;
    }
  }
  return order_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl $0x8, %esi
callq 0x291f0
testb $0x1, %al
jne 0x26657
jmp 0x266fc
movb %fs:-0x8, %al
cmpb $0x0, %al
jne 0x266a3
callq 0x6060
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x29220
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x29240
movq %rax, %rsi
movq %fs:0x0, %rax
leaq -0x10(%rax), %rdi
callq 0x29260
movb $0x1, %fs:-0x8
leaq -0x30(%rbp), %rdi
xorps %xmm0, %xmm0
movsd 0x10ee6(%rip), %xmm1    # 0x37598
callq 0x29290
movq %fs:0x0, %rax
leaq -0x10(%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0x292c0
movaps %xmm0, %xmm1
movsd 0x10ec5(%rip), %xmm0    # 0x375a0
ucomisd %xmm1, %xmm0
jbe 0x266fa
movq -0x38(%rbp), %rax
movl 0x68(%rax), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x1, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x26706
jmp 0x266fc
movq -0x38(%rbp), %rax
movl 0x68(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: nvanbenschoten[P]byzantine-agreement/src/general.cc
// Function: generals::Lieutenant::ContinueUnlessTimeout()
udp::ServerAction Lieutenant::ContinueUnlessTimeout() {
  // Compute the duration between the start of the round and now.
  const auto now = std::chrono::steady_clock::now();
  const auto round_dur = std::chrono::duration_cast<std::chrono::microseconds>(
      now - round_start_ts_);

  // If this duration is more than the round timeout, handle the timeout.
  if (round_dur > kRoundTimeout) {
    HandleRoundTimeout();
  }
  return udp::ServerAction::Continue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x65a0
movq -0x28(%rbp), %rsi
movq %rax, -0x10(%rbp)
addq $0xa0, %rsi
leaq -0x10(%rbp), %rdi
callq 0x299d0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x299a0
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
leaq 0x10a23(%rip), %rsi     # 0x37400
callq 0x29a20
testb $0x1, %al
jne 0x269e8
jmp 0x269f1
movq -0x28(%rbp), %rdi
callq 0x26a00
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: nvanbenschoten[P]byzantine-agreement/src/general.cc
// Function: generals::Lieutenant::HandleRoundTimeout()
udp::ServerAction Lieutenant::HandleRoundTimeout() {
  if (FirstRound()) {
    // We can't timeout in the first round. Just continue to wait.
    return udp::ServerAction::Continue;
  }

  logging::out << "Timeout in round " << round_ << "\n";
  return MoveToNewRoundOrStop();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x29a50
testb $0x1, %al
jne 0x26a1f
jmp 0x26a28
movl $0x0, -0x4(%rbp)
jmp 0x26a66
leaq 0x2cc41(%rip), %rdi     # 0x53670
leaq 0x10cde(%rip), %rsi     # 0x37714
callq 0x29a70
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x64, %rsi
callq 0x296e0
movq %rax, %rdi
leaq 0x100fd(%rip), %rsi     # 0x36b52
callq 0x29730
movq -0x18(%rbp), %rdi
callq 0x26a70
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: nvanbenschoten[P]byzantine-agreement/src/general.cc
// Function: generals::Lieutenant::MoveToNewRoundOrStop()
udp::ServerAction Lieutenant::MoveToNewRoundOrStop() {
  if (LastRound()) {
    ClearSenders();
    return udp::ServerAction::Stop;
  }
  InitNewRound();
  return udp::ServerAction::Continue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x29ac0
testb $0x1, %al
jne 0x26a8f
jmp 0x26aa1
movq -0x18(%rbp), %rdi
callq 0x26ac0
movl $0x1, -0x4(%rbp)
jmp 0x26ab1
movq -0x18(%rbp), %rdi
callq 0x26b00
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: bowenfan96[P]icl-mcs-enigma/main.cpp
// Function: main
int main(int argc, char** argv) 
{
    try {
        Enigma en(argc, argv);
        
        char input;
        while(std::cin >> std::ws >> input) {
            std::cout << en.encryptor(input) << std::flush;
        }
    }
    
    catch(int error) {
        return error;
    }
    
    return(NO_ERROR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x45b0
jmp 0x252b
jmp 0x252d
movq 0xfaa4(%rip), %rdi      # 0x11fd8
movq 0xfa75(%rip), %rsi      # 0x11fb0
callq 0x2070
movq %rax, -0x78(%rbp)
jmp 0x2546
movq -0x78(%rbp), %rdi
leaq -0x65(%rbp), %rsi
callq 0x2240
movq %rax, -0x80(%rbp)
jmp 0x2559
movq -0x80(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2230
movb %al, -0x81(%rbp)
jmp 0x2574
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x2583
jmp 0x261a
movsbl -0x65(%rbp), %esi
leaq -0x58(%rbp), %rdi
callq 0x4f50
movb %al, -0x82(%rbp)
jmp 0x2598
movb -0x82(%rbp), %al
movsbl %al, %esi
movq 0xfa10(%rip), %rdi      # 0x11fb8
callq 0x2220
movq %rax, -0x90(%rbp)
jmp 0x25b6
movq -0x90(%rbp), %rdi
movq 0xf9fc(%rip), %rsi      # 0x11fc0
callq 0x21f0
jmp 0x25cb
jmp 0x252d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x25f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x51c0
movl -0x64(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x2636
movq -0x60(%rbp), %rdi
callq 0x2090
movl (%rax), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x4(%rbp)
callq 0x22f0
jmp 0x262a
leaq -0x58(%rbp), %rdi
callq 0x51c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x2330
nop
// File: bowenfan96[P]icl-mcs-enigma/enigma.cpp
// Function: Enigma::is_numeric(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Enigma::is_numeric(const std::string& index)
{
    for(auto ch : index) {
        if(!isdigit(ch)) {
            return false;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x21c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2370
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5e30
testb $0x1, %al
jne 0x2ec1
jmp 0x2ef0
leaq -0x20(%rbp), %rdi
callq 0x5e70
movb (%rax), %al
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %edi
callq 0x21a0
cmpl $0x0, %eax
jne 0x2ee3
movb $0x0, -0x1(%rbp)
jmp 0x2ef4
jmp 0x2ee5
leaq -0x20(%rbp), %rdi
callq 0x5e90
jmp 0x2eae
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: bowenfan96[P]icl-mcs-enigma/enigma.cpp
// Function: Enigma::is_valid(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Enigma::is_valid(const std::string& index) 
{
    size_t sz;
    int num = std::stoi(index, &sz);
    if(num < 0 || num > 25) {
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0xa, %edx
callq 0x52f0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x2f2d
cmpl $0x19, -0x1c(%rbp)
jle 0x2f33
movb $0x0, -0x1(%rbp)
jmp 0x2f37
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bowenfan96[P]icl-mcs-enigma/enigma.cpp
// Function: Enigma::Plugboard::mapper(int)
int Enigma::Plugboard::mapper(int input) 
{
    auto iter = std::find(map_from.cbegin(), map_from.cend(), input);
    
    if(iter != map_from.cend()) {
        int index = std::distance(map_from.cbegin(), iter);
        return map_to.at(index);
    }
    else {
        return input;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x56b0
movq -0x58(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x56e0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x5660
movq -0x58(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x56e0
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5710
testb $0x1, %al
jne 0x3232
jmp 0x326f
movq -0x58(%rbp), %rdi
callq 0x56b0
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x5750
movq -0x58(%rbp), %rdi
movl %eax, -0x3c(%rbp)
addq $0x18, %rdi
movslq -0x3c(%rbp), %rsi
callq 0x5790
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3275
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: bowenfan96[P]icl-mcs-enigma/enigma.cpp
// Function: Enigma::Rotor::rotate()
void Enigma::Rotor::rotate() 
{
    position = (position + 1) % 26;
    
    if(std::find(triggers.cbegin(), triggers.cend(), position) != triggers.cend()) {
        triggered = true;
    }
    else {
        triggered = false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl 0xe8(%rdi), %eax
addl $0x1, %eax
movl $0x1a, %ecx
cltd
idivl %ecx
movl %edx, 0xe8(%rdi)
addq $0xd0, %rdi
callq 0x56b0
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0xd0, %rdi
callq 0x56e0
movq -0x30(%rbp), %rdx
movq %rax, -0x20(%rbp)
addq $0xe8, %rdx
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5660
movq -0x30(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0xd0, %rdi
callq 0x56e0
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5710
testb $0x1, %al
jne 0x3b72
jmp 0x3b7f
movq -0x30(%rbp), %rax
movb $0x1, 0xec(%rax)
jmp 0x3b8a
movq -0x30(%rbp), %rax
movb $0x0, 0xec(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: bowenfan96[P]icl-mcs-enigma/enigma.cpp
// Function: Enigma::Rotor::mapper(int)
int Enigma::Rotor::mapper(int input) 
{
    // adjust for offset of the rotor during input
    input = (input + position) % 26;
    
    input = map_rtl[input];
    
    // adjust for offset of the rotor during output
    input = (input - position) % 26;
    
    // account for rollover if input - position is negative
    if(input < 0) {
        input = input + 26;
    }
    
    return input;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl 0xe8(%rdi), %eax
movl $0x1a, %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
movslq -0xc(%rbp), %rsi
callq 0x57d0
movq -0x18(%rbp), %rcx
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
subl 0xe8(%rcx), %eax
movl $0x1a, %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x3bf0
movl -0xc(%rbp), %eax
addl $0x1a, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: bowenfan96[P]icl-mcs-enigma/enigma.cpp
// Function: Enigma::Rotor::rf_mapper(int)
int Enigma::Rotor::rf_mapper(int input) 
{
    // adjust for offset of the rotor during input
    input = (input + position) % 26;
    
    input = map_ltr[input];
    
    // adjust for offset of the rotor during output
    input = (input - position) % 26;
    
    // account for rollover if input - position is negative
    if(input < 0) {
        input = input + 26;
    }
    
    return input;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl 0xe8(%rdi), %eax
movl $0x1a, %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
addq $0x68, %rdi
movslq -0xc(%rbp), %rsi
callq 0x57d0
movq -0x18(%rbp), %rcx
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
subl 0xe8(%rcx), %eax
movl $0x1a, %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x3c64
movl -0xc(%rbp), %eax
addl $0x1a, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: bowenfan96[P]icl-mcs-enigma/enigma.cpp
// Function: Enigma::turn_rotors()
void Enigma::turn_rotors() 
{
    for(auto rot = vec_rotors.rbegin(); rot != vec_rotors.rend(); ++rot) {
        
        if(rot == vec_rotors.rbegin()) {
            rot->rotate();
        }
        else if ((rot-1)->triggered) {
            rot->rotate();
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
addq $0x8, %rsi
leaq -0x10(%rbp), %rdi
callq 0x5b80
movq -0x30(%rbp), %rsi
addq $0x8, %rsi
leaq -0x18(%rbp), %rdi
callq 0x5c00
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x5bd0
testb $0x1, %al
jne 0x5135
jmp 0x51b3
movq -0x30(%rbp), %rsi
addq $0x8, %rsi
leaq -0x20(%rbp), %rdi
callq 0x5b80
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5da0
testb $0x1, %al
jne 0x5159
jmp 0x516c
leaq -0x10(%rbp), %rdi
callq 0x5c50
movq %rax, %rdi
callq 0x3ae0
jmp 0x51a3
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x5de0
leaq -0x28(%rbp), %rdi
callq 0x5c50
testb $0x1, 0xec(%rax)
je 0x51a1
leaq -0x10(%rbp), %rdi
callq 0x5c50
movq %rax, %rdi
callq 0x3ae0
jmp 0x51a3
jmp 0x51a5
leaq -0x10(%rbp), %rdi
callq 0x5c90
jmp 0x5111
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: shreyas-gopalakrishna[P]Concurrent-Skip-list/main.cpp
// Function: show_usage()
void show_usage(){
	cout << "Usage: \n\n" ;
	cout << "./skiplist [--name] -i <max_number> -t <num_threads> --operation=<combined, separate> [--help] \n" ;
	cout << "--name                  Prints full name \n" ;
	cout << "-i <max_number>         Numbers from 1 to max_number are inserted into skip list, subset is chosen for get, delete, and range \n" ;
	cout << "-t <num_threads>        Max number of threads to use \n" ;
	cout << "--operation=<separate>  Performs multithreaded insert, delete, get and range operations one after the other \n" ;
	cout << "--operation=<combined>  Mixes up or combined get, insert, delete, range operations \n" ;
    cout << "--help                  Prints the usage of the program \n";
    cout << "\n[ Kindly use less input values since the output is displayed on console. Higher values provide an unreadable display ]\n"; 
    cout << "\n[ max_number must be between INT_MIN and INT_MAX and exclusive of INT_MIN and INT_MAX ]" << endl;
    cout << "[Output may be interleaved since multiple threads tend to print search value found together.] \n" << endl;

	exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x138cd(%rip), %rdi     # 0x16fc8
leaq 0xb9de(%rip), %rsi      # 0xf0e0
callq 0x3240
movq 0x138ba(%rip), %rdi     # 0x16fc8
leaq 0xb9d5(%rip), %rsi      # 0xf0ea
callq 0x3240
movq 0x138a7(%rip), %rdi     # 0x16fc8
leaq 0xba23(%rip), %rsi      # 0xf14b
callq 0x3240
movq 0x13894(%rip), %rdi     # 0x16fc8
leaq 0xba3b(%rip), %rsi      # 0xf176
callq 0x3240
movq 0x13881(%rip), %rdi     # 0x16fc8
leaq 0xbaa8(%rip), %rsi      # 0xf1f6
callq 0x3240
movq 0x1386e(%rip), %rdi     # 0x16fc8
leaq 0xbacc(%rip), %rsi      # 0xf22d
callq 0x3240
movq 0x1385b(%rip), %rdi     # 0x16fc8
leaq 0xbb27(%rip), %rsi      # 0xf29b
callq 0x3240
movq 0x13848(%rip), %rdi     # 0x16fc8
leaq 0xbb69(%rip), %rsi      # 0xf2f0
callq 0x3240
movq 0x13835(%rip), %rdi     # 0x16fc8
leaq 0xbb90(%rip), %rsi      # 0xf32a
callq 0x3240
movq 0x13822(%rip), %rdi     # 0x16fc8
leaq 0xbbf6(%rip), %rsi      # 0xf3a3
callq 0x3240
movq %rax, %rdi
movq 0x137ec(%rip), %rsi     # 0x16fa8
callq 0x3280
movq 0x13800(%rip), %rdi     # 0x16fc8
leaq 0xbc2d(%rip), %rsi      # 0xf3fc
callq 0x3240
movq %rax, %rdi
movq 0x137ca(%rip), %rsi     # 0x16fa8
callq 0x3280
movl $0x1, %edi
callq 0x32f0
nopl (%rax)
// File: shreyas-gopalakrishna[P]Concurrent-Skip-list/main.cpp
// Function: generate_input(int)
void generate_input(int max_number){
    // generating insert data
    for(int i = 1; i <= max_number; i++){
        numbers_insert.push_back(i);
    }

    // generating delete data
    for(size_t i = 0; i < numbers_insert.size(); i++){
        if( rand() % 4 == 0 ){
            numbers_delete.push_back(numbers_insert[i]);
        }
    }

    // generating search data
    for(size_t i = 0; i < numbers_insert.size(); i++){
        if( rand() % 4 == 0 ){
            numbers_get.push_back(numbers_insert[i]);
        }
    }

    // generating range data
    for(size_t i = 0; i < num_threads; i++){
        int a = (rand() % static_cast<int>(max_number + 1));
        int b = a + (rand() % static_cast<int>(max_number - a + 1));
        numbers_range.push_back(make_pair(a,b));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jg 0x3825
leaq 0x13aef(%rip), %rdi     # 0x17300
leaq -0x8(%rbp), %rsi
callq 0x5390
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3802
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x13ac4(%rip), %rdi     # 0x17300
callq 0x5400
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x388e
callq 0x3080
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x387e
movq -0x10(%rbp), %rsi
leaq 0x13a96(%rip), %rdi     # 0x17300
callq 0x5420
movq %rax, %rsi
leaq 0x13a9f(%rip), %rdi     # 0x17318
callq 0x5390
jmp 0x3880
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x382d
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x13a5b(%rip), %rdi     # 0x17300
callq 0x5400
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x38f7
callq 0x3080
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x38e7
movq -0x18(%rbp), %rsi
leaq 0x13a2d(%rip), %rdi     # 0x17300
callq 0x5420
movq %rax, %rsi
leaq 0x13a4e(%rip), %rdi     # 0x17330
callq 0x5390
jmp 0x38e9
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3896
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x13936(%rip), %rax     # 0x17240
jae 0x396b
callq 0x3080
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
cltd
idivl %ecx
movl %edx, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x44(%rbp)
callq 0x3080
movl -0x4(%rbp), %ecx
subl -0x24(%rbp), %ecx
addl $0x1, %ecx
cltd
idivl %ecx
movl -0x44(%rbp), %eax
addl %edx, %eax
movl %eax, -0x28(%rbp)
leaq -0x24(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5470
movq %rax, -0x30(%rbp)
leaq 0x139f4(%rip), %rdi     # 0x17348
leaq -0x30(%rbp), %rsi
callq 0x5440
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x38ff
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: shreyas-gopalakrishna[P]Concurrent-Skip-list/main.cpp
// Function: skiplist_search(unsigned long, unsigned long)
void skiplist_search(size_t start, size_t end){
    if(end >= numbers_get.size()) end = numbers_get.size();
    if(start == end) end++;
    for(size_t i = start; i < end; i++){
        string s = skiplist.search(numbers_get[i]);
        if(s.empty()) s = "Not Found";
        cout << "Searching for " << numbers_get[i] << " Search value: " << s << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x13761(%rip), %rdi     # 0x17330
callq 0x5400
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jb 0x3bf0
leaq 0x13749(%rip), %rdi     # 0x17330
callq 0x5400
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x3c06
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x3d0a
movq -0x18(%rbp), %rsi
leaq 0x13709(%rip), %rdi     # 0x17330
callq 0x5420
movl (%rax), %edx
leaq -0x38(%rbp), %rdi
leaq 0x136b7(%rip), %rsi     # 0x172f0
callq 0xb6d0
leaq -0x38(%rbp), %rdi
callq 0x33c0
testb $0x1, %al
jne 0x3c4d
jmp 0x3c7b
leaq 0xb808(%rip), %rsi      # 0xf45c
leaq -0x38(%rbp), %rdi
callq 0x3330
jmp 0x3c5f
jmp 0x3c7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3170
jmp 0x3d10
movq 0x13346(%rip), %rdi     # 0x16fc8
leaq 0xb7dd(%rip), %rsi      # 0xf466
callq 0x3240
movq %rax, -0x58(%rbp)
jmp 0x3c94
movq -0x18(%rbp), %rsi
leaq 0x13691(%rip), %rdi     # 0x17330
callq 0x5420
movq -0x58(%rbp), %rdi
movl (%rax), %esi
callq 0x33e0
movq %rax, -0x60(%rbp)
jmp 0x3cb5
movq -0x60(%rbp), %rdi
leaq 0xb7b5(%rip), %rsi      # 0xf475
callq 0x3240
movq %rax, -0x68(%rbp)
jmp 0x3ccb
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3220
movq %rax, -0x70(%rbp)
jmp 0x3cde
movq -0x70(%rbp), %rdi
movq 0x132bf(%rip), %rsi     # 0x16fa8
callq 0x3280
jmp 0x3cf0
leaq -0x38(%rbp), %rdi
callq 0x3170
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3c0e
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x33f0
nopl (%rax)
// File: shreyas-gopalakrishna[P]Concurrent-Skip-list/main.cpp
// Function: skiplist_range(int, int)
void skiplist_range(int start, int end){
    map<int, string> range_output = skiplist.range(start, end);

    string s = "";
    for (auto const& x : range_output){
        s += x.second + " ";
    }
    cout << "Range (" << start << ", " << end << ") = " << s << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
leaq 0x135b2(%rip), %rsi     # 0x172f0
leaq -0x38(%rbp), %rdi
callq 0xc260
leaq -0x59(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3400
movq -0xb8(%rbp), %rdx
leaq 0xb384(%rip), %rsi      # 0xf0e9
leaq -0x58(%rbp), %rdi
callq 0x55c0
jmp 0x3d70
leaq -0x59(%rbp), %rdi
callq 0x32a0
leaq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x5670
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
callq 0x56a0
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x56d0
testb $0x1, %al
jne 0x3db7
jmp 0x3e58
leaq -0x80(%rbp), %rdi
callq 0x5700
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rsi
addq $0x8, %rsi
leaq 0xbaf0(%rip), %rdx      # 0xf8c9
leaq -0xb0(%rbp), %rdi
callq 0x5720
jmp 0x3de7
leaq -0x58(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x3320
jmp 0x3df9
leaq -0xb0(%rbp), %rdi
callq 0x3170
leaq -0x80(%rbp), %rdi
callq 0x57a0
jmp 0x3d9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x32a0
jmp 0x3f2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x3f25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3170
jmp 0x3f25
movq 0x13169(%rip), %rdi     # 0x16fc8
leaq 0xb61f(%rip), %rsi      # 0xf485
callq 0x3240
movq %rax, -0xc0(%rbp)
jmp 0x3e74
movq -0xc0(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x33e0
movq %rax, -0xc8(%rbp)
jmp 0x3e8c
movq -0xc8(%rbp), %rdi
leaq 0xb5f3(%rip), %rsi      # 0xf48d
callq 0x3240
movq %rax, -0xd0(%rbp)
jmp 0x3ea8
movq -0xd0(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x33e0
movq %rax, -0xd8(%rbp)
jmp 0x3ec0
movq -0xd8(%rbp), %rdi
leaq 0xb5c2(%rip), %rsi      # 0xf490
callq 0x3240
movq %rax, -0xe0(%rbp)
jmp 0x3edc
movq -0xe0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3220
movq %rax, -0xe8(%rbp)
jmp 0x3ef5
movq -0xe8(%rbp), %rdi
movq 0x130a5(%rip), %rsi     # 0x16fa8
callq 0x3280
jmp 0x3f0a
leaq -0x58(%rbp), %rdi
callq 0x3170
leaq -0x38(%rbp), %rdi
callq 0x57d0
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x3170
leaq -0x38(%rbp), %rdi
callq 0x57d0
movq -0x68(%rbp), %rdi
callq 0x33f0
// File: DuoLife-QNL[P]lexical_analysis/token.cpp
// Function: id::display(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void id::display(string s){
    if(argc == 3){
        outfile << left << setw(30) << "Identifier" << left << setw(30) << s << endl;
    }else{
        cout << left << setw(30) << "Identifier" << left << setw(30) << s << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x8a39(%rip), %rax      # 0xe234
cmpl $0x3, (%rax)
jne 0x588f
leaq 0x8a35(%rip), %rdi      # 0xe240
leaq -0x23a2(%rip), %rsi     # 0x3470
callq 0x20b0
movq %rax, -0x38(%rbp)
movl $0x1e, %edi
callq 0x34a0
movq -0x38(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0x2280
movq %rax, %rdi
leaq 0x3806(%rip), %rsi      # 0x9044
callq 0x21d0
movq %rax, %rdi
leaq -0x23dd(%rip), %rsi     # 0x3470
callq 0x20b0
movq %rax, -0x30(%rbp)
movl $0x1e, %edi
callq 0x34a0
movq -0x30(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0x2280
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movq 0x8723(%rip), %rsi      # 0xdfa8
callq 0x2220
jmp 0x5915
movq 0x8732(%rip), %rdi      # 0xdfc8
leaq -0x242d(%rip), %rsi     # 0x3470
callq 0x20b0
movq %rax, -0x48(%rbp)
movl $0x1e, %edi
callq 0x34a0
movq -0x48(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0x2280
movq %rax, %rdi
leaq 0x377b(%rip), %rsi      # 0x9044
callq 0x21d0
movq %rax, %rdi
leaq -0x2468(%rip), %rsi     # 0x3470
callq 0x20b0
movq %rax, -0x40(%rbp)
movl $0x1e, %edi
callq 0x34a0
movq -0x40(%rbp), %rdi
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
callq 0x2280
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movq 0x8698(%rip), %rsi      # 0xdfa8
callq 0x2220
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DuoLife-QNL[P]lexical_analysis/token.cpp
// Function: id::detected()
int id::detected(){
    string s(yytext);
    if(exit(s)){
        inc_id_cnt();
        display(s);
        return wordlist[s];
    }else{
        add_id(s);
        display(s);
        return id_id - 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq 0x8af7(%rip), %rax      # 0xe468
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x23b0
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x7230
jmp 0x59a4
leaq -0x31(%rbp), %rdi
callq 0x2250
leaq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x20f0
jmp 0x59bc
movq -0xe8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5920
movb %al, -0xe9(%rbp)
jmp 0x59d4
leaq -0x68(%rbp), %rdi
callq 0x2130
movb -0xe9(%rbp), %al
testb $0x1, %al
jne 0x59ec
jmp 0x5ac1
movq -0xe8(%rbp), %rdi
callq 0x5770
leaq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x20f0
jmp 0x5a0a
movq -0xe8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x57e0
jmp 0x5a1f
leaq -0x88(%rbp), %rdi
callq 0x2130
leaq 0x8a96(%rip), %rdi      # 0xe4c8
leaq -0x30(%rbp), %rsi
callq 0x70f0
movq %rax, -0xf8(%rbp)
jmp 0x5a44
movq -0xf8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x8c(%rbp)
jmp 0x5b73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x2250
jmp 0x5b91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5b88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2130
jmp 0x5b88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2130
jmp 0x5b88
leaq -0xb0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x20f0
jmp 0x5ad3
movq -0xe8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x57a0
jmp 0x5ae8
leaq -0xb0(%rbp), %rdi
callq 0x2130
leaq -0xd0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x20f0
jmp 0x5b06
movq -0xe8(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x57e0
jmp 0x5b1b
leaq -0xd0(%rbp), %rdi
callq 0x2130
movl 0x86e7(%rip), %eax      # 0xe214
subl $0x1, %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x8c(%rbp)
jmp 0x5b73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x2130
jmp 0x5b88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x2130
jmp 0x5b88
leaq -0x30(%rbp), %rdi
callq 0x2130
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x2130
movq -0x40(%rbp), %rdi
callq 0x23a0
nopw (%rax,%rax)
// File: DuoLife-QNL[P]lexical_analysis/token.cpp
// Function: num::display(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void num::display(string s){
    if (argc == 3){
    outfile << left << setw(30) << "Number" << left << setw(30) << s << endl;
    }else{
        cout << left << setw(30) << "Number" << left << setw(30) << s << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x83b9(%rip), %rax      # 0xe234
cmpl $0x3, (%rax)
jne 0x5f0f
leaq 0x83b5(%rip), %rdi      # 0xe240
leaq -0x2a22(%rip), %rsi     # 0x3470
callq 0x20b0
movq %rax, -0x38(%rbp)
movl $0x1e, %edi
callq 0x34a0
movq -0x38(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0x2280
movq %rax, %rdi
leaq 0x3191(%rip), %rsi      # 0x904f
callq 0x21d0
movq %rax, %rdi
leaq -0x2a5d(%rip), %rsi     # 0x3470
callq 0x20b0
movq %rax, -0x30(%rbp)
movl $0x1e, %edi
callq 0x34a0
movq -0x30(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0x2280
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movq 0x80a3(%rip), %rsi      # 0xdfa8
callq 0x2220
jmp 0x5f95
movq 0x80b2(%rip), %rdi      # 0xdfc8
leaq -0x2aad(%rip), %rsi     # 0x3470
callq 0x20b0
movq %rax, -0x48(%rbp)
movl $0x1e, %edi
callq 0x34a0
movq -0x48(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0x2280
movq %rax, %rdi
leaq 0x3106(%rip), %rsi      # 0x904f
callq 0x21d0
movq %rax, %rdi
leaq -0x2ae8(%rip), %rsi     # 0x3470
callq 0x20b0
movq %rax, -0x40(%rbp)
movl $0x1e, %edi
callq 0x34a0
movq -0x40(%rbp), %rdi
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
callq 0x2280
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movq 0x8018(%rip), %rsi      # 0xdfa8
callq 0x2220
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DuoLife-QNL[P]lexical_analysis/token.cpp
// Function: num::detected()
double num::detected(){
    inc_num_cnt();
    string s(yytext);
    display(s);
    double value = stod(s);
    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x5e30
leaq 0x84a5(%rip), %rax      # 0xe468
movq (%rax), %rax
movq %rax, -0x78(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x23b0
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x7230
jmp 0x5fea
leaq -0x29(%rbp), %rdi
callq 0x2250
leaq -0x60(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x20f0
jmp 0x6002
movq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x5e60
jmp 0x6011
leaq -0x60(%rbp), %rdi
callq 0x2130
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x73d0
movsd %xmm0, -0x88(%rbp)
jmp 0x6031
movsd -0x88(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x90(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2130
movsd -0x90(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x2250
jmp 0x60a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x609f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2130
leaq -0x28(%rbp), %rdi
callq 0x2130
movq -0x38(%rbp), %rdi
callq 0x23a0
nopw %cs:(%rax,%rax)
// File: DuoLife-QNL[P]lexical_analysis/token.cpp
// Function: operators::display(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void operators::display(string s){
    if (argc == 3){
        outfile << left << setw(30) << "Operator" << left << setw(30) << s << endl;            
    }else{
        cout << left << setw(30) << "Operator" << left << setw(30) << s << endl;    
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x8129(%rip), %rax      # 0xe234
cmpl $0x3, (%rax)
jne 0x619f
leaq 0x8125(%rip), %rdi      # 0xe240
leaq -0x2cb2(%rip), %rsi     # 0x3470
callq 0x20b0
movq %rax, -0x38(%rbp)
movl $0x1e, %edi
callq 0x34a0
movq -0x38(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0x2280
movq %rax, %rdi
leaq 0x2f08(%rip), %rsi      # 0x9056
callq 0x21d0
movq %rax, %rdi
leaq -0x2ced(%rip), %rsi     # 0x3470
callq 0x20b0
movq %rax, -0x30(%rbp)
movl $0x1e, %edi
callq 0x34a0
movq -0x30(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0x2280
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movq 0x7e13(%rip), %rsi      # 0xdfa8
callq 0x2220
jmp 0x6225
movq 0x7e22(%rip), %rdi      # 0xdfc8
leaq -0x2d3d(%rip), %rsi     # 0x3470
callq 0x20b0
movq %rax, -0x48(%rbp)
movl $0x1e, %edi
callq 0x34a0
movq -0x48(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0x2280
movq %rax, %rdi
leaq 0x2e7d(%rip), %rsi      # 0x9056
callq 0x21d0
movq %rax, %rdi
leaq -0x2d78(%rip), %rsi     # 0x3470
callq 0x20b0
movq %rax, -0x40(%rbp)
movl $0x1e, %edi
callq 0x34a0
movq -0x40(%rbp), %rdi
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
callq 0x2280
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movq 0x7d88(%rip), %rsi      # 0xdfa8
callq 0x2220
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)