LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc253
movq %rsi, %r14
movq 0x20(%rsi), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
testb %al, %al
je 0xc23e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x3526(%rip), %rsi      # 0xf75b
leaq 0x3526(%rip), %rdx      # 0xf762
jmp 0xc268
cmpq $0x0, 0x30(%r14)
je 0xc253
movq 0x20(%r14), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
testb %al, %al
je 0xc27b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x3509(%rip), %rsi      # 0xf76a
leaq 0x3509(%rip), %rdx      # 0xf771
movq %rbx, %rdi
callq 0x64c4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x34da(%rip), %rsi      # 0xf763
leaq 0x34d9(%rip), %rdx      # 0xf769
jmp 0xc268
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movups 0x28(%rsi), %xmm0
movups 0x28(%rdi), %xmm1
movups %xmm0, 0x28(%rdi)
movq 0x38(%rsi), %rcx
movq %rcx, 0x38(%rdi)
movq %rsp, %rdi
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rsi)
movq $0x0, 0x38(%rsi)
callq 0xc5e2
movl 0x18(%rbx), %edi
testl %edi, %edi
js 0xe0fb
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 $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe26e
callq 0x53d0
movl $0xffffffff, 0x50(%rbx) # imm = 0xFFFFFFFF
movb $0x1, 0x54(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x9e3c
movq $0x0, (%rsp)
movl $0x78, %edi
callq 0x5390
movq %rax, %r14
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x8(%r14)
leaq 0x79f7(%rip), %rax      # 0x15cf0
movq %rax, (%r14)
leaq 0x10(%r14), %r12
movl 0x50(%r15), %esi
leaq 0x20(%rsp), %rcx
movq %r15, (%rcx)
movq %rbx, 0x8(%rcx)
leaq 0x4d3(%rip), %rax       # 0xe7ea
movq %rax, 0x18(%rcx)
leaq 0x5ba(%rip), %rax       # 0xe8dc
movq %rax, 0x10(%rcx)
movq %r12, %rdi
movq %r13, %rdx
callq 0x7702
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xe34a
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, 0x8(%rsp)
movq %r12, (%rsp)
movq 0x20(%r14), %rax
testq %rax, %rax
je 0xe363
movl 0x8(%rax), %eax
testl %eax, %eax
jne 0xe383
leaq 0x8(%rsp), %r13
movq %r14, %rdi
addq $0x20, %rdi
movq %r12, 0x18(%r14)
movq %r13, %rsi
callq 0xc630
movq -0x8(%r13), %r12
movq (%r13), %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq %r12, 0x78(%r15)
movq 0x80(%r15), %rdi
movq %r14, 0x80(%r15)
testq %rdi, %rdi
je 0xe3bc
callq 0x69c2
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xe3b5
callq 0x69c2
movq 0x80(%r15), %r14
movq 0x78(%r15), %rax
movq %rax, 0x10(%rsp)
movq %r14, 0x18(%rsp)
testq %r14, %r14
je 0xe3e6
movq 0x7bba(%rip), %rax      # 0x15f90
cmpb $0x0, (%rax)
je 0xe3e1
incl 0xc(%r14)
jmp 0xe3e6
lock
incl 0xc(%r14)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x9c16
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xe429
movq 0x7b8c(%rip), %rax      # 0x15f90
cmpb $0x0, (%rax)
je 0xe414
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xe41e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xe429
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xe48c
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xe484
leaq 0x20(%rsp), %r14
movq %rbx, %rsi
movq %r14, %rcx
callq 0x587c
movq (%r14), %rbx
jmp 0xe484
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xe477
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl $0x78, %esi
movq %r14, %rdi
callq 0x5070
movq %rbx, %rdi
callq 0x5200
movq %rax, %rdi
callq 0x6406
// File: /workspace/github_cpp_makefile_star2_O3/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, (%rsp)
movq %rdi, %r14
leaq 0x58(%rdi), %r15
leaq 0x1513(%rip), %rsi      # 0xf9c7
movl $0x2, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x5170
cmpq $-0x1, %rax
je 0xe585
movq %rax, %r12
leaq 0x8(%rsp), %r13
leaq 0x14eb(%rip), %rbx      # 0xf9c7
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %r12, %rcx
callq 0x5640
movq %r13, %rdi
movq %r14, %rsi
movq (%rsp), %rdx
movq %rbp, %rcx
callq 0x7456
movq %r13, %rdi
movq %rbx, %rsi
callq 0x5530
movq %r14, %rdi
movq (%rsp), %rsi
movq %r13, %rdx
callq 0xe2ae
addq $0x2, %r12
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x5230
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe54a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5070
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xe566
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5070
movl $0x2, %ecx
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5170
movq %rax, %r12
cmpq $-0x1, %rax
jne 0xe4dc
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xe5b8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe5b8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5070
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xe5d4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5070
movq %rbx, %rdi
callq 0x5200
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe66a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe494
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0xe659
movq %r14, %rdi
callq 0x5050
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x7982(%rip), %rdi      # 0x15fa0
movq %rax, %rsi
callq 0x54d0
movq %rax, %rdi
callq 0x52c0
movl 0x50(%rbx), %edi
testl %edi, %edi
js 0xe63a
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 0x6406
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe6a4
movq 0x60(%rbx), %rsi
addq $0x58, %rbx
movq %rsp, %rcx
movq %rbx, %rdi
xorl %edx, %edx
movq %rax, %r8
callq 0x50a0
jmp 0xe6bb
movl 0x50(%rbx), %edi
testl %edi, %edi
js 0xe6b0
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_O3/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), %r12
movq %rcx, 0x8(%rdi)
movq -0x18(%rax), %rdi
addq $-0x20, %rax
movq %rax, 0x8(%rbx)
movl 0x4(%rdi), %r14d
movq %rsp, %r13
leaq 0xf(,%r14,8), %rcx
andq $-0x10, %rcx
subq %rcx, %r13
movq %r13, %rsp
movq 0x10(%rdi), %rcx
movq %rcx, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
testl %r14d, %r14d
jle 0x2bc4
leal 0x1(%r14), %ecx
leaq -0x1(%r14), %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shrl %ecx
shlq $0x4, %rcx
movdqa 0x15d2(%rip), %xmm1     # 0x40f0
xorl %edx, %edx
movdqa 0x15d8(%rip), %xmm2     # 0x4100
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x15d8(%rip), %xmm4     # 0x4110
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm5     # xmm5 = xmm5[1,1,3,3]
pand %xmm6, %xmm5
pshufd $0xf5, %xmm6, %xmm6     # xmm6 = xmm6[1,1,3,3]
por %xmm5, %xmm6
movdqa %xmm1, %xmm5
pxor %xmm3, %xmm5
movd %xmm6, %r9d
notl %r9d
testb $0x1, %r9b
je 0x2b89
movq %xmm5, %r9
shlq $0x4, %r9
addq %rax, %r9
addq $0x8, %r9
movq %r9, (%r13,%rdx)
pxor %xmm3, %xmm6
pextrw $0x4, %xmm6, %r9d
testb $0x1, %r9b
je 0x2bb3
pshufd $0xee, %xmm5, %xmm5     # xmm5 = xmm5[2,3,2,3]
movq %xmm5, %r9
shlq $0x4, %r9
addq %rax, %r9
addq $0x8, %r9
movq %r9, 0x8(%r13,%rdx)
paddq %xmm4, %xmm1
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0x2b38
leaq -0x38(%rbp), %rdx
movl %esi, -0x2c(%rbp)
testb %sil, %sil
je 0x2be5
movq %rdi, %r15
callq 0x2050
leaq -0x38(%rbp), %rdx
movq %r15, %rdi
movl $0x0, (%rax)
movq %r12, %rsi
movq %r13, %rcx
callq 0x2090
movq 0x8(%rbx), %rsi
testl %r14d, %r14d
jle 0x2c0b
decl %r14d
shlq $0x4, %r14
subq %r14, %rsi
addq $-0x10, %rsi
movq %rsi, 0x8(%rbx)
movl -0x2c(%rbp), %r15d
testb %r15b, %r15b
je 0x2c27
callq 0x2050
movl (%rax), %esi
movq %rbx, %rdi
callq 0x3612
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2c3d
movdqu -0x40(%rbp), %xmm0
movdqu %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x2c49
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x383c
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2cc8
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 0x2cb0
movq %r14, %rdi
movl $0x2, %esi
movl %r15d, %edx
movq %r12, %rcx
movq %rax, %r8
callq 0x2270
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37fe
movq 0x28(%rbx), %rsi
cmpq 0x30(%rbx), %rsi
je 0x2cfd
movq %r14, (%rsi)
addq $0x8, 0x28(%rbx)
jmp 0x2d0e
addq $0x20, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x391c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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)
movl $0x1, %esi
callq 0x2200
movq %rax, %r14
movq %rax, (%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x37fe
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x2d9b
movq %r14, (%rsi)
addq $0x8, 0x40(%rbx)
jmp 0x2daa
addq $0x38, %rbx
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x3a58
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x33e7
movq (%r14), %rax
movq 0x8(%rax), %rdi
movl $0x8, %esi
callq 0x2190
movq (%r14), %rdi
movl $0x20, %esi
callq 0x2190
addq $0x8, %r14
jmp 0x33be
movq 0x38(%rbx), %r14
movq 0x40(%rbx), %r15
cmpq %r15, %r14
je 0x340e
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3401
callq 0x2120
addq $0x8, %r14
cmpq %r15, %r14
jne 0x33f4
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x3422
movq 0x48(%rbx), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x2190
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x3437
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x2190
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3450
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_O3/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 0x360a
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 0x4472
leaq 0x10a36(%rip), %rsi     # 0x14004
movq %r15, %rdi
callq 0x3430
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x30e0
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x3640
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x3646
movq 0x38(%r14), %rdx
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testq %rdx, %rdx
je 0x362b
movq 0x30(%r14), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4472
jmp 0x368c
cmpl $0x1, %eax
jne 0x3676
leaq 0x109cf(%rip), %rsi     # 0x14006
leaq 0x109dd(%rip), %rdx     # 0x1401b
jmp 0x3684
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 0x368c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0x368c
leaq 0x1099f(%rip), %rsi     # 0x1401c
leaq 0x109a3(%rip), %rdx     # 0x14027
movq %rbx, %rdi
callq 0x4508
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x369d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x36b7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x95d6(%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 0x9af5(%rip), %rdi      # 0xd190
callq 0x4d24
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x36b1
movq %rax, %r14
movq -0x38(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0x36d0
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4eb8
movl %ecx, 0x44(%rdi)
cmpl %esi, %eax
setge %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x595e
leaq 0x39b2(%rip), %rsi      # 0x9307
leaq 0x39c2(%rip), %rdx      # 0x931e
jmp 0x596c
leaq 0x39ba(%rip), %rsi      # 0x931f
leaq 0x39eb(%rip), %rdx      # 0x9357
movq %rbx, %rdi
callq 0x33fc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x60c7
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 0x6bcc(%rip), %rcx      # 0xcca8
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
leaq 0x6be2(%rip), %rsi      # 0xccd0
movq 0x6eeb(%rip), %rdx      # 0xcfe0
movq %rax, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6125
leaq 0x3278(%rip), %rsi      # 0x9394
leaq 0x3280(%rip), %rdx      # 0x93a3
jmp 0x6133
leaq 0x3278(%rip), %rsi      # 0x93a4
leaq 0x3280(%rip), %rdx      # 0x93b3
movq %rbx, %rdi
callq 0x33fc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6156
popq %rbp
jmp 0x60b0
popq %rbp
jmp 0x5a3c
// File: /workspace/github_cpp_makefile_star2_O3/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 0x628e
decl %eax
movl %eax, (%rdi)
movl 0x4(%rdi), %eax
retq
pushq %rbp
movq %rsp, %rbp
movl $0x8, %edi
callq 0x20d0
leaq 0x6a45(%rip), %rcx      # 0xcce8
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x6a5f(%rip), %rsi      # 0xcd10
movq 0x6d28(%rip), %rdx      # 0xcfe0
movq %rax, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/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 0x639e
movl %ecx, 0x48(%rdi)
cmpl %esi, %eax
setge %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6886
leaq 0x2bc8(%rip), %rsi      # 0x9445
leaq 0x2bd2(%rip), %rdx      # 0x9456
jmp 0x6894
leaq 0x2bca(%rip), %rsi      # 0x9457
leaq 0x2bf5(%rip), %rdx      # 0x9489
movq %rbx, %rdi
callq 0x33fc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x68c5(%rip), %r15      # 0xd190
movq 0x8(%r15), %r12
subq (%r15), %r12
leaq -0x80(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x2c51(%rip), %rdx      # 0x9532
leaq -0x90(%rbp), %rdi
movq %rdx, %rsi
callq 0x33fc
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 0x335e
leaq 0x2b7b(%rip), %rsi      # 0x9492
leaq -0x48(%rbp), %rdi
callq 0x2290
leaq -0x60(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x2c03(%rip), %rdx      # 0x9532
leaq -0x70(%rbp), %rdi
movq %rdx, %rsi
callq 0x33fc
leaq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x70b2
movq -0x70(%rbp), %rdi
cmpq %rbx, %rdi
je 0x6964
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x6979
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x6991
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x21c0
movq (%r15), %r13
movq 0x8(%r15), %rbx
cmpq %rbx, %r13
je 0x69df
shrq $0x3, %r12
movq (%r13), %r14
movq %r14, %rdi
callq 0x4c70
cmpl $0x7, %eax
je 0x69d6
movq -0x50(%rbp), %rax
movl 0x2c(%rax), %eax
cltd
idivl %r12d
movl %eax, %r15d
movq %r14, %rdi
callq 0x4c66
subl %eax, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x4542
addq $0x8, %r13
cmpq %rbx, %r13
jne 0x69a1
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 0x6a0d
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x6a0d
jmp 0x6a0a
movq %rax, %r15
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x6a27
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x6a27
movq %rax, %r15
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x6a3f
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %r15, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6abb
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 0x6ac7
cltq
leaq 0x66e8(%rip), %rcx      # 0xd190
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3d7e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x68b0
leaq 0x66c2(%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 0x455c
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6471(%rip), %rbx      # 0xcfc8
leaq 0x295b(%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 0x2939(%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 0x295d(%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 0x6c1e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x335e
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x335e
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x335e
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x71d4
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x713f
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x7154
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x7169
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 0x719d
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x719d
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x71b7
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x71b7
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x71cc
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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 0x335e
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x335e
leaq 0x2202(%rip), %rsi      # 0x94fc
leaq -0x40(%rbp), %rdi
callq 0x2290
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x221e(%rip), %rsi      # 0x9531
leaq 0x2218(%rip), %rdx      # 0x9532
leaq -0x68(%rbp), %rdi
callq 0x33fc
leaq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x71d4
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x734c
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x7361
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x88(%rbp), %rdi
cmpq %r14, %rdi
je 0x7379
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21c0
movq 0x5e50(%rip), %rsi      # 0xd1d0
movq 0x5e51(%rip), %rdx      # 0xd1d8
movq 0x5c3a(%rip), %rdi      # 0xcfc8
callq 0x21e0
movq 0x5c3e(%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 0x73d4
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x73d4
jmp 0x73d1
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x73ee
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x73ee
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r14, %rdi
je 0x7406
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/Matteo-Grellier[P]RPG/Menu.cpp
// Function: Menu::isEndOfCombat()
bool Menu::isEndOfCombat(){

    int deadGoodGuys = 0;
    int deadMonsters = 0;
    string awnser = "none";

    for (Character* c : Character::charactersList) { //for every characters
        
        if(c->getCurrentHp() <= 0 && c->getJob() != 7) {
            deadGoodGuys++;

        } else if(c->getCurrentHp() <= 0 && c->getJob() == 7) {
            deadMonsters++;

        }

        if (deadMonsters == 3) {
            end("win");
            return true;

        } else if (deadGoodGuys == 3) {
            end("defeat");
            return true;
        }

    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ff4(%rip), %rsi      # 0x9622
leaq 0x1ff1(%rip), %rdx      # 0x9626
leaq -0x48(%rbp), %rdi
callq 0x33fc
leaq 0x5b4b(%rip), %rax      # 0xd190
movq (%rax), %r12
movq 0x8(%rax), %r13
xorl %ebx, %ebx
cmpq %r13, %r12
je 0x7730
xorl %r15d, %r15d
movq (%r12), %r14
movq %r14, %rdi
callq 0x3d5c
testl %eax, %eax
jg 0x7677
movq %r14, %rdi
callq 0x4c70
cmpl $0x7, %eax
jne 0x769b
movq %r14, %rdi
callq 0x3d5c
testl %eax, %eax
jg 0x76a2
movq %r14, %rdi
callq 0x4c70
cmpl $0x7, %eax
jne 0x76a2
incl %r15d
cmpl $0x3, %r15d
jne 0x76a2
jmp 0x76e5
incl %ebx
cmpl $0x3, %ebx
je 0x76b3
addq $0x8, %r12
cmpq %r13, %r12
jne 0x765a
xorl %ebx, %ebx
leaq -0x38(%rbp), %r15
jmp 0x7730
leaq -0x58(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1f69(%rip), %rsi      # 0x962b
leaq 0x1f68(%rip), %rdx      # 0x9631
leaq -0x68(%rbp), %rdi
callq 0x33fc
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %r15
callq 0x8350
movq -0x68(%rbp), %rdi
jmp 0x771e
leaq -0x78(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1f33(%rip), %rsi      # 0x9627
leaq 0x1f2f(%rip), %rdx      # 0x962a
leaq -0x88(%rbp), %rdi
callq 0x33fc
leaq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %r15
callq 0x8350
movq -0x88(%rbp), %rdi
cmpq %r14, %rdi
je 0x772e
movq (%r14), %rsi
incq %rsi
callq 0x21c0
movb $0x1, %bl
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x7745
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r14, %rdi
je 0x778c
movq -0x78(%rbp), %rsi
jmp 0x777d
jmp 0x7789
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r14, %rdi
je 0x778c
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x778c
jmp 0x7789
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x77a5
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/Matteo-Grellier[P]RPG/Menu.cpp
// Function: Menu::end(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Menu::end(string endtype){

    if ( endtype == "win") {
        toScreen(
        "",
        "you won mate, well done !",
        "");
        sleep(1);

    } else if ( endtype == "defeat") {
        toScreen(
        "",
        "you failed poor noob...",
        "");
        sleep(1);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
leaq 0x12bb(%rip), %rsi      # 0x9627
callq 0x2070
testl %eax, %eax
je 0x8436
leaq 0x12ab(%rip), %rsi      # 0x962b
movq %rbx, %rdi
callq 0x2070
testl %eax, %eax
jne 0x8500
leaq -0xb0(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1190(%rip), %rdx      # 0x9532
leaq -0xc0(%rbp), %rdi
movq %rdx, %rsi
callq 0x33fc
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x128c(%rip), %rsi      # 0x964c
leaq 0x129c(%rip), %rdx      # 0x9663
leaq -0x60(%rbp), %rdi
callq 0x33fc
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x1152(%rip), %rdx      # 0x9532
leaq -0x40(%rbp), %rdi
movq %rdx, %rsi
callq 0x33fc
leaq -0xc0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x70b2
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x8415
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x842a
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0xc0(%rbp), %rdi
jmp 0x84e6
leaq -0xd0(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x10ea(%rip), %rdx      # 0x9532
leaq -0xe0(%rbp), %rdi
movq %rdx, %rsi
callq 0x33fc
leaq -0x90(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x11c9(%rip), %rsi      # 0x9632
leaq 0x11db(%rip), %rdx      # 0x964b
leaq -0xa0(%rbp), %rdi
callq 0x33fc
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x10a6(%rip), %rdx      # 0x9532
leaq -0x80(%rbp), %rdi
movq %rdx, %rsi
callq 0x33fc
leaq -0xe0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x70b2
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x84c4
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0xa0(%rbp), %rdi
cmpq %r15, %rdi
je 0x84df
movq -0x90(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0xe0(%rbp), %rdi
cmpq %r14, %rdi
je 0x84f6
movq (%r14), %rsi
incq %rsi
callq 0x21c0
movl $0x1, %edi
callq 0x2130
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x852d
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x852d
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x8547
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x8547
movq %rax, %rbx
movq -0xc0(%rbp), %rdi
jmp 0x8594
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x856d
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x856d
movq %rax, %rbx
movq -0xa0(%rbp), %rdi
cmpq %r15, %rdi
je 0x858d
movq -0x90(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x858d
movq %rax, %rbx
movq -0xe0(%rbp), %rdi
cmpq %r14, %rdi
je 0x85a4
movq (%r14), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/srcmake[P]tries/src/trie.hpp
// Function: Trie::Insert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Trie::Insert(const std::string& word)
	{
	// Starting from the root, traverse/create nodes for each char in the string.
	Node* currNode = root;

	for(int i = 0; i < word.length(); i++)
		{
		char c = word[i];

		// Check if this char has a node created for it yet.
		std::unordered_map<char, Node*>::const_iterator it = currNode->nextNodesMap.find(c);
		
		// If the next node doesn't exist, create it. Otherwise just get the existing one.
		Node* nextNode = it == currNode->nextNodesMap.end() ? new Node(c) : currNode->nextNodesMap[c];
		
		// In case the next node is newly created, make the current node update it's pointer to point to it.
		currNode->nextNodesMap[c] = nextNode;

		// Update currNode for the next iteration.
		currNode = nextNode;

		// If this is the last character in the word, mark the node as the end of the word.
		if(i == word.length() - 1)
			{
			currNode->isEndOfWord = true;
			}
		}
	}

// Assembly:
cmpq $0x0, 0x8(%rsi)
je 0x13b4
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r15
xorl %r13d, %r13d
leaq -0x29(%rbp), %r14
movq (%rbx), %rax
movb (%rax,%r13), %al
movb %al, -0x29(%rbp)
movq %r15, %r12
addq $0x8, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x195e
testq %rax, %rax
je 0x133d
movq %r12, %rdi
movq %r14, %rsi
callq 0x19c2
movq (%rax), %r15
jmp 0x137a
movl $0x40, %edi
callq 0x10c0
movq %rax, %r15
addq $0x38, %rax
movq %rax, 0x8(%r15)
movq $0x1, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movl $0x3f800000, 0x28(%r15) # imm = 0x3F800000
movups %xmm0, 0x30(%r15)
movb -0x29(%rbp), %al
movb %al, (%r15)
movb $0x0, 0x1(%r15)
movq %r12, %rdi
movq %r14, %rsi
callq 0x19c2
movq %r15, (%rax)
movq 0x8(%rbx), %rax
leaq -0x1(%rax), %rcx
cmpq %rcx, %r13
jne 0x139a
movb $0x1, 0x1(%r15)
incq %r13
cmpq %r13, %rax
ja 0x130c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/srcmake[P]tries/src/trie.hpp
// Function: Trie::Contains(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Trie::Contains(const std::string& word)
	{
	// Starting from the root, traverse nodes for each char in the string.
	Node* currNode = root;

	for(int i = 0; i < word.length(); i++)
		{
		char c = word[i];

		// Check if this char has a node created for it yet.
		std::unordered_map<char, Node*>::const_iterator it = currNode->nextNodesMap.find(c);
		
		// Get the next node if it exists.
		Node* nextNode = it == currNode->nextNodesMap.end() ? NULL : currNode->nextNodesMap[c];
		
		// If the next node doesn't exist...our Trie doesn't contain it. Return false.
		if(nextNode == NULL) { return false; }
	
		// Update currNode for the next iteration.
		currNode = nextNode;

		// If this is the last character in the word, check if it's marked as the return of a word.
		if(i == word.length() - 1)
			{ return currNode->isEndOfWord; }
		}
	
	return false;
	}

// Assembly:
cmpq $0x0, 0x8(%rsi)
je 0x1423
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq (%rdi), %r15
xorl %r12d, %r12d
leaq -0x21(%rbp), %r14
movq (%rbx), %rax
movb (%rax,%r12), %al
movb %al, -0x21(%rbp)
addq $0x8, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x195e
testq %rax, %rax
je 0x141f
movq %r15, %rdi
movq %r14, %rsi
callq 0x19c2
movq (%rax), %r15
testq %r15, %r15
je 0x141f
movq 0x8(%rbx), %rax
leaq -0x1(%rax), %rcx
cmpq %rcx, %r12
je 0x1426
incq %r12
cmpq %r12, %rax
ja 0x13d9
xorl %eax, %eax
jmp 0x142a
xorl %eax, %eax
retq
movb 0x1(%r15), %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/srcmake[P]tries/src/trie.hpp
// Function: Trie::PrefixExists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Trie::PrefixExists(const std::string& prefix)
	{
	// Starting from the root, traverse nodes for each char in the string.
	Node* currNode = root;

	for(int i = 0; i < prefix.length(); i++)
		{
		char c = prefix[i];

		// Check if this char has a node created for it yet.
		std::unordered_map<char, Node*>::const_iterator it = currNode->nextNodesMap.find(c);
		
		// Get the next node if it exists.
		Node* nextNode = it == currNode->nextNodesMap.end() ? NULL : currNode->nextNodesMap[c];

		// If the nextNode doesn't exist, then this prefix doesn't exist in our Trie.
		if(nextNode == NULL) { return false; }
	
		// Update currNode for the next iteration.
		currNode = nextNode;

		// If this is the last character in the prefix, then this prefix did exist.
		if(i == prefix.length() - 1)
			{ return true; }
		}
	
	return false;
	}

// Assembly:
cmpq $0x0, 0x8(%rsi)
je 0x14b5
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq (%rdi), %r15
xorl %r12d, %r12d
leaq -0x21(%rbp), %r14
movq (%rbx), %rax
movb (%rax,%r12), %al
movb %al, -0x21(%rbp)
addq $0x8, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x195e
testq %rax, %rax
je 0x14a6
movq %r15, %rdi
movq %r14, %rsi
callq 0x19c2
movq (%rax), %r15
testq %r15, %r15
je 0x14a6
movq 0x8(%rbx), %rcx
leaq -0x1(%rcx), %rax
cmpq %rax, %r12
sete %al
je 0x14a8
incq %r12
cmpq %r12, %rcx
ja 0x145b
jmp 0x14a8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/main.cpp
// Function: main
int main(int argc, char **argv) {
  if (argc < 2) {
	printf("usage: %s bin", argv[0]);
	return 1;
  }

  setbuf(stdin, NULL);
  setbuf(stdout, NULL);

  int fd = open(argv[1], O_RDONLY);
  if (fd < 0) {
	perror("open");
	return 1;
  }

  read(fd, mem, 0xf000);

  mos6502 emu((BusRead)MemRead, (BusWrite)MemWrite);
  emu.Reset();
  emu.Run(0xf000);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x2098, %rsp           # imm = 0x2098
movq %rsi, %rbx
cmpl $0x1, %edi
jg 0x24ac
movq (%rbx), %rsi
leaq 0x4b69(%rip), %rdi      # 0x7004
xorl %eax, %eax
callq 0x2040
movl $0x1, %eax
jmp 0x2564
movq 0x7b15(%rip), %rax      # 0x9fc8
movq (%rax), %rdi
xorl %esi, %esi
callq 0x21d0
movq 0x7ae4(%rip), %rax      # 0x9fa8
movq (%rax), %rdi
xorl %esi, %esi
callq 0x21d0
movq 0x8(%rbx), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x2110
testl %eax, %eax
js 0x256e
leaq 0x7c96(%rip), %rsi      # 0xa180
movl $0xf000, %edx           # imm = 0xF000
movl %eax, %edi
callq 0x21e0
leaq -0xb6(%rip), %rsi       # 0x2447
leaq -0xf8(%rip), %rdx       # 0x240c
leaq -0x20a0(%rbp), %rbx
movq %rbx, %rdi
callq 0x340c
movq %rbx, %rdi
callq 0x5786
leaq -0x20a0(%rbp), %rdi
movl $0xf000, %esi           # imm = 0xF000
callq 0x5966
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x25ee
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x254d
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2190
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x2562
movq -0x58(%rbp), %rsi
subq %rdi, %rsi
callq 0x2190
xorl %eax, %eax
addq $0x2098, %rsp           # imm = 0x2098
popq %rbx
popq %rbp
retq
leaq 0x4a9d(%rip), %rdi      # 0x7012
callq 0x2150
jmp 0x24a2
movq %rax, %rbx
leaq -0x20a0(%rbp), %rdi
callq 0x2596
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::DumpStatus(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void mos6502::DumpStatus(std::vector<std::string> &args) {
  std::cout << "--- Status ---" << std::endl;
  printf("  A : 0x%x\n  X : 0x%x\n  Y : 0x%x\n", A, X, Y);
  std::cout << " sp : 0x" << std::hex << sp << std::endl;
  std::cout << " pc : 0x" << std::hex << pc << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x755e(%rip), %rbx      # 0x9fd0
leaq 0x45e9(%rip), %rsi      # 0x7062
movl $0xe, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movzbl (%r14), %esi
movzbl 0x1(%r14), %edx
movzbl 0x2(%r14), %ecx
leaq 0x45af(%rip), %rdi      # 0x7071
xorl %eax, %eax
callq 0x2040
leaq 0x45c3(%rip), %rsi      # 0x7093
movl $0x8, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x20d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x456d(%rip), %rsi      # 0x709c
movl $0x8, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
movzwl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0x20d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20e0