LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0xf620
movq %rax, %r14
movq (%r15), %r12
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0xf620
movq (%r15), %r15
cmpq %r15, %r12
jb 0x1b6ee
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x10680
testq %rax, %rax
je 0x1b6ee
movq %rax, %rsi
addq %r15, %rsi
subq %r14, %rsi
jmp 0x1b6f0
xorl %esi, %esi
movq %rbx, %rdi
callq 0xf910
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movl $0x1, %ebp
movl $0x1, %esi
movq %r14, %rdx
callq 0xf620
movq (%r14), %rcx
movq %rax, -0x8(%r14)
movq %rcx, (%r14)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10920
movapd %xmm0, %xmm1
xorpd 0x19ddd(%rip), %xmm1    # 0x35530
cvttsd2si %xmm1, %rax
movq %rax, %rcx
movsd 0x198cd(%rip), %xmm3    # 0x35030
movapd %xmm1, %xmm2
subsd %xmm3, %xmm2
cvttsd2si %xmm2, %rdx
sarq $0x3f, %rcx
andq %rcx, %rdx
orq %rax, %rdx
negq %rdx
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
movapd %xmm0, %xmm2
subsd %xmm3, %xmm2
cvttsd2si %xmm2, %r14
andq %rcx, %r14
orq %rax, %r14
ucomisd %xmm0, %xmm1
cmovaq %rdx, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x10920
movapd 0x19d77(%rip), %xmm2    # 0x35530
xorpd %xmm0, %xmm2
cvttsd2si %xmm2, %rax
movq %rax, %rcx
movapd %xmm2, %xmm1
movsd 0x1985f(%rip), %xmm3    # 0x35030
subsd %xmm3, %xmm1
cvttsd2si %xmm1, %rdx
sarq $0x3f, %rcx
andq %rcx, %rdx
orq %rax, %rdx
negq %rdx
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
movapd %xmm0, %xmm1
subsd %xmm3, %xmm1
cvttsd2si %xmm1, %r15
andq %rcx, %r15
orq %rax, %r15
ucomisd %xmm0, %xmm2
cmovaq %rdx, %r15
movq %rbx, %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0xf6c0
movq %rbx, %rdi
movl $0x4, %esi
callq 0xf540
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %r8
movq %r14, %rsi
movq %r15, %rdx
callq 0x19a60
cmpq $-0x1, %rax
jne 0x1b8aa
movq %rbx, %rdi
callq 0xf980
movl 0xc(%rsp), %ebp
xorpd %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movapd %xmm0, (%rsi)
movapd %xmm0, 0x10(%rsi)
movapd %xmm0, 0x20(%rsi)
movapd %xmm0, 0x30(%rsi)
movapd %xmm0, 0x40(%rsi)
movapd %xmm0, 0x50(%rsi)
movapd %xmm0, 0x60(%rsi)
movapd %xmm0, 0x70(%rsi)
movl $0x80, %edx
movl %ebp, %edi
callq 0xf250
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfbd0
movslq %ebp, %rax
movl $0x3, %ebp
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf910
movl %ebp, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0xf620
movq %rax, %r15
movq (%r14), %r12
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0xf6c0
movq %rbx, %rdi
movl $0x2, %esi
callq 0xf540
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
movq %rbx, %rdi
movq %r12, %rsi
callq 0xfb00
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xfa60
movq %r13, -0x8(%r14)
movq %r12, (%r14)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0x19329
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0xf4c0
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
leal 0x646e7340(%rdi), %eax
cmpl $0xb, %eax
ja 0x1ba2f
callq 0xf8e0
jmp 0x1ba3f
leal 0x73636b39(%rdi), %eax
cmpl $0x4, %eax
ja 0x1ba85
callq 0xfbe0
movq %rax, %r15
cmpq %rbx, %r15
sete %al
testq %r14, %r14
sete %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x1ba78
decq %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x10500
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xfa60
movb $0x0, (%rbx,%r14)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rsi
movq %r14, %rdx
callq 0xf320
movq %rax, %r15
testq %rax, %rax
jne 0x1ba42
movl $0x16, %ebp
jmp 0x1ba78
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/errno.c
// Function: cqs_strerror
const char *(cqs_strerror)(int error, void *dst, size_t lim) {
	char *p, *pe, *unknown;
	char e10[((sizeof error * CHAR_BIT) / 3) + 1], *ep;
	int n;

	if (!lim)
		return dst;

	if (0 == cqs_strerror_r(error, dst, lim) && *(char *)dst)
		return dst;

	p = dst;
	pe = p + lim;

	unknown = "Unknown error: ";
	while (*unknown && p < pe)
		*p++ = *unknown++;

	if (error < 0 && p < pe)
		*p++ = '-';

	/* translate integer to string in LSB order */
	for (ep = e10, n = error; n; ep++, n /= 10)
		*ep = "0123456789"[abs(n % 10)];
	if (ep == e10)
		*ep++ = '0';

	/* copy string, flipping from LSB to MSB */
	while (ep > e10 && p < pe)
		*p++ = *--ep;

	p[-1] = '\0';

	return dst;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
testq %rdx, %rdx
je 0x1bbb7
movq %rdx, %r15
movl %edi, %r14d
movq %rbx, %rsi
callq 0xfa00
testl %eax, %eax
je 0x1bbae
leaq (%rbx,%r15), %rcx
movq %rbx, %rax
testq %r15, %r15
setg %dl
jle 0x1bb02
movb $0x55, %dil
leaq 0x19e91(%rip), %rsi     # 0x35974
movq %rbx, %rax
movb %dil, (%rax)
incq %rax
movb (%rsi), %dil
cmpq %rcx, %rax
setb %dl
testb %dil, %dil
je 0x1bb02
incq %rsi
cmpq %rcx, %rax
jb 0x1bae6
testl %r14d, %r14d
sets %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x1bb18
movb $0x2d, (%rax)
incq %rax
leaq 0x5(%rsp), %rsi
movq %rsi, %rdx
testl %r14d, %r14d
je 0x1bb75
leaq 0x5(%rsp), %rdx
leaq 0x19e52(%rip), %rdi     # 0x35983
movslq %r14d, %r8
imulq $0x66666667, %r8, %r14  # imm = 0x66666667
movq %r14, %r9
shrq $0x3f, %r9
sarq $0x22, %r14
addl %r9d, %r14d
leal (%r14,%r14), %r9d
leal (%r9,%r9,4), %r9d
movl %r8d, %r10d
subl %r9d, %r10d
movl %r10d, %r9d
negl %r9d
cmovsl %r10d, %r9d
movb (%r9,%rdi), %r9b
movb %r9b, (%rdx)
incq %rdx
addl $0x9, %r8d
cmpl $0x12, %r8d
ja 0x1bb31
cmpq %rsi, %rdx
jne 0x1bb80
movb $0x30, (%rdx)
incq %rdx
leaq 0x5(%rsp), %rsi
cmpq %rsi, %rdx
jbe 0x1bba8
cmpq %rcx, %rax
jae 0x1bba8
decq %rdx
movb (%rdx), %dil
movb %dil, (%rax)
incq %rax
cmpq %rsi, %rdx
jbe 0x1bba8
decq %rdx
cmpq %rcx, %rax
jb 0x1bb92
movb $0x0, -0x1(%rax)
jmp 0x1bbb7
cmpb $0x0, (%rbx)
je 0x1baca
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x19426(%rip), %xmm0    # 0x35000
movl $0x88, %esi
callq 0x10530
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x101e0
leaq 0x286a6(%rip), %rsi     # 0x442a0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movl $0x8, %r13d
leaq 0x286af(%rip), %rbp     # 0x442c0
leaq 0x19d76(%rip), %r14     # 0x3598e
movq -0x8(%r13,%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfbd0
movslq (%r13,%rbp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf910
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x10260
movq %r15, %rdi
movq %r14, %rsi
callq 0x10250
testl %eax, %eax
je 0x1bc77
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf910
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfbd0
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x10260
addq $0x10, %r13
cmpq $0x868, %r13            # imm = 0x868
jne 0x1bc18
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/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 %rbx
movq %rdi, %rbx
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x10010
leaq 0x88(%rbx), %rdi
callq 0x10010
leaq 0x108(%rbx), %rdi
callq 0x10010
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
movq %rax, 0x188(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
leaq 0x19f3b(%rip), %rdx     # 0x35e85
movl $0x1, %esi
callq 0xfcf0
movq %rax, %r14
movq %rsp, %r15
xorl %ebp, %ebp
movl 0x4(%r14), %edi
movl $0x80, %edx
movq %r15, %rsi
callq 0x10310
testq %rax, %rax
jg 0x1bf8d
cmpq $-0x1, %rax
jne 0x1bf9e
callq 0xf0a0
movl (%rax), %eax
cmpl $0x4, %eax
je 0x1bf5c
cmpl $0xb, %eax
je 0x1bf9e
movl %eax, %ebp
jmp 0x1bf9e
leaq 0x108(%r14), %rdi
movl (%rsp), %esi
callq 0x104c0
xorl %ebp, %ebp
testl %ebp, %ebp
je 0x1bfee
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rsi
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl $0x80, %edx
movl %ebp, %edi
callq 0xf250
leaq 0x19ec3(%rip), %rsi     # 0x35ea2
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfd60
jmp 0x1c02f
movq %rsp, %r15
movq %r15, %rdi
callq 0x10010
addq $0x108, %r14            # imm = 0x108
movq %r14, %rdi
movq %r15, %rsi
callq 0x1c199
testl %eax, %eax
je 0x1c02d
movl %eax, %ebp
movslq %eax, %rsi
movq %rbx, %rdi
callq 0xf910
movq %r14, %rdi
movl %ebp, %esi
callq 0x10060
movl $0x1, %eax
jmp 0x1c02f
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x19ddf(%rip), %rdx     # 0x35e85
movl $0x1, %esi
callq 0xfcf0
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x10010
leaq 0x108(%r14), %rdi
movq %r15, %rsi
callq 0x1c199
testl %eax, %eax
je 0x1c0d7
pxor %xmm0, %xmm0
jmp 0x1c11b
movq 0x188(%r14), %xmm0
movq %xmm0, %rax
movq %rax, %rcx
btrq $0x3f, %rcx
movabsq $-0x10000000000000, %rdx # imm = 0xFFF0000000000000
addq %rcx, %rdx
shrq $0x35, %rdx
cmpl $0x3ff, %edx            # imm = 0x3FF
setae %cl
testq %rax, %rax
sets %al
orb %cl, %al
je 0x1c11b
movq %rbx, %rdi
callq 0xf980
jmp 0x1c123
movq %rbx, %rdi
callq 0xf2c0
movl $0x1, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x19d42(%rip), %rdx     # 0x35e85
movl $0x1, %esi
callq 0xfcf0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10640
movsd 0x188(%r14), %xmm0
movq %rbx, %rdi
callq 0xf2c0
movsd 0x18e92(%rip), %xmm0    # 0x35008
movq %rbx, %rdi
movl $0x2, %esi
callq 0xf780
movsd %xmm0, 0x188(%r14)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %ebx
movq %r15, %rdi
movl %ebx, %esi
callq 0xf610
testl %eax, %eax
setne %bpl
movq %r14, %rdi
movl %ebx, %esi
callq 0xf610
testl %eax, %eax
setne %al
xorb %bpl, %al
jne 0x1c1d8
incl %ebx
cmpl $0x20, %ebx
jne 0x1c1ab
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movl $0x190, %esi            # imm = 0x190
callq 0xfb00
movq %rax, %r14
movq %rax, %r12
movq %rax, %rdi
callq 0x1bec7
movq %rbx, %rdi
callq 0xf920
cmpl $0x2, %eax
jl 0x1c247
leaq 0x8(%r14), %r15
movl $0x1, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x10a60
movq %r15, %rdi
movl %eax, %esi
callq 0x104c0
incl %ebp
movq %rbx, %rdi
callq 0xf920
cmpl %eax, %ebp
jl 0x1c225
leaq 0x19c37(%rip), %rdx     # 0x35e85
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xf1e0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10910
orb $0x1, (%r12)
leaq 0x8(%r14), %r15
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r15, %rsi
movl $0x80800, %edx          # imm = 0x80800
callq 0xf760
movl %eax, 0x4(%r12)
cmpl $-0x1, %eax
je 0x1c2a3
leaq 0x88(%r14), %rdi
movl $0x10, %ecx
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
xorl %ebp, %ebp
jmp 0x1c2aa
callq 0xf0a0
movl (%rax), %ebp
testl %ebp, %ebp
jne 0x1c2f9
addq $0x88, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x1c199
testl %eax, %eax
je 0x1c2ea
movl 0x4(%r12), %edi
xorl %ebp, %ebp
movq %r15, %rsi
xorl %edx, %edx
callq 0xf760
cmpl $-0x1, %eax
je 0x1c2ee
movl $0x10, %ecx
movq %r14, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
jmp 0x1c2f5
xorl %ebp, %ebp
jmp 0x1c2f5
callq 0xf0a0
movl (%rax), %ebp
testl %ebp, %ebp
je 0x1c34e
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl $0x80, %edx
movl %ebp, %edi
callq 0xf250
leaq 0x19bb7(%rip), %rsi     # 0x35ee8
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfd60
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
jmp 0x1c33e
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
leaq 0x19b25(%rip), %rdx     # 0x35e85
movl $0x1, %esi
callq 0x10720
testq %rax, %rax
je 0x1c380
leaq 0x19b84(%rip), %rsi     # 0x35efa
movq %rbx, %rdi
callq 0xfbd0
jmp 0x1c388
movq %rbx, %rdi
callq 0xf980
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xf920
movl %eax, 0x4(%rsp)
testl %eax, %eax
jle 0x1c4be
movl $0x1, %r12d
xorl %r14d, %r14d
leaq 0x28944(%rip), %rbp     # 0x44d80
movq %rbx, %rdi
movl %r12d, %esi
callq 0x10a60
movq %rax, %r13
testl %r13d, %r13d
je 0x1c476
movl %r13d, %ecx
negl %ecx
andl %r13d, %ecx
je 0x1c468
bsfl %r13d, %edx
cmpq $0x0, (%rbp,%rdx,8)
setne %dl
jmp 0x1c46a
xorl %edx, %edx
xorl %ecx, %r13d
testb %dl, %dl
cmovnel %ecx, %eax
je 0x1c44a
jmp 0x1c478
xorl %eax, %eax
testl %eax, %eax
je 0x1c4ad
bsfl %eax, %eax
movq (%rbp,%rax,8), %r15
testq %r15, %r15
je 0x1c44a
movq %rbx, %rdi
movl $0x1, %esi
leaq 0x19a72(%rip), %rdx     # 0x35f0a
callq 0xfca0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfbd0
incl %r14d
jmp 0x1c44a
leal 0x1(%r12), %eax
cmpl 0x4(%rsp), %r12d
movl %eax, %r12d
jne 0x1c43c
jmp 0x1c4c1
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xf920
xorl %r14d, %r14d
testl %eax, %eax
jle 0x1c508
xorl %ebp, %ebp
incl %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x10a60
orl %eax, %ebp
movq %rbx, %rdi
callq 0xf920
cmpl %eax, %r14d
jl 0x1c4e8
movslq %ebp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf910
leaq 0x4d1(%rip), %rsi       # 0x1c9eb
movq %rbx, %rdi
movl $0x1, %edx
callq 0x109f0
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rdi, %rbx
callq 0xf920
testl %eax, %eax
jle 0x1c5a0
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
incl %r14d
movq $0x1, 0x8(%rsp)
movq %r15, %rdi
callq 0x10010
movl $0x0, 0x90(%rsp)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x10a60
movl %eax, %edi
movq %r12, %rsi
xorl %edx, %edx
callq 0x10020
testl %eax, %eax
jne 0x1c5b4
movq %rbx, %rdi
callq 0xf920
cmpl %eax, %r14d
jl 0x1c559
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
jmp 0x1c605
callq 0xf0a0
movl (%rax), %edi
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x70(%rsi)
movl $0x80, %edx
callq 0xf250
leaq 0x1994a(%rip), %rsi     # 0x35f40
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfd60
movl %eax, %ebp
movl %ebp, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rdi, %rbx
callq 0xf920
testl %eax, %eax
jle 0x1c686
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
incl %r14d
movq $0x0, 0x8(%rsp)
movq %r15, %rdi
callq 0x10010
movl $0x0, 0x90(%rsp)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x10a60
movl %eax, %edi
movq %r12, %rsi
xorl %edx, %edx
callq 0x10020
testl %eax, %eax
jne 0x1c69a
movq %rbx, %rdi
callq 0xf920
cmpl %eax, %r14d
jl 0x1c63f
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
jmp 0x1c6eb
callq 0xf0a0
movl (%rax), %edi
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x70(%rsi)
movl $0x80, %edx
callq 0xf250
leaq 0x19876(%rip), %rsi     # 0x35f52
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfd60
movl %eax, %ebp
movl %ebp, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
callq 0xf920
testl %eax, %eax
jle 0x1c771
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
leaq 0x34e(%rip), %r13       # 0x1ca77
leaq 0x8(%rsp), %r12
incl %r14d
movq %r13, 0x8(%rsp)
movq %r15, %rdi
callq 0x10010
movl $0x0, 0x90(%rsp)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x10a60
movl %eax, %edi
movq %r12, %rsi
xorl %edx, %edx
callq 0x10020
testl %eax, %eax
jne 0x1c785
movq %rbx, %rdi
callq 0xf920
cmpl %eax, %r14d
jl 0x1c72e
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
jmp 0x1c7d6
callq 0xf0a0
movl (%rax), %edi
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x70(%rsi)
movl $0x80, %edx
callq 0xf250
leaq 0x1979e(%rip), %rsi     # 0x35f65
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfd60
movl %eax, %ebp
movl %ebp, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x10010
movq %rbx, %rdi
callq 0xf920
testl %eax, %eax
jle 0x1c833
xorl %ebp, %ebp
movq %rsp, %r14
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x10a60
movq %r14, %rdi
movl %eax, %esi
callq 0x104c0
movq %rbx, %rdi
callq 0xf920
cmpl %eax, %ebp
jl 0x1c811
movq %rsp, %rsi
xorl %edi, %edi
xorl %edx, %edx
callq 0x10510
testl %eax, %eax
je 0x1c891
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rsi
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl $0x80, %edx
movl %eax, %edi
callq 0xf250
leaq 0x196f8(%rip), %rsi     # 0x35f78
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfd60
movl %eax, %ebp
jmp 0x1c8a3
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
movl %ebp, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x10010
movq %rbx, %rdi
callq 0xf920
testl %eax, %eax
jle 0x1c8fa
xorl %ebp, %ebp
movq %rsp, %r14
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x10a60
movq %r14, %rdi
movl %eax, %esi
callq 0x104c0
movq %rbx, %rdi
callq 0xf920
cmpl %eax, %ebp
jl 0x1c8d8
movl $0x1, %ebp
movq %rsp, %rsi
movl $0x1, %edi
xorl %edx, %edx
callq 0x10510
testl %eax, %eax
je 0x1c960
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rsi
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl $0x80, %edx
movl %eax, %edi
callq 0xf250
leaq 0x1963a(%rip), %rsi     # 0x35f89
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfd60
movl %eax, %ebp
jmp 0x1c96d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
movl %ebp, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xf920
testl %eax, %eax
jle 0x1c9ab
xorl %ebp, %ebp
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x10a60
movl %eax, %edi
callq 0xfd30
movq %rbx, %rdi
callq 0xf920
cmpl %eax, %ebp
jl 0x1c98c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/signal.c
// Function: lsl_nxtflag
static int lsl_nxtflag(lua_State *L) {
	int flags = (int)lua_tointeger(L, lua_upvalueindex(1));
	int flag;

	if ((flag = signal_flags(&flags))) {
		lua_pushinteger(L, flags);
		lua_replace(L, lua_upvalueindex(1));

		lua_pushinteger(L, flag);

		return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
xorl %edx, %edx
callq 0xfd20
leaq 0x2837c(%rip), %rcx     # 0x44d80
testl %eax, %eax
je 0x1ca2c
movl %eax, %edx
negl %edx
andl %eax, %edx
je 0x1ca1e
bsfl %eax, %esi
cmpq $0x0, (%rcx,%rsi,8)
setne %sil
jmp 0x1ca20
xorl %esi, %esi
xorl %edx, %eax
testb %sil, %sil
cmovnel %edx, %ebp
je 0x1ca04
jmp 0x1ca2e
xorl %ebp, %ebp
testl %ebp, %ebp
je 0x1ca6e
movslq %eax, %rsi
movq %rbx, %rdi
callq 0xf910
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfff0b9d7, %edx       # imm = 0xFFF0B9D7
callq 0xfcc0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x1, %eax
jmp 0x1ca70
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/thread.c
// Function: luaopen__cqueues_thread
int luaopen__cqueues_thread(lua_State *L) {
	int error;

	if ((error = ct_protectssl())) {
		if (error == -1) {
			return luaL_error(L, "%s", dlerror());
		} else {
			return luaL_error(L, "%s", cqs_strerror(error));
		}
	}

	cqs_newmetatable(L, CQS_THREAD, ct_methods, ct_metamethods, 0);

	luaL_newlib(L, ct_globals);

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0x2bb6a(%rip), %rdi     # 0x485f8
callq 0x103b0
xorl %r14d, %r14d
cmpq $0x0, 0x2bb82(%rip)     # 0x48620
jne 0x1cad5
movl $0x28, %edi
callq 0x10110
movq %rax, %r15
movq %rax, 0x2bb6c(%rip)     # 0x48620
testq %rax, %rax
je 0x1cac8
xorl %r14d, %r14d
movq %r15, %rdi
xorl %esi, %esi
callq 0x103f0
jmp 0x1cad0
callq 0xf0a0
movl (%rax), %r14d
testq %r15, %r15
je 0x1cb1d
cmpq $0x0, 0x2bb4b(%rip)     # 0x48628
jne 0x1cb1d
movq 0x2a4fa(%rip), %rdi     # 0x46fe0
movq %rsp, %rsi
callq 0xf5c0
testl %eax, %eax
je 0x1cb17
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x10220
movq %rax, 0x2bb21(%rip)     # 0x48628
xorl %ecx, %ecx
cmpq $0x1, %rax
sbbl %ecx, %ecx
orl %r14d, %ecx
movl %ecx, %r14d
jmp 0x1cb1d
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
leaq 0x2bad4(%rip), %rdi     # 0x485f8
callq 0xf9b0
testl %r14d, %r14d
je 0x1cb42
cmpl $-0x1, %r14d
jne 0x1cbd2
callq 0xfc50
jmp 0x1cc06
leaq 0x1949b(%rip), %rsi     # 0x35fe4
movq %rbx, %rdi
callq 0x10180
leaq 0x28378(%rip), %rsi     # 0x44ed0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movq %rbx, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x101e0
leaq 0x28308(%rip), %rsi     # 0x44e80
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
leaq 0x1859e(%rip), %rdx     # 0x35127
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movsd 0x18462(%rip), %xmm0    # 0x35000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x10530
movq %rbx, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x101e0
leaq 0x2833f(%rip), %rsi     # 0x44f00
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movl $0x1, %eax
jmp 0x1cc1a
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl $0x80, %edx
movl %r14d, %edi
callq 0xf250
leaq 0x19368(%rip), %rsi     # 0x35f75
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfd60
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/thread.c
// Function: ct_join
static int ct_join(lua_State *L) {
	struct cthread *ct = ct_checkthread(L, 1);
	int error;

	if (pthread_equal(ct->id, pthread_self()))
		return luaL_error(L, "thread.join: cannot join self");

	if (0 == read(ct->pipe[0], &(char){ 0 }, 1)) {
		lua_pushboolean(L, 1);

		if (ct->error)
			lua_pushinteger(L, ct->error);
		else if (ct->msg)
			lua_pushstring(L, ct->msg);
		else
			lua_pushnil(L);

		return 2;
	} else {
		error = errno;

		if (error == EAGAIN && !hdl_isheld(&ct->handle))
			error = CT_EOWNERDEAD;

		lua_pushboolean(L, 0);
		lua_pushinteger(L, error);

		return 2;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1cd69
movq %rax, %r14
movq 0x18(%rax), %r15
callq 0xfb90
movq %r15, %rdi
movq %rax, %rsi
callq 0x107a0
testl %eax, %eax
je 0x1cc6c
leaq 0x1939c(%rip), %rsi     # 0x35ff4
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xfd60
movl 0x1a8(%r14), %edi
leaq 0x7(%rsp), %rsi
movb $0x0, (%rsi)
movl $0x1, %edx
callq 0x10310
testq %rax, %rax
je 0x1ccd9
callq 0xf0a0
movl (%rax), %ebp
cmpl $0xb, %ebp
jne 0x1ccca
addq $0x180, %r14            # imm = 0x180
movq %r14, %rdi
callq 0xf1f0
testl %eax, %eax
je 0x1ccbd
movl $0xb, %ebp
cmpl $0x82, %eax
jne 0x1ccca
movq %r14, %rdi
callq 0xfb30
movq %r14, %rdi
callq 0xf9b0
movl $0x82, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10800
movslq %ebp, %rsi
jmp 0x1ccef
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
movslq 0x4(%r14), %rsi
testq %rsi, %rsi
je 0x1cd07
movq %rbx, %rdi
callq 0xf910
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r14), %rsi
movq %rbx, %rdi
testq %rsi, %rsi
je 0x1cd1a
callq 0xfbd0
jmp 0x1ccf7
callq 0xf980
jmp 0x1ccf7
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/thread.c
// Function: ct__eq
static int ct__eq(lua_State *L) {
	struct cthread **a = luaL_testudata(L, 1, CQS_THREAD);
	struct cthread **b = luaL_testudata(L, 2, CQS_THREAD);

	lua_pushboolean(L, a && b && (*a == *b));

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1922c(%rip), %r15     # 0x35fe4
movl $0x1, %esi
movq %r15, %rdx
callq 0x10720
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x10720
testq %r14, %r14
setne %cl
testq %rax, %rax
setne %dl
andb %cl, %dl
xorl %esi, %esi
cmpb $0x1, %dl
jne 0x1cdf9
movq (%r14), %rcx
xorl %esi, %esi
cmpq (%rax), %rcx
sete %sil
movq %rbx, %rdi
callq 0x10800
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/thread.c
// Function: ct__gc
static int ct__gc(lua_State *L) {
	struct cthread **ud = luaL_checkudata(L, 1, CQS_THREAD);

	ct_release(*ud);
	*ud = NULL;

	return 0;
}

// Assembly:
pushq %rbx
leaq 0x191d0(%rip), %rdx     # 0x35fe4
movl $0x1, %esi
callq 0xfcf0
movq %rax, %rbx
movq (%rax), %rdi
callq 0x1ce34
movq $0x0, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/thread.c
// Function: ct_type
static int ct_type(lua_State *L) {
	if (luaL_testudata(L, 1, CQS_THREAD)) {
		lua_pushstring(L, "thread");
	} else {
		lua_pushnil(L);
	}

	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x18275(%rip), %rdx     # 0x35fe4
movl $0x1, %esi
callq 0x10720
testq %rax, %rax
je 0x1dd8f
leaq 0x1830f(%rip), %rsi     # 0x36094
movq %rbx, %rdi
callq 0xfbd0
jmp 0x1dd97
movq %rbx, %rdi
callq 0xf980
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/thread.c
// Function: atpanic_trap
static int atpanic_trap(lua_State *L NOTUSED) {
	struct cthread *ct;

	if ((ct = pthread_getspecific(atpanic.key)))
		_longjmp(ct->trap, EINVAL);

	return 0;
}

// Assembly:
pushq %rax
movl 0x2a373(%rip), %edi     # 0x485ec
callq 0x10470
testq %rax, %rax
jne 0x1e287
xorl %eax, %eax
popq %rcx
retq
addq $0xb0, %rax
movq %rax, %rdi
movl $0x16, %esi
callq 0x10030
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/notify.c
// Function: luaopen__cqueues_notify
int luaopen__cqueues_notify(lua_State *L) {
	static const struct {
		const char *name;
		int value;
	} flag[] = {
		{ "CREATE", NOTIFY_CREATE },
		{ "DELETE", NOTIFY_DELETE },
		{ "ATTRIB", NOTIFY_ATTRIB },
		{ "MODIFY", NOTIFY_MODIFY },
		{ "REVOKE", NOTIFY_REVOKE },
		{ "ALL",    NOTIFY_ALL },

		{ "INOTIFY",    NOTIFY_INOTIFY },
		{ "FEN",        NOTIFY_FEN },
		{ "KQUEUE",     NOTIFY_KQUEUE },
		{ "KQUEUE1",    NOTIFY_KQUEUE1 },
		{ "OPENAT",     NOTIFY_OPENAT },
		{ "FDOPENDIR",  NOTIFY_FDOPENDIR},
		{ "O_CLOEXEC",  NOTIFY_O_CLOEXEC },
		{ "IN_CLOEXEC", NOTIFY_IN_CLOEXEC },
	};
	unsigned i;

	if (luaL_newmetatable(L, CQS_NOTIFY)) {
		luaL_setfuncs(L, ln_metatable, 0);

		luaL_newlib(L, ln_methods);
		lua_setfield(L, -2, "__index");
	}

	luaL_newlib(L, ln_globals);

	for (i = 0; i < countof(flag); i++) {
		lua_pushinteger(L, flag[i].value);
		lua_setfield(L, -2, flag[i].name);

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

	lua_pushinteger(L, notify_features());
	lua_setfield(L, -2, "FEATURES");

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x17dcd(%rip), %rsi     # 0x36104
callq 0x10180
testl %eax, %eax
je 0x1e39a
leaq 0x26ce9(%rip), %rsi     # 0x45030
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movsd 0x16ca7(%rip), %xmm0    # 0x35000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x10530
movq %rbx, %rdi
xorl %esi, %esi
movl $0x6, %edx
callq 0x101e0
leaq 0x26cd4(%rip), %rsi     # 0x45050
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
leaq 0x16d9a(%rip), %rdx     # 0x35127
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movsd 0x16c5e(%rip), %xmm0    # 0x35000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x10530
movq %rbx, %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x101e0
leaq 0x26cfb(%rip), %rsi     # 0x450c0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movl $0x8, %r12d
leaq 0x26b74(%rip), %r13     # 0x44f50
movslq (%r12,%r13), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf910
movq -0x8(%r12,%r13), %r15
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0xf530
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf910
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfbd0
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x10260
addq $0x10, %r12
cmpq $0xe8, %r12
jne 0x1e3dc
callq 0xf7f0
movslq %eax, %rsi
movq %rbx, %rdi
callq 0xf910
leaq 0x17a49(%rip), %rdx     # 0x35e90
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/notify.c
// Function: ln__gc
static int ln__gc(lua_State *L) {
	struct luanotify *N = luaL_checkudata(L, 1, CQS_NOTIFY);

	notify_close(N->notify);
	N->notify = 0;

	return 0;
}

// Assembly:
pushq %rbx
leaq 0x17c99(%rip), %rdx     # 0x36104
movl $0x1, %esi
callq 0xfcf0
movq %rax, %rbx
movq (%rax), %rdi
callq 0x106a0
movq $0x0, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/notify.c
// Function: ln_step
static int ln_step(lua_State *L) {
	struct luanotify *N = luaL_checkudata(L, 1, CQS_NOTIFY);
	int error;

	if ((error = notify_step(N->notify, 0))) {
		lua_pushboolean(L, 0);
		lua_pushinteger(L, error);

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

		return 1;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x17c6b(%rip), %rdx     # 0x36104
movl $0x1, %ebp
movl $0x1, %esi
callq 0xfcf0
movq (%rax), %rdi
xorl %esi, %esi
callq 0xfb40
testl %eax, %eax
je 0x1e4d5
movl %eax, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10800
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %ebp
jmp 0x1e4e2
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/notify.c
// Function: ln_get
static int ln_get(lua_State *L) {
	struct luanotify *N = luaL_checkudata(L, 1, CQS_NOTIFY);
	const char *name = 0;
	int changes;

	if (!(changes = notify_get(N->notify, &name)))
		return 0;

	lua_pushinteger(L, changes);
	lua_pushstring(L, name);

	return 2;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x17c0c(%rip), %rdx     # 0x36104
movl $0x1, %esi
callq 0xfcf0
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
movq (%rax), %rdi
callq 0x107e0
testl %eax, %eax
je 0x1e539
movslq %eax, %rsi
movq %rbx, %rdi
callq 0xf910
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xfbd0
movl $0x2, %eax
jmp 0x1e53b
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/notify.c
// Function: ln_add
static int ln_add(lua_State *L) {
	struct luanotify *N = luaL_checkudata(L, 1, CQS_NOTIFY);
	const char *name = luaL_checkstring(L, 2);
	int flags = luaL_optinteger(L, 3, NOTIFY_ALL);
	int error;

	if ((error = notify_add(N->notify, name, flags))) {
		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 %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x17bb2(%rip), %rdx     # 0x36104
movl $0x1, %esi
callq 0xfcf0
movq %rax, %r14
movl $0x2, %ebp
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0xf620
movq %rax, %r15
movl $0x1f, %edx
movq %rbx, %rdi
movl $0x3, %esi
callq 0xf400
movq (%r14), %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0xf230
testl %eax, %eax
je 0x1e5b3
movl %eax, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10800
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0xf910
jmp 0x1e5c5
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/notify.c
// Function: ln_timeout
static int ln_timeout(lua_State *L) {
	struct luanotify *N = luaL_checkudata(L, 1, CQS_NOTIFY);
	int timeout;

	if ((timeout = notify_timeout(N->notify)) >= 0) {
		lua_pushnumber(L, (lua_Number)timeout / 1000);

		return 1;
	} else {
		return 0;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x17aca(%rip), %rdx     # 0x36104
movl $0x1, %ebx
movl $0x1, %esi
callq 0xfcf0
movq (%rax), %rdi
callq 0xf140
testl %eax, %eax
js 0x1e66b
cvtsi2sd %eax, %xmm0
divsd 0x169af(%rip), %xmm0    # 0x35010
movq %r14, %rdi
callq 0xf2c0
jmp 0x1e66d
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/notify.c
// Function: ln_opendir
static int ln_opendir(lua_State *L) {
	const char *path = luaL_checkstring(L, 1);
	struct luanotify *N = 0;
	int error;

	N = lua_newuserdata(L, sizeof *N);
	N->notify = 0;
	luaL_setmetatable(L, CQS_NOTIFY);

	if (!(N->notify = notify_opendir(path, NOTIFY_ALL, &error)))
		goto error;

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

	return 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %ebp
movl $0x1, %esi
xorl %edx, %edx
callq 0xf620
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0xfb00
movq %rax, %r15
movq $0x0, (%rax)
leaq 0x17a51(%rip), %rsi     # 0x36104
movq %rbx, %rdi
callq 0x101f0
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
movl $0x1f, %esi
callq 0xf650
movq %rax, (%r15)
testq %rax, %rax
jne 0x1e6ef
movq %rbx, %rdi
callq 0xf980
movslq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/notify.c
// Function: ln_type
static int ln_type(lua_State *L) {
	if (luaL_testudata(L, 1, CQS_NOTIFY)) {
		lua_pushstring(L, "file notifier");
	} else {
		lua_pushnil(L);
	}

	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x179fd(%rip), %rdx     # 0x36104
movl $0x1, %esi
callq 0x10720
testq %rax, %rax
je 0x1e727
leaq 0x179f6(%rip), %rsi     # 0x36113
movq %rbx, %rdi
callq 0xfbd0
jmp 0x1e72f
movq %rbx, %rdi
callq 0xf980
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/notify.c
// Function: ln_strflag
static int ln_strflag(lua_State *L) {
	int flags = luaL_checkint(L, 1);
	int flag, count = 0;
	const char *name;

	while (ffs(flags)) {
		flag = 1 << (ffs(flags) - 1);
		flags &= ~flag;

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

	return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x10a60
movq %rax, %r14
xorl %ebp, %ebp
testl %r14d, %r14d
je 0x1e821
leaq 0x1772d(%rip), %r15     # 0x35f0a
movl %r14d, %r12d
negl %r12d
andl %r14d, %r12d
movl %r12d, %edi
callq 0xfd10
testq %rax, %rax
je 0x1e813
movq %rax, %r13
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0xfca0
movq %rbx, %rdi
movq %r13, %rsi
callq 0xfbd0
incl %ebp
movl %r12d, %eax
xorl %r14d, %eax
cmpl %r14d, %r12d
movl %eax, %r14d
jne 0x1e7dd
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/notify.c
// Function: ln_flags
static int ln_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, &ln_nxtflag, 1);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xf920
xorl %r14d, %r14d
testl %eax, %eax
jle 0x1e867
xorl %ebp, %ebp
incl %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x10a60
orl %eax, %ebp
movq %rbx, %rdi
callq 0xf920
cmpl %eax, %r14d
jl 0x1e847
movslq %ebp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf910
leaq 0x17(%rip), %rsi        # 0x1e890
movq %rbx, %rdi
movl $0x1, %edx
callq 0x109f0
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/notify.c
// Function: ln_nxtflag
static int ln_nxtflag(lua_State *L) {
	int flags = (int)lua_tointeger(L, lua_upvalueindex(1));
	int flag;

	if (ffs(flags)) {
		flag = 1 << (ffs(flags) - 1);

		lua_pushinteger(L, flags & ~flag);
		lua_replace(L, lua_upvalueindex(1));

		lua_pushinteger(L, flag);

		return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
xorl %edx, %edx
callq 0xfd20
testl %eax, %eax
je 0x1e8ed
movl %eax, %ebp
negl %ebp
andl %eax, %ebp
xorl %ebp, %eax
movslq %eax, %rsi
movq %rbx, %rdi
callq 0xf910
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfff0b9d7, %edx       # imm = 0xFFF0B9D7
callq 0xfcc0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x1, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/dns.c
// Function: rr_type
static int rr_type(lua_State *L) {
	unsigned i;

	lua_settop(L, 2);
	lua_pushnil(L); /* default result */

	if (lua_isuserdata(L, 2)) {
		for (i = 0; i < countof(rrinfo); i++) {
			if (!rrinfo[i].tname)
				continue;
			if (!luaL_testudata(L, 2, rrinfo[i].tname)
			&&  !luaL_testudata(L, 2, RR_ANY_CLASS))
				continue;

			lua_pushstring(L, "dns record");

			break;
		}
	}

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2, %esi
callq 0x10640
movq %rbx, %rdi
callq 0xf980
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10690
testl %eax, %eax
je 0x1f016
xorl %r15d, %r15d
leaq 0x2701f(%rip), %r12     # 0x45fe0
leaq 0x172f3(%rip), %r14     # 0x362bb
movq (%r15,%r12), %rdx
testq %rdx, %rdx
je 0x1eff8
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10720
testq %rax, %rax
jne 0x1f007
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x10720
testq %rax, %rax
jne 0x1f007
addq $0x10, %r15
cmpq $0x640, %r15            # imm = 0x640
jne 0x1efc8
jmp 0x1f016
leaq 0x173e1(%rip), %rsi     # 0x363ef
movq %rbx, %rdi
callq 0xfbd0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq