LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3fe8(%rip), %rax      # 0xe67e
leaq 0x3fe6(%rip), %rcx      # 0xe683
cmoveq %rax, %rcx
leaq 0x8(%rsp), %rdi
movl $0x4, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x8830
leaq 0x3fcc(%rip), %rsi      # 0xe688
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x83f0
leaq 0x3fc5(%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 0xa6fe
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0xa704
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 0xa736
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x84c0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xa74d
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 0xa77d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0xa77d
jmp 0xa77a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xa794
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84c0
movq %rbx, %rdi
callq 0x8970
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa8ec
movl $0x4, %r15d
movl %ebx, %eax
cmpl $0x63, %eax
jbe 0xa8e3
cmpl $0x3e7, %eax            # imm = 0x3E7
jbe 0xa8e9
cmpl $0x2710, %eax           # imm = 0x2710
jb 0xa8ec
movl %eax, %ecx
imulq %r13, %rcx
shrq $0x2d, %rcx
addl $0x4, %r15d
cmpl $0x1869f, %eax          # imm = 0x1869F
movl %ecx, %eax
ja 0xa8b3
addl $-0x3, %r15d
jmp 0xa8ec
addl $-0x2, %r15d
jmp 0xa8ec
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 0xa94a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
movq %r12, %rdi
callq 0x8510
jmp 0xa85d
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
movl $0xd1b71759, %r13d      # imm = 0xD1B71759
je 0xa98d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0xa98d
movq %rax, %rbx
movl $0xd1b71759, %r13d      # imm = 0xD1B71759
jmp 0xa98d
jmp 0xa98a
movq %rax, %rbx
movq %r12, %rdi
callq 0x8510
jmp 0xa99a
movq %rax, %rbx
movq %rbx, %rdi
callq 0x81c0
callq 0x88c0
jmp 0xa85d
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8450
movq %rbx, (%rsp)
movq 0x30(%rsp), %r15
movq 0x38(%rsp), %r12
cmpq %r12, %r15
je 0xad70
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 0x3aa5(%rip), %rsi      # 0xe7c6
leaq 0x3aa2(%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 0xad54
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 0xacfc
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 0xadca
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x8100
jmp 0xadd1
movq %rax, %rdi
callq 0x95b2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x82e0
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 0x399f(%rip), %rsi      # 0xe7cb
leaq 0x10(%rsp), %rdi
movl $0x4, %ecx
xorl %edx, %edx
callq 0x8930
cmpq $-0x1, %rax
jne 0xae84
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 0xaec5
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 0xaeec
jmp 0xaee9
jmp 0xaee9
jmp 0xaee9
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0xaf03
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x84c0
movq %rbx, %rdi
callq 0x8970
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8a60
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 0xaf71
movq %r14, %rdi
callq 0x81c0
callq 0x8030
cmpl $0x20, (%rax)
jne 0xafc6
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 0xaf59
callq 0x87d0
jmp 0xafcf
jmp 0xaf6e
movq %rax, %r14
callq 0x88c0
jmp 0xaf71
movq %rax, %rdi
callq 0x95b2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8450
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq (%r15), %r13
movq 0x8(%r15), %rbp
cmpq %rbp, %r13
je 0xb093
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), %rax
movl 0x18(%rsp), %ecx
movq %rax, (%rsp)
movl %ecx, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xb070
movl 0x8(%rsp), %eax
movl %eax, 0x8(%rsi)
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0xc, 0x8(%rbx)
jmp 0xb07b
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 0xb027
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 0xb0b1
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb0c8
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_O1/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 0xb69a
movl (%r14), %ebp
cmpl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
jne 0xb5e8
xorl %edi, %edi
jmp 0xb67f
movq 0x8(%r14), %r8
movq 0x10(%r14), %r9
xorl %edi, %edi
movl $0x1, %r10d
movslq %ebp, %rax
xorl %edx, %edx
divq %r9
movq %rdx, %rcx
movq (%r8,%rdx,8), %rdx
movl $0x0, %eax
testq %rdx, %rdx
je 0xb649
movq (%rdx), %r11
movq %rdx, %rax
cmpl 0x8(%r11), %ebp
je 0xb649
movq %r11, %r14
movq (%r11), %r11
testq %r11, %r11
je 0xb647
movslq 0x8(%r11), %rsi
movq %rsi, %rax
xorl %edx, %edx
divq %r9
movl $0x0, %eax
cmpq %rcx, %rdx
jne 0xb649
movq %r14, %rax
cmpl %esi, %ebp
jne 0xb61d
jmp 0xb649
xorl %eax, %eax
testq %rax, %rax
je 0xb657
cmpq $0x0, (%rax)
sete %al
jmp 0xb659
movb $0x1, %al
movl %eax, %ecx
xorb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %ebp
movzbl %dil, %edi
testb %al, %al
cmovnel %r10d, %edi
cmpl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
je 0xb67f
testb $0x1, %dil
je 0xb5f8
testb $0x1, %dil
je 0xb6a1
movq %rbx, %rdi
callq 0x8360
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x82d0
movl $0x10, %edi
callq 0x8220
movq %rax, %r14
leaq 0x31bc(%rip), %rsi      # 0xe871
movq %rax, %rdi
callq 0x8190
movq 0x792c(%rip), %rsi      # 0x12ff0
movq 0x786d(%rip), %rdx      # 0x12f38
movq %r14, %rdi
callq 0x8900
movq %rax, %r15
jmp 0xb6e3
movq %rax, %r15
movq %r14, %rdi
callq 0x8330
movq %rbx, %rdi
callq 0x8360
movq %r15, %rdi
callq 0x8970
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdi, %r14
movl %esi, 0xc(%rsp)
movslq %esi, %rax
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %r8
xorl %r10d, %r10d
xorl %edx, %edx
divq %r8
movq (%rdi,%rdx,8), %rax
testq %rax, %rax
je 0xb786
movq (%rax), %r9
movq %rax, %r10
cmpl %esi, 0x8(%r9)
je 0xb786
movq %rdx, %rcx
movq %r9, %r11
movq (%r9), %r9
testq %r9, %r9
je 0xb783
movslq 0x8(%r9), %rdi
movq %rdi, %rax
xorl %edx, %edx
divq %r8
movl $0x0, %r10d
cmpq %rcx, %rdx
jne 0xb786
movq %r11, %r10
cmpl %esi, %edi
jne 0xb758
jmp 0xb786
xorl %r10d, %r10d
testq %r10, %r10
je 0xb791
cmpq $0x0, (%r10)
jne 0xb805
leaq 0x68(%r14), %r15
movq %r15, %rdi
callq 0x87e0
testl %eax, %eax
jne 0xb7cc
addq $0x8, %r14
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8910
testb $0x1, %dl
je 0xb7d3
movq %r15, %rdi
callq 0x8360
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x82d0
movl $0x10, %edi
callq 0x8220
movq %rax, %r14
leaq 0x30ba(%rip), %rsi      # 0xe8a1
movq %rax, %rdi
callq 0x8a00
movq 0x77c2(%rip), %rsi      # 0x12fb8
movq 0x779b(%rip), %rdx      # 0x12f98
movq %r14, %rdi
callq 0x8900
movl $0x10, %edi
callq 0x8220
movq %rax, %r14
leaq 0x306d(%rip), %rsi      # 0xe886
movq %rax, %rdi
callq 0x8190
movq 0x77c8(%rip), %rsi      # 0x12ff0
movq 0x7709(%rip), %rdx      # 0x12f38
movq %r14, %rdi
callq 0x8900
movq %rax, %rbx
movq %r14, %rdi
callq 0x8330
jmp 0xb85c
movq %rax, %rbx
movq %r14, %rdi
callq 0x8330
jmp 0xb854
movq %rax, %rbx
movq %r15, %rdi
callq 0x8360
movq %rbx, %rdi
callq 0x8970
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb8c5
addq $0x8, %r15
leaq 0xc(%rsp), %rsi
movq %r15, %rdi
callq 0x84a0
movq %r14, %rdi
movq %rax, %rsi
callq 0x8400
leaq 0xc(%rsp), %rsi
movq %r15, %rdi
callq 0x84f0
movq %rbx, %rdi
callq 0x8360
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x82d0
movq %rax, %r15
movq %r14, %rdi
callq 0x8510
jmp 0xb8dc
movq %rax, %r15
movq %rbx, %rdi
callq 0x8360
movq %r15, %rdi
callq 0x8970
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb987
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x18(%r15), %rbp
testq %rbp, %rbp
je 0xb961
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %r13
leaq 0xc(%rbp), %rsi
movl 0x8(%rbp), %eax
movl %eax, 0xc(%rsp)
movq %r12, %rdi
callq 0x8400
movq %r14, %rdi
movq %r13, %rsi
callq 0x8460
movq %r12, %rdi
callq 0x8510
movq (%rbp), %rbp
testq %rbp, %rbp
jne 0xb932
addq $0x8, %r15
movq %r15, %rdi
callq 0x86d0
movq %rbx, %rdi
callq 0x8360
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x82d0
movq %rax, %r15
movq %r12, %rdi
callq 0x8510
movq %r14, %rdi
callq 0x80c0
movq %rbx, %rdi
callq 0x8360
movq %r15, %rdi
callq 0x8970
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x89b0
testb %al, %al
jne 0xc11d
leaq 0x255c(%rip), %rsi      # 0xe664
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x8190
movq %r15, %rdi
callq 0x8a78
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
cmpl $0x2, (%r14)
leaq 0x2541(%rip), %rax      # 0xe67e
leaq 0x253f(%rip), %rcx      # 0xe683
cmoveq %rax, %rcx
movq %rsp, %rdi
movl $0x4, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x8830
leaq 0x2527(%rip), %rsi      # 0xe688
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x83f0
leaq 0x2522(%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 0xc1a1
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0xc1a7
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 0xc1d9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84c0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xc1ef
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 0xc221
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0xc221
jmp 0xc21e
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xc237
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
movq %rbx, %rdi
callq 0x8970
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
callq 0x8500
movq %rbx, %rdi
callq 0x8690
rolw $0x8, %ax
movw %ax, 0x2(%r14)
movw $0x2, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2503(%rip), %rsi      # 0xe78c
movq %r14, %rdi
callq 0x8110
testl %eax, %eax
je 0xc2ef
movq (%r14), %rsi
leaq 0x4(%rbx), %rdx
movl $0x2, %edi
callq 0x8a10
testl %eax, %eax
jne 0xc2f6
movl $0x10, %edi
callq 0x8220
movq %rax, %rbx
leaq 0x261a(%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 0x6cd8(%rip), %rsi      # 0x12fb8
movq 0x6cb1(%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 0xc32d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0xc32d
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xc33a
movq %rbx, %rdi
callq 0x8330
movq %r14, %rdi
callq 0x8970
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %rax
leal 0x1(%rax), %ecx
movq %rsp, %r14
addq $0x10, %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
addq $0x4, %rsi
movl $0x2, %edi
movq %r14, %rdx
callq 0x8520
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x81d0
leaq (%rax,%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x81a0
movq %rbx, %rax
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc51a
movl $0x2, %ebp
cmpw $0x64, %ax
jb 0xc51a
movl $0x3, %ebp
cmpl $0x3e8, %r14d           # imm = 0x3E8
jb 0xc51a
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 0x8440
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x40, %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 0xd2a1
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x8220
movq %rax, %r14
movq %rsp, %rdi
callq 0x8340
leaq 0x171c(%rip), %rsi      # 0xe9d9
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x88e0
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x88a0
xorl %ebp, %ebp
movq 0x5d0d(%rip), %rsi      # 0x12ff0
movq 0x5c4e(%rip), %rdx      # 0x12f38
movq %r14, %rdi
callq 0x8900
movq %rax, %r15
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd318
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0xd318
movq %rax, %r15
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd33b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0xd33b
movq %rax, %r15
movb $0x1, %bpl
leaq 0x8(%rbx), %r12
testb %bpl, %bpl
je 0xd34c
movq %r14, %rdi
callq 0x8330
movq (%r12), %rdi
testq %rdi, %rdi
je 0xd361
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x84c0
movq %r15, %rdi
callq 0x8970
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8420
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 0xd42d
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
je 0xd415
movq (%rbx), %rax
movq %rax, (%rsi)
addq $0x8, 0x10(%r14)
jmp 0xd424
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 0x8340
leaq 0x15b8(%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 0x5b81(%rip), %rsi      # 0x12ff0
movq 0x5ac2(%rip), %rdx      # 0x12f38
movq %rbx, %rdi
callq 0x8900
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd4a4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0xd4a4
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd4c7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0xd4c7
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xd4d4
movq %rbx, %rdi
callq 0x8330
movq %r14, %rdi
callq 0x8970
// File: /workspace/github_cpp_makefile_star2_O1/dak98[P]SocketIO/src/epoll.cpp
// Function: socket_io::epoll::get_event() const
auto epoll::get_event() const -> event
{
    epoll_event events[1];
    int error_code = epoll_wait(handle, events, 1, -1);
    if (error_code == -1 && errno == EINTR)
	throw std::system_error{std::make_error_code(std::errc::interrupted)};
    if (error_code == -1)
	throw std::runtime_error{"An error occured while acquiring an event: " +
		                 get_errno_as_string()};

    auto it = std::find_if(std::begin(monitored_sockets),
			   std::end(monitored_sockets),
			   [=](socket_view const& view)
			   { return view.get_native_handle() ==
			            events[0].data.fd; });
    return {events[0].events, *it};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
movl (%rdi), %edi
leaq 0x4(%rsp), %rsi
movl $0x1, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x8210
cmpl $-0x1, %eax
je 0xd7fa
movq 0x8(%r14), %rbx
movq 0x10(%r14), %r15
movl 0x8(%rsp), %ebp
movq %r15, %r12
subq %rbx, %r12
sarq $0x5, %r12
testq %r12, %r12
jle 0xd789
incq %r12
movq %rbx, %rdi
callq 0x8420
cmpl %ebp, %eax
je 0xd7c1
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x8420
cmpl %ebp, %eax
je 0xd7db
leaq 0x10(%rbx), %r14
movq %r14, %rdi
callq 0x8420
cmpl %ebp, %eax
je 0xd7db
leaq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0x8420
cmpl %ebp, %eax
je 0xd7db
addq $0x20, %rbx
decq %r12
cmpq $0x1, %r12
jg 0xd740
movq %r15, %rax
subq %rbx, %rax
sarq $0x3, %rax
cmpq $0x1, %rax
je 0xd7ca
cmpq $0x2, %rax
je 0xd7b5
cmpq $0x3, %rax
jne 0xd7d8
movq %rbx, %rdi
callq 0x8420
cmpl %ebp, %eax
je 0xd7c1
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x8420
cmpl %ebp, %eax
jne 0xd7c6
movq %rbx, %r14
jmp 0xd7db
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x8420
cmpl %ebp, %eax
cmoveq %rbx, %r15
movq %r15, %r14
movl 0x4(%rsp), %ecx
movl (%r14), %eax
movl 0x4(%r14), %edx
shlq $0x20, %rax
orq %rcx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x8030
cmpl $0x4, (%rax)
jne 0xd83c
movl $0x20, %edi
callq 0x8220
movq %rax, %rbx
callq 0x8240
movq %rbx, %rdi
movl $0x4, %esi
movq %rax, %rdx
callq 0x8300
movq 0x56f3(%rip), %rsi      # 0x12f20
movq 0x570c(%rip), %rdx      # 0x12f40
movq %rbx, %rdi
callq 0x8900
movl $0x10, %edi
callq 0x8220
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8340
leaq 0x11f3(%rip), %rsi      # 0xea4d
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x88e0
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x88a0
xorl %ebp, %ebp
movq 0x576e(%rip), %rsi      # 0x12ff0
movq 0x56af(%rip), %rdx      # 0x12f38
movq %rbx, %rdi
callq 0x8900
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd8b7
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0xd8b7
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd8da
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x84c0
jmp 0xd8da
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
jne 0xd8e4
jmp 0xd8ec
movq %rax, %r14
movq %rbx, %rdi
callq 0x8330
movq %r14, %rdi
callq 0x8970
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rbx, %rax
addq $0x318, %rsp            # imm = 0x318
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x198(%rsp), %rdi
callq 0x3110
jmp 0x5ea3
jmp 0x5ea0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x3480
movq %rax, %rdi
callq 0x6c22
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9875(%rip), %rdi      # 0xfbc3
callq 0x3300
testq %rax, %rax
je 0x63bc
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 0x844e
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 0x63bc
callq 0x3220
movl 0xc(%rsp), %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3110
jmp 0x63e7
movq %rax, %rdi
callq 0x6c22
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x63f6
callq 0x3220
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpq %rcx, %rdx
je 0x6497
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbp
movq %rsi, %r13
movq %rdx, %r12
cmpq %rbp, %r12
je 0x644f
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %rbx, %rdi
callq 0x30c0
leaq 0x20(%r12), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xbf08
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 0x6487
callq 0x3220
movq %r12, %rdi
callq 0x32c0
movq %rax, %r12
cmpq %r15, %rax
jne 0x643a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x64ab
movq %rax, %r14
jmp 0x64c7
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x64c7
callq 0x3220
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x64d5
callq 0x3220
movq %r14, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6c6c
movq %r15, %rdi
callq 0x3100
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x32b0
jmp 0x6c88
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 0xdd10
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x3140
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6cc6
callq 0x3220
leaq 0x28(%rsp), %rdi
callq 0x3090
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x6ce2
movq %rax, %rbx
jmp 0x6cfd
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6cfd
callq 0x3220
leaq 0x28(%rsp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x3480
movq %rax, %rdi
callq 0x6c22
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x88f5(%rip), %rsi      # 0xf6d5
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x6e5e
leaq 0x8785(%rip), %rsi      # 0xf578
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x6e5e
leaq 0x874b(%rip), %rsi      # 0xf551
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x6e5e
leaq 0x89bf(%rip), %rsi      # 0xf7d8
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x6e5e
leaq 0x8886(%rip), %rsi      # 0xf6b2
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x6e5e
leaq 0x890e(%rip), %rsi      # 0xf74d
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x6e5e
leaq 0x890f(%rip), %rsi      # 0xf761
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x6e69
movq $0x0, 0xe0(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/myint[P]optparse/./optparse.h
// Function: optparse::Option& optparse::Option::set_default<char const*>(char const*)
Option &set_default(T t)
        {
            std::ostringstream ss;
            ss << t;
            _default = ss.str();
            return *this;
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3330
testq %r14, %r14
je 0x7011
movq %r14, %rdi
callq 0x3100
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x32b0
jmp 0x702d
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x20, %rdi
movl 0x20(%rdi), %esi
orl $0x1, %esi
callq 0x3440
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x33d0
leaq 0xc0(%rbx), %rdi
movq %rsp, %rsi
callq 0x3140
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x705c
callq 0x3220
leaq 0x20(%rsp), %rdi
callq 0x3090
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7091
callq 0x3220
jmp 0x7091
jmp 0x708e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x3480
movq %rax, %rdi
callq 0x6c22
nop
// File: /workspace/github_cpp_makefile_star2_O1/myint[P]optparse/./optparse.h
// Function: optparse::Values::all(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const std::vector<std::string> all(const std::string &d) const
        {
            static const std::vector<std::string> empty;
            return (_append_map.find(d) == _append_map.end()) ?
                empty :
                _append_map.at(d);
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb 0xdb8b(%rip), %al       # 0x155c8
testb %al, %al
je 0x7a87
leaq 0x30(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xe2b0
addq $0x38, %r15
cmpq %r15, %rax
je 0x7a69
movq %r12, %rdi
movq %r14, %rsi
callq 0xe23a
movq %rax, %rsi
jmp 0x7a70
leaq 0xdb40(%rip), %rsi      # 0x155b0
movq %rbx, %rdi
callq 0x76f4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x3500
jmp 0x7a41
// File: /workspace/github_cpp_makefile_star2_O1/myint[P]optparse/test.cpp
// Function: Output::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void operator()(const std::string &s)
    {
        if (first)
        {
            first = false;
        }
        else
        {
            std::cout << delim;
        }
        std::cout << s;
    }

// Assembly:
pushq %rbx
movq %rsi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x7b12
movb $0x0, 0x8(%rdi)
jmp 0x7b28
movq (%rdi), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq 0xd4a5(%rip), %rdi      # 0x14fc8
callq 0x32b0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0xd492(%rip), %rdi      # 0x14fc8
popq %rbx
jmp 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/myint[P]optparse/./optparse.h
// Function: optparse::OptionParser::set_usage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void set_usage(const std::string &u)
        {
            std::string lower = u;
            std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
            if (lower.compare(0, 7, "usage: ") == 0)
            {
                _usage = u.substr(7);
            }
            else
            {
                _usage = u;
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x82a4
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x8391
movq 0x8(%rsp), %r13
xorl %ebp, %ebp
movsbl (%r13,%rbp), %edi
callq 0x3350
movb %al, (%r13,%rbp)
incq %rbp
cmpq %rbp, %r15
jne 0x8379
leaq 0x7609(%rip), %rcx      # 0xf9a1
leaq 0x8(%rsp), %rdi
movl $0x7, %edx
xorl %esi, %esi
callq 0x3320
testl %eax, %eax
je 0x83be
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3140
jmp 0x83fb
leaq 0x28(%rsp), %rdi
movl $0x7, %edx
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x3280
addq $0x8, %rbx
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x3140
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x83fb
callq 0x3220
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x840a
callq 0x3220
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8436
callq 0x3220
jmp 0x8436
jmp 0x8433
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x8445
callq 0x3220
movq %rbx, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O1/myint[P]optparse/./optparse.h
// Function: optparse::OptionParser::format_option_help[abi:cxx11](unsigned int) const
std::string format_option_help(unsigned int indent=2) const
        {
            std::stringstream ss;

            if (_opts.empty())
            {
                return ss.str();
            }

            for (std::list<Option>::const_iterator it = _opts.begin(); it != _opts.end(); ++it)
            {
                if (not it->_suppress_help)
                {
                    ss << it->format_help(indent);
                }
            }

            return ss.str();
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x31b0
movq 0x148(%r14), %r13
addq $0x148, %r14            # imm = 0x148
cmpq %r14, %r13
je 0xcf23
leaq 0x40(%rsp), %r15
leaq 0x20(%rsp), %rbx
leaq 0x10(%rsp), %r12
cmpb $0x0, 0x150(%r13)
jne 0xcf1a
leaq 0x10(%r13), %rsi
movq %r12, %rdi
movl %ebp, %edx
callq 0xcf88
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r15, %rdi
callq 0x32b0
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0xcf1a
callq 0x3220
movq (%r13), %r13
cmpq %r14, %r13
jne 0xcee1
leaq 0x48(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x33d0
leaq 0x30(%rsp), %rdi
callq 0x31d0
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcf56
movq %rax, %r14
jmp 0xcf6d
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0xcf6d
callq 0x3220
leaq 0x30(%rsp), %rdi
callq 0x31d0
movq %r14, %rdi
callq 0x3480
movq %rax, %rdi
callq 0x6c22
nop
// File: /workspace/github_cpp_makefile_star2_O1/myint[P]optparse/./optparse.h
// Function: optparse::OptionParser::lookup_short_opt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const Option &lookup_short_opt(const std::string &opt) const
        {
            std::map<std::string, Option const *>::const_iterator it = _optmap_s.find(opt);
            if (it == _optmap_s.end())
            {
                error("no such option" + std::string(": -") + opt);

                static const Option empty;
                return empty;
            }
            return *it->second;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x160, %rdi            # imm = 0x160
callq 0xbf72
leaq 0x168(%rbx), %rcx
cmpq %rcx, %rax
je 0xd95a
movq 0x40(%rax), %rbx
jmp 0xd9f2
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2263(%rip), %rsi      # 0xfbcd
leaq 0x225f(%rip), %rdx      # 0xfbd0
movq %rsp, %rdi
callq 0x844e
leaq 0x21b7(%rip), %rsi      # 0xfb37
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xb9e6
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %r14, %rdx
callq 0xbe30
movq (%rbx), %rax
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd9c0
callq 0x3220
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd9d3
callq 0x3220
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xd9e1
callq 0x3220
movb 0x7b99(%rip), %al       # 0x15580
leaq 0x7a22(%rip), %rbx      # 0x15410
testb %al, %al
je 0xd9ff
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x7b7a(%rip), %rdi      # 0x15580
callq 0x34a0
testl %eax, %eax
je 0xd9f2
leaq 0x79fa(%rip), %rbx      # 0x15410
movq %rbx, %rdi
callq 0x96c6
leaq -0x5b09(%rip), %rdi     # 0x7f1c
leaq 0x7854(%rip), %rdx      # 0x15280
movq %rbx, %rsi
callq 0x3210
leaq 0x7b45(%rip), %rdi      # 0x15580
callq 0x3170
jmp 0xd9f2
movq %rax, %rbx
leaq 0x7b34(%rip), %rdi      # 0x15580
callq 0x3160
jmp 0xda99
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xda6e
callq 0x3220
jmp 0xda6e
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xda86
callq 0x3220
jmp 0xda86
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xda99
callq 0x3220
jmp 0xda99
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3480
nop