LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Themaister[P]umusd/player.cpp
// Function: Player::next()
void Player::next()
{
   FF::MediaInfo old_info{};
   if (ff)
      old_info = ff->info();

   queue.next();
   play_media();

   auto &new_info = ff->info();

   // Attempt gapless
   if (old_info.channels != new_info.channels ||
         old_info.rate != new_info.rate ||
         old_info.fmt != new_info.fmt ||
         !ff ||
         !dev->active())
   {
      event->remove(*dev);
      play_audio();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movl $0x0, -0x78(%rbp)
movl $0x0, -0x74(%rbp)
movl $0x0, -0x70(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x6c(%rbp)
leaq -0x78(%rbp), %rdi
addq $0x10, %rdi
callq 0x5520
leaq -0x78(%rbp), %rdi
addq $0x30, %rdi
callq 0x5520
leaq -0x78(%rbp), %rdi
addq $0x50, %rdi
callq 0x5520
movq -0xc0(%rbp), %rdi
addq $0x30, %rdi
callq 0x8570
testb $0x1, %al
jne 0x1aa54
jmp 0x1aa9d
movq -0xc0(%rbp), %rdi
addq $0x30, %rdi
callq 0x8590
movq %rax, %rdi
callq 0x17960
movq %rax, -0xc8(%rbp)
jmp 0x1aa75
movq -0xc8(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x17b50
jmp 0x1aa87
jmp 0x1aa9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x1ac44
movq -0xc0(%rbp), %rdi
addq $0x40, %rdi
callq 0x1e3a0
jmp 0x1aaaf
leaq -0xa9(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x5370
movq -0xd0(%rbp), %rdx
leaq 0xc004(%rip), %rsi      # 0x26ad4
leaq -0xa8(%rbp), %rdi
callq 0x67d0
jmp 0x1aade
movq -0xc0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1a5d0
jmp 0x1aaf3
leaq -0xa8(%rbp), %rdi
callq 0x5670
leaq -0xa9(%rbp), %rdi
callq 0x5040
movq -0xc0(%rbp), %rdi
addq $0x30, %rdi
callq 0x8590
movq %rax, %rdi
callq 0x17960
movq %rax, -0xd8(%rbp)
jmp 0x1ab2c
movq -0xd8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movl -0x78(%rbp), %eax
movq -0xb8(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1abb0
movl -0x74(%rbp), %eax
movq -0xb8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x1abb0
movl -0x70(%rbp), %eax
movq -0xb8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x1abb0
movq -0xc0(%rbp), %rdi
addq $0x30, %rdi
callq 0x8570
testb $0x1, %al
jne 0x1ab7c
jmp 0x1abb0
movq -0xc0(%rbp), %rdi
addq $0x20, %rdi
callq 0x1b4f0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x48(%rax), %rax
callq *%rax
movb %al, -0xd9(%rbp)
jmp 0x1aba0
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x1ac32
jmp 0x1abb0
movq -0xc0(%rbp), %rdi
addq $0x18, %rdi
callq 0x1b510
movq -0xc0(%rbp), %rdi
movq %rax, -0xe8(%rbp)
addq $0x20, %rdi
callq 0x1b710
movq -0xe8(%rbp), %rdi
movq %rax, %rsi
callq 0x14c30
jmp 0x1abe8
movq -0xc0(%rbp), %rdi
callq 0x1a6a0
jmp 0x1abf6
jmp 0x1ac32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x1ac24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x5670
leaq -0xa9(%rbp), %rdi
callq 0x5040
jmp 0x1ac44
leaq -0x78(%rbp), %rdi
callq 0x14460
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x78(%rbp), %rdi
callq 0x14460
movq -0x80(%rbp), %rdi
callq 0x52a0
nopw %cs:(%rax,%rax)
// File: Themaister[P]umusd/player.cpp
// Function: Player::pause()
void Player::pause()
{
   if (!ff)
      throw std::logic_error("FFmpeg file not loaded.\n");

   if (dev->active())
   {
      event->remove(*dev);
      dev->stop();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x30, %rdi
callq 0x8570
testb $0x1, %al
jne 0x1ad91
movl $0x10, %edi
callq 0x5540
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0xba2e(%rip), %rsi      # 0x2678a
callq 0x5330
jmp 0x1ad63
movq -0x28(%rbp), %rdi
movq 0x2028a(%rip), %rsi     # 0x3aff8
movq 0x20273(%rip), %rdx     # 0x3afe8
callq 0x5260
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x56d0
jmp 0x1adf3
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x1b4f0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x48(%rax)
testb $0x1, %al
jne 0x1adad
jmp 0x1aded
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x1b510
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x20, %rdi
callq 0x1b710
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x14c30
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x1b4f0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x40(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x52a0
nopl (%rax)
// File: Themaister[P]umusd/player.cpp
// Function: Player::unpause()
void Player::unpause()
{
   auto info = media_info();
   if (!dev->active())
   {
      dev->init(info.channels, info.rate, info.fmt, dev->default_device());
      event->add(dev);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xc8(%rbp)
movq (%rsi), %rax
movq 0x48(%rax), %rax
leaq -0x78(%rbp), %rdi
callq *%rax
movq -0xc8(%rbp), %rdi
addq $0x20, %rdi
callq 0x1b4f0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x48(%rax), %rax
callq *%rax
movb %al, -0xb9(%rbp)
jmp 0x1ae4b
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x1af8f
jmp 0x1ae5b
movq -0xc8(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0xe8(%rbp)
callq 0x1b4f0
movq -0xe8(%rbp), %rdi
movq %rax, -0xe0(%rbp)
movl -0x78(%rbp), %eax
movl %eax, -0xd4(%rbp)
movl -0x74(%rbp), %eax
movl %eax, -0xd0(%rbp)
movl -0x70(%rbp), %eax
movl %eax, -0xcc(%rbp)
callq 0x1b4f0
movq %rax, %rsi
movq (%rsi), %rax
movq 0x28(%rax), %rax
leaq -0xa8(%rbp), %rdi
callq *%rax
jmp 0x1aeb5
movl -0xcc(%rbp), %ecx
movl -0xd0(%rbp), %edx
movl -0xd4(%rbp), %esi
movq -0xe0(%rbp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
leaq -0xa8(%rbp), %r8
callq *%rax
jmp 0x1aee0
leaq -0xa8(%rbp), %rdi
callq 0x5670
movq -0xc8(%rbp), %rdi
addq $0x18, %rdi
callq 0x1b510
movq -0xc8(%rbp), %rsi
movq %rax, -0xf8(%rbp)
addq $0x20, %rsi
leaq -0xb8(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x1b6e0
movq -0xf8(%rbp), %rdi
movq -0xf0(%rbp), %rsi
callq 0x14990
jmp 0x1af36
leaq -0xb8(%rbp), %rdi
callq 0x6f00
jmp 0x1af8f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x1afa1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x5670
jmp 0x1afa1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x6f00
jmp 0x1afa1
leaq -0x78(%rbp), %rdi
callq 0x14460
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0x78(%rbp), %rdi
callq 0x14460
movq -0x80(%rbp), %rdi
callq 0x52a0
nopw %cs:(%rax,%rax)
// File: Themaister[P]umusd/player.cpp
// Function: Player::status[abi:cxx11]() const
std::string Player::status() const
{
   if (ff && dev->active())
      return "PLAYING";
   else if (ff && !dev->active())
      return "PAUSED";
   else
      return "STOPPED";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x30, %rdi
callq 0x8570
testb $0x1, %al
jne 0x1b162
jmp 0x1b1c9
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x1b4f0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x48(%rax)
testb $0x1, %al
jne 0x1b17e
jmp 0x1b1c9
leaq -0x11(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x5370
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0xb609(%rip), %rsi      # 0x267a3
callq 0x67d0
jmp 0x1b1a1
leaq -0x11(%rbp), %rdi
callq 0x5040
jmp 0x1b280
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x5040
jmp 0x1b28a
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
callq 0x8570
testb $0x1, %al
jne 0x1b1dc
jmp 0x1b23b
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x1b4f0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x48(%rax)
testb $0x1, %al
jne 0x1b23b
leaq -0x25(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5370
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0xb599(%rip), %rsi      # 0x267ab
callq 0x67d0
jmp 0x1b219
leaq -0x25(%rbp), %rdi
callq 0x5040
jmp 0x1b280
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x5040
jmp 0x1b28a
leaq -0x26(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x5370
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0xb55b(%rip), %rsi      # 0x267b2
callq 0x67d0
jmp 0x1b25e
leaq -0x26(%rbp), %rdi
callq 0x5040
jmp 0x1b280
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x26(%rbp), %rdi
callq 0x5040
jmp 0x1b28a
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x52a0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Themaister[P]umusd/queue.cpp
// Function: PlayQueue::current(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void PlayQueue::current(const std::string &path)
{
   if (path.empty())
      return;

   if (!queue.current.empty())
   {
      queue.prev.push_back(std::move(queue.current));

      if (queue.prev.size() > max_prev_backlog)
      {
         queue.prev.erase(queue.prev.begin() + queue.prev.size() - max_prev_backlog,
               queue.prev.end());
      }
   }

   queue.current = path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x51a0
testb $0x1, %al
jne 0x1e24d
jmp 0x1e252
jmp 0x1e356
movq -0xf8(%rbp), %rdi
callq 0x51a0
testb $0x1, %al
jne 0x1e346
movq -0xf8(%rbp), %rsi
movq %rsi, %rdi
addq $0x20, %rdi
callq 0x1e580
movq -0xf8(%rbp), %rdi
addq $0x20, %rdi
callq 0x1e5b0
cmpq $0x1000, %rax           # imm = 0x1000
jbe 0x1e344
movq -0xf8(%rbp), %rsi
movq %rsi, %rax
addq $0x20, %rax
movq %rax, -0x100(%rbp)
addq $0x20, %rsi
leaq -0x90(%rbp), %rdi
callq 0x19c30
movq -0xf8(%rbp), %rdi
addq $0x20, %rdi
callq 0x1e5b0
movq %rax, %rdx
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1e6a0
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x1e660
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1e6e0
movq -0xf8(%rbp), %rsi
addq $0x20, %rsi
leaq -0xd0(%rbp), %rdi
callq 0x19c60
leaq -0xb0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x1e6e0
movq -0x100(%rbp), %rsi
leaq -0xf0(%rbp), %rdi
leaq -0x30(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
callq 0x1e5e0
jmp 0x1e346
movq -0xf8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x57a0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nop
// File: Themaister[P]umusd/queue.cpp
// Function: PlayQueue::next()
void PlayQueue::next()
{
   if (queue.next.empty())
      throw std::logic_error("No files in next queue.");

   current(std::move(queue.next.front()));
   queue.next.pop_front();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x70, %rdi
callq 0x1e720
testb $0x1, %al
jne 0x1e3c3
jmp 0x1e413
movl $0x10, %edi
callq 0x5540
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x8560(%rip), %rsi      # 0x2693e
callq 0x5330
jmp 0x1e3e5
movq -0x28(%rbp), %rdi
movq 0x1cc08(%rip), %rsi     # 0x3aff8
movq 0x1cbf1(%rip), %rdx     # 0x3afe8
callq 0x5260
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x56d0
jmp 0x1e43f
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
callq 0x1e820
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x1e220
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
callq 0x1e850
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x52a0
nopl (%rax,%rax)
// File: Themaister[P]umusd/queue.cpp
// Function: PlayQueue::prev()
void PlayQueue::prev()
{
   if (queue.prev.empty())
      throw std::logic_error("No files in prev queue.");

   if (!queue.current.empty())
      queue.next.push_front(std::move(queue.current));

   queue.current = std::move(queue.prev.back());
   queue.prev.pop_back();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x20, %rdi
callq 0x1e720
testb $0x1, %al
jne 0x1e473
jmp 0x1e4c3
movl $0x10, %edi
callq 0x5540
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x8498(%rip), %rsi      # 0x26926
callq 0x5330
jmp 0x1e495
movq -0x28(%rbp), %rdi
movq 0x1cb58(%rip), %rsi     # 0x3aff8
movq 0x1cb41(%rip), %rdx     # 0x3afe8
callq 0x5260
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x56d0
jmp 0x1e50c
movq -0x20(%rbp), %rdi
callq 0x51a0
testb $0x1, %al
jne 0x1e4e0
movq -0x20(%rbp), %rsi
movq %rsi, %rdi
addq $0x70, %rdi
callq 0x1e750
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x1e780
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x55b0
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x1e7c0
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x52a0
nopw %cs:(%rax,%rax)
// File: Themaister[P]umusd/tcpcommand.cpp
// Function: TCPCommand::handle(EventHandler&)
void TCPCommand::handle(EventHandler &handler)
{
   int newfd = accept(fd, nullptr, nullptr);
   if (newfd < 0)
      return;
   
   connections.erase(std::remove_if(std::begin(connections), std::end(connections),
         [](std::shared_ptr<TCPSocket> sock) { return sock->dead(); }),
         connections.end());

   auto conn = std::make_shared<TCPSocket>(newfd);
   handler.add(conn);
   conn->set_remote(*remote);
   connections.push_back(conn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movl 0x18(%rax), %edi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x56a0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x20ceb
jmp 0x20dfe
movq -0x90(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0xb0(%rbp)
callq 0x22940
movq -0xb0(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x22970
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x20e50
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x229a0
movq -0xb0(%rbp), %rdi
callq 0x229e0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x229a0
movq -0xb0(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x228b0
movq %rax, -0x58(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x22a10
movq -0xa8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x22a80
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x14990
jmp 0x20db4
leaq -0x78(%rbp), %rdi
callq 0x6f00
leaq -0x68(%rbp), %rdi
callq 0x22ab0
movq %rax, %rdi
movq -0x90(%rbp), %rax
movq 0x20(%rax), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0x20ddf
movq -0x90(%rbp), %rdi
addq $0x28, %rdi
leaq -0x68(%rbp), %rsi
callq 0x22ad0
jmp 0x20df5
leaq -0x68(%rbp), %rdi
callq 0x1cb70
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x6f00
jmp 0x20e30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1cb70
movq -0x80(%rbp), %rdi
callq 0x52a0
nopw %cs:(%rax,%rax)
// File: Themaister[P]umusd/tcpcommand.cpp
// Function: TCPCommand::operator=(TCPCommand&&)
TCPCommand& TCPCommand::operator=(TCPCommand &&tcp)
{
   connections = std::move(tcp.connections);

   if (fd >= 0)
      close(fd);
   fd = -1;
   std::swap(fd, tcp.fd);

   remote = tcp.remote;
   return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
addq $0x28, %rdi
callq 0x22bf0
movq -0x18(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jl 0x20fff
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x54c0
movq -0x18(%rbp), %rdi
movl $0xffffffff, 0x18(%rdi) # imm = 0xFFFFFFFF
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x22c20
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Themaister[P]umusd/tcpcommand.cpp
// Function: TCPSocket::kill_sock()
void TCPSocket::kill_sock()
{
   if (fd >= 0)
      close(fd);
   fd = -1;
   is_dead = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x50(%rax)
jl 0x211a6
movq -0x10(%rbp), %rax
movl 0x50(%rax), %edi
callq 0x54c0
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x50(%rax) # imm = 0xFFFFFFFF
movb $0x1, 0x54(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Themaister[P]umusd/tcpcommand.cpp
// Function: TCPSocket::write_all(EventHandler&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&)
void TCPSocket::write_all(EventHandler &handler, std::string &&str)
{
   handler.remove(*this);

   reply = std::make_shared<SocketReply>(fd, std::move(str),
         [this, &handler](bool success)
         {
            if (success)
               handler.add(shared_from_this());
            else
               kill_sock();
         });

   handler.add(reply);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14c30
movq -0x80(%rbp), %rax
movq %rax, %rsi
addq $0x50, %rsi
movq -0x18(%rbp), %rdx
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x78(%rbp)
leaq -0x38(%rbp), %rcx
callq 0x21330
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
addq $0x78, %rdi
movq %rdi, -0x70(%rbp)
callq 0x22cd0
movq -0x78(%rbp), %rdi
callq 0x22c70
movq -0x70(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x22d00
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x14990
jmp 0x212fa
leaq -0x48(%rbp), %rdi
callq 0x6f00
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6f00
movq -0x50(%rbp), %rdi
callq 0x52a0
nopw (%rax,%rax)
// File: Themaister[P]umusd/tcpcommand.cpp
// Function: TCPSocket::parse_commands(EventHandler&)
void TCPSocket::parse_commands(EventHandler &event)
{
   for (;;)
   {
      auto first = command_buf.find("\r\n");
      if (first == std::string::npos)
         return;

      auto cmd = command_buf.substr(0, first);

      auto reply = parse_command(event, cmd);
      reply += "\r\n";

      write_all(event, std::move(reply));

      command_buf.erase(0, first + 2);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
addq $0x58, %rdi
leaq 0x56f8(%rip), %rsi      # 0x26ad2
xorl %eax, %eax
movl %eax, %edx
callq 0x50f0
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x213f7
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rsi
addq $0x58, %rsi
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x5740
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rcx
movq -0x10(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0xa020
jmp 0x2142b
leaq 0x56a0(%rip), %rsi      # 0x26ad2
leaq -0x58(%rbp), %rdi
callq 0x54a0
jmp 0x2143d
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x21260
jmp 0x21450
movq -0x70(%rbp), %rdi
addq $0x58, %rdi
movq -0x18(%rbp), %rdx
addq $0x2, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x52d0
jmp 0x2146b
leaq -0x58(%rbp), %rdi
callq 0x5670
leaq -0x38(%rbp), %rdi
callq 0x5670
jmp 0x213cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x214a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5670
leaq -0x38(%rbp), %rdi
callq 0x5670
movq -0x60(%rbp), %rdi
callq 0x52a0
nopw (%rax,%rax)
// File: Themaister[P]umusd/tcpcommand.cpp
// Function: TCPSocket::handle(EventHandler&)
void TCPSocket::handle(EventHandler &event)
{
   flush_buffer();

   try
   {
      parse_commands(event);
   }
   catch (const std::exception &e)
   {
      std::cerr << e.what() << std::endl;
      kill_sock();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x21590
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x213b0
jmp 0x214ec
jmp 0x21557
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x21572
movq -0x18(%rbp), %rdi
callq 0x5080
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rsi
movq 0x19a6e(%rip), %rdi     # 0x3af98
callq 0x55d0
movq %rax, -0x38(%rbp)
jmp 0x21535
movq -0x38(%rbp), %rdi
movq 0x19a68(%rip), %rsi     # 0x3afa8
callq 0x5730
jmp 0x21547
movq -0x30(%rbp), %rdi
callq 0x21180
jmp 0x21552
callq 0x5660
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5660
jmp 0x21570
jmp 0x21572
movq -0x18(%rbp), %rdi
callq 0x52a0
movq %rax, %rdi
callq 0x6700
nopw %cs:(%rax,%rax)
// File: Themaister[P]umusd/tcpcommand.cpp
// Function: TCPSocket::flush_buffer()
void TCPSocket::flush_buffer()
{
   char buf[1024];
   ssize_t ret = ::read(fd, buf, sizeof(buf));
   if (ret <= 0)
   {
      kill_sock();
      return;
   }

   command_buf.insert(command_buf.end(), buf, buf + ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x438(%rbp)
movl 0x50(%rax), %edi
leaq -0x410(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x5650
movq %rax, -0x418(%rbp)
cmpq $0x0, -0x418(%rbp)
jg 0x215dd
movq -0x438(%rbp), %rdi
callq 0x21180
jmp 0x21644
movq -0x438(%rbp), %rdi
movq %rdi, %rax
addq $0x58, %rax
movq %rax, -0x440(%rbp)
addq $0x58, %rdi
callq 0x5220
movq %rax, -0x428(%rbp)
leaq -0x420(%rbp), %rdi
leaq -0x428(%rbp), %rsi
callq 0x22dc0
movq -0x440(%rbp), %rdi
leaq -0x410(%rbp), %rdx
leaq -0x410(%rbp), %rcx
addq -0x418(%rbp), %rcx
movq -0x420(%rbp), %rsi
callq 0x22d30
movq %rax, -0x430(%rbp)
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopl (%rax)
// File: Themaister[P]umusd/tcpcommand.cpp
// Function: TCPSocket::operator=(TCPSocket&&)
TCPSocket& TCPSocket::operator=(TCPSocket &&tcp)
{
   kill_sock();

   std::swap(tcp.fd, fd);
   std::swap(tcp.is_dead, is_dead);
   remote = tcp.remote;

   return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x21180
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
addq $0x50, %rsi
callq 0x22c20
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x54, %rdi
addq $0x54, %rsi
callq 0x22e00
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: skeeto[P]elisp-ffi/ffi-glue.cc
// Function: Machine::call(bool)
void call(bool get_errno) {
        void (*function)() = reinterpret_cast<void (*)()>(stack.pop().value.ptr);
        ffi_cif *cif = static_cast<ffi_cif *>(stack.pop().value.ptr);
        int nargs = cif->nargs;
        void *args[nargs];
        Value result {cif->rtype, {0}};
        for (int i = 0; i < nargs; i++) {
            args[i] = &stack[i].value;
        }
        if(get_errno)
            errno = 0;
        ffi_call(cif, function, &result.value, args);
        for (int i = 0; i < nargs; i++) {
            stack.pop();
        }
        if(get_errno)
            stack.push(errno);
        stack.push(result);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3260
movq -0x90(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x3260
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x50(%rbp)
leaq 0xf(,%rax,8), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x88(%rbp)
movq %rcx, %rsp
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x68(%rbp)
movb $0x0, -0x60(%rbp)
movl $0x0, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
cmpl -0x44(%rbp), %eax
jge 0x3056
movq -0x90(%rbp), %rdi
movl -0x6c(%rbp), %esi
callq 0x5320
movq %rax, %rdx
movq -0x88(%rbp), %rax
addq $0x8, %rdx
movslq -0x6c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x301e
testb $0x1, -0x9(%rbp)
je 0x3067
callq 0x2040
movl $0x0, (%rax)
movq -0x88(%rbp), %rcx
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdx
addq $0x8, %rdx
callq 0x20d0
movl $0x0, -0x70(%rbp)
movl -0x70(%rbp), %eax
cmpl -0x44(%rbp), %eax
jge 0x30b1
movq -0x90(%rbp), %rdi
callq 0x3260
movq %rax, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
movl -0x70(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x70(%rbp)
jmp 0x308a
testb $0x1, -0x9(%rbp)
je 0x30ca
callq 0x2040
movq -0x90(%rbp), %rdi
movl (%rax), %esi
callq 0x50b0
movq -0x90(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5360
movq -0x50(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: skeeto[P]elisp-ffi/ffi-glue.cc
// Function: Machine::cif()
void cif() {
        ffi_cif *cif = new ffi_cif;
        uint32_t nargs = stack.pop().value.u32;
        ffi_type *rtype = stack.pop().type;
        ffi_type **types = new ffi_type*[nargs];
        for (uint32_t i = 0; i < nargs; i++) {
            types[i] = stack.pop().type;
        }
        ffi_prep_cif(cif, FFI_DEFAULT_ABI, nargs, rtype, types);
        stack.push(cif);
        cifs_.push_back(cif);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x20, %edi
callq 0x21c0
movq -0x68(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x3260
movq -0x68(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x14(%rbp)
callq 0x3260
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x31a4
movq -0x68(%rbp), %rdi
callq 0x3260
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x60(%rbp), %rdx
movq -0x48(%rbp), %rax
movl -0x4c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x3171
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x30(%rbp), %rcx
movq -0x48(%rbp), %r8
movl $0x2, %esi
callq 0x22b0
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x52b0
movq -0x68(%rbp), %rdi
addq $0x20, %rdi
leaq -0x10(%rbp), %rsi
callq 0x5600
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: skeeto[P]elisp-ffi/ffi-glue.cc
// Function: Reader::read(unsigned int)
void read(uint32_t size) {
        char *buffer = new char[size + 1];
        buffer[size] = '\0';
        in_.read(buffer, size);
        vm_.stack.push(buffer);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x2030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %edx
movb $0x0, (%rcx,%rdx)
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %eax
movl %eax, %edx
callq 0x2220
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x52b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: skeeto[P]elisp-ffi/ffi-glue.cc
// Function: Machine::dlopen()
void dlopen() {
        const char *name = static_cast<const char *>(stack.pop().value.ptr);
        void *handle = ::dlopen(name, RTLD_LAZY);
        stack.push(handle);
        libs_.push_back(handle);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x3260
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x2250
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x52b0
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
leaq -0x28(%rbp), %rsi
callq 0x5d90
addq $0x30, %rsp
popq %rbp
retq
nop
// File: skeeto[P]elisp-ffi/ffi-glue.cc
// Function: Machine::dlsym()
void dlsym() {
        const char *name = static_cast<const char *>(stack.pop().value.ptr);
        void *handle = stack.pop().value.ptr;
        void *ptr = ::dlsym(handle, name);
        stack.push(ptr);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3260
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x3260
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21a0
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x52b0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: skeeto[P]elisp-ffi/ffi-glue.cc
// Function: Machine::~Machine()
~Machine() {
        for (auto &i : cifs_) {
            delete i->arg_types;
            delete i;
        }
        for (auto &i : libs_) {
            if (i) dlclose(i);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x20, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5990
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5820
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x64d0
testb $0x1, %al
jne 0x3d79
jmp 0x3dd5
leaq -0x18(%rbp), %rdi
callq 0x6510
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x3da9
movq -0x58(%rbp), %rdi
movl $0x8, %esi
callq 0x21d0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x3dc8
movq -0x60(%rbp), %rdi
movl $0x20, %esi
callq 0x21d0
jmp 0x3dca
leaq -0x18(%rbp), %rdi
callq 0x6530
jmp 0x3d66
movq -0x50(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6120
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x5fb0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6550
testb $0x1, %al
jne 0x3e0e
jmp 0x3e3e
leaq -0x38(%rbp), %rdi
callq 0x6590
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3e31
movq -0x48(%rbp), %rax
movq (%rax), %rdi
callq 0x2160
jmp 0x3e33
leaq -0x38(%rbp), %rdi
callq 0x65b0
jmp 0x3dfb
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
callq 0x3f00
movq -0x50(%rbp), %rdi
addq $0x20, %rdi
callq 0x3f60
movq -0x50(%rbp), %rdi
callq 0x3fc0
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH05_Statements/examples/ifgrades.cc
// Function: goodVers(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
string goodVers(string lettergrade, unsigned grade)
{
	// add a plus for grades the end in 8 or 9 and a minus for those ending in 0, 1, or 2
	if (grade % 10 > 7)
		lettergrade += '+';	   // grades ending in 8 or 9 get a '+'
	else 
		if (grade % 10 < 3)
			lettergrade += '-';   // those ending in 0, 1, or 2 get a '-'
	return lettergrade;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
cmpl $0x7, %edx
jbe 0x2803
movq -0x30(%rbp), %rdi
movl $0x2b, %esi
callq 0x20c0
jmp 0x2824
movl -0x14(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
cmpl $0x3, %edx
jae 0x2822
movq -0x30(%rbp), %rdi
movl $0x2d, %esi
callq 0x20c0
jmp 0x2824
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x20a0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH05_Statements/examples/ifgrades.cc
// Function: badVers(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
string badVers(string lettergrade, unsigned grade)
{
	// add a plus for grades the end in 8 or 9 and a minus for those ending in 0, 1, or 2
	// WRONG: execution does NOT match indentation; the else goes with the inner if
	if (grade % 10 >= 3) 
		if (grade % 10 > 7) 
			lettergrade += '+';  // grades ending in 8 or 9 get a +
	else
		lettergrade += '-'; // grades ending in 3, 4, 5, 6 will get a minus!
	return lettergrade;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
cmpl $0x3, %edx
jb 0x28a4
movl -0x14(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
cmpl $0x7, %edx
jbe 0x2894
movq -0x30(%rbp), %rdi
movl $0x2b, %esi
callq 0x20c0
jmp 0x28a2
movq -0x30(%rbp), %rdi
movl $0x2d, %esi
callq 0x20c0
jmp 0x28a4
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x20a0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH05_Statements/examples/ifgrades.cc
// Function: rightVers(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
string rightVers(string lettergrade, unsigned grade)
{
	// add a plus for grades that end in 8 or 9 and a minus for those ending in 0, 1, or 2
	if (grade % 10 >= 3) {
		if (grade % 10 > 7) 
			lettergrade += '+';  // grades ending in 8 or 9 get a +
	} else                  // curlies force the else to go with the outer if
		lettergrade += '-'; // grades ending in 0, 1, or 2 will get a minus
	return lettergrade;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
cmpl $0x3, %edx
jb 0x2914
movl -0x14(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
cmpl $0x7, %edx
jbe 0x2912
movq -0x30(%rbp), %rdi
movl $0x2b, %esi
callq 0x20c0
jmp 0x2922
movq -0x30(%rbp), %rdi
movl $0x2d, %esi
callq 0x20c0
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x20a0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: dguglielmi[P]dlan-linux-software/tools/dlanlist.cpp
// Function: VersionProductString[abi:cxx11](CDlanDevice const&)
std::string VersionProductString(const CDlanDevice& device)
{
  if(device.GetType() == CDlanDevice::eThunderbolt)
  {
    return device.GetVersion() + " " + device.GetManufacturingString();
  }
  else if(!device.GetManufacturingString().empty())
  {
    return device.GetManufacturingString();
  }
  else if(device.GetType() == CDlanDevice::eTurbo)
  {
    return "devolo dLAN Highspeed";
  }
  else
  {
    return "devolo dLAN";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5180
cmpl $0x2, %eax
jne 0x479f
movq -0x10(%rbp), %rdi
callq 0x5270
movq %rax, %rsi
leaq 0x318b8(%rip), %rdx     # 0x36004
leaq -0x30(%rbp), %rdi
callq 0x51f0
movq -0x10(%rbp), %rdi
callq 0x5290
movq %rax, -0x58(%rbp)
jmp 0x4764
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x51a0
jmp 0x4777
leaq -0x30(%rbp), %rdi
callq 0x4240
jmp 0x4866
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4240
jmp 0x4870
movq -0x10(%rbp), %rdi
callq 0x5290
movq %rax, %rdi
callq 0x4510
testb $0x1, %al
jne 0x47ce
movq -0x10(%rbp), %rdi
callq 0x5290
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x4190
jmp 0x4866
movq -0x10(%rbp), %rdi
callq 0x5180
cmpl $0x1, %eax
jne 0x4821
leaq -0x3d(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x4540
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x3180e(%rip), %rsi     # 0x36006
callq 0x52b0
jmp 0x47ff
leaq -0x3d(%rbp), %rdi
callq 0x4380
jmp 0x4866
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x3d(%rbp), %rdi
callq 0x4380
jmp 0x4870
leaq -0x3e(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4540
movq -0x50(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x317df(%rip), %rsi     # 0x3601c
callq 0x52b0
jmp 0x4844
leaq -0x3e(%rbp), %rdi
callq 0x4380
jmp 0x4866
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x3e(%rbp), %rdi
callq 0x4380
jmp 0x4870
movq -0x48(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4530
nopl (%rax)
// File: Matteo-Grellier[P]RPG/Character.cpp
// Function: Character::Character(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Job, int, int, int, int, int)
Character::Character(string name, Job job, int pAtt, int mAtt, int def, int maxHp, int speed){
    this->name = name;
    this->job = job;
    this->physicalAttack = pAtt;
    this->magicAttack = mAtt;
    this->defense = def;
    this->maxHp = maxHp;
    this->hp = maxHp;
    this->speed = speed;
    charactersList.push_back(this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq 0xe239(%rip), %rax      # 0x13c10
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x48(%rbp)
callq 0x32f0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3040
jmp 0x59f6
movq -0x50(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x40(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x2c(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x30(%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0x34(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x38(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x3c(%rax)
movl 0x18(%rbp), %ecx
movl %ecx, 0x28(%rax)
movq %rax, -0x38(%rbp)
leaq 0xe819(%rip), %rdi      # 0x14248
leaq -0x38(%rbp), %rsi
callq 0x65a0
jmp 0x5a3a
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3418
movq -0x28(%rbp), %rdi
callq 0x3390
nop
// File: Matteo-Grellier[P]RPG/Character.cpp
// Function: Character::heal(unsigned int)
void Character::heal(unsigned int healingValue) {
    if( hp + healingValue > maxHp){
        hp = maxHp;
    }
    else {
        hp += healingValue;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl 0x3c(%rcx), %eax
addl -0xc(%rbp), %eax
cmpl 0x38(%rcx), %eax
jbe 0x5a8a
movq -0x18(%rbp), %rax
movl 0x38(%rax), %ecx
movl %ecx, 0x3c(%rax)
jmp 0x5a97
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
addl 0x3c(%rax), %ecx
movl %ecx, 0x3c(%rax)
popq %rbp
retq
nopl (%rax)
// File: Matteo-Grellier[P]RPG/Character.cpp
// Function: Character::receiveDamage(int)
void Character::receiveDamage(int damage){
    if(damage < 0) {
        damage = 0;
    }
    if(this->hp - damage < 0){
        this->hp = 0;
    }
    else {
        this->hp -= damage;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x6180
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rax
movl 0x3c(%rax), %eax
subl -0xc(%rbp), %eax
cmpl $0x0, %eax
jge 0x619c
movq -0x18(%rbp), %rax
movl $0x0, 0x3c(%rax)
jmp 0x61ab
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
movl 0x3c(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x3c(%rax)
popq %rbp
retq
nopl (%rax)
// File: Matteo-Grellier[P]RPG/Mage.cpp
// Function: Mage::tryUsingMp(int)
bool Mage::tryUsingMp(int mp){
    if(this->mp < mp){
        return false;
    }
    this->mp -= mp;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x44(%rax), %eax
cmpl -0x14(%rbp), %eax
jge 0x7281
movb $0x0, -0x1(%rbp)
jmp 0x7294
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %edx
movl 0x44(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x44(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: Matteo-Grellier[P]RPG/Mage.cpp
// Function: Mage::getSpecialActionName[abi:cxx11]()
string Mage::getSpecialActionName() {
    if(tryUsingMp(0)) {
        return "Lancez une boule de feu";
    } else {
        return "Lancez une boule de feu (plus assez de point magique...)";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x7260
testb $0x1, %al
jne 0x785c
jmp 0x78a1
leaq -0x11(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x33a0
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x6a6f(%rip), %rsi      # 0xe2e7
callq 0x4500
jmp 0x787f
leaq -0x11(%rbp), %rdi
callq 0x3280
jmp 0x78e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x3280
jmp 0x78f0
leaq -0x25(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x33a0
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x6a42(%rip), %rsi      # 0xe2ff
callq 0x4500
jmp 0x78c4
leaq -0x25(%rbp), %rdi
callq 0x3280
jmp 0x78e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x3280
jmp 0x78f0
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3390
nopl (%rax)
// File: Matteo-Grellier[P]RPG/Barbarian.cpp
// Function: Barbarian::leaveFury()
void Barbarian::leaveFury(){
    if(!inFury){
        throw IllegalFury(false);
    }
    physicalAttack = baseAttack;
    defense = baseDefense;
    inFury = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x4c(%rax)
jne 0x7dc5
movl $0x10, %edi
callq 0x3110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
xorl %esi, %esi
callq 0x7f00
jmp 0x7d97
movq -0x28(%rbp), %rdi
leaq 0xbf26(%rip), %rsi      # 0x13cc8
leaq 0x1a7(%rip), %rdx       # 0x7f50
callq 0x3370
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x31a0
jmp 0x7ddf
movq -0x20(%rbp), %rax
movl 0x44(%rax), %ecx
movl %ecx, 0x2c(%rax)
movl 0x48(%rax), %ecx
movl %ecx, 0x34(%rax)
movb $0x0, 0x4c(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x3390
nopl (%rax,%rax)
// File: Matteo-Grellier[P]RPG/Barbarian.cpp
// Function: Barbarian::getSpecialActionName[abi:cxx11]()
string Barbarian::getSpecialActionName() {
    if(this->inFury) {
        return "Sortir en Furie";
    } else {
        return "Entrer de Furie";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x4c(%rax)
je 0x7e5a
leaq -0x11(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x33a0
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x6543(%rip), %rsi      # 0xe374
callq 0x4500
jmp 0x7e38
leaq -0x11(%rbp), %rdi
callq 0x3280
jmp 0x7e9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x3280
jmp 0x7ea9
leaq -0x25(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x33a0
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x650e(%rip), %rsi      # 0xe384
callq 0x4500
jmp 0x7e7d
leaq -0x25(%rbp), %rdi
callq 0x3280
jmp 0x7e9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x3280
jmp 0x7ea9
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3390
nopw %cs:(%rax,%rax)
// File: Matteo-Grellier[P]RPG/Barbarian.cpp
// Function: Barbarian::launchSpecialAction(Character&)
void Barbarian::launchSpecialAction(Character& target) {
    if(inFury) {
        leaveFury();
    } else {
        enterFury();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x4c(%rax)
je 0x7ee9
movq -0x18(%rbp), %rdi
callq 0x7d60
jmp 0x7ef2
movq -0x18(%rbp), %rdi
callq 0x79e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Matteo-Grellier[P]RPG/Exceptions.cpp
// Function: IllegalFury::what() const
const char* IllegalFury::what() const throw(){
    if(entering){
        return "Cannot enter fury twice !";
    }
    else {
        return "Cannot leave fury if not in fury !";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x83df
leaq 0x5fea(%rip), %rax      # 0xe3c3
movq %rax, -0x8(%rbp)
jmp 0x83ea
leaq 0x5ff7(%rip), %rax      # 0xe3dd
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: Matteo-Grellier[P]RPG/Potion.cpp
// Function: Potion::getHealedHp()
int Potion::getHealedHp(){
    if(remainingCharges <= 0){
        throw EmptyPotion();
    }
    remainingCharges -= 1;
    return hpPerCharge;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, (%rax)
jg 0x84c6
movl $0x8, %edi
callq 0x3110
movq %rax, %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x3130
movq -0x18(%rbp), %rdi
callq 0x8510
movq -0x18(%rbp), %rdi
leaq 0xb84e(%rip), %rsi      # 0x13d08
leaq -0xa1(%rip), %rdx       # 0x8420
callq 0x3370
movq -0x10(%rbp), %rax
movl (%rax), %ecx
subl $0x1, %ecx
movl %ecx, (%rax)
movl 0x4(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Matteo-Grellier[P]RPG/Priest.cpp
// Function: Priest::tryUsingMp(int)
bool Priest::tryUsingMp(int Mp){
    if(this->Mp < Mp){
        return false;
    }
    this->Mp -= Mp;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x48(%rax), %eax
cmpl -0x14(%rbp), %eax
jge 0x8621
movb $0x0, -0x1(%rbp)
jmp 0x8634
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %edx
movl 0x48(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x48(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: Matteo-Grellier[P]RPG/Priest.cpp
// Function: Priest::getSpecialActionName[abi:cxx11]()
string Priest::getSpecialActionName() {
    if(tryUsingMp(0)) {
        return "Soignez un allié";
    } else {
        return "Soignez un allié (plus assez de point magique...)";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x8600
testb $0x1, %al
jne 0x890c
jmp 0x8951
leaq -0x11(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x33a0
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x5afd(%rip), %rsi      # 0xe425
callq 0x4500
jmp 0x892f
leaq -0x11(%rbp), %rdi
callq 0x3280
jmp 0x8996
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x3280
jmp 0x89a0
leaq -0x25(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x33a0
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x5aca(%rip), %rsi      # 0xe437
callq 0x4500
jmp 0x8974
leaq -0x25(%rbp), %rdi
callq 0x3280
jmp 0x8996
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x3280
jmp 0x89a0
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3390
nopl (%rax)