LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_strlcpy
size_t dns_strlcpy(char *dst, const char *src, size_t lim) {
	char *d		= dst;
	char *e		= &dst[lim];
	const char *s	= src;

	if (d < e) {
		do {
			if ('\0' == (*d++ = *s++))
				return s - src - 1;
		} while (d < e);

		d[-1]	= '\0';
	}

	while (*s++ != '\0')
		;;

	return s - src - 1;
}

// Assembly:
movq %rsi, %rax
movq %rsi, %rcx
testq %rdx, %rdx
jle 0x23386
addq %rdi, %rdx
movq %rax, %rcx
movb (%rcx), %sil
movb %sil, (%rdi)
incq %rcx
testb %sil, %sil
je 0x23394
incq %rdi
cmpq %rdx, %rdi
jb 0x2336c
movb $0x0, -0x1(%rdi)
leaq 0x1(%rcx), %rdx
cmpb $0x0, (%rcx)
movq %rdx, %rcx
jne 0x23386
jmp 0x23397
movq %rcx, %rdx
notq %rax
addq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_strlcat
size_t dns_strlcat(char *dst, const char *src, size_t lim) {
	char *d = memchr(dst, '\0', lim);
	char *e = &dst[lim];
	const char *s = src;
	const char *p;

	if (d && d < e) {
		do {
			if ('\0' == (*d++ = *s++))
				return d - dst - 1;
		} while (d < e);

		d[-1] = '\0';
	}

	p = s;

	while (*s++ != '\0')
		;;

	return lim + (s - p - 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
xorl %esi, %esi
callq 0xff20
movq %rax, %rcx
leaq (%r15,%r14), %rdx
testq %rax, %rax
setne %al
cmpq %rdx, %rcx
setb %sil
andb %al, %sil
cmpb $0x1, %sil
jne 0x233f3
movq %rcx, %rax
subq %r15, %rax
movb (%rbx), %sil
movb %sil, (%rcx)
testb %sil, %sil
je 0x23405
incq %rcx
incq %rbx
incq %rax
cmpq %rdx, %rcx
jb 0x233d6
movb $0x0, -0x1(%rcx)
decq %r14
movq %r14, %rax
incq %rax
cmpb $0x0, (%rbx)
leaq 0x1(%rbx), %rbx
jne 0x233f9
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_p_count
unsigned dns_p_count(struct dns_packet *P, enum dns_section section) {
	unsigned count;

	switch (section) {
	case DNS_S_QD:
		return ntohs(dns_header(P)->qdcount);
	case DNS_S_AN:
		return ntohs(dns_header(P)->ancount);
	case DNS_S_NS:
		return ntohs(dns_header(P)->nscount);
	case DNS_S_AR:
		return ntohs(dns_header(P)->arcount);
	default:
		count = 0;

		if (section & DNS_S_QD)
			count += ntohs(dns_header(P)->qdcount);
		if (section & DNS_S_AN)
			count += ntohs(dns_header(P)->ancount);
		if (section & DNS_S_NS)
			count += ntohs(dns_header(P)->nscount);
		if (section & DNS_S_AR)
			count += ntohs(dns_header(P)->arcount);

		return count;
	}
}

// Assembly:
leal -0x1(%rsi), %eax
cmpl $0x7, %eax
ja 0x23441
leaq 0xe6c6(%rip), %rcx      # 0x31ae0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzwl 0x60(%rdi), %eax
jmp 0x23439
movzwl 0x64(%rdi), %eax
jmp 0x23439
movzwl 0x62(%rdi), %eax
jmp 0x23439
movzwl 0x66(%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %eax
retq
xorl %eax, %eax
testb $0x1, %sil
je 0x23454
movzwl 0x60(%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %eax
testb $0x2, %sil
je 0x23467
movzwl 0x62(%rdi), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
addl %ecx, %eax
testb $0x4, %sil
je 0x2347a
movzwl 0x64(%rdi), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
addl %ecx, %eax
testb $0x8, %sil
je 0x2348d
movzwl 0x66(%rdi), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
addl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_p_init
struct dns_packet *dns_p_init(struct dns_packet *P, size_t size) {
	if (!P)
		return 0;

	assert(size >= offsetof(struct dns_packet, data) + 12);

	memset(P, 0, sizeof *P);
	P->size = size - offsetof(struct dns_packet, data);
	P->end  = 12;

	memset(P->data, '\0', 12);

	return P;
}

// Assembly:
testq %rdi, %rdi
je 0x234cc
cmpq $0x67, %rsi
jbe 0x234d0
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
addq $-0x5c, %rsi
movq %rsi, 0x48(%rdi)
movq $0xc, 0x50(%rdi)
andl $0x0, 0x64(%rdi)
andq $0x0, 0x5c(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0x10966(%rip), %rdi     # 0x33e3e
leaq 0x1098e(%rip), %rsi     # 0x33e6d
leaq 0x109cc(%rip), %rcx     # 0x33eb2
movl $0x60d, %edx            # imm = 0x60D
callq 0xf8e0
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_p_make
struct dns_packet *dns_p_make(size_t len, int *error) {
	struct dns_packet *P;
	size_t size = dns_p_calcsize(len);

	if (!(P = dns_p_init(malloc(size), size)))
		*error = dns_syerr();

	return P;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq $0xd, %rdi
pushq $0xc
popq %r15
cmovaeq %rdi, %r15
addq $0x5c, %r15
movq %r15, %rdi
callq 0x101a0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x10b10
testq %r14, %r14
jne 0x2352c
callq 0xf0a0
movl (%rax), %eax
movl %eax, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_p_grow
int dns_p_grow(struct dns_packet **P) {
	struct dns_packet *tmp;
	size_t size;
	int error;

	if (!*P) {
		if (!(*P = dns_p_make(DNS_P_QBUFSIZ, &error)))
			return error;

		return 0;
	}

	size = dns_p_sizeof(*P);
	size |= size >> 1;
	size |= size >> 2;
	size |= size >> 4;
	size |= size >> 8;
	size++;

	if (size > 65536)
		return DNS_ENOBUFS;

	if (!(tmp = realloc(*P, dns_p_calcsize(size))))
		return dns_syerr();

	tmp->size = size;
	*P = tmp;

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x235b3
movq 0x50(%rdi), %rax
leaq 0x5c(%rax), %rcx
cmpq $0xc, %rax
pushq $0x68
popq %rax
cmovaeq %rcx, %rax
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %r14
shrq $0x8, %r14
orq %rcx, %r14
incq %r14
movl $0x9b918cc0, %eax       # imm = 0x9B918CC0
cmpq $0x10000, %r14          # imm = 0x10000
ja 0x235dc
cmpq $0xd, %r14
pushq $0xc
popq %rsi
cmovaeq %r14, %rsi
addq $0x5c, %rsi
callq 0x106d0
testq %rax, %rax
je 0x235d5
movq %r14, 0x48(%rax)
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x235dc
leaq 0x4(%rsp), %rsi
movl $0x160, %edi            # imm = 0x160
callq 0xfaa0
movq %rax, %rcx
movq %rax, (%rbx)
xorl %eax, %eax
testq %rcx, %rcx
jne 0x235dc
movl 0x4(%rsp), %eax
jmp 0x235dc
callq 0xf0a0
movl (%rax), %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_p_copy
struct dns_packet *dns_p_copy(struct dns_packet *P, const struct dns_packet *P0) {
	if (!P)
		return 0;

	P->end	= DNS_PP_MIN(P->size, P0->end);

	memcpy(P->data, P0->data, P->end);

	return P;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x2360d
movq 0x48(%rbx), %rax
movq 0x50(%rsi), %rdx
cmpq %rdx, %rax
cmovbq %rax, %rdx
movq %rdx, 0x50(%rbx)
leaq 0x5c(%rbx), %rdi
addq $0x5c, %rsi
callq 0xfad0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_rr_copy
int dns_rr_copy(struct dns_packet *P, struct dns_rr *rr, struct dns_packet *Q) {
	unsigned char dn[DNS_D_MAXNAME + 1];
	union dns_any any;
	size_t len;
	int error;

	if (!(len = dns_d_expand(dn, sizeof dn, rr->dn.p, Q, &error)))
		return error;
	else if (len >= sizeof dn)
		return DNS_EILLEGAL;

	if (rr->section != DNS_S_QD && (error = dns_any_parse(dns_any_init(&any, sizeof any), rr, Q)))
		return error;

	return dns_p_push(P, rr->section, dn, len, rr->type, rr->class, rr->ttl, &any);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x528, %rsp            # imm = 0x528
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x4(%rsi), %edx
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %r8
movl $0x100, %esi            # imm = 0x100
movq %r12, %rcx
callq 0xff50
testq %rax, %rax
je 0x23d6a
movq %rax, %r15
movl $0x9b918cc1, %eax       # imm = 0x9B918CC1
cmpq $0xff, %r15
ja 0x23dbf
cmpl $0x1, (%r14)
jne 0x23d70
pushq $0x1
popq %rsi
jmp 0x23d96
movl 0xc(%rsp), %eax
jmp 0x23dbf
leaq 0x118(%rsp), %rdi
movq $0x400, (%rdi)          # imm = 0x400
andq $0x0, 0x8(%rdi)
movq %r14, %rsi
movq %r12, %rdx
callq 0xff00
testl %eax, %eax
jne 0x23dbf
movl (%r14), %esi
movl 0x8(%r14), %r8d
movl 0xc(%r14), %r9d
movl 0x10(%r14), %eax
leaq 0x118(%rsp), %r10
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rcx
pushq %r10
pushq %rax
callq 0x10780
popq %rcx
popq %rdx
addq $0x528, %rsp            # imm = 0x528
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_rr_cmp
int dns_rr_cmp(struct dns_rr *r0, struct dns_packet *P0, struct dns_rr *r1, struct dns_packet *P1) {
	char host0[DNS_D_MAXNAME + 1], host1[DNS_D_MAXNAME + 1];
	union dns_any any0, any1;
	int cmp, error;
	size_t len;

	if ((cmp = r0->type - r1->type))
		return cmp;

	if ((cmp = r0->class - r1->class))
		return cmp;

	/*
	 * FIXME: Do label-by-label comparison to handle illegally long names?
	 */

	if (!(len = dns_d_expand(host0, sizeof host0, r0->dn.p, P0, &error))
	||  len >= sizeof host0)
		return -1;

	if (!(len = dns_d_expand(host1, sizeof host1, r1->dn.p, P1, &error))
	||  len >= sizeof host1)
		return 1;

	if ((cmp = strcasecmp(host0, host1)))
		return cmp;

	if (DNS_S_QD & (r0->section | r1->section)) {
		if (r0->section == r1->section)
			return 0;

		return (r0->section == DNS_S_QD)? -1 : 1;
	}

	if ((error = dns_any_parse(&any0, r0, P0)))
		return -1;

	if ((error = dns_any_parse(&any1, r1, P1)))
		return 1;

	return dns_any_cmp(&any0, r0->type, &any1, r1->type);
}

// Assembly:
movl 0x8(%rdi), %eax
subl 0x8(%rdx), %eax
je 0x23dd7
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa38, %rsp            # imm = 0xA38
movq %rdx, %rbx
movq %rdi, %r14
movl 0xc(%rdi), %eax
subl 0xc(%rdx), %eax
jne 0x23e7c
movq %rcx, %r15
movq %rsi, %r12
movzwl 0x4(%r14), %edx
leaq 0x110(%rsp), %rdi
leaq 0xc(%rsp), %r8
movl $0x100, %esi            # imm = 0x100
movq %r12, %rcx
callq 0xff50
addq $-0x100, %rax
pushq $-0x1
popq %rbp
cmpq $-0xff, %rax
jae 0x23e34
movl %ebp, %eax
jmp 0x23e7c
movzwl 0x4(%rbx), %edx
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %r8
movl $0x100, %esi            # imm = 0x100
movq %r15, %rcx
callq 0xff50
addq $-0x100, %rax
pushq $0x1
popq %r13
cmpq $-0xff, %rax
jae 0x23e66
movl %r13d, %eax
jmp 0x23e7c
leaq 0x110(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xfed0
testl %eax, %eax
je 0x23e8e
addq $0xa38, %rsp            # imm = 0xA38
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl (%r14), %ecx
movl (%rbx), %edx
movl %edx, %eax
orl %ecx, %eax
testb $0x1, %al
jne 0x23ef0
leaq 0x628(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xff00
movl %eax, %ecx
movl %ebp, %eax
testl %ecx, %ecx
jne 0x23e7c
leaq 0x218(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xff00
movl %eax, %ecx
movl %r13d, %eax
testl %ecx, %ecx
jne 0x23e7c
movl 0x8(%r14), %esi
movl 0x8(%rbx), %ecx
leaq 0x628(%rsp), %rdi
leaq 0x218(%rsp), %rdx
callq 0xfd20
jmp 0x23e7c
xorl %eax, %eax
cmpl %edx, %ecx
je 0x23e7c
xorl %eax, %eax
cmpl $0x1, %ecx
setne %al
leal -0x1(,%rax,2), %eax
jmp 0x23e7c
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_p_dictadd
void dns_p_dictadd(struct dns_packet *P, unsigned short dn) {
	unsigned short lp, lptr, i;

	lp	= dn;

	while (lp < P->end) {
		if (0xc0 == (0xc0 & P->data[lp]) && P->end - lp >= 2 && lp != dn) {
			lptr	= ((0x3f & P->data[lp + 0]) << 8)
				| ((0xff & P->data[lp + 1]) << 0);

			for (i = 0; i < lengthof(P->dict) && P->dict[i]; i++) {
				if (P->dict[i] == lptr) {
					P->dict[i]	= dn;

					return;
				}
			}
		}

		lp	= dns_l_skip(lp, P->data, P->end);
	}

	for (i = 0; i < lengthof(P->dict); i++) {
		if (!P->dict[i]) {
			P->dict[i]	= dn;

			break;
		}
	}
}

// Assembly:
pushq %rbx
movq 0x50(%rdi), %rax
movabsq $-0x1, %rcx
movl %esi, %r10d
movzwl %r10w, %r8d
movq %rax, %r10
subq %r8, %r10
jbe 0x23fc4
movb 0x5c(%rdi,%r8), %r9b
movzbl %r9b, %edx
cmpw %si, %r8w
je 0x23f94
cmpq $0x2, %r10
jb 0x23f94
cmpb $-0x40, %r9b
jb 0x23f94
movl %edx, %r10d
andl $0x3f, %r10d
shll $0x8, %r10d
movzbl 0x5d(%rdi,%r8), %r11d
orl %r10d, %r11d
movq %rcx, %r10
cmpq $0xf, %r10
je 0x23f94
movzwl 0x2(%rdi,%r10,2), %ebx
testl %ebx, %ebx
je 0x23f94
incq %r10
cmpl %ebx, %r11d
jne 0x23f7a
jmp 0x23fe3
movq %rax, %r10
cmpb $0x3f, %r9b
ja 0x23f3c
incl %r8d
movzwl %r8w, %r8d
movq %rax, %r9
subq %r8, %r9
movq %rax, %r10
cmpq %rdx, %r9
jb 0x23f3c
addq %rdx, %r8
testq %rdx, %rdx
cmoveq %rax, %r8
movq %r8, %r10
jmp 0x23f3c
movabsq $-0x1, %rax
cmpq $0xf, %rax
je 0x23fe8
leaq 0x1(%rax), %r10
cmpw $0x0, 0x2(%rdi,%rax,2)
movq %r10, %rax
jne 0x23fce
movw %si, (%rdi,%r10,2)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_d_push
int dns_d_push(struct dns_packet *P, const void *dn, size_t len) {
	size_t lim	= P->size - P->end;
	unsigned dp	= P->end;
	int error	= DNS_EILLEGAL; /* silence compiler */

	len	= dns_d_comp(&P->data[dp], lim, dn, len, P, &error);

	if (len == 0)
		return error;
	if (len > lim)
		return DNS_ENOBUFS;

	P->end	+= len;

	dns_p_dictadd(P, dp);

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x48(%rdi), %r14
movq 0x50(%rdi), %r15
subq %r15, %r14
leaq 0xc(%rsp), %r9
movl $0x9b918cc1, (%r9)      # imm = 0x9B918CC1
movl %r15d, %eax
addq %rax, %rdi
addq $0x5c, %rdi
movq %r14, %rsi
movq %rbx, %r8
callq 0xfe90
testq %rax, %rax
je 0x242e5
movl $0x9b918cc0, %ecx       # imm = 0x9B918CC0
cmpq %r14, %rax
ja 0x242e9
addq %rax, 0x50(%rbx)
movzwl %r15w, %esi
movq %rbx, %rdi
callq 0xf3e0
xorl %ecx, %ecx
jmp 0x242e9
movl 0xc(%rsp), %ecx
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_any_push
int dns_any_push(struct dns_packet *P, union dns_any *any, enum dns_type type) {
	const struct dns_rrtype *t;

	if ((t = dns_rrtype(type)))
		return t->push(P, any);

	if (P->size - P->end < any->rdata.len + 2)
		return DNS_ENOBUFS;

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

	memcpy(&P->data[P->end], any->rdata.data, any->rdata.len);
	P->end	+= any->rdata.len;

	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rbp
movl %edx, %edi
callq 0x26f81
testq %rax, %rax
je 0x2431e
movq 0x20(%rax), %rcx
movq %rbp, %rdi
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rcx
movq 0x48(%rbp), %rsi
movq 0x50(%rbp), %rcx
subq %rcx, %rsi
movq 0x8(%rbx), %rdx
leaq 0x2(%rdx), %rdi
movl $0x9b918cc0, %eax       # imm = 0x9B918CC0
cmpq %rdi, %rsi
jb 0x24379
leaq 0x5c(%rbp), %rdi
leaq 0x1(%rcx), %rax
movq %rax, 0x50(%rbp)
movb %dh, 0x5c(%rbp,%rcx)
movb 0x8(%rbx), %al
movq 0x50(%rbp), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x50(%rbp)
movb %al, 0x5c(%rbp,%rcx)
addq 0x50(%rbp), %rdi
leaq 0x10(%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0xfad0
movq 0x8(%rbx), %rax
addq %rax, 0x50(%rbp)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_d_init
char *dns_d_init(void *dst, size_t lim, const void *src, size_t len, int flags) {
	if (flags & DNS_D_TRIM) {
		dns_d_trim(dst, lim, src, len, flags);
	} if (flags & DNS_D_ANCHOR) {
		dns_d_anchor(dst, lim, src, len);
	} else {
		memmove(dst, src, DNS_PP_MIN(lim, len));

		if (lim > 0)
			((char *)dst)[DNS_PP_MIN(len, lim - 1)]	= '\0';
	}

	return dst;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testb $0x4, %r8b
jne 0x24706
andl $0x1, %r8d
jmp 0x2477e
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x24718
cmpb $0x2e, (%rdx,%rcx)
jne 0x2471b
incq %rcx
jmp 0x24708
movq %r14, %rcx
xorl %eax, %eax
pushq $0x2e
popq %rsi
xorl %edi, %edi
cmpq %r14, %rcx
jae 0x24753
movb (%rdx,%rcx), %r9b
cmpb $0x2e, %r9b
jne 0x2473a
cmpl $0x2e, %edi
jne 0x2473a
movl %esi, %edi
jmp 0x2474e
cmpq %r15, %rax
jae 0x24747
movb %r9b, (%rbx,%rax)
movb (%rdx,%rcx), %r9b
incq %rax
movzbl %r9b, %edi
incq %rcx
jmp 0x24722
andl $0x1, %r8d
je 0x2476a
cmpl $0x2e, %edi
je 0x2476a
cmpq %r15, %rax
jae 0x24767
movb $0x2e, (%rbx,%rax)
incq %rax
testq %r15, %r15
je 0x2477e
leaq -0x1(%r15), %rcx
cmpq %rcx, %rax
cmovbq %rax, %rcx
movb $0x0, (%rbx,%rcx)
testl %r8d, %r8d
je 0x24793
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0xfbe0
jmp 0x247bf
cmpq %r14, %r15
movq %r14, %rax
cmovbq %r15, %rax
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x106a0
testq %r15, %r15
je 0x247bf
decq %r15
cmpq %r14, %r15
cmovaeq %r14, %r15
movb $0x0, (%rbx,%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_d_anchor
size_t dns_d_anchor(void *dst, size_t lim, const void *src, size_t len) {
	if (len == 0)
		return 0;

	memmove(dst, src, DNS_PP_MIN(lim, len));

	if (((const char *)src)[len - 1] != '.') {
		if (len < lim)
			((char *)dst)[len]	= '.';
		len++;
	}

	if (lim > 0)
		((char *)dst)[DNS_PP_MIN(lim - 1, len)]	= '\0';

	return len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rcx, %rcx
je 0x2481e
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
cmpq %rcx, %rsi
movq %rcx, %rdx
cmovbq %rsi, %rdx
movq %r12, %rsi
callq 0x106a0
cmpb $0x2e, -0x1(%r12,%rbx)
je 0x24808
cmpq %r14, %rbx
jae 0x24805
movb $0x2e, (%r15,%rbx)
incq %rbx
testq %r14, %r14
je 0x24820
decq %r14
cmpq %rbx, %r14
cmovaeq %rbx, %r14
movb $0x0, (%r15,%r14)
jmp 0x24820
xorl %ebx, %ebx
movq %rbx, %rax
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_d_cleave
size_t dns_d_cleave(void *dst, size_t lim, const void *src, size_t len) {
	const char *dot;

	/* XXX: Skip any leading dot. Handles cleaving root ".". */
	if (len == 0 || !(dot = memchr((const char *)src + 1, '.', len - 1)))
		return 0;

	len	-= dot - (const char *)src;

	/* XXX: Unless root, skip the label's trailing dot. */
	if (len > 1) {
		src	= ++dot;
		len--;
	} else
		src	= dot;

	memmove(dst, src, DNS_PP_MIN(lim, len));

	if (lim > 0)
		((char *)dst)[DNS_PP_MIN(lim - 1, len)]	= '\0';

	return len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rcx, %rcx
je 0x2489d
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1(%rdx), %rdi
leaq -0x1(%rcx), %rdx
pushq $0x2e
popq %rsi
callq 0xff20
testq %rax, %rax
je 0x2489d
subq %rax, %rbx
addq %r12, %rbx
xorl %ecx, %ecx
cmpq $0x2, %rbx
setae %cl
addq %rcx, %rax
subq %rcx, %rbx
cmpq %r14, %rbx
movq %r14, %rdx
cmovbq %rbx, %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x106a0
testq %r14, %r14
je 0x2489f
decq %r14
cmpq %rbx, %r14
cmovaeq %rbx, %r14
movb $0x0, (%r15,%r14)
jmp 0x2489f
xorl %ebx, %ebx
movq %rbx, %rax
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_l_expand
static size_t dns_l_expand(unsigned char *dst, size_t lim, unsigned short src, unsigned short *nxt, const unsigned char *data, size_t end) {
	unsigned short len;
	unsigned nptrs	= 0;

retry:
	if (src >= end)
		goto invalid;

	switch (0x03 & (data[src] >> 6)) {
	case 0x00:
		len	= (0x3f & (data[src++]));

		if (end - src < len)
			goto invalid;

		if (lim > 0) {
			memcpy(dst, &data[src], DNS_PP_MIN(lim, len));

			dst[DNS_PP_MIN(lim - 1, len)]	= '\0';
		}

		*nxt	= src + len;

		return len;
	case 0x01:
		goto invalid;
	case 0x02:
		goto invalid;
	case 0x03:
		if (++nptrs > DNS_D_MAXPTRS)
			goto invalid;

		if (end - src < 2)
			goto invalid;

		src	= ((0x3f & data[src + 0]) << 8)
			| ((0xff & data[src + 1]) << 0);

		goto retry;
	} /* switch() */

	/* NOT REACHED */
invalid:
	*nxt	= end;

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
xorl %edx, %edx
movzwl %si, %eax
movq %r8, %rsi
subq %rax, %rsi
jbe 0x24ba4
movzbl (%rcx,%rax), %r15d
movl %r15d, %edi
shrl $0x6, %edi
cmpl $0x3, %edi
jne 0x24b9d
cmpl $0x7e, %edx
ja 0x24ba4
cmpq $0x2, %rsi
jb 0x24ba4
incl %edx
andb $0x3f, %r15b
movzbl %r15b, %edi
shll $0x8, %edi
movzbl 0x1(%rcx,%rax), %esi
orl %edi, %esi
jmp 0x24b61
decl %edi
cmpl $0x2, %edi
jae 0x24bba
xorl %r15d, %r15d
movw %r8w, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
incl %eax
andl $0x3f, %r15d
movzwl %ax, %r12d
movq %r8, %rax
subq %r12, %rax
cmpq %r15, %rax
jb 0x24ba4
addq %r12, %rcx
movq %r14, %rdi
movq %rcx, %rsi
movq %r15, %rdx
callq 0xfad0
movb $0x0, (%r14,%r15)
movzbl %r15b, %r8d
addl %r12d, %r8d
jmp 0x24ba7
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_d_expand
size_t dns_d_expand(void *dst, size_t lim, unsigned short src, struct dns_packet *P, int *error) {
	size_t dstp	= 0;
	unsigned nptrs	= 0;
	unsigned char len;

	while (src < P->end) {
		switch ((0x03 & (P->data[src] >> 6))) {
		case 0x00:	/* FOLLOWS */
			len	= (0x3f & P->data[src]);

			if (0 == len) {
				if (dstp == 0) {
					if (dstp < lim)
						((unsigned char *)dst)[dstp]	= '.';

					dstp++;
				}

				/* NUL terminate */
				if (lim > 0)
					((unsigned char *)dst)[DNS_PP_MIN(dstp, lim - 1)]	= '\0';

/* success ==> */		return dstp;
			}

			src++;

			if (P->end - src < len)
				goto toolong;

			if (dstp < lim)
				memcpy(&((unsigned char *)dst)[dstp], &P->data[src], DNS_PP_MIN(len, lim - dstp));

			src	+= len;
			dstp	+= len;

			if (dstp < lim)
				((unsigned char *)dst)[dstp]	= '.';

			dstp++;

			nptrs	= 0;

			continue;
		case 0x01:	/* RESERVED */
			goto reserved;
		case 0x02:	/* RESERVED */
			goto reserved;
		case 0x03:	/* POINTER */
			if (++nptrs > DNS_D_MAXPTRS)
				goto toolong;

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

			src	= ((0x3f & P->data[src + 0]) << 8)
				| ((0xff & P->data[src + 1]) << 0);

			continue;
		} /* switch() */
	} /* while() */

toolong:
	*error	= DNS_EILLEGAL;

	if (lim > 0)
		((unsigned char *)dst)[DNS_PP_MIN(dstp, lim - 1)]	= '\0';

	return 0;
reserved:
	*error	= DNS_EILLEGAL;

	if (lim > 0)
		((unsigned char *)dst)[DNS_PP_MIN(dstp, lim - 1)]	= '\0';

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movq %rsi, %rbx
movq %rdi, %r9
leaq 0x5c(%rcx), %rbp
xorl %r13d, %r13d
movq 0x50(%r12), %rax
xorl %esi, %esi
movzwl %dx, %ecx
movq %rax, %rdi
subq %rcx, %rdi
jbe 0x24d1b
movzbl (%rbp,%rcx), %edx
movzwl %dx, %r14d
movl %r14d, %r10d
shrl $0x6, %r10d
cmpl $0x3, %r10d
jne 0x24cae
cmpl $0x7e, %esi
ja 0x24d1b
cmpq $0x2, %rdi
jb 0x24d1b
incl %esi
andb $0x3f, %dl
movzbl %dl, %edi
shll $0x8, %edi
movzbl 0x1(%rcx,%rbp), %edx
orl %edi, %edx
jmp 0x24c62
decl %r10d
cmpl $0x2, %r10d
jb 0x24d1b
andl $0x3f, %r14d
je 0x24d47
incl %ecx
movzwl %cx, %r15d
subq %r15, %rax
cmpq %r14, %rax
jb 0x24d1b
movq %rbx, %rdx
subq %r13, %rdx
jbe 0x24cff
leaq (%r9,%r13), %rdi
leaq (%r15,%rbp), %rsi
cmpq %r14, %rdx
cmovaeq %r14, %rdx
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
callq 0xfad0
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
addq %r14, %r13
cmpq %rbx, %r13
jae 0x24d0c
movb $0x2e, (%r9,%r13)
movzwl %r14w, %edx
addl %r15d, %edx
incq %r13
jmp 0x24c5b
movl $0x9b918cc1, (%r8)      # imm = 0x9B918CC1
xorl %eax, %eax
testq %rbx, %rbx
je 0x24d38
decq %rbx
cmpq %rbx, %r13
cmovbq %r13, %rbx
movb $0x0, (%r9,%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %r13, %r13
je 0x24d51
movq %r13, %rax
jmp 0x24d24
testq %rbx, %rbx
je 0x24d63
movb $0x2e, (%r9)
pushq $0x1
popq %r13
movq %r13, %rax
jmp 0x24d29
pushq $0x1
popq %rax
jmp 0x24d38
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_d_cname
size_t dns_d_cname(void *dst, size_t lim, const void *dn, size_t len, struct dns_packet *P, int *error_) {
	char host[DNS_D_MAXNAME + 1];
	struct dns_rr_i i;
	struct dns_rr rr;
	unsigned depth;
	int error;

	if (sizeof host <= dns_d_anchor(host, sizeof host, dn, len))
		{ error = ENAMETOOLONG; goto error; }

	for (depth = 0; depth < 7; depth++) {
		dns_rr_i_init(memset(&i, 0, sizeof i), P);

		i.section	= DNS_S_ALL & ~DNS_S_QD;
		i.name		= host;
		i.type		= DNS_T_CNAME;

		if (!dns_rr_grep(&rr, 1, &i, P, &error))
			break;

		if ((error = dns_cname_parse((struct dns_cname *)host, &rr, P)))
			goto error;
	}

	return dns_strlcpy(dst, host, lim);
error:
	*error_	= error;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %r9, %rbx
movq %r8, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0x90(%rsp), %r13
movl $0x100, %esi            # imm = 0x100
movq %r13, %rdi
callq 0xfbe0
cmpq $0xff, %rax
jbe 0x24daa
pushq $0x24
popq %rax
jmp 0x24e36
movq %r12, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, (%rsp)
leaq 0x58(%rsp), %r14
pushq $0x8
popq %r12
leaq 0x78(%rsp), %rbp
leaq 0x1c(%rsp), %rbx
decl %r12d
je 0x24e3c
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x50(%rsp)
movups %xmm0, (%r14)
movups %xmm0, 0x10(%r14)
movl $0xe, 0x20(%rsp)
movq %r13, 0x28(%rsp)
movl $0x5, 0x30(%rsp)
movq %rbp, %rdi
pushq $0x1
popq %rsi
leaq 0x20(%rsp), %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0xfe00
testl %eax, %eax
je 0x24e3c
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x107a0
testl %eax, %eax
je 0x24dcb
movq (%rsp), %rbx
movl %eax, (%rbx)
xorl %eax, %eax
jmp 0x24e53
leaq 0x90(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0xf4f0
addq $0x198, %rsp            # imm = 0x198
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_any_parse
int dns_any_parse(union dns_any *any, struct dns_rr *rr, struct dns_packet *P) {
	const struct dns_rrtype *t;

	if ((t = dns_rrtype(rr->type)))
		return t->parse(dns_any_reinit(any, t), rr, P);

	if (rr->rd.len > any->rdata.size)
		return DNS_EILLEGAL;

	memcpy(any->rdata.data, &P->data[rr->rd.p], rr->rd.len);
	any->rdata.len	= rr->rd.len;

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %edi
callq 0x26f81
testq %rax, %rax
je 0x24eba
movq 0x10(%rax), %rcx
movq 0x18(%rax), %r8
testq %rcx, %rcx
je 0x24ea7
movq (%r14), %rsi
addq $0x10, %rsi
movq %r14, %rdi
movq %r8, %r14
callq *%rcx
movq %r14, %r8
movq %rax, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmpq *%r8
movzwl 0x16(%rbx), %edx
movl $0x9b918cc1, %eax       # imm = 0x9B918CC1
cmpq %rdx, (%r14)
jb 0x24ee7
leaq 0x10(%r14), %rdi
movzwl 0x14(%rbx), %eax
leaq (%r15,%rax), %rsi
addq $0x5c, %rsi
callq 0xfad0
movzwl 0x16(%rbx), %eax
movq %rax, 0x8(%r14)
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_rr_parse
int dns_rr_parse(struct dns_rr *rr, unsigned short src, struct dns_packet *P) {
	unsigned short p	= src;

	if (src >= P->end)
		goto invalid;

	rr->dn.p   = p;
	rr->dn.len = (p = dns_d_skip(p, P)) - rr->dn.p;

	if (P->end - p < 4)
		goto invalid;

	rr->type = ((0xff & P->data[p + 0]) << 8)
	         | ((0xff & P->data[p + 1]) << 0);

	rr->class = ((0xff & P->data[p + 2]) << 8)
	          | ((0xff & P->data[p + 3]) << 0);

	p += 4;

	if (src < dns_p_qend(P)) {
		rr->section = DNS_S_QUESTION;

		rr->ttl    = 0;
		rr->rd.p   = 0;
		rr->rd.len = 0;

		return 0;
	}

	if (P->end - p < 4)
		goto invalid;

	rr->ttl = ((0xff & P->data[p + 0]) << 24)
	        | ((0xff & P->data[p + 1]) << 16)
	        | ((0xff & P->data[p + 2]) << 8)
	        | ((0xff & P->data[p + 3]) << 0);
	if (rr->type != DNS_T_OPT)
		rr->ttl = DNS_PP_MIN(rr->ttl, 0x7fffffffU);

	p += 4;

	if (P->end - p < 2)
		goto invalid;

	rr->rd.len = ((0xff & P->data[p + 0]) << 8)
	           | ((0xff & P->data[p + 1]) << 0);
	rr->rd.p = p + 2;

	p += 2;

	if (P->end - p < rr->rd.len)
		goto invalid;

	return 0;
invalid:
	return DNS_EILLEGAL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %eax
movq 0x50(%rdx), %r15
cmpq %rax, %r15
jbe 0x24f35
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movw %bp, 0x4(%rdi)
movzwl %bp, %edi
movq %rdx, %rsi
callq 0x10340
movzwl %ax, %r12d
subl %ebp, %eax
movw %ax, 0x6(%rbx)
movq %r15, %rax
subq %r12, %rax
cmpq $0x4, %rax
jae 0x24f49
movl $0x9b918cc1, %eax       # imm = 0x9B918CC1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzwl 0x5c(%r14,%r12), %eax
rolw $0x8, %ax
movzwl %ax, %r13d
movl %r13d, 0x8(%rbx)
movzwl 0x5e(%r14,%r12), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl %eax, 0xc(%rbx)
movq %r14, %rdi
callq 0x2501f
cmpw %bp, %ax
jbe 0x24f87
movl $0x1, (%rbx)
andq $0x0, 0x10(%rbx)
xorl %eax, %eax
jmp 0x24f3a
leal 0x4(%r12), %eax
movzwl %ax, %eax
movq %r15, %rcx
subq %rax, %rcx
cmpq $0x4, %rcx
jb 0x24f35
movzbl 0x5c(%r14,%rax), %ecx
shll $0x18, %ecx
movzbl 0x5d(%r14,%rax), %edx
shll $0x10, %edx
orl %ecx, %edx
movzbl 0x5e(%r14,%rax), %ecx
shll $0x8, %ecx
orl %edx, %ecx
movzbl 0x5f(%r14,%rax), %eax
orl %ecx, %eax
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpl %ecx, %eax
cmovbl %eax, %ecx
cmpl $0x29, %r13d
cmovel %eax, %ecx
movl %ecx, 0x10(%rbx)
leal 0x8(%r12), %eax
movzwl %ax, %eax
movq %r15, %rcx
subq %rax, %rcx
cmpq $0x2, %rcx
jb 0x24f35
movzwl 0x5c(%r14,%rax), %eax
rolw $0x8, %ax
movzwl %ax, %ecx
movw %cx, 0x16(%rbx)
addl $0xa, %r12d
movw %r12w, 0x14(%rbx)
movzwl %r12w, %eax
subq %rax, %r15
xorl %eax, %eax
cmpq %rcx, %r15
jb 0x24f35
jmp 0x24f3a
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_p_qend
static unsigned short dns_p_qend(struct dns_packet *P) {
	unsigned short qend	= 12;
	unsigned i, count	= dns_p_count(P, DNS_S_QD);

	for (i = 0; i < count && qend < P->end; i++) {
		if (P->end == (qend = dns_d_skip(qend, P)))
			goto invalid;

		if (P->end - qend < 4)
			goto invalid;

		qend	+= 4;
	}

	return DNS_PP_MIN(qend, P->end);
invalid:
	return P->end;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movzwl 0x60(%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %ebp
movq 0x50(%rdi), %rbx
movw $0xc, %ax
movzwl %ax, %edi
addl $-0x1, %ebp
jae 0x25062
cmpq %rdi, %rbx
jbe 0x25062
movq %r14, %rsi
callq 0x10340
movzwl %ax, %ecx
movq %rbx, %rdx
subq %rcx, %rdx
cmpq $0x4, %rdx
jb 0x25068
addl $0x4, %eax
jmp 0x25039
cmpq %rdi, %rbx
cmoval %edi, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_any_cmp
int dns_any_cmp(const union dns_any *a, enum dns_type x, const union dns_any *b, enum dns_type y) {
	const struct dns_rrtype *t;
	int cmp;

	if ((cmp = x - y))
		return cmp;

	if ((t = dns_rrtype(x)))
		return t->cmp(a, b);

	return -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %eax
subl %ecx, %eax
je 0x250f6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %edi
callq 0x26f81
testq %rax, %rax
je 0x2511d
movq 0x28(%rax), %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
pushq $-0x1
popq %rax
jmp 0x250ee
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_rr_i_order
int dns_rr_i_order(struct dns_rr *a, struct dns_rr *b, struct dns_rr_i *i, struct dns_packet *P) {
	int cmp;

	(void)i;

	if ((cmp = a->section - b->section))
		return cmp;

	if (a->type != b->type)
		return (int)a->dn.p - (int)b->dn.p;

	return dns_rr_cmp(a, P, b, P);
}

// Assembly:
movl (%rdi), %eax
subl (%rsi), %eax
je 0x25134
retq
movq %rsi, %rdx
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x25147
movq %rcx, %rsi
jmp 0x10ac0
movzwl 0x4(%rdi), %eax
movzwl 0x4(%rdx), %ecx
subl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_rr_i_shuffle
int dns_rr_i_shuffle(struct dns_rr *a, struct dns_rr *b, struct dns_rr_i *i, struct dns_packet *P) {
	int cmp;

	(void)i;
	(void)P;

	while (!i->state.regs[0])
		i->state.regs[0]	= dns_random();

	if ((cmp = a->section - b->section))
		return cmp;

	return dns_k_shuffle16(a->dn.p, i->state.regs[0]) - dns_k_shuffle16(b->dn.p, i->state.regs[0]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl 0x40(%rdx), %ebp
testl %ebp, %ebp
jne 0x25177
callq *0x211d1(%rip)          # 0x46340
movl %eax, %ebp
movl %eax, 0x40(%r15)
jmp 0x25165
movl (%r14), %r15d
subl (%rbx), %r15d
jne 0x251a0
movzwl 0x4(%r14), %edi
movl %ebp, %esi
callq 0x251ae
movzwl %ax, %r15d
movzwl 0x4(%rbx), %edi
movl %ebp, %esi
callq 0x251ae
movzwl %ax, %eax
subl %eax, %r15d
movl %r15d, %eax
addq $0x8, %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_rr_section
static enum dns_section dns_rr_section(unsigned short src, struct dns_packet *P) {
	enum dns_section section;
	unsigned count, index;
	unsigned short rp;

	if (src >= P->memo.qd.base && src < P->memo.qd.end)
		return DNS_S_QD;
	if (src >= P->memo.an.base && src < P->memo.an.end)
		return DNS_S_AN;
	if (src >= P->memo.ns.base && src < P->memo.ns.end)
		return DNS_S_NS;
	if (src >= P->memo.ar.base && src < P->memo.ar.end)
		return DNS_S_AR;

	/* NOTE: Possibly bad memoization. Try it the hard-way. */

	for (rp = 12, index = 0; rp < src && rp < P->end; index++)
		rp = dns_rr_skip(rp, P);

	section = DNS_S_QD;
	count   = dns_p_count(P, section);

	while (index >= count && section <= DNS_S_AR) {
		section <<= 1;
		count += dns_p_count(P, section);
	}

	return DNS_S_ALL & section;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
cmpw %bp, 0x20(%rsi)
ja 0x25204
cmpw %bp, 0x22(%rbx)
jbe 0x25204
pushq $0x1
jmp 0x25232
cmpw %bp, 0x24(%rbx)
ja 0x25214
cmpw %bp, 0x26(%rbx)
jbe 0x25214
pushq $0x2
jmp 0x25232
cmpw %bp, 0x28(%rbx)
ja 0x25224
cmpw %bp, 0x2a(%rbx)
jbe 0x25224
pushq $0x4
jmp 0x25232
cmpw %bp, 0x2c(%rbx)
ja 0x25235
cmpw %bp, 0x2e(%rbx)
jbe 0x25235
pushq $0x8
popq %rbp
jmp 0x25284
movw $0xc, %ax
xorl %r14d, %r14d
cmpw %bp, %ax
jae 0x25257
movzwl %ax, %edi
cmpq %rdi, 0x50(%rbx)
jbe 0x25257
movq %rbx, %rsi
callq 0xf2f0
incl %r14d
jmp 0x2523c
movzwl 0x60(%rbx), %eax
rolw $0x8, %ax
movzwl %ax, %r15d
pushq $0x1
popq %rbp
cmpl $0x8, %ebp
ja 0x25281
cmpl %r15d, %r14d
jb 0x25281
addl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x10850
addl %eax, %r15d
jmp 0x25266
andl $0xf, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_b_putc
static dns_error_t
dns_b_putc(struct dns_buf *b, unsigned char uc)
{
	if (!(b->p < b->pe))
		return dns_b_setoverflow(b, 1, DNS_ENOBUFS);

	*b->p++ = uc;

	return 0;
}

// Assembly:
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
jae 0x25534
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movb %sil, (%rax)
xorl %eax, %eax
retq
incq 0x20(%rdi)
movl $0x9b918cc0, 0x18(%rdi) # imm = 0x9B918CC0
movl $0x9b918cc0, %eax       # imm = 0x9B918CC0
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_b_put
static dns_error_t
dns_b_put(struct dns_buf *b, const void *src, size_t len)
{
	size_t n = DNS_PP_MIN((size_t)(b->pe - b->p), len);

	memcpy(b->p, src, n);
	b->p += n;

	if (n < len)
		return dns_b_setoverflow(b, len - n, DNS_ENOBUFS);

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %r12
subq %rdi, %r12
cmpq %rdx, %r12
movq %rdx, %r15
cmovbq %r12, %r15
movq %r15, %rdx
callq 0xfad0
addq %r15, 0x8(%r14)
subq %r12, %rbx
jbe 0x25585
addq %rbx, 0x20(%r14)
movl $0x9b918cc0, 0x18(%r14) # imm = 0x9B918CC0
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_b_fmtju
DNS_NOTUSED static inline dns_error_t
dns_b_fmtju(struct dns_buf *b, const uintmax_t u, const unsigned width)
{
	size_t digits, padding, overflow;
	uintmax_t r;
	unsigned char *tp, *te, tc;

	digits = 0;
	r = u;
	do {
		digits++;
		r /= 10;
	} while (r);

	padding = width - DNS_PP_MIN(digits, width);
	overflow = (digits + padding) - DNS_PP_MIN((size_t)(b->pe - b->p), (digits + padding));

	while (padding--) {
		dns_b_putc(b, '0');
	}

	digits = 0;
	tp = b->p;
	r = u;
	do {
		if (overflow < ++digits)
			dns_b_putc(b, '0' + (r % 10));
		r /= 10;
	} while (r);

	te = b->p;
	while (tp < te) {
		tc = *--te;
		*te = *tp;
		*tp++ = tc;
	}

	return b->error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %esi
xorl %r15d, %r15d
pushq $0xa
popq %rdi
movq %rsi, %r12
movq %r14, %rcx
incq %r15
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
incq %r12
cmpq $0x9, %rcx
movq %rax, %rcx
ja 0x255b3
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
movq %rax, 0x8(%rsp)
cmpq %rsi, %r15
movq %rsi, %r13
cmovbq %r15, %r13
movq %rsi, 0x10(%rsp)
subq %rsi, %r13
pushq $0x30
popq %rbp
testq %r13, %r13
je 0x25600
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2551c
incq %r13
jmp 0x255ec
movq 0x10(%rsp), %r13
cmpq %r13, %r15
movq %r13, %rax
cmovbq %r15, %rax
subq %rax, %r13
subq %rax, %r12
movq 0x8(%rsp), %rax
cmpq %r12, %rax
cmovbq %rax, %r12
subq %r12, %r13
addq %r15, %r13
movq 0x8(%rbx), %r12
pushq $0x1
popq %rbp
movq %r14, %rax
xorl %edx, %edx
pushq $0xa
popq %rcx
divq %rcx
movq %rax, %r15
cmpq %rbp, %r13
jae 0x2564f
orb $0x30, %dl
movzbl %dl, %esi
movq %rbx, %rdi
callq 0x2551c
incq %rbp
cmpq $0x9, %r14
movq %r15, %r14
ja 0x2562e
movq 0x8(%rbx), %rax
cmpq %rax, %r12
jae 0x2567a
movb -0x1(%rax), %cl
movb (%r12), %dl
movb %dl, -0x1(%rax)
decq %rax
movb %cl, (%r12)
incq %r12
jmp 0x2565f
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_strclass
const char *(dns_strclass)(enum dns_class type, void *_dst, size_t lim) {
	struct dns_buf dst = DNS_B_INTO(_dst, lim);
	unsigned i;

	for (i = 0; i < lengthof(dns_classes); i++) {
		if (dns_classes[i].type == type) {
			dns_b_puts(&dst, dns_classes[i].name);
			break;
		}
	}

	if (dst.p == dst.base)
		dns_b_fmtju(&dst, (0xffff & type), 0);

	return dns_b_tostring(&dst);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
movq %rsi, (%rsp)
movq %rsi, 0x8(%rsp)
addq %rsi, %rdx
movq %rdx, 0x10(%rsp)
andl $0x0, 0x18(%rsp)
andq $0x0, 0x20(%rsp)
cmpl $0x1, %edi
jne 0x256f5
leaq 0xdf1f(%rip), %rsi      # 0x33600
movq %rsp, %r14
movq %r14, %rdi
callq 0x25689
movq 0x8(%r14), %rax
cmpq (%r14), %rax
jne 0x25702
movzwl %bx, %esi
movq %rsp, %rdi
xorl %edx, %edx
callq 0x25591
movq %rsp, %rdi
callq 0x2dbb7
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_strtype
const char *(dns_strtype)(enum dns_type type, void *_dst, size_t lim) {
	struct dns_buf dst = DNS_B_INTO(_dst, lim);
	unsigned i;

	for (i = 0; i < lengthof(dns_rrtypes); i++) {
		if (dns_rrtypes[i].type == type) {
			dns_b_puts(&dst, dns_rrtypes[i].name);
			break;
		}
	}

	if (dst.p == dst.base)
		dns_b_fmtju(&dst, (0xffff & type), 0);

	return dns_b_tostring(&dst);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, (%rsp)
movq %rsi, 0x8(%rsp)
addq %rsi, %rdx
movq %rdx, 0x10(%rsp)
andl $0x0, 0x18(%rsp)
andq $0x0, 0x20(%rsp)
movl %edi, %ebx
pushq $-0x38
popq %rcx
leaq 0x1f03f(%rip), %rax     # 0x44780
leaq 0x40(%rcx), %rdx
cmpq $0x348, %rdx            # imm = 0x348
je 0x2576f
cmpl %ebx, 0x38(%rcx,%rax)
movq %rdx, %rcx
jne 0x25741
movq (%rdx,%rax), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x25689
movq 0x8(%r14), %rax
cmpq (%r14), %rax
jne 0x2577c
movzwl %bx, %esi
movq %rsp, %rdi
xorl %edx, %edx
callq 0x25591
movq %rsp, %rdi
callq 0x2dbb7
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_any_print
size_t dns_any_print(void *_dst, size_t lim, union dns_any *any, enum dns_type type) {
	const struct dns_rrtype *t;
	struct dns_buf src, dst;

	if ((t = dns_rrtype(type)))
		return t->print(_dst, lim, any);

	dns_b_from(&src, any->rdata.data, any->rdata.len);
	dns_b_into(&dst, _dst, lim);

	dns_b_putc(&dst, '"');

	while (src.p < src.pe) {
		dns_b_putc(&dst, '\\');
		dns_b_fmtju(&dst, *src.p++, 3);
	}

	dns_b_putc(&dst, '"');

	return dns_b_strllen(&dst);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl %ecx, %edi
callq 0x26f81
testq %rax, %rax
je 0x257ca
movq 0x30(%rax), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rcx
leaq 0x10(%r15), %r12
movq 0x8(%r15), %r15
addq %r12, %r15
leaq (%rbx,%r14), %rax
movq %rbx, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
andl $0x0, 0x20(%rsp)
andq $0x0, 0x28(%rsp)
testq %r14, %r14
jle 0x25806
leaq 0x1(%rbx), %rax
movq %rax, 0x10(%rsp)
movb $0x22, (%rbx)
jmp 0x25817
movq $0x1, 0x28(%rsp)
movl $0x9b918cc0, 0x20(%rsp) # imm = 0x9B918CC0
leaq 0x8(%rsp), %rbx
pushq $0x3
popq %rbp
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq %r15, %r12
jae 0x25862
cmpq %rcx, %rax
jae 0x25841
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%rsp)
movb $0x5c, (%rax)
jmp 0x2584e
incq 0x28(%rsp)
movl $0x9b918cc0, 0x20(%rsp) # imm = 0x9B918CC0
movzbl (%r12), %esi
incq %r12
movq %rbx, %rdi
movl %ebp, %edx
callq 0x25591
jmp 0x2581f
cmpq %rcx, %rax
jae 0x25875
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%rsp)
movb $0x22, (%rax)
jmp 0x25882
incq 0x28(%rsp)
movl $0x9b918cc0, 0x20(%rsp) # imm = 0x9B918CC0
leaq 0x8(%rsp), %rdi
callq 0x25899
addq $0x30, %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_a_arpa
size_t dns_a_arpa(void *_dst, size_t lim, const struct dns_a *a) {
	struct dns_buf dst = DNS_B_INTO(_dst, lim);
	unsigned long octets = ntohl(a->addr.s_addr);
	unsigned i;

	for (i = 0; i < 4; i++) {
		dns_b_fmtju(&dst, 0xff & octets, 0);
		dns_b_putc(&dst, '.');
		octets >>= 8;
	}

	dns_b_puts(&dst, "in-addr.arpa.");

	return dns_b_strllen(&dst);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x8(%rsp), %rbx
movq %rdi, (%rbx)
movq %rdi, 0x8(%rbx)
addq %rdi, %rsi
movq %rsi, 0x10(%rbx)
andl $0x0, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
movl (%rdx), %r14d
bswapl %r14d
pushq $0x4
popq %rbp
subl $0x1, %ebp
jb 0x259c5
movzbl %r14b, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x25591
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x259b2
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%rsp)
movb $0x2e, (%rax)
jmp 0x259bf
incq 0x28(%rsp)
movl $0x9b918cc0, 0x20(%rsp) # imm = 0x9B918CC0
shrq $0x8, %r14
jmp 0x25985
leaq 0xe521(%rip), %rsi      # 0x33eed
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x25689
movq %rbx, %rdi
callq 0x25899
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_a_cmp
int dns_a_cmp(const struct dns_a *a, const struct dns_a *b) {
	if (ntohl(a->addr.s_addr) < ntohl(b->addr.s_addr))
		return -1;
	if (ntohl(a->addr.s_addr) > ntohl(b->addr.s_addr))
		return 1;

	return 0;
}

// Assembly:
movl (%rdi), %eax
bswapl %eax
movl (%rsi), %ecx
bswapl %ecx
xorl %edx, %edx
cmpl %ecx, %eax
seta %dl
pushq $-0x1
popq %rax
cmovael %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_aaaa_parse
int dns_aaaa_parse(struct dns_aaaa *aaaa, struct dns_rr *rr, struct dns_packet *P) {
	if (rr->rd.len != sizeof aaaa->addr.s6_addr)
		return DNS_EILLEGAL;

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

	return 0;
}

// Assembly:
movl $0x9b918cc1, %eax       # imm = 0x9B918CC1
cmpw $0x10, 0x16(%rsi)
jne 0x25a65
movzwl 0x14(%rsi), %eax
movups 0x5c(%rdx,%rax), %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpq $0x10, %rcx
je 0x25ac6
movzbl (%rdi,%rcx), %eax
movzbl (%rsi,%rcx), %edx
incq %rcx
subl %edx, %eax
je 0x25ab0
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
addq %rdi, %rsi
movq %rsi, 0x18(%rsp)
andl $0x0, 0x20(%rsp)
andq $0x0, 0x28(%rsp)
pushq $0xf
popq %rax
xorl %r10d, %r10d
pushq $0x2
popq %rcx
leaq 0xe152(%rip), %r8       # 0x33c50
xorl %r9d, %r9d
testl %eax, %eax
js 0x25b64
movl %eax, %r11d
movzbl (%rdx,%r11), %r11d
movl %ecx, %ebx
subl $0x1, %ebx
jb 0x25b51
cmpq %rsi, %rdi
jae 0x25b2c
movl %r11d, %r14d
andl $0xf, %r14d
movb (%r14,%r8), %bpl
movb %bpl, (%rdi)
incq %rdi
jmp 0x25b35
incq %r9
movl $0x9b918cc0, %r10d      # imm = 0x9B918CC0
cmpq %rsi, %rdi
jae 0x25b42
movb $0x2e, (%rdi)
incq %rdi
jmp 0x25b4b
incq %r9
movl $0x9b918cc0, %r10d      # imm = 0x9B918CC0
shrl $0x4, %r11d
jmp 0x25b0f
movq %rdi, 0x10(%rsp)
movq %r9, 0x28(%rsp)
movl %r10d, 0x20(%rsp)
decl %eax
jmp 0x25b01
leaq 0xe390(%rip), %rsi      # 0x33efb
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x25689
movq %rbx, %rdi
callq 0x25899
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x25c33
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 0xff50
testq %rax, %rax
je 0x25c2b
xorl %ecx, %ecx
cmpq $0x100, %rax            # imm = 0x100
movl $0x9b918cc1, %eax       # imm = 0x9B918CC1
cmovbl %ecx, %eax
jmp 0x25c2f
movl 0x4(%rsp), %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x25cb0
movq %rsi, %r14
movq %rdi, %rbx
movb 0x1(%rsi), %al
leaq 0x3(%r15), %rcx
movq %rcx, 0x50(%rdi)
movb %al, 0x5e(%r15,%rdi)
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 0xf580
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf3a0
testl %eax, %eax
je 0x25c9b
movq %r15, 0x50(%rbx)
jmp 0x25cb0
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