LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_aaaa_push
int dns_aaaa_push(struct dns_packet *P, struct dns_aaaa *aaaa) {
	if (P->size - P->end < 2 + sizeof aaaa->addr.s6_addr)
		return DNS_ENOBUFS;

	P->data[P->end++]	= 0x00;
	P->data[P->end++]	= 0x10;

	memcpy(&P->data[P->end], aaaa->addr.s6_addr, sizeof aaaa->addr.s6_addr);

	P->end	+= sizeof aaaa->addr.s6_addr;

	return 0;
}

// Assembly:
movq 0x48(%rdi), %rdx
movq 0x50(%rdi), %rcx
subq %rcx, %rdx
movl $0x9b918cc0, %eax       # imm = 0x9B918CC0
cmpq $0x12, %rdx
jb 0x2914c
leaq 0x1(%rcx), %rax
movq %rax, 0x50(%rdi)
movb $0x0, 0x5c(%rdi,%rcx)
movq 0x50(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x50(%rdi)
movb $0x10, 0x5c(%rdi,%rax)
movq 0x50(%rdi), %rax
movups (%rsi), %xmm0
movups %xmm0, 0x5c(%rdi,%rax)
addq $0x10, 0x50(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_aaaa_cmp
int dns_aaaa_cmp(const struct dns_aaaa *a, const struct dns_aaaa *b) {
	unsigned i;
	int cmp;

	for (i = 0; i < lengthof(a->addr.s6_addr); i++) {
		if ((cmp = (a->addr.s6_addr[i] - b->addr.s6_addr[i])))
			return cmp;
	}

	return 0;
}

// Assembly:
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %eax
movzbl (%rsi,%rcx), %edx
subl %edx, %eax
jne 0x29166
incq %rcx
cmpq $0x10, %rcx
jne 0x2914f
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_aaaa_arpa
size_t dns_aaaa_arpa(void *_dst, size_t lim, const struct dns_aaaa *aaaa) {
	static const unsigned char hex[16] = "0123456789abcdef";
	struct dns_buf dst = DNS_B_INTO(_dst, lim);
	unsigned nyble;
	int i, j;

	for (i = sizeof aaaa->addr.s6_addr - 1; i >= 0; i--) {
		nyble = aaaa->addr.s6_addr[i];

		for (j = 0; j < 2; j++) {
			dns_b_putc(&dst, hex[0x0f & nyble]);
			dns_b_putc(&dst, '.');
			nyble >>= 4;
		}
	}

	dns_b_puts(&dst, "ip6.arpa.");

	return dns_b_strllen(&dst);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq %rdi, %r14
movl $0xf, %ecx
xorl %eax, %eax
leaq 0xfb09(%rip), %rsi      # 0x38c90
movq %rdi, %r15
movzbl (%rdx,%rcx), %edi
movl $0x1, %r8d
cmpq %r14, %r15
jae 0x291ac
movl %edi, %r9d
andl $0xf, %r9d
movb (%r9,%rsi), %r9b
movb %r9b, (%r15)
incq %r15
jmp 0x291af
incq %rax
cmpq %r14, %r15
jae 0x291bd
movb $0x2e, (%r15)
incq %r15
jmp 0x291c0
incq %rax
shrl $0x4, %edi
decl %r8d
je 0x29194
subq $0x1, %rcx
jae 0x2918a
movq %r14, %rcx
subq %r15, %rcx
cmpq $0x9, %rcx
movl $0x9, %r13d
cmovbq %rcx, %r13
movq %rax, %r12
subq %r13, %r12
addq $0x9, %r12
cmpq $0x9, %rcx
leaq 0xfd54(%rip), %rsi      # 0x38f4b
cmovaeq %rax, %r12
movq %r15, %rdi
movq %r13, %rdx
callq 0xfa60
addq %r15, %r13
cmpq %r14, %r13
jae 0x2921b
movb $0x0, (%r13)
subq %rbx, %r13
movq %r13, %rax
jmp 0x29238
cmpq %rbx, %r13
jbe 0x29236
leaq -0x1(%r13), %rax
cmpb $0x0, -0x1(%r13)
je 0x29231
incq %r12
movb $0x0, (%rax)
subq %rbx, %rax
jmp 0x29238
xorl %eax, %eax
addq %rax, %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_mx_parse
int dns_mx_parse(struct dns_mx *mx, struct dns_rr *rr, struct dns_packet *P) {
	size_t len;
	int error;

	if (rr->rd.len < 3)
		return DNS_EILLEGAL;

	mx->preference	= (0xff00 & (P->data[rr->rd.p + 0] << 8))
			| (0x00ff & (P->data[rr->rd.p + 1] << 0));

	if (!(len = dns_d_expand(mx->host, sizeof mx->host, rr->rd.p + 2, P, &error)))
		return error;
	else if (len >= sizeof mx->host)
		return DNS_EILLEGAL;

	return 0;
}

// Assembly:
movl $0x9b918cc1, %eax       # imm = 0x9B918CC1
cmpw $0x3, 0x16(%rsi)
jb 0x29322
pushq %rax
movq %rdx, %rcx
movzwl 0x14(%rsi), %eax
movzwl 0x5c(%rdx,%rax), %edx
rolw $0x8, %dx
movw %dx, (%rdi)
addq $0x2, %rdi
addl $0x2, %eax
movzwl %ax, %edx
leaq 0x4(%rsp), %r8
movl $0x100, %esi            # imm = 0x100
callq 0xfec0
testq %rax, %rax
je 0x2931a
xorl %ecx, %ecx
cmpq $0x100, %rax            # imm = 0x100
movl $0x9b918cc1, %eax       # imm = 0x9B918CC1
cmovbl %ecx, %eax
jmp 0x2931e
movl 0x4(%rsp), %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_mx_push
int dns_mx_push(struct dns_packet *P, struct dns_mx *mx) {
	size_t end, len;
	int error;

	if (P->size - P->end < 5)
		return DNS_ENOBUFS;

	end	= P->end;
	P->end	+= 2;

	P->data[P->end++]	= 0xff & (mx->preference >> 8);
	P->data[P->end++]	= 0xff & (mx->preference >> 0);

	if ((error = dns_d_push(P, mx->host, strlen(mx->host))))
		goto error;

	len	= P->end - end - 2;

	P->data[end + 0]	= 0xff & (len >> 8);
	P->data[end + 1]	= 0xff & (len >> 0);

	return 0;
error:
	P->end	= end;

	return error;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x48(%rdi), %rcx
movq 0x50(%rdi), %r15
subq %r15, %rcx
movl $0x9b918cc0, %eax       # imm = 0x9B918CC0
cmpq $0x5, %rcx
jb 0x293a7
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2(%r15), %rax
movq %rax, 0x50(%rdi)
movb 0x1(%rsi), %al
leaq 0x3(%r15), %rcx
movq %rcx, 0x50(%rdi)
movb %al, 0x5e(%rdi,%r15)
movb (%rsi), %al
movq 0x50(%rdi), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x50(%rdi)
movb %al, 0x5c(%rdi,%rcx)
addq $0x2, %r14
movq %r14, %rdi
callq 0xf560
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf390
testl %eax, %eax
je 0x29392
movq %r15, 0x50(%rbx)
jmp 0x293a7
movl 0x50(%rbx), %eax
subl %r15d, %eax
addl $-0x2, %eax
rolw $0x8, %ax
movw %ax, 0x5c(%rbx,%r15)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_mx_print
size_t dns_mx_print(void *_dst, size_t lim, struct dns_mx *mx) {
	struct dns_buf dst = DNS_B_INTO(_dst, lim);

	dns_b_fmtju(&dst, mx->preference, 0);
	dns_b_putc(&dst, ' ');
	dns_b_puts(&dst, mx->host);

	return dns_b_strllen(&dst);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movzwl (%rdx), %ecx
xorl %r8d, %r8d
movabsq $-0x3333333333333333, %r9 # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %r10
incq %r8
movq %r10, %rax
mulq %r9
shrq $0x3, %rdx
cmpq $0x9, %r10
movq %rdx, %r10
ja 0x293e6
leaq (%rdi,%rsi), %rbp
xorl %ebx, %ebx
subq %rsi, %r8
cmovbq %rbx, %r8
movl $0x1, %esi
movq %rdi, %r15
cmpq %rsi, %r8
jae 0x2943c
cmpq %rbp, %r15
jae 0x29439
movq %rcx, %rax
mulq %r9
shrl $0x2, %edx
andl $-0x2, %edx
leal (%rdx,%rdx,4), %eax
movl %ecx, %edx
subl %eax, %edx
orb $0x30, %dl
movb %dl, (%r15)
incq %r15
jmp 0x2943c
incq %rbx
movq %rcx, %rax
mulq %r9
shrq $0x3, %rdx
incq %rsi
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x29411
cmpq %rdi, %r15
jbe 0x2947b
leaq 0x1(%rdi), %rax
movq %r15, %rcx
movb -0x1(%rcx), %dl
movb -0x1(%rax), %sil
movb %sil, -0x1(%rcx)
decq %rcx
movb %dl, -0x1(%rax)
leaq 0x1(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x2945e
cmpq %rbp, %r15
movq %rdi, (%rsp)
jae 0x2948d
movb $0x20, (%r15)
incq %r15
jmp 0x29490
incq %rbx
addq $0x2, %r14
movq %r14, %rdi
callq 0xf560
movq %rbp, %rcx
subq %r15, %rcx
cmpq %rax, %rcx
movq %rax, %r13
cmovbq %rcx, %r13
movq %rax, %rdx
subq %r13, %rdx
xorl %r12d, %r12d
cmpq %rax, %rcx
cmovbq %rdx, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0xfa60
addq %r15, %r13
addq %rbx, %r12
cmpq %rbp, %r13
jae 0x294e3
movb $0x0, (%r13)
subq (%rsp), %r13
movq %r13, %rax
jmp 0x29504
movq (%rsp), %rcx
cmpq %rcx, %r13
jbe 0x29502
leaq -0x1(%r13), %rax
cmpb $0x0, -0x1(%r13)
je 0x294fd
incq %r12
movb $0x0, (%rax)
subq %rcx, %rax
jmp 0x29504
xorl %eax, %eax
addq %rax, %r12
movq %r12, %rax
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/lib/dns.c
// Function: dns_ns_parse
int dns_ns_parse(struct dns_ns *ns, struct dns_rr *rr, struct dns_packet *P) {
	size_t len;
	int error;

	if (!(len = dns_d_expand(ns->host, sizeof ns->host, rr->rd.p, P, &error)))
		return error;
	else if (len >= sizeof ns->host)
		return DNS_EILLEGAL;

	return 0;
}

// Assembly:
pushq %rax
movq %rdx, %rcx
movzwl 0x14(%rsi), %edx
leaq 0x4(%rsp), %r8
movl $0x100, %esi            # imm = 0x100
callq 0xfec0
movq %rax, %rcx
xorl %edx, %edx
cmpq $0x100, %rax            # imm = 0x100
movl $0x9b918cc1, %eax       # imm = 0x9B918CC1
cmovbl %edx, %eax
testq %rcx, %rcx
jne 0x29590
movl 0x4(%rsp), %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_ns_push
int dns_ns_push(struct dns_packet *P, struct dns_ns *ns) {
	size_t end, len;
	int error;

	if (P->size - P->end < 3)
		return DNS_ENOBUFS;

	end	= P->end;
	P->end	+= 2;

	if ((error = dns_d_push(P, ns->host, strlen(ns->host))))
		goto error;

	len	= P->end - end - 2;

	P->data[end + 0]	= 0xff & (len >> 8);
	P->data[end + 1]	= 0xff & (len >> 0);

	return 0;
error:
	P->end	= end;

	return error;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x48(%rdi), %rcx
movq 0x50(%rdi), %r15
subq %r15, %rcx
movl $0x9b918cc0, %eax       # imm = 0x9B918CC0
cmpq $0x3, %rcx
jb 0x295f0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2(%r15), %rax
movq %rax, 0x50(%rdi)
movq %rsi, %rdi
callq 0xf560
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf390
testl %eax, %eax
je 0x295db
movq %r15, 0x50(%rbx)
jmp 0x295f0
movl 0x50(%rbx), %eax
subl %r15d, %eax
addl $-0x2, %eax
rolw $0x8, %ax
movw %ax, 0x5c(%rbx,%r15)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_soa_parse
int dns_soa_parse(struct dns_soa *soa, struct dns_rr *rr, struct dns_packet *P) {
	struct { void *dst; size_t lim; } dn[] =
		{ { soa->mname, sizeof soa->mname },
		  { soa->rname, sizeof soa->rname } };
	unsigned *ts[] =
		{ &soa->serial, &soa->refresh, &soa->retry, &soa->expire, &soa->minimum };
	unsigned short rp;
	unsigned i, j, n;
	int error;

	/* MNAME / RNAME */
	if ((rp = rr->rd.p) >= P->end)
		return DNS_EILLEGAL;

	for (i = 0; i < lengthof(dn); i++) {
		if (!(n = dns_d_expand(dn[i].dst, dn[i].lim, rp, P, &error)))
			return error;
		else if (n >= dn[i].lim)
			return DNS_EILLEGAL;

		if ((rp = dns_d_skip(rp, P)) >= P->end)
			return DNS_EILLEGAL;
	}

	/* SERIAL / REFRESH / RETRY / EXPIRE / MINIMUM */
	for (i = 0; i < lengthof(ts); i++) {
		for (j = 0; j < 4; j++, rp++) {
			if (rp >= P->end)
				return DNS_EILLEGAL;

			*ts[i]	<<= 8;
			*ts[i]	|= (0xff & P->data[rp]);
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movl $0x100, %eax            # imm = 0x100
movq %rax, 0x18(%rsp)
leaq (%rdi,%rax), %rcx
movq %rcx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
leaq 0x200(%rdi), %rax
movq %rax, 0x30(%rsp)
leaq 0x204(%rdi), %rax
movq %rax, 0x38(%rsp)
leaq 0x208(%rdi), %rax
movq %rax, 0x40(%rsp)
leaq 0x20c(%rdi), %rax
movq %rax, 0x48(%rsp)
addq $0x210, %rdi            # imm = 0x210
movq %rdi, 0x50(%rsp)
movzwl 0x14(%rsi), %eax
cmpq %rax, 0x50(%rdx)
jbe 0x29815
movq %rdx, %rbx
xorl %r12d, %r12d
leaq 0xc(%rsp), %r14
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq 0x10(%rsp,%r12), %rdi
movq 0x18(%rsp,%r12), %r15
movzwl %ax, %ebp
movq %r15, %rsi
movl %ebp, %edx
movq %rbx, %rcx
movq %r14, %r8
callq 0xfec0
andq %r13, %rax
je 0x2982b
cmpq %r15, %rax
jae 0x29815
movl %ebp, %edi
movq %rbx, %rsi
callq 0x102a0
movzwl %ax, %ecx
cmpq %rcx, 0x50(%rbx)
jbe 0x29815
addq $0x10, %r12
cmpq $0x10, %r12
je 0x2978b
movq 0x50(%rbx), %rdx
xorl %esi, %esi
movzwl %ax, %eax
xorl %ecx, %ecx
leal (%rax,%rcx), %edi
movzwl %di, %edi
cmpq %rdi, %rdx
jbe 0x29815
movq 0x30(%rsp,%rsi,8), %r8
movl (%r8), %r9d
shll $0x8, %r9d
movl %r9d, (%r8)
movzbl 0x5c(%rbx,%rdi), %edi
orl %r9d, %edi
movl %edi, (%r8)
incl %ecx
cmpl $0x4, %ecx
jne 0x297da
incq %rsi
addl %ecx, %eax
xorl %ecx, %ecx
cmpq $0x5, %rsi
jne 0x297d5
jmp 0x2981a
movl $0x9b918cc1, %ecx       # imm = 0x9B918CC1
movl %ecx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0xc(%rsp), %ecx
jmp 0x2981a
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_soa_push
int dns_soa_push(struct dns_packet *P, struct dns_soa *soa) {
	void *dn[]	= { soa->mname, soa->rname };
	unsigned ts[]	= { (0xffffffff & soa->serial),
			    (0x7fffffff & soa->refresh),
			    (0x7fffffff & soa->retry),
			    (0x7fffffff & soa->expire),
			    (0xffffffff & soa->minimum) };
	unsigned i, j;
	size_t end, len;
	int error;

	end	= P->end;

	if ((P->end += 2) >= P->size)
		goto toolong;

	/* MNAME / RNAME */
	for (i = 0; i < lengthof(dn); i++) {
		if ((error = dns_d_push(P, dn[i], strlen(dn[i]))))
			goto error;
	}

	/* SERIAL / REFRESH / RETRY / EXPIRE / MINIMUM */
	for (i = 0; i < lengthof(ts); i++) {
		if ((P->end += 4) >= P->size)
			goto toolong;

		for (j = 1; j <= 4; j++) {
			P->data[P->end - j]	= (0xff & ts[i]);
			ts[i]			>>= 8;
		}
	}

	len			= P->end - end - 2;
	P->data[end + 0]	= (0xff & (len >> 8));
	P->data[end + 1]	= (0xff & (len >> 0));

	return 0;
toolong:
	error	= DNS_ENOBUFS;

	/* FALL THROUGH */
error:
	P->end	= end;

	return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rsi, 0x20(%rsp)
leaq 0x100(%rsi), %rax
movq %rax, 0x28(%rsp)
movl 0x200(%rsi), %eax
movl %eax, (%rsp)
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl 0x204(%rsi), %ecx
andl %eax, %ecx
movl %ecx, 0x4(%rsp)
movl 0x208(%rsi), %ecx
andl %eax, %ecx
movl %ecx, 0x8(%rsp)
andl 0x20c(%rsi), %eax
movl %eax, 0xc(%rsp)
movl 0x210(%rsi), %eax
movl %eax, 0x10(%rsp)
movq 0x50(%rdi), %r15
leaq 0x2(%r15), %rax
movq %rax, 0x50(%rdi)
movl $0x9b918cc0, %ebp       # imm = 0x9B918CC0
cmpq 0x48(%rdi), %rax
jae 0x29929
xorl %r12d, %r12d
movq 0x20(%rsp,%r12,8), %r14
movq %r14, %rdi
callq 0xf560
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf390
testl %eax, %eax
jne 0x29927
incq %r12
cmpq $0x1, %r12
je 0x298a9
leaq 0x5b(%rbx), %rax
xorl %ecx, %ecx
movq 0x50(%rbx), %rdx
addq $0x4, %rdx
movq %rdx, 0x50(%rbx)
cmpq 0x48(%rbx), %rdx
jae 0x29929
movl (%rsp,%rcx,4), %edx
xorl %esi, %esi
movq 0x50(%rbx), %rdi
addq %rax, %rdi
movb %dl, (%rsi,%rdi)
shrl $0x8, %edx
decq %rsi
cmpq $-0x4, %rsi
jne 0x298ee
movl %edx, (%rsp,%rcx,4)
incq %rcx
cmpq $0x5, %rcx
jne 0x298d7
movl 0x50(%rbx), %eax
subl %r15d, %eax
addl $-0x2, %eax
rolw $0x8, %ax
movw %ax, 0x5c(%rbx,%r15)
xorl %ebp, %ebp
jmp 0x2992d
movl %eax, %ebp
movq %r15, 0x50(%rbx)
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_soa_cmp
int dns_soa_cmp(const struct dns_soa *a, const struct dns_soa *b) {
	int cmp;

	if ((cmp = strcasecmp(a->mname, b->mname)))
		return cmp;

	if ((cmp = strcasecmp(a->rname, b->rname)))
		return cmp;

	if (a->serial > b->serial)
		return -1;
	else if (a->serial < b->serial)
		return 1;

	if (a->refresh > b->refresh)
		return -1;
	else if (a->refresh < b->refresh)
		return 1;

	if (a->retry > b->retry)
		return -1;
	else if (a->retry < b->retry)
		return 1;

	if (a->expire > b->expire)
		return -1;
	else if (a->expire < b->expire)
		return 1;

	if (a->minimum > b->minimum)
		return -1;
	else if (a->minimum < b->minimum)
		return 1;

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xfe40
testl %eax, %eax
jne 0x29981
movl $0x100, %esi            # imm = 0x100
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0xfe40
testl %eax, %eax
jne 0x29981
movl 0x200(%r14), %eax
cmpl %eax, 0x200(%rbx)
jbe 0x2997a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x29981
movl $0x1, %eax
jae 0x29989
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x204(%r14), %ecx
cmpl %ecx, 0x204(%rbx)
ja 0x29973
jb 0x29981
movl 0x208(%r14), %ecx
cmpl %ecx, 0x208(%rbx)
ja 0x29973
jb 0x29981
movl 0x20c(%r14), %ecx
cmpl %ecx, 0x20c(%rbx)
ja 0x29973
jb 0x29981
movl 0x210(%r14), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, 0x210(%rbx)
ja 0x29981
setb %al
movzbl %al, %eax
jmp 0x29981
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_srv_parse
int dns_srv_parse(struct dns_srv *srv, struct dns_rr *rr, struct dns_packet *P) {
	unsigned short rp;
	unsigned i;
	size_t n;
	int error;

	memset(srv, '\0', sizeof *srv);

	rp	= rr->rd.p;

	if (rr->rd.len < 7)
		return DNS_EILLEGAL;

	for (i = 0; i < 2; i++, rp++) {
		srv->priority	<<= 8;
		srv->priority	|= (0xff & P->data[rp]);
	}

	for (i = 0; i < 2; i++, rp++) {
		srv->weight	<<= 8;
		srv->weight	|= (0xff & P->data[rp]);
	}

	for (i = 0; i < 2; i++, rp++) {
		srv->port	<<= 8;
		srv->port	|= (0xff & P->data[rp]);
	}

	if (!(n = dns_d_expand(srv->target, sizeof srv->target, rp, P, &error)))
		return error;
	else if (n >= sizeof srv->target)
		return DNS_EILLEGAL;

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %r12d, %r12d
movl $0x106, %edx            # imm = 0x106
xorl %esi, %esi
callq 0xf750
movl $0x9b918cc1, %eax       # imm = 0x9B918CC1
cmpw $0x7, 0x16(%r15)
jb 0x29f5c
movzwl 0x14(%r15), %eax
movzwl (%r14), %ecx
leal (%rax,%r12), %edx
shll $0x8, %ecx
movw %cx, (%r14)
movzwl %dx, %edx
movzbl 0x5c(%rbx,%rdx), %edx
orl %ecx, %edx
movw %dx, (%r14)
incl %r12d
movl %edx, %ecx
cmpl $0x1, %r12d
je 0x29eac
movzwl 0x2(%r14), %edx
addl %r12d, %eax
movl $0x1, %ecx
shll $0x8, %edx
movw %dx, 0x2(%r14)
movzwl %ax, %esi
movzbl 0x5c(%rbx,%rsi), %esi
orl %edx, %esi
movw %si, 0x2(%r14)
incl %eax
movl %esi, %edx
decl %ecx
je 0x29edd
movzwl 0x4(%r14), %edx
movl $0x1, %ecx
shll $0x8, %edx
movw %dx, 0x4(%r14)
movzwl %ax, %esi
movzbl 0x5c(%rbx,%rsi), %esi
orl %edx, %esi
movw %si, 0x4(%r14)
incl %eax
movl %esi, %edx
decl %ecx
je 0x29f06
addq $0x6, %r14
movzwl %ax, %edx
leaq 0x4(%rsp), %r8
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movq %rbx, %rcx
callq 0xfec0
testq %rax, %rax
je 0x29f58
xorl %ecx, %ecx
cmpq $0x100, %rax            # imm = 0x100
movl $0x9b918cc1, %eax       # imm = 0x9B918CC1
cmovbl %ecx, %eax
jmp 0x29f5c
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_srv_push
int dns_srv_push(struct dns_packet *P, struct dns_srv *srv) {
	size_t end, len;
	int error;

	end	= P->end;

	if (P->size - P->end < 2)
		goto toolong;

	P->end	+= 2;

	if (P->size - P->end < 6)
		goto toolong;

	P->data[P->end++]	= 0xff & (srv->priority >> 8);
	P->data[P->end++]	= 0xff & (srv->priority >> 0);

	P->data[P->end++]	= 0xff & (srv->weight >> 8);
	P->data[P->end++]	= 0xff & (srv->weight >> 0);

	P->data[P->end++]	= 0xff & (srv->port >> 8);
	P->data[P->end++]	= 0xff & (srv->port >> 0);

	if (0 == (len = dns_d_comp(&P->data[P->end], P->size - P->end, srv->target, strlen(srv->target), P, &error)))
		goto error;
	else if (P->size - P->end < len)
		goto toolong;

	P->end	+= len;

	if (P->end > 65535)
		goto toolong;

	len	= P->end - end - 2;

	P->data[end + 0]	= 0xff & (len >> 8);
	P->data[end + 1]	= 0xff & (len >> 0);

	return 0;
toolong:
	error	= DNS_ENOBUFS;

	/* FALL THROUGH */
error:
	P->end	= end;

	return error;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %r13
movq %rax, %rcx
subq %r13, %rcx
cmpq $0x2, %rcx
jb 0x2a073
leaq 0x2(%r13), %rcx
movq %rcx, 0x50(%rbx)
subq %rcx, %rax
cmpq $0x6, %rax
jb 0x2a073
movq %rsi, %r14
movb 0x1(%rsi), %al
leaq 0x3(%r13), %rcx
movq %rcx, 0x50(%rbx)
movb %al, 0x5e(%rbx,%r13)
movb (%rsi), %al
movq 0x50(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movb %al, 0x5c(%rbx,%rcx)
movb 0x3(%rsi), %al
movq 0x50(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movb %al, 0x5c(%rbx,%rcx)
movb 0x2(%rsi), %al
movq 0x50(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movb %al, 0x5c(%rbx,%rcx)
movb 0x5(%rsi), %al
movq 0x50(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movb %al, 0x5c(%rbx,%rcx)
movb 0x4(%rsi), %al
movq 0x50(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movb %al, 0x5c(%rbx,%rcx)
movq 0x48(%rbx), %r15
movq 0x50(%rbx), %rax
leaq (%rbx,%rax), %r12
addq $0x5c, %r12
subq %rax, %r15
addq $0x6, %r14
movq %r14, %rdi
callq 0xf560
leaq 0xc(%rsp), %r9
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rax, %rcx
movq %rbx, %r8
callq 0xfe00
testq %rax, %rax
je 0x2a07b
movq 0x48(%rbx), %rdx
movq 0x50(%rbx), %rcx
subq %rcx, %rdx
cmpq %rax, %rdx
jb 0x2a073
addq %rax, %rcx
movq %rcx, 0x50(%rbx)
cmpq $0xffff, %rcx           # imm = 0xFFFF
jbe 0x2a091
movl $0x9b918cc0, 0xc(%rsp)  # imm = 0x9B918CC0
movq %r13, 0x50(%rbx)
movl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
addq $0x5c, %rbx
subl %r13d, %ecx
addl $-0x2, %ecx
rolw $0x8, %cx
movw %cx, (%rbx,%r13)
xorl %eax, %eax
jmp 0x2a083
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_opt_ttl
unsigned int dns_opt_ttl(const struct dns_opt *opt) {
	unsigned int ttl = 0;

	ttl |= (0xffU & opt->rcode) << 24;
	ttl |= (0xffU & opt->version) << 16;
	ttl |= (0xffffU & opt->flags) << 0;

	return ttl;
}

// Assembly:
movl (%rdi), %eax
shll $0x18, %eax
movzbl 0x4(%rdi), %ecx
shll $0x10, %ecx
orl %eax, %ecx
movzwl 0x6(%rdi), %eax
orl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_opt_init
struct dns_opt *dns_opt_init(struct dns_opt *opt, size_t size) {
	assert(size >= offsetof(struct dns_opt, data));

	opt->size = size - offsetof(struct dns_opt, data);
	opt->len  = 0;

	opt->rcode   = 0;
	opt->version = 0;
	opt->maxudp  = 0;

	return opt;
}

// Assembly:
cmpq $0x1f, %rsi
jbe 0x2a416
addq $-0x20, %rsi
movq %rsi, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movl $0x0, (%rdi)
movb $0x0, 0x4(%rdi)
movw $0x0, 0x8(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0xeb37(%rip), %rdi      # 0x38f55
leaq 0xea98(%rip), %rsi      # 0x38ebd
leaq 0xeb50(%rip), %rcx      # 0x38f7c
movl $0xe06, %edx            # imm = 0xE06
callq 0xf890
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_opt_push
int dns_opt_push(struct dns_packet *P, struct dns_opt *opt) {
	const struct dns_buf src = DNS_B_FROM(opt->data, opt->len);
	struct dns_buf dst = DNS_B_INTO(&P->data[P->end], (P->size - P->end));
	int error;

	/* rdata length (see below) */
	if ((error = dns_b_put16(&dst, 0)))
		goto error;

	/* ... push known options here */

	/* push opaque option data */
	if ((error = dns_b_move(&dst, &src, (size_t)(src.pe - src.p))))
		goto error;

	/* rdata length */
	if ((error = dns_b_pput16(&dst, dns_b_tell(&dst) - 2, 0)))
		goto error;

#if !DNS_DEBUG_OPT_FORMERR
	P->end += dns_b_tell(&dst);
#endif

	return 0;
error:
	return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x18(%rsi), %rax
movq 0x48(%rdi), %r12
movq 0x50(%rdi), %r8
leaq 0x5c(%rdi,%r8), %rdi
leaq 0x5c(%rbx,%r12), %r15
movl $0x9b918cc0, %r13d      # imm = 0x9B918CC0
movl $0x9b918cc0, %edx       # imm = 0x9B918CC0
movq %rdi, %rcx
cmpq %r8, %r12
jle 0x2a6ae
leaq 0x1(%rdi), %rcx
movb $0x0, (%rdi)
xorl %edx, %edx
movq %rcx, %r14
movl $0x9b918cc0, %ebp       # imm = 0x9B918CC0
cmpq %r15, %rcx
jae 0x2a6c7
leaq 0x1(%rcx), %r14
movb $0x0, (%rcx)
xorl %ebp, %ebp
movl %edx, %r13d
cmpq %r15, %rcx
jae 0x2a73f
movq %r8, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
addq $0x20, %rsi
subq %r14, %r15
cmpq %rax, %r15
cmovaeq %rax, %r15
movl $0x9b918cc0, %ebp       # imm = 0x9B918CC0
cmovbl %ebp, %r13d
movq %r14, %rdi
movq %r15, %rdx
callq 0xfa60
testl %r13d, %r13d
je 0x2a702
movl %r13d, %ebp
jmp 0x2a73f
addq %r15, %r14
movq 0x10(%rsp), %rcx
subq %rcx, %r14
leal -0x2(%r14), %eax
movq 0x8(%rsp), %rdx
cmpq %rdx, %r12
je 0x2a720
movb %ah, (%rcx)
movl %r13d, %ebp
subq %rdx, %r12
je 0x2a735
movl $0x9b918cc0, %ebp       # imm = 0x9B918CC0
cmpq $0x2, %r12
jb 0x2a735
movb %al, 0x1(%rcx)
xorl %ebp, %ebp
testl %ebp, %ebp
jne 0x2a73f
addq %r14, 0x50(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_opt_print
size_t dns_opt_print(void *_dst, size_t lim, struct dns_opt *opt) {
	struct dns_buf dst = DNS_B_INTO(_dst, lim);
	size_t p;

	dns_b_putc(&dst, '"');

	for (p = 0; p < opt->len; p++) {
		dns_b_putc(&dst, '\\');
		dns_b_fmtju(&dst, opt->data[p], 3);
	}

	dns_b_putc(&dst, '"');

	return dns_b_strllen(&dst);
}

// Assembly:
movq %rdx, %r8
testq %rsi, %rsi
jle 0x2a769
leaq 0x1(%rdi), %r11
movb $0x22, (%rdi)
xorl %ecx, %ecx
jmp 0x2a771
movl $0x1, %ecx
movq %rdi, %r11
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
addq %rdi, %rsi
cmpq $0x0, 0x18(%r8)
je 0x2a8be
xorl %ebx, %ebx
movabsq $-0x3333333333333333, %r14 # imm = 0xCCCCCCCCCCCCCCCD
movl $0x3, %r15d
cmpq %rsi, %r11
jae 0x2a7a9
movb $0x5c, (%r11)
incq %r11
jmp 0x2a7ac
incq %rcx
movzbl 0x20(%r8,%rbx), %r9d
movl $0x3, %r12d
movl $0x1, %eax
movq %r9, %r10
xorl %r13d, %r13d
movq %rax, %rbp
incq %r13
movq %r10, %rax
mulq %r14
shrq $0x3, %rdx
incq %r12
leaq 0x1(%rbp), %rax
cmpq $0x9, %r10
movq %rdx, %r10
ja 0x2a7c3
movq %rsi, %rdx
subq %r11, %rdx
cmpq $0x3, %r13
movl $0x3, %eax
cmovbq %r13, %rax
subq %rax, %r12
cmpq %r12, %rdx
cmovbq %rdx, %r12
cmpq $0x2, %r13
ja 0x2a82d
cmpq $0x3, %rbp
cmovaeq %r15, %rbp
addq $-0x3, %rbp
movq %r11, %r10
cmpq %rsi, %r10
jae 0x2a823
movb $0x30, (%r10)
incq %r10
jmp 0x2a826
incq %rcx
incq %rbp
jne 0x2a815
jmp 0x2a830
movq %r11, %r10
addq %rax, %r12
negq %r12
addq %r13, %r12
addq $0x3, %r12
movl $0x1, %r13d
movq %r10, %r11
cmpq %r13, %r12
jae 0x2a872
cmpq %rsi, %r11
jae 0x2a86f
movq %r9, %rax
mulq %r14
shrl $0x2, %edx
andl $-0x2, %edx
leal (%rdx,%rdx,4), %eax
movl %r9d, %edx
subl %eax, %edx
orb $0x30, %dl
movb %dl, (%r11)
incq %r11
jmp 0x2a872
incq %rcx
movq %r9, %rax
mulq %r14
shrq $0x3, %rdx
incq %r13
cmpq $0x9, %r9
movq %rdx, %r9
ja 0x2a846
cmpq %r11, %r10
jae 0x2a8b1
incq %r10
movq %r11, %rax
movb -0x1(%rax), %dl
movb -0x1(%r10), %r9b
movb %r9b, -0x1(%rax)
decq %rax
movb %dl, -0x1(%r10)
leaq 0x1(%r10), %rdx
cmpq %rax, %r10
movq %rdx, %r10
jb 0x2a893
incq %rbx
cmpq 0x18(%r8), %rbx
jb 0x2a79b
cmpq %rsi, %r11
jae 0x2a8cc
movb $0x22, (%r11)
incq %r11
jmp 0x2a8cf
incq %rcx
cmpq %rsi, %r11
jae 0x2a8e0
movb $0x0, (%r11)
subq %rdi, %r11
movq %r11, %rax
jmp 0x2a8fd
cmpq %rdi, %r11
jbe 0x2a8fb
leaq -0x1(%r11), %rax
cmpb $0x0, -0x1(%r11)
je 0x2a8f6
incq %rcx
movb $0x0, (%rax)
subq %rdi, %rax
jmp 0x2a8fd
xorl %eax, %eax
addq %rax, %rcx
movq %rcx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_ptr_qname
size_t dns_ptr_qname(void *dst, size_t lim, int af, void *addr) {
	switch (af) {
	case AF_INET6:
		return dns_aaaa_arpa(dst, lim, addr);
	case AF_INET:
		return dns_a_arpa(dst, lim, addr);
	default: {
		struct dns_a a;
		a.addr.s_addr = INADDR_NONE;
		return dns_a_arpa(dst, lim, &a);
	}
	}
}

// Assembly:
cmpl $0x2, %edx
je 0x2a95a
cmpl $0xa, %edx
jne 0x2a962
movq %rcx, %rdx
jmp 0x10610
movq %rcx, %rdx
jmp 0xff40
pushq %rax
leaq 0x4(%rsp), %rdx
movl $0xffffffff, (%rdx)     # imm = 0xFFFFFFFF
callq 0xff40
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_sshfp_parse
int dns_sshfp_parse(struct dns_sshfp *fp, struct dns_rr *rr, struct dns_packet *P) {
	unsigned p = rr->rd.p, pe = rr->rd.p + rr->rd.len;

	if (pe - p < 2)
		return DNS_EILLEGAL;

	fp->algo = P->data[p++];
	fp->type = P->data[p++];

	switch (fp->type) {
	case DNS_SSHFP_SHA1:
		if (pe - p < sizeof fp->digest.sha1)
			return DNS_EILLEGAL;

		memcpy(fp->digest.sha1, &P->data[p], sizeof fp->digest.sha1);

		break;
	default:
		break;
	} /* switch() */

	return 0;
}

// Assembly:
movzwl 0x16(%rsi), %r8d
movl $0x9b918cc1, %eax       # imm = 0x9B918CC1
cmpl $0x2, %r8d
jb 0x2aa45
movzwl 0x14(%rsi), %ecx
movzbl 0x5c(%rdx,%rcx), %esi
movl %esi, (%rdi)
movzbl 0x5d(%rdx,%rcx), %esi
movl %esi, 0x4(%rdi)
cmpl $0x1, %esi
jne 0x2aa43
addl $-0x2, %r8d
cmpl $0x14, %r8d
jb 0x2aa45
addq $0x5c, %rdx
addq $0x2, %rcx
movl 0x10(%rdx,%rcx), %eax
movl %eax, 0x18(%rdi)
movups (%rdx,%rcx), %xmm0
movups %xmm0, 0x8(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_sshfp_push
int dns_sshfp_push(struct dns_packet *P, struct dns_sshfp *fp) {
	unsigned p = P->end, pe = P->size, n;

	if (pe - p < 4)
		return DNS_ENOBUFS;

	p += 2;
	P->data[p++] = 0xff & fp->algo;
	P->data[p++] = 0xff & fp->type;

	switch (fp->type) {
	case DNS_SSHFP_SHA1:
		if (pe - p < sizeof fp->digest.sha1)
			return DNS_ENOBUFS;

		memcpy(&P->data[p], fp->digest.sha1, sizeof fp->digest.sha1);
		p += sizeof fp->digest.sha1;

		break;
	default:
		return DNS_EILLEGAL;
	} /* switch() */

	n = p - P->end - 2;
	P->data[P->end++] = 0xff & (n >> 8);
	P->data[P->end++] = 0xff & (n >> 0);
	P->end = p;

	return 0;
}

// Assembly:
movq 0x50(%rdi), %rcx
movl 0x48(%rdi), %edx
movl %edx, %r8d
subl %ecx, %r8d
movl $0x9b918cc0, %eax       # imm = 0x9B918CC0
cmpl $0x4, %r8d
jb 0x2aad0
leal 0x2(%rcx), %eax
movb (%rsi), %r8b
leal 0x3(%rcx), %r9d
movb %r8b, 0x5c(%rdi,%rax)
movb 0x4(%rsi), %al
movb %al, 0x5c(%rdi,%r9)
movl $0x9b918cc1, %eax       # imm = 0x9B918CC1
cmpl $0x1, 0x4(%rsi)
jne 0x2aad0
leal 0x4(%rcx), %r8d
subl %r8d, %edx
movl $0x9b918cc0, %eax       # imm = 0x9B918CC0
cmpl $0x14, %edx
jb 0x2aad0
leaq 0x5c(%rdi), %rax
movl %r8d, %edx
movl 0x18(%rsi), %r8d
movl %r8d, 0x10(%rax,%rdx)
movups 0x8(%rsi), %xmm0
movups %xmm0, (%rax,%rdx)
leal 0x18(%rcx), %eax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x50(%rdi)
movb $0x0, 0x5c(%rdi,%rcx)
movq 0x50(%rdi), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x50(%rdi)
movb $0x16, 0x5c(%rdi,%rcx)
movq %rax, 0x50(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_sshfp_cmp
int dns_sshfp_cmp(const struct dns_sshfp *a, const struct dns_sshfp *b) {
	int cmp;

	if ((cmp = a->algo - b->algo) || (cmp = a->type - b->type))
		return cmp;

	switch (a->type) {
	case DNS_SSHFP_SHA1:
		return memcmp(a->digest.sha1, b->digest.sha1, sizeof a->digest.sha1);
	default:
		return 0;
	} /* switch() */

	/* NOT REACHED */
}

// Assembly:
movl (%rdi), %eax
subl (%rsi), %eax
jne 0x2aafa
movl 0x4(%rdi), %ecx
movl %ecx, %eax
subl 0x4(%rsi), %eax
jne 0x2aafa
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x2aafa
addq $0x8, %rdi
addq $0x8, %rsi
movl $0x14, %edx
jmp 0xf580
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_txt_parse
int dns_txt_parse(struct dns_txt *txt, struct dns_rr *rr, struct dns_packet *P) {
	struct { unsigned char *b; size_t p, end; } dst, src;
	unsigned n;

	dst.b	= txt->data;
	dst.p	= 0;
	dst.end	= txt->size;

	src.b	= P->data;
	src.p	= rr->rd.p;
	src.end	= src.p + rr->rd.len;

	while (src.p < src.end) {
		n	= 0xff & P->data[src.p++];

		if (src.end - src.p < n || dst.end - dst.p < n)
			return DNS_EILLEGAL;

		memcpy(&dst.b[dst.p], &src.b[src.p], n);

		dst.p	+= n;
		src.p	+= n;
	}

	txt->len	= dst.p;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movzwl 0x16(%rsi), %r12d
xorl %r13d, %r13d
testq %r12, %r12
movq %rdi, 0x8(%rsp)
je 0x2adca
movq %rdx, %r14
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq (%rdi), %rbx
addq $0x5c, %r14
movzwl 0x14(%rsi), %ebp
addq %rbp, %r12
xorl %r13d, %r13d
movzbl (%r14,%rbp), %r15d
incq %rbp
movq %r12, %rcx
subq %rbp, %rcx
movl $0x9b918cc1, %eax       # imm = 0x9B918CC1
cmpq %r15, %rcx
jb 0x2add5
movq %rbx, %rcx
subq %r13, %rcx
cmpq %r15, %rcx
jb 0x2add5
movq 0x10(%rsp), %rax
leaq (%rax,%r13), %rdi
leaq (%r14,%rbp), %rsi
movq %r15, %rdx
callq 0xfa60
addq %r15, %r13
addq %r15, %rbp
cmpq %r12, %rbp
jb 0x2ad87
movq 0x8(%rsp), %rax
movq %r13, 0x8(%rax)
xorl %eax, %eax
addq $0x18, %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/lib/dns.c
// Function: dns_txt_push
int dns_txt_push(struct dns_packet *P, struct dns_txt *txt) {
	struct { unsigned char *b; size_t p, end; } dst, src;
	unsigned n;

	dst.b	= P->data;
	dst.p	= P->end;
	dst.end	= P->size;

	src.b	= txt->data;
	src.p	= 0;
	src.end	= txt->len;

	if (dst.end - dst.p < 2)
		return DNS_ENOBUFS;

	n	= txt->len + ((txt->len + 254) / 255);

	dst.b[dst.p++]	= 0xff & (n >> 8);
	dst.b[dst.p++]	= 0xff & (n >> 0);

	while (src.p < src.end) {
		n	= DNS_PP_MIN(255, src.end - src.p);

		if (dst.p >= dst.end)
			return DNS_ENOBUFS;

		dst.b[dst.p++]	= n;

		if (dst.end - dst.p < n)
			return DNS_ENOBUFS;

		memcpy(&dst.b[dst.p], &src.b[src.p], n);

		dst.p	+= n;
		src.p	+= n;
	}

	P->end	= dst.p;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x48(%rdi), %rbp
movq 0x50(%rdi), %r13
movq %rbp, %rcx
subq %r13, %rcx
movl $0x9b918cc0, %eax       # imm = 0x9B918CC0
cmpq $0x2, %rcx
jb 0x2aeaf
movq 0x8(%rsi), %rbx
leaq 0xfe(%rbx), %rax
movabsq $-0x7f7f7f7f7f7f7f7f, %rcx # imm = 0x8080808080808081
mulq %rcx
shrl $0x7, %edx
leal (%rbx,%rdx), %eax
rolw $0x8, %ax
movq %rdi, 0x8(%rsp)
leaq 0x5c(%rdi), %r14
movw %ax, (%r14,%r13)
addq $0x2, %r13
testq %rbx, %rbx
je 0x2ae9d
addq $0x10, %rsi
movq %rsi, 0x10(%rsp)
xorl %r15d, %r15d
cmpq %rbp, %r13
jae 0x2aeaa
movq %rbx, %r12
subq %r15, %r12
movl $0xff, %eax
cmpq %rax, %r12
cmovaeq %rax, %r12
movb %r12b, (%r14,%r13)
incq %r13
movq %rbp, %rax
subq %r13, %rax
cmpq %r12, %rax
jb 0x2aeaa
leaq (%r14,%r13), %rdi
movq 0x10(%rsp), %rax
leaq (%rax,%r15), %rsi
movq %r12, %rdx
callq 0xfa60
addq %r12, %r13
addq %r12, %r15
cmpq %rbx, %r15
jb 0x2ae54
movq 0x8(%rsp), %rax
movq %r13, 0x50(%rax)
xorl %eax, %eax
jmp 0x2aeaf
movl $0x9b918cc0, %eax       # imm = 0x9B918CC0
addq $0x18, %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/lib/dns.c
// Function: dns_any_cname
size_t dns_any_cname(void *dst, size_t lim, union dns_any *any, enum dns_type type) {
	const struct dns_rrtype *t;

	if ((t = dns_rrtype(type)) && t->cname)
		return t->cname(dst, lim, any);

	return 0;
}

// Assembly:
xorl %eax, %eax
leaq 0x1b651(%rip), %r8      # 0x46780
xorl %r9d, %r9d
cmpl %ecx, (%r9,%r8)
jne 0x2b140
cmpq $0x0, 0x18(%r9,%r8)
jne 0x2b152
leaq 0x40(%r9), %r10
cmpq $0x300, %r9             # imm = 0x300
movq %r10, %r9
jb 0x2b132
jmp 0x2b158
addq %r9, %r8
movq %r8, %rax
testq %rax, %rax
je 0x2b16a
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x2b16a
xorl %eax, %eax
jmpq *%rcx
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_hosts_open
struct dns_hosts *dns_hosts_open(int *error) {
	static const struct dns_hosts hosts_initializer	= { .refcount = 1 };
	struct dns_hosts *hosts;

	if (!(hosts = malloc(sizeof *hosts)))
		goto syerr;

	*hosts	= hosts_initializer;

	hosts->tail	= &hosts->head;

	return hosts;
syerr:
	*error	= dns_syerr();

	free(hosts);

	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x18, %edi
callq 0x10110
testq %rax, %rax
je 0x2b19b
movups 0xbb71(%rip), %xmm0     # 0x36cf8
movups %xmm0, (%rax)
movq 0xbb77(%rip), %rcx      # 0x36d08
movq %rcx, 0x10(%rax)
movq %rax, 0x8(%rax)
jmp 0x2b1a6
callq 0xf0a0
movl (%rax), %eax
movl %eax, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_hosts_close
void dns_hosts_close(struct dns_hosts *hosts) {
	struct dns_hosts_entry *ent, *xnt;

	if (!hosts || 1 != dns_hosts_release(hosts))
		return;

	for (ent = hosts->head; ent; ent = xnt) {
		xnt	= ent->next;

		free(ent);
	}

	free(hosts);

	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2b1f1
movq %rdi, %rbx
movq $-0x1, %rax
lock
xaddq %rax, 0x10(%rdi)
cmpl $0x1, %eax
jne 0x2b1f1
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b1e2
movq 0x168(%rdi), %r14
callq 0xff30
movq %r14, %rdi
testq %r14, %r14
jne 0x2b1ce
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xff30
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_hosts_local
struct dns_hosts *dns_hosts_local(int *error_) {
	struct dns_hosts *hosts;
	int error;

	if (!(hosts = dns_hosts_open(&error)))
		goto error;

	if ((error = dns_hosts_loadpath(hosts, "/etc/hosts")))
		goto error;

	return hosts;
error:
	*error_	= error;

	dns_hosts_close(hosts);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x4(%rsp), %rdi
callq 0xf790
movq %rax, %rbx
testq %rax, %rax
je 0x2b255
leaq 0xddcb(%rip), %rsi      # 0x39010
movq %rbx, %rdi
callq 0x10520
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x2b266
movl 0x4(%rsp), %eax
movl %eax, (%r14)
movq %rbx, %rdi
callq 0x10730
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_hosts_loadpath
int dns_hosts_loadpath(struct dns_hosts *hosts, const char *path) {
	FILE *fp;
	int error;

	if (!(fp = dns_fopen(path, "rt", &error)))
		return error;

	error = dns_hosts_loadfile(hosts, fp);

	fclose(fp);

	return error;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %r14
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x2b5b0
testq %rax, %rax
je 0x2b2a7
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x10390
movl %eax, 0x4(%rsp)
movq %rbx, %rdi
callq 0xfce0
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_hosts_insert
int dns_hosts_insert(struct dns_hosts *hosts, int af, const void *addr, const void *host, _Bool alias) {
	struct dns_hosts_entry *ent;
	int error;

	if (!(ent = malloc(sizeof *ent)))
		goto syerr;

	dns_d_anchor(ent->host, sizeof ent->host, host, strlen(host));

	switch ((ent->af = af)) {
	case AF_INET6:
		memcpy(&ent->addr.a6, addr, sizeof ent->addr.a6);

		dns_aaaa_arpa(ent->arpa, sizeof ent->arpa, addr);

		break;
	case AF_INET:
		memcpy(&ent->addr.a4, addr, sizeof ent->addr.a4);

		dns_a_arpa(ent->arpa, sizeof ent->arpa, addr);

		break;
	default:
		error	= EINVAL;

		goto error;
	} /* switch() */

	ent->alias	= alias;

	ent->next	= 0;
	*hosts->tail	= ent;
	hosts->tail	= &ent->next;

	return 0;
syerr:
	error	= dns_syerr();
error:
	free(ent);

	return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r13d
movq %rcx, %rbp
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r14
movl $0x170, %edi            # imm = 0x170
callq 0x10110
movq %rax, %rbx
testq %rax, %rax
je 0x2b544
movl %r13d, 0x4(%rsp)
movq %rbp, %rdi
callq 0xf560
testq %rax, %rax
je 0x2b506
movq %rax, %r13
movl $0x100, %edx            # imm = 0x100
cmpq %rdx, %rax
cmovbq %rax, %rdx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xfa60
cmpb $0x2e, -0x1(%rbp,%r13)
je 0x2b4f6
cmpq $0xff, %r13
ja 0x2b4f3
movb $0x2e, (%rbx,%r13)
incq %r13
movl $0xff, %eax
cmpq %rax, %r13
cmovbq %r13, %rax
movb $0x0, (%rbx,%rax)
movl %r12d, 0x14c(%rbx)
cmpl $0x2, %r12d
je 0x2b555
movl $0x16, %ebp
cmpl $0xa, %r12d
movl 0x4(%rsp), %r12d
jne 0x2b54b
movups (%r15), %xmm0
movups %xmm0, 0x150(%rbx)
leaq 0x100(%rbx), %rdi
movl $0x4a, %esi
movq %r15, %rdx
callq 0x10610
jmp 0x2b577
callq 0xf0a0
movl (%rax), %ebp
movq %rbx, %rdi
callq 0xff30
jmp 0x2b59f
movl (%r15), %eax
movl %eax, 0x150(%rbx)
leaq 0x100(%rbx), %rdi
movl $0x4a, %esi
movq %r15, %rdx
callq 0xff40
movl 0x4(%rsp), %r12d
movb %r12b, 0x160(%rbx)
movq %rbx, %rax
addq $0x168, %rax            # imm = 0x168
movq $0x0, 0x168(%rbx)
movq 0x8(%r14), %rcx
movq %rbx, (%rcx)
movq %rax, 0x8(%r14)
xorl %ebp, %ebp
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/lib/dns.c
// Function: dns_fopen
static FILE *dns_fopen(const char *path, const char *mode, dns_error_t *_error) {
	FILE *fp;
	char mode_cloexec[32];
	int error;

	assert(path && mode && *mode);
	if (!*path) {
		error = EINVAL;
		goto error;
	}

#if _WIN32 || _WIN64
	if ((error = dns_fopen_addflag(mode_cloexec, mode, sizeof mode_cloexec, 'N')))
		goto error;
	if (!(fp = fopen(path, mode_cloexec)))
		goto syerr;
#else
	if ((error = dns_fopen_addflag(mode_cloexec, mode, sizeof mode_cloexec, 'e')))
		goto error;
	if (!(fp = fopen(path, mode_cloexec))) {
		if (errno != EINVAL)
			goto syerr;
		if (!(fp = fopen(path, mode)))
			goto syerr;
	}
#endif

	return fp;
syerr:
	error = dns_syerr();
error:
	*_error = error;

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x2b6ba
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x2b622
movb $0x72, %bpl
xorl %r13d, %r13d
leaq 0xddaa(%rip), %r15      # 0x39389
leaq 0xdafc(%rip), %r12      # 0x390e2
movsbl %bpl, %esi
movl $0x7, %edx
movq %r15, %rdi
callq 0xfe90
testq %rax, %rax
je 0x2b629
leaq 0x1(%r13), %rax
movb %bpl, (%rsp,%r13)
movb 0x1(%r13,%r12), %bpl
movq %rax, %r13
cmpq $0x2, %rax
jne 0x2b5e6
leaq 0x2(%rsp), %rcx
addq %rax, %r12
movl $0x2, %r13d
jmp 0x2b630
movl $0x16, %eax
jmp 0x2b6a7
leaq (%rsp,%r13), %rcx
addq %r13, %r12
movl $0xc, %eax
cmpq $0x1f, %r13
ja 0x2b66d
movq %rsp, %rdx
movb $0x65, (%rcx)
addq %r13, %rdx
incq %rdx
movl $0x1f, %esi
subq %r13, %rsi
xorl %edi, %edi
cmpq %rdi, %rsi
setne %cl
je 0x2b66f
movb (%r12,%rdi), %r8b
movb %r8b, (%rdx,%rdi)
incq %rdi
testb %r8b, %r8b
jne 0x2b651
xorl %eax, %eax
jmp 0x2b66f
xorl %ecx, %ecx
testb %cl, %cl
je 0x2b6a7
movq %rsp, %rsi
movq %r14, %rdi
callq 0xff10
testq %rax, %rax
jne 0x2b6ab
callq 0xf0a0
movq %rax, %r15
cmpl $0x16, (%rax)
jne 0x2b6a4
leaq 0xda4b(%rip), %rsi      # 0x390e2
movq %r14, %rdi
callq 0xff10
testq %rax, %rax
jne 0x2b6ab
movl (%r15), %eax
movl %eax, (%rbx)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xdc7f(%rip), %rdi      # 0x39340
leaq 0xd7f5(%rip), %rsi      # 0x38ebd
leaq 0xdc87(%rip), %rcx      # 0x39356
movl $0x4c3, %edx            # imm = 0x4C3
callq 0xf890
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_hosts_dump
int dns_hosts_dump(struct dns_hosts *hosts, FILE *fp) {
	struct dns_hosts_entry *ent, *xnt;
	char addr[INET6_ADDRSTRLEN + 1];
	unsigned i;

	for (ent = hosts->head; ent; ent = xnt) {
		xnt	= ent->next;

		dns_inet_ntop(ent->af, &ent->addr, addr, sizeof addr);

		fputs(addr, fp);

		for (i = strlen(addr); i < INET_ADDRSTRLEN; i++)
			fputc(' ', fp);

		fputc(' ', fp);

		fputs(ent->host, fp);
		fputc('\n', fp);
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq (%rdi), %r15
testq %r15, %r15
je 0x2b77d
movq %rsi, %rbx
movq %rsp, %r14
movq 0x168(%r15), %r13
movl 0x14c(%r15), %edi
leaq 0x150(%r15), %rsi
movq %r14, %rdx
movl $0x2f, %ecx
callq 0xfda0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfea0
movq %r14, %rdi
callq 0xf560
movq %rax, %r12
cmpl $0xf, %r12d
ja 0x2b74c
addl $-0x10, %r12d
movl $0x20, %edi
movq %rbx, %rsi
callq 0x10000
incl %r12d
jne 0x2b73a
movl $0x20, %edi
movq %rbx, %rsi
callq 0x10000
movq %r15, %rdi
movq %rbx, %rsi
callq 0xfea0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x10000
movq %r13, %r15
testq %r13, %r13
jne 0x2b6f8
xorl %eax, %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/lib/dns.c
// Function: dns_resconf_open
struct dns_resolv_conf *dns_resconf_open(int *error) {
	static const struct dns_resolv_conf resconf_initializer = {
		.lookup = "bf",
		.family = { AF_INET, AF_INET6 },
		.options = { .ndots = 1, .timeout = 5, .attempts = 2, .tcp = DNS_RESCONF_TCP_ENABLE, },
		.iface = { .ss_family = AF_INET },
	};
	struct dns_resolv_conf *resconf;
	struct sockaddr_in *sin;
	size_t len;

	if (!(resconf = malloc(sizeof *resconf)))
		goto syerr;

	*resconf = resconf_initializer;

	sin = (struct sockaddr_in *)&resconf->nameserver[0];
	sin->sin_family      = AF_INET;
	sin->sin_addr.s_addr = INADDR_ANY;
	sin->sin_port        = htons(53);
#if defined(SA_LEN)
	sin->sin_len         = sizeof *sin;
#endif

	if (0 != gethostname(resconf->search[0], sizeof resconf->search[0]))
		goto syerr;

	len = strlen(resconf->search[0]);
	len = dns_d_anchor(resconf->search[0], sizeof resconf->search[0], resconf->search[0], len);
	len = dns_d_cleave(resconf->search[0], sizeof resconf->search[0], resconf->search[0], len);
	if (1 == len) /* gethostname() returned a string without any label */
		resconf->search[0][0] = '\0';

	dns_resconf_acquire(resconf);

	return resconf;
syerr:
	*error	= dns_syerr();

	free(resconf);

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl $0x650, %edi            # imm = 0x650
callq 0x10110
movq %rax, %rbx
testq %rax, %rax
je 0x2ba3e
movq %rax, %r14
leaq 0xb2fe(%rip), %rsi      # 0x36d10
movl $0x650, %edx            # imm = 0x650
movq %rbx, %rdi
callq 0xfa60
movq $0x35000002, (%rbx)     # imm = 0x35000002
addq $0x180, %r14            # imm = 0x180
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
callq 0x10420
testl %eax, %eax
je 0x2ba54
callq 0xf0a0
movl (%rax), %eax
movl %eax, (%r15)
movq %rbx, %rdi
callq 0xff30
xorl %ebx, %ebx
jmp 0x2bab3
movq %r14, %rdi
callq 0xf560
testq %rax, %rax
je 0x2ba8c
cmpb $0x2e, -0x1(%r14,%rax)
je 0x2ba79
cmpq $0xff, %rax
ja 0x2ba76
movb $0x2e, (%r14,%rax)
incq %rax
movl $0xff, %ecx
cmpq %rcx, %rax
cmovbq %rax, %rcx
movb $0x0, (%r14,%rcx)
jmp 0x2ba8e
xorl %eax, %eax
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movq %r14, %rdx
movq %rax, %rcx
callq 0x104f0
cmpq $0x1, %rax
jne 0x2baab
movb $0x0, (%r14)
lock
incq 0x648(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_resconf_local
struct dns_resolv_conf *dns_resconf_local(int *error_) {
	struct dns_resolv_conf *resconf;
	int error;

	if (!(resconf = dns_resconf_open(&error)))
		goto error;

	if ((error = dns_resconf_loadpath(resconf, "/etc/resolv.conf"))) {
		/*
		 * NOTE: Both the glibc and BIND9 resolvers ignore a missing
		 * /etc/resolv.conf, defaulting to a nameserver of
		 * 127.0.0.1. See also dns_hints_insert_resconf, and the
		 * default initialization of nameserver[0] in
		 * dns_resconf_open.
		 */
		if (error != ENOENT)
			goto error;
	}

	if ((error = dns_nssconf_loadpath(resconf, "/etc/nsswitch.conf"))) {
		if (error != ENOENT)
			goto error;
	}

	return resconf;
error:
	*error_	= error;

	dns_resconf_close(resconf);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x4(%rsp), %rdi
callq 0xf740
testq %rax, %rax
je 0x2bb88
movq %rax, %rbx
leaq 0xd4eb(%rip), %rsi      # 0x3901b
movq %rax, %rdi
callq 0xfac0
movl %eax, 0x4(%rsp)
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jne 0x2bb5d
leaq 0xd4e2(%rip), %rsi      # 0x3902c
movq %rbx, %rdi
callq 0xfc90
movl %eax, 0x4(%rsp)
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
je 0x2bb91
movl 0x4(%rsp), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0x2bb8f
movq $-0x1, %rax
lock
xaddq %rax, 0x648(%rbx)
cmpl $0x1, %eax
jne 0x2bb8f
movq %rbx, %rdi
callq 0xff30
jmp 0x2bb8f
movl 0x4(%rsp), %eax
movl %eax, (%r14)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_resconf_loadpath
int dns_resconf_loadpath(struct dns_resolv_conf *resconf, const char *path) {
	FILE *fp;
	int error;

	if (!(fp = dns_fopen(path, "rt", &error)))
		return error;

	error = dns_resconf_loadfile(resconf, fp);

	fclose(fp);

	return error;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x2b5b0
testq %rax, %rax
je 0x2bbd6
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10a00
movl $0x0, 0x4(%rsp)
movq %r14, %rdi
callq 0xfce0
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_nssconf_loadpath
int dns_nssconf_loadpath(struct dns_resolv_conf *resconf, const char *path) {
	FILE *fp;
	int error;

	if (!(fp = dns_fopen(path, "rt", &error)))
		return error;

	error = dns_nssconf_loadfile(resconf, fp);

	fclose(fp);

	return error;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x2b5b0
testq %rax, %rax
je 0x2bc1c
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf7d0
movl $0x0, 0x4(%rsp)
movq %r14, %rdi
callq 0xfce0
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq