LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x13fcc(%rip), %rdx     # 0x3128e
pushq $0x1
popq %rsi
callq 0xfd80
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movb $0x0, 0x10(%rsp)
cmpl $0x1, (%rax)
je 0x1d2f0
addq $0x20, %rax
pushq $0x2
popq %rdi
movq %rsp, %rdx
pushq $0x11
popq %rcx
movq %rax, %rsi
callq 0xfe30
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xfc50
pushq $0x1
popq %rax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1d1c6
cmpl $0x1, (%rax)
leaq 0x20(%rax), %rax
leaq 0x16ce0(%rip), %rsi     # 0x33ffb
cmovneq %rax, %rsi
movq %rbx, %rdi
callq 0xfc50
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x13e05(%rip), %rdx     # 0x312d9
pushq $0x1
popq %rsi
callq 0xfd80
xorps %xmm0, %xmm0
movups %xmm0, 0x1f(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
cmpl $0x1, (%rax)
je 0x1d507
addq $0x20, %rax
pushq $0xa
popq %rdi
movq %rsp, %rdx
pushq $0x2f
popq %rcx
movq %rax, %rsi
callq 0xfe30
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xfc50
pushq $0x1
popq %rax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x2038, %rsp           # imm = 0x2038
movq %rdi, %r15
leaq 0x13c67(%rip), %rdx     # 0x312fb
pushq $0x1
popq %rsi
callq 0xfd80
movq %rax, %rbx
movups 0x2691a(%rip), %xmm0    # 0x43fc0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movq 0x2691d(%rip), %rax     # 0x43fd0
movq %rax, 0x10(%rcx)
leaq 0x12a6f(%rip), %rdx     # 0x3012d
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0xfc40
movl %eax, %ebp
movl 0x24(%rbx), %esi
movq %r15, %rdi
callq 0xf960
cmpl $0x1, 0x24(%rbx)
jne 0x1d78f
addq $0x28, %rbx
cmpl $0x1, %ebp
jne 0x1d799
leaq 0x18(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x106e0
xorl %r12d, %r12d
leaq 0x13c98(%rip), %r13     # 0x3139f
pushq $0x1
popq %r15
cmpq $0x14, %r12
je 0x1d7a9
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jb 0x1d731
movq %r14, %rdi
movq %r15, %rsi
callq 0xf3c0
movq 0x28(%rsp), %rax
movzbl (%rbx,%r12), %ecx
shrl $0x4, %ecx
movb (%rcx,%r13), %cl
movq 0x18(%rsp), %rdx
leaq 0x1(%rax), %rsi
movq %rsi, 0x28(%rsp)
movb %cl, (%rdx,%rax)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jb 0x1d76a
movq %r14, %rdi
movq %r15, %rsi
callq 0xf3c0
movq 0x28(%rsp), %rax
movzbl (%rbx,%r12), %ecx
andl $0xf, %ecx
movb (%rcx,%r13), %cl
movq 0x18(%rsp), %rdx
leaq 0x1(%rax), %rsi
movq %rsi, 0x28(%rsp)
movb %cl, (%rdx,%rax)
incq %r12
jmp 0x1d70b
movq %r15, %rdi
callq 0xf9d0
jmp 0x1d7b3
pushq $0x14
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xf4e0
jmp 0x1d7b3
leaq 0x18(%rsp), %rdi
callq 0x107d0
pushq $0x2
popq %rax
addq $0x2038, %rsp           # imm = 0x2038
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x139a6(%rip), %rdx     # 0x311af
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0xfd80
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x10b40
rolw $0x8, %ax
movw %ax, 0x5c(%r14)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x106f0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x13963(%rip), %rdx     # 0x311af
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0xfd80
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10270
movl 0x5c(%r15), %esi
shrl $0x17, %esi
andl $0x1, %esi
movq %r14, %rdi
callq 0x108d0
leaq 0x13b63(%rip), %rdx     # 0x313e1
pushq $-0x2
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0xf550
movl 0x5c(%r15), %esi
shrl $0x13, %esi
andl $0xf, %esi
movq %r14, %rdi
callq 0xf960
leaq 0x1391e(%rip), %rdx     # 0x311c2
movq %r14, %rdi
movl %ebp, %esi
callq 0xf550
movl 0x5c(%r15), %esi
shrl $0x12, %esi
andl $0x1, %esi
movq %r14, %rdi
callq 0x108d0
leaq 0x13b1d(%rip), %rdx     # 0x313e4
movq %r14, %rdi
movl %ebp, %esi
callq 0xf550
movl 0x5c(%r15), %esi
shrl $0x11, %esi
andl $0x1, %esi
movq %r14, %rdi
callq 0x108d0
leaq 0x13afd(%rip), %rdx     # 0x313e7
movq %r14, %rdi
movl %ebp, %esi
callq 0xf550
movl 0x5c(%r15), %esi
shrl $0x10, %esi
andl $0x1, %esi
movq %r14, %rdi
callq 0x108d0
leaq 0x13598(%rip), %rdx     # 0x30ea5
movq %r14, %rdi
movl %ebp, %esi
callq 0xf550
movl 0x5c(%r15), %esi
shrl $0x1f, %esi
movq %r14, %rdi
callq 0x108d0
leaq 0x13abd(%rip), %rdx     # 0x313ea
movq %r14, %rdi
movl %ebp, %esi
callq 0xf550
movl 0x5c(%r15), %esi
shrl $0x1c, %esi
andl $0x7, %esi
movq %r14, %rdi
callq 0xf960
leaq 0x12cac(%rip), %rdx     # 0x305fc
movq %r14, %rdi
movl %ebp, %esi
callq 0xf550
movzbl 0x5f(%r15), %esi
andl $0xf, %esi
movq %r14, %rdi
callq 0xf960
leaq 0x13858(%rip), %rdx     # 0x311c9
movq %r14, %rdi
movl %ebp, %esi
callq 0xf550
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x13590(%rip), %rdx     # 0x311af
pushq $0x1
popq %rsi
callq 0xfd80
movq %rax, 0x8(%rsp)
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x10b40
movq %rax, %r12
pushq $0x3
popq %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xf660
movq %rax, %r13
pushq $0x4
popq %rsi
pushq $0x1
popq %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0xf420
movq %rax, %r14
pushq $0x5
popq %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0xf420
movq %rax, %r15
cmpl $0x1, %r12d
je 0x1dc8d
leaq 0x1376b(%rip), %rdx     # 0x313ed
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf410
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdi
movl %r12d, %esi
movq %r13, %rdx
movl %r14d, %r8d
movl %r15d, %r9d
pushq $0x0
pushq $0x0
callq 0x10780
addq $0x10, %rsp
testl %eax, %eax
je 0x1dccc
movl %eax, %r14d
movq %rbx, %rdi
callq 0xf9d0
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0xf960
jmp 0x1dcd9
movq %rbx, %rdi
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x106f0
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x134b7(%rip), %rdx     # 0x311af
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0xfd80
movq %rax, %r14
pushq $0x2
popq %rsi
pushq $0xf
popq %rdx
movq %rbx, %rdi
callq 0xf420
movq %r14, %rdi
movl %eax, %esi
callq 0x10850
movl %eax, %esi
movq %rbx, %rdi
callq 0xf960
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x13470(%rip), %rdx     # 0x311af
pushq $0x1
popq %r14
movl %r14d, %esi
callq 0xfd80
movq %rax, %r15
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x106f0
movq %rbx, %rdi
movl %r14d, %esi
callq 0xfa10
pushq $0x58
popq %rsi
movq %rbx, %rdi
callq 0xfb70
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
andq $0x0, 0x50(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x10650
movq %rax, %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf270
testl %eax, %eax
je 0x1de2e
pushq $0x2
popq %rbp
pushq $0x5
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf700
leaq 0x133f7(%rip), %rsi     # 0x311ba
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1df08
movl %eax, (%r14)
leaq 0x15fe7(%rip), %rsi     # 0x33dbe
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1df08
movl %eax, 0x10(%r14)
leaq 0x1331d(%rip), %rsi     # 0x31109
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1df08
movl %eax, 0x14(%r14)
leaq 0x16038(%rip), %rdx     # 0x33e39
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf1f0
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf900
movq %rax, 0x8(%r14)
testq %rax, %rax
jne 0x1de2e
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x106f0
movq %rbx, %rdi
callq 0xf970
leal -0x2(%rax), %edx
leaq 0x102(%rip), %rsi       # 0x1df42
movq %rbx, %rdi
callq 0x10ad0
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x13348(%rip), %rdx     # 0x311af
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0xfd80
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0xf660
movq (%r15), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x1e147
movq %rbx, %rdi
movl %ebp, %esi
callq 0x106f0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x1
popq %rsi
callq 0xfc00
pushq $-0x1
popq %rsi
movq %rbx, %rdi
testl %eax, %eax
je 0x1defc
xorl %edx, %edx
callq 0xfdb0
testq %rax, %rax
jmp 0x1df03
callq 0xf560
testl %eax, %eax
setne %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: optfint
static int optfint(lua_State *L, int t, const char *k, int def) {
	int i;

	lua_getfield(L, t, k);
	i = luaL_optint(L, -1, def);
	lua_pop(L, 1);

	return i;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %rdx
movq %rdi, %r14
pushq $0x2
popq %rsi
callq 0xf1f0
movslq %ebx, %rdx
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0xf420
movq %rax, %rbx
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0x106f0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x103f0
movq %rax, %r14
movq %rbx, %rdi
movl $0xfff0b9d6, %esi       # imm = 0xFFF0B9D6
callq 0x103f0
movq %rsp, %r8
andl $0x0, (%r8)
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0xfe00
testl %eax, %eax
je 0x1e0e1
movzwl 0xc(%rsp), %edx
leaq 0x120(%rsp), %rdi
leaq 0x4(%rsp), %r8
movl $0x100, %esi            # imm = 0x100
movq %r14, %rcx
callq 0xff50
movq %rax, %r12
movzwl 0x1e(%rsp), %r15d
addq $0x11, %r15
movl 0x10(%rsp), %eax
cmpq $0x63, %rax
ja 0x1dfe4
shlq $0x4, %rax
leaq 0x2600d(%rip), %rcx     # 0x43fe0
movzwl 0x8(%rax,%rcx), %eax
testq %rax, %rax
je 0x1dfe4
cmpq %rax, %r15
cmovbeq %rax, %r15
leaq (%r12,%r15), %rsi
addq $0x21, %rsi
movq %rbx, %rdi
callq 0xfb70
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 0xfad0
movq 0x18(%rbp), %rax
movb $0x0, (%rax,%r12)
movq %r13, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0xf790
cmpl $0x1, 0x8(%rsp)
je 0x1e0af
movq %r13, %rdi
movq %r15, %rsi
callq 0x10760
leaq 0x8(%rsp), %rsi
movq %r13, %rdi
movq %r14, %rdx
callq 0xff00
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x1e0af
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 0xf260
leaq 0x1337f(%rip), %rsi     # 0x31421
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfdf0
movl 0x10(%rsp), %eax
cmpq $0x63, %rax
pushq $0x1
popq %rbp
ja 0x1e0d0
shlq $0x4, %rax
leaq 0x25f19(%rip), %rcx     # 0x43fe0
movq (%rax,%rcx), %rsi
testq %rsi, %rsi
jne 0x1e0d7
leaq 0x131ac(%rip), %rsi     # 0x31283
movq %rbx, %rdi
callq 0x10280
jmp 0x1e133
movl (%rsp), %edi
testl %edi, %edi
je 0x1e131
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 0xf260
leaq 0x132ed(%rip), %rsi     # 0x3140d
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfdf0
movl %eax, %ebp
jmp 0x1e133
xorl %ebp, %ebp
movl %ebp, %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_O2/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 0x1e172
movq %r12, %rdi
movq %r14, %rdx
callq 0xfad0
orb $0x2, 0x2(%r12)
jmp 0x1e180
movq %rdx, %r15
movq %r12, %rdi
callq 0xfad0
movq %r15, %r14
movq %r14, 0x50(%rbx)
movq %rbx, %rdi
callq 0xf7e0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
pushq $0xc
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf3e0
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x24a8, %rsp           # imm = 0x24A8
movq %rdi, %r14
leaq 0x12feb(%rip), %rdx     # 0x311af
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0xfd80
movq %rax, %r12
callq 0x10290
testq %rax, %rax
je 0x1e245
movq %rax, %r15
movq %r12, %rdi
movq %rax, %rsi
callq 0x10690
leaq 0x488(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x106e0
movq %r15, %rdi
callq 0xf160
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdx
callq 0x10600
testq %rax, %rax
je 0x1e22e
movq %r12, %rdi
movq %r14, %rsi
callq 0xf8a0
jmp 0x1e20c
movq %r15, %rdi
callq 0xfd70
leaq 0x488(%rsp), %rdi
callq 0x107d0
jmp 0x1e291
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 0xf260
leaq 0x131b0(%rip), %rsi     # 0x31432
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfdf0
movl %eax, %ebx
movl %ebx, %eax
addq $0x24a8, %rsp           # imm = 0x24A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: pkt_new
static int pkt_new(lua_State *L) {
	struct dns_packet *P;
	const char *data = NULL;
	size_t prepbufsiz, datasiz, size;

	if (lua_isnoneornil(L, 1) || lua_isnumber(L, 1)) {
		prepbufsiz = luaL_optunsigned(L, 1, DNS_P_QBUFSIZ);
	} else {
		data = luaL_checklstring(L, 1, &datasiz);
		prepbufsiz = luaL_optunsigned(L, 2, datasiz);
	}

	size = dns_p_calcsize(prepbufsiz);
	P = memset(lua_newuserdata(L, size), '\0', size);
	luaL_setmetatable(L, PACKET_CLASS);

	dns_p_init(P, size);

	if (data)
		pkt_reload(P, data, datasiz);

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xf270
testl %eax, %eax
jle 0x1e2c8
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xfc00
testl %eax, %eax
je 0x1e2dd
pushq $0x1
popq %rsi
movl $0x160, %edx            # imm = 0x160
movq %rbx, %rdi
callq 0xf420
xorl %r14d, %r14d
jmp 0x1e2ff
pushq $0x1
popq %rsi
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0xf660
movq %rax, %r14
movq (%r15), %rdx
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf420
cmpq $0xd, %rax
pushq $0xc
popq %r12
cmovaeq %rax, %r12
addq $0x5c, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xfb70
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xf790
leaq 0x12e7e(%rip), %rsi     # 0x311af
movq %rbx, %rdi
callq 0x10280
movq %r15, %rdi
movq %r12, %rsi
callq 0x10b10
testq %r14, %r14
je 0x1e358
movq (%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1e147
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: pkt_type
static int pkt_type(lua_State *L) {
	if (luaL_testudata(L, 1, PACKET_CLASS)) {
		lua_pushstring(L, "dns packet");
	} else {
		lua_pushnil(L);
	}

	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x12e3d(%rip), %rdx     # 0x311af
pushq $0x1
popq %rsi
callq 0x107e0
testq %rax, %rax
je 0x1e390
leaq 0x130b8(%rip), %rsi     # 0x3143e
movq %rbx, %rdi
callq 0xfc50
jmp 0x1e398
movq %rbx, %rdi
callq 0xf9d0
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: resconf_getns
static int resconf_getns(lua_State *L) {
	struct dns_resolv_conf *resconf = resconf_check(L, 1);

	lua_newtable(L);

	for (unsigned i = 0; i < countof(resconf->nameserver); i++) {
		union { struct sockaddr_storage *other; struct sockaddr_in *in; struct sockaddr_in6 *in6; } any;
		char ns[INET6_ADDRSTRLEN + 1] = "";
		int port;

		any.other = &resconf->nameserver[i];

		switch (any.other->ss_family) {
		case AF_INET:
			inet_ntop(AF_INET, &any.in->sin_addr, ns, sizeof ns);
			port = ntohs(any.in->sin_port);
			break;
		case AF_INET6:
			inet_ntop(AF_INET6, &any.in6->sin6_addr, ns, sizeof ns);
			port = ntohs(any.in6->sin6_port);
			break;
		default:
			continue;
		}

		if (port && port != 53)
			lua_pushfstring(L, "[%s]:%d", ns, port);
		else
			lua_pushstring(L, ns);

		lua_rawseti(L, -2, i + 1);
	}

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x1edfb
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10270
movq %rsp, %r15
pushq $-0x2
popq %r12
xorl %ebp, %ebp
cmpq $0x3, %rbp
je 0x1e4f3
xorps %xmm0, %xmm0
movups %xmm0, 0x1f(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %rbp, %r13
shlq $0x7, %r13
movzwl (%r14,%r13), %edi
cmpl $0x2, %edi
je 0x1e48d
cmpl $0xa, %edi
jne 0x1e4c4
pushq $0x8
popq %rsi
pushq $0xa
popq %rdi
jmp 0x1e490
pushq $0x4
popq %rsi
addq %r14, %r13
addq %r13, %rsi
movq %r15, %rdx
pushq $0x2f
popq %rcx
callq 0xfe30
movzwl 0x2(%r13), %eax
rolw $0x8, %ax
testw %ax, %ax
je 0x1e4b7
movzwl %ax, %ecx
cmpl $0x35, %ecx
jne 0x1e4c9
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfc50
jmp 0x1e4dd
incq %rbp
jmp 0x1e454
movq %rbx, %rdi
leaq 0x12fde(%rip), %rsi     # 0x314b1
movq %r15, %rdx
xorl %eax, %eax
callq 0x10080
incq %rbp
movq %rbx, %rdi
movl %r12d, %esi
movq %rbp, %rdx
callq 0xfb90
jmp 0x1e454
pushq $0x1
popq %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: resconf_setns
static int resconf_setns(lua_State *L) {
	struct dns_resolv_conf *resconf = resconf_check(L, 1);

	luaL_checktype(L, 2, LUA_TTABLE);

	for (unsigned i = 0; i < countof(resconf->nameserver); i++) {
		const char *ns;
		int error;

		lua_rawgeti(L, 2, i + 1);

		if ((ns = luaL_optstring(L, -1, 0))) {
			if ((error = dns_resconf_pton(&resconf->nameserver[i], ns)))
				return luaL_error(L, "%s: %s", ns, cqs_strerror(error));
		} else {
			memset(&resconf->nameserver[i], 0, sizeof resconf->nameserver[i]);
			resconf->nameserver[i].ss_family = AF_UNSPEC;
		}

		lua_pop(L, 1);
	}

	return lua_pushboolean(L, 1), 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x1edfb
movq %rax, %r14
pushq $0x2
popq %rsi
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0xf700
pushq $0x1
popq %r12
pushq $-0x1
popq %r13
pushq $-0x2
popq %rbp
cmpq $0x4, %r12
je 0x1e5b6
movq %rbx, %rdi
pushq $0x2
popq %rsi
movq %r12, %rdx
callq 0xf470
movq %rbx, %rdi
movl %r13d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf900
testq %rax, %rax
je 0x1e579
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x10a30
testl %eax, %eax
je 0x1e5a3
jmp 0x1e5c5
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%r14)
movups %xmm0, 0x60(%r14)
movups %xmm0, 0x50(%r14)
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x106f0
incq %r12
subq $-0x80, %r14
jmp 0x1e53d
movq %rbx, %rdi
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x108d0
jmp 0x1e60f
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl $0x80, %edx
movl %eax, %edi
callq 0xf260
leaq 0x11d36(%rip), %rsi     # 0x30333
movq %rbx, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfdf0
movl %eax, %ebx
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: resconf_getsearch
static int resconf_getsearch(lua_State *L) {
	struct dns_resolv_conf *resconf = resconf_check(L, 1);

	lua_newtable(L);

	for (unsigned i = 0; i < countof(resconf->search) && *resconf->search[i]; i++) {
		lua_pushstring(L, resconf->search[i]);
		lua_rawseti(L, -2, i + 1);
	}

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x1edfb
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10270
addq $0x180, %r14            # imm = 0x180
pushq $0x1
popq %r15
pushq $-0x2
popq %rbp
cmpq $0x5, %r15
je 0x1e682
cmpb $0x0, (%r14)
je 0x1e682
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfc50
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0xfb90
incq %r15
addq $0x100, %r14            # imm = 0x100
jmp 0x1e652
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: resconf_setsearch
static int resconf_setsearch(lua_State *L) {
	struct dns_resolv_conf *resconf = resconf_check(L, 1);

	luaL_checktype(L, 2, LUA_TTABLE);

	for (unsigned i = 0; i < countof(resconf->search); i++) {
		const char *dn;

		lua_rawgeti(L, 2, i + 1);

		if ((dn = luaL_optstring(L, -1, 0))) {
			dns_strlcpy(resconf->search[i], dn, sizeof resconf->search[i]);
		} else {
			memset(resconf->search[i], 0, sizeof resconf->search[i]);
		}

		lua_pop(L, 1);
	}

	return lua_pushboolean(L, 1), 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x1edfb
movq %rax, %r14
pushq $0x2
popq %rbp
pushq $0x5
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf700
addq $0x180, %r14            # imm = 0x180
pushq $0x1
popq %r15
pushq $-0x1
popq %r12
pushq $-0x2
popq %r13
cmpq $0x5, %r15
je 0x1e723
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0xf470
movq %rbx, %rdi
movl %r12d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf900
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
testq %rax, %rax
je 0x1e705
movq %rax, %rsi
callq 0xf4f0
jmp 0x1e70c
xorl %esi, %esi
callq 0xf790
movq %rbx, %rdi
movl %r13d, %esi
callq 0x106f0
incq %r15
addq $0x100, %r14            # imm = 0x100
jmp 0x1e6cc
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x108d0
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_O2/wahern[P]cqueues/src/dns.c
// Function: resconf_getlookup
static int resconf_getlookup(lua_State *L) {
	struct dns_resolv_conf *resconf = resconf_check(L, 1);

	lua_newtable(L);

	for (unsigned i = 0; i < countof(resconf->lookup) && resconf->lookup[i]; i++) {
		switch (resconf->lookup[i]) {
		case 'f': case 'F':
			lua_pushliteral(L, "file");
			break;
		case 'b': case 'B':
			lua_pushliteral(L, "bind");
			break;
		case 'c': case 'C':
			lua_pushliteral(L, "cache");
			break;
		default:
			continue;
		}

		lua_rawseti(L, -2, i + 1);
	}

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x1edfb
movq %rax, %r14
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10270
movabsq $0x100000001, %r13      # imm = 0x100000001
pushq $-0x2
popq %rbp
movabsq $0x200000002, %r12      # imm = 0x200000002
cmpq $0x24, %r15
je 0x1e7ed
movzbl 0x580(%r14,%r15), %eax
leal -0x42(%rax), %ecx
cmpl $0x24, %ecx
ja 0x1e7ba
btq %rcx, %r13
jb 0x1e7c3
btq %rcx, %r12
jb 0x1e7cc
movabsq $0x1000000010, %rdx     # imm = 0x1000000010
btq %rcx, %rdx
leaq 0x1588a(%rip), %rsi     # 0x34042
jb 0x1e7d3
testl %eax, %eax
je 0x1e7ed
incq %r15
jmp 0x1e780
leaq 0x15872(%rip), %rsi     # 0x3403c
jmp 0x1e7d3
leaq 0x15875(%rip), %rsi     # 0x34048
movq %rbx, %rdi
callq 0xfc50
incq %r15
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0xfb90
jmp 0x1e780
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: resconf_setlookup
static int resconf_setlookup(lua_State *L) {
	struct dns_resolv_conf *resconf = resconf_check(L, 1);

	luaL_checktype(L, 2, LUA_TTABLE);

	memset(resconf->lookup, 0, sizeof resconf->lookup);

	for (unsigned i = 0; i < countof(resconf->lookup); i++) {
		const char *lu;

		lua_rawgeti(L, 2, i + 1);

		if ((lu = luaL_optstring(L, -1, 0))) {
			switch (*lu) {
			case 'f': case 'F':
				resconf->lookup[i] = 'f';
				break;
			case 'b': case 'B':
				resconf->lookup[i] = 'b';
				break;
			case 'c': case 'C':
				resconf->lookup[i] = 'c';
				break;
			}
		}

		lua_pop(L, 1);
	}

	return lua_pushboolean(L, 1), 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x1edfb
movq %rax, %r14
pushq $0x2
popq %rsi
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0xf700
leaq 0x580(%r14), %r13
xorps %xmm0, %xmm0
andl $0x0, 0x5a0(%r14)
movups %xmm0, 0x590(%r14)
movups %xmm0, 0x580(%r14)
xorl %ebp, %ebp
pushq $-0x1
popq %r14
pushq $-0x2
popq %r15
cmpq $0x24, %rbp
je 0x1e8de
movq %rbp, %r12
incq %rbp
movq %rbx, %rdi
pushq $0x2
popq %rsi
movq %rbp, %rdx
callq 0xf470
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf900
testq %rax, %rax
je 0x1e8ce
movzbl (%rax), %eax
addl $-0x42, %eax
cmpl $0x24, %eax
ja 0x1e8ce
movabsq $0x100000001, %rcx      # imm = 0x100000001
btq %rax, %rcx
jb 0x1e8c7
movabsq $0x200000002, %rcx      # imm = 0x200000002
btq %rax, %rcx
jb 0x1e8c3
movb $0x66, %cl
movabsq $0x1000000010, %rdx     # imm = 0x1000000010
btq %rax, %rdx
jb 0x1e8c9
jmp 0x1e8ce
movb $0x63, %cl
jmp 0x1e8c9
movb $0x62, %cl
movb %cl, (%r13,%r12)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x106f0
jmp 0x1e852
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x108d0
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_O2/wahern[P]cqueues/src/dns.c
// Function: resconf_getopts
static int resconf_getopts(lua_State *L) {
	struct dns_resolv_conf *resconf = resconf_check(L, 1);

	lua_newtable(L);

	lua_pushboolean(L, resconf->options.edns0);
	lua_setfield(L, -2, "edns0");

	lua_pushinteger(L, resconf->options.ndots);
	lua_setfield(L, -2, "ndots");

	lua_pushinteger(L, resconf->options.timeout);
	lua_setfield(L, -2, "timeout");

	lua_pushinteger(L, resconf->options.attempts);
	lua_setfield(L, -2, "attempts");

	lua_pushboolean(L, resconf->options.rotate);
	lua_setfield(L, -2, "rotate");

	lua_pushboolean(L, resconf->options.recurse);
	lua_setfield(L, -2, "recurse");

	lua_pushboolean(L, resconf->options.smart);
	lua_setfield(L, -2, "smart");

	lua_pushinteger(L, resconf->options.tcp);
	lua_setfield(L, -2, "tcp");

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x1edfb
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10270
movzbl 0x5b0(%r15), %esi
movq %r14, %rdi
callq 0x108d0
leaq 0x15741(%rip), %rdx     # 0x34077
pushq $-0x2
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0xf550
movl 0x5b4(%r15), %esi
movq %r14, %rdi
callq 0xf960
leaq 0x12b60(%rip), %rdx     # 0x314b9
movq %r14, %rdi
movl %ebp, %esi
callq 0xf550
movl 0x5b8(%r15), %esi
movq %r14, %rdi
callq 0xf960
leaq 0x11c93(%rip), %rdx     # 0x3060c
movq %r14, %rdi
movl %ebp, %esi
callq 0xf550
movl 0x5bc(%r15), %esi
movq %r14, %rdi
callq 0xf960
leaq 0x12b26(%rip), %rdx     # 0x314bf
movq %r14, %rdi
movl %ebp, %esi
callq 0xf550
movzbl 0x5c0(%r15), %esi
movq %r14, %rdi
callq 0x108d0
leaq 0x156c4(%rip), %rdx     # 0x3407e
movq %r14, %rdi
movl %ebp, %esi
callq 0xf550
movzbl 0x5c1(%r15), %esi
movq %r14, %rdi
callq 0x108d0
leaq 0x156ab(%rip), %rdx     # 0x34086
movq %r14, %rdi
movl %ebp, %esi
callq 0xf550
movzbl 0x5c2(%r15), %esi
movq %r14, %rdi
callq 0x108d0
leaq 0x15693(%rip), %rdx     # 0x3408f
movq %r14, %rdi
movl %ebp, %esi
callq 0xf550
movl 0x5c4(%r15), %esi
movq %r14, %rdi
callq 0xf960
leaq 0x1567a(%rip), %rdx     # 0x34096
movq %r14, %rdi
movl %ebp, %esi
callq 0xf550
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: resconf_setopts
static int resconf_setopts(lua_State *L) {
	struct dns_resolv_conf *resconf = resconf_check(L, 1);

	luaL_checktype(L, 2, LUA_TTABLE);

	resconf->options.edns0 = optfbool(L, 2, "edns0", resconf->options.edns0);
	resconf->options.ndots = optfint(L, 2, "ndots", resconf->options.ndots);
	resconf->options.timeout = optfint(L, 2, "timeout", resconf->options.timeout);
	resconf->options.attempts = optfint(L, 2, "attempts", resconf->options.attempts);
	resconf->options.rotate = optfbool(L, 2, "rotate", resconf->options.rotate);
	resconf->options.recurse = optfbool(L, 2, "recurse", resconf->options.recurse);
	resconf->options.smart = optfbool(L, 2, "smart", resconf->options.smart);
	resconf->options.tcp = optfint(L, 2, "tcp", resconf->options.tcp);

	return lua_pushboolean(L, 1), 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x1edfb
movq %rax, %r15
pushq $0x2
popq %rsi
pushq $0x5
popq %rdx
movq %r14, %rdi
callq 0xf700
movzbl 0x5b0(%r15), %edx
leaq 0x15612(%rip), %rsi     # 0x34077
movq %r14, %rdi
callq 0x1ee0d
movb %al, 0x5b0(%r15)
movl 0x5b4(%r15), %edx
leaq 0x12a37(%rip), %rsi     # 0x314b9
movq %r14, %rdi
callq 0x1df08
movl %eax, 0x5b4(%r15)
movl 0x5b8(%r15), %edx
leaq 0x11b6d(%rip), %rsi     # 0x3060c
movq %r14, %rdi
callq 0x1df08
movl %eax, 0x5b8(%r15)
movl 0x5bc(%r15), %edx
leaq 0x12a03(%rip), %rsi     # 0x314bf
movq %r14, %rdi
callq 0x1df08
movl %eax, 0x5bc(%r15)
movzbl 0x5c0(%r15), %edx
leaq 0x155a4(%rip), %rsi     # 0x3407e
movq %r14, %rdi
callq 0x1ee0d
movb %al, 0x5c0(%r15)
movzbl 0x5c1(%r15), %edx
leaq 0x1558e(%rip), %rsi     # 0x34086
movq %r14, %rdi
callq 0x1ee0d
movb %al, 0x5c1(%r15)
movzbl 0x5c2(%r15), %edx
leaq 0x15579(%rip), %rsi     # 0x3408f
movq %r14, %rdi
callq 0x1ee0d
movb %al, 0x5c2(%r15)
movl 0x5c4(%r15), %edx
leaq 0x15563(%rip), %rsi     # 0x34096
movq %r14, %rdi
callq 0x1df08
movl %eax, 0x5c4(%r15)
movq %r14, %rdi
movl %ebx, %esi
callq 0x108d0
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: resconf_getiface
static int resconf_getiface(lua_State *L) {
	struct dns_resolv_conf *resconf = resconf_check(L, 1);
	union { struct sockaddr_storage *other; struct sockaddr_in *in; struct sockaddr_in6 *in6; } any;
	char ipbuf[INET6_ADDRSTRLEN + 1];
	const char *ip = 0;
	int port = 0;

	any.other = &resconf->iface;

	switch (any.other->ss_family) {
	case AF_INET:
		ip = inet_ntop(AF_INET, &any.in->sin_addr, ipbuf, sizeof ipbuf);
		port = ntohs(any.in->sin_port);
		break;
	case AF_INET6:
		ip = inet_ntop(AF_INET6, &any.in6->sin6_addr, ipbuf, sizeof ipbuf);
		port = ntohs(any.in6->sin6_port);
		break;
	}

	if (!ip)
		return 0;

	if (port && port != 53)
		lua_pushfstring(L, "[%s]:%d", ip, port);
	else
		lua_pushstring(L, ip);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x1edfb
movq %rax, %r15
movzwl 0x5c8(%rax), %edi
xorl %ebp, %ebp
cmpl $0x2, %edi
je 0x1eb8b
cmpl $0xa, %edi
jne 0x1ebde
pushq $0xa
popq %rdi
movl $0x5d0, %esi            # imm = 0x5D0
jmp 0x1eb90
movl $0x5cc, %esi            # imm = 0x5CC
addq %r15, %rsi
movq %rsp, %rdx
pushq $0x2f
popq %rcx
callq 0xfe30
testq %rax, %rax
je 0x1ebde
movzwl 0x5ca(%r15), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
testl %ecx, %ecx
je 0x1ebbb
cmpl $0x35, %ecx
jne 0x1ebc8
movq %r14, %rdi
movq %rax, %rsi
callq 0xfc50
jmp 0x1ebdc
leaq 0x128e2(%rip), %rsi     # 0x314b1
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10080
movl %ebx, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: resconf_setiface
static int resconf_setiface(lua_State *L) {
	struct dns_resolv_conf *resconf = resconf_check(L, 1);
	const char *ip = luaL_checkstring(L, 2);
	int error;

	if ((error = dns_resconf_pton(&resconf->iface, ip)))
		return luaL_error(L, "%s: %s", ip, cqs_strerror(error));

	return lua_pushboolean(L, 1), 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x1edfb
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xf660
movq %rax, %r14
addq $0x5c8, %r15            # imm = 0x5C8
movq %r15, %rdi
movq %rax, %rsi
callq 0x10a30
testl %eax, %eax
je 0x1ec7a
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movl $0x80, %edx
movl %eax, %edi
callq 0xf260
leaq 0x116cd(%rip), %rsi     # 0x30333
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfdf0
movl %eax, %ebp
jmp 0x1ec84
movq %rbx, %rdi
movl %ebp, %esi
callq 0x108d0
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: resconf_loadfile
static int resconf_loadfile(lua_State *L) {
	struct dns_resolv_conf *resconf = resconf_check(L, 1);
	luaL_Stream *file = luaL_checkudata(L, 2, LUA_FILEHANDLE);
	int syntax = luaL_optint(L, 3, RESCONF_RESOLV_CONF);
	int error;

	switch (syntax) {
	case RESCONF_NSSWITCH_CONF:
		error = dns_nssconf_loadfile(resconf, file->f);
		break;
	default:
		error = dns_resconf_loadfile(resconf, file->f);
		break;
	}

	if (error)
		return lua_pushboolean(L, 0), lua_pushinteger(L, error), 2;

	return lua_pushboolean(L, 1), 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %r14
movl %r14d, %esi
callq 0x1edfb
movq %rax, %r15
leaq 0x11aef(%rip), %rdx     # 0x307a4
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xfd80
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xf420
movq (%r12), %rsi
movq %r15, %rdi
cmpl $0x1, %eax
jne 0x1ece5
callq 0xf810
jmp 0x1ecea
callq 0x10ae0
movl %eax, %r15d
testl %eax, %eax
je 0x1ed08
movq %rbx, %rdi
xorl %esi, %esi
callq 0x108d0
movslq %r15d, %rsi
movq %rbx, %rdi
callq 0xf960
jmp 0x1ed16
movq %rbx, %rdi
movl %r14d, %esi
callq 0x108d0
movl %r14d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: resconf_loadpath
static int resconf_loadpath(lua_State *L) {
	struct dns_resolv_conf *resconf = resconf_check(L, 1);
	const char *path = luaL_checkstring(L, 2);
	int syntax = luaL_optint(L, 3, RESCONF_RESOLV_CONF);
	int error;

	switch (syntax) {
	case RESCONF_NSSWITCH_CONF:
		error = dns_nssconf_loadpath(resconf, path);
		break;
	default:
		error = dns_resconf_loadpath(resconf, path);
		break;
	}

	if (error)
		return lua_pushboolean(L, 0), lua_pushinteger(L, error), 2;

	return lua_pushboolean(L, 1), 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %r14
movl %r14d, %esi
callq 0x1edfb
movq %rax, %r15
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0xf660
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xf420
movq %r15, %rdi
movq %r12, %rsi
cmpl $0x1, %eax
jne 0x1ed6c
callq 0xfd10
jmp 0x1ed71
callq 0xfb30
movl %eax, %r15d
testl %eax, %eax
je 0x1ed8f
movq %rbx, %rdi
xorl %esi, %esi
callq 0x108d0
movslq %r15d, %rsi
movq %rbx, %rdi
callq 0xf960
jmp 0x1ed9d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x108d0
movl %r14d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: resconf_search
static int resconf_search(lua_State *L) {
	dns_resconf_i_t *i;

	resconf_check(L, 1);

	lua_settop(L, 2);
	luaL_checktype(L, 2, LUA_TSTRING);

	i = lua_newuserdata(L, sizeof *i);
	*i = 0;

	lua_pushcclosure(L, &resconf__next, 3);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x1edfb
pushq $0x2
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x106f0
pushq $0x4
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0xf700
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0xfb70
andq $0x0, (%rax)
leaq 0x6d(%rip), %rsi        # 0x1ee56
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x10ad0
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: optfbool
static int optfbool(lua_State *L, int t, const char *k, _Bool def) {
	_Bool b;

	lua_getfield(L, t, k);
	b = (lua_isnil(L, -1))? def : lua_toboolean(L, -1);
	lua_pop(L, 1);

	return b;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rdx
movq %rdi, %rbx
pushq $0x2
popq %rsi
callq 0xf1f0
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xf270
testl %eax, %eax
je 0x1ee40
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xf560
testl %eax, %eax
setne %bpl
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x106f0
movzbl %bpl, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: resconf__next
static int resconf__next(lua_State *L) {
	struct dns_resolv_conf *resconf = *(struct dns_resolv_conf **)lua_touserdata(L, lua_upvalueindex(1));
	size_t len;
	const char *qn = lua_tolstring(L, lua_upvalueindex(2), &len);
	dns_resconf_i_t *i = lua_touserdata(L, lua_upvalueindex(3));
	char dn[DNS_D_MAXNAME + 1];

	if (!(len = dns_resconf_search(dn, sizeof dn, qn, len, resconf, i)))
		return 0;

	lua_pushlstring(L, dn, len);

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x103f0
movq (%rax), %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movl $0xfff0b9d6, %esi       # imm = 0xFFF0B9D6
movq %r15, %rdx
callq 0xf120
movq %rax, %r12
movq %rbx, %rdi
movl $0xfff0b9d5, %esi       # imm = 0xFFF0B9D5
callq 0x103f0
movq (%r15), %rcx
leaq 0x10(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
movq %r12, %rdx
movq %r14, %r8
movq %rax, %r9
callq 0x10980
movq %rax, (%r15)
testq %rax, %rax
je 0x1eed1
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0xf4e0
pushq $0x1
popq %rax
jmp 0x1eed3
xorl %eax, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: resconf__tostring
static int resconf__tostring(lua_State *L) {
	struct dns_resolv_conf *resconf = resconf_check(L, 1);
	char line[1024];
	luaL_Buffer B;
	FILE *fp;

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

	dns_resconf_dump(resconf, 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 %r12
pushq %rbx
subq $0x24a8, %rsp           # imm = 0x24A8
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x1edfb
movq %rax, %r12
callq 0x10290
testq %rax, %rax
je 0x1ef74
movq %rax, %r15
movq %r12, %rdi
movq %rax, %rsi
callq 0xfee0
leaq 0x488(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x106e0
movq %r15, %rdi
callq 0xf160
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdx
callq 0x10600
testq %rax, %rax
je 0x1ef5d
movq %r12, %rdi
movq %r14, %rsi
callq 0xf8a0
jmp 0x1ef3b
movq %r15, %rdi
callq 0xfd70
leaq 0x488(%rsp), %rdi
callq 0x107d0
jmp 0x1efc0
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 0xf260
leaq 0x12481(%rip), %rsi     # 0x31432
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfdf0
movl %eax, %ebx
movl %ebx, %eax
addq $0x24a8, %rsp           # imm = 0x24A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: resconf__gc
static int resconf__gc(lua_State *L) {
	struct dns_resolv_conf **resconf = luaL_checkudata(L, 1, RESCONF_CLASS);

	dns_resconf_close(*resconf);
	*resconf = 0;

	return 0;
}

// Assembly:
pushq %rbx
leaq 0x121f6(%rip), %rdx     # 0x311cf
pushq $0x1
popq %rsi
callq 0xfd80
movq %rax, %rbx
movq (%rax), %rdi
callq 0xff70
andq $0x0, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/dns.c
// Function: resconf_new
static int resconf_new(lua_State *L) {
	struct dns_resolv_conf **resconf = lua_newuserdata(L, sizeof *resconf);
	int error;

	*resconf = 0;

	if (!(*resconf = dns_resconf_open(&error)))
		return lua_pushboolean(L, 0), lua_pushinteger(L, error), 2;

	luaL_setmetatable(L, RESCONF_CLASS);

	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x8
popq %rsi
callq 0xfb70
movq %rax, %r14
andq $0x0, (%rax)
leaq 0x4(%rsp), %rdi
callq 0xf780
movq %rax, (%r14)
testq %rax, %rax
je 0x1f02f
leaq 0x121ac(%rip), %rsi     # 0x311cf
movq %rbx, %rdi
callq 0x10280
pushq $0x1
jmp 0x1f048
movq %rbx, %rdi
xorl %esi, %esi
callq 0x108d0
movslq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0xf960
pushq $0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq