LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsp, %r14
movq %rdi, (%r14)
movq %rdi, 0x8(%r14)
addq %rdi, %rsi
movq %rsi, 0x10(%r14)
andl $0x0, 0x18(%r14)
andq $0x0, 0x20(%r14)
movzwl (%rdx), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x25591
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
jae 0x25d18
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
movb $0x20, (%rax)
jmp 0x25d25
incq 0x20(%rsp)
movl $0x9b918cc0, 0x18(%rsp) # imm = 0x9B918CC0
addq $0x2, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x25689
movq %r14, %rdi
callq 0x25899
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xff50
movq %rax, %rcx
xorl %edx, %edx
cmpq $0x100, %rax            # imm = 0x100
movl $0x9b918cc1, %eax       # imm = 0x9B918CC1
cmovbl %edx, %eax
testq %rcx, %rcx
jne 0x25d89
movl 0x4(%rsp), %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x25de9
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2(%r15), %rax
movq %rax, 0x50(%rdi)
movq %rsi, %rdi
callq 0xf580
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf3a0
testl %eax, %eax
je 0x25dd4
movq %r15, 0x50(%rbx)
jmp 0x25de9
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_O2/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 %rdx, %rbx
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
movq 0x50(%rdx), %rcx
movl $0x9b918cc1, %edx       # imm = 0x9B918CC1
cmpq %rax, %rcx
jbe 0x25f61
pushq $0x8
popq %rdx
leaq 0xc(%rsp), %r14
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
leaq 0x10(%rdx), %rbp
cmpq $0x38, %rbp
je 0x25f18
movq 0x8(%rsp,%rdx), %rdi
movq 0x10(%rsp,%rdx), %r12
movzwl %ax, %r15d
movq %r12, %rsi
movl %r15d, %edx
movq %rbx, %rcx
movq %r14, %r8
callq 0xff50
andq %r13, %rax
je 0x25f5d
cmpq %r12, %rax
jae 0x25f11
movl %r15d, %edi
movq %rbx, %rsi
callq 0x10340
movzwl %ax, %esi
movq 0x50(%rbx), %rcx
movq %rbp, %rdx
cmpq %rsi, %rcx
ja 0x25ec4
movl $0x9b918cc1, %edx       # imm = 0x9B918CC1
jmp 0x25f61
xorl %edx, %edx
cmpq $0x5, %rdx
je 0x25f72
movzwl %ax, %edi
xorl %esi, %esi
cmpl $0x4, %esi
je 0x25f56
leal (%rdi,%rsi), %r8d
movzwl %r8w, %r8d
cmpq %r8, %rcx
jbe 0x25f11
movq 0x30(%rsp,%rdx,8), %r9
movl (%r9), %r10d
shll $0x8, %r10d
movl %r10d, (%r9)
movzbl 0x5c(%rbx,%r8), %r8d
orl %r10d, %r8d
movl %r8d, (%r9)
incl %esi
jmp 0x25f25
incq %rdx
addl %esi, %eax
jmp 0x25f1a
movl 0xc(%rsp), %edx
movl %edx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edx, %edx
jmp 0x25f61
// File: /workspace/github_c_makefile_star2_O2/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)
movabsq $0x7fffffff7fffffff, %rax # imm = 0x7FFFFFFF7FFFFFFF
andq 0x204(%rsi), %rax
movq %rax, 0x4(%rsp)
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
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 0x26012
xorl %r12d, %r12d
cmpq $0x2, %r12
je 0x26025
movq 0x20(%rsp,%r12,8), %r14
movq %r14, %rdi
callq 0xf580
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf3a0
incq %r12
testl %eax, %eax
je 0x25fe8
movl %eax, %ebp
movq %r15, 0x50(%rbx)
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5b(%rbx), %rax
xorl %ecx, %ecx
movq 0x50(%rbx), %rdx
cmpq $0x5, %rcx
je 0x26068
addq $0x4, %rdx
movq %rdx, 0x50(%rbx)
cmpq 0x48(%rbx), %rdx
jae 0x26012
movl (%rsp,%rcx,4), %edx
xorl %esi, %esi
cmpq $-0x4, %rsi
je 0x26060
movq 0x50(%rbx), %rdi
addq %rax, %rdi
movb %dl, (%rsi,%rdi)
shrl $0x8, %edx
decq %rsi
jmp 0x26048
movl %edx, (%rsp,%rcx,4)
incq %rcx
jmp 0x2602b
subl %r15d, %edx
addl $-0x2, %edx
rolw $0x8, %dx
movw %dx, 0x5c(%rbx,%r15)
xorl %ebp, %ebp
jmp 0x26016
// File: /workspace/github_c_makefile_star2_O2/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 0xfed0
testl %eax, %eax
jne 0x260bf
movl $0x100, %esi            # imm = 0x100
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0xfed0
testl %eax, %eax
jne 0x260bf
movl 0x200(%r14), %eax
pushq $-0x1
popq %rcx
cmpl %eax, 0x200(%rbx)
jbe 0x260ba
movl %ecx, %eax
jmp 0x260bf
pushq $0x1
popq %rax
jae 0x260c7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x204(%r14), %edx
cmpl %edx, 0x204(%rbx)
ja 0x260b6
jb 0x260bf
movl 0x208(%r14), %edx
cmpl %edx, 0x208(%rbx)
ja 0x260b6
jb 0x260bf
movl 0x20c(%r14), %edx
cmpl %edx, 0x20c(%rbx)
ja 0x260b6
jb 0x260bf
movl 0x210(%r14), %edx
movl %ecx, %eax
cmpl %edx, 0x210(%rbx)
ja 0x260bf
setb %al
movzbl %al, %eax
jmp 0x260bf
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_soa_print
size_t dns_soa_print(void *_dst, size_t lim, struct dns_soa *soa) {
	struct dns_buf dst = DNS_B_INTO(_dst, lim);

	dns_b_puts(&dst, soa->mname);
	dns_b_putc(&dst, ' ');
	dns_b_puts(&dst, soa->rname);
	dns_b_putc(&dst, ' ');
	dns_b_fmtju(&dst, soa->serial, 0);
	dns_b_putc(&dst, ' ');
	dns_b_fmtju(&dst, soa->refresh, 0);
	dns_b_putc(&dst, ' ');
	dns_b_fmtju(&dst, soa->retry, 0);
	dns_b_putc(&dst, ' ');
	dns_b_fmtju(&dst, soa->expire, 0);
	dns_b_putc(&dst, ' ');
	dns_b_fmtju(&dst, soa->minimum, 0);

	return dns_b_strllen(&dst);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsp, %r14
movq %rdi, (%r14)
movq %rdi, 0x8(%r14)
addq %rdi, %rsi
movq %rsi, 0x10(%r14)
andl $0x0, 0x18(%r14)
movq %rdx, %rbx
andq $0x0, 0x20(%r14)
movq %r14, %rdi
movq %rdx, %rsi
callq 0x25689
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
jae 0x2615b
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
movb $0x20, (%rax)
jmp 0x26168
incq 0x20(%rsp)
movl $0x9b918cc0, 0x18(%rsp) # imm = 0x9B918CC0
leaq 0x100(%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x25689
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
jae 0x26192
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
movb $0x20, (%rax)
jmp 0x2619f
incq 0x20(%rsp)
movl $0x9b918cc0, 0x18(%rsp) # imm = 0x9B918CC0
movl 0x200(%rbx), %esi
movq %rsp, %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x25591
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
jae 0x261ca
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
movb $0x20, (%rax)
jmp 0x261d7
incq 0x20(%rsp)
movl $0x9b918cc0, 0x18(%rsp) # imm = 0x9B918CC0
movl 0x204(%rbx), %esi
movq %rsp, %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x25591
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
jae 0x26202
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
movb $0x20, (%rax)
jmp 0x2620f
incq 0x20(%rsp)
movl $0x9b918cc0, 0x18(%rsp) # imm = 0x9B918CC0
movl 0x208(%rbx), %esi
movq %rsp, %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x25591
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
jae 0x2623a
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
movb $0x20, (%rax)
jmp 0x26247
incq 0x20(%rsp)
movl $0x9b918cc0, 0x18(%rsp) # imm = 0x9B918CC0
movl 0x20c(%rbx), %esi
movq %rsp, %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x25591
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
jae 0x26272
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
movb $0x20, (%rax)
jmp 0x2627f
incq 0x20(%rsp)
movl $0x9b918cc0, 0x18(%rsp) # imm = 0x9B918CC0
movl 0x210(%rbx), %esi
movq %rsp, %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x25591
movq %rbx, %rdi
callq 0x25899
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf790
movl $0x9b918cc1, %eax       # imm = 0x9B918CC1
cmpw $0x7, 0x16(%r15)
jb 0x26383
movzwl 0x14(%r15), %ecx
xorl %edx, %edx
leal (%rcx,%r12), %eax
cmpl $0x2, %r12d
je 0x26300
shll $0x8, %edx
movw %dx, (%r14)
movzwl %ax, %eax
movzbl 0x5c(%rbx,%rax), %eax
orl %edx, %eax
movw %ax, (%r14)
incl %r12d
movl %eax, %edx
jmp 0x262da
pushq $0x2
popq %rcx
xorl %edx, %edx
subl $0x1, %ecx
jb 0x26327
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
jmp 0x26305
pushq $0x2
popq %rcx
xorl %esi, %esi
movzwl %ax, %edx
subl $0x1, %ecx
jb 0x2634f
shll $0x8, %esi
movw %si, 0x4(%r14)
movzbl 0x5c(%rbx,%rdx), %edi
orl %esi, %edi
movw %di, 0x4(%r14)
leal 0x1(%rdx), %eax
movl %edi, %esi
jmp 0x2632c
addq $0x6, %r14
leaq 0x4(%rsp), %r8
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movq %rbx, %rcx
callq 0xff50
testq %rax, %rax
je 0x2637f
xorl %ecx, %ecx
cmpq $0x100, %rax            # imm = 0x100
movl $0x9b918cc1, %eax       # imm = 0x9B918CC1
cmovbl %ecx, %eax
jmp 0x26383
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %r13
subq %r13, %rax
movl $0x9b918cc0, %ebp       # imm = 0x9B918CC0
cmpq $0x2, %rax
jb 0x264ae
addq $-0x2, %rax
cmpq $0x6, %rax
jb 0x264ae
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 0xf580
leaq 0x4(%rsp), %r9
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rax, %rcx
movq %rbx, %r8
callq 0xfe90
testq %rax, %rax
je 0x264aa
movq 0x48(%rbx), %rdx
movq 0x50(%rbx), %rcx
subq %rcx, %rdx
cmpq %rax, %rdx
jb 0x264ae
addq %rax, %rcx
movq %rcx, 0x50(%rbx)
cmpq $0xffff, %rcx           # imm = 0xFFFF
ja 0x264ae
addq $0x5c, %rbx
subl %r13d, %ecx
addl $-0x2, %ecx
rolw $0x8, %cx
movw %cx, (%rbx,%r13)
xorl %ebp, %ebp
jmp 0x264b2
movl 0x4(%rsp), %ebp
movq %r13, 0x50(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_srv_print
size_t dns_srv_print(void *_dst, size_t lim, struct dns_srv *srv) {
	struct dns_buf dst = DNS_B_INTO(_dst, lim);

	dns_b_fmtju(&dst, srv->priority, 0);
	dns_b_putc(&dst, ' ');
	dns_b_fmtju(&dst, srv->weight, 0);
	dns_b_putc(&dst, ' ');
	dns_b_fmtju(&dst, srv->port, 0);
	dns_b_putc(&dst, ' ');
	dns_b_puts(&dst, srv->target);

	return dns_b_strllen(&dst);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsp, %r14
movq %rdi, (%r14)
movq %rdi, 0x8(%r14)
addq %rdi, %rsi
movq %rsi, 0x10(%r14)
andl $0x0, 0x18(%r14)
andq $0x0, 0x20(%r14)
movzwl (%rdx), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x25591
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
jae 0x2653d
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
movb $0x20, (%rax)
jmp 0x2654a
incq 0x20(%rsp)
movl $0x9b918cc0, 0x18(%rsp) # imm = 0x9B918CC0
movzwl 0x2(%rbx), %esi
movq %rsp, %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x25591
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
jae 0x26573
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
movb $0x20, (%rax)
jmp 0x26580
incq 0x20(%rsp)
movl $0x9b918cc0, 0x18(%rsp) # imm = 0x9B918CC0
movzwl 0x4(%rbx), %esi
movq %rsp, %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x25591
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
jae 0x265a9
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
movb $0x20, (%rax)
jmp 0x265b6
incq 0x20(%rsp)
movl $0x9b918cc0, 0x18(%rsp) # imm = 0x9B918CC0
addq $0x6, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x25689
movq %r14, %rdi
callq 0x25899
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x26624
addq $-0x20, %rsi
movq %rsi, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
andl $0x0, (%rdi)
movb $0x0, 0x4(%rdi)
andw $0x0, 0x8(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0xd8d9(%rip), %rdi      # 0x33f05
leaq 0xd83a(%rip), %rsi      # 0x33e6d
leaq 0xd8f2(%rip), %rcx      # 0x33f2c
movl $0xe06, %edx            # imm = 0xE06
callq 0xf8e0
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_opt_parse
int dns_opt_parse(struct dns_opt *opt, struct dns_rr *rr, struct dns_packet *P) {
	const struct dns_buf src = DNS_B_FROM(&P->data[rr->rd.p], rr->rd.len);
	struct dns_buf dst = DNS_B_INTO(opt->data, opt->size);
	int error;

	opt->rcode = 0xfff & ((rr->ttl >> 20) | dns_header(P)->rcode);
	opt->version = 0xff & (rr->ttl >> 16);
	opt->flags = 0xffff & rr->ttl;
	opt->maxudp = 0xffff & rr->class;

	while (src.p < src.pe) {
		int code, len;

		if (-1 == (code = dns_b_get16(&src, -1)))
			return src.error;
		if (-1 == (len = dns_b_get16(&src, -1)))
			return src.error;

		switch (code) {
		default:
			dns_b_put16(&dst, code);
			dns_b_put16(&dst, len);
			if ((error = dns_b_move(&dst, &src, len)))
				return error;
			break;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movzwl 0x14(%rsi), %eax
leaq (%rdx,%rax), %rcx
leaq 0x5c(%rdx,%rax), %rax
movq %rsp, %rbx
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
movzwl 0x16(%rsi), %eax
addq %rcx, %rax
addq $0x5c, %rax
movq %rax, 0x10(%rbx)
andl $0x0, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
leaq 0x20(%rdi), %rax
leaq 0x28(%rsp), %r14
movq %rax, (%r14)
movq %rax, 0x8(%r14)
addq 0x10(%rdi), %rax
movq %rax, 0x10(%r14)
andl $0x0, 0x18(%r14)
andq $0x0, 0x20(%r14)
movl 0x10(%rsi), %eax
movl %eax, %ecx
shrl $0x14, %ecx
movzbl 0x5f(%rdx), %edx
andl $0xf, %edx
orl %ecx, %edx
movl %edx, (%rdi)
movl %eax, %ecx
shrl $0x10, %ecx
movb %cl, 0x4(%rdi)
movw %ax, 0x6(%rdi)
movzwl 0xc(%rsi), %eax
movw %ax, 0x8(%rdi)
movl $0xffff, %ebp           # imm = 0xFFFF
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x26730
movq %rbx, %rdi
callq 0x2673f
cmpq $-0x1, %rax
je 0x2672a
movq %rax, %r12
movq %rbx, %rdi
callq 0x2673f
cmpq $-0x1, %rax
je 0x2672a
movq %rax, %r15
andl %ebp, %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0x2676c
movl %r15d, %esi
andl %ebp, %esi
movq %r14, %rdi
callq 0x2676c
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2678f
testl %eax, %eax
je 0x266cd
jmp 0x26732
movl 0x18(%rsp), %eax
jmp 0x26732
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_b_move
static inline dns_error_t
dns_b_move(struct dns_buf *dst, const struct dns_buf *_src, size_t n)
{
	struct dns_buf *src = (struct dns_buf *)_src;
	size_t src_n = DNS_PP_MIN((size_t)(src->pe - src->p), n);
	size_t src_r = n - src_n;

	dns_b_put(dst, src->p, src_n);
	src->p += src_n;

	if (src_r)
		return dns_b_setoverflow(src, src_r, DNS_EILLEGAL);

	return dst->error;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %rsi
movq 0x10(%rbx), %r13
subq %rsi, %r13
cmpq %rdx, %r13
movq %rdx, %r12
cmovbq %r13, %r12
movq %r12, %rdx
callq 0x25545
addq %r12, 0x8(%rbx)
cmpq %r14, %r13
jae 0x267dc
subq %r12, %r14
addq %r14, 0x20(%rbx)
movl $0x9b918cc1, 0x18(%rbx) # imm = 0x9B918CC1
movl $0x9b918cc1, %eax       # imm = 0x9B918CC1
jmp 0x267e0
movl 0x18(%r15), %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x58, %rsp
leaq 0x20(%rsi), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x18(%rsi), %r14
leaq (%rsi,%r14), %rax
addq $0x20, %rax
movq %rax, 0x18(%rsp)
andl $0x0, 0x20(%rsp)
movq %rdi, %rbx
andq $0x0, 0x28(%rsp)
leaq 0x5c(%rdi), %rax
movq 0x50(%rdi), %rcx
addq %rax, %rcx
leaq 0x30(%rsp), %rdi
movq %rcx, (%rdi)
movq %rcx, 0x8(%rdi)
addq 0x48(%rbx), %rax
movq %rax, 0x10(%rdi)
andl $0x0, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
xorl %esi, %esi
callq 0x2676c
testl %eax, %eax
jne 0x26867
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x2678f
testl %eax, %eax
je 0x2686f
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq 0x30(%rsp), %rcx
movq 0x40(%rsp), %rsi
movl $0x9b918cc0, %eax       # imm = 0x9B918CC0
subq %rcx, %rsi
je 0x26867
movq 0x38(%rsp), %r8
subq %rcx, %r8
leal -0x2(%r8), %edx
movb %dh, (%rcx)
cmpq $0x2, %rsi
jb 0x26867
movl %edx, %edi
movb %dil, 0x1(%rcx)
addq %r8, 0x50(%rbx)
xorl %eax, %eax
jmp 0x26867
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, (%rsp)
movq %rdi, 0x8(%rsp)
leaq (%rdi,%rsi), %rax
movq %rax, 0x10(%rsp)
andl $0x0, 0x18(%rsp)
andq $0x0, 0x20(%rsp)
testq %rsi, %rsi
jle 0x268e6
leaq 0x1(%rdi), %rax
movq %rax, 0x8(%rsp)
movb $0x22, (%rdi)
jmp 0x268f7
movq $0x1, 0x20(%rsp)
movl $0x9b918cc0, 0x18(%rsp) # imm = 0x9B918CC0
xorl %r15d, %r15d
movq %rsp, %r14
pushq $0x3
popq %rbp
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x18(%rbx), %r15
jae 0x26945
cmpq %rcx, %rax
jae 0x26923
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
movb $0x5c, (%rax)
jmp 0x26930
incq 0x20(%rsp)
movl $0x9b918cc0, 0x18(%rsp) # imm = 0x9B918CC0
movzbl 0x20(%rbx,%r15), %esi
movq %r14, %rdi
movl %ebp, %edx
callq 0x25591
incq %r15
jmp 0x26900
cmpq %rcx, %rax
jae 0x26958
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
movb $0x22, (%rax)
jmp 0x26965
incq 0x20(%rsp)
movl $0x9b918cc0, 0x18(%rsp) # imm = 0x9B918CC0
movq %rsp, %rdi
callq 0x25899
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x26994
cmpl $0xa, %edx
jne 0x2699c
movq %rcx, %rdx
jmp 0x106c0
movq %rcx, %rdx
jmp 0xffd0
pushq %rax
leaq 0x4(%rsp), %rdx
orl $-0x1, (%rdx)
callq 0xffd0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x26a18
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 0x26a16
addl $-0x2, %r8d
cmpl $0x14, %r8d
jb 0x26a18
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_O2/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 0x26a9b
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 0x26a9b
leal 0x4(%rcx), %r8d
subl %r8d, %edx
movl $0x9b918cc0, %eax       # imm = 0x9B918CC0
cmpl $0x14, %edx
jb 0x26a9b
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
movb $0x16, 0x5c(%rdi,%rcx)
movq %rax, 0x50(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x26ac3
movl 0x4(%rdi), %ecx
movl %ecx, %eax
subl 0x4(%rsi), %eax
jne 0x26ac3
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x26ac3
addq $0x8, %rdi
addq $0x8, %rsi
pushq $0x14
popq %rdx
jmp 0xf5a0
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_sshfp_print
size_t dns_sshfp_print(void *_dst, size_t lim, struct dns_sshfp *fp) {
	static const unsigned char hex[16] = "0123456789abcdef";
	struct dns_buf dst = DNS_B_INTO(_dst, lim);
	size_t i;

	dns_b_fmtju(&dst, fp->algo, 0);
	dns_b_putc(&dst, ' ');
	dns_b_fmtju(&dst, fp->type, 0);
	dns_b_putc(&dst, ' ');

	switch (fp->type) {
	case DNS_SSHFP_SHA1:
		for (i = 0; i < sizeof fp->digest.sha1; i++) {
			dns_b_putc(&dst, hex[0x0f & (fp->digest.sha1[i] >> 4)]);
			dns_b_putc(&dst, hex[0x0f & (fp->digest.sha1[i] >> 0)]);
		}

		break;
	default:
		dns_b_putc(&dst, '0');

		break;
	} /* switch() */

	return dns_b_strllen(&dst);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsp, %r14
movq %rdi, (%r14)
movq %rdi, 0x8(%r14)
addq %rdi, %rsi
movq %rsi, 0x10(%r14)
andl $0x0, 0x18(%r14)
andq $0x0, 0x20(%r14)
movl (%rdx), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x25591
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
jae 0x26b0d
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
movb $0x20, (%rax)
jmp 0x26b1a
incq 0x20(%rsp)
movl $0x9b918cc0, 0x18(%rsp) # imm = 0x9B918CC0
movl 0x4(%rbx), %esi
movq %rsp, %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x25591
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
cmpq %rcx, %rax
jae 0x26b48
leaq 0x1(%rax), %rdx
movq %rdx, 0x8(%rsp)
movb $0x20, (%rax)
movq %rdx, %rax
jmp 0x26b55
incq 0x20(%rsp)
movl $0x9b918cc0, 0x18(%rsp) # imm = 0x9B918CC0
cmpl $0x1, 0x4(%rbx)
jne 0x26bc0
movq 0x20(%rsp), %rdx
pushq $0x8
popq %rsi
movl 0x18(%rsp), %r8d
leaq 0xd0e1(%rip), %rdi      # 0x33c50
cmpq $0x1c, %rsi
je 0x26bd3
cmpq %rcx, %rax
jae 0x26b8f
movzbl (%rbx,%rsi), %r9d
shrl $0x4, %r9d
movb (%r9,%rdi), %r9b
movb %r9b, (%rax)
incq %rax
jmp 0x26b98
incq %rdx
movl $0x9b918cc0, %r8d       # imm = 0x9B918CC0
cmpq %rcx, %rax
jae 0x26bb2
movzbl (%rbx,%rsi), %r9d
andl $0xf, %r9d
movb (%r9,%rdi), %r9b
movb %r9b, (%rax)
incq %rax
jmp 0x26bbb
incq %rdx
movl $0x9b918cc0, %r8d       # imm = 0x9B918CC0
incq %rsi
jmp 0x26b6f
cmpq %rcx, %rax
jae 0x26be4
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
movb $0x30, (%rax)
jmp 0x26bf1
movq %rax, 0x8(%rsp)
movq %rdx, 0x20(%rsp)
movl %r8d, 0x18(%rsp)
jmp 0x26bf1
incq 0x20(%rsp)
movl $0x9b918cc0, 0x18(%rsp) # imm = 0x9B918CC0
movq %rsp, %rdi
callq 0x25899
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_txt_init
struct dns_txt *dns_txt_init(struct dns_txt *txt, size_t size) {
	assert(size > offsetof(struct dns_txt, data));

	txt->size	= size - offsetof(struct dns_txt, data);
	txt->len	= 0;

	return txt;
}

// Assembly:
cmpq $0x10, %rsi
jbe 0x26c17
addq $-0x10, %rsi
movq %rsi, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0xd344(%rip), %rdi      # 0x33f63
leaq 0xd247(%rip), %rsi      # 0x33e6d
leaq 0xd35c(%rip), %rcx      # 0x33f89
movl $0xefd, %edx            # imm = 0xEFD
callq 0xf8e0
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdx, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq (%rdi), %r13
addq $0x5c, %rbx
movzwl 0x14(%rsi), %ebp
movzwl 0x16(%rsi), %r14d
addq %rbp, %r14
xorl %r12d, %r12d
cmpq %r14, %rbp
jae 0x26cb1
movzbl (%rbx,%rbp), %r15d
incq %rbp
movq %r14, %rcx
subq %rbp, %rcx
movl $0x9b918cc1, %eax       # imm = 0x9B918CC1
cmpq %r15, %rcx
jb 0x26cbc
movq %r13, %rcx
subq %r12, %rcx
cmpq %r15, %rcx
jb 0x26cbc
movq 0x10(%rsp), %rax
leaq (%rax,%r12), %rdi
leaq (%rbx,%rbp), %rsi
movq %r15, %rdx
callq 0xfad0
addq %r15, %r12
addq %r15, %rbp
jmp 0x26c6c
movq 0x8(%rsp), %rax
movq %r12, 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_O2/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 0x26d8a
movq %rdi, 0x8(%rsp)
leaq 0x5c(%rdi), %rbx
movq 0x8(%rsi), %r14
addq $0x10, %rsi
movq %rsi, 0x10(%rsp)
leaq 0xfe(%r14), %rax
xorl %r15d, %r15d
movl $0xff, %ecx
xorl %edx, %edx
divq %rcx
addl %r14d, %eax
rolw $0x8, %ax
movw %ax, (%rbx,%r13)
addq $0x2, %r13
movq %r14, %r12
subq %r15, %r12
jbe 0x26d7f
cmpq %rbp, %r13
jae 0x26d78
movl $0xff, %eax
cmpq %rax, %r12
cmovaeq %rax, %r12
movb %r12b, (%rbx,%r13)
incq %r13
movq %rbp, %rax
subq %r13, %rax
cmpq %r12, %rax
jb 0x26d78
leaq (%rbx,%r13), %rdi
movq 0x10(%rsp), %rax
leaq (%rax,%r15), %rsi
movq %r12, %rdx
callq 0xfad0
addq %r12, %r13
addq %r12, %r15
jmp 0x26d30
movl $0x9b918cc0, %eax       # imm = 0x9B918CC0
jmp 0x26d8a
movq 0x8(%rsp), %rax
movq %r13, 0x50(%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_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_rrtype
static const struct dns_rrtype *dns_rrtype(enum dns_type type) {
	const struct dns_rrtype *t;

	for (t = dns_rrtypes; t < endof(dns_rrtypes); t++) {
		if (t->type == type && t->parse) {
			return t;
		}
	}

	return NULL;
}

// Assembly:
xorl %eax, %eax
leaq 0x1d7f6(%rip), %rcx     # 0x44780
xorl %edx, %edx
cmpq $0x33f, %rdx            # imm = 0x33F
ja 0x26fae
cmpl %edi, (%rdx,%rcx)
jne 0x26fa2
cmpq $0x0, 0x18(%rdx,%rcx)
jne 0x26fa8
addq $0x40, %rdx
jmp 0x26f8c
addq %rdx, %rcx
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl %ecx, %edi
callq 0x26f81
testq %rax, %rax
je 0x26fe4
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x26fe4
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmpq *%rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x101a0
movq %rax, %rbx
testq %rax, %rax
je 0x2701e
movups 0xac9e(%rip), %xmm0     # 0x31ca8
movups %xmm0, (%rbx)
movq 0xaca4(%rip), %rax      # 0x31cb8
movq %rax, 0x10(%rbx)
movq %rbx, 0x8(%rbx)
jmp 0x27028
callq 0xf0a0
movl (%rax), %eax
movl %eax, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x27066
movq %rdi, %rbx
pushq $-0x1
popq %rax
lock
xaddq %rax, 0x10(%rdi)
cmpl $0x1, %eax
jne 0x27066
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2706e
movq 0x168(%rdi), %r14
callq 0xffc0
movq %r14, %rdi
jmp 0x27050
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xffc0
// File: /workspace/github_c_makefile_star2_O2/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 0xf7d0
movq %rax, %rbx
testq %rax, %rax
je 0x270d1
leaq 0xcefd(%rip), %rsi      # 0x33fc0
movq %rbx, %rdi
callq 0x105d0
testl %eax, %eax
jne 0x270d5
jmp 0x270e2
movl 0x4(%rsp), %eax
movl %eax, (%r14)
movq %rbx, %rdi
callq 0x107f0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x273b4
testq %rax, %rax
je 0x27125
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10430
movl %eax, %ebx
movq %r14, %rdi
callq 0xfd70
movl %ebx, %eax
jmp 0x27129
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_hosts_loadfile
int dns_hosts_loadfile(struct dns_hosts *hosts, FILE *fp) {
	struct dns_hosts_entry ent;
	char word[DNS_PP_MAX(INET6_ADDRSTRLEN, DNS_D_MAXNAME) + 1];
	unsigned wp, wc, skip;
	int ch, error;

	rewind(fp);

	do {
		memset(&ent, '\0', sizeof ent);
		wc	= 0;
		skip	= 0;

		do {
			memset(word, '\0', sizeof word);
			wp	= 0;

			while (EOF != (ch = fgetc(fp)) && ch != '\n') {
				skip	|= !!dns_hosts_iscom(ch);

				if (skip)
					continue;

				if (dns_hosts_issep(ch))
					break;

				if (wp < sizeof word - 1)
					word[wp]	= ch;
				wp++;
			}

			if (!wp)
				continue;

			wc++;

			switch (wc) {
			case 0:
				break;
			case 1:
				ent.af	= (strchr(word, ':'))? AF_INET6 : AF_INET;
				skip	= (1 != dns_inet_pton(ent.af, word, &ent.addr));

				break;
			default:
				if (!wp)
					break;

				dns_d_anchor(ent.host, sizeof ent.host, word, wp);

				if ((error = dns_hosts_insert(hosts, ent.af, &ent.addr, ent.host, (wc > 2))))
					return error;

				break;
			} /* switch() */
		} while (ch != EOF && ch != '\n');
	} while (ch != EOF);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movq %rsi, %rdi
callq 0xf160
pushq $0x1
popq %r12
xorl %r15d, %r15d
movl $0x170, %edx            # imm = 0x170
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0xf790
xorl %r14d, %r14d
movl %r15d, 0x4(%rsp)
movl $0x100, %edx            # imm = 0x100
leaq 0x180(%rsp), %rdi
xorl %esi, %esi
callq 0xf790
xorl %r13d, %r13d
movq %rbx, %rdi
callq 0x105f0
movl %eax, %ebp
movl %r13d, %r15d
cmpl $-0x1, %eax
je 0x271e2
cmpl $0xa, %ebp
je 0x271e2
cmpl $0x23, %ebp
sete %al
cmpl $0x3b, %ebp
sete %cl
orb %al, %cl
movzbl %cl, %eax
orl %eax, %r14d
movl %r12d, %r14d
jne 0x27189
movzbl %bpl, %edi
callq 0x272bc
testb %al, %al
jne 0x271df
cmpl $0xfe, %r13d
ja 0x271d7
movb %bpl, 0x180(%rsp,%r15)
incl %r13d
xorl %r14d, %r14d
jmp 0x27189
xorl %r14d, %r14d
testl %r13d, %r13d
je 0x2723c
movl 0x4(%rsp), %eax
cmpl $-0x1, %eax
je 0x27243
testl %eax, %eax
jne 0x27248
leaq 0x180(%rsp), %r14
movq %r14, %rdi
pushq $0x3a
popq %rsi
callq 0xf500
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
leal 0x2(,%rcx,8), %edi
movl %edi, 0x15c(%rsp)
movq %r14, %rsi
leaq 0x160(%rsp), %rdx
callq 0x10a40
xorl %r14d, %r14d
cmpl $0x1, %eax
setne %r14b
movl %r12d, %r15d
jmp 0x27296
movl 0x4(%rsp), %r15d
jmp 0x27296
xorl %r15d, %r15d
jmp 0x27296
movl $0x100, %esi            # imm = 0x100
leaq 0x10(%rsp), %r13
movq %r13, %rdi
leaq 0x180(%rsp), %rdx
movq %r15, %rcx
movl %eax, %r15d
callq 0xfbe0
movl 0x15c(%rsp), %esi
xorl %r8d, %r8d
cmpl $0x2, %r15d
setae %r8b
movq 0x8(%rsp), %rdi
leaq 0x160(%rsp), %rdx
movq %r13, %rcx
callq 0xf760
testl %eax, %eax
jne 0x272aa
incl %r15d
xorl %eax, %eax
cmpl $0xa, %ebp
je 0x27156
cmpl $-0x1, %ebp
jne 0x2716d
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %ebp
movq %rcx, %r13
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r14
movl $0x170, %edi            # imm = 0x170
callq 0x101a0
movq %rax, %rbx
testq %rax, %rax
je 0x2734d
movq %r13, %rdi
callq 0xf580
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
movq %r13, %rdx
movq %rax, %rcx
callq 0xfbe0
movl %r12d, 0x14c(%rbx)
cmpl $0x2, %r12d
je 0x27356
cmpl $0xa, %r12d
jne 0x27398
movups (%r15), %xmm0
movups %xmm0, 0x150(%rbx)
leaq 0x100(%rbx), %rdi
pushq $0x4a
popq %rsi
movq %r15, %rdx
callq 0x106c0
jmp 0x27371
callq 0xf0a0
movl (%rax), %ebp
jmp 0x2739b
movl (%r15), %eax
movl %eax, 0x150(%rbx)
leaq 0x100(%rbx), %rdi
pushq $0x4a
popq %rsi
movq %r15, %rdx
callq 0xffd0
movb %bpl, 0x160(%rbx)
movq %rbx, %rax
addq $0x168, %rax            # imm = 0x168
andq $0x0, 0x168(%rbx)
movq 0x8(%r14), %rcx
movq %rbx, (%rcx)
movq %rax, 0x8(%r14)
xorl %ebp, %ebp
jmp 0x273a3
pushq $0x16
popq %rbp
movq %rbx, %rdi
callq 0xffc0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/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 $0x38, %rsp
testq %rdi, %rdi
je 0x274bf
movq %rsi, %rbx
cmpb $0x0, (%rdi)
je 0x2741d
movq %rdi, 0x8(%rsp)
movq %rbx, (%rsp)
xorl %r13d, %r13d
leaq 0xccac(%rip), %rbx      # 0x34092
leaq 0xcf4c(%rip), %r15      # 0x34339
pushq $0x7
popq %r12
pushq $0xc
popq %rbp
cmpq $0x2, %r13
je 0x27425
movb (%r13,%rbx), %r14b
movsbl %r14b, %esi
movq %r15, %rdi
movq %r12, %rdx
callq 0xff20
testq %rax, %rax
je 0x2742a
movb %r14b, 0x10(%rsp,%r13)
incq %r13
jmp 0x273f4
pushq $0x16
popq %rbp
jmp 0x274ac
pushq $0x2
popq %rdx
jmp 0x27433
movq %r13, %rdx
cmpq $0x1f, %r13
ja 0x274a8
movb $0x65, 0x10(%rsp,%r13)
leaq 0x10(%rsp), %rax
addq %rdx, %rax
incq %rax
pushq $0x1f
popq %rcx
subq %rdx, %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x274a8
leaq (%rdx,%r13), %rsi
movb (%rbx,%rsi), %sil
movb %sil, (%rax,%rdx)
incq %rdx
testb %sil, %sil
jne 0x2744c
leaq 0x10(%rsp), %rsi
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xffa0
testq %rax, %rax
movq (%rsp), %rbx
jne 0x274b0
callq 0xf0a0
movl (%rax), %ebp
cmpl $0x16, %ebp
jne 0x274ac
movq %rax, %r15
leaq 0xcbfc(%rip), %rsi      # 0x34092
movq %r14, %rdi
callq 0xffa0
testq %rax, %rax
jne 0x274b0
movl (%r15), %ebp
jmp 0x274ac
movq (%rsp), %rbx
movl %ebp, (%rbx)
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xce2a(%rip), %rdi      # 0x342f0
leaq 0xc9a0(%rip), %rsi      # 0x33e6d
leaq 0xce32(%rip), %rcx      # 0x34306
movl $0x4c3, %edx            # imm = 0x4C3
callq 0xf8e0
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq (%rdi), %r13
movq %rsp, %r14
pushq $0x20
popq %r15
testq %r13, %r13
je 0x27563
movq 0x168(%r13), %r12
movl 0x14c(%r13), %edi
leaq 0x150(%r13), %rsi
movq %r14, %rdx
pushq $0x2f
popq %rcx
callq 0xfe30
movq %r14, %rdi
movq %rbx, %rsi
callq 0xff30
movq %r14, %rdi
callq 0xf580
movq %rax, %rbp
decl %ebp
movl %r15d, %edi
movq %rbx, %rsi
callq 0x10090
incl %ebp
cmpl $0x10, %ebp
jb 0x27536
movq %r13, %rdi
movq %rbx, %rsi
callq 0xff30
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x10090
movq %r12, %r13
jmp 0x274f9
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq