LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/adamiaonr[P]rid-analytics/src/argvparser.cpp
// Function: CommandLineProcessing::ArgvParser::getAllOptionAlternatives[abi:cxx11](unsigned int) const
list<string> ArgvParser::getAllOptionAlternatives( unsigned int _key ) const
{
    // keys go here
    list<string> keys;
    // for all container elements
    for( map<string, unsigned int>::const_iterator it = option2key.begin();
            it != option2key.end();
            ++it )
    {
        if (it->second == _key)
            keys.push_back(it->first);
    }
    return(keys);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x20(%rsi), %r15
addq $0x10, %r14
cmpq %r14, %r15
je 0x204ec
movl %edx, %ebp
cmpl %ebp, 0x40(%r15)
jne 0x204dc
leaq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x2324c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4090
incq 0x10(%rbx)
movq %r15, %rdi
callq 0x4420
movq %rax, %r15
cmpq %r14, %rax
jne 0x204bb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2246c
movq %r14, %rdi
callq 0x4700
nop
// File: /workspace/github_cpp_makefile_star2_O1/adamiaonr[P]rid-analytics/src/argvparser.cpp
// Function: CommandLineProcessing::ArgvParser::argument[abi:cxx11](unsigned int) const
string ArgvParser::argument(unsigned int _id) const
{
    if (_id >= arguments())
    {
        cerr << "ArgvParser::argument(): Request for non-existing argument." << endl;
        return ("");
    }
    else
        return(argument_container[_id]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xf8(%rsi), %rax
movq 0x100(%rsi), %rcx
subq %rax, %rcx
shrq $0x5, %rcx
cmpl %edx, %ecx
jbe 0x20565
movl %edx, %ecx
shlq $0x5, %rcx
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1c27c
jmp 0x205c0
movq 0x1fa84(%rip), %r14     # 0x3fff0
leaq 0x1166b(%rip), %rsi     # 0x31bde
movl $0x3a, %edx
movq %r14, %rdi
callq 0x4400
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4370
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x42a0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x11142(%rip), %rdx     # 0x316f7
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x19074
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/adamiaonr[P]rid-analytics/src/argvparser.cpp
// Function: CommandLineProcessing::ArgvParser::defineOption(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&, int)
bool ArgvParser::defineOption( const string & _name,
                               const string& _descr,
                               OptionAttributes _attrs)
{
    // do nothing if there already is an option of this name
    if (isDefinedOption(_name))
    {
        cerr << "ArgvParser::defineOption(): The option label equals an already defined option." << endl;
        return(false);
    }

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

    option2key[_name] = max_key;     // give the option a unique key

    // store the option attributes
    option2attribute[max_key] = _attrs;

    // store the option description if there is one
    if (_descr.length())
        option2descr[max_key] = _descr;

    // inc the key counter
    ++max_key;

    return(true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r12
movq %r12, %rdi
callq 0x225bc
leaq 0x10(%rbx), %rcx
cmpq %rcx, %rax
je 0x217c9
movq 0x1e866(%rip), %rbx     # 0x3fff0
leaq 0x105e4(%rip), %rsi     # 0x31d75
movl $0x4e, %edx
movq %rbx, %rdi
callq 0x4400
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4370
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x42a0
xorl %eax, %eax
jmp 0x21831
cmpq $0x1, 0x8(%r15)
jne 0x217f0
movq (%r15), %rax
movb (%rax), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x217f0
movq 0x1e80e(%rip), %rbx     # 0x3fff0
leaq 0x105db(%rip), %rsi     # 0x31dc4
movl $0x49, %edx
jmp 0x21796
movl (%rbx), %r13d
movq %r12, %rdi
movq %r15, %rsi
callq 0x21e6a
movl %r13d, (%rax)
leaq 0x38(%rbx), %rdi
movq %rbx, %rsi
callq 0x21ee6
movl %ebp, (%rax)
cmpq $0x0, 0x8(%r14)
je 0x2182d
leaq 0x68(%rbx), %rdi
movq %rbx, %rsi
callq 0x21d7e
movq %rax, %rdi
movq %r14, %rsi
callq 0x4230
incl (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x225bc
addq $0x10, %r15
cmpq %r15, %rax
je 0x218bc
cmpq $0x1, 0x8(%rbx)
jne 0x21897
movq (%rbx), %rax
movb (%rax), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x21897
movq 0x1e767(%rip), %rbx     # 0x3fff0
leaq 0x105d4(%rip), %rsi     # 0x31e64
movl $0x54, %edx
jmp 0x218cf
movq %r14, %rdi
movq %rbx, %rsi
callq 0x225bc
cmpq %r15, %rax
je 0x21909
movq 0x1e742(%rip), %rbx     # 0x3fff0
leaq 0x10604(%rip), %rsi     # 0x31eb9
movl $0x65, %edx
jmp 0x218cf
movq 0x1e72d(%rip), %rbx     # 0x3fff0
leaq 0x10544(%rip), %rsi     # 0x31e0e
movl $0x55, %edx
movq %rbx, %rdi
callq 0x4400
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4370
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x42a0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %r12, %rsi
callq 0x225bc
cmpq %r15, %rax
je 0x2191e
movl 0x40(%rax), %ebp
jmp 0x21923
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21e6a
movl %ebp, (%rax)
movb $0x1, %al
jmp 0x21900
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r13
movq %r13, %rdi
callq 0x225bc
leaq 0x10(%rbx), %rbp
cmpq %rbp, %rax
jne 0x21970
movq %r13, %rdi
movq %r14, %rsi
callq 0x225bc
cmpq %rbp, %rax
je 0x219c3
movq 0x1e679(%rip), %rbx     # 0x3fff0
leaq 0x105a1(%rip), %rsi     # 0x31f1f
movl $0x5e, %edx
movq %rbx, %rdi
callq 0x4400
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4370
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x42a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x21758
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2184a
movl (%rbx), %eax
decl %eax
movl %eax, 0x130(%rbx)
movb $0x1, %al
jmp 0x219b4
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x21a95
leaq 0x10534(%rip), %r12     # 0x31f7e
movl $0x8, %ecx
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4690
movq %rax, %r15
movl $0x8, %ecx
movq %r14, %rdi
movq %r12, %rsi
movq $-0x1, %rdx
callq 0x4640
cmpq $-0x1, %r15
je 0x21aac
subq %r15, %rax
incq %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x4100
jmp 0x21ac5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1c27c
jmp 0x21ac5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xfc3d(%rip), %rdx      # 0x316f7
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x19074
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x50(%rdi), %r14
movq 0x68(%rdi), %r15
leaq 0x58(%rdi), %r13
cmpq %r13, %r15
je 0x257cf
movq 0x40(%r15), %r12
testq %r12, %r12
je 0x257bf
movq %r12, %rdi
callq 0x1c6ea
movl $0xa8, %esi
movq %r12, %rdi
callq 0x43a0
movq %r15, %rdi
callq 0x42b0
movq %rax, %r15
cmpq %r13, %rax
jne 0x257a1
leaq 0x98(%rbx), %rdi
callq 0x283fc
movq %r14, %rdi
callq 0x288d2
leaq 0x20(%rbx), %rdi
callq 0x2894a
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2580a
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x43a0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
leal 0x7(%rbx), %r14d
testl %edx, %edx
cmovnsl %edx, %r14d
sarl $0x3, %r14d
movzbl %sil, %eax
movq 0x30(%rdi), %rcx
leaq (%rax,%rax,4), %rax
shll $0x5, %eax
leaq (%rcx,%rax), %rdi
addq $0x60, %rdi
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
callq 0x28660
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
cmpq %r14, %rax
jbe 0x25e7d
movzbl (%rcx,%r14), %eax
andl $0x7, %ebx
btl %ebx, %eax
setb %al
jmp 0x25e7f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x98(%rdi), %r15
leaq 0x28(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x1c27c
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x4400
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x25eee
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x43a0
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
je 0x25f48
movl $0x1, %ebp
xorl %r13d, %r13d
leaq 0xb7f0(%rip), %r15      # 0x316f6
movq 0x98(%r14), %r12
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x4400
movq (%rbx), %rax
shlq $0x4, %r13
fldt (%rax,%r13)
fstpt (%rsp)
movq %r12, %rdi
callq 0x41f0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
movl %ebp, %r13d
sarq $0x4, %rax
incl %ebp
cmpq %r13, %rax
ja 0x25f06
movq 0x98(%r14), %rdi
leaq 0xb75c(%rip), %rsi      # 0x316b2
movl $0x1, %edx
callq 0x4400
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x25f89
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x43a0
movq %rbx, %rdi
callq 0x4700
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
fldt 0x60(%rsp)
fstpt 0x2c(%rsp)
movq 0x19b1f(%rip), %r12     # 0x3ffb8
leaq 0xbe8d(%rip), %rsi      # 0x3232d
movl $0x3b, %edx
movq %r12, %rdi
callq 0x4400
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x4370
movsbl %al, %esi
movq %r12, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x42a0
movq %r15, %rdi
callq 0x1f3a2
movl %eax, 0x28(%rsp)
fildl 0x28(%rsp)
fstpt 0x10(%rsp)
fldt 0x2c(%rsp)
fstpt (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movl $0x5, %edx
callq 0x25c58
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %rsi
movl %edi, (%rsi)
movq %rdx, %rdi
callq 0x1e016
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x2a0dc
addq $0x60, %r14
xorl %r12d, %r12d
leaq 0x4(%rsp), %r15
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1e016
movq (%rax), %rax
movzbl (%rax,%r12), %r13d
movq %r14, %rdi
movq %r15, %rsi
callq 0x1e016
movq (%rax), %rax
movzbl (%rax,%r12), %ecx
movl $0x0, %eax
andl %r13d, %ecx
je 0x2a0be
xorl %eax, %eax
leal 0x7fffffff(%rcx), %edx
andl %ecx, %edx
incl %eax
movl %edx, %ecx
testl %edx, %edx
jg 0x2a0ae
addl %eax, %ebp
incl %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1e016
movq 0x8(%rax), %rcx
subq (%rax), %rcx
cmpq %r12, %rcx
ja 0x2a07c
jmp 0x2a0de
xorl %ebp, %ebp
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_O1/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:
cmpb $0x0, 0xb0(%rdi)
je 0x2abdd
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax), %rax
movq (%rax,%r15,8), %rdx
movzbl %r15b, %ebp
movq %r14, %rdi
movl %ebp, %esi
xorl %r8d, %r8d
callq 0x2a676
movq (%rbx), %rax
movq 0x18(%rax), %rax
movq (%rax,%r15,8), %rdx
movq %r14, %rdi
movl %ebp, %esi
movl $0x1, %r8d
callq 0x2a676
incq %r15
movzbl 0xb0(%r14), %eax
cmpq %rax, %r15
jb 0x2ab8d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe5a(%rip), %rdi       # 0x2034
callq 0x1030
leaq 0xe1e(%rip), %rdi       # 0x2004
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
movq 0x2de1(%rip), %rax      # 0x3fd8
movq (%rax), %rdx
leaq -0x230(%rbp), %r12
movq %r12, %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x1050
testq %rax, %rax
je 0x129e
leaq 0xdf7(%rip), %r14       # 0x2015
movq 0x2dab(%rip), %r13      # 0x3fd0
leaq 0xdee(%rip), %r15       # 0x201a
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movq %r12, %rbx
movzbl (%rbx), %eax
cmpl $0x22, %eax
je 0x124c
cmpl $0x5c, %eax
je 0x124c
testl %eax, %eax
jne 0x125a
jmp 0x1278
movq (%r13), %rsi
movl $0x5c, %edi
callq 0x1060
movzbl (%rbx), %eax
cmpl $0xa, %eax
je 0x1273
cmpl $0xd, %eax
je 0x1273
movsbl %al, %edi
movq (%r13), %rsi
callq 0x1060
incq %rbx
jmp 0x1239
movq %r15, %rdi
xorl %eax, %eax
callq 0x1040
movq 0x2d4f(%rip), %rax      # 0x3fd8
movq (%rax), %rdx
movq %r12, %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x1050
testq %rax, %rax
jne 0x122c
leaq 0xdb6(%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_O1/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 0x12d2
movq 0x8(%rsi), %rdi
callq 0x11bc
xorl %eax, %eax
popq %rbp
retq
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x29cc(%rip), %rsi      # 0x5080
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x2310
shlq $0x20, %rax
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
cmpq %rcx, %rax
je 0x26f5
sarq $0x20, %rax
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x2210
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2923(%rip), %rsi      # 0x5028
leaq 0x293b(%rip), %rdx      # 0x5047
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x3c66
movq %rbx, %rdi
callq 0x266c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x273b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
leaq 0x28c7(%rip), %rdi      # 0x5048
leaq 0x20(%rsp), %rsi
movl $0x1ff, %edx            # imm = 0x1FF
callq 0x2230
cmpq $-0x1, %rax
je 0x27d8
movb $0x0, 0x20(%rsp,%rax)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x2100
leaq (%rsp,%rax), %rdx
addq $0x20, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c66
movq %rbx, %rdi
callq 0x2743
movq %rbx, %rax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
retq
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x286f(%rip), %rsi      # 0x5057
leaq 0x2892(%rip), %rdx      # 0x5081
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x3c66
movq %rbx, %rdi
callq 0x266c
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x281b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x2260
movq %r14, %rdi
movq %r15, %rsi
movl $0x18, %edx
callq 0x2290
leaq 0xc8(%rsp), %rdi
callq 0x2080
testb %al, %al
je 0x2943
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movb $0x0, (%rbp)
addq $0x10, %rbx
leaq 0x8(%rsp), %r15
leaq 0x2807(%rip), %r12      # 0x5098
movq 0x48(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2340
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2910
movq %r15, %rdi
movq %r12, %rsi
callq 0x20a0
testl %eax, %eax
je 0x2891
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2240
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
jmp 0x2891
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2927
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
leaq 0x48(%rsp), %rdi
callq 0x2070
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2738(%rip), %rsi      # 0x5082
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
callq 0x3629
leaq 0x2734(%rip), %rsi      # 0x5092
leaq 0x8(%rsp), %rdi
callq 0x2350
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2989
movups (%rcx), %xmm0
movups %xmm0, (%r14)
jmp 0x2996
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x266c
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x29d6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x29d6
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x29fa
jmp 0x2a07
jmp 0x29e8
movq %rax, %rbx
jmp 0x2a07
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2a07
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
leaq 0x48(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %edi, %edi
callq 0x21c0
leaq 0x48(%rsp), %r13
movq %rax, (%r13)
leaq 0x10(%rbx), %r14
leaq 0x22be(%rip), %rsi      # 0x50af
movl $0x36, %edx
movq %r14, %rdi
callq 0x2240
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r14, %rdi
callq 0x2240
movq %rax, %r12
leaq 0x22cd(%rip), %rsi      # 0x50e6
movl $0xa, %edx
movq %rax, %rdi
callq 0x2240
movq %r13, %rdi
callq 0x20d0
testq %rax, %rax
je 0x2e4e
movq %rax, %r13
movq %rax, %rdi
callq 0x2100
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x2240
jmp 0x2e69
movq (%r12), %rax
movq -0x18(%rax), %rax
movq %r12, %rdi
addq %rax, %rdi
movl 0x20(%r12,%rax), %esi
orl $0x1, %esi
callq 0x2300
leaq 0x2281(%rip), %rsi      # 0x50f1
movl $0x72, %edx
movq %r12, %rdi
callq 0x2240
leaq 0x28(%rsp), %rdi
callq 0x276d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2a19
leaq 0x22cb(%rip), %rsi      # 0x5164
movl $0x26, %edx
movq %r14, %rdi
callq 0x2240
leaq 0x532b(%rip), %rdx      # 0x81d8
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x376c
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2823
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ee4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2eff
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f32
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x2f32
jmp 0x2f2f
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f4d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0x3d2d(%rip), %rdi      # 0x6150
movq %rdi, 0x10(%rsi)
callq 0x29f0
testl %ebx, %ebx
je 0x243d
incq (%rsp)
incq 0x8(%rsp)
decl %ebx
jne 0x2430
movq %rsp, %rdi
callq 0x2800
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0x3cee(%rip), %rdi      # 0x6150
movq %rdi, 0x10(%rsi)
callq 0x29f0
testl %ebx, %ebx
je 0x2483
lock
incq 0x3d49(%rip)            # 0x61c0
lock
incq 0x3d49(%rip)            # 0x61c8
decl %ebx
jne 0x246f
movq %rsp, %rdi
callq 0x2800
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0x21d0
testl %eax, %eax
jne 0x287c
movups 0x60(%r14), %xmm0
movaps %xmm0, (%rsp)
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x2863
movq 0x8(%rax), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
addq %rsi, (%rsp,%rdx,8)
incq %rdx
cmpl $0x1, %edx
je 0x284e
movq (%rax), %rax
jmp 0x2843
movq %rbx, %rdi
callq 0x2100
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl %eax, %edi
callq 0x20c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/pxzwxx[P]SynBS/./serverFile/./../share/log.h
// Function: void Log::INFO<>(char const*)
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 %rbx
subq $0x2838, %rsp           # imm = 0x2838
movq %rdi, %rbx
leaq 0x87ac(%rip), %rdi      # 0xc2e8
callq 0x474e
leaq 0x8710(%rip), %rdi      # 0xc258
callq 0x3380
testl %eax, %eax
jne 0x3cb6
leaq -0x2840(%rbp), %r14
movl $0x2800, %edx           # imm = 0x2800
movq %r14, %rdi
xorl %esi, %esi
callq 0x3190
xorl %edi, %edi
callq 0x3260
leaq -0x40(%rbp), %rdi
movq %rax, (%rdi)
callq 0x31f0
movl $0x76c, %edx            # imm = 0x76C
addl 0x14(%rax), %edx
movl 0x10(%rax), %ecx
incl %ecx
movl 0xc(%rax), %r8d
movl 0x4(%rax), %esi
movl 0x8(%rax), %r9d
movl %esi, (%rsp)
leaq 0x4559(%rip), %rsi      # 0x80f9
movq %r14, %rdi
xorl %eax, %eax
callq 0x3090
movq %r14, %rdi
callq 0x3130
cltq
leaq (%rax,%rbp), %rdi
addq $-0x2840, %rdi          # imm = 0xD7C0
leaq 0x4542(%rip), %rsi      # 0x8108
leaq 0x4540(%rip), %rdx      # 0x810d
xorl %eax, %eax
callq 0x3090
movq %r14, %rdi
callq 0x3130
cltq
leaq (%rax,%rbp), %rdi
addq $-0x2840, %rdi          # imm = 0xD7C0
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3090
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x3130
leaq (%rax,%rbp), %rdx
addq $-0x2840, %rdx          # imm = 0xD7C0
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x72bc
movl $0x30, %edi
callq 0x3280
movq %rax, %rcx
addq $0x20, %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rdx
cmpq %r15, %rdx
je 0x3c46
movq %rdx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x3c4d
movups (%r15), %xmm0
movups %xmm0, (%rcx)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq %r15, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movb $0x0, -0x28(%rbp)
leaq 0x86dc(%rip), %rbx      # 0xc348
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3060
incq 0x10(%rbx)
leaq 0x85d6(%rip), %rdi      # 0xc258
callq 0x3200
leaq 0x85fa(%rip), %rdi      # 0xc288
callq 0x47a4
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x3ca8
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x32a0
addq $0x2838, %rsp           # imm = 0x2838
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x31c0
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x3cd5
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x118(%rdi), %esi
cmpl $-0x1, %esi
je 0x3f05
leaq 0x4352(%rip), %rdi      # 0x824a
callq 0x4efc
movq %rbx, %rdi
callq 0x405e
movl $0x2, %edi
movl $0x1, %esi
movl $0x6, %edx
callq 0x30a0
movl %eax, 0x118(%rbx)
cmpl $-0x1, %eax
je 0x3f61
leaq -0x14(%rbp), %rcx
movl $0x1, (%rcx)
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x3400
movl %eax, %r14d
movl 0x118(%rbx), %esi
cmpl $-0x1, %eax
je 0x3f6f
leaq 0x4365(%rip), %rdi      # 0x82bf
callq 0x4efc
jmp 0x3f7b
leaq 0x430f(%rip), %rdi      # 0x8277
callq 0x3cde
jmp 0x3f81
leaq 0x4321(%rip), %rdi      # 0x8297
callq 0x458e
cmpl $-0x1, %r14d
je 0x3f89
movl 0x118(%rbx), %eax
jmp 0x3f8e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movw $0x2, -0x20(%rbp)
movl %ebx, %eax
rolw $0x8, %ax
movw %ax, -0x1e(%rbp)
testq %rsi, %rsi
je 0x3fce
movq %rsi, %rdi
callq 0x3290
jmp 0x3fd0
xorl %eax, %eax
leaq -0x20(%rbp), %rsi
movl %eax, 0x4(%rsi)
movl 0x118(%r14), %edi
movl $0x10, %edx
callq 0x3070
movl %eax, %r14d
movzwl %bx, %esi
cmpl $-0x1, %eax
je 0x4001
leaq 0x430e(%rip), %rdi      # 0x8308
callq 0x527e
jmp 0x400d
leaq 0x42e0(%rip), %rdi      # 0x82e8
callq 0x50bc
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32d0
movl %eax, %ebx
movl 0x118(%r14), %esi
cmpl $-0x1, %eax
je 0x404b
leaq 0x4302(%rip), %rdi      # 0x8346
callq 0x458e
jmp 0x4057
leaq 0x42d0(%rip), %rdi      # 0x8322
callq 0x4efc
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4488(%rip), %rdi      # 0x84fa
callq 0x3b22
leaq 0x8(%rbx), %rdi
callq 0x5d48
cmpl $-0x1, 0x118(%rbx)
je 0x40dc
movq 0xf8(%rbx), %r14
movq 0x100(%rbx), %r15
cmpq %r15, %r14
je 0x40b0
movq (%r14), %rdi
testq %rdi, %rdi
je 0x40aa
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x4097
movq 0xf8(%rbx), %rax
cmpq %rax, 0x100(%rbx)
je 0x40c7
movq %rax, 0x100(%rbx)
movl 0x118(%rbx), %edi
callq 0x3440
movl $0xffffffff, 0x118(%rbx) # imm = 0xFFFFFFFF
leaq 0x4432(%rip), %rdi      # 0x8515
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3b22
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x78aa(%rip), %rax      # 0xbc20
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0xb8(%rbx), %r14
xorl %r15d, %r15d
movl $0xb0, %edx
xorl %esi, %esi
callq 0x3190
movq %r14, %rdi
callq 0x3340
movl %r15d, 0xe8(%rbx)
movb $0x0, 0xf0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xf8(%rbx)
movq $0x0, 0x108(%rbx)
xorl %edi, %edi
callq 0x3260
movq %rax, 0x110(%rbx)
movw $0x101, 0x11c(%rbx)     # imm = 0x101
movb $0x1, 0x11e(%rbx)
movl $0xffffffff, 0x118(%rbx) # imm = 0xFFFFFFFF
xorl %eax, %eax
xchgl %eax, 0x124(%rbx)
movl $0x1, %eax
xchgl %eax, 0x128(%rbx)
xorl %eax, %eax
xchgl %eax, 0x12c(%rbx)
movl %r15d, 0x120(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, -0x30(%rbp)
movq %rdi, %r14
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq -0x40(%rbp), %rdi
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x1, %esi
callq 0x4888
movl 0x118(%r14), %edx
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
movl $0x1, %ecx
callq 0x48ee
movq -0x30(%rbp), %rax
cmpb $0x1, 0xe8(%rax)
jne 0x4552
movq %r14, %rdi
callq 0x4924
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x49f6
movl %eax, %r13d
testl %eax, %eax
js 0x4538
je 0x454d
movq -0x38(%rbp), %r12
movl %r13d, %eax
shlq $0x2, %rax
leaq (%rax,%rax,2), %r15
xorl %ebx, %ebx
movl 0x4(%r12,%rbx), %eax
cmpl 0x118(%r14), %eax
jne 0x452d
movq %r14, %rdi
callq 0x4a64
addq $0xc, %rbx
cmpq %rbx, %r15
jne 0x4517
jmp 0x454d
leaq 0x3bf0(%rip), %rdi      # 0x812f
callq 0x3b22
movq -0x30(%rbp), %rdi
callq 0x4a24
testl %r13d, %r13d
jns 0x44da
leaq -0x40(%rbp), %rdi
callq 0x4abe
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4586
jmp 0x4572
jmp 0x4572
jmp 0x4572
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4abe
movq %rbx, %rdi
callq 0x33f0
movq %rax, %rdi
callq 0x4354
// File: /workspace/github_cpp_makefile_star2_O1/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 0x48a1
movq %r14, %rdi
callq 0x4abe
movl %ebx, %edi
callq 0x3430
movl %eax, (%r14)
cmpl $-0x1, %eax
je 0x48e1
cmpq $0x0, 0x8(%r14)
jne 0x48d6
movslq %ebx, %rax
movl $0xc, %ecx
mulq %rcx
movq $-0x1, %rdi
cmovnoq %rax, %rdi
callq 0x3030
movq %rax, 0x8(%r14)
movl %ebx, 0x4(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x346c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x48dc
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3320
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
je 0x4918
addq $0x10, %rsp
popq %rbp
retq
callq 0x3489
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x4912
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3260
movl 0x110(%rbx), %ecx
movl %eax, %r14d
subl %ecx, %r14d
testl %r14d, %r14d
jle 0x49e8
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 0x3814(%rip), %r15      # 0x81a6
movq %r15, %rdi
movl %r14d, %edx
callq 0x4af6
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
// File: /workspace/github_cpp_makefile_star2_O1/pxzwxx[P]SynBS/./serverFile/./../share/CELLEpoll.hpp
// Function: CELLEpoll::wait(int)
int wait(int timeout) { //以毫秒为单位
        int ret = epoll_wait(_epfd, _pEvents, _nMaxEvents, timeout);
        if (ret < 0) { //error
            perror("error, epoll_wait");
			Log::ERROR("epoll_wait : EPOLL_ERROR\n");
            return ret;
        }
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %esi, %ecx
movq 0x8(%rdi), %rsi
movl (%rdi), %eax
movl 0x4(%rdi), %edx
movl %eax, %edi
callq 0x3150
movl %eax, %ebx
testl %eax, %eax
js 0x4a1d
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x34a7
jmp 0x4a14
// File: /workspace/github_cpp_makefile_star2_O1/pxzwxx[P]SynBS/./serverFile/./EasyTcpServer.hpp
// Function: EasyTcpServer::Accept()
SOCKET Accept() {
		// 4 accept 等待接受客户端连接
		sockaddr_in clientAddr = {};
		int nAddrLen = sizeof(sockaddr_in);
		SOCKET cSock = INVALID_SOCKET;
		cSock = accept(_sock, (sockaddr*)&clientAddr, (socklen_t *)&nAddrLen);
		if (INVALID_SOCKET == cSock) {
			Log::INFO("error, accept INVALID_SOCKET...\n");
		}
		else {
			//将新客户端分配给客户数量最少的cellServer
			addClientToCELLServer(cSock);
		}
		return cSock;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rsi
movaps %xmm0, (%rsi)
leaq -0x14(%rbp), %rdx
movl $0x10, (%rdx)
movl 0x118(%rdi), %edi
callq 0x30e0
movl %eax, %r14d
cmpl $-0x1, %eax
je 0x4aa6
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4cea
jmp 0x4ab2
leaq 0x3762(%rip), %rdi      # 0x820f
callq 0x3b22
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq