LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/signal.c
// Function: signal_flags
static int signal_flags(int *flags) {
	while (0xFFFFFFFF & *flags) {
		int flag = 1 << (ffs(0xFFFFFFFF & *flags) - 1);
		*flags &= ~flag;
		if (signal_strflag(flag))
			return flag;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x0, %eax
je 0x22fa2
movq -0x10(%rbp), %rax
movl (%rax), %edi
andl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x10650
movl %eax, %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
xorl $-0x1, %ecx
movq -0x10(%rbp), %rax
andl (%rax), %ecx
movl %ecx, (%rax)
movl -0x14(%rbp), %edi
callq 0x22fc0
cmpq $0x0, %rax
je 0x22fa0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x22fa9
jmp 0x22f4c
movl $0x0, -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/signal.c
// Function: signal_strflag
static const char *signal_strflag(int flag) {
	static const char *const table[32] = {
		[0] = "signalfd", "EVFILT_SIGNAL", "sigtimedwait",
		      "kqueue", "kqueue1",
	};
	int i = ffs(0xFFFFFFFF & flag);
	return (i)? table[i - 1] : NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
andl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x10650
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x22ffc
movl -0x8(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x36fae(%rip), %rax     # 0x59fa0
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0x23004
xorl %eax, %eax
movq %rax, -0x10(%rbp)
jmp 0x23004
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
xorl %eax, %eax
movl %eax, %edx
callq 0xfe30
movl %eax, -0x14(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x22f40
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x23086
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0xf9a0
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfff0b9d7, %edx       # imm = 0xFFF0B9D7
callq 0xfdd0
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x107f0
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0xf9a0
movl $0x1, -0x4(%rbp)
jmp 0x2308d
movl $0x0, -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/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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
callq 0x231d0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x23161
cmpl $-0x1, -0x14(%rbp)
jne 0x23106
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
callq 0xfd50
movq -0xa0(%rbp), %rdi
movq %rax, %rdx
leaq 0x2602a(%rip), %rsi     # 0x49121
movb $0x0, %al
callq 0xfe70
movl %eax, -0x4(%rbp)
jmp 0x231c1
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xac(%rbp)
leaq -0x94(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movl -0xac(%rbp), %edi
leaq -0x94(%rbp), %rsi
movl $0x80, %edx
callq 0xf270
movq -0xa8(%rbp), %rdi
movq %rax, %rdx
leaq 0x25fcc(%rip), %rsi     # 0x49121
movb $0x0, %al
callq 0xfe70
movl %eax, -0x4(%rbp)
jmp 0x231c1
movq -0x10(%rbp), %rdi
leaq 0x26028(%rip), %rsi     # 0x49194
leaq 0x36f2d(%rip), %rdx     # 0x5a0a0
leaq 0x36f76(%rip), %rcx     # 0x5a0f0
xorl %r8d, %r8d
callq 0x232f0
movq -0x10(%rbp), %rdi
movsd 0x24e72(%rip), %xmm0    # 0x48000
movl $0x88, %esi
callq 0x106d0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x10330
movq -0x10(%rbp), %rdi
leaq 0x36f6d(%rip), %rsi     # 0x5a120
xorl %edx, %edx
callq 0x10390
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/thread.c
// Function: ct_protectssl
static int ct_protectssl(void) {
	static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
	int bound = 0, error = 0;

	pthread_mutex_lock(&mutex);

	if (!CRYPTO_get_locking_callback()) {
		if (!openssl.lock) {
			int i;

			openssl.count = CRYPTO_num_locks();

			if (!(openssl.lock = malloc(openssl.count * sizeof *openssl.lock))) {
				error = errno;
				goto leave;
			}

			for (i = 0; i < openssl.count; i++) {
				pthread_mutex_init(&openssl.lock[i], NULL);
			}
		}

		CRYPTO_set_locking_callback(&ct_lockssl);
		bound = 1;
	}

	if (!CRYPTO_get_id_callback()) {
		CRYPTO_set_id_callback(&ct_selfid);
		bound = 1;
	}

	/*
	 * Prevent loader from unlinking us if we've registered a callback
	 * with OpenSSL.
	 */
	if (bound && !openssl.dlref) {
		Dl_info info;

		if (!dladdr(EXTENSION (void *)&luaopen__cqueues_thread, &info)) {
			error = -1;
			goto leave;
		}

		if (!(openssl.dlref = dlopen(info.dli_fname, RTLD_NOW|RTLD_LOCAL))) {
			error = -1;
			goto leave;
		}
	}

leave:
	pthread_mutex_unlock(&mutex);

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
leaq 0x3a77b(%rip), %rdi     # 0x5d968
callq 0x10510
cmpq $0x0, 0x3a796(%rip)     # 0x5d990
jne 0x2326c
movl $0x1, 0x3a792(%rip)     # 0x5d998
movslq 0x3a78b(%rip), %rax     # 0x5d998
imulq $0x28, %rax, %rdi
callq 0x10260
movq %rax, 0x3a773(%rip)     # 0x5d990
cmpq $0x0, %rax
jne 0x23232
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x8(%rbp)
jmp 0x232d0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x3a756(%rip), %eax     # 0x5d998
jge 0x2326a
movq 0x3a745(%rip), %rdi     # 0x5d990
movslq -0xc(%rbp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10560
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x23239
jmp 0x2326c
movl $0x1, -0x4(%rbp)
movl $0x1, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x232ce
cmpq $0x0, 0x3a718(%rip)     # 0x5d9a0
jne 0x232ce
movq 0x38d47(%rip), %rdi     # 0x5bfd8
leaq -0x30(%rbp), %rsi
callq 0xf640
cmpl $0x0, %eax
jne 0x232a8
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
jmp 0x232d0
movq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x10370
movq %rax, 0x3a6e3(%rip)     # 0x5d9a0
cmpq $0x0, %rax
jne 0x232cc
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
jmp 0x232d0
jmp 0x232ce
jmp 0x232d0
leaq 0x3a691(%rip), %rdi     # 0x5d968
callq 0xfa40
movl -0x8(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x23630
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
callq 0xfc80
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x10960
cmpl $0x0, %eax
je 0x234aa
movq -0x10(%rbp), %rdi
leaq 0x25d09(%rip), %rsi     # 0x491a4
movb $0x0, %al
callq 0xfe70
movl %eax, -0x4(%rbp)
jmp 0x23577
movq -0x18(%rbp), %rax
movl 0x1a8(%rax), %edi
movb $0x0, -0x1d(%rbp)
leaq -0x1d(%rbp), %rsi
movl $0x1, %edx
callq 0x10470
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x2352d
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x109d0
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x234fb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rsi
callq 0xf9a0
jmp 0x23524
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x23519
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xfcc0
jmp 0x23522
movq -0x10(%rbp), %rdi
callq 0xfa10
jmp 0x23524
movl $0x2, -0x4(%rbp)
jmp 0x23577
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0xb, -0x1c(%rbp)
jne 0x23558
movq -0x18(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
callq 0x236a0
testb $0x1, %al
jne 0x23558
movl $0x82, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x109d0
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xf9a0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/thread.c
// Function: hdl_isheld
static _Bool hdl_isheld(struct cthread_handle *h) {
#if ENABLE_PTHREAD_MUTEX_ROBUST
	int error;

	switch ((error = pthread_mutex_trylock(&h->hold))) {
	case EBUSY:
		return 1;
	case EOWNERDEAD:
		pthread_mutex_consistent(&h->hold);
		/* FALL THROUGH */
	case 0:
		pthread_mutex_unlock(&h->hold);

		return 0;
	default:
		return 1;
	}
#else
	return h->held;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xf210
movl %eax, -0x14(%rbp)
movl %eax, %ecx
movl %ecx, -0x18(%rbp)
testl %eax, %eax
je 0x236f0
jmp 0x236c7
movl -0x18(%rbp), %eax
subl $0x10, %eax
je 0x236dd
jmp 0x236d1
movl -0x18(%rbp), %eax
subl $0x82, %eax
je 0x236e3
jmp 0x23703
movb $0x1, -0x1(%rbp)
jmp 0x23707
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xfc10
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xfa40
movb $0x0, -0x1(%rbp)
jmp 0x23707
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x25a58(%rip), %rdx     # 0x49194
callq 0x108e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x25a3f(%rip), %rdx     # 0x49194
callq 0x108e0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x23792
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x23792
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
sete %al
movb %al, -0x19(%rbp)
movq -0x28(%rbp), %rdi
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x109d0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x259c8(%rip), %rdx     # 0x49194
callq 0xfe00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x23800
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/thread.c
// Function: ct_release
static void ct_release(struct cthread *ct) {
	_Bool destroy;
	struct cthread_lib *ent, *nxt;

	pthread_mutex_lock(&ct->mutex);
	destroy = !--ct->refs;
	pthread_mutex_unlock(&ct->mutex);

	if (!destroy)
		return;

	hdl_destroy(&ct->handle);

	pthread_attr_destroy(&ct->attr);
	pthread_cond_destroy(&ct->cond);
	pthread_mutex_destroy(&ct->mutex);

	cqs_closefd(&ct->pipe[0]);
	cqs_closefd(&ct->pipe[1]);

	for (ent = LLRB_MIN(libs, &ct->libs); ent; ent = nxt) {
		nxt = LLRB_NEXT(libs, &ct->libs, ent);
		LLRB_REMOVE(libs, &ct->libs, ent);
		dlclose(ent->ref);
		free(ent);
	}

	cqs_closefd(&ct->tmp.fd[0]);
	cqs_closefd(&ct->tmp.fd[1]);

	free(ct->tmp.arg);

	free(ct->msg);
	free(ct);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x10510
movq -0x8(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0xfa40
testb $0x1, -0x9(%rbp)
jne 0x23849
jmp 0x23952
movq -0x8(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
callq 0x23960
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
callq 0x10870
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x10bb0
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x10010
movq -0x8(%rbp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0x23980
movq -0x8(%rbp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
addq $0x4, %rdi
callq 0x23980
movq -0x8(%rbp), %rax
movq 0x1b0(%rax), %rdi
callq 0x239b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x23900
movq -0x18(%rbp), %rdi
callq 0x239f0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
movq -0x18(%rbp), %rsi
callq 0x23ab0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xfb00
movq -0x18(%rbp), %rdi
callq 0x10060
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x238b8
movq -0x8(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
addq $0xc, %rdi
callq 0x23980
movq -0x8(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
addq $0xc, %rdi
addq $0x4, %rdi
callq 0x23980
movq -0x8(%rbp), %rax
movq 0x1b8(%rax), %rdi
callq 0x10060
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10060
movq -0x8(%rbp), %rdi
callq 0x10060
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/thread.c
// Function: lib_cmp
static int lib_cmp(struct cthread_lib *a, struct cthread_lib *b) {
	if ((intptr_t)a->info.dli_fbase < (intptr_t)b->info.dli_fbase)
		return -1;
	if ((intptr_t)a->info.dli_fbase > (intptr_t)b->info.dli_fbase)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq %rcx, %rax
jge 0x23e2a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x23e4f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq %rcx, %rax
jle 0x23e48
movl $0x1, -0x4(%rbp)
jmp 0x23e4f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x249b8(%rip), %rdx     # 0x49194
callq 0x108e0
cmpq $0x0, %rax
je 0x247f9
movq -0x8(%rbp), %rdi
leaq 0x24a52(%rip), %rsi     # 0x49244
callq 0xfcc0
jmp 0x24802
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/thread.c
// Function: ct_create
static struct cthread *ct_create(int *_error) {
	struct cthread *ct = NULL;
	int error;

	if (!(ct = calloc(1, sizeof *ct)))
		goto syerr;

	if ((error = ct_init(ct))) {
		free(ct);
		ct = NULL;
		goto error;
	}

	if ((error = pthread_attr_setdetachstate(&ct->attr, PTHREAD_CREATE_DETACHED)))
		goto error;

	if ((error = cqs_pipe(ct->pipe, O_NONBLOCK|O_CLOEXEC)))
		goto error;

	return ct;
syerr:
	error = errno;
error:
	*_error = error;

	ct_release(ct);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x1, %edi
movl $0x1d0, %esi            # imm = 0x1D0
callq 0xf930
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2489f
jmp 0x24908
movq -0x18(%rbp), %rdi
callq 0x25070
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x248c3
movq -0x18(%rbp), %rdi
callq 0x10060
movq $0x0, -0x18(%rbp)
jmp 0x24912
movq -0x18(%rbp), %rdi
addq $0x78, %rdi
movl $0x1, %esi
callq 0x10220
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x248df
jmp 0x24912
movq -0x18(%rbp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
movl $0x80800, %esi          # imm = 0x80800
callq 0x251d0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x248fe
jmp 0x24912
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2492c
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x23800
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.h
// Function: cqs_socketpair
static inline int cqs_socketpair(int family, int type, int proto, int fd[2], int flags) {
#if defined SOCK_NONBLOCK && defined SOCK_CLOEXEC
	if (flags & O_NONBLOCK)
		type |= SOCK_NONBLOCK;
	if (flags & O_CLOEXEC)
		type |= SOCK_CLOEXEC;

	if (0 != socketpair(family, type, proto, fd))
		return errno;

	return 0;
#else
	int error;

	if (0 != socketpair(family, type, proto, fd))
		return errno;

	if ((error = cqs_setfd(fd[0], flags)) || (error = cqs_setfd(fd[1], flags)))
		return error;

	return 0;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x24b41
movl -0xc(%rbp), %eax
orl $0x800, %eax            # imm = 0x800
movl %eax, -0xc(%rbp)
movl -0x1c(%rbp), %eax
andl $0x80000, %eax          # imm = 0x80000
cmpl $0x0, %eax
je 0x24b59
movl -0xc(%rbp), %eax
orl $0x80000, %eax          # imm = 0x80000
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0xfc40
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x24b7f
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x24b86
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/thread.c
// Function: ct_init
static int ct_init(struct cthread *ct) {
	int progress = 0;
	int error;

	ct->refs = 1;

	ct->pipe[0] = -1;
	ct->pipe[1] = -1;

	ct->tmp.fd[0] = -1;
	ct->tmp.fd[1] = -1;

	if ((error = pthread_mutex_init(&ct->mutex, NULL)))
		goto error;

	progress++;

	if ((error = pthread_cond_init(&ct->cond, NULL)))
		goto error;

	progress++;

	if ((error = pthread_attr_init(&ct->attr)))
		goto error;

	progress++;

	if ((error = hdl_init(&ct->handle)))
		goto error;

	progress++;

	return 0;
error:
	switch (progress) {
	case 4:
		hdl_destroy(&ct->handle);
		/* FALL THROUGH */
	case 3:
		pthread_attr_destroy(&ct->attr);
		/* FALL THROUGH */
	case 2:
		pthread_cond_destroy(&ct->cond);
		/* FALL THROUGH */
	case 1:
		pthread_mutex_destroy(&ct->mutex);
		/* FALL THROUGH */
	case 0:
		break;
	}

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x1a8(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x1ac(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x1c4(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x1c8(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10560
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x250e0
jmp 0x25159
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x100c0
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x25104
jmp 0x25159
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
addq $0x78, %rdi
callq 0x100d0
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x25124
jmp 0x25159
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
callq 0x25210
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x25147
jmp 0x25159
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x4(%rbp)
jmp 0x251b9
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x4, %rax
ja 0x251b3
movq -0x20(%rbp), %rax
leaq 0x2400b(%rip), %rcx     # 0x4917c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
callq 0x23960
movq -0x10(%rbp), %rdi
addq $0x78, %rdi
callq 0x10870
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x10bb0
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x10010
jmp 0x251b3
movl -0x18(%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/cqueues.h
// Function: cqs_pipe
static inline int cqs_pipe(int fd[2], int flags) {
#if HAVE_PIPE2
	if (0 != pipe2(fd, flags))
		return errno;

	return 0;
#else
	int error;

	if (0 != pipe(fd))
		return errno;

	if ((error = cqs_setfd(fd[0], flags)) || (error = cqs_setfd(fd[1], flags)))
		return error;

	return 0;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xf910
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x251ff
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x25206
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/thread.c
// Function: hdl_init
static int hdl_init(struct cthread_handle *h) {
#if ENABLE_PTHREAD_MUTEX_ROBUST
	pthread_mutexattr_t attr;
	int error;

	h->held = 0;

	if ((error = pthread_mutexattr_init(&attr)))
		return error;

	if ((error = pthread_mutexattr_setrobust(&attr, PTHREAD_MUTEX_ROBUST)))
		goto error;

	if ((error = pthread_mutex_init(&h->hold, &attr)))
		goto error;

	pthread_mutexattr_destroy(&attr);

	return 0;
error:
	pthread_mutexattr_destroy(&attr);

	return error;
#else
	h->held = 0;

	return 0;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
leaq -0x14(%rbp), %rdi
callq 0xf0c0
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x2523f
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x25293
leaq -0x14(%rbp), %rdi
movl $0x1, %esi
callq 0xfbc0
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x25257
jmp 0x25284
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
leaq -0x14(%rbp), %rsi
callq 0x10560
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x25272
jmp 0x25284
leaq -0x14(%rbp), %rdi
callq 0x10550
movl $0x0, -0x4(%rbp)
jmp 0x25293
leaq -0x14(%rbp), %rdi
callq 0x10550
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/thread.c
// Function: ct_addfunc
static int ct_addfunc(struct cthread *ct, lua_CFunction f) {
	struct cthread_lib key, *ent;
	void *ref = NULL;

	if (!dladdr(EXTENSION (void *)f, &key.info))
		goto dlerr;

	if ((ent = LLRB_FIND(libs, &ct->libs, &key)))
		return 0;

	if (!(ref = dlopen(key.info.dli_fname, RTLD_NOW|RTLD_LOCAL)))
		goto dlerr;

	if (!(ent = calloc(1, sizeof *ent)))
		goto syerr;

	ent->info = key.info;
	ent->ref = ref;

	LLRB_INSERT(libs, &ct->libs, ent);

	return 0;
dlerr:
	return -1;
syerr:
	if (ref)
		dlclose(ref);

	return errno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x70(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xf640
cmpl $0x0, %eax
jne 0x252cf
jmp 0x2537a
movq -0x10(%rbp), %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
leaq -0x60(%rbp), %rsi
callq 0x253f0
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x252f9
movl $0x0, -0x4(%rbp)
jmp 0x2539d
movq -0x60(%rbp), %rdi
movl $0x2, %esi
callq 0x10370
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
jne 0x25313
jmp 0x2537a
movl $0x1, %edi
movl $0x48, %esi
callq 0xf930
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
jne 0x2532e
jmp 0x25383
movq -0x68(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
movq -0x58(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x70(%rbp), %rcx
movq -0x68(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
movq -0x68(%rbp), %rsi
callq 0x25470
movl $0x0, -0x4(%rbp)
jmp 0x2539d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2539d
cmpq $0x0, -0x70(%rbp)
je 0x25393
movq -0x70(%rbp), %rdi
callq 0xfb00
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/thread.c
// Function: hdl_hold
static int hdl_hold(struct cthread_handle *h) {
#if ENABLE_PTHREAD_MUTEX_ROBUST
	int error;

	if ((error = pthread_mutex_lock(&h->hold)))
		return error;
#endif
	h->held = 1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x10510
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x25669
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2567a
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, -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/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0x3829a(%rip), %edi     # 0x5d95c
callq 0x105f0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x256e6
movq -0x10(%rbp), %rdi
addq $0xb0, %rdi
movl $0x16, %esi
callq 0x10170
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/cqueues.h
// Function: cqs_openlibs
static void cqs_openlibs(lua_State *L) {
	int top = lua_gettop(L);

	cqs_requiref(L, "_cqueues", &luaopen__cqueues, 0);
	cqs_requiref(L, "_cqueues.errno", &luaopen__cqueues_errno, 0);
	cqs_requiref(L, "_cqueues.socket", &luaopen__cqueues_socket, 0);
	cqs_requiref(L, "_cqueues.signal", &luaopen__cqueues_signal, 0);
	cqs_requiref(L, "_cqueues.thread", &luaopen__cqueues_thread, 0);
	cqs_requiref(L, "_cqueues.notify", &luaopen__cqueues_notify, 0);
#if 0 /* Make optional? */
	cqs_requiref(L, "_cqueues.condition", &luaopen__cqueues_condition, 0);
	cqs_requiref(L, "_cqueues.dns.record", &luaopen__cqueues_dns_record, 0);
	cqs_requiref(L, "_cqueues.dns.packet", &luaopen__cqueues_dns_packet, 0);
	cqs_requiref(L, "_cqueues.dns.config", &luaopen__cqueues_dns_config, 0);
	cqs_requiref(L, "_cqueues.dns.hosts", &luaopen__cqueues_dns_hosts, 0);
	cqs_requiref(L, "_cqueues.dns.hints", &luaopen__cqueues_dns_hints, 0);
	cqs_requiref(L, "_cqueues.dns.resolver", &luaopen__cqueues_dns_resolver, 0);
	cqs_requiref(L, "_cqueues.dns", &luaopen__cqueues_dns, 0);
#endif

	lua_settop(L, top);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf9b0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x23b00(%rip), %rsi     # 0x49213
movq 0x3684e(%rip), %rdx     # 0x5bf68
xorl %ecx, %ecx
callq 0x257b0
movq -0x8(%rbp), %rdi
leaq 0x23af0(%rip), %rsi     # 0x4921c
movq 0x3689d(%rip), %rdx     # 0x5bfd0
xorl %ecx, %ecx
callq 0x257b0
movq -0x8(%rbp), %rdi
leaq 0x22998(%rip), %rsi     # 0x480dd
movq 0x3684c(%rip), %rdx     # 0x5bf98
xorl %ecx, %ecx
callq 0x257b0
movq -0x8(%rbp), %rdi
leaq 0x23acd(%rip), %rsi     # 0x4922b
movq 0x3682b(%rip), %rdx     # 0x5bf90
xorl %ecx, %ecx
callq 0x257b0
movq -0x8(%rbp), %rdi
leaq 0x23ac4(%rip), %rsi     # 0x4923b
movq 0x3685a(%rip), %rdx     # 0x5bfd8
xorl %ecx, %ecx
callq 0x257b0
movq -0x8(%rbp), %rdi
leaq 0x23abb(%rip), %rsi     # 0x4924b
movq 0x36849(%rip), %rdx     # 0x5bfe0
xorl %ecx, %ecx
callq 0x257b0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x107f0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x237f8(%rip), %rdx     # 0x492b4
callq 0xfe00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x10850
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x237a8(%rip), %rdx     # 0x492b4
callq 0xfe00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0xfc20
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x25b4c
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x109d0
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xf9a0
movl $0x2, -0x4(%rbp)
jmp 0x25b61
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x109d0
movl $0x1, -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/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x23728(%rip), %rdx     # 0x492b4
callq 0xfe00
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x109b0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jne 0x25bbe
movl $0x0, -0x4(%rbp)
jmp 0x25bdf
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0xf9a0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xfcc0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x236a8(%rip), %rdx     # 0x492b4
callq 0xfe00
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xf6a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
movl $0x1f, %edx
callq 0xf450
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0xf250
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
je 0x25c7d
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x109d0
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0xf9a0
movl $0x2, -0x4(%rbp)
jmp 0x25c92
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x109d0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x23568(%rip), %rdx     # 0x492b4
callq 0xfe00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0xf160
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jl 0x25d8c
movq -0x10(%rbp), %rdi
cvtsi2sdl -0x1c(%rbp), %xmm0
movsd 0x222b6(%rip), %xmm1    # 0x48030
divsd %xmm1, %xmm0
callq 0xf300
movl $0x1, -0x4(%rbp)
jmp 0x25d93
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xf6a0
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0xfbe0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq 0x234c2(%rip), %rsi     # 0x492b4
callq 0x10340
movq -0x18(%rbp), %rdi
movl $0x1f, %esi
leaq -0x24(%rbp), %rdx
callq 0xf6d0
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x25e18
jmp 0x25e21
movl $0x1, -0x4(%rbp)
jmp 0x25e3e
movq -0x10(%rbp), %rdi
callq 0xfa10
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0xf9a0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x23448(%rip), %rdx     # 0x492b4
callq 0x108e0
cmpq $0x0, %rax
je 0x25e89
movq -0x8(%rbp), %rdi
leaq 0x23441(%rip), %rsi     # 0x492c3
callq 0xfcc0
jmp 0x25e92
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/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x10c70
movl %eax, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl -0xc(%rbp), %edi
callq 0x10650
cmpl $0x0, %eax
je 0x25f63
movl -0xc(%rbp), %edi
callq 0x10650
movl %eax, %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
xorl $-0x1, %eax
andl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %edi
callq 0xfe20
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x25f61
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x23170(%rip), %rdx     # 0x490b6
callq 0xfdb0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xfcc0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x25ef4
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
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 0x25fbf
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 0x25f8a
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0xf9a0
movq -0x8(%rbp), %rdi
leaq 0xb9(%rip), %rsi        # 0x26090
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/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
xorl %eax, %eax
movl %eax, %edx
callq 0xfe30
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x10650
cmpl $0x0, %eax
je 0x26123
movl -0x14(%rbp), %edi
callq 0x10650
movl %eax, %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movslq %eax, %rsi
callq 0xf9a0
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfff0b9d7, %edx       # imm = 0xFFF0B9D7
callq 0xfdd0
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x107f0
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0xf9a0
movl $0x1, -0x4(%rbp)
jmp 0x2612a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/dns.c
// Function: luaopen__cqueues_dns_record
int luaopen__cqueues_dns_record(lua_State *L) {
	static const struct cqs_macro classes[] = {
		{ "IN", DNS_C_IN }, { "ANY", DNS_C_ANY },
	};
	static const struct cqs_macro types[] = {
		{ "A",     DNS_T_A },     { "NS",   DNS_T_NS },
		{ "CNAME", DNS_T_CNAME }, { "SOA",  DNS_T_SOA },
		{ "PTR",   DNS_T_PTR },   { "MX",   DNS_T_MX },
		{ "TXT",   DNS_T_TXT },   { "AAAA", DNS_T_AAAA },
		{ "SRV",   DNS_T_SRV },   { "OPT",  DNS_T_OPT },
		{ "SSHFP", DNS_T_SSHFP }, { "SPF",  DNS_T_SPF },
		{ "ALL",   DNS_T_ALL },
	};
	static const struct cqs_macro sshfp[] = {
		{ "RSA",  DNS_SSHFP_RSA }, { "DSA", DNS_SSHFP_DSA },
		{ "SHA1", DNS_SSHFP_SHA1 },
	};

	rr_loadall(L);

	luaL_newlib(L, rr_globals);

	lua_createtable(L, 0, countof(classes));
	cqs_setmacros(L, -1, classes, countof(classes), 1);
	lua_setfield(L, -2, "class");

	lua_createtable(L, 0, countof(types));
	cqs_setmacros(L, -1, types, countof(types), 1);
	lua_createtable(L, 0, 1);
	lua_pushcfunction(L, &rr_type);
	lua_setfield(L, -2, "__call");
	lua_setmetatable(L, -2);
	lua_setfield(L, -2, "type");

	lua_createtable(L, 0, countof(sshfp));
	cqs_setmacros(L, -1, sshfp, countof(sshfp), 1);
	lua_setfield(L, -2, "sshfp");

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x262b0
movq -0x8(%rbp), %rdi
movsd 0x21e9f(%rip), %xmm0    # 0x48000
movl $0x88, %esi
callq 0x106d0
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x10330
movq -0x8(%rbp), %rdi
leaq 0x235bd(%rip), %rsi     # 0x49740
xorl %edx, %edx
callq 0x10390
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x10330
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x34196(%rip), %rdx     # 0x5a340
movl $0x2, %ecx
movl $0x1, %r8d
callq 0x26490
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x23127(%rip), %rdx     # 0x492f1
callq 0xf580
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0xd, %edx
callq 0x10330
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x34171(%rip), %rdx     # 0x5a360
movl $0xd, %ecx
movl $0x1, %r8d
callq 0x26490
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x10330
movq -0x8(%rbp), %rdi
leaq 0x376(%rip), %rsi       # 0x26590
xorl %edx, %edx
callq 0x10bf0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x21f80(%rip), %rdx     # 0x481b1
callq 0xf580
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10b10
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x270da(%rip), %rdx     # 0x4d32e
callq 0xf580
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x10330
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x341b7(%rip), %rdx     # 0x5a430
movl $0x3, %ecx
movl $0x1, %r8d
callq 0x26490
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x2305e(%rip), %rdx     # 0x492f7
callq 0xf580
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x107f0
movq -0x8(%rbp), %rdi
callq 0xfa10
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x10840
cmpl $0x0, %eax
je 0x26662
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpq $0x64, %rax
jae 0x26660
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x34c26(%rip), %rax     # 0x5b210
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x265f9
jmp 0x26652
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x34c07(%rip), %rax     # 0x5b210
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movl $0x2, %esi
callq 0x108e0
cmpq $0x0, %rax
jne 0x26640
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x22e38(%rip), %rdx     # 0x4946b
callq 0x108e0
cmpq $0x0, %rax
jne 0x26640
jmp 0x26652
movq -0x8(%rbp), %rdi
leaq 0x22f54(%rip), %rsi     # 0x4959f
callq 0xfcc0
jmp 0x26660
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x265d1
jmp 0x26662
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/dns.c
// Function: luaopen__cqueues_dns_config
int luaopen__cqueues_dns_config(lua_State *L) {
	cqs_newmetatable(L, RESCONF_CLASS, resconf_methods, resconf_metatable, 0);

	luaL_newlib(L, resconf_globals);

	lua_pushinteger(L, DNS_RESCONF_TCP_ENABLE);
	lua_setfield(L, -2, "TCP_ENABLE");

	lua_pushinteger(L, DNS_RESCONF_TCP_ONLY);
	lua_setfield(L, -2, "TCP_ONLY");

	lua_pushinteger(L, DNS_RESCONF_TCP_DISABLE);
	lua_setfield(L, -2, "TCP_DISABLE");

	lua_pushinteger(L, RESCONF_RESOLV_CONF);
	lua_setfield(L, -2, "RESOLV_CONF");

	lua_pushinteger(L, RESCONF_NSSWITCH_CONF);
	lua_setfield(L, -2, "NSSWITCH_CONF");

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x22aa0(%rip), %rsi     # 0x493b7
leaq 0x33dd2(%rip), %rdx     # 0x5a6f0
leaq 0x33eab(%rip), %rcx     # 0x5a7d0
xorl %r8d, %r8d
callq 0x267e0
movq -0x8(%rbp), %rdi
movsd 0x216c7(%rip), %xmm0    # 0x48000
movl $0x88, %esi
callq 0x106d0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x10330
movq -0x8(%rbp), %rdi
leaq 0x33ea2(%rip), %rsi     # 0x5a800
xorl %edx, %edx
callq 0x10390
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x22a40(%rip), %rdx     # 0x493c2
callq 0xf580
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x22a28(%rip), %rdx     # 0x493cd
callq 0xf580
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x22a0e(%rip), %rdx     # 0x493d6
callq 0xf580
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x229f8(%rip), %rdx     # 0x493e2
callq 0xf580
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x229e1(%rip), %rdx     # 0x493ee
callq 0xf580
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/dns.c
// Function: luaopen__cqueues_dns_hosts
int luaopen__cqueues_dns_hosts(lua_State *L) {
	// not needed until dns_hosts_query bound
	//cqs_requiref(L, "_cqueues.dns.packet", &luaopen__cqueues_dns_packet, 0);

	cqs_newmetatable(L, HOSTS_CLASS, hosts_methods, hosts_metatable, 0);

	luaL_newlib(L, hosts_globals);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x229c5(%rip), %rsi     # 0x493fc
leaq 0x33e22(%rip), %rdx     # 0x5a860
leaq 0x33e5b(%rip), %rcx     # 0x5a8a0
xorl %r8d, %r8d
callq 0x267e0
movq -0x8(%rbp), %rdi
movsd 0x215a7(%rip), %xmm0    # 0x48000
movl $0x88, %esi
callq 0x106d0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x10330
movq -0x8(%rbp), %rdi
leaq 0x33e52(%rip), %rsi     # 0x5a8d0
xorl %edx, %edx
callq 0x10390
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/dns.c
// Function: luaopen__cqueues_dns_hints
int luaopen__cqueues_dns_hints(lua_State *L) {
	cqs_newmetatable(L, HINTS_CLASS, hints_methods, hints_metatable, 0);

	cqs_requiref(L, "_cqueues.dns.config", &luaopen__cqueues_dns_config, 0);
	// not needed until dns_hints_query bound
	//cqs_requiref(L, "_cqueues.dns.packet", &luaopen__cqueues_dns_packet, 0);

	luaL_newlib(L, hints_globals);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2295f(%rip), %rsi     # 0x49406
leaq 0x33e62(%rip), %rdx     # 0x5a910
leaq 0x33e8b(%rip), %rcx     # 0x5a940
xorl %r8d, %r8d
callq 0x267e0
movq -0x8(%rbp), %rdi
leaq 0x22948(%rip), %rsi     # 0x49410
movq 0x354b9(%rip), %rdx     # 0x5bf88
xorl %ecx, %ecx
callq 0x26b20
movq -0x8(%rbp), %rdi
movsd 0x2151e(%rip), %xmm0    # 0x48000
movl $0x88, %esi
callq 0x106d0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x10330
movq -0x8(%rbp), %rdi
leaq 0x33e69(%rip), %rsi     # 0x5a970
xorl %edx, %edx
callq 0x10390
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)