LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Unreality3D[P]Unreality3D/indie-studio/source/Network/Broker.cpp
// Function: network::Broker::onReadPossible(Socket::Server&, int, unsigned long)
void	Broker::onReadPossible(Socket::Server &s, int fd, size_t size)
  {
    auto found = _clients.find(fd);
    char *tmp;

    if (found != _clients.end())
      {
	tmp = new char[size];
	s.read(fd, tmp, size);
	(*found).second.deserializer(IndieProtocol::Serialized(size, tmp));
	delete[] tmp;
      }
  }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x180, %rdi            # imm = 0x180
leaq 0x64(%rsp), %rsi
callq 0x2ad40
movq 0x18(%rsp), %rdi
movq %rax, 0x50(%rsp)
addq $0x180, %rdi            # imm = 0x180
callq 0x2b860
movq %rax, 0x40(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x28750
testb $0x1, %al
jne 0x37625
jmp 0x376c6
movq 0x58(%rsp), %rdi
callq 0x28030
movq %rax, 0x48(%rsp)
movq 0x68(%rsp), %rdi
movl 0x64(%rsp), %esi
movq 0x48(%rsp), %rdx
movq 0x58(%rsp), %rcx
callq 0x2bb00
leaq 0x50(%rsp), %rdi
callq 0x2b060
addq $0x30, %rax
movq %rax, 0x8(%rsp)
movl 0x58(%rsp), %esi
movq 0x48(%rsp), %rdx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2a480
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2ab40
jmp 0x37688
leaq 0x30(%rsp), %rdi
callq 0x295d0
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x376aa
movq (%rsp), %rdi
callq 0x2a870
jmp 0x376c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x295d0
jmp 0x376cb
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x2b6f0
nopw %cs:(%rax,%rax)
// File: Unreality3D[P]Unreality3D/indie-studio/source/Network/Broker.cpp
// Function: network::Broker::onWritePossible(Socket::Server&, int)
void	Broker::onWritePossible(Socket::Server &s, int fd)
  {
    auto found = _clients.find(fd);
    IndieProtocol::Serialized tmp;

    if (found != _clients.end())
      {
	while ((*found).second.writeBuffer.size())
	  {
	    tmp = (*found).second.writeBuffer.back();
	    (*found).second.writeBuffer.pop_back();
	    s.write(fd, tmp.data, tmp.size);
	  }
      }
  }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x180, %rdi            # imm = 0x180
leaq 0x44(%rsp), %rsi
callq 0x2ad40
movq %rax, 0x38(%rsp)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x2a480
movq 0x8(%rsp), %rdi
addq $0x180, %rdi            # imm = 0x180
callq 0x2b860
movq %rax, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x28750
testb $0x1, %al
jne 0x37750
jmp 0x377f2
jmp 0x37752
leaq 0x38(%rsp), %rdi
callq 0x2b060
movq %rax, %rdi
addq $0x8, %rdi
addq $0xb8, %rdi
callq 0x284e0
cmpq $0x0, %rax
je 0x377f0
leaq 0x38(%rsp), %rdi
callq 0x2b060
movq %rax, %rdi
addq $0xc0, %rdi
callq 0x2b590
movq %rax, %rsi
leaq 0x28(%rsp), %rdi
callq 0x289e0
jmp 0x3779d
leaq 0x38(%rsp), %rdi
callq 0x2b060
movq %rax, %rdi
addq $0xc0, %rdi
callq 0x2aa40
movq 0x48(%rsp), %rdi
movl 0x44(%rsp), %esi
movq 0x30(%rsp), %rdx
movl 0x28(%rsp), %eax
movl %eax, %ecx
callq 0x2ba10
jmp 0x377d1
jmp 0x37752
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x295d0
jmp 0x37801
jmp 0x377f2
leaq 0x28(%rsp), %rdi
callq 0x295d0
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x2b6f0
nopl (%rax,%rax)
// File: Unreality3D[P]Unreality3D/indie-studio/source/Network/Broker.cpp
// Function: network::Broker::onPacketConnect(int, IndieProtocol::Connect)
void	Broker::onPacketConnect(int fd, IndieProtocol::Connect conn)
  {
    std::cout << "FD : " << fd << " : CONNECT" << std::endl;
    std::cout << conn.name << std::endl;

    auto found = _clients.find(fd);
    if (found == _clients.end())
      {
	_clients[fd] = Client(fd);
	found = _clients.find(fd);
      }
    (*found).second.connected = true;
    (*found).second.name = conn.name;
  }

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdx, 0x8(%rsp)
movq %rdi, 0x120(%rsp)
movl %esi, 0x11c(%rsp)
movq %rdx, 0x110(%rsp)
movq 0x120(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x1b6e9(%rip), %rdi     # 0x52fb0
leaq 0xeba4(%rip), %rsi      # 0x46472
callq 0x2a030
movq %rax, %rdi
movl 0x11c(%rsp), %esi
callq 0x2b5c0
movq %rax, %rdi
leaq 0xeb8c(%rip), %rsi      # 0x46478
callq 0x2a030
movq %rax, %rdi
movq 0x1b665(%rip), %rsi     # 0x52f60
callq 0x2a150
movq 0x8(%rsp), %rsi
movq 0x1b6a4(%rip), %rdi     # 0x52fb0
callq 0x29c50
movq %rax, %rdi
movq 0x1b645(%rip), %rsi     # 0x52f60
callq 0x2a150
movq 0x10(%rsp), %rdi
addq $0x180, %rdi            # imm = 0x180
leaq 0x11c(%rsp), %rsi
callq 0x2ad40
movq 0x10(%rsp), %rdi
movq %rax, 0x108(%rsp)
addq $0x180, %rdi            # imm = 0x180
callq 0x2b860
movq %rax, 0x100(%rsp)
leaq 0x108(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0x2b6b0
testb $0x1, %al
jne 0x37978
jmp 0x37a09
movl 0x11c(%rsp), %esi
leaq 0x30(%rsp), %rdi
callq 0x28d90
movq 0x10(%rsp), %rdi
addq $0x180, %rdi            # imm = 0x180
leaq 0x11c(%rsp), %rsi
callq 0x2ae00
movq %rax, (%rsp)
jmp 0x379a8
movq (%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2b220
jmp 0x379b8
leaq 0x30(%rsp), %rdi
callq 0x2a600
movq 0x10(%rsp), %rdi
addq $0x180, %rdi            # imm = 0x180
leaq 0x11c(%rsp), %rsi
callq 0x2ad40
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x108(%rsp)
jmp 0x37a09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2a600
jmp 0x37a44
leaq 0x108(%rsp), %rdi
callq 0x2b060
movb $0x1, 0x8(%rax)
leaq 0x108(%rsp), %rdi
callq 0x2b060
movq 0x8(%rsp), %rsi
movq %rax, %rdi
addq $0x8, %rdi
addq $0x8, %rdi
callq 0x28090
addq $0x128, %rsp            # imm = 0x128
retq
movq 0x28(%rsp), %rdi
callq 0x2b6f0
nop
// File: Unreality3D[P]Unreality3D/indie-studio/source/Network/protocol/Deserializer.cpp
// Function: IndieProtocol::Deserializer::deserializeConnect(IndieProtocol::Serialized const&)
void	Deserializer::deserializeConnect(Serialized const &to_handle)
  {
    Connect	conn;
    uint32_t	pos = 0;

    if (!_OnConnect)
      return ;

    if (!deserializeString(to_handle, pos, conn.name))
      return ;

    _OnConnect(conn);
  }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x2b730
movq 0x20(%rsp), %rdx
leaq 0x95e8(%rip), %rsi      # 0x46477
leaq 0x68(%rsp), %rdi
callq 0x2aa80
jmp 0x3ce9b
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x29b30
jmp 0x3ceaf
leaq 0x68(%rsp), %rdi
callq 0x29360
leaq 0x67(%rsp), %rdi
callq 0x2a210
movq 0x18(%rsp), %rdi
movl $0x0, 0x50(%rsp)
addq $0x40, %rdi
callq 0x28850
testb $0x1, %al
jne 0x3cf21
movl $0x1, 0x4c(%rsp)
jmp 0x3cfaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x3cf12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x29360
leaq 0x67(%rsp), %rdi
callq 0x2a210
jmp 0x3cfe9
movq 0x18(%rsp), %rdi
movq 0xa8(%rsp), %rsi
leaq 0x50(%rsp), %rdx
leaq 0x88(%rsp), %rcx
callq 0x2b610
movb %al, 0x17(%rsp)
jmp 0x3cf46
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x3cf6a
jmp 0x3cf50
movl $0x1, 0x4c(%rsp)
jmp 0x3cfaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x3cfdc
movq 0x18(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x2b550
jmp 0x3cf8c
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x296c0
jmp 0x3cf9d
leaq 0x28(%rsp), %rdi
callq 0x29140
movl $0x0, 0x4c(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x29140
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x29140
leaq 0x88(%rsp), %rdi
callq 0x29140
movq 0x58(%rsp), %rdi
callq 0x2b6f0
nopw %cs:(%rax,%rax)
// File: Unreality3D[P]Unreality3D/indie-studio/source/Network/protocol/Deserializer.cpp
// Function: IndieProtocol::Deserializer::deserializeList(IndieProtocol::Serialized const&)
void	Deserializer::deserializeList(Serialized const &to_handle)
  {
    List	list;
    uint16_t	listSize;
    uint32_t	pos = 0;
    std::string tmp;

    if (!_OnList)
      return ;

    memcpy(&listSize, to_handle.data, sizeof(listSize));
    pos += sizeof(listSize);

    for (uint16_t i = 0; i < listSize; ++i)
      {
	if (!deserializeString(to_handle, pos, tmp))
	    return ;
	list.clients.push_back(tmp);
      }
    _OnList(list);
  }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x2b950
movl $0x0, 0x68(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2ab50
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x282f0
testb $0x1, %al
jne 0x3d05f
movl $0x1, 0x44(%rsp)
jmp 0x3d140
movq 0x88(%rsp), %rax
movq 0x8(%rax), %rax
movw (%rax), %ax
movw %ax, 0x6e(%rsp)
movl 0x68(%rsp), %eax
addq $0x2, %rax
movl %eax, 0x68(%rsp)
movw $0x0, 0x42(%rsp)
movzwl 0x42(%rsp), %eax
movzwl 0x6e(%rsp), %ecx
cmpl %ecx, %eax
jge 0x3d100
movq 0x10(%rsp), %rdi
movq 0x88(%rsp), %rsi
leaq 0x68(%rsp), %rdx
leaq 0x48(%rsp), %rcx
callq 0x2b610
movb %al, 0xf(%rsp)
jmp 0x3d0b6
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x3d0dd
jmp 0x3d0c0
movl $0x1, 0x44(%rsp)
jmp 0x3d140
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x3d174
leaq 0x70(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x28f70
jmp 0x3d0ee
jmp 0x3d0f0
movw 0x42(%rsp), %ax
addw $0x1, %ax
movw %ax, 0x42(%rsp)
jmp 0x3d086
movq 0x10(%rsp), %rax
addq $0x20, %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x28e80
jmp 0x3d11e
movq (%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x299c0
jmp 0x3d12e
leaq 0x18(%rsp), %rdi
callq 0x2baa0
movl $0x0, 0x44(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x29360
leaq 0x70(%rsp), %rdi
callq 0x2baa0
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x2baa0
leaq 0x48(%rsp), %rdi
callq 0x29360
leaq 0x70(%rsp), %rdi
callq 0x2baa0
movq 0x38(%rsp), %rdi
callq 0x2b6f0
nopw %cs:(%rax,%rax)
// File: Unreality3D[P]Unreality3D/indie-studio/source/Network/protocol/Deserializer.cpp
// Function: IndieProtocol::Deserializer::deserializeString(IndieProtocol::Serialized const&, unsigned int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool	Deserializer::deserializeString
  (Serialized const &to_handle, uint32_t &pos, std::string &to_change)
  {
    uint16_t	size;

    memcpy(&size, to_handle.data + pos, sizeof(size));
    pos += sizeof(size);
    // error
    if (pos + size + sizeof(Header) > _header.size)
      return false;

    char buffer[size + 1];
    memcpy(buffer, to_handle.data + pos, size);
    buffer[size] = '\0';
    pos += size;
    to_change = std::string(buffer);
    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rdx
movl (%rdx), %edx
movw (%rax,%rdx), %ax
movw %ax, -0x2a(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edx
addq $0x2, %rdx
movl %edx, (%rax)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movzwl -0x2a(%rbp), %edx
addl %edx, %eax
movl %eax, %eax
addq $0x6, %rax
movl (%rcx), %ecx
cmpq %rcx, %rax
jbe 0x3d713
movb $0x0, -0x1(%rbp)
jmp 0x3d7db
movzwl -0x2a(%rbp), %ecx
movl %ecx, %eax
incl %eax
movq %rsp, %rdx
movq %rdx, -0x38(%rbp)
addl $0x10, %ecx
andl $-0x10, %ecx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x88(%rbp)
movq %rdi, %rsp
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movl (%rax), %eax
addq %rax, %rsi
movzwl -0x2a(%rbp), %eax
movl %eax, %edx
callq 0x29a50
movq -0x88(%rbp), %rax
movzwl -0x2a(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movzwl -0x2a(%rbp), %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl %edx, %ecx
movl %ecx, (%rax)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x2b730
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x2aa80
jmp 0x3d798
movq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2a6a0
leaq -0x60(%rbp), %rdi
callq 0x29360
leaq -0x61(%rbp), %rdi
callq 0x2a210
movb $0x1, -0x1(%rbp)
movq -0x38(%rbp), %rax
movq %rax, %rsp
jmp 0x3d7db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x61(%rbp), %rdi
callq 0x2a210
jmp 0x3d7e5
movb -0x1(%rbp), %al
andb $0x1, %al
movq %rbp, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x2b6f0
nop
// File: Unreality3D[P]Unreality3D/indie-studio/include/Network/protocol/IndieProtocol.hpp
// Function: IndieProtocol::Serialized::operator+(IndieProtocol::Serialized const&) const
Serialized operator+ (Serialized const &oth) const
    {
      Serialized result;

      result.size = size + oth.size;
      result.data = new char[result.size];
      memcpy(result.data, data, size);
      memcpy(result.data + size, oth.data, oth.size);
      return result;
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x3f(%rsp)
xorl %esi, %esi
movl %esi, %edx
callq 0x2a480
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movl (%rax), %eax
movq 0x40(%rsp), %rcx
movl (%rcx), %ecx
addl %ecx, %eax
movl %eax, (%rdi)
movl (%rdi), %eax
movl %eax, %edi
callq 0x28030
movq %rax, 0x20(%rsp)
jmp 0x3dfff
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rdx
movq %rdx, 0x8(%rcx)
movq 0x8(%rcx), %rdi
movq 0x8(%rax), %rsi
movl (%rax), %eax
movl %eax, %edx
callq 0x29a50
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rcx), %rdi
movl (%rax), %eax
addq %rax, %rdi
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x40(%rsp), %rax
movl (%rax), %eax
movl %eax, %edx
callq 0x29a50
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x3e07f
jmp 0x3e075
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x295d0
jmp 0x3e089
movq 0x18(%rsp), %rdi
callq 0x295d0
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x2b6f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Unreality3D[P]Unreality3D/indie-studio/source/Network/protocol/Serializer.cpp
// Function: IndieProtocol::Serializer::operator()(IndieProtocol::Connect const&)
Serialized	Serializer::operator() (Connect const &packet)
  {
    uint32_t	size = sizeof(Header) + getStringSize(packet.name);
    Serialized	buff;

    buff.data = new char[size];
    serializeHeader(buff, Header(PacketType::CONNECT, size));
    serializeString(buff, packet.name);

    return buff;
  }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
callq 0x3e950
movq 0x18(%rsp), %rdi
addl $0x6, %eax
movl %eax, 0x4c(%rsp)
movb $0x0, 0x4b(%rsp)
xorl %esi, %esi
movl %esi, %edx
callq 0x2a480
movl 0x4c(%rsp), %eax
movl %eax, %edi
callq 0x28030
movq %rax, 0x20(%rsp)
jmp 0x3e890
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x4c(%rsp), %edx
leaq 0x36(%rsp), %rdi
movl $0x1, %esi
callq 0x2b490
jmp 0x3e8b3
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
movw 0x3a(%rsp), %ax
movw %ax, 0x2c(%rsp)
movl 0x36(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %ecx
movl 0x2c(%rsp), %eax
movl %ecx, %edx
shlq $0x20, %rax
orq %rax, %rdx
callq 0x29740
jmp 0x3e8e7
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq 0x50(%rsp), %rdx
callq 0x2a350
jmp 0x3e8fd
movb $0x1, 0x4b(%rsp)
testb $0x1, 0x4b(%rsp)
jne 0x3e92f
jmp 0x3e925
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x295d0
jmp 0x3e939
movq 0x18(%rsp), %rdi
callq 0x295d0
movq 0x8(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x2b6f0
nopw %cs:(%rax,%rax)
// File: Unreality3D[P]Unreality3D/indie-studio/source/Network/protocol/Serializer.cpp
// Function: IndieProtocol::Serializer::operator()(IndieProtocol::List const&)
Serialized	Serializer::operator() (List const &packet)
  {
    uint32_t	size = sizeof(Header) + sizeof(uint16_t);
    uint16_t	listSize = packet.clients.size();
    Serialized	buff;

    for (auto it = packet.clients.begin(); it != packet.clients.end(); ++it)
      size += getStringSize(*it);

    buff.data = new char[size];
    serializeHeader(buff, Header(PacketType::LIST, size));
    buff.append(&listSize, sizeof(listSize));
    for (auto it = packet.clients.begin(); it != packet.clients.end(); ++it)
      serializeString(buff, *it);

    return buff;
  }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x8, 0x6c(%rsp)
movq 0x70(%rsp), %rdi
callq 0x2b940
movq 0x20(%rsp), %rdi
movw %ax, 0x6a(%rsp)
movb $0x0, 0x69(%rsp)
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x2a480
movq 0x70(%rsp), %rdi
callq 0x28400
movq %rax, 0x60(%rsp)
movq 0x70(%rsp), %rdi
callq 0x29550
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x29800
testb $0x1, %al
jne 0x3eaaf
jmp 0x3eafc
leaq 0x60(%rsp), %rdi
callq 0x28170
movq %rax, %rdi
callq 0x3e950
movl %eax, 0xc(%rsp)
jmp 0x3eac7
movl 0xc(%rsp), %eax
addl 0x6c(%rsp), %eax
movl %eax, 0x6c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x29ac0
jmp 0x3ea8b
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x295d0
jmp 0x3ebfb
movl 0x6c(%rsp), %eax
movl %eax, %edi
callq 0x28030
movq %rax, (%rsp)
jmp 0x3eb0d
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x6c(%rsp), %edx
leaq 0x46(%rsp), %rdi
movl $0x2, %esi
callq 0x2b490
jmp 0x3eb2f
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdi
movw 0x4a(%rsp), %ax
movw %ax, 0x3c(%rsp)
movl 0x46(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0x38(%rsp), %ecx
movl 0x3c(%rsp), %eax
movl %ecx, %edx
shlq $0x20, %rax
orq %rax, %rdx
callq 0x29740
jmp 0x3eb63
movq 0x20(%rsp), %rdi
leaq 0x6a(%rsp), %rsi
movl $0x2, %edx
callq 0x2bb40
jmp 0x3eb79
movq 0x70(%rsp), %rdi
callq 0x28400
movq %rax, 0x30(%rsp)
movq 0x70(%rsp), %rdi
callq 0x29550
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x29800
testb $0x1, %al
jne 0x3ebac
jmp 0x3ebd8
leaq 0x30(%rsp), %rdi
callq 0x28170
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
callq 0x2a350
jmp 0x3ebca
jmp 0x3ebcc
leaq 0x30(%rsp), %rdi
callq 0x29ac0
jmp 0x3eb88
movb $0x1, 0x69(%rsp)
testb $0x1, 0x69(%rsp)
jne 0x3ebee
movq 0x20(%rsp), %rdi
callq 0x295d0
movq 0x10(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x2b6f0
nopw %cs:(%rax,%rax)
// File: Unreality3D[P]Unreality3D/indie-studio/source/Network/protocol/Serializer.cpp
// Function: IndieProtocol::Serializer::operator()(IndieProtocol::Message const&)
Serialized	Serializer::operator() (Message const &packet)
  {
    uint16_t	size =
      sizeof(Header) +
      getStringSize(packet.target) +
      getStringSize(packet.topic) +
      getStringSize(packet.event) +
      sizeof (packet.payloadSize) +
      packet.payloadSize;

    Serialized	buff;
    buff.data = new char[size];

    serializeHeader(buff, Header(PacketType::MESSAGE, size));
    serializeString(buff, packet.target);
    serializeString(buff, packet.topic);
    serializeString(buff, packet.event);
    buff.append(&packet.payloadSize, sizeof(packet.payloadSize));
    buff.append(packet.payload, packet.payloadSize);

    return buff;
  }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rdi
callq 0x3e950
movl %eax, 0x1c(%rsp)
movq 0x60(%rsp), %rdi
addq $0x20, %rdi
callq 0x3e950
movl %eax, %ecx
movl 0x1c(%rsp), %eax
addl %ecx, %eax
movl %eax, 0x2c(%rsp)
movq 0x60(%rsp), %rdi
addq $0x40, %rdi
callq 0x3e950
movq 0x20(%rsp), %rdi
movl %eax, %ecx
movl 0x2c(%rsp), %eax
addl %ecx, %eax
movq 0x60(%rsp), %rcx
movl 0x60(%rcx), %edx
movl %eax, %ecx
movl %edx, %eax
leal 0xa(%rax,%rcx), %eax
movw %ax, 0x5e(%rsp)
movb $0x0, 0x5d(%rsp)
xorl %esi, %esi
movl %esi, %edx
callq 0x2a480
movzwl 0x5e(%rsp), %eax
movl %eax, %edi
callq 0x28030
movq %rax, 0x30(%rsp)
jmp 0x3ecb3
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rax)
movzwl 0x5e(%rsp), %edx
leaq 0x46(%rsp), %rdi
movl $0x3, %esi
callq 0x2b490
jmp 0x3ecd7
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdi
movw 0x4a(%rsp), %ax
movw %ax, 0x3c(%rsp)
movl 0x46(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0x38(%rsp), %ecx
movl 0x3c(%rsp), %eax
movl %ecx, %edx
shlq $0x20, %rax
orq %rax, %rdx
callq 0x29740
jmp 0x3ed0b
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq 0x60(%rsp), %rdx
callq 0x2a350
jmp 0x3ed21
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq 0x60(%rsp), %rdx
addq $0x20, %rdx
callq 0x2a350
jmp 0x3ed3b
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq 0x60(%rsp), %rdx
addq $0x40, %rdx
callq 0x2a350
jmp 0x3ed55
movq 0x20(%rsp), %rdi
movq 0x60(%rsp), %rsi
addq $0x60, %rsi
movl $0x4, %edx
callq 0x2bb40
jmp 0x3ed6f
movq 0x20(%rsp), %rdi
movq 0x60(%rsp), %rax
movq 0x68(%rax), %rsi
movl 0x60(%rax), %eax
movl %eax, %edx
callq 0x2bb40
jmp 0x3ed89
movb $0x1, 0x5d(%rsp)
testb $0x1, 0x5d(%rsp)
jne 0x3edbb
jmp 0x3edb1
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x295d0
jmp 0x3edc5
movq 0x20(%rsp), %rdi
callq 0x295d0
movq 0x8(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x2b6f0
nop
// File: Unreality3D[P]Unreality3D/indie-studio/source/Network/sockets/Client.cpp
// Function: Socket::Client::Client()
Client::Client()
  {
    _stateThread = std::thread();
    _OnDisconnect = NULL;
    _OnReadPossible = NULL;
    _OnWritePossible = NULL;
    _OnStart = NULL;
    _isRunning = false;
    _timeout.tv_sec = 10;
    _timeout.tv_usec = 0;
  }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x1413f(%rip), %rax     # 0x52f78
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x2ab50
movq (%rsp), %rdi
addq $0x30, %rdi
callq 0x28a00
movq (%rsp), %rdi
addq $0x48, %rdi
callq 0x29b40
movq (%rsp), %rdi
addq $0x68, %rdi
callq 0x29b40
movq (%rsp), %rdi
addq $0x88, %rdi
callq 0x29370
movq (%rsp), %rdi
addq $0xa8, %rdi
callq 0x29b40
movq (%rsp), %rdi
addq $0xc8, %rdi
callq 0x2bd60
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x29060
leaq 0x8(%rsp), %rdi
callq 0x28a00
movq (%rsp), %rdi
addq $0x30, %rdi
leaq 0x8(%rsp), %rsi
callq 0x2b350
leaq 0x8(%rsp), %rdi
callq 0x2b010
movq (%rsp), %rdi
addq $0x68, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x299d0
movq (%rsp), %rdi
addq $0x88, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x298b0
movq (%rsp), %rdi
addq $0xa8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x299d0
movq (%rsp), %rdi
addq $0xc8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x29900
movq (%rsp), %rdi
addq $0x168, %rdi            # imm = 0x168
xorl %esi, %esi
callq 0x289c0
movq (%rsp), %rax
movq $0xa, 0x38(%rax)
movq $0x0, 0x40(%rax)
addq $0x18, %rsp
retq
nop
// File: Unreality3D[P]Unreality3D/indie-studio/source/Network/sockets/Client.cpp
// Function: Socket::Client::read(void*, unsigned long)
int  Client::read(void *buffer, size_t size)
  {
    int tmp;

    if ((tmp = ::recv(_fd, (char *)buffer, size, 0)) == -1)
      {
	throw SocketIOError(std::string(strerror(getError())));
      }
    if (size != 0 && tmp == 0)
      disconnect();
    return tmp;
  }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x2c(%rax), %edi
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
xorl %ecx, %ecx
callq 0x28910
movl %eax, 0x5c(%rsp)
cmpl $-0x1, %eax
jne 0x3fff8
movb $0x1, 0x2a(%rsp)
movl $0x48, %edi
callq 0x28e70
movq %rax, 0x10(%rsp)
callq 0x3f9d0
movl %eax, 0x1c(%rsp)
jmp 0x3ff3d
movl 0x1c(%rsp), %edi
callq 0x28970
movq %rax, (%rsp)
leaq 0x2b(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x2b730
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0x2aa80
jmp 0x3ff6e
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x2afd0
jmp 0x3ff7f
movq 0x10(%rsp), %rdi
movb $0x0, 0x2a(%rsp)
movq 0x12ff8(%rip), %rsi     # 0x52f88
movq 0x12f99(%rip), %rdx     # 0x52f30
callq 0x2b540
jmp 0x40024
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x3ffe3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x3ffd9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x29360
leaq 0x2b(%rsp), %rdi
callq 0x2a210
testb $0x1, 0x2a(%rsp)
jne 0x3ffec
jmp 0x3fff6
movq 0x10(%rsp), %rdi
callq 0x29690
jmp 0x4001a
cmpq $0x0, 0x60(%rsp)
je 0x40011
cmpl $0x0, 0x5c(%rsp)
jne 0x40011
movq 0x20(%rsp), %rdi
callq 0x2b1c0
movl 0x5c(%rsp), %eax
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x2b6f0
nopw %cs:(%rax,%rax)
// File: Unreality3D[P]Unreality3D/indie-studio/source/Network/sockets/Client.cpp
// Function: Socket::Client::write(void const*, unsigned long)
int  Client::write(void const *buffer, size_t size)
  {
    int tmp;

    if ((tmp = ::send(_fd, (char *)buffer, size, 0)) == -1)
      {
	if (errno == ECONNRESET)
	  disconnect();
	else
	  throw SocketIOError(std::string(strerror(getError())));
      }
    return tmp;
  }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x2c(%rax), %edi
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
xorl %ecx, %ecx
callq 0x28ed0
movl %eax, 0x5c(%rsp)
cmpl $-0x1, %eax
jne 0x401b0
callq 0x280d0
cmpl $0x68, (%rax)
jne 0x400d7
movq 0x20(%rsp), %rdi
callq 0x2b1c0
jmp 0x401ae
movb $0x1, 0x2a(%rsp)
movl $0x48, %edi
callq 0x28e70
movq %rax, 0x10(%rsp)
callq 0x3f9d0
movl %eax, 0x1c(%rsp)
jmp 0x400f6
movl 0x1c(%rsp), %edi
callq 0x28970
movq %rax, (%rsp)
leaq 0x2b(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x2b730
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0x2aa80
jmp 0x40127
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x2afd0
jmp 0x40138
movq 0x10(%rsp), %rdi
movb $0x0, 0x2a(%rsp)
movq 0x12e3f(%rip), %rsi     # 0x52f88
movq 0x12de0(%rip), %rdx     # 0x52f30
callq 0x2b540
jmp 0x401c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x40199
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x4018f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x29360
leaq 0x2b(%rsp), %rdi
callq 0x2a210
testb $0x1, 0x2a(%rsp)
jne 0x401a2
jmp 0x401ac
movq 0x10(%rsp), %rdi
callq 0x29690
jmp 0x401b9
jmp 0x401b0
movl 0x5c(%rsp), %eax
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x2b6f0
nopw %cs:(%rax,%rax)
// File: Unreality3D[P]Unreality3D/indie-studio/source/Network/sockets/Client.cpp
// Function: Socket::Client::bytesAvailables() const
size_t Client::bytesAvailables() const
  {
#ifdef _WIN32
    u_long bytes = 0;
#else
    size_t bytes = 0;
#endif

    if (::ioctl(_fd, FIONREAD, &bytes) == -1)
      {
	throw SocketIOError(std::string(strerror(getError())));
      }
    return bytes;
  }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq $0x0, 0x58(%rsp)
movl 0x2c(%rax), %edi
movl $0x541b, %esi           # imm = 0x541B
leaq 0x58(%rsp), %rdx
movb $0x0, %al
callq 0x2ac20
cmpl $-0x1, %eax
jne 0x402dd
movb $0x1, 0x2a(%rsp)
movl $0x48, %edi
callq 0x28e70
movq %rax, 0x18(%rsp)
callq 0x3f9d0
movl %eax, 0x24(%rsp)
jmp 0x40223
movl 0x24(%rsp), %edi
callq 0x28970
movq %rax, 0x8(%rsp)
leaq 0x2b(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2b730
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0x2aa80
jmp 0x40256
movq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x2afd0
jmp 0x40267
movq 0x18(%rsp), %rdi
movb $0x0, 0x2a(%rsp)
movq 0x12d10(%rip), %rsi     # 0x52f88
movq 0x12cb1(%rip), %rdx     # 0x52f30
callq 0x2b540
jmp 0x402f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x402c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x402be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x29360
leaq 0x2b(%rsp), %rdi
callq 0x2a210
testb $0x1, 0x2a(%rsp)
jne 0x402d1
jmp 0x402db
movq 0x18(%rsp), %rdi
callq 0x29690
jmp 0x402e7
movq 0x58(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x2b6f0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Unreality3D[P]Unreality3D/indie-studio/source/Network/sockets/Server.cpp
// Function: Socket::Server::Server()
Server::Server()
		{
			_stateThread = std::thread();
			_OnConnect = NULL;
			_OnDisconnect = NULL;
			_OnReadPossible = NULL;
			_OnWritePossible = NULL;
			_OnStart = NULL;
			_isRunning = false;
			_timeout.tv_sec = 10;
			_timeout.tv_usec = 0;
		}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x11207(%rip), %rax     # 0x52fa0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x2ae70
movq (%rsp), %rdi
addq $0x38, %rdi
callq 0x28a00
movq (%rsp), %rdi
addq $0x50, %rdi
callq 0x28340
movq (%rsp), %rdi
addq $0x70, %rdi
callq 0x28340
movq (%rsp), %rdi
addq $0x90, %rdi
callq 0x29e10
movq (%rsp), %rdi
addq $0xb0, %rdi
callq 0x28340
movq (%rsp), %rdi
addq $0xd0, %rdi
callq 0x28340
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x29060
leaq 0x8(%rsp), %rdi
callq 0x28a00
movq (%rsp), %rdi
addq $0x38, %rdi
leaq 0x8(%rsp), %rsi
callq 0x2b350
leaq 0x8(%rsp), %rdi
callq 0x2b010
movq (%rsp), %rdi
addq $0x50, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x290d0
movq (%rsp), %rdi
addq $0x70, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x290d0
movq (%rsp), %rdi
addq $0x90, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2b2a0
movq (%rsp), %rdi
addq $0xb0, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x290d0
movq (%rsp), %rdi
addq $0xd0, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x290d0
movq (%rsp), %rdi
addq $0x174, %rdi            # imm = 0x174
xorl %esi, %esi
callq 0x289c0
movq (%rsp), %rax
movq $0xa, 0x40(%rax)
movq $0x0, 0x48(%rax)
addq $0x18, %rsp
retq
// File: Unreality3D[P]Unreality3D/indie-studio/source/Network/sockets/Server.cpp
// Function: Socket::Server::disconnect(int)
void  Server::disconnect(int fd)
	{
		auto found = std::find(_clients.begin(), _clients.end(), fd);

		if (found != std::end(_clients))
		{
			_clients.erase(found);
			closesocket(fd);
			FD_CLR(fd, &_fd_set);

			auto max = (std::max_element(_clients.begin(), _clients.end()));
			if (max != _clients.end())
				_max_fd = *max;
			else
				_max_fd = _fd;

			if (_OnDisconnect)
				_OnDisconnect(*this, fd);
		}
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x20, %rdi
callq 0x28c00
movq 0x10(%rsp), %rdi
movq %rax, 0x58(%rsp)
addq $0x20, %rdi
callq 0x296e0
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
leaq 0x6c(%rsp), %rdx
callq 0x28d80
movq 0x10(%rsp), %rdi
movq %rax, 0x60(%rsp)
addq $0x20, %rdi
callq 0x29b20
movq %rax, 0x48(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2b500
testb $0x1, %al
jne 0x434fc
jmp 0x4362a
movq 0x10(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x28a20
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x29de0
movq %rax, 0x38(%rsp)
movl 0x6c(%rsp), %edi
callq 0x2bce0
movq 0x10(%rsp), %rdi
movl 0x6c(%rsp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
xorq $-0x1, %rcx
movl 0x6c(%rsp), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
andq 0xf0(%rdi,%rax,8), %rcx
movq %rcx, 0xf0(%rdi,%rax,8)
addq $0x20, %rdi
callq 0x28c00
movq 0x10(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x20, %rdi
callq 0x296e0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x29410
movq 0x10(%rsp), %rdi
movq %rax, 0x30(%rsp)
addq $0x20, %rdi
callq 0x296e0
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2b500
testb $0x1, %al
jne 0x435d5
jmp 0x435f1
leaq 0x30(%rsp), %rdi
callq 0x2ad70
movq %rax, %rcx
movq 0x10(%rsp), %rax
movl (%rcx), %ecx
movl %ecx, 0x170(%rax)
jmp 0x435ff
movq 0x10(%rsp), %rax
movl 0x18(%rax), %ecx
movl %ecx, 0x170(%rax)
movq 0x10(%rsp), %rdi
addq $0x70, %rdi
callq 0x29b50
testb $0x1, %al
jne 0x43613
jmp 0x43628
movq 0x10(%rsp), %rsi
movq %rsi, %rdi
addq $0x70, %rdi
movl 0x6c(%rsp), %edx
callq 0x2a300
jmp 0x4362a
addq $0x78, %rsp
retq
nop
// File: Unreality3D[P]Unreality3D/indie-studio/source/Network/sockets/Server.cpp
// Function: Socket::Server::read(int, void*, unsigned long)
int  Server::read(int fd, void *buffer, size_t size)
	{
		int tmp;

		if ((tmp = ::recv(fd, (char *)buffer, size, 0)) == -1)
		{
			throw SocketIOError(std::string(strerror(getError())));
		}
		if (size != 0 && tmp == 0)
			disconnect(fd);
		return tmp;
	}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x7c(%rsp), %edi
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
xorl %ecx, %ecx
callq 0x28910
movl %eax, 0x64(%rsp)
cmpl $-0x1, %eax
jne 0x43758
movb $0x1, 0x32(%rsp)
movl $0x48, %edi
callq 0x28e70
movq %rax, 0x18(%rsp)
callq 0x42930
movl %eax, 0x24(%rsp)
jmp 0x4369b
movl 0x24(%rsp), %edi
callq 0x28970
movq %rax, 0x8(%rsp)
leaq 0x33(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2b730
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x2aa80
jmp 0x436ce
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2afd0
jmp 0x436df
movq 0x18(%rsp), %rdi
movb $0x0, 0x32(%rsp)
movq 0xf898(%rip), %rsi      # 0x52f88
movq 0xf839(%rip), %rdx      # 0x52f30
callq 0x2b540
jmp 0x4378b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x43743
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x43739
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x29360
leaq 0x33(%rsp), %rdi
callq 0x2a210
testb $0x1, 0x32(%rsp)
jne 0x4374c
jmp 0x43756
movq 0x18(%rsp), %rdi
callq 0x29690
jmp 0x43781
cmpq $0x0, 0x68(%rsp)
je 0x43775
cmpl $0x0, 0x64(%rsp)
jne 0x43775
movq 0x28(%rsp), %rdi
movl 0x7c(%rsp), %esi
callq 0x2aa00
movl 0x64(%rsp), %eax
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x2b6f0
nopl (%rax,%rax)
// File: Unreality3D[P]Unreality3D/indie-studio/source/Network/sockets/Server.cpp
// Function: Socket::Server::write(int, void const*, unsigned long)
int  Server::write(int fd, void const *buffer, size_t size)
	{
		int tmp;

		if ((tmp = ::send(fd, (char *)buffer, size, 0)) == -1)
		{
			if (errno == ECONNRESET)
				disconnect(fd);
			else
				throw SocketIOError(std::string(strerror(getError())));
		}
		return tmp;
	}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x7c(%rsp), %edi
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
xorl %ecx, %ecx
callq 0x28ed0
movl %eax, 0x64(%rsp)
cmpl $-0x1, %eax
jne 0x438d4
callq 0x280d0
cmpl $0x68, (%rax)
jne 0x437f9
movq 0x28(%rsp), %rdi
movl 0x7c(%rsp), %esi
callq 0x2aa00
jmp 0x438d2
movb $0x1, 0x32(%rsp)
movl $0x48, %edi
callq 0x28e70
movq %rax, 0x18(%rsp)
callq 0x42930
movl %eax, 0x24(%rsp)
jmp 0x43818
movl 0x24(%rsp), %edi
callq 0x28970
movq %rax, 0x8(%rsp)
leaq 0x33(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2b730
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x2aa80
jmp 0x4384b
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2afd0
jmp 0x4385c
movq 0x18(%rsp), %rdi
movb $0x0, 0x32(%rsp)
movq 0xf71b(%rip), %rsi      # 0x52f88
movq 0xf6bc(%rip), %rdx      # 0x52f30
callq 0x2b540
jmp 0x438ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x438bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x438b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x29360
leaq 0x33(%rsp), %rdi
callq 0x2a210
testb $0x1, 0x32(%rsp)
jne 0x438c6
jmp 0x438d0
movq 0x18(%rsp), %rdi
callq 0x29690
jmp 0x438e0
jmp 0x438d4
movl 0x64(%rsp), %eax
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x2b6f0
nopw (%rax,%rax)
// File: Unreality3D[P]Unreality3D/indie-studio/source/Network/sockets/Server.cpp
// Function: Socket::Server::bytesAvailables(int) const
size_t Server::bytesAvailables(int fd) const
	{
#ifdef _WIN32
	    u_long bytes = 0;
#else
	    size_t bytes = 0;
#endif

	    if (::ioctl(fd, FIONREAD, &bytes) == -1)
	    {
	    	throw SocketIOError(std::string(strerror(getError())));
	    }
	    return bytes;
	}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq $0x0, 0x50(%rsp)
movl 0x5c(%rsp), %edi
movl $0x541b, %esi           # imm = 0x541B
leaq 0x50(%rsp), %rdx
movb $0x0, %al
callq 0x2ac20
cmpl $-0x1, %eax
jne 0x439fb
movb $0x1, 0x22(%rsp)
movl $0x48, %edi
callq 0x28e70
movq %rax, 0x10(%rsp)
callq 0x42930
movl %eax, 0x1c(%rsp)
jmp 0x43943
movl 0x1c(%rsp), %edi
callq 0x28970
movq %rax, (%rsp)
leaq 0x23(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x2b730
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x2aa80
jmp 0x43974
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2afd0
jmp 0x43985
movq 0x10(%rsp), %rdi
movb $0x0, 0x22(%rsp)
movq 0xf5f2(%rip), %rsi      # 0x52f88
movq 0xf593(%rip), %rdx      # 0x52f30
callq 0x2b540
jmp 0x43a0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x439e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x439dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x29360
leaq 0x23(%rsp), %rdi
callq 0x2a210
testb $0x1, 0x22(%rsp)
jne 0x439ef
jmp 0x439f9
movq 0x10(%rsp), %rdi
callq 0x29690
jmp 0x43a05
movq 0x50(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x2b6f0
nop
// File: andersonfernandes[P]sm-chat/src/shm_queue.cpp
// Function: create_queue()
ShmQueue* create_queue() {
  ShmQueue* shmq = new ShmQueue();
  shmq->capacity = MAX_MESSAGES;  
  shmq->front = shmq->size = 0;  
  shmq->rear = MAX_MESSAGES - 1;
  shmq->locked = false;
  shmq->messages_list_shmid = shmget(generate_key(), MAX_MESSAGES * sizeof(Message), 0666|IPC_CREAT);

  return shmq;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x10e0
movq %rax, %rdi
movq %rdi, -0x10(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x1050
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x2710, (%rax)         # imm = 0x2710
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x270f, 0xc(%rax)      # imm = 0x270F
movq -0x8(%rbp), %rax
movb $0x0, 0x14(%rax)
callq 0x1460
movl %eax, %edi
movl $0x284880, %esi         # imm = 0x284880
movl $0x3b6, %edx            # imm = 0x3B6
callq 0x1060
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: andersonfernandes[P]sm-chat/src/shm_queue.cpp
// Function: enqueue(ShmQueue*, Message*)
void enqueue(ShmQueue* shmq, Message* message) {
  if(full(shmq)) return;
  shmq->locked = true;

  shmq->rear = (shmq->rear + 1) % shmq->capacity;
  shmq->size = shmq->size + 1;

  Message* messages = (Message*) shmat(shmq->messages_list_shmid, NULL, 0);
  memcpy(&messages[shmq->rear], message, sizeof(Message));
  shmdt(messages);
  shmq->locked = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14a0
testb $0x1, %al
jne 0x14df
jmp 0x14e1
jmp 0x155d
movq -0x8(%rbp), %rax
movb $0x1, 0x14(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cltd
idivl (%rcx)
movq -0x8(%rbp), %rax
movl %edx, 0xc(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1120
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rax
imulq $0x108, %rax, %rax      # imm = 0x108
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl $0x108, %edx            # imm = 0x108
callq 0x1070
movq -0x18(%rbp), %rdi
callq 0x1140
movq -0x8(%rbp), %rax
movb $0x0, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: andersonfernandes[P]sm-chat/src/shm_queue.cpp
// Function: dequeue(ShmQueue*, Message*)
bool dequeue(ShmQueue* shmq, Message* dest_message) {
  if(empty(shmq) || shmq->locked) return false;

  Message* messages = (Message*) shmat(shmq->messages_list_shmid, NULL, 0);
  memcpy(dest_message, &messages[shmq->front], sizeof(Message));
  shmdt(messages);

  shmq->front = (shmq->front + 1) % shmq->capacity;  
  shmq->size = shmq->size - 1;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1480
testb $0x1, %al
jne 0x1597
movq -0x10(%rbp), %rax
testb $0x1, 0x14(%rax)
je 0x159d
movb $0x0, -0x1(%rbp)
jmp 0x160d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1120
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rax
imulq $0x108, %rax, %rax      # imm = 0x108
addq %rax, %rsi
movl $0x108, %edx            # imm = 0x108
callq 0x1070
movq -0x20(%rbp), %rdi
callq 0x1140
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
cltd
idivl (%rcx)
movq -0x10(%rbp), %rax
movl %edx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: andersonfernandes[P]sm-chat/src/server.cpp
// Function: main
int main() {
  init();

  while (1) {
    process_new_users();

    if(kill_server_flag) {
      cout << "\nCleaning shared memory segments" << endl;

      User *users = att_users(users_shmid);
      int *users_count = att_users_count(users_count_shmid);
      for (int i = 0; i < (*users_count); i++) {

        ShmQueue* shmq = (ShmQueue*) shmat(users[i].shmq_id, NULL, 0);
        shmctl(shmq->messages_list_shmid, IPC_RMID, NULL);
        shmdt(shmq);

        shmctl(users[i].shmq_id, IPC_RMID, NULL);
      }

      shmdt(users_count);
      shmdt(users);

      shmctl(users_shmid, IPC_RMID, NULL);
      shmctl(users_count_shmid, IPC_RMID, NULL);

      cout << "\nBye!" << endl;
      exit(0);
    }
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
callq 0x17c0
callq 0x1870
testb $0x1, 0x2a29(%rip)      # 0x40c9
je 0x17b7
movq 0x292b(%rip), %rdi      # 0x3fd8
leaq 0x950(%rip), %rsi       # 0x2004
callq 0x10d0
movq %rax, %rdi
movq 0x2905(%rip), %rsi      # 0x3fc8
callq 0x10f0
movl 0x29fe(%rip), %edi      # 0x40cc
callq 0x1640
movq %rax, -0x10(%rbp)
movl 0x29f3(%rip), %edi      # 0x40d0
callq 0x1660
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x175a
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1120
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %edi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1080
movq -0x28(%rbp), %rdi
callq 0x1140
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %edi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1080
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x16ed
movq -0x18(%rbp), %rdi
callq 0x1140
movq -0x10(%rbp), %rdi
callq 0x1140
movl 0x295a(%rip), %edi      # 0x40cc
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1080
movl 0x294d(%rip), %edi      # 0x40d0
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1080
movq 0x2843(%rip), %rdi      # 0x3fd8
leaq 0x889(%rip), %rsi       # 0x2025
callq 0x10d0
movq %rax, %rdi
movq 0x281d(%rip), %rsi      # 0x3fc8
callq 0x10f0
xorl %edi, %edi
callq 0x1110
jmp 0x1694
nopl (%rax)
// File: andersonfernandes[P]sm-chat/src/server.cpp
// Function: init()
void init() {
  srand(time(NULL));

  system("clear");
  cout << "\n> Starting the server \n" <<  endl;

  int *users_count = att_users_count(users_count_shmid);
  *users_count = 0;
  shmdt(users_count);

  cout << "Use Ctrl-C to stop\n" << endl;
  signal(SIGINT, sigint_handler);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movl %eax, %edi
callq 0x10c0
leaq 0x84c(%rip), %rdi       # 0x202b
callq 0x1090
movq 0x27ed(%rip), %rdi      # 0x3fd8
leaq 0x83f(%rip), %rsi       # 0x2031
callq 0x10d0
movq %rax, %rdi
movq 0x27c7(%rip), %rsi      # 0x3fc8
callq 0x10f0
movl 0x28c4(%rip), %edi      # 0x40d0
callq 0x1660
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x1140
movq 0x27a9(%rip), %rdi      # 0x3fd8
leaq 0x814(%rip), %rsi       # 0x204a
callq 0x10d0
movq %rax, %rdi
movq 0x2783(%rip), %rsi      # 0x3fc8
callq 0x10f0
movl $0x2, %edi
leaq 0x12a(%rip), %rsi       # 0x1980
callq 0x1100
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: andersonfernandes[P]sm-chat/src/server.cpp
// Function: process_new_users()
void process_new_users() {
  User *users = att_users(users_shmid);
  int *users_count = att_users_count(users_count_shmid);

  if(old_count != *users_count) {
    for (int i = old_count; i < *users_count; i++) {
      User user = users[i];

      time_t now = time(0);
      cout << ctime(&now) << " > ";
      cout << user.name << " logged on the server\n" <<  endl;  
    }

    old_count = (*users_count);
  }

  shmdt(users_count);
  shmdt(users);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x284e(%rip), %edi      # 0x40cc
callq 0x1640
movq %rax, -0x8(%rbp)
movl 0x2843(%rip), %edi      # 0x40d0
callq 0x1660
movq %rax, -0x10(%rbp)
movl 0x2838(%rip), %eax      # 0x40d4
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
je 0x195d
movl 0x2826(%rip), %eax      # 0x40d4
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x1951
movq -0x8(%rbp), %rsi
movslq -0x14(%rbp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rsi
leaq -0x4c(%rbp), %rdi
movl $0x38, %edx
callq 0x1070
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1040
movq %rax, %rsi
movq 0x26db(%rip), %rdi      # 0x3fd8
callq 0x10d0
movq %rax, %rdi
leaq 0x752(%rip), %rsi       # 0x205e
callq 0x10d0
leaq -0x4c(%rbp), %rsi
addq $0x4, %rsi
movq 0x26b8(%rip), %rdi      # 0x3fd8
callq 0x10d0
movq %rax, %rdi
leaq 0x733(%rip), %rsi       # 0x2062
callq 0x10d0
movq %rax, %rdi
movq 0x268a(%rip), %rsi      # 0x3fc8
callq 0x10f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x18b1
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, 0x2777(%rip)      # 0x40d4
movq -0x10(%rbp), %rdi
callq 0x1140
movq -0x8(%rbp), %rdi
callq 0x1140
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: roberto-bayardo[P]google-extremal-sets/all-maximal-sets-satelite.cc
// Function: google_extremal_sets::AllMaximalSetsSateLite::PrepareForDataScan(google_extremal_sets::DataSourceIterator*, unsigned int, long)
bool AllMaximalSetsSateLite::PrepareForDataScan(
    DataSourceIterator* data, uint32_t max_item_id, off_t resume_offset) {
  occurs_.clear();
  occurs_.resize(max_item_id);
  std::cerr << "; Starting new dataset scan at offset: "
            << resume_offset << std::endl;
  return data->Seek(resume_offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x30, %rdi
callq 0x2e70
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2e90
movq 0x867f(%rip), %rdi      # 0xaff0
leaq 0x46d6(%rip), %rsi      # 0x704e
callq 0x2200
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x23a0
movq %rax, %rdi
movq 0x862d(%rip), %rsi      # 0xafc0
callq 0x2240
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x52c0
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)