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

	so_clear(S->socket);

	if (!(error = so_connect(S->socket))) {
		lua_pushvalue(L, 1);

		return 1;
	} else {
		lua_pushnil(L);
		lua_pushinteger(L, error);

		return 2;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x128(%rax), %rdi
callq 0xf8d0
movq -0x18(%rbp), %rax
movq 0x128(%rax), %rdi
callq 0xf860
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jne 0x195bd
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xfa50
movl $0x1, -0x4(%rbp)
jmp 0x195da
movq -0x10(%rbp), %rdi
callq 0xfa10
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xf9a0
movl $0x2, -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/socket.c
// Function: lso_listen1
static lso_nargs_t lso_listen1(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	int error;

	so_clear(S->socket);

	if (!(error = so_listen(S->socket))) {
		lua_pushvalue(L, 1);

		return 1;
	} else {
		lua_pushnil(L);
		lua_pushinteger(L, error);

		return 2;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x128(%rax), %rdi
callq 0xf8d0
movq -0x18(%rbp), %rax
movq 0x128(%rax), %rdi
callq 0x10100
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jne 0x1964d
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xfa50
movl $0x1, -0x4(%rbp)
jmp 0x1966a
movq -0x10(%rbp), %rdi
callq 0xfa10
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xf9a0
movl $0x2, -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/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0xfbe0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x128(%rax), %rdi
callq 0xfbd0
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x19906
movl $0x0, -0x4(%rbp)
jmp 0x19958
movq -0x10(%rbp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0x2ef78(%rip), %rdx     # 0x4888e
callq 0xf200
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf280
cmpl $0x0, %eax
jne 0x19937
movl $0x0, -0x4(%rbp)
jmp 0x19958
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10b10
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xf120
movl $0x1, -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/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x107f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x2, %edx
movl $0x3, %ecx
callq 0x1c9a0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x19130
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
je 0x19a69
jmp 0x19a71
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x19a97
movq -0x10(%rbp), %rdi
callq 0xfa10
movq -0x10(%rbp), %rdi
callq 0xfa10
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0xf9a0
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xf6a0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xf450
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x1cc20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0x2ecc3(%rip), %rdx     # 0x488e1
xorl %eax, %eax
movl %eax, %ecx
callq 0xf940
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x19ce4
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x28(%rbp)
subl $0x72, %eax
je 0x19c5a
jmp 0x19c50
movl -0x28(%rbp), %eax
subl $0x77, %eax
je 0x19c78
jmp 0x19c96
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x94(%rax), %esi
callq 0x1cd50
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x19cd1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x108(%rax), %esi
callq 0x1cd50
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x19cd1
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
leaq 0x2ec0c(%rip), %rsi     # 0x488c0
movb $0x0, %al
callq 0x10130
movq -0x30(%rbp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0xf440
movl %eax, -0x4(%rbp)
jmp 0x19cea
jmp 0x19cd3
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x19c32
movl -0x24(%rbp), %eax
movl %eax, -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/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq -0x28(%rbp), %rdx
callq 0xf6a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
addq $0x18, %rdi
movq -0x28(%rbp), %rsi
callq 0x1deb0
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x1a3e3
jmp 0x1a448
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
addq $0x18, %rdi
movq -0x28(%rbp), %rsi
callq 0x1e840
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
addq $0x18, %rdi
movq -0x28(%rbp), %rcx
leaq -0x38(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1c230
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xfb40
movq -0x18(%rbp), %rax
movb $0x0, 0x90(%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x109d0
movl $0x1, -0x4(%rbp)
jmp 0x1a467
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x109d0
movq -0x10(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0xf9a0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0x2e230(%rip), %rdx     # 0x48ace
xorl %eax, %eax
movl %eax, %ecx
callq 0xf940
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0xa8(%rax), %esi
callq 0x1c8c0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e8d0
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
jne 0x1a8e5
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1bf30
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
je 0x1a906
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x109d0
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0xf9a0
movl $0x2, -0x4(%rbp)
jmp 0x1a91b
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x109d0
movl $0x1, -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/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x128(%rax), %rdi
callq 0x102b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x1a987
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x109d0
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xf9a0
movl $0x2, -0x4(%rbp)
jmp 0x1a99c
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x109d0
movl $0x1, -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/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
addq $0x18, %rdi
callq 0x1c210
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0xf9a0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0xa8, %rdi
addq $0x18, %rdi
callq 0x1c210
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0xf9a0
movl $0x2, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e8d0
movl %eax, -0x30(%rbp)
cmpl $0x0, %eax
je 0x1aa6b
jmp 0x1ab75
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x107f0
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq -0x28(%rbp), %rdx
callq 0xf6a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x1ec60
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jge 0x1aaaa
jmp 0x1ab6e
movq -0x18(%rbp), %rax
movq 0x128(%rax), %rdi
callq 0xf8d0
movq -0x18(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, -0xc0(%rbp)
movq $0x0, -0x68(%rbp)
movl $0x0, -0x60(%rbp)
movq $0x0, -0x78(%rbp)
movq $0x0, -0x70(%rbp)
leaq -0x78(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0x1, -0x50(%rbp)
leaq -0xb8(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0xf7d0
leaq -0xb8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x40, -0x40(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
leaq -0x68(%rbp), %rdi
callq 0x1ed30
movq -0xc0(%rbp), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xf570
movl %eax, -0x30(%rbp)
cmpl $0x0, %eax
je 0x1ab57
jmp 0x1ab75
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x109d0
movl $0x1, -0x4(%rbp)
jmp 0x1ab94
movl $0x9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x109d0
movq -0x10(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0xf9a0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e8d0
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x1aed8
jmp 0x1afa1
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x107f0
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x10b20
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
movl $0x20, %edx
callq 0xf450
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
leaq 0x3264c(%rip), %rdx     # 0x4d56b
xorl %eax, %eax
movl %eax, %ecx
callq 0xf940
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0xa8(%rax), %esi
callq 0x1c8c0
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0xa8, %rdi
addq $0x18, %rdi
cvttsd2si -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x1edf0
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x1af64
jmp 0x1afa1
movq -0x18(%rbp), %rax
movq 0x128(%rax), %rdi
callq 0xf8d0
movq -0x18(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x1bf30
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x1af8a
jmp 0x1afa1
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x109d0
movl $0x1, -0x4(%rbp)
jmp 0x1afc0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x109d0
movq -0x10(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0xf9a0
movl $0x2, -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/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x1e920
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1cf90
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jne 0x1b1fa
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1d280
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x1b21b
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x109d0
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0xf9a0
movl $0x2, -0x4(%rbp)
jmp 0x1b230
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x109d0
movl $0x1, -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/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rdi
callq 0xf8d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x109d0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rdi
callq 0x10320
movw %ax, -0x12(%rbp)
leaq -0x15(%rbp), %rax
movq %rax, -0x20(%rbp)
movswl -0x12(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1b338
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x72, (%rax)
movswl -0x12(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x1b356
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x77, (%rax)
movq -0x8(%rbp), %rdi
leaq -0x15(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x15(%rbp), %rax
subq %rax, %rdx
callq 0xf510
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsd 0x140(%rax), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $-0x10000000000000, %rcx # imm = 0xFFF0000000000000
addq %rcx, %rax
shrq $0x35, %rax
subl $0x3ff, %eax            # imm = 0x3FF
setb %al
testb $0x1, %al
jne 0x1b3f0
movq -0x18(%rbp), %rax
movsd 0x140(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1b40e
jp 0x1b40e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd 0x140(%rax), %xmm0
callq 0xf300
movl $0x1, -0x4(%rbp)
jmp 0x1b415
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq 0x3e06f(%rip), %rax     # 0x594b8
movq %rax, -0x30(%rbp)
movups 0x3e054(%rip), %xmm0    # 0x594a8
movaps %xmm0, -0x40(%rbp)
movups 0x3e039(%rip), %xmm0    # 0x59498
movaps %xmm0, -0x50(%rbp)
leaq 0x2d477(%rip), %rdx     # 0x488e1
movl $0x2, %esi
leaq -0x50(%rbp), %rcx
callq 0xfcb0
movl %eax, %ecx
movl %ecx, -0x54(%rbp)
testl %eax, %eax
je 0x1b48d
jmp 0x1b483
movl -0x54(%rbp), %eax
subl $0x1, %eax
je 0x1b496
jmp 0x1b49f
movl $0x0, -0x1c(%rbp)
jmp 0x1b4a6
movl $0x1, -0x1c(%rbp)
jmp 0x1b4a6
movl $0x2, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x128(%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x10630
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
je 0x1b4e2
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x109d0
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0xf9a0
movl $0x2, -0x4(%rbp)
jmp 0x1b4f7
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x109d0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x2d3b3(%rip), %rdx     # 0x488e1
xorl %eax, %eax
movl %eax, %ecx
callq 0xf940
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1b5ba
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x20(%rbp)
subl $0x72, %eax
je 0x1b566
jmp 0x1b55c
movl -0x20(%rbp), %eax
subl $0x77, %eax
je 0x1b589
jmp 0x1b5aa
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movb 0x90(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x109d0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1b5aa
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movb 0xf8(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x109d0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1b5ac
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1b542
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x18(%rbp)
movl $0xffffffff, -0x74(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0xf280
cmpl $0x5, %eax
jne 0x1b637
movq -0x10(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
movl $0x2, %edx
callq 0x1f110
leaq -0x70(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
movl $0x50, %edx
callq 0xfb40
jmp 0x1b698
leaq -0x118(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0xf7d0
movb $0x1, -0x107(%rbp)
movl $0x0, -0x100(%rbp)
movb $0x1, -0xfc(%rbp)
movb $0x1, -0xfb(%rbp)
movb $0x1, -0xfa(%rbp)
movl $0x1, %eax
movq %rax, -0xd8(%rbp)
movb $0x1, -0xd0(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x118(%rbp), %rsi
movl $0x50, %edx
callq 0xfb40
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x120(%rax), %esi
callq 0x18700
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x2e5e(%rip), %rax     # 0x18860
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x128(%rax), %rdi
callq 0xf8d0
movq -0x18(%rbp), %rax
movq 0x128(%rax), %rdi
xorl %eax, %eax
movl %eax, %edx
leaq -0x78(%rbp), %rcx
movq %rdx, %rsi
callq 0x10110
movl %eax, %ecx
movl %ecx, -0x74(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x1b6fd
jmp 0x1b73c
movq -0x20(%rbp), %rdi
callq 0x18840
movl %eax, -0x78(%rbp)
cmpl $0x0, %eax
je 0x1b710
jmp 0x1b73c
movl -0x74(%rbp), %edi
leaq -0x70(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0xf330
movq -0x20(%rbp), %rcx
movq %rax, 0x128(%rcx)
cmpq $0x0, %rax
jne 0x1b733
jmp 0x1b73c
movl $0x1, -0x4(%rbp)
jmp 0x1b762
leaq -0x74(%rbp), %rdi
callq 0x194f0
movq -0x10(%rbp), %rdi
callq 0xfa10
movq -0x10(%rbp), %rdi
movslq -0x78(%rbp), %rsi
callq 0xf9a0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x18(%rbp)
movl $0x80, -0x9c(%rbp)
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movq -0x18(%rbp), %rax
movq 0x128(%rax), %rdi
leaq -0x98(%rbp), %rsi
leaq -0x9c(%rbp), %rdx
callq 0xf9e0
movl %eax, -0xa0(%rbp)
cmpl $0x0, %eax
je 0x1b7f9
movq -0x10(%rbp), %rdi
callq 0xfa10
movq -0x10(%rbp), %rdi
movslq -0xa0(%rbp), %rsi
callq 0xf9a0
movl $0x2, -0x4(%rbp)
jmp 0x1b812
movq -0x10(%rbp), %rdi
movl -0x9c(%rbp), %edx
leaq -0x98(%rbp), %rsi
callq 0x1fe10
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x128(%rax), %rdi
leaq -0x1c(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x10ab0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x1b87d
movq -0x10(%rbp), %rdi
callq 0xfa10
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0xf9a0
movl $0x2, -0x4(%rbp)
jmp 0x1b8a0
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0xf9a0
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0xf9a0
movl $0x2, -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/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x128(%rax), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x10b40
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
je 0x1b909
movq -0x10(%rbp), %rdi
callq 0xfa10
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0xf9a0
movl $0x2, -0x4(%rbp)
jmp 0x1b91d
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xf9a0
movl $0x1, -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/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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x18(%rbp)
movl $0x80, -0x9c(%rbp)
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movq -0x18(%rbp), %rax
movq 0x128(%rax), %rdi
leaq -0x98(%rbp), %rsi
leaq -0x9c(%rbp), %rdx
callq 0x10200
movl %eax, -0xa0(%rbp)
cmpl $0x0, %eax
je 0x1b9b9
movq -0x10(%rbp), %rdi
callq 0xfa10
movq -0x10(%rbp), %rdi
movslq -0xa0(%rbp), %rsi
callq 0xf9a0
movl $0x2, -0x4(%rbp)
jmp 0x1b9d2
movq -0x10(%rbp), %rdi
movl -0x9c(%rbp), %edx
leaq -0x98(%rbp), %rsi
callq 0x1fe10
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x1bba0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rdi
callq 0x10020
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x10330
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x10330
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x2c7b1(%rip), %rdx     # 0x481fd
callq 0xf580
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x109d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x2cde5(%rip), %rdx     # 0x4885b
callq 0xf580
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x2d01a(%rip), %rdx     # 0x48ab6
callq 0xf580
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x2d00a(%rip), %rdx     # 0x48abb
callq 0xf580
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x10330
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x2c719(%rip), %rdx     # 0x481fd
callq 0xf580
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movb 0x20(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x109d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x2cd4d(%rip), %rdx     # 0x4885b
callq 0xf580
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x2cf82(%rip), %rdx     # 0x48ab6
callq 0xf580
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x2cf77(%rip), %rdx     # 0x48ac0
callq 0xf580
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
addq 0x28(%rcx), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x1c150
testb $0x1, -0x11(%rbp)
je 0x1c150
movq -0x8(%rbp), %rdi
callq 0x192d0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
addq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
subq 0x20(%rcx), %rax
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x1c197
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
subq 0x20(%rcx), %rax
movq %rax, -0x20(%rbp)
jmp 0x1c1a3
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/fifo.h
// Function: fifo_purge
FIFO_NOTUSED static struct fifo *fifo_purge(struct fifo *fifo) {
	fifo->head  = 0;
	fifo->count = 0;
	fifo->rbits.byte  = 0;
	fifo->rbits.count = 0;
	fifo->wbits.byte  = 0;
	fifo->wbits.count = 0;
	return fifo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x31(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x32(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x33(%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jbe 0x1c27a
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x1c32e
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jae 0x1c299
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x1c2a9
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
addq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x1c2f2
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
addq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x1c2f2
movq -0x10(%rbp), %rdi
callq 0x192d0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
addq -0x20(%rbp), %rax
movq -0x10(%rbp), %rsi
xorl %edx, %edx
divq 0x18(%rsi)
addq %rdx, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/fifo.h
// Function: fifo_discard
static inline size_t fifo_discard(struct fifo *fifo, size_t count) {
	count       = FIFO_MIN(count, fifo->count);
	fifo->head  = (fifo->head + count) % fifo->size;
	fifo->count -= count;
#if FIFO_AUTOALIGN
	if (!fifo->count)
		fifo->head = 0;
#endif
	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x1c364
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x1c370
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divq 0x18(%rcx)
movq -0x8(%rbp), %rax
movq %rdx, 0x20(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x1c3c0
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xa8(%rax), %esi
movl $0xffffffbf, %edx       # imm = 0xFFFFFFBF
movl $0x1, %ecx
callq 0x1c480
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rsi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1c660
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl 0xa8(%rax), %eax
andl $-0x8, %eax
orl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movl 0xa8(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x1c46f
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x1c6f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xb8(%rax)
movl $0x2, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/socket.c
// Function: lso_checkvbuf
static int lso_checkvbuf(struct lua_State *L, int index) {
	switch (luaL_checkoption(L, index, "line", (const char *[]){ "line", "full", "nobuf", "no", NULL })) {
	case 0: /* "line" */
		return LSO_LINEBUF;
	case 1: /* "full" */
		return LSO_FULLBUF;
	case 2: /* "nobuf" */
		/* FALL THROUGH */
	case 3: /* "no" */
		/* FALL THROUGH */
	default:
		return LSO_NOBUF;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq 0x3ce13(%rip), %rax     # 0x59490
movq %rax, -0x20(%rbp)
movups 0x3cdf8(%rip), %xmm0    # 0x59480
movaps %xmm0, -0x30(%rbp)
movups 0x3cddd(%rip), %xmm0    # 0x59470
movaps %xmm0, -0x40(%rbp)
leaq 0x2c3d4(%rip), %rdx     # 0x48a72
leaq -0x40(%rbp), %rcx
callq 0xfcb0
movl %eax, %ecx
movl %ecx, -0x44(%rbp)
testl %eax, %eax
je 0x1c6c9
jmp 0x1c6b2
movl -0x44(%rbp), %eax
subl $0x1, %eax
je 0x1c6d2
jmp 0x1c6bc
movl -0x44(%rbp), %eax
addl $-0x2, %eax
subl $0x2, %eax
jb 0x1c6db
jmp 0x1c6dd
movl $0x1, -0x4(%rbp)
jmp 0x1c6e4
movl $0x2, -0x4(%rbp)
jmp 0x1c6e4
jmp 0x1c6dd
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
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 0xf280
cmpl $0x0, %eax
jg 0x1c721
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1c7de
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x10b20
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x28(%rbp), %xmm0
ja 0x1c785
movsd -0x28(%rbp), %xmm1
movaps %xmm1, %xmm0
movaps 0x2b905(%rip), %xmm2    # 0x48050
pand %xmm2, %xmm0
movq %xmm1, %rdx
movl $0x1, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovll %eax, %ecx
movsd 0x2b8ab(%rip), %xmm1    # 0x48018
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setnp %sil
sete %dl
testb %sil, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
je 0x1c78f
movq $-0x1, -0x8(%rbp)
jmp 0x1c7de
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1c7ce
movsd -0x28(%rbp), %xmm0
movsd 0x2b896(%rip), %xmm2    # 0x48040
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x1c7d6
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x40(%rax), %esi
movl $0xffffffd8, %edx       # imm = 0xFFFFFFD8
xorl %ecx, %ecx
callq 0x1c480
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xa8(%rax), %esi
movl $0xffffffbf, %edx       # imm = 0xFFFFFFBF
xorl %ecx, %ecx
callq 0x1c480
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xf280
cmpl $0x0, %eax
je 0x1c874
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xf6a0
movq %rax, %rdi
movl $0x69, %esi
callq 0x1c8c0
movl %eax, %ecx
andl $0xffffffd8, %ecx       # imm = 0xFFFFFFD8
movq -0x10(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xf280
cmpl $0x0, %eax
je 0x1c8b4
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xf6a0
movq %rax, %rdi
movl $0x69, %esi
callq 0x1c8c0
movl %eax, %ecx
andl $0xffffffbf, %ecx       # imm = 0xFFFFFFBF
movq -0x10(%rbp), %rax
movl %ecx, 0xa8(%rax)
movl $0x2, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x1c98d
movl -0x14(%rbp), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x33, %eax
ja 0x1c988
movq -0x20(%rbp), %rax
leaq 0x2bc8d(%rip), %rcx     # 0x4859c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x10(%rbp), %eax
andl $-0x8, %eax
orl $0x4, %eax
movl %eax, -0x10(%rbp)
jmp 0x1c988
movl -0x10(%rbp), %eax
andl $-0x8, %eax
orl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1c988
movl -0x10(%rbp), %eax
andl $-0x8, %eax
orl $0x2, %eax
movl %eax, -0x10(%rbp)
jmp 0x1c988
movl -0x10(%rbp), %eax
andl $-0x11, %eax
orl $0x8, %eax
movl %eax, -0x10(%rbp)
jmp 0x1c988
movl -0x10(%rbp), %eax
andl $-0x9, %eax
orl $0x10, %eax
movl %eax, -0x10(%rbp)
jmp 0x1c988
movl -0x10(%rbp), %eax
orl $0x20, %eax
movl %eax, -0x10(%rbp)
jmp 0x1c988
movl -0x10(%rbp), %eax
andl $-0x21, %eax
movl %eax, -0x10(%rbp)
jmp 0x1c988
movl -0x10(%rbp), %eax
orl $0x40, %eax
movl %eax, -0x10(%rbp)
jmp 0x1c988
movl -0x10(%rbp), %eax
andl $-0x41, %eax
movl %eax, -0x10(%rbp)
jmp 0x1c8d1
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0x1ca30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rsi
callq 0x1ca30
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdx
callq 0x1c6f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rdx
callq 0x1c6f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xb8(%rax)
movl $0x2, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/socket.c
// Function: lso_pushsize
static void lso_pushsize(struct lua_State *L, size_t size) {
	if (size == LSO_INFSIZ) {
		lua_pushnumber(L, INFINITY);
	} else {
		lua_pushinteger(L, size);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $-0x1, -0x10(%rbp)
jne 0x1ca5a
movq -0x8(%rbp), %rdi
movsd 0x2b5c5(%rip), %xmm0    # 0x48018
callq 0xf300
jmp 0x1ca67
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf9a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)