LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_starttls
static lso_nargs_t lso_starttls(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	SSL_CTX **ctx = NULL;
	SSL **ssl = NULL;
	int error;

	/*
	 * NB: short-circuit if we've already started so we don't
	 * unnecessarily check for or take a reference to the SSL_CTX
	 * object.
	 */
	if ((S->todo & LSO_DO_STARTTLS))
		goto check;

	if ((ssl = luaL_testudata(L, 2, "SSL*"))) {
		/* accept-mode check handled by so_starttls() */
	} else if ((ctx = luaL_testudata(L, 2, "SSL_CTX*"))) {
		/* accept-mode check handled by so_starttls() */
	} else if ((ctx = luaL_testudata(L, 2, "SSL:Context"))) { /* luasec compatability */
		luaL_argcheck(L, ((lsec_context*)ctx)->mode != LSEC_MODE_INVALID, 2, "invalid mode");
		so_setbool(&S->tls.config.accept, ((((lsec_context*)ctx)->mode) == LSEC_MODE_SERVER));
	}

	if (ssl && *ssl && *ssl != S->tls.config.instance) {
		if (S->tls.config.instance)
			SSL_free(S->tls.config.instance);

		SSL_up_ref(*ssl);
		S->tls.config.instance = *ssl;
	}

	if (ctx && *ctx && *ctx != S->tls.config.context) {
		if (S->tls.config.context)
			SSL_CTX_free(S->tls.config.context);

		SSL_CTX_up_ref(*ctx);
		S->tls.config.context = *ctx;
	}

	S->todo |= LSO_DO_STARTTLS;

	if (S->obuf.mode & LSO_AUTOFLUSH)
		S->todo |= LSO_DO_FLUSH;
check:
	if ((error = lso_checktodo(S)))
		goto error;

	lua_pushvalue(L, 1);

	return 1;
error:
	lua_pushnil(L);
	lua_pushinteger(L, error);

	return 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x18609
movq %rax, %r14
testb $0x2, (%rax)
jne 0x166eb
leaq 0x1f0f1(%rip), %rdx     # 0x356e2
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10720
movq %rax, %r12
testq %rax, %rax
je 0x1660b
xorl %r15d, %r15d
jmp 0x1666f
leaq 0x1f0d5(%rip), %rdx     # 0x356e7
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10720
movq %rax, %r15
testq %rax, %rax
jne 0x1666f
leaq 0x1f0c2(%rip), %rdx     # 0x356f0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10720
testq %rax, %rax
je 0x16606
movq %rax, %r15
cmpl $0x0, 0x18(%rax)
jne 0x1665d
leaq 0x1f0ac(%rip), %rdx     # 0x356fc
movq %rbx, %rdi
movl $0x2, %esi
callq 0xf3f0
cmpl $0x1, 0x18(%r15)
movl $0x1, 0x38(%r14)
sete 0x3c(%r14)
testq %r12, %r12
je 0x166a1
movq (%r12), %rax
testq %rax, %rax
je 0x166a1
movq 0x20(%r14), %rdi
cmpq %rdi, %rax
je 0x166a1
testq %rdi, %rdi
je 0x16690
callq 0xf770
movq (%r12), %rdi
callq 0xf100
movq (%r12), %rax
movq %rax, 0x20(%r14)
testq %r15, %r15
je 0x166d0
movq (%r15), %rax
testq %rax, %rax
je 0x166d0
movq 0x18(%r14), %rdi
cmpq %rdi, %rax
je 0x166d0
testq %rdi, %rdi
je 0x166c1
callq 0xf0f0
movq (%r15), %rdi
callq 0xfb70
movq (%r15), %rax
movq %rax, 0x18(%r14)
movl (%r14), %eax
movl %eax, %ecx
orl $0x2, %ecx
movl %ecx, (%r14)
testb $0x20, 0xa8(%r14)
je 0x166eb
orl $0x3, %eax
movl %eax, (%r14)
movq %r14, %rdi
callq 0x18694
testl %eax, %eax
je 0x16713
movl %eax, %ebp
movq %rbx, %rdi
callq 0xf980
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %ebp
jmp 0x16725
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf9c0
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_checktls
static lso_nargs_t lso_checktls(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	SSL **ssl;

	ssl = lua_newuserdata(L, sizeof *ssl);

	if (!(*ssl = so_checktls(S->socket)))
		return 0;

	luaL_getmetatable(L, "SSL*");

	if (lua_isnil(L, -1))
		return 0;

	lua_setmetatable(L, -2);

	SSL_up_ref(*ssl);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x18609
movq %rax, %r15
movl $0x8, %esi
movq %rbx, %rdi
callq 0xfb00
movq %rax, %r14
movq 0x128(%r15), %rdi
callq 0xfaf0
movq %rax, (%r14)
xorl %ebp, %ebp
testq %rax, %rax
je 0x167a7
leaq 0x1ef73(%rip), %rdx     # 0x356e2
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xf1e0
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf260
testl %eax, %eax
je 0x167a7
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10910
movq (%r14), %rdi
callq 0xf100
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_setbufsiz3
static lso_nargs_t lso_setbufsiz3(struct lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	int n, error;

	lua_settop(L, 3);

	n = lso_setbufsiz_(L, S, 2, 3);

	if ((error = lso_adjbufs(S)))
		goto error;

	return n;
error:
	lua_pushnil(L);
	lua_pushnil(L);
	lua_pushinteger(L, error);

	return 3;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x18609
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x10640
movl $0x2, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
movl $0x3, %ecx
callq 0x18d25
movq %r14, %rdi
callq 0x1636e
testl %eax, %eax
je 0x1687d
movl %eax, %r14d
movq %rbx, %rdi
callq 0xf980
movq %rbx, %rdi
callq 0xf980
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x3, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_seterror
static lso_nargs_t lso_seterror(struct lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	const char *what = luaL_checkstring(L, 2);
	int error = luaL_optint(L, 3, 0);

	return lso_seterror_(L, S, what, error);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x18609
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0xf620
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0xf400
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %eax, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x18ead
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_error
static lso_nargs_t lso_error(struct lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	const char *what = luaL_optstring(L, 2, "rw");
	int nret = 0;

	for (; *what; what++) {
		switch (*what) {
		case 'r':
			lso_pusherror(L, S->ibuf.error);
			nret++;

			break;
		case 'w':
			lso_pusherror(L, S->obuf.error);
			nret++;

			break;
		default:
			return luaL_argerror(L, 2, lua_pushfstring(L, "%s: %c: only `r' or `w' accepted", what, *what));
		} /* switch() */
	} /* for() */

	return nret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x18609
movq %rax, %r12
leaq 0x1edd7(%rip), %rdx     # 0x35735
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0xf8b0
movq %rax, %r15
leaq 0x108(%r12), %r13
addq $0x94, %r12
movzbl (%r15,%r14), %eax
movq %r12, %rcx
cmpl $0x72, %eax
je 0x16997
movq %r13, %rcx
cmpl $0x77, %eax
jne 0x169a6
movl (%rcx), %esi
movq %rbx, %rdi
callq 0x18f7e
incq %r14
jmp 0x16982
testl %eax, %eax
jne 0x169b7
movl %r14d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movsbl %al, %ecx
addq %r14, %r15
leaq 0x1ed50(%rip), %rsi     # 0x35714
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xfff0
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf3f0
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_unget2
static lso_nargs_t lso_unget2(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	const void *src;
	size_t len;
	struct iovec iov;
	int error;

	src = luaL_checklstring(L, 2, &len);

	if ((error = fifo_grow(&S->ibuf.fifo, len)))
		goto error;

	fifo_rewind(&S->ibuf.fifo, len);
	fifo_slice(&S->ibuf.fifo, &iov, 0, len);
	memcpy(iov.iov_base, src, len);

	S->ibuf.eof = 0;

	lua_pushboolean(L, 1);

	return 1;
error:
	lua_pushboolean(L, 0);
	lua_pushinteger(L, error);

	return 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x18609
movq %rax, %r14
movq %rsp, %r13
movq %rbx, %rdi
movl $0x2, %esi
movq %r13, %rdx
callq 0xf620
movq %rax, %r15
leaq 0x58(%r14), %r12
movq (%r13), %rax
movq 0x70(%r14), %rcx
movq 0x80(%r14), %rsi
subq %rsi, %rcx
xorl %ebp, %ebp
cmpq %rax, %rcx
jae 0x17248
movl $0x4b, %ebp
addq %rax, %rsi
jb 0x17248
movq %r12, %rdi
callq 0x163ad
movl %eax, %ebp
testl %ebp, %ebp
je 0x17268
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10800
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %ebp
jmp 0x172de
movq (%rsp), %rcx
movq 0x70(%r14), %rsi
movq 0x80(%r14), %rdi
movq %rsi, %r8
subq %rdi, %r8
cmpq %rcx, %r8
cmovaeq %rcx, %r8
movq 0x78(%r14), %rax
addq %rsi, %rax
subq %r8, %rax
xorl %edx, %edx
divq %rsi
movq %rdx, 0x78(%r14)
addq %rdi, %r8
movq %r8, 0x80(%r14)
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movq %rcx, %rdx
callq 0x18955
movq (%r13), %rdi
movq (%rsp), %rdx
movq %r15, %rsi
callq 0xfa60
movb $0x0, 0x90(%r14)
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_flush
static lso_nargs_t lso_flush(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	int mode = lso_imode(luaL_optstring(L, 2, "n"), S->obuf.mode);
	int error;

	if ((error = lso_prepsnd(L, S)) || (error = lso_doflush(S, mode))) {
		lua_pushboolean(L, 0);
		lua_pushinteger(L, error);

		return 2;
	} else {
		lua_pushboolean(L, 1);

		return 1;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
callq 0x18609
movq %rax, %r15
leaq 0x1e289(%rip), %rdx     # 0x35922
movl $0x2, %ebx
movq %r14, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0xf8b0
movl 0xa8(%r15), %esi
movq %rax, %rdi
callq 0x18ca2
movl %eax, %r12d
movq %r14, %rdi
movq %r15, %rsi
callq 0x19b72
testl %eax, %eax
jne 0x176dd
movq %r15, %rdi
movl %r12d, %esi
callq 0x187b1
testl %eax, %eax
je 0x176ff
movl %eax, %ebp
movq %r14, %rdi
xorl %esi, %esi
callq 0x10800
movslq %ebp, %rsi
movq %r14, %rdi
callq 0xf910
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %ebx
movq %r14, %rdi
movl $0x1, %esi
callq 0x10800
jmp 0x176f4
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_uncork
static lso_nargs_t lso_uncork(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	int error;

	if ((error = so_uncork(S->socket))) {
		lua_pushboolean(L, 0);
		lua_pushinteger(L, error);

		return 2;
	} else {
		lua_pushboolean(L, 1);

		return 1;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x18609
movq 0x128(%rax), %rdi
callq 0x10160
testl %eax, %eax
je 0x1774c
movl %eax, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10800
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %ebp
jmp 0x1775e
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_pending
static lso_nargs_t lso_pending(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);

	lua_pushunsigned(L, fifo_rlen(&S->ibuf.fifo));
	lua_pushunsigned(L, fifo_rlen(&S->obuf.fifo));

	return 2;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x18609
movq %rax, %r14
movq 0x80(%rax), %rsi
movq %rbx, %rdi
callq 0xf910
movq 0xe8(%r14), %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_sendfd3
static lso_nargs_t lso_sendfd3(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	const void *src;
	size_t len;
	int fd, error;

	if ((error = lso_prepsnd(L, S)))
		goto error;

	lua_settop(L, 3);

	src = luaL_checklstring(L, 2, &len);

	if ((fd = lso_tofileno(L, 3)) < 0)
		goto badfd;

	so_clear(S->socket);

	if ((error = so_sendmsg(S->socket, so_fdmsg(src, len, fd), 0)))
		goto error;

	lua_pushboolean(L, 1);

	return 1;
badfd:
	error = EBADF;
error:
	lua_pushboolean(L, 0);
	lua_pushinteger(L, error);

	return 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
callq 0x18609
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x19b72
testl %eax, %eax
je 0x177f4
movl %eax, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10800
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %ebp
movl %ebp, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x3, %esi
callq 0x10640
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0xf620
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x19d44
testl %eax, %eax
js 0x178d5
movl %eax, %ebp
movq 0x128(%r14), %rdi
callq 0xf840
movq 0x128(%r14), %rdi
leaq 0x28(%rsp), %rsi
movq $0x0, (%rsi)
xorl %eax, %eax
movl %eax, 0x8(%rsi)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movq %rcx, 0x10(%rsi)
movq $0x1, 0x18(%rsi)
leaq 0x60(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x30(%rdx)
movq %rdx, 0x20(%rsi)
movl %eax, 0x30(%rsi)
movq 0x8(%rsp), %rax
movq %r15, (%rcx)
movq %rax, 0x8(%rcx)
movq $0x18, 0x28(%rsi)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x8(%rdx)
movq $0x14, (%rdx)
movl %ebp, 0x10(%rdx)
xorl %edx, %edx
callq 0xf520
testl %eax, %eax
jne 0x177c8
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
jmp 0x177e4
movl $0x9, %ebp
jmp 0x177ca
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_pack4
static lso_nargs_t lso_pack4(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	lua_Number value;
	unsigned count;
	int mode, error;

	if ((error = lso_prepsnd(L, S)))
		goto error;

	lua_settop(L, 4);

	value = luaL_checknumber(L, 2);
	count = luaL_optunsigned(L, 3, 32);
	mode = lso_imode(luaL_optstring(L, 4, ""), S->obuf.mode);

	if ((error = fifo_pack(&S->obuf.fifo, (unsigned long long)(long long)value, count)))
		goto error;

	so_clear(S->socket);

	if ((error = lso_doflush(S, mode)))
		goto error;

	lua_pushboolean(L, 1);

	return 1;
error:
	lua_pushboolean(L, 0);
	lua_pushinteger(L, error);

	return 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x18609
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x19b72
testl %eax, %eax
je 0x17b63
movl %eax, %r13d
jmp 0x17ca0
movq %rbx, %rdi
movl $0x4, %esi
callq 0x10640
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10920
movsd %xmm0, (%rsp)
movl $0x20, %edx
movq %rbx, %rdi
movl $0x3, %esi
callq 0xf400
movq %rax, %r15
leaq 0x214ad(%rip), %rdx     # 0x3904b
movq %rbx, %rdi
movl $0x4, %esi
xorl %ecx, %ecx
callq 0xf8b0
movl 0xa8(%r14), %esi
movq %rax, %rdi
callq 0x18ca2
movl %eax, %ebp
movq %r14, %r12
addq $0xc0, %r12
movzbl 0xf3(%r14), %ecx
movq 0xd8(%r14), %rax
movq 0xe8(%r14), %rsi
subq %rsi, %rax
leaq (,%rax,8), %rdx
subq %rcx, %rdx
addq $0x8, %rdx
movl %r15d, %ecx
cmpq %rcx, %rdx
jae 0x17c21
xorl %r13d, %r13d
cmpq $0x7, %rax
ja 0x17c1c
movl $0x4b, %r13d
cmpq $-0x9, %rsi
ja 0x17c1c
addq $0x8, %rsi
movq %r12, %rdi
callq 0x163ad
movl %eax, %r13d
testl %r13d, %r13d
jne 0x17c9b
testl %r15d, %r15d
je 0x17c98
cvttsd2si (%rsp), %r13
movzbl 0xf3(%r14), %edx
movl $0x8, %eax
subl %edx, %eax
cmpl %eax, %r15d
cmovbl %r15d, %eax
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl %eax, %ecx
shll %cl, %edi
movzbl 0xf2(%r14), %r8d
shll %cl, %r8d
subl %eax, %r15d
movq %r13, %rsi
movl %r15d, %ecx
shrq %cl, %rsi
notl %edi
andl %edi, %esi
orl %r8d, %esi
movb %sil, 0xf2(%r14)
addl %edx, %eax
movb %al, 0xf3(%r14)
cmpb $0x8, %al
jb 0x17c93
movzbl %sil, %esi
movq %r12, %rdi
callq 0x19cd5
movw $0x0, 0xf2(%r14)
testl %r15d, %r15d
jne 0x17c2c
xorl %r13d, %r13d
testl %r13d, %r13d
je 0x17ccb
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10800
movslq %r13d, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x128(%r14), %rdi
callq 0xf840
movq %r14, %rdi
movl %ebp, %esi
callq 0x187b1
testl %eax, %eax
jne 0x17b5b
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
jmp 0x17cba
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_unpack2
static lso_nargs_t lso_unpack2(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	unsigned long long value;
	unsigned count;
	int error;

	if ((error = lso_preprcv(L, S)))
		goto error;

	lua_settop(L, 2);

	count = luaL_optunsigned(L, 2, 32);

	if (fifo_rbits(&S->ibuf.fifo) < count) {
		size_t rem = ((count - fifo_rbits(&S->ibuf.fifo)) + 7U) / 8U;

		if ((error = lso_fill(S, rem))) {
			if (fifo_rbits(&S->ibuf.fifo) < count)
				goto error;
		}
	}

	value = fifo_unpack(&S->ibuf.fifo, count);

	if (value == (unsigned long long)(lua_Integer)value)
		lua_pushinteger(L, (lua_Integer)value);
	else if (value == (unsigned long long)(lua_Number)value)
		lua_pushnumber(L, (lua_Number)value);
	else
		goto range;

	return 1;
range:
	error = ERANGE;
error:
	lua_pushnil(L);
	lua_pushinteger(L, error);

	return 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x18609
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x190fa
testl %eax, %eax
je 0x17d44
movl %eax, %ebp
movq %rbx, %rdi
callq 0xf980
movslq %ebp, %rsi
movl $0x2, %ebp
movq %rbx, %rdi
callq 0xf910
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10640
movl $0x20, %edx
movq %rbx, %rdi
movl $0x2, %esi
callq 0xf400
movq %rax, %r15
movzbl 0x89(%r14), %eax
movq 0x80(%r14), %rcx
leaq (%rax,%rcx,8), %rax
movl %r15d, %r12d
cmpq %r12, %rax
jae 0x17db9
movq %r12, %rsi
subq %rax, %rsi
addq $0x7, %rsi
shrq $0x3, %rsi
movq %r14, %rdi
callq 0x191c4
testl %eax, %eax
je 0x17db9
movl %eax, %ebp
movzbl 0x89(%r14), %eax
movq 0x80(%r14), %rcx
leaq (%rax,%rcx,8), %rax
cmpq %r12, %rax
jb 0x17d21
xorl %esi, %esi
movl $0x1, %ebp
testl %r15d, %r15d
je 0x17d31
movzbl 0x89(%r14), %eax
movq 0x80(%r14), %rcx
leaq (%rax,%rcx,8), %rcx
movl %r15d, %edx
cmpq %rdx, %rcx
jb 0x17d31
movb 0x88(%r14), %dil
xorl %esi, %esi
testb %al, %al
jne 0x17e49
movq 0x80(%r14), %rcx
testq %rcx, %rcx
je 0x17e35
movq 0x68(%r14), %rdx
movq 0x78(%r14), %rax
movb (%rdx,%rax), %dil
incq %rax
xorl %edx, %edx
divq 0x70(%r14)
movq %rdx, 0x78(%r14)
leaq -0x1(%rcx), %rax
movq %rax, 0x80(%r14)
cmpq $0x1, %rcx
jne 0x17e38
movq $0x0, 0x78(%r14)
jmp 0x17e38
movb $-0x1, %dil
movb %dil, 0x88(%r14)
movb $0x8, 0x89(%r14)
movb $0x8, %al
movzbl %al, %eax
cmpl %eax, %r15d
movl %eax, %edx
cmovbl %r15d, %edx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl %edx, %ecx
shll %cl, %r8d
movq %rsi, %r9
shlq %cl, %r9
notl %r8d
movzbl %dil, %esi
subl %edx, %eax
movl %eax, %ecx
shrl %cl, %esi
andl %r8d, %esi
orq %r9, %rsi
movb %al, 0x89(%r14)
subl %edx, %r15d
jne 0x17df1
jmp 0x17d31
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_fill2
static lso_nargs_t lso_fill2(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	size_t size = lso_checksize(L, 2);
	int error;

	if ((error = lso_preprcv(L, S)) || (error = lso_fill(S, size))) {
		lua_pushboolean(L, 0);
		lua_pushinteger(L, error);

		return 2;
	}

	lua_pushboolean(L, 1);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
callq 0x18609
movq %rax, %r15
movl $0x2, %ebx
movq %r14, %rdi
movl $0x2, %esi
callq 0x10920
movapd %xmm0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x190fa
testl %eax, %eax
jne 0x17f62
movdqa (%rsp), %xmm0
movq %xmm0, %rcx
movq %rcx, %rax
btrq $0x3f, %rax
movabsq $-0x10000000000000, %rdx # imm = 0xFFF0000000000000
addq %rax, %rdx
shrq $0x35, %rdx
cvttsd2si %xmm0, %rsi
movq %rsi, %rdi
subsd 0x1d130(%rip), %xmm0    # 0x35030
cvttsd2si %xmm0, %r8
sarq $0x3f, %rdi
andq %rdi, %r8
orq %rsi, %r8
testq %rcx, %rcx
movq $-0x1, %rsi
movq %r8, %rdi
cmovsq %rsi, %rdi
cmpl $0x3ff, %edx            # imm = 0x3FF
cmovaeq %r8, %rdi
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rax
cmoveq %rsi, %rdi
testq %rcx, %rcx
cmovnsq %rdi, %rsi
decq %rax
movabsq $0xfffffffffffff, %rcx  # imm = 0xFFFFFFFFFFFFF
cmpq %rcx, %rax
cmovaeq %rdi, %rsi
movq %r15, %rdi
callq 0x191c4
testl %eax, %eax
je 0x17f86
movl %eax, %ebp
movq %r14, %rdi
xorl %esi, %esi
callq 0x10800
movslq %ebp, %rsi
movq %r14, %rdi
callq 0xf910
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %ebx
movq %r14, %rdi
movl $0x1, %esi
callq 0x10800
jmp 0x17f79
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_clear
static lso_nargs_t lso_clear(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);

	so_clear(S->socket);

	lua_pushboolean(L, 1);

	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x18609
movq 0x128(%rax), %rdi
callq 0xf840
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_events
static lso_nargs_t lso_events(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	short events = so_events(S->socket);
	char mode[3], *p = mode;

	if ((events & POLLIN))
		*p++ = 'r';

	if ((events & POLLOUT))
		*p++ = 'w';

	lua_pushlstring(L, mode, p - mode);

	return 1;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x18609
movq 0x128(%rax), %rdi
callq 0x101d0
testb $0x1, %al
jne 0x1800e
leaq 0xd(%rsp), %rdx
jmp 0x18017
leaq 0xe(%rsp), %rdx
movb $0x72, -0x1(%rdx)
testb $0x4, %al
je 0x18021
movb $0x77, (%rdx)
incq %rdx
leaq 0xd(%rsp), %rsi
subq %rsi, %rdx
movq %rbx, %rdi
callq 0xf4c0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_timeout
static lso_nargs_t lso_timeout(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);

	if (isnormal(S->timeout) || S->timeout == 0) {
		lua_pushnumber(L, S->timeout);

		return 1;
	}

	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x18609
movq 0x140(%rax), %xmm0
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $-0x10000000000000, %rcx # imm = 0xFFF0000000000000
addq %rax, %rcx
shrq $0x35, %rcx
cmpl $0x3ff, %ecx            # imm = 0x3FF
jb 0x1807e
xorl %eax, %eax
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1808b
jp 0x1808b
movq %rbx, %rdi
callq 0xf2c0
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_shutdown
static lso_nargs_t lso_shutdown(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	int how, error;

	switch (luaL_checkoption(L, 2, "rw", (const char *[]){ "r", "w", "rw", "wr", 0 })) {
	case 0:
		how = SHUT_RD;

		break;
	case 1:
		how = SHUT_WR;

		break;
	default:
		how = SHUT_RDWR;

		break;
	} /* switch() */

	if ((error = so_shutdown(S->socket, how))) {
		lua_pushboolean(L, 0);
		lua_pushinteger(L, error);

		return 2;
	} else {
		lua_pushboolean(L, 1);

		return 1;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x18609
movq %rax, %r14
movups 0x2c1d1(%rip), %xmm0    # 0x44278
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movups 0x2c1d4(%rip), %xmm0    # 0x44288
movaps %xmm0, 0x10(%rcx)
movq 0x2c1d9(%rip), %rax     # 0x44298
movq %rax, 0x20(%rcx)
leaq 0x1d66b(%rip), %rdx     # 0x35735
movl $0x2, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0xfbc0
xorl %esi, %esi
cmpl $0x1, %eax
setne %sil
incl %esi
testl %eax, %eax
cmovel %eax, %esi
movq 0x128(%r14), %rdi
callq 0x104b0
testl %eax, %eax
je 0x18116
movl %eax, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10800
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0xf910
jmp 0x18128
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_eof
static lso_nargs_t lso_eof(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	const char *which = luaL_optstring(L, 2, "rw");
	int nret = 0;

	for (; *which; which++) {
		switch (*which) {
		case 'r':
			lua_pushboolean(L, S->ibuf.eof);
			nret++;

			break;
		case 'w':
			lua_pushboolean(L, S->obuf.eof);
			nret++;

			break;
		}
	} /* for() */

	return nret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x18609
movq %rax, %r14
leaq 0x1d5e7(%rip), %rdx     # 0x35735
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0xf8b0
movq %rax, %r12
leaq 0xf8(%r14), %r13
addq $0x90, %r14
movzbl (%r12), %eax
movq %r14, %rcx
cmpl $0x72, %eax
je 0x1818c
cmpl $0x77, %eax
je 0x18189
testl %eax, %eax
jne 0x1819a
jmp 0x1819f
movq %r13, %rcx
movzbl (%rcx), %esi
movq %rbx, %rdi
callq 0x10800
incl %r15d
incq %r12
jmp 0x18171
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_accept
static lso_nargs_t lso_accept(lua_State *L) {
	struct luasocket *A = lso_checkself(L, 1), *S;
	struct so_options opts;
	int fd = -1, error;

	if (lua_istable(L, 2)) {
		opts = lso_checkopts(L, 2);
	} else {
		opts = *so_opts();
	}

	S = lso_newsocket(L, A->type);

	opts.fd_close.arg = S;
	opts.fd_close.cb = &lso_closefd;

	so_clear(A->socket);

	if (-1 == (fd = so_accept(A->socket, 0, 0, &error)))
		goto error;

	if ((error = lso_prepsocket(S)))
		goto error;

	if (!(S->socket = so_fdopen(fd, &opts, &error)))
		goto error;

	return 1;
error:
	cqs_closefd(&fd);
	lua_pushnil(L);
	lua_pushinteger(L, error);

	return 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
callq 0x18609
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0xf260
cmpl $0x5, %eax
jne 0x181e7
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
movl $0x2, %edx
callq 0x19dc5
jmp 0x18238
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movw $0x100, 0x20(%rsp)      # imm = 0x100
xorl %eax, %eax
movl %eax, 0x22(%rsp)
movw $0x0, 0x26(%rsp)
movups %xmm0, 0x2f(%rsp)
movups %xmm0, 0x3f(%rsp)
movb $0x0, 0x4f(%rsp)
movl %eax, 0x59(%rsp)
movl %eax, 0x5c(%rsp)
movl %eax, 0x28(%rsp)
movw $0x101, 0x2c(%rsp)      # imm = 0x101
movb $0x1, %al
movb %al, 0x2e(%rsp)
movq $0x1, 0x50(%rsp)
movb %al, 0x58(%rsp)
movl 0x120(%r14), %esi
movq %rbx, %rdi
callq 0x15e40
movq %rax, %r15
movq %rax, 0x38(%rsp)
leaq -0x22ff(%rip), %rax     # 0x15f57
movq %rax, 0x40(%rsp)
movq 0x128(%r14), %rdi
callq 0xf840
movq 0x128(%r14), %rdi
leaq 0xc(%rsp), %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0xffd0
cmpl $-0x1, %eax
je 0x1829f
movl %eax, %ebp
movq %r15, %rdi
callq 0x1636e
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x182c4
cmpl $-0x1, %ebp
je 0x1829f
movl %ebp, %edi
callq 0x10a10
movq %rbx, %rdi
callq 0xf980
movslq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
movl %ebp, %edi
callq 0xf2f0
movq %rax, %rcx
movq %rax, 0x128(%r15)
movl $0x1, %eax
testq %rcx, %rcx
jne 0x182b9
jmp 0x18293
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_peername
static lso_nargs_t lso_peername(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	struct sockaddr_storage ss;
	socklen_t salen = sizeof ss;
	int error;

	memset(&ss, 0, sizeof ss);

	if ((error = so_remoteaddr(S->socket, &ss, &salen))) {
		lua_pushnil(L);
		lua_pushinteger(L, error);

		return 2;
	}

	return lso_pushname(L, &ss, salen);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
callq 0x18609
leaq 0xc(%rsp), %rdx
movl $0x80, (%rdx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x70(%rsi)
movq 0x128(%rax), %rdi
callq 0xf950
testl %eax, %eax
je 0x1835a
movl %eax, %ebp
movq %rbx, %rdi
callq 0xf980
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %eax
jmp 0x1836b
movl 0xc(%rsp), %edx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a633
addq $0x98, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_peereid
static lso_nargs_t lso_peereid(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	uid_t uid;
	gid_t gid;
	int error;

	if ((error = so_peereid(S->socket, &uid, &gid))) {
		lua_pushnil(L);
		lua_pushinteger(L, error);

		return 2;
	}

	lua_pushinteger(L, uid);
	lua_pushinteger(L, gid);

	return 2;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x18609
movq 0x128(%rax), %rdi
leaq 0x4(%rsp), %rsi
movq %rsp, %rdx
callq 0x108b0
testl %eax, %eax
je 0x183a7
movl %eax, %ebp
movq %rbx, %rdi
callq 0xf980
movslq %ebp, %rsi
jmp 0x183b6
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0xf910
movl (%rsp), %esi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_peerpid
static lso_nargs_t lso_peerpid(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	pid_t pid;
	int error;

	if ((error = so_peerpid(S->socket, &pid))) {
		lua_pushnil(L);
		lua_pushinteger(L, error);

		return 2;
	}

	lua_pushinteger(L, pid);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x18609
movq 0x128(%rax), %rdi
leaq 0xc(%rsp), %rsi
callq 0x10940
testl %eax, %eax
je 0x18401
movl %eax, %ebp
movq %rbx, %rdi
callq 0xf980
movl $0x2, %r14d
jmp 0x1840b
movl $0x1, %r14d
movl 0xc(%rsp), %ebp
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf910
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_localname
static lso_nargs_t lso_localname(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	struct sockaddr_storage ss;
	socklen_t salen = sizeof ss;
	int error;

	memset(&ss, 0, sizeof ss);

	if ((error = so_localaddr(S->socket, &ss, &salen))) {
		lua_pushnil(L);
		lua_pushinteger(L, error);

		return 2;
	}

	return lso_pushname(L, &ss, salen);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
callq 0x18609
leaq 0xc(%rsp), %rdx
movl $0x80, (%rdx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x70(%rsi)
movq 0x128(%rax), %rdi
callq 0x100b0
testl %eax, %eax
je 0x18491
movl %eax, %ebp
movq %rbx, %rdi
callq 0xf980
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %eax
jmp 0x184a2
movl 0xc(%rsp), %edx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a633
addq $0x98, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_stat
static lso_nargs_t lso_stat(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	const struct so_stat *st = so_stat(S->socket);

	lua_newtable(L);

	lua_newtable(L);
	lua_pushinteger(L, st->sent.count);
	lua_setfield(L, -2, "count");
	lua_pushboolean(L, st->sent.eof);
	lua_setfield(L, -2, "eof");
	lua_pushinteger(L, st->sent.time);
	lua_setfield(L, -2, "time");
	lua_setfield(L, -2, "sent");

	lua_newtable(L);
	lua_pushinteger(L, st->rcvd.count);
	lua_setfield(L, -2, "count");
	lua_pushboolean(L, st->rcvd.eof);
	lua_setfield(L, -2, "eof");
	lua_pushinteger(L, st->rcvd.time);
	lua_setfield(L, -2, "time");
	lua_setfield(L, -2, "rcvd");

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x18609
movq 0x128(%rax), %rdi
callq 0xff00
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x101e0
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x101e0
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xf910
leaq 0x1cc93(%rip), %r15     # 0x35189
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0xf530
movzbl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x10800
leaq 0x1d195(%rip), %r12     # 0x356af
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r12, %rdx
callq 0xf530
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0xf910
leaq 0x1d3cd(%rip), %r13     # 0x3590a
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r13, %rdx
callq 0xf530
leaq 0x1d3bb(%rip), %rdx     # 0x3590f
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x101e0
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0xf910
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0xf530
movzbl 0x20(%r14), %esi
movq %rbx, %rdi
callq 0x10800
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r12, %rdx
callq 0xf530
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0xf910
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r13, %rdx
callq 0xf530
leaq 0x1d34b(%rip), %rdx     # 0x35914
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_checktodo
static lso_error_t lso_checktodo(struct luasocket *S) {
	int todo, error;

	while ((todo = (S->todo & ~S->done))) {
		if (todo & LSO_DO_FLUSH) {
			so_clear(S->socket);

			if ((error = lso_doflush(S, LSO_NOBUF)))
				return error;

			S->done |= LSO_DO_FLUSH;
		} else if (todo & LSO_DO_STARTTLS) {
			so_clear(S->socket);

			if (!S->tls.once) {
				S->tls.once = 1;

				if (S->ibuf.mode & LSO_PUSHBACK)
					fifo_rvec(&S->ibuf.fifo, &S->tls.config.pushback, 1);

				error = so_starttls(S->socket, &S->tls.config);

				if (S->ibuf.mode & LSO_PUSHBACK) {
					fifo_purge(&S->ibuf.fifo);
					S->ibuf.eom = 0;
				}
			} else {
				error = so_starttls(S->socket, NULL);
			}

			if (S->tls.config.instance) {
				SSL_free(S->tls.config.instance);
				S->tls.config.instance = NULL;
			}

			if (S->tls.config.context) {
				SSL_CTX_free(S->tls.config.context);
				S->tls.config.context = NULL;
			}

			if (error)
				return error;

			S->done |= LSO_DO_STARTTLS;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x4(%rdi), %eax
notl %eax
andl (%rdi), %eax
je 0x1879e
movq %rdi, %rbx
leaq 0x58(%rdi), %r14
leaq 0x28(%rdi), %r15
leaq 0x10(%rdi), %r12
leaq 0x78(%rdi), %r13
testb $0x1, %al
jne 0x186ef
testb $0x2, %al
je 0x18791
movq 0x128(%rbx), %rdi
callq 0xf840
cmpb $0x0, 0x8(%rbx)
je 0x18711
movq 0x128(%rbx), %rdi
xorl %esi, %esi
callq 0x10480
movl %eax, %ebp
jmp 0x18759
movq 0x128(%rbx), %rdi
callq 0xf840
movq %rbx, %rdi
movl $0x4, %esi
callq 0x187b1
movl %eax, %ebp
movl $0x1, %eax
jmp 0x1878a
movb $0x1, 0x8(%rbx)
testb $0x40, 0x40(%rbx)
je 0x1872b
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x18901
movq 0x128(%rbx), %rdi
movq %r12, %rsi
callq 0x10480
movl %eax, %ebp
testb $0x40, 0x40(%rbx)
je 0x18759
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movl $0x0, 0x10(%r13)
movb $0x0, 0x91(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1876f
callq 0xf770
movq $0x0, 0x20(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x18785
callq 0xf0f0
movq $0x0, 0x18(%rbx)
movl $0x2, %eax
testl %ebp, %ebp
jne 0x187a0
orl %eax, 0x4(%rbx)
movl 0x4(%rbx), %eax
notl %eax
andl (%rbx), %eax
jne 0x186bf
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_doflush
static lso_error_t lso_doflush(struct luasocket *S, int mode) {
	size_t amount = 0, n;
	struct iovec iov;
	int error;

	if (mode & LSO_LINEBUF) {
		if (S->obuf.eol > 0) {
			amount = S->obuf.eol;
		} else if (fifo_rlen(&S->obuf.fifo) >= S->obuf.maxline) {
			amount = S->obuf.maxline;
		}
	} else if (mode & LSO_FULLBUF) {
		amount = fifo_rlen(&S->obuf.fifo);
		amount -= amount % S->obuf.bufsiz;
	} else if (mode & LSO_NOBUF) {
		amount = fifo_rlen(&S->obuf.fifo);
	}

	while (amount) {
		if (!fifo_slice(&S->obuf.fifo, &iov, 0, amount))
			break; /* should never happen */

		if (!(n = so_write(S->socket, iov.iov_base, iov.iov_len, &error)))
			goto error;

		fifo_discard(&S->obuf.fifo, n);
		amount -= n;
		S->obuf.eol -= MIN(S->obuf.eol, n);
	}

	return 0;
error:
	switch (error) {
	case EPIPE:
		S->obuf.eof = 1;

		break;
	} /* switch() */

	return error;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testb $0x1, %sil
jne 0x187d8
testb $0x2, %sil
jne 0x187fb
testb $0x4, %sil
jne 0x18813
xorl %r14d, %r14d
jmp 0x1881a
movq 0x100(%rbx), %r14
testq %r14, %r14
jne 0x1881a
movq 0xb0(%rbx), %rax
xorl %r14d, %r14d
cmpq %rax, 0xe8(%rbx)
cmovaeq %rax, %r14
jmp 0x1881a
movq 0xe8(%rbx), %r14
movq %r14, %rax
xorl %edx, %edx
divq 0xb8(%rbx)
subq %rdx, %r14
jmp 0x1881a
movq 0xe8(%rbx), %r14
testq %r14, %r14
je 0x188df
leaq 0xc0(%rbx), %r15
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x18955
testq %rax, %rax
je 0x188df
movq 0x128(%rbx), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r13, %rcx
callq 0xf3e0
testq %rax, %rax
je 0x188ef
movq %rax, %rcx
movq 0xe8(%rbx), %rsi
cmpq %rax, %rsi
movq %rax, %rdi
cmovbq %rsi, %rdi
movq 0xe0(%rbx), %rax
addq %rdi, %rax
xorl %edx, %edx
divq 0xd8(%rbx)
movq %rsi, %rax
subq %rdi, %rax
movq %rdx, 0xe0(%rbx)
movq %rax, 0xe8(%rbx)
cmpq %rcx, %rsi
ja 0x188b8
movq $0x0, 0xe0(%rbx)
movq 0x100(%rbx), %rdx
xorl %eax, %eax
subq %rcx, %rdx
movl $0x0, %esi
cmovaeq %rdx, %rsi
movq %rsi, 0x100(%rbx)
subq %rcx, %r14
jne 0x18834
jmp 0x188e1
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl 0xc(%rsp), %eax
cmpl $0x20, %eax
jne 0x188e1
movb $0x1, 0xf8(%rbx)
jmp 0x188e1
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/fifo.h
// Function: fifo_rvec
static size_t fifo_rvec(struct fifo *fifo, struct iovec *iov, _Bool realign) {
	if (fifo->head + fifo->count > fifo->size && realign)
		fifo_realign(fifo);

	iov->iov_base = &fifo->base[fifo->head];
	iov->iov_len  = FIFO_MIN(fifo->size - fifo->head, fifo->count);

	return iov->iov_len;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorb $0x1, %dl
movq 0x28(%rdi), %rax
addq 0x20(%rdi), %rax
cmpq 0x18(%rdi), %rax
movq %rsi, %r14
setbe %al
orb %dl, %al
jne 0x18929
movq %rbx, %rdi
callq 0x1645c
movq 0x20(%rbx), %rax
movq 0x10(%rbx), %rcx
addq %rax, %rcx
movq %rcx, (%r14)
movq 0x18(%rbx), %rcx
movq 0x28(%rbx), %rdx
subq %rax, %rcx
cmpq %rdx, %rcx
cmovaeq %rdx, %rcx
movq %rcx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/fifo.h
// Function: fifo_slice
FIFO_NOTUSED static size_t fifo_slice(struct fifo *fifo, struct iovec *iov, size_t p, size_t count) {
	size_t pe;

	if (p > fifo->count) {
		iov->iov_base = 0;
		iov->iov_len  = 0;

		return 0;
	}

	count = FIFO_MIN(count, fifo->count - p);
	pe    = p + count;

	if (fifo->head + p < fifo->size && fifo->head + pe > fifo->size)
		fifo_realign(fifo);

	iov->iov_base = &fifo->base[((fifo->head + p) % fifo->size)];
	iov->iov_len  = count;

	return count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x28(%rdi), %rax
cmpq %rdx, %rax
cmovbq %rax, %rbx
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
cmpq %rax, %rcx
setb %dl
addq %rbx, %rcx
cmpq %rax, %rcx
seta %al
andb %dl, %al
cmpb $0x1, %al
jne 0x18993
movq %r15, %rdi
callq 0x1645c
movq 0x20(%r15), %rax
xorl %edx, %edx
divq 0x18(%r15)
addq 0x10(%r15), %rdx
movq %rdx, (%r14)
movq %rbx, 0x8(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_setvbuf_
static lso_nargs_t lso_setvbuf_(struct lua_State *L, struct luasocket *S, int modeidx, int bufidx) {
	lso_pushmode(L, S->obuf.mode, LSO_WRMASK, 1);
	lua_pushinteger(L, S->obuf.bufsiz);

	S->obuf.mode = lso_checkvbuf(L, modeidx) | (S->obuf.mode & ~LSO_ALLBUF);

	if (S->obuf.mode & (LSO_LINEBUF|LSO_FULLBUF))
		S->obuf.bufsiz = lso_optsize(L, bufidx, LSO_BUFSIZ);

	return 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl 0xa8(%rsi), %esi
movl $0x1, %r12d
movl $0xffffffbf, %edx       # imm = 0xFFFFFFBF
movl $0x1, %ecx
callq 0x18a75
movq 0xb8(%rbx), %rsi
movq %r14, %rdi
callq 0xf910
movq 0x2b877(%rip), %rax     # 0x44270
movq %rsp, %rcx
movq %rax, 0x20(%rcx)
movups 0x2b859(%rip), %xmm0    # 0x44260
movaps %xmm0, 0x10(%rcx)
movups 0x2b83e(%rip), %xmm0    # 0x44250
movaps %xmm0, (%rcx)
leaq 0x1ceaa(%rip), %rdx     # 0x358c6
movq %r14, %rdi
movl %r15d, %esi
callq 0xfbc0
xorl %ecx, %ecx
cmpl $0x1, %eax
setne %cl
leal 0x2(,%rcx,2), %ecx
testl %eax, %eax
cmovel %r12d, %ecx
movl 0xa8(%rbx), %eax
andl $-0x8, %eax
orl %ecx, %eax
movl %eax, 0xa8(%rbx)
testb $0x3, %cl
je 0x18a68
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rdi
movl %ebp, %esi
callq 0x18b46
movq %rax, 0xb8(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_pushmode
static void lso_pushmode(lua_State *L, int mode, int mask, _Bool libc) {
	if (libc) {
		if (mode & LSO_NOBUF)
			lua_pushstring(L, "no");
		else if (mode & LSO_LINEBUF)
			lua_pushstring(L, "line");
		else if (mode & LSO_FULLBUF)
			lua_pushstring(L, "full");
		else
			lua_pushnil(L); /* XXX: shouldn't happen */
	} else {
		char flag[8], *p = flag;

		if (mode & LSO_TEXT)
			*p++ = 't';
		else if (mode & LSO_BINARY)
			*p++ = 'b';
		else
			*p++ = '-';

		if (mode & LSO_NOBUF)
			*p++ = 'n';
		else if (mode & LSO_LINEBUF)
			*p++ = 'l';
		else if (mode & LSO_FULLBUF)
			*p++ = 'f';
		else
			*p++ = '-';

		if (mask & LSO_AUTOFLUSH)
			*p++ = (mode & LSO_AUTOFLUSH)? 'a' : 'A';

		if (mask & LSO_PUSHBACK)
			*p++ = (mode & LSO_PUSHBACK)? 'p' : 'P';

		lua_pushlstring(L, flag, p - flag);
	}
}

// Assembly:
testl %ecx, %ecx
je 0x18a94
testb $0x4, %sil
jne 0x18aa7
testb $0x1, %sil
jne 0x18ab9
testb $0x2, %sil
jne 0x18b3a
jmp 0xf980
pushq %rax
testb $0x8, %sil
jne 0x18ab3
testb $0x10, %sil
jne 0x18ac5
movb $0x2d, (%rsp)
jmp 0x18ac9
leaq 0x1d5ca(%rip), %rsi     # 0x36078
jmp 0xfbd0
movb $0x74, (%rsp)
jmp 0x18ac9
leaq 0x1ce06(%rip), %rsi     # 0x358c6
jmp 0xfbd0
movb $0x62, (%rsp)
testb $0x4, %sil
jne 0x18aef
testb $0x1, %sil
jne 0x18af3
testb $0x2, %sil
leaq 0x2(%rsp), %rax
movl $0x2d, %r8d
movl $0x66, %ecx
cmovel %r8d, %ecx
jmp 0x18afa
movb $0x6e, %cl
jmp 0x18af5
movb $0x6c, %cl
leaq 0x2(%rsp), %rax
movb %cl, 0x1(%rsp)
testb $0x20, %dl
je 0x18b13
movl %esi, %ecx
andb $0x20, %cl
orb $0x41, %cl
leaq 0x3(%rsp), %rax
movb %cl, -0x1(%rax)
testb $0x40, %dl
je 0x18b2a
movzbl %sil, %ecx
shrl $0x6, %ecx
shlb $0x5, %cl
orb $0x50, %cl
movb %cl, (%rax)
incq %rax
movq %rsp, %rsi
subq %rsi, %rax
movq %rax, %rdx
callq 0xf4c0
popq %rax
retq
leaq 0x1cbc8(%rip), %rsi     # 0x35709
jmp 0xfbd0
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_optsize
static size_t lso_optsize(struct lua_State *L, int index, size_t def) {
	lua_Number size;

	if (lua_isnoneornil(L, index))
		return def;

	size = luaL_checknumber(L, index);

	if (size < 0 || isinf(size))
		return LSO_INFSIZ;

	return (size > 0)? (size_t)size : def;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0xf260
testl %eax, %eax
jle 0x18bfa
movq %r14, %rdi
movl %ebp, %esi
callq 0x10920
movq %xmm0, %rax
testq %rax, %rax
sets %cl
btrq $0x3f, %rax
leaq -0x1(%rax), %rdx
movabsq $0xfffffffffffff, %rsi  # imm = 0xFFFFFFFFFFFFF
cmpq %rsi, %rdx
setb %dl
andb %cl, %dl
movabsq $0x7ff0000000000000, %rsi # imm = 0x7FF0000000000000
cmpq %rsi, %rax
sete %sil
orb %dl, %sil
movabsq $-0x10000000000000, %rdx # imm = 0xFFF0000000000000
addq %rax, %rdx
shrq $0x35, %rdx
cmpl $0x3ff, %edx            # imm = 0x3FF
setb %al
andb %cl, %al
orb %sil, %al
movq $-0x1, %rax
jne 0x18bfd
cvttsd2si %xmm0, %rax
movq %rax, %rcx
movapd %xmm0, %xmm1
subsd 0x1c451(%rip), %xmm1    # 0x35030
sarq $0x3f, %rcx
cvttsd2si %xmm1, %rdx
andq %rcx, %rdx
orq %rax, %rdx
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
cmovaq %rdx, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_setmode_
static lso_nargs_t lso_setmode_(struct lua_State *L, struct luasocket *S, int ridx, int widx) {
	lso_pushmode(L, S->ibuf.mode, LSO_RDMASK, 0);
	lso_pushmode(L, S->obuf.mode, LSO_WRMASK, 0);

	if (!lua_isnil(L, ridx))
		S->ibuf.mode = LSO_RDMASK & lso_imode(luaL_checkstring(L, ridx), LSO_INITMODE);

	if (!lua_isnil(L, widx))
		S->obuf.mode = LSO_WRMASK & lso_imode(luaL_checkstring(L, widx), LSO_INITMODE);

	return 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl 0x40(%rsi), %esi
movl $0xffffffd8, %edx       # imm = 0xFFFFFFD8
xorl %ecx, %ecx
callq 0x18a75
movl 0xa8(%rbx), %esi
movq %r14, %rdi
movl $0xffffffbf, %edx       # imm = 0xFFFFFFBF
xorl %ecx, %ecx
callq 0x18a75
movq %r14, %rdi
movl %r15d, %esi
callq 0xf260
testl %eax, %eax
je 0x18c67
movq %r14, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0xf620
movq %rax, %rdi
movl $0x69, %esi
callq 0x18ca2
andl $-0x28, %eax
movl %eax, 0x40(%rbx)
movq %r14, %rdi
movl %ebp, %esi
callq 0xf260
testl %eax, %eax
je 0x18c97
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0xf620
movq %rax, %rdi
movl $0x69, %esi
callq 0x18ca2
andl $-0x41, %eax
movl %eax, 0xa8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_imode
static int lso_imode(const char *str, int init) {
	int mode = init, ch;

	while ((ch = *str++)) {
		switch (ch) {
		case 'n':
			mode = LSO_NOBUF | (mode & ~LSO_ALLBUF);
			break;
		case 'l':
			mode = LSO_LINEBUF | (mode & ~LSO_ALLBUF);
			break;
		case 'f':
			mode = LSO_FULLBUF | (mode & ~LSO_ALLBUF);
			break;
		case 't':
			mode = LSO_TEXT | (mode & ~LSO_BINARY);
			break;
		case 'b':
			mode = LSO_BINARY | (mode & ~LSO_TEXT);
			break;
		case 'a':
			mode |= LSO_AUTOFLUSH;
			break;
		case 'A':
			mode &= ~LSO_AUTOFLUSH;
			break;
		case 'p':
			mode |= LSO_PUSHBACK;
			break;
		case 'P':
			mode &= ~LSO_PUSHBACK;
			break;
		} /* switch() */
	} /* while() */

	return mode;
}

// Assembly:
movl %esi, %eax
leaq 0x1c8bd(%rip), %rcx     # 0x35568
movzbl (%rdi), %edx
incq %rdi
cmpl $0x61, %edx
jle 0x18cce
leal -0x6c(%rdx), %esi
cmpl $0x8, %esi
ja 0x18ce2
movslq (%rcx,%rsi,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
andl $-0x8, %eax
incl %eax
jmp 0x18cab
cmpl $0x4f, %edx
jle 0x18cf4
cmpl $0x50, %edx
je 0x18cfe
cmpl $0x61, %edx
jne 0x18cab
orl $0x20, %eax
jmp 0x18cab
cmpl $0x62, %edx
je 0x18d18
cmpl $0x66, %edx
jne 0x18cab
andl $-0x8, %eax
orl $0x2, %eax
jmp 0x18cab
cmpl $0x41, %edx
jne 0x18d20
andl $-0x21, %eax
jmp 0x18cab
andl $-0x41, %eax
jmp 0x18cab
orl $0x40, %eax
jmp 0x18cab
andl $-0x19, %eax
orl $0x8, %eax
jmp 0x18cab
andl $-0x8, %eax
orl $0x4, %eax
jmp 0x18cab
andl $-0x19, %eax
orl $0x10, %eax
jmp 0x18cab
testl %edx, %edx
jne 0x18cab
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_setbufsiz_
static lso_nargs_t lso_setbufsiz_(struct lua_State *L, struct luasocket *S, int ridx, int widx) {
	lso_pushsize(L, S->ibuf.bufsiz);
	lso_pushsize(L, S->obuf.bufsiz);

	S->ibuf.bufsiz = lso_optsize(L, ridx, S->ibuf.bufsiz);
	S->obuf.bufsiz = lso_optsize(L, widx, S->obuf.bufsiz);

	return 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq 0x50(%rsi), %rsi
callq 0x18d85
movq 0xb8(%rbx), %rsi
movq %r15, %rdi
callq 0x18d85
movq 0x50(%rbx), %rdx
movq %r15, %rdi
movl %r14d, %esi
callq 0x18b46
movq %rax, 0x50(%rbx)
movq 0xb8(%rbx), %rdx
movq %r15, %rdi
movl %ebp, %esi
callq 0x18b46
movq %rax, 0xb8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq