LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: so_pipeign
static int so_pipeign(struct socket *so, _Bool rdonly) {
	if (!so_needign(so, rdonly))
		return 0;

#if _POSIX_REALTIME_SIGNALS > 0
	if (so->pipeign.ncalls++ > 0)
		return 0;

	sigemptyset(&so->pipeign.pending);
	sigpending(&so->pipeign.pending);

	if (sigismember(&so->pipeign.pending, SIGPIPE))
		return 0;

	sigset_t piped;
	sigemptyset(&piped);
	sigaddset(&piped, SIGPIPE);
	sigemptyset(&so->pipeign.blocked);

	return thr_sigmask(SIG_BLOCK, &piped, &so->pipeign.blocked);
#else
	return EOPNOTSUPP;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x31420
testb $0x1, %al
jne 0x2e898
movl $0x0, -0x4(%rbp)
jmp 0x2e964
movq -0x10(%rbp), %rcx
movl 0x108(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x108(%rcx)
cmpl $0x0, %eax
jle 0x2e8be
movl $0x0, -0x4(%rbp)
jmp 0x2e964
movq -0x10(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
addq $0x8, %rdi
callq 0x10150
movq -0x10(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
addq $0x8, %rdi
callq 0xf350
movq -0x10(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
addq $0x8, %rdi
movl $0xd, %esi
callq 0xf690
cmpl $0x0, %eax
je 0x2e90d
movl $0x0, -0x4(%rbp)
jmp 0x2e964
leaq -0x98(%rbp), %rdi
callq 0x10150
leaq -0x98(%rbp), %rdi
movl $0xd, %esi
callq 0x10660
movq -0x10(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
addq $0x88, %rdi
callq 0x10150
movq -0x10(%rbp), %rdx
addq $0x108, %rdx            # imm = 0x108
addq $0x88, %rdx
xorl %edi, %edi
leaq -0x98(%rbp), %rsi
callq 0x314b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: ssl_error
static int ssl_error(SSL *ctx, int rval, short *events) {
	unsigned long code;

	switch (SSL_get_error(ctx, rval)) {
	case SSL_ERROR_ZERO_RETURN:
		return SO_ECLOSURE;
	case SSL_ERROR_WANT_READ:
		*events |= POLLIN;

		return SO_EAGAIN;
	case SSL_ERROR_WANT_WRITE:
		*events |= POLLOUT;

		return SO_EAGAIN;
	case SSL_ERROR_WANT_CONNECT:
		*events |= POLLOUT;

		return SO_EAGAIN;
	case SSL_ERROR_WANT_ACCEPT:
		*events |= POLLIN;

		return SO_EAGAIN;
	case SSL_ERROR_WANT_X509_LOOKUP:
		return SO_EX509INT;
	case SSL_ERROR_SYSCALL:
		if ((code = ERR_peek_last_error()))
			return SO_EOPENSSL;
		else if (rval == 0)
			return ECONNRESET;
		else if (rval == -1 && so_soerr() && so_soerr() != SO_EAGAIN)
			return so_soerr();
		else
			return SO_EOPENSSL;
	case SSL_ERROR_SSL:
		/* FALL THROUGH */
	default:
		return SO_EOPENSSL;
	} /* switch(SSL_get_error()) */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xf060
decl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x7, %eax
ja 0x2ea7f
movq -0x30(%rbp), %rax
leaq 0x1ada5(%rip), %rcx     # 0x49750
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x8c9c94ca, -0x4(%rbp) # imm = 0x8C9C94CA
jmp 0x2ea86
movq -0x20(%rbp), %rax
movswl (%rax), %ecx
orl $0x1, %ecx
movw %cx, (%rax)
movl $0xb, -0x4(%rbp)
jmp 0x2ea86
movq -0x20(%rbp), %rax
movswl (%rax), %ecx
orl $0x4, %ecx
movw %cx, (%rax)
movl $0xb, -0x4(%rbp)
jmp 0x2ea86
movq -0x20(%rbp), %rax
movswl (%rax), %ecx
orl $0x4, %ecx
movw %cx, (%rax)
movl $0xb, -0x4(%rbp)
jmp 0x2ea86
movq -0x20(%rbp), %rax
movswl (%rax), %ecx
orl $0x1, %ecx
movw %cx, (%rax)
movl $0xb, -0x4(%rbp)
jmp 0x2ea86
movl $0x8c9c94c8, -0x4(%rbp) # imm = 0x8C9C94C8
jmp 0x2ea86
callq 0xf080
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2ea3f
movl $0x8c9c94c7, -0x4(%rbp) # imm = 0x8C9C94C7
jmp 0x2ea86
cmpl $0x0, -0x14(%rbp)
jne 0x2ea4e
movl $0x68, -0x4(%rbp)
jmp 0x2ea86
cmpl $-0x1, -0x14(%rbp)
jne 0x2ea74
callq 0xf0a0
cmpl $0x0, (%rax)
je 0x2ea74
callq 0xf0a0
cmpl $0xb, (%rax)
je 0x2ea74
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2ea86
movl $0x8c9c94c7, -0x4(%rbp) # imm = 0x8C9C94C7
jmp 0x2ea86
jmp 0x2ea7f
movl $0x8c9c94c7, -0x4(%rbp) # imm = 0x8C9C94C7
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: so_sysread
static size_t so_sysread(struct socket *so, void *dst, size_t lim, int *error) {
	long len;

retry:
#if _WIN32
	len = recv(so->fd, dst, SO_MIN(lim, LONG_MAX), 0);
#else
	len = read(so->fd, dst, SO_MIN(lim, LONG_MAX));
#endif

	if (len == -1)
		goto error;
	if (len == 0)
		goto epipe;

	return len;
epipe:
	*error = EPIPE;
	so->st.rcvd.eof = 1;

	return 0;
error:
	*error = so_soerr();

	switch (*error) {
	case SO_EINTR:
		goto retry;
#if SO_EWOULDBLOCK != SO_EAGAIN
	case SO_EWOULDBLOCK:
		*error = SO_EAGAIN;
		/* FALL THROUGH */
#endif
	case SO_EAGAIN:
		so->events |= POLLIN;
		break;
	} /* switch() */

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x20(%rbp)
jae 0x2ead4
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x2eae4
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x48(%rbp)
jmp 0x2eae4
movq -0x38(%rbp), %rsi
movl -0x3c(%rbp), %edi
movq -0x48(%rbp), %rdx
callq 0x10470
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
jne 0x2eb01
jmp 0x2eb33
cmpq $0x0, -0x30(%rbp)
jne 0x2eb0a
jmp 0x2eb14
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2eb7c
movq -0x28(%rbp), %rax
movl $0x20, (%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x90(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x2eb7c
callq 0xf0a0
movl (%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
subl $0x4, %eax
je 0x2eb5a
jmp 0x2eb50
movl -0x4c(%rbp), %eax
subl $0xb, %eax
je 0x2eb5f
jmp 0x2eb74
jmp 0x2eaa8
movq -0x10(%rbp), %rax
movswl 0xb0(%rax), %ecx
orl $0x1, %ecx
movw %cx, 0xb0(%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: so_pipeok
static int so_pipeok(struct socket *so, _Bool rdonly) {
	if (!so_needign(so, rdonly))
		return 0;

#if _POSIX_REALTIME_SIGNALS > 0
	assert(so->pipeign.ncalls > 0);

	if (--so->pipeign.ncalls)
		return 0;

	if (sigismember(&so->pipeign.pending, SIGPIPE))
		return 0;

	sigset_t piped;
	sigemptyset(&piped);
	sigaddset(&piped, SIGPIPE);

	while (-1 == sigtimedwait(&piped, NULL, &(struct timespec){ 0, 0 }) && errno == EINTR)
		;;

	return thr_sigmask(SIG_SETMASK, &so->pipeign.blocked, NULL);
#else
	return EOPNOTSUPP;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x31420
testb $0x1, %al
jne 0x2f4d8
movl $0x0, -0x4(%rbp)
jmp 0x2f5f3
movq -0x10(%rbp), %rax
cmpl $0x0, 0x108(%rax)
jle 0x2f4e7
jmp 0x2f506
leaq 0x1a8da(%rip), %rdi     # 0x49dc8
leaq 0x1a776(%rip), %rsi     # 0x49c6b
movl $0x56e, %edx            # imm = 0x56E
leaq 0x1a8de(%rip), %rcx     # 0x49ddf
callq 0xf920
movq -0x10(%rbp), %rcx
movl 0x108(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x108(%rcx)
cmpl $0x0, %eax
je 0x2f52a
movl $0x0, -0x4(%rbp)
jmp 0x2f5f3
movq -0x10(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
addq $0x8, %rdi
movl $0xd, %esi
callq 0xf690
cmpl $0x0, %eax
je 0x2f554
movl $0x0, -0x4(%rbp)
jmp 0x2f5f3
leaq -0x98(%rbp), %rdi
callq 0x10150
leaq -0x98(%rbp), %rdi
movl $0xd, %esi
callq 0x10660
movq $0x0, -0xa8(%rbp)
movq $0x0, -0xa0(%rbp)
leaq -0x98(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0xa8(%rbp), %rdx
callq 0xf770
movl %eax, %edx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl %edx, %ecx
movb %al, -0xa9(%rbp)
jne 0x2f5c2
callq 0xf0a0
cmpl $0x4, (%rax)
sete %al
movb %al, -0xa9(%rbp)
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x2f5ce
jmp 0x2f5d0
jmp 0x2f571
movq -0x10(%rbp), %rsi
addq $0x108, %rsi            # imm = 0x108
addq $0x88, %rsi
movl $0x2, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x314b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: so_sendmsg
int so_sendmsg(struct socket *so, const struct msghdr *msg, int flags) {
	ssize_t count;
	int error;

	so_pipeign(so, 0);

	so->todo |= SO_S_SETWRITE;

	if ((error = so_exec(so)))
		goto error;

	so->events &= ~POLLOUT;

#if defined MSG_NOSIGNAL
	if (so->opts.fd_nosigpipe)
		flags |= MSG_NOSIGNAL;
#endif

retry:
	if (-1 == (count = sendmsg(so->fd, msg, flags)))
		goto syerr;

	st_update(&so->st.sent, count, &so->opts);

	so_pipeok(so, 0);

	return 0;
syerr:
	error = errno;
error:
	switch (error) {
	case SO_EINTR:
		goto retry;
#if SO_EWOULDBLOCK != SO_EAGAIN
	case SO_EWOULDBLOCK:
		/* FALL THROUGH */
#endif
	case SO_EAGAIN:
		so->events |= POLLOUT;

		break;
	} /* switch() */

	so_pipeok(so, 0);

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x2e860
movq -0x10(%rbp), %rax
movl 0xb8(%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, 0xb8(%rax)
movq -0x10(%rbp), %rdi
callq 0x2dbb0
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x2fc6a
jmp 0x2fcf1
movq -0x10(%rbp), %rax
movswl 0xb0(%rax), %ecx
andl $-0x5, %ecx
movw %cx, 0xb0(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x1e(%rax)
je 0x2fc94
movl -0x1c(%rbp), %eax
orl $0x4000, %eax           # imm = 0x4000
movl %eax, -0x1c(%rbp)
jmp 0x2fc96
movq -0x10(%rbp), %rax
movl 0x58(%rax), %edi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0xfb20
movq %rax, %rcx
movq %rcx, -0x28(%rbp)
movq $-0x1, %rax
cmpq %rcx, %rax
jne 0x2fcbe
jmp 0x2fce7
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x2f450
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x2f4a0
movl $0x0, -0x4(%rbp)
jmp 0x2fd30
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
subl $0x4, %eax
je 0x2fd08
jmp 0x2fcfe
movl -0x30(%rbp), %eax
subl $0xb, %eax
je 0x2fd0a
jmp 0x2fd1f
jmp 0x2fc96
movq -0x10(%rbp), %rax
movswl 0xb0(%rax), %ecx
orl $0x4, %ecx
movw %cx, 0xb0(%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x2f4a0
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: so_events
int so_events(struct socket *so) {
	short events;

	switch (so->opts.fd_events) {
	case SO_LIBEVENT:
		events = SO_POLL2EV(so->events);

		break;
	default:
		/* FALL THROUGH */
	case SO_SYSPOLL:
		events = so->events;

		break;
	} /* switch (.fd_events) */

	return events;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x2ffb2
jmp 0x2ff68
movl -0x10(%rbp), %eax
subl $0x1, %eax
jne 0x2ffb0
jmp 0x2ff72
movq -0x8(%rbp), %rax
movswl 0xb0(%rax), %edx
andl $0x1, %edx
xorl %eax, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movq -0x8(%rbp), %rcx
movswl 0xb0(%rcx), %esi
andl $0x4, %esi
xorl %ecx, %ecx
movl $0x4, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
orl %ecx, %eax
movw %ax, -0xa(%rbp)
jmp 0x2ffc1
jmp 0x2ffb2
movq -0x8(%rbp), %rax
movw 0xb0(%rax), %ax
movw %ax, -0xa(%rbp)
movswl -0xa(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: so_pollfd
int so_pollfd(struct socket *so) {
	switch (so_state(so)) {
	case SO_S_GETADDR:
		return dns_ai_pollfd(so->res);
	default:
		return so->fd;
	} /* switch() */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2db00
subl $0x2, %eax
jne 0x2fffe
jmp 0x2ffec
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0xf150
movl %eax, -0x4(%rbp)
jmp 0x30008
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: so_poll
int so_poll(struct socket *so, int timeout) {
	int nfds;

#if 1
	struct pollfd pfd = { .fd = so_pollfd(so), .events = so->events, };

	if (!pfd.events)
		return 0;

	if (timeout != -1)
		timeout *= 1000;

	nfds = poll(&pfd, 1, timeout);
#else
	fd_set rfds, wfds;
	int set, fd;

	FD_ZERO(&rfds);
	FD_ZERO(&wfds);

	if (!(set = so->events))
		return 0;

	fd = so_pollfd(so);

	if ((set & POLLIN) && fd < FD_SETSIZE)
		FD_SET(fd, &rfds);

	if ((set & POLLOUT) && fd < FD_SETSIZE)
		FD_SET(fd, &wfds);

	nfds = select(fd + 1, &rfds, &wfds, 0, (timeout >= 0)? &(struct timeval){ timeout, 0 } : 0);
#endif

	switch (nfds) {
	case -1:
		return errno;
	case 0:
		return ETIMEDOUT;
	default:
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x105c0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movw 0xb0(%rax), %ax
movw %ax, -0x1c(%rbp)
movw $0x0, -0x1a(%rbp)
cmpw $0x0, -0x1c(%rbp)
jne 0x30060
movl $0x0, -0x4(%rbp)
jmp 0x300b6
cmpl $-0x1, -0x14(%rbp)
je 0x30070
imull $0x3e8, -0x14(%rbp), %eax # imm = 0x3E8
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edx
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x105b0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $-0x1, %eax
je 0x3009a
jmp 0x30091
movl -0x24(%rbp), %eax
testl %eax, %eax
je 0x300a6
jmp 0x300af
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x300b6
movl $0x6e, -0x4(%rbp)
jmp 0x300b6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: so_peereid
int so_peereid(struct socket *so, uid_t *uid, gid_t *gid) {
	int error;

	if ((error = so_loadcred(so)))
		return error;

	if (so->cred.uid == (uid_t)-1)
		return EOPNOTSUPP;

	if (uid)
		*uid = so->cred.uid;
	if (gid)
		*gid = so->cred.gid;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30190
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x3012d
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x30178
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x214(%rax)
jne 0x30143
movl $0x5f, -0x4(%rbp)
jmp 0x30178
cmpq $0x0, -0x18(%rbp)
je 0x3015a
movq -0x10(%rbp), %rax
movl 0x214(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x30171
movq -0x10(%rbp), %rax
movl 0x218(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: so_peerpid
int so_peerpid(struct socket *so, pid_t *pid) {
	int error;

	if ((error = so_loadcred(so)))
		return error;

	if (so->cred.pid == (pid_t)-1)
		return EOPNOTSUPP;

	if (pid)
		*pid = so->cred.pid;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30190
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x30259
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3028d
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x210(%rax)
jne 0x3026f
movl $0x5f, -0x4(%rbp)
jmp 0x3028d
cmpq $0x0, -0x18(%rbp)
je 0x30286
movq -0x10(%rbp), %rax
movl 0x210(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: so_initdebug
static void so_initdebug(void) {
	const char *debug;

	if ((debug = getenv("SOCKET_DEBUG")) || (debug = getenv("SO_DEBUG"))) {
		switch (*debug) {
		case 'Y': case 'y':
		case 'T': case 't':
		case '1':
			socket_debug = 1;

			break;
		case 'N': case 'n':
		case 'F': case 'f':
		case '0':
			socket_debug = 0;

			break;
		} /* switch() */
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x19b26(%rip), %rdi     # 0x49e05
callq 0x100e0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jne 0x30304
leaq 0x19b1d(%rip), %rdi     # 0x49e12
callq 0x100e0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x3034b
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
addl $-0x30, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x49, %eax
ja 0x30349
movq -0x10(%rbp), %rax
leaq 0x1945c(%rip), %rcx     # 0x49780
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x2bc74(%rip), %rax     # 0x5bfa8
movl $0x1, (%rax)
jmp 0x30349
movq 0x2bc65(%rip), %rax     # 0x5bfa8
movl $0x0, (%rax)
jmp 0x3034b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: so_ffamily
static so_error_t so_ffamily(int fd, int *family) {
	struct sockaddr_storage ss;

	if (0 != getsockname(fd, (struct sockaddr *)&ss, &(socklen_t){ sizeof ss }))
		return errno;

	*family = ss.ss_family;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
leaq -0x90(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0x80, -0x9c(%rbp)
movq -0x98(%rbp), %rsi
leaq -0x9c(%rbp), %rdx
callq 0xfd30
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x303b4
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x303c8
movzwl -0x90(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: so_getaddr_
static int so_getaddr_(struct socket *so) {
	int error;

	if (!so->res)
		return SO_ENOHOST;

	so->events = 0;

	free(so->host);
	so->host = 0;

	if ((error = dns_ai_nextent(&so->host, so->res)))
		goto error;

	return 0;
error:
	switch (error) {
#if SO_EWOULDBLOCK != SO_EAGAIN
	case SO_EWOULDBLOCK:
		/* FALL THROUGH */
#endif
	case SO_EAGAIN:
		so->events = dns_ai_events(so->res);

		break;
	} /* switch() */

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x30403
movl $0x8c9c94cb, -0x4(%rbp) # imm = 0x8C9C94CB
jmp 0x30485
movq -0x10(%rbp), %rax
movw $0x0, 0xb0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x10060
movq -0x10(%rbp), %rax
movq $0x0, 0xa8(%rax)
movq -0x10(%rbp), %rdi
addq $0xa8, %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0xfde0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x30451
jmp 0x3045a
movl $0x0, -0x4(%rbp)
jmp 0x30485
movl -0x14(%rbp), %eax
subl $0xb, %eax
jne 0x3047f
jmp 0x30464
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x10980
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0xb0(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: so_socket_
static int so_socket_(struct socket *so) {
	int error;

	if (!so->host)
		return SO_ENOHOST;

	so_closesocket(&so->fd, &so->opts);

	if (-1 == (so->fd = so_socket(so->host->ai_family, so->host->ai_socktype, &so->opts, &error)))
		return error;

	if ((error = so_ftype(so->fd, &so->mode, &so->domain, &so->type, &so->protocol)))
		return error;

	so->flags = so_getfl(so->fd, ~0);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x304b6
movl $0x8c9c94cb, -0x4(%rbp) # imm = 0x8C9C94CB
jmp 0x30567
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
movq -0x10(%rbp), %rsi
callq 0xf2f0
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
movl 0x4(%rax), %edi
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
movl 0x8(%rax), %esi
movq -0x10(%rbp), %rdx
leaq -0x14(%rbp), %rcx
callq 0x10040
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x58(%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x3050a
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x30567
movq -0x10(%rbp), %rax
movl 0x58(%rax), %edi
movq -0x10(%rbp), %rsi
addq $0x5c, %rsi
movq -0x10(%rbp), %rdx
addq $0x60, %rdx
movq -0x10(%rbp), %rcx
addq $0x64, %rcx
movq -0x10(%rbp), %r8
addq $0x68, %r8
callq 0x2d7c0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x30546
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x30567
movq -0x10(%rbp), %rax
movl 0x58(%rax), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x10ac0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x6c(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: so_bind_
static int so_bind_(struct socket *so) {
	struct sockaddr *saddr;

	if (so->todo & SO_S_LISTEN) {
		if (!so->host)
			return SO_ENOHOST;

		saddr = so->host->ai_addr;
	} else if (so->opts.sa_bind) {
		saddr = (struct sockaddr *)so->opts.sa_bind;
	} else {
		return 0;
	}

	return so_bind(so->fd, saddr, &so->opts);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0xb8(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x305ba
movq -0x10(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x305a5
movl $0x8c9c94cb, -0x4(%rbp) # imm = 0x8C9C94CB
jmp 0x305fb
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x305dc
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x305d1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x305da
movl $0x0, -0x4(%rbp)
jmp 0x305fb
jmp 0x305dc
movq -0x10(%rbp), %rax
movl 0x58(%rax), %edi
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rsi
callq 0xfe90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: so_connect_
static int so_connect_(struct socket *so) {
	int error;

	so->events &= ~POLLOUT;

retry:
	if (!so->host) {
		error = SO_ENOHOST;
		goto error;
	}

	if (0 != connect(so->fd, so->host->ai_addr, so->host->ai_addrlen)) {
		error = so_soerr();
		goto error;
	}

ready:
	so_trace(SO_T_CONNECT, so->fd, so->host, "ready");

	return 0;
error:
	switch (error) {
	case SO_EISCONN:
		goto ready;
	case SO_EINTR:
		goto retry;
	case SO_EINPROGRESS:
		/* FALL THROUGH */
	case SO_EALREADY:
		/* FALL THROUGH */
#if SO_EWOULDBLOCK != SO_EAGAIN
	case SO_EWOULDBLOCK
		/* FALL THROUGH */
#endif
		so->events |= POLLOUT;

		return SO_EAGAIN;
	default:
		so_trace(SO_T_CONNECT, so->fd, so->host, "%s", so_strerror(error));

		return error;
	} /* switch() */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movswl 0xb0(%rax), %ecx
andl $-0x5, %ecx
movw %cx, 0xb0(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x306c8
movl $0x8c9c94cb, -0x14(%rbp) # imm = 0x8C9C94CB
jmp 0x3073d
movq -0x10(%rbp), %rax
movl 0x58(%rax), %edi
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
movl 0x10(%rax), %edx
movq -0x20(%rbp), %rsi
callq 0xfb80
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x3070d
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x3073d
jmp 0x3070f
movq -0x10(%rbp), %rax
movl 0x58(%rax), %esi
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rdx
xorl %edi, %edi
leaq 0x195de(%rip), %rcx     # 0x49d08
movb $0x0, %al
callq 0x2eb90
movl $0x0, -0x4(%rbp)
jmp 0x307c7
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x4, %eax
je 0x30763
jmp 0x3074a
movl -0x24(%rbp), %eax
subl $0x6a, %eax
je 0x30761
jmp 0x30754
movl -0x24(%rbp), %eax
addl $-0x72, %eax
subl $0x2, %eax
jb 0x30768
jmp 0x30786
jmp 0x3070f
jmp 0x306b1
movq -0x10(%rbp), %rax
movswl 0xb0(%rax), %ecx
orl $0x4, %ecx
movw %cx, 0xb0(%rax)
movl $0xb, -0x4(%rbp)
jmp 0x307c7
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %edi
callq 0xfcd0
movl -0x34(%rbp), %esi
movq -0x30(%rbp), %rdx
movq %rax, %r8
xorl %edi, %edi
leaq 0x18967(%rip), %rcx     # 0x49121
movb $0x0, %al
callq 0x2eb90
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: so_shutwr_
static int so_shutwr_(struct socket *so) {
	if (so->fd != -1 && 0 != shutdown(so->fd, SHUT_WR))
		return so_soerr();

	so->shut.wr = 1;
	so->st.sent.eof = 1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x58(%rax)
je 0x30bfb
movq -0x10(%rbp), %rax
movl 0x58(%rax), %edi
movl $0x1, %esi
callq 0x102e0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x30bfb
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x30c15
movq -0x10(%rbp), %rax
movb $0x1, 0xa1(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x78(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: so_shutrd_
static int so_shutrd_(struct socket *so) {
	if (so->fd != -1 && 0 != shutdown(so->fd, SHUT_RD)) {
		/*
		 * NOTE: OS X will fail with ENOTCONN if the requested
		 * SHUT_RD or SHUT_WR flag is already set, including if the
		 * SHUT_RD flag is set from the peer sending eof. Other OSs
		 * just treat this as a noop and return successfully.
		 */
		if (so_soerr() != SO_ENOTCONN)
			return so_soerr();
		else if (!so_isconn(so->fd))
			return SO_ENOTCONN;
	}

	so->shut.rd = 1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x58(%rax)
je 0x30c7f
movq -0x10(%rbp), %rax
movl 0x58(%rax), %edi
xorl %esi, %esi
callq 0x102e0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x30c7f
callq 0xf0a0
cmpl $0x6b, (%rax)
je 0x30c62
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x30c91
movq -0x10(%rbp), %rax
movl 0x58(%rax), %edi
callq 0x31340
testb $0x1, %al
jne 0x30c7b
movl $0x6b, -0x4(%rbp)
jmp 0x30c91
jmp 0x30c7d
jmp 0x30c7f
movq -0x10(%rbp), %rax
movb $0x1, 0xa0(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: so_newbio
static BIO *so_newbio(struct socket *so, int *error) {
	BIO *bio;
	BIO_METHOD *bio_methods = so_get_bio_methods();

	if (bio_methods == NULL || !(bio = BIO_new(bio_methods))) {
		*error = SO_EOPENSSL;
		return NULL;
	}

	BIO_set_init(bio, 1);
	BIO_set_data(bio, so);

	/*
	 * NOTE: Applications can acquire a reference to our BIO via the SSL
	 * state object. The lifetime of the BIO could last longer than the
	 * lifetime of our socket object, so we must keep our own reference
	 * and zero any pointer to ourselves here and from so_destroy.
	 */
	if (so->bio.ctx) {
		BIO_set_init(so->bio.ctx, 0);
		BIO_set_data(so->bio.ctx, NULL);
		BIO_free(so->bio.ctx);
	}

	BIO_up_ref(bio);
	so->bio.ctx = bio;

	return bio;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x30db0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x30cd3
movq -0x28(%rbp), %rdi
callq 0x108c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x30ce7
movq -0x18(%rbp), %rax
movl $0x8c9c94c7, (%rax)     # imm = 0x8C9C94C7
movq $0x0, -0x8(%rbp)
jmp 0x30d66
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0xf8a0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xff20
movq -0x10(%rbp), %rax
cmpq $0x0, 0xe0(%rax)
je 0x30d46
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rdi
xorl %esi, %esi
callq 0xf8a0
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xff20
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rdi
callq 0xfea0
movq -0x20(%rbp), %rdi
callq 0x10760
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xe0(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: bio_methods_init
static void bio_methods_init(void) {
	int type = BIO_get_new_index();
	if (type == -1)
		return;

	bio_methods = BIO_meth_new(type|BIO_TYPE_SOURCE_SINK, "struct socket*");
	if (bio_methods == NULL)
		return;

	BIO_meth_set_write(bio_methods, bio_write);
	BIO_meth_set_read(bio_methods, bio_read);
	BIO_meth_set_puts(bio_methods, bio_puts);
	BIO_meth_set_ctrl(bio_methods, bio_ctrl);
	BIO_meth_set_create(bio_methods, bio_create);
	BIO_meth_set_destroy(bio_methods, bio_destroy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x10290
movl %eax, -0x4(%rbp)
cmpl $-0x1, -0x4(%rbp)
jne 0x30dfb
jmp 0x30e95
movl -0x4(%rbp), %edi
orl $0x400, %edi            # imm = 0x400
leaq 0x18f03(%rip), %rsi     # 0x49d0e
callq 0xf960
movq %rax, 0x2cba1(%rip)     # 0x5d9b8
cmpq $0x0, 0x2cb99(%rip)     # 0x5d9b8
jne 0x30e23
jmp 0x30e95
movq 0x2cb8e(%rip), %rdi     # 0x5d9b8
leaq 0x6f(%rip), %rsi        # 0x30ea0
callq 0x10990
movq 0x2cb7b(%rip), %rdi     # 0x5d9b8
leaq 0x16c(%rip), %rsi       # 0x30fb0
callq 0xff70
movq 0x2cb68(%rip), %rdi     # 0x5d9b8
leaq 0x329(%rip), %rsi       # 0x31180
callq 0x100f0
movq 0x2cb55(%rip), %rdi     # 0x5d9b8
leaq 0x386(%rip), %rsi       # 0x311f0
callq 0x10c60
movq 0x2cb42(%rip), %rdi     # 0x5d9b8
leaq 0x3f3(%rip), %rsi       # 0x31270
callq 0xf4e0
movq 0x2cb2f(%rip), %rdi     # 0x5d9b8
leaq 0x420(%rip), %rsi       # 0x312b0
callq 0xffe0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: bio_write
static int bio_write(BIO *bio, const char *src, int len) {
	struct socket *so = BIO_get_data(bio);
	size_t count;

	assert(so);
	assert(len >= 0);

	BIO_clear_retry_flags(bio);
	so->bio.error = 0;

	if ((count = so_syswrite(so, src, len, &so->bio.error)))
		return (int)count;

	if (bio_nonfatal(so->bio.error))
		BIO_set_retry_write(bio);

	/*
	 * SSL_get_error will return SSL_ERROR_SYSCALL, expecting errno to
	 * be set.
	 */
	errno = so->bio.error;

	return -1;
}

// 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
callq 0x10af0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x30ec9
jmp 0x30ee8
leaq 0x18e4d(%rip), %rdi     # 0x49d1d
leaq 0x18d94(%rip), %rsi     # 0x49c6b
movl $0x9a2, %edx            # imm = 0x9A2
leaq 0x18e3d(%rip), %rcx     # 0x49d20
callq 0xf920
cmpl $0x0, -0x1c(%rbp)
jl 0x30ef0
jmp 0x30f0f
leaq 0x18e51(%rip), %rdi     # 0x49d48
leaq 0x18d6d(%rip), %rsi     # 0x49c6b
movl $0x9a3, %edx            # imm = 0x9A3
leaq 0x18e16(%rip), %rcx     # 0x49d20
callq 0xf920
movq -0x10(%rbp), %rdi
movl $0xf, %esi
callq 0x10670
movq -0x28(%rbp), %rax
movl $0x0, 0xe8(%rax)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
movq -0x28(%rbp), %rcx
addq $0xe0, %rcx
addq $0x8, %rcx
callq 0x2f850
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x30f5e
movq -0x30(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x30f9f
movq -0x28(%rbp), %rax
movl 0xe8(%rax), %edi
callq 0x312f0
testb $0x1, %al
jne 0x30f73
jmp 0x30f81
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0xf190
movq -0x28(%rbp), %rax
movl 0xe8(%rax), %eax
movl %eax, -0x34(%rbp)
callq 0xf0a0
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: bio_read
static int bio_read(BIO *bio, char *dst, int lim) {
	struct socket *so = BIO_get_data(bio);
	size_t count;

	assert(so);
	assert(lim >= 0);

	BIO_clear_retry_flags(bio);
	so->bio.error = 0;

	if (so->bio.ahead.p < so->bio.ahead.pe) {
		count = SO_MIN(so->bio.ahead.pe - so->bio.ahead.p, lim);
		memcpy(dst, so->bio.ahead.p, count);
		so->bio.ahead.p += count;

		return count;
	}

	if ((count = so_sysread(so, dst, lim, &so->bio.error)))
		return (int)count;

	if (bio_nonfatal(so->bio.error))
		BIO_set_retry_read(bio);

	/* see note about SSL_ERROR_SYSCALL at bio_write */
	errno = so->bio.error;

	return (so->bio.error == EPIPE)? 0 : -1;
}

// 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
callq 0x10af0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x30fd9
jmp 0x30ff8
leaq 0x18d3d(%rip), %rdi     # 0x49d1d
leaq 0x18c84(%rip), %rsi     # 0x49c6b
movl $0x984, %edx            # imm = 0x984
leaq 0x18d5e(%rip), %rcx     # 0x49d51
callq 0xf920
cmpl $0x0, -0x1c(%rbp)
jl 0x31000
jmp 0x3101f
leaq 0x18d6b(%rip), %rdi     # 0x49d72
leaq 0x18c5d(%rip), %rsi     # 0x49c6b
movl $0x985, %edx            # imm = 0x985
leaq 0x18d37(%rip), %rcx     # 0x49d51
callq 0xf920
movq -0x10(%rbp), %rdi
movl $0xf, %esi
callq 0x10670
movq -0x28(%rbp), %rax
movl $0x0, 0xe8(%rax)
movq -0x28(%rbp), %rax
movq 0xf8(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x100(%rcx), %rax
jae 0x310e2
movq -0x28(%rbp), %rax
movq 0x100(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0xf8(%rcx), %rcx
subq %rcx, %rax
movslq -0x1c(%rbp), %rcx
cmpq %rcx, %rax
jge 0x31098
movq -0x28(%rbp), %rax
movq 0x100(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0xf8(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x310a0
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0xf8(%rax), %rsi
movq -0x30(%rbp), %rdx
callq 0xfb40
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0xf8(%rax), %rcx
movq %rcx, 0xf8(%rax)
movq -0x30(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x31169
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
movq -0x28(%rbp), %rcx
addq $0xe0, %rcx
addq $0x8, %rcx
callq 0x2ea90
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x31115
movq -0x30(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x31169
movq -0x28(%rbp), %rax
movl 0xe8(%rax), %edi
callq 0x312f0
testb $0x1, %al
jne 0x3112a
jmp 0x31138
movq -0x10(%rbp), %rdi
movl $0x9, %esi
callq 0xf190
movq -0x28(%rbp), %rax
movl 0xe8(%rax), %eax
movl %eax, -0x3c(%rbp)
callq 0xf0a0
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl 0xe8(%rax), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpl $0x20, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: bio_ctrl
static long bio_ctrl(BIO *bio, int cmd, long udata_i, void *udata_p) {
	(void)bio;
	(void)udata_i;

	switch (cmd) {
	case BIO_CTRL_DUP: {
		/*
		 * We'll permit duping, just like all the other BIOs do by
		 * default and so we don't inadvertently break something.
		 * But we won't copy our state because our memory management
		 * assumes 1:1 mapping between BIO and socket objects. And
		 * just to be safe, zero the state members. BIO_dup_chain,
		 * for example, has a hack to always copy .init and .num.
		 */
		BIO *udata = udata_p;
		BIO_set_init(udata, 0);
		BIO_set_data(udata, NULL);

		return 1;
	}
	case BIO_CTRL_FLUSH:
		return 1;
	default:
		/*
		 * BIO_ctrl manual page says
		 *
		 * 	Source/sink BIOs return an 0 if they do not
		 * 	recognize the BIO_ctrl() operation.
		 */
		return 0;
	} /* switch() */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0xb, %eax
je 0x31248
jmp 0x31214
movl -0x34(%rbp), %eax
subl $0xc, %eax
jne 0x31252
jmp 0x3121e
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xf8a0
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xff20
movq $0x1, -0x8(%rbp)
jmp 0x3125a
movq $0x1, -0x8(%rbp)
jmp 0x3125a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: bio_create
static int bio_create(BIO *bio) {
	BIO_set_init(bio, 0);
	BIO_set_shutdown(bio, 0);
	BIO_set_data(bio, NULL);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xf8a0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x10930
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xff20
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: bio_nonfatal
static _Bool bio_nonfatal(int error) {
	switch (error) {
	case SO_EAGAIN:
	case SO_EALREADY:
	case SO_EINPROGRESS:
	case SO_EINTR:
	case SO_ENOTCONN: /* FIXME (bss_sock.c has this but is it correct?) */
		return 1;
	default:
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x4, %eax
je 0x31325
jmp 0x31304
movl -0xc(%rbp), %eax
subl $0xb, %eax
je 0x31325
jmp 0x3130e
movl -0xc(%rbp), %eax
subl $0x6b, %eax
je 0x31325
jmp 0x31318
movl -0xc(%rbp), %eax
addl $-0x72, %eax
subl $0x1, %eax
ja 0x3132b
jmp 0x31325
movb $0x1, -0x1(%rbp)
jmp 0x3132f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: so_needign
static _Bool so_needign(struct socket *so, _Bool rdonly) {
	if (!so->opts.fd_nosigpipe || (so->flags & SO_F_NOSIGPIPE))
		return 0;
	if (so->ssl.ctx && !so->bio.ctx)
		return 1;
	if (rdonly)
		return 0;
#if defined MSG_NOSIGNAL
	if (S_ISSOCK(so->mode))
		return 0;
#endif
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x1e(%rax)
je 0x3144b
movq -0x10(%rbp), %rax
movl 0x6c(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x31451
movb $0x0, -0x1(%rbp)
jmp 0x3149c
movq -0x10(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x31473
movq -0x10(%rbp), %rax
cmpq $0x0, 0xe0(%rax)
jne 0x31473
movb $0x1, -0x1(%rbp)
jmp 0x3149c
testb $0x1, -0x11(%rbp)
je 0x3147f
movb $0x0, -0x1(%rbp)
jmp 0x3149c
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0xc000, %eax           # imm = 0xC000
jne 0x31498
movb $0x0, -0x1(%rbp)
jmp 0x3149c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.c
// Function: math_addull
static int math_addull(unsigned long long *x, unsigned long long a, unsigned long long b) {
	if (~a < b) {
		*x = ~0ULL;

		return EOVERFLOW;
	} else {
		*x = a + b;

		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
xorq $-0x1, %rax
cmpq -0x20(%rbp), %rax
jae 0x317f2
movq -0x10(%rbp), %rax
movq $-0x1, (%rax)
movl $0x4b, -0x4(%rbp)
jmp 0x31808
movq -0x18(%rbp), %rcx
addq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_strerror
const char *dns_strerror(int error) {
	switch (error) {
	case DNS_ENOBUFS:
		return "DNS packet buffer too small";
	case DNS_EILLEGAL:
		return "Illegal DNS RR name or data";
	case DNS_EORDER:
		return "Attempt to push RR out of section order";
	case DNS_ESECTION:
		return "Invalid section specified";
	case DNS_EUNKNOWN:
		return "Unknown DNS error";
	case DNS_EADDRESS:
		return "Invalid textual address form";
	case DNS_ENOQUERY:
		return "Bad execution state (missing query packet)";
	case DNS_ENOANSWER:
		return "Bad execution state (missing answer packet)";
	case DNS_EFETCHED:
		return "Answer already fetched";
	case DNS_ESERVICE:
		return "The service passed was not recognized for the specified socket type";
	case DNS_ENONAME:
		return "The name does not resolve for the supplied parameters";
	case DNS_EFAIL:
		return "A non-recoverable error occurred when attempting to resolve the name";
	default:
		return strerror(error);
	} /* switch() */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x646e7340, %eax       # imm = 0x646E7340
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0xb, %eax
ja 0x3193b
movq -0x18(%rbp), %rax
leaq 0x18593(%rip), %rcx     # 0x49e20
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1b93b(%rip), %rax     # 0x4d1d8
movq %rax, -0x8(%rbp)
jmp 0x31947
leaq 0x1b947(%rip), %rax     # 0x4d1f4
movq %rax, -0x8(%rbp)
jmp 0x31947
leaq 0x1b953(%rip), %rax     # 0x4d210
movq %rax, -0x8(%rbp)
jmp 0x31947
leaq 0x1b96b(%rip), %rax     # 0x4d238
movq %rax, -0x8(%rbp)
jmp 0x31947
leaq 0x1b978(%rip), %rax     # 0x4d252
movq %rax, -0x8(%rbp)
jmp 0x31947
leaq 0x1b97d(%rip), %rax     # 0x4d264
movq %rax, -0x8(%rbp)
jmp 0x31947
leaq 0x1b98d(%rip), %rax     # 0x4d281
movq %rax, -0x8(%rbp)
jmp 0x31947
leaq 0x1b9ab(%rip), %rax     # 0x4d2ac
movq %rax, -0x8(%rbp)
jmp 0x31947
leaq 0x1b9ca(%rip), %rax     # 0x4d2d8
movq %rax, -0x8(%rbp)
jmp 0x31947
leaq 0x1b9d4(%rip), %rax     # 0x4d2ef
movq %rax, -0x8(%rbp)
jmp 0x31947
leaq 0x1ba0b(%rip), %rax     # 0x4d333
movq %rax, -0x8(%rbp)
jmp 0x31947
leaq 0x1ba34(%rip), %rax     # 0x4d369
movq %rax, -0x8(%rbp)
jmp 0x31947
movl -0xc(%rbp), %edi
callq 0xf4c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_random_
static unsigned dns_random_(void) {
#if DNS_RANDOM_OPENSSL
	unsigned r;
	_Bool ok;

	ok = (1 == RAND_bytes((unsigned char *)&r, sizeof r));
	assert(ok && "1 == RAND_bytes()");

	return r;
#else
	return DNS_RANDOM();
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x4(%rbp), %rdi
movl $0x4, %esi
callq 0x10530
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x5(%rbp)
testb $0x1, -0x5(%rbp)
je 0x319a7
movb $0x1, %al
testb $0x1, %al
jne 0x319a5
jmp 0x319a7
jmp 0x319c6
leaq 0x1bd5c(%rip), %rdi     # 0x4d70a
leaq 0x1ba28(%rip), %rsi     # 0x4d3dd
movl $0x1ca, %edx            # imm = 0x1CA
leaq 0x1bd63(%rip), %rcx     # 0x4d724
callq 0xf920
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_strlcpy
size_t dns_strlcpy(char *dst, const char *src, size_t lim) {
	char *d		= dst;
	char *e		= &dst[lim];
	const char *s	= src;

	if (d < e) {
		do {
			if ('\0' == (*d++ = *s++))
				return s - src - 1;
		} while (d < e);

		d[-1]	= '\0';
	}

	while (*s++ != '\0')
		;;

	return s - src - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x31a5c
jmp 0x31a08
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movb (%rax), %al
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %al, (%rcx)
movsbl %al, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x31a48
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x31a8a
jmp 0x31a4a
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jb 0x31a08
movq -0x28(%rbp), %rax
movb $0x0, -0x1(%rax)
jmp 0x31a5e
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x31a77
jmp 0x31a5e
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_strlcat
size_t dns_strlcat(char *dst, const char *src, size_t lim) {
	char *d = memchr(dst, '\0', lim);
	char *e = &dst[lim];
	const char *s = src;
	const char *p;

	if (d && d < e) {
		do {
			if ('\0' == (*d++ = *s++))
				return d - dst - 1;
		} while (d < e);

		d[-1] = '\0';
	}

	p = s;

	while (*s++ != '\0')
		;;

	return lim + (s - p - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
xorl %esi, %esi
callq 0xffa0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x31b32
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x31b32
jmp 0x31ade
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movb (%rax), %al
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %al, (%rcx)
movsbl %al, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x31b1e
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x31b6d
jmp 0x31b20
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jb 0x31ade
movq -0x28(%rbp), %rax
movb $0x0, -0x1(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x31b53
jmp 0x31b3a
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rdx
subq %rdx, %rcx
subq $0x1, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)