LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x118(%rcx), %eax
je 0x41b0
movq -0x20(%rbp), %rax
movl 0x118(%rax), %esi
leaq 0xb0d4(%rip), %rdi      # 0xf276
callq 0x6fc0
movq -0x20(%rbp), %rdi
callq 0x43c0
movl $0x2, %edi
movl $0x1, %esi
movl $0x6, %edx
callq 0x30c0
movq -0x20(%rbp), %rcx
movl %eax, 0x118(%rcx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x118(%rcx), %eax
jne 0x41e9
leaq 0xb0c1(%rip), %rdi      # 0xf2a3
callq 0x3e20
jmp 0x4253
movq -0x20(%rbp), %rax
movl $0x1, -0x14(%rbp)
movl 0x118(%rax), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x14(%rbp), %rcx
movl $0x4, %r8d
callq 0x34e0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x423d
movq -0x20(%rbp), %rax
movl 0x118(%rax), %esi
leaq 0xb094(%rip), %rdi      # 0xf2c3
callq 0x5310
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4260
movq -0x20(%rbp), %rax
movl 0x118(%rax), %esi
leaq 0xb09d(%rip), %rdi      # 0xf2eb
callq 0x6fc0
movq -0x20(%rbp), %rax
movl 0x118(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x24(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x31e0
movw $0x2, -0x24(%rbp)
movzwl -0x12(%rbp), %edi
callq 0x3060
movw %ax, -0x22(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x42c7
movq -0x10(%rbp), %rdi
callq 0x3330
movl %eax, -0x20(%rbp)
jmp 0x42ce
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rax
movl 0x118(%rax), %edi
leaq -0x24(%rbp), %rsi
movl $0x10, %edx
callq 0x3080
movl %eax, -0x28(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x28(%rbp), %eax
jne 0x4305
leaq 0xb01a(%rip), %rdi      # 0xf314
movzwl -0x12(%rbp), %esi
callq 0x71c0
jmp 0x4315
leaq 0xb028(%rip), %rdi      # 0xf334
movzwl -0x12(%rbp), %esi
callq 0x73c0
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x118(%rax), %edi
movl -0xc(%rbp), %esi
callq 0x33b0
movl %eax, -0x10(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x10(%rbp), %eax
jne 0x436a
movq -0x18(%rbp), %rax
movl 0x118(%rax), %esi
leaq 0xafeb(%rip), %rdi      # 0xf34e
callq 0x6fc0
jmp 0x4380
movq -0x18(%rbp), %rax
movl 0x118(%rax), %esi
leaq 0xaff7(%rip), %rdi      # 0xf372
callq 0x5310
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0xb14b(%rip), %rdi      # 0xf526
callq 0x3c20
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x88c0
movq -0x30(%rbp), %rax
cmpl $-0x1, 0x118(%rax)
je 0x449b
movq -0x30(%rbp), %rax
addq $0xf8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6560
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6590
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x65c0
testb $0x1, %al
jne 0x4439
jmp 0x446e
leaq -0x18(%rbp), %rdi
callq 0x6600
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x4461
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x4463
leaq -0x18(%rbp), %rdi
callq 0x6660
jmp 0x4426
movq -0x30(%rbp), %rdi
addq $0xf8, %rdi
callq 0xd890
movq -0x30(%rbp), %rax
movl 0x118(%rax), %edi
callq 0x3520
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x118(%rax) # imm = 0xFFFFFFFF
leaq 0xb09f(%rip), %rdi      # 0xf541
callq 0x3c20
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x4ba0
movq -0x10(%rbp), %rdi
leaq 0x1233c(%rip), %rax     # 0x16bd0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x4bc0
movq -0x10(%rbp), %rdi
addq $0xf8, %rdi
callq 0x4c70
xorl %eax, %eax
movl %eax, %edi
callq 0x3300
movq -0x10(%rbp), %rdi
movq %rax, 0x110(%rdi)
movb $0x1, 0x11c(%rdi)
movb $0x1, 0x11d(%rdi)
movb $0x1, 0x11e(%rdi)
movl $0xffffffff, 0x118(%rdi) # imm = 0xFFFFFFFF
addq $0x124, %rdi            # imm = 0x124
xorl %esi, %esi
callq 0x4c90
movq -0x10(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
movl $0x1, %esi
callq 0x4c90
movq -0x10(%rbp), %rdi
addq $0x12c, %rdi            # imm = 0x12C
xorl %esi, %esi
callq 0x4c90
movq -0x10(%rbp), %rax
movl $0x0, 0x120(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x5c40
movq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x5c70
jmp 0x4a75
movq -0x50(%rbp), %rdi
callq 0x5da0
movl %eax, -0x54(%rbp)
jmp 0x4a83
movl -0x54(%rbp), %edx
leaq -0x20(%rbp), %rdi
movl $0x1, %ecx
movl %ecx, %esi
callq 0x5d30
jmp 0x4a98
jmp 0x4a9a
movq -0x10(%rbp), %rdi
callq 0x5dc0
movb %al, -0x55(%rbp)
jmp 0x4aa8
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0x4ab4
jmp 0x4b83
movq -0x50(%rbp), %rdi
callq 0x5de0
jmp 0x4abf
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x5f50
movl %eax, -0x5c(%rbp)
jmp 0x4ad2
movl -0x5c(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jge 0x4b13
leaq 0xa676(%rip), %rdi      # 0xf15b
callq 0x3c20
jmp 0x4aec
movq -0x10(%rbp), %rdi
callq 0x5fb0
jmp 0x4af7
jmp 0x4b83
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x60a0
jmp 0x4b92
leaq -0x20(%rbp), %rdi
callq 0x6000
movq %rax, -0x68(%rbp)
jmp 0x4b22
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x4b7e
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rax
movslq -0x3c(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, -0x70(%rbp)
callq 0x5da0
movl %eax, -0x6c(%rbp)
jmp 0x4b5a
movl -0x70(%rbp), %eax
movl -0x6c(%rbp), %ecx
cmpl %ecx, %eax
jne 0x4b71
movq -0x50(%rbp), %rdi
callq 0x6020
jmp 0x4b6f
jmp 0x4b71
jmp 0x4b73
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x4b31
jmp 0x4a9a
leaq -0x20(%rbp), %rdi
callq 0x60a0
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x34c0
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, (%rax)
jle 0x5c95
movq -0x20(%rbp), %rdi
callq 0x60d0
movl -0x14(%rbp), %edi
callq 0x3510
movq -0x20(%rbp), %rcx
movl %eax, (%rcx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl (%rcx), %eax
jne 0x5ccd
leaq 0x94ca(%rip), %rdi      # 0xf17d
callq 0x32c0
leaq 0x94cc(%rip), %rdi      # 0xf18b
callq 0x3e20
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5d19
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x5d08
movslq -0x14(%rbp), %rax
movl $0xc, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, -0x28(%rbp)
movl -0x18(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movl (%rax), %edi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
leaq -0x28(%rbp), %rcx
callq 0x3410
cmpl $-0x1, %eax
jne 0x5d8c
leaq 0x9436(%rip), %rdi      # 0xf1a8
callq 0x32c0
leaq 0x943b(%rip), %rdi      # 0xf1b9
callq 0x3e20
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5d93
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x3300
movq -0x20(%rbp), %rcx
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
subq 0x110(%rcx), %rax
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jl 0x5f3e
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x110(%rdi)
addq $0xf8, %rdi
callq 0x6370
movq -0x20(%rbp), %rdi
movl %eax, -0x48(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movl 0x118(%rdi), %eax
movl %eax, -0x40(%rbp)
addq $0x12c, %rdi            # imm = 0x12C
callq 0x6390
movq -0x20(%rbp), %rdi
movl %eax, -0x3c(%rbp)
addq $0x124, %rdi            # imm = 0x124
callq 0x6390
movq -0x20(%rbp), %rdi
movl %eax, -0x38(%rbp)
addq $0x128, %rdi            # imm = 0x128
callq 0x6390
movl -0x48(%rbp), %esi
movl -0x44(%rbp), %edx
movl -0x40(%rbp), %ecx
movl -0x3c(%rbp), %r8d
movl -0x38(%rbp), %r9d
leaq 0x933a(%rip), %rdi      # 0xf1d2
movl %eax, (%rsp)
callq 0x6140
movq -0x20(%rbp), %rdi
addq $0xf8, %rdi
callq 0x6370
movq -0x20(%rbp), %rdi
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
movl 0x118(%rdi), %eax
movl %eax, -0x2c(%rbp)
addq $0x12c, %rdi            # imm = 0x12C
callq 0x6390
movq -0x20(%rbp), %rdi
movl %eax, -0x28(%rbp)
addq $0x124, %rdi            # imm = 0x124
callq 0x6390
movq -0x20(%rbp), %rdi
movl %eax, -0x24(%rbp)
addq $0x128, %rdi            # imm = 0x128
callq 0x6390
movl -0x34(%rbp), %esi
movl -0x30(%rbp), %edx
movl -0x2c(%rbp), %ecx
movl -0x28(%rbp), %r8d
movl -0x24(%rbp), %r9d
leaq 0x92c2(%rip), %rdi      # 0xf1d2
movl %eax, (%rsp)
movb $0x0, %al
callq 0x3050
movq -0x20(%rbp), %rdi
addq $0x124, %rdi            # imm = 0x124
xorl %esi, %esi
callq 0x4c90
movq -0x20(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
xorl %esi, %esi
callq 0x4c90
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq 0x8(%rax), %rsi
movl 0x4(%rax), %edx
movl -0x14(%rbp), %ecx
callq 0x31a0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x5f9d
leaq 0x928b(%rip), %rdi      # 0xf20f
callq 0x32c0
leaq 0x9291(%rip), %rdi      # 0xf221
callq 0x3e20
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5fa3
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x31e0
movq -0x28(%rbp), %rax
movl $0x10, -0x1c(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl 0x118(%rax), %edi
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x3100
movl %eax, -0x20(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x20(%rbp), %eax
jne 0x6084
leaq 0x91be(%rip), %rdi      # 0xf23b
callq 0x3c20
jmp 0x6090
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x6470
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, (%rax)
jle 0x60fe
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x3520
movq -0x10(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6130
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x6124
movq -0x18(%rbp), %rdi
callq 0x3400
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0xf8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6540
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x18(%rbp)
addq $0xf8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6560
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6590
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x65c0
testb $0x1, %al
jne 0x64dc
jmp 0x6523
leaq -0x28(%rbp), %rdi
callq 0x6600
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6620
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
callq 0x6620
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jbe 0x6516
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x6518
leaq -0x28(%rbp), %rdi
callq 0x6660
jmp 0x64c9
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x6680
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x76b0
movl $0x198, %edi            # imm = 0x198
callq 0x3320
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
callq 0x77a0
jmp 0x760e
movq -0xa8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
addl $0x1, %esi
callq 0x7800
movq -0xa0(%rbp), %rax
movq -0x18(%rbp), %rdi
movl 0x120(%rax), %eax
cltd
idivl -0xc(%rbp)
movl %eax, %esi
addl $0x1, %esi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0xa0(%rbp), %rdi
addq $0xf8, %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x7820
movq -0xa0(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x7850
movq -0x18(%rbp), %rdi
callq 0x7870
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x75e4
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x198, %esi            # imm = 0x198
callq 0x3340
jmp 0x778a
movq -0xa0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xc8(%rbp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0xd0(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x7af0
movq -0xa0(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
leaq -0x78(%rbp), %rsi
callq 0x7b30
movq -0xd0(%rbp), %rsi
leaq -0x98(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x7af0
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
movq -0xb0(%rbp), %rcx
callq 0x7970
jmp 0x7739
leaq -0x98(%rbp), %rdi
callq 0x4e30
leaq -0x70(%rbp), %rdi
callq 0x4e30
leaq -0x50(%rbp), %rdi
callq 0x4e30
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x4e30
leaq -0x70(%rbp), %rdi
callq 0x4e30
leaq -0x50(%rbp), %rdi
callq 0x4e30
movq -0x20(%rbp), %rdi
callq 0x34c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
addq $0x88, %rax
movq %rax, -0xa8(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x7af0
movq -0xb0(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x98(%rbp)
leaq -0x50(%rbp), %rsi
callq 0xa350
movq -0xb0(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x90(%rbp)
leaq -0x78(%rbp), %rsi
callq 0xa3e0
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
movq -0x90(%rbp), %rcx
callq 0x7970
jmp 0x790c
leaq -0x70(%rbp), %rdi
callq 0x4e30
leaq -0x48(%rbp), %rdi
callq 0x4e30
leaq -0x28(%rbp), %rdi
callq 0x4e30
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4e30
leaq -0x48(%rbp), %rdi
callq 0x4e30
leaq -0x28(%rbp), %rdi
callq 0x4e30
movq -0x80(%rbp), %rdi
callq 0x34c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rsi, -0x88(%rbp)
movq %rdx, -0x80(%rbp)
movq %rcx, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x70(%rbp)
addq $0x60, %rsi
leaq -0x28(%rbp), %rdi
callq 0x6410
movq -0x70(%rbp), %rax
testb $0x1, 0xe8(%rax)
jne 0x7abd
movq -0x88(%rbp), %rdi
movq -0x70(%rbp), %rax
movb $0x1, 0xe8(%rax)
callq 0xc7c0
testb $0x1, %al
jne 0x79dd
jmp 0x7a02
movq -0x88(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0xc7f0
jmp 0x79ef
jmp 0x7a02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x7acf
movq -0x80(%rbp), %rdi
callq 0xc7c0
testb $0x1, %al
jne 0x7a11
jmp 0x7a26
movq -0x80(%rbp), %rsi
movq -0x70(%rbp), %rdi
addq $0x20, %rdi
callq 0xc7f0
jmp 0x7a24
jmp 0x7a26
movq -0x78(%rbp), %rdi
callq 0xc7c0
testb $0x1, %al
jne 0x7a35
jmp 0x7a4a
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdi
addq $0x40, %rdi
callq 0xc7f0
jmp 0x7a48
jmp 0x7a4a
leaq 0x4e3f(%rip), %rax      # 0xc890
movq %rax, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xc840
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0xc920
jmp 0x7a90
leaq -0x40(%rbp), %rdi
callq 0x34b0
jmp 0x7a9b
leaq -0x40(%rbp), %rdi
callq 0xc9e0
jmp 0x7abd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xc9e0
jmp 0x7acf
leaq -0x28(%rbp), %rdi
callq 0x6440
addq $0x90, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x6440
movq -0x30(%rbp), %rdi
callq 0x34c0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x180, %rdi            # imm = 0x180
movl $0x1, %esi
callq 0x5f50
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x7d9f
callq 0x3040
movl (%rax), %edi
callq 0x3120
leaq 0x7677(%rip), %rdi      # 0xf408
callq 0x3c20
movb $0x0, -0x1(%rbp)
jmp 0x7ebd
cmpl $0x0, -0x14(%rbp)
jne 0x7dae
movb $0x1, -0x1(%rbp)
jmp 0x7ebd
movq -0x38(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
callq 0x6000
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x7eb5
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq 0x4(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x7ea5
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x7e47
movq -0x30(%rbp), %rdi
callq 0x89d0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x7e33
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x8a20
jmp 0x7ea7
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x30(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x7e47
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x7ea3
movq -0x30(%rbp), %rdi
callq 0x8b30
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x7e83
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x8a20
jmp 0x7ea7
movq -0x38(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
movq -0x30(%rbp), %rdx
movl $0x3, %esi
movl $0x1, %ecx
callq 0x8940
jmp 0x7ea3
jmp 0x7ea5
jmp 0x7ea7
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7dc9
jmp 0x7eb7
jmp 0x7eb9
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x28(%rbp)
addq $0x60, %rsi
leaq -0x10(%rbp), %rdi
callq 0x6410
movq -0x28(%rbp), %rax
testb $0x1, 0xe8(%rax)
je 0x8920
movq -0x28(%rbp), %rdi
movb $0x0, 0xe8(%rdi)
addq $0x88, %rdi
callq 0x5530
jmp 0x8907
jmp 0x8920
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x6440
jmp 0x892f
leaq -0x10(%rbp), %rdi
callq 0x6440
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x34c0
nopl (%rax,%rax)
// File: 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 $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x2c(%rbp)
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5510
movl -0x38(%rbp), %edi
movl -0x34(%rbp), %esi
movl %eax, %edx
leaq -0x30(%rbp), %rcx
callq 0x3410
cmpl $-0x1, %eax
jne 0x89b3
leaq 0x680f(%rip), %rdi      # 0xf1a8
callq 0x32c0
leaq 0x6814(%rip), %rdi      # 0xf1b9
callq 0x3e20
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x89ba
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x30(%rax)
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5510
movq -0x48(%rbp), %rdi
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x8c10
movq -0x40(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x8, %rdi
callq 0x8c70
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8c40
testb $0x1, %al
jne 0x8a8f
jmp 0x8b01
cmpq $0x0, -0x10(%rbp)
je 0x8ae4
movq -0x10(%rbp), %rdi
callq 0x5510
cmpl $0x0, %eax
jle 0x8ab4
movq -0x10(%rbp), %rdi
callq 0x5510
movl %eax, %edi
callq 0x3520
cmpq $0x0, -0x10(%rbp)
je 0x8ae2
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x8ae0
movq -0x50(%rbp), %rdi
callq 0x8ca0
movq -0x50(%rbp), %rdi
movl $0x60, %esi
callq 0x3340
jmp 0x8ae2
jmp 0x8ae4
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x8d20
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x8b1e
movq -0x40(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movl 0xc(%rcx), %eax
subl 0x8(%rcx), %eax
cmpl $0x0, %eax
jle 0x8bf2
movq -0x30(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rdx
addq %rdx, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
movl 0xc(%rcx), %eax
subl 0x8(%rcx), %eax
movslq %eax, %rdx
xorl %ecx, %ecx
callq 0x3110
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jg 0x8bdd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8bf9
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8bf9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl (%rax), %edx
movl 0x4(%rax), %esi
leaq 0x676b(%rip), %rdi      # 0xf42b
callq 0x9030
jmp 0x8cc7
movq -0x10(%rbp), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0xc(%rcx), %eax
je 0x8cee
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x3520
jmp 0x8ce3
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x9230
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x9230
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x4ef0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x0, 0x8(%rax)
jle 0x942e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x14(%rbp), %eax
je 0x942e
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %edi
movq (%rax), %rsi
movslq 0x8(%rax), %rdx
xorl %ecx, %ecx
callq 0x31c0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jg 0x93e5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9434
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x8(%rcx), %eax
jne 0x93fe
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x9423
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %edx
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
movq (%rax), %rdi
movq (%rax), %rsi
movslq -0x18(%rbp), %rcx
addq %rcx, %rsi
movslq 0x8(%rax), %rdx
callq 0x32b0
movq -0x20(%rbp), %rax
movl $0x0, 0x10(%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: pxzwxx[P]SynBS/./serverFile/./../share/./CELLBuffer.hpp
// Function: CELLBuffer::push(char const*, int)
bool push(const char* pData, int nLen)
	{
		if (_nLast + nLen <= _nSize)
		{
			//将要发送的数据 拷贝到发送缓冲区尾部
			memcpy(_pBuff + _nLast, pData, nLen);
			//计算数据尾部位置
			_nLast += nLen;

			if (_nLast == SEND_BUFF_SZIE)
			{
				++_fullCount;
			}

			return true;
		}
		else {
			++_fullCount;
		}

		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl 0x8(%rcx), %eax
addl -0x1c(%rbp), %eax
cmpl 0xc(%rcx), %eax
jg 0x9bba
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movslq 0x8(%rax), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x32b0
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
cmpl $0x1400, 0x8(%rax)      # imm = 0x1400
jne 0x9bb4
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x9bcb
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5510
movl -0x1c(%rbp), %edi
movl %eax, %edx
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x3410
cmpl $-0x1, %eax
jne 0x9c3b
leaq 0x5587(%rip), %rdi      # 0xf1a8
callq 0x32c0
leaq 0x558c(%rip), %rdi      # 0xf1b9
callq 0x3e20
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9c42
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
movl $0xffffffff, 0x4(%rdi)  # imm = 0xFFFFFFFF
addq $0x10, %rdi
movq %rdi, -0x38(%rbp)
movl -0x14(%rbp), %esi
callq 0xae70
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movl -0x10(%rbp), %esi
callq 0xae70
jmp 0xa9ac
movq -0x30(%rbp), %rax
movl $0x0, 0x48(%rax)
movl $0x1, 0x4c(%rax)
movl $0x1, 0x50(%rax)
movl $0x0, 0x54(%rax)
movl 0xc8de(%rip), %ecx      # 0x172b0
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0xc8d3(%rip)      # 0x172b0
movl %ecx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0xc(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x3300
movq -0x30(%rbp), %rdi
addq $0xb4, %rax
movq %rax, 0x58(%rdi)
callq 0x9370
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9230
movq -0x20(%rbp), %rdi
callq 0x34c0
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbfd0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8c70
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8c40
testb $0x1, %al
jne 0xac69
jmp 0xace7
leaq -0x18(%rbp), %rdi
callq 0xaf20
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xc000
testb $0x1, %al
jne 0xac98
jmp 0xacd7
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
callq 0xc030
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
movq %rax, %rdx
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x38(%rbp), %rdi
callq 0xc050
movq -0x40(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x38(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0xac89
jmp 0xacd9
leaq -0x18(%rbp), %rdi
callq 0x92d0
jmp 0xac56
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x3300
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x10(%rbp)
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbfd0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8c70
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8c40
testb $0x1, %al
jne 0xad4d
jmp 0xad8e
leaq -0x20(%rbp), %rdi
callq 0xaf20
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
cmpq 0x58(%rcx), %rax
jl 0xad81
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x8a20
jmp 0xad83
leaq -0x20(%rbp), %rdi
callq 0x92d0
jmp 0xad3a
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: pxzwxx[P]SynBS/./serverFile/./../share/./CELLBuffer.hpp
// Function: CELLBuffer::hasMsg()
bool hasMsg()
	{
		//判断消息缓冲区的数据长度大于消息头netmsg_DataHeader长度
		if (_nLast >= sizeof(netmsg_DataHeader))
		{
			//这时就可以知道当前消息的长度
			netmsg_DataHeader* header = (netmsg_DataHeader*)_pBuff;
			//判断消息缓冲区的数据长度大于消息长度
			return _nLast >= header->dataLength;
		}
		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movslq 0x8(%rax), %rax
cmpq $0x4, %rax
jb 0xc0db
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x18(%rbp)
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
setge %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xc0df
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pxzwxx[P]SynBS/./serverFile/./../share/./CELLBuffer.hpp
// Function: CELLBuffer::pop(int)
void pop(int nLen)
	{
		int n = _nLast - nLen;
		if (n > 0)
		{
			memcpy(_pBuff, _pBuff + nLen, n);
		}
		_nLast = n;
		if (_fullCount > 0)
			--_fullCount;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x8(%rax), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0xc150
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq (%rax), %rsi
movslq -0xc(%rbp), %rax
addq %rax, %rsi
movslq -0x10(%rbp), %rdx
callq 0x32b0
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, 0x8(%rax)
cmpl $0x0, 0x10(%rax)
jle 0xc16d
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: pxzwxx[P]SynBS/./serverFile/./CELLServer.hpp
// Function: CELLServer::ClearClients()
void ClearClients() {
		for (auto iter : _clients) {
			delete iter.second;
		}
		_clients.clear();
		_clientSocketBuff.clear();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbfd0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8c70
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8c40
testb $0x1, %al
jne 0xc559
jmp 0xc5a3
leaq -0x18(%rbp), %rdi
callq 0xaf20
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xc596
movq -0x40(%rbp), %rdi
callq 0x8ca0
movq -0x40(%rbp), %rdi
movl $0x60, %esi
callq 0x3340
jmp 0xc598
leaq -0x18(%rbp), %rdi
callq 0x92d0
jmp 0xc546
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0xc5d0
movq -0x38(%rbp), %rdi
addq $0x48, %rdi
callq 0xab30
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: pxzwxx[P]SynBS/./serverFile/./../share/CELLThread.hpp
// Function: CELLThread::OnWork()
void OnWork()
	{
		if (_onCreate)
			_onCreate(this);
		if (_onRun)
			_onRun(this);
		if (_onDestory)
			_onDestory(this);

		//_sem.wakeup();
		m_sem.V();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xc7c0
testb $0x1, %al
jne 0xc8af
jmp 0xc8bb
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
callq 0xcca0
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0xc7c0
testb $0x1, %al
jne 0xc8ce
jmp 0xc8de
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0x20, %rdi
callq 0xcca0
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0xc7c0
testb $0x1, %al
jne 0xc8f1
jmp 0xc901
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0x40, %rdi
callq 0xcca0
movq -0x10(%rbp), %rdi
addq $0x88, %rdi
callq 0x5610
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: pxzwxx[P]SynBS/./share/log.cpp
// Function: Log::GetLogInstance()
Log* Log::GetLogInstance() {
    if(m_log == NULL) {
        std::unique_lock<std::mutex> ulock(m_mutex);
        if(m_log == NULL) {
            m_log = new Log;
            if(m_log == NULL) return NULL;
        }
    }
    return m_log;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
cmpq $0x0, 0x9728(%rip)      # 0x172f8
jne 0xdc85
leaq -0x18(%rbp), %rdi
leaq 0x96ef(%rip), %rsi      # 0x172d0
callq 0x5660
cmpq $0x0, 0x970a(%rip)      # 0x172f8
jne 0xdc5d
movl $0xa0, %edi
callq 0x3320
movq %rax, -0x30(%rbp)
jmp 0xdc00
movq -0x30(%rbp), %rdi
callq 0xe040
jmp 0xdc0b
movq -0x30(%rbp), %rax
movq %rax, 0x96e2(%rip)      # 0x172f8
cmpq $0x0, 0x96da(%rip)      # 0x172f8
jne 0xdc5b
movq $0x0, -0x8(%rbp)
movl $0x1, -0x28(%rbp)
jmp 0xdc64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xdc7a
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0xa0, %esi
callq 0x3340
jmp 0xdc7a
jmp 0xdc5d
movl $0x0, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x56a0
movl -0x28(%rbp), %eax
testl %eax, %eax
je 0xdc78
jmp 0xdc76
jmp 0xdc90
jmp 0xdc85
leaq -0x18(%rbp), %rdi
callq 0x56a0
jmp 0xdc9a
movq 0x966c(%rip), %rax      # 0x172f8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34c0
nopw %cs:(%rax,%rax)
// File: pxzwxx[P]SynBS/./share/log.cpp
// Function: Log::async_write_log()
void Log::async_write_log() {
    while(isRun) {
        m_fullBuff.P();
        m_mutex.lock();
        auto item = m_list.front();
        m_list.pop_front();

        fputs(item.c_str(), m_fp);
        fflush(m_fp);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
testb $0x1, 0x98(%rax)
je 0xdd81
leaq 0x9624(%rip), %rdi      # 0x17300
callq 0x5530
leaq 0x95e8(%rip), %rdi      # 0x172d0
callq 0x5580
leaq 0x96cc(%rip), %rdi      # 0x173c0
movq %rdi, -0x50(%rbp)
callq 0xe080
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3170
movq -0x50(%rbp), %rdi
callq 0xe0b0
movq -0x48(%rbp), %rdi
callq 0x3160
movq %rax, %rdi
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x33a0
jmp 0xdd31
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x33d0
jmp 0xdd40
leaq 0x9589(%rip), %rdi      # 0x172d0
callq 0x55f0
jmp 0xdd4e
leaq 0x960b(%rip), %rdi      # 0x17360
callq 0x5610
jmp 0xdd5c
leaq -0x28(%rbp), %rdi
callq 0x3220
jmp 0xdcc4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3220
jmp 0xdd87
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34c0