LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: pfnet-research[P]pml/src/test.cpp
// Function: parsing_term_test::parsing_term_test()
PML_TEST(parsing_term_test) {
    std::string input = "a+b*c";
    parser::parse_term(input).case_of(
        ok >> [&](ptr<logic::term_t> const& term) {
            assert_(term != nullptr, "\"" + input + "\" was parsed to nullptr");
            assert_eq(
                    logic::to_debug_string(*term),
                    "Add(a, Mul(b, c))");
        },
        error >> [this](parser::error_t err) {
            std::string msg = "parse error at " +
                std::to_string(err.pos) + " : " +
                err.message;
            assert_(false, msg);
        });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x71f20
movq -0xb0(%rbp), %rax
leaq 0x7883b(%rip), %rcx     # 0xe69c8
movq %rcx, (%rax)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xa660
movq -0xa8(%rbp), %rdx
leaq 0x31b3b(%rip), %rsi     # 0x9fce9
leaq -0x28(%rbp), %rdi
callq 0x1dd10
jmp 0x6e1b9
leaq -0x29(%rbp), %rdi
callq 0xa420
leaq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3fca0
jmp 0x6e1d1
movq -0xb0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq 0x31d72(%rip), %rdi     # 0x9ff63
leaq -0x90(%rbp), %rsi
callq 0x685a0
movq %rax, -0xb8(%rbp)
jmp 0x6e206
movq -0xb0(%rbp), %rax
movq -0xb8(%rbp), %rcx
movq %rcx, -0x80(%rbp)
movq %rax, -0xa0(%rbp)
leaq 0x31d3e(%rip), %rdi     # 0x9ff64
leaq -0xa0(%rbp), %rsi
callq 0x685c0
movq %rax, -0xc0(%rbp)
jmp 0x6e23b
movq -0xc0(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x7f340
jmp 0x6e25f
leaq -0x78(%rbp), %rdi
callq 0x40860
leaq -0x28(%rbp), %rdi
callq 0xa240
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0xa420
jmp 0x6e2bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x6e2b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x40860
leaq -0x28(%rbp), %rdi
callq 0xa240
movq -0xb0(%rbp), %rdi
callq 0x71f80
movq -0x38(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: pfnet-research[P]pml/src/test.cpp
// Function: lang_feature_test::parse_test(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 parse_test(std::string const& input, std::string const& output) {
        parser::parse(input).case_of(
            ok >> [&](ptr<ast::expr_t> const& ast) {
                assert_(
                    ast != nullptr,
                    "\"" + input + "\" was parsed to nullptr");
                assert_eq(ast::to_debug_string(*ast), output);
            },
            error >> [this](parser::error_t err) {
                std::string msg = "parse error at" +
                    std::to_string(err.pos) + " : " +
                    err.message;
                assert_(false, msg);
            });
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x3fba0
movq -0xa0(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x2e352(%rip), %rdi     # 0x9ff63
leaq -0x70(%rbp), %rsi
callq 0x67ea0
movq %rax, -0x98(%rbp)
jmp 0x71c23
movq -0xa0(%rbp), %rax
movq -0x98(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x90(%rbp)
leaq 0x2e321(%rip), %rdi     # 0x9ff64
leaq -0x90(%rbp), %rsi
callq 0x67ec0
movq %rax, -0xa8(%rbp)
jmp 0x71c58
movq -0xa8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x71fa0
jmp 0x71c7c
leaq -0x50(%rbp), %rdi
callq 0x2ffa0
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2ffa0
movq -0x78(%rbp), %rdi
callq 0xa650
nopl (%rax)
// File: pfnet-research[P]pml/./include/test.hpp
// Function: test::test_base::assert_(bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void assert_(bool is_ok, std::string const& msg = "") {
        assert_count++;
        if (is_ok)
            return;
        std::stringstream ss;
        ss << "\033[31mtest[" << name() <<  "] fail.. \033[39m ";
        ss << "assertion: " << msg << std::endl;
        throw test_fail_exception{ss.str()};
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x200(%rbp)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
testb $0x1, -0x9(%rbp)
je 0x7230e
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
leaq -0x1a0(%rbp), %rdi
callq 0xa290
leaq -0x190(%rbp), %rdi
leaq 0x2d623(%rip), %rsi     # 0x9f94b
callq 0xa3b0
movq %rax, -0x208(%rbp)
jmp 0x72336
movq -0x200(%rbp), %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq -0x1d0(%rbp), %rdi
callq *%rax
jmp 0x7234f
movq -0x208(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0xa340
movq %rax, -0x210(%rbp)
jmp 0x7236b
movq -0x210(%rbp), %rdi
leaq 0x2d5dd(%rip), %rsi     # 0x9f956
callq 0xa3b0
jmp 0x72380
leaq -0x1d0(%rbp), %rdi
callq 0xa240
leaq -0x190(%rbp), %rdi
leaq 0x2d5cc(%rip), %rsi     # 0x9f966
callq 0xa3b0
movq %rax, -0x218(%rbp)
jmp 0x723a8
movq -0x218(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa340
movq %rax, -0x220(%rbp)
jmp 0x723c1
movq -0x220(%rbp), %rdi
movq 0x74b89(%rip), %rsi     # 0xe6f58
callq 0xa400
jmp 0x723d6
movb $0x1, -0x1f1(%rbp)
movl $0x28, %edi
callq 0xa1d0
movq %rax, -0x228(%rbp)
leaq -0x1f0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xa3a0
jmp 0x72403
movq -0x228(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0x72760
jmp 0x72418
movq -0x228(%rbp), %rdi
movb $0x0, -0x1f1(%rbp)
leaq 0x7417b(%rip), %rsi     # 0xe65a8
leaq 0x38c(%rip), %rdx       # 0x727c0
callq 0xa610
jmp 0x724d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x724bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0xa240
jmp 0x724bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x724a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0xa240
testb $0x1, -0x1f1(%rbp)
jne 0x724af
jmp 0x724bb
movq -0x228(%rbp), %rdi
callq 0xa2c0
jmp 0x724bd
leaq -0x1a0(%rbp), %rdi
callq 0xa2d0
movq -0x1a8(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
nop
// File: pfnet-research[P]pml/./include/test.hpp
// Function: void test::test_base::assert_eq<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void assert_eq(T1 const& lhs, T2 const& rhs) {
        assert_count++;
        if (lhs == rhs)
            return;
        std::stringstream ss;
        ss << "\033[31mtest[" << name() <<  "] fail.. \033[39m ";
        ss << "assertion: " << lhs << " == " << rhs << std::endl;
        throw test_fail_exception{ss.str()};
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x200(%rbp)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf040
testb $0x1, %al
jne 0x7254e
jmp 0x72557
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
leaq -0x1a0(%rbp), %rdi
callq 0xa290
leaq -0x190(%rbp), %rdi
leaq 0x2d3da(%rip), %rsi     # 0x9f94b
callq 0xa3b0
movq %rax, -0x208(%rbp)
jmp 0x7257f
movq -0x200(%rbp), %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq -0x1d0(%rbp), %rdi
callq *%rax
jmp 0x72598
movq -0x208(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0xa340
movq %rax, -0x210(%rbp)
jmp 0x725b4
movq -0x210(%rbp), %rdi
leaq 0x2d394(%rip), %rsi     # 0x9f956
callq 0xa3b0
jmp 0x725c9
leaq -0x1d0(%rbp), %rdi
callq 0xa240
leaq -0x190(%rbp), %rdi
leaq 0x2d383(%rip), %rsi     # 0x9f966
callq 0xa3b0
movq %rax, -0x218(%rbp)
jmp 0x725f1
movq -0x218(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa340
movq %rax, -0x220(%rbp)
jmp 0x7260a
movq -0x220(%rbp), %rdi
leaq 0x2d35a(%rip), %rsi     # 0x9f972
callq 0xa3b0
movq %rax, -0x228(%rbp)
jmp 0x72626
movq -0x228(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa340
movq %rax, -0x230(%rbp)
jmp 0x7263f
movq -0x230(%rbp), %rdi
movq 0x7490b(%rip), %rsi     # 0xe6f58
callq 0xa400
jmp 0x72654
movb $0x1, -0x1f1(%rbp)
movl $0x28, %edi
callq 0xa1d0
movq %rax, -0x238(%rbp)
leaq -0x1f0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xa3a0
jmp 0x72681
movq -0x238(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0x72760
jmp 0x72696
movq -0x238(%rbp), %rdi
movb $0x0, -0x1f1(%rbp)
leaq 0x73efd(%rip), %rsi     # 0xe65a8
leaq 0x10e(%rip), %rdx       # 0x727c0
callq 0xa610
jmp 0x72753
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x7273b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0xa240
jmp 0x7273b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x72722
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0xa240
testb $0x1, -0x1f1(%rbp)
jne 0x7272d
jmp 0x72739
movq -0x238(%rbp), %rdi
callq 0xa2c0
jmp 0x7273b
leaq -0x1a0(%rbp), %rdi
callq 0xa2d0
movq -0x1a8(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: pfnet-research[P]pml/src/translate_to_mdp.cpp
// Function: create_binop_case(ast::expr_t const&, ast::expr_t const&, ast::expr_kind_t, environment_t<value_info_t> const&)
mdp_with_info_t create_binop_case(
        ast::expr_t const& lhs_expr,
        ast::expr_t const& rhs_expr,
        ast::expr_kind_t op,
        var_env_t const& var_env) {
    auto lhs_ = trans_impl(lhs_expr, var_env);
    auto const& lhs = lhs_.value;
    auto rhs_ = trans_impl(rhs_expr, var_env);
    auto const& rhs = rhs_.value;

    auto result_mdp = mdp::mdp_t::merge(
            std::move(lhs_.mdp),
            std::move(rhs_.mdp));

    auto result_bound = calc_binop_bound(lhs, rhs, op);

    return mdp_with_info_t {
        result_mdp, lhs_.init, rhs_.accept,
        result_bound
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x230(%rbp)
movq %rdi, %rax
movq %rax, -0x228(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0xc8(%rbp), %rdi
callq 0x881e0
leaq -0x58(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x170(%rbp), %rdi
callq 0x881e0
jmp 0x89e64
leaq -0x100(%rbp), %rax
movq %rax, -0x188(%rbp)
leaq -0x1f0(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
leaq -0x170(%rbp), %rdx
callq 0xa960
jmp 0x89e8e
movq -0xd0(%rbp), %rsi
movq -0x188(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq -0x220(%rbp), %rdi
callq 0x89050
jmp 0x89ead
movq -0x230(%rbp), %rdi
movq %rdi, %rax
movq %rax, -0x238(%rbp)
leaq -0x1f0(%rbp), %rsi
callq 0x8b6f0
jmp 0x89ecc
movq -0x230(%rbp), %rdi
movl -0x60(%rbp), %eax
movl %eax, 0x68(%rdi)
movl -0x104(%rbp), %eax
movl %eax, 0x6c(%rdi)
addq $0x70, %rdi
leaq -0x220(%rbp), %rsi
callq 0x8ba30
jmp 0x89ef4
leaq -0x220(%rbp), %rdi
callq 0x7a3a0
leaq -0x1f0(%rbp), %rdi
callq 0xc340
leaq -0x170(%rbp), %rdi
callq 0x79690
leaq -0xc8(%rbp), %rdi
callq 0x79690
movq -0x228(%rbp), %rax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x178(%rbp)
movl %eax, -0x17c(%rbp)
jmp 0x89fc6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x178(%rbp)
movl %eax, -0x17c(%rbp)
jmp 0x89fba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x178(%rbp)
movl %eax, -0x17c(%rbp)
jmp 0x89fae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x178(%rbp)
movl %eax, -0x17c(%rbp)
jmp 0x89fa2
movq -0x238(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x178(%rbp)
movl %eax, -0x17c(%rbp)
callq 0xc340
leaq -0x220(%rbp), %rdi
callq 0x7a3a0
leaq -0x1f0(%rbp), %rdi
callq 0xc340
leaq -0x170(%rbp), %rdi
callq 0x79690
leaq -0xc8(%rbp), %rdi
callq 0x79690
movq -0x178(%rbp), %rdi
callq 0xa650
nop
// File: pfnet-research[P]pml/src/translate_to_mdp.cpp
// Function: create_var_case(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, environment_t<value_info_t> const&)
mdp_with_info_t create_var_case(std::string const& name, var_env_t const& var_env) {
    auto result_var = *var_env.lookup(name);
    result_var.name = name;
    int current = translation_data::current_location();
    return mdp_with_info_t {
        mdp::mdp_t {
            "default", {}, {}, {}
        },
        current, current,
        result_var
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x8bc30
movq -0x78(%rbp), %rdi
callq 0x8bce0
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x8ba30
jmp 0x8abd1
leaq -0x58(%rbp), %rdi
callq 0x8b8c0
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xa060
jmp 0x8abe9
callq 0x8bbb0
movl %eax, -0x8c(%rbp)
jmp 0x8abf6
movq -0x88(%rbp), %rax
movl -0x8c(%rbp), %ecx
movl %ecx, -0x68(%rbp)
movq %rax, -0xa0(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xa660
movq -0x88(%rbp), %rdi
movq -0x98(%rbp), %rdx
leaq 0x15008(%rip), %rsi     # 0x9fc3a
callq 0x1dd10
jmp 0x8ac39
movq -0xa0(%rbp), %rax
movq %rax, %rdi
addq $0x20, %rdi
xorps %xmm0, %xmm0
movaps %xmm0, -0xb0(%rbp)
movups %xmm0, 0x20(%rax)
movq $0x0, 0x30(%rax)
callq 0x79550
movaps -0xb0(%rbp), %xmm0
movq -0xa0(%rbp), %rax
movq %rax, %rdi
addq $0x38, %rdi
movups %xmm0, 0x38(%rax)
movq $0x0, 0x48(%rax)
callq 0x7a4e0
movaps -0xb0(%rbp), %xmm0
movq -0xa0(%rbp), %rax
movq %rax, %rdi
addq $0x50, %rdi
movups %xmm0, 0x50(%rax)
movq $0x0, 0x60(%rax)
callq 0x79670
movq -0x88(%rbp), %rdi
movl -0x68(%rbp), %eax
movl %eax, 0x68(%rdi)
movl -0x68(%rbp), %eax
movl %eax, 0x6c(%rdi)
addq $0x70, %rdi
leaq -0x48(%rbp), %rsi
callq 0x8ba30
jmp 0x8acd0
leaq -0x69(%rbp), %rdi
callq 0xa420
leaq -0x48(%rbp), %rdi
callq 0x7a3a0
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x8b8c0
jmp 0x8ad4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x8ad43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x8ad3a
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0xc340
leaq -0x69(%rbp), %rdi
callq 0xa420
leaq -0x48(%rbp), %rdi
callq 0x7a3a0
movq -0x60(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x8bd10
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x8bd30
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
callq 0x881e0
jmp 0x8b004
leaq -0x30(%rbp), %rdi
callq 0x8ba90
movq -0xd8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0xbcc0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0xbcf0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xbd20
testb $0x1, %al
jne 0x8b04c
jmp 0x8b1a8
leaq -0x50(%rbp), %rdi
callq 0xbd60
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
leaq 0xe100(%rip), %rsi      # 0x99164
callq 0xbdb0
movb %al, -0xe1(%rbp)
jmp 0x8b071
movb -0xe1(%rbp), %al
testb $0x1, %al
jne 0x8b080
jmp 0x8b198
leaq -0xb1(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0xa660
movq -0xf0(%rbp), %rdx
leaq 0xe0c3(%rip), %rsi      # 0x99164
leaq -0xb0(%rbp), %rdi
callq 0x1dd10
jmp 0x8b0af
movq -0xd8(%rbp), %rax
movl $0x0, -0xbc(%rbp)
movl 0x6c(%rax), %eax
movl %eax, -0xb8(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
leaq -0xbc(%rbp), %rdx
xorl %ecx, %ecx
callq 0x7a3c0
jmp 0x8b0e7
movq -0x60(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x8bd50
jmp 0x8b0f9
leaq -0x90(%rbp), %rdi
callq 0xdda0
leaq -0xb0(%rbp), %rdi
callq 0xa240
leaq -0xb1(%rbp), %rdi
callq 0xa420
jmp 0x8b198
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8ba90
jmp 0x8b1da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x8b1ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x8b18a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x8b17e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xdda0
leaq -0xb0(%rbp), %rdi
callq 0xa240
leaq -0xb1(%rbp), %rdi
callq 0xa420
jmp 0x8b1ce
jmp 0x8b19a
leaq -0x50(%rbp), %rdi
callq 0xbe60
jmp 0x8b036
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x8b1be
movq -0xd8(%rbp), %rdi
callq 0x79690
movq -0xe0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0x79690
movq -0x38(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movb $0x0, -0x51(%rbp)
movb $0x0, -0x52(%rbp)
movb $0x0, -0x89(%rbp)
movb $0x0, -0x8a(%rbp)
cmpl $0x0, %eax
jne 0x95471
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
addq $0x28, %rax
movq %rax, -0xb8(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x955e0
movq -0xc0(%rbp), %rsi
movb $0x1, -0x51(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x40770
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
movq -0xa8(%rbp), %rcx
movb $0x1, -0x52(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1ed70
jmp 0x9546f
jmp 0x954e0
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
addq $0x28, %rax
movq %rax, -0xc8(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x95610
jmp 0x95499
movb $0x1, -0x89(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
leaq -0x88(%rbp), %rsi
callq 0x40ed0
movq -0xc8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
movq -0xd8(%rbp), %rcx
movb $0x1, -0x8a(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1fb70
jmp 0x954de
jmp 0x954e0
testb $0x1, -0x8a(%rbp)
jne 0x954eb
jmp 0x954f4
leaq -0x78(%rbp), %rdi
callq 0x16150
testb $0x1, -0x89(%rbp)
jne 0x954ff
jmp 0x9550b
leaq -0x88(%rbp), %rdi
callq 0x40f00
testb $0x1, -0x52(%rbp)
jne 0x95513
jmp 0x9551c
leaq -0x40(%rbp), %rdi
callq 0x25000
testb $0x1, -0x51(%rbp)
jne 0x95524
jmp 0x9552d
leaq -0x50(%rbp), %rdi
callq 0x407a0
movq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x6c(%rax), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x16250
leaq -0x30(%rbp), %rdi
callq 0x16150
movq -0x98(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x955aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
testb $0x1, -0x8a(%rbp)
jne 0x95588
jmp 0x95591
leaq -0x78(%rbp), %rdi
callq 0x16150
testb $0x1, -0x89(%rbp)
jne 0x9559c
jmp 0x955a8
leaq -0x88(%rbp), %rdi
callq 0x40f00
jmp 0x955aa
testb $0x1, -0x52(%rbp)
jne 0x955b2
jmp 0x955bb
leaq -0x40(%rbp), %rdi
callq 0x25000
testb $0x1, -0x51(%rbp)
jne 0x955c3
jmp 0x955cc
leaq -0x50(%rbp), %rdi
callq 0x407a0
jmp 0x955ce
movq -0x60(%rbp), %rdi
callq 0xa650
nopw (%rax,%rax)
// File: pfnet-research[P]pml/src/type_ast.cpp
// Function: ast::operator==(ast::refinement_type_t const&, ast::refinement_type_t const&)
bool operator==(refinement_type_t const& lhs, refinement_type_t const& rhs) {
    return
        lhs.name == rhs.name &&
        lhs.domain == rhs.domain &&
        *lhs.constraint == *rhs.constraint;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf040
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x95dab
jmp 0x95ded
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl 0x20(%rdx), %ecx
movb %al, -0x11(%rbp)
jne 0x95ded
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0x115e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x115e0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x246c0
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: pfnet-research[P]pml/src/type_ast.cpp
// Function: ast::to_debug_string[abi:cxx11](ast::dependent_type_t const&)
std::string to_debug_string(dependent_type_t const& ty) {
    std::string args = to_debug_string(ty.args[0]);
    for (size_t i=1; i<ty.args.size(); ++i)
        args += format(", {}", to_debug_string(ty.args[i]));
    return format("Dep([{}], {})",
            args,
            to_debug_string(ty.ret_type));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x108(%rbp)
movq %rdi, %rax
movq %rax, -0x100(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1dff0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x95e00
movq $0x1, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13340
movq %rax, %rcx
movq -0x110(%rbp), %rax
cmpq %rcx, %rax
jae 0x963aa
leaq -0x79(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0xa660
movq -0x118(%rbp), %rdx
leaq 0xbd9d(%rip), %rsi      # 0xa2047
leaq -0x78(%rbp), %rdi
callq 0x1dd10
jmp 0x962b5
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1dff0
movq %rax, %rsi
leaq -0xb0(%rbp), %rdi
callq 0x95e00
jmp 0x962d3
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x964c0
jmp 0x962e9
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa4e0
jmp 0x962f8
leaq -0x58(%rbp), %rdi
callq 0xa240
leaq -0xb0(%rbp), %rdi
callq 0xa240
leaq -0x78(%rbp), %rdi
callq 0xa240
leaq -0x79(%rbp), %rdi
callq 0xa420
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x96265
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x9639c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x96393
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x96387
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xa240
leaq -0xb0(%rbp), %rdi
callq 0xa240
leaq -0x78(%rbp), %rdi
callq 0xa240
leaq -0x79(%rbp), %rdi
callq 0xa420
jmp 0x964aa
leaq -0xd1(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0xa660
movq -0x120(%rbp), %rdx
leaq 0xbc81(%rip), %rsi      # 0xa204c
leaq -0xd0(%rbp), %rdi
callq 0x1dd10
jmp 0x963d9
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
leaq -0xf8(%rbp), %rdi
callq 0x95e00
jmp 0x963ef
movq -0x108(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0xf8(%rbp), %rcx
callq 0x96730
jmp 0x9640f
leaq -0xf8(%rbp), %rdi
callq 0xa240
leaq -0xd0(%rbp), %rdi
callq 0xa240
leaq -0xd1(%rbp), %rdi
callq 0xa420
leaq -0x30(%rbp), %rdi
callq 0xa240
movq -0x100(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x9649e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x96492
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0xa240
leaq -0xd0(%rbp), %rdi
callq 0xa240
leaq -0xd1(%rbp), %rdi
callq 0xa420
leaq -0x30(%rbp), %rdi
callq 0xa240
movq -0x88(%rbp), %rdi
callq 0xa650
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x50006(%rip), %rdi     # 0xe6fa0
movq %rdi, -0xf0(%rbp)
leaq 0xb19d(%rip), %rsi      # 0xa2145
callq 0xa3b0
movq %rax, %rdi
movq 0x4fff9(%rip), %rsi     # 0xe6fb0
callq 0xa400
movq -0x8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x8afa0
movq -0xf0(%rbp), %rdi
leaq 0xb191(%rip), %rsi      # 0xa216b
callq 0xa3b0
movq %rax, -0xe8(%rbp)
jmp 0x96fe8
movq -0xe8(%rbp), %rdi
movq 0x4ff62(%rip), %rsi     # 0xe6f58
callq 0xa400
jmp 0x96ffd
movq 0x4ff9c(%rip), %rdi     # 0xe6fa0
leaq 0xb166(%rip), %rsi      # 0xa2171
callq 0xa3b0
movq %rax, -0xf8(%rbp)
jmp 0x97019
movq -0xf8(%rbp), %rdi
movq 0x4ff89(%rip), %rsi     # 0xe6fb0
callq 0xa400
jmp 0x9702e
movq -0x10(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
leaq -0xb0(%rbp), %rdx
callq 0x953b0
jmp 0x97047
movq 0x4ff52(%rip), %rdi     # 0xe6fa0
leaq 0xb116(%rip), %rsi      # 0xa216b
callq 0xa3b0
movq %rax, -0x100(%rbp)
jmp 0x97063
movq -0x100(%rbp), %rdi
movq 0x4fee7(%rip), %rsi     # 0xe6f58
callq 0xa400
jmp 0x97078
movq 0x4ff21(%rip), %rdi     # 0xe6fa0
leaq 0xb10f(%rip), %rsi      # 0xa2195
callq 0xa3b0
movq %rax, -0x108(%rbp)
jmp 0x97094
movq -0x108(%rbp), %rdi
movq 0x4ff0e(%rip), %rsi     # 0xe6fb0
callq 0xa400
jmp 0x970a9
leaq -0xb0(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x96be0
movb %al, -0x109(%rbp)
jmp 0x970c4
movb -0x109(%rbp), %al
andb $0x1, %al
movb %al, -0xd9(%rbp)
movq 0x4fec7(%rip), %rdi     # 0xe6fa0
leaq 0xb08b(%rip), %rsi      # 0xa216b
callq 0xa3b0
movq %rax, -0x118(%rbp)
jmp 0x970ee
movq -0x118(%rbp), %rdi
movq 0x4fe5c(%rip), %rsi     # 0xe6f58
callq 0xa400
jmp 0x97103
movb -0xd9(%rbp), %al
movb %al, -0x119(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x979a0
leaq -0xb0(%rbp), %rdi
callq 0x79690
movb -0x119(%rbp), %al
andb $0x1, %al
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x9716a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x979a0
leaq -0xb0(%rbp), %rdi
callq 0x79690
movq -0xb8(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x10(%rbp), %rsi
callq 0x13050
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x979c0
movq -0x28(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x97a40
movq -0x78(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x97a10
movb %al, -0x69(%rbp)
jmp 0x971f7
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x97203
jmp 0x9728d
leaq -0x30(%rbp), %rdi
callq 0x97a90
movq %rax, -0x80(%rbp)
jmp 0x97212
movq -0x80(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x97a90
movq %rax, -0x88(%rbp)
jmp 0x9722f
movq -0x68(%rbp), %rcx
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
addq $0x20, %rdx
leaq -0x58(%rbp), %rdi
callq 0x972c0
jmp 0x97250
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x97ad0
leaq -0x58(%rbp), %rdi
callq 0x41af0
leaq -0x30(%rbp), %rdi
callq 0x97b00
jmp 0x97271
jmp 0x971d4
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x13080
jmp 0x972ad
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x972a0
movq -0x68(%rbp), %rdi
callq 0x13080
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xa650
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x88(%rsp), %rdi
leaq 0x19977(%rip), %rsi     # 0x46477
callq 0x2be70
testb $0x1, %al
jne 0x2cb0b
jmp 0x2cb27
movq 0x10(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x29dd0
jmp 0x2cc23
movq 0x10(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x2a1a0
movq 0x10(%rsp), %rdi
movq %rax, 0x70(%rsp)
callq 0x28280
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x283f0
testb $0x1, %al
jne 0x2cb65
jmp 0x2cbf0
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2b510
movq 0x10(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x2a680
movq %rax, 0x8(%rsp)
jmp 0x2cb9a
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x29340
leaq 0x30(%rsp), %rdi
callq 0x28590
movq 0x10(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x2a1a0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x2cbf0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x28590
jmp 0x2cc2b
movq 0x78(%rsp), %rax
movq %rax, (%rsp)
leaq 0x70(%rsp), %rdi
callq 0x297c0
movq %rax, %rdi
addq $0x20, %rdi
movq 0x80(%rsp), %rsi
callq 0x2afe0
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x2a020
addq $0x98, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x2b6f0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x197be(%rip), %rsi     # 0x46477
callq 0x2be70
testb $0x1, %al
jne 0x2ccc4
jmp 0x2ccd8
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x29fc0
jmp 0x2cd8c
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x2a1a0
movq 0x8(%rsp), %rdi
movq %rax, 0x38(%rsp)
callq 0x28280
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x28aa0
testb $0x1, %al
jne 0x2cd10
jmp 0x2cd8c
leaq 0x38(%rsp), %rdi
callq 0x297c0
movq %rax, %rdi
addq $0x20, %rdi
movq 0x40(%rsp), %rsi
callq 0x289d0
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x297c0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x2b110
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x29000
testb $0x1, %al
jne 0x2cd60
jmp 0x2cd8a
leaq 0x38(%rsp), %rdi
callq 0x297c0
movq %rax, %rdi
addq $0x20, %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
callq 0x28d00
movq %rax, 0x10(%rsp)
jmp 0x2cd8c
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x58(%rsp), %rsi
callq 0x29e80
movq 0x8(%rsp), %rdi
movq %rax, 0x38(%rsp)
callq 0x2a8b0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x28e30
testb $0x1, %al
jne 0x2ce7a
jmp 0x2cef6
leaq 0x38(%rsp), %rdi
callq 0x292d0
movq %rax, %rdi
addq $0x20, %rdi
movq 0x50(%rsp), %rsi
callq 0x2abf0
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x292d0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x29db0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2a040
testb $0x1, %al
jne 0x2ceca
jmp 0x2cef4
leaq 0x28(%rsp), %rdi
callq 0x2a3f0
movq %rax, %rdi
addq $0x20, %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x40(%rsp), %r8
callq 0x2bd20
jmp 0x2cf62
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
movq 0x50(%rsp), %rsi
callq 0x2abf0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x30, %rdi
callq 0x29db0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2a040
testb $0x1, %al
jne 0x2cf36
jmp 0x2cf60
leaq 0x18(%rsp), %rdi
callq 0x2a3f0
movq %rax, %rdi
addq $0x20, %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x40(%rsp), %r8
callq 0x2bd20
jmp 0x2cf62
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
callq 0x28030
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x28520
movq 0x10(%rsp), %rax
addq $0x178, %rax            # imm = 0x178
movq %rax, 0x18(%rsp)
movl 0x50(%rsp), %esi
movq 0x48(%rsp), %rdx
leaq 0x38(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x2a480
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2ab40
jmp 0x2d7f9
leaq 0x38(%rsp), %rdi
callq 0x295d0
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2d81d
movq 0x8(%rsp), %rdi
callq 0x2a870
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x295d0
movq 0x30(%rsp), %rdi
callq 0x2b6f0
nopw %cs:(%rax,%rax)
// File: Unreality3D[P]Unreality3D/indie-studio/source/Network/NetManager.cpp
// Function: network::NetManager::onWritePossible(Socket::Client&)
void  NetManager::onWritePossible(Socket::Client &c)
  {
    if (!_writeBuffer.size())
      return;

    IndieProtocol::Serialized tmp;

    while (_writeBuffer.size())
      {
	tmp = _writeBuffer.back();
	_writeBuffer.pop_back();
	c.write(tmp.data, tmp.size);
      }
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x240, %rdi            # imm = 0x240
callq 0x284e0
cmpq $0x0, %rax
jne 0x2d87e
jmp 0x2d910
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x2a480
movq (%rsp), %rdi
addq $0x240, %rdi            # imm = 0x240
callq 0x284e0
cmpq $0x0, %rax
je 0x2d906
movq (%rsp), %rdi
addq $0x240, %rdi            # imm = 0x240
callq 0x2b590
movq %rax, %rsi
leaq 0x18(%rsp), %rdi
callq 0x289e0
jmp 0x2d8c3
movq (%rsp), %rdi
addq $0x240, %rdi            # imm = 0x240
callq 0x2aa40
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x18(%rsp), %eax
movl %eax, %edx
callq 0x28f90
jmp 0x2d8ea
jmp 0x2d88e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x295d0
jmp 0x2d915
leaq 0x18(%rsp), %rdi
callq 0x295d0
addq $0x38, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x2b6f0
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
cmpq $0x0, 0x8(%rax)
je 0x2ff78
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2ff76
movq 0x8(%rsp), %rdi
callq 0x2a870
jmp 0x2ff78
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, %edi
callq 0x28030
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rsi
movl (%rax), %eax
movl %eax, %edx
callq 0x29a50
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x118, %rsp            # imm = 0x118
movq %rdi, 0x110(%rsp)
movl %esi, 0x10c(%rsp)
movq %rdx, 0x100(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x40(%rsp)
movq %rax, 0xd8(%rsp)
leaq 0xe0(%rsp), %rdi
movq %rdi, 0x48(%rsp)
leaq 0xd8(%rsp), %rsi
callq 0x36e70
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x2a980
jmp 0x36cba
leaq 0xe0(%rsp), %rdi
callq 0x2ace0
movq 0x38(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x28(%rsp)
movq %rax, 0xa0(%rsp)
leaq 0xa8(%rsp), %rdi
movq %rdi, 0x30(%rsp)
leaq 0xa0(%rsp), %rsi
callq 0x36f00
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x28b50
jmp 0x36d0b
leaq 0xa8(%rsp), %rdi
callq 0x2ace0
movq 0x38(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x18(%rsp)
movq %rax, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x78(%rsp), %rsi
callq 0x36f90
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2af00
jmp 0x36d56
leaq 0x80(%rsp), %rdi
callq 0x2af90
movq 0x38(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x8(%rsp)
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x50(%rsp), %rsi
callq 0x37020
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x29260
jmp 0x36d9e
leaq 0x58(%rsp), %rdi
callq 0x2ace0
movq 0x38(%rsp), %rdi
addq $0x8, %rdi
movl 0x10c(%rsp), %esi
movq 0x100(%rsp), %rdx
callq 0x29460
addq $0x118, %rsp            # imm = 0x118
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x2ace0
jmp 0x36e54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x2ace0
jmp 0x36e54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x2af90
jmp 0x36e54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x2ace0
movq 0xd0(%rsp), %rdi
callq 0x2b6f0
nopw %cs:(%rax,%rax)
// File: Unreality3D[P]Unreality3D/indie-studio/source/Network/Broker.cpp
// Function: network::Broker::onConnect(Socket::Server&, int)
void	Broker::onConnect(Socket::Server &s, int fd)
  {
    std::cout << "connexion etablished" << std::endl;
    _clients[fd] = network::Client(fd);
    _clients[fd].deserializer.OnConnect(
					[fd, this] (IndieProtocol::Connect c)
					{
					  this->onPacketConnect(fd, c);
					});
    _clients[fd].deserializer.OnList(
					[fd, this] (IndieProtocol::List l)
					{
					  this->onPacketList(fd, l);
					});
    _clients[fd].deserializer.OnMessage(
					[fd, this] (IndieProtocol::Message m)
					{
					  this->onPacketMessage(fd, m);
					});
  }

// Assembly:
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, 0x1c0(%rsp)
movq %rsi, 0x1b8(%rsp)
movl %edx, 0x1b4(%rsp)
movq 0x1c0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x1beae(%rip), %rdi     # 0x52fb0
leaq 0xf354(%rip), %rsi      # 0x4645d
callq 0x2a030
movq %rax, %rdi
movq 0x1be48(%rip), %rsi     # 0x52f60
callq 0x2a150
movl 0x1b4(%rsp), %esi
leaq 0xe0(%rsp), %rdi
callq 0x28d90
movq 0x30(%rsp), %rdi
addq $0x180, %rdi            # imm = 0x180
leaq 0x1b4(%rsp), %rsi
callq 0x2ae00
movq %rax, 0x38(%rsp)
jmp 0x37151
movq 0x38(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x2b220
jmp 0x37165
leaq 0xe0(%rsp), %rdi
callq 0x2a600
movq 0x30(%rsp), %rdi
addq $0x180, %rdi            # imm = 0x180
leaq 0x1b4(%rsp), %rsi
callq 0x2ae00
movq %rax, %rcx
movq 0x30(%rsp), %rax
addq $0x28, %rcx
movq %rcx, 0x20(%rsp)
movl 0x1b4(%rsp), %ecx
movl %ecx, 0xa0(%rsp)
movq %rax, 0xa8(%rsp)
leaq 0xb0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
leaq 0xa0(%rsp), %rsi
callq 0x37360
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x297f0
jmp 0x371dd
leaq 0xb0(%rsp), %rdi
callq 0x2a100
movq 0x30(%rsp), %rdi
addq $0x180, %rdi            # imm = 0x180
leaq 0x1b4(%rsp), %rsi
callq 0x2ae00
movq %rax, %rcx
movq 0x30(%rsp), %rax
addq $0x28, %rcx
movq %rcx, 0x10(%rsp)
movl 0x1b4(%rsp), %ecx
movl %ecx, 0x70(%rsp)
movq %rax, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x70(%rsp), %rsi
callq 0x373f0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2bbc0
jmp 0x3724c
leaq 0x80(%rsp), %rdi
callq 0x2b9f0
movq 0x30(%rsp), %rdi
addq $0x180, %rdi            # imm = 0x180
leaq 0x1b4(%rsp), %rsi
callq 0x2ae00
movq %rax, %rcx
movq 0x30(%rsp), %rax
addq $0x28, %rcx
movq %rcx, (%rsp)
movl 0x1b4(%rsp), %ecx
movl %ecx, 0x40(%rsp)
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x40(%rsp), %rsi
callq 0x37480
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2b720
jmp 0x372b6
leaq 0x50(%rsp), %rdi
callq 0x28790
addq $0x1c8, %rsp            # imm = 0x1C8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x2a600
jmp 0x3734f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x2a100
jmp 0x3734f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x2b9f0
jmp 0x3734f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x28790
movq 0xd8(%rsp), %rdi
callq 0x2b6f0
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x1ba7d(%rip), %rdi     # 0x52fb0
leaq 0xed66(%rip), %rsi      # 0x462a0
callq 0x2a030
movq %rax, %rdi
movq 0x1ba17(%rip), %rsi     # 0x52f60
callq 0x2a150
movq 0x8(%rsp), %rdi
addq $0x180, %rdi            # imm = 0x180
leaq 0x34(%rsp), %rsi
callq 0x2ad40
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x180, %rdi            # imm = 0x180
callq 0x2b860
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x28750
testb $0x1, %al
jne 0x37594
jmp 0x375b9
movq 0x8(%rsp), %rdi
addq $0x180, %rdi            # imm = 0x180
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
callq 0x2bd70
movq %rax, 0x10(%rsp)
addq $0x48, %rsp
retq
nop