LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x1c7a5
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 0x1c783
movl $0x1, %ebp
movq %rsp, %rsi
movl $0x1, %edi
xorl %edx, %edx
callq 0x10510
testl %eax, %eax
je 0x1c80b
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 0x19767(%rip), %rsi     # 0x35f61
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfd60
movl %eax, %ebp
jmp 0x1c818
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_O3/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 0x1c856
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 0x1c837
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_O3/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 %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
xorl %edx, %edx
callq 0xfd20
testl %eax, %eax
je 0x1c912
leaq 0x284c9(%rip), %rcx     # 0x44d80
movl %eax, %ebp
negl %ebp
andl %eax, %ebp
movl %ebp, %edx
xorl %eax, %edx
testl %ebp, %ebp
je 0x1c8cf
bsfl %eax, %esi
cmpq $0x0, (%rcx,%rsi,8)
jne 0x1c8d7
cmpl %eax, %ebp
movl %edx, %eax
jne 0x1c8b7
jmp 0x1c912
movslq %edx, %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
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x2bcc9(%rip), %rdi     # 0x485f8
callq 0x103b0
cmpq $0x0, 0x2bce4(%rip)     # 0x48620
jne 0x1c95e
movl $0x28, %edi
callq 0x10110
movq %rax, 0x2bcd1(%rip)     # 0x48620
testq %rax, %rax
je 0x1c9a8
movq %rax, %rdi
xorl %esi, %esi
callq 0x103f0
cmpq $0x0, 0x2bcc2(%rip)     # 0x48628
je 0x1c976
leaq 0x2bc89(%rip), %rdi     # 0x485f8
callq 0xf9b0
jmp 0x1c9d9
movq 0x2a663(%rip), %rdi     # 0x46fe0
movq %rsp, %rsi
callq 0xf5c0
testl %eax, %eax
je 0x1c9b1
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x10220
movq %rax, 0x2bc8a(%rip)     # 0x48628
xorl %ebp, %ebp
cmpq $0x1, %rax
sbbl %ebp, %ebp
jmp 0x1c9b6
callq 0xf0a0
movl (%rax), %ebp
jmp 0x1c9b6
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x2bc3b(%rip), %rdi     # 0x485f8
callq 0xf9b0
testl %ebp, %ebp
je 0x1c9d9
cmpl $-0x1, %ebp
jne 0x1ca69
callq 0xfc50
jmp 0x1ca9c
leaq 0x195cc(%rip), %rsi     # 0x35fac
movq %rbx, %rdi
callq 0x10180
leaq 0x284e1(%rip), %rsi     # 0x44ed0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movq %rbx, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x101e0
leaq 0x28471(%rip), %rsi     # 0x44e80
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
leaq 0x18707(%rip), %rdx     # 0x35127
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movsd 0x185cb(%rip), %xmm0    # 0x35000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x10530
movq %rbx, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x101e0
leaq 0x284a8(%rip), %rsi     # 0x44f00
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movl $0x1, %eax
jmp 0x1cab0
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 %ebp, %edi
callq 0xf250
leaq 0x194aa(%rip), %rsi     # 0x35f4d
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfd60
addq $0xa8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1cbfc
movq %rax, %r14
movq 0x18(%rax), %r15
callq 0xfb90
movq %r15, %rdi
movq %rax, %rsi
callq 0x107a0
testl %eax, %eax
je 0x1caff
leaq 0x194d1(%rip), %rsi     # 0x35fbc
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 0x1cb6c
callq 0xf0a0
movl (%rax), %ebp
cmpl $0xb, %ebp
jne 0x1cb5d
addq $0x180, %r14            # imm = 0x180
movq %r14, %rdi
callq 0xf1f0
testl %eax, %eax
je 0x1cb50
movl $0xb, %ebp
cmpl $0x82, %eax
jne 0x1cb5d
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 0x1cb82
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
movslq 0x4(%r14), %rsi
testq %rsi, %rsi
je 0x1cb9a
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 0x1cbad
callq 0xfbd0
jmp 0x1cb8a
callq 0xf980
jmp 0x1cb8a
// File: /workspace/github_c_makefile_star2_O3/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 0x1935f(%rip), %r15     # 0x35fac
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 0x1cc8e
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_O3/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 0x19303(%rip), %rdx     # 0x35fac
movl $0x1, %esi
callq 0xfcf0
movq %rax, %rbx
movq (%rax), %rdi
callq 0x1ccc9
movq $0x0, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x18381(%rip), %rdx     # 0x35fac
movl $0x1, %esi
callq 0x10720
testq %rax, %rax
je 0x1dc4b
leaq 0x1841b(%rip), %rsi     # 0x3605c
movq %rbx, %rdi
callq 0xfbd0
jmp 0x1dc53
movq %rbx, %rdi
callq 0xf980
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2a4b7(%rip), %edi     # 0x485ec
callq 0x10470
testq %rax, %rax
jne 0x1e143
xorl %eax, %eax
popq %rcx
retq
addq $0xb0, %rax
movq %rax, %rdi
movl $0x16, %esi
callq 0x10030
// File: /workspace/github_c_makefile_star2_O3/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 0x17ed9(%rip), %rsi     # 0x360cc
callq 0x10180
testl %eax, %eax
je 0x1e256
leaq 0x26e2d(%rip), %rsi     # 0x45030
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movsd 0x16deb(%rip), %xmm0    # 0x35000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x10530
movq %rbx, %rdi
xorl %esi, %esi
movl $0x6, %edx
callq 0x101e0
leaq 0x26e18(%rip), %rsi     # 0x45050
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
leaq 0x16ede(%rip), %rdx     # 0x35127
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movsd 0x16da2(%rip), %xmm0    # 0x35000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x10530
movq %rbx, %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x101e0
leaq 0x26e3f(%rip), %rsi     # 0x450c0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movl $0x8, %r12d
leaq 0x26cb8(%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 0x1e298
callq 0xf7f0
movslq %eax, %rsi
movq %rbx, %rdi
callq 0xf910
leaq 0x17b65(%rip), %rdx     # 0x35e68
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_O3/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 0x17da5(%rip), %rdx     # 0x360cc
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_O3/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 0x17d77(%rip), %rdx     # 0x360cc
movl $0x1, %ebp
movl $0x1, %esi
callq 0xfcf0
movq (%rax), %rdi
xorl %esi, %esi
callq 0xfb40
testl %eax, %eax
je 0x1e391
movl %eax, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10800
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %ebp
jmp 0x1e39e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x17d18(%rip), %rdx     # 0x360cc
movl $0x1, %esi
callq 0xfcf0
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
movq (%rax), %rdi
callq 0x107e0
testl %eax, %eax
je 0x1e3f5
movslq %eax, %rsi
movq %rbx, %rdi
callq 0xf910
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xfbd0
movl $0x2, %eax
jmp 0x1e3f7
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x17cbe(%rip), %rdx     # 0x360cc
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 0x1e46f
movl %eax, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10800
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0xf910
jmp 0x1e481
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_O3/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 0x17bd6(%rip), %rdx     # 0x360cc
movl $0x1, %ebx
movl $0x1, %esi
callq 0xfcf0
movq (%rax), %rdi
callq 0xf140
testl %eax, %eax
js 0x1e527
cvtsi2sd %eax, %xmm0
divsd 0x16af3(%rip), %xmm0    # 0x35010
movq %r14, %rdi
callq 0xf2c0
jmp 0x1e529
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x17b5d(%rip), %rsi     # 0x360cc
movq %rbx, %rdi
callq 0x101f0
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
movl $0x1f, %esi
callq 0xf650
movq %rax, (%r15)
testq %rax, %rax
jne 0x1e5ab
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_O3/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 0x17b09(%rip), %rdx     # 0x360cc
movl $0x1, %esi
callq 0x10720
testq %rax, %rax
je 0x1e5e3
leaq 0x17b02(%rip), %rsi     # 0x360db
movq %rbx, %rdi
callq 0xfbd0
jmp 0x1e5eb
movq %rbx, %rdi
callq 0xf980
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1e6dd
leaq 0x17849(%rip), %r15     # 0x35ee2
movl %r14d, %r12d
negl %r12d
andl %r14d, %r12d
movl %r12d, %edi
callq 0xfd10
testq %rax, %rax
je 0x1e6cf
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 0x1e699
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_O3/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 0x1e723
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 0x1e703
movslq %ebp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf910
leaq 0x17(%rip), %rsi        # 0x1e74c
movq %rbx, %rdi
movl $0x1, %edx
callq 0x109f0
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1eed2
xorl %r15d, %r15d
leaq 0x27163(%rip), %r12     # 0x45fe0
leaq 0x173ff(%rip), %r14     # 0x36283
movq (%r15,%r12), %rdx
testq %rdx, %rdx
je 0x1eeb4
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10720
testq %rax, %rax
jne 0x1eec3
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x10720
testq %rax, %rax
jne 0x1eec3
addq $0x10, %r15
cmpq $0x640, %r15            # imm = 0x640
jne 0x1ee84
jmp 0x1eed2
leaq 0x174ed(%rip), %rsi     # 0x363b7
movq %rbx, %rdi
callq 0xfbd0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
leaq 0x16ff2(%rip), %rsi     # 0x361cf
callq 0x10180
leaq 0x263b7(%rip), %rsi     # 0x455a0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movq %rbx, %rdi
xorl %esi, %esi
movl $0xd, %edx
callq 0x101e0
leaq 0x262b7(%rip), %rsi     # 0x454c0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
leaq 0x15f0d(%rip), %rdx     # 0x35127
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movsd 0x15dd1(%rip), %xmm0    # 0x35000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x10530
movq %rbx, %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x101e0
leaq 0x2637e(%rip), %rsi     # 0x455d0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf910
leaq 0x16f6d(%rip), %rdx     # 0x361da
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl $0x1, %esi
movq %rbx, %rdi
callq 0xf910
leaq 0x16f57(%rip), %rdx     # 0x361e5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl $0x2, %esi
movq %rbx, %rdi
callq 0xf910
leaq 0x16f3f(%rip), %rdx     # 0x361ee
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf910
leaq 0x16f2d(%rip), %rdx     # 0x361fa
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl $0x1, %esi
movq %rbx, %rdi
callq 0xf910
leaq 0x16f18(%rip), %rdx     # 0x36206
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
leaq 0x16f07(%rip), %rsi     # 0x36214
callq 0x10180
leaq 0x26357(%rip), %rsi     # 0x45670
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movq %rbx, %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x101e0
leaq 0x262f7(%rip), %rsi     # 0x45630
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
leaq 0x15ddd(%rip), %rdx     # 0x35127
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movsd 0x15ca1(%rip), %xmm0    # 0x35000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x10530
movq %rbx, %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x101e0
leaq 0x2631e(%rip), %rsi     # 0x456a0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
leaq 0x16e80(%rip), %rsi     # 0x3621e
callq 0x10180
leaq 0x26366(%rip), %rsi     # 0x45710
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x101e0
leaq 0x26316(%rip), %rsi     # 0x456e0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
leaq 0x15d4c(%rip), %rdx     # 0x35127
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
leaq 0x16e39(%rip), %rsi     # 0x36228
movq 0x27b9a(%rip), %rdx     # 0x46f90
movq %rbx, %rdi
callq 0x1f43a
movsd 0x15bfa(%rip), %xmm0    # 0x35000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x10530
movq %rbx, %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x101e0
leaq 0x26317(%rip), %rsi     # 0x45740
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/dns.c
// Function: luaopen__cqueues_dns_resolver
int luaopen__cqueues_dns_resolver(lua_State *L) {
	cqs_newmetatable(L, RESOLVER_CLASS, res_methods, res_metatable, 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.packet", &luaopen__cqueues_dns_packet, 0);

	luaL_newlib(L, res_globals);

	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x16d70(%rip), %rsi     # 0x3623c
callq 0x10180
leaq 0x26348(%rip), %rsi     # 0x45820
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movq %rbx, %rdi
xorl %esi, %esi
movl $0x7, %edx
callq 0x101e0
leaq 0x262a8(%rip), %rsi     # 0x457a0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
leaq 0x15c1e(%rip), %rdx     # 0x35127
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
leaq 0x16d0b(%rip), %rsi     # 0x36228
movq 0x27a6c(%rip), %rdx     # 0x46f90
movq %rbx, %rdi
callq 0x1f43a
leaq 0x16d16(%rip), %rsi     # 0x36249
movq 0x27a8e(%rip), %rdx     # 0x46fc8
movq %rbx, %rdi
callq 0x1f43a
leaq 0x16d13(%rip), %rsi     # 0x3625c
movq 0x27a18(%rip), %rdx     # 0x46f68
movq %rbx, %rdi
callq 0x1f43a
leaq 0x16d10(%rip), %rsi     # 0x3626f
movq 0x27a42(%rip), %rdx     # 0x46fa8
movq %rbx, %rdi
callq 0x1f43a
movsd 0x15a8a(%rip), %xmm0    # 0x35000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x10530
movq %rbx, %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x101e0
leaq 0x262a7(%rip), %rsi     # 0x45840
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/dns.c
// Function: any_rdata
static int any_rdata(lua_State *L) {
	struct rr *rr = rr_toany(L, 1);

	if (rr->attr.section == DNS_S_QD)
		return lua_pushliteral(L, ""), 1;

	lua_pushlstring(L, (char *)rr->data.rdata.data, rr->data.rdata.len);

	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1f6a7
cmpl $0x1, (%rax)
jne 0x1f68d
leaq 0x19988(%rip), %rsi     # 0x3900b
movq %rbx, %rdi
callq 0xfbd0
jmp 0x1f6a0
movq %rax, %rsi
addq $0x30, %rsi
movq 0x28(%rax), %rdx
movq %rbx, %rdi
callq 0xf4c0
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/dns.c
// Function: any__tostring
static int any__tostring(lua_State *L) {
	struct rr *rr = rr_toany(L, 1);

	if (rr->attr.section == DNS_S_QD)
		return lua_pushliteral(L, ""), 1;

	if (luaL_testudata(L, 1, RR_ANY_CLASS)) {
		lua_pushlstring(L, (char *)rr->data.rdata.data, rr->data.rdata.len);
	} else {
		luaL_Buffer B;
		size_t len;

		luaL_buffinit(L, &B);
		len = dns_any_print(luaL_prepbuffer(&B), LUAL_BUFFERSIZE, &rr->data, rr->attr.type);
		luaL_addsize(&B, len);
		luaL_pushresult(&B);
	}

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, %r14
callq 0x1f6a7
cmpl $0x1, (%rax)
jne 0x1f719
leaq 0x198fc(%rip), %rsi     # 0x3900b
movq %r14, %rdi
callq 0xfbd0
jmp 0x1f788
movq %rax, %rbx
leaq 0x16b60(%rip), %rdx     # 0x36283
movq %r14, %rdi
movl $0x1, %esi
callq 0x10720
testq %rax, %rax
je 0x1f74a
movq %rbx, %rsi
addq $0x30, %rsi
movq 0x28(%rbx), %rdx
movq %r14, %rdi
callq 0xf4c0
jmp 0x1f788
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x10630
movl $0x2000, %esi           # imm = 0x2000
movq %r15, %rdi
callq 0xf3a0
movq %rbx, %rdx
addq $0x20, %rdx
movl 0x8(%rbx), %ecx
movl $0x2000, %esi           # imm = 0x2000
movq %rax, %rdi
callq 0xf860
addq %rax, 0x10(%r15)
movq %r15, %rdi
callq 0x10710
movl $0x1, %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/dns.c
// Function: a_addr
static int a_addr(lua_State *L) {
	struct rr *rr = luaL_checkudata(L, 1, RR_A_CLASS);
	char addr[INET_ADDRSTRLEN + 1] = "";

	if (rr->attr.section != DNS_S_QD)
		inet_ntop(AF_INET, &rr->data.a.addr, addr, sizeof addr);
	lua_pushstring(L, addr);

	return 1;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x16ae5(%rip), %rdx     # 0x3628e
movl $0x1, %esi
callq 0xfcf0
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movb $0x0, 0x10(%rsp)
cmpl $0x1, (%rax)
je 0x1f7dd
addq $0x20, %rax
movq %rsp, %rdx
movl $0x2, %edi
movq %rax, %rsi
movl $0x11, %ecx
callq 0xfda0
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xfbd0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/dns.c
// Function: ns_host
static int ns_host(lua_State *L) {
	struct rr *rr = rr_toany(L, 1);

	if (rr->attr.section == DNS_S_QD)
		return lua_pushliteral(L, ""), 1;

	lua_pushstring(L, rr->data.ns.host);

	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1f6a7
cmpl $0x1, (%rax)
leaq 0x20(%rax), %rax
leaq 0x19801(%rip), %rsi     # 0x3900b
cmovneq %rax, %rsi
movq %rbx, %rdi
callq 0xfbd0
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/dns.c
// Function: aaaa_addr
static int aaaa_addr(lua_State *L) {
	struct rr *rr = luaL_checkudata(L, 1, RR_AAAA_CLASS);
	char addr[INET6_ADDRSTRLEN + 1] = "";

	if (rr->attr.section != DNS_S_QD)
		inet_ntop(AF_INET6, &rr->data.aaaa.addr, addr, sizeof addr);
	lua_pushstring(L, addr);

	return 1;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x16938(%rip), %rdx     # 0x362d9
movl $0x1, %esi
callq 0xfcf0
xorps %xmm0, %xmm0
movups %xmm0, 0x1f(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
cmpl $0x1, (%rax)
je 0x1f9da
addq $0x20, %rax
movq %rsp, %rdx
movl $0xa, %edi
movq %rax, %rsi
movl $0x2f, %ecx
callq 0xfda0
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xfbd0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/dns.c
// Function: sshfp_digest
static int sshfp_digest(lua_State *L) {
	struct rr *rr = luaL_checkudata(L, 1, RR_SSHFP_CLASS);
	int fmt = luaL_checkoption(L, 2, "x", (const char *[]){ "s", "x", 0 });
	unsigned char *hash;
	size_t hashlen;

	lua_pushinteger(L, rr->data.sshfp.type);

	switch (rr->data.sshfp.type) {
	case DNS_SSHFP_SHA1:
		hash = rr->data.sshfp.digest.sha1;
		hashlen = sizeof rr->data.sshfp.digest.sha1;

		break;
	default:
		lua_pushnil(L);

		return 2;
	}

	switch (fmt) {
	case 1: {
		luaL_Buffer B;
		size_t i;

		luaL_buffinit(L, &B);

		for (i = 0; i < hashlen; i++) {
			luaL_addchar(&B, "0123456789abcdef"[0x0f & (hash[i] >> 4)]);
			luaL_addchar(&B, "0123456789abcdef"[0x0f & (hash[i] >> 0)]);
		}

		luaL_pushresult(&B);

		break;
	}
	default:
		lua_pushlstring(L, (char *)hash, hashlen);
		break;
	} /* switch() */

	return 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2040, %rsp           # imm = 0x2040
movq %rdi, %r15
leaq 0x167b4(%rip), %rdx     # 0x362fb
movl $0x1, %esi
callq 0xfcf0
movq %rax, %rbx
movups 0x26465(%rip), %xmm0    # 0x45fc0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movq 0x26468(%rip), %rax     # 0x45fd0
movq %rax, 0x10(%rcx)
leaq 0x155ba(%rip), %rdx     # 0x3512d
movq %r15, %rdi
movl $0x2, %esi
callq 0xfbc0
movl %eax, %ebp
movl 0x24(%rbx), %esi
movq %r15, %rdi
callq 0xf910
cmpl $0x1, 0x24(%rbx)
jne 0x1fc49
addq $0x28, %rbx
cmpl $0x1, %ebp
jne 0x1fc53
leaq 0x20(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x10630
xorl %r15d, %r15d
leaq 0x167e1(%rip), %r12     # 0x3639f
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jb 0x1fbdc
movl $0x1, %esi
movq %r14, %rdi
callq 0xf3a0
movq 0x30(%rsp), %rax
movzbl (%rbx,%r15), %ecx
shrl $0x4, %ecx
movb (%rcx,%r12), %cl
movq 0x20(%rsp), %rdx
leaq 0x1(%rax), %rsi
movq %rsi, 0x30(%rsp)
movb %cl, (%rdx,%rax)
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jb 0x1fc17
movl $0x1, %esi
movq %r14, %rdi
callq 0xf3a0
movq 0x30(%rsp), %rax
movzbl (%rbx,%r15), %ecx
andl $0xf, %ecx
movb (%rcx,%r12), %cl
movq 0x20(%rsp), %rdx
leaq 0x1(%rax), %rsi
movq %rsi, 0x30(%rsp)
movb %cl, (%rdx,%rax)
incq %r15
cmpq $0x14, %r15
jne 0x1fbbe
leaq 0x20(%rsp), %rdi
callq 0x10710
jmp 0x1fc63
movq %r15, %rdi
callq 0xf980
jmp 0x1fc63
movl $0x14, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xf4c0
movl $0x2, %eax
addq $0x2040, %rsp           # imm = 0x2040
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/dns.c
// Function: pkt_setqid
static int pkt_setqid(lua_State *L) {
	struct dns_packet *P = luaL_checkudata(L, 1, PACKET_CLASS);
	int qid = luaL_checkint(L, 2);

	dns_header(P)->qid = htons(qid);

	lua_settop(L, 1);

	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x164fa(%rip), %rdx     # 0x361af
movl $0x1, %esi
callq 0xfcf0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10a60
rolw $0x8, %ax
movw %ax, 0x5c(%r14)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10640
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/dns.c
// Function: pkt_flags
static int pkt_flags(lua_State *L) {
	struct dns_packet *P = luaL_checkudata(L, 1, PACKET_CLASS);
	struct dns_header *hdr = dns_header(P);

	lua_newtable(L);

	lua_pushboolean(L, hdr->qr);
	lua_setfield(L, -2, "qr");

	lua_pushinteger(L, hdr->opcode);
	lua_setfield(L, -2, "opcode");

	lua_pushboolean(L, hdr->aa);
	lua_setfield(L, -2, "aa");

	lua_pushboolean(L, hdr->tc);
	lua_setfield(L, -2, "tc");

	lua_pushboolean(L, hdr->rd);
	lua_setfield(L, -2, "rd");

	lua_pushboolean(L, hdr->ra);
	lua_setfield(L, -2, "ra");

	lua_pushinteger(L, hdr->unused);
	lua_setfield(L, -2, "z");

	lua_pushinteger(L, hdr->rcode);
	lua_setfield(L, -2, "rcode");

	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x164af(%rip), %rdx     # 0x361af
movl $0x1, %esi
callq 0xfcf0
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x101e0
movl 0x5c(%r14), %esi
shrl $0x17, %esi
andl $0x1, %esi
movq %rbx, %rdi
callq 0x10800
leaq 0x166af(%rip), %rdx     # 0x363e1
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl 0x5c(%r14), %esi
shrl $0x13, %esi
andl $0xf, %esi
movq %rbx, %rdi
callq 0xf910
leaq 0x1646a(%rip), %rdx     # 0x361c2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl 0x5c(%r14), %esi
shrl $0x12, %esi
andl $0x1, %esi
movq %rbx, %rdi
callq 0x10800
leaq 0x16666(%rip), %rdx     # 0x363e4
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl 0x5c(%r14), %esi
shrl $0x11, %esi
andl $0x1, %esi
movq %rbx, %rdi
callq 0x10800
leaq 0x16643(%rip), %rdx     # 0x363e7
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl 0x5c(%r14), %esi
shrl $0x10, %esi
andl $0x1, %esi
movq %rbx, %rdi
callq 0x10800
leaq 0x160db(%rip), %rdx     # 0x35ea5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl 0x5c(%r14), %esi
shrl $0x1f, %esi
movq %rbx, %rdi
callq 0x10800
leaq 0x165fd(%rip), %rdx     # 0x363ea
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl 0x5c(%r14), %esi
shrl $0x1c, %esi
andl $0x7, %esi
movq %rbx, %rdi
callq 0xf910
leaq 0x157e9(%rip), %rdx     # 0x355fc
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movzbl 0x5f(%r14), %esi
andl $0xf, %esi
movq %rbx, %rdi
callq 0xf910
leaq 0x16392(%rip), %rdx     # 0x361c9
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/dns.c
// Function: pkt_push
static int pkt_push(lua_State *L) {
	struct dns_packet *P = luaL_checkudata(L, 1, PACKET_CLASS);
	int section = luaL_checkint(L, 2);
	size_t namelen;
	const char *name = luaL_checklstring(L, 3, &namelen);
	int type = luaL_optint(L, 4, DNS_T_A);
	int class = luaL_optint(L, 5, DNS_C_IN);
	int error;

	luaL_argcheck(L, section == DNS_S_QUESTION, 2, "pushing RDATA not yet supported");

	if ((error = dns_p_push(P, section, name, namelen, type, class, 0, NULL)))
		return lua_pushnil(L), lua_pushinteger(L, error), 2;

	lua_settop(L, 1);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x16084(%rip), %rdx     # 0x361af
movl $0x1, %esi
callq 0xfcf0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10a60
movq %rax, %r15
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0xf620
movq %rax, %r12
movl $0x1, %edx
movq %rbx, %rdi
movl $0x4, %esi
callq 0xf400
movq %rax, %r13
movl $0x1, %edx
movq %rbx, %rdi
movl $0x5, %esi
callq 0xf400
movq %rax, %rbp
cmpl $0x1, %r15d
je 0x2019f
leaq 0x1625b(%rip), %rdx     # 0x363ed
movq %rbx, %rdi
movl $0x2, %esi
callq 0xf3f0
movq (%rsp), %rcx
movq %r14, %rdi
movl %r15d, %esi
movq %r12, %rdx
movl %r13d, %r8d
movl %ebp, %r9d
pushq $0x0
pushq $0x0
callq 0x106d0
addq $0x10, %rsp
testl %eax, %eax
je 0x201df
movl %eax, %ebp
movq %rbx, %rdi
callq 0xf980
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %ebp
jmp 0x201f1
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10640
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_O3/wahern[P]cqueues/src/dns.c
// Function: pkt_count
static int pkt_count(lua_State *L) {
	struct dns_packet *P = luaL_checkudata(L, 1, PACKET_CLASS);
	int flags = luaL_optint(L, 2, DNS_S_ALL);

	lua_pushinteger(L, dns_p_count(P, flags));

	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x15f9f(%rip), %rdx     # 0x361af
movl $0x1, %esi
callq 0xfcf0
movq %rax, %r14
movl $0xf, %edx
movq %rbx, %rdi
movl $0x2, %esi
callq 0xf400
movq %r14, %rdi
movl %eax, %esi
callq 0x10790
movl %eax, %esi
movq %rbx, %rdi
callq 0xf910
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/dns.c
// Function: pkt_grep
static int pkt_grep(lua_State *L) {
	struct dns_packet *P = luaL_checkudata(L, 1, PACKET_CLASS);
	struct dns_rr_i *rr_i;

	lua_settop(L, 2);

	lua_pushvalue(L, 1);
	rr_i = memset(lua_newuserdata(L, sizeof *rr_i), '\0', sizeof *rr_i);
	rr_i = dns_rr_i_init(rr_i, P);

	if (!lua_isnil(L, 2)) {
		luaL_checktype(L, 2, LUA_TTABLE);

		rr_i->section = optfint(L, 2, "section", 0);
		rr_i->type = optfint(L, 2, "type", 0);
		rr_i->class = optfint(L, 2, "class", 0);

		lua_getfield(L, 2, "name");
		if (!(rr_i->name = luaL_optstring(L, -1, NULL)))
			lua_pop(L, 1);
	}

	lua_pushcclosure(L, &pkt_next, lua_gettop(L) - 2);

	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x15f51(%rip), %rdx     # 0x361af
movl $0x1, %esi
callq 0xfcf0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10640
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf9c0
movl $0x58, %esi
movq %rbx, %rdi
callq 0xfb00
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movq $0x0, 0x50(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x105a0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0xf260
testl %eax, %eax
je 0x2035e
movq %rbx, %rdi
movl $0x2, %esi
movl $0x5, %edx
callq 0xf6c0
leaq 0x15ece(%rip), %rsi     # 0x361ba
movq %rbx, %rdi
xorl %edx, %edx
callq 0x20442
movl %eax, (%r14)
leaq 0x18ace(%rip), %rsi     # 0x38dce
movq %rbx, %rdi
xorl %edx, %edx
callq 0x20442
movl %eax, 0x10(%r14)
leaq 0x15df4(%rip), %rsi     # 0x36109
movq %rbx, %rdi
xorl %edx, %edx
callq 0x20442
movl %eax, 0x14(%r14)
leaq 0x18b1f(%rip), %rdx     # 0x38e49
movq %rbx, %rdi
movl $0x2, %esi
callq 0xf1e0
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf8b0
movq %rax, 0x8(%r14)
testq %rax, %rax
jne 0x2035e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
movq %rbx, %rdi
callq 0xf920
leal -0x2(%rax), %edx
leaq 0x112(%rip), %rsi       # 0x20482
movq %rbx, %rdi
callq 0x109f0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/dns.c
// Function: pkt_load
static int pkt_load(lua_State *L) {
	struct dns_packet *P = luaL_checkudata(L, 1, PACKET_CLASS);
	size_t size;
	const char *data = luaL_checklstring(L, 2, &size);

	pkt_reload(P, data, size);

	lua_settop(L, 1);

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x15e17(%rip), %rdx     # 0x361af
movl $0x1, %esi
callq 0xfcf0
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0xf620
movq (%r15), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x2068a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10640
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/dns.c
// Function: pkt_tobool
static _Bool pkt_tobool(lua_State *L, int index) {
	if (lua_isnumber(L, index)) {
		return lua_tointeger(L, index);
	} else {
		return lua_toboolean(L, index);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xfb80
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x20436
xorl %edx, %edx
callq 0xfd20
testq %rax, %rax
jmp 0x2043d
callq 0xf540
testl %eax, %eax
setne %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/dns.c
// Function: pkt_next
static int pkt_next(lua_State *L) {
	struct dns_packet *P = lua_touserdata(L, lua_upvalueindex(1));
	struct dns_rr_i *rr_i = lua_touserdata(L, lua_upvalueindex(2));
	struct dns_rr rr;
	int error = 0;

	if (!dns_rr_grep(&rr, 1, rr_i, P, &error))
		return (error)? luaL_error(L, "dns.packet:grep: %s", cqs_strerror(error)) : 0;

	rr_push(L, &rr, P);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x10350
movq %rax, %r14
movq %rbx, %rdi
movl $0xfff0b9d6, %esi       # imm = 0xFFF0B9D6
callq 0x10350
movq %rsp, %r8
movl $0x0, (%r8)
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movq %rax, %rdx
movq %r14, %rcx
callq 0xfd70
testl %eax, %eax
je 0x20628
movzwl 0xc(%rsp), %edx
leaq 0x120(%rsp), %rdi
leaq 0x4(%rsp), %r8
movl $0x100, %esi            # imm = 0x100
movq %r14, %rcx
callq 0xfec0
movq %rax, %r12
movl 0x10(%rsp), %eax
movzwl 0x1e(%rsp), %r15d
addq $0x11, %r15
cmpq $0x63, %rax
ja 0x20529
shlq $0x4, %rax
leaq 0x25ac8(%rip), %rcx     # 0x45fe0
movzwl 0x8(%rax,%rcx), %eax
testq %rax, %rax
je 0x20529
cmpq %rax, %r15
cmovbeq %rax, %r15
leaq (%r12,%r15), %rsi
addq $0x21, %rsi
movq %rbx, %rdi
callq 0xfb00
movq %rax, %rbp
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbp)
leaq 0x20(%rbp), %r13
leaq 0x20(%rbp,%r15), %rdi
movq %rdi, 0x18(%rbp)
leaq 0x120(%rsp), %rsi
movq %r12, %rdx
callq 0xfa60
movq 0x18(%rbp), %rax
movb $0x0, (%rax,%r12)
movq %r13, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0xf750
cmpl $0x1, 0x8(%rsp)
je 0x205f4
movq %r13, %rdi
movq %r15, %rsi
callq 0x106b0
leaq 0x8(%rsp), %rsi
movq %r13, %rdi
movq %r14, %rdx
callq 0xfe70
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x205f4
xorps %xmm0, %xmm0
leaq 0xa0(%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 0x15e3a(%rip), %rsi     # 0x36421
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfd60
movl 0x10(%rsp), %eax
cmpq $0x63, %rax
ja 0x20612
shlq $0x4, %rax
leaq 0x259d7(%rip), %rcx     # 0x45fe0
movq (%rax,%rcx), %rsi
testq %rsi, %rsi
jne 0x20619
leaq 0x15c6a(%rip), %rsi     # 0x36283
movq %rbx, %rdi
callq 0x101f0
movl $0x1, %eax
jmp 0x20678
movl (%rsp), %edi
testl %edi, %edi
je 0x20676
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
callq 0xf250
leaq 0x15da6(%rip), %rsi     # 0x3640d
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfd60
jmp 0x20678
xorl %eax, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/dns.c
// Function: pkt_reload
static void pkt_reload(struct dns_packet *P, const void *data, size_t size) {
	if (P->size < size) {
		memcpy(P->data, data, P->size);
		P->end = P->size;
		dns_header(P)->tc = 1;
	} else {
		memcpy(P->data, data, size);
		P->end = size;
	}

	dns_p_study(P);

	memset(P->dict, 0, sizeof P->dict);
	dns_p_dictadd(P, 12); /* add query name to dictionary */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %r14
leaq 0x5c(%rdi), %r12
cmpq %rdx, %r14
jae 0x206b5
movq %r12, %rdi
movq %r14, %rdx
callq 0xfa60
orb $0x2, 0x2(%r12)
jmp 0x206c3
movq %rdx, %r15
movq %r12, %rdi
callq 0xfa60
movq %r15, %r14
movq %r14, 0x50(%rbx)
movq %rbx, %rdi
callq 0xf7a0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movq %rbx, %rdi
movl $0xc, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf3c0
// File: /workspace/github_c_makefile_star2_O3/wahern[P]cqueues/src/dns.c
// Function: pkt__tostring
static int pkt__tostring(lua_State *L) {
	struct dns_packet *P = luaL_checkudata(L, 1, PACKET_CLASS);
	char line[1024];
	luaL_Buffer B;
	FILE *fp;

	if (!(fp = tmpfile()))
		return luaL_error(L, "tmpfile: %s", cqs_strerror(errno));

	dns_p_dump(P, fp);

	luaL_buffinit(L, &B);

	rewind(fp);

	while (fgets(line, sizeof line, fp))
		luaL_addstring(&B, line);

	fclose(fp);

	luaL_pushresult(&B);

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x24a0, %rsp           # imm = 0x24A0
movq %rdi, %rbx
leaq 0x15aa8(%rip), %rdx     # 0x361af
movl $0x1, %esi
callq 0xfcf0
movq %rax, %r15
callq 0x10200
testq %rax, %rax
je 0x207ae
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0x105e0
leaq 0x480(%rsp), %rsi
movq %rbx, %rdi
callq 0x10630
movq %r14, %rdi
callq 0xf150
leaq 0x80(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x10550
testq %rax, %rax
je 0x20792
leaq 0x480(%rsp), %rbx
leaq 0x80(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf850
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x10550
testq %rax, %rax
jne 0x20772
movq %r14, %rdi
callq 0xfce0
leaq 0x480(%rsp), %rdi
callq 0x10710
movl $0x1, %eax
jmp 0x207f8
callq 0xf0a0
movl (%rax), %edi
xorps %xmm0, %xmm0
movq %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 0x15c47(%rip), %rsi     # 0x36432
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfd60
addq $0x24a0, %rsp           # imm = 0x24A0
popq %rbx
popq %r14
popq %r15
retq