LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/adamiaonr[P]rid-analytics/src/argvparser.cpp
// Function: CommandLineProcessing::ArgvParser::defineOptionAlternative(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&)
bool ArgvParser::defineOptionAlternative( const string & _original,
        const string & _alternative )
{
    // do nothing if there already is no option of this name
    if (!isDefinedOption(_original))
    {
        cerr << "ArgvParser::defineOptionAlternative(): Original option label is not a defined option." << endl;
        return(false);
    }

    // AND no digits as short options allowed
    if (_alternative.length() == 1 && isDigit(_alternative[0]))
    {
        cerr << "ArgvParser::defineOptionAlternative(): Digits as short option labels are not allowd." << endl;
        return(false);
    }

    // AND do nothing if there already is an option with the alternativ name
    if (isDefinedOption(_alternative))
    {
        cerr << "ArgvParser::defineOptionAlternative(): The alternative option label equals an already defined option." << endl;
        return(false);
    }

    option2key[_alternative] = optionKey(_original);

    return(true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x1af4e
testb %al, %al
je 0x1c495
cmpq $0x1, 0x8(%rbx)
jne 0x1c4a5
movq (%rbx), %rax
movb (%rax), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x1c4a5
movq 0x1eb64(%rip), %rdi     # 0x3aff0
leaq 0xe971(%rip), %rsi      # 0x2ae04
jmp 0x1c4c2
movq 0x1eb54(%rip), %rdi     # 0x3aff0
leaq 0xe90b(%rip), %rsi      # 0x2adae
jmp 0x1c4c2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1af4e
testb %al, %al
je 0x1c4dc
movq 0x1eb35(%rip), %rdi     # 0x3aff0
leaq 0xe997(%rip), %rsi      # 0x2ae59
callq 0x43a0
movq %rax, %rdi
callq 0x41e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %r15, %rsi
callq 0x1af2e
movl %eax, %ebp
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1c8fc
movl %ebp, (%rax)
movb $0x1, %al
jmp 0x1c4d1
// File: /workspace/github_cpp_makefile_star2_O2/adamiaonr[P]rid-analytics/src/argvparser.cpp
// Function: CommandLineProcessing::ArgvParser::setHelpOption(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&)
bool ArgvParser::setHelpOption(const string& _shortname,
                               const string& _longname,
                               const string& _descr)
{
    // do nothing if any name is already in use
    if (isDefinedOption(_shortname) || isDefinedOption(_longname))
    {
        cerr << "ArgvParser::setHelpOption(): Short or long help option label equals an already defined option." << endl;
        return(false);
    }

    // define the help option's short name and the alternative
    // longname
    defineOption(_shortname, _descr, NoOptionAttribute);
    defineOptionAlternative(_shortname, _longname);

    help_option = max_key-1; // store the key in a special member

    return(true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1af4e
testb %al, %al
jne 0x1c52a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1af4e
testb %al, %al
je 0x1c549
movq 0x1eabf(%rip), %rdi     # 0x3aff0
leaq 0xe987(%rip), %rsi      # 0x2aebf
callq 0x43a0
movq %rax, %rdi
callq 0x41e0
xorl %eax, %eax
jmp 0x1c573
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x1c3a8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1c45a
movl (%rbx), %eax
decl %eax
movl %eax, 0x130(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/adamiaonr[P]rid-analytics/src/argvparser.cpp
// Function: CommandLineProcessing::trimmedString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CommandLineProcessing::trimmedString( const std::string & _str )
{
    // no string no work
    if(_str.length() == 0)
        return _str;

    string::size_type start_pos = _str.find_first_not_of(" \a\b\f\n\r\t\v");
    string::size_type end_pos = _str.find_last_not_of(" \a\b\f\n\r\t\v");

    // check whether there was any non-whitespace
    if (start_pos == string::npos)
        return("");

    return string(_str, start_pos, end_pos - start_pos + 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x1c615
leaq 0xe946(%rip), %r12      # 0x2af1e
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4270
movq %rax, %r15
pushq $-0x1
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x4720
cmpq $-0x1, %r15
je 0x1c622
subq %r15, %rax
incq %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x4100
jmp 0x1c636
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4510
jmp 0x1c636
leaq 0xe06e(%rip), %rsi      # 0x2a697
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x16c66
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/adamiaonr[P]rid-analytics/include/argvparser.h
// Function: void CommandLineProcessing::splitString<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*)
void splitString(Container& _container, const std::string& _in,
                 const char* const _delimiters = " \t\n")
{
    const std::string::size_type len = _in.length();
    std::string::size_type i = 0;

    while ( i < len )
    {
        // eat leading whitespace
        i = _in.find_first_not_of (_delimiters, i);
        if (i == std::string::npos)
            return;   // nothing left but white space

        // find the end of the token
        std::string::size_type j = _in.find_first_of (_delimiters, i);

        // push token
        if (j == std::string::npos)
        {
            _container.push_back (_in.substr(i));
            return;
        }
        else
            _container.push_back (_in.substr(i, j-i));

        // set up for next loop
        i = j + 1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, (%rsp)
movq 0x8(%rsi), %rbx
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
cmpq %rbx, %r13
jae 0x1caca
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x4270
cmpq $-0x1, %rax
je 0x1caca
movq %rax, %rbp
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x4210
cmpq $-0x1, %rax
je 0x1ca9e
movq %rax, %r13
movq %rax, %rcx
subq %rbp, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x43e0
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x1de5e
movq %r12, %rdi
callq 0x41c0
incq %r13
jmp 0x1ca3a
leaq 0x8(%rsp), %r15
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x43e0
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x1de5e
leaq 0x8(%rsp), %rdi
callq 0x41c0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1cadb
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x41c0
movq %rbx, %rdi
callq 0x4700
// File: /workspace/github_cpp_makefile_star2_O2/adamiaonr[P]rid-analytics/src/rid-analytics.cpp
// Function: RID_Analytics::~RID_Analytics()
RID_Analytics::~RID_Analytics() {

    // erase the routers in the topology. use the router map for that (see the 
    // advantage of using modern C++ features you dummy?)
    for(RID_RouterMap::iterator rit = this->routers.begin(); 
        rit != this->routers.end(); 
        ++rit) {

        delete (*rit).second;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %r14
leaq 0x58(%rdi), %r12
cmpq %r12, %r14
je 0x1f81f
movq 0x40(%r14), %r15
testq %r15, %r15
je 0x1f805
movq %r15, %rdi
callq 0x17cee
movl $0xa8, %esi
movq %r15, %rdi
callq 0x43d0
movq %r14, %rdi
callq 0x42d0
movq %rax, %r14
jmp 0x1f7ef
leaq 0x50(%rbx), %r14
leaq 0x98(%rbx), %rdi
callq 0x216e2
movq %r14, %rdi
callq 0x21bf4
leaq 0x20(%rbx), %rdi
callq 0x21c58
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x195d0
// File: /workspace/github_cpp_makefile_star2_O2/adamiaonr[P]rid-analytics/src/rid-analytics.cpp
// Function: RID_Analytics::add_outcome(RID_Router*, int, long double, long double)
void RID_Analytics::add_outcome(
    RID_Router * router,
    int outcome, 
    __float080 prob,
    __float080 latency) {

    // header : router\ttype\tprob\tlatency\n
    std::string code = "";
    switch (outcome) {

        case OUTCOME_CORRECT_DELIVERY:
            code = "cd";
            break;

        case OUTCOME_INCORRECT_DELIVERY:
            code = "id";
            break;

        case OUTCOME_SOFT_FALLBACK_FWD:
            code = "sff";
            break;

        case OUTCOME_SOFT_FALLBACK_AID_FWD:
            code = "sffid";
            break;

        case OUTCOME_HARD_FALLBACK_DELIVERY:
            code = "hfd";
            break;

        case OUTCOME_FEEDBACK_DELIVERY:
            code = "fed";
            break;

        case OUTCOME_PACKET_DROP:
            code = "dr";
            break;

        default:
            code = "uk";
            break;
    }

    // add line to outcome file
    this->output_file[1] << router->get_id() << "\t" 
        << code << "\t" << prob << "\t" << latency << "\n";
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
fldt 0xa0(%rsp)
fstpt 0x18(%rsp)
fldt 0x90(%rsp)
fstpt 0x24(%rsp)
leaq 0xac04(%rip), %rsi      # 0x2a697
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x16c66
cmpl $0xc, %ebp
jae 0x1fab9
movl %ebp, %eax
leaq 0xba98(%rip), %rcx      # 0x2b548
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
jmp 0x1fac0
leaq 0xb7d8(%rip), %rsi      # 0x2b298
leaq 0x50(%rsp), %rdi
callq 0x4770
movq 0x98(%r14), %r14
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x4510
addq $0x200, %r14            # imm = 0x200
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x4360
leaq 0xab9d(%rip), %rsi      # 0x2a696
movq %rax, %rdi
callq 0x43a0
leaq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x4360
leaq 0xab81(%rip), %rsi      # 0x2a696
movq %rax, %rdi
callq 0x43a0
fldt 0x24(%rsp)
fstpt (%rsp)
movq %rax, %rdi
callq 0x4220
leaq 0xab63(%rip), %rsi      # 0x2a696
movq %rax, %rdi
callq 0x43a0
fldt 0x18(%rsp)
fstpt (%rsp)
movq %rax, %rdi
callq 0x4220
leaq 0xab01(%rip), %rsi      # 0x2a652
movq %rax, %rdi
callq 0x43a0
leaq 0x30(%rsp), %rdi
callq 0x41c0
leaq 0x50(%rsp), %rdi
callq 0x41c0
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1fb78
movq %rax, %rbx
jmp 0x1fb8a
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x41c0
leaq 0x50(%rsp), %rdi
callq 0x41c0
movq %rbx, %rdi
callq 0x4700
// File: /workspace/github_cpp_makefile_star2_O2/adamiaonr[P]rid-analytics/src/rid-analytics.cpp
// Function: on_path_to_origin(RID_Router*, int, int)
bool on_path_to_origin(RID_Router * router, int i, int os_id) {

    // check if bit is on 
    unsigned int byte_ix = (unsigned int) (os_id / 8);
    std::vector<uint8_t> * bitmask = router->get_tree_bitmask(i);

    // std::cout << "RID_Analytics : on_path_to_origin() : is [" 
    //     << router->get_id() << "][" << i << "] on the path to " << os_id << "?"
    //     << "\n\t [byte] : " << byte_ix
    //     << "\n\t [bit] : " << std::bitset<(sizeof(uint8_t) * 8)>(1 << (os_id % 8))
    //     << "\n\t [ bitmask[byte] ] : " << std::bitset<(sizeof(uint8_t) * 8)>((*bitmask)[byte_ix])
    //     << "\n\t [result] : " << (((1 << (os_id % 8)) & (*bitmask)[byte_ix]) > 0 ? "YES" : "NO") << std::endl;

    if (byte_ix < (*bitmask).size())
        return (((1 << (os_id % 8)) & (*bitmask)[byte_ix]) > 0);

    return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
pushq $0x8
popq %rcx
movl %edx, %eax
cltd
idivl %ecx
movl %eax, %r14d
movzbl %sil, %esi
callq 0x217a8
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
cmpq %r14, %rax
jbe 0x1fbd5
movzbl (%rcx,%r14), %eax
andl $0x7, %ebx
btl %ebx, %eax
setb %al
jmp 0x1fbd7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/adamiaonr[P]rid-analytics/src/rid-analytics.cpp
// Function: RID_Analytics::add_events(RID_Router*, std::vector<long double, std::allocator<long double>>)
void RID_Analytics::add_events(
    RID_Router * router,
    std::vector<__float080> events) {

    // header: router\tnlm\tllm\tmlm\tslm\n
    this->output_file[0] << router->get_id();
    for (unsigned int e = 0; e < events.size(); e++) {

        // if(((e == EVENT_SLMC) || (e == EVENT_SLMI) || (e == EVENT_LLM)) && events[e] > 1.1)
        //     std::cout << "RID_Analytics::add_events() : [ERROR] E[" << ((e == EVENT_LLM) ? "LLM" : "SLMx") << "] = " 
        //         << events[e] << " (> 1.0) @R" << router->get_id() << std::endl;

        this->output_file[0] << "\t" << events[e];
    }
    this->output_file[0] << "\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x98(%rdi), %r15
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x4510
movq %r15, %rdi
movq %r12, %rsi
callq 0x4360
leaq 0x18(%rsp), %rdi
callq 0x41c0
xorl %eax, %eax
leaq 0xaa73(%rip), %r15      # 0x2a696
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
movl %eax, %r12d
sarq $0x4, %rcx
movq 0x98(%r14), %rdi
cmpq %r12, %rcx
jbe 0x1fc64
movq %r15, %rsi
callq 0x43a0
movq (%rbx), %rcx
movq %r12, %rdx
shlq $0x4, %rdx
fldt (%rcx,%rdx)
fstpt (%rsp)
movq %rax, %rdi
callq 0x4220
leal 0x1(%r12), %eax
jmp 0x1fc23
leaq 0xa9e7(%rip), %rsi      # 0x2a652
callq 0x43a0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x41c0
movq %rbx, %rdi
callq 0x4700
nop
// File: /workspace/github_cpp_makefile_star2_O2/adamiaonr[P]rid-analytics/src/rid-analytics.cpp
// Function: RID_Analytics::handle_llm(RID_Router*, std::vector<std::vector<long double, std::allocator<long double>>, std::allocator<std::vector<long double, std::allocator<long double>>>>&, std::vector<long double, std::allocator<long double>>&, Path_State*)
int RID_Analytics::handle_llm(
    RID_Router * router,
    std::vector<std::vector<__float080> > & iface_probs,
    std::vector<__float080> & events,
    Path_State * prev_state) {

    // LLM : 'local link match' i.e. a delivery to a cache
    std::cout << "RID_Analytics::handle_llm() : analyzing LLM event" 
        << std::endl;

    // update the events array
    events[EVENT_LLM] = iface_probs[0][2];

    // don't continue if prob of llm is 0.0
    if (iface_probs[0][2] == 0.0) return 0;
    
    // assess correctness of local delivery
    if (this->tp_sizes[router->get_id()][0] > 0) {

        // add record of correct delivery
        add_outcome(router, OUTCOME_CORRECT_DELIVERY, iface_probs[0][2], prev_state->get_length());

    } else {

        // add record of incorrect delivery
        add_outcome(router, OUTCOME_INCORRECT_DELIVERY, iface_probs[0][2], prev_state->get_length());

        // handling incorrect deliveries if resolution is on
        if (this->mode & 0x04) {

            if (this->mode == MMH_FLOOD) {

                add_outcome(
                    router, 
                    OUTCOME_FEEDBACK_DELIVERY,
                    iface_probs[0][2], 
                    prev_state->get_length() + get_origin_distance(this->start_router));

            } 
            // else if ((this->mode & 0x03) == HARD_FALLBACK) {

            //     add_outcome(
            //         router, 
            //         OUTCOME_HARD_FALLBACK_DELIVERY, 
            //         iface_probs[0][0],
            //         prev_state->get_length() + get_origin_distance(router));

            // }
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1b078(%rip), %rdi     # 0x3afb0
leaq 0xb35c(%rip), %rsi      # 0x2b29b
callq 0x43a0
movq %rax, %rdi
callq 0x41e0
movq (%r12), %rax
movq (%rax), %rax
fldt 0x20(%rax)
movq (%r13), %rax
fld %st(0)
fstpt 0x20(%rax)
fldz
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x1ff6b
jnp 0x1ffd6
leaq 0x20(%r14), %r13
leaq 0x38(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x4510
movq %r13, %rdi
movq %rbp, %rsi
callq 0x21b0e
movq (%rax), %rax
xorl %ebp, %ebp
cmpb $0x0, (%rax)
sete %bpl
leaq 0x38(%rsp), %rdi
callq 0x41c0
movq (%r12), %rax
movq (%rax), %rax
fldt 0x20(%rax)
fstpt 0x2c(%rsp)
movq %r15, %rdi
callq 0x1ab16
movl %eax, 0x28(%rsp)
fildl 0x28(%rsp)
fstpt 0x10(%rsp)
fldt 0x2c(%rsp)
fstpt (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1fa66
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x41c0
movq %rbx, %rdi
callq 0x4700
// File: /workspace/github_cpp_makefile_star2_O2/adamiaonr[P]rid-analytics/src/rid-analytics.cpp
// Function: RID_Analytics::handle_ttl_drop(RID_Router*, long double, Path_State*)
int RID_Analytics::handle_ttl_drop(
    RID_Router * router,
    __float080 event_num,
    Path_State * prev_state) {

    std::cout << "RID_Analytics::handle_ttl_drop() : analyzing TTL drop event" 
        << std::endl;

    add_outcome(
        router, 
        OUTCOME_TTL_DROP, 
        event_num, 
        prev_state->get_length());

    // FIXME: special event to end simulation
    //  - it's not solved by any kind of resolution
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
fldt 0x50(%rsp)
fstpt 0x24(%rsp)
movq 0x1af93(%rip), %rdi     # 0x3afb0
leaq 0xb2a9(%rip), %rsi      # 0x2b2cd
callq 0x43a0
movq %rax, %rdi
callq 0x41e0
movq %rbx, %rdi
callq 0x1ab16
movl %eax, 0x20(%rsp)
fildl 0x20(%rsp)
fstpt 0x10(%rsp)
fldt 0x24(%rsp)
fstpt (%rsp)
pushq $0x5
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1fa66
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/adamiaonr[P]rid-analytics/src/prob.cpp
// Function: count_shared_trees(int, Prob::fp_data*, std::map<int, std::vector<unsigned char, std::allocator<unsigned char>>, std::less<int>, std::allocator<std::pair<int const, std::vector<unsigned char, std::allocator<unsigned char>>>>>*)
int count_shared_trees(
    int t,
    Prob::fp_data * iface_fp_data,
    std::map<int, std::vector<uint8_t> > * tree_bitmasks) {

    int count = 0;
    for (unsigned int k = 0; k < (*tree_bitmasks)[t].size(); k++)
        count += count_set_bits((int) (((*tree_bitmasks)[t][k]) & (iface_fp_data->tree_bitmasks[t][k])));

    return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x4(%rsp), %r15
movl %edi, (%r15)
addq $0x60, %r14
xorl %ebp, %ebp
xorl %eax, %eax
movl %eax, %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1909a
movq 0x8(%rax), %rcx
subq (%rax), %rcx
cmpq %r12, %rcx
jbe 0x235f9
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1909a
movq (%rax), %rax
movb (%rax,%r12), %r13b
movq %r14, %rdi
movq %r15, %rsi
callq 0x1909a
movq (%rax), %rax
andb (%rax,%r12), %r13b
movzbl %r13b, %edi
callq 0x233cd
addl %eax, %ebp
leal 0x1(%r12), %eax
jmp 0x235a9
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/adamiaonr[P]rid-analytics/src/prob.cpp
// Function: local_tree_ratios(Prob::fp_data*, std::map<int, std::vector<unsigned char, std::allocator<unsigned char>>, std::less<int>, std::allocator<std::pair<int const, std::vector<unsigned char, std::allocator<unsigned char>>>>>*, std::vector<long double, std::allocator<long double>>&)
void local_tree_ratios(
    Prob::fp_data * iface_fp_data,
    std::map<int, std::vector<uint8_t> > * tree_bitmasks,
    std::vector<__float080> & lt_ratios) {

    std::map<int, std::vector<uint8_t> >::iterator itr;
    for (itr = (*tree_bitmasks).begin(); itr != (*tree_bitmasks).end(); itr++) {

        // isolate the tree size
        int t = itr->first;
        // skip 'union' of tree bitmasks
        if (t == 0) continue;
        // count trees & shared trees which pass through iface
        int trees = 0, shared_trees = 0;
        for (unsigned int k = 0; k < (*tree_bitmasks)[t].size(); k++) {
            trees += count_set_bits((int) iface_fp_data->tree_bitmasks[t][k]);
            shared_trees += count_set_bits((int) (((*tree_bitmasks)[t][k]) & (iface_fp_data->tree_bitmasks[t][k])));
        }

        if (trees > 0)
            lt_ratios[t - 1] = (__float080) (trees - shared_trees) / (__float080) (trees);
        // std::cout << "\t [# trees] : " << trees
        //     << "\n\t [# shared trees] : " << shared_trees
        //     << "\n\t [lt ratios[" << (t) << "]] : " << lt_ratios[t - 1] << std::endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x18(%rsp)
movq %rsi, %r13
movq 0x18(%rsi), %rdx
leaq 0x8(%rsi), %rax
movq %rax, 0x20(%rsp)
addq $0x60, %rdi
movq %rdi, 0x30(%rsp)
leaq 0xc(%rsp), %r14
movq 0x30(%rsp), %rbx
cmpq 0x20(%rsp), %rdx
je 0x2371b
movl 0x20(%rdx), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x2370b
movq %rdx, 0x28(%rsp)
xorl %ebp, %ebp
movl $0x0, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %r12d
movq %r13, %rdi
movq %r14, %rsi
callq 0x1909a
movq 0x8(%rax), %rcx
subq (%rax), %rcx
cmpq %r12, %rcx
jbe 0x236d7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1909a
movq (%rax), %rax
movzbl (%rax,%r12), %edi
callq 0x233cd
addl %eax, %ebp
movq %r13, %rdi
movq %r14, %rsi
callq 0x1909a
movq (%rax), %rax
movb (%rax,%r12), %r15b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1909a
movq (%rax), %rax
andb (%rax,%r12), %r15b
movzbl %r15b, %edi
callq 0x233cd
addl %eax, 0x8(%rsp)
leal 0x1(%r12), %eax
jmp 0x2366b
testl %ebp, %ebp
movq 0x28(%rsp), %rdx
jle 0x2370b
movl %ebp, %eax
subl 0x8(%rsp), %eax
movl %eax, 0x14(%rsp)
fildl 0x14(%rsp)
movl %ebp, 0x10(%rsp)
fidivl 0x10(%rsp)
movslq 0xc(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
shlq $0x4, %rax
fstpt -0x10(%rcx,%rax)
movq %rdx, %rdi
callq 0x42d0
movq %rax, %rdx
jmp 0x23640
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/adamiaonr[P]rid-analytics/src/prob.cpp
// Function: Prob::calc_lm_probs(std::vector<std::vector<Prob::fp_data*, std::allocator<Prob::fp_data*>>, std::allocator<std::vector<Prob::fp_data*, std::allocator<Prob::fp_data*>>>>*, std::map<int, std::vector<unsigned char, std::allocator<unsigned char>>, std::less<int>, std::allocator<std::pair<int const, std::vector<unsigned char, std::allocator<unsigned char>>>>>*)
int Prob::calc_lm_probs(
    std::vector<std::vector<Prob::fp_data *> > * iface_fp_data,
    std::map<int, std::vector<uint8_t> > * tree_bitmasks) {

    for (uint8_t i = 0; i < this->iface_num; i++) {

        // time complexity : O(N^2 * I)
        calc_lm_prob(i, (*iface_fp_data)[0][i], tree_bitmasks);       // iface i
        // time complexity : O(N^2 * I)
        calc_lm_prob(i, (*iface_fp_data)[1][i], tree_bitmasks, true); // iface ~i

        // print_lm_prob(i);
        // print_lm_prob(i, true);
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
pushq $0x1
popq %rbp
movzbl 0xb0(%r14), %eax
cmpq %rax, %r12
jae 0x23f41
movq (%rbx), %rax
movq (%rax), %rax
movq (%rax,%r12,8), %rdx
movzbl %r12b, %r15d
movq %r14, %rdi
movl %r15d, %esi
xorl %r8d, %r8d
callq 0x23ac2
movq (%rbx), %rax
movq 0x18(%rax), %rax
movq (%rax,%r12,8), %rdx
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %r8d
callq 0x23ac2
incq %r12
jmp 0x23efa
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/stringify.c
// Function: stringify
void stringify(const char* name)
{
    char line[512];
    char* p;

    printf("/*\n"
           " * Auto-generated by stringify\n"
           " */\n\n");
    printf("const char* %s =", name);
    while (fgets(line, sizeof(line), stdin)) {
        printf("\n  \"");
        for (p = line; *p; ++p) {
            if (*p == '"' || *p == '\\')
                putc('\\', stdout);
            if (*p != '\n' && *p != '\r')
                putc(*p, stdout);
        }
        printf("\\n\"");
    }
    printf(";\n\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0xe8a(%rip), %rdi       # 0x2034
callq 0x1030
leaq 0xe4e(%rip), %rdi       # 0x2004
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
leaq -0x230(%rbp), %r14
movq 0x2e02(%rip), %r13      # 0x3fd0
pushq $0x5c
popq %r15
leaq 0xe41(%rip), %r12       # 0x201a
movq 0x2df8(%rip), %rax      # 0x3fd8
movq (%rax), %rdx
movq %r14, %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x1050
testq %rax, %rax
je 0x1250
leaq 0xe19(%rip), %rdi       # 0x2015
xorl %eax, %eax
callq 0x1040
movq %r14, %rbx
movzbl (%rbx), %eax
cmpl $0x22, %eax
je 0x1219
cmpl $0x5c, %eax
je 0x1219
testl %eax, %eax
jne 0x1227
jmp 0x1244
movq (%r13), %rsi
movl %r15d, %edi
callq 0x1060
movb (%rbx), %al
cmpb $0xa, %al
je 0x123f
movzbl %al, %ecx
cmpl $0xd, %ecx
je 0x123f
movsbl %al, %edi
movq (%r13), %rsi
callq 0x1060
incq %rbx
jmp 0x1206
movq %r12, %rdi
xorl %eax, %eax
callq 0x1040
jmp 0x11d9
leaq 0xe04(%rip), %rdi       # 0x205b
callq 0x1030
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zgimbutas[P]mwrap/src/stringify.c
// Function: main
int main(int argc, char** argv)
{
    if (argc != 2) {
        fprintf(stderr, "String name required\n");
        exit(-1);
    }
    stringify(argv[1]);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x2, %edi
jne 0x1284
movq 0x8(%rsi), %rdi
callq 0x118c
xorl %eax, %eax
popq %rbp
retq
movq 0x2d6d(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xd89(%rip), %rdi       # 0x201e
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x1080
pushq $-0x1
popq %rdi
callq 0x1070
// File: /workspace/github_cpp_makefile_star2_O2/calgagi[P]cp_gen/main.cpp
// Function: noAfterDot(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string noAfterDot(const string& filename) {
    int where = filename.find(".");
    if (where == string::npos) {
        error("Could not find task in filename");
    } 
    return filename.substr(0, where);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2aaa(%rip), %rsi      # 0x509c
movq %r14, %rdi
xorl %edx, %edx
callq 0x2320
shlq $0x20, %rax
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
cmpq %rcx, %rax
je 0x262e
sarq $0x20, %rax
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x21e0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x2a0f(%rip), %rsi      # 0x5044
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x2ed8
movq %rbx, %rdi
callq 0x25ac
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2338
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/calgagi[P]cp_gen/main.cpp
// Function: pathToGen[abi:cxx11]()
string pathToGen() {
    char buff[512];

    // Linux syscall that gets the linked path to the current executable, "gen"
    ssize_t r = ::readlink("/proc/self/exe", buff, 511);
    if (r == -1) {
        error("Could not find path to current executable."); 
    }
    else {
        buff[r] = '\0';
    }

    // this assumes that gen is in the root directory of cp_gen (where lib is)
    string gen_path = buff;
    shavePath(gen_path);
    return gen_path;
}

// Assembly:
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rdi, %rbx
leaq 0x29cb(%rip), %rdi      # 0x5064
leaq 0x30(%rsp), %rsi
movl $0x1ff, %edx            # imm = 0x1FF
callq 0x2200
cmpq $-0x1, %rax
je 0x26d9
movb $0x0, 0x30(%rsp,%rax)
leaq 0x30(%rsp), %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x2ed8
movq %rbx, %rdi
callq 0x2664
movq %rbx, %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
retq
leaq 0x2993(%rip), %rsi      # 0x5073
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x2ed8
movq %rbx, %rdi
callq 0x25ac
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2338
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/calgagi[P]cp_gen/main.cpp
// Function: output_file(std::basic_fstream<char, std::char_traits<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void output_file(fstream& new_file, const string& file_path) {
    fstream to_output;
    to_output.open(file_path);
    if (!to_output.is_open()) {
        error("Could not find " + file_path + " file");
    }
    string line;
    while (getline(to_output, line)) {
        // Skip "#pragma once" lines, they are used for dependencies in testing
        if (line != "#pragma once") {
            new_file << line << endl;
        }
    }
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x2210
pushq $0x18
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2260
leaq 0xc8(%rsp), %rdi
callq 0x2080
testb %al, %al
je 0x27d9
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x10, %rbx
leaq 0x48(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x293b(%rip), %r12      # 0x50b4
movq %r14, %rdi
movq %r15, %rsi
callq 0x2060
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x27b6
movq %r15, %rdi
movq %r12, %rsi
callq 0x30a4
testb %al, %al
je 0x2779
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2190
movq %rax, %rdi
callq 0x2100
jmp 0x2779
leaq 0x8(%rsp), %rdi
callq 0x2338
leaq 0x48(%rsp), %rdi
callq 0x2070
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x28be(%rip), %rsi      # 0x509e
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x302e
leaq 0x28ba(%rip), %rdx      # 0x50ae
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x300f
leaq 0x28(%rsp), %rdi
callq 0x25ac
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2338
jmp 0x2828
jmp 0x2825
jmp 0x2820
movq %rax, %rbx
jmp 0x2832
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2338
leaq 0x48(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/calgagi[P]cp_gen/main.cpp
// Function: output(std::basic_fstream<char, std::char_traits<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void output(fstream& new_file, const string& filename, const vector<string>& templates) {
    // Static Header
    time_t now = time(0);
    new_file << "/*\n"
        " * generated by github.com/calgagi/cp_gen\n" 
        " * file: " << filename << "\n"
        " * time: " << ctime(&now) << ""
        " */\n"
        "\n"
        "#include <bits/stdc++.h>\n"
        "using namespace std;\n"
        "typedef long long ll;\n"
        "typedef long double ld;\n\n"
        "namespace cp {\n\n";


    string gen_path = pathToGen();

    // Output templates
    output_templates(new_file, templates);
    new_file << "}\n\n"
                "/* ===== BEGIN USER CODE ===== */\n\n";
    // User-defined after cp namespace file
    output_file(new_file, gen_path + CP_GEN_AFTER);

    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
xorl %edi, %edi
callq 0x21a0
leaq 0x48(%rsp), %r13
movq %rax, (%r13)
leaq 0x10(%rbx), %r15
leaq 0x25f1(%rip), %rsi      # 0x50cb
movq %r15, %rdi
callq 0x21b0
movq %rax, %rdi
movq %r12, %rsi
callq 0x2190
leaq 0x260e(%rip), %rsi      # 0x5102
movq %rax, %rdi
callq 0x21b0
movq %rax, %r12
movq %r13, %rdi
callq 0x20c0
movq %r12, %rdi
movq %rax, %rsi
callq 0x21b0
leaq 0x25f4(%rip), %rsi      # 0x510d
movq %rax, %rdi
callq 0x21b0
leaq 0x28(%rsp), %rdi
callq 0x2687
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2844
leaq 0x2643(%rip), %rsi      # 0x5180
movq %r15, %rdi
callq 0x21b0
leaq 0x5674(%rip), %rdx      # 0x81c0
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x315c
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x270f
leaq 0x8(%rsp), %rdi
callq 0x2338
leaq 0x28(%rsp), %rdi
callq 0x2338
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2338
jmp 0x2b9e
jmp 0x2b9b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2338
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/mcounter-multi.cc
// Function: unsharedStructWorker(unsigned int)
void unsharedStructWorker(unsigned int a)
{
  UnsharedCounterStruct<MyCounters> uc(&myc);
  for(unsigned int n = 0; n < a; ++n) {
    ++uc.d_value.a;
    ++uc.d_value.b;
  }
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl %edi, %ebx
leaq 0x4d56(%rip), %rsi      # 0x7150
leaq 0x8(%rsp), %rdi
callq 0x26ea
subl $0x1, %ebx
jb 0x2415
incq 0x8(%rsp)
incq 0x10(%rsp)
jmp 0x2404
leaq 0x8(%rsp), %rdi
callq 0x2702
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/mcounter-multi.cc
// Function: sharedStructWorker(unsigned int)
void sharedStructWorker(unsigned int a)
{
  UnsharedCounterStruct<MyCounters> uc(&myc);
  for(unsigned int n = 0; n < a; ++n) {
    ++mca.a;
    ++mca.b;
  }
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl %edi, %ebx
leaq 0x4d1d(%rip), %rsi      # 0x7150
leaq 0x8(%rsp), %rdi
callq 0x26ea
subl $0x1, %ebx
jb 0x2454
lock
incq 0x4d76(%rip)            # 0x71c0
lock
incq 0x4d76(%rip)            # 0x71c8
jmp 0x243d
leaq 0x8(%rsp), %rdi
callq 0x2702
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./mcounter.hh
// Function: UnsharedCounterStructParent<MyCounters>::get()
T UnsharedCounterStructParent<T>::get()
{
  std::lock_guard<std::mutex> l(d_mutex);
  T ret = d_formerChildren;

  for(const auto& c : d_children) {
    StructPlusIs(ret, c->d_value);
  }
  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0x29ae
movups 0x60(%r14), %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
leaq 0x10(%r14), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x2763
movq 0x8(%r12), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2d9a
jmp 0x2748
movq %rbx, %rdi
callq 0x2110
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/pxzwxx[P]SynBS/./serverFile/./../share/log.h
// Function: void Log::INFO<int, int, int, int, int, int>(char const*, int, int, int, int, int, int)
static void INFO(const char *format, Args ...args) {
        m_emptyBuff.P();
        m_mutex.lock();
      
        char log_buf[10240] = {0};
        time_t t = time(NULL);
        struct tm *sys_tm = localtime(&t);
        sprintf(log_buf, "%d-%d-%d-%d-%d", sys_tm->tm_year + 1900, sys_tm->tm_mon + 1, sys_tm->tm_mday, sys_tm->tm_hour, sys_tm->tm_min);
        int n = strlen(log_buf);
        sprintf(log_buf + n, "  %s", "[info]  : ");
        n = strlen(log_buf);
        sprintf(log_buf + n, format, args...);
        std::string s(log_buf);

        m_list.push_back(std::move(s));

        m_mutex.unlock();
        m_fullBuff.V();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2838, %rsp           # imm = 0x2838
movq %r9, -0x38(%rbp)
movl %r8d, -0x30(%rbp)
movl %ecx, %r15d
movl %edx, %r12d
movl %esi, %ebx
movq %rdi, %r14
leaq 0x7a32(%rip), %rdi      # 0xc308
callq 0x43cc
leaq 0x7996(%rip), %rdi      # 0xc278
callq 0x4412
leaq -0x2860(%rbp), %r13
movl $0x2800, %edx           # imm = 0x2800
movq %r13, %rdi
xorl %esi, %esi
callq 0x31b0
xorl %edi, %edi
callq 0x3280
leaq -0x40(%rbp), %rdi
movq %rax, (%rdi)
callq 0x3210
movl $0x76c, %edx            # imm = 0x76C
addl 0x14(%rax), %edx
movl 0x10(%rax), %ecx
incl %ecx
movl 0xc(%rax), %r8d
movl 0x4(%rax), %r10d
movl 0x8(%rax), %r9d
subq $0x8, %rsp
leaq 0x37b5(%rip), %rsi      # 0x80e9
movq %r13, %rdi
xorl %eax, %eax
pushq %r10
callq 0x3090
popq %rcx
popq %rdx
movq %r13, %rdi
callq 0x3140
cltq
leaq (%rax,%rbp), %rdi
addq $-0x2860, %rdi          # imm = 0xD7A0
leaq 0x379a(%rip), %rsi      # 0x80f8
leaq 0x3798(%rip), %rdx      # 0x80fd
xorl %eax, %eax
callq 0x3090
movq %r13, %rdi
callq 0x3140
cltq
leaq (%rax,%rbp), %rdi
addq $-0x2860, %rdi          # imm = 0xD7A0
movq %r14, %rsi
movl %ebx, %edx
movl %r12d, %ecx
movl %r15d, %r8d
movl -0x30(%rbp), %r9d
xorl %eax, %eax
movl 0x10(%rbp), %r10d
pushq %r10
pushq -0x38(%rbp)
callq 0x3090
popq %rcx
popq %rdx
leaq -0x60(%rbp), %rbx
leaq -0x29(%rbp), %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3b22
leaq 0x79ac(%rip), %rdi      # 0xc368
movq %rbx, %rsi
callq 0x4428
leaq 0x78ad(%rip), %rdi      # 0xc278
callq 0x3220
leaq 0x78d1(%rip), %rdi      # 0xc2a8
callq 0x4438
leaq -0x60(%rbp), %rdi
callq 0x3150
addq $0x2838, %rsp           # imm = 0x2838
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x3150
movq %rbx, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O2/pxzwxx[P]SynBS/./serverFile/./EasyTcpServer.hpp
// Function: EasyTcpServer::InitSocket()
SOCKET InitSocket() {
		if (INVALID_SOCKET != _sock) {
			Log::ERROR("warning, initSocket close old socket<%d>...\n", (int)_sock);
			Close();
		}
		_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
		if (INVALID_SOCKET == _sock) {
			Log::ERROR("error, create socket failed...\n");
		}
		else {
			int flag = 1;
			if(SOCKET_ERROR == setsockopt(_sock, SOL_SOCKET, SO_REUSEADDR, (const char*)&flag, sizeof(int))) {
				Log::INFO("setsockopt socket<%d> SO_REUSEADDR fail",(int)(_sock));
				return SOCKET_ERROR;
			}
			Log::ERROR("create socket<%d> success...\n", (int)_sock);
		}
		return _sock;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x118(%rdi), %esi
cmpl $-0x1, %esi
je 0x3ba6
leaq 0x46a1(%rip), %rdi      # 0x823a
callq 0x4c52
movq %rbx, %rdi
callq 0x3ce0
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
pushq $0x6
popq %rdx
callq 0x30a0
movl %eax, 0x118(%rbx)
cmpl $-0x1, %eax
je 0x3bf3
leaq -0xc(%rbp), %rcx
movl $0x1, (%rcx)
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
pushq $0x4
popq %r8
movl %eax, %edi
callq 0x3440
movl 0x118(%rbx), %esi
cmpl $-0x1, %eax
je 0x3c07
leaq 0x46c3(%rip), %rdi      # 0x82af
callq 0x4c52
jmp 0x3bff
leaq 0x466d(%rip), %rdi      # 0x8267
callq 0x39d6
movl 0x118(%rbx), %eax
jmp 0x3c16
leaq 0x4679(%rip), %rdi      # 0x8287
callq 0x429a
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pxzwxx[P]SynBS/./serverFile/./EasyTcpServer.hpp
// Function: EasyTcpServer::Bind(char const*, unsigned short)
int Bind(const char* ip, unsigned short port) {
		sockaddr_in _sin = {};
		_sin.sin_family = AF_INET;
		_sin.sin_port = htons(port);//host to net unsigned short
		if (ip) {
			_sin.sin_addr.s_addr = inet_addr(ip);
		}
		else {
			_sin.sin_addr.s_addr = INADDR_ANY;
		}
		int ret = bind(_sock, (sockaddr*)&_sin, sizeof(_sin));
		if (SOCKET_ERROR == ret) {
			Log::ERROR("error, bind port<%d> failed...\n", port);
		}
		else {
			Log::INFO("bind port<%d> success...\n", port);
		}
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
andq $0x0, -0x18(%rbp)
movq %rdi, %r14
movw $0x2, -0x20(%rbp)
movl %ebx, %eax
rolw $0x8, %ax
movw %ax, -0x1e(%rbp)
testq %rsi, %rsi
je 0x3c52
movq %rsi, %rdi
callq 0x32b0
jmp 0x3c54
xorl %eax, %eax
leaq -0x20(%rbp), %rsi
movl %eax, 0x4(%rsi)
movl 0x118(%r14), %edi
pushq $0x10
popq %rdx
callq 0x3070
movl %eax, %r14d
movzwl %bx, %esi
cmpl $-0x1, %eax
je 0x3c83
leaq 0x467c(%rip), %rdi      # 0x82f8
callq 0x4eb6
jmp 0x3c8f
leaq 0x464e(%rip), %rdi      # 0x82d8
callq 0x4d84
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pxzwxx[P]SynBS/./serverFile/./EasyTcpServer.hpp
// Function: EasyTcpServer::Listen(int)
int Listen(int n) {
		// 3 listen 监听网络端口
		int ret = listen(_sock, n);
		if (SOCKET_ERROR == ret) {
			Log::ERROR("error, listen socket<%d> failed...\n",_sock);
		}
		else {
			Log::INFO("listen port<%d> success...\n", _sock);
		}
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl 0x118(%rdi), %edi
callq 0x3300
movl %eax, %ebx
movl 0x118(%r14), %esi
cmpl $-0x1, %eax
je 0x3ccd
leaq 0x4670(%rip), %rdi      # 0x8336
callq 0x429a
jmp 0x3cd9
leaq 0x463e(%rip), %rdi      # 0x8312
callq 0x4c52
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pxzwxx[P]SynBS/./serverFile/./EasyTcpServer.hpp
// Function: EasyTcpServer::Close()
void Close()
	{
		Log::INFO("EasyTcpServer.Close begin\n");
		_thread.Close();
		if (_sock != INVALID_SOCKET) {
			for (auto s : _cellServers) {
				delete s;
			}
			_cellServers.clear();
			close(_sock);
			_sock = INVALID_SOCKET;
		}
		Log::INFO("EasyTcpServer.Close end\n");
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x47f6(%rip), %rdi      # 0x84ea
callq 0x38ac
leaq 0x8(%rbx), %rdi
callq 0x5778
cmpl $-0x1, 0x118(%rbx)
je 0x3d5b
movq 0xf8(%rbx), %r14
movq 0x100(%rbx), %r15
cmpq %r15, %r14
je 0x3d32
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3d2c
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x3d19
movq 0xf8(%rbx), %rax
cmpq %rax, 0x100(%rbx)
je 0x3d49
movq %rax, 0x100(%rbx)
movl 0x118(%rbx), %edi
callq 0x3480
orl $-0x1, 0x118(%rbx)
leaq 0x47a3(%rip), %rdi      # 0x8505
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x38ac
nop
// File: /workspace/github_cpp_makefile_star2_O2/pxzwxx[P]SynBS/./serverFile/./EasyTcpServer.hpp
// Function: EasyTcpServer::EasyTcpServer()
EasyTcpServer() {
		_sock = INVALID_SOCKET;
		_recvCount = 0;
		_msgCount = 1;
		_clientCount = 0;
		_nMaxClient = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x7c49(%rip), %rax      # 0xbc18
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x418c
xorps %xmm0, %xmm0
movups %xmm0, 0xf8(%rbx)
andq $0x0, 0x108(%rbx)
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x3280
movq %rax, 0x110(%rbx)
movw $0x101, 0x11c(%rbx)     # imm = 0x101
movb $0x1, 0x11e(%rbx)
orl $-0x1, 0x118(%rbx)
xorl %eax, %eax
xchgl %eax, 0x124(%rbx)
pushq $0x1
popq %rax
xchgl %eax, 0x128(%rbx)
xchgl %r14d, 0x12c(%rbx)
andl $0x0, 0x120(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pxzwxx[P]SynBS/./serverFile/./EasyEpollServer.hpp
// Function: EasyEpollServer::OnRun(CELLThread*)
void OnRun(CELLThread* pThread)
	{
		CELLEpoll ep;
		ep.create(1);
		ep.ctl(EPOLL_CTL_ADD, sockfd(), EPOLLIN);
		while (pThread->isRun())
		{
			time4msg();
			int ret = ep.wait(1);
			if(ret < 0) {			
				Log::INFO("EasyTcpServer.OnRun select exit.\n");
				pThread->Exit();
				break;
			}
			auto events = ep.events();
			for(int i = 0; i < ret; i ++) {
				if(events[i].data.fd == sockfd()) {
					Accept();
				}
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq -0x38(%rbp), %rdi
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
pushq $0x1
popq %rsi
callq 0x4608
movl 0x118(%r14), %edx
leaq -0x38(%rbp), %rdi
pushq $0x1
popq %rcx
movl %ecx, %esi
callq 0x4678
cmpb $0x1, 0xe8(%rbx)
jne 0x4158
movq %r14, %rdi
callq 0x46c0
leaq -0x38(%rbp), %rdi
pushq $0x1
popq %rsi
callq 0x4792
testl %eax, %eax
js 0x4144
movq -0x30(%rbp), %r13
movl %eax, %eax
imulq $0xc, %rax, %r15
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x40f5
movl 0x4(%r13,%r12), %eax
cmpl 0x118(%r14), %eax
jne 0x413e
movq %r14, %rdi
callq 0x4808
addq $0xc, %r12
jmp 0x4123
leaq 0x3fd4(%rip), %rdi      # 0x811f
callq 0x38ac
movq %rbx, %rdi
callq 0x47d4
leaq -0x38(%rbp), %rdi
callq 0x4862
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4178
jmp 0x4178
jmp 0x4178
jmp 0x4178
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x4862
movq %rbx, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O2/pxzwxx[P]SynBS/./serverFile/./../share/CELLEpoll.hpp
// Function: CELLEpoll::create(int)
int create(int nMaxEvents) {
		if(_epfd > 0) {
			destory();
		}		

		_epfd = epoll_create(nMaxEvents);
		if(EPOLL_ERROR == _epfd) {
			perror("epolll_create");
			Log::ERROR("epolll_create : EPOLL_ERROR\n");
			return EPOLL_ERROR;	
		}
		if(_pEvents == nullptr) {
			_pEvents = new epoll_event[nMaxEvents];
		}	
		_nMaxEvents = nMaxEvents;
		return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x0, (%rdi)
jle 0x4621
movq %r14, %rdi
callq 0x4876
movl %ebx, %edi
callq 0x3470
movl %eax, (%r14)
cmpl $-0x1, %eax
je 0x465b
cmpq $0x0, 0x8(%r14)
jne 0x4650
movslq %ebx, %rax
pushq $0xc
popq %rcx
mulq %rcx
pushq $-0x1
popq %rdi
cmovnoq %rax, %rdi
callq 0x3030
movq %rax, 0x8(%r14)
movl %ebx, 0x4(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3adf(%rip), %rdi      # 0x8141
callq 0x3250
leaq 0x3ae1(%rip), %rdi      # 0x814f
callq 0x39d6
pushq $-0x1
popq %rax
jmp 0x4656
// File: /workspace/github_cpp_makefile_star2_O2/pxzwxx[P]SynBS/./serverFile/./../share/CELLEpoll.hpp
// Function: CELLEpoll::ctl(int, int, unsigned int)
int ctl(int op, SOCKET cSock, uint32_t events) {
		epoll_event ev;
		ev.events = events;
		ev.data.fd = cSock;
		if(epoll_ctl(_epfd, op, cSock, &ev) == EPOLL_ERROR) {
			perror("error, epoll_ctl");
			Log::ERROR("epoll_ctl : EPOLL_ERROR\n");
			return EPOLL_ERROR;
		}
    	return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0xc(%rbp), %rax
movl %ecx, (%rax)
movl %edx, 0x4(%rax)
movl (%rdi), %edi
movq %rax, %rcx
callq 0x3370
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
je 0x46a2
addq $0x10, %rsp
popq %rbp
retq
leaq 0x3ac3(%rip), %rdi      # 0x816c
callq 0x3250
leaq 0x3ac8(%rip), %rdi      # 0x817d
callq 0x39d6
pushq $-0x1
popq %rax
jmp 0x469c
nop
// File: /workspace/github_cpp_makefile_star2_O2/pxzwxx[P]SynBS/./serverFile/./EasyTcpServer.hpp
// Function: EasyTcpServer::time4msg()
void time4msg() {
		time_t cur = time(NULL);
		int t1 = cur - _old;
		if (t1 >= 1) {
			_old = cur;
			Log::INFO("thread<%d>,time<%d>,socket<%d>,clients<%d>,recv<%d>,msg<%d>\n", (int)_cellServers.size(), t1, _sock, (int)_clientCount, (int)(_recvCount), (int)(_msgCount));	
			printf("thread<%d>,time<%d>,socket<%d>,clients<%d>,recv<%d>,msg<%d>\n", (int)_cellServers.size(), t1, _sock, (int)_clientCount, (int)(_recvCount), (int)(_msgCount));
			_recvCount = 0;
			_msgCount = 0;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x3280
movl 0x110(%rbx), %ecx
movl %eax, %r14d
subl %ecx, %r14d
testl %r14d, %r14d
jle 0x4784
movq %rax, 0x110(%rbx)
movq 0x100(%rbx), %rsi
subq 0xf8(%rbx), %rsi
shrq $0x3, %rsi
movl 0x118(%rbx), %ecx
movl 0x12c(%rbx), %r8d
movl 0x124(%rbx), %r9d
movl 0x128(%rbx), %eax
movl %eax, (%rsp)
leaq 0x3a68(%rip), %r15      # 0x8196
movq %r15, %rdi
movl %r14d, %edx
callq 0x48a8
movq 0x100(%rbx), %rsi
subq 0xf8(%rbx), %rsi
shrq $0x3, %rsi
movl 0x118(%rbx), %ecx
movl 0x12c(%rbx), %r8d
movl 0x124(%rbx), %r9d
movl 0x128(%rbx), %eax
movl %eax, (%rsp)
movq %r15, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x3050
xorl %eax, %eax
xchgl %eax, 0x124(%rbx)
xchgl %r12d, 0x128(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop