LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/communication.cpp
// Function: socket_io::operator<<(socket_io::socket_view&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto operator<<(socket_view& dst, std::string const& to_send) -> socket_view&
{
    // Prepare data to send
    std::string::size_type const length = to_send.length();
    if (length > std::numeric_limits<uint32_t>::max())
	throw std::invalid_argument{"Input message is too long"};
    uint32_t with_byte_order = htonl(static_cast<uint32_t>(length));
    
    char buffer[length + 1];
    if (snprintf(buffer, length + 1, "%s", to_send.c_str()) < 0)
	throw std::invalid_argument{"Input message is wrong: " +
		                    get_errno_as_string()};
    
    // Send the data
    send(dst.get_native_handle(), static_cast<void*>(&with_byte_order),
	 sizeof(uint32_t));
    send(dst.get_native_handle(), static_cast<void*>(&buffer), length);

    return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq 0x8(%rsi), %r14
movq %r14, %rax
shrq $0x20, %rax
jne 0x8c56
movq %rdi, %rbx
movq %rsp, %r12
movl %r14d, %eax
bswapl %eax
movl %eax, -0x24(%rbp)
leaq 0x1(%r14), %rax
movq %rsp, %r15
leaq 0x10(%r14), %rcx
andq $-0x10, %rcx
subq %rcx, %r15
movq %r15, %rsp
movq (%rsi), %rcx
leaq 0x5415(%rip), %rdx      # 0xe01a
movq %r15, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x8870
testl %eax, %eax
js 0x8c88
movq %rbx, %rdi
callq 0x8430
leaq -0x24(%rbp), %rsi
movl $0x4, %edx
movl %eax, %edi
callq 0x8d49
movq %rbx, %rdi
callq 0x8430
movl %eax, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x8d49
movq %r12, %rsp
movq %rbx, %rax
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x8220
movq %rax, %rbx
leaq 0x5396(%rip), %rsi      # 0xe000
movq %rax, %rdi
callq 0x8a00
movq 0xa33f(%rip), %rsi      # 0x12fb8
movq 0xa318(%rip), %rdx      # 0x12f98
movq %rbx, %rdi
callq 0x8900
movl $0x10, %edi
callq 0x8220
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x8350
leaq 0x5378(%rip), %rsi      # 0xe01d
leaq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x88e0
movb $0x1, %r15b
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x8920
xorl %r15d, %r15d
movq 0xa2ed(%rip), %rsi      # 0x12fb8
movq 0xa2c6(%rip), %rdx      # 0x12f98
movq %rbx, %rdi
callq 0x8900
movq %rax, %r14
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8cf6
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x84c0
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8d0f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x84c0
testb %r15b, %r15b
jne 0x8d39
jmp 0x8d41
movq %rax, %r14
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8d39
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x84c0
jmp 0x8d39
jmp 0x8d36
movq %rax, %r14
movq %rbx, %rdi
callq 0x8340
movq %r14, %rdi
callq 0x8970
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/communication.cpp
// Function: socket_io::send(int, void const*, unsigned long)
static inline auto send(int sockfd, void const* buf, size_t len) -> void
{
    int error_code = ::send(sockfd, buf, len, MSG_NOSIGNAL);
    if (error_code == -1 && errno == EPIPE)
	throw std::system_error{std::make_error_code(std::errc::broken_pipe)};
    else if (error_code == -1)    
	throw std::runtime_error{"An error occured while sending the data: " +
		                 get_errno_as_string()};
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl $0x4000, %ecx           # imm = 0x4000
callq 0x8230
cmpl $-0x1, %eax
je 0x8d69
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x8030
cmpl $0x20, (%rax)
jne 0x8dab
movl $0x20, %edi
callq 0x8220
movq %rax, %rbx
callq 0x8240
movq %rbx, %rdi
movl $0x20, %esi
movq %rax, %rdx
callq 0x8310
movq 0xa184(%rip), %rsi      # 0x12f20
movq 0xa19d(%rip), %rdx      # 0x12f40
movq %rbx, %rdi
callq 0x8900
movl $0x10, %edi
callq 0x8220
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8350
leaq 0x526f(%rip), %rsi      # 0xe036
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x88e0
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x88a0
xorl %ebp, %ebp
movq 0xa203(%rip), %rsi      # 0x12ff0
movq 0xa144(%rip), %rdx      # 0x12f38
movq %rbx, %rdi
callq 0x8900
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8e1a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84c0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8e35
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
testb %bpl, %bpl
jne 0x8e61
jmp 0x8e69
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8e61
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0x8e61
jmp 0x8e5e
movq %rax, %r14
movq %rbx, %rdi
callq 0x8340
movq %r14, %rdi
callq 0x8970
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/communication.cpp
// Function: socket_io::recv(int, void*, unsigned long)
static inline auto recv(int sockfd, void* buf, size_t len) -> int
{
    ssize_t error_code = ::recv(sockfd, buf, len, 0);
    if (error_code == 0)
	throw std::system_error{std::make_error_code(std::errc::broken_pipe)};
    if (error_code == -1)
	throw std::runtime_error{"An error occured while reading the data: " +
		                 get_errno_as_string()};
    return error_code;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
xorl %ecx, %ecx
callq 0x8150
cmpq $-0x1, %rax
je 0x8f57
testq %rax, %rax
je 0x8fa8
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x8220
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8350
leaq 0x50ed(%rip), %rsi      # 0xe060
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x88e0
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x88a0
xorl %ebp, %ebp
movq 0xa057(%rip), %rsi      # 0x12ff0
movq 0x9f98(%rip), %rdx      # 0x12f38
movq %rbx, %rdi
callq 0x8900
movl $0x20, %edi
callq 0x8220
movq %rax, %rbx
callq 0x8240
movq %rbx, %rdi
movl $0x20, %esi
movq %rax, %rdx
callq 0x8310
movq 0x9f4f(%rip), %rsi      # 0x12f20
movq 0x9f68(%rip), %rdx      # 0x12f40
movq %rbx, %rdi
callq 0x8900
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8ffe
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84c0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9019
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
testb %bpl, %bpl
jne 0x9045
jmp 0x904d
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9045
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0x9045
jmp 0x9042
movq %rax, %r14
movq %rbx, %rdi
callq 0x8340
movq %r14, %rdi
callq 0x8970
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/connection.cpp
// Function: socket_io::bind(socket_io::socket const&, boost::variant<socket_io::socket_address<sockaddr_in>, socket_io::socket_address<sockaddr_in6>> const&)
auto bind(socket const& unbound, ip_socket_address const& to_bind) -> void
{
    bool is_ipv4 = to_bind.type() == typeid(ipv4_socket_address);
    auto ip_version = unbound.get_ip_protocol();

    if ((is_ipv4 && ip_version == ip_protocol::IPv6) ||
	(!is_ipv4 && ip_version == ip_protocol::IPv4))
	throw std::logic_error{"Socket and address have different protocols"};
    
    if (is_ipv4)
    {
	auto tmp_to_bind = boost::get<ipv4_socket_address>(to_bind);	
	sockaddr_in addr_in = tmp_to_bind.get_native_handle();
	socket_io::bind_wrapper(unbound, reinterpret_cast<sockaddr*>(&addr_in),
				sizeof(sockaddr_in));
	
    }
    else
    {
	auto tmp_to_bind = boost::get<ipv6_socket_address>(to_bind);	
	sockaddr_in6 addr_in6 = tmp_to_bind.get_native_handle();
	socket_io::bind_wrapper(unbound, reinterpret_cast<sockaddr*>(&addr_in6),
				sizeof(sockaddr_in6));
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x8860
movq 0x8(%rax), %rdi
cmpq 0x9d0d(%rip), %rdi      # 0x12f90
je 0x9295
cmpb $0x2a, (%rdi)
jne 0x929e
cmpl $0x2, 0x4(%rbx)
jne 0x92e7
jmp 0x9335
movl $0xa, %eax
movb $0x1, %cl
jmp 0x92b8
movq 0x9ceb(%rip), %rsi      # 0x12f90
callq 0x8710
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
leal 0x2(,%rcx,8), %eax
cmpl %eax, 0x4(%rbx)
je 0x9335
testb %cl, %cl
je 0x92e7
movq %rsp, %rsi
movq %r14, %rdi
callq 0x8950
testq %rax, %rax
je 0x937d
movups (%rax), %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movl (%rbx), %edi
movl $0x10, %edx
jmp 0x9328
movq %rsp, %rsi
movq %r14, %rdi
callq 0x83c0
testq %rax, %rax
je 0x9367
movq 0x20(%rax), %rcx
movq %rcx, 0x20(%rsp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movups 0xc(%rsp), %xmm1
leaq 0x30(%rsp), %rsi
movups %xmm1, 0xc(%rsi)
movaps %xmm0, (%rsi)
movl (%rbx), %edi
movl $0x1c, %edx
callq 0x93bf
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x8220
movq %rax, %r14
leaq 0x4e87(%rip), %rsi      # 0xe1d0
movq %rax, %rdi
callq 0x8790
movq 0x9c58(%rip), %rsi      # 0x12fb0
movq 0x9bf9(%rip), %rdx      # 0x12f58
movq %r14, %rdi
callq 0x8900
movq 0x9ba2(%rip), %rax      # 0x12f10
addq $0x10, %rax
movq %rsp, %rdi
movq %rax, (%rdi)
callq 0x84b0
movq 0x9b8c(%rip), %rax      # 0x12f10
addq $0x10, %rax
movq %rsp, %rdi
movq %rax, (%rdi)
callq 0x84b0
jmp 0x93a4
jmp 0x93b7
movq %rax, %rbx
movq %r14, %rdi
callq 0x8340
jmp 0x93af
movq %rax, %rbx
movq %rsp, %rdi
callq 0x89d0
movq %rbx, %rdi
callq 0x8970
movq %rax, %rdi
callq 0x960d
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/connection.cpp
// Function: socket_io::accept(socket_io::socket const&)
auto accept(socket const& server) -> socket
{
    int sockfd = ::accept(server.get_native_handle(), nullptr, nullptr);
    if (sockfd == -1)
	throw std::runtime_error{"An error occured while accepting a client: " +
				 get_errno_as_string()};
    return socket{sockfd, server.get_ip_protocol()};
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8140
cmpl $-0x1, %eax
je 0x94dd
movl 0x4(%r14), %ecx
leaq 0x20(%rsp), %rdx
movl %ecx, (%rdx)
movq %rbx, %rdi
movl %eax, %esi
callq 0x8590
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x8220
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8350
leaq 0x4d03(%rip), %rsi      # 0xe1fc
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x88e0
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x88a0
xorl %ebp, %ebp
movq 0x9ad1(%rip), %rsi      # 0x12ff0
movq 0x9a12(%rip), %rdx      # 0x12f38
movq %rbx, %rdi
callq 0x8900
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x954c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84c0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9567
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
testb %bpl, %bpl
jne 0x9591
jmp 0x9599
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9591
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0x9591
movq %rax, %r14
movq %rbx, %rdi
callq 0x8340
movq %r14, %rdi
callq 0x8970
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/connection.cpp
// Function: socket_io::is_socket_handle(int, socket_io::ip_protocol const&)
auto is_socket_handle(int const handle, ip_protocol const& ip_version) noexcept
    -> bool
{
    sockaddr addr;
    socklen_t addrlen = sizeof(sockaddr);

    if (getsockname(handle, &addr, &addrlen) == -1)
	return false;

    if (addr.sa_family != AF_INET && addr.sa_family != AF_INET6)
	return false;

    if (addr.sa_family == AF_INET && ip_version == ip_protocol::IPv6)
	return false;
    if (addr.sa_family == AF_INET6 && ip_version == ip_protocol::IPv4)
	return false;

    return true;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
leaq 0xc(%rsp), %rdx
movl $0x10, (%rdx)
leaq 0x10(%rsp), %rsi
callq 0x8440
cmpl $-0x1, %eax
je 0x95f4
movzwl 0x10(%rsp), %eax
movl %eax, %ecx
andl $-0x9, %ecx
cmpw $0x2, %cx
jne 0x95f4
cmpw $0x2, %ax
sete %dl
movl (%rbx), %ecx
cmpl $0xa, %ecx
sete %sil
testb %sil, %dl
je 0x95fc
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
cmpw $0xa, %ax
setne %dl
cmpl $0x2, %ecx
setne %al
orb %dl, %al
jmp 0x95f6
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/client.cpp
// Function: socket_io::client::~client()
client::~client() noexcept
{
    try
    {
	main_socket.make_view() << std::to_string(id);
    }
    catch (...)
    { /* Ignore the exception */ }	
    shutdown(main_socket);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x80d0
movq %rax, (%rsp)
movl 0x38(%rbx), %r14d
movl %r14d, %ebp
negl %ebp
cmovsl %r14d, %ebp
movl $0x1, %r15d
cmpl $0xa, %ebp
jb 0x9f7f
movl $0x4, %r15d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x9f76
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x9f7c
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x9f7f
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r15d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x9f43
addl $-0x3, %r15d
jmp 0x9f7f
addl $-0x2, %r15d
jmp 0x9f7f
decl %r15d
shrl $0x1f, %r14d
leal (%r15,%r14), %esi
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x8(%rsp), %rdi
movl $0x2d, %edx
callq 0x8580
leaq 0x8(%rsp), %r12
addq (%r12), %r14
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x8750
movq %rsp, %rdi
movq %r12, %rsi
callq 0x8a50
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9fd7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84c0
movq %rbx, %rdi
callq 0x8640
leaq 0x8(%rbx), %rdi
callq 0x87a0
movq %rbx, %rdi
callq 0x8510
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xa01e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0xa01e
movq %rax, %r14
movq %r14, %rdi
callq 0x81c0
callq 0x88c0
jmp 0x9fd7
movq %rax, %rdi
callq 0x960d
nop
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/socket.cpp
// Function: socket_io::socket::socket(socket_io::ip_protocol const&)
socket::socket(ip_protocol const& ip_version)
    : ip_version{ip_version}
{
    handle = ::socket(static_cast<int>(ip_version), SOCK_STREAM, 0);
    if (handle == -1)
	throw std::runtime_error("An error occured while creating a socket: " +
				 get_errno_as_string());
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movl (%rsi), %edi
movl %edi, 0x4(%rbx)
movl $0x1, %esi
xorl %edx, %edx
callq 0x80f0
movl %eax, (%rbx)
cmpl $-0x1, %eax
je 0xa52c
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x8220
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8350
leaq 0x40f1(%rip), %rsi      # 0xe639
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x88e0
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x88a0
xorl %ebp, %ebp
movq 0x8a82(%rip), %rsi      # 0x12ff0
movq 0x89c3(%rip), %rdx      # 0x12f38
movq %rbx, %rdi
callq 0x8900
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa59b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84c0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa5b6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
testb %bpl, %bpl
jne 0xa5e0
jmp 0xa5e8
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa5e0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0xa5e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x8340
movq %r14, %rdi
callq 0x8970
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/socket.cpp
// Function: socket_io::socket::to_string[abi:cxx11]() const
auto socket::to_string() const -> std::string
{
    std::string ip_version_str;
    if (ip_version == ip_protocol::IPv4)
        ip_version_str = "IPv4";
    else
	ip_version_str = "IPv6";       
    return "(SOCK_STREAM, " + ip_version_str + ")";
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
cmpl $0x2, 0x4(%rsi)
leaq 0x3fc2(%rip), %rax      # 0xe67e
leaq 0x3fc0(%rip), %rcx      # 0xe683
cmoveq %rax, %rcx
leaq 0x8(%rsp), %rdi
movl $0x4, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x8830
leaq 0x3fa6(%rip), %rsi      # 0xe688
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x8400
leaq 0x3f9f(%rip), %rsi      # 0xe697
leaq 0x28(%rsp), %rdi
callq 0x8a30
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0xa724
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0xa72a
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)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa75c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x84c0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xa773
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84c0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa7a3
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0xa7a3
jmp 0xa7a0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xa7ba
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84c0
movq %rbx, %rdi
callq 0x8970
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/server.cpp
// Function: socket_io::server::accept_clients()
auto server::accept_clients() -> void
{
    for (;;)
    {
	try
	{
	    socket client = accept(main_socket);
	    socket_view view = client.make_view();

	    epoll_handle.add(view, EPOLLIN);
	    
	    int const id = connected.add(std::move(client));
	    view << std::to_string(id);
	}
	catch (...)
	{ /* Ignore the exceptions */ }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0xc(%rdi), %rax
movq %rax, 0x30(%rsp)
leaq 0x48(%rdi), %rax
movq %rax, 0x28(%rsp)
addq $0x68, %rdi
movq %rdi, 0x20(%rsp)
leaq 0x40(%rsp), %r12
leaq 0x38(%rsp), %rbp
movl $0xd1b71759, %r13d      # imm = 0xD1B71759
movq %r12, %rdi
movq 0x30(%rsp), %rsi
callq 0x8720
movq %r12, %rdi
callq 0x80d0
movq %rax, 0x38(%rsp)
movq 0x28(%rsp), %rdi
movq %rbp, %rsi
movl $0x1, %edx
callq 0x88d0
movq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x8770
movl %eax, %r14d
movl %eax, %ebx
negl %ebx
cmovsl %eax, %ebx
movl $0x1, %r15d
cmpl $0xa, %ebx
jb 0xa914
movl $0x4, %r15d
movl %ebx, %eax
cmpl $0x63, %eax
jbe 0xa90b
cmpl $0x3e7, %eax            # imm = 0x3E7
jbe 0xa911
cmpl $0x2710, %eax           # imm = 0x2710
jb 0xa914
movl %eax, %ecx
imulq %r13, %rcx
shrq $0x2d, %rcx
addl $0x4, %r15d
cmpl $0x1869f, %eax          # imm = 0x1869F
movl %ecx, %eax
ja 0xa8db
addl $-0x3, %r15d
jmp 0xa914
addl $-0x2, %r15d
jmp 0xa914
decl %r15d
shrl $0x1f, %r14d
leal (%r15,%r14), %esi
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %rsp, %r13
movq %r13, %rdi
movl $0x2d, %edx
callq 0x8580
movl %r14d, %edi
addq (%rsp), %rdi
movl %r15d, %esi
movl %ebx, %edx
callq 0x8750
movq %rbp, %rdi
movq %r13, %rsi
callq 0x8250
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
movl $0xd1b71759, %r13d      # imm = 0xD1B71759
je 0xa972
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
movq %r12, %rdi
callq 0x8510
jmp 0xa885
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
movl $0xd1b71759, %r13d      # imm = 0xD1B71759
je 0xa9b5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0xa9b5
movq %rax, %rbx
movl $0xd1b71759, %r13d      # imm = 0xD1B71759
jmp 0xa9b5
jmp 0xa9b2
movq %rax, %rbx
movq %r12, %rdi
callq 0x8510
jmp 0xa9c2
movq %rax, %rbx
movq %rbx, %rdi
callq 0x81c0
callq 0x88c0
jmp 0xa885
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/server.cpp
// Function: socket_io::server::~server()
server::~server() noexcept
{
    using client_cell = registry_of_clients::client_cell;
    std::vector<client_cell> sockets_for_clients = connected.get_clients();
    for (auto& [id, socket] : sockets_for_clients)
    {
	socket_view view = socket.make_view();
	
	view << "EXIT";
	epoll_handle.remove(view);
	shutdown(socket);
    }
    shutdown(main_socket);
    pthread_cancel(accept_clients_tid.native_handle());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x68(%rdi), %rsi
leaq 0x30(%rsp), %rdi
callq 0x8460
movq %rbx, (%rsp)
movq 0x30(%rsp), %r15
movq 0x38(%rsp), %r12
cmpq %r12, %r15
je 0xada6
movq (%rsp), %rax
leaq 0x48(%rax), %r14
leaq 0x10(%rsp), %r13
leaq 0x8(%rsp), %rbp
leaq 0x4(%r15), %rbx
movq %rbx, %rdi
callq 0x80d0
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %r13, %rdi
leaq 0x3a6f(%rip), %rsi      # 0xe7c6
leaq 0x3a6c(%rip), %rdx      # 0xe7ca
callq 0x81a0
movq %rbp, %rdi
movq %r13, %rsi
callq 0x8250
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xad8a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x84c0
movq %r14, %rdi
movq %rbp, %rsi
callq 0x84d0
movq %rbx, %rdi
callq 0x8640
addq $0xc, %r15
cmpq %r12, %r15
jne 0xad32
movq (%rsp), %r14
leaq 0xc(%r14), %rbx
movq %rbx, %rdi
callq 0x8640
movq (%r14), %rdi
callq 0x8700
leaq 0x30(%rsp), %rdi
callq 0x80c0
leaq 0x70(%r14), %rdi
callq 0x8530
leaq 0x48(%r14), %rdi
callq 0x85a0
leaq 0x18(%r14), %rdi
callq 0x87a0
movq %rbx, %rdi
callq 0x8510
cmpq $0x0, (%r14)
jne 0xae00
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x8100
jmp 0xae07
movq %rax, %rdi
callq 0x960d
nop
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/server.cpp
// Function: socket_io::server::receive[abi:cxx11]()
auto server::receive() -> std::string
{
    auto&& [flags, caused_by] = epoll_handle.get_event();

    std::string message;
    caused_by >> message;
    
    if (message.find("FROM") == std::string::npos)
    {
	int const id = string_to_integer<int>(message);
	socket client = connected.get_client(id);
	epoll_handle.remove(client.make_view());
    }

    auto message_start_pos = message.find('}') + 2;
    return message.substr(message_start_pos,
			  message.length() - message_start_pos);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x48(%rsi), %r14
movq %r14, %rdi
callq 0x82f0
leaq 0x3c(%rsp), %rdi
movq %rax, -0x4(%rdi)
movl %edx, 0x4(%rdi)
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x10(%rsp), %rsi
callq 0x8740
leaq 0x3969(%rip), %rsi      # 0xe7cb
leaq 0x10(%rsp), %rdi
movl $0x4, %ecx
xorl %edx, %edx
callq 0x8930
cmpq $-0x1, %rax
jne 0xaeba
leaq 0x10(%rsp), %rdi
callq 0x8810
addq $0x68, %r15
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x85b0
leaq 0x8(%rsp), %rdi
callq 0x80d0
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x84d0
leaq 0x8(%rsp), %rdi
callq 0x8510
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x7d, %esi
xorl %edx, %edx
callq 0x8650
leaq 0x2(%rax), %rdx
movq 0x8(%r14), %rcx
subq %rdx, %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84e0
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0xaefb
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x84c0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8510
jmp 0xaf22
jmp 0xaf1f
jmp 0xaf1f
jmp 0xaf1f
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0xaf39
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x84c0
movq %rbx, %rdi
callq 0x8970
nop
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/server.cpp
// Function: socket_io::server::send(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto server::send(int const client_id, std::string const& message) -> void
{
    socket client = connected.get_client(client_id);
    try
    {
	client.make_view() << message;
    }
    catch (std::runtime_error const& e)
    {
	if (errno == EPIPE) // Client has disconnected
	{
	    epoll_handle.remove(client.make_view());
	    shutdown(client);
	    return;
	}
	throw;
    }
    connected.add(client_id, std::move(client));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x68(%rdi), %r14
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x85b0
movq %r12, %rdi
callq 0x80d0
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %r15, %rsi
callq 0x8a50
movq %rsp, %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x8780
movq %rsp, %rdi
callq 0x8510
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x8510
movq %r14, %rdi
callq 0x8970
movq %rax, %r14
cmpl $0x1, %edx
jne 0xafa7
movq %r14, %rdi
callq 0x81c0
callq 0x8030
cmpl $0x20, (%rax)
jne 0xaffc
addq $0x48, %rbx
movq %rsp, %rdi
callq 0x80d0
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x84d0
movq %rsp, %rdi
callq 0x8640
callq 0x88c0
jmp 0xaf8f
callq 0x87d0
jmp 0xb005
jmp 0xafa4
movq %rax, %r14
callq 0x88c0
jmp 0xafa7
movq %rax, %rdi
callq 0x960d
nop
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/server.cpp
// Function: socket_io::server::get_connected_clients()
auto server::get_connected_clients() -> std::vector<connected_client>
{
    using client_cell = registry_of_clients::client_cell;
    std::vector<client_cell> connected_clients = connected.get_clients();

    std::vector<connected_client> views;
    for (auto& [id, socket] : connected_clients)
    {
	views.emplace_back(std::make_pair(id, socket.make_view()));
	connected.add(id, std::move(socket));
    }
    return views;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x68, %r14
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x8460
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq (%r15), %r13
movq 0x8(%r15), %rbp
cmpq %rbp, %r13
je 0xb0c9
movq %rsp, %r15
leaq 0x4(%r13), %r12
movq %r12, %rdi
callq 0x80d0
movl (%r13), %ecx
movl %ecx, 0x10(%rsp)
movq %rax, 0x14(%rsp)
movq 0x10(%rsp), %rcx
shrq $0x20, %rax
movq %rcx, (%rsp)
movl %eax, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xb0a6
movl 0x8(%rsp), %eax
movl %eax, 0x8(%rsi)
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0xc, 0x8(%rbx)
jmp 0xb0b1
movq %rbx, %rdi
movq %r15, %rdx
callq 0x8260
movl (%r13), %esi
movq %r14, %rdi
movq %r12, %rdx
callq 0x8780
addq $0xc, %r13
cmpq %rbp, %r13
jne 0xb05d
leaq 0x20(%rsp), %rdi
callq 0x80c0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb0e7
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb0fe
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x84c0
leaq 0x20(%rsp), %rdi
callq 0x80c0
movq %r14, %rdi
callq 0x8970
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/registry.cpp
// Function: socket_io::registry_of_clients::get_new_id() const
auto registry_of_clients::get_new_id() const -> int
{
    std::lock_guard<std::mutex> lock(get_new_id_mutex);
    
    int id = base_id;
    bool found_id = false;
    while (id < std::numeric_limits<int>::max() && !found_id)
	if (client_to_socket.find(id) == client_to_socket.end())
	    found_id = true;
	else
	    id++;
    if (!found_id)
	throw std::runtime_error{"No free ID available"};
    return id;    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x40(%rdi), %rbx
movq %rbx, %rdi
callq 0x87e0
testl %eax, %eax
jne 0xb68f
movl (%r14), %eax
movl %eax, 0x4(%rsp)
cmpl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
je 0xb648
addq $0x8, %r14
leaq 0x4(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x82c0
movl 0x4(%rsp), %ebp
testq %rax, %rax
je 0xb67a
incl %ebp
movl %ebp, 0x4(%rsp)
cmpl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
je 0xb648
testq %rax, %rax
jne 0xb621
movl $0x10, %edi
callq 0x8220
movq %rax, %r15
leaq 0x3215(%rip), %rsi      # 0xe871
movq %rax, %rdi
callq 0x8190
movq 0x7985(%rip), %rsi      # 0x12ff0
movq 0x78c6(%rip), %rdx      # 0x12f38
movq %r15, %rdi
callq 0x8900
movq %rbx, %rdi
callq 0x8370
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x82e0
jmp 0xb6a5
movq %rax, %r14
movq %r15, %rdi
callq 0x8340
jmp 0xb6a8
movq %rax, %r14
movq %rbx, %rdi
callq 0x8370
movq %r14, %rdi
callq 0x8970
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/registry.cpp
// Function: socket_io::registry_of_clients::add(int, socket_io::socket&&)
auto registry_of_clients::add(int const id, socket&& client) -> void
{
    if (client_to_socket.find(id) != client_to_socket.end())
	throw std::runtime_error{"Specified id already taken"};
    
    std::lock_guard<std::mutex> lock(add_remove_mutex);
    
    auto result = client_to_socket.emplace(id, std::move(client));

    if (!result.second)
	throw std::invalid_argument{"Failed to add the client to the registry"};
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
leaq 0x8(%rdi), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x8980
testq %rax, %rax
jne 0xb73f
addq $0x68, %rbx
movq %rbx, %rdi
callq 0x87e0
testl %eax, %eax
jne 0xb771
leaq 0xc(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x8910
testb $0x1, %dl
je 0xb778
movq %rbx, %rdi
callq 0x8370
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x8220
movq %rax, %rbx
leaq 0x3133(%rip), %rsi      # 0xe886
movq %rax, %rdi
callq 0x8190
movq 0x788e(%rip), %rsi      # 0x12ff0
movq 0x77cf(%rip), %rdx      # 0x12f38
movq %rbx, %rdi
callq 0x8900
movl %eax, %edi
callq 0x82e0
movl $0x10, %edi
callq 0x8220
movq %rax, %r15
leaq 0x3115(%rip), %rsi      # 0xe8a1
movq %rax, %rdi
callq 0x8a00
movq 0x781d(%rip), %rsi      # 0x12fb8
movq 0x77f6(%rip), %rdx      # 0x12f98
movq %r15, %rdi
callq 0x8900
movq %rax, %r14
movq %r15, %rdi
callq 0x8340
jmp 0xb7c7
movq %rax, %r14
movq %rbx, %rdi
callq 0x8340
jmp 0xb7cf
movq %rax, %r14
movq %rbx, %rdi
callq 0x8370
movq %r14, %rdi
callq 0x8970
nop
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/registry.cpp
// Function: socket_io::registry_of_clients::get_client(int)
auto registry_of_clients::get_client(int const id) -> socket
{
    std::lock_guard<std::mutex> lock(add_remove_mutex);

    socket client = std::move(client_to_socket.at(id));
    client_to_socket.erase(id);
    return client;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl %edx, 0xc(%rsp)
leaq 0x68(%rsi), %rbx
movq %rbx, %rdi
callq 0x87e0
testl %eax, %eax
jne 0xb842
addq $0x8, %r15
leaq 0xc(%rsp), %rsi
movq %r15, %rdi
callq 0x8980
testq %rax, %rax
je 0xb849
addq $0xc, %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x8410
leaq 0xc(%rsp), %rsi
movq %r15, %rdi
callq 0x84f0
movq %rbx, %rdi
callq 0x8370
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x82e0
leaq 0x307a(%rip), %rdi      # 0xe8ca
callq 0x87b0
movq %rax, %r15
movq %r14, %rdi
callq 0x8510
jmp 0xb865
movq %rax, %r15
movq %rbx, %rdi
callq 0x8370
movq %r15, %rdi
callq 0x8970
nop
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/registry.cpp
// Function: socket_io::registry_of_clients::get_clients()
auto registry_of_clients::get_clients() -> std::vector<client_cell>
{
    std::lock_guard<std::mutex> lock(add_remove_mutex);
    
    std::vector<client_cell> sockets;
    for (auto&& [id, sock] : client_to_socket)
	sockets.emplace_back(std::make_pair(id, std::move(sock)));
    client_to_socket.clear();
    return sockets;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x68(%rsi), %rbx
movq %rbx, %rdi
callq 0x87e0
testl %eax, %eax
jne 0xb911
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x18(%r15), %rbp
testq %rbp, %rbp
je 0xb8eb
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %r13
leaq 0xc(%rbp), %rsi
movl 0x8(%rbp), %eax
movl %eax, 0xc(%rsp)
movq %r12, %rdi
callq 0x8410
movq %r14, %rdi
movq %r13, %rsi
callq 0x8470
movq %r12, %rdi
callq 0x8510
movq (%rbp), %rbp
testq %rbp, %rbp
jne 0xb8bc
addq $0x8, %r15
movq %r15, %rdi
callq 0x86d0
movq %rbx, %rdi
callq 0x8370
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x82e0
movq %rax, %r15
movq %r12, %rdi
callq 0x8510
movq %r14, %rdi
callq 0x80c0
movq %rbx, %rdi
callq 0x8370
movq %r15, %rdi
callq 0x8970
nop
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/socket_view.cpp
// Function: socket_io::socket_view::to_string[abi:cxx11]() const
auto socket_view::to_string() const -> std::string
{
    if (!is_socket_handle(handle, ip_version))
	std::runtime_error{"Not a valid socket handle"};

    std::string ip_version_str;
    if (ip_version == ip_protocol::IPv4)
        ip_version_str = "IPv4";
    else
	ip_version_str = "IPv6";       
    return "(SOCK_STREAM, " + ip_version_str + ")";    
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %edi
addq $0x4, %r14
movq %r14, %rsi
callq 0x89c0
testb %al, %al
jne 0xc0e9
leaq 0x2590(%rip), %rsi      # 0xe664
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x8190
movq %r15, %rdi
callq 0x8a68
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
cmpl $0x2, (%r14)
leaq 0x2575(%rip), %rax      # 0xe67e
leaq 0x2573(%rip), %rcx      # 0xe683
cmoveq %rax, %rcx
movq %rsp, %rdi
movl $0x4, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x8830
leaq 0x255b(%rip), %rsi      # 0xe688
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x8400
leaq 0x2556(%rip), %rsi      # 0xe697
leaq 0x20(%rsp), %rdi
callq 0x8a30
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0xc16d
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0xc173
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)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc1a5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84c0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xc1bb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc1ed
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0xc1ed
jmp 0xc1ea
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xc203
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
movq %rbx, %rdi
callq 0x8970
nop
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/address.cpp
// Function: socket_io::socket_address<sockaddr_in>::set_ip_address(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto socket_address<T>::set_ip_address(std::string const& ip_address) -> void
{
    int error_code = 1;
    if constexpr(is_ipv4)
    {
	if (ip_address == "INADDR_ANY")
	    handle.sin_addr.s_addr = INADDR_ANY;
	else
            error_code = inet_pton(AF_INET, ip_address.c_str(),
			           static_cast<void*>(&handle.sin_addr));
    }
    else
    {
	if (ip_address == "in6addr_any")
	    handle.sin6_addr = in6addr_any;
	else
	    error_code = inet_pton(AF_INET6, ip_address.c_str(),
			           static_cast<void*>(&handle.sin6_addr));
    }
    /*
     * Error checking for EAFNOSUPPORT no necessary as AF_INET and AF_INET6 are
     * valid address families
    */
    if (error_code == 0)
	throw std::invalid_argument{ip_address + " is not a valid IP address"};
    ip_address_length = ip_address.length();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2537(%rip), %rsi      # 0xe78c
movq %r14, %rdi
callq 0x8110
testl %eax, %eax
je 0xc2bb
movq (%r14), %rsi
leaq 0x4(%rbx), %rdx
movl $0x2, %edi
callq 0x8a10
testl %eax, %eax
jne 0xc2c2
movl $0x10, %edi
callq 0x8220
movq %rax, %rbx
leaq 0x264e(%rip), %rdx      # 0xe8d8
movq %rsp, %rdi
movq %r14, %rsi
callq 0x8620
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8920
xorl %ebp, %ebp
movq 0x6d0c(%rip), %rsi      # 0x12fb8
movq 0x6ce5(%rip), %rdx      # 0x12f98
movq %rbx, %rdi
callq 0x8900
movl $0x0, 0x4(%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x10(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc2f1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
testb %bpl, %bpl
jne 0xc2fb
jmp 0xc303
movq %rax, %r14
movq %rbx, %rdi
callq 0x8340
movq %r14, %rdi
callq 0x8970
nop
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/address.cpp
// Function: socket_io::socket_address<sockaddr_in>::get_port[abi:cxx11]() const
auto socket_address<T>::get_port() const -> std::string
{
    long port_as_integer;
    if constexpr(is_ipv4)
	port_as_integer = ntohs(handle.sin_port);
    else
	port_as_integer = ntohs(handle.sin6_port);
    return std::to_string(port_as_integer);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movzwl 0x2(%rsi), %eax
rolw $0x8, %ax
movq %rdi, %rbx
movl $0x1, %ebp
movzwl %ax, %r14d
cmpw $0xa, %ax
jb 0xc4e4
movl $0x2, %ebp
cmpw $0x64, %ax
jb 0xc4e4
movl $0x3, %ebp
cmpl $0x3e8, %r14d           # imm = 0x3E8
jb 0xc4e4
cmpl $0x2710, %r14d          # imm = 0x2710
movl $0x5, %ebp
sbbl $0x0, %ebp
movl %ebp, %esi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
movl $0x2d, %edx
callq 0x8580
movq (%rbx), %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x8450
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/epoll.cpp
// Function: socket_io::epoll::epoll()
epoll::epoll()
{
    handle = epoll_create1(0);
    if (handle == -1)
	throw std::runtime_error{"An error occured while creating epoll: " +
		                 get_errno_as_string()};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
xorl %edi, %edi
callq 0x8660
movl %eax, (%rbx)
cmpl $-0x1, %eax
je 0xd265
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x8220
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8350
leaq 0x1756(%rip), %rsi      # 0xe9d9
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x88e0
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x88a0
xorl %ebp, %ebp
movq 0x5d45(%rip), %rsi      # 0x12ff0
movq 0x5c86(%rip), %rdx      # 0x12f38
movq %r14, %rdi
callq 0x8900
movq %rax, %r15
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd2d8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x84c0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd2f3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84c0
testb %bpl, %bpl
jne 0xd31d
jmp 0xd325
movq %rax, %r15
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd31d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0xd31d
movq %rax, %r15
movq %r14, %rdi
callq 0x8340
leaq 0x8(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0xd33d
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x84c0
movq %r15, %rdi
callq 0x8970
nop
// File: /workspace/github_cpp_makefile_star2_O3/dak98[P]SocketIO/src/epoll.cpp
// Function: socket_io::epoll::add(socket_io::socket_view const&, unsigned int)
auto epoll::add(socket_view const& to_monitor, uint32_t const events) -> void
{
    int const sockfd = to_monitor.get_native_handle();
    epoll_event config { events, { .fd = sockfd } };
    if (epoll_ctl(handle, EPOLL_CTL_ADD, sockfd, &config) == -1)
	throw std::runtime_error{"An error occured while adding a fd: " +
		                 get_errno_as_string()};
    monitored_sockets.push_back(to_monitor);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x8430
leaq 0x44(%rsp), %rcx
movl %ebp, (%rcx)
movl %eax, 0x4(%rcx)
movl (%r14), %edi
movl $0x1, %esi
movl %eax, %edx
callq 0x86c0
cmpl $-0x1, %eax
je 0xd409
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
je 0xd3f1
movq (%rbx), %rax
movq %rax, (%rsi)
addq $0x8, 0x10(%r14)
jmp 0xd400
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8570
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x8220
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8350
leaq 0x15dc(%rip), %rsi      # 0xea01
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x88e0
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x88a0
xorl %ebp, %ebp
movq 0x5ba5(%rip), %rsi      # 0x12ff0
movq 0x5ae6(%rip), %rdx      # 0x12f38
movq %rbx, %rdi
callq 0x8900
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd478
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84c0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd493
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
testb %bpl, %bpl
jne 0xd4bd
jmp 0xd4c5
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd4bd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0xd4bd
movq %rax, %r14
movq %rbx, %rdi
callq 0x8340
movq %r14, %rdi
callq 0x8970
nop
// File: /workspace/github_cpp_makefile_star2_O3/myint[P]optparse/./optparse.h
// Function: optparse::detail::str_inc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::string str_inc(const std::string &s)
        {
            std::stringstream ss;
            long i = 0;
            std::istringstream(s) >> i;
            ss << i + 1;
            return ss.str();
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x318, %rsp            # imm = 0x318
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x31b0
movq $0x0, 0x8(%rsp)
leaq 0x198(%rsp), %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x3430
leaq 0x198(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3260
leaq 0x198(%rsp), %rdi
callq 0x3110
leaq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
incq %rsi
callq 0x3230
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x33d0
leaq 0x10(%rsp), %rdi
callq 0x31d0
addq $0x318, %rsp            # imm = 0x318
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x198(%rsp), %rdi
callq 0x3110
jmp 0x5e93
jmp 0x5e90
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x3480
movq %rax, %rdi
callq 0x6bfc
// File: /workspace/github_cpp_makefile_star2_O3/myint[P]optparse/./optparse.h
// Function: optparse::detail::cols()
static unsigned int cols()
        {
            unsigned int n = 80;
#ifndef _WIN32
            const char *s = getenv("COLUMNS");
            if (s)
            {
                std::istringstream(s) >> n;
            }
#endif
            return n;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl $0x50, 0xc(%rsp)
leaq 0x989f(%rip), %rdi      # 0xfbc3
callq 0x3300
testq %rax, %rax
je 0x6398
movq %rax, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rax, %rdi
callq 0x3100
movq %rbx, %rdx
addq %rax, %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x83e0
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x3430
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x3470
leaq 0x30(%rsp), %rdi
callq 0x3110
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x6392
callq 0x3220
movl 0xc(%rsp), %eax
jmp 0x639d
movl $0x50, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3110
jmp 0x63c4
movq %rax, %rdi
callq 0x6bfc
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x63d3
callq 0x3220
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/myint[P]optparse/./optparse.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> optparse::detail::str_join_trans<std::_Rb_tree_const_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, optparse::detail::str_wrap>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::_Rb_tree_const_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::_Rb_tree_const_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, optparse::detail::str_wrap)
static std::string str_join_trans(const std::string &sep, InputIterator begin, InputIterator end, UnaryOperator op)
        {
            std::string buf;
            for (InputIterator it = begin; it != end; ++it)
            {
                if (it != begin)
                {
                    buf += sep;
                }
                buf += op(*it);
            }

            return buf;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpq %rcx, %rdx
je 0x6474
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %rbx
movq %rdx, %r12
cmpq %rbp, %r12
je 0x642c
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %rbx, %rdi
callq 0x30c0
leaq 0x20(%r12), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xbebc
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x30c0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6464
callq 0x3220
movq %r12, %rdi
callq 0x32c0
movq %rax, %r12
cmpq %r15, %rax
jne 0x6417
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6485
movq %rax, %r14
jmp 0x64a1
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x64a1
callq 0x3220
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x64af
callq 0x3220
movq %r14, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/myint[P]optparse/./optparse.h
// Function: optparse::OptionParser& optparse::OptionParser::set_defaults<char const*>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*)
OptionParser &set_defaults(const std::string &dest, T t)
        {
            std::ostringstream ss;
            ss << t;
            _defaults[dest] = ss.str();
            return *this;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3330
testq %r15, %r15
je 0x6c46
movq %r15, %rdi
callq 0x3100
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x32b0
jmp 0x6c62
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x28, %rdi
movl 0x20(%rdi), %esi
orl $0x1, %esi
callq 0x3440
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x33d0
leaq 0x1c0(%rbx), %rdi
movq %r14, %rsi
callq 0xdc8a
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x3140
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6ca0
callq 0x3220
leaq 0x28(%rsp), %rdi
callq 0x3090
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x6cbc
movq %rax, %rbx
jmp 0x6cd7
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6cd7
callq 0x3220
leaq 0x28(%rsp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x3480
movq %rax, %rdi
callq 0x6bfc
nop
// File: /workspace/github_cpp_makefile_star2_O3/myint[P]optparse/./optparse.h
// Function: optparse::Option::action(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Option &action(const std::string &a)
        {
            _action = a;
            if (a == "store_const" or
                a == "store_true" or
                a == "store_false" or
                a == "append_const" or
                a == "count" or
                a == "help" or
                a == "version")
            {
                nargs(0);
            }
            return *this;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x60, %rdi
callq 0x3140
leaq 0x891b(%rip), %rsi      # 0xf6d5
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x6e38
leaq 0x87ab(%rip), %rsi      # 0xf578
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x6e38
leaq 0x8771(%rip), %rsi      # 0xf551
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x6e38
leaq 0x89e5(%rip), %rsi      # 0xf7d8
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x6e38
leaq 0x88ac(%rip), %rsi      # 0xf6b2
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x6e38
leaq 0x8934(%rip), %rsi      # 0xf74d
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x6e38
leaq 0x8935(%rip), %rsi      # 0xf761
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x6e43
movq $0x0, 0xe0(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq