LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
callq *0x48(%rax)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
testb %al, %al
jne 0x9c72
leaq 0x20(%rbx), %r14
movq (%r14), %r15
movl 0x38(%rsp), %ebp
movl 0x3c(%rsp), %r12d
movl 0x40(%rsp), %r13d
movq (%r15), %rax
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq *0x28(%rax)
movq (%r15), %rax
leaq 0x18(%rsp), %r8
movq %r15, %rdi
movl %ebp, %esi
movl %r12d, %edx
movl %r13d, %ecx
callq *0x30(%rax)
leaq 0x18(%rsp), %rdi
callq 0x4540
movq 0x18(%rbx), %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xa6de
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7f4e
leaq 0x10(%rsp), %rdi
callq 0x4f44
leaq 0x38(%rsp), %rdi
callq 0x7dd2
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4f44
jmp 0x9cb1
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4540
jmp 0x9cb1
jmp 0x9cae
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x7dd2
movq %rbx, %rdi
callq 0x4200
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
cmpq $0x0, 0x30(%rsi)
je 0x9dde
movq %rsi, %r14
movq 0x20(%rsi), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
testb %al, %al
je 0x9dc9
leaq 0x3919(%rip), %rsi      # 0xd6db
leaq 0x7(%rsp), %rdx
jmp 0x9dea
cmpq $0x0, 0x30(%r14)
je 0x9dde
movq 0x20(%r14), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
testb %al, %al
je 0x9dfd
leaq 0x3905(%rip), %rsi      # 0xd6ea
leaq 0x5(%rsp), %rdx
movq %rbx, %rdi
callq 0x4eca
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x38df(%rip), %rsi      # 0xd6e3
leaq 0x6(%rsp), %rdx
jmp 0x9dea
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x18(%rdi), %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x45a0
movl %eax, 0xc(%rsp)
testl %eax, %eax
js 0xbbea
movq %r14, 0x20(%rsp)
leaq 0x28(%rbx), %rax
movq %rax, (%rsp)
movq 0x28(%rbx), %r13
movq 0x30(%rbx), %r14
movq %r14, %r15
subq %r13, %r15
movq %r15, %r12
sarq $0x6, %r12
testq %r12, %r12
jle 0xbb00
movq %r13, %rdi
callq 0xc1c2
testb %al, %al
jne 0xbb3f
leaq 0x10(%r13), %rbp
movq %rbp, %rdi
callq 0xc1c2
testb %al, %al
jne 0xbb42
leaq 0x20(%r13), %rbp
movq %rbp, %rdi
callq 0xc1c2
testb %al, %al
jne 0xbb42
leaq 0x30(%r13), %rbp
movq %rbp, %rdi
callq 0xc1c2
testb %al, %al
jne 0xbb42
addq $0x40, %r13
decq %r12
addq $-0x40, %r15
jmp 0xbab2
sarq $0x4, %r15
cmpq $0x1, %r15
je 0xbc0f
cmpq $0x2, %r15
je 0xbbf9
cmpq $0x3, %r15
jne 0xbc29
movq %r13, %rdi
callq 0xc1c2
testb %al, %al
movq (%rsp), %r15
jne 0xbc21
addq $0x10, %r13
jmp 0xbbfd
movq %r13, %rbp
movq (%rsp), %r15
cmpq %r14, %rbp
je 0xbb79
movq %rbp, %r13
addq $0x10, %rbp
cmpq %r14, %rbp
je 0xbb74
movq %rbp, %rdi
callq 0xc1c2
testb %al, %al
jne 0xbb4e
movq %r13, %rdi
movq %rbp, %rsi
callq 0xc49e
addq $0x10, %r13
jmp 0xbb4e
movq %r13, %r14
jmp 0xbb7c
movq %rbp, %r14
movq 0x30(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xc33a
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %rsi
movq %r12, %rdi
callq 0xc33f
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0xc726
movq 0x20(%rsp), %rdi
movq %r13, %rsi
callq 0x7f4e
leaq 0x30(%rsp), %rdi
callq 0x4f44
movq 0x10(%rsp), %rdi
movq 0x20(%rbx), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0xc35e
leaq 0x18(%rsp), %rdi
callq 0x5444
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %r15
movq %r13, %rdi
callq 0xc1c2
testb %al, %al
jne 0xbc21
addq $0x10, %r13
jmp 0xbc13
movq (%rsp), %r15
movq %r13, %rdi
callq 0xc1c2
testb %al, %al
cmoveq %r14, %r13
movq %r13, %rbp
jmp 0xbb46
movq (%rsp), %r15
jmp 0xbb7c
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4f44
jmp 0xbc44
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5444
movq %rbx, %rdi
callq 0x4200
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc8ce
movl 0x18(%rbx), %edi
testl %edi, %edi
js 0xbcdb
callq 0x43e0
orl $-0x1, 0x18(%rbx)
movl 0x18(%r14), %eax
movl %eax, 0x18(%rbx)
orl $-0x1, 0x18(%r14)
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbddc
callq 0x43e0
orl $-0x1, 0x50(%rbx)
movb $0x1, 0x54(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x60, %rsp
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x8122
leaq 0xf(%rsp), %r15
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0xc948
movq %rax, %r12
movq %r15, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x8(%r12)
leaq 0x8e8e(%rip), %rax      # 0x14cf8
movq %rax, (%r12)
leaq 0x10(%r12), %r15
movl 0x50(%r14), %esi
leaq 0x40(%rsp), %rcx
movq %r14, (%rcx)
movq %rbx, 0x8(%rcx)
leaq 0x364(%rip), %rax       # 0xc1ee
movq %rax, 0x18(%rcx)
leaq 0x3e9(%rip), %rax       # 0xc27e
movq %rax, 0x10(%rcx)
movq %r15, %rdi
movq %r13, %rdx
callq 0x5f58
leaq 0x38(%rsp), %r13
leaq 0x40(%rsp), %rdi
callq 0x7162
leaq 0x10(%rsp), %rdi
andq $0x0, 0x8(%rdi)
movq %r12, (%r13)
movq %r15, -0x8(%r13)
callq 0xc936
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xc920
addq $0x78, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0xcaae
movq %r13, %rdi
callq 0x5444
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xcadc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7f4e
leaq 0x28(%rsp), %rdi
callq 0x4f44
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4f44
jmp 0xbf4a
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x7162
leaq 0x10(%rsp), %rdi
callq 0xc936
movq %rbx, %rdi
callq 0x4200
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %r15, %rdi
leaq 0x19c9(%rip), %rsi      # 0xd947
xorl %edx, %edx
callq 0x40a0
cmpq $-0x1, %rax
je 0xbfef
movq %rax, %r12
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4630
movq %rbp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x5d5a
movq %rbp, %rdi
leaq 0x198e(%rip), %rsi      # 0xd947
callq 0x4520
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xbe16
addq $0x2, %r12
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x4230
movq %rbp, %rdi
callq 0x4540
movq %r13, %rdi
callq 0x4540
jmp 0xbf74
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xc010
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4540
leaq 0x28(%rsp), %rdi
callq 0x4540
movq %rbx, %rdi
callq 0x4200
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc0a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbf52
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0xc090
movq %r14, %rdi
callq 0x4050
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x8f44(%rip), %rdi      # 0x14fa8
movq %rax, %rsi
callq 0x44c0
movq %rax, %rdi
callq 0x42d0
movq %rbx, %rdi
callq 0xbdcc
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4570
movq %rax, %r14
callq 0x4570
movq %r14, %rdi
callq 0x4200
movq %rax, %rdi
callq 0x4e96
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4560
testq %rax, %rax
jle 0xc0e1
leaq 0x58(%rbx), %rdi
movq 0x58(%rbx), %rsi
addq 0x60(%rbx), %rsi
leaq (%rsp,%rax), %rcx
movq %rsp, %rdx
callq 0xc3b2
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
movq %rbx, %rdi
addq $0x400, %rsp            # imm = 0x400
popq %rbx
jmp 0xbdcc
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r14
callq 0xbdcc
movl 0x50(%rbx), %eax
movl 0x50(%r14), %ecx
movl %ecx, 0x50(%rbx)
movl %eax, 0x50(%r14)
movb 0x54(%rbx), %al
movb 0x54(%r14), %cl
movb %cl, 0x54(%rbx)
movb %al, 0x54(%r14)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
movq 0x8(%rdi), %rax
leaq -0x10(%rax), %rcx
movq -0x8(%rax), %r8
movq %rcx, 0x8(%rdi)
leaq -0x20(%rax), %rcx
movq -0x18(%rax), %r12
movq %rcx, 0x8(%rdi)
movl 0x4(%r12), %edi
movq %rsp, %r13
leaq 0xf(,%rdi,8), %rcx
andq $-0x10, %rcx
subq %rcx, %r13
movq %r13, %rsp
movq 0x10(%r12), %rcx
leaq -0x38(%rbp), %rdx
movq %rcx, -0x8(%rdx)
movb $0x0, (%rdx)
xorl %ecx, %ecx
testl %edi, %edi
movl $0x0, %r14d
cmovgl %edi, %r14d
addq $-0x28, %rax
cmpq %rcx, %r14
je 0x2b4d
movq %rax, (%r13,%rcx,8)
incq %rcx
addq $-0x10, %rax
jmp 0x2b3a
movl %esi, %r15d
testb %sil, %sil
je 0x2b69
movq %r8, -0x30(%rbp)
callq 0x2040
leaq -0x38(%rbp), %rdx
movq -0x30(%rbp), %r8
andl $0x0, (%rax)
movq %r12, %rdi
movq %r8, %rsi
movq %r13, %rcx
callq 0x20b0
movq 0x8(%rbx), %rax
addq $-0x10, %rax
subl $0x1, %r14d
jb 0x2b8b
movq %rax, 0x8(%rbx)
jmp 0x2b7b
testb %r15b, %r15b
je 0x2b9f
callq 0x2040
movl (%rax), %esi
movq %rbx, %rdi
callq 0x3512
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3652
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x21b0
movq %rax, %r14
movq %rax, (%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, %ebp
leaq (,%rbp,8), %rdi
callq 0x2030
addq $-0x30, %r13
xorl %ecx, %ecx
cmpq %rcx, %rbp
je 0x2c23
movq (%r13), %rdx
movq %r13, 0x8(%rbx)
movq %rdx, (%rax,%rcx,8)
incq %rcx
addq $-0x10, %r13
jmp 0x2c09
pushq $0x2
popq %rsi
movq %r14, %rdi
movl %r15d, %edx
movq %r12, %rcx
movq %rax, %r8
callq 0x22b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x362e
addq $0x20, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3738
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2200
movq (%r14), %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x362e
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq -0x8(%rax), %rdi
addq $-0x10, %rax
movq %rax, 0x8(%rbx)
pushq $0x1
popq %rsi
callq 0x2230
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x362e
addq $0x38, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x389a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
leaq -0x10(%rax), %rcx
movq -0x8(%rax), %rsi
movq %rcx, 0x8(%rdi)
movq -0x18(%rax), %rdi
addq $-0x20, %rax
movq %rax, 0x8(%rbx)
callq 0x2180
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x362e
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq 0x20(%rdi), %r13
movq 0x28(%rdi), %rbp
pushq $0x8
popq %r15
pushq $0x20
popq %r12
cmpq %rbp, %r13
je 0x3257
movq (%r13), %rax
movq 0x8(%rax), %rdi
movq %r15, %rsi
callq 0x21c0
movq (%r13), %rdi
movq %r12, %rsi
callq 0x21c0
addq $0x8, %r13
jmp 0x3230
leaq 0x38(%rbx), %r15
movq 0x38(%rbx), %r12
movq 0x40(%rbx), %r13
cmpq %r13, %r12
je 0x327c
movq (%r12), %rdi
testq %rdi, %rdi
je 0x3276
callq 0x2150
addq $0x8, %r12
jmp 0x3263
movq %r15, %rdi
callq 0x32ae
movq %r14, %rdi
callq 0x32e2
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3316
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %edx, %eax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0xa
popq %rcx
xorl %edx, %edx
divl %ecx
movb $0x2b, %al
cmpl $0x7, %edx
ja 0x2490
movb $0x2d, %al
cmpl $0x2, %edx
ja 0x249b
movzbl %al, %esi
movq %r14, %rdi
callq 0x20d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2130
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %edx, %eax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0xa
popq %rcx
xorl %edx, %edx
divl %ecx
cmpl $0x3, %edx
jb 0x24e0
xorl %eax, %eax
cmpl $0x8, %edx
setb %al
leal 0x2b(,%rax,2), %esi
movq %r14, %rdi
callq 0x20d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2130
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %edx, %eax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0xa
popq %rcx
xorl %edx, %edx
divl %ecx
movb $0x2d, %al
cmpl $0x3, %edx
jb 0x2517
movb $0x2b, %al
cmpl $0x8, %edx
jb 0x2522
movzbl %al, %esi
movq %r14, %rdi
callq 0x20d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2130
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %eax
cmpl $0x2, %eax
jne 0x45f5
leaq 0x10(%r14), %rsi
leaq 0xea36(%rip), %rdx      # 0x13004
movq %rsp, %r15
movq %r15, %rdi
callq 0x49f1
addq $0x30, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x49d2
movq %rsp, %rdi
callq 0x4170
jmp 0x462d
cmpq $0x0, 0x38(%r14)
je 0x460d
addq $0x30, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4340
jmp 0x462d
cmpl $0x1, %eax
jne 0x461b
leaq 0xe9ed(%rip), %rsi      # 0x13006
jmp 0x4622
leaq 0xe9fa(%rip), %rsi      # 0x1301c
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x4a2a
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x68, %rsp
leaq -0x68(%rbp), %rbx
movq $0x1, (%rbx)
movabsq $0x4010000000000000, %rax # imm = 0x4010000000000000
leaq -0x88(%rbp), %r14
movq %rax, (%r14)
movabsq $0x3ff8000000000000, %rax # imm = 0x3FF8000000000000
movq %rax, 0x8(%r14)
andq $0x0, 0x10(%r14)
movb $0x0, 0x18(%r14)
leaq -0x40(%rbp), %rdi
pushq $0x9
popq %rsi
leaq -0x60(%rbp), %rdx
callq 0x146e
movl $0xc8, %r15d
subq $0x1, %r15
jb 0x135b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14c0
callq 0x1030
movl %eax, %eax
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rdx, %rax
jae 0x132a
incl (%rcx,%rax,4)
jmp 0x132a
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
xorl %ebx, %ebx
cmpq %rcx, %rax
je 0x1372
addl (%rax), %ebx
addq $0x4, %rax
jmp 0x1365
cmpl $0xc8, %ebx
je 0x13b3
movq 0x2c57(%rip), %rdi      # 0x3fd8
leaq 0xcd8(%rip), %rsi       # 0x2060
callq 0x1120
movl $0xc8, %esi
subl %ebx, %esi
movq %rax, %rdi
callq 0x1170
leaq 0xcc8(%rip), %rsi       # 0x206b
movq %rax, %rdi
callq 0x1120
movq %rax, %rdi
callq 0x1080
xorl %ebx, %ebx
leaq 0xcb8(%rip), %r15       # 0x2074
leaq -0x60(%rbp), %r12
pushq $0x2a
popq %r13
movq -0x38(%rbp), %rax
subq -0x40(%rbp), %rax
sarq $0x2, %rax
cmpq %rax, %rbx
je 0x142c
movq 0x2bfc(%rip), %rdi      # 0x3fd8
movq %rbx, %rsi
callq 0x10b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x1120
movq %rax, %r14
movq -0x40(%rbp), %rax
movl (%rax,%rbx,4), %esi
leaq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %r12, %rdi
movl %r13d, %edx
callq 0x1150
movq %r14, %rdi
movq %r12, %rsi
callq 0x1110
movq %rax, %rdi
callq 0x1080
movq %r12, %rdi
callq 0x1070
incq %rbx
jmp 0x13c4
leaq -0x40(%rbp), %rdi
callq 0x14dc
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x145a
jmp 0x145a
jmp 0x145a
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x1070
jmp 0x145d
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x14dc
movq %rbx, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7ab2(%rip), %rax      # 0xac18
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
andq $0x0, 0x10(%r14)
movb $0x0, 0x18(%r14)
movq %rdi, -0x30(%rbp)
callq 0x20e0
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 -0x38(%rbp), %rsi
movq %r14, (%rsi)
leaq 0x7fd8(%rip), %rdi      # 0xb190
callq 0x3b12
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x31ce
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x22a8
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/Matteo-Grellier[P]RPG/Character.cpp
// Function: Character::drink(Potion&)
void Character::drink(Potion& p){
    this->heal(p.getHealedHp());

    Menu::toScreen(
        "",
        this->name + " a bu une potion qui lui a redonné " + to_string(p.getHealedHp()) + " pv.",
        this->name + " est à " + to_string(this->getCurrentHp()) + " pv."
    );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x4640
addl 0x3c(%rbx), %eax
movl 0x38(%rbx), %ecx
cmpl %ecx, %eax
cmovael %ecx, %eax
movl %eax, 0x3c(%rbx)
leaq 0x4309(%rip), %rsi      # 0x7532
leaq -0x140(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x2c78
leaq 0x8(%rbx), %r14
leaq 0x3eef(%rip), %rdx      # 0x7133
leaq -0xe0(%rbp), %rdi
movq %r14, %rsi
callq 0x39a9
movq %r15, %rdi
callq 0x4640
leaq -0xc0(%rbp), %rdi
movl %eax, %esi
callq 0x39e1
leaq -0x100(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
leaq -0xc0(%rbp), %rdx
callq 0x3938
leaq 0x3ece(%rip), %rdx      # 0x7158
leaq -0x120(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x2dbc
leaq 0x3eb9(%rip), %rdx      # 0x715d
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0x39a9
movl 0x3c(%rbx), %esi
leaq -0x40(%rbp), %rdi
callq 0x39e1
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x3938
leaq 0x3e84(%rip), %rdx      # 0x7158
leaq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2dbc
leaq -0x140(%rbp), %rdi
leaq -0x120(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x4e84
leaq -0xa0(%rbp), %rdi
callq 0x22a8
leaq -0x80(%rbp), %rdi
callq 0x22a8
leaq -0x40(%rbp), %rdi
callq 0x22a8
leaq -0x60(%rbp), %rdi
callq 0x22a8
leaq -0x120(%rbp), %rdi
callq 0x22a8
leaq -0x100(%rbp), %rdi
callq 0x22a8
leaq -0xc0(%rbp), %rdi
callq 0x22a8
leaq -0xe0(%rbp), %rdi
callq 0x22a8
leaq -0x140(%rbp), %rdi
callq 0x22a8
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x22a8
jmp 0x3383
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x22a8
jmp 0x3391
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x22a8
jmp 0x339f
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x22a8
jmp 0x33ad
movq %rax, %rbx
leaq -0x120(%rbp), %rdi
callq 0x22a8
leaq -0x100(%rbp), %rdi
callq 0x22a8
leaq -0xc0(%rbp), %rdi
callq 0x22a8
jmp 0x33e5
movq %rax, %rbx
jmp 0x33b9
movq %rax, %rbx
jmp 0x33c5
movq %rax, %rbx
jmp 0x33f1
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
callq 0x22a8
leaq -0x140(%rbp), %rdi
callq 0x22a8
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/Matteo-Grellier[P]RPG/Character.cpp
// Function: Character::attack(Character&)
void Character::attack(Character& defender) {
    int damage = this->physicalAttack - defender.defense;
    defender.receiveDamage(damage);

    Menu::toScreen(
        "",
        this->name + " attaque " + defender.name + " et lui inflige " + to_string(damage) + " de dégats" ,
        defender.name + " est à " + to_string(defender.getCurrentHp()) + " pv."
    );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %rsi, %rbx
movq %rdi, %r15
movl 0x2c(%rdi), %r14d
subl 0x34(%rsi), %r14d
xorl %eax, %eax
testl %r14d, %r14d
movl $0x0, %ecx
cmovgl %r14d, %ecx
movl 0x3c(%rsi), %edx
subl %ecx, %edx
testl %edx, %edx
cmovlel %eax, %edx
movl %edx, 0x3c(%rsi)
leaq 0x40ca(%rip), %rsi      # 0x7532
leaq -0x180(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x2c78
addq $0x8, %r15
leaq 0x3ce3(%rip), %rdx      # 0x7166
leaq -0xe0(%rbp), %rdi
movq %r15, %rsi
callq 0x39a9
leaq 0x8(%rbx), %r15
leaq -0x100(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
movq %r15, %rdx
callq 0x3a41
leaq 0x3cbd(%rip), %rdx      # 0x7170
leaq -0x120(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x2dbc
leaq -0xc0(%rbp), %rdi
movl %r14d, %esi
callq 0x39e1
leaq -0x140(%rbp), %rdi
leaq -0x120(%rbp), %rsi
leaq -0xc0(%rbp), %rdx
callq 0x3938
leaq 0x3c8b(%rip), %rdx      # 0x7181
leaq -0x160(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x2dbc
leaq 0x3c4d(%rip), %rdx      # 0x715d
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
callq 0x39a9
movl 0x3c(%rbx), %esi
leaq -0x40(%rbp), %rdi
callq 0x39e1
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x3938
leaq 0x3c18(%rip), %rdx      # 0x7158
leaq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2dbc
leaq -0x180(%rbp), %rdi
leaq -0x160(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x4e84
leaq -0xa0(%rbp), %rdi
callq 0x22a8
leaq -0x80(%rbp), %rdi
callq 0x22a8
leaq -0x40(%rbp), %rdi
callq 0x22a8
leaq -0x60(%rbp), %rdi
callq 0x22a8
leaq -0x160(%rbp), %rdi
callq 0x22a8
leaq -0x140(%rbp), %rdi
callq 0x22a8
leaq -0xc0(%rbp), %rdi
callq 0x22a8
leaq -0x120(%rbp), %rdi
callq 0x22a8
leaq -0x100(%rbp), %rdi
callq 0x22a8
leaq -0xe0(%rbp), %rdi
callq 0x22a8
leaq -0x180(%rbp), %rdi
callq 0x22a8
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x22a8
jmp 0x3607
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x22a8
jmp 0x3615
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x22a8
jmp 0x3623
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x22a8
jmp 0x3631
movq %rax, %rbx
leaq -0x160(%rbp), %rdi
callq 0x22a8
leaq -0x140(%rbp), %rdi
callq 0x22a8
leaq -0xc0(%rbp), %rdi
callq 0x22a8
leaq -0x120(%rbp), %rdi
callq 0x22a8
leaq -0x100(%rbp), %rdi
callq 0x22a8
leaq -0xe0(%rbp), %rdi
callq 0x22a8
leaq -0x180(%rbp), %rdi
callq 0x22a8
movq %rbx, %rdi
callq 0x2260
movq %rax, %rbx
jmp 0x363d
movq %rax, %rbx
jmp 0x3649
movq %rax, %rbx
jmp 0x3655
movq %rax, %rbx
jmp 0x3661
movq %rax, %rbx
jmp 0x366d
movq %rax, %rbx
jmp 0x3679
nop
// File: /workspace/github_cpp_makefile_star2_O2/Matteo-Grellier[P]RPG/Character.cpp
// Function: Character::increaseDefense(Character&, int)
void Character::increaseDefense(Character& other, int valueToIncrease) {
    other.defense += valueToIncrease;

    Menu::toScreen(
        "",
        this->name + " donne de la défense à " + other.name + " et ajoute " + to_string(valueToIncrease),
        other.name + " est à " + to_string(other.defense) + " de defense."
    );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
addl %edx, 0x34(%rsi)
leaq 0x3e49(%rip), %rsi      # 0x7532
leaq -0x160(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x2c78
addq $0x8, %r15
leaq 0x3a89(%rip), %rdx      # 0x718d
leaq -0xe0(%rbp), %rdi
movq %r15, %rsi
callq 0x39a9
leaq 0x8(%rbx), %r15
leaq -0x100(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
movq %r15, %rdx
callq 0x3a41
leaq 0x3a73(%rip), %rdx      # 0x71a7
leaq -0x120(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x2dbc
leaq -0xc0(%rbp), %rdi
movl %r14d, %esi
callq 0x39e1
leaq -0x140(%rbp), %rdi
leaq -0x120(%rbp), %rsi
leaq -0xc0(%rbp), %rdx
callq 0x3938
leaq 0x39e6(%rip), %rdx      # 0x715d
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
callq 0x39a9
movl 0x34(%rbx), %esi
leaq -0x40(%rbp), %rdi
callq 0x39e1
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x3938
leaq 0x3a0c(%rip), %rdx      # 0x71b3
leaq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2dbc
leaq -0x160(%rbp), %rdi
leaq -0x140(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x4e84
leaq -0xa0(%rbp), %rdi
callq 0x22a8
leaq -0x80(%rbp), %rdi
callq 0x22a8
leaq -0x40(%rbp), %rdi
callq 0x22a8
leaq -0x60(%rbp), %rdi
callq 0x22a8
leaq -0x140(%rbp), %rdi
callq 0x22a8
leaq -0xc0(%rbp), %rdi
callq 0x22a8
leaq -0x120(%rbp), %rdi
callq 0x22a8
leaq -0x100(%rbp), %rdi
callq 0x22a8
leaq -0xe0(%rbp), %rdi
callq 0x22a8
leaq -0x160(%rbp), %rdi
callq 0x22a8
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x22a8
jmp 0x3862
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x22a8
jmp 0x3870
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x22a8
jmp 0x387e
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x22a8
jmp 0x388c
movq %rax, %rbx
leaq -0x140(%rbp), %rdi
callq 0x22a8
leaq -0xc0(%rbp), %rdi
callq 0x22a8
leaq -0x120(%rbp), %rdi
callq 0x22a8
leaq -0x100(%rbp), %rdi
callq 0x22a8
leaq -0xe0(%rbp), %rdi
callq 0x22a8
leaq -0x160(%rbp), %rdi
callq 0x22a8
movq %rbx, %rdi
callq 0x2260
movq %rax, %rbx
jmp 0x3898
movq %rax, %rbx
jmp 0x38a4
movq %rax, %rbx
jmp 0x38b0
movq %rax, %rbx
jmp 0x38bc
movq %rax, %rbx
jmp 0x38c8
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3cc0
movl %ecx, 0x44(%rdi)
cmpl %esi, %eax
setge %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpl $0x0, 0x44(%rsi)
js 0x409e
leaq 0x326f(%rip), %rsi      # 0x7307
leaq -0xa(%rbp), %rdx
jmp 0x40a9
leaq 0x327a(%rip), %rsi      # 0x731f
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x2c78
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x43d1
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
pushq $0x10
popq %rdi
callq 0x20c0
leaq 0x68c4(%rip), %rcx      # 0xaca8
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
leaq 0x68da(%rip), %rsi      # 0xacd0
movq 0x6be3(%rip), %rdx      # 0xafe0
movq %rax, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpb $0x1, 0x4c(%rsi)
jne 0x4422
leaq 0x2f78(%rip), %rsi      # 0x7394
leaq -0xa(%rbp), %rdx
jmp 0x442d
leaq 0x2f7b(%rip), %rsi      # 0x73a4
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x2c78
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4450
popq %rbp
jmp 0x43ba
popq %rbp
jmp 0x4146
// File: /workspace/github_cpp_makefile_star2_O2/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 0x464e
decl %eax
movl %eax, (%rdi)
movl 0x4(%rdi), %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq $0x8
popq %rdi
callq 0x20c0
leaq 0x6687(%rip), %rcx      # 0xace8
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x66a1(%rip), %rsi      # 0xad10
movq 0x696a(%rip), %rdx      # 0xafe0
movq %rax, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4722
movl %ecx, 0x48(%rdi)
cmpl %esi, %eax
setge %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Matteo-Grellier[P]RPG/Priest.cpp
// Function: Priest::healSpell(Character&)
void Priest::healSpell(Character& other){
    if(!tryUsingMp(this->maxMp*0.10f)){
        return;
    }
    int healValue = (rand() % ( magicAttack*2 - magicAttack)+magicAttack );
    other.heal(healValue);

    Menu::toScreen(
        "",
        this->name + " soigne " + other.name,
        other.name + " est à " + to_string(other.getCurrentHp()) + " pv." 
    );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xf0, %rsp
cvtsi2ssl 0x44(%rdi), %xmm0
mulss 0x2b67(%rip), %xmm0     # 0x72ac
cvttss2si %xmm0, %ecx
movl 0x48(%rdi), %eax
subl %ecx, %eax
jl 0x4871
movq %rdi, %r14
movq %rsi, %rbx
movl %eax, 0x48(%rdi)
callq 0x2050
movl 0x30(%r14), %esi
cltd
idivl %esi
addl %edx, %esi
movq %rbx, %rdi
callq 0x31e2
leaq 0x2db8(%rip), %rsi      # 0x7532
leaq -0xf8(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x2c78
addq $0x8, %r14
leaq 0x2ca7(%rip), %rdx      # 0x743c
leaq -0xb8(%rbp), %rdi
movq %r14, %rsi
callq 0x39a9
leaq 0x8(%rbx), %r14
leaq -0xd8(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
movq %r14, %rdx
callq 0x3a41
leaq 0x2998(%rip), %rdx      # 0x715d
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
callq 0x39a9
movq %rbx, %rdi
callq 0x3406
leaq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x39e1
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x3938
leaq 0x295c(%rip), %rdx      # 0x7158
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2dbc
leaq -0xf8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x4e84
leaq -0x98(%rbp), %rdi
callq 0x22a8
leaq -0x78(%rbp), %rdi
callq 0x22a8
leaq -0x38(%rbp), %rdi
callq 0x22a8
leaq -0x58(%rbp), %rdi
callq 0x22a8
leaq -0xd8(%rbp), %rdi
callq 0x22a8
leaq -0xb8(%rbp), %rdi
callq 0x22a8
leaq -0xf8(%rbp), %rdi
callq 0x22a8
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x22a8
jmp 0x4891
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x22a8
jmp 0x489f
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x22a8
jmp 0x48bc
movq %rax, %rbx
jmp 0x48c5
movq %rax, %rbx
jmp 0x48d1
movq %rax, %rbx
jmp 0x48dd
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x22a8
leaq -0xd8(%rbp), %rdi
callq 0x22a8
leaq -0xb8(%rbp), %rdi
callq 0x22a8
leaq -0xf8(%rbp), %rdi
callq 0x22a8
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpl $0x0, 0x48(%rsi)
js 0x490e
leaq 0x2b3d(%rip), %rsi      # 0x7445
leaq -0xa(%rbp), %rdx
jmp 0x4919
leaq 0x2b42(%rip), %rsi      # 0x7457
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x2c78
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x78, %rsp
movq %rdi, %rbx
leaq 0x683d(%rip), %r14      # 0xb190
movq 0x8(%r14), %r12
subq (%r14), %r12
leaq 0x2bd1(%rip), %rsi      # 0x7532
leaq -0x98(%rbp), %rdi
leaq -0x2a(%rbp), %rdx
callq 0x2c78
movq %rbx, -0x38(%rbp)
leaq 0x8(%rbx), %rsi
leaq 0x2b12(%rip), %rdx      # 0x7492
leaq -0x78(%rbp), %rdi
callq 0x39a9
leaq 0x2ba2(%rip), %rsi      # 0x7532
leaq -0x58(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x2c78
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x4e84
shrq $0x3, %r12
leaq -0x58(%rbp), %rdi
callq 0x22a8
leaq -0x78(%rbp), %rdi
callq 0x22a8
leaq -0x98(%rbp), %rdi
callq 0x22a8
movq (%r14), %r13
movq 0x8(%r14), %rbx
cmpq %rbx, %r13
je 0x4a1a
movq (%r13), %r14
movq %r14, %rdi
callq 0x3900
cmpl $0x7, %eax
je 0x4a14
movq -0x38(%rbp), %rax
movl 0x2c(%rax), %eax
cltd
idivl %r12d
movl %eax, %r15d
movq %r14, %rdi
callq 0x38f6
subl %eax, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x36ac
addq $0x8, %r13
jmp 0x49da
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x22a8
jmp 0x4a3a
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x22a8
jmp 0x4a48
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x22a8
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2050
pushq $0x3
popq %r15
cltd
idivl %r15d
movl %edx, %r14d
callq 0x2050
cltd
idivl %r15d
cmpl $0x1, %r14d
je 0x4ab0
testl %r14d, %r14d
jne 0x4ac2
movslq %edx, %rax
leaq 0x66f9(%rip), %rcx      # 0xb190
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3428
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4938
leaq 0x66c7(%rip), %rax      # 0xb190
movq (%rax), %rax
movslq %edx, %rcx
movq 0x18(%rax,%rcx,8), %rsi
pushq $0x14
popq %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x36c6
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x648d(%rip), %rbx      # 0xafc8
leaq 0x2977(%rip), %rsi      # 0x74b9
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20b0
leaq 0x2979(%rip), %rsi      # 0x74d2
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20b0
leaq 0x29c1(%rip), %rsi      # 0x7531
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20b0
pushq $0x2
popq %rdi
callq 0x2110
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4b94
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
leaq -0x70(%rbp), %rdi
callq 0x21e0
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x21e0
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4f26
leaq -0x30(%rbp), %rdi
callq 0x22a8
leaq -0x50(%rbp), %rdi
callq 0x22a8
leaq -0x70(%rbp), %rdi
callq 0x22a8
pushq $0x2
popq %rdi
callq 0x2110
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x22a8
jmp 0x4f07
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x22a8
jmp 0x4f15
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x22a8
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, %r15
callq 0x4af4
movq 0x6082(%rip), %r12      # 0xafc8
movq %r12, %rdi
movq %r15, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x20b0
movq %r12, %rdi
movq %r14, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x20b0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2150
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
nop