LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x16ee6(%rip), %rsi     # 0x36207
callq 0x10180
leaq 0x26273(%rip), %rsi     # 0x455a0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movq %rbx, %rdi
xorl %esi, %esi
movl $0xd, %edx
callq 0x101e0
leaq 0x26173(%rip), %rsi     # 0x454c0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
leaq 0x15dc9(%rip), %rdx     # 0x35127
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movsd 0x15c8d(%rip), %xmm0    # 0x35000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x10530
movq %rbx, %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x101e0
leaq 0x2623a(%rip), %rsi     # 0x455d0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf910
leaq 0x16e61(%rip), %rdx     # 0x36212
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl $0x1, %esi
movq %rbx, %rdi
callq 0xf910
leaq 0x16e4b(%rip), %rdx     # 0x3621d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl $0x2, %esi
movq %rbx, %rdi
callq 0xf910
leaq 0x16e33(%rip), %rdx     # 0x36226
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf910
leaq 0x16e21(%rip), %rdx     # 0x36232
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl $0x1, %esi
movq %rbx, %rdi
callq 0xf910
leaq 0x16e0c(%rip), %rdx     # 0x3623e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16dfb(%rip), %rsi     # 0x3624c
callq 0x10180
leaq 0x26213(%rip), %rsi     # 0x45670
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movq %rbx, %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x101e0
leaq 0x261b3(%rip), %rsi     # 0x45630
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
leaq 0x15c99(%rip), %rdx     # 0x35127
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movsd 0x15b5d(%rip), %xmm0    # 0x35000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x10530
movq %rbx, %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x101e0
leaq 0x261da(%rip), %rsi     # 0x456a0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16d74(%rip), %rsi     # 0x36256
callq 0x10180
leaq 0x26222(%rip), %rsi     # 0x45710
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x101e0
leaq 0x261d2(%rip), %rsi     # 0x456e0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
leaq 0x15c08(%rip), %rdx     # 0x35127
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
leaq 0x16d2d(%rip), %rsi     # 0x36260
movq 0x27a56(%rip), %rdx     # 0x46f90
movq %rbx, %rdi
callq 0x1f57e
movsd 0x15ab6(%rip), %xmm0    # 0x35000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x10530
movq %rbx, %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x101e0
leaq 0x261d3(%rip), %rsi     # 0x45740
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16c64(%rip), %rsi     # 0x36274
callq 0x10180
leaq 0x26204(%rip), %rsi     # 0x45820
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movq %rbx, %rdi
xorl %esi, %esi
movl $0x7, %edx
callq 0x101e0
leaq 0x26164(%rip), %rsi     # 0x457a0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
leaq 0x15ada(%rip), %rdx     # 0x35127
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
leaq 0x16bff(%rip), %rsi     # 0x36260
movq 0x27928(%rip), %rdx     # 0x46f90
movq %rbx, %rdi
callq 0x1f57e
leaq 0x16c0a(%rip), %rsi     # 0x36281
movq 0x2794a(%rip), %rdx     # 0x46fc8
movq %rbx, %rdi
callq 0x1f57e
leaq 0x16c07(%rip), %rsi     # 0x36294
movq 0x278d4(%rip), %rdx     # 0x46f68
movq %rbx, %rdi
callq 0x1f57e
leaq 0x16c04(%rip), %rsi     # 0x362a7
movq 0x278fe(%rip), %rdx     # 0x46fa8
movq %rbx, %rdi
callq 0x1f57e
movsd 0x15946(%rip), %xmm0    # 0x35000
movl $0x88, %esi
movq %rbx, %rdi
callq 0x10530
movq %rbx, %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x101e0
leaq 0x26163(%rip), %rsi     # 0x45840
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10240
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1f7eb
cmpl $0x1, (%rax)
jne 0x1f7d1
leaq 0x19884(%rip), %rsi     # 0x3904b
movq %rbx, %rdi
callq 0xfbd0
jmp 0x1f7e4
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_O1/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 0x1f7eb
cmpl $0x1, (%rax)
jne 0x1f85d
leaq 0x197f8(%rip), %rsi     # 0x3904b
movq %r14, %rdi
callq 0xfbd0
jmp 0x1f8cc
movq %rax, %rbx
leaq 0x16a54(%rip), %rdx     # 0x362bb
movq %r14, %rdi
movl $0x1, %esi
callq 0x10720
testq %rax, %rax
je 0x1f88e
movq %rbx, %rsi
addq $0x30, %rsi
movq 0x28(%rbx), %rdx
movq %r14, %rdi
callq 0xf4c0
jmp 0x1f8cc
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_O1/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 0x169d9(%rip), %rdx     # 0x362c6
movl $0x1, %esi
callq 0xfcf0
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movb $0x0, 0x10(%rsp)
cmpl $0x1, (%rax)
je 0x1f921
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_O1/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 0x1f7eb
cmpl $0x1, (%rax)
leaq 0x20(%rax), %rax
leaq 0x196fd(%rip), %rsi     # 0x3904b
cmovneq %rax, %rsi
movq %rbx, %rdi
callq 0xfbd0
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1682c(%rip), %rdx     # 0x36311
movl $0x1, %esi
callq 0xfcf0
xorps %xmm0, %xmm0
movups %xmm0, 0x1f(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
cmpl $0x1, (%rax)
je 0x1fb1e
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_O1/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 0x166a8(%rip), %rdx     # 0x36333
movl $0x1, %esi
callq 0xfcf0
movq %rax, %rbx
movups 0x26321(%rip), %xmm0    # 0x45fc0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movq 0x26324(%rip), %rax     # 0x45fd0
movq %rax, 0x10(%rcx)
leaq 0x15476(%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 0x1fd8d
addq $0x28, %rbx
cmpl $0x1, %ebp
jne 0x1fd97
leaq 0x20(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x10630
xorl %r15d, %r15d
leaq 0x166d5(%rip), %r12     # 0x363d7
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jb 0x1fd1b
movl $0x1, %esi
movq %r14, %rdi
callq 0xf3a0
movzbl (%rbx,%r15), %eax
shrl $0x4, %eax
movb (%rax,%r12), %al
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x30(%rsp)
movb %al, (%rcx,%rdx)
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jb 0x1fd56
movl $0x1, %esi
movq %r14, %rdi
callq 0xf3a0
movzbl (%rbx,%r15), %eax
andl $0xf, %eax
movb (%rax,%r12), %al
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x30(%rsp)
movb %al, (%rcx,%rdx)
incq %r15
cmpq $0x14, %r15
jne 0x1fd02
leaq 0x20(%rsp), %rdi
callq 0x10710
jmp 0x1fda7
movq %r15, %rdi
callq 0xf980
jmp 0x1fda7
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_O1/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 0x163ee(%rip), %rdx     # 0x361e7
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_O1/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 0x163a3(%rip), %rdx     # 0x361e7
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 0x165a3(%rip), %rdx     # 0x36419
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 0x1635e(%rip), %rdx     # 0x361fa
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 0x1655a(%rip), %rdx     # 0x3641c
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 0x16537(%rip), %rdx     # 0x3641f
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 0x15fbf(%rip), %rdx     # 0x35ecd
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl 0x5c(%r14), %esi
shrl $0x1f, %esi
movq %rbx, %rdi
callq 0x10800
leaq 0x164f1(%rip), %rdx     # 0x36422
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 0x156cd(%rip), %rdx     # 0x35624
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movzbl 0x5f(%r14), %esi
andl $0xf, %esi
movq %rbx, %rdi
callq 0xf910
leaq 0x16286(%rip), %rdx     # 0x36201
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_O1/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 0x15f8c(%rip), %rdx     # 0x361e7
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 0x202cf
leaq 0x16163(%rip), %rdx     # 0x36425
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 0x2030f
movl %eax, %ebp
movq %rbx, %rdi
callq 0xf980
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0xf910
movl $0x2, %ebp
jmp 0x20321
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_O1/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 0x15ea7(%rip), %rdx     # 0x361e7
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_O1/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 0x15e59(%rip), %rdx     # 0x361e7
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 0x2048e
movq %rbx, %rdi
movl $0x2, %esi
movl $0x5, %edx
callq 0xf6c0
leaq 0x15dd6(%rip), %rsi     # 0x361f2
movq %rbx, %rdi
xorl %edx, %edx
callq 0x20572
movl %eax, (%r14)
leaq 0x189de(%rip), %rsi     # 0x38e0e
movq %rbx, %rdi
xorl %edx, %edx
callq 0x20572
movl %eax, 0x10(%r14)
leaq 0x15cfc(%rip), %rsi     # 0x36141
movq %rbx, %rdi
xorl %edx, %edx
callq 0x20572
movl %eax, 0x14(%r14)
leaq 0x18a2f(%rip), %rdx     # 0x38e89
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 0x2048e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
movq %rbx, %rdi
callq 0xf920
leal -0x2(%rax), %edx
leaq 0x112(%rip), %rsi       # 0x205b2
movq %rbx, %rdi
callq 0x109f0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15d1f(%rip), %rdx     # 0x361e7
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 0x207ba
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_O1/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 0x20566
xorl %edx, %edx
callq 0xfd20
testq %rax, %rax
jmp 0x2056d
callq 0xf540
testl %eax, %eax
setne %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x2, %esi
callq 0xf1e0
movslq %ebx, %rdx
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf400
movq %rax, %rbx
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x20758
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
movzwl 0x1e(%rsp), %r15d
addq $0x11, %r15
movl 0x10(%rsp), %eax
cmpq $0x63, %rax
ja 0x20659
shlq $0x4, %rax
leaq 0x25998(%rip), %rcx     # 0x45fe0
movzwl 0x8(%rax,%rcx), %eax
testq %rax, %rax
je 0x20659
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 0x20724
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 0x20724
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 0x15d42(%rip), %rsi     # 0x36459
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfd60
movl 0x10(%rsp), %eax
cmpq $0x63, %rax
ja 0x20742
shlq $0x4, %rax
leaq 0x258a7(%rip), %rcx     # 0x45fe0
movq (%rax,%rcx), %rsi
testq %rsi, %rsi
jne 0x20749
leaq 0x15b72(%rip), %rsi     # 0x362bb
movq %rbx, %rdi
callq 0x101f0
movl $0x1, %eax
jmp 0x207a8
movl (%rsp), %edi
testl %edi, %edi
je 0x207a6
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 0x15cae(%rip), %rsi     # 0x36445
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfd60
jmp 0x207a8
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_O1/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 %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %r15
addq $0x5c, %rdi
cmpq %rdx, %r15
jae 0x207e1
movq %r15, %rdx
callq 0xfa60
movq %r15, 0x50(%rbx)
orb $0x2, 0x5e(%rbx)
jmp 0x207ed
movq %rdx, %r14
callq 0xfa60
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
popq %rbx
popq %r14
popq %r15
jmp 0xf3c0
// File: /workspace/github_c_makefile_star2_O1/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 0x159c0(%rip), %rdx     # 0x361e7
movl $0x1, %esi
callq 0xfcf0
movq %rax, %r15
callq 0x10200
testq %rax, %rax
je 0x208ce
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 0x208b2
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 0x20892
movq %r14, %rdi
callq 0xfce0
leaq 0x480(%rsp), %rdi
callq 0x10710
movl $0x1, %eax
jmp 0x20918
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 0x15b5f(%rip), %rsi     # 0x3646a
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfd60
addq $0x24a0, %rsp           # imm = 0x24A0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0xf260
testl %eax, %eax
jle 0x2094f
movq %rbx, %rdi
movl $0x1, %esi
callq 0xfb80
testl %eax, %eax
je 0x20966
movl $0x160, %edx            # imm = 0x160
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf400
xorl %r14d, %r14d
jmp 0x2098c
movq %rsp, %r15
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0xf620
movq %rax, %r14
movq (%r15), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0xf400
cmpq $0xd, %rax
movl $0xc, %r12d
cmovaeq %rax, %r12
addq $0x5c, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xfb00
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xf750
leaq 0x15827(%rip), %rsi     # 0x361e7
movq %rbx, %rdi
callq 0x101f0
movq %r15, %rdi
movq %r12, %rsi
callq 0x10a30
testq %r14, %r14
je 0x209e7
movq (%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x207ba
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x157e4(%rip), %rdx     # 0x361e7
movl $0x1, %esi
callq 0x10720
testq %rax, %rax
je 0x20a23
leaq 0x15a5d(%rip), %rsi     # 0x36476
movq %rbx, %rdi
callq 0xfbd0
jmp 0x20a2b
movq %rbx, %rdi
callq 0xf980
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x15740(%rip), %rdx     # 0x36207
movl $0x1, %esi
callq 0xfcf0
movq (%rax), %r13
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x101e0
movl $0x1, %r14d
movq %rsp, %r15
leaq 0x159f9(%rip), %r12     # 0x364e9
xorps %xmm0, %xmm0
movups %xmm0, 0x1f(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movzwl (%r13), %edi
cmpl $0x2, %edi
je 0x20b1c
cmpl $0xa, %edi
jne 0x20b74
movl $0xa, %edi
movl $0x8, %esi
jmp 0x20b21
movl $0x4, %esi
addq %r13, %rsi
movq %r15, %rdx
movl $0x2f, %ecx
callq 0xfda0
movzwl 0x2(%r13), %eax
rolw $0x8, %ax
testw %ax, %ax
je 0x20b47
movzwl %ax, %ecx
cmpl $0x35, %ecx
jne 0x20b54
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfbd0
jmp 0x20b64
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xfff0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r14, %rdx
callq 0xfb20
subq $-0x80, %r13
incq %r14
cmpq $0x4, %r14
jne 0x20af0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x98, %rsp
movq %rdi, %rbx
leaq 0x15654(%rip), %rdx     # 0x36207
movl $0x1, %esi
callq 0xfcf0
movq (%rax), %r14
movq %rbx, %rdi
movl $0x2, %esi
movl $0x5, %edx
callq 0xf6c0
xorl %r13d, %r13d
movq %r13, %r12
cmpq $0x3, %r13
je 0x20cc8
leaq 0x1(%r12), %r13
movq %rbx, %rdi
movl $0x2, %esi
movq %r13, %rdx
callq 0xf450
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf8b0
testq %rax, %rax
je 0x20c81
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x10950
testl %eax, %eax
je 0x20cab
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movl $0x80, %edx
movl %eax, %edi
leaq 0x10(%rsp), %rsi
callq 0xf250
xorl %ebp, %ebp
movq %rbx, %rdi
leaq 0x146c5(%rip), %rsi     # 0x35333
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfd60
movl %eax, 0xc(%rsp)
jmp 0x20cbb
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 $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
movb $0x1, %bpl
subq $-0x80, %r14
testb %bpl, %bpl
jne 0x20bd5
cmpq $0x3, %r12
movl 0xc(%rsp), %ebp
jb 0x20ce4
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x15500(%rip), %rdx     # 0x36207
movl $0x1, %esi
callq 0xfcf0
movl $0x180, %r14d           # imm = 0x180
addq (%rax), %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x101e0
movl $0x1, %r15d
cmpb $0x0, (%r14)
je 0x20d5d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfbd0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0xfb20
addq $0x100, %r14            # imm = 0x100
incq %r15
cmpq $0x5, %r15
jne 0x20d2c
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x15490(%rip), %rdx     # 0x36207
movl $0x1, %esi
callq 0xfcf0
movl $0x180, %r14d           # imm = 0x180
addq (%rax), %r14
movq %rbx, %rdi
movl $0x2, %esi
movl $0x5, %edx
callq 0xf6c0
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0xf450
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf8b0
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
testq %rax, %rax
je 0x20dda
movq %rax, %rsi
callq 0xf4d0
jmp 0x20de1
xorl %esi, %esi
callq 0xf750
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
addq $0x100, %r14            # imm = 0x100
incq %r15
cmpq $0x5, %r15
jne 0x20da2
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x153dc(%rip), %rdx     # 0x36207
movl $0x1, %esi
callq 0xfcf0
movq (%rax), %r14
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x101e0
movabsq $0x100000001, %r13      # imm = 0x100000001
movabsq $0x200000002, %rbp      # imm = 0x200000002
movabsq $0x1000000010, %r12     # imm = 0x1000000010
movzbl 0x580(%r14,%r15), %eax
leal -0x42(%rax), %ecx
cmpl $0x24, %ecx
ja 0x20e8f
btq %rcx, %r13
jb 0x20e95
btq %rcx, %rbp
jb 0x20e9e
btq %rcx, %r12
leaq 0x18205(%rip), %rsi     # 0x39092
jb 0x20ea5
testl %eax, %eax
jne 0x20ebe
jmp 0x20ec7
leaq 0x181f0(%rip), %rsi     # 0x3908c
jmp 0x20ea5
leaq 0x181f3(%rip), %rsi     # 0x39098
movq %rbx, %rdi
callq 0xfbd0
leaq 0x1(%r15), %rdx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xfb20
incq %r15
cmpq $0x24, %r15
jne 0x20e65
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/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
leaq 0x15317(%rip), %rdx     # 0x36207
movl $0x1, %esi
callq 0xfcf0
movq (%rax), %r14
movq %rbx, %rdi
movl $0x2, %esi
movl $0x5, %edx
callq 0xf6c0
leaq 0x580(%r14), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x590(%r14)
movups %xmm0, 0x580(%r14)
movl $0x0, 0x5a0(%r14)
xorl %r14d, %r14d
movabsq $0x100000001, %r12      # imm = 0x100000001
movabsq $0x200000002, %r13      # imm = 0x200000002
movq %r14, %rbp
incq %r14
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0xf450
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf8b0
testq %rax, %rax
je 0x20fac
movzbl (%rax), %eax
addl $-0x42, %eax
cmpl $0x24, %eax
ja 0x20fac
btq %rax, %r12
jb 0x20fa6
btq %rax, %r13
jb 0x20fa2
movb $0x66, %cl
movabsq $0x1000000010, %rdx     # imm = 0x1000000010
btq %rax, %rdx
jb 0x20fa8
jmp 0x20fac
movb $0x63, %cl
jmp 0x20fa8
movb $0x62, %cl
movb %cl, (%r15,%rbp)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10640
cmpq $0x24, %r14
jne 0x20f4b
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x15219(%rip), %rdx     # 0x36207
movl $0x1, %esi
callq 0xfcf0
movq (%rax), %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x101e0
movzbl 0x5b0(%r14), %esi
movq %rbx, %rdi
callq 0x10800
leaq 0x180a9(%rip), %rdx     # 0x390c7
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl 0x5b4(%r14), %esi
movq %rbx, %rdi
callq 0xf910
leaq 0x154b0(%rip), %rdx     # 0x364f1
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl 0x5b8(%r14), %esi
movq %rbx, %rdi
callq 0xf910
leaq 0x145d0(%rip), %rdx     # 0x35634
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl 0x5bc(%r14), %esi
movq %rbx, %rdi
callq 0xf910
leaq 0x15470(%rip), %rdx     # 0x364f7
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movzbl 0x5c0(%r14), %esi
movq %rbx, %rdi
callq 0x10800
leaq 0x18023(%rip), %rdx     # 0x390ce
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movzbl 0x5c1(%r14), %esi
movq %rbx, %rdi
callq 0x10800
leaq 0x18007(%rip), %rdx     # 0x390d6
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movzbl 0x5c2(%r14), %esi
movq %rbx, %rdi
callq 0x10800
leaq 0x17fec(%rip), %rdx     # 0x390df
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xf530
movl 0x5c4(%r14), %esi
movq %rbx, %rdi
callq 0xf910
leaq 0x17fd0(%rip), %rdx     # 0x390e6
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_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x150c9(%rip), %rdx     # 0x36207
movl $0x1, %esi
callq 0xfcf0
movq (%rax), %r14
movq %rbx, %rdi
movl $0x2, %esi
movl $0x5, %edx
callq 0xf6c0
movzbl 0x5b0(%r14), %edx
leaq 0x17f5b(%rip), %rsi     # 0x390c7
movq %rbx, %rdi
callq 0x21558
movb %al, 0x5b0(%r14)
movl 0x5b4(%r14), %edx
leaq 0x15368(%rip), %rsi     # 0x364f1
movq %rbx, %rdi
callq 0x20572
movl %eax, 0x5b4(%r14)
movl 0x5b8(%r14), %edx
leaq 0x1448e(%rip), %rsi     # 0x35634
movq %rbx, %rdi
callq 0x20572
movl %eax, 0x5b8(%r14)
movl 0x5bc(%r14), %edx
leaq 0x15334(%rip), %rsi     # 0x364f7
movq %rbx, %rdi
callq 0x20572
movl %eax, 0x5bc(%r14)
movzbl 0x5c0(%r14), %edx
leaq 0x17eed(%rip), %rsi     # 0x390ce
movq %rbx, %rdi
callq 0x21558
movb %al, 0x5c0(%r14)
movzbl 0x5c1(%r14), %edx
leaq 0x17ed7(%rip), %rsi     # 0x390d6
movq %rbx, %rdi
callq 0x21558
movb %al, 0x5c1(%r14)
movzbl 0x5c2(%r14), %edx
leaq 0x17ec2(%rip), %rsi     # 0x390df
movq %rbx, %rdi
callq 0x21558
movb %al, 0x5c2(%r14)
movl 0x5c4(%r14), %edx
leaq 0x17eac(%rip), %rsi     # 0x390e6
movq %rbx, %rdi
callq 0x20572
movl %eax, 0x5c4(%r14)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x14f93(%rip), %rdx     # 0x36207
movl $0x1, %esi
callq 0xfcf0
movq (%rax), %r14
movzwl 0x5c8(%r14), %edi
cmpl $0x2, %edi
je 0x2129f
cmpl $0xa, %edi
jne 0x212c2
movl $0xa, %edi
movl $0x5d0, %esi            # imm = 0x5D0
jmp 0x212a4
movl $0x5cc, %esi            # imm = 0x5CC
addq %r14, %rsi
movq %rsp, %rdx
movl $0x2f, %ecx
callq 0xfda0
movzwl 0x5ca(%r14), %ecx
rolw $0x8, %cx
jmp 0x212c6
xorl %eax, %eax
xorl %ecx, %ecx
testq %rax, %rax
je 0x212e4
movzwl %cx, %ecx
testl %ecx, %ecx
je 0x212d7
cmpl $0x35, %ecx
jne 0x212e8
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfbd0
jmp 0x212fc
xorl %eax, %eax
jmp 0x21301
leaq 0x151fa(%rip), %rsi     # 0x364e9
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfff0
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x14ee7(%rip), %rdx     # 0x36207
movl $0x1, %ebp
movl $0x1, %esi
callq 0xfcf0
movl $0x5c8, %r15d           # imm = 0x5C8
addq (%rax), %r15
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0xf620
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0x10950
testl %eax, %eax
je 0x213a5
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 0xf250
leaq 0x13fa2(%rip), %rsi     # 0x35333
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfd60
movl %eax, %ebp
jmp 0x213b2
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10800
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq