LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: roberty65[P]bServer/frame/main/Connector.cpp
// Function: beyondy::Async::Connector::destroy()
int Connector::destroy()
{
	SYSLOG_ERROR("connector(%s) is cleared, outQ-size=%ld", address, (long)((outMsg == NULL ? 0 : 1) + outQueue->size()));

	if (inMsg != NULL) {
		Message::destroy(inMsg);
		inMsg = NULL;
	}

	if (outMsg != NULL) {
		outMsg->setRptr(0);	// reset it and re-send next time
		outQueue->push_front(outMsg);
		outMsg = NULL;
	}

	// keep other message in the queue
	// Need check timeout in the main-loop

	// DO NOT UNMAP FLOW
	emgr->deleteConnection(this);

	::close(fd); fd = -1;
	status = CONN_CLOSE;

	// re-connect sometime later
	gettimeofday(&tsLastClosed, NULL);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0xf33d(%rip), %rax      # 0x1a5e8
movq (%rax), %rdi
movl $0x2, %esi
callq 0x4b50
cmpl $0x0, %eax
je 0xb321
movq -0x10(%rbp), %rax
leaq 0xf320(%rip), %rcx      # 0x1a5e8
movq (%rcx), %rcx
movq %rcx, -0x20(%rbp)
movq %rax, %rcx
addq $0xb8, %rcx
movq %rcx, -0x18(%rbp)
movq 0x60(%rax), %rsi
movl $0x1, %ecx
xorl %edx, %edx
cmpq $0x0, %rsi
cmovel %edx, %ecx
movslq %ecx, %rcx
movq %rcx, -0x28(%rbp)
movq 0x68(%rax), %rdi
callq 0x8f20
movq -0x28(%rbp), %r8
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rcx
addq %rax, %r8
movl $0x2, %esi
leaq 0x7e01(%rip), %rdx      # 0x1311b
movb $0x0, %al
callq 0xbf40
jmp 0xb323
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0xb347
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0xc3b0
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0xb380
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb650
movq -0x10(%rbp), %rsi
movq 0x68(%rsi), %rdi
addq $0x60, %rsi
callq 0xb670
movq -0x10(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x10(%rbp), %rsi
movq 0x70(%rsi), %rdi
callq 0x7c30
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x3710
movq -0x10(%rbp), %rdi
movl $0xffffffff, 0x8(%rdi)  # imm = 0xFFFFFFFF
movl $0x0, 0xb4(%rdi)
addq $0xa0, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3630
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: roberty65[P]bServer/frame/main/Listener.cpp
// Function: beyondy::Async::Listener::createConnection(int)
Connection *Listener::createConnection(int cfd) 
{
	int flow = emgr->nextFlow();
	
	Connection *connection = new Connection(cfd, flow, emgr, inQueue, proc, CT_LISTENER, static_cast<void *>(this));
	if (connection != NULL) {
		emgr->mapFlow(flow, connection);
		emgr->addConnection(connection, EVENT_IN);
	}
	else {
		SYSLOG_ERROR("listener(%s) new Connection failed: %m", address);
	}
	
	return connection;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x98(%rax), %rdi
callq 0x7900
movl %eax, -0x10(%rbp)
movl $0x90, %edi
callq 0x33c0
movq -0x38(%rbp), %r10
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq 0x98(%r10), %rcx
movq 0xa0(%r10), %r8
movq 0xa8(%r10), %r9
movq %rsp, %rax
movq %r10, 0x8(%rax)
movl $0x0, (%rax)
callq 0x9770
jmp 0xbc3d
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xbc9a
movq -0x38(%rbp), %rax
movq 0x98(%rax), %rdi
movl -0x10(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x7920
movq -0x38(%rbp), %rax
movq 0x98(%rax), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x7a20
jmp 0xbcde
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x90, %esi
callq 0x33d0
jmp 0xbce8
jmp 0xbc9c
leaq 0xe945(%rip), %rax      # 0x1a5e8
movq (%rax), %rdi
movl $0x2, %esi
callq 0x4b50
cmpl $0x0, %eax
je 0xbcda
movq -0x38(%rbp), %rcx
leaq 0xe928(%rip), %rax      # 0x1a5e8
movq (%rax), %rdi
addq $0x10, %rcx
movl $0x2, %esi
leaq 0x7778(%rip), %rdx      # 0x1344b
movb $0x0, %al
callq 0xbf40
jmp 0xbcdc
jmp 0xbcde
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3690
nopw %cs:(%rax,%rax)
// File: roberty65[P]bServer/frame/main/Listener.cpp
// Function: beyondy::Async::Listener::destroyConnection(beyondy::Async::Connection*)
void Listener::destroyConnection(Connection *connection) 
{
	SYSLOG_INFO("listener(%s) close its connection: fd=%d, flow=%d", address, connection->fd, connection->flow);

	emgr->unmapFlow(connection);
	emgr->deleteConnection(connection);
	::close(connection->fd);

	--connActive;
	delete connection;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xe869(%rip), %rax      # 0x1a5e8
movq (%rax), %rdi
movl $0x4, %esi
callq 0x4b50
cmpl $0x0, %eax
je 0xbdc6
movq -0x18(%rbp), %rcx
leaq 0xe84c(%rip), %rax      # 0x1a5e8
movq (%rax), %rdi
addq $0x10, %rcx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %r8d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r9d
movl $0x4, %esi
leaq 0x76b3(%rip), %rdx      # 0x13472
movb $0x0, %al
callq 0xbf40
jmp 0xbdc8
movq -0x18(%rbp), %rax
movq 0x98(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x7ef0
movq -0x18(%rbp), %rax
movq 0x98(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x7c30
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x3710
movq -0x18(%rbp), %rax
movl 0x90(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x90(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xbe27
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: roberty65[P]bServer/frame/main/Listener.cpp
// Function: beyondy::Async::Listener::open()
int Listener::open()
{
	fd = XbsServer(address, 1024, O_NONBLOCK);
	if (fd < 0) {
		SYSLOG_ERROR("listener(%s) open failed: %m", address);
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x10, %rdi
movl $0x400, %esi            # imm = 0x400
movl $0x800, %edx            # imm = 0x800
movl $0x3, %ecx
callq 0xcd50
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
cmpl $0x0, 0x8(%rax)
jge 0xbeb6
jmp 0xbe6d
leaq 0xe774(%rip), %rax      # 0x1a5e8
movq (%rax), %rdi
movl $0x2, %esi
callq 0x4b50
cmpl $0x0, %eax
je 0xbeab
movq -0x18(%rbp), %rcx
leaq 0xe757(%rip), %rax      # 0x1a5e8
movq (%rax), %rdi
addq $0x10, %rcx
movl $0x2, %esi
leaq 0x7600(%rip), %rdx      # 0x134a4
movb $0x0, %al
callq 0xbf40
jmp 0xbead
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xbebd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: roberty65[P]bServer/common/src/xbs_socket.cpp
// Function: beyondy::XbsConnect(int, sockaddr const*, unsigned int, long)
int XbsConnect(int fd, const struct sockaddr *target, socklen_t alen, long timedout)
{
	int retval = connect(fd, target, alen);
	if (retval == -1) {
		if (timedout < 1)
			return 0;	// with errno

		if (errno == EINPROGRESS) {
			if (XbsWaitWritable(fd, timedout) < 0) {
				return -1;
			}

			if ((retval = XbsGetError(fd)) != 0) {
				errno = retval;
				return -1;
			}

			errno = 0;	// clear errno
			return 0;
		}
		else {
			return -1;
		}
	}
	
	errno = 0;	// clear errno
	return 0;	// good?!
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x3330
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0xc7b8
cmpq $0x1, -0x20(%rbp)
jge 0xc74e
movl $0x0, -0x4(%rbp)
jmp 0xc7ca
callq 0x3060
cmpl $0x73, (%rax)
jne 0xc7af
movl -0x8(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x10ca0
cmpl $0x0, %eax
jge 0xc772
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc7ca
movl -0x8(%rbp), %edi
callq 0xc7e0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0xc79b
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
callq 0x3060
movl -0x28(%rbp), %ecx
movl %ecx, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc7ca
callq 0x3060
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xc7ca
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc7ca
callq 0x3060
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: roberty65[P]bServer/common/src/xbs_socket.cpp
// Function: beyondy::XbsGetPeername(int, char*, unsigned long)
int XbsGetPeername(int fd, char *nbuf, size_t size)
{
	struct sockaddr_storage addr_buf;
	int type = 0;
	socklen_t addr_len = sizeof(addr_buf);
	socklen_t tlen = sizeof(type);

	if (getpeername(fd, (struct sockaddr *)&addr_buf, &addr_len) < 0) return -1;
	if (getsockopt(fd, SOL_SOCKET, SO_TYPE, &type, &tlen) < 0) return -1;

	return sockaddr2str((struct sockaddr *)&addr_buf, type, nbuf, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x9c(%rbp)
movl $0x80, -0xa0(%rbp)
movl $0x4, -0xa4(%rbp)
movl -0x8(%rbp), %edi
leaq -0x98(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x32a0
cmpl $0x0, %eax
jge 0xc908
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc953
movl -0x8(%rbp), %edi
movl $0x1, %esi
movl $0x3, %edx
leaq -0x9c(%rbp), %rcx
leaq -0xa4(%rbp), %r8
callq 0x32c0
cmpl $0x0, %eax
jge 0xc936
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc953
movl -0x9c(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x98(%rbp), %rdi
callq 0x108c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: roberty65[P]bServer/common/src/xbs_socket.cpp
// Function: beyondy::XbsGetLocalname(int, char*, unsigned long)
int XbsGetLocalname(int fd, char *nbuf, size_t size)
{
	struct sockaddr_storage addr_buf;
	int type = 0;
	socklen_t addr_len = sizeof(addr_buf);
	socklen_t tlen = sizeof(type);

	if (getsockname(fd, (struct sockaddr *)&addr_buf, &addr_len) < 0) return -1;
	if (getsockopt(fd, SOL_SOCKET, SO_TYPE, &type, &tlen) < 0) return -1;

	return sockaddr2str((struct sockaddr *)&addr_buf, type, nbuf, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x9c(%rbp)
movl $0x80, -0xa0(%rbp)
movl $0x4, -0xa4(%rbp)
movl -0x8(%rbp), %edi
leaq -0x98(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x3380
cmpl $0x0, %eax
jge 0xc9b8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca03
movl -0x8(%rbp), %edi
movl $0x1, %esi
movl $0x3, %edx
leaq -0x9c(%rbp), %rcx
leaq -0xa4(%rbp), %r8
callq 0x32c0
cmpl $0x0, %eax
jge 0xc9e6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca03
movl -0x9c(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x98(%rbp), %rdi
callq 0x108c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: roberty65[P]bServer/common/src/xbs_socket.cpp
// Function: beyondy::XbsGetReuse(int)
int XbsGetReuse (int fd)
{
	int address = 0, port = 0;
	socklen_t addrlen = sizeof(address);

	if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &address, addrlen) < 0) return -1;

#ifdef SOL_REUSEPORT
	socklen_t plen = sizeof(port);
	if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &port, plen) < 0) return -1;
#endif /* SOL_REUSEPORT */

	return (port ? XBS_REUSE_PORT : 0) | (address ? XBS_REUSE_ADDR : 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x4, -0x14(%rbp)
movl -0x8(%rbp), %edi
movl -0x14(%rbp), %r8d
movl $0x1, %esi
movl $0x2, %edx
leaq -0xc(%rbp), %rcx
callq 0x36b0
cmpl $0x0, %eax
jge 0xccb8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xccdd
movl -0x10(%rbp), %edx
xorl %eax, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl -0xc(%rbp), %esi
xorl %ecx, %ecx
movl $0x1, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: roberty65[P]bServer/common/src/xbs_socket.cpp
// Function: beyondy::XbsServer(char const*, int, int, int)
int XbsServer(const char *address, int backlog, int flags, int reuse)
{
	struct sockaddr_storage addr_buf;
	socklen_t addr_len = sizeof(addr_buf);
	int type;
	int fd;

	if (str2sockaddr(address, &type, (struct sockaddr *)&addr_buf, &addr_len, 1) < 0) goto error_out;
	if ((fd = XbsSocket(addr_buf.ss_family, type, 0)) < 0) goto error_out;
	if (flags && XbsSetFlags(fd, flags, 0) < 0) goto error_close;
	if (XbsSetReuse(fd, reuse) < 0) goto error_close;
	if (bind(fd, (struct sockaddr *)&addr_buf, addr_len) < 0) goto error_close;
	if (type == SOCK_STREAM && listen(fd, backlog) < 0) goto error_close;
	return fd;
error_close:
	close(fd);
error_out:
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x80, -0xa4(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
leaq -0xa4(%rbp), %rcx
movl $0x1, %r8d
callq 0x10500
cmpl $0x0, %eax
jge 0xcda0
jmp 0xce49
movzwl -0xa0(%rbp), %edi
movl -0xa8(%rbp), %esi
xorl %edx, %edx
callq 0xc600
movl %eax, -0xac(%rbp)
cmpl $0x0, %eax
jge 0xcdc4
jmp 0xce49
cmpl $0x0, -0x18(%rbp)
je 0xcde1
movl -0xac(%rbp), %edi
movl -0x18(%rbp), %esi
xorl %edx, %edx
callq 0xca10
cmpl $0x0, %eax
jge 0xcde1
jmp 0xce3e
movl -0xac(%rbp), %edi
movl -0x1c(%rbp), %esi
callq 0xca60
cmpl $0x0, %eax
jge 0xcdf6
jmp 0xce3e
movl -0xac(%rbp), %edi
movl -0xa4(%rbp), %edx
leaq -0xa0(%rbp), %rsi
callq 0x3080
cmpl $0x0, %eax
jge 0xce15
jmp 0xce3e
cmpl $0x1, -0xa8(%rbp)
jne 0xce33
movl -0xac(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0x3480
cmpl $0x0, %eax
jge 0xce33
jmp 0xce3e
movl -0xac(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xce50
movl -0xac(%rbp), %edi
callq 0x3710
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: roberty65[P]bServer/common/src/xbs_socket.cpp
// Function: beyondy::XbsClient(char const*, int, long)
int XbsClient(const char *address, int flags, long timedout)
{
	struct sockaddr_storage addr_buf;
	socklen_t addr_len = sizeof(addr_buf);
	int type;
	int fd;

	if (str2sockaddr(address, &type, (struct sockaddr *)&addr_buf, &addr_len, 1) < 1) goto error_out;
	if ((fd = XbsSocket(addr_buf.ss_family, type, 0)) < 0) goto error_out;
	if (flags && XbsSetFlags(fd, flags, 0) < 0) goto error_close;
	if (XbsConnect(fd, (struct sockaddr *)&addr_buf, addr_len, timedout) < 0) goto error_close;
	return fd;
error_close:
	close(fd);
error_out:
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x80, -0xa4(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
leaq -0xa4(%rbp), %rcx
movl $0x1, %r8d
callq 0x10500
cmpl $0x1, %eax
jge 0xceab
jmp 0xcf22
movzwl -0xa0(%rbp), %edi
movl -0xa8(%rbp), %esi
xorl %edx, %edx
callq 0xc600
movl %eax, -0xac(%rbp)
cmpl $0x0, %eax
jge 0xcecc
jmp 0xcf22
cmpl $0x0, -0x14(%rbp)
je 0xcee9
movl -0xac(%rbp), %edi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0xca10
cmpl $0x0, %eax
jge 0xcee9
jmp 0xcf17
movl -0xac(%rbp), %edi
movl -0xa4(%rbp), %edx
movq -0x20(%rbp), %rcx
leaq -0xa0(%rbp), %rsi
callq 0xc710
cmpl $0x0, %eax
jge 0xcf0c
jmp 0xcf17
movl -0xac(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcf29
movl -0xac(%rbp), %edi
callq 0x3710
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: roberty65[P]bServer/common/src/rbtree.c
// Function: _rb_rotate_left
static void __rb_rotate_left(struct rb_node *node, struct rb_root *root)
{
	struct rb_node *right = node->rb_right;
	struct rb_node *parent = rb_parent(node);

	if ((node->rb_right = right->rb_left))
		rb_set_parent(right->rb_left, node);
	right->rb_left = node;

	rb_set_parent(right, parent);

	if (parent)
	{
		if (node == parent->rb_left)
			parent->rb_left = right;
		else
			parent->rb_right = right;
	}
	else
		root->rb_node = right;
	rb_set_parent(node, right);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $-0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
je 0xd1b2
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xd510
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xd510
cmpq $0x0, -0x20(%rbp)
je 0xd1fc
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0xd1ee
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xd1fa
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xd207
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd510
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: roberty65[P]bServer/common/src/rbtree.c
// Function: _rb_rotate_right
static void __rb_rotate_right(struct rb_node *node, struct rb_root *root)
{
	struct rb_node *left = node->rb_left;
	struct rb_node *parent = rb_parent(node);

	if ((node->rb_left = left->rb_right))
		rb_set_parent(left->rb_right, node);
	left->rb_right = node;

	rb_set_parent(left, parent);

	if (parent)
	{
		if (node == parent->rb_right)
			parent->rb_right = left;
		else
			parent->rb_left = left;
	}
	else
		root->rb_node = left;
	rb_set_parent(node, left);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $-0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
je 0xd272
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xd510
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xd510
cmpq $0x0, -0x20(%rbp)
je 0xd2bc
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0xd2ae
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xd2ba
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xd2c7
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd510
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: roberty65[P]bServer/common/src/rbtree.c
// Function: rb_first
struct rb_node *rb_first(struct rb_root *root)
{
	struct rb_node	*n;

	n = root->rb_node;
	if (!n)
		return 0; //NULL;
	while (n->rb_left)
		n = n->rb_left;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd914
movq $0x0, -0x8(%rbp)
jmp 0xd937
jmp 0xd916
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xd92f
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xd916
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: roberty65[P]bServer/common/src/rbtree.c
// Function: rb_last
struct rb_node *rb_last(struct rb_root *root)
{
	struct rb_node	*n;

	n = root->rb_node;
	if (!n)
		return 0; //NULL;
	while (n->rb_right)
		n = n->rb_right;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd964
movq $0x0, -0x8(%rbp)
jmp 0xd987
jmp 0xd966
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd97f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xd966
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: roberty65[P]bServer/common/src/rbtree.c
// Function: rb_next
struct rb_node *rb_next(struct rb_node *node)
{
	struct rb_node *parent;

	/* If we have a right-hand child, go down and then left as far
	   as we can. */
	if (node->rb_right) {
		node = node->rb_right; 
		while (node->rb_left)
			node=node->rb_left;
		return node;
	}

	/* No right-hand children.  Everything down and left is
	   smaller than us, so any 'next' node must be in the general
	   direction of our parent. Go up the tree; any time the
	   ancestor is a right-hand child of its parent, keep going
	   up. First time it's a left-hand child of its parent, said
	   parent is our 'next' node. */
	while ((parent = rb_parent(node)) && node == parent->rb_right)
		node = parent;

	return parent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd9d2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xd9c8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xd9af
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xda1b
jmp 0xd9d4
movq -0x10(%rbp), %rax
movq (%rax), %rcx
andq $-0x4, %rcx
movq %rcx, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x19(%rbp)
je 0xda00
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xda09
jmp 0xda13
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xd9d4
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: roberty65[P]bServer/common/src/rbtree.c
// Function: rb_prev
struct rb_node *rb_prev(struct rb_node *node)
{
	struct rb_node *parent;

	/* If we have a left-hand child, go down and then right as far
	   as we can. */
	if (node->rb_left) {
		node = node->rb_left; 
		while (node->rb_right)
			node=node->rb_right;
		return node;
	}

	/* No left-hand children. Go up till we find an ancestor which
	   is a right-hand child of its parent */
	while ((parent = rb_parent(node)) && node == parent->rb_left)
		node = parent;

	return parent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xda72
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xda68
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xda4f
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xdabb
jmp 0xda74
movq -0x10(%rbp), %rax
movq (%rax), %rcx
andq $-0x4, %rcx
movq %rcx, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x19(%rbp)
je 0xdaa0
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xdaa9
jmp 0xdab3
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xda74
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: roberty65[P]bServer/common/src/rbtree.c
// Function: rb_replace_node
void rb_replace_node(struct rb_node *victim, struct rb_node *newn,
		     struct rb_root *root)
{
	struct rb_node *parent = rb_parent(victim);

	/* Set the surrounding nodes to point to the replacement */
	if (parent) {
		if (victim == parent->rb_left)
			parent->rb_left = newn;
		else
			parent->rb_right = newn;
	} else {
		root->rb_node = newn;
	}
	if (victim->rb_left)
		rb_set_parent(victim->rb_left, newn);
	if (victim->rb_right)
		rb_set_parent(victim->rb_right, newn);

	/* Copy the pointers/colour from the victim to the replacement */
	*newn = *victim;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $-0x4, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xdb24
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0xdb16
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xdb22
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xdb2f
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xdb4b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd510
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xdb67
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd510
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: roberty65[P]bServer/common/src/ConfigProperty.cpp
// Function: ConfigProperty::getInt(char const*, int) const
int ConfigProperty::getInt(const char *name, int def) const
{
	const char *val = getString(name, NULL);
	if (val == NULL || strlen(val) == 0) return def;

	char *eptr;
	int v = strtol(val, &eptr, 0);
	if (eptr == val) {
		// invalid number
		if (!strcasecmp(val, "true")  || !strcasecmp(val, "yes") || !strcasecmp(val, "t")  || !strcasecmp(val, "y"))
			return 1;
		if (!strcasecmp(val, "false") || !strcasecmp(val, "no") || !strcasecmp(val, "f") || !strcasecmp(val, "n"))
			return 0;
		return def;
	}

	if (*eptr == 'k' || *eptr == 'K') v *= 1024;
	else if (*eptr == 'm' || *eptr == 'M') v *= 1024 * 1024;
	else if (*eptr == 'g' || *eptr == 'G') v *= 1024 * 1024 * 1024;
	/* ignore others */

	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xe1f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xe3be
movq -0x28(%rbp), %rdi
callq 0x3170
cmpq $0x0, %rax
jne 0xe3c9
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe51f
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x3590
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0xe4ae
movq -0x28(%rbp), %rdi
leaq 0x5147(%rip), %rsi      # 0x1353b
callq 0x3440
cmpl $0x0, %eax
je 0xe43d
movq -0x28(%rbp), %rdi
leaq 0x5137(%rip), %rsi      # 0x13540
callq 0x3440
cmpl $0x0, %eax
je 0xe43d
movq -0x28(%rbp), %rdi
leaq 0x4389(%rip), %rsi      # 0x127a7
callq 0x3440
cmpl $0x0, %eax
je 0xe43d
movq -0x28(%rbp), %rdi
leaq 0x3fdc(%rip), %rsi      # 0x1240f
callq 0x3440
cmpl $0x0, %eax
jne 0xe449
movl $0x1, -0x4(%rbp)
jmp 0xe51f
movq -0x28(%rbp), %rdi
leaq 0x50f0(%rip), %rsi      # 0x13544
callq 0x3440
cmpl $0x0, %eax
je 0xe49d
movq -0x28(%rbp), %rdi
leaq 0x50e1(%rip), %rsi      # 0x1354a
callq 0x3440
cmpl $0x0, %eax
je 0xe49d
movq -0x28(%rbp), %rdi
leaq 0x3cfb(%rip), %rsi      # 0x12179
callq 0x3440
cmpl $0x0, %eax
je 0xe49d
movq -0x28(%rbp), %rdi
leaq 0x3ea1(%rip), %rsi      # 0x12334
callq 0x3440
cmpl $0x0, %eax
jne 0xe4a6
movl $0x0, -0x4(%rbp)
jmp 0xe51f
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe51f
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6b, %eax
je 0xe4c6
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4b, %eax
jne 0xe4d1
movl -0x34(%rbp), %eax
shll $0xa, %eax
movl %eax, -0x34(%rbp)
jmp 0xe519
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6d, %eax
je 0xe4e9
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4d, %eax
jne 0xe4f4
movl -0x34(%rbp), %eax
shll $0x14, %eax
movl %eax, -0x34(%rbp)
jmp 0xe517
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x67, %eax
je 0xe50c
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x47, %eax
jne 0xe515
movl -0x34(%rbp), %eax
shll $0x1e, %eax
movl %eax, -0x34(%rbp)
jmp 0xe517
jmp 0xe519
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: roberty65[P]bServer/common/src/xbs_naddr.cpp
// Function: beyondy::__unix_str2sockaddr(char const*, sockaddr*, unsigned int*, int)
static int __unix_str2sockaddr(const char *host, struct sockaddr *naddr, socklen_t *nlen, int count)
{
	struct sockaddr_un *unaddr = (struct sockaddr_un *)&naddr[0];
	nlen[0] = sizeof(*unaddr);

	unaddr->sun_family = AF_UNIX;
	strncpy(unaddr->sun_path, host, sizeof unaddr->sun_path);
	unaddr->sun_path[sizeof unaddr->sun_path - 1] = '\0';

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl $0x6e, (%rax)
movq -0x28(%rbp), %rax
movw $0x1, (%rax)
movq -0x28(%rbp), %rdi
addq $0x2, %rdi
movq -0x8(%rbp), %rsi
movl $0x6c, %edx
callq 0x31b0
movq -0x28(%rbp), %rax
movb $0x0, 0x6d(%rax)
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: roberty65[P]bServer/common/src/xbs_naddr.cpp
// Function: beyondy::__inet_str2sockaddr(int, char const*, char const*, sockaddr*, unsigned int*, int)
static int __inet_str2sockaddr(int type, const char *host, const char *serv, struct sockaddr *naddr, socklen_t *nlen, int count)
{
	struct addrinfo hints;
	struct addrinfo *result = NULL, *next;
	int i;

	memset((void *)&hints, 0, sizeof(hints));
	hints.ai_family = AF_UNSPEC;	/* Allow IPv4 or IPv6 */
	hints.ai_socktype = type;	/* TCP/UDP */
	hints.ai_flags = AI_PASSIVE;	/* For wildcard IP address */
	hints.ai_protocol = 0;		/* Any protocol */

	if (strcmp(host, "*") == 0)
		host = NULL;
	if ((errno = getaddrinfo(host, serv, &hints, &result)) != 0)
		return -1;

	next = result;
	for (i = 0; i < count && next != NULL; ++i) {
		if (next->ai_socktype != type)
			continue;	/* should not have such case */	
		if (next->ai_family == AF_INET || next->ai_family == AF_INET6) {
			memcpy(&naddr[i], next->ai_addr, next->ai_addrlen);
			nlen[i] = next->ai_addrlen;
		}

		next = next->ai_next;
	}	

	freeaddrinfo(result);
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq $0x0, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x31f0
movl $0x0, -0x5c(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x58(%rbp)
movl $0x1, -0x60(%rbp)
movl $0x0, -0x54(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2db3(%rip), %rsi      # 0x13563
callq 0x3570
cmpl $0x0, %eax
jne 0x107c2
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x60(%rbp), %rdx
leaq -0x68(%rbp), %rcx
callq 0x3510
movl %eax, -0x78(%rbp)
callq 0x3060
movq %rax, %rcx
movl -0x78(%rbp), %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
je 0x107f8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x108aa
movq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0x0, -0x74(%rbp)
movl -0x74(%rbp), %ecx
xorl %eax, %eax
cmpl -0x2c(%rbp), %ecx
movb %al, -0x79(%rbp)
jge 0x1081f
cmpq $0x0, -0x70(%rbp)
setne %al
movb %al, -0x79(%rbp)
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x10828
jmp 0x1089b
movq -0x70(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x8(%rbp), %eax
je 0x10836
jmp 0x1088d
movq -0x70(%rbp), %rax
cmpl $0x2, 0x4(%rax)
je 0x1084a
movq -0x70(%rbp), %rax
cmpl $0xa, 0x4(%rax)
jne 0x10881
movq -0x20(%rbp), %rdi
movslq -0x74(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x70(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x70(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %edx
callq 0x3320
movq -0x70(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x28(%rbp), %rax
movslq -0x74(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x70(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x70(%rbp)
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x10807
movq -0x68(%rbp), %rdi
callq 0x3530
movl -0x74(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: roberty65[P]bServer/common/src/xbs_naddr.cpp
// Function: beyondy::sockaddr2str(sockaddr const*, int, char*, unsigned long)
int sockaddr2str(const struct sockaddr *naddr, int type, char *address, size_t addrlen)
{
	if (naddr->sa_family == PF_UNIX || naddr->sa_family == PF_LOCAL) {
		return __unix_naddr2str((struct sockaddr_un *)naddr, type, address, addrlen);
	}
	else if (naddr->sa_family == PF_INET) {
		return __inet_naddr2str((struct sockaddr_in *)naddr, type, address, addrlen);
	}
	else if (naddr->sa_family == PF_INET6) {
		return __inet6_naddr2str((struct sockaddr_in6 *)naddr, type, address, addrlen);
	}

	errno = EAFNOSUPPORT;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x1, %eax
je 0x108ef
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x1, %eax
jne 0x10908
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x10980
movl %eax, -0x4(%rbp)
jmp 0x10968
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x2, %eax
jne 0x1092d
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x10a20
movl %eax, -0x4(%rbp)
jmp 0x10968
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0xa, %eax
jne 0x10952
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x10b00
movl %eax, -0x4(%rbp)
jmp 0x10968
jmp 0x10954
jmp 0x10956
callq 0x3060
movl $0x61, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: roberty65[P]bServer/common/src/xbs_naddr.cpp
// Function: beyondy::__unix_naddr2str(sockaddr_un const*, int, char*, unsigned long)
static int __unix_naddr2str(const struct sockaddr_un *unaddr, int type, char *address, size_t addrlen)
{
	int slen = snprintf(address, addrlen, "%s@%s",
			type == SOCK_STREAM ? "tcp://" : "udp://",
			unaddr->sun_path);
	if ((slen < 0 || slen >= (int)addrlen) && addrlen > 0) address[addrlen - 1] = '\0';
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x109ba
leaq 0x2ba1(%rip), %rax      # 0x13555
movq %rax, -0x40(%rbp)
jmp 0x109c7
leaq 0x2b9b(%rip), %rax      # 0x1355c
movq %rax, -0x40(%rbp)
jmp 0x109c7
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rcx
movq -0x8(%rbp), %r8
addq $0x2, %r8
leaq 0x2b83(%rip), %rdx      # 0x13565
movb $0x0, %al
callq 0x3620
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x109fd
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl %ecx, %eax
jl 0x10a14
cmpq $0x0, -0x20(%rbp)
jbe 0x10a14
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: roberty65[P]bServer/common/src/xbs_naddr.cpp
// Function: beyondy::__inet_naddr2str(sockaddr_in const*, int, char*, unsigned long)
static int __inet_naddr2str(const struct sockaddr_in *inaddr, int type, char *address, size_t addrlen)
{
	char ibuf[INET_ADDRSTRLEN];
	int slen;

	inet_ntop(inaddr->sin_family, (void *)&inaddr->sin_addr, ibuf, sizeof(ibuf));
	slen = snprintf(address, addrlen, "%s%s:%d",
			type == SOCK_STREAM ? "tcp://" : "udp://",
			ibuf, ntohs(inaddr->sin_port));
	if ((slen < 0 || slen >= (int)addrlen) && addrlen > 0) address[addrlen - 1] = 0;	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %edi
movq -0x8(%rbp), %rsi
addq $0x4, %rsi
leaq -0x30(%rbp), %rdx
movl $0x10, %ecx
callq 0x3410
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x10a77
leaq 0x2ae4(%rip), %rax      # 0x13555
movq %rax, -0x50(%rbp)
jmp 0x10a84
leaq 0x2ade(%rip), %rax      # 0x1355c
movq %rax, -0x50(%rbp)
jmp 0x10a84
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x36e0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %r8
movzwl %ax, %r9d
leaq 0x2aaf(%rip), %rdx      # 0x1356b
movb $0x0, %al
callq 0x3620
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x10ad7
movl -0x34(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl %ecx, %eax
jl 0x10aee
cmpq $0x0, -0x20(%rbp)
jbe 0x10aee
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: roberty65[P]bServer/common/src/xbs_naddr.cpp
// Function: beyondy::__inet6_naddr2str(sockaddr_in6 const*, int, char*, unsigned long)
static int __inet6_naddr2str(const struct sockaddr_in6 *inaddr, int type, char *address, size_t addrlen)
{
	char ibuf[INET_ADDRSTRLEN];
	int slen;

	inet_ntop(inaddr->sin6_family, (void *)&inaddr->sin6_addr, ibuf, sizeof(ibuf));
	slen = snprintf(address, addrlen, "%s%s:%d",
			type == SOCK_STREAM ? "tcp://" : "udp://",
			ibuf, ntohs(inaddr->sin6_port));
	if ((slen < 0 || slen >= (int)addrlen) && addrlen > 0) address[addrlen - 1] = 0;	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %edi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
leaq -0x30(%rbp), %rdx
movl $0x10, %ecx
callq 0x3410
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x10b57
leaq 0x2a04(%rip), %rax      # 0x13555
movq %rax, -0x50(%rbp)
jmp 0x10b64
leaq 0x29fe(%rip), %rax      # 0x1355c
movq %rax, -0x50(%rbp)
jmp 0x10b64
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x36e0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %r8
movzwl %ax, %r9d
leaq 0x29cf(%rip), %rdx      # 0x1356b
movb $0x0, %al
callq 0x3620
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x10bb7
movl -0x34(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl %ecx, %eax
jl 0x10bce
cmpq $0x0, -0x20(%rbp)
jbe 0x10bce
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: roberty65[P]bServer/common/src/xbs_io.cpp
// Function: beyondy::XbsWaitPollable(int, short, long)
int XbsWaitPollable(int fd, short events, long msTimedout)
{
	struct pollfd pfd = { fd, events, 0 };
	int nfd = poll(&pfd, 1, msTimedout);

	if (nfd < 0) return -1;
	if (nfd == 0) return errno = ETIMEDOUT, -1;
	return pfd.revents;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movl %edi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
movw -0xa(%rbp), %ax
movw %ax, -0x1c(%rbp)
movw $0x0, -0x1a(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %edx
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x35f0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x10c70
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10c91
cmpl $0x0, -0x24(%rbp)
jne 0x10c8a
callq 0x3060
movl $0x6e, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10c91
movswl -0x1a(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: roberty65[P]bServer/common/src/xbs_io.cpp
// Function: beyondy::XbsWriteN(int, void const*, unsigned long, long)
ssize_t XbsWriteN(int fd, const void *buf, size_t size, long msTimedout)
{
	if (size == 0) return 0;

	TimedoutCountdown toCountdown(msTimedout);
	size_t sed = 0;
	ssize_t slen;

	do {
		if (XbsWaitWritable(fd, toCountdown.Update()) < 0) goto out;
		if ((slen = write(fd, (char *)buf + sed, size - sed)) < 0) goto out;
		sed += static_cast<size_t>(slen);
	} while (sed < size);
out:
	return (sed > 0) ? static_cast<ssize_t>(sed) : -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x10d5b
movq $0x0, -0x8(%rbp)
jmp 0x10df7
movq -0x28(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x111a0
movq $0x0, -0x48(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x111d0
movl -0x54(%rbp), %edi
movq %rax, %rsi
callq 0x10ca0
cmpl $0x0, %eax
jge 0x10d95
jmp 0x10dd1
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
addq -0x48(%rbp), %rsi
movq -0x20(%rbp), %rdx
subq -0x48(%rbp), %rdx
callq 0x3100
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
jge 0x10db9
jmp 0x10dd1
movq -0x50(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x10d70
jmp 0x10dd1
cmpq $0x0, -0x48(%rbp)
jbe 0x10de2
movq -0x48(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x10def
movq $-0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x10def
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: roberty65[P]bServer/common/src/xbs_io.cpp
// Function: beyondy::XbsReadN(int, void*, unsigned long, long)
ssize_t XbsReadN(int fd, void *buf, size_t size, long msTimedout)
{
	TimedoutCountdown toCountdown(msTimedout);
	ssize_t red = 0, rlen = -1;

	do {
		if (XbsWaitReadable(fd, toCountdown.Update()) < 0) goto out;
		if ((rlen = read(fd, (char *)buf + red, size - red)) < 1) goto out;
		red += rlen;
	} while (red < (ssize_t)size);
out:
	if (red > 0) {
		return red;
	}
	else if (rlen == 0) {
		return 0;
	}

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x111a0
movq $0x0, -0x48(%rbp)
movq $-0x1, -0x50(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x111d0
movl -0x54(%rbp), %edi
movq %rax, %rsi
callq 0x10be0
cmpl $0x0, %eax
jge 0x110e9
jmp 0x11125
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
addq -0x48(%rbp), %rsi
movq -0x20(%rbp), %rdx
subq -0x48(%rbp), %rdx
callq 0x35b0
movq %rax, -0x50(%rbp)
cmpq $0x1, %rax
jge 0x1110d
jmp 0x11125
movq -0x50(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x20(%rbp), %rax
jl 0x110c4
jmp 0x11125
cmpq $0x0, -0x48(%rbp)
jle 0x11136
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11151
cmpq $0x0, -0x50(%rbp)
jne 0x11147
movq $0x0, -0x8(%rbp)
jmp 0x11151
jmp 0x11149
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: roberty65[P]bServer/common/src/../include/beyondy/timedout_countdown.hpp
// Function: beyondy::TimedoutCountdown::Update(long*) const
long Update(long *during = NULL) const {
		if (timedout_ < 0) return -1;		// never timeout

		long past = During();
		if (during != NULL) *during = past;
		past = timedout_  - past;

		return (past < 1) ? 0 : past;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
jge 0x111f8
movq $-0x1, -0x8(%rbp)
jmp 0x11245
movq -0x28(%rbp), %rdi
callq 0x11250
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x11217
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
jge 0x11235
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x1123d
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: roberty65[P]bServer/common/src/../include/beyondy/timedout_countdown.hpp
// Function: beyondy::TimedoutCountdown::During() const
long During() const {
		struct timeval tn;
		gettimeofday(&tn, NULL);
		return (tn.tv_sec  - start_tv_.tv_sec ) * 1000 + \
		       (tn.tv_usec - start_tv_.tv_usec) / 1000;
	}

// 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 %eax, %eax
movl %eax, %esi
callq 0x3630
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
subq 0x8(%rcx), %rax
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
subq 0x10(%rcx), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
// File: AshOlogn[P]ash-language-interpreter/src/main.cpp
// Function: getLines(char*)
vector<char*>* getLines(char* code) {
  
  vector<char*>* lines = new vector<char*>();
  uint32_t codeIndex = 0;
  
  while(code[codeIndex]) {
    
    //edge cases
    if(code[codeIndex] == '\n') {
      char* c = new char[2];
      c[0] = '\n'; c[1] = '\0';
      lines->push_back(c);
      codeIndex++;
      continue;
    }
    
    //setup
    uint32_t start = codeIndex;
    uint32_t end = codeIndex;
    
    while(code[end] != '\n' && code[end] != '\0') {
      end++;
    }
    
    char* c = new char[end-start+2];
    for(uint32_t i = start; i < end; i++) {
      c[i-start] = code[i];
    }
    c[end-start] = '\n';
    c[end-start+1] = '\0';

    lines->push_back(c);
    codeIndex = end+1;
  }
  
  return lines;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
callq 0x4260
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x4160
movq -0x40(%rbp), %rdi
callq 0x5420
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
cmpb $0x0, (%rax,%rcx)
je 0x5216
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x5147
movl $0x2, %edi
callq 0x4030
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0xa, (%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5440
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x50f1
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x41(%rbp)
je 0x517c
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x5185
jmp 0x5190
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x5153
movl -0x28(%rbp), %eax
subl -0x24(%rbp), %eax
addl $0x2, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x4030
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x51d8
movq -0x8(%rbp), %rax
movl -0x34(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
subl -0x24(%rbp), %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x51ac
movq -0x30(%rbp), %rax
movl -0x28(%rbp), %ecx
subl -0x24(%rbp), %ecx
movl %ecx, %ecx
movb $0xa, (%rax,%rcx)
movq -0x30(%rbp), %rax
movl -0x28(%rbp), %ecx
subl -0x24(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5440
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x50f1
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq