LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/pfnet-research[P]pml/src/translate_to_mdp.cpp
// Function: translate_to_mdp(ast::expr_t const&)
mdp_with_info_t translate_to_mdp(ast::expr_t const& e) {
    translation_data::init();
    auto mdp_with_info = trans_impl(e, var_env_t{});
    for (auto&& var : mdp_with_info.mdp.variables) {
        if (var.name == "location") {
            var = mdp::variable_t{
                "location",
                bound_t{0, mdp_with_info.accept}, 0};
        }
    }
    return mdp_with_info;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0x222cc(%rip)     # 0x622c8
movl %eax, 0x222ca(%rip)     # 0x622cc
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
callq 0x3d82e
leaq 0x20(%rsp), %rdi
callq 0x40d92
movq 0x20(%rbx), %r14
movq 0x28(%rbx), %r13
cmpq %r13, %r14
je 0x40115
leaq 0x10(%rsp), %r15
leaq 0x20(%rsp), %rbp
movq %r14, %rdi
leaq 0x5107(%rip), %rsi      # 0x45150
callq 0x90c0
testl %eax, %eax
jne 0x40108
movq %r15, (%rsp)
movq %rsp, %rdi
leaq 0x50ec(%rip), %rsi      # 0x45150
leaq 0x50ed(%rip), %rdx      # 0x45158
callq 0x116f8
movq %rbx, %r15
movl 0x6c(%rbx), %ebx
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
movq %rbp, %r12
movq %rbp, %rdi
callq 0xac68
shlq $0x20, %rbx
movq %rbx, 0x44(%rsp)
xorl %eax, %eax
movl %eax, 0x4c(%rsp)
movl %eax, 0x40(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x9170
leaq 0x40(%rsp), %rbx
leaq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x4104a
movq %rbx, %rdi
callq 0xaa94
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
movq %r15, %rbx
je 0x400ed
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x92e0
movq (%rsp), %rdi
leaq 0x10(%rsp), %r15
cmpq %r15, %rdi
je 0x40108
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x92e0
addq $0x30, %r14
cmpq %r13, %r14
jne 0x4003f
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x40d92
jmp 0x40173
movq %rax, %r14
jmp 0x40150
movq %rbx, %r15
movq %rax, %r14
jmp 0x4016b
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x37daa
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x4016b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x92e0
movq %r15, %rdi
callq 0x37b5c
movq %r14, %rdi
callq 0x94e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/pfnet-research[P]pml/src/translate_to_pctl.cpp
// Function: translate_to_pctl(ast::refinement_type_t const&, mdp_with_info_t const&)
pctl::pctl_t translate_to_pctl(ast::refinement_type_t const& ty, mdp_with_info_t const& mdp_with_info) {
    using namespace logic;
    auto const& arg = mdp_with_info.value.name;
    auto formula = ty.domain == domain_kind_t::Int ?
        subst(ty.constraint, ty.name, make<var_term_t>(arg)) :
        subst(ty.constraint, ty.name, make<var_formula_t>(arg));
    return pctl::pctl_t {
        mdp_with_info.accept,
        formula
    };
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x70(%rdx), %rcx
cmpl $0x0, 0x20(%rsi)
je 0x427b0
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %rsi
leaq 0xf(%rsp), %rdx
callq 0x42928
leaq 0x28(%r15), %rsi
movaps 0x10(%rsp), %xmm0
leaq 0x20(%rsp), %rcx
movaps %xmm0, (%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
movq %r15, %rdx
callq 0x127f6
jmp 0x427f8
leaq 0x28(%r15), %r12
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r13
leaq 0xf(%rsp), %rdx
movq %r13, %rsi
callq 0x42898
movaps (%r13), %xmm0
leaq 0x20(%rsp), %rcx
movaps %xmm0, (%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, (%r13)
leaq 0x30(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x11c49
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x42807
callq 0xa946
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x42816
callq 0xa946
movl 0x6c(%r14), %eax
movl %eax, (%rbx)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rbx)
movq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rbx)
testq %rdi, %rdi
je 0x42857
movq 0x1f776(%rip), %rax     # 0x61fb0
cmpb $0x0, (%rax)
je 0x42844
incl 0x8(%rdi)
jmp 0x42852
lock
incl 0x8(%rdi)
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x42857
callq 0xa946
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4286a
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x4287c
callq 0xa946
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x42890
callq 0xa946
jmp 0x42890
movq %rax, %rbx
movq %rbx, %rdi
callq 0x94e0
// File: /workspace/github_cpp_makefile_star2_O3/pfnet-research[P]pml/src/typechecker.cpp
// Function: model_checking(ast::expr_t const&, ast::refinement_type_t const&)
bool model_checking(ast::expr_t const& expr, ast::refinement_type_t const& type) {
    std::cout << "    converting the program to MDP .. " << std::flush;
    auto mdp_with_info = translate_to_mdp(expr);
    std::cout << "done!" << std::endl;
    std::cout << "    converting the type to PCTL .. " << std::flush;
    auto pctl = translate_to_pctl(type, mdp_with_info);
    std::cout << "done!" << std::endl;
    std::cout << "    checking with PRISM .. " << std::flush;
    auto result = check_by_PRISM(mdp_with_info.mdp, pctl);
    std::cout << "done!" << std::endl;
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x1e327(%rip), %r14     # 0x61fb8
leaq 0x8f58(%rip), %rsi      # 0x4cbf0
movl $0x25, %edx
movq %r14, %rdi
callq 0x9350
movq %r14, %rdi
callq 0x91c0
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x3ffe3
leaq 0x8f55(%rip), %rsi      # 0x4cc16
movl $0x5, %edx
movq %r14, %rdi
callq 0x9350
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x92c0
movsbl %al, %esi
movq 0x1e2cc(%rip), %rdi     # 0x61fb8
callq 0x9030
movq %rax, %rdi
callq 0x91c0
movq 0x1e2b8(%rip), %rdi     # 0x61fb8
leaq 0x8f15(%rip), %rsi      # 0x4cc1c
movl $0x23, %edx
callq 0x9350
movq 0x1e2a0(%rip), %rdi     # 0x61fb8
callq 0x91c0
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %rbx, %rsi
callq 0x4274c
movq 0x1e282(%rip), %rbx     # 0x61fb8
leaq 0x8ed9(%rip), %rsi      # 0x4cc16
movl $0x5, %edx
movq %rbx, %rdi
callq 0x9350
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x92c0
movsbl %al, %esi
movq 0x1e250(%rip), %rdi     # 0x61fb8
callq 0x9030
movq %rax, %rdi
callq 0x91c0
movq 0x1e23c(%rip), %rdi     # 0x61fb8
leaq 0x8ebd(%rip), %rsi      # 0x4cc40
movl $0x1b, %edx
callq 0x9350
movq 0x1e224(%rip), %rdi     # 0x61fb8
callq 0x91c0
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x4398c
movl %eax, %ebx
movq 0x1e207(%rip), %r14     # 0x61fb8
leaq 0x8e5e(%rip), %rsi      # 0x4cc16
movl $0x5, %edx
movq %r14, %rdi
callq 0x9350
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x92c0
movsbl %al, %esi
movq 0x1e1d5(%rip), %rdi     # 0x61fb8
callq 0x9030
movq %rax, %rdi
callq 0x91c0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x43dff
callq 0xa946
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43e20
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x92e0
leaq 0x70(%rsp), %rdi
callq 0xa808
leaq 0x58(%rsp), %rdi
callq 0xa838
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0xa868
movq -0x20(%r14), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x43e5c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x92e0
movl %ebx, %eax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x43e83
jmp 0x43e6f
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x43e86
callq 0xa946
jmp 0x43e86
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x37b5c
movq %rbx, %rdi
callq 0x94e0
// File: /workspace/github_cpp_makefile_star2_O3/pfnet-research[P]pml/src/typechecker.cpp
// Function: add_bindings(std::shared_ptr<ast::expr_t> const&, environment_t<ast::expr_t> const&)
ptr<ast::expr_t> add_bindings(ptr<ast::expr_t> const& expr, env_t const& env) {
    auto acc = expr;
    auto const& maps = env.elems;
    for (auto it = maps.rbegin(); it != maps.rend(); ++it)
        acc = make<ast::let_expr_t>(it->first, it->second, acc);
    return acc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x43ed4
movq 0x1e0ea(%rip), %rcx     # 0x61fb0
cmpb $0x0, (%rcx)
je 0x43ed0
incl 0x8(%rax)
jmp 0x43ed4
lock
incl 0x8(%rax)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x43f51
leaq (%rax,%rax,2), %r15
shlq $0x4, %r15
addq (%r14), %r15
leaq 0x18(%rsp), %r12
leaq 0x10(%rsp), %r13
leaq 0xf(%rsp), %rbp
movq %r15, %r8
addq $-0x30, %r15
addq $-0x10, %r8
movq $0x0, 0x10(%rsp)
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r15, %rcx
movq %rbx, %r9
callq 0x4438a
movaps 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x8(%rbx), %rdi
movups %xmm0, (%rbx)
testq %rdi, %rdi
je 0x43f4c
callq 0xa946
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x43f4c
callq 0xa946
cmpq (%r14), %r15
jne 0x43ef7
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x43f74
callq 0xa946
movq %r14, %rdi
callq 0x94e0
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/NetManager.cpp
// Function: network::NetManager::unsubscribe(network::NetClient const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void	NetManager::unsubscribe(NetClient const *client, std::string const &topic)
  {
    // global
    if (topic == "")
      {
	auto c = std::find(_fullClients.begin(), _fullClients.end(), client);
	if (c != _fullClients.end())
	  _fullClients.erase(c);
      }
    // topic
    else
      {
	auto topicSubs = _netClients.find(topic);
	// new topic
	if (topicSubs != _netClients.end())
	  {
	    auto c = std::find((*topicSubs).second.begin(),
			       (*topicSubs).second.end(),
			       client);
	    if (c != (*topicSubs).second.end())
	      (*topicSubs).second.erase(c);

	    if ((*topicSubs).second.size() == 0)
	      _netClients.erase(topicSubs);
	  }
      }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %r15
movq %rsi, 0x8(%rsp)
leaq 0x90d5(%rip), %rsi      # 0x152ba
movq %rdx, %rdi
callq 0xb170
testl %eax, %eax
je 0xc275
leaq 0x1f8(%r15), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb520
addq $0x200, %r15            # imm = 0x200
cmpq %r15, %rax
je 0xc2bf
movq %rax, %r14
movq 0x40(%rax), %rdi
movq 0x48(%rax), %rsi
leaq 0x8(%rsp), %rdx
callq 0xbb70
movq 0x40(%r14), %rcx
movq 0x48(%r14), %rdx
cmpq %rdx, %rax
je 0xc263
movq %rax, %rsi
addq $0x8, %rsi
cmpq %rdx, %rsi
je 0xc258
subq %rsi, %rdx
movq %rax, %rdi
callq 0xbbb0
movq 0x40(%r14), %rcx
movq 0x48(%r14), %rdx
addq $-0x8, %rdx
movq %rdx, 0x48(%r14)
movq %rdx, %rax
cmpq %rcx, %rax
jne 0xc2bf
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb4b0
jmp 0xc2bf
movq 0x228(%r15), %rdi
movq 0x230(%r15), %rsi
leaq 0x8(%rsp), %rdx
callq 0xbb70
movq 0x230(%r15), %rdx
cmpq %rdx, %rax
je 0xc2bf
leaq 0x8(%rax), %rsi
cmpq %rdx, %rsi
je 0xc2b4
subq %rsi, %rdx
movq %rax, %rdi
callq 0xbbb0
movq 0x230(%r15), %rdx
addq $-0x8, %rdx
movq %rdx, 0x230(%r15)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/NetManager.cpp
// Function: network::NetManager::publish(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void const*, unsigned long)
void	NetManager::publish(std::string const &target,
			    std::string const &topic,
			    std::string const &event,
			    void const *payload, size_t size)
  {
    IndieProtocol::Message	m;

    m.target = target;
    m.topic = topic;
    m.event = event;

    m.payloadSize = size;
    m.payload = payload;

    _writeBuffer.push_back(_serializer(m));
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, 0x8(%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8f9d(%rip), %r14      # 0x152ba
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0xb270
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x68(%rsp), %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0xb270
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x8f64(%rip), %rdx      # 0x152ba
leaq 0x48(%rsp), %rdi
movq %rdx, %rsi
callq 0xb270
leaq 0x88(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x68(%rsp), %rdx
leaq 0x48(%rsp), %rcx
callq 0xb660
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0xc38e
callq 0xb730
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0xc39d
callq 0xb730
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xc3b1
callq 0xb730
leaq 0x88(%rsp), %rdi
movq %rbp, %rsi
callq 0xb3e0
leaq 0xa8(%rsp), %rdi
movq %r13, %rsi
callq 0xb3e0
leaq 0xc8(%rsp), %rdi
movq %r12, %rsi
callq 0xb3e0
leaq 0x88(%rsp), %rdx
movq 0x8(%rsp), %rax
movl %eax, 0x60(%rdx)
movq 0x10(%rsp), %rax
movq %rax, 0x68(%rdx)
leaq 0x170(%rbx), %rsi
leaq 0x18(%rsp), %rdi
callq 0xbda0
addq $0x240, %rbx            # imm = 0x240
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0xb690
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xc42e
callq 0xb990
leaq 0xd8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc444
callq 0xb730
leaq 0xb8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc45a
callq 0xb730
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc470
callq 0xb730
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xc4dc
callq 0xb990
jmp 0xc4dc
jmp 0xc4d9
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0xc4af
callq 0xb730
jmp 0xc4af
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0xc4c3
callq 0xb730
jmp 0xc4c3
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xc4e9
callq 0xb730
jmp 0xc4e9
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xb0f0
movq %rbx, %rdi
callq 0xbce0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/NetManager.cpp
// Function: network::NetClient::on(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&, std::function<void (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&, void const*, unsigned long)> const&)
void	NetClient::on(std::string const & topic, std::string const & event,
		      NetEventListener const &callback)
  {
    if (topic == "")
      {
	on(event, callback);
	return ;
      }

    auto topicListener = _topicListeners.find(topic);

    // new topic
    if (topicListener == _topicListeners.end())
      {
	_topicListeners[topic] = std::map<std::string, NetEventListener>();
	topicListener = _topicListeners.find(topic);
      }

    (*topicListener).second[event] = callback;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x8cfd(%rip), %rsi      # 0x152ba
movq %r12, %rdi
callq 0xb170
testl %eax, %eax
je 0xc69f
movq %r15, %rdi
movq %r12, %rsi
callq 0xb140
leaq 0x8(%r15), %rcx
cmpq %rcx, %rax
jne 0xc676
leaq 0x8(%rsp), %rbp
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%rbp)
xorl %eax, %eax
movq %rax, 0x8(%rbp)
movq %rbp, 0x10(%rbp)
movq %rbp, 0x18(%rbp)
movq %rax, 0x20(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xb8f0
movq %rax, %r13
movq %rax, %rdi
callq 0xb1d0
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xc663
movq %r13, %rcx
addq $0x8, %rcx
movl 0x8(%rsp), %edx
movl %edx, 0x8(%r13)
movq %rax, 0x10(%r13)
movups 0x18(%rsp), %xmm0
movups %xmm0, 0x18(%r13)
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x28(%r13)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rbp, 0x18(%rsp)
movq %rbp, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq %rsp, %rdi
callq 0xb4c0
movq %r15, %rdi
movq %r12, %rsi
callq 0xb140
addq $0x40, %rax
movq %rax, %rdi
movq %r14, %rsi
callq 0xbb30
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb7b0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x30, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xbb30
movq %rax, %rdi
movq %rbx, %rsi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb7b0
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb4c0
movq %rbx, %rdi
callq 0xbce0
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/NetManager.cpp
// Function: network::NetClient::removeListener(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&)
void	NetClient::removeListener(std::string const & topic, std::string const & event)
  {
    if (topic == "")
      {
	removeListener(event);
	return ;
      }

    auto topicListener = _topicListeners.find(topic);
    if (topicListener != _topicListeners.end())
      {
	auto eventListener = (*topicListener).second.find(event);
	if (eventListener != (*topicListener).second.end())
	  {
	    (*topicListener).second.erase(eventListener);
	  }
      }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8bb1(%rip), %rsi      # 0x152ba
movq %r15, %rdi
callq 0xb170
testl %eax, %eax
je 0xc75a
movq %r14, %rdi
movq %r15, %rsi
callq 0xb140
addq $0x8, %r14
cmpq %r14, %rax
je 0xc754
movq %rax, %r15
leaq 0x40(%rax), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb9f0
addq $0x48, %r15
cmpq %r15, %rax
je 0xc754
movq %r14, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xbb10
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xb7a0
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/NetManager.cpp
// Function: network::NetClient::message(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&, void const*, unsigned long) const
void	NetClient::message(std::string const &topic,
			   std::string const &event,
			   void const *payload, size_t size) const
  {
    auto topicListener = _topicListeners.find(topic);

    if (topicListener != _topicListeners.end())
      {
	auto eventListener = (*topicListener).second.find(event);
	if (eventListener != (*topicListener).second.end())
	  {
	    (*eventListener).second(topic, event, payload, size);
	  }
      }
    else
      {
	auto eventListener = _globalListeners.find(event);
	if (eventListener != _globalListeners.end())
	  {
	    (*eventListener).second(topic, event, payload, size);
	  }
      }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
callq 0xbe30
movq %rax, %rbp
leaq 0x8(%r13), %rax
cmpq %rax, %rbp
je 0xc7e5
leaq 0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0xb240
addq $0x48, %rbp
cmpq %rbp, %rax
jne 0xc7fa
jmp 0xc825
leaq 0x30(%r13), %rdi
movq %rbx, %rsi
callq 0xb240
addq $0x38, %r13
cmpq %r13, %rax
je 0xc825
movq %r12, 0x10(%rsp)
movq %r15, 0x8(%rsp)
cmpq $0x0, 0x50(%rax)
je 0xc834
movq %rax, %rdi
addq $0x40, %rdi
leaq 0x10(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %r14, %rsi
movq %rbx, %rdx
callq *0x58(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xb230
nop
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/NetManager.cpp
// Function: network::NetManager::onReadPossible(Socket::Client&, unsigned long)
void  NetManager::onReadPossible(Socket::Client &c, size_t size)
  {
    char *tmp;

    tmp = new char[size];
    c.read(tmp, size);
    _deserializer(IndieProtocol::Serialized(size, tmp));
    delete[] tmp;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rdx, %rdi
callq 0xb030
movq %rax, %rbx
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xb120
addq $0x178, %r14            # imm = 0x178
movl %r15d, 0x8(%rsp)
testl %r15d, %r15d
movl %r15d, %r12d
movl $0x1, %edi
cmovneq %r12, %rdi
callq 0xb030
movq %rax, 0x10(%rsp)
testl %r15d, %r15d
je 0xcce5
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xb670
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xba20
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xcd01
callq 0xb990
movq %rbx, %rdi
callq 0xb990
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xcd27
callq 0xb990
movq %rbx, %rdi
callq 0xbce0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/NetManager.cpp
// Function: network::NetManager::onPacketMessage(IndieProtocol::Message)
void  NetManager::onPacketMessage(IndieProtocol::Message msg)
  {
    std::cout << "MESSAGE" << std::endl;
    std::cout << msg.target << std::endl;
    std::cout << msg.topic << std::endl;
    std::cout << msg.event << std::endl;

    if (msg.topic != "")
      {
	auto topicSubs = _netClients.find(msg.topic);
	if (topicSubs != _netClients.end())
	  {
	    for (auto it = (*topicSubs).second.begin();
		 it != (*topicSubs).second.end(); ++it)
	      {
		if (*it)
		  (*it)->message(msg.topic, msg.event, msg.payload, msg.payloadSize);
	      }

	  }
	// warning : if subscribed to the topic and to the global, event will fire twice
	for (auto client = _fullClients.begin(); client != _fullClients.end(); ++client)
	  {
	    if (*client)
	      (*client)->message(msg.topic, msg.event, msg.payload, msg.payloadSize);
	  }
      }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xe080(%rip), %r12      # 0x1afb8
leaq 0x8392(%rip), %rsi      # 0x152d1
movl $0x7, %edx
movq %r12, %rdi
callq 0xb870
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0xb750
movsbl %al, %esi
movq %r12, %rdi
callq 0xb040
movq %rax, %rdi
callq 0xb540
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r12, %rdi
callq 0xb870
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xb750
movsbl %al, %esi
movq %r15, %rdi
callq 0xb040
movq %rax, %rdi
callq 0xb540
leaq 0x20(%rbx), %r15
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r12, %rdi
callq 0xb870
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0xb750
movsbl %al, %esi
movq %r13, %rdi
callq 0xb040
movq %rax, %rdi
callq 0xb540
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rdx
movq %r12, %rdi
callq 0xb870
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0xb750
movsbl %al, %esi
movq %r12, %rdi
callq 0xb040
movq %rax, %rdi
callq 0xb540
leaq 0x828e(%rip), %rsi      # 0x152ba
movq %r15, %rdi
callq 0xb170
testl %eax, %eax
je 0xd0cd
leaq 0x40(%rbx), %r12
leaq 0x1f8(%r14), %rdi
movq %r15, %rsi
callq 0xb520
movq %rax, %r13
leaq 0x200(%r14), %rax
cmpq %rax, %r13
je 0xd091
movq 0x40(%r13), %rbp
movq 0x48(%r13), %rax
cmpq %rax, %rbp
je 0xd091
movq (%rbp), %rdi
testq %rdi, %rdi
je 0xd08b
movq 0x68(%rbx), %rcx
movl 0x60(%rbx), %r8d
movq %r15, %rsi
movq %r12, %rdx
callq 0xb930
movq 0x48(%r13), %rax
addq $0x8, %rbp
jmp 0xd066
movq 0x228(%r14), %r13
movq 0x230(%r14), %rax
cmpq %rax, %r13
je 0xd0cd
movq (%r13), %rdi
testq %rdi, %rdi
je 0xd0c7
movq 0x68(%rbx), %rcx
movl 0x60(%rbx), %r8d
movq %r15, %rsi
movq %r12, %rdx
callq 0xb930
movq 0x230(%r14), %rax
addq $0x8, %r13
jmp 0xd09f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/Broker.cpp
// Function: network::Broker::start(int, unsigned long)
void	Broker::start(int port, size_t maxClients)
  {
    _server.OnConnect(
		      [this](Socket::Server &s, int fd)
		      {
			this->onConnect(s, fd);
		      });
    _server.OnDisconnect(
			 [this](Socket::Server &s, int fd)
			 {
			   this->onDisconnect(s, fd);
			 });
    _server.OnReadPossible(
			   [this](Socket::Server &s, int fd, size_t size)
		      {
			this->onReadPossible(s, fd, size);
		      });
    _server.OnWritePossible(
		      [this](Socket::Server &s, int fd)
		      {
			this->onWritePossible(s, fd);
		      });

    _server.start(port, maxClients);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
leaq 0x8(%rdi), %r14
leaq 0x8(%rsp), %rsi
movq $0x0, 0x8(%rsi)
movq %rdi, (%rsi)
leaq 0xf6d(%rip), %rax       # 0xfd76
movq %rax, 0x18(%rsi)
leaq 0xf6c(%rip), %rax       # 0xfd80
movq %rax, 0x10(%rsi)
movq %r14, %rdi
callq 0xb9d0
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xee39
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x8(%rsp), %rsi
movq $0x0, 0x8(%rsi)
movq %r15, (%rsi)
leaq 0xf56(%rip), %rax       # 0xfda6
movq %rax, 0x18(%rsi)
leaq 0xf55(%rip), %rax       # 0xfdb0
movq %rax, 0x10(%rsi)
movq %r14, %rdi
callq 0xb2c0
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xee80
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x8(%rsp), %rsi
movq $0x0, 0x8(%rsi)
movq %r15, (%rsi)
leaq 0xf3f(%rip), %rax       # 0xfdd6
movq %rax, 0x18(%rsi)
leaq 0xf42(%rip), %rax       # 0xfde4
movq %rax, 0x10(%rsi)
movq %r14, %rdi
callq 0xbae0
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xeec7
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x8(%rsp), %rsi
movq $0x0, 0x8(%rsi)
movq %r15, (%rsi)
leaq 0xf2c(%rip), %rax       # 0xfe0a
movq %rax, 0x18(%rsi)
leaq 0xf2b(%rip), %rax       # 0xfe14
movq %rax, 0x10(%rsi)
movq %r14, %rdi
callq 0xb450
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xef0e
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0xb4f0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xefbe
jmp 0xefbe
jmp 0xefbe
jmp 0xefbe
movq %rax, %rbx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xefb6
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xefb6
jmp 0xefbe
movq %rax, %rbx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xefb6
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xefb6
jmp 0xefbe
movq %rax, %rbx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xefb6
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xefb6
jmp 0xefbe
movq %rax, %rbx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xefb6
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0xbce0
movq %rax, %rdi
callq 0xd85c
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/Broker.cpp
// Function: network::Broker::onDisconnect(Socket::Server&, int)
void	Broker::onDisconnect(Socket::Server &s, int fd)
  {
    std::cout << "connexion interrupted" << std::endl;
    auto found = _clients.find(fd);
    if (found != _clients.end())
      _clients.erase(found);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
movq 0xbcbd(%rip), %r15      # 0x1afb8
leaq 0x5cfe(%rip), %rsi      # 0x15000
movl $0x15, %edx
movq %r15, %rdi
callq 0xb870
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xb750
movsbl %al, %esi
movq %r15, %rdi
callq 0xb040
movq %rax, %rdi
callq 0xb540
movq 0x190(%r14), %rax
testq %rax, %rax
je 0xf373
leaq 0x180(%r14), %rdi
addq $0x188, %r14            # imm = 0x188
movq %r14, %rsi
xorl %ecx, %ecx
cmpl %ebx, 0x20(%rax)
setl %cl
cmovgeq %rax, %rsi
movq 0x10(%rax,%rcx,8), %rax
testq %rax, %rax
jne 0xf353
cmpq %r14, %rsi
je 0xf373
cmpl %ebx, 0x20(%rsi)
jle 0xf379
popq %rbx
popq %r14
popq %r15
retq
popq %rbx
popq %r14
popq %r15
jmp 0xbad0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/Broker.cpp
// Function: network::Broker::onWritePossible(Socket::Server&, int)
void	Broker::onWritePossible(Socket::Server &s, int fd)
  {
    auto found = _clients.find(fd);
    IndieProtocol::Serialized tmp;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x190(%rdi), %rcx
addq $0x188, %r15            # imm = 0x188
movq %r15, %r12
testq %rcx, %rcx
je 0xf4be
movq %r15, %rax
xorl %edx, %edx
cmpl %ebx, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0xf496
movq %r15, %r12
cmpq %r15, %rax
je 0xf4be
cmpl %ebx, 0x20(%rax)
cmovgq %r15, %rax
movq %rax, %r12
movl $0x0, 0x8(%rsp)
movl $0x1, %edi
callq 0xb030
movq %rax, 0x10(%rsp)
cmpq %r15, %r12
je 0xf53e
leaq 0x8(%rsp), %r15
movq 0xe8(%r12), %rsi
cmpq 0xe0(%r12), %rsi
je 0xf534
addq $-0x10, %rsi
movq %r15, %rdi
callq 0xb200
movq 0xe8(%r12), %rax
leaq -0x10(%rax), %rcx
movq %rcx, 0xe8(%r12)
movq -0x8(%rax), %rdi
testq %rdi, %rdi
je 0xf51f
callq 0xb990
movq 0x10(%rsp), %rdx
movl 0x8(%rsp), %ecx
movq %r14, %rdi
movl %ebx, %esi
callq 0xbd70
jmp 0xf4df
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xf546
movq %rax, %rdi
callq 0xb990
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xf564
callq 0xb990
movq %rbx, %rdi
callq 0xbce0
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/protocol/Deserializer.cpp
// Function: IndieProtocol::Deserializer::deserializeConnect(IndieProtocol::Serialized const&)
void	Deserializer::deserializeConnect(Serialized const &to_handle)
  {
    Connect	conn;
    uint32_t	pos = 0;

    if (!_OnConnect)
      return ;

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

    _OnConnect(conn);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x4113(%rip), %rdx      # 0x152ba
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0xb270
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0xb2b0
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x111e4
callq 0xb730
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x50(%rbx)
je 0x1124e
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbc90
testb %al, %al
je 0x1124e
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %rdi
callq 0xb2b0
cmpq $0x0, 0x50(%rbx)
je 0x1126b
leaq 0x40(%rbx), %rdi
leaq 0x30(%rsp), %rsi
callq *0x58(%rbx)
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x1124e
callq 0xb730
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1125d
callq 0xb730
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0xb230
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x11287
callq 0xb730
jmp 0x11287
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x11296
callq 0xb730
movq %rbx, %rdi
callq 0xbce0
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
jne 0x11291
jmp 0x11296
nop
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/include/Network/protocol/IndieProtocol.hpp
// Function: IndieProtocol::Serialized::operator+(IndieProtocol::Serialized const&) const
Serialized operator+ (Serialized const &oth) const
    {
      Serialized result;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl $0x1, %edi
callq 0xb030
movq %rax, (%rsp)
movq %rax, 0x8(%rbx)
movl (%r12), %r13d
movl (%r14), %r15d
leal (%r15,%r13), %edi
movl %edi, (%rbx)
callq 0xb030
movq %rax, %rbp
movq %rax, 0x8(%rbx)
movq 0x8(%r12), %rsi
movq %rax, %rdi
movq %r13, %rdx
callq 0xb670
addq %r13, %rbp
movq 0x8(%r14), %rsi
movq %rbp, %rdi
movq %r15, %rdx
callq 0xb670
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
callq 0xb990
movq %rbx, %rdi
callq 0xbce0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/protocol/Serializer.cpp
// Function: IndieProtocol::Serializer::operator()(IndieProtocol::List const&)
Serialized	Serializer::operator() (List const &packet)
  {
    uint32_t	size = sizeof(Header) + sizeof(uint16_t);
    uint16_t	listSize = packet.clients.size();
    Serialized	buff;

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

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

    return buff;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdx), %r12
movq 0x8(%rdx), %r13
movl $0x0, (%rdi)
movl $0x1, %edi
callq 0xb030
movq %rax, %r15
movq %rax, 0x8(%rbx)
movl $0x8, %ebp
cmpq %r12, %r13
je 0x120fc
movq %r12, %rax
movl 0x8(%rax), %ecx
addl %ecx, %ebp
addl $0x2, %ebp
addq $0x20, %rax
cmpq %r13, %rax
jne 0x120eb
movl %ebp, %edi
callq 0xb030
movq %rax, %r14
movl %r13d, %eax
subl %r12d, %eax
shrl $0x5, %eax
movq %r14, 0x8(%rbx)
movl %ebp, (%r14)
movw $0x2, 0x4(%r14)
movw %ax, 0x6(%r14)
movl $0x8, %ebp
cmpq %r13, %r12
je 0x12156
movq 0x8(%r12), %r15
movl %ebp, %eax
movw %r15w, (%r14,%rax)
leal 0x2(%rbp), %edi
movq (%r12), %rsi
addq %r14, %rdi
movq %r15, %rdx
callq 0xb670
addl %r15d, %ebp
addl $0x2, %ebp
addq $0x20, %r12
jmp 0x12127
movl %ebp, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0xb990
movq %rbx, %rdi
callq 0xbce0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/protocol/Serializer.cpp
// Function: IndieProtocol::Serializer::operator()(IndieProtocol::Message const&)
Serialized	Serializer::operator() (Message const &packet)
  {
    uint16_t	size =
      sizeof(Header) +
      getStringSize(packet.target) +
      getStringSize(packet.topic) +
      getStringSize(packet.event) +
      sizeof (packet.payloadSize) +
      packet.payloadSize;

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

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

    return buff;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rdi, %r14
movq 0x8(%rdx), %r13
movq 0x28(%rdx), %rbp
movq 0x48(%rdx), %r12
movl 0x60(%rdx), %ecx
leal (%rbp,%r13), %eax
addl %r12d, %eax
movq %rcx, 0x10(%rsp)
leal (%rcx,%rax), %ebx
addl $0x10, %ebx
movl $0x0, (%rdi)
movl $0x1, %edi
callq 0xb030
movq %r14, (%rsp)
movq %rax, 0x8(%rsp)
movq %rax, 0x8(%r14)
movzwl %bx, %ebx
movq %rbx, %rdi
callq 0xb030
movq %rax, %r14
movq (%rsp), %rax
movq %r14, 0x8(%rax)
movl %ebx, (%r14)
movw $0x3, 0x4(%r14)
movw %r13w, 0x6(%r14)
movq (%r15), %rsi
leaq 0x8(%r14), %rdi
movq %r13, %rdx
callq 0xb670
leal 0x8(%r13), %eax
movw %bp, (%r14,%rax)
leal 0xa(%r13), %edi
movq 0x20(%r15), %rsi
addq %r14, %rdi
movq %rbp, %rdx
callq 0xb670
leal 0xa(%r13,%rbp), %ebx
movw %r12w, (%r14,%rbx)
leal 0xc(%r13,%rbp), %edi
movq 0x40(%r15), %rsi
addq %r14, %rdi
movq %r12, %rdx
callq 0xb670
leal (%r12,%rbx), %r13d
addl $0x2, %r13d
movq 0x10(%rsp), %rbp
movl %ebp, (%r14,%r13)
leal (%r12,%rbx), %edi
addl $0x6, %edi
movq 0x68(%r15), %rsi
addq %r14, %rdi
movq %rbp, %rdx
callq 0xb670
leal 0x4(%rbp,%r13), %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0xb990
movq %rbx, %rdi
callq 0xbce0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/sockets/Client.cpp
// Function: Socket::Client::Client()
Client::Client()
  {
    _stateThread = std::thread();
    _OnDisconnect = NULL;
    _OnReadPossible = NULL;
    _OnWritePossible = NULL;
    _OnStart = NULL;
    _isRunning = false;
    _timeout.tv_sec = 10;
    _timeout.tv_usec = 0;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8cda(%rip), %rax      # 0x1af80
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
xorl %r14d, %r14d
movq %r14, 0x10(%rdi)
movb %r14b, 0x18(%rdi)
addq $0x48, %rdi
movq %r14, 0x30(%rbx)
movl $0xa0, %edx
xorl %esi, %esi
callq 0xb3f0
xorl %eax, %eax
xchgb %al, 0x168(%rbx)
movq $0xa, 0x38(%rbx)
movq %r14, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/sockets/Client.cpp
// Function: Socket::Client::read(void*, unsigned long)
int  Client::read(void *buffer, size_t size)
  {
    int tmp;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movl 0x2c(%rdi), %edi
xorl %ecx, %ecx
callq 0xb1c0
movq %rax, %r14
cmpl $-0x1, %r14d
je 0x12c1f
testq %r15, %r15
sete %al
testl %r14d, %r14d
setne %cl
orb %al, %cl
jne 0x12c11
movl 0x2c(%rbx), %edi
callq 0xbe10
cmpq $0x0, 0x78(%rbx)
je 0x12c11
leaq 0x68(%rbx), %rdi
movq %rbx, %rsi
callq *0x80(%rbx)
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x48, %edi
callq 0xb360
movq %rax, %rbx
callq 0xb070
movl (%rax), %edi
callq 0xb1e0
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0xb290
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xbb20
xorl %ebp, %ebp
movq 0x8335(%rip), %rsi      # 0x1af98
movq 0x8326(%rip), %rdx      # 0x1af90
movq %rbx, %rdi
callq 0xbc70
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12c88
callq 0xb730
testb %bpl, %bpl
jne 0x12c92
jmp 0x12c9a
movq %rax, %r14
movq %rbx, %rdi
callq 0xb5b0
movq %r14, %rdi
callq 0xbce0
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/sockets/Client.cpp
// Function: Socket::Client::write(void const*, unsigned long)
int  Client::write(void const *buffer, size_t size)
  {
    int tmp;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x2c(%rdi), %edi
xorl %ecx, %ecx
callq 0xb370
movq %rax, %r14
cmpl $-0x1, %r14d
jne 0x12d0e
callq 0xb070
cmpl $0x68, (%rax)
jne 0x12d1c
movl 0x2c(%rbx), %edi
callq 0xbe10
cmpq $0x0, 0x78(%rbx)
je 0x12d0e
leaq 0x68(%rbx), %rdi
movq %rbx, %rsi
callq *0x80(%rbx)
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movl $0x48, %edi
callq 0xb360
movq %rax, %rbx
movl (%r15), %edi
callq 0xb1e0
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0xb290
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xbb20
xorl %ebp, %ebp
movq 0x8239(%rip), %rsi      # 0x1af98
movq 0x822a(%rip), %rdx      # 0x1af90
movq %rbx, %rdi
callq 0xbc70
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12d84
callq 0xb730
testb %bpl, %bpl
jne 0x12d8e
jmp 0x12d96
movq %rax, %r14
movq %rbx, %rdi
callq 0xb5b0
movq %r14, %rdi
callq 0xbce0
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/sockets/Client.cpp
// Function: Socket::Client::bytesAvailables() const
size_t Client::bytesAvailables() const
  {
#ifdef _WIN32
    u_long bytes = 0;
#else
    size_t bytes = 0;
#endif

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
movl 0x2c(%rdi), %edi
movl $0x541b, %esi           # imm = 0x541B
xorl %eax, %eax
callq 0xba50
cmpl $-0x1, %eax
je 0x12dd4
movq 0x8(%rsp), %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x48, %edi
callq 0xb360
movq %rax, %rbx
callq 0xb070
movl (%rax), %edi
callq 0xb1e0
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0xb290
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xbb20
xorl %ebp, %ebp
movq 0x8180(%rip), %rsi      # 0x1af98
movq 0x8171(%rip), %rdx      # 0x1af90
movq %rbx, %rdi
callq 0xbc70
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12e3d
callq 0xb730
testb %bpl, %bpl
jne 0x12e47
jmp 0x12e4f
movq %rax, %r14
movq %rbx, %rdi
callq 0xb5b0
movq %r14, %rdi
callq 0xbce0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/sockets/Server.cpp
// Function: Socket::Server::Server()
Server::Server()
		{
			_stateThread = std::thread();
			_OnConnect = NULL;
			_OnDisconnect = NULL;
			_OnReadPossible = NULL;
			_OnWritePossible = NULL;
			_OnStart = NULL;
			_isRunning = false;
			_timeout.tv_sec = 10;
			_timeout.tv_usec = 0;
		}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x78c3(%rip), %rax      # 0x1afb0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x50, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
xorl %ebp, %ebp
movl $0xa0, %edx
xorl %esi, %esi
callq 0xb3f0
xchgb %bpl, 0x174(%rbx)
movq $0xa, 0x40(%rbx)
movq $0x0, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/sockets/Server.cpp
// Function: Socket::Server::disconnect(int)
void  Server::disconnect(int fd)
	{
		auto found = std::find(_clients.begin(), _clients.end(), fd);

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

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

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

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movl %esi, (%rdx)
movq 0x20(%rdi), %rdi
movq 0x28(%rbx), %rsi
callq 0xb3a0
movq 0x28(%rbx), %rdx
cmpq %rdx, %rax
je 0x143b0
leaq 0x4(%rax), %rsi
cmpq %rdx, %rsi
je 0x1430f
subq %rsi, %rdx
movq %rax, %rdi
callq 0xbbb0
movq 0x28(%rbx), %rdx
addq $-0x4, %rdx
movq %rdx, 0x28(%rbx)
movl 0x8(%rsp), %edi
callq 0xbe10
movl 0x8(%rsp), %ecx
movq $-0x2, %rax
rolq %cl, %rax
leal 0x3f(%rcx), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
sarl $0x6, %edx
movslq %edx, %rdx
andq %rax, 0xf0(%rbx,%rdx,8)
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rdx
cmpq %rdx, %rax
sete %dil
movq %rax, %rsi
addq $0x4, %rsi
cmpq %rdx, %rsi
sete %r8b
orb %dil, %r8b
jne 0x1437f
movl (%rax), %edi
movl (%rsi), %r8d
cmpl %r8d, %edi
cmovlel %r8d, %edi
cmovlq %rsi, %rax
addq $0x4, %rsi
cmpq %rdx, %rsi
jne 0x14368
leaq 0x18(%rbx), %rsi
cmpq %rdx, %rax
cmovneq %rax, %rsi
movl (%rsi), %eax
movl %eax, 0x170(%rbx)
cmpq $0x0, 0x80(%rbx)
je 0x143b0
leaq 0x70(%rbx), %rdi
leaq 0xc(%rsp), %rdx
movl %ecx, (%rdx)
movq %rbx, %rsi
callq *0x88(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/sockets/Server.cpp
// Function: Socket::Server::read(int, void*, unsigned long)
int  Server::read(int fd, void *buffer, size_t size)
	{
		int tmp;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r12
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
movq %rcx, %rdx
xorl %ecx, %ecx
callq 0xb1c0
movq %rax, %r15
cmpl $-0x1, %r15d
je 0x1440c
testq %r12, %r12
sete %al
testl %r15d, %r15d
setne %cl
orb %al, %cl
jne 0x143fc
movq %r14, %rdi
movl %ebx, %esi
callq 0xba00
movl %r15d, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x48, %edi
callq 0xb360
movq %rax, %rbx
callq 0xb070
movl (%rax), %edi
callq 0xb1e0
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0xb290
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xbb20
xorl %ebp, %ebp
movq 0x6b48(%rip), %rsi      # 0x1af98
movq 0x6b39(%rip), %rdx      # 0x1af90
movq %rbx, %rdi
callq 0xbc70
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14475
callq 0xb730
testb %bpl, %bpl
jne 0x1447f
jmp 0x14487
movq %rax, %r14
movq %rbx, %rdi
callq 0xb5b0
movq %r14, %rdi
callq 0xbce0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/sockets/Server.cpp
// Function: Socket::Server::write(int, void const*, unsigned long)
int  Server::write(int fd, void const *buffer, size_t size)
	{
		int tmp;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
movq %rcx, %rdx
xorl %ecx, %ecx
callq 0xb370
movq %rax, %r15
cmpl $-0x1, %r15d
jne 0x144cd
callq 0xb070
cmpl $0x68, (%rax)
jne 0x144dd
movq %r14, %rdi
movl %ebx, %esi
callq 0xba00
movl %r15d, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movl $0x48, %edi
callq 0xb360
movq %rax, %rbx
movl (%r12), %edi
callq 0xb1e0
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0xb290
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xbb20
xorl %ebp, %ebp
movq 0x6a77(%rip), %rsi      # 0x1af98
movq 0x6a68(%rip), %rdx      # 0x1af90
movq %rbx, %rdi
callq 0xbc70
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14546
callq 0xb730
testb %bpl, %bpl
jne 0x14550
jmp 0x14558
movq %rax, %r14
movq %rbx, %rdi
callq 0xb5b0
movq %r14, %rdi
callq 0xbce0
// File: /workspace/github_cpp_makefile_star2_O3/Unreality3D[P]Unreality3D/indie-studio/source/Network/sockets/Server.cpp
// Function: Socket::Server::bytesAvailables(int) const
size_t Server::bytesAvailables(int fd) const
	{
#ifdef _WIN32
	    u_long bytes = 0;
#else
	    size_t bytes = 0;
#endif

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %edi
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
movl $0x541b, %esi           # imm = 0x541B
xorl %eax, %eax
callq 0xba50
cmpl $-0x1, %eax
je 0x14595
movq 0x8(%rsp), %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x48, %edi
callq 0xb360
movq %rax, %rbx
callq 0xb070
movl (%rax), %edi
callq 0xb1e0
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0xb290
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xbb20
xorl %ebp, %ebp
movq 0x69bf(%rip), %rsi      # 0x1af98
movq 0x69b0(%rip), %rdx      # 0x1af90
movq %rbx, %rdi
callq 0xbc70
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x145fe
callq 0xb730
testb %bpl, %bpl
jne 0x14608
jmp 0x14610
movq %rax, %r14
movq %rbx, %rdi
callq 0xb5b0
movq %r14, %rdi
callq 0xbce0