LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: wakecb_wakeup
static cqs_error_t wakecb_wakeup(struct wakecb *cb) {
	struct cqueue *Q = cb->arg[0];
	struct event *event = cb->arg[1];

	event->pending = 1;
	thread_move(event->thread, &Q->thread.pending);

	return cqueue_tryalert(Q);
}

// Assembly:
movq %rdi, %rax
movq 0x10(%rdi), %rdi
movq 0x18(%rax), %rax
movb $0x1, 0x10(%rax)
movq 0x18(%rax), %rax
leaq 0x210(%rdi), %rcx
cmpq %rcx, 0x20(%rax)
je 0x11c34
leaq 0x28(%rax), %rdx
movq 0x28(%rax), %rsi
movq 0x30(%rax), %r8
testq %rsi, %rsi
je 0x14b8c
movq %r8, 0x30(%rsi)
movq %rsi, (%r8)
movq (%rcx), %rsi
movq %rsi, (%rdx)
testq %rsi, %rsi
je 0x14b9e
movq %rdx, 0x30(%rsi)
movq %rax, (%rcx)
movq %rcx, 0x30(%rax)
movq %rcx, 0x20(%rax)
jmp 0x11c34
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: err_pushvalue
static const char *err_pushvalue(lua_State *L, struct callinfo *I) {
	if (I->error.value) {
		lua_pushvalue(L, I->error.value);
	} else {
		lua_pushstring(L, "no error message");
	}

	return lua_tostring(L, -1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x14bc0
movq %rbx, %rdi
callq 0xf9c0
jmp 0x14bcf
leaq 0x20837(%rip), %rsi     # 0x353fe
movq %rbx, %rdi
callq 0xfbd0
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
popq %rbx
jmp 0xf110
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_checkfd
static int cqueue_checkfd(lua_State *L, struct callinfo *I, int index) {
	int fd;

	if (!lua_isnil(L, index) && !lua_isnumber(L, index)) {
		if (LUA_OK != object_pcall(L, I, NULL, index, "pollfd", LUA_TNUMBER))
			err_error(L, I);

		fd = luaL_optint(L, -1, -1);
		lua_pop(L, 1);
	} else {
		fd = luaL_optint(L, index, -1);
	}

	return fd;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %esi
callq 0xf260
testl %eax, %eax
je 0x14d3f
movq %rbx, %rdi
movl %ebp, %esi
callq 0xfb80
testl %eax, %eax
je 0x14d55
movq %rbx, %rdi
movl %ebp, %esi
movq $-0x1, %rdx
callq 0xf400
movq %rax, %r14
jmp 0x14dba
leaq 0xc(%rsp), %r9
movl $0x3, (%r9)
movl $0x1, (%rsp)
leaq 0x203c0(%rip), %r8      # 0x3512f
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl %ebp, %ecx
callq 0x14a10
testl %eax, %eax
je 0x14d96
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0x14bae
movq %rbx, %rdi
callq 0xf690
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq $-0x1, %rdx
callq 0xf400
movq %rax, %r14
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_reboot
static cqs_error_t cqueue_reboot(struct cqueue *Q, _Bool stop, _Bool restart) {
	if (stop) {
		struct fileno *fileno;
		struct thread *thread;

		while ((fileno = LIST_FIRST(&Q->fileno.polling))) {
			LIST_REMOVE(fileno, le);
			LIST_INSERT_HEAD(&Q->fileno.outstanding, fileno, le);
		}

		LIST_FOREACH(fileno, &Q->fileno.outstanding, le) {
			fileno->state = 0;
		}

		while ((thread = LIST_FIRST(&Q->thread.polling))) {
			thread_move(thread, &Q->thread.pending);
		}

		kpoll_destroy(&Q->kp, &cstack_onclosefd, Q->cstack);
	}

	if (restart) {
		int error;

		if ((error = kpoll_init(&Q->kp)))
			return error;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
testl %esi, %esi
je 0x14eaa
movq 0x1a8(%rbx), %rax
testq %rax, %rax
je 0x14e28
leaq 0x1b0(%rbx), %rcx
movq 0x30(%rax), %rdx
movq 0x38(%rax), %rsi
testq %rdx, %rdx
je 0x14dfa
movq %rsi, 0x38(%rdx)
movq %rdx, (%rsi)
movq (%rcx), %rdx
movq %rdx, 0x30(%rax)
testq %rdx, %rdx
je 0x14e11
leaq 0x30(%rax), %rsi
movq %rsi, 0x38(%rdx)
movq %rax, 0x1b0(%rbx)
movq %rcx, 0x38(%rax)
movq 0x1a8(%rbx), %rax
testq %rax, %rax
jne 0x14de9
movq 0x1b0(%rbx), %rax
testq %rax, %rax
je 0x14e40
movw $0x0, 0x4(%rax)
movq 0x30(%rax), %rax
jmp 0x14e2f
movq 0x208(%rbx), %rax
testq %rax, %rax
je 0x14e9b
leaq 0x210(%rbx), %rcx
cmpq %rcx, 0x20(%rax)
je 0x14e96
movq 0x28(%rax), %rdx
movq 0x30(%rax), %rdi
testq %rdx, %rdx
je 0x14e6a
movq %rdi, 0x30(%rdx)
leaq 0x28(%rax), %rsi
movq %rdx, (%rdi)
movq (%rcx), %rdx
movq %rdx, (%rsi)
testq %rdx, %rdx
je 0x14e80
movq %rsi, 0x30(%rdx)
movq %rax, 0x210(%rbx)
movq %rcx, 0x30(%rax)
movq %rcx, 0x20(%rax)
movq 0x208(%rbx), %rax
testq %rax, %rax
jne 0x14e53
movq 0x230(%rbx), %rsi
movq %rbx, %rdi
callq 0x14ec4
testb %bpl, %bpl
je 0x14ebb
movq %rbx, %rdi
callq 0x14f73
testl %eax, %eax
jne 0x14ebd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: pool_destroy
static void pool_destroy(struct pool *P) {
	void *p;

	while ((p = P->head)) {
		P->head = *(void **)p;
		free(p);
		P->count--;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x15727
movq (%rdi), %rax
movq %rax, 0x10(%rbx)
callq 0xff30
decq 0x8(%rbx)
movq 0x10(%rbx), %rdi
jmp 0x1570c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cqueue__gc
static int cqueue__gc(lua_State *L) {
	struct cqueue *Q = cqs_checkudata(L, 1, 1, CQUEUE_CLASS);
	struct callinfo I;

	cqueue_enter_nothrow(L, &I, 1, Q);
	cqueue_destroy(L, Q, &I);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x1f952(%rip), %rsi     # 0x3508c
callq 0x11852
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf280
movq %rsp, %rdx
movl %eax, (%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rdx)
movl $0xffffffff, 0x14(%rdx) # imm = 0xFFFFFFFF
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14f9a
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_create
static int cqueue_create(lua_State *L) {
	struct cqueue *Q;
	int error;

	Q = lua_newuserdata(L, sizeof *Q);

	cqueue_preinit(Q);

	luaL_getmetatable(L, CQUEUE_CLASS);
	lua_setmetatable(L, -2);

	if ((error = cqueue_init(L, Q, -1)))
		goto error;

	return 1;

error:
	lua_pushnil(L);
	lua_pushstring(L, cqs_strerror(error));
	lua_pushinteger(L, error);

	return 3;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movl $0x248, %esi            # imm = 0x248
callq 0xfb00
movq %rax, %r14
movl $0x248, %edx            # imm = 0x248
movq %rax, %rdi
xorl %esi, %esi
callq 0xf750
movl $0xffffffff, (%r14)     # imm = 0xFFFFFFFF
movq $-0x1, 0x190(%r14)
movq $0x38, 0x1c0(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c8(%r14)
movq $0x40, 0x1d8(%r14)
movups %xmm0, 0x1e0(%r14)
movq $0x50, 0x1f0(%r14)
movups %xmm0, 0x1f8(%r14)
leaq 0x1f894(%rip), %rdx     # 0x3508c
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xf1e0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10910
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf280
movl %eax, %r15d
movq %r14, %rdi
callq 0x14f73
testl %eax, %eax
je 0x15886
movl %eax, %ebp
movq %rbx, %rdi
callq 0xf980
movq %rsp, %rsi
xorps %xmm0, %xmm0
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
movl %ebp, %edi
callq 0xf250
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfbd0
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x3, %eax
jmp 0x158db
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x101e0
movq %rbx, %rdi
movl %r15d, %esi
callq 0xf630
movq %rbx, %rdi
callq 0x11168
movq %rax, 0x230(%r14)
movq (%rax), %rcx
movq %rcx, 0x238(%r14)
testq %rcx, %rcx
je 0x158cc
movq %r14, %rdx
addq $0x238, %rdx            # imm = 0x238
movq %rdx, 0x240(%rcx)
movq %r14, (%rax)
movq %rax, 0x240(%r14)
movl $0x1, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cqueue_type
static int cqueue_type(lua_State *L) {
	struct cqueue *Q;

	if ((Q = cqs_testudata(L, 1, 1))) {
		if (Q->cstack) {
			lua_pushstring(L, "controller");
		} else {
			lua_pushstring(L, "closed controller");
		}
	} 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 0x1594b
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf900
testl %eax, %eax
je 0x1594b
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
testl %ebp, %ebp
je 0x1594b
cmpq $0x0, 0x230(%r14)
je 0x15955
leaq 0x1fb8b(%rip), %rsi     # 0x354d4
jmp 0x1595c
movq %rbx, %rdi
callq 0xf980
jmp 0x15964
leaq 0x1fb71(%rip), %rsi     # 0x354cd
movq %rbx, %rdi
callq 0xfbd0
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cstack_cancel
static int cstack_cancel(lua_State *L) {
	struct callinfo I = CALLINFO_INITIALIZER;
	struct cstack *CS = cstack_self(L);
	int index, fd;

	for (index = 1; index <= lua_gettop(L); index++) {
		fd = cqueue_checkfd(L, &I, index);
		cstack_cancelfd(CS, fd);
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movups 0x1fab8(%rip), %xmm0    # 0x35504
movaps %xmm0, (%rsp)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x10(%rsp)
callq 0x11168
movq %rax, %r14
movq %rbx, %rdi
callq 0xf920
testl %eax, %eax
jle 0x15abf
movl $0x1, %r12d
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x14d16
movq (%r14), %r13
testq %r13, %r13
je 0x15aaa
movl %eax, %ebp
movq %r13, %rdi
movl %ebp, %esi
callq 0x11ad7
movq 0x238(%r13), %r13
testq %r13, %r13
jne 0x15a94
leal 0x1(%r12), %ebp
movq %rbx, %rdi
callq 0xf920
cmpl %eax, %r12d
movl %ebp, %r12d
jl 0x15a7c
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_O3/wahern[P]cqueues/src/cqueues.c
// Function: cstack_reset
static int cstack_reset(lua_State *L) {
	struct cstack *CS = cstack_self(L);
	struct cqueue *Q;
	int error;

	LIST_FOREACH(Q, &CS->cqueues, le) {
		cqueue_reboot(Q, 1, 0);
	}

	LIST_FOREACH(Q, &CS->cqueues, le) {
		if ((error = cqueue_reboot(Q, 0, 1)))
			return luaL_error(L, "unable to reset continuation queue: %s", cqs_strerror(error));
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
callq 0x11168
movq (%rax), %r15
testq %r15, %r15
je 0x15b27
movq %rax, %r14
movq %r15, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x14dc6
movq 0x238(%r15), %r15
testq %r15, %r15
jne 0x15aef
movq (%r14), %r14
testq %r14, %r14
je 0x15b27
movq %r14, %rdi
callq 0x14f73
testl %eax, %eax
jne 0x15b36
movq 0x238(%r14), %r14
jmp 0x15b0d
xorl %eax, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rsp, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0x10b27
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: cstack_running
static int cstack_running(lua_State *L) {
	struct cstack *CS = cstack_self(L);

	if (CS->running) {
		lua_pushvalue(CS->running->L, CS->running->self);
		lua_xmove(CS->running->L, L, 1);
		lua_pushboolean(L, CS->running->T == L);
	} else {
		lua_pushnil(L);
		lua_pushboolean(L, 0);
	}

	return 2;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x11168
movq %rax, %r14
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x15b8c
movq 0x8(%rax), %rdi
movl 0x10(%rax), %esi
callq 0xf9c0
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x10230
movq 0x8(%r14), %rax
xorl %esi, %esi
cmpq %rbx, 0x18(%rax)
sete %sil
jmp 0x15b96
movq %rbx, %rdi
callq 0xf980
xorl %esi, %esi
movq %rbx, %rdi
callq 0x10800
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: dbg_f2ms
static int dbg_f2ms(lua_State *L) {
	int ms = f2ms(luaL_checknumber(L, 1));

	lua_pushinteger(L, ms);
	lua_pushboolean(L, ms == INT_MAX);

	return 2;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %ebp
movl $0x1, %esi
callq 0x10920
movsd %xmm0, 0x8(%rsp)
callq 0xf060
cmpl $0x2, %eax
je 0x15c0e
cmpl $0x3, %eax
je 0x15c17
cmpl $0x4, %eax
jne 0x15c12
movq 0x8(%rsp), %xmm0
movq %xmm0, %rax
testq %rax, %rax
js 0x15c0e
mulsd 0x1f419(%rip), %xmm0    # 0x35010
callq 0xf1c0
movsd 0x1f414(%rip), %xmm1    # 0x35018
minsd %xmm0, %xmm1
cvttsd2si %xmm1, %ebp
jmp 0x15c17
xorl %ebp, %ebp
jmp 0x15c17
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movslq %ebp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf910
xorl %esi, %esi
cmpl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
sete %sil
movq %rbx, %rdi
callq 0x10800
movl $0x2, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/cqueues.c
// Function: dbg_f2ts
static int dbg_f2ts(lua_State *L) {
	struct timespec *ts = f2ts(luaL_checknumber(L, 1));

	if (!ts)
		return 0;

	lua_createtable(L, 0, 2);
	lua_pushinteger(L, ts->tv_sec);
	lua_setfield(L, -2, "tv_sec");
	lua_pushinteger(L, ts->tv_nsec);
	lua_setfield(L, -2, "tv_nsec");

	lua_pushboolean(L, ts->tv_sec == LONG_MAX);

	return 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x10920
movsd %xmm0, 0x8(%rsp)
callq 0xf060
cmpl $0x2, %eax
je 0x15d06
cmpl $0x3, %eax
je 0x15d0b
cmpl $0x4, %eax
jne 0x15d83
movq 0x8(%rsp), %xmm0
movq %xmm0, %rax
testq %rax, %rax
js 0x15d06
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x10830
movsd 0x1f376(%rip), %xmm1    # 0x35020
mulsd %xmm1, %xmm0
callq 0xf1c0
movsd (%r14), %xmm1
movsd 0x1f368(%rip), %xmm2    # 0x35028
addsd %xmm1, %xmm2
movsd 0x1f354(%rip), %xmm3    # 0x35020
cmpnlesd %xmm0, %xmm3
andpd %xmm3, %xmm1
andnpd %xmm2, %xmm3
orpd %xmm1, %xmm3
ucomisd 0x1f34b(%rip), %xmm3    # 0x35030
jae 0x15d92
xorl %r14d, %r14d
ucomisd 0x1f32a(%rip), %xmm0    # 0x35020
cvttsd2si %xmm0, %rax
cmovbq %rax, %r14
cvttsd2si %xmm3, %r15
jmp 0x15d14
xorl %r14d, %r14d
jmp 0x15d11
movl $0x1, %r14d
xorl %r15d, %r15d
movl $0x2, %ebp
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x101e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf910
leaq 0x1f7af(%rip), %rdx     # 0x354e9
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf910
leaq 0x1f797(%rip), %rdx     # 0x354f0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %esi, %esi
cmpq %rax, %r15
sete %sil
movq %rbx, %rdi
callq 0x10800
jmp 0x15d85
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movabsq $0x7fffffffffffffff, %r15 # imm = 0x7FFFFFFFFFFFFFFF
xorl %r14d, %r14d
jmp 0x15d14
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/socket.c
// Function: cqs_socket_fdopen
lso_error_t cqs_socket_fdopen(lua_State *L, int fd, const struct so_options *_opts) {
	struct so_options opts = *((_opts)? _opts : so_opts());
	struct luasocket *S;
	int type = SOCK_STREAM, error;

	if (0 != getsockopt(fd, SOL_SOCKET, SO_TYPE, &type, &(socklen_t){ sizeof type })) {
		switch (errno) {
		case ENOTSOCK:
		case EOPNOTSUPP:
			break;
		default:
			goto syerr;
		}
	}

	S = lso_newsocket(L, type);

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

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

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

	return 0;
syerr:
	error = errno;
error:
	lua_pop(L, 1);

	return error;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movl %esi, %ebp
movq %rdi, %rbx
testq %rdx, %rdx
jne 0x15ded
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, 0x40(%rdx)
movaps %xmm0, 0x30(%rdx)
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, (%rdx)
movb $0x1, %al
movb %al, 0x11(%rdx)
movw $0x101, 0x1c(%rdx)      # imm = 0x101
movb %al, 0x1e(%rdx)
movq $0x1, 0x40(%rdx)
movb %al, 0x48(%rdx)
leaq 0x10(%rsp), %rdi
movl $0xa, %ecx
movq %rdx, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x8(%rsp), %rcx
movl $0x1, (%rcx)
leaq 0xc(%rsp), %r8
movl $0x4, (%r8)
movl %ebp, %edi
movl $0x1, %esi
movl $0x3, %edx
callq 0xf9a0
testl %eax, %eax
je 0x15e3a
callq 0xf0a0
movl (%rax), %eax
cmpl $0x5f, %eax
je 0x15e3a
cmpl $0x58, %eax
jne 0x15e8c
movl 0x8(%rsp), %esi
movq %rbx, %rdi
callq 0x15ead
movq %rax, %r14
movq %rax, %rdi
callq 0x163df
movl %eax, 0x4(%rsp)
testl %eax, %eax
jne 0x15e90
leaq 0x10(%rsp), %rsi
movq %r14, 0x28(%rsi)
leaq 0x15b(%rip), %rax       # 0x15fc4
movq %rax, 0x30(%rsi)
leaq 0x4(%rsp), %rdx
movl %ebp, %edi
callq 0xf2f0
movq %rax, %rcx
movq %rax, 0x128(%r14)
xorl %eax, %eax
testq %rcx, %rcx
jne 0x15ea1
jmp 0x15e90
movl %eax, 0x4(%rsp)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
movl 0x4(%rsp), %eax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/socket.c
// Function: lso_newsocket
static struct luasocket *lso_newsocket(lua_State *L, int type) {
	struct luasocket *S;

	S = lua_newuserdata(L, sizeof *S);
	*S = *lso_prototype(L);

	S->type = type;

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

	if (S->onerror != LUA_NOREF && S->onerror != LUA_REFNIL) {
		cqs_getref(L, S->onerror);
		S->onerror = LUA_NOREF;
		cqs_ref(L, &S->onerror);
	}

#if defined LUA_RIDX_MAINTHREAD
	lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_MAINTHREAD);
	S->mainthread = lua_tothread(L, -1);
	lua_pop(L, 1);
#endif

	luaL_getmetatable(L, LSO_CLASS);
	lua_setmetatable(L, -2);

	return S;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl $0x148, %esi            # imm = 0x148
callq 0xfb00
movq %rax, %r14
leaq 0x1f69a(%rip), %rsi     # 0x35564
leaq 0x3229f(%rip), %rdx     # 0x48170
movl $0x148, %ecx            # imm = 0x148
movq %rbx, %rdi
callq 0x16351
movl $0x148, %edx            # imm = 0x148
movq %r14, %rdi
movq %rax, %rsi
callq 0xfa60
movl %ebp, 0x120(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%r14)
movups %xmm0, 0x68(%r14)
movups %xmm0, 0x78(%r14)
xorl %eax, %eax
movl %eax, 0x88(%r14)
movups %xmm0, 0xc0(%r14)
movups %xmm0, 0xd0(%r14)
movups %xmm0, 0xe0(%r14)
movl %eax, 0xf0(%r14)
movslq 0x130(%r14), %rdx
cmpq $-0x3, %rdx
ja 0x15f68
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xf450
movl $0xfffffffe, 0x130(%r14) # imm = 0xFFFFFFFE
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x10930
movl %eax, 0x130(%r14)
movl $0x1, %edx
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xf450
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf460
movq %rax, 0x138(%r14)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
leaq 0x1f0fd(%rip), %rdx     # 0x3509f
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xf1e0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10910
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/socket.c
// Function: lso_closefd
static int lso_closefd(int *fd, void *arg) {
	struct luasocket *S = arg;

	if (S->mainthread) {
		cqs_cancelfd(S->mainthread, *fd);
		cqs_closefd(fd);
	}

	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x138(%rsi), %rdi
testq %rdi, %rdi
je 0x15fed
movl (%rbx), %esi
callq 0xfc10
movl (%rbx), %edi
cmpl $-0x1, %edi
je 0x15fed
callq 0x10a10
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/socket.c
// Function: lso_singleton
static void *lso_singleton(lua_State *L, const void *key, const void *init, size_t len) {
	void *p;

	lua_rawgetp(L, LUA_REGISTRYINDEX, key);
	p = lua_touserdata(L, -1);
	lua_pop(L, 1);

	if (p)
		return p;

	p = lua_newuserdata(L, len);
	if (init)
		memcpy(p, init, len);
	else
		memset(p, 0, len);
	lua_rawsetp(L, LUA_REGISTRYINDEX, key);

	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %rbx, %rdx
callq 0xf080
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x10350
movq %rax, %r12
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
testq %r12, %r12
jne 0x163d2
movq %r14, %rdi
movq %r15, %rsi
callq 0xfb00
movq %rax, %r12
movq %rax, %rdi
testq %r13, %r13
je 0x163b8
movq %r13, %rsi
movq %r15, %rdx
callq 0xfa60
jmp 0x163c2
xorl %esi, %esi
movq %r15, %rdx
callq 0xf750
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %rbx, %rdx
callq 0xf160
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/socket.c
// Function: lso_adjbufs
static lso_error_t lso_adjbufs(struct luasocket *S) {
	int error;

	if ((error = lso_adjbuf(&S->ibuf.fifo, S->ibuf.bufsiz)))
		return error;

	if ((error = lso_adjbuf(&S->obuf.fifo, S->obuf.bufsiz)))
		return error;

	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rsi
cmpq $-0x1, %rsi
je 0x163fa
leaq 0x58(%rbx), %rdi
callq 0x16418
testl %eax, %eax
jne 0x16416
movq 0xb8(%rbx), %rsi
cmpq $-0x1, %rsi
je 0x16414
addq $0xc0, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x16418
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/lib/fifo.h
// Function: fifo_realloc
static int fifo_realloc(struct fifo *fifo, size_t size) {
	void *tmp;

	if (fifo->size >= size)
		return 0;
	if (fifo_type(fifo) == FIFO_STATIC)
		return ENOMEM;

	fifo_realign(fifo);

	size = fifo_roundup(size);

	if (!(tmp = realloc(fifo->base, size)))
		return errno;

	fifo->base = tmp;
	fifo->size = size;

	return 0;
}

// Assembly:
xorl %eax, %eax
cmpq %rsi, 0x18(%rdi)
jae 0x164c6
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0xc, %eax
cmpq $0x0, (%rdi)
jne 0x164c1
movq %rsi, %r14
movq %rbx, %rdi
callq 0x164c7
movq $-0x1, %r15
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, %r14
ja 0x1649d
decq %r14
movq %r14, %rax
shrq %rax
orq %r14, %rax
movq %rax, %rcx
shrq $0x2, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x4, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x8, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x10, %rax
orq %rcx, %rax
movq %rax, %r15
shrq $0x20, %r15
orq %rax, %r15
incq %r15
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x10620
testq %rax, %rax
je 0x164ba
movq %rax, 0x10(%rbx)
movq %r15, 0x18(%rbx)
xorl %eax, %eax
jmp 0x164c1
callq 0xf0a0
movl (%rax), %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/lib/fifo.h
// Function: fifo_realign
static void fifo_realign(struct fifo *fifo) {
	if (fifo->size - fifo->head >= fifo->count) {
		memmove(fifo->base, &fifo->base[fifo->head], fifo->count);
		fifo->head = 0;
	} else {
		unsigned char tmp[FIFO_TMPBUFSIZ];
		unsigned n, m;

		while (fifo->head != 0) {
			n = FIFO_MIN(fifo->head, sizeof tmp);
			m = fifo->size - n;

			memcpy(tmp, fifo->base, n);
			memmove(fifo->base, &fifo->base[n], m);
			memcpy(&fifo->base[m], tmp, n);
			fifo->head -= n;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %r14
subq %r14, %rax
movq 0x28(%rdi), %rdx
cmpq %rdx, %rax
jae 0x1654f
testq %r14, %r14
je 0x16566
movl $0x800, %ebp            # imm = 0x800
movq %rsp, %r15
cmpq %rbp, %r14
cmovaeq %rbp, %r14
movl 0x18(%rbx), %r12d
subl %r14d, %r12d
movq 0x10(%rbx), %r13
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0xfa60
leaq (%r14,%r13), %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x105f0
addq 0x10(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xfa60
movq 0x20(%rbx), %rax
subq %r14, %rax
movq %rax, 0x20(%rbx)
movq %rax, %r14
jne 0x164fc
jmp 0x16566
movq 0x10(%rbx), %rdi
addq %rdi, %r14
movq %r14, %rsi
callq 0x105f0
movq $0x0, 0x20(%rbx)
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x184cf
movq %rax, %r14
movq 0x128(%rax), %rdi
callq 0xf840
movq 0x128(%r14), %rdi
callq 0xf7e0
testl %eax, %eax
je 0x165bf
movl %eax, %ebp
movq %rbx, %rdi
callq 0xf980
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %ebp
jmp 0x165d1
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf9c0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x184cf
movq %rax, %r14
movq 0x128(%rax), %rdi
callq 0xf840
movq 0x128(%r14), %rdi
callq 0xffc0
testl %eax, %eax
je 0x1661f
movl %eax, %ebp
movq %rbx, %rdi
callq 0xf980
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %ebp
jmp 0x16631
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf9c0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/socket.c
// Function: lso_starttls
static lso_nargs_t lso_starttls(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	SSL_CTX **ctx = NULL;
	SSL **ssl = NULL;
	int error;

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

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

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

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

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

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

	S->todo |= LSO_DO_STARTTLS;

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

	lua_pushvalue(L, 1);

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

	return 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x184cf
movq %rax, %r14
testb $0x2, (%rax)
jne 0x16760
leaq 0x1f05f(%rip), %rdx     # 0x356ba
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10720
testq %rax, %rax
je 0x166aa
movq %rax, %r15
movq (%rax), %rdi
testq %rdi, %rdi
je 0x16745
movq 0x20(%r14), %rax
cmpq %rax, %rdi
je 0x16745
testq %rax, %rax
je 0x16699
movq %rax, %rdi
callq 0xf770
movq (%r15), %rdi
movq %r14, %r12
addq $0x20, %r12
callq 0xf100
jmp 0x1673e
leaq 0x1f00e(%rip), %rdx     # 0x356bf
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10720
movq %rax, %r15
testq %rax, %rax
jne 0x16711
leaq 0x1effb(%rip), %rdx     # 0x356c8
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10720
testq %rax, %rax
je 0x16745
movq %rax, %r15
movl 0x18(%rax), %eax
testl %eax, %eax
jne 0x16701
leaq 0x1efe4(%rip), %rdx     # 0x356d4
movq %rbx, %rdi
movl $0x2, %esi
callq 0xf3f0
movl 0x18(%r15), %eax
cmpl $0x1, %eax
movl $0x1, 0x38(%r14)
sete 0x3c(%r14)
movq (%r15), %rdi
testq %rdi, %rdi
je 0x16745
movq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x16745
testq %rax, %rax
je 0x16732
movq %rax, %rdi
callq 0xf0f0
movq (%r15), %rdi
movq %r14, %r12
addq $0x18, %r12
callq 0xfb70
movq (%r15), %rax
movq %rax, (%r12)
movl (%r14), %eax
movl %eax, %ecx
orl $0x2, %ecx
movl %ecx, (%r14)
testb $0x20, 0xa8(%r14)
je 0x16760
orl $0x3, %eax
movl %eax, (%r14)
movq %r14, %rdi
callq 0x1854c
testl %eax, %eax
je 0x16788
movl %eax, %ebp
movq %rbx, %rdi
callq 0xf980
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %ebp
jmp 0x1679a
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf9c0
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/socket.c
// Function: lso_checktls
static lso_nargs_t lso_checktls(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	SSL **ssl;

	ssl = lua_newuserdata(L, sizeof *ssl);

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

	luaL_getmetatable(L, "SSL*");

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

	lua_setmetatable(L, -2);

	SSL_up_ref(*ssl);

	return 1;
}

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

	lua_settop(L, 3);

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

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

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

	return 3;
}

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

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

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

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

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

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

	return nret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x184cf
movq %rax, %r12
leaq 0x1ed3a(%rip), %rdx     # 0x3570d
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0xf8b0
movq %rax, %r15
leaq 0x108(%r12), %r13
addq $0x94, %r12
movzbl (%r15,%r14), %eax
movq %r12, %rcx
cmpl $0x72, %eax
je 0x16a0c
movq %r13, %rcx
cmpl $0x77, %eax
jne 0x16a1b
movl (%rcx), %esi
movq %rbx, %rdi
callq 0x18e4c
incq %r14
jmp 0x169f7
testl %eax, %eax
jne 0x16a2c
movl %r14d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movsbl %al, %ecx
addq %r14, %r15
leaq 0x1ecb3(%rip), %rsi     # 0x356ec
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xfff0
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf3f0
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/socket.c
// Function: lso_unget2
static lso_nargs_t lso_unget2(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	const void *src;
	size_t len;
	struct iovec iov;
	int error;

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

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

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

	S->ibuf.eof = 0;

	lua_pushboolean(L, 1);

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

	return 2;
}

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

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

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

		return 1;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
callq 0x184cf
movq %rax, %r15
leaq 0x1e37e(%rip), %rdx     # 0x358fa
movl $0x2, %ebx
movq %r14, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0xf8b0
movl 0xa8(%r15), %esi
movq %rax, %rdi
callq 0x18b70
movl %eax, %r12d
movq %r14, %rdi
movq %r15, %rsi
callq 0x19a37
testl %eax, %eax
jne 0x175c0
movq %r15, %rdi
movl %r12d, %esi
callq 0x1866f
testl %eax, %eax
je 0x175e2
movl %eax, %ebp
movq %r14, %rdi
xorl %esi, %esi
callq 0x10800
movslq %ebp, %rsi
movq %r14, %rdi
callq 0xf910
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %ebx
movq %r14, %rdi
movl $0x1, %esi
callq 0x10800
jmp 0x175d7
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/socket.c
// Function: lso_uncork
static lso_nargs_t lso_uncork(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	int error;

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

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

		return 1;
	}
}

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

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

	return 2;
}

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

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

	lua_settop(L, 3);

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

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

	so_clear(S->socket);

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

	lua_pushboolean(L, 1);

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

	return 2;
}

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

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

	lua_settop(L, 4);

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

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

	so_clear(S->socket);

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

	lua_pushboolean(L, 1);

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

	return 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x184cf
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x19a37
testl %eax, %eax
je 0x17a6d
movl %eax, %r13d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10800
movslq %r13d, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x4, %esi
callq 0x10640
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10920
movsd %xmm0, (%rsp)
movl $0x20, %edx
movq %rbx, %rdi
movl $0x3, %esi
callq 0xf400
movq %rax, %r15
leaq 0x21563(%rip), %rdx     # 0x3900b
movq %rbx, %rdi
movl $0x4, %esi
xorl %ecx, %ecx
callq 0xf8b0
movl 0xa8(%r14), %esi
movq %rax, %rdi
callq 0x18b70
movl %eax, %ebp
movq %r14, %r12
addq $0xc0, %r12
movq 0xd8(%r14), %rax
movq 0xe8(%r14), %rsi
subq %rsi, %rax
cmpq $0x7, %rax
ja 0x17b28
movzbl 0xf3(%r14), %ecx
shlq $0x3, %rax
subq %rcx, %rax
addq $0x8, %rax
movl %r15d, %ecx
cmpq %rcx, %rax
jae 0x17b28
movl $0x4b, %r13d
cmpq $-0x9, %rsi
ja 0x17a42
addq $0x8, %rsi
movq %r12, %rdi
callq 0x16418
testl %eax, %eax
jne 0x17a3f
testl %r15d, %r15d
je 0x17bab
cvttsd2si (%rsp), %r13
movb 0xf2(%r14), %dl
movb 0xf3(%r14), %sil
movzbl %sil, %esi
movl $0x8, %eax
subl %esi, %eax
cmpl %eax, %r15d
cmovbl %r15d, %eax
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl %eax, %ecx
shll %cl, %edi
movzbl %dl, %r8d
shll %cl, %r8d
subl %eax, %r15d
movq %r13, %rdx
movl %r15d, %ecx
shrq %cl, %rdx
notl %edi
andl %edi, %edx
orl %r8d, %edx
movb %dl, 0xf2(%r14)
addb %al, %sil
movb %sil, 0xf3(%r14)
cmpb $0x8, %sil
jb 0x17ba6
movzbl %dl, %esi
movq %r12, %rdi
callq 0x19b96
movw $0x0, 0xf2(%r14)
xorl %edx, %edx
xorl %esi, %esi
testl %r15d, %r15d
jne 0x17b41
movq 0x128(%r14), %rdi
callq 0xf840
movq %r14, %rdi
movl %ebp, %esi
callq 0x1866f
testl %eax, %eax
jne 0x17a3f
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
jmp 0x17a5c
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/socket.c
// Function: lso_unpack2
static lso_nargs_t lso_unpack2(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	unsigned long long value;
	unsigned count;
	int error;

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

	lua_settop(L, 2);

	count = luaL_optunsigned(L, 2, 32);

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

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

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

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

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

	return 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x184cf
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x18fc8
testl %eax, %eax
je 0x17c27
movl %eax, %ebp
movq %rbx, %rdi
callq 0xf980
movslq %ebp, %rsi
movl $0x2, %ebp
movq %rbx, %rdi
callq 0xf910
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10640
movl $0x20, %edx
movq %rbx, %rdi
movl $0x2, %esi
callq 0xf400
movq %rax, %r15
movq 0x80(%r14), %rdi
movzbl 0x89(%r14), %eax
leaq (%rax,%rdi,8), %rcx
movl %r15d, %r12d
cmpq %r12, %rcx
jae 0x17ca4
movq %r12, %rsi
subq %rcx, %rsi
addq $0x7, %rsi
shrq $0x3, %rsi
movq %r14, %rdi
callq 0x19094
movl %eax, %ebp
testl %eax, %eax
setne %dl
movq 0x80(%r14), %rdi
movzbl 0x89(%r14), %eax
leaq (%rax,%rdi,8), %rcx
cmpq %r12, %rcx
setb %sil
testb %sil, %dl
jne 0x17c04
xorl %esi, %esi
movl $0x1, %ebp
testl %r15d, %r15d
je 0x17c14
cmpq %r12, %rcx
jb 0x17c14
movb 0x88(%r14), %r8b
xorl %esi, %esi
testb %al, %al
jne 0x17d14
testq %rdi, %rdi
je 0x17d03
movq 0x68(%r14), %rcx
movq 0x78(%r14), %rax
movb (%rcx,%rax), %r8b
incq %rax
xorl %edx, %edx
divq 0x70(%r14)
movq %rdx, 0x78(%r14)
leaq -0x1(%rdi), %rcx
movq %rcx, 0x80(%r14)
cmpq $0x1, %rdi
jne 0x17d08
movq $0x0, 0x78(%r14)
jmp 0x17d06
movb $-0x1, %r8b
xorl %ecx, %ecx
movb %r8b, 0x88(%r14)
movb $0x8, %al
movq %rcx, %rdi
movzbl %al, %eax
cmpl %eax, %r15d
movl %eax, %edx
cmovbl %r15d, %edx
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
movl %edx, %ecx
shll %cl, %r9d
movq %rsi, %r10
shlq %cl, %r10
notl %r9d
movzbl %r8b, %esi
subl %edx, %eax
movl %eax, %ecx
shrl %cl, %esi
andl %r9d, %esi
orq %r10, %rsi
movb %al, 0x89(%r14)
subl %edx, %r15d
jne 0x17cc6
jmp 0x17c14
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/socket.c
// Function: lso_fill2
static lso_nargs_t lso_fill2(lua_State *L) {
	struct luasocket *S = lso_checkself(L, 1);
	size_t size = lso_checksize(L, 2);
	int error;

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

		return 2;
	}

	lua_pushboolean(L, 1);

	return 1;
}

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

	so_clear(S->socket);

	lua_pushboolean(L, 1);

	return 1;
}

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

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

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

	lua_pushlstring(L, mode, p - mode);

	return 1;
}

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

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

		return 1;
	}

	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x184cf
movq 0x140(%rax), %xmm0
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $-0x10000000000000, %rcx # imm = 0xFFF0000000000000
addq %rax, %rcx
shrq $0x35, %rcx
cmpl $0x3ff, %ecx            # imm = 0x3FF
jb 0x17f49
xorl %eax, %eax
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x17f56
jp 0x17f56
movq %rbx, %rdi
callq 0xf2c0
movl $0x1, %eax
popq %rbx
retq