LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %r15
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%r15)
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq 0x60(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
leaq 0x80(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0xbaab
callq 0xaba0
movq %rax, %r14
leaq 0x30(%rsp), %rdi
movups (%rax), %xmm0
movaps %xmm0, -0x10(%rdi)
leaq 0x10(%rax), %rsi
callq 0x5310
leaq 0x50(%rsp), %rdi
leaq 0x30(%r14), %rsi
callq 0x5310
leaq 0x70(%rsp), %rdi
addq $0x50, %r14
movq %r14, %rsi
callq 0x5310
leaq 0x40(%rbx), %rdi
callq 0xc79a
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3ea5(%rip), %rdx      # 0xf969
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x6214
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xb5e8
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xbaf0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5070
movq 0x30(%rbx), %rdi
callq 0xaba0
movl 0x20(%rsp), %ecx
cmpl (%rax), %ecx
jne 0xbb28
movl 0x24(%rsp), %ecx
cmpl 0x4(%rax), %ecx
jne 0xbb28
movl 0x28(%rsp), %ecx
cmpl 0x8(%rax), %ecx
jne 0xbb28
cmpq $0x0, 0x30(%rbx)
je 0xbb28
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
testb %al, %al
jne 0xbb3d
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
callq 0x9bcc
movq %rbx, %rdi
callq 0xb6ec
movq 0x70(%rsp), %rdi
cmpq %r13, %rdi
je 0xbb57
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x5070
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0xbb6e
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x5070
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0xbb85
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x5070
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xbbb8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5070
jmp 0xbbb8
jmp 0xbbb5
jmp 0xbbb5
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9822
movq %rbx, %rdi
callq 0x5200
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq *0x48(%rax)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
testb %al, %al
jne 0xbe4c
movq 0x20(%rbx), %r14
movl 0x30(%rsp), %ebp
movl 0x34(%rsp), %r15d
movl 0x38(%rsp), %r12d
movq (%r14), %rax
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq *0x28(%rax)
movq (%r14), %rax
leaq 0x10(%rsp), %r8
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
movl %r12d, %ecx
callq *0x30(%rax)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbddf
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x5070
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rax
movq %rax, (%rsp)
movq 0x28(%rbx), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xbe0e
movq 0xa190(%rip), %rcx      # 0x15f90
cmpb $0x0, (%rcx)
je 0xbe0a
incl 0xc(%rax)
jmp 0xbe0e
lock
incl 0xc(%rax)
movq %rsp, %rsi
callq 0x996a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xbe4c
movq 0xa169(%rip), %rax      # 0x15f90
cmpb $0x0, (%rax)
je 0xbe37
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xbe41
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xbe4c
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbe6d
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x5070
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbe88
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x5070
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbea3
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x5070
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xbefa
leaq 0x10(%rsp), %r14
movq %rbx, %rsi
movq %r14, %rcx
callq 0x57da
movq (%r14), %rbx
jmp 0xbefa
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbefa
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x5070
jmp 0xbefa
jmp 0xbef7
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x9822
movq %rbx, %rdi
callq 0x5200
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x30(%rsi)
je 0xc01e
movq 0x20(%r14), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
testb %al, %al
je 0xc01e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x36e6(%rip), %rsi      # 0xf6fb
leaq 0x36e6(%rip), %rdx      # 0xf702
jmp 0xc05f
cmpq $0x0, 0x30(%r14)
je 0xc033
movq 0x20(%r14), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
testb %al, %al
je 0xc04a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x36c9(%rip), %rsi      # 0xf70a
leaq 0x36c9(%rip), %rdx      # 0xf711
jmp 0xc05f
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x36ab(%rip), %rsi      # 0xf703
leaq 0x36aa(%rip), %rdx      # 0xf709
movq %rbx, %rdi
callq 0x6214
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x28, %rsi
addq $0x28, %rdi
callq 0xec6c
movl 0x18(%rbx), %edi
testl %edi, %edi
js 0xdf7d
callq 0x53d0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x18(%rbx)
movl 0x18(%r14), %ecx
movl %ecx, 0x18(%rbx)
movl %eax, 0x18(%r14)
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl 0x50(%rdi), %edi
testl %edi, %edi
js 0xe0f0
callq 0x53d0
movl $0xffffffff, 0x50(%rbx) # imm = 0xFFFFFFFF
movb $0x1, 0x54(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x9bcc
movq $0x0, (%rsp)
movl $0x78, %edi
callq 0x5390
movq %rax, %r15
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x8(%r15)
leaq 0x7b75(%rip), %rax      # 0x15cf0
movq %rax, (%r15)
leaq 0x10(%r15), %r12
movl 0x50(%r14), %esi
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rcx
movups %xmm0, 0x10(%rcx)
movq %r14, (%rcx)
movq %rbx, 0x8(%rcx)
leaq 0x4a8(%rip), %rax       # 0xe648
movq %rax, 0x18(%rcx)
leaq 0x58f(%rip), %rax       # 0xe73a
movq %rax, 0x10(%rcx)
movq %r12, %rdi
movq %r13, %rdx
callq 0x73ea
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xe1d3
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %r15, 0x8(%rsp)
movq %r12, (%rsp)
movq 0x20(%r15), %rax
testq %rax, %rax
je 0xe1ec
movl 0x8(%rax), %eax
testl %eax, %eax
jne 0xe201
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
addq $0x20, %rdi
movq %r12, 0x18(%r15)
callq 0xc3f0
movaps (%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%rsp)
movq 0x80(%r14), %rdi
movups %xmm0, 0x78(%r14)
testq %rdi, %rdi
je 0xe222
callq 0x65e2
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xe231
callq 0x65e2
movq 0x78(%r14), %rax
movq %rax, 0x10(%rsp)
movq 0x80(%r14), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0xe260
movq 0x7d3e(%rip), %rcx      # 0x15f90
cmpb $0x0, (%rcx)
je 0xe25c
incl 0xc(%rax)
jmp 0xe260
lock
incl 0xc(%rax)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x996a
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xe2a3
movq 0x7d12(%rip), %rax      # 0x15f90
cmpb $0x0, (%rax)
je 0xe28e
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xe298
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xe2a3
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xe306
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xe2fe
leaq 0x20(%rsp), %r14
movq %rbx, %rsi
movq %r14, %rcx
callq 0x587e
movq (%r14), %rbx
jmp 0xe2fe
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xe2f1
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl $0x78, %esi
movq %r15, %rdi
callq 0x5070
movq %rbx, %rdi
callq 0x5200
movq %rax, %rdi
callq 0x6156
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x58(%rdi), %r15
leaq 0x28(%rsp), %r13
leaq 0x8(%rsp), %rbp
movl $0x2, %ecx
movq %r15, %rdi
leaq 0x1628(%rip), %rsi      # 0xf967
xorl %edx, %edx
callq 0x5170
cmpq $-0x1, %rax
je 0xe3e2
movq %rax, %r12
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x5640
movq %rbp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x713a
movq %rbp, %rdi
leaq 0x15e9(%rip), %rsi      # 0xf967
callq 0x5530
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xe130
leaq 0x2(%r12), %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x5230
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe3bc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5070
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xe3d8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5070
cmpq $-0x1, %r12
jne 0xe330
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xe415
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe415
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5070
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xe431
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5070
movq %rbx, %rdi
callq 0x5200
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xe4c8
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe30e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0xe4b7
movq %r14, %rdi
callq 0x5050
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x7b24(%rip), %rdi      # 0x15fa0
movq %rax, %rsi
callq 0x54d0
movq %rax, %rdi
callq 0x52c0
movl 0x50(%rbx), %edi
testl %edi, %edi
js 0xe498
callq 0x53d0
movl $0xffffffff, 0x50(%rbx) # imm = 0xFFFFFFFF
movb $0x1, 0x54(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5590
movq %rax, %r14
callq 0x5590
movq %r14, %rdi
callq 0x5200
movq %rax, %rdi
callq 0x6156
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %rbx
movl 0x50(%rdi), %edi
movq %rsp, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x5570
testq %rax, %rax
jle 0xe502
movq 0x60(%rbx), %rsi
addq $0x58, %rbx
movq %rsp, %rcx
movq %rbx, %rdi
xorl %edx, %edx
movq %rax, %r8
callq 0x50a0
jmp 0xe519
movl 0x50(%rbx), %edi
testl %edi, %edi
js 0xe50e
callq 0x53d0
movl $0xffffffff, 0x50(%rbx) # imm = 0xFFFFFFFF
movb $0x1, 0x54(%rbx)
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x50(%rdi), %edi
testl %edi, %edi
js 0xe5be
callq 0x53d0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x50(%rbx)
movb $0x1, %cl
movb %cl, 0x54(%rbx)
movl 0x50(%r14), %edx
movl %eax, 0x50(%r14)
movl %edx, 0x50(%rbx)
movb 0x54(%r14), %al
movb %cl, 0x54(%r14)
movb %al, 0x54(%rbx)
movq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x8(%rdi), %rax
leaq -0x10(%rax), %rcx
movq -0x8(%rax), %rsi
movq %rcx, 0x8(%rdi)
leaq -0x20(%rax), %rcx
movq -0x18(%rax), %r12
movq %rcx, 0x8(%rdi)
movl 0x4(%r12), %r15d
movq %rsp, %r13
leaq 0xf(,%r15,8), %rcx
andq $-0x10, %rcx
subq %rcx, %r13
movq %r13, %rsp
movq 0x10(%r12), %rcx
movq %rcx, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
testl %r15d, %r15d
jle 0x2b22
addq $-0x28, %rax
xorl %ecx, %ecx
movq %rax, (%r13,%rcx,8)
incq %rcx
addq $-0x10, %rax
cmpq %rcx, %r15
jne 0x2b11
leaq -0x38(%rbp), %rdx
testb %r14b, %r14b
je 0x2b48
movl %r14d, -0x2c(%rbp)
movq %rsi, %r14
callq 0x2050
leaq -0x38(%rbp), %rdx
movq %r14, %rsi
movl -0x2c(%rbp), %r14d
movl $0x0, (%rax)
movq %r12, %rdi
movq %r13, %rcx
callq 0x2090
testl %r15d, %r15d
jle 0x2b71
movq 0x8(%rbx), %rax
decl %r15d
shlq $0x4, %r15
negq %r15
addq %r15, %rax
addq $-0x10, %rax
movq %rax, 0x8(%rbx)
testb %r14b, %r14b
je 0x2b85
callq 0x2050
movl (%rax), %esi
movq %rbx, %rdi
callq 0x3582
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2b9d
movups -0x40(%rbp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x2ba9
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x37ac
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x20, %edi
callq 0x2180
movq %rax, %r14
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %r13
leaq -0x10(%r13), %rax
movq -0x8(%r13), %r15
movq %rax, 0x8(%rbx)
leaq -0x20(%r13), %rax
movq -0x20(%r13), %r12
movq %rax, 0x8(%rbx)
movl %r15d, %edi
shlq $0x3, %rdi
callq 0x2030
testl %r15d, %r15d
je 0x2c28
movl %r15d, %ecx
addq $-0x30, %r13
xorl %edx, %edx
movq (%r13), %rsi
movq %r13, 0x8(%rbx)
movq %rsi, (%rax,%rdx,8)
incq %rdx
addq $-0x10, %r13
cmpq %rdx, %rcx
jne 0x2c10
movq %r14, %rdi
movl $0x2, %esi
movl %r15d, %edx
movq %r12, %rcx
movq %rax, %r8
callq 0x2270
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x376e
movq 0x28(%rbx), %rsi
cmpq 0x30(%rbx), %rsi
je 0x2c64
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x28(%rbx)
jmp 0x2c75
addq $0x20, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x388c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leal 0x1(%rbx), %edi
callq 0x2030
movq %rax, %r15
movl %ebx, %edx
movb $0x0, (%rax,%rdx)
movq 0x8(%r14), %rdi
movq %rax, %rsi
callq 0x21d0
movq (%r14), %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x376e
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq -0x8(%rax), %rdi
addq $-0x10, %rax
movq %rax, 0x8(%rbx)
movl $0x1, %esi
callq 0x2200
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x376e
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x2d07
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x40(%rbx)
jmp 0x2d18
addq $0x38, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x39c8
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq 0x28(%rdi), %r15
cmpq %r15, %r14
je 0x335d
movq (%r14), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x3345
movl $0x8, %esi
callq 0x2190
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3357
movl $0x20, %esi
callq 0x2190
addq $0x8, %r14
jmp 0x332a
movq 0x38(%rbx), %r14
movq 0x40(%rbx), %r15
cmpq %r15, %r14
je 0x337d
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3377
callq 0x2120
addq $0x8, %r14
jmp 0x3365
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x3392
movq 0x48(%rbx), %rsi
subq %rdi, %rsi
callq 0x2190
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x33a7
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x2190
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x33c0
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2190
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %eax
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
imulq %rax, %rcx
shrq $0x23, %rcx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %eax
subl %eax, %edx
movb $0x2b, %al
cmpl $0x7, %edx
ja 0x14ad
movb $0x2d, %al
cmpl $0x2, %edx
ja 0x14b8
movzbl %al, %esi
movq %rbx, %rdi
callq 0x10e0
leaq 0x10(%r14), %rcx
movq %rcx, (%r14)
movq (%rbx), %rdx
leaq 0x10(%rbx), %rax
cmpq %rax, %rdx
je 0x14d7
movq %rdx, (%r14)
movq (%rax), %rcx
movq %rcx, 0x10(%r14)
jmp 0x14dd
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %eax
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
imulq %rax, %rcx
shrq $0x23, %rcx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %eax
subl %eax, %edx
cmpl $0x3, %edx
jb 0x153b
xorl %eax, %eax
cmpl $0x8, %edx
setb %al
leal 0x2b(,%rax,2), %esi
movq %rbx, %rdi
callq 0x10e0
leaq 0x10(%r14), %rcx
movq %rcx, (%r14)
movq (%rbx), %rdx
leaq 0x10(%rbx), %rax
cmpq %rax, %rdx
je 0x155a
movq %rdx, (%r14)
movq (%rax), %rcx
movq %rcx, 0x10(%r14)
jmp 0x1560
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %eax
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
imulq %rax, %rcx
shrq $0x23, %rcx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %eax
subl %eax, %edx
movb $0x2d, %al
cmpl $0x3, %edx
jb 0x15b0
movb $0x2b, %al
cmpl $0x8, %edx
jb 0x15bb
movzbl %al, %esi
movq %rbx, %rdi
callq 0x10e0
leaq 0x10(%r14), %rcx
movq %rcx, (%r14)
movq (%rbx), %rdx
leaq 0x10(%rbx), %rax
cmpq %rax, %rdx
je 0x15da
movq %rdx, (%r14)
movq (%rax), %rcx
movq %rcx, 0x10(%r14)
jmp 0x15e0
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %eax
cmpl $0x2, %eax
jne 0x460a
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x5c80
leaq 0x11a36(%rip), %rsi     # 0x16004
movq %r15, %rdi
callq 0x4430
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x40e0
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x4640
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x4646
movq 0x38(%r14), %rdx
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testq %rdx, %rdx
je 0x462b
movq 0x30(%r14), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x5c80
jmp 0x468c
cmpl $0x1, %eax
jne 0x4676
leaq 0x119cf(%rip), %rsi     # 0x16006
leaq 0x119dd(%rip), %rdx     # 0x1601b
jmp 0x4684
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x468c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4270
jmp 0x468c
leaq 0x1199f(%rip), %rsi     # 0x1601c
leaq 0x119a3(%rip), %rdx     # 0x16027
movq %rbx, %rdi
callq 0x5d10
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x469d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x46b7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4270
movq %rbx, %rdi
callq 0x43e0
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/normalInts.cc
// Function: main
int main()
{
	default_random_engine e;        // generates random integers
	normal_distribution<> n(4,1.5); // mean 4, standard deviation 1.5
	vector<unsigned> vals(9);       // nine elements each 0

	for (size_t i = 0; i != 200; ++i) {
		unsigned v = lround(n(e));  // round to the nearest integer
		if (v < vals.size())        // if this result is in range 
			++vals[v];              // count how often each number appears
	}

	int sum = accumulate(vals.begin(), vals.end(), 0);

	if (sum != 200)
		cout << "discarded " << 200 - sum << " results" << endl;

	for (size_t j = 0; j != vals.size(); ++j)
		cout << j << ": " << string(vals[j], '*') << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq -0x50(%rbp), %r14
movq $0x1, (%r14)
movabsq $0x4010000000000000, %rax # imm = 0x4010000000000000
leaq -0x70(%rbp), %r15
movq %rax, (%r15)
movabsq $0x3ff8000000000000, %rax # imm = 0x3FF8000000000000
movq %rax, 0x8(%r15)
movq $0x0, 0x10(%r15)
movb $0x0, 0x18(%r15)
movl $0x24, %edi
callq 0x10d0
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movl $0x0, 0x20(%rax)
movl $0xc8, %r12d
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x148a
callq 0x1040
movl %eax, %eax
cmpq $0x8, %rax
ja 0x1306
incl (%rbx,%rax,4)
decq %r12
jne 0x12e8
xorl %r14d, %r14d
xorl %eax, %eax
addl (%rbx,%rax), %r14d
addq $0x4, %rax
cmpq $0x24, %rax
jne 0x1310
cmpl $0xc8, %r14d
je 0x1391
movq 0x2caa(%rip), %rdi      # 0x3fd8
leaq 0xd2b(%rip), %rsi       # 0x2060
movl $0xa, %edx
callq 0x10f0
movl $0xc8, %esi
subl %r14d, %esi
movq 0x2c8a(%rip), %rdi      # 0x3fd8
callq 0x1120
movq %rax, %r14
leaq 0xd0e(%rip), %rsi       # 0x206b
movl $0x8, %edx
movq %rax, %rdi
callq 0x10f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x10c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
leaq -0x38(%rbp), %r12
xorl %r14d, %r14d
leaq -0x48(%rbp), %r13
movq 0x2c35(%rip), %rdi      # 0x3fd8
movq %r14, %rsi
callq 0x1060
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
leaq 0xcb7(%rip), %rsi       # 0x2074
callq 0x10f0
movl (%rbx,%r14,4), %esi
movq %r12, -0x48(%rbp)
movq %r13, %rdi
movl $0x2a, %edx
callq 0x1100
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x10f0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x10c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x1426
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x10e0
incq %r14
cmpq $0x9, %r14
jne 0x139c
movl $0x24, %esi
movq %rbx, %rdi
callq 0x10e0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1457
jmp 0x1457
jmp 0x1457
movq %rax, %r14
jmp 0x1474
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x1474
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x10e0
movl $0x24, %esi
movq %rbx, %rdi
callq 0x10e0
movq %r14, %rdi
callq 0x1130
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r15d
movl %r8d, %r12d
movl %ecx, %r13d
movl %edx, %ebx
movq %rdi, %r14
leaq 0x95d2(%rip), %rax      # 0xcc18
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x18(%r14), %rax
movq %rax, -0x30(%rbp)
movq %rax, 0x8(%r14)
movq $0x0, 0x10(%r14)
movb $0x0, 0x18(%r14)
movq %rdi, -0x38(%rbp)
callq 0x20f0
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %ecx
movl %ebx, 0x40(%r14)
movl %r13d, 0x2c(%r14)
movl %r12d, 0x30(%r14)
movl %r15d, 0x34(%r14)
movl %ecx, 0x38(%r14)
movl %ecx, 0x3c(%r14)
movl %eax, 0x28(%r14)
leaq -0x40(%rbp), %rsi
movq %r14, (%rsi)
leaq 0x9af1(%rip), %rdi      # 0xd190
callq 0x4d34
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x36b5
movq %rax, %r14
movq -0x38(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0x36d4
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/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
movl 0x44(%rdi), %eax
movl %eax, %ecx
subl %esi, %ecx
jl 0x4ec0
movl %ecx, 0x44(%rdi)
cmpl %esi, %eax
setge %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
cmpl $0x0, 0x44(%rsi)
movq %rax, (%rdi)
js 0x596e
leaq 0x39a2(%rip), %rsi      # 0x9307
leaq 0x39b2(%rip), %rdx      # 0x931e
jmp 0x597c
leaq 0x39aa(%rip), %rsi      # 0x931f
leaq 0x39db(%rip), %rdx      # 0x9357
movq %rbx, %rdi
callq 0x340c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Matteo-Grellier[P]RPG/Barbarian.cpp
// Function: Barbarian::leaveFury()
void Barbarian::leaveFury(){
    if(!inFury){
        throw IllegalFury(false);
    }
    physicalAttack = baseAttack;
    defense = baseDefense;
    inFury = false;
}

// Assembly:
cmpb $0x0, 0x4c(%rdi)
je 0x60db
movl 0x44(%rdi), %eax
movl 0x48(%rdi), %ecx
movl %eax, 0x2c(%rdi)
movl %ecx, 0x34(%rdi)
movb $0x0, 0x4c(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
movl $0x10, %edi
callq 0x20d0
leaq 0x6bb8(%rip), %rcx      # 0xcca8
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
leaq 0x6bce(%rip), %rsi      # 0xccd0
movq 0x6ed7(%rip), %rdx      # 0xcfe0
movq %rax, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x4c(%rsi), %al
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
cmpb $0x1, %al
jne 0x6139
leaq 0x3264(%rip), %rsi      # 0x9394
leaq 0x326c(%rip), %rdx      # 0x93a3
jmp 0x6147
leaq 0x3264(%rip), %rsi      # 0x93a4
leaq 0x326c(%rip), %rdx      # 0x93b3
movq %rbx, %rdi
callq 0x340c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpb $0x1, 0x4c(%rdi)
jne 0x616a
popq %rbp
jmp 0x60c4
popq %rbp
jmp 0x5a4c
// File: /workspace/github_cpp_makefile_star2_O1/Matteo-Grellier[P]RPG/Potion.cpp
// Function: Potion::getHealedHp()
int Potion::getHealedHp(){
    if(remainingCharges <= 0){
        throw EmptyPotion();
    }
    remainingCharges -= 1;
    return hpPerCharge;
}

// Assembly:
movl (%rdi), %eax
testl %eax, %eax
jle 0x62a2
decl %eax
movl %eax, (%rdi)
movl 0x4(%rdi), %eax
retq
pushq %rbp
movq %rsp, %rbp
movl $0x8, %edi
callq 0x20d0
leaq 0x6a31(%rip), %rcx      # 0xcce8
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x6a4b(%rip), %rsi      # 0xcd10
movq 0x6d14(%rip), %rdx      # 0xcfe0
movq %rax, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/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
movl 0x48(%rdi), %eax
movl %eax, %ecx
subl %esi, %ecx
jl 0x63b2
movl %ecx, 0x48(%rdi)
cmpl %esi, %eax
setge %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
cmpl $0x0, 0x48(%rsi)
movq %rax, (%rdi)
js 0x689e
leaq 0x2bb0(%rip), %rsi      # 0x9445
leaq 0x2bba(%rip), %rdx      # 0x9456
jmp 0x68ac
leaq 0x2bb2(%rip), %rsi      # 0x9457
leaq 0x2bdd(%rip), %rdx      # 0x9489
movq %rbx, %rdi
callq 0x340c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Matteo-Grellier[P]RPG/Monster.cpp
// Function: Monster::teamAttack()
void Monster::teamAttack() {
    int damage = 0;
    int nbrOfCharacters = charactersList.size();

    Menu::toScreen(
        "",
        this->name + " attaque le groupe...",
        ""
    );

    for(Character* character : charactersList) {

        if (character->getJob() != 7) {
            damage = (this->physicalAttack / nbrOfCharacters) - character->getDefense();
            character->receiveDamage(damage);
        }

    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x68ad(%rip), %r15      # 0xd190
movq 0x8(%r15), %r12
subq (%r15), %r12
leaq -0x80(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x2c39(%rip), %rdx      # 0x9532
leaq -0x90(%rbp), %rdi
movq %rdx, %rsi
callq 0x340c
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rbx), %rsi
movq %rbx, -0x50(%rbp)
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x3372
leaq 0x2b63(%rip), %rsi      # 0x9492
leaq -0x48(%rbp), %rdi
callq 0x2290
leaq -0x60(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x2beb(%rip), %rdx      # 0x9532
leaq -0x70(%rbp), %rdi
movq %rdx, %rsi
callq 0x340c
leaq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x70ca
movq -0x70(%rbp), %rdi
cmpq %rbx, %rdi
je 0x697c
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x6991
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x69a9
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x21c0
movq (%r15), %r13
movq 0x8(%r15), %rbx
cmpq %rbx, %r13
je 0x69f7
shrq $0x3, %r12
movq (%r13), %r14
movq %r14, %rdi
callq 0x4c80
cmpl $0x7, %eax
je 0x69ee
movq -0x50(%rbp), %rax
movl 0x2c(%rax), %eax
cltd
idivl %r12d
movl %eax, %r15d
movq %r14, %rdi
callq 0x4c76
subl %eax, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x454e
addq $0x8, %r13
cmpq %rbx, %r13
jne 0x69b9
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq -0x70(%rbp), %rdi
cmpq %rbx, %rdi
je 0x6a25
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x6a25
jmp 0x6a22
movq %rax, %r15
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x6a3f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x6a3f
movq %rax, %r15
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x6a57
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %r15, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O1/Matteo-Grellier[P]RPG/Monster.cpp
// Function: Monster::randomAction()
void Monster::randomAction() {
    int randomNbr = rand()%3;
    int target = rand()%3;

    if(randomNbr == 0) {
        
        this->attack(*Character::charactersList[target]);
    } else if (randomNbr == 1) {
        this->teamAttack();
    } else {
        this->increaseDefense(*Character::charactersList[target+3],20);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2050
movslq %eax, %r14
imulq $0x55555556, %r14, %rax # imm = 0x55555556
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
addl %ecx, %eax
leal (%rax,%rax,2), %eax
subl %eax, %r14d
callq 0x2050
cmpl $0x1, %r14d
je 0x6ad3
cltq
imulq $0x55555556, %rax, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
testl %r14d, %r14d
jne 0x6adf
cltq
leaq 0x66d0(%rip), %rcx      # 0xd190
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3d86
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x68c8
leaq 0x66aa(%rip), %rcx      # 0xd190
movq (%rcx), %rcx
cltq
movq 0x18(%rcx,%rax,8), %rsi
movq %rbx, %rdi
movl $0x14, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x4568
nop
// File: /workspace/github_cpp_makefile_star2_O1/Matteo-Grellier[P]RPG/Menu.cpp
// Function: Menu::start()
void Menu::start(){

    cout << "Welcome to the PURPL RPG" << endl;
    cout << "   by PURPL STUDIO®" << endl;
    cout << " " << endl;

    sleep(2);

    loading();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x6459(%rip), %rbx      # 0xcfc8
leaq 0x2943(%rip), %rsi      # 0x94b9
movl $0x18, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
leaq 0x2921(%rip), %rsi      # 0x94d2
movl $0x14, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
leaq 0x2945(%rip), %rsi      # 0x9531
movl $0x1, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movl $0x2, %edi
callq 0x2130
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6c36
nop
// File: /workspace/github_cpp_makefile_star2_O1/Matteo-Grellier[P]RPG/Menu.cpp
// Function: Menu::toScreen(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Menu::toScreen(string line1, string line2, string line3) {
    Menu::devToScreen(
    line1,
    line2,
    line3);

    sleep(2);
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0x3372
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x3372
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x3372
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x71ec
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x7157
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x716c
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x7181
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x21c0
movl $0x2, %edi
callq 0x2130
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x71b5
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x71b5
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x71cf
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x71cf
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x71e4
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/Matteo-Grellier[P]RPG/Menu.cpp
// Function: Menu::devToScreen(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Menu::devToScreen(string line1, string line2, string line3) {
    refresh();
    
    cout << line1 << endl;
    cout << line2 << endl;
    cout << line3 << endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x6b0c
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x5db5(%rip), %r14      # 0xcfc8
movq %r14, %rdi
callq 0x21e0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x21e0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x21e0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O1/Matteo-Grellier[P]RPG/Menu.cpp
// Function: Menu::ask(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Menu::ask(string line1, string line2) {
    
    int answer;

    devToScreen(
    line1,
    line2 + " :",
    " ");

    cout << Menu::endLine;
    cin >> answer;

    return answer;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
leaq -0x78(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x3372
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x3372
leaq 0x21ea(%rip), %rsi      # 0x94fc
leaq -0x40(%rbp), %rdi
callq 0x2290
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x2206(%rip), %rsi      # 0x9531
leaq 0x2200(%rip), %rdx      # 0x9532
leaq -0x68(%rbp), %rdi
callq 0x340c
leaq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x71ec
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x7364
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x7379
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x88(%rbp), %rdi
cmpq %r14, %rdi
je 0x7391
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21c0
movq 0x5e38(%rip), %rsi      # 0xd1d0
movq 0x5e39(%rip), %rdx      # 0xd1d8
movq 0x5c22(%rip), %rdi      # 0xcfc8
callq 0x21e0
movq 0x5c26(%rip), %rdi      # 0xcfd8
leaq -0x44(%rbp), %rbx
movq %rbx, %rsi
callq 0x2100
movl (%rbx), %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x73ec
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x73ec
jmp 0x73e9
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x7406
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x7406
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r14, %rdi
je 0x741e
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2270