LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1bdb4
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x4400
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x259e0
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x43a0
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
je 0x25a3a
movl $0x1, %ebp
xorl %r13d, %r13d
leaq 0xaade(%rip), %r15      # 0x304d6
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 0x259f8
movq 0x98(%r14), %rdi
leaq 0xaa4a(%rip), %rsi      # 0x30492
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 0x25a7b
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x43a0
movq %rbx, %rdi
callq 0x4700
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1902d(%rip), %r12     # 0x3efb8
leaq 0xb17b(%rip), %rsi      # 0x3110d
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 0x1ef10
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 0x2574a
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1db98
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x29bfb
addq $0x60, %r14
xorl %r12d, %r12d
leaq 0x4(%rsp), %r15
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1db98
movq (%rax), %rax
movzbl (%rax,%r12), %r13d
movq %r14, %rdi
movq %r15, %rsi
callq 0x1db98
movq (%rax), %rax
movzbl (%rax,%r12), %ecx
movl $0x0, %eax
andl %r13d, %ecx
je 0x29bdd
xorl %eax, %eax
leal 0x7fffffff(%rcx), %edx
incl %eax
andl %ecx, %edx
movl %edx, %ecx
jne 0x29bcf
addl %eax, %ebp
incl %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1db98
movq 0x8(%rax), %rcx
subq (%rax), %rcx
cmpq %r12, %rcx
ja 0x29b9d
jmp 0x29bfd
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_O3/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 0x2a6dd
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 0x2a188
movq (%rbx), %rax
movq 0x18(%rax), %rax
movq (%rax,%r15,8), %rdx
movq %r14, %rdi
movl %ebp, %esi
movl $0x1, %r8d
callq 0x2a188
incq %r15
movzbl 0xb0(%r14), %eax
cmpq %rax, %r15
jb 0x2a68d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x129f
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 0x125c
jmp 0x1279
movq (%r13), %rsi
movl $0x5c, %edi
callq 0x1060
movb (%rbx), %al
cmpb $0xa, %al
je 0x1274
movzbl %al, %ecx
cmpl $0xd, %ecx
je 0x1274
movsbl %al, %edi
movq (%r13), %rsi
callq 0x1060
incq %rbx
jmp 0x1239
movq %r15, %rdi
xorl %eax, %eax
callq 0x1040
movq 0x2d4e(%rip), %rax      # 0x3fd8
movq (%rax), %rdx
movq %r12, %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x1050
testq %rax, %rax
jne 0x122c
leaq 0xdb5(%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_O3/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 0x12d3
movq 0x8(%rsi), %rdi
callq 0x11bc
xorl %eax, %eax
popq %rbp
retq
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x29e8
testl %ebx, %ebx
je 0x243d
incq (%rsp)
incq 0x8(%rsp)
decl %ebx
jne 0x2430
movq %rsp, %rdi
callq 0x27f8
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x29e8
testl %ebx, %ebx
je 0x2483
lock
incq 0x3d49(%rip)            # 0x61c0
lock
incq 0x3d49(%rip)            # 0x61c8
decl %ebx
jne 0x246f
movq %rsp, %rdi
callq 0x27f8
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x287e
movups 0x60(%r14), %xmm0
movaps %xmm0, (%rsp)
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x2865
movq 0x8(%rax), %rcx
movb $0x1, %sil
xorl %edx, %edx
movq (%rcx,%rdx), %rdi
addq %rdi, (%rsp,%rdx)
addq $0x8, %rdx
testb $0x1, %sil
movl $0x0, %esi
jne 0x2849
movq (%rax), %rax
jmp 0x283b
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_O3/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 0x8784(%rip), %rdi      # 0xc2e8
callq 0x475c
leaq 0x86e8(%rip), %rdi      # 0xc258
callq 0x3380
testl %eax, %eax
jne 0x3cde
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 0x4531(%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 0x451a(%rip), %rsi      # 0x8108
leaq 0x4518(%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 0x7298
movl $0x30, %edi
callq 0x3280
movq %rax, %rcx
addq $0x20, %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rdx
cmpq %r15, %rdx
je 0x3c6e
movq %rdx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x3c75
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 0x86b4(%rip), %rbx      # 0xc348
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3060
incq 0x10(%rbx)
leaq 0x85ae(%rip), %rdi      # 0xc258
callq 0x3200
leaq 0x85d2(%rip), %rdi      # 0xc288
callq 0x47b2
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x3cd0
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 0x3cfd
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3f28
leaq 0x432f(%rip), %rdi      # 0x824a
callq 0x4f0c
movq %rbx, %rdi
callq 0x4074
movl $0x2, %edi
movl $0x1, %esi
movl $0x6, %edx
callq 0x30a0
movl %eax, 0x118(%rbx)
cmpl $-0x1, %eax
je 0x3f81
leaq -0xc(%rbp), %rcx
movl $0x1, (%rcx)
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x3400
movl 0x118(%rbx), %esi
cmpl $-0x1, %eax
je 0x3f95
leaq 0x4345(%rip), %rdi      # 0x82bf
callq 0x4f0c
jmp 0x3f8d
leaq 0x42ef(%rip), %rdi      # 0x8277
callq 0x3d06
movl 0x118(%rbx), %eax
jmp 0x3fa6
leaq 0x42fb(%rip), %rdi      # 0x8297
callq 0x459c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq $0x0, -0x18(%rbp)
movw $0x2, -0x20(%rbp)
movl %ebx, %eax
rolw $0x8, %ax
movw %ax, -0x1e(%rbp)
testq %rsi, %rsi
je 0x3fe5
movq %rsi, %rdi
callq 0x3290
jmp 0x3fe7
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 0x4018
leaq 0x42f7(%rip), %rdi      # 0x8308
callq 0x528e
jmp 0x4024
leaq 0x42c9(%rip), %rdi      # 0x82e8
callq 0x50cc
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4061
leaq 0x42ec(%rip), %rdi      # 0x8346
callq 0x459c
jmp 0x406d
leaq 0x42ba(%rip), %rdi      # 0x8322
callq 0x4f0c
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4472(%rip), %rdi      # 0x84fa
callq 0x3b4a
leaq 0x8(%rbx), %rdi
callq 0x5d46
cmpl $-0x1, 0x118(%rbx)
je 0x40f5
movq 0xf8(%rbx), %r14
movq 0x100(%rbx), %r15
cmpq %r15, %r14
je 0x40e0
movq (%r14), %rdi
testq %rdi, %rdi
je 0x40c0
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x40b2
movq 0xf8(%rbx), %rax
cmpq %rax, 0x100(%rbx)
je 0x40e0
movq %rax, 0x100(%rbx)
movl 0x118(%rbx), %edi
callq 0x3440
movl $0xffffffff, 0x118(%rbx) # imm = 0xFFFFFFFF
leaq 0x4419(%rip), %rdi      # 0x8515
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3b4a
nop
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $0x0, 0x8(%rdi)
movl $0x1, %esi
callq 0x4896
movl 0x118(%r14), %edx
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
movl $0x1, %ecx
callq 0x48fc
cmpb $0x1, 0xe8(%rbx)
jne 0x455e
movq %r14, %rdi
callq 0x4932
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x4a04
testl %eax, %eax
js 0x454a
je 0x44f3
movq -0x30(%rbp), %r12
movl %eax, %eax
shlq $0x2, %rax
leaq (%rax,%rax,2), %r13
xorl %r15d, %r15d
movl 0x4(%r12,%r15), %eax
cmpl 0x118(%r14), %eax
jne 0x453f
movq %r14, %rdi
callq 0x4a72
addq $0xc, %r15
cmpq %r15, %r13
jne 0x4529
jmp 0x44f3
leaq 0x3bde(%rip), %rdi      # 0x812f
callq 0x3b4a
movq %rbx, %rdi
callq 0x4a32
leaq -0x38(%rbp), %rdi
callq 0x4acc
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4580
jmp 0x4594
jmp 0x4580
jmp 0x4580
jmp 0x4580
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x4acc
movq %rbx, %rdi
callq 0x33f0
movq %rax, %rdi
callq 0x436e
// File: /workspace/github_cpp_makefile_star2_O3/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 0x48af
movq %r14, %rdi
callq 0x4acc
movl %ebx, %edi
callq 0x3430
movl %eax, (%r14)
cmpl $-0x1, %eax
je 0x48ef
cmpq $0x0, 0x8(%r14)
jne 0x48e4
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 0x48ea
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4926
addq $0x10, %rsp
popq %rbp
retq
callq 0x3489
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x4920
// File: /workspace/github_cpp_makefile_star2_O3/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 0x49f6
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 0x3806(%rip), %r15      # 0x81a6
movq %r15, %rdi
movl %r14d, %edx
callq 0x4b04
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_O3/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 0x4a2b
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x34a7
jmp 0x4a22
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4ab4
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4cf8
jmp 0x4ac0
leaq 0x3754(%rip), %rdi      # 0x820f
callq 0x3b4a
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./serverFile/./../share/CELLEpoll.hpp
// Function: CELLEpoll::destory()
void destory() {
		if(_epfd > 0) {
			close(_epfd);
			_epfd = -1;
		}
		if(_pEvents) {
			delete[] _pEvents;
			_pEvents = nullptr;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
testl %edi, %edi
jle 0x4ae6
callq 0x3440
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4afc
callq 0x3310
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./serverFile/./EasyTcpServer.hpp
// Function: EasyTcpServer::addClientToCELLServer(int)
void addClientToCELLServer(SOCKET cSock) {
		//查找客户数量最少的CELLServer消息处理对象
		auto pMinServer = _cellServers[0];
		for(auto pServer : _cellServers) {
			if (pMinServer->getClientCount() > pServer->getClientCount()) {
				pMinServer = pServer;
			}
		}
		pMinServer->addClient(cSock);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xf8(%rdi), %rax
movq 0x100(%rdi), %rcx
movq (%rax), %rdx
cmpq %rcx, %rax
je 0x4d4b
movq 0x50(%rdx), %r8
subq 0x48(%rdx), %r8
sarq $0x2, %r8
addq 0x30(%rdx), %r8
movq (%rax), %rdi
movq 0x50(%rdi), %r9
subq 0x48(%rdi), %r9
sarq $0x2, %r9
addq 0x30(%rdi), %r9
cmpq %r9, %r8
ja 0x4d3d
movq %rdx, %rdi
addq $0x8, %rax
movq %rdi, %rdx
cmpq %rcx, %rax
jne 0x4d12
jmp 0x4d4e
movq %rdx, %rdi
popq %rbp
jmp 0x4d54
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./serverFile/./EasyTcpServer.hpp
// Function: void EasyTcpServer::Start<CELLEpollServer>(int)
void Start(int nCELLServer) {
		for (int n = 0; n < nCELLServer; n++) {
			auto ser = new ServerT;
			ser->setId(n+1);
			ser->setIOListenNum((_nMaxClient / nCELLServer) + 1);
			_cellServers.push_back(ser);
			ser->setEventObj(this);
			ser->Start();
		}
		_thread.Start(
			nullptr,
			[this](CELLThread* pThread) {
				OnRun(pThread);
			},
			nullptr
		);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x54e2
movl %esi, %r14d
leaq 0xf8(%rbx), %rax
movq %rax, -0x30(%rbp)
movl %esi, %r12d
negl %r12d
movl $0x1, %r15d
movl $0x198, %edi            # imm = 0x198
callq 0x3280
movq %rax, %r13
movq %rax, %rdi
callq 0x5604
movl %r15d, 0x38(%r13)
movl 0x120(%rbx), %eax
cltd
idivl %r14d
leal 0x1(%rax), %esi
movq (%r13), %rax
movq %r13, %rdi
callq *0x10(%rax)
movq %r13, -0x38(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x67b8
movq %rbx, 0x40(%r13)
movq %r13, %rdi
callq 0x56a6
leal (%r12,%r15), %eax
incl %eax
movl %r15d, %ecx
incl %ecx
movl %ecx, %r15d
cmpl $0x1, %eax
jne 0x5482
xorps %xmm0, %xmm0
leaq -0x80(%rbp), %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
leaq -0xa0(%rbp), %rdx
movq $0x0, 0x8(%rdx)
movq %rbx, (%rdx)
addq $0x8, %rbx
leaq 0x1d4d(%rip), %rax      # 0x725a
movq %rax, 0x18(%rdx)
leaq 0x1d56(%rip), %rax      # 0x726e
movq %rax, 0x10(%rdx)
leaq -0x60(%rbp), %rcx
movaps %xmm0, (%rcx)
movaps %xmm0, 0x10(%rcx)
movq %rbx, %rdi
callq 0x57c0
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x5546
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x90(%rbp), %rax
testq %rax, %rax
je 0x5563
leaq -0xa0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x70(%rbp), %rax
testq %rax, %rax
je 0x557a
leaq -0x80(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x55e3
jmp 0x55e3
jmp 0x55e3
movq %rax, %rbx
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x55a9
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x90(%rbp), %rax
testq %rax, %rax
je 0x55c6
leaq -0xa0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x70(%rbp), %rax
testq %rax, %rax
je 0x55fb
leaq -0x80(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x55fb
jmp 0x55e3
jmp 0x55e3
movq %rax, %rdi
callq 0x436e
movq %rax, %rbx
movl $0x198, %esi            # imm = 0x198
movq %r13, %rdi
callq 0x32a0
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./serverFile/./CELLServer.hpp
// Function: CELLServer::Start()
void Start() {
		_thread.Start(
			nullptr,
			[this](CELLThread* pThread) {
				OnRun(pThread);
			},
			[this](CELLThread* pThread) {
				ClearClients();
			}
		);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
leaq 0x88(%rdi), %rax
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
xorl %r8d, %r8d
leaq -0x70(%rbp), %rdx
movq %r8, 0x8(%rdx)
movq %rdi, (%rdx)
leaq 0x1261(%rip), %rcx      # 0x693a
movq %rcx, 0x18(%rdx)
leaq 0x1266(%rip), %rcx      # 0x694a
movq %rcx, 0x10(%rdx)
leaq -0x50(%rbp), %rcx
movq %r8, 0x8(%rcx)
movq %rdi, (%rcx)
leaq 0x187a(%rip), %rdi      # 0x6f74
movq %rdi, 0x18(%rcx)
leaq 0x187d(%rip), %rdi      # 0x6f82
movq %rdi, 0x10(%rcx)
movq %rax, %rdi
callq 0x57c0
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x5728
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x60(%rbp), %rax
testq %rax, %rax
je 0x573f
leaq -0x70(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x20(%rbp), %rax
testq %rax, %rax
je 0x5756
leaq -0x30(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
jmp 0x57b7
jmp 0x57b7
jmp 0x57b7
movq %rax, %rbx
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x577d
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x60(%rbp), %rax
testq %rax, %rax
je 0x5794
leaq -0x70(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x20(%rbp), %rax
testq %rax, %rax
je 0x57ab
leaq -0x30(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x33f0
jmp 0x57b7
jmp 0x57b7
movq %rax, %rdi
callq 0x436e
nop
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./serverFile/./../share/CELLThread.hpp
// Function: CELLThread::Start(std::function<void (CELLThread*)>, std::function<void (CELLThread*)>, std::function<void (CELLThread*)>)
void Start(
		EventCall onCreate = nullptr,
		EventCall onRun = nullptr,
		EventCall onDestory = nullptr)
	{
		std::lock_guard<std::mutex> lock(_mutex);
		if (!_isRun)
		{
			_isRun = true;

			if (onCreate)
				_onCreate = onCreate;
			if (onRun)
				_onRun = onRun;
			if (onDestory)
				_onDestory = onDestory;

			//线程
			std::thread t(std::mem_fn(&CELLThread::OnWork), this);
			t.detach();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
leaq 0x60(%rdi), %rbx
movq %rbx, %rdi
callq 0x3380
testl %eax, %eax
jne 0x5889
cmpb $0x0, 0xe8(%r14)
jne 0x5872
movb $0x1, 0xe8(%r14)
cmpq $0x0, 0x10(%r13)
je 0x5815
movq %r14, %rdi
movq %r13, %rsi
callq 0x705a
cmpq $0x0, 0x10(%r12)
je 0x5829
leaq 0x20(%r14), %rdi
movq %r12, %rsi
callq 0x705a
cmpq $0x0, 0x10(%r15)
je 0x583c
leaq 0x40(%r14), %rdi
movq %r15, %rsi
callq 0x705a
leaq 0x188b(%rip), %rax      # 0x70ce
leaq -0x48(%rbp), %rsi
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
leaq -0x38(%rbp), %rdx
movq %r14, (%rdx)
leaq -0x30(%rbp), %rdi
callq 0x712c
leaq -0x30(%rbp), %rdi
callq 0x33e0
cmpq $0x0, -0x30(%rbp)
jne 0x5897
movq %rbx, %rdi
callq 0x3200
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x31c0
cmpq $0x0, -0x30(%rbp)
je 0x589e
callq 0x30b0
jmp 0x589e
movq %rax, %r14
movq %rbx, %rdi
callq 0x3200
movq %r14, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./serverFile/./CELLEpollServer.hpp
// Function: CELLEpollServer::DoNetEvents()
bool DoNetEvents() {
		int ret = _ep.wait(1);
		if(ret < 0) {
			strerror(errno); //print the reason of wrong
			Log::INFO("CELLEpollServer DoNetEvents error\n");
			return false;
		}
		else if(ret == 0) return true;
		else {
			auto events = _ep.events();
			for(int i = 0; i < ret; i ++) {
				CELLClient *pClient = (CELLClient*)events[i].data.ptr;
				if(pClient) {
					if(events[i].events & EPOLLIN) {
						if(SOCKET_ERROR == pClient->RecvData()) {
							rmClient(pClient);
							continue;
						}
						else { //接收消息成功, 接收计数++
							_pNetEvent->OnNetRecv(pClient);
						}	
					}
					if(events[i].events & EPOLLOUT) {
						if(SOCKET_ERROR == pClient->SendDataReal()) {
							rmClient(pClient);
							continue;
						}
						else { //修改当前描述符号为只读
							_ep.ctl(EPOLL_CTL_MOD, pClient, EPOLLIN);
						}	
					}
				} 
			}
		}				
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
addq $0x180, %rdi            # imm = 0x180
movq %rdi, -0x38(%rbp)
movl $0x1, %esi
callq 0x4a04
movl %eax, -0x2c(%rbp)
testl %eax, %eax
js 0x5a43
je 0x5a5b
movq 0x188(%r14), %r13
movl -0x2c(%rbp), %eax
shlq $0x2, %rax
leaq (%rax,%rax,2), %rbx
xorl %r15d, %r15d
movq 0x4(%r13,%r15), %r12
testq %r12, %r12
je 0x5a34
movl (%r13,%r15), %eax
testb $0x1, %al
je 0x59de
xorl %edi, %edi
callq 0x3260
addq $0xb4, %rax
movq %rax, 0x58(%r12)
leaq 0x10(%r12), %rdi
movl 0xc(%r12), %esi
callq 0x5e82
cmpl $-0x1, %eax
je 0x5a29
movq 0x40(%r14), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x18(%rax)
movl (%r13,%r15), %eax
testb $0x4, %al
je 0x5a34
movq $0x0, 0x40(%r12)
xorl %edi, %edi
callq 0x3260
addq $0xb4, %rax
movq %rax, 0x58(%r12)
leaq 0x28(%r12), %rdi
movl 0xc(%r12), %esi
callq 0x613a
cmpl $-0x1, %eax
je 0x5a29
movq -0x38(%rbp), %rdi
movl $0x3, %esi
movq %r12, %rdx
movl $0x1, %ecx
callq 0x5da8
jmp 0x5a34
movq %r14, %rdi
movq %r12, %rsi
callq 0x5de2
addq $0xc, %r15
cmpq %r15, %rbx
jne 0x598f
jmp 0x5a5b
callq 0x3040
movl (%rax), %edi
callq 0x3100
leaq 0x2986(%rip), %rdi      # 0x83dc
callq 0x3b4a
cmpl $0x0, -0x2c(%rbp)
setns %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./serverFile/./../share/CELLThread.hpp
// Function: CELLThread::Close()
void Close()
	{
		std::lock_guard<std::mutex> lock(_mutex);
		if (_isRun)
		{
			_isRun = false;
			//_sem.wait();
			m_sem.P();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x60(%rdi), %rbx
movq %rbx, %rdi
callq 0x3380
testl %eax, %eax
jne 0x5d8d
cmpb $0x1, 0xe8(%r14)
jne 0x5d81
movb $0x0, 0xe8(%r14)
addq $0x88, %r14
movq %r14, %rdi
callq 0x475c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3200
movl %eax, %edi
callq 0x31c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x3200
movq %r14, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./serverFile/./../share/CELLEpoll.hpp
// Function: CELLEpoll::ctl(int, CELLClient*, unsigned int)
int ctl(int op, CELLClient* pClient, uint32_t events) {
		epoll_event ev;
		ev.events = events;
		ev.data.ptr = pClient;
		if(epoll_ctl(_epfd, op, pClient->sockfd(), &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)
movq %rdx, 0x4(%rax)
movl (%rdi), %edi
movl 0xc(%rdx), %edx
movq %rax, %rcx
callq 0x3320
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
je 0x5dd6
addq $0x10, %rsp
popq %rbp
retq
callq 0x34d8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x5dd0
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./serverFile/./CELLServer.hpp
// Function: CELLServer::rmClient(CELLClient*)
void rmClient(CELLClient* pClient) {
		removeIO(pClient); //移除IO复用中的文件描述符
        auto iter = _clients.find(pClient->sockfd());
        if(iter != _clients.end()) {
			if(pClient) {
				if(pClient->sockfd() > 0) {
					close(pClient->sockfd()); //关闭文件描述符
				}
				if(pClient) {
					delete pClient;
				}
			}
			_clients.erase(iter);
        }
        if(_pNetEvent) {
            _pNetEvent->OnNetLeave(pClient);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x30(%rax)
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x5e5b
leaq 0x8(%r14), %r15
movl 0xc(%rbx), %edi
leaq 0x10(%r14), %rcx
movq %rcx, %r12
xorl %edx, %edx
cmpl %edi, 0x20(%rax)
setl %dl
cmovgeq %rax, %r12
movq 0x10(%rax,%rdx,8), %rax
testq %rax, %rax
jne 0x5e10
cmpq %rcx, %r12
je 0x5e5b
cmpl 0x20(%r12), %edi
jl 0x5e5b
testl %edi, %edi
jle 0x5e3b
callq 0x3440
movq %rbx, %rdi
callq 0x5ec0
movl $0x60, %esi
movq %rbx, %rdi
callq 0x32a0
movq %r15, %rdi
movq %r12, %rsi
callq 0x60f4
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x5e78
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./serverFile/./../share/./CELLBuffer.hpp
// Function: CELLBuffer::read4socket(int)
int read4socket(SOCKET sockfd)
	{
		if (_nSize - _nLast > 0)
		{
			//接收客户端数据
			char* szRecv = _pBuff + _nLast;
			int nLen = (int)recv(sockfd, szRecv, _nSize - _nLast, 0);
			if (nLen <= 0)
			{
				return SOCKET_ERROR;
			}
			//消息缓冲区的数据尾部位置后移
			_nLast += nLen;
			return nLen;
		}
		return 0;
	}

// Assembly:
movl 0xc(%rdi), %ecx
movslq 0x8(%rdi), %rax
subl %eax, %ecx
jle 0x5eb0
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq (%rdi), %rax
movl %ecx, %edx
movl %esi, %edi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x30f0
testl %eax, %eax
jle 0x5eb3
addl %eax, 0x8(%rbx)
jmp 0x5eb8
xorl %eax, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./serverFile/./../share/CELLClient.hpp
// Function: CELLClient::~CELLClient()
~CELLClient()
	{
		Log::INFO("s=%d CELLClient%d.~CELLClient\n", serverId, id);
		if (INVALID_SOCKET != _sockfd)
		{
			close(_sockfd);
			_sockfd = INVALID_SOCKET;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edx
movl 0x4(%rdi), %esi
leaq 0x252a(%rip), %rdi      # 0x83ff
callq 0x5f2a
movl 0xc(%rbx), %edi
cmpl $-0x1, %edi
je 0x5eee
callq 0x3440
movl $0xffffffff, 0xc(%rbx)  # imm = 0xFFFFFFFF
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x5f04
callq 0x3310
movq $0x0, 0x28(%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x5f1a
callq 0x3310
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x436e
nop
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./serverFile/./../share/./CELLBuffer.hpp
// Function: CELLBuffer::write2socket(int)
int write2socket(SOCKET sockfd)
	{
		int ret = 0;
		//缓冲区有数据
		if (_nLast > 0 && INVALID_SOCKET != sockfd)
		{
			//发送数据
			ret = send(sockfd, _pBuff, _nLast, 0);
			if (ret <= 0) {
				return SOCKET_ERROR;
			}
			if (ret == _nLast) {
				//数据尾部位置清零
				_nLast = 0;
			}
			else {
				_nLast -= ret;
				memcpy(_pBuff, _pBuff + ret, _nLast);
			}
			_fullCount = 0;
		}
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movslq 0x8(%rdi), %rdx
testq %rdx, %rdx
setle %al
cmpl $-0x1, %esi
sete %cl
xorl %r14d, %r14d
orb %al, %cl
jne 0x61ac
movq %rdi, %rbx
movq (%rdi), %rax
movl %esi, %edi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x3170
movq %rax, %r14
testl %r14d, %r14d
jle 0x6183
movl 0x8(%rbx), %eax
subl %r14d, %eax
jne 0x618b
movl $0x0, 0x8(%rbx)
jmp 0x61a5
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x61ac
movl %eax, 0x8(%rbx)
movq (%rbx), %rdi
movl %r14d, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
addq %rdi, %rsi
movslq %eax, %rdx
callq 0x3220
movl $0x0, 0x10(%rbx)
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./serverFile/./../share/CELLEpoll.hpp
// Function: CELLEpoll::del(CELLClient*)
int del(CELLClient* pClient) {
        if(epoll_ctl(_epfd, EPOLL_CTL_DEL, pClient->sockfd(), NULL) == EPOLL_ERROR) {
            perror("error, epoll_ctl");
			Log::ERROR("epoll_ctl : EPOLL_ERROR\n");
            return EPOLL_ERROR;
        }
		return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl (%rdi), %edi
movl 0xc(%rsi), %edx
xorl %ebx, %ebx
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x3320
cmpl $-0x1, %eax
je 0x67ab
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x34f6
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x67a2
nop
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./serverFile/./CELLServer.hpp
// Function: CELLServer::OnRun(CELLThread*)
void OnRun(CELLThread* pThread) {
		while (pThread->isRun()) {
			if (!_clientSocketBuff.empty()) {//从缓冲队列里取出客户数据
				std::lock_guard<std::mutex> lock(_mutex);
				for (auto cSock : _clientSocketBuff) {
					CELLClient *pClient = new CELLClient(cSock);
					_clients[cSock] = pClient;
					pClient->serverId = _id;

					if (_pNetEvent)
						_pNetEvent->OnNetJoin(_clients[cSock]);
					addClient2IO(_clients[cSock]);
				}
				_clientSocketBuff.clear();
			}
			//如果没有需要处理的客户端，就跳过
			if (_clients.empty()) {
				std::chrono::milliseconds t(1);
				std::this_thread::sleep_for(t);
				continue;
			}
			if (!DoNetEvents()) { //读写socket
				pThread->Exit();
				break;
			}
			DoMsg(); //处理时间，分包，组织响应消息
			processTimer(); //处理定时器心跳时间
		}
		Log::INFO("CELLServer%d.OnRun exit\n", _id);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq %rsi, -0x48(%rbp)
cmpb $0x1, 0xe8(%rsi)
jne 0x6ae4
leaq 0x60(%r14), %rbx
leaq 0x8(%r14), %r12
movq %rbx, -0x40(%rbp)
movq 0x48(%r14), %rax
cmpq 0x50(%r14), %rax
je 0x6a77
movq %rbx, %rdi
callq 0x3380
testl %eax, %eax
jne 0x6b03
movq 0x48(%r14), %r13
movq 0x50(%r14), %rax
movq %rax, -0x50(%rbp)
cmpq %rax, %r13
je 0x6a6b
movl (%r13), %ebx
movl %ebx, -0x38(%rbp)
movl $0x60, %edi
callq 0x3280
movq %rax, %r15
movq %rax, %rdi
movl %ebx, %esi
movl $0x1400, %edx           # imm = 0x1400
movl $0x1400, %ecx           # imm = 0x1400
callq 0x6b30
movq %r12, %rdi
leaq -0x38(%rbp), %rsi
callq 0x6bf8
movq %r15, (%rax)
movl 0x38(%r14), %eax
movl %eax, 0x4(%r15)
movq 0x40(%r14), %r15
testq %r15, %r15
je 0x6a37
movq %r12, %rdi
leaq -0x38(%rbp), %rsi
callq 0x6bf8
movq (%rax), %rsi
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
movq %r12, %rdi
leaq -0x38(%rbp), %rsi
callq 0x6bf8
movq (%rax), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
addq $0x4, %r13
cmpq -0x50(%rbp), %r13
jne 0x69d8
movq 0x48(%r14), %rax
cmpq %rax, 0x50(%r14)
je 0x6a6b
movq %rax, 0x50(%r14)
movq -0x40(%rbp), %rbx
movq %rbx, %rdi
callq 0x3200
cmpq $0x0, 0x30(%r14)
je 0x6a9d
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
testb %al, %al
je 0x6adb
movq %r14, %rdi
callq 0x6c60
movq %r14, %rdi
callq 0x6cd6
jmp 0x6ac8
movq $0x0, -0x38(%rbp)
movq $0xf4240, -0x30(%rbp)   # imm = 0xF4240
leaq -0x38(%rbp), %rdi
movq %rdi, %rsi
callq 0x30d0
cmpl $-0x1, %eax
jne 0x6ac8
callq 0x3040
cmpl $0x4, (%rax)
je 0x6aad
movq -0x48(%rbp), %rax
cmpb $0x0, 0xe8(%rax)
jne 0x69a5
jmp 0x6ae4
movq -0x48(%rbp), %rdi
callq 0x4a32
movl 0x38(%r14), %esi
leaq 0x19f2(%rip), %rdi      # 0x84e1
callq 0x459c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x31c0
movq %rax, %r14
movl $0x60, %esi
movq %r15, %rdi
callq 0x32a0
jmp 0x6b1f
movq %rax, %r14
movq -0x40(%rbp), %rdi
callq 0x3200
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./serverFile/./../share/CELLClient.hpp
// Function: CELLClient::CELLClient(int, int, int)
CELLClient(SOCKET sockfd = INVALID_SOCKET, int sendBuffSize = SEND_BUFF_SZIE, int recvBuffSize = RECV_BUFF_SZIE) :_recvBuff(recvBuffSize), _sendBuff(sendBuffSize)
	{
		static int n = 1;
		id = n++;
		_sockfd = sockfd;
		_expire = time(NULL) + TIMESLOT;
		resetDTSend();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movl %esi, %r14d
movq %rdi, %rbx
movq $-0x1, (%rdi)
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
xorl %r13d, %r13d
movl %r13d, 0x20(%rdi)
movl %ecx, 0x1c(%rdi)
movslq %ecx, %rdi
callq 0x3030
movq %rax, %r15
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movl %r13d, 0x38(%rbx)
movl %r12d, 0x34(%rbx)
movslq %r12d, %rdi
callq 0x3030
movq %rax, 0x28(%rbx)
movaps 0x1478(%rip), %xmm0     # 0x8010
movups %xmm0, 0x48(%rbx)
movl 0x5696(%rip), %eax      # 0xc238
leal 0x1(%rax), %ecx
movl %ecx, 0x568d(%rip)      # 0xc238
movl %eax, (%rbx)
movl %r14d, 0xc(%rbx)
xorl %edi, %edi
callq 0x3260
addq $0xb4, %rax
movq %rax, 0x58(%rbx)
movq $0x0, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x3310
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./serverFile/./CELLServer.hpp
// Function: CELLServer::DoMsg()
void DoMsg() { 
		for (auto iter : _clients) {
			auto pClient = iter.second;
			//接收客户端数据
			while (pClient->hasMsg()) {
				ProcessNetMsg(pClient, pClient->front_msg()); //处理网络消息
				pClient->pop_front_msg(); //移除消息队列（缓冲区）最前的一条数据
				_pNetEvent->OnNetMsg(pClient);//添加消息计数 
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x20(%rdi), %r14
leaq 0x10(%rdi), %r12
cmpq %r12, %r14
je 0x6ccd
movq %rdi, %rbx
movq 0x28(%r14), %r15
movl 0x18(%r15), %eax
cmpl $0x4, %eax
jb 0x6cbd
movq 0x10(%r15), %rdx
movzwl (%rdx), %ecx
cmpl %ecx, %eax
jl 0x6cbd
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x28(%rax)
movq %r15, %rdi
callq 0x6f30
movq 0x40(%rbx), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x10(%rax)
movl 0x18(%r15), %eax
cmpl $0x3, %eax
ja 0x6c88
movq %r14, %rdi
callq 0x31d0
movq %rax, %r14
cmpq %r12, %rax
jne 0x6c7b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pxzwxx[P]SynBS/./serverFile/./CELLServer.hpp
// Function: CELLServer::processTimer()
void processTimer() { //心跳检测
		time_t cur = time(NULL);
		for(auto &client : _clients) {
			auto pClient = client.second;
			if(cur >= pClient->_expire) {
				rmClient(pClient);
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
callq 0x3260
movq 0x20(%rbx), %r15
leaq 0x10(%rbx), %r12
cmpq %r12, %r15
je 0x6d1d
movq %rax, %r14
movq 0x28(%r15), %rsi
cmpq 0x58(%rsi), %r14
jl 0x6d0d
movq %rbx, %rdi
callq 0x5de2
movq %r15, %rdi
callq 0x31d0
movq %rax, %r15
cmpq %r12, %rax
jne 0x6cfb
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq