LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2284d(%rip), %rsi     # 0x49424
leaq 0x33df2(%rip), %rdx     # 0x5a9d0
leaq 0x33e6b(%rip), %rcx     # 0x5aa50
xorl %r8d, %r8d
callq 0x267e0
movq -0x8(%rbp), %rdi
leaq 0x22818(%rip), %rsi     # 0x49410
movq 0x35389(%rip), %rdx     # 0x5bf88
xorl %ecx, %ecx
callq 0x26b20
movq -0x8(%rbp), %rdi
leaq 0x22820(%rip), %rsi     # 0x49431
movq 0x353a8(%rip), %rdx     # 0x5bfc0
xorl %ecx, %ecx
callq 0x26b20
movq -0x8(%rbp), %rdi
leaq 0x2281a(%rip), %rsi     # 0x49444
movq 0x3532f(%rip), %rdx     # 0x5bf60
xorl %ecx, %ecx
callq 0x26b20
movq -0x8(%rbp), %rdi
leaq 0x22814(%rip), %rsi     # 0x49457
movq 0x35356(%rip), %rdx     # 0x5bfa0
xorl %ecx, %ecx
callq 0x26b20
movq -0x8(%rbp), %rdi
movsd 0x213a3(%rip), %xmm0    # 0x48000
movl $0x88, %esi
callq 0x106d0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x10330
movq -0x8(%rbp), %rdi
leaq 0x33dee(%rip), %rsi     # 0x5aa70
xorl %edx, %edx
callq 0x10390
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x26ea0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x26e70
movq -0x10(%rbp), %rdi
leaq 0x26709(%rip), %rsi     # 0x4d56b
callq 0xfcc0
movl $0x1, -0x4(%rbp)
jmp 0x26e94
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
addq $0x10, %rsi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdx
callq 0xf510
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/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 %rbp
movq %rsp, %rbp
subq $0x2040, %rsp           # imm = 0x2040
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x26ea0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x26f56
movq -0x10(%rbp), %rdi
leaq 0x26626(%rip), %rsi     # 0x4d56b
callq 0xfcc0
movl $0x1, -0x4(%rbp)
jmp 0x26ffc
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x22505(%rip), %rdx     # 0x4946b
callq 0x108e0
cmpq $0x0, %rax
je 0x26f90
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
addq $0x10, %rsi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdx
callq 0xf510
jmp 0x26ff5
movq -0x10(%rbp), %rdi
leaq -0x2038(%rbp), %rsi
callq 0x107e0
leaq -0x2038(%rbp), %rdi
movl $0x2000, %esi           # imm = 0x2000
callq 0xf3f0
movq %rax, %rdi
movq -0x18(%rbp), %rdx
addq $0x20, %rdx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movl $0x2000, %esi           # imm = 0x2000
callq 0xf8f0
movq %rax, -0x2040(%rbp)
movq -0x2040(%rbp), %rax
addq -0x2028(%rbp), %rax
movq %rax, -0x2028(%rbp)
leaq -0x2038(%rbp), %rdi
callq 0x108d0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x2040, %rsp           # imm = 0x2040
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x2244a(%rip), %rdx     # 0x49476
callq 0xfe00
movq %rax, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x11, %edx
callq 0xf7d0
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
je 0x27069
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
leaq -0x30(%rbp), %rdx
movl $0x2, %edi
movl $0x11, %ecx
callq 0xfeb0
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xfcc0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x26ea0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x270d0
movq -0x10(%rbp), %rdi
leaq 0x264a9(%rip), %rsi     # 0x4d56b
callq 0xfcc0
movl $0x1, -0x4(%rbp)
jmp 0x270e8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
callq 0xfcc0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x220d5(%rip), %rdx     # 0x494c1
callq 0xfe00
movq %rax, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x2f, %edx
callq 0xf7d0
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
je 0x27429
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
leaq -0x40(%rbp), %rdx
movl $0xa, %edi
movl $0x2f, %ecx
callq 0xfeb0
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xfcc0
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x219db(%rip), %rdx     # 0x49397
callq 0xfe00
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x10c70
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movzwl %ax, %edi
callq 0xf0e0
movzwl %ax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq 0x5c(%rax), %rcx
andq $0xffff, %rdx           # imm = 0xFFFF
andq $-0x10000, %rcx         # imm = 0xFFFF0000
orq %rdx, %rcx
movq %rcx, 0x5c(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x107f0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x2195b(%rip), %rdx     # 0x49397
callq 0xfe00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x5c, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x10330
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
shrq $0x17, %rax
andq $0x1, %rax
movl %eax, %esi
callq 0x109d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x21b41(%rip), %rdx     # 0x495c9
callq 0xf580
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
shrq $0x13, %rax
andq $0xf, %rax
movl %eax, %eax
movl %eax, %esi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x218f1(%rip), %rdx     # 0x493aa
callq 0xf580
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
shrq $0x12, %rax
andq $0x1, %rax
movl %eax, %esi
callq 0x109d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x21ae4(%rip), %rdx     # 0x495cc
callq 0xf580
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
shrq $0x11, %rax
andq $0x1, %rax
movl %eax, %esi
callq 0x109d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x21ab8(%rip), %rdx     # 0x495cf
callq 0xf580
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
shrq $0x10, %rax
andq $0x1, %rax
movl %eax, %esi
callq 0x109d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x21533(%rip), %rdx     # 0x49079
callq 0xf580
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
shrq $0x1f, %rax
andq $0x1, %rax
movl %eax, %esi
callq 0x109d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x21a5d(%rip), %rdx     # 0x495d2
callq 0xf580
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
shrq $0x1c, %rax
andq $0x7, %rax
movl %eax, %eax
movl %eax, %esi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x20c2a(%rip), %rdx     # 0x487d0
callq 0xf580
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
shrq $0x18, %rax
andq $0xf, %rax
movl %eax, %eax
movl %eax, %esi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x217da(%rip), %rdx     # 0x493b1
callq 0xf580
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x212db(%rip), %rdx     # 0x49397
callq 0xfe00
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x10c70
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
leaq -0x28(%rbp), %rdx
callq 0xf6a0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0xf450
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movl $0x5, %esi
movl $0x1, %edx
callq 0xf450
movl %eax, -0x38(%rbp)
movb $0x1, %al
cmpl $0x1, -0x1c(%rbp)
movb %al, -0x3d(%rbp)
je 0x28141
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0x214a2(%rip), %rdx     # 0x495d5
callq 0xf440
cmpl $0x0, %eax
setne %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x34(%rbp), %r8d
movl -0x38(%rbp), %r9d
xorl %eax, %eax
xorl %eax, %eax
movl $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x10880
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x2819b
movq -0x10(%rbp), %rdi
callq 0xfa10
movq -0x10(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0xf9a0
movl $0x2, -0x4(%rbp)
jmp 0x281b0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x107f0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x211bb(%rip), %rdx     # 0x49397
callq 0xfe00
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movl $0xf, %edx
callq 0xf450
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x10950
movq -0x20(%rbp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0xf9a0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x2114b(%rip), %rdx     # 0x49397
callq 0xfe00
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x107f0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xfa50
movq -0x8(%rbp), %rdi
movl $0x58, %esi
callq 0xfbe0
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
xorl %esi, %esi
movl $0x58, %edx
callq 0xf7d0
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10750
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0xf280
cmpl $0x0, %eax
je 0x2837c
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movl $0x5, %edx
callq 0xf740
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x210bd(%rip), %rdx     # 0x493a2
xorl %ecx, %ecx
callq 0x284d0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x2502a(%rip), %rdx     # 0x4d32e
xorl %ecx, %ecx
callq 0x284d0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x20fcd(%rip), %rdx     # 0x492f1
xorl %ecx, %ecx
callq 0x284d0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x25065(%rip), %rdx     # 0x4d3a9
callq 0xf200
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xf940
movq -0x18(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x2837a
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x107f0
jmp 0x2837c
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf9b0
movq -0x28(%rbp), %rdi
movl %eax, %edx
subl $0x2, %edx
leaq 0x193(%rip), %rsi       # 0x28530
callq 0x10bf0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x20fcb(%rip), %rdx     # 0x49397
callq 0xfe00
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq -0x18(%rbp), %rdx
callq 0xf6a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x28930
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x107f0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xfc70
cmpl $0x0, %eax
je 0x284ae
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xfe30
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x284c5
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xf590
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0xf200
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xf450
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x107f0
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x104b0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfff0b9d6, %esi       # imm = 0xFFF0B9D6
callq 0x104b0
movq %rax, -0x20(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
leaq -0x3c(%rbp), %r8
callq 0xfe80
cmpl $0x0, %eax
jne 0x28602
cmpl $0x0, -0x3c(%rbp)
je 0x285ed
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0xcc(%rbp)
leaq -0xbc(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movl -0xcc(%rbp), %edi
leaq -0xbc(%rbp), %rsi
movl $0x80, %edx
callq 0xf270
movq -0xc8(%rbp), %rdi
movq %rax, %rdx
leaq 0x21017(%rip), %rsi     # 0x495f5
movb $0x0, %al
callq 0xfe70
movl %eax, -0xc0(%rbp)
jmp 0x285f7
xorl %eax, %eax
movl %eax, -0xc0(%rbp)
jmp 0x285f7
movl -0xc0(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2861a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0x28630
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/dns.c
// Function: rr_push
static void rr_push(lua_State *L, struct dns_rr *any, struct dns_packet *P) {
	char name[DNS_D_MAXNAME + 1];
	size_t namelen, datasiz;
	struct rr *rr;
	int error;

	namelen = dns_d_expand(name, sizeof name, any->dn.p, P, &error);
	datasiz = rr_bufsiz(any);

	rr = lua_newuserdata(L, offsetof(struct rr, data) + datasiz + namelen + 1);

	rr->attr = *any;

	rr->name = (char *)rr + offsetof(struct rr, data) + datasiz;
	memcpy(rr->name, name, namelen);
	rr->name[namelen] = '\0';

	memset(&rr->data, '\0', datasiz);

	if (any->section != DNS_S_QD) {
		dns_any_init(&rr->data, datasiz);

		if ((error = dns_any_parse(&rr->data, any, P)))
			luaL_error(L, "dns.rr.parse: %s", cqs_strerror(error));
	}

	luaL_setmetatable(L, rr_tname(any));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x120(%rbp), %rdi
movq -0x10(%rbp), %rax
movw 0x4(%rax), %ax
movq -0x18(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
leaq -0x13c(%rbp), %r8
movzwl %ax, %edx
callq 0xffd0
movq %rax, -0x128(%rbp)
movq -0x10(%rbp), %rdi
callq 0x28810
movq %rax, -0x130(%rbp)
movq -0x8(%rbp), %rdi
movq -0x130(%rbp), %rsi
addq $0x20, %rsi
addq -0x128(%rbp), %rsi
addq $0x1, %rsi
callq 0xfbe0
movq %rax, -0x138(%rbp)
movq -0x138(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x138(%rbp), %rcx
addq $0x20, %rcx
addq -0x130(%rbp), %rcx
movq -0x138(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x138(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x120(%rbp), %rsi
movq -0x128(%rbp), %rdx
callq 0xfb40
movq -0x138(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x128(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x138(%rbp), %rdi
addq $0x20, %rdi
movq -0x130(%rbp), %rdx
xorl %esi, %esi
callq 0xf7d0
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
je 0x287d8
movq -0x138(%rbp), %rdi
addq $0x20, %rdi
movq -0x130(%rbp), %rsi
callq 0x10860
movq -0x138(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xff80
movl %eax, -0x13c(%rbp)
cmpl $0x0, %eax
je 0x287d6
movq -0x8(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movl -0x13c(%rbp), %eax
movl %eax, -0x1cc(%rbp)
leaq -0x1bc(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movl -0x1cc(%rbp), %edi
leaq -0x1bc(%rbp), %rsi
movl $0x80, %edx
callq 0xf270
movq -0x1c8(%rbp), %rdi
movq %rax, %rdx
leaq 0x20e3a(%rip), %rsi     # 0x49609
movb $0x0, %al
callq 0xfe70
jmp 0x287d8
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x288a0
movq -0x1d8(%rbp), %rdi
movq %rax, %rsi
callq 0x10340
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/dns.c
// Function: rr_bufsiz
static size_t rr_bufsiz(const struct dns_rr *rr) {
	const struct rr_info *info;
	size_t minbufsiz = offsetof(struct dns_txt, data) + rr->rd.len + 1;

	if ((info = rr_info(rr->type)) && info->bufsiz)
		return MAX(info->bufsiz, minbufsiz);
	else
		return minbufsiz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x16(%rax), %eax
addq $0x10, %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x288f0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x28881
movq -0x18(%rbp), %rax
movzwl 0x8(%rax), %eax
cmpl $0x0, %eax
je 0x28881
movq -0x18(%rbp), %rax
movzwl 0x8(%rax), %eax
cmpq -0x20(%rbp), %rax
jbe 0x2886f
movq -0x18(%rbp), %rax
movzwl 0x8(%rax), %eax
movq %rax, -0x28(%rbp)
jmp 0x28877
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x28889
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/dns.c
// Function: rr_tname
static const char *rr_tname(const struct dns_rr *rr) {
	const struct rr_info *info;

	if ((info = rr_info(rr->type)) && info->tname)
		return info->tname;
	else
		return RR_ANY_CLASS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x288f0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x288d9
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x288d9
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x288e4
leaq 0x20b8b(%rip), %rax     # 0x4946b
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0x28997
movq -0x8(%rbp), %rdi
addq $0x5c, %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdx
callq 0xfb40
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x5c(%rax), %rcx
andq $-0x20001, %rcx         # imm = 0xFFFDFFFF
orq $0x20000, %rcx          # imm = 0x20000
movq %rcx, 0x5c(%rax)
jmp 0x289b8
movq -0x8(%rbp), %rdi
addq $0x5c, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xfb40
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rdi
callq 0xf820
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0xf7d0
movq -0x8(%rbp), %rdi
movl $0xc, %esi
callq 0xf410
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x24e0, %rsp           # imm = 0x24E0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x20988(%rip), %rdx     # 0x49397
callq 0xfe00
movq %rax, -0x18(%rbp)
callq 0x10350
movq %rax, -0x2448(%rbp)
cmpq $0x0, %rax
jne 0x28a89
movq -0x10(%rbp), %rax
movq %rax, -0x24d0(%rbp)
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x24d4(%rbp)
leaq -0x24c8(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movl -0x24d4(%rbp), %edi
leaq -0x24c8(%rbp), %rsi
movl $0x80, %edx
callq 0xf270
movq -0x24d0(%rbp), %rdi
movq %rax, %rdx
leaq 0x20b9d(%rip), %rsi     # 0x4961a
movb $0x0, %al
callq 0xfe70
movl %eax, -0x4(%rbp)
jmp 0x28b07
movq -0x18(%rbp), %rdi
movq -0x2448(%rbp), %rsi
callq 0x10790
movq -0x10(%rbp), %rdi
leaq -0x2440(%rbp), %rsi
callq 0x107e0
movq -0x2448(%rbp), %rdi
callq 0xf170
leaq -0x420(%rbp), %rdi
movq -0x2448(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x106f0
cmpq $0x0, %rax
je 0x28ae8
leaq -0x420(%rbp), %rsi
leaq -0x2440(%rbp), %rdi
callq 0xf8e0
jmp 0x28ab5
movq -0x2448(%rbp), %rdi
callq 0xfdf0
leaq -0x2440(%rbp), %rdi
callq 0x108d0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x24e0, %rsp           # imm = 0x24E0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xf280
cmpl $0x0, %eax
jle 0x28b5a
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xfc70
cmpl $0x0, %eax
je 0x28b73
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x160, %edx            # imm = 0x160
callq 0xf450
movq %rax, -0x20(%rbp)
jmp 0x28b9f
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x28(%rbp), %rdx
callq 0xf6a0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x2, %esi
callq 0xf450
movq %rax, -0x20(%rbp)
movl $0xc, %eax
cmpq -0x20(%rbp), %rax
jbe 0x28bb5
movl $0xc, %eax
movq %rax, -0x38(%rbp)
jmp 0x28bbd
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x5c, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xfbe0
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
movq -0x30(%rbp), %rdx
xorl %esi, %esi
callq 0xf7d0
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2079c(%rip), %rsi     # 0x49397
callq 0x10340
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x10c30
cmpq $0x0, -0x18(%rbp)
je 0x28c25
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x28930
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x2074b(%rip), %rdx     # 0x49397
callq 0x108e0
cmpq $0x0, %rax
je 0x28c69
movq -0x8(%rbp), %rdi
leaq 0x209c4(%rip), %rsi     # 0x49626
callq 0xfcc0
jmp 0x28c72
movq -0x8(%rbp), %rdi
callq 0xfa10
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x29bd0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x10330
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x3, %rax
jae 0x28e87
xorps %xmm0, %xmm0
movups %xmm0, -0x31(%rbp)
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x58(%rbp)
subl $0x2, %eax
je 0x28dcb
jmp 0x28dc1
movl -0x58(%rbp), %eax
subl $0xa, %eax
je 0x28dfb
jmp 0x28e2b
movq -0x20(%rbp), %rsi
addq $0x4, %rsi
leaq -0x50(%rbp), %rdx
movl $0x2, %edi
movl $0x2f, %ecx
callq 0xfeb0
movq -0x20(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x10a80
movzwl %ax, %eax
movl %eax, -0x54(%rbp)
jmp 0x28e2d
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
leaq -0x50(%rbp), %rdx
movl $0xa, %edi
movl $0x2f, %ecx
callq 0xfeb0
movq -0x20(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x10a80
movzwl %ax, %eax
movl %eax, -0x54(%rbp)
jmp 0x28e2d
jmp 0x28e79
cmpl $0x0, -0x54(%rbp)
je 0x28e54
cmpl $0x35, -0x54(%rbp)
je 0x28e54
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rdx
movl -0x54(%rbp), %ecx
leaq 0x2084e(%rip), %rsi     # 0x49699
movb $0x0, %al
callq 0x10130
jmp 0x28e61
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xfcc0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xfc00
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x28d82
movl $0x1, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x29bd0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x5, %edx
callq 0xf740
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpq $0x3, %rax
jae 0x28ffa
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0x2, %esi
callq 0xf4a0
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xf940
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x28fb1
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
shlq $0x7, %rax
addq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x10b50
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x28faf
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xb8(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0xc4(%rbp)
leaq -0xac(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movl -0xc4(%rbp), %edi
leaq -0xac(%rbp), %rsi
movl $0x80, %edx
callq 0xf270
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rdx
movq %rax, %rcx
leaq 0x1f404(%rip), %rsi     # 0x483a7
movb $0x0, %al
callq 0xfe70
movl %eax, -0x4(%rbp)
jmp 0x2900f
jmp 0x28fde
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
shlq $0x7, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xf7d0
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
movw $0x0, (%rax)
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x107f0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x28edb
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x109d0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x29bd0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x10330
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
cmpq $0x4, %rcx
movb %al, -0x15(%rbp)
jae 0x29082
movq -0x10(%rbp), %rax
addq $0x180, %rax            # imm = 0x180
movl -0x14(%rbp), %ecx
shlq $0x8, %rcx
addq %rcx, %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x2908b
jmp 0x290cc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x180, %rsi            # imm = 0x180
movl -0x14(%rbp), %eax
shlq $0x8, %rax
addq %rax, %rsi
callq 0xfcc0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xfc00
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x29052
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x29bd0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movl $0x5, %edx
callq 0xf740
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x4, %rax
jae 0x291be
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0x2, %esi
callq 0xf4a0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xf940
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x29181
movq -0x10(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
movl -0x14(%rbp), %eax
shlq $0x8, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0xf520
jmp 0x291a2
movq -0x10(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
movl -0x14(%rbp), %eax
shlq $0x8, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0xf7d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x107f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x29118
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x109d0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x29bd0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x10330
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
cmpq $0x24, %rcx
movb %al, -0x15(%rbp)
jae 0x2923a
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl 0x580(%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x29246
jmp 0x292ef
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl 0x580(%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
subl $0x42, %eax
je 0x292a3
jmp 0x2925f
movl -0x1c(%rbp), %eax
subl $0x43, %eax
je 0x292b5
jmp 0x29269
movl -0x1c(%rbp), %eax
subl $0x46, %eax
je 0x29291
jmp 0x29273
movl -0x1c(%rbp), %eax
subl $0x62, %eax
je 0x292a3
jmp 0x2927d
movl -0x1c(%rbp), %eax
subl $0x63, %eax
je 0x292b5
jmp 0x29287
movl -0x1c(%rbp), %eax
subl $0x66, %eax
jne 0x292c7
jmp 0x29291
movq -0x8(%rbp), %rdi
leaq 0x24316(%rip), %rsi     # 0x4d5b2
callq 0xfcc0
jmp 0x292c9
movq -0x8(%rbp), %rdi
leaq 0x242fe(%rip), %rsi     # 0x4d5ac
callq 0xfcc0
jmp 0x292c9
movq -0x8(%rbp), %rdi
leaq 0x242f8(%rip), %rsi     # 0x4d5b8
callq 0xfcc0
jmp 0x292c9
jmp 0x292e1
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xfc00
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x29212
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x29bd0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movl $0x5, %edx
callq 0xf740
movq -0x10(%rbp), %rdi
addq $0x580, %rdi            # imm = 0x580
xorl %esi, %esi
movl $0x24, %edx
callq 0xf7d0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x24, %rax
jae 0x29425
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0x2, %esi
callq 0xf4a0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xf940
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x29409
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x42, %eax
je 0x293e7
jmp 0x293a4
movl -0x24(%rbp), %eax
subl $0x43, %eax
je 0x293f8
jmp 0x293ae
movl -0x24(%rbp), %eax
subl $0x46, %eax
je 0x293d6
jmp 0x293b8
movl -0x24(%rbp), %eax
subl $0x62, %eax
je 0x293e7
jmp 0x293c2
movl -0x24(%rbp), %eax
subl $0x63, %eax
je 0x293f8
jmp 0x293cc
movl -0x24(%rbp), %eax
subl $0x66, %eax
jne 0x29407
jmp 0x293d6
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x66, 0x580(%rax,%rcx)
jmp 0x29407
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x62, 0x580(%rax,%rcx)
jmp 0x29407
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x63, 0x580(%rax,%rcx)
jmp 0x29409
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x107f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2934f
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x109d0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x29bd0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x10330
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movb 0x5b0(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x109d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x24154(%rip), %rdx     # 0x4d5e7
callq 0xf580
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x5b4(%rax), %eax
movl %eax, %esi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x201e4(%rip), %rdx     # 0x496a1
callq 0xf580
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x5b8(%rax), %eax
movl %eax, %esi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x1f2f9(%rip), %rdx     # 0x487e0
callq 0xf580
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x5bc(%rax), %eax
movl %eax, %esi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x20196(%rip), %rdx     # 0x496a7
callq 0xf580
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movb 0x5c0(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x109d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x240b0(%rip), %rdx     # 0x4d5ee
callq 0xf580
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movb 0x5c1(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x109d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x2408b(%rip), %rdx     # 0x4d5f6
callq 0xf580
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movb 0x5c2(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x109d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x24067(%rip), %rdx     # 0x4d5ff
callq 0xf580
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x5c4(%rax), %eax
movl %eax, %esi
callq 0xf9a0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x24044(%rip), %rdx     # 0x4d606
callq 0xf580
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)