LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/fifo.h
// Function: fifo_unpack
FIFO_NOTUSED static unsigned long long fifo_unpack(struct fifo *fifo, unsigned count) {
	unsigned long long bits = 0;
	unsigned mask, nbits;

	if (fifo_rbits(fifo) < count)
		return 0;

	while (count) {
		if (!fifo->rbits.count) {
			fifo->rbits.byte  = fifo_getc(fifo);
			fifo->rbits.count = 8;
		}

		nbits = FIFO_MIN(count, fifo->rbits.count);
		mask  = (1 << nbits) - 1;

		bits <<= nbits;
		bits |= mask & (fifo->rbits.byte >> (fifo->rbits.count - nbits));

		fifo->rbits.count -= nbits;
		count             -= nbits;
	}

	return bits;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ef60
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jae 0x1efd5
movq $0x0, -0x8(%rbp)
jmp 0x1f09b
jmp 0x1efd7
cmpl $0x0, -0x14(%rbp)
je 0x1f093
movq -0x10(%rbp), %rax
cmpb $0x0, 0x31(%rax)
jne 0x1f005
movq -0x10(%rbp), %rdi
callq 0x1f0b0
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x30(%rax)
movq -0x10(%rbp), %rax
movb $0x8, 0x31(%rax)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl 0x31(%rcx), %ecx
cmpl %ecx, %eax
jae 0x1f01c
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x1f027
movq -0x10(%rbp), %rax
movzbl 0x31(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl 0x30(%rcx), %edx
movq -0x10(%rbp), %rcx
movzbl 0x31(%rcx), %ecx
subl -0x28(%rbp), %ecx
sarl %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
movl %eax, %eax
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x28(%rbp), %edx
movq -0x10(%rbp), %rax
movzbl 0x31(%rax), %ecx
subl %edx, %ecx
movb %cl, 0x31(%rax)
movl -0x28(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x1efd7
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/fifo.h
// Function: fifo_getc
static inline int fifo_getc(struct fifo *fifo) {
	int c;

	if (!fifo->count)
		return EOF;

	c = fifo->base[fifo->head];
	fifo_discard(fifo, 1);

	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x1f0d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f0fb
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1c340
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x1f9f8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xe4(%rbp)
cmpl $0x28, %eax
ja 0x1fa7a
movq -0xf0(%rbp), %rcx
movl -0xe4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0xf8(%rbp)
jmp 0x1fa97
movq -0xf0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1fac8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x1fd60
testb $0x1, %al
jne 0x1fac1
jmp 0x1fac3
jmp 0x1fac8
jmp 0x1fa3f
movq -0x18(%rbp), %rax
testq %rax, %rax
setne %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movslq -0x18(%rbp), %rdx
callq 0xf4a0
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf280
cmpl $0x0, %eax
jne 0x1fb29
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x107f0
movb $0x0, -0x1(%rbp)
jmp 0x1fb2d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/socket.h
// Function: sa_port
static inline in_port_t *(sa_port)(sockaddr_arg_t arg, const in_port_t *def, int *error) {
	switch (*sa_family(arg)) {
	case AF_INET:
		return &sockaddr_ref(arg).sin->sin_port;
	case AF_INET6:
		return &sockaddr_ref(arg).sin6->sin6_port;
	default:
		if (error)
			*error = EAFNOSUPPORT;

		return (in_port_t *)def;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1fdc0
movzwl (%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x2, %eax
je 0x1fb74
jmp 0x1fb6a
movl -0x34(%rbp), %eax
subl $0xa, %eax
je 0x1fb8f
jmp 0x1fbaa
movq -0x10(%rbp), %rdi
callq 0x1fdf0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x1fbc3
movq -0x10(%rbp), %rdi
callq 0x1fdf0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x1fbc3
cmpq $0x0, -0x20(%rbp)
je 0x1fbbb
movq -0x20(%rbp), %rax
movl $0x61, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xf6a0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x1fc29
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x1fc29
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x103c0
movl %eax, -0x1c(%rbp)
jmp 0x1fcec
movl $0x9, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %ecx
movl %ecx, -0x28(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x1fc59
cmpl $0x0, -0x20(%rbp)
setg %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x1fc65
jmp 0x1fcea
cmpl $0x72, -0x28(%rbp)
je 0x1fc71
cmpl $0x52, -0x28(%rbp)
jne 0x1fc7a
movl $0x4, -0x24(%rbp)
jmp 0x1fcbe
cmpl $0x77, -0x28(%rbp)
je 0x1fc86
cmpl $0x57, -0x28(%rbp)
jne 0x1fc8f
movl $0x2, -0x24(%rbp)
jmp 0x1fcbc
cmpl $0x78, -0x28(%rbp)
je 0x1fc9b
cmpl $0x58, -0x28(%rbp)
jne 0x1fca4
movl $0x1, -0x24(%rbp)
jmp 0x1fcba
cmpl $0x2d, -0x28(%rbp)
jne 0x1fcb3
movl $0x0, -0x24(%rbp)
jmp 0x1fcb8
jmp 0x1fc30
jmp 0x1fcba
jmp 0x1fcbc
jmp 0x1fcbe
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x30(%rbp), %eax
imull $0x3, %ecx, %ecx
shll %cl, %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x1fc30
jmp 0x1fcec
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/socket.c
// Function: lso_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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0xf740
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf590
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x107f0
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0xf200
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf280
cmpl $0x0, %eax
jne 0x1fdaa
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x107f0
movb $0x0, -0x1(%rbp)
jmp 0x1fdae
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x130, %rsi            # imm = 0x130
callq 0x190f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x200e8
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xf7f0
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2010c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xf100
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
addq $0x18, %rdi
callq 0x201a0
movq -0x10(%rbp), %rdi
addq $0xa8, %rdi
addq $0x18, %rdi
callq 0x201a0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x138(%rax)
jne 0x2016f
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x138(%rax)
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rdi
callq 0xf470
movq -0x10(%rbp), %rax
movq $0x0, 0x138(%rax)
jmp 0x2017f
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rdi
callq 0xf470
movq -0x10(%rbp), %rax
movq $0x0, 0x128(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x27f07(%rip), %rdx     # 0x48113
callq 0xfe00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x138(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x200a0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x10(%rbp)
movl $0xffffffff, -0x68(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xf280
cmpl $0x5, %eax
jne 0x20a79
movq -0x10(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
movl $0x1, %edx
callq 0x1f110
leaq -0x60(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
movl $0x50, %edx
callq 0xfb40
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x27e0f(%rip), %rdx     # 0x48836
leaq 0x2cb84(%rip), %rcx     # 0x4d5b2
leaq 0x280b3(%rip), %r8      # 0x48ae8
xorl %eax, %eax
movl %eax, %r9d
movb $0x0, %al
callq 0x1f9c0
testb $0x1, %al
jne 0x20a58
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0xf4a0
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x1ec60
movl %eax, -0x64(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x107f0
jmp 0x20aeb
leaq -0x110(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0xf7d0
movb $0x1, -0xff(%rbp)
movl $0x0, -0xf8(%rbp)
movb $0x1, -0xf4(%rbp)
movb $0x1, -0xf3(%rbp)
movb $0x1, -0xf2(%rbp)
movl $0x1, %eax
movq %rax, -0xd0(%rbp)
movb $0x1, -0xc8(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x110(%rbp), %rsi
movl $0x50, %edx
callq 0xfb40
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1ec60
movl %eax, -0x64(%rbp)
cmpl $0x0, -0x64(%rbp)
jge 0x20af3
jmp 0x20b37
movl -0x64(%rbp), %edi
movl $0x406, %esi            # imm = 0x406
xorl %edx, %edx
movb $0x0, %al
callq 0xf830
movl %eax, %ecx
movl %ecx, -0x68(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x20b14
jmp 0x20b40
movq -0x10(%rbp), %rdi
movl -0x68(%rbp), %esi
leaq -0x60(%rbp), %rdx
callq 0x102c0
movl %eax, -0x6c(%rbp)
cmpl $0x0, %eax
je 0x20b2e
jmp 0x20b4a
movl $0x1, -0x4(%rbp)
jmp 0x20b70
movl $0x9, -0x6c(%rbp)
jmp 0x20b4a
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x6c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x194f0
movq -0x10(%rbp), %rdi
callq 0xfa10
movq -0x10(%rbp), %rdi
movslq -0x6c(%rbp), %rsi
callq 0xf9a0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xf280
cmpl $0x5, %eax
jne 0x20c38
movq -0x10(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
movl $0x1, %edx
callq 0x1f110
leaq -0x60(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
movl $0x50, %edx
callq 0xfb40
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x27c56(%rip), %rdx     # 0x48836
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x1f9c0
testb $0x1, %al
jne 0x20bf1
jmp 0x20c04
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x10c70
movl %eax, -0x64(%rbp)
jmp 0x20c28
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0xf4a0
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x10c70
movl %eax, -0x64(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x107f0
jmp 0x20caa
leaq -0x108(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0xf7d0
movb $0x1, -0xf7(%rbp)
movl $0x0, -0xf0(%rbp)
movb $0x1, -0xec(%rbp)
movb $0x1, -0xeb(%rbp)
movb $0x1, -0xea(%rbp)
movl $0x1, %eax
movq %rax, -0xc8(%rbp)
movb $0x1, -0xc0(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x108(%rbp), %rsi
movl $0x50, %edx
callq 0xfb40
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x10c70
movl %eax, -0x64(%rbp)
cmpl $0x0, -0x64(%rbp)
jge 0x20cb2
jmp 0x20cd5
movq -0x10(%rbp), %rdi
movl -0x64(%rbp), %esi
leaq -0x60(%rbp), %rdx
callq 0x102c0
movl %eax, -0x68(%rbp)
cmpl $0x0, %eax
je 0x20ccc
jmp 0x20cdc
movl $0x1, -0x4(%rbp)
jmp 0x20cf9
movl $0x9, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfa10
movq -0x10(%rbp), %rdi
movslq -0x68(%rbp), %rsi
callq 0xf9a0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x21220
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x20fc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rcx
leaq 0x27b37(%rip), %rsi     # 0x48ae1
leaq 0x27b37(%rip), %rax     # 0x48ae8
cmpq $0x0, %rcx
cmovneq %rax, %rsi
callq 0xfcc0
jmp 0x20fc9
movq -0x8(%rbp), %rdi
callq 0xfa10
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x216c0
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x21700
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
leaq -0x20(%rbp), %rdi
xorl %edx, %edx
leaq -0x34(%rbp), %rcx
andb $0x1, %al
movzbl %al, %esi
callq 0x1e250
movq %rax, %rcx
movq %rcx, -0x30(%rbp)
movq $-0x1, %rax
cmpq %rcx, %rax
jne 0x213c5
movq -0x10(%rbp), %rdi
callq 0xfa10
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0xc4(%rbp)
leaq -0xb4(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movl -0xc4(%rbp), %edi
leaq -0xb4(%rbp), %rsi
movl $0x80, %edx
callq 0xf270
movq -0xc0(%rbp), %rdi
movq %rax, %rsi
callq 0xfcc0
movq -0x10(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0xf9a0
movl $0x3, -0x4(%rbp)
jmp 0x213d9
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xf9a0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/socket.c
// Function: dbg_iov_eob
static int dbg_iov_eob(lua_State *L) {
	struct iovec haystack = dbg_checkstring(L, 1);
	struct iovec needle = dbg_checkstring(L, 2);

	lua_pushinteger(L, iov_eob(&haystack, needle.iov_base, needle.iov_len));

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x216c0
movq %rax, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x216c0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0x1e540
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xf9a0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/socket.c
// Function: dbg_iov_eot
static int dbg_iov_eot(lua_State *L) {
	struct iovec iov = dbg_checkstring(L, 1);
	size_t minbuf = dbg_checksize(L, 2);
	size_t maxbuf = dbg_checksize(L, 3);
	_Bool eof = dbg_checkbool(L, 4);
	size_t n;
	int error;

	if ((size_t)-1 == (n = iov_eot(&iov, minbuf, maxbuf, eof, &error))) {
		lua_pushnil(L);
		lua_pushstring(L, cqs_strerror(error));
		lua_pushinteger(L, error);

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

		return 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x216c0
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x21740
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x21740
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x21700
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movb -0x31(%rbp), %al
leaq -0x20(%rbp), %rdi
leaq -0x44(%rbp), %r8
andb $0x1, %al
movzbl %al, %ecx
callq 0x1e680
movq %rax, %rcx
movq %rcx, -0x40(%rbp)
movq $-0x1, %rax
cmpq %rcx, %rax
jne 0x2155f
movq -0x10(%rbp), %rdi
callq 0xfa10
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0xd4(%rbp)
leaq -0xc4(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movl -0xd4(%rbp), %edi
leaq -0xc4(%rbp), %rsi
movl $0x80, %edx
callq 0xf270
movq -0xd0(%rbp), %rdi
movq %rax, %rsi
callq 0xfcc0
movq -0x10(%rbp), %rdi
movslq -0x44(%rbp), %rsi
callq 0xf9a0
movl $0x3, -0x4(%rbp)
jmp 0x21573
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xf9a0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/socket.c
// Function: dbg_iov_trimcr
static int dbg_iov_trimcr(lua_State *L) {
	struct iovec src = dbg_checkstring(L, 1);
	_Bool chomp = dbg_checkbool(L, 2);
	struct iovec dst = { memcpy(lua_newuserdata(L, src.iov_len), src.iov_base, src.iov_len), src.iov_len };

	iov_trimcr(&dst, chomp);

	lua_pushlstring(L, dst.iov_base, dst.iov_len);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x216c0
movq %rax, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x21700
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xfbe0
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xfb40
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movb -0x19(%rbp), %al
leaq -0x30(%rbp), %rdi
andb $0x1, %al
movzbl %al, %esi
callq 0x1d3f0
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xf510
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/errno.c
// Function: cqs_strerror_r
cqs_error_t cqs_strerror_r(cqs_error_t error, char *dst, size_t lim) {
	const char *src;

	if (error >= DNS_EBASE && error < DNS_ELAST) {
		src = dns_strerror(error);
	} else if (error >= SO_EBASE && error < SO_ELAST) {
		src = so_strerror(error);
	} else {
#if STRERROR_R_CHAR_P
		if (!(src = strerror_r(error, dst, lim)))
			return EINVAL;
#else
		/* glibc between 2.3.4 and 2.13 returns -1 on error */
		if (-1 == (error = strerror_r(error, dst, lim)))
			return errno;

		return error;
#endif
	}

	if (src != dst && lim > 0) {
		size_t n = strnlen(src, lim - 1);
		memcpy(dst, src, n);
		dst[n] = '\0';
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x9b918cc0, -0x8(%rbp) # imm = 0x9B918CC0
jl 0x21823
cmpl $0x9b918ccc, -0x8(%rbp) # imm = 0x9B918CCC
jge 0x21823
movl -0x8(%rbp), %edi
callq 0xf970
movq %rax, -0x20(%rbp)
jmp 0x2186a
cmpl $0x8c9c94c7, -0x8(%rbp) # imm = 0x8C9C94C7
jl 0x21843
cmpl $0x8c9c94cc, -0x8(%rbp) # imm = 0x8C9C94CC
jge 0x21843
movl -0x8(%rbp), %edi
callq 0xfcd0
movq %rax, -0x20(%rbp)
jmp 0x21868
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf360
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x21866
movl $0x16, -0x4(%rbp)
jmp 0x218b4
jmp 0x21868
jmp 0x2186a
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x218ad
cmpq $0x0, -0x18(%rbp)
jbe 0x218ad
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
subq $0x1, %rsi
callq 0x106a0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xfb40
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/errno.c
// Function: luaopen__cqueues_errno
int luaopen__cqueues_errno(lua_State *L) {
	unsigned i;

	luaL_newlib(L, le_globals);

	for (i = 0; i < sizeof errlist / sizeof *errlist; i++) {
		lua_pushstring(L, errlist[i].name);
		lua_pushinteger(L, errlist[i].value);
		lua_settable(L, -3);

#if EAGAIN == EWOULDBLOCK
		if (!strcmp(errlist[i].name, "EWOULDBLOCK"))
			continue;
#endif

		lua_pushinteger(L, errlist[i].value);
		lua_pushstring(L, errlist[i].name);
		lua_settable(L, -3);
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movsd 0x26558(%rip), %xmm0    # 0x48000
movl $0x88, %esi
callq 0x106d0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x10330
movq -0x8(%rbp), %rdi
leaq 0x379f3(%rip), %rsi     # 0x594c0
xorl %edx, %edx
callq 0x10390
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpq $0x86, %rax
jae 0x21bbb
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x379e6(%rip), %rax     # 0x594e0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0xfcc0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x379c7(%rip), %rax     # 0x594e0
shlq $0x4, %rcx
addq %rcx, %rax
movslq 0x8(%rax), %rsi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x103b0
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x3799d(%rip), %rax     # 0x594e0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
leaq 0x26fe6(%rip), %rsi     # 0x48b3a
callq 0x103a0
cmpl $0x0, %eax
jne 0x21b60
jmp 0x21bad
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x37970(%rip), %rax     # 0x594e0
shlq $0x4, %rcx
addq %rcx, %rax
movslq 0x8(%rax), %rsi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x37950(%rip), %rax     # 0x594e0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0xfcc0
movq -0x8(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x103b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x21adb
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/signal.c
// Function: sfd_preinit
static void sfd_preinit(struct signalfd *S) {
	S->features = 0;
	S->fd = -1;

	sigemptyset(&S->desired);
	sigemptyset(&S->polling);
	sigemptyset(&S->pending);

#if ENABLE_SIGNALFD || ENABLE_EVFILT_SIGNAL
	S->timeout = NAN;
#else
	S->timeout = 1.1;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x10150
movq -0x8(%rbp), %rdi
addq $0x88, %rdi
callq 0x10150
movq -0x8(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x10150
movq -0x8(%rbp), %rax
movsd 0x2605e(%rip), %xmm0    # 0x48008
movsd %xmm0, 0x188(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/signal.c
// Function: lsl_wait
static int lsl_wait(lua_State *L) {
	struct signalfd *S = luaL_checkudata(L, 1, LSL_CLASS);
	sigset_t none;
	int error, signo;

	if ((error = sfd_query(S)))
		return luaL_error(L, "signal:get: %s", cqs_strerror(error));

	sigemptyset(&none);

	if ((signo = sfd_diff(&S->pending, &none))) {
		lua_pushinteger(L, signo);
		sigdelset(&S->pending, signo);

		return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x27012(%rip), %rdx     # 0x49031
callq 0xfe00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22310
movl %eax, -0x9c(%rbp)
cmpl $0x0, %eax
je 0x2209a
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
movl -0x9c(%rbp), %eax
movl %eax, -0x12c(%rbp)
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movl -0x12c(%rbp), %edi
leaq -0x120(%rbp), %rsi
movl $0x80, %edx
callq 0xf270
movq -0x128(%rbp), %rdi
movq %rax, %rdx
leaq 0x26fc0(%rip), %rsi     # 0x4904e
movb $0x0, %al
callq 0xfe70
movl %eax, -0x4(%rbp)
jmp 0x220fe
leaq -0x98(%rbp), %rdi
callq 0x10150
movq -0x18(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
leaq -0x98(%rbp), %rsi
callq 0x223c0
movl %eax, -0xa0(%rbp)
cmpl $0x0, %eax
je 0x220f7
movq -0x10(%rbp), %rdi
movslq -0xa0(%rbp), %rsi
callq 0xf9a0
movq -0x18(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
movl -0xa0(%rbp), %esi
callq 0x101a0
movl $0x1, -0x4(%rbp)
jmp 0x220fe
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/signal.c
// Function: lsl_timeout
static int lsl_timeout(lua_State *L) {
	struct signalfd *S = luaL_checkudata(L, 1, LSL_CLASS);
	sigset_t none;

	sigemptyset(&none);

	if (sfd_diff(&S->pending, &none)) {
		lua_pushnumber(L, 0.0);
	} else if (isnormal(S->timeout) && !signbit(S->timeout)) {
		lua_pushnumber(L, S->timeout);
	} else {
		lua_pushnil(L);
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x26e72(%rip), %rdx     # 0x49031
callq 0xfe00
movq %rax, -0x10(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x10150
movq -0x10(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
leaq -0x90(%rbp), %rsi
callq 0x223c0
cmpl $0x0, %eax
je 0x221fe
movq -0x8(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0xf300
jmp 0x22274
movq -0x10(%rbp), %rax
movsd 0x188(%rax), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $-0x10000000000000, %rcx # imm = 0xFFF0000000000000
addq %rcx, %rax
shrq $0x35, %rax
subl $0x3ff, %eax            # imm = 0x3FF
setb %al
testb $0x1, %al
jne 0x2223b
jmp 0x22269
movq -0x10(%rbp), %rax
movsd 0x188(%rax), %xmm0
movq %xmm0, %rax
cmpq $0x0, %rax
jl 0x22269
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd 0x188(%rax), %xmm0
callq 0xf300
jmp 0x22272
movq -0x8(%rbp), %rdi
callq 0xfa10
jmp 0x22274
movl $0x1, %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/signal.c
// Function: lsl_settimeout
static int lsl_settimeout(lua_State *L) {
	struct signalfd *S = luaL_checkudata(L, 1, LSL_CLASS);

	lua_settop(L, 2);

	lua_pushnumber(L, S->timeout);

	S->timeout = luaL_optnumber(L, 2, NAN);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x26d85(%rip), %rdx     # 0x49031
callq 0xfe00
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x107f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd 0x188(%rax), %xmm0
callq 0xf300
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movsd 0x25d1f(%rip), %xmm0    # 0x48008
callq 0xf800
movq -0x10(%rbp), %rax
movsd %xmm0, 0x188(%rax)
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/signal.c
// Function: sfd_diff
static int sfd_diff(const sigset_t *a, const sigset_t *b) {
	for (int signo = 1; signo < 32; signo++) {
		if (!!sigismember(a, signo) ^ !!sigismember(b, signo))
			return signo;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
cmpl $0x20, -0x1c(%rbp)
jge 0x2243a
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xf690
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xf690
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl $0x0, %ecx
setne %cl
xorb $-0x1, %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
je 0x2242d
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x22441
jmp 0x2242f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x223d7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/signal.c
// Function: lsl_listen
static int lsl_listen(lua_State *L) {
	struct signalfd *S;
	int index, error;

	S = lua_newuserdata(L, sizeof *S);

	sfd_preinit(S);

	for (index = 1; index <= lua_gettop(L) - 1; index++)
		sigaddset(&S->desired, luaL_checkint(L, index));

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

	if ((error = sfd_init(S)) || (error = sfd_update(S)))
		return luaL_error(L, "signal.listen: %s", cqs_strerror(error));

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x190, %esi            # imm = 0x190
callq 0xfbe0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x21f50
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xa4(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf9b0
movl %eax, %ecx
movl -0xa4(%rbp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0x224d6
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x10c70
movq -0xb0(%rbp), %rdi
movl %eax, %esi
callq 0x10660
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x22481
movq -0x10(%rbp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0x26b4b(%rip), %rdx     # 0x49031
callq 0xf200
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10b10
movq -0x18(%rbp), %rdi
callq 0x22d90
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
jne 0x2251b
movq -0x18(%rbp), %rdi
callq 0x22e10
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
je 0x22576
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0xbc(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movl -0xbc(%rbp), %edi
leaq -0xa0(%rbp), %rsi
movl $0x80, %edx
callq 0xf270
movq -0xb8(%rbp), %rdi
movq %rax, %rdx
leaq 0x26b2a(%rip), %rsi     # 0x49094
movb $0x0, %al
callq 0xfe70
movl %eax, -0x4(%rbp)
jmp 0x2257d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/signal.c
// Function: lsl_type
static int lsl_type(lua_State *L) {
	if (luaL_testudata(L, 1, LSL_CLASS)) {
		lua_pushstring(L, "signal listener");
	} else {
		lua_pushnil(L);
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x26a85(%rip), %rdx     # 0x49031
callq 0x108e0
cmpq $0x0, %rax
je 0x225c9
movq -0x8(%rbp), %rdi
leaq 0x26ae4(%rip), %rsi     # 0x490a6
callq 0xfcc0
jmp 0x225d2
movq -0x8(%rbp), %rdi
callq 0xfa10
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/signal.c
// Function: lsl_strflag
static int lsl_strflag(lua_State *L) {
	int top = lua_gettop(L), count = 0;

	for (int i = 1; i <= top; i++) {
		int flags = luaL_checkint(L, i);
		int flag;

		while ((flag = signal_flags(&flags))) {
			const char *txt;

			if ((txt = signal_strflag(flag))) {
				luaL_checkstack(L, 1, "too many results");
				lua_pushstring(L, txt);
				count++;
			}
		}
	}

	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf9b0
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x226aa
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x10c70
movl %eax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x22f40
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x2269d
movl -0x1c(%rbp), %edi
callq 0x22fc0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2269b
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x26a36(%rip), %rdx     # 0x490b6
callq 0xfdb0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xfcc0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2264d
jmp 0x2269f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x22636
movl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/signal.c
// Function: lsl_flags
static int lsl_flags(lua_State *L) {
	int i, flags = 0;

	for (i = 1; i <= lua_gettop(L); i++)
		flags |= luaL_checkint(L, i);

	lua_pushinteger(L, flags);
	lua_pushcclosure(L, &lsl_nxtflag, 1);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf9b0
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jg 0x2270f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x10c70
orl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x226da
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0xf9a0
movq -0x8(%rbp), %rdi
leaq 0x8e9(%rip), %rsi       # 0x23010
movl $0x1, %edx
callq 0x10bf0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/signal.c
// Function: ls_ignore
static int ls_ignore(lua_State *L) {
	struct sigaction sa;
	int index;

	for (index = 1; index <= lua_gettop(L); index++) {
		sa.sa_handler = SIG_IGN;
		sigemptyset(&sa.sa_mask);
		sa.sa_flags = 0;

		if (0 != sigaction(luaL_checkint(L, index), &sa, 0))
			return luaL_error(L, "signal.ignore: %s", cqs_strerror(errno));
	}

	lua_pushboolean(L, 1);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
movl $0x1, -0xac(%rbp)
movl -0xac(%rbp), %eax
movl %eax, -0x130(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf9b0
movl %eax, %ecx
movl -0x130(%rbp), %eax
cmpl %ecx, %eax
jg 0x2283f
movl $0x1, %eax
movq %rax, -0xa8(%rbp)
leaq -0xa8(%rbp), %rdi
addq $0x8, %rdi
callq 0x10150
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0xac(%rbp), %esi
callq 0x10c70
movl %eax, %edi
leaq -0xa8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x10160
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x22829
movq -0x10(%rbp), %rax
movq %rax, -0x138(%rbp)
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x13c(%rbp)
leaq -0x12c(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movl -0x13c(%rbp), %edi
leaq -0x12c(%rbp), %rsi
movl $0x80, %edx
callq 0xf270
movq -0x138(%rbp), %rdi
movq %rax, %rdx
leaq 0x268cf(%rip), %rsi     # 0x490ec
movb $0x0, %al
callq 0xfe70
movl %eax, -0x4(%rbp)
jmp 0x22854
jmp 0x2282b
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x22759
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x109d0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/signal.c
// Function: ls_default
static int ls_default(lua_State *L) {
	struct sigaction sa;
	int index;

	for (index = 1; index <= lua_gettop(L); index++) {
		sa.sa_handler = SIG_DFL;
		sigemptyset(&sa.sa_mask);
		sa.sa_flags = 0;

		if (0 != sigaction(luaL_checkint(L, index), &sa, 0))
			return luaL_error(L, "signal.default: %s", cqs_strerror(errno));
	}

	lua_pushboolean(L, 1);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
movl $0x1, -0xac(%rbp)
movl -0xac(%rbp), %eax
movl %eax, -0x130(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf9b0
movl %eax, %ecx
movl -0x130(%rbp), %eax
cmpl %ecx, %eax
jg 0x2295e
movq $0x0, -0xa8(%rbp)
leaq -0xa8(%rbp), %rdi
addq $0x8, %rdi
callq 0x10150
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0xac(%rbp), %esi
callq 0x10c70
movl %eax, %edi
leaq -0xa8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x10160
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x22948
movq -0x10(%rbp), %rax
movq %rax, -0x138(%rbp)
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x13c(%rbp)
leaq -0x12c(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movl -0x13c(%rbp), %edi
leaq -0x12c(%rbp), %rsi
movl $0x80, %edx
callq 0xf270
movq -0x138(%rbp), %rdi
movq %rax, %rdx
leaq 0x267c2(%rip), %rsi     # 0x490fe
movb $0x0, %al
callq 0xfe70
movl %eax, -0x4(%rbp)
jmp 0x22973
jmp 0x2294a
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x22879
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x109d0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/signal.c
// Function: ls_discard
static int ls_discard(lua_State *L) {
	struct sigaction sa;
	int index;

	for (index = 1; index <= lua_gettop(L); index++) {
		sa.sa_handler = &ls_noop;
		sigemptyset(&sa.sa_mask);
		sa.sa_flags = 0;

		if (0 != sigaction(luaL_checkint(L, index), &sa, 0))
			return luaL_error(L, "signal.discard: %s", cqs_strerror(errno));
	}

	lua_pushboolean(L, 1);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
movl $0x1, -0xac(%rbp)
movl -0xac(%rbp), %eax
movl %eax, -0x130(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf9b0
movl %eax, %ecx
movl -0x130(%rbp), %eax
cmpl %ecx, %eax
jg 0x22a81
leaq 0x6db(%rip), %rax       # 0x230a0
movq %rax, -0xa8(%rbp)
leaq -0xa8(%rbp), %rdi
addq $0x8, %rdi
callq 0x10150
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0xac(%rbp), %esi
callq 0x10c70
movl %eax, %edi
leaq -0xa8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x10160
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x22a6b
movq -0x10(%rbp), %rax
movq %rax, -0x138(%rbp)
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x13c(%rbp)
leaq -0x12c(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movl -0x13c(%rbp), %edi
leaq -0x12c(%rbp), %rsi
movl $0x80, %edx
callq 0xf270
movq -0x138(%rbp), %rdi
movq %rax, %rdx
leaq 0x266b2(%rip), %rsi     # 0x49111
movb $0x0, %al
callq 0xfe70
movl %eax, -0x4(%rbp)
jmp 0x22a96
jmp 0x22a6d
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x22999
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x109d0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/signal.c
// Function: ls_block
static int ls_block(lua_State *L) {
	sigset_t set;
	int index, error;

	sigemptyset(&set);

	for (index = 1; index <= lua_gettop(L); index++) {
		sigaddset(&set, luaL_checkint(L, index));
	}

	if ((error = cqs_sigmask(SIG_BLOCK, &set, 0)))
		return luaL_error(L, "signal.block: %s", cqs_strerror(error));

	lua_pushboolean(L, 1);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x10150
movl $0x1, -0x94(%rbp)
movl -0x94(%rbp), %eax
movl %eax, -0x11c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf9b0
movl %eax, %ecx
movl -0x11c(%rbp), %eax
cmpl %ecx, %eax
jg 0x22b24
movq -0x10(%rbp), %rdi
movl -0x94(%rbp), %esi
callq 0x10c70
movl %eax, %esi
leaq -0x90(%rbp), %rdi
callq 0x10660
movl -0x94(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x94(%rbp)
jmp 0x22ad5
xorl %edi, %edi
leaq -0x90(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x106b0
movl %eax, -0x98(%rbp)
cmpl $0x0, %eax
je 0x22b9f
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
movl -0x98(%rbp), %eax
movl %eax, -0x12c(%rbp)
leaq -0x118(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movl -0x12c(%rbp), %edi
leaq -0x118(%rbp), %rsi
movl $0x80, %edx
callq 0xf270
movq -0x128(%rbp), %rdi
movq %rax, %rdx
leaq 0x26591(%rip), %rsi     # 0x49124
movb $0x0, %al
callq 0xfe70
movl %eax, -0x4(%rbp)
jmp 0x22bb4
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x109d0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/signal.c
// Function: ls_unblock
static int ls_unblock(lua_State *L) {
	sigset_t set;
	int index, error;

	sigemptyset(&set);

	for (index = 1; index <= lua_gettop(L); index++) {
		sigaddset(&set, luaL_checkint(L, index));
	}

	if ((error = cqs_sigmask(SIG_UNBLOCK, &set, 0)))
		return luaL_error(L, "signal.unblock: %s", cqs_strerror(error));

	lua_pushboolean(L, 1);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x10150
movl $0x1, -0x94(%rbp)
movl -0x94(%rbp), %eax
movl %eax, -0x11c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf9b0
movl %eax, %ecx
movl -0x11c(%rbp), %eax
cmpl %ecx, %eax
jg 0x22c34
movq -0x10(%rbp), %rdi
movl -0x94(%rbp), %esi
callq 0x10c70
movl %eax, %esi
leaq -0x90(%rbp), %rdi
callq 0x10660
movl -0x94(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x94(%rbp)
jmp 0x22be5
movl $0x1, %edi
leaq -0x90(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x106b0
movl %eax, -0x98(%rbp)
cmpl $0x0, %eax
je 0x22cb2
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
movl -0x98(%rbp), %eax
movl %eax, -0x12c(%rbp)
leaq -0x118(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movl -0x12c(%rbp), %edi
leaq -0x118(%rbp), %rsi
movl $0x80, %edx
callq 0xf270
movq -0x128(%rbp), %rdi
movq %rax, %rdx
leaq 0x2648f(%rip), %rsi     # 0x49135
movb $0x0, %al
callq 0xfe70
movl %eax, -0x4(%rbp)
jmp 0x22cc7
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x109d0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/signal.c
// Function: ls_raise
static int ls_raise(lua_State *L) {
	int index;

	for (index = 1; index <= lua_gettop(L); index++) {
		raise(luaL_checkint(L, index));
	}

	lua_pushboolean(L, 1);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf9b0
movl %eax, %ecx
movl -0x10(%rbp), %eax
cmpl %ecx, %eax
jg 0x22d29
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x10c70
movl %eax, %edi
callq 0xfe40
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x22cf3
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x109d0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)