LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/examples/echo/server.cpp
// Function: main
int main(){
	acceptor a;

	if(!a.bind("localhost", 1234)){
		std::cout << "bind port failed!" << std::endl;
		return -1;
	}

	if(!a.listen()){
		std::cout << "listen failed!" << std::endl;
		return -2;
	}

	a.accept([](int ec, std::shared_ptr<socket> sock){
		std::cout << "accept a connection" << std::endl;
		sock->async_read(buff, 2048, std::bind(handle_read, std::placeholders::_1,
		std::placeholders::_2, sock));
	});

	char c;
	std::cin >> c;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
leaq -0x88(%rbp), %rdi
callq 0x3c7c
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x5947(%rip), %rsi      # 0x902f
leaq 0x5949(%rip), %rdx      # 0x9038
leaq -0x30(%rbp), %rdi
callq 0x3bdc
leaq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x4d2, %edx            # imm = 0x4D2
callq 0x3d6a
movl %eax, %ebx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x371d
callq 0x31e0
testb %bl, %bl
je 0x378f
leaq -0x88(%rbp), %rdi
callq 0x3de8
testb %al, %al
je 0x37dc
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rsi
movaps %xmm0, (%rsi)
leaq 0x150(%rip), %rax       # 0x3896
movq %rax, 0x18(%rsi)
leaq 0x293(%rip), %rax       # 0x39e4
movq %rax, 0x10(%rsi)
leaq -0x88(%rbp), %rdi
callq 0x3d4c
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x3778
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0xb859(%rip), %rdi      # 0xefd8
leaq -0x30(%rbp), %rsi
callq 0x3240
xorl %ebx, %ebx
jmp 0x3827
movq 0xb832(%rip), %rbx      # 0xefc8
leaq 0x589c(%rip), %rsi      # 0x9039
movl $0x11, %edx
movq %rbx, %rdi
callq 0x3230
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq 0xb800(%rip), %rdi      # 0xefc8
callq 0x3030
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %rax, %rdi
callq 0x3150
jmp 0x3827
movq 0xb7e5(%rip), %rbx      # 0xefc8
leaq 0x5861(%rip), %rsi      # 0x904b
movl $0xe, %edx
movq %rbx, %rdi
callq 0x3230
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq 0xb7b3(%rip), %rdi      # 0xefc8
callq 0x3030
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
movq %rax, %rdi
callq 0x3150
leaq -0x88(%rbp), %rdi
callq 0x3cf0
movl %ebx, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3861
jmp 0x387e
movq %rax, %rbx
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x3881
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x3881
movq %rax, %rdi
callq 0x3a01
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x3881
callq 0x31e0
jmp 0x3881
jmp 0x387e
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x3cf0
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/acceptor.cpp
// Function: acceptor::bind(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned short)
bool acceptor::bind(const std::string &ip, unsigned short port){
	struct hostent *hostent = gethostbyname(ip.c_str());
	if(nullptr == hostent){
		return false;
	}
	struct sockaddr_in local;
	bzero(&local, sizeof(struct sockaddr_in));
	local.sin_family = AF_INET;
	local.sin_port = htons(port);
	local.sin_addr = *(reinterpret_cast<struct in_addr*>(hostent->h_addr));
	return -1 != ::bind(sock, reinterpret_cast<struct sockaddr *>(&local), sizeof(local));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x3220
testq %rax, %rax
je 0x3dd8
movq %rax, %r15
leaq -0x30(%rbp), %r12
movl $0x10, %esi
movq %r12, %rdi
callq 0x3320
movw $0x2, (%r12)
rolw $0x8, %r14w
movw %r14w, 0x2(%r12)
movq 0x18(%r15), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, 0x4(%r12)
movl 0x8(%rbx), %edi
movq %r12, %rsi
movl $0x10, %edx
callq 0x3060
cmpl $-0x1, %eax
setne %al
jmp 0x3dda
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/./include/net/singleton.h
// Function: singleton<scheduler>::instance()
static singleton &instance(){
			if(nullptr == _instance){
				static std::mutex mutex;
				std::lock_guard<std::mutex> locker(mutex);
				if(nullptr == _instance){
					_instance = std::shared_ptr<singleton>(new singleton);
				}
			}
			return *_instance;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0xb77c(%rip), %rax      # 0xfa08
testq %rax, %rax
jne 0x42be
leaq 0xb788(%rip), %rdi      # 0xfa20
callq 0x32a0
testl %eax, %eax
jne 0x431f
cmpq $0x0, 0xb75f(%rip)      # 0xfa08
je 0x42c7
leaq 0xb76e(%rip), %rdi      # 0xfa20
callq 0x3180
movq 0xb74a(%rip), %rax      # 0xfa08
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x18, %edi
callq 0x3200
movq %rax, %rbx
movq %rax, %rdi
callq 0x4a14
leaq -0x18(%rbp), %rdi
movq %rbx, -0x8(%rdi)
movq %rbx, %rsi
callq 0x450c
movaps -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x20(%rbp)
movq 0xb712(%rip), %rdi      # 0xfa10
movups %xmm0, 0xb703(%rip)     # 0xfa08
testq %rdi, %rdi
je 0x42ab
callq 0x3a10
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x42ab
callq 0x3a10
jmp 0x42ab
movl %eax, %edi
callq 0x3140
movq %rax, %r14
movq %rbx, %rdi
callq 0x31e0
jmp 0x4336
movq %rax, %r14
leaq 0xb6e3(%rip), %rdi      # 0xfa20
callq 0x3180
movq %r14, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/scheduler.cpp
// Function: scheduler::arrange(std::function<void ()>)
bool scheduler::arrange(std::function<void()> proc){
	for(auto i = 0; i != workers.size(); ++i){
		if(workers[i]->task_once(proc)){
			workers[i]->active();
			return true;
		}
	}

	if(workers.size() < 60000){
		std::shared_ptr<worker> w(new worker());
		w->task_once(proc);
		w->active();
		workers.push_back(w);
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x4ac4
xorl %r13d, %r13d
leaq -0x80(%rbp), %r15
xorl %r14d, %r14d
movq (%rax,%r13), %r12
movq %r15, %rdi
movq -0x30(%rbp), %rsi
callq 0x4c2a
movq %r12, %rdi
movq %r15, %rsi
callq 0x8158
movl %eax, %r12d
movq -0x70(%rbp), %rax
testq %rax, %rax
je 0x4a91
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
testb %r12b, %r12b
jne 0x4b47
incq %r14
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
movq %rcx, %rdx
sarq $0x4, %rdx
addq $0x10, %r13
cmpq %rdx, %r14
jne 0x4a5d
cmpq $0xea5ff, %rcx          # imm = 0xEA5FF
ja 0x4b64
movl $0x88, %edi
callq 0x3200
movq %rax, %r15
movq %rax, %rdi
callq 0x7ea8
leaq -0x38(%rbp), %r12
movq %r15, -0x8(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x4cde
movq -0x8(%r12), %r15
leaq -0x60(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4c2a
leaq -0x60(%rbp), %rsi
movq %r15, %rdi
callq 0x8158
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x4b22
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x40(%rbp), %rdi
callq 0x819c
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x4c90
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x4b53
callq 0x3a10
jmp 0x4b53
movq (%rbx), %rax
movq (%rax,%r13), %rdi
callq 0x819c
movb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x4b55
jmp 0x4bcc
movq %rax, %rbx
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x4b98
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x4b98
jmp 0x4bcc
movq %rax, %rbx
movq %r15, %rdi
callq 0x31e0
jmp 0x4bc4
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x4bc4
callq 0x3a10
jmp 0x4bc4
jmp 0x4bcc
movq %rax, %rbx
movq -0x70(%rbp), %rax
testq %rax, %rax
je 0x4bc4
leaq -0x80(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x3330
movq %rax, %rdi
callq 0x3a01
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/socket.cpp
// Function: socket::job(bool)
void socket::job(bool is_read){
	std::mutex *mutex = nullptr;
	std::list<std::function<void()>> *requests = nullptr;

	switch(connect_status){
		case CONNECTING:
			mutex = &conn_mutex;
			requests = &conn_request;
			break;
		case CONNECTED:
			if(is_read){
				mutex = &rd_mutex;
				requests = &rd_request;
			}
			else{
				mutex = &wr_mutex;
				requests = &wr_request;
			}
			break;
		default:
			return;
	}

	std::function<void()> callback;
	{
		std::lock_guard<std::mutex> locker(*mutex);
		if(requests->empty()){
			return;
		}
		callback = requests->front();
		requests->pop_front();
		if(nullptr == callback)
			return;
	}
	callback();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x1f4(%rdi), %eax
cmpl $0x1, %eax
je 0x51ff
cmpl $0x2, %eax
jne 0x5288
testb %sil, %sil
movl $0x120, %eax            # imm = 0x120
movl $0x148, %r14d           # imm = 0x148
cmovneq %rax, %r14
movl $0x198, %eax            # imm = 0x198
movl $0x1b0, %r15d           # imm = 0x1B0
cmovneq %rax, %r15
jmp 0x520b
movl $0x1c8, %r15d           # imm = 0x1C8
movl $0x170, %r14d           # imm = 0x170
addq %rbx, %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movq %r14, %rdi
callq 0x32a0
testl %eax, %eax
jne 0x5293
addq %r15, %rbx
movq (%rbx), %rsi
cmpq %rbx, %rsi
je 0x5269
addq $0x10, %rsi
leaq -0x40(%rbp), %rdi
callq 0x6bf4
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x7b06
movq -0x30(%rbp), %rbx
movq %r14, %rdi
callq 0x3180
testq %rbx, %rbx
je 0x5271
cmpq $0x0, -0x30(%rbp)
je 0x529a
leaq -0x40(%rbp), %rdi
callq *0x18(%rdi)
jmp 0x5271
movq %r14, %rdi
callq 0x3180
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x5288
leaq -0x40(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x3140
callq 0x30e0
jmp 0x52d2
movq %rax, %rbx
movq %r14, %rdi
callq 0x3180
jmp 0x52b3
jmp 0x52b0
movq %rax, %rbx
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x52ca
leaq -0x40(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x3330
movq %rax, %rdi
callq 0x3a01
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/socket.cpp
// Function: socket::update_addr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned short)
bool socket::update_addr(const std::string &host, unsigned short port){
	struct hostent *hostent = gethostbyname(host.c_str());
	if(nullptr == hostent){
		return false;
	}
	if(nullptr == addr){
		addr = std::shared_ptr<struct sockaddr_in>(new struct sockaddr_in());
	}
	bzero(addr.get(), sizeof(struct sockaddr_in));

	addr->sin_family = AF_INET;
	addr->sin_port = htons(port);
	addr->sin_addr = *(reinterpret_cast<struct in_addr*>(hostent->h_addr));

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rdi, %r15
movq (%rsi), %rdi
callq 0x3220
movq %rax, %r14
testq %rax, %rax
je 0x56f5
movq 0x1e0(%r15), %rdi
testq %rdi, %rdi
jne 0x56cb
movl $0x10, %edi
callq 0x3200
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
leaq -0x28(%rbp), %r12
movq %rax, -0x8(%r12)
movq %r12, %rdi
movq %rax, %rsi
callq 0x4472
movaps -0x8(%r12), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x8(%r12)
movq 0x1e8(%r15), %rdi
movups %xmm0, 0x1e0(%r15)
testq %rdi, %rdi
je 0x56c4
callq 0x3a10
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x56c4
callq 0x3a10
movq 0x1e0(%r15), %rdi
movl $0x10, %esi
callq 0x3320
movq 0x1e0(%r15), %rax
movw $0x2, (%rax)
rolw $0x8, %bx
movw %bx, 0x2(%rax)
movq 0x18(%r14), %rcx
movq (%rcx), %rcx
movl (%rcx), %ecx
movl %ecx, 0x4(%rax)
testq %r14, %r14
setne %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/socket.cpp
// Function: socket::async_conn_action(std::function<void (int)>)
void socket::async_conn_action(ccallback ccb){
	int error;
	socklen_t len = sizeof(error);
	if(::getsockopt(sock, SOL_SOCKET, SO_ERROR, &error, &len) < 0){
		return;
	}
	connect_status = (0 == error)?CONNECTED:CONNECTERR;
	wrable = true;
	singleton<scheduler>::instance()->arrange(std::bind(ccb, error));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %r8
movl $0x4, (%r8)
movl 0x8(%rdi), %edi
leaq -0x1c(%rbp), %rcx
movl $0x1, %esi
movl $0x4, %edx
callq 0x3170
testl %eax, %eax
js 0x5d8f
cmpl $0x1, -0x1c(%rbp)
movl $0x3, %eax
sbbl $0x0, %eax
movl %eax, 0x1f4(%r14)
movb $0x1, 0x1f1(%r14)
callq 0x427a
movq %rax, %r14
leaq -0x68(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6f0c
movl -0x1c(%rbp), %eax
movl %eax, 0x20(%r15)
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x6a7c
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x4a32
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x5d78
leaq -0x40(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x58(%rbp), %rax
testq %rax, %rax
je 0x5d8f
leaq -0x68(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5dde
jmp 0x5dde
movq %rax, %rbx
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x5dbf
leaq -0x40(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x5dbf
jmp 0x5dde
movq %rax, %rbx
movq -0x58(%rbp), %rax
testq %rax, %rax
je 0x5dd6
leaq -0x68(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x3330
movq %rax, %rdi
callq 0x3a01
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/socket.cpp
// Function: socket::sync_write(void const*, unsigned long)
int socket::sync_write(const void *buff, size_t length){
	int transfered = 0;
	std::mutex sync_mutex;
	std::unique_lock<std::mutex> locker(sync_mutex);
	bool processed = false;
	std::condition_variable cv;
	{
		std::lock_guard<std::mutex> scope_locker(wr_mutex);
		wr_request.push_back(std::bind(&socket::sync_wr_action, this, 
					reinterpret_cast<const char*>(buff), length, std::ref(transfered),
					std::ref(cv), std::ref(processed)));
		if(wrable)
			wr_worker.active();
	}
	cv.wait(locker, [&processed]()->bool{return processed;});
	
	return transfered;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movl $0x0, -0x30(%rbp)
xorps %xmm0, %xmm0
leaq -0xc0(%rbp), %rax
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq $0x0, 0x20(%rax)
leaq -0x40(%rbp), %rbx
movq %rax, (%rbx)
xorl %r13d, %r13d
movb %r13b, 0x8(%rbx)
movq %rbx, %rdi
callq 0x6d68
movb $0x1, 0x8(%rbx)
movb %r13b, -0x29(%rbp)
leaq -0x90(%rbp), %r13
movq %r13, %rdi
callq 0x3270
leaq 0x148(%r14), %rbx
movq %rbx, %rdi
callq 0x32a0
testl %eax, %eax
jne 0x5f42
leaq 0x130(%rip), %rax       # 0x5f9e
leaq -0x100(%rbp), %rsi
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
leaq -0x29(%rbp), %rax
movq %rax, 0x10(%rsi)
movq %r13, 0x18(%rsi)
leaq -0x30(%rbp), %rax
movq %rax, 0x20(%rsi)
movq %r12, 0x28(%rsi)
movq %r15, 0x30(%rsi)
movq %r14, 0x38(%rsi)
leaq -0x60(%rbp), %rdi
callq 0x6ada
leaq 0x1b0(%r14), %rdi
leaq -0x60(%rbp), %rdx
movq %rdi, %rsi
callq 0x6de0
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x5ed3
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
cmpb $0x1, 0x1f1(%r14)
jne 0x5eec
addq $0x98, %r14
movq %r14, %rdi
callq 0x819c
movq %rbx, %rdi
callq 0x3180
cmpb $0x0, -0x29(%rbp)
jne 0x5f16
leaq -0x90(%rbp), %rbx
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30a0
cmpb $0x1, -0x29(%rbp)
jne 0x5f05
movl -0x30(%rbp), %ebx
leaq -0x90(%rbp), %rdi
callq 0x3350
leaq -0x40(%rbp), %rdi
callq 0x6a04
movl %ebx, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x3140
jmp 0x5f71
jmp 0x5f69
movq %rax, %r14
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x5f74
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x5f74
movq %rax, %rdi
callq 0x3a01
movq %rax, %r14
movq %rbx, %rdi
callq 0x3180
jmp 0x5f81
movq %rax, %r14
leaq -0x90(%rbp), %rdi
callq 0x3350
leaq -0x40(%rbp), %rdi
callq 0x6a04
movq %r14, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/socket.cpp
// Function: socket::sync_read(void*, unsigned long)
int socket::sync_read(void *buff, size_t length){
	int transfered = 0;
	std::mutex sync_mutex;
	std::unique_lock<std::mutex> locker(sync_mutex);
	bool processed = false;
	std::condition_variable sync_cv;
	{
		std::lock_guard<std::mutex> scope_locker(rd_mutex);
		rd_request.push_back(std::bind(&socket::sync_rd_action, this, 
					reinterpret_cast<char*>(buff), length, std::ref(transfered),
					std::ref(sync_cv), std::ref(processed)));
		if(rdable)
			rd_worker.active();
	}
	sync_cv.wait(locker, [&processed]()->bool{return processed;});

	return transfered;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movl $0x0, -0x30(%rbp)
xorps %xmm0, %xmm0
leaq -0xc0(%rbp), %rax
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq $0x0, 0x20(%rax)
leaq -0x40(%rbp), %rbx
movq %rax, (%rbx)
xorl %r13d, %r13d
movb %r13b, 0x8(%rbx)
movq %rbx, %rdi
callq 0x6d68
movb $0x1, 0x8(%rbx)
movb %r13b, -0x29(%rbp)
leaq -0x90(%rbp), %r13
movq %r13, %rdi
callq 0x3270
leaq 0x120(%r14), %rbx
movq %rbx, %rdi
callq 0x32a0
testl %eax, %eax
jne 0x618d
leaq 0x12e(%rip), %rax       # 0x61ea
leaq -0x100(%rbp), %rsi
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
leaq -0x29(%rbp), %rax
movq %rax, 0x10(%rsi)
movq %r13, 0x18(%rsi)
leaq -0x30(%rbp), %rax
movq %rax, 0x20(%rsi)
movq %r12, 0x28(%rsi)
movq %r15, 0x30(%rsi)
movq %r14, 0x38(%rsi)
leaq -0x60(%rbp), %rdi
callq 0x6b38
leaq 0x198(%r14), %rdi
leaq -0x60(%rbp), %rdx
movq %rdi, %rsi
callq 0x6de0
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x6121
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
cmpb $0x1, 0x1f0(%r14)
jne 0x6137
addq $0x10, %r14
movq %r14, %rdi
callq 0x819c
movq %rbx, %rdi
callq 0x3180
cmpb $0x0, -0x29(%rbp)
jne 0x6161
leaq -0x90(%rbp), %rbx
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30a0
cmpb $0x1, -0x29(%rbp)
jne 0x6150
movl -0x30(%rbp), %ebx
leaq -0x90(%rbp), %rdi
callq 0x3350
leaq -0x40(%rbp), %rdi
callq 0x6a04
movl %ebx, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x3140
jmp 0x61bc
jmp 0x61b4
movq %rax, %r14
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x61bf
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x61bf
movq %rax, %rdi
callq 0x3a01
movq %rax, %r14
movq %rbx, %rdi
callq 0x3180
jmp 0x61cc
movq %rax, %r14
leaq -0x90(%rbp), %rdi
callq 0x3350
leaq -0x40(%rbp), %rdi
callq 0x6a04
movq %r14, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/socket.cpp
// Function: socket::async_write(void const*, unsigned long, std::function<void (int, int)>)
void socket::async_write(const void *buff, size_t length, ocallback ocb){
	std::lock_guard<std::mutex> locker(rd_mutex);
	wr_request.push_back(
			std::bind(&socket::async_wr_action, this, reinterpret_cast<const char *>(buff), length, ocb));

	if(wrable)
		wr_worker.active();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r15
addq $0x120, %rdi            # imm = 0x120
movq %rdi, -0x30(%rbp)
callq 0x32a0
testl %eax, %eax
jne 0x63d7
leaq 0x17e(%rip), %rax       # 0x643a
leaq -0x88(%rbp), %r14
movq %rax, -0x10(%r14)
movq $0x0, -0x8(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7574
movq %r13, -0x68(%rbp)
movq %r12, -0x60(%rbp)
movq %r15, -0x58(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x40(%rbp)
movl $0x48, %edi
callq 0x3200
leaq 0x1b0(%r15), %rdi
movups -0x98(%rbp), %xmm0
movups %xmm0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq -0x70(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x78(%rbp), %rcx
testq %rcx, %rcx
je 0x6348
movq %rax, %rdx
addq $0x10, %rdx
leaq -0x78(%rbp), %rsi
movups (%r14), %xmm0
movups %xmm0, (%rdx)
movq %rcx, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq %r13, 0x30(%rax)
movq %r12, 0x38(%rax)
movq %r15, 0x40(%rax)
leaq -0x50(%rbp), %rdx
movq %rax, (%rdx)
leaq 0x1278(%rip), %rax      # 0x75da
movq %rax, 0x18(%rdx)
leaq 0x128b(%rip), %rax      # 0x75f8
movq %rax, 0x10(%rdx)
movq %rdi, %rsi
callq 0x6de0
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x6390
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x78(%rbp), %rax
testq %rax, %rax
je 0x63a6
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
cmpb $0x1, 0x1f1(%r15)
jne 0x63bf
addq $0x98, %r15
movq %r15, %rdi
callq 0x819c
movq -0x30(%rbp), %rdi
callq 0x3180
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x3140
jmp 0x6425
jmp 0x641d
jmp 0x641d
movq %rax, %r15
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x6405
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x6405
jmp 0x641d
movq %rax, %r15
movq -0x78(%rbp), %rax
testq %rax, %rax
je 0x6428
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x6428
movq %rax, %rdi
callq 0x3a01
movq %rax, %r15
movq -0x30(%rbp), %rdi
callq 0x3180
movq %r15, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/socket.cpp
// Function: socket::async_wr_action(char const*, unsigned long, std::function<void (int, int)>)
void socket::async_wr_action(const char *buff, size_t length, ocallback ocb){
	int transfered = write_some(buff, length);
	int ec = 0;
	if(transfered == -1){
		socklen_t len = sizeof(ec);
		if(::getsockopt(sock, SOL_SOCKET, SO_ERROR, &ec, &len) < 0){
			//
		}
	}

	singleton<scheduler>::instance()->arrange(std::bind(ocb, ec, transfered));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x64a2
movq %rdx, %r15
movq %rsi, %r12
xorl %r13d, %r13d
movl 0x8(%r14), %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x30c0
testl %eax, %eax
jle 0x6489
addl %eax, %r13d
cmpq %r15, %r13
jb 0x645f
movl $0x0, -0x2c(%rbp)
cmpl $-0x1, %r13d
jne 0x64d1
jmp 0x64a9
cmpl $-0x1, %eax
jne 0x64a2
callq 0x3040
cmpl $0xb, (%rax)
jne 0x64a2
movb $0x0, 0x1f1(%r14)
jmp 0x647a
movl $0x0, -0x2c(%rbp)
leaq -0x78(%rbp), %r8
movl $0x4, (%r8)
movl 0x8(%r14), %edi
leaq -0x2c(%rbp), %rcx
movl $0x1, %esi
movl $0x4, %edx
callq 0x3170
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
callq 0x427a
movq %rax, %r14
leaq -0x78(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7574
movl %r13d, 0x20(%r15)
movl -0x2c(%rbp), %eax
movl %eax, 0x24(%r15)
leaq -0x50(%rbp), %rdi
movq %r15, %rsi
callq 0x6b96
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x4a32
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x6522
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x68(%rbp), %rax
testq %rax, %rax
je 0x6539
leaq -0x78(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x658c
jmp 0x658c
movq %rax, %rbx
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x656d
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x656d
jmp 0x658c
movq %rax, %rbx
movq -0x68(%rbp), %rax
testq %rax, %rax
je 0x6584
leaq -0x78(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x3330
movq %rax, %rdi
callq 0x3a01
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/socket.cpp
// Function: socket::async_read(void*, unsigned long, std::function<void (int, int)>)
void socket::async_read(void *buff, size_t length, icallback icb){
	std::lock_guard<std::mutex> locker(wr_mutex);
	rd_request.push_back(
			std::bind(&socket::async_rd_action, this, reinterpret_cast<char*>(buff), length, icb));

	if(rdable)
		rd_worker.active();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r15
addq $0x148, %rdi            # imm = 0x148
movq %rdi, -0x30(%rbp)
callq 0x32a0
testl %eax, %eax
jne 0x66e8
leaq 0x17a(%rip), %rax       # 0x674a
leaq -0x88(%rbp), %r14
movq %rax, -0x10(%r14)
movq $0x0, -0x8(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7574
movq %r13, -0x68(%rbp)
movq %r12, -0x60(%rbp)
movq %r15, -0x58(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x40(%rbp)
movl $0x48, %edi
callq 0x3200
leaq 0x198(%r15), %rdi
movups -0x98(%rbp), %xmm0
movups %xmm0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq -0x70(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x78(%rbp), %rcx
testq %rcx, %rcx
je 0x665c
movq %rax, %rdx
addq $0x10, %rdx
leaq -0x78(%rbp), %rsi
movups (%r14), %xmm0
movups %xmm0, (%rdx)
movq %rcx, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq %r13, 0x30(%rax)
movq %r12, 0x38(%rax)
movq %r15, 0x40(%rax)
leaq -0x50(%rbp), %rdx
movq %rax, (%rdx)
leaq 0x112e(%rip), %rax      # 0x77a4
movq %rax, 0x18(%rdx)
leaq 0x1141(%rip), %rax      # 0x77c2
movq %rax, 0x10(%rdx)
movq %rdi, %rsi
callq 0x6de0
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x66a4
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x78(%rbp), %rax
testq %rax, %rax
je 0x66ba
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
cmpb $0x1, 0x1f0(%r15)
jne 0x66d0
addq $0x10, %r15
movq %r15, %rdi
callq 0x819c
movq -0x30(%rbp), %rdi
callq 0x3180
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x3140
jmp 0x6736
jmp 0x672e
jmp 0x672e
movq %rax, %r15
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x6716
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x6716
jmp 0x672e
movq %rax, %r15
movq -0x78(%rbp), %rax
testq %rax, %rax
je 0x6739
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x6739
movq %rax, %rdi
callq 0x3a01
movq %rax, %r15
movq -0x30(%rbp), %rdi
callq 0x3180
movq %r15, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/socket.cpp
// Function: socket::async_rd_action(char*, unsigned long, std::function<void (int, int)>)
void socket::async_rd_action(char *buff, size_t length, icallback icb){
	int transfered = read_some(buff, length);
	int ec = 0;
	if(transfered == -1){
		socklen_t len = sizeof(ec);
		if(::getsockopt(sock, SOL_SOCKET, SO_ERROR, &ec, &len) < 0){
			//
		}
	}
	singleton<scheduler>::instance()->arrange(std::bind(icb, ec, transfered));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x67b2
movq %rdx, %r15
movq %rsi, %r12
xorl %r13d, %r13d
movl 0x8(%r14), %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3280
testl %eax, %eax
jle 0x6799
addl %eax, %r13d
cmpq %r15, %r13
jb 0x676f
movl $0x0, -0x2c(%rbp)
cmpl $-0x1, %r13d
jne 0x67e1
jmp 0x67b9
cmpl $-0x1, %eax
jne 0x67b2
callq 0x3040
cmpl $0xb, (%rax)
jne 0x67b2
movb $0x0, 0x1f0(%r14)
jmp 0x678a
movl $0x0, -0x2c(%rbp)
leaq -0x78(%rbp), %r8
movl $0x4, (%r8)
movl 0x8(%r14), %edi
leaq -0x2c(%rbp), %rcx
movl $0x1, %esi
movl $0x4, %edx
callq 0x3170
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
callq 0x427a
movq %rax, %r14
leaq -0x78(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7574
movl %r13d, 0x20(%r15)
movl -0x2c(%rbp), %eax
movl %eax, 0x24(%r15)
leaq -0x50(%rbp), %rdi
movq %r15, %rsi
callq 0x6b96
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x4a32
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x6832
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x68(%rbp), %rax
testq %rax, %rax
je 0x6849
leaq -0x78(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x689c
jmp 0x689c
movq %rax, %rbx
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x687d
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x687d
jmp 0x689c
movq %rax, %rbx
movq -0x68(%rbp), %rax
testq %rax, %rax
je 0x6894
leaq -0x78(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x3330
movq %rax, %rdi
callq 0x3a01
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/socket.cpp
// Function: socket::rdhupevent()
void socket::rdhupevent(){
	unregister_epoll_req();
	connect_status = PRECONNECT;
	rdable = false;
	wrable = false;
	close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7c32
movl $0x0, 0x1f4(%rbx)
movw $0x0, 0x1f0(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7c62
nop
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/socket.cpp
// Function: socket::eevent()
void socket::eevent(){
	if(CONNECTING == connect_status){
		std::function<void()> callback;
		{
			std::lock_guard<std::mutex> locker(conn_mutex);
			if(conn_request.empty()){
				return;
			}
			callback = conn_request.front();
			conn_request.pop_front();
			if(nullptr == callback)
				return;
		}
		callback();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpl $0x1, 0x1f4(%rdi)
jne 0x69b4
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movaps %xmm0, -0x30(%rbp)
leaq 0x170(%rdi), %rbx
movq %rbx, %rdi
callq 0x32a0
testl %eax, %eax
jne 0x69bd
movq 0x1c8(%r14), %rsi
addq $0x1c8, %r14            # imm = 0x1C8
cmpq %r14, %rsi
je 0x6995
addq $0x10, %rsi
leaq -0x30(%rbp), %rdi
callq 0x6bf4
movq (%r14), %rsi
movq %r14, %rdi
callq 0x7b06
movq -0x20(%rbp), %r14
movq %rbx, %rdi
callq 0x3180
testq %r14, %r14
je 0x699d
cmpq $0x0, -0x20(%rbp)
je 0x69c4
leaq -0x30(%rbp), %rdi
callq *0x18(%rdi)
jmp 0x699d
movq %rbx, %rdi
callq 0x3180
movq -0x20(%rbp), %rax
testq %rax, %rax
je 0x69b4
leaq -0x30(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl %eax, %edi
callq 0x3140
callq 0x30e0
jmp 0x69fc
movq %rax, %r14
movq %rbx, %rdi
callq 0x3180
jmp 0x69dd
jmp 0x69da
movq %rax, %r14
movq -0x20(%rbp), %rax
testq %rax, %rax
je 0x69f4
leaq -0x30(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0x3330
movq %rax, %rdi
callq 0x3a01
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/socket_base.cpp
// Function: socket_base::register_epoll_req()
void socket_base::register_epoll_req(){
	if(-1 == sock){
		return;
	}
	if(!epolled){
		singleton<epoll>::instance()->add_request(
				this, EPOLLHUP|EPOLLRDHUP|EPOLLPRI|EPOLLOUT|EPOLLIN|EPOLLET);
		epolled = true;
	}
}

// Assembly:
cmpl $-0x1, 0x8(%rdi)
je 0x7bca
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0xc(%rdi)
jne 0x7bc4
callq 0x7d04
movq %rax, %rdi
movq %rbx, %rsi
movl $0x80002017, %edx       # imm = 0x80002017
callq 0x8434
movb $0x1, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/socket_base.cpp
// Function: socket_base::unregister_epoll_req()
void socket_base::unregister_epoll_req(){
	if(-1 == sock){
		return;
	}
	if(epolled){
		singleton<epoll>::instance()->del_request(this);
		epolled = false;
	}
}

// Assembly:
cmpl $-0x1, 0x8(%rdi)
je 0x7c61
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0xc(%rdi)
jne 0x7c5b
callq 0x7d04
movq %rax, %rdi
movq %rbx, %rsi
callq 0x84ac
movb $0x0, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/socket_base.cpp
// Function: socket_base::set_noblock()
bool socket_base::set_noblock(){
	if(-1 == sock){
		return false;
	}
	int flags = fcntl(sock, F_GETFL, 0);
	if(flags < 0){
		return false;
	}

	if(fcntl(sock, F_SETFL, flags | O_NONBLOCK) < 0) {
		return false;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl 0x8(%rdi), %edi
xorl %ebx, %ebx
cmpl $-0x1, %edi
je 0x7cd8
movl $0x3, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x3130
testl %eax, %eax
js 0x7cd8
movl 0x8(%r14), %edi
orl $0x800, %eax            # imm = 0x800
movl $0x4, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x3130
testl %eax, %eax
setns %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/worker.cpp
// Function: worker::worker()
worker::worker():stop(false), onced(true){
	mutex.lock();
	stop = false;
	thread = std::shared_ptr<std::thread>(
			new std::thread(std::bind(&worker::work, this)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x19(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movb $0x1, 0x2a(%rdi)
addq $0x30, %rdi
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x70(%rbx)
movq $0x0, 0x80(%rbx)
callq 0x32a0
testl %eax, %eax
jne 0x7f72
movb $0x0, 0x28(%rbx)
movl $0x8, %edi
callq 0x3200
movq %rax, %r15
leaq 0xba(%rip), %rax        # 0x7fc8
leaq -0x48(%rbp), %rsi
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
movq %rbx, 0x10(%rsi)
movq %r15, %rdi
callq 0x81aa
leaq -0x28(%rbp), %rdi
movq %r15, -0x8(%rdi)
movq %r15, %rsi
callq 0x8268
movaps -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x30(%rbp)
movq 0x80(%rbx), %rdi
movups %xmm0, 0x78(%rbx)
testq %rdi, %rdi
je 0x7f67
callq 0x3a10
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x7f67
callq 0x3a10
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x3140
jmp 0x7f8a
movq %rax, %r14
movq %r15, %rdi
callq 0x31e0
jmp 0x7f8d
jmp 0x7f8a
movq %rax, %r14
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x7f9e
callq 0x3a10
movq 0x68(%rbx), %rax
testq %rax, %rax
je 0x7fb8
addq $0x58, %rbx
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0x3330
movq %rax, %rdi
callq 0x3a01
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/worker.cpp
// Function: worker::work()
void worker::work(){
	while(true){
		while(!mutex.try_lock_for(std::chrono::milliseconds(30))){
			if(stop)
				return;
		}
		std::lock_guard<std::mutex> locker(task_safe);
		if(proc != nullptr)
			proc();
		if(once){
			proc = nullptr;
			onced = true;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
leaq 0x58(%rdi), %r15
leaq 0x68(%rdi), %r13
leaq -0x30(%rbp), %r12
movq $0x1e, -0x30(%rbp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x8324
testb %al, %al
je 0x804b
movq %rbx, %rdi
callq 0x32a0
testl %eax, %eax
jne 0x8060
cmpq $0x0, (%r13)
je 0x8019
movq %r15, %rdi
callq *0x70(%rbx)
cmpb $0x1, 0x29(%rbx)
jne 0x8041
movq (%r13), %rax
testq %rax, %rax
je 0x803d
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movb $0x1, 0x2a(%rbx)
movq %rbx, %rdi
callq 0x3180
jmp 0x7fe9
cmpb $0x1, 0x28(%rbx)
jne 0x7fe9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x3140
movq %rax, %rdi
callq 0x3a01
movq %rax, %r14
movq %rbx, %rdi
callq 0x3180
movq %r14, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/worker.cpp
// Function: worker::interrupt()
void worker::interrupt(){
	if(nullptr != thread){
		stop = true;
		if(thread->joinable()){
			thread->join();
		}
		thread = nullptr;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0x810b
movb $0x1, 0x28(%rbx)
cmpq $0x0, (%rdi)
je 0x80ed
callq 0x3300
xorps %xmm0, %xmm0
movq 0x80(%rbx), %rdi
movups %xmm0, 0x78(%rbx)
testq %rdi, %rdi
je 0x810b
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3a10
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/worker.cpp
// Function: worker::task(std::function<void ()>)
bool worker::task(std::function<void()> job){
	if(task_safe.try_lock()){
		once = false;
		proc = job;
		task_safe.unlock();
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x3070
movl %eax, %r14d
testl %eax, %eax
jne 0x8146
movb $0x0, 0x29(%rbx)
leaq 0x58(%rbx), %rdi
movq %r15, %rsi
callq 0x6bf4
movq %rbx, %rdi
callq 0x3180
testl %r14d, %r14d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/worker.cpp
// Function: worker::task_once(std::function<void ()>)
bool worker::task_once(std::function<void()> job){
	if(onced && task_safe.try_lock()){
		once = true;
		onced = false;
		proc = job;
		task_safe.unlock();
		return true;
	}
	return false;
}

// Assembly:
cmpb $0x1, 0x2a(%rdi)
jne 0x8178
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3070
testl %eax, %eax
je 0x817b
xorl %eax, %eax
jmp 0x8197
xorl %eax, %eax
retq
movw $0x1, 0x29(%rbx)
leaq 0x58(%rbx), %rdi
movq %r14, %rsi
callq 0x6bf4
movq %rbx, %rdi
callq 0x3180
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/epoll.cpp
// Function: epoll::interrupt()
void epoll::interrupt(){
	if(nullptr != service){
		polling = false;
		if(service->joinable()){
			service->join();
		}
		service = nullptr;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x842d
movb $0x0, (%rbx)
cmpq $0x0, (%rdi)
je 0x8412
callq 0x3300
xorps %xmm0, %xmm0
movq 0x10(%rbx), %rdi
movups %xmm0, 0x8(%rbx)
testq %rdi, %rdi
je 0x842d
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3a10
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/epoll.cpp
// Function: epoll::add_request(socket_base*, int)
void epoll::add_request(socket_base *sock, int events){
	struct epoll_event ev;
	ev.events = events;
	ev.data.ptr = sock;

	epoll_ctl(fd, EPOLL_CTL_ADD, sock->fd(), &ev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq -0x1c(%rbp), %rbx
movl %edx, (%rbx)
movq %rsi, 0x4(%rbx)
movl 0x4(%rdi), %r14d
movq %rsi, %rdi
callq 0x7c8c
movl %r14d, %edi
movl $0x1, %esi
movl %eax, %edx
movq %rbx, %rcx
callq 0x3260
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/src/epoll.cpp
// Function: epoll::poll_service()
void epoll::poll_service(){
	struct epoll_event evs[20000];
	polling = true;
	while(polling){
		int cnt = ::epoll_wait(fd, evs, 20000, 30);

		for(int i = 0; i != cnt; ++i){
			struct epoll_event &ev = evs[i];

			socket_base *sock = reinterpret_cast<socket_base*>(ev.data.ptr);
			if(nullptr == sock){
				continue;
			}

			if(ev.events & EPOLLRDHUP){
				sock->rdhupevent();
			}
			else{
				if(ev.events & EPOLLERR){
					sock->eevent();
				}
				if(ev.events & EPOLLIN){
					sock->ievent();
				}
				if(ev.events & EPOLLOUT){
					sock->oevent();
				}
				if(ev.events & EPOLLHUP){
					sock->hupevent();
				}
				if(ev.events & EPOLLPRI){
					sock->prievent();
				}
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3a988, %rsp          # imm = 0x3A988
movq %rdi, %rbx
movb $0x1, (%rdi)
leaq -0x3a9b0(%rbp), %r14
movl 0x4(%rbx), %edi
movq %r14, %rsi
movl $0x4e20, %edx           # imm = 0x4E20
movl $0x1e, %ecx
callq 0x3110
testl %eax, %eax
je 0x8664
movl %eax, %eax
shlq $0x2, %rax
leaq (%rax,%rax,2), %r12
xorl %r13d, %r13d
movq -0x3a9ac(%rbp,%r13), %r15
testq %r15, %r15
je 0x8657
movl -0x3a9b0(%rbp,%r13), %eax
movl $0x38, %ecx
btl $0xd, %eax
jb 0x864e
testb $0x8, %al
je 0x8606
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
movl -0x3a9b0(%rbp,%r13), %eax
testb $0x1, %al
je 0x861b
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movl -0x3a9b0(%rbp,%r13), %eax
testb $0x4, %al
je 0x8630
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movl -0x3a9b0(%rbp,%r13), %eax
testb $0x10, %al
je 0x8645
movq (%r15), %rax
movq %r15, %rdi
callq *0x30(%rax)
movl -0x3a9b0(%rbp,%r13), %eax
movl $0x28, %ecx
testb $0x2, %al
je 0x8657
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax,%rcx)
addq $0xc, %r13
cmpq %r13, %r12
jne 0x85d1
cmpb $0x1, (%rbx)
je 0x85a7
addq $0x3a988, %rsp          # imm = 0x3A988
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ivanzamanov[P]kmeans/src/stemmer/stemmer.cpp
// Function: main
int main(int argc, char** argv) {
	int inputFD = -1;
	int outputFD = -1;

	const char* inputPath = "STDIN";
	if(argc < 2) {
		inputFD = 0;
	} else {
		inputPath = argv[1];
		inputFD = open(inputPath, O_RDONLY);
		if(inputFD < 0) {
			printf("Cannot open file %s\n", inputPath);
			return 1;
		}
	}

	if(argc < 3) {
		outputFD = 1;
	} else {
		char* outputPath = argv[2];
		outputFD = open(outputPath, O_WRONLY | O_CREAT, 0664);
		if(outputFD < 0) {
			printf("Cannot open file %s\n", outputPath);
			return 1;
		}
	}

	struct stat fileStat;
	if(fstat(inputFD, &fileStat) != 0) {
		printf("Cannot stat file %s\n", inputPath);
		return 1;
	}

	processFile(inputFD, outputFD, &fileStat);

	if(outputFD == 1) {
		printf("\n");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movl $0x1, %ebp
cmpl $0x2, %edi
jge 0x1201
xorl %r14d, %r14d
leaq 0x1e05(%rip), %rbx      # 0x3004
jmp 0x1242
movq %rsi, %r15
movl %edi, %r12d
movq 0x8(%rsi), %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x1070
testl %eax, %eax
js 0x1277
movl %eax, %r14d
cmpl $0x2, %r12d
je 0x1242
movq 0x10(%r15), %r15
movq %r15, %rdi
movl $0x41, %esi
movl $0x1b4, %edx            # imm = 0x1B4
xorl %eax, %eax
callq 0x1070
movl %eax, %ebp
testl %eax, %eax
js 0x129f
movq %rsp, %rsi
movl %r14d, %edi
callq 0x10d0
testl %eax, %eax
je 0x125a
leaq 0x1dc7(%rip), %rdi      # 0x301f
jmp 0x127e
movl %r14d, %edi
movl %ebp, %esi
callq 0x12ab
xorl %ebx, %ebx
cmpl $0x1, %ebp
jne 0x128d
movl $0xa, %edi
callq 0x10a0
jmp 0x128d
leaq 0x1d8c(%rip), %rdi      # 0x300a
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
movl $0x1, %ebx
movl %ebx, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1d64(%rip), %rdi      # 0x300a
movq %r15, %rsi
jmp 0x1281
// File: /workspace/github_cpp_makefile_star2_O3/ivanzamanov[P]kmeans/src/stemmer/stemmer.cpp
// Function: processFile(int, int, stat*)
void processFile(int inputFD, int outputFD, struct stat* const fileStat) {
	char* fullData = 0;
	readFullData(inputFD, &fullData);

	char* buffer = new char[4096];
	int offset = 0;
	readToken(fullData, offset, buffer, 4096);
	stemToken(buffer);
	writeToken(buffer, outputFD);
	while(readToken(fullData, offset, buffer, 4096)) {
		writeToken(" ", outputFD);
		stemToken(buffer);
		writeToken(buffer, outputFD);
	}
	delete fullData;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
leaq 0x10(%rsp), %r15
movq $0x0, (%r15)
movq %r15, %rsi
callq 0x20c4
movl $0x1000, %edi           # imm = 0x1000
callq 0x1030
movq %rax, %r14
leaq 0xc(%rsp), %r12
movl $0x0, (%r12)
movq (%r15), %rdi
movq %r12, %rsi
movq %rax, %rdx
movl $0x1000, %ecx           # imm = 0x1000
callq 0x1fe9
movq %r14, %rdi
callq 0x137c
movq %r14, %rdi
movl %ebx, %esi
callq 0x1f5c
movq (%r15), %rdi
movq %r12, %rsi
movq %r14, %rdx
movl $0x1000, %ecx           # imm = 0x1000
callq 0x1fe9
testb %al, %al
je 0x1363
leaq 0x1d0b(%rip), %r15      # 0x3034
leaq 0xc(%rsp), %r12
movq %r15, %rdi
movl %ebx, %esi
callq 0x1f5c
movq %r14, %rdi
callq 0x137c
movq %r14, %rdi
movl %ebx, %esi
callq 0x1f5c
movq 0x10(%rsp), %rdi
movq %r12, %rsi
movq %r14, %rdx
movl $0x1000, %ecx           # imm = 0x1000
callq 0x1fe9
testb %al, %al
jne 0x132e
movq 0x10(%rsp), %rdi
callq 0x1080
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/ivanzamanov[P]kmeans/src/common/stem.cpp
// Function: ends(char const*)
static int ends(const char * s)
{  int length = s[0];
   if (s[length] != b[k]) return FALSE; /* tiny speed-up */
   if (length > k-k0+1) return FALSE;
   if (memcmp(b+k-length+1,s+1,length) != 0) return FALSE;
   j = k-length;
   return TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rsi
movsbq (%rdi), %r14
movb (%rdi,%r14), %al
movq 0x34c4(%rip), %rdi      # 0x5088
movslq 0x34c5(%rip), %r15      # 0x5090
xorl %ebx, %ebx
cmpb (%rdi,%r15), %al
jne 0x1c0a
movl %r15d, %eax
subl 0x34b8(%rip), %eax      # 0x5094
incl %eax
cmpl %r14d, %eax
jl 0x1c0a
addq %r15, %rdi
subq %r14, %rdi
incq %rdi
incq %rsi
movq %r14, %rdx
callq 0x1090
testl %eax, %eax
jne 0x1c0a
subl %r14d, %r15d
movl %r15d, 0x3493(%rip)     # 0x5098
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ivanzamanov[P]kmeans/src/common/stem.cpp
// Function: m()
static int m()
{  int n = 0;
   int i = k0;
   while(TRUE)
   {  if (i > j) return n;
      if (! cons(i)) break; i++;
   }
   i++;
   while(TRUE)
   {  while(TRUE)
      {  if (i > j) return n;
            if (cons(i)) break;
            i++;
      }
      i++;
      n++;
      while(TRUE)
      {  if (i > j) return n;
         if (! cons(i)) break;
         i++;
      }
      i++;
   }
}

// Assembly:
movslq 0x347b(%rip), %rcx      # 0x5094
movslq 0x3478(%rip), %rdx      # 0x5098
cmpl %edx, %ecx
jle 0x1c27
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x3452(%rip), %rsi      # 0x5088
leal 0x1(%rdx), %eax
leaq (%rsi,%rcx), %rdi
xorl %r9d, %r9d
movl $0x495, %r10d           # imm = 0x495
movq %rcx, %r8
movq %r9, %rbx
xorl %r11d, %r11d
movsbl (%rdi,%rbx), %r14d
addl $-0x61, %r14d
rorl %r14d
movl $0x1, %ebp
cmpl $0xc, %r14d
jne 0x1c72
subq $0x1, %rbx
jb 0x1c80
xorl $0x1, %r11d
jmp 0x1c4f
cmpl $0xa, %r14d
ja 0x1c80
btl %r14d, %r10d
jae 0x1c80
xorl %ebp, %ebp
cmpl %r11d, %ebp
je 0x1c97
incq %r8
incq %r9
cmpl %r8d, %eax
jne 0x1c49
xorl %eax, %eax
jmp 0x1d77
xorl %eax, %eax
movl $0x495, %edi            # imm = 0x495
movslq %r8d, %rbx
leal 0x2(%rbx), %r15d
movq %rcx, %r9
subq %rbx, %r9
leaq (%rsi,%rbx), %r11
cmpq %rdx, %rbx
jge 0x1d77
movq %rbx, %r10
movl %r15d, %r8d
incq %rbx
xorl %ebp, %ebp
movl $0x1, %r15d
movsbl (%r11,%r15), %r12d
addl $-0x61, %r12d
rorl %r12d
movl $0x1, %r14d
cmpl $0xc, %r12d
jne 0x1cee
cmpq %r15, %r9
je 0x1cfd
xorl $0x1, %ebp
decq %r15
jmp 0x1cc9
cmpl $0xa, %r12d
ja 0x1cfd
btl %r12d, %edi
jae 0x1cfd
xorl %r14d, %r14d
leal 0x1(%r8), %r15d
decq %r9
incq %r11
cmpl %ebp, %r14d
je 0x1caf
addl $0x2, %r10d
incl %eax
cmpl %edx, %r10d
jg 0x1d77
movslq %r8d, %r8
movq %rcx, %r9
subq %r8, %r9
leaq (%rsi,%r8), %r10
xorl %ebx, %ebx
xorl %r11d, %r11d
movsbl (%r10,%rbx), %r14d
addl $-0x61, %r14d
rorl %r14d
movl $0x1, %ebp
cmpl $0xc, %r14d
jne 0x1d4e
cmpq %rbx, %r9
je 0x1d5c
xorl $0x1, %r11d
decq %rbx
jmp 0x1d29
cmpl $0xa, %r14d
ja 0x1d5c
btl %r14d, %edi
jae 0x1d5c
xorl %ebp, %ebp
cmpl %r11d, %ebp
je 0x1c9e
leaq 0x1(%r8), %r11
decq %r9
incq %r10
cmpq %rdx, %r8
movq %r11, %r8
jl 0x1d24
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ivanzamanov[P]kmeans/src/common/stem.cpp
// Function: cvc(int)
static int cvc(int i)
{  if (i < k0+2 || !cons(i) || cons(i-1) || !cons(i-2)) return FALSE;
   {  int ch = b[i];
      if (ch == 'w' || ch == 'x' || ch == 'y') return FALSE;
   }
   return TRUE;
}

// Assembly:
movslq 0x3236(%rip), %rdx      # 0x5094
leal 0x2(%rdx), %eax
cmpl %edi, %eax
jg 0x1f48
movq 0x3218(%rip), %rax      # 0x5088
movslq %edi, %rcx
xorl %esi, %esi
movq %rcx, %r8
movl $0x1, %r9d
movsbl (%rax,%r8), %r10d
addl $-0x61, %r10d
rorl %r10d
cmpl $0xc, %r10d
jne 0x1e9d
cmpq %r8, %rdx
je 0x1eb2
decq %r8
xorl $0x1, %esi
jmp 0x1e7e
cmpl $0xa, %r10d
ja 0x1eb2
movl $0x495, %r8d            # imm = 0x495
btl %r10d, %r8d
jae 0x1eb2
xorl %r9d, %r9d
cmpl %esi, %r9d
je 0x1f48
leal -0x1(%rdi), %esi
movslq %esi, %r8
xorl %esi, %esi
movl $0x1, %r9d
movsbl (%rax,%r8), %r10d
addl $-0x61, %r10d
rorl %r10d
cmpl $0xc, %r10d
jne 0x1ee8
cmpq %r8, %rdx
je 0x1efd
decq %r8
xorl $0x1, %esi
jmp 0x1ec9
cmpl $0xa, %r10d
ja 0x1efd
movl $0x495, %r8d            # imm = 0x495
btl %r10d, %r8d
jae 0x1efd
xorl %r9d, %r9d
cmpl %esi, %r9d
jne 0x1f48
addl $-0x2, %edi
movslq %edi, %rdi
xorl %esi, %esi
movl $0x1, %r8d
movsbl (%rax,%rdi), %r9d
addl $-0x61, %r9d
rorl %r9d
cmpl $0xc, %r9d
jne 0x1f2f
cmpq %rdi, %rdx
je 0x1f43
decq %rdi
xorl $0x1, %esi
jmp 0x1f10
cmpl $0xa, %r9d
ja 0x1f43
movl $0x495, %edx            # imm = 0x495
btl %r9d, %edx
jae 0x1f43
xorl %r8d, %r8d
cmpl %esi, %r8d
jne 0x1f4b
xorl %eax, %eax
retq
movb (%rax,%rcx), %cl
addb $-0x7a, %cl
xorl %eax, %eax
cmpb $-0x3, %cl
setb %al
retq
nop