LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_setmaxline_
static lso_nargs_t lso_setmaxline_(struct lua_State *L, struct luasocket *S, int ridx, int widx) {
	lso_pushsize(L, S->ibuf.maxline);
	lso_pushsize(L, S->obuf.maxline);

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

	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 0x48(%rsi), %rsi
callq 0x18d85
movq 0xb0(%rbx), %rsi
movq %r15, %rdi
callq 0x18d85
movq 0x48(%rbx), %rdx
movq %r15, %rdi
movl %r14d, %esi
callq 0x18b46
movq %rax, 0x48(%rbx)
movq 0xb0(%rbx), %rdx
movq %r15, %rdi
movl %ebp, %esi
callq 0x18b46
movq %rax, 0xb0(%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_settimeout_
static lso_nargs_t lso_settimeout_(struct lua_State *L, struct luasocket *S, int index) {
	double timeout;

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

	timeout = luaL_optnumber(L, index, NAN);

	S->timeout = (isnormal(timeout) || timeout == 0)? timeout : NAN;

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x140(%rsi), %xmm0
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $-0x10000000000000, %r15 # imm = 0xFFF0000000000000
addq %r15, %rax
shrq $0x35, %rax
cmpl $0x3ff, %eax            # imm = 0x3FF
jb 0x18e4b
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x18e41
jnp 0x18e4b
movq %r14, %rdi
callq 0xf980
jmp 0x18e53
movq %r14, %rdi
callq 0xf2c0
movq 0x1c1ad(%rip), %xmm0    # 0x35008
movq %r14, %rdi
movl %ebp, %esi
callq 0xf780
movq %xmm0, %rax
btrq $0x3f, %rax
addq %r15, %rax
shrq $0x35, %rax
cmpl $0x3ff, %eax            # imm = 0x3FF
jb 0x18e9a
xorpd %xmm1, %xmm1
cmpeqsd %xmm0, %xmm1
andpd %xmm1, %xmm0
movsd 0x1c176(%rip), %xmm2    # 0x35008
andnpd %xmm2, %xmm1
orpd %xmm1, %xmm0
movsd %xmm0, 0x140(%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_seterror_
static lso_nargs_t lso_seterror_(struct lua_State *L, struct luasocket *S, const char *what, int error) {
	int nret = 0;

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

			if (!(S->ibuf.error = error))
				S->ibuf.numerrs = 0;

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

			if (!(S->obuf.error = error))
				S->obuf.numerrs = 0;

			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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x110(%rsi), %rax
movq %rax, (%rsp)
leaq 0x98(%rsi), %r13
xorl %r15d, %r15d
movzbl (%r14,%r15), %eax
cmpl $0x72, %eax
je 0x18f05
cmpl $0x77, %eax
jne 0x18f30
movl 0x108(%r12), %esi
movq %rbx, %rdi
callq 0x18f7e
movl %ebp, 0x108(%r12)
movq (%rsp), %rax
jmp 0x18f20
movl 0x94(%r12), %esi
movq %rbx, %rdi
callq 0x18f7e
movl %ebp, 0x94(%r12)
movq %r13, %rax
testl %ebp, %ebp
jne 0x18f2b
movq $0x0, (%rax)
incq %r15
jmp 0x18ed8
testl %eax, %eax
jne 0x18f46
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movsbl %al, %ecx
addq %r15, %r14
leaq 0x1c7c1(%rip), %rsi     # 0x35714
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xfff0
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf3f0
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_setmaxerrs_
static lso_nargs_t lso_setmaxerrs_(struct lua_State *L, struct luasocket *S, int index) {
	const char *what = "rw";
	int nret = 0;

	if (lua_type(L, index) == LUA_TSTRING) {
		what = luaL_checkstring(L, index);
		index++;
	}

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

			S->ibuf.maxerrs = luaL_optunsigned(L, index, S->ibuf.maxerrs);

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

			S->obuf.maxerrs = luaL_optunsigned(L, index, S->obuf.maxerrs);

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

	return nret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %esi
callq 0xf260
cmpl $0x4, %eax
jne 0x18fc0
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0xf620
movq %rax, %r15
incl %ebp
jmp 0x18fc7
leaq 0x1c76e(%rip), %r15     # 0x35735
leaq 0x118(%r14), %rax
movq %rax, (%rsp)
addq $0xa0, %r14
xorl %r12d, %r12d
movzbl (%r15,%r12), %eax
movq %r14, %r13
cmpl $0x72, %eax
je 0x18ff2
movq (%rsp), %r13
cmpl $0x77, %eax
jne 0x19015
movq (%r13), %rsi
movq %rbx, %rdi
callq 0xf910
movq (%r13), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf400
movq %rax, (%r13)
incq %r12
jmp 0x18fdc
testl %eax, %eax
jne 0x1902b
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movsbl %al, %ecx
addq %r12, %r15
leaq 0x1c6dc(%rip), %rsi     # 0x35714
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xfff0
movq %rbx, %rdi
movl $0x1, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf3f0
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_onerror_
static lso_nargs_t lso_onerror_(struct lua_State *L, struct luasocket *S, int fidx) {
	cqs_getref(L, S->onerror);

	if (lua_gettop(L) > fidx) {
		if (!lua_isnil(L, fidx))
			luaL_checktype(L, fidx, LUA_TFUNCTION);
		lua_pushvalue(L, fidx);
		cqs_ref(L, &S->onerror);
	}

	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x130(%rsi), %rdx
cmpq $-0x2, %rdx
jne 0x19083
callq 0xf980
jmp 0x1908d
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xf450
movq %r14, %rdi
callq 0xf920
cmpl %ebp, %eax
jle 0x190f5
movq %r14, %rdi
movl %ebp, %esi
callq 0xf260
testl %eax, %eax
je 0x190b6
movq %r14, %rdi
movl %ebp, %esi
movl $0x6, %edx
callq 0xf6c0
movq %r14, %rdi
movl %ebp, %esi
callq 0xf9c0
movl 0x130(%rbx), %edx
cmpl $-0x2, %edx
je 0x190e2
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xfad0
movl $0xfffffffe, 0x130(%rbx) # imm = 0xFFFFFFFE
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x10930
movl %eax, 0x130(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_preprcv
static lso_error_t lso_preprcv(lua_State *L, struct luasocket *S) {
	int error;

	if ((error = lso_checkrcverrs(L, S)))
		return error;

	if ((error = lso_checktodo(S)))
		return error;

	so_clear(S->socket);

	if (S->obuf.mode & LSO_AUTOFLUSH) {
		switch ((error = lso_doflush(S, LSO_NOBUF))) {
		case EAGAIN:
			break;
		case EPIPE:
			break;
		default:
			return error;
		}
	}

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x94(%rsi), %edi
testl %edi, %edi
je 0x19179
movq 0x98(%rbx), %rax
incq %rax
movq %rax, 0x98(%rbx)
cmpq 0xa0(%rbx), %rax
jbe 0x19171
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl $0x80, %edx
callq 0xf250
leaq 0x1c5eb(%rip), %rsi     # 0x3574f
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfd60
movl 0x94(%rbx), %eax
jmp 0x1917b
xorl %eax, %eax
testl %eax, %eax
jne 0x191b9
movq %rbx, %rdi
callq 0x18694
testl %eax, %eax
jne 0x191b9
movq 0x128(%rbx), %rdi
callq 0xf840
testb $0x20, 0xa8(%rbx)
je 0x191b7
movq %rbx, %rdi
movl $0x4, %esi
callq 0x187b1
cmpl $0x20, %eax
je 0x191b7
cmpl $0xb, %eax
jne 0x191b9
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_fill
static lso_error_t lso_fill(struct luasocket *S, size_t limit) {
	struct iovec iov;
	size_t prepbuf, count;
	int error;

	if (S->ibuf.eom && fifo_rlen(&S->ibuf.fifo) > 0)
		return 0;

	prepbuf = (S->type == SOCK_DGRAM)? (SO_MIN(limit, 65536)) : 1;

	while (fifo_rlen(&S->ibuf.fifo) < limit) {
		if ((error = fifo_wbuf(&S->ibuf.fifo, &iov, prepbuf)))
			return error;

		if ((count = so_read(S->socket, iov.iov_base, iov.iov_len, &error))) {
			fifo_update(&S->ibuf.fifo, count);

			if (S->type == SOCK_DGRAM || S->type == SOCK_SEQPACKET) {
				S->ibuf.eom = 1;

				return 0;
			}
		} else {
			if (error == EPIPE)
				S->ibuf.eof = 1;

			return error;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x91(%rdi)
jne 0x191f1
xorl %ebp, %ebp
cmpq $0x0, 0x80(%rbx)
jne 0x19306
movl $0x10000, %eax          # imm = 0x10000
cmpq %rax, %r14
cmovbq %r14, %rax
cmpl $0x2, 0x120(%rbx)
movl $0x1, %r12d
cmoveq %rax, %r12
leaq 0x58(%rbx), %r15
leaq 0x4(%rsp), %r13
movq 0x80(%rbx), %rsi
cmpq %r14, %rsi
jae 0x19304
movq 0x70(%rbx), %rax
subq %rsi, %rax
xorl %ebp, %ebp
cmpq %r12, %rax
jae 0x19249
movl $0x4b, %ebp
addq %r12, %rsi
jb 0x19249
movq %r15, %rdi
callq 0x163ad
movl %eax, %ebp
testl %ebp, %ebp
jne 0x192a4
movq 0x70(%rbx), %rcx
movq 0x80(%rbx), %rsi
testq %rcx, %rcx
je 0x1926b
movq 0x78(%rbx), %rax
addq %rsi, %rax
xorl %edx, %edx
divq %rcx
jmp 0x1926d
xorl %edx, %edx
movq %rcx, %rax
subq %rdx, %rcx
addq 0x68(%rbx), %rdx
subq %rsi, %rax
cmpq %rax, %rcx
cmovaeq %rax, %rcx
movq %rdx, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
xorl %ebp, %ebp
cmpq %r12, %rcx
jae 0x192a4
movq %r15, %rdi
leaq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x1989c
movl %ebp, 0x4(%rsp)
testl %ebp, %ebp
jne 0x19306
movq 0x128(%rbx), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r13, %rcx
callq 0xf3b0
testq %rax, %rax
je 0x19317
movq 0x70(%rbx), %rcx
movq 0x80(%rbx), %rdx
subq %rdx, %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x80(%rbx)
movl 0x120(%rbx), %eax
cmpl $0x5, %eax
je 0x192fd
cmpl $0x2, %eax
jne 0x19217
movb $0x1, 0x91(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x4(%rsp), %ebp
cmpl $0x20, %ebp
jne 0x19306
movb $0x1, 0x90(%rbx)
jmp 0x19306
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: iov_trimcr
static size_t iov_trimcr(struct iovec *iov, _Bool chomp) {
	char *p, *pe;

	p = iov->iov_base;
	pe = p + iov->iov_len;

	if (chomp) {
		if (pe - p >= 2 && pe[-1] == '\n' && pe[-2] == '\r')
			*(--pe - 1) = '\n';
	} else {
		while (p < pe && (p = memchr(p, '\r', pe - p))) {
			if (++p >= pe) {
				break;
			} else if (*p == '\n') {
				memmove(p - 1, p, pe - p);
				--pe;
			}
		}
	}

	return iov->iov_len = pe - (char *)iov->iov_base;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %rax
leaq (%r14,%rax), %r15
testl %esi, %esi
je 0x1935e
cmpq $0x2, %rax
jl 0x193a3
cmpb $0xa, -0x1(%r15)
jne 0x193a3
cmpb $0xd, -0x2(%r15)
jne 0x193a3
movb $0xa, -0x2(%r15)
decq %r15
jmp 0x193a3
testq %rax, %rax
jle 0x193a3
movq %r15, %rdx
subq %r14, %rdx
movq %r14, %rdi
movl $0xd, %esi
callq 0xfe90
testq %rax, %rax
je 0x193a3
leaq 0x1(%rax), %r14
cmpq %r15, %r14
jae 0x193a3
cmpb $0xa, (%r14)
jne 0x1939e
movq %r15, %rdx
subq %r14, %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x105f0
decq %r15
cmpq %r15, %r14
jb 0x19363
subq (%rbx), %r15
movq %r15, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_getline
static lso_error_t lso_getline(struct luasocket *S, struct iovec *iov) {
	int error;

	while (!fifo_lvec(&S->ibuf.fifo, iov)) {
		error = lso_fill(S, S->ibuf.maxline);

		if (fifo_lvec(&S->ibuf.fifo, iov))
			break;

		if (fifo_rlen(&S->ibuf.fifo) > 0 && lso_nomore(S, S->ibuf.maxline)) {
			fifo_slice(&S->ibuf.fifo, iov, 0, S->ibuf.maxline);

			break;
		}

		return lso_asserterror(error);
	}

	iov->iov_len = MIN(iov->iov_len, S->ibuf.maxline);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x58(%rdi), %rax
movq %rax, 0x8(%rsp)
movq 0x78(%rdi), %rax
movq 0x80(%rdi), %r15
movq 0x68(%rdi), %r12
movq 0x70(%rdi), %rbx
leaq (%r12,%rax), %rbp
movq %rbp, (%rsi)
subq %rax, %rbx
cmpq %r15, %rbx
movq %r15, %r13
cmovbq %rbx, %r13
movq %r13, 0x8(%rsi)
testq %r13, %r13
movq %rsi, (%rsp)
je 0x1947b
movq %rbp, %rdi
movl $0xa, %esi
movq %r13, %rdx
callq 0xfe90
testq %rax, %rax
je 0x19423
subq %rbp, %rax
incq %rax
movq (%rsp), %rsi
movq %rax, 0x8(%rsi)
jmp 0x1947d
cmpq %r15, %rbx
movq (%rsp), %rsi
jae 0x19473
subq %r13, %r15
movq %r15, 0x8(%rsi)
movq %r12, (%rsi)
movq %r12, %rdi
movl $0xa, %esi
movq %r15, %rdx
callq 0xfe90
movq (%rsp), %rsi
testq %rax, %rax
je 0x19473
subq %r12, %rbx
addq %rbx, %rax
incq %rax
movq %rax, 0x8(%rsi)
movq %r12, (%rsi)
movq 0x8(%rsp), %rdi
callq 0x1645c
movq (%rsp), %rsi
movq 0x8(%rsi), %rax
jmp 0x1947d
movq $0x0, 0x8(%rsi)
xorl %eax, %eax
testq %rax, %rax
jne 0x1959b
movq 0x48(%r14), %rsi
movq %r14, %rdi
callq 0x191c4
movq (%rsp), %rsi
movl %eax, 0x14(%rsp)
movq 0x78(%r14), %rax
movq 0x80(%r14), %r13
movq 0x68(%r14), %r12
movq 0x70(%r14), %rbx
leaq (%r12,%rax), %rbp
movq %rbp, (%rsi)
subq %rax, %rbx
cmpq %r13, %rbx
movq %r13, %r15
cmovbq %rbx, %r15
movq %r15, 0x8(%rsi)
testq %r15, %r15
je 0x19547
movq %rbp, %rdi
movl $0xa, %esi
movq %r15, %rdx
callq 0xfe90
testq %rax, %rax
je 0x194ef
subq %rbp, %rax
incq %rax
movq (%rsp), %rsi
movq %rax, 0x8(%rsi)
jmp 0x19549
cmpq %r13, %rbx
movq (%rsp), %rsi
jae 0x1953f
subq %r15, %r13
movq %r13, 0x8(%rsi)
movq %r12, (%rsi)
movq %r12, %rdi
movl $0xa, %esi
movq %r13, %rdx
callq 0xfe90
movq (%rsp), %rsi
testq %rax, %rax
je 0x1953f
subq %r12, %rbx
addq %rbx, %rax
incq %rax
movq %rax, 0x8(%rsi)
movq %r12, (%rsi)
movq 0x8(%rsp), %rdi
callq 0x1645c
movq (%rsp), %rsi
movq 0x8(%rsi), %rax
jmp 0x19549
movq $0x0, 0x8(%rsi)
xorl %eax, %eax
testq %rax, %rax
jne 0x1959b
cmpq $0x0, 0x80(%r14)
je 0x19579
movq 0x48(%r14), %rdx
cmpb $0x0, 0x90(%r14)
jne 0x19589
cmpb $0x0, 0x91(%r14)
jne 0x19589
cmpq %rdx, 0x80(%r14)
jae 0x19589
movl 0x14(%rsp), %ecx
testl %ecx, %ecx
movl $0xe, %eax
cmovnel %ecx, %eax
jmp 0x195b0
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x18955
movq (%rsp), %rsi
movq 0x8(%rsi), %rax
movq 0x48(%r14), %rcx
cmpq %rcx, %rax
cmovbq %rax, %rcx
movq %rcx, 0x8(%rsi)
xorl %eax, %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_getheader
static lso_error_t lso_getheader(struct luasocket *S, struct iovec *iov) {
	size_t eoh;
	int error;

	fifo_slice(&S->ibuf.fifo, iov, 0, S->ibuf.maxline);

	if ((size_t)-1 == (eoh = iov_eoh(iov, lso_nomore(S, S->ibuf.maxline), 0, &error)))
		goto error;

	if (!eoh || eoh > iov->iov_len) {
		error = lso_fill(S, S->ibuf.maxline);

		fifo_slice(&S->ibuf.fifo, iov, 0, S->ibuf.maxline);

		if ((size_t)-1 == (eoh = iov_eoh(iov, lso_nomore(S, S->ibuf.maxline), 0, &error)))
			goto error;
		else if (!eoh)
			goto nomore;
		else if (eoh > iov->iov_len)
			goto error; /* lso_fill should have returned error */
	}

	iov->iov_len = eoh;

	return 0;
nomore:
	iov->iov_len = 0;

	return 0;
error:
	return lso_asserterror(error);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x58(%rdi), %r15
movq 0x48(%rdi), %rdx
movq %r15, %rdi
callq 0x18955
movq 0x48(%r14), %r12
movb $0x1, %al
cmpb $0x0, 0x90(%r14)
jne 0x19601
cmpb $0x0, 0x91(%r14)
jne 0x19601
cmpq %r12, 0x80(%r14)
setae %al
movzbl %al, %esi
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x19902
cmpq $-0x1, %rax
je 0x1968f
testq %rax, %rax
je 0x19622
cmpq 0x8(%rbx), %rax
jbe 0x1969f
movq %r14, %rdi
movq %r12, %rsi
callq 0x191c4
movl %eax, 0x4(%rsp)
movq 0x48(%r14), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x18955
movb $0x1, %al
cmpb $0x0, 0x90(%r14)
jne 0x19664
cmpb $0x0, 0x91(%r14)
jne 0x19664
movq 0x48(%r14), %rax
cmpq %rax, 0x80(%r14)
setae %al
movzbl %al, %esi
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x19902
cmpq $-0x1, %rax
je 0x1968f
testq %rax, %rax
jne 0x19689
movq $0x0, 0x8(%rbx)
jmp 0x196a3
cmpq 0x8(%rbx), %rax
jbe 0x1969f
movl 0x4(%rsp), %ecx
testl %ecx, %ecx
movl $0xe, %eax
cmovnel %ecx, %eax
jmp 0x196a5
movq %rax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: iov_trimcrlf
static size_t iov_trimcrlf(struct iovec *iov, _Bool chomp) {
	char *sp, *p, *pe;

	sp = iov->iov_base;
	p = iov->iov_base;
	pe = p + iov->iov_len;

	if (chomp) {
		if (p < pe && pe[-1] == '\n') {
			--pe;

			if (p < pe && pe[-1] == '\r')
				--pe;
		}
	} else {
		while (p < pe && (p = memchr(p, '\n', pe - p))) {
			if (p > sp && p[-1] == '\r') {
				++p;
				memmove(p - 2, p, pe - p);
				pe -= 2;
			} else {
				memmove(p, p + 1, pe - p - 1);
				--pe;
			}
		}
	}

	return iov->iov_len = pe - (char *)iov->iov_base;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r12
movq 0x8(%rdi), %rax
leaq (%r12,%rax), %r15
testl %esi, %esi
je 0x196fa
testq %rax, %rax
jle 0x1976b
cmpb $0xa, -0x1(%r15)
jne 0x1976b
leaq -0x1(%r15), %rax
cmpq %rax, %r12
jae 0x196f5
cmpb $0xd, -0x2(%r15)
leaq -0x2(%r15), %rcx
cmoveq %rcx, %rax
movq %rax, %r15
jmp 0x1976b
testq %rax, %rax
jle 0x1976b
movq %r12, %r14
movq %r15, %rdx
subq %r14, %rdx
movq %r14, %rdi
movl $0xa, %esi
callq 0xfe90
testq %rax, %rax
je 0x1976b
movq %rax, %r14
cmpq %r12, %rax
jbe 0x19747
cmpb $0xd, -0x1(%r14)
jne 0x19747
leaq -0x1(%r14), %rdi
incq %r14
movq %r15, %rdx
subq %r14, %rdx
movq %r14, %rsi
callq 0x105f0
movq $-0x2, %rax
jmp 0x19763
leaq 0x1(%r14), %rsi
movq %r14, %rdx
notq %rdx
addq %r15, %rdx
movq %r14, %rdi
callq 0x105f0
movq $-0x1, %rax
addq %rax, %r15
cmpq %r15, %r14
jb 0x19702
subq (%rbx), %r15
movq %r15, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_getblock
static lso_error_t lso_getblock(struct luasocket *S, struct iovec *iov, size_t minbuf, size_t maxbuf, int mode) {
	int error;

	if (mode & LSO_TEXT) {
		size_t fillsz = maxbuf, n;

		do {
			error = lso_fill(S, fillsz);

			fifo_slice(&S->ibuf.fifo, iov, 0, -1);

			if ((size_t)-1 == (n = iov_eot(iov, minbuf, maxbuf, (S->ibuf.eof || S->ibuf.eom), &error))) {
				goto error;
			} else if (n > iov->iov_len) {
				if (fillsz < n)
					error = 0;

				fillsz = n;
			} else {
				iov->iov_len = n;

				return 0;
			}
		} while (!error);
	} else {
		error = lso_fill(S, maxbuf);

		if (fifo_slice(&S->ibuf.fifo, iov, 0, maxbuf) >= minbuf)
			return 0;

		if ((S->ibuf.eof || S->ibuf.eom) && iov->iov_len > 0)
			return 0;
	}

error:
	return lso_asserterror(error);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testb $0x8, %r8b
jne 0x197ef
movq %r14, %rdi
movq %rbp, %rsi
callq 0x191c4
movl %eax, 0x4(%rsp)
leaq 0x58(%r14), %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x18955
movq %rax, %rcx
xorl %eax, %eax
cmpq %r15, %rcx
jae 0x1988d
cmpb $0x0, 0x90(%r14)
jne 0x197df
cmpb $0x1, 0x91(%r14)
jne 0x1987b
cmpq $0x0, 0x8(%rbx)
jne 0x1988d
jmp 0x1987b
leaq 0x58(%r14), %r13
movq %rbp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x191c4
movl %eax, 0x4(%rsp)
movq %r13, %rdi
movq %rbx, %rsi
movq $-0x1, %rdx
callq 0x18955
movb $0x1, %al
cmpb $0x0, 0x90(%r14)
jne 0x1982a
movb 0x91(%r14), %al
movzbl %al, %ecx
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
leaq 0x4(%rsp), %r8
callq 0x19a60
cmpq $-0x1, %rax
je 0x19867
cmpq 0x8(%rbx), %rax
jbe 0x1986e
cmpq %rax, %r12
jae 0x19859
movl $0x0, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
movq %rax, %r12
je 0x197f6
xorl %eax, %eax
jmp 0x19877
movl $0x4, %eax
jmp 0x19877
movq %rax, 0x8(%rbx)
movl $0x1, %eax
testb $0x3, %al
jne 0x1988b
movl 0x4(%rsp), %ecx
testl %ecx, %ecx
movl $0xe, %eax
cmovnel %ecx, %eax
jmp 0x1988d
xorl %eax, %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/lib/fifo.h
// Function: fifo_wvec
static size_t fifo_wvec(struct fifo *fifo, struct iovec *iov, _Bool realign) {
	size_t tail, count;

	if (fifo->head + fifo->count < fifo->size && realign)
		fifo_realign(fifo);

	tail  = (fifo->size)? ((fifo->head + fifo->count) % fifo->size) : 0;
	count = fifo_wlen(fifo);

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

	return iov->iov_len;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorb $0x1, %dl
movq 0x28(%rdi), %rax
addq 0x20(%rdi), %rax
cmpq 0x18(%rdi), %rax
setae %al
orb %dl, %al
jne 0x198c4
movq %r14, %rdi
callq 0x1645c
movq 0x18(%r14), %rcx
testq %rcx, %rcx
je 0x198dc
movq 0x28(%r14), %rax
addq 0x20(%r14), %rax
xorl %edx, %edx
divq %rcx
jmp 0x198de
xorl %edx, %edx
movq %rcx, %rax
subq 0x28(%r14), %rax
subq %rdx, %rcx
addq 0x10(%r14), %rdx
movq %rdx, (%rbx)
cmpq %rax, %rcx
cmovaeq %rax, %rcx
movq %rcx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: iov_eoh
static size_t iov_eoh(const struct iovec *iov, _Bool eof, int flags, int *_error) {
	const char *tp, *p, *pe;
	size_t n;
	int error;

	tp = iov->iov_base;
	p = tp;
	pe = tp + iov->iov_len;

	while (p < pe && mime_isfname(*p))
		p++;

	if (p == tp && p < pe && !(flags & IOV_F_EMPTYFNAME))
		return 0; /* not allowing empty field names */

	while (p < pe && mime_isblank(*p))
		p++;

	if (p < pe && *p != ':')
		return 0; /* not a valid field name */

	while (p < pe && (p = memchr(p, '\n', pe - p))) {
		if (++p < pe && !mime_isblank(*p))
			return p - tp; /* found */
	}

	if (eof)
		return 0; /* do not allow truncated headers */

	if ((error = iov_addzu(&n, iov->iov_len, 1)))
		goto error;

	return n; /* need more */
error:
	*_error = error;

	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq (%rdi), %r15
movq 0x8(%rdi), %r14
leaq (%r15,%r14), %r12
testq %r14, %r14
setle %cl
jle 0x19962
movb (%r15), %al
leal -0x21(%rax), %edx
cmpb $0x5e, %dl
setae %dl
cmpb $0x3a, %al
sete %al
orb %dl, %al
movq %r15, %rax
jne 0x19965
leaq 0x1(%r15), %rdx
movq %rdx, %rax
cmpq %r12, %rdx
setae %cl
jae 0x19965
movb (%rax), %sil
cmpb $0x3a, %sil
je 0x19965
addb $-0x21, %sil
leaq 0x1(%rax), %rdx
cmpb $0x5d, %sil
jbe 0x1993e
jmp 0x19965
movq %r15, %rax
cmpq %r15, %rax
sete %dl
xorb $0x1, %cl
testb %cl, %dl
jne 0x199ca
cmpq %r12, %rax
jae 0x1998e
movzbl (%rax), %ecx
cmpl $0x9, %ecx
je 0x19984
cmpl $0x20, %ecx
jne 0x19989
incq %rax
jmp 0x19972
cmpl $0x3a, %ecx
jne 0x199ca
cmpq %r12, %rax
jae 0x199c5
movq %r12, %rdx
subq %rax, %rdx
movq %rax, %rdi
movl $0xa, %esi
callq 0xfe90
testq %rax, %rax
je 0x199c5
incq %rax
cmpq %r12, %rax
jae 0x1998e
movzbl (%rax), %ecx
cmpl $0x9, %ecx
je 0x1998e
cmpl $0x20, %ecx
je 0x1998e
subq %r15, %rax
jmp 0x199cc
testb %bpl, %bpl
je 0x199d5
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpq $-0x2, %r14
jae 0x199e3
incq %r14
movq %r14, %rax
jmp 0x199cc
movl $0x4b, (%rbx)
movq $-0x1, %rax
jmp 0x199cc
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: iov_eol
static size_t iov_eol(const struct iovec *iov) {
	const char *p, *pe;
	size_t eol = 0;

	p = iov->iov_base;
	pe = p + iov->iov_len;

	while (p < pe && (p = memchr(p, '\n', pe - p))) {
		eol = ++p - (char *)iov->iov_base;
	}

	return (eol)? eol : iov->iov_len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
jle 0x19a47
movq (%rdi), %r14
movq %r14, %rdi
movl $0xa, %esi
movq %rbx, %rdx
callq 0xfe90
testq %rax, %rax
je 0x19a47
leaq (%r14,%rbx), %r12
movq %rax, %r15
incq %r15
cmpq %r12, %r15
jae 0x19a42
movq %r12, %rdx
subq %r15, %rdx
movq %r15, %rdi
movl $0xa, %esi
callq 0xfe90
testq %rax, %rax
jne 0x19a1f
subq %r14, %r15
jmp 0x19a4a
xorl %r15d, %r15d
testq %r15, %r15
cmovneq %r15, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: iov_eot
static size_t iov_eot(const struct iovec *iov, size_t minbuf, size_t maxbuf, _Bool eof, int *_error) {
	const char *p, *pe;
	size_t n = 0, eot;
	int lc = -1, error;

	p = iov->iov_base;
	pe = p + iov->iov_len;

	for (; p < pe && n < maxbuf; ++n) {
		lc = *p++;

		if (lc == '\r' && p < pe && *p == '\n') {
			lc = *p++; /* skip \n so we don't ++n */
		}
	}

	if ((size_t)-1 == (eot = p - (char *)iov->iov_base)) {
		error = EOVERFLOW;
		goto error;
	}

	if (n < maxbuf) {
		if (!eof) {
			if (n >= minbuf && lc != '\r') {
				/*
				 * just continue as we're not splitting a
				 * \r\n pair
				 */
				(void)0;
			} else if (n > minbuf && lc == '\r') {
				/*
				 * just exclude it. we might end up
				 * returning a trailing \r, but we know for
				 * a fact it's not part of a \r\n pair.
				 */
				--eot;
			} else if ((error = iov_addzu(&eot, eot, maxbuf - n))) {
				goto error;
			}
		}
	} else if (lc == '\r') {
		if (n > minbuf) {
			--eot; /* see comment ~10 lines above */
		} else if ((error = iov_addzu(&eot, eot, 1))) {
			goto error;
		}
	}

	return eot;
error:
	*_error = error;

	return -1;
}

// Assembly:
pushq %rbp
pushq %rbx
movq (%rdi), %r9
movq 0x8(%rdi), %r11
testq %r11, %r11
setle %al
testq %rdx, %rdx
setne %bl
sete %dil
orb %al, %dil
jne 0x19ada
addq %r9, %r11
xorl %edi, %edi
movq %r9, %rax
leaq 0x1(%rax), %rbx
movsbl (%rax), %r10d
cmpl $0xd, %r10d
jne 0x19ab1
movl $0xd, %r10d
cmpq %r11, %rbx
jae 0x19ab1
xorl %r10d, %r10d
cmpb $0xa, 0x1(%rax)
setne %bpl
je 0x19ab6
movq %rbx, %rax
jmp 0x19aba
movq %rbx, %rax
jmp 0x19ac5
addq $0x2, %rax
movb %bpl, %r10b
leal (%r10,%r10,2), %r10d
addl $0xa, %r10d
incq %rdi
cmpq %rdx, %rdi
setb %bl
cmpq %r11, %rax
jae 0x19ae5
cmpq %rdx, %rdi
jb 0x19a86
jmp 0x19ae5
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
xorl %edi, %edi
movq %r9, %rax
subq %r9, %rax
cmpq $-0x1, %rax
je 0x19b3b
testb %bl, %bl
je 0x19b4c
testb %cl, %cl
jne 0x19b6f
cmpq %rsi, %rdi
jb 0x19b01
cmpl $0xd, %r10d
jne 0x19b6f
cmpq %rsi, %rdi
jbe 0x19b0c
cmpl $0xd, %r10d
je 0x19b57
subq %rdi, %rdx
movq %rax, %rcx
notq %rcx
xorl %esi, %esi
cmpq %rcx, %rdx
setbe %dil
cmovaq %rsi, %rdx
addq %rdx, %rax
cmpq $-0x1, %rax
setne %dl
movl $0x4b, %ecx
testb %dl, %dil
cmovnel %esi, %ecx
je 0x19b40
jmp 0x19b6f
movl $0x4b, %ecx
movl %ecx, (%r8)
movq $-0x1, %rax
jmp 0x19b6f
cmpl $0xd, %r10d
jne 0x19b6f
cmpq %rsi, %rdi
jbe 0x19b5c
decq %rax
jmp 0x19b6f
incq %rax
xorl %edx, %edx
movl $0x4b, %ecx
cmpq $-0x1, %rax
cmovnel %edx, %ecx
je 0x19b40
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_prepsnd
static lso_error_t lso_prepsnd(lua_State *L, struct luasocket *S) {
	int error;

	if ((error = lso_checksnderrs(L, S)))
		return error;

	return lso_checktodo(S);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x108(%rsi), %edi
testl %edi, %edi
je 0x19bf1
movq 0x110(%rbx), %rax
incq %rax
movq %rax, 0x110(%rbx)
cmpq 0x118(%rbx), %rax
jbe 0x19be9
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl $0x80, %edx
callq 0xf250
leaq 0x1bb73(%rip), %rsi     # 0x3574f
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfd60
movl 0x108(%rbx), %eax
jmp 0x19bf3
xorl %eax, %eax
testl %eax, %eax
jne 0x19bff
movq %rbx, %rdi
callq 0x18694
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/fifo.h
// Function: fifo_write
FIFO_NOTUSED static int fifo_write(struct fifo *fifo, const void *src, size_t len) {
	const unsigned char *p = src, *pe = p + len;
	struct iovec iov;
	size_t n;
	int error = 0;

	do {
		while (fifo_wvec(fifo, &iov) && p < pe) {
			n = FIFO_MIN(iov.iov_len, (size_t)(pe - p));
			memcpy(iov.iov_base, p, n);
			p += n;
			fifo_update(fifo, n);
		}
	} while (p < pe && !(error = fifo_grow(fifo, pe - p)));

	return error;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq %rsi, %rbx
xorl %r12d, %r12d
movq 0x18(%r15), %rcx
movq 0x28(%r15), %rsi
testq %rcx, %rcx
je 0x19c40
movq 0x20(%r15), %rax
addq %rsi, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rdi
jmp 0x19c42
xorl %edi, %edi
movq %rcx, %rax
subq %rsi, %rax
subq %rdi, %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
testq %rcx, %rcx
je 0x19c96
cmpq %rbx, %r14
jae 0x19c96
addq 0x10(%r15), %rdi
movq %rbx, %r13
subq %r14, %r13
cmpq %r13, %rcx
cmovbq %rcx, %r13
movq %r14, %rsi
movq %r13, %rdx
callq 0xfa60
addq %r13, %r14
movq 0x18(%r15), %rax
movq 0x28(%r15), %rcx
subq %rcx, %rax
cmpq %r13, %rax
cmovaeq %r13, %rax
addq %rcx, %rax
movq %rax, 0x28(%r15)
jmp 0x19c22
cmpq %rbx, %r14
jae 0x19cc8
movq %rbx, %rcx
subq %r14, %rcx
xorl %r12d, %r12d
cmpq %rcx, %rax
jae 0x19cbf
movl $0x4b, %r12d
addq %rcx, %rsi
jb 0x19cbf
movq %r15, %rdi
callq 0x163ad
movl %eax, %r12d
testl %r12d, %r12d
je 0x19c22
movl %r12d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/fifo.h
// Function: fifo_putc
static int fifo_putc(struct fifo *fifo, int c) {
	int error;

	if (fifo->count >= fifo->size && (error = fifo_grow(fifo, 1)))
		return error;

	fifo->base[(fifo->head + fifo->count) % fifo->size] = (0xff & c);
	fifo_update(fifo, 1);

	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x28(%rdi), %rsi
cmpq %rax, %rsi
jb 0x19d0f
xorl %ecx, %ecx
cmpq %rsi, %rax
jne 0x19d0b
cmpq $-0x1, %rsi
je 0x19d06
incq %rsi
movq %rbx, %rdi
callq 0x163ad
movl %eax, %ecx
jmp 0x19d0b
movl $0x4b, %ecx
testl %ecx, %ecx
jne 0x19d3b
movq 0x28(%rbx), %rax
addq 0x20(%rbx), %rax
movq 0x10(%rbx), %rsi
xorl %ecx, %ecx
xorl %edx, %edx
divq 0x18(%rbx)
movb %bpl, (%rsi,%rdx)
movq 0x28(%rbx), %rax
xorl %edx, %edx
cmpq %rax, 0x18(%rbx)
setne %dl
addq %rax, %rdx
movq %rdx, 0x28(%rbx)
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_tofileno
static int lso_tofileno(lua_State *L, int index) {
	struct luasocket *so;
	luaL_Stream *fh;

	if (lua_isnumber(L, index)) {
		return lua_tointeger(L, index);
	} else if ((so = luaL_testudata(L, index, LSO_CLASS))) {
		return so_peerfd(so->socket);
	} else if ((fh = luaL_testudata(L, index, LUA_FILEHANDLE))) {
		return (fh->f)? fileno(fh->f) : -1;
	} else {
		return -1;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0xfb80
testl %eax, %eax
je 0x19d6a
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0xfd20
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1b32e(%rip), %rdx     # 0x3509f
movq %r14, %rdi
movl %ebx, %esi
callq 0x10720
testq %rax, %rax
je 0x19d93
movq 0x128(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10a20
leaq 0x1ba32(%rip), %rdx     # 0x357cc
movq %r14, %rdi
movl %ebx, %esi
callq 0x10720
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x19d62
movq (%rcx), %rdi
testq %rdi, %rdi
je 0x19d62
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xfdd0
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_altfield
static _Bool lso_altfield(lua_State *L, int index, ...) {
	const char *k;
	va_list ap;

	va_start(ap, index);

	while ((k = va_arg(ap, const char *))) {
		if (lso_getfield(L, index, k))
			break;
	}

	va_end(ap);

	return !!k;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x1a478
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x1a4b1
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x1a4bf
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r15
testq %r15, %r15
je 0x1a4d8
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x1a5fc
testb %al, %al
je 0x1a498
testq %r15, %r15
setne %al
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_rawgeti
static _Bool lso_rawgeti(lua_State *L, int index, int k) {
	lua_rawgeti(L, index, k);

	if (lua_isnil(L, -1)) {
		lua_pop(L, 1);

		return 0;
	} else {
		return 1;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf450
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf260
movl %eax, %ebp
testl %eax, %eax
jne 0x1a51d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
testl %ebp, %ebp
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_checkperm
static mode_t lso_checkperm(lua_State *L, int index) {
	const char *mode = luaL_checkstring(L, index);
	mode_t perm = 0;

	if (*mode >= '0' && *mode <= '9') {
		perm = strtol(mode, NULL, 0);
	} else {
		int i = 9, flag, ch;

		while ((ch = *mode++) && i > 0) {
			if (ch == 'r' || ch == 'R')
				flag = 04;
			else if (ch == 'w' || ch == 'W')
				flag = 02;
			else if (ch == 'x' || ch == 'X')
				flag = 01;
			else if (ch == '-')
				flag = 00;
			else
				continue;

			perm |= (flag << (3 * (--i / 3)));
		}
	}

	return perm;
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0xf620
movb (%rax), %cl
addb $-0x30, %cl
cmpb $0xa, %cl
jae 0x1a555
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10270
movq %rax, %rbx
movl %ebx, %eax
popq %rbx
retq
movl $0x9, %edx
movl $0xaaaaaaab, %esi       # imm = 0xAAAAAAAB
incq %rax
movq %rax, %rdi
movzbl -0x1(%rdi), %ecx
testl %ecx, %ecx
je 0x1a551
movq %rdi, %rax
movl %ecx, %edi
andl $-0x21, %edi
cmpl $0x52, %edi
je 0x1a591
cmpl $0x57, %edi
je 0x1a59f
cmpl $0x58, %edi
je 0x1a598
leaq 0x1(%rax), %rdi
cmpl $0x2d, %ecx
jne 0x1a565
xorl %edi, %edi
jmp 0x1a5a4
movl $0x4, %edi
jmp 0x1a5a4
movl $0x1, %edi
jmp 0x1a5a4
movl $0x2, %edi
decl %edx
movq %rdx, %rcx
imulq %rsi, %rcx
shrq $0x21, %rcx
leal (%rcx,%rcx,2), %ecx
shll %cl, %edi
orl %edi, %ebx
testl %edx, %edx
jne 0x1a55f
jmp 0x1a551
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_popbool
static _Bool lso_popbool(lua_State *L) {
	_Bool val;
	luaL_checktype(L, -1, LUA_TBOOLEAN);
	val = lua_toboolean(L, -1);
	lua_pop(L, 1);
	return val;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0xf6c0
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf540
testl %eax, %eax
setne %bpl
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
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_getfield
static _Bool lso_getfield(lua_State *L, int index, const char *k) {
	lua_getfield(L, index, k);

	if (lua_isnil(L, -1)) {
		lua_pop(L, 1);

		return 0;
	} else {
		return 1;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xf1e0
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf260
movl %eax, %ebp
testl %eax, %eax
jne 0x1a627
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
testl %ebp, %ebp
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_pushname
static lso_nargs_t lso_pushname(lua_State *L, struct sockaddr_storage *ss, socklen_t salen) {
	switch (ss->ss_family) {
	case AF_INET:
		/* FALL THROUGH */
	case AF_INET6:
		lua_pushinteger(L, ss->ss_family);
		lua_pushstring(L, sa_ntoa(ss));
		lua_pushinteger(L, ntohs(*sa_port(ss, SA_PORT_NONE, NULL)));

		return 3;
	case AF_UNIX:
		lua_pushinteger(L, ss->ss_family);

		/* support nameless sockets and Linux's abstract namespace */
		if (salen > offsetof(struct sockaddr_un, sun_path)) {
			struct sockaddr_un *sun = (struct sockaddr_un *)ss;
			char *pe = (char *)sun + SO_MIN(sizeof *sun, salen);
			size_t plen;

			while (pe > sun->sun_path && pe[-1] == '\0')
				--pe;

			if ((plen = (pe - sun->sun_path)) > 0) {
				lua_pushlstring(L, sun->sun_path, plen);
			} else {
				lua_pushnil(L);
			}
		} else {
			lua_pushnil(L);
		}

		return 2;
	default:
		lua_pushinteger(L, ss->ss_family);

		return 1;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movzwl (%rsi), %esi
cmpl $0x1, %esi
je 0x1a6e9
cmpl $0xa, %esi
je 0x1a662
cmpl $0x2, %esi
jne 0x1a742
movq %rbx, %rdi
callq 0xf910
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movups %xmm0, 0x5d(%r15)
movaps %xmm0, 0x50(%r15)
movaps %xmm0, 0x40(%r15)
movaps %xmm0, 0x30(%r15)
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
leaq 0xc(%rsp), %r8
movl $0x0, (%r8)
xorl %r12d, %r12d
movl $0x6d, %esi
movq %r15, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xf200
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfbd0
movzwl (%r14), %eax
orl $0x8, %eax
cmpl $0xa, %eax
jne 0x1a6d1
movzwl 0x2(%r14), %r12d
rolw $0x8, %r12w
movzwl %r12w, %esi
movq %rbx, %rdi
callq 0xf910
movl $0x3, %eax
jmp 0x1a75e
movl %edx, %ebp
movq %rbx, %rdi
callq 0xf910
cmpl $0x3, %ebp
jb 0x1a751
cmpl $0x6e, %ebp
movl $0x6e, %eax
cmovbl %ebp, %eax
cmpq $0x2, %rax
movl $0x2, %edx
cmovlq %rax, %rdx
cmpq $0x3, %rax
jl 0x1a72b
leaq -0x1(%rax), %rcx
cmpb $0x0, -0x1(%r14,%rax)
movq %rcx, %rax
je 0x1a710
incq %rcx
movq %rcx, %rdx
addq $-0x2, %rdx
je 0x1a751
addq $0x2, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf4c0
jmp 0x1a759
movq %rbx, %rdi
callq 0xf910
movl $0x1, %eax
jmp 0x1a75e
movq %rbx, %rdi
callq 0xf980
movl $0x2, %eax
addq $0x80, %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_destroy
static void lso_destroy(lua_State *L, struct luasocket *S) {
	cqs_unref(L, &S->onerror);

	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;
	}

	fifo_reset(&S->ibuf.fifo);
	fifo_reset(&S->obuf.fifo);

	/* Hack for Lua 5.1 and LuaJIT */
	if (!S->mainthread) {
		S->mainthread = L;
		so_close(S->socket);
		S->mainthread = 0;
	} else {
		so_close(S->socket);
	}

	S->socket = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x130(%rsi), %edx
cmpl $-0x2, %edx
je 0x1a79a
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xfad0
movl $0xfffffffe, 0x130(%rbx) # imm = 0xFFFFFFFE
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1a7b0
callq 0xf770
movq $0x0, 0x20(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1a7c6
callq 0xf0f0
movq $0x0, 0x18(%rbx)
movq 0x68(%rbx), %rdi
cmpq 0x58(%rbx), %rdi
je 0x1a7d5
callq 0xff30
movups 0x58(%rbx), %xmm0
movups %xmm0, 0x68(%rbx)
xorps %xmm1, %xmm1
movups %xmm1, 0x78(%rbx)
movl $0x0, 0x88(%rbx)
movq 0xd0(%rbx), %rdi
cmpq 0xc0(%rbx), %rdi
je 0x1a806
callq 0xff30
xorps %xmm1, %xmm1
movups 0xc0(%rbx), %xmm0
movups %xmm0, 0xd0(%rbx)
movups %xmm1, 0xe0(%rbx)
movl $0x0, 0xf0(%rbx)
cmpq $0x0, 0x138(%rbx)
je 0x1a83d
movq 0x128(%rbx), %rdi
callq 0xf420
jmp 0x1a85b
movq %r14, 0x138(%rbx)
movq 0x128(%rbx), %rdi
callq 0xf420
movq $0x0, 0x138(%rbx)
movq $0x0, 0x128(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso__gc
static lso_nargs_t lso__gc(lua_State *L) {
	struct luasocket *S = luaL_checkudata(L, 1, LSO_CLASS);

	S->mainthread = NULL; // disable poll cancellation
	lso_destroy(L, S);

	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x1a826(%rip), %rdx     # 0x3509f
movl $0x1, %esi
callq 0xfcf0
movq $0x0, 0x138(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1a76e
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_dup
static lso_nargs_t lso_dup(lua_State *L) {
	struct so_options opts;
	int ofd, fd = -1, error;

	if (lua_istable(L, 1)) {
		opts = lso_checkopts(L, 1);

		if (!lso_altfield(L, 1, "fd", "file", "socket"))
			lua_rawgeti(L, 1, 1);

		ofd = lso_tofileno(L, -1);

		lua_pop(L, 1);
	} else {
		opts = *so_opts();
		ofd = lso_tofileno(L, 1);
	}

	if (ofd < 0)
		goto badfd;

#if defined F_DUPFD_CLOEXEC
	if (-1 == (fd = fcntl(ofd, F_DUPFD_CLOEXEC, 0)))
		goto syerr;
#else
	if (-1 == (fd = dup(ofd)))
		goto syerr;
#endif

	if ((error = cqs_socket_fdopen(L, fd, &opts)))
		goto error;

	return 1;
badfd:
	error = EBADF;
	goto error;
syerr:
	error = errno;
error:
	cqs_closefd(&fd);

	lua_pushnil(L);
	lua_pushinteger(L, error);

	return 2;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0xf260
cmpl $0x5, %eax
jne 0x1aee6
movq %rsp, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x19dc5
leaq 0x1a7f8(%rip), %rdx     # 0x3568a
leaq 0x1e1f9(%rip), %rcx     # 0x39092
leaq 0x1aa9c(%rip), %r8      # 0x3593c
movq %rbx, %rdi
movl $0x1, %esi
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x1a417
testb %al, %al
jne 0x1aec8
movl $0x1, %edx
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf450
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x19d44
movl %eax, %ebp
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
jmp 0x1af45
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movw $0x100, 0x10(%rsp)      # imm = 0x100
xorl %eax, %eax
movl %eax, 0x12(%rsp)
movw $0x0, 0x16(%rsp)
movups %xmm0, 0x1f(%rsp)
movups %xmm0, 0x2f(%rsp)
movb $0x0, 0x3f(%rsp)
movl %eax, 0x49(%rsp)
movl %eax, 0x4c(%rsp)
movl %eax, 0x18(%rsp)
movw $0x101, 0x1c(%rsp)      # imm = 0x101
movb $0x1, %al
movb %al, 0x1e(%rsp)
movq $0x1, 0x40(%rsp)
movb %al, 0x48(%rsp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x19d44
movl %eax, %ebp
testl %ebp, %ebp
js 0x1af7b
movl %ebp, %edi
movl $0x406, %esi            # imm = 0x406
xorl %edx, %edx
xorl %eax, %eax
callq 0xf7b0
movl %eax, %ebp
cmpl $-0x1, %eax
je 0x1af88
movq %rsp, %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x10170
movl %eax, %r14d
testl %eax, %eax
jne 0x1af90
movl $0x1, %eax
jmp 0x1afb4
movl $0x9, %r14d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x1af90
callq 0xf0a0
movl (%rax), %r14d
cmpl $-0x1, %ebp
je 0x1af9c
movl %ebp, %edi
callq 0x10a10
movq %rbx, %rdi
callq 0xf980
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_fdopen
static lso_nargs_t lso_fdopen(lua_State *L) {
	struct so_options opts;
	int fd, error;

	if (lua_istable(L, 1)) {
		opts = lso_checkopts(L, 1);

		if (lso_altfield(L, 1, "fd")) {
			fd = luaL_checkint(L, -1);
		} else {
			lua_rawgeti(L, 1, 1);
			fd = luaL_checkint(L, -1);
		}

		lua_pop(L, 1);
	} else {
		opts = *so_opts();
		fd = luaL_checkint(L, 1);
	}

	if (fd < 0)
		goto badfd;

	if ((error = cqs_socket_fdopen(L, fd, &opts)))
		goto error;

	return 1;
badfd:
	error = EBADF;
	goto error;
error:
	lua_pushnil(L);
	lua_pushinteger(L, error);

	return 2;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0xf260
cmpl $0x5, %eax
jne 0x1b034
movq %rsp, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x19dc5
leaq 0x1a69c(%rip), %rdx     # 0x3568a
movq %rbx, %rdi
movl $0x1, %esi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1a417
testb %al, %al
jne 0x1b015
movl $0x1, %edx
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf450
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x10a60
movq %rax, %r14
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
jmp 0x1b094
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movw $0x100, 0x10(%rsp)      # imm = 0x100
xorl %eax, %eax
movl %eax, 0x12(%rsp)
movw $0x0, 0x16(%rsp)
movups %xmm0, 0x1f(%rsp)
movups %xmm0, 0x2f(%rsp)
movb $0x0, 0x3f(%rsp)
movl %eax, 0x49(%rsp)
movl %eax, 0x4c(%rsp)
movl %eax, 0x18(%rsp)
movw $0x101, 0x1c(%rsp)      # imm = 0x101
movb $0x1, %al
movb %al, 0x1e(%rsp)
movq $0x1, 0x40(%rsp)
movb %al, 0x48(%rsp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10a60
movq %rax, %r14
testl %r14d, %r14d
js 0x1b0b4
movq %rsp, %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x10170
movl %eax, %ebp
testl %eax, %eax
jne 0x1b0b9
movl $0x1, %eax
jmp 0x1b0d1
movl $0x9, %ebp
movq %rbx, %rdi
callq 0xf980
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: lso_type
static int lso_type(lua_State *L) {
	struct luasocket *S;

	if ((S = lso_testself(L, 1))) {
		lua_pushstring(L, (S->socket)? "socket" : "closed socket");
	} else {
		lua_pushnil(L);
	}

	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x10350
testq %rax, %rax
je 0x1b344
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf900
testl %eax, %eax
je 0x1b344
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfff0b9d7, %edx       # imm = 0xFFF0B9D7
callq 0xf6b0
movl %eax, %ebp
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
xorl %eax, %eax
testl %ebp, %ebp
cmoveq %rax, %r14
jmp 0x1b347
xorl %r14d, %r14d
testq %r14, %r14
je 0x1b370
cmpq $0x0, 0x128(%r14)
leaq 0x1a5da(%rip), %rax     # 0x35935
leaq 0x1a5da(%rip), %rsi     # 0x3593c
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0xfbd0
jmp 0x1b378
movq %rbx, %rdi
callq 0xf980
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/socket.c
// Function: dbg_iov_eoh
static int dbg_iov_eoh(lua_State *L) {
	struct iovec iov = dbg_checkstring(L, 1);
	_Bool eof = dbg_checkbool(L, 2);
	size_t eoh;
	int error;

	if ((size_t)-1 == (eoh = iov_eoh(&iov, eof, 0, &error))) {
		lua_pushnil(L);
		lua_pushstring(L, cqs_strerror(error));
		lua_pushinteger(L, error);

		return 3;
	} else {
		lua_pushinteger(L, eoh);

		return 1;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movl $0x1, %ebp
movl $0x1, %esi
movq %r14, %rdx
callq 0xf620
movq (%r14), %rcx
movq %rax, -0x8(%r14)
movq %rcx, (%r14)
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0xf6c0
movq %rbx, %rdi
movl $0x2, %esi
callq 0xf540
xorl %esi, %esi
testl %eax, %eax
setne %sil
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0x19902
cmpq $-0x1, %rax
jne 0x1b671
movq %rbx, %rdi
callq 0xf980
movl 0xc(%rsp), %ebp
xorps %xmm0, %xmm0
leaq 0x20(%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)
movl $0x80, %edx
movl %ebp, %edi
callq 0xf250
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfbd0
movslq %ebp, %rax
movl $0x3, %ebp
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf910
movl %ebp, %eax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq