LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x22a05(%rip)     # 0x632c8
movl %eax, 0x22a03(%rip)     # 0x632cc
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
callq 0x3e126
leaq 0x20(%rsp), %rdi
callq 0x416a2
movq 0x20(%rbx), %r14
movq 0x28(%rbx), %r13
cmpq %r13, %r14
je 0x409dc
leaq 0x10(%rsp), %r15
leaq 0x20(%rsp), %rbp
movq %r14, %rdi
leaq 0x4840(%rip), %rsi      # 0x45150
callq 0x90c0
testl %eax, %eax
jne 0x409cf
movq %r15, (%rsp)
movq %rsp, %rdi
leaq 0x4825(%rip), %rsi      # 0x45150
leaq 0x4826(%rip), %rdx      # 0x45158
callq 0x11866
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 0xad30
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 0x4197a
movq %rbx, %rdi
callq 0xab60
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
movq %r15, %rbx
je 0x409b4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x92e0
movq (%rsp), %rdi
leaq 0x10(%rsp), %r15
cmpq %r15, %rdi
je 0x409cf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x92e0
addq $0x30, %r14
cmpq %r13, %r14
jne 0x40906
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 0x416a2
jmp 0x40a3a
movq %rax, %r14
jmp 0x40a17
movq %rbx, %r15
movq %rax, %r14
jmp 0x40a32
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x3852e
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x40a32
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x92e0
movq %r15, %rdi
callq 0x382e4
movq %r14, %rdi
callq 0x94e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x70(%rdx), %rcx
movl 0x20(%rsi), %r12d
testl %r12d, %r12d
je 0x43194
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %rsi
leaq 0xf(%rsp), %rdx
callq 0x43348
leaq 0x28(%r15), %rsi
movups 0x10(%rsp), %xmm0
leaq 0x58(%rsp), %rcx
movups %xmm0, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
callq 0x129a0
jmp 0x431e7
leaq 0x28(%r15), %rax
movq %rax, 0x30(%rsp)
leaq 0x40(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x38(%rsp), %r13
leaq 0x48(%rsp), %rbp
movq %r13, %rsi
movq %rbp, %rdx
callq 0x432b8
movups (%r13), %xmm0
movups %xmm0, (%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rcx
movq 0x30(%rsp), %rsi
movq %r15, %rdx
callq 0x11dd9
testl %r12d, %r12d
je 0x43202
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x431fb
callq 0xaa12
movq 0x18(%rsp), %rdi
jmp 0x43216
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x43211
callq 0xaa12
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x43220
callq 0xaa12
movl 0x6c(%r14), %eax
movl %eax, (%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rbx)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x43252
movq 0x1fd6c(%rip), %rcx     # 0x62fb0
cmpb $0x0, (%rcx)
je 0x4324e
incl 0x8(%rax)
jmp 0x43252
lock
incl 0x8(%rax)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x43261
callq 0xaa12
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x43298
movq %rax, %rbx
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x43287
callq 0xaa12
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4329b
callq 0xaa12
jmp 0x4329b
movq %rax, %rbx
testl %r12d, %r12d
jne 0x432af
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x9974
movq %rbx, %rdi
callq 0x94e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1e8d7(%rip), %r14     # 0x62fb8
leaq 0x8508(%rip), %rsi      # 0x4cbf0
movl $0x25, %edx
movq %r14, %rdi
callq 0x9350
movq %r14, %rdi
callq 0x91c0
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x408aa
leaq 0x8505(%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 0x1e87c(%rip), %rdi     # 0x62fb8
callq 0x9030
movq %rax, %rdi
callq 0x91c0
movq 0x1e868(%rip), %rdi     # 0x62fb8
leaq 0x84c5(%rip), %rsi      # 0x4cc1c
movl $0x23, %edx
callq 0x9350
movq 0x1e850(%rip), %rdi     # 0x62fb8
callq 0x91c0
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %rbx, %rsi
callq 0x4312c
movq 0x1e832(%rip), %rbx     # 0x62fb8
leaq 0x8489(%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 0x1e800(%rip), %rdi     # 0x62fb8
callq 0x9030
movq %rax, %rdi
callq 0x91c0
movq 0x1e7ec(%rip), %rdi     # 0x62fb8
leaq 0x846d(%rip), %rsi      # 0x4cc40
movl $0x1b, %edx
callq 0x9350
movq 0x1e7d4(%rip), %rdi     # 0x62fb8
callq 0x91c0
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x443dc
movl %eax, %ebx
movq 0x1e7b7(%rip), %r14     # 0x62fb8
leaq 0x840e(%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 0x1e785(%rip), %rdi     # 0x62fb8
callq 0x9030
movq %rax, %rdi
callq 0x91c0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4484f
callq 0xaa12
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x44870
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x92e0
leaq 0x70(%rsp), %rdi
callq 0xa8d4
leaq 0x58(%rsp), %rdi
callq 0xa904
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0xa934
movq -0x20(%r14), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x448ac
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x92e0
movl %ebx, %eax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x448d3
jmp 0x448bf
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x448d6
callq 0xaa12
jmp 0x448d6
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x382e4
movq %rbx, %rdi
callq 0x94e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x44924
movq 0x1e69a(%rip), %rcx     # 0x62fb0
cmpb $0x0, (%rcx)
je 0x44920
incl 0x8(%rax)
jmp 0x44924
lock
incl 0x8(%rax)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x449a1
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 0x44dda
movaps 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x8(%rbx), %rdi
movups %xmm0, (%rbx)
testq %rdi, %rdi
je 0x4498d
callq 0xaa12
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4499c
callq 0xaa12
cmpq (%r14), %r15
jne 0x44947
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 0x449c4
callq 0xaa12
movq %r14, %rdi
callq 0x94e0
// File: /workspace/github_cpp_makefile_star2_O1/pajlads[P]pajlang/compiler.cpp
// Function: main
int main(int argc, char *argv[])
{
    if (argc <= 1) { 
        std::cout << "no input files" << std::endl;
        return 1;
    }
    std::string file = argv[1];

    std::ifstream inFile;
    inFile.open(file);
    std::stringstream strStream;
    strStream << inFile.rdbuf();
    std::string str = strStream.str();

    auto instructions = split(str, ';');

    for (auto it = instructions.begin(); it != instructions.end(); ++it) {
        std::cout << *it;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x3f0, %rsp            # imm = 0x3F0
cmpl $0x1, %edi
jg 0x24c7
movq 0x2b56(%rip), %rbx      # 0x4fd8
leaq 0xb7b(%rip), %rsi       # 0x3004
movl $0xe, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movl $0x1, %eax
jmp 0x25cf
movq 0x8(%rsi), %rsi
leaq -0x68(%rbp), %rdi
leaq -0x3f8(%rbp), %rdx
callq 0x271a
leaq -0x3f8(%rbp), %rdi
callq 0x2170
leaq -0x3f8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x8, %edx
callq 0x2120
leaq -0x1f0(%rbp), %rdi
callq 0x20d0
leaq -0x1e0(%rbp), %rdi
leaq -0x3e8(%rbp), %rsi
callq 0x2040
leaq -0x1d8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x21b0
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl $0x3b, %edx
callq 0x235c
movq -0x28(%rbp), %r14
cmpq -0x20(%rbp), %r14
je 0x2567
movq 0x2a8a(%rip), %rbx      # 0x4fd8
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x2180
addq $0x20, %r14
cmpq -0x20(%rbp), %r14
jne 0x254e
leaq -0x28(%rbp), %rdi
callq 0x26b0
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2589
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2160
movq 0x2a30(%rip), %rsi      # 0x4fc0
leaq -0x1f0(%rbp), %rdi
callq 0x20f0
leaq -0x170(%rbp), %rdi
callq 0x2070
leaq -0x3f8(%rbp), %rdi
callq 0x2050
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25cd
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2160
xorl %eax, %eax
addq $0x3f0, %rsp            # imm = 0x3F0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
jmp 0x25ff
jmp 0x25e2
movq %rax, %rbx
jmp 0x2618
jmp 0x25e9
movq %rax, %rbx
jmp 0x2637
movq %rax, %rbx
jmp 0x2643
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x26b0
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2618
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2160
movq 0x29a1(%rip), %rsi      # 0x4fc0
leaq -0x1f0(%rbp), %rdi
callq 0x20f0
leaq -0x170(%rbp), %rdi
callq 0x2070
leaq -0x3f8(%rbp), %rdi
callq 0x2050
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x265c
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/Unreality3D[P]Unreality3D/indie-studio/source/Network/NetManager.cpp
// Function: network::NetManager::subscribe(network::NetClient const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void	NetManager::subscribe(NetClient const *client, std::string const &topic)
  {
    // global
    if (topic == "")
      {
	auto c = std::find(_fullClients.begin(), _fullClients.end(), client);
	if (c == _fullClients.end())
	  _fullClients.push_back(client);
      }
    // topic
    else
      {
	auto topicSubs = _netClients.find(topic);
	// new topic
	if (topicSubs == _netClients.end())
	  {
	    _netClients[topic] = std::vector<NetClient const *>();
	    topicSubs = _netClients.find(topic);
	  }
	auto c = std::find((*topicSubs).second.begin(),
			   (*topicSubs).second.end(),
			   client);
	if (c == (*topicSubs).second.end())
	  (*topicSubs).second.push_back(client);
      }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, (%rsp)
leaq 0x91f7(%rip), %rsi      # 0x152ba
movq %rdx, %rdi
callq 0xb170
testl %eax, %eax
je 0xc155
leaq 0x1f8(%r14), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0xb520
movq %rax, %r15
addq $0x200, %r14            # imm = 0x200
cmpq %r14, %rax
jne 0xc128
movq %r12, %rdi
movq %rbx, %rsi
callq 0xb590
movq (%rax), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
testq %rdi, %rdi
je 0xc11a
callq 0xb730
movq %r12, %rdi
movq %rbx, %rsi
callq 0xb520
movq %rax, %r15
movq 0x40(%r15), %rdi
movq 0x48(%r15), %rsi
movq %rsp, %rdx
callq 0xbb70
movq 0x48(%r15), %rsi
cmpq %rsi, %rax
jne 0xc1af
cmpq 0x50(%r15), %rsi
je 0xc191
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x48(%r15)
jmp 0xc1af
movq 0x228(%r14), %rdi
movq 0x230(%r14), %rsi
movq %rsp, %rdx
callq 0xbb70
movq 0x230(%r14), %rsi
cmpq %rsi, %rax
jne 0xc1af
cmpq 0x238(%r14), %rsi
je 0xc19d
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x230(%r14)
jmp 0xc1af
addq $0x40, %r15
movq %rsp, %rdx
movq %r15, %rdi
jmp 0xc1aa
addq $0x228, %r14            # imm = 0x228
movq %rsp, %rdx
movq %r14, %rdi
callq 0xbcc0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
leaq 0x90d5(%rip), %rsi      # 0x152ba
movq %rdx, %rdi
callq 0xb170
testl %eax, %eax
je 0xc261
leaq 0x1f8(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xb520
addq $0x200, %rbx            # imm = 0x200
cmpq %rbx, %rax
je 0xc2a1
movq %rax, %r15
movq 0x40(%rax), %rdi
movq 0x48(%rax), %rsi
leaq 0x8(%rsp), %rdx
callq 0xbb70
movq 0x48(%r15), %rdx
cmpq %rdx, %rax
je 0xc24a
leaq 0x8(%rax), %rsi
cmpq %rdx, %rsi
je 0xc245
subq %rsi, %rdx
movq %rax, %rdi
callq 0xbbb0
addq $-0x8, 0x48(%r15)
movq 0x48(%r15), %rax
cmpq 0x40(%r15), %rax
jne 0xc2a1
movq %r14, %rdi
movq %r15, %rsi
callq 0xb4b0
jmp 0xc2a1
movq 0x228(%rbx), %rdi
movq 0x230(%rbx), %rsi
leaq 0x8(%rsp), %rdx
callq 0xbb70
movq 0x230(%rbx), %rdx
cmpq %rdx, %rax
je 0xc2a1
leaq 0x8(%rax), %rsi
cmpq %rdx, %rsi
je 0xc299
subq %rsi, %rdx
movq %rax, %rdi
callq 0xbbb0
addq $-0x8, 0x230(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8fbb(%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 0x8f82(%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 0xc370
callq 0xb730
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0xc37f
callq 0xb730
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xc393
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 0xc410
callq 0xb990
leaq 0xd8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc426
callq 0xb730
leaq 0xb8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc43c
callq 0xb730
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc452
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 0xc4be
callq 0xb990
jmp 0xc4be
jmp 0xc4bb
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0xc491
callq 0xb730
jmp 0xc491
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0xc4a5
callq 0xb730
jmp 0xc4a5
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xc4cb
callq 0xb730
jmp 0xc4cb
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xb0f0
movq %rbx, %rdi
callq 0xbce0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8d1b(%rip), %rsi      # 0x152ba
movq %r12, %rdi
callq 0xb170
testl %eax, %eax
je 0xc66a
movq %r15, %rdi
movq %r12, %rsi
callq 0xb140
movq %rax, %rdi
leaq 0x8(%r15), %rax
cmpq %rax, %rdi
jne 0xc664
leaq 0x8(%rsp), %rbp
xorps %xmm0, %xmm0
movaps %xmm0, 0x8(%rbp)
movaps %xmm0, 0x18(%rbp)
movaps %xmm0, -0x8(%rbp)
movq %rbp, 0x10(%rbp)
movq %rbp, 0x18(%rbp)
movq $0x0, 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 0xc64e
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
movq %rax, %rdi
addq $0x40, %rdi
jmp 0xc671
addq $0x30, %r15
movq %r15, %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
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb4c0
movq %rbx, %rdi
callq 0xbce0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8be5(%rip), %rsi      # 0x152ba
movq %r15, %rdi
callq 0xb170
testl %eax, %eax
je 0xc726
movq %r14, %rdi
movq %r15, %rsi
callq 0xb140
addq $0x8, %r14
cmpq %r14, %rax
je 0xc720
movq %rax, %r15
leaq 0x40(%rax), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb9f0
addq $0x48, %r15
cmpq %r15, %rax
je 0xc720
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_O1/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 0xc7b1
leaq 0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0xb240
addq $0x48, %rbp
cmpq %rbp, %rax
jne 0xc7c6
jmp 0xc7f1
leaq 0x30(%r13), %rdi
movq %rbx, %rsi
callq 0xb240
addq $0x38, %r13
cmpq %r13, %rax
je 0xc7f1
movq %r12, 0x10(%rsp)
movq %r15, 0x8(%rsp)
cmpq $0x0, 0x50(%rax)
je 0xc800
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_O1/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 0xcc8d
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 0xcca9
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 0xcccf
callq 0xb990
movq %rbx, %rdi
callq 0xbce0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe0d8(%rip), %r12      # 0x1afb8
leaq 0x83ea(%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 0x82e6(%rip), %rsi      # 0x152ba
movq %r15, %rdi
callq 0xb170
testl %eax, %eax
je 0xd064
leaq 0x40(%rbx), %r12
leaq 0x1f8(%r14), %rdi
movq %r15, %rsi
callq 0xb520
movq %rax, %r13
leaq 0x200(%r14), %rax
cmpq %rax, %r13
je 0xd032
movq 0x40(%r13), %rbp
cmpq 0x48(%r13), %rbp
je 0xd032
movq (%rbp), %rdi
testq %rdi, %rdi
je 0xd02c
movq 0x68(%rbx), %rcx
movl 0x60(%rbx), %r8d
movq %r15, %rsi
movq %r12, %rdx
callq 0xb930
addq $0x8, %rbp
jmp 0xd00a
movq 0x228(%r14), %r13
cmpq 0x230(%r14), %r13
je 0xd064
movq (%r13), %rdi
testq %rdi, %rdi
je 0xd05e
movq 0x68(%rbx), %rcx
movl 0x60(%rbx), %r8d
movq %r15, %rsi
movq %r12, %rdx
callq 0xb930
addq $0x8, %r13
jmp 0xd039
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Unreality3D[P]Unreality3D/indie-studio/include/Network/protocol/IndieProtocol.hpp
// Function: IndieProtocol::Serialized::operator=(IndieProtocol::Serialized const&)
Serialized &operator= (Serialized const &oth)
    {
      size = oth.size;
      if (data)
	delete[] data;
      data = new char[size];
      memcpy(data, oth.data, size);
      return *this;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xd7c7
callq 0xb990
movl (%rbx), %r15d
movq %r15, %rdi
callq 0xb030
movq %rax, 0x8(%rbx)
movq 0x8(%r14), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0xb670
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %rdi, (%rsi)
leaq 0xfaf(%rip), %rax       # 0xfd24
movq %rax, 0x18(%rsi)
leaq 0xfae(%rip), %rax       # 0xfd2e
movq %rax, 0x10(%rsi)
movq %r14, %rdi
callq 0xb9d0
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xeda3
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %r15, (%rsi)
leaq 0xf9a(%rip), %rax       # 0xfd54
movq %rax, 0x18(%rsi)
leaq 0xf99(%rip), %rax       # 0xfd5e
movq %rax, 0x10(%rsi)
movq %r14, %rdi
callq 0xb2c0
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xede8
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %r15, (%rsi)
leaq 0xf85(%rip), %rax       # 0xfd84
movq %rax, 0x18(%rsi)
leaq 0xf88(%rip), %rax       # 0xfd92
movq %rax, 0x10(%rsi)
movq %r14, %rdi
callq 0xbae0
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xee2d
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %r15, (%rsi)
leaq 0xf74(%rip), %rax       # 0xfdb8
movq %rax, 0x18(%rsi)
leaq 0xf73(%rip), %rax       # 0xfdc2
movq %rax, 0x10(%rsi)
movq %r14, %rdi
callq 0xb450
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xee72
movq %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 0xef14
jmp 0xef14
jmp 0xef14
jmp 0xef14
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xef0c
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xef0c
jmp 0xef14
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xef0c
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xef0c
jmp 0xef14
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xef0c
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xef0c
jmp 0xef14
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xef0c
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0xbce0
movq %rax, %rdi
callq 0xd7ee
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
movq 0xbd4c(%rip), %r14      # 0x1afb8
leaq 0x5d8d(%rip), %rsi      # 0x15000
movl $0x15, %edx
movq %r14, %rdi
callq 0xb870
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb750
movsbl %al, %esi
movq %r14, %rdi
callq 0xb040
movq %rax, %rdi
callq 0xb540
movq 0x190(%rbx), %rdx
leaq 0x188(%rbx), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0xf2d7
movq %rax, %rcx
xorl %esi, %esi
cmpl %ebp, 0x20(%rdx)
setl %sil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0xf2c0
movq %rax, %rsi
cmpq %rax, %rcx
je 0xf2e9
cmpl %ebp, 0x20(%rcx)
cmovgq %rax, %rcx
movq %rcx, %rsi
cmpq %rax, %rsi
je 0xf301
addq $0x180, %rbx            # imm = 0x180
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xbad0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Unreality3D[P]Unreality3D/indie-studio/source/Network/Broker.cpp
// Function: network::Broker::onReadPossible(Socket::Server&, int, unsigned long)
void	Broker::onReadPossible(Socket::Server &s, int fd, size_t size)
  {
    auto found = _clients.find(fd);
    char *tmp;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r12
movq 0x190(%rdi), %rcx
addq $0x188, %rdi            # imm = 0x188
movq %rdi, %rax
testq %rcx, %rcx
je 0xf349
movq %rdi, %rax
xorl %edx, %edx
cmpl %ebp, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0xf333
movq %rdi, %r15
cmpq %rdi, %rax
je 0xf35b
cmpl %ebp, 0x20(%rax)
cmovgq %rdi, %rax
movq %rax, %r15
cmpq %rdi, %r15
je 0xf3ce
movq %rbx, %rdi
callq 0xb030
movq %rax, %r14
movq %r12, %rdi
movl %ebp, %esi
movq %rax, %rdx
movq %rbx, %rcx
callq 0xbdb0
addq $0x50, %r15
movl %ebx, (%rsp)
testl %ebx, %ebx
movl %ebx, %r12d
movl $0x1, %edi
cmovneq %r12, %rdi
callq 0xb030
movq %rax, 0x8(%rsp)
testl %ebx, %ebx
je 0xf3ac
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xb670
movq %rsp, %rsi
movq %r15, %rdi
callq 0xba20
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xf3c6
callq 0xb990
movq %r14, %rdi
callq 0xb990
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xf3ed
callq 0xb990
movq %rbx, %rdi
callq 0xbce0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rax
testq %rcx, %rcx
je 0xf438
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 0xf422
movq %r15, %r12
cmpq %r15, %rax
je 0xf44a
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 0xf4c0
leaq 0x8(%rsp), %r15
movq 0xe8(%r12), %rsi
cmpq 0xe0(%r12), %rsi
je 0xf4c0
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 0xf4ab
callq 0xb990
movq 0x10(%rsp), %rdx
movl 0x8(%rsp), %ecx
movq %r14, %rdi
movl %ebx, %esi
callq 0xbd70
jmp 0xf46b
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xf4cf
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 0xf4ed
callq 0xb990
movq %rbx, %rdi
callq 0xbce0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4139(%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 0x111be
callq 0xb730
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x50(%rbx)
je 0x11228
leaq 0xc(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbc90
testb %al, %al
je 0x11228
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 0x11245
leaq 0x40(%rbx), %rdi
leaq 0x30(%rsp), %rsi
callq *0x58(%rbx)
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x11228
callq 0xb730
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x11237
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 0x11261
callq 0xb730
jmp 0x11261
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x11270
callq 0xb730
movq %rbx, %rdi
callq 0xbce0
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
jne 0x1126b
jmp 0x11270
nop
// File: /workspace/github_cpp_makefile_star2_O1/Unreality3D[P]Unreality3D/indie-studio/source/Network/protocol/Deserializer.cpp
// Function: IndieProtocol::Deserializer::deserializeString(IndieProtocol::Serialized const&, unsigned int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool	Deserializer::deserializeString
  (Serialized const &to_handle, uint32_t &pos, std::string &to_change)
  {
    uint16_t	size;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq 0x8(%rsi), %rax
movl (%rdx), %edx
movzwl (%rax,%rdx), %ebx
leal 0x2(%rdx), %eax
movl %eax, (%r14)
leal (%rdx,%rbx), %r13d
addl $0x2, %r13d
addq $0x6, %r13
movl (%rdi), %eax
cmpq %rax, %r13
ja 0x117ef
movq %rax, -0x48(%rbp)
movq %rsp, -0x40(%rbp)
movq %rsp, %r15
leal 0x10(%rbx), %eax
andl $-0x10, %eax
subq %rax, %r15
movq %r15, %rsp
movl (%r14), %eax
movq %rax, -0x30(%rbp)
addq 0x8(%rsi), %rax
movl %ebx, %r12d
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %rcx, -0x38(%rbp)
callq 0xb670
movb $0x0, (%r15,%r12)
addl -0x30(%rbp), %ebx
movl %ebx, (%r14)
leaq -0x58(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq %r15, %rdi
callq 0xb300
leaq (%rax,%r15), %rdx
leaq -0x68(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xb270
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0xb910
movq (%r14), %rdi
cmpq %rbx, %rdi
je 0x117e7
callq 0xb730
movq -0x40(%rbp), %rsp
movq -0x48(%rbp), %rax
cmpq %rax, %r13
setbe %al
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdi, %rbx
movl $0x0, (%rdi)
movl $0x1, %edi
callq 0xb030
movq %rax, (%rsp)
movq %rax, 0x8(%rbx)
movl (%r15), %r13d
movl (%r14), %r12d
leal (%r12,%r13), %edi
movl %edi, (%rbx)
callq 0xb030
movq %rax, %rbp
movq %rax, 0x8(%rbx)
movq 0x8(%r15), %rsi
movq %rax, %rdi
movq %r13, %rdx
callq 0xb670
addq %r13, %rbp
movq 0x8(%r14), %rsi
movq %rbp, %rdi
movq %r12, %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_O1/Unreality3D[P]Unreality3D/indie-studio/source/Network/protocol/Serializer.cpp
// Function: IndieProtocol::Serializer::operator()(IndieProtocol::Connect const&)
Serialized	Serializer::operator() (Connect const &packet)
  {
    uint32_t	size = sizeof(Header) + getStringSize(packet.name);
    Serialized	buff;

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

    return buff;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rdi, %rbx
movq 0x8(%rdx), %r15
leal 0x8(%r15), %r14d
movl $0x0, (%rdi)
movl $0x1, %edi
callq 0xb030
movq %rax, %r13
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0xb030
movq %rax, 0x8(%rbx)
movl %r14d, (%rax)
movw $0x1, 0x4(%rax)
movl $0x6, (%rbx)
movw %r15w, 0x6(%rax)
movl $0x8, (%rbx)
movq (%r12), %rsi
addq $0x8, %rax
movq %rax, %rdi
movq %r15, %rdx
callq 0xb670
movl %r14d, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r13, %rdi
callq 0xb990
movq %rbx, %rdi
callq 0xbce0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %r13
movq 0x8(%rdx), %rbp
movl $0x0, (%rdi)
movl $0x1, %edi
callq 0xb030
movq %rax, (%rsp)
movq %rax, 0x8(%rbx)
movl $0x8, %r12d
cmpq %r13, %rbp
je 0x1213b
movq %r13, %rax
movl 0x8(%rax), %ecx
addl %ecx, %r12d
addl $0x2, %r12d
addq $0x20, %rax
cmpq %rbp, %rax
jne 0x12128
movl %r12d, %edi
callq 0xb030
movq %rax, %r15
subl %r13d, %ebp
shrl $0x5, %ebp
movq %rax, 0x8(%rbx)
movl %r12d, (%rax)
movw $0x2, 0x4(%rax)
movl $0x6, (%rbx)
movw %bp, 0x6(%rax)
movl $0x8, (%rbx)
movq 0x8(%r14), %rbp
movl $0x8, %r12d
cmpq %rbp, %r13
je 0x121aa
movzwl 0x8(%r13), %eax
movl %r12d, %ecx
movw %ax, (%r15,%rcx)
leal 0x2(%r12), %edi
movq (%r13), %rsi
movq 0x8(%r13), %r14
addq %r15, %rdi
movq %r14, %rdx
callq 0xb670
addl %r14d, %r12d
addl $0x2, %r12d
addq $0x20, %r13
jmp 0x12173
movl %r12d, (%rbx)
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_O1/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 $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rdx), %rsi
movq 0x28(%rdx), %rax
movq 0x48(%rdx), %rdi
movq %rdx, %rbp
movl 0x60(%rdx), %ecx
movq %rax, %r13
movq %rsi, %r15
addl %esi, %eax
movq %rdi, 0x18(%rsp)
addl %edi, %eax
movq %rcx, 0x20(%rsp)
leal (%rcx,%rax), %r14d
addl $0x10, %r14d
movl $0x0, (%rbx)
movl $0x1, %edi
callq 0xb030
movq %rax, 0x8(%rsp)
movq %rax, 0x8(%rbx)
movzwl %r14w, %r12d
movq %r12, %rdi
callq 0xb030
movq %rax, %r14
movq %rax, 0x8(%rbx)
movl %r12d, (%rax)
movw $0x3, 0x4(%rax)
movl $0x6, (%rbx)
movw %r15w, 0x6(%rax)
movl $0x8, (%rbx)
movq (%rbp), %rsi
movq %rbp, 0x10(%rsp)
leaq 0x8(%rax), %rdi
movq %r15, %rdx
callq 0xb670
leal 0x8(%r15), %eax
movl %eax, (%rbx)
movw %r13w, (%r14,%rax)
leal 0xa(%r15), %edi
movl %edi, (%rbx)
movq 0x20(%rbp), %rsi
addq %r14, %rdi
movq %r13, %rdx
callq 0xb670
leal (%r15,%r13), %r12d
addl $0xa, %r12d
movl %r12d, (%rbx)
movq 0x18(%rsp), %rbp
movw %bp, (%r14,%r12)
leal 0xc(%r15,%r13), %edi
movl %edi, (%rbx)
movq 0x10(%rsp), %r15
movq 0x40(%r15), %rsi
addq %r14, %rdi
movq %rbp, %rdx
callq 0xb670
leal (%r12,%rbp), %r13d
addl $0x2, %r13d
movl %r13d, (%rbx)
movl 0x60(%r15), %eax
movl %eax, (%r14,%r13)
leal (%r12,%rbp), %edi
addl $0x6, %edi
movl %edi, (%rbx)
movq 0x68(%r15), %rsi
addq %r14, %rdi
movq 0x20(%rsp), %r14
movq %r14, %rdx
callq 0xb670
leal (%r14,%r13), %eax
addl $0x4, %eax
movl %eax, (%rbx)
movq %rbx, %rax
addq $0x28, %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
nop