LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x48, %rdi
callq 0x1ee70
movl %edx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x1fed0
movq -0x88(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x4, %rdi
callq 0x1ffc0
jmp 0x266fb
leaq -0x58(%rbp), %rdi
leaq 0xb0f9(%rip), %rsi      # 0x317ff
xorl %eax, %eax
movl %eax, %edx
callq 0x20d80
cmpq $-0x1, %rax
jne 0x267b0
leaq -0x58(%rbp), %rdi
callq 0x20280
movl %eax, -0xa4(%rbp)
jmp 0x2672a
movq -0x90(%rbp), %rsi
movl -0xa4(%rbp), %eax
movl %eax, -0x68(%rbp)
addq $0x68, %rsi
movl -0x68(%rbp), %edx
leaq -0x70(%rbp), %rdi
callq 0x1fb10
jmp 0x2674c
movq -0x90(%rbp), %rax
addq $0x48, %rax
movq %rax, -0xb0(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1e3c0
movq -0xb0(%rbp), %rdi
movq %rax, -0x78(%rbp)
leaq -0x78(%rbp), %rsi
callq 0x1f760
jmp 0x2677d
leaq -0x70(%rbp), %rdi
callq 0x1f7d0
jmp 0x267b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x26827
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1f7d0
jmp 0x26827
xorl %eax, %eax
movl %eax, %edx
leaq -0x58(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movl $0x7d, %esi
callq 0x1fcf0
movq -0xc0(%rbp), %rdi
addq $0x2, %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0xb8(%rbp)
callq 0x201f0
movq -0xa0(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
movq %rax, %rcx
movq -0x80(%rbp), %rax
subq %rax, %rcx
callq 0x1f790
jmp 0x2680e
leaq -0x58(%rbp), %rdi
callq 0x1ed60
movq -0x98(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x1ed60
movq -0x60(%rbp), %rdi
callq 0x20840
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x60(%rbp)
addq $0x68, %rsi
movl -0xc(%rbp), %edx
leaq -0x20(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1fb10
movq -0x58(%rbp), %rdi
callq 0x1e3c0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x20d90
jmp 0x2688b
jmp 0x2692e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x2695a
movq -0x30(%rbp), %rdi
callq 0x1e8b0
movq %rax, -0x40(%rbp)
callq 0x1e0e0
cmpl $0x20, (%rax)
jne 0x26915
movq -0x60(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1e3c0
movq -0x68(%rbp), %rdi
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x1f760
jmp 0x268eb
leaq -0x20(%rbp), %rdi
callq 0x1fcd0
movl $0x1, -0x4c(%rbp)
callq 0x20520
jmp 0x2691c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x20520
jmp 0x2692c
callq 0x20170
jmp 0x26974
jmp 0x2694b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2695a
jmp 0x2695a
movq -0x60(%rbp), %rdi
addq $0x68, %rdi
movl -0xc(%rbp), %esi
leaq -0x20(%rbp), %rdx
callq 0x20050
jmp 0x26944
movl $0x0, -0x4c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1f7d0
addq $0x70, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x1f7d0
movq -0x30(%rbp), %rdi
callq 0x20840
movq %rax, %rdi
callq 0x21b10
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
addq $0x68, %rsi
leaq -0x28(%rbp), %rdi
callq 0x1f5c0
movq -0xa0(%rbp), %rdi
movb $0x0, -0x29(%rbp)
callq 0x1f380
leaq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x1e8f0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x1f770
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1e460
testb $0x1, %al
jne 0x26a04
jmp 0x26af4
leaq -0x40(%rbp), %rdi
callq 0x1fb80
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1f4c0
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1e330
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x60(%rbp), %rdi
callq 0x1e3c0
movq -0xc8(%rbp), %rdi
movq %rax, -0x78(%rbp)
leaq -0x78(%rbp), %rsi
callq 0x1fba0
movl %edx, -0xbc(%rbp)
movq %rax, -0xb8(%rbp)
jmp 0x26a62
movq -0xa0(%rbp), %rdi
movl -0xbc(%rbp), %eax
movq -0xb8(%rbp), %rcx
movq %rcx, -0x98(%rbp)
movl %eax, -0x90(%rbp)
movl -0x90(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rsi
callq 0x1fb20
jmp 0x26aa2
movq -0xa8(%rbp), %rdi
addq $0x68, %rdi
movq -0x58(%rbp), %rax
movl (%rax), %esi
movq -0x60(%rbp), %rdx
callq 0x20050
jmp 0x26abe
jmp 0x26ac0
leaq -0x40(%rbp), %rdi
callq 0x1e910
jmp 0x269ee
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
callq 0x1e860
leaq -0x28(%rbp), %rdi
callq 0x1e3b0
jmp 0x26b23
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x26b0a
movq -0xa0(%rbp), %rdi
callq 0x1e860
leaq -0x28(%rbp), %rdi
callq 0x1e3b0
movq -0xb0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x20840
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x40(%rbp)
addq $0x40, %rsi
leaq -0x10(%rbp), %rdi
callq 0x1f980
movq -0x40(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
callq 0x1f1c0
movl -0x48(%rbp), %ecx
movl %eax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x41(%rbp)
jge 0x2a4ff
movb -0x15(%rbp), %al
xorb $-0x1, %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x2a508
jmp 0x2a56d
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
leaq -0x14(%rbp), %rsi
callq 0x205c0
movq %rax, -0x50(%rbp)
jmp 0x2a51f
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x1f5b0
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1eb70
testb $0x1, %al
jne 0x2a54b
jmp 0x2a55f
movb $0x1, -0x15(%rbp)
jmp 0x2a568
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2a5dd
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2a4de
testb $0x1, -0x15(%rbp)
jne 0x2a5c5
movl $0x10, %edi
callq 0x1ea70
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x7317(%rip), %rsi      # 0x318a5
callq 0x1e810
jmp 0x2a595
movq -0x58(%rbp), %rdi
movq 0x10a50(%rip), %rsi     # 0x3aff0
movq 0x10981(%rip), %rdx     # 0x3af28
callq 0x20690
jmp 0x2a5ef
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x1efc0
jmp 0x2a5dd
movl -0x14(%rbp), %eax
movl %eax, -0x5c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x20460
movl -0x5c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
leaq -0x10(%rbp), %rdi
callq 0x20460
movq -0x28(%rbp), %rdi
callq 0x20840
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x8, %rdi
leaq -0xc(%rbp), %rsi
callq 0x1f340
movq -0x68(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x1e6e0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x208a0
testb $0x1, %al
jne 0x2a683
jmp 0x2a6d6
movl $0x10, %edi
callq 0x1ea70
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
leaq 0x721c(%rip), %rsi      # 0x318ba
callq 0x1e810
jmp 0x2a6a5
movq -0x70(%rbp), %rdi
movq 0x10940(%rip), %rsi     # 0x3aff0
movq 0x10871(%rip), %rdx     # 0x3af28
callq 0x20690
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x1efc0
jmp 0x2a7ab
movq -0x68(%rbp), %rsi
addq $0x68, %rsi
leaq -0x40(%rbp), %rdi
callq 0x1f980
movq -0x68(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rdx
leaq -0xc(%rbp), %rsi
callq 0x20340
movb %dl, -0x79(%rbp)
movq %rax, -0x78(%rbp)
jmp 0x2a705
movb -0x79(%rbp), %al
movq -0x78(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movb -0x58(%rbp), %al
movb %al, -0x48(%rbp)
testb $0x1, -0x48(%rbp)
jne 0x2a790
movl $0x10, %edi
callq 0x1ea70
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
leaq 0x7190(%rip), %rsi      # 0x318d5
callq 0x20b80
jmp 0x2a74c
movq -0x88(%rbp), %rdi
movq 0x1085e(%rip), %rsi     # 0x3afb8
movq 0x10837(%rip), %rdx     # 0x3af98
callq 0x20690
jmp 0x2a7b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2a7a2
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x1efc0
jmp 0x2a7a2
leaq -0x40(%rbp), %rdi
callq 0x20460
addq $0x90, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x20460
movq -0x30(%rbp), %rdi
callq 0x20840
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x48(%rbp)
addq $0x68, %rsi
leaq -0x20(%rbp), %rdi
callq 0x1f980
movq -0x48(%rbp), %rdi
movb $0x0, -0x21(%rbp)
addq $0x8, %rdi
leaq -0x14(%rbp), %rsi
callq 0x1e7c0
movq %rax, -0x40(%rbp)
jmp 0x2a80e
movq -0x40(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x1f450
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
leaq -0x14(%rbp), %rsi
callq 0x1ee30
jmp 0x2a82e
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x2a868
jmp 0x2a85f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2a87b
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x1f7d0
jmp 0x2a87b
movq -0x58(%rbp), %rdi
callq 0x1f7d0
leaq -0x20(%rbp), %rdi
callq 0x20460
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x20460
movq -0x30(%rbp), %rdi
callq 0x20840
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x78(%rbp)
addq $0x68, %rsi
leaq -0x18(%rbp), %rdi
callq 0x1f980
movq -0x80(%rbp), %rdi
movb $0x0, -0x19(%rbp)
callq 0x20a30
movq -0x78(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1f400
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1e6e0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x208a0
testb $0x1, %al
jne 0x2a90f
jmp 0x2a991
leaq -0x30(%rbp), %rdi
callq 0x1f460
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1f8c0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x20080
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x5c(%rbp), %rdi
callq 0x1f9a0
jmp 0x2a949
movq -0x80(%rbp), %rdi
leaq -0x5c(%rbp), %rsi
callq 0x1f650
jmp 0x2a958
leaq -0x5c(%rbp), %rdi
callq 0x20230
leaq -0x30(%rbp), %rdi
callq 0x1e590
jmp 0x2a8f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x2a9ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x5c(%rbp), %rdi
callq 0x20230
jmp 0x2a9ca
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
callq 0x1e210
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x2a9b1
movq -0x80(%rbp), %rdi
callq 0x1e3b0
leaq -0x18(%rbp), %rdi
callq 0x20460
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x1e3b0
leaq -0x18(%rbp), %rdi
callq 0x20460
movq -0x68(%rbp), %rdi
callq 0x20840
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x78(%rbp)
movl (%rsi), %edi
addq $0x4, %rsi
callq 0x209e0
testb $0x1, %al
jne 0x2ce61
leaq -0x20(%rbp), %rdi
leaq 0x4841(%rip), %rsi      # 0x31694
callq 0x1e810
leaq -0x20(%rbp), %rdi
callq 0x20dd8
leaq -0x40(%rbp), %rdi
callq 0x1fed0
movq -0x78(%rbp), %rax
cmpl $0x2, 0x4(%rax)
jne 0x2ce96
leaq 0x4833(%rip), %rsi      # 0x316ae
leaq -0x40(%rbp), %rdi
callq 0x1fe30
jmp 0x2ce86
jmp 0x2ceaa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2cf0d
leaq 0x4816(%rip), %rsi      # 0x316b3
leaq -0x40(%rbp), %rdi
callq 0x1fe30
jmp 0x2cea8
jmp 0x2ceaa
leaq 0x4807(%rip), %rsi      # 0x316b8
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x1f3e0
jmp 0x2cec0
movq -0x88(%rbp), %rdi
leaq 0x47f9(%rip), %rdx      # 0x316c7
leaq -0x70(%rbp), %rsi
callq 0x1e3d0
jmp 0x2ced9
leaq -0x70(%rbp), %rdi
callq 0x1ed60
leaq -0x40(%rbp), %rdi
callq 0x1ed60
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1ed60
leaq -0x40(%rbp), %rdi
callq 0x1ed60
movq -0x48(%rbp), %rdi
callq 0x20840
nop
// File: dak98[P]SocketIO/src/address.cpp
// Function: socket_io::socket_address<sockaddr_in>::socket_address(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
socket_address<T>::socket_address(std::string const& ip_address,
				  std::string const& port)
    : handle{} // Set the structure to zero
{
    set_ip_address(ip_address);
    set_port(port);
    if constexpr(is_ipv4)
	handle.sin_family = AF_INET;
    else
	handle.sin6_family = AF_INET6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movw $0x0, (%rdi)
movw $0x0, 0x2(%rdi)
movl $0x0, 0x4(%rdi)
addq $0x8, %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x1ebd0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1f7b0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x20650
movq -0x20(%rbp), %rax
movw $0x2, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x4806(%rip), %rsi      # 0x317c0
callq 0x20db0
testb $0x1, %al
jne 0x2cfc5
jmp 0x2cfd2
movq -0x50(%rbp), %rax
movl $0x0, 0x4(%rax)
jmp 0x2cff3
movq -0x10(%rbp), %rdi
callq 0x1e8e0
movq -0x50(%rbp), %rdx
movq %rax, %rsi
addq $0x4, %rdx
movl $0x2, %edi
callq 0x20ba0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x2d087
movb $0x1, -0x45(%rbp)
movl $0x10, %edi
callq 0x1ea70
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x48f2(%rip), %rdx      # 0x3190c
leaq -0x38(%rbp), %rdi
callq 0x1fc90
jmp 0x2d025
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x20710
jmp 0x2d034
movq -0x58(%rbp), %rdi
movb $0x0, -0x45(%rbp)
movq 0xdf75(%rip), %rsi      # 0x3afb8
movq 0xdf4e(%rip), %rdx      # 0x3af98
callq 0x20690
jmp 0x2d0aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2d074
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1ed60
testb $0x1, -0x45(%rbp)
jne 0x2d07c
jmp 0x2d085
movq -0x58(%rbp), %rdi
callq 0x1efc0
jmp 0x2d0a1
movq -0x10(%rbp), %rdi
callq 0x201f0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x20840
nopw (%rax,%rax)
// File: dak98[P]SocketIO/src/address.cpp
// Function: socket_io::socket_address<sockaddr_in>::get_ip_address[abi:cxx11]() const
auto socket_address<T>::get_ip_address() const -> std::string
{
    size_type const buffer_length = ip_address_length + 1;
    char buffer[buffer_length];
    /* 
     * Error checking is no necessary as:
     * - AF_INET or AF_INET6 is a valid address family (no EAFNOSUPPORT)
     * - ip_address_length is a proper length of the address (no ENOSPC)
     */
    if constexpr(is_ipv4)
        inet_ntop(AF_INET, &handle.sin_addr, buffer, buffer_length);
    else
	inet_ntop(AF_INET6, &handle.sin6_addr, buffer, buffer_length);
    return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq 0x10(%rsi), %rax
incq %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rdx
subq %rcx, %rdx
movq %rdx, -0x50(%rbp)
movq %rdx, %rsp
movq %rax, -0x28(%rbp)
addq $0x4, %rsi
movl -0x18(%rbp), %ecx
movl $0x2, %edi
callq 0x1f7f0
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x20850
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x20640
jmp 0x2d2f2
leaq -0x29(%rbp), %rdi
callq 0x1f860
movq -0x60(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x1f860
movq -0x38(%rbp), %rdi
callq 0x20840
nopl (%rax)
// File: dak98[P]SocketIO/src/address.cpp
// Function: socket_io::socket_address<sockaddr_in>::to_string[abi:cxx11]() const
auto socket_address<T>::to_string() const -> std::string
{    
    std::string address_family;
    if constexpr(is_ipv4)
        address_family = "IPv4";
    else
	address_family = "IPv6";
    return "(" + address_family +   ", " +
	         get_ip_address() + ", " +
	         get_port() + ")";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x140(%rbp)
movq %rdi, %rax
movq %rax, -0x138(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x130(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x1fed0
movq -0x128(%rbp), %rdi
leaq 0x41b1(%rip), %rsi      # 0x316ae
callq 0x1fe30
jmp 0x2d504
leaq 0x441c(%rip), %rsi      # 0x31927
leaq -0xe0(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x1f3e0
jmp 0x2d51d
leaq 0x41a0(%rip), %rdx      # 0x316c4
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x1e3d0
jmp 0x2d539
movq -0x130(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0x1fc30
jmp 0x2d54e
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
leaq -0x100(%rbp), %rdx
callq 0x1f350
jmp 0x2d56a
leaq 0x4153(%rip), %rdx      # 0x316c4
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x1e3d0
jmp 0x2d583
movq -0x130(%rbp), %rsi
leaq -0x120(%rbp), %rdi
callq 0x1e660
jmp 0x2d598
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0x120(%rbp), %rdx
callq 0x1f350
jmp 0x2d5ae
movq -0x140(%rbp), %rdi
leaq 0x410b(%rip), %rdx      # 0x316c7
leaq -0x60(%rbp), %rsi
callq 0x1e3d0
jmp 0x2d5c7
leaq -0x60(%rbp), %rdi
callq 0x1ed60
leaq -0x120(%rbp), %rdi
callq 0x1ed60
leaq -0x80(%rbp), %rdi
callq 0x1ed60
leaq -0xa0(%rbp), %rdi
callq 0x1ed60
leaq -0x100(%rbp), %rdi
callq 0x1ed60
leaq -0xc0(%rbp), %rdi
callq 0x1ed60
leaq -0xe0(%rbp), %rdi
callq 0x1ed60
leaq -0x30(%rbp), %rdi
callq 0x1ed60
movq -0x138(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2d6f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2d6e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2d6d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2d6cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2d6c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2d6b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2d6ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1ed60
leaq -0x120(%rbp), %rdi
callq 0x1ed60
leaq -0x80(%rbp), %rdi
callq 0x1ed60
leaq -0xa0(%rbp), %rdi
callq 0x1ed60
leaq -0x100(%rbp), %rdi
callq 0x1ed60
leaq -0xc0(%rbp), %rdi
callq 0x1ed60
leaq -0xe0(%rbp), %rdi
callq 0x1ed60
leaq -0x30(%rbp), %rdi
callq 0x1ed60
movq -0x38(%rbp), %rdi
callq 0x20840
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x8, %rdi
movq %rdi, -0x68(%rbp)
callq 0x1ec00
xorl %edi, %edi
callq 0x1fd40
movl %eax, %ecx
movq -0x60(%rbp), %rax
movl %ecx, (%rax)
cmpl $-0x1, (%rax)
jne 0x2dfce
movb $0x1, -0x55(%rbp)
movl $0x10, %edi
callq 0x1ea70
movq %rax, -0x70(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1f040
jmp 0x2df36
leaq 0x3adf(%rip), %rsi      # 0x31a1c
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x20610
jmp 0x2df4c
movq -0x70(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x204c0
jmp 0x2df5b
movq -0x70(%rbp), %rdi
movb $0x0, -0x55(%rbp)
movq 0xd086(%rip), %rsi      # 0x3aff0
movq 0xcfb7(%rip), %rdx      # 0x3af28
callq 0x20690
jmp 0x2dfdd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2dfb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2dfa9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1ed60
leaq -0x48(%rbp), %rdi
callq 0x1ed60
testb $0x1, -0x55(%rbp)
jne 0x2dfba
jmp 0x2dfc3
movq -0x70(%rbp), %rdi
callq 0x1efc0
movq -0x68(%rbp), %rdi
callq 0x1fd70
jmp 0x2dfd4
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x20840
nopl (%rax)
// File: dak98[P]SocketIO/src/epoll.cpp
// Function: socket_io::epoll::operator=(socket_io::epoll&&)
auto epoll::operator=(epoll&& other) noexcept -> epoll&
{
    if (this == &other)
	return *this;
    
    handle = other.handle;
    other.handle = EPFD_AFTER_MOVE;
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x2e094
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2e0ae
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movl $0x1, (%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1f480
movl %eax, %ecx
movq -0x80(%rbp), %rax
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movl -0x18(%rbp), %ecx
movl %ecx, -0x20(%rbp)
movl (%rax), %edi
movl -0x18(%rbp), %edx
movl $0x1, %esi
leaq -0x24(%rbp), %rcx
callq 0x1fec0
cmpl $-0x1, %eax
jne 0x2e1d0
movb $0x1, -0x75(%rbp)
movl $0x10, %edi
callq 0x1ea70
movq %rax, -0x88(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1f040
jmp 0x2e138
leaq 0x3905(%rip), %rsi      # 0x31a44
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x20610
jmp 0x2e14e
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x204c0
jmp 0x2e160
movq -0x88(%rbp), %rdi
movb $0x0, -0x75(%rbp)
movq 0xce7e(%rip), %rsi      # 0x3aff0
movq 0xcdaf(%rip), %rdx      # 0x3af28
callq 0x20690
jmp 0x2e1f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x2e1ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x2e1b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1ed60
leaq -0x68(%rbp), %rdi
callq 0x1ed60
testb $0x1, -0x75(%rbp)
jne 0x2e1c2
jmp 0x2e1ce
movq -0x88(%rbp), %rdi
callq 0x1efc0
jmp 0x2e1ea
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x208c0
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x20840
nopw %cs:(%rax,%rax)
// File: dak98[P]SocketIO/src/epoll.cpp
// Function: socket_io::epoll::remove(socket_io::socket_view const&)
auto epoll::remove(socket_view const& to_stop_monitor) -> void
{
    int const sockfd = to_stop_monitor.get_native_handle();
    epoll_event config { 0, { .fd = sockfd } };
    if (epoll_ctl(handle, EPOLL_CTL_DEL, sockfd, &config) == -1)
    {
	if (errno == ENOENT)
	    return;
	throw std::runtime_error{"An error occured while removing a fd: " +
		                 get_errno_as_string()};
    }
    
    auto new_end = std::remove_if(std::begin(monitored_sockets),
				  std::end(monitored_sockets),
				  [=](socket_view const& view)
				  { return view.get_native_handle() ==
				           sockfd; });
    monitored_sockets.erase(new_end, std::end(monitored_sockets));		   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1f480
movl %eax, %ecx
movq -0xb8(%rbp), %rax
movl %ecx, -0x14(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, -0x1c(%rbp)
movl (%rax), %edi
movl -0x14(%rbp), %edx
movl $0x2, %esi
leaq -0x20(%rbp), %rcx
callq 0x1fec0
cmpl $-0x1, %eax
jne 0x2e329
callq 0x1e0e0
cmpl $0x2, (%rax)
jne 0x2e26b
jmp 0x2e3e7
movb $0x1, -0x6d(%rbp)
movl $0x10, %edi
callq 0x1ea70
movq %rax, -0xc0(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1f040
jmp 0x2e28b
leaq 0x37d7(%rip), %rsi      # 0x31a69
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x20610
jmp 0x2e2a1
movq -0xc0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x204c0
jmp 0x2e2b3
movq -0xc0(%rbp), %rdi
movb $0x0, -0x6d(%rbp)
movq 0xcd2b(%rip), %rsi      # 0x3aff0
movq 0xcc5c(%rip), %rdx      # 0x3af28
callq 0x20690
jmp 0x2e3f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x2e310
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x2e307
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1ed60
leaq -0x60(%rbp), %rdi
callq 0x1ed60
testb $0x1, -0x6d(%rbp)
jne 0x2e318
jmp 0x2e324
movq -0xc0(%rbp), %rdi
callq 0x1efc0
jmp 0x2e3f0
movq -0xb8(%rbp), %rdi
addq $0x8, %rdi
callq 0x1f730
movq -0xb8(%rbp), %rdi
movq %rax, -0x80(%rbp)
addq $0x8, %rdi
callq 0x1fce0
movq %rax, -0x88(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rsi
movl -0x8c(%rbp), %edx
callq 0x2e400
movq %rax, %rcx
movq -0xb8(%rbp), %rax
movq %rcx, -0x78(%rbp)
addq $0x8, %rax
movq %rax, -0xc8(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1ee50
movq -0xb8(%rbp), %rdi
addq $0x8, %rdi
callq 0x1fce0
movq %rax, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1ee50
movq -0xc8(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0xa0(%rbp), %rdx
callq 0x205e0
movq %rax, -0xb0(%rbp)
addq $0xd0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x20840
nopl (%rax)
// File: myint[P]optparse/./optparse.h
// Function: optparse::detail::str_replace_helper(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::string &str_replace_helper(std::string &s, const std::string &patt, const std::string &repl)
        {
            size_t pos = 0;
            const size_t n = patt.length();
            while (true)
            {
                pos = s.find(patt, pos);
                if (pos == std::string::npos)
                {
                    break;
                }
                s.replace(pos, n, repl);
                pos += repl.size();
            }

            return s;
        }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x44a0
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x4600
movq %rax, 0x8(%rsp)
cmpq $-0x1, 0x8(%rsp)
jne 0x98cd
jmp 0x98fb
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x40f0
movq 0x10(%rsp), %rdi
callq 0x4250
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x98aa
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: myint[P]optparse/./optparse.h
// Function: optparse::detail::add_option_group_helper(optparse::OptionParser&, optparse::OptionGroup const&)
static OptionParser &add_option_group_helper(OptionParser &parser,
                                                     const OptionGroup &group)
        {
            for (std::list<Option>::const_iterator oit = group._opts.begin(); oit != group._opts.end(); ++oit)
            {
                const Option &option = *oit;
                for (std::set<std::string>::const_iterator it = option._short_opts.begin();
                     it != option._short_opts.end();
                     ++it)
                {
                    parser._optmap_s[*it] = &option;
                }

                for (std::set<std::string>::const_iterator it = option._long_opts.begin();
                     it != option._long_opts.end();
                     ++it)
                {
                    parser._optmap_l[*it] = &option;
                }
            }
            parser._groups.push_back(&group);
            return parser;
        }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x12200
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x12230
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x12300
testb $0x1, %al
jne 0x9962
jmp 0x9a7a
leaq 0x60(%rsp), %rdi
callq 0x12360
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x17510
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x17560
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x17540
testb $0x1, %al
jne 0x99a4
jmp 0x99e9
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x70(%rsp), %rax
addq $0x160, %rax            # imm = 0x160
movq %rax, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x17590
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x14f70
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
leaq 0x48(%rsp), %rdi
callq 0x175b0
jmp 0x9980
movq 0x50(%rsp), %rdi
addq $0x30, %rdi
callq 0x17510
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rdi
addq $0x30, %rdi
callq 0x17560
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x17540
testb $0x1, %al
jne 0x9a24
jmp 0x9a69
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rax
addq $0x190, %rax            # imm = 0x190
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x17590
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x14f70
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
leaq 0x38(%rsp), %rdi
callq 0x175b0
jmp 0x99fc
jmp 0x9a6b
leaq 0x60(%rsp), %rdi
callq 0x12380
jmp 0x9934
movq 0x70(%rsp), %rdi
addq $0x1f0, %rdi            # imm = 0x1F0
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x175e0
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: myint[P]optparse/./optparse.h
// Function: optparse::detail::basename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::string basename(const std::string &s)
        {
            const char seps[] = 
#ifdef _WIN32
            "/\\";
#else
            "/";
#endif
            std::string b = s;
            size_t i = b.find_last_not_of(seps);
            if (i == std::string::npos)
            {
                if (b[0] == '/')
                {
                    b.erase(1);
                }

                return b;
            }

            b.erase(i + 1, b.length() - i - 1);
            i = b.find_last_of(seps);
            if (i != std::string::npos)
            {
                b.erase(0, i + 1);
            }

            return b;
        }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movw $0x2f, 0x56(%rsp)
movb $0x0, 0x55(%rsp)
movq 0x58(%rsp), %rsi
callq 0x4130
movq 0x28(%rsp), %rdi
leaq 0x56(%rsp), %rsi
movq $-0x1, %rdx
callq 0x4590
movq %rax, 0x30(%rsp)
jmp 0x9afe
movq 0x30(%rsp), %rax
movq %rax, 0x48(%rsp)
cmpq $-0x1, 0x48(%rsp)
jne 0x9b7b
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x45f0
movq %rax, 0x18(%rsp)
jmp 0x9b25
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x9b69
movq 0x28(%rsp), %rdi
movl $0x1, %esi
movq $-0x1, %rdx
callq 0x40a0
jmp 0x9b4a
jmp 0x9b69
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x4618
jmp 0x9c29
movb $0x1, 0x55(%rsp)
movl $0x1, 0x38(%rsp)
jmp 0x9c0e
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rax
incq %rax
movq %rax, 0x8(%rsp)
callq 0x44a0
movq %rax, 0x10(%rsp)
jmp 0x9b99
movq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x48(%rsp), %rdx
notq %rdx
addq %rax, %rdx
callq 0x40a0
jmp 0x9bba
movq 0x28(%rsp), %rdi
leaq 0x56(%rsp), %rsi
movq $-0x1, %rdx
callq 0x4310
movq %rax, (%rsp)
jmp 0x9bd6
movq (%rsp), %rax
movq %rax, 0x48(%rsp)
cmpq $-0x1, 0x48(%rsp)
je 0x9c01
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rdx
incq %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x40a0
jmp 0x9bff
jmp 0x9c01
movb $0x1, 0x55(%rsp)
movl $0x1, 0x38(%rsp)
testb $0x1, 0x55(%rsp)
jne 0x9c1f
movq 0x28(%rsp), %rdi
callq 0x4618
movq 0x20(%rsp), %rax
addq $0x68, %rsp
retq
jmp 0x9c2b
movq 0x40(%rsp), %rdi
callq 0x4570
movq %rax, %rdi
callq 0xcc60
nopl (%rax)
// File: myint[P]optparse/./optparse.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> optparse::detail::str_join_trans<__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, optparse::detail::str_wrap>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, __gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, __gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, 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:
subq $0x98, %rsp
movq %r8, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
movq %rcx, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %r8, 0x70(%rsp)
movb $0x0, 0x6f(%rsp)
callq 0x4460
movq 0x88(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x1aea0
movb %al, 0x17(%rsp)
jmp 0xaeaa
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0xaeb7
jmp 0xaf72
leaq 0x60(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x1aea0
movb %al, 0x16(%rsp)
jmp 0xaecf
movb 0x16(%rsp), %al
testb $0x1, %al
jne 0xaed9
jmp 0xaeff
movq 0x20(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x43f0
jmp 0xaeea
jmp 0xaeff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0xaf95
leaq 0x60(%rsp), %rdi
callq 0x1af80
movq %rax, 0x8(%rsp)
jmp 0xaf10
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x1aee0
jmp 0xaf26
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x43f0
jmp 0xaf37
leaq 0x30(%rsp), %rdi
callq 0x4618
jmp 0xaf43
jmp 0xaf45
leaq 0x60(%rsp), %rdi
callq 0x1af90
jmp 0xaf51
jmp 0xae92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4618
jmp 0xaf70
jmp 0xaf95
movb $0x1, 0x6f(%rsp)
testb $0x1, 0x6f(%rsp)
jne 0xaf88
movq 0x20(%rsp), %rdi
callq 0x4618
movq 0x28(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x4618
jmp 0xafa1
jmp 0xafa3
movq 0x58(%rsp), %rdi
callq 0x4570
movq %rax, %rdi
callq 0xcc60
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x348, %rsp            # imm = 0x348
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x340(%rsp)
movq %rsi, 0x338(%rsp)
leaq 0x1b0(%rsp), %rdi
callq 0x4260
movq $0x0, 0x1a8(%rsp)
movq 0x338(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movl $0x8, %edx
callq 0x4520
jmp 0xb016
leaq 0x28(%rsp), %rdi
leaq 0x1a8(%rsp), %rsi
callq 0x41e0
jmp 0xb02a
leaq 0x28(%rsp), %rdi
callq 0x4170
jmp 0xb036
leaq 0x1c0(%rsp), %rdi
movq 0x1a8(%rsp), %rsi
incq %rsi
callq 0x45b0
jmp 0xb050
movq 0x8(%rsp), %rdi
leaq 0x1b0(%rsp), %rsi
callq 0x4320
jmp 0xb064
leaq 0x1b0(%rsp), %rdi
callq 0x4290
movq 0x10(%rsp), %rax
addq $0x348, %rsp            # imm = 0x348
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0xb0aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x4170
jmp 0xb0a8
jmp 0xb0aa
leaq 0x1b0(%rsp), %rdi
callq 0x4290
jmp 0xb0b9
jmp 0xb0bb
movq 0x20(%rsp), %rdi
callq 0x4570
movq %rax, %rdi
callq 0xcc60
nopl (%rax)
// File: 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:
subq $0x1d8, %rsp            # imm = 0x1D8
movl $0x50, 0x1d4(%rsp)
leaq 0x15c0d(%rip), %rdi     # 0x21b66
callq 0x43e0
movq %rax, 0x1c8(%rsp)
cmpq $0x0, 0x1c8(%rsp)
je 0xc049
movq 0x1c8(%rsp), %rax
movq %rax, (%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4580
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x4450
jmp 0xbfa5
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl $0x8, %edx
callq 0x4520
jmp 0xbfbb
leaq 0x48(%rsp), %rdi
leaq 0x1d4(%rsp), %rsi
callq 0x4060
jmp 0xbfcf
leaq 0x48(%rsp), %rdi
callq 0x4170
jmp 0xbfdb
leaq 0x28(%rsp), %rdi
callq 0x4618
jmp 0xbfe7
leaq 0x27(%rsp), %rdi
callq 0x4390
jmp 0xc049
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0xc03d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0xc02f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4170
jmp 0xc02d
jmp 0xc02f
leaq 0x28(%rsp), %rdi
callq 0x4618
jmp 0xc03b
jmp 0xc03d
leaq 0x27(%rsp), %rdi
callq 0x4390
jmp 0xc058
movl 0x1d4(%rsp), %eax
addq $0x1d8, %rsp            # imm = 0x1D8
retq
movq 0x18(%rsp), %rdi
callq 0x4570
movq %rax, %rdi
callq 0xcc60
nopw (%rax,%rax)
// File: 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:
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
movq %rdx, 0x1c0(%rsp)
movq 0x1d0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4430
movq 0x10(%rsp), %rdi
movq 0x1c0(%rsp), %rsi
callq 0x4330
jmp 0xccbf
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x4350
jmp 0xccd0
movq 0x8(%rsp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
movq 0x1c8(%rsp), %rsi
callq 0x1f3e0
movq %rax, (%rsp)
jmp 0xccef
movq (%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x4040
jmp 0xccff
leaq 0x18(%rsp), %rdi
callq 0x4618
jmp 0xcd0b
leaq 0x48(%rsp), %rdi
callq 0x40b0
movq 0x8(%rsp), %rax
addq $0x1d8, %rsp            # imm = 0x1D8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0xcd4e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x4618
jmp 0xcd4c
jmp 0xcd4e
leaq 0x48(%rsp), %rdi
callq 0x40b0
jmp 0xcd5a
jmp 0xcd5c
movq 0x40(%rsp), %rdi
callq 0x4570
movq %rax, %rdi
callq 0xcc60
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
addq $0x60, %rdi
callq 0x4040
movq 0x8(%rsp), %rdi
leaq 0x146b4(%rip), %rsi     # 0x216c5
callq 0x14e90
testb $0x1, %al
jne 0xd09e
movq 0x8(%rsp), %rdi
leaq 0x1453e(%rip), %rsi     # 0x21568
callq 0x14e90
testb $0x1, %al
jne 0xd09e
movq 0x8(%rsp), %rdi
leaq 0x14502(%rip), %rsi     # 0x21541
callq 0x14e90
testb $0x1, %al
jne 0xd09e
movq 0x8(%rsp), %rdi
leaq 0x14774(%rip), %rsi     # 0x217c8
callq 0x14e90
testb $0x1, %al
jne 0xd09e
movq 0x8(%rsp), %rdi
leaq 0x14639(%rip), %rsi     # 0x216a2
callq 0x14e90
testb $0x1, %al
jne 0xd09e
movq 0x8(%rsp), %rdi
leaq 0x146bf(%rip), %rsi     # 0x2173d
callq 0x14e90
testb $0x1, %al
jne 0xd09e
movq 0x8(%rsp), %rdi
leaq 0x146be(%rip), %rsi     # 0x21751
callq 0x14e90
testb $0x1, %al
jne 0xd09e
jmp 0xd0ab
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x171a0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop