LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x7, %eax
ja 0x31c37
movq -0x20(%rbp), %rax
leaq 0x182a2(%rip), %rcx     # 0x49e50
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq 0x5c(%rax), %rax
shrq $0x20, %rax
andq $0xffff, %rax           # imm = 0xFFFF
movzwl %ax, %edi
callq 0x10a80
movzwl %ax, %eax
movl %eax, -0x4(%rbp)
jmp 0x31ce8
movq -0x10(%rbp), %rax
movq 0x5c(%rax), %rax
shrq $0x30, %rax
movzwl %ax, %edi
callq 0x10a80
movzwl %ax, %eax
movl %eax, -0x4(%rbp)
jmp 0x31ce8
movq -0x10(%rbp), %rax
movl 0x64(%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movzwl %ax, %edi
callq 0x10a80
movzwl %ax, %eax
movl %eax, -0x4(%rbp)
jmp 0x31ce8
movq -0x10(%rbp), %rax
movl 0x64(%rax), %eax
shrl $0x10, %eax
movzwl %ax, %edi
callq 0x10a80
movzwl %ax, %eax
movl %eax, -0x4(%rbp)
jmp 0x31ce8
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x31c6c
movq -0x10(%rbp), %rax
movq 0x5c(%rax), %rax
shrq $0x20, %rax
andq $0xffff, %rax           # imm = 0xFFFF
movzwl %ax, %edi
callq 0x10a80
movzwl %ax, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x31c94
movq -0x10(%rbp), %rax
movq 0x5c(%rax), %rax
shrq $0x30, %rax
movzwl %ax, %edi
callq 0x10a80
movzwl %ax, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x31cbc
movq -0x10(%rbp), %rax
movl 0x64(%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movzwl %ax, %edi
callq 0x10a80
movzwl %ax, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x31ce2
movq -0x10(%rbp), %rax
movl 0x64(%rax), %eax
shrl $0x10, %eax
movzwl %ax, %edi
callq 0x10a80
movzwl %ax, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x31d21
movq $0x0, -0x8(%rbp)
jmp 0x31d91
cmpq $0x68, -0x18(%rbp)
jb 0x31d2a
jmp 0x31d49
leaq 0x1b67d(%rip), %rdi     # 0x4d3ae
leaq 0x1b6a5(%rip), %rsi     # 0x4d3dd
movl $0x60d, %edx            # imm = 0x60D
leaq 0x1b6de(%rip), %rcx     # 0x4d422
callq 0xf920
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0xf7d0
movq -0x18(%rbp), %rcx
subq $0x5c, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq $0xc, 0x50(%rax)
movq -0x10(%rbp), %rdi
addq $0x5c, %rdi
xorl %esi, %esi
movl $0xc, %edx
callq 0xf7d0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xc, %eax
cmpq -0x8(%rbp), %rax
jbe 0x31dc6
movl $0xc, %eax
movq %rax, -0x28(%rbp)
jmp 0x31dce
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x5c, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10260
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x10c30
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x31e06
callq 0xf0a0
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x31e58
movl $0x160, %edi            # imm = 0x160
leaq -0x24(%rbp), %rsi
callq 0xfb10
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x31e4c
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x31f5c
movl $0x0, -0x4(%rbp)
jmp 0x31f5c
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl $0xc, %eax
cmpq 0x50(%rcx), %rax
jbe 0x31e75
movl $0xc, %eax
movq %rax, -0x30(%rbp)
jmp 0x31e84
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x5c, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shrq %rax
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shrq $0x2, %rax
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shrq $0x4, %rax
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shrq $0x8, %rax
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x10000, -0x20(%rbp)   # imm = 0x10000
jbe 0x31eee
movl $0x9b918cc0, -0x4(%rbp) # imm = 0x9B918CC0
jmp 0x31f5c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl $0xc, %eax
cmpq -0x20(%rbp), %rax
jbe 0x31f0f
movl $0xc, %eax
movq %rax, -0x40(%rbp)
jmp 0x31f17
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x5c, %rsi
callq 0x107d0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x31f3e
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x31f5c
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x31f91
movq $0x0, -0x8(%rbp)
jmp 0x31fee
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jae 0x31fb1
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x31fbd
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rdi
addq $0x5c, %rdi
movq -0x18(%rbp), %rsi
addq $0x5c, %rsi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdx
callq 0xfb40
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_rr_i_init
struct dns_rr_i *dns_rr_i_init(struct dns_rr_i *i, struct dns_packet *P) {
	static const struct dns_rr_i i_initializer;

	(void)P;

	i->state	= i_initializer.state;
	i->saved	= i->state;

	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x17df1(%rip), %rcx     # 0x4a208
movq %rcx, 0x38(%rax)
movq 0x17dee(%rip), %rcx     # 0x4a210
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rdx
movq %rdx, 0x48(%rax)
movq 0x40(%rcx), %rcx
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_rr_grep
unsigned dns_rr_grep(struct dns_rr *rr, unsigned lim, struct dns_rr_i *i, struct dns_packet *P, int *error_) {
	unsigned count	= 0;
	int error;

	switch (i->state.exec) {
	case 0:
		if (!i->sort)
			i->sort	= &dns_rr_i_packet;

		i->state.next	= dns_rr_i_start(i, P);
		i->state.exec++;

		/* FALL THROUGH */
	case 1:
		while (count < lim && i->state.next < P->end) {
			if ((error = dns_rr_parse(rr, i->state.next, P)))
				goto error;

			rr->section	= dns_rr_section(i->state.next, P);

			rr++;
			count++;
			i->state.count++;

			i->state.next	= dns_rr_i_skip(i->state.next, i, P);
		} /* while() */

		break;
	} /* switch() */

	return count;
error:
	*error_	= error;

	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x20(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x3c(%rbp)
testl %eax, %eax
je 0x3248f
jmp 0x32482
movl -0x3c(%rbp), %eax
subl $0x1, %eax
je 0x324ce
jmp 0x3258c
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x324a9
movq -0x20(%rbp), %rax
movq 0x29adb(%rip), %rcx     # 0x5bf80
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x35220
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, 0x38(%rax)
movq -0x20(%rbp), %rax
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
jmp 0x324d0
movl -0x34(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x3d(%rbp)
jae 0x324f3
movq -0x20(%rbp), %rax
movzwl 0x38(%rax), %eax
movq -0x28(%rbp), %rcx
cmpq 0x50(%rcx), %rax
setb %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x324ff
jmp 0x3258a
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movw 0x38(%rax), %ax
movq -0x28(%rbp), %rdx
movzwl %ax, %esi
callq 0xf790
movl %eax, -0x38(%rbp)
cmpl $0x0, %eax
je 0x32521
jmp 0x32594
movq -0x20(%rbp), %rax
movw 0x38(%rax), %ax
movq -0x28(%rbp), %rsi
movzwl %ax, %edi
callq 0x35470
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movw 0x3a(%rax), %cx
addw $0x1, %cx
movw %cx, 0x3a(%rax)
movq -0x20(%rbp), %rax
movw 0x38(%rax), %ax
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movzwl %ax, %edi
callq 0x355f0
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, 0x38(%rax)
jmp 0x324d0
jmp 0x3258c
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x325a3
movl -0x38(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x550, %rsp            # imm = 0x550
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rax
movw 0x4(%rax), %ax
movq -0x20(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
leaq -0x53c(%rbp), %r8
movzwl %ax, %edx
callq 0xffd0
movq %rax, -0x538(%rbp)
cmpq $0x0, %rax
jne 0x32609
movl -0x53c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x326ac
cmpq $0x100, -0x538(%rbp) # imm = 0x100
jb 0x32622
movl $0x9b918cc1, -0x4(%rbp) # imm = 0x9B918CC1
jmp 0x326ac
jmp 0x32624
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
je 0x32664
leaq -0x530(%rbp), %rdi
movl $0x410, %esi            # imm = 0x410
callq 0x10860
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xff80
movl %eax, -0x53c(%rbp)
cmpl $0x0, %eax
je 0x32664
movl -0x53c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x326ac
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
leaq -0x120(%rbp), %rdx
movq -0x538(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %r8d
movq -0x18(%rbp), %rax
movl 0xc(%rax), %r9d
movq -0x18(%rbp), %rax
movl 0x10(%rax), %r10d
leaq -0x530(%rbp), %rax
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x10880
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x550, %rsp            # imm = 0x550
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movw -0xa(%rbp), %ax
movw %ax, -0xc(%rbp)
movzwl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jae 0x32a43
movq -0x8(%rbp), %rax
movzwl -0xc(%rbp), %ecx
movzbl 0x5c(%rax,%rcx), %ecx
andl $0xc0, %ecx
movl $0xc0, %eax
cmpl %ecx, %eax
jne 0x32a1e
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movzwl -0xc(%rbp), %ecx
subq %rcx, %rax
cmpq $0x2, %rax
jb 0x32a1e
movzwl -0xc(%rbp), %eax
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
je 0x32a1e
movq -0x8(%rbp), %rax
movzwl -0xc(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movzbl 0x5c(%rax,%rcx), %eax
andl $0x3f, %eax
shll $0x8, %eax
movq -0x8(%rbp), %rcx
movzwl -0xc(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl 0x5c(%rcx,%rdx), %ecx
andl $0xff, %ecx
shll $0x0, %ecx
orl %ecx, %eax
movw %ax, -0xe(%rbp)
movw $0x0, -0x10(%rbp)
movzwl -0x10(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
cmpq $0x10, %rcx
movb %al, -0x11(%rbp)
jae 0x329dd
movq -0x8(%rbp), %rax
movzwl -0x10(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x329e6
jmp 0x32a1c
movq -0x8(%rbp), %rax
movzwl -0x10(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
movzwl -0xe(%rbp), %ecx
cmpl %ecx, %eax
jne 0x32a0c
movw -0xa(%rbp), %dx
movq -0x8(%rbp), %rax
movzwl -0x10(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
jmp 0x32a84
jmp 0x32a0e
movw -0x10(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x10(%rbp)
jmp 0x329b7
jmp 0x32a1e
movw -0xc(%rbp), %ax
movq -0x8(%rbp), %rsi
addq $0x5c, %rsi
movq -0x8(%rbp), %rcx
movq 0x50(%rcx), %rdx
movzwl %ax, %edi
callq 0x32a90
movw %ax, -0xc(%rbp)
jmp 0x3291b
movw $0x0, -0x10(%rbp)
movzwl -0x10(%rbp), %eax
cmpq $0x10, %rax
jae 0x32a84
movq -0x8(%rbp), %rax
movzwl -0x10(%rbp), %ecx
cmpw $0x0, (%rax,%rcx,2)
jne 0x32a74
movw -0xa(%rbp), %dx
movq -0x8(%rbp), %rax
movzwl -0x10(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
jmp 0x32a84
jmp 0x32a76
movw -0x10(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x10(%rbp)
jmp 0x32a49
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_l_skip
static unsigned short dns_l_skip(unsigned short src, const unsigned char *data, size_t end) {
	unsigned short len;

	if (src >= end)
		goto invalid;

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

		if (end - src < len)
			goto invalid;

		return (len)? src + len : end;
	case 0x01:
		goto invalid;
	case 0x02:
		goto invalid;
	case 0x03:
		return end;
	} /* switch() */

	/* NOT REACHED */
invalid:
	return end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movzwl -0x4(%rbp), %eax
cmpq -0x18(%rbp), %rax
jb 0x32ab2
jmp 0x32b58
movq -0x10(%rbp), %rax
movzwl -0x4(%rbp), %ecx
movzbl (%rax,%rcx), %eax
shrl $0x6, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x3, %eax
ja 0x32b56
movq -0x28(%rbp), %rax
leaq 0x17395(%rip), %rcx     # 0x49e70
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movw -0x4(%rbp), %cx
movw %cx, %dx
addw $0x1, %dx
movw %dx, -0x4(%rbp)
movzwl %cx, %ecx
movzbl (%rax,%rcx), %eax
andl $0x3f, %eax
movw %ax, -0x1a(%rbp)
movq -0x18(%rbp), %rax
movzwl -0x4(%rbp), %ecx
subq %rcx, %rax
movzwl -0x1a(%rbp), %ecx
cmpq %rcx, %rax
jae 0x32b1b
jmp 0x32b58
movzwl -0x1a(%rbp), %eax
cmpl $0x0, %eax
je 0x32b36
movzwl -0x4(%rbp), %eax
movzwl -0x1a(%rbp), %ecx
addl %ecx, %eax
cltq
movq %rax, -0x30(%rbp)
jmp 0x32b3e
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movw %ax, -0x2(%rbp)
jmp 0x32b60
jmp 0x32b58
jmp 0x32b58
movq -0x18(%rbp), %rax
movw %ax, -0x2(%rbp)
jmp 0x32b60
jmp 0x32b58
movq -0x18(%rbp), %rax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x50(%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movl %eax, -0x2c(%rbp)
movl $0x9b918cc1, -0x30(%rbp) # imm = 0x9B918CC1
movq -0x10(%rbp), %rdi
addq $0x5c, %rdi
movl -0x2c(%rbp), %eax
addq %rax, %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %r8
leaq -0x30(%rbp), %r9
callq 0xff10
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x331b4
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x331ed
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x331c7
movl $0x9b918cc0, -0x4(%rbp) # imm = 0x9B918CC0
jmp 0x331ed
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x50(%rax), %rcx
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %eax
movzwl %ax, %esi
callq 0xf410
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x38c40
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x33241
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movb $0x0, %al
callq *%rcx
movl %eax, -0x4(%rbp)
jmp 0x3330c
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x50(%rcx), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq $0x2, %rcx
cmpq %rcx, %rax
jae 0x3326e
movl $0x9b918cc0, -0x4(%rbp) # imm = 0x9B918CC0
jmp 0x3330c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x8, %rax
andq $0xff, %rax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rsi
movq 0x50(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x50(%rsi)
movb %dl, 0x5c(%rax,%rcx)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x0, %rax
andq $0xff, %rax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rsi
movq 0x50(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x50(%rsi)
movb %dl, 0x5c(%rax,%rcx)
movq -0x10(%rbp), %rdi
addq $0x5c, %rdi
movq -0x10(%rbp), %rax
addq 0x50(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0xfb40
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x50(%rax), %rcx
movq %rcx, 0x50(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_m_study
static int dns_m_study(struct dns_p_memo *m, struct dns_packet *P) {
	struct dns_rr rr;
	int error;

	if ((error = dns_s_study(&m->qd, DNS_S_QD, 12, P)))
		goto error;
	if ((error = dns_s_study(&m->an, DNS_S_AN, m->qd.end, P)))
		goto error;
	if ((error = dns_s_study(&m->ns, DNS_S_NS, m->an.end, P)))
		goto error;
	if ((error = dns_s_study(&m->ar, DNS_S_AR, m->ns.end, P)))
		goto error;

	m->opt.p = 0;
	m->opt.maxudp = 0;
	m->opt.ttl = 0;
	dns_rr_foreach(&rr, P, .type = DNS_T_OPT, .section = DNS_S_AR) {
		m->opt.p = rr.dn.p;
		m->opt.maxudp = rr.class;
		m->opt.ttl = rr.ttl;
		break;
	}

	return 0;
error:
	dns_m_unstudy(m);

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x1, %esi
movl $0xc, %edx
callq 0x431b0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x33747
jmp 0x33897
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
movq -0x10(%rbp), %rax
movw 0x2(%rax), %ax
movq -0x18(%rbp), %rcx
movl $0x2, %esi
movzwl %ax, %edx
callq 0x431b0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x33775
jmp 0x33897
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movw 0x6(%rax), %ax
movq -0x18(%rbp), %rcx
movl $0x4, %esi
movzwl %ax, %edx
callq 0x431b0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x337a3
jmp 0x33897
movq -0x10(%rbp), %rdi
addq $0xc, %rdi
movq -0x10(%rbp), %rax
movw 0xa(%rax), %ax
movq -0x18(%rbp), %rcx
movl $0x8, %esi
movzwl %ax, %edx
callq 0x431b0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x337d1
jmp 0x33897
movq -0x10(%rbp), %rax
movw $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movw $0x0, 0x12(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
leaq -0xe8(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0xf7d0
movl $0x8, -0xe8(%rbp)
movl $0x29, -0xd8(%rbp)
movq -0x18(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
callq 0x10750
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
movl $0x58, %edx
callq 0xfb40
movq -0x18(%rbp), %rcx
movl $0x0, -0xec(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
leaq -0x90(%rbp), %rdx
leaq -0xec(%rbp), %r8
callq 0xfe80
cmpl $0x0, %eax
je 0x3388e
movw -0x2c(%rbp), %cx
movq -0x10(%rbp), %rax
movw %cx, 0x10(%rax)
movl -0x24(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x12(%rax)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x338a6
movq -0x10(%rbp), %rdi
callq 0x43250
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl -0x24(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x33930
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
callq 0x339e0
movl -0x24(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x33955
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xfc50
jmp 0x339d6
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x33979
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x33981
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
callq 0x107a0
cmpq $0x0, -0x10(%rbp)
jbe 0x339d4
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x339bc
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x339c8
movq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x339d6
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_d_trim
static size_t dns_d_trim(void *dst_, size_t lim, const void *src_, size_t len, int flags) {
	unsigned char *dst = dst_;
	const unsigned char *src = src_;
	size_t dp = 0, sp = 0;
	int lc;

	/* trim any leading dot(s) */
	while (sp < len && src[sp] == '.')
		sp++;

	for (lc = 0; sp < len; lc = src[sp++]) {
		/* trim extra dot(s) */
		if (src[sp] == '.' && lc == '.')
			continue;

		if (dp < lim)
			dst[dp] = src[sp];

		dp++;
	}

	if ((flags & DNS_D_ANCHOR) && lc != '.') {
		if (dp < lim)
			dst[dp] = '.';

		dp++;
	}

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

	return dp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x4d(%rbp)
jae 0x33a3c
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
sete %al
movb %al, -0x4d(%rbp)
movb -0x4d(%rbp), %al
testb $0x1, %al
jne 0x33a45
jmp 0x33a53
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x33a18
movl $0x0, -0x4c(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x33ac5
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x33a7d
cmpl $0x2e, -0x4c(%rbp)
jne 0x33a7d
jmp 0x33aa9
movq -0x40(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x33a9d
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x48(%rbp)
movzbl (%rax,%rcx), %eax
movl %eax, -0x4c(%rbp)
jmp 0x33a5a
movl -0x24(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x33af8
cmpl $0x2e, -0x4c(%rbp)
je 0x33af8
movq -0x40(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x33aec
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movb $0x2e, (%rax,%rcx)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0x33b3a
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x33b22
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x33b2e
movq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x40(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x33b6c
movq $0x0, -0x8(%rbp)
jmp 0x33c27
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x33b90
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x33b98
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
callq 0x107a0
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
je 0x33be0
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x33bd4
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x2e, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x33c1f
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
cmpq -0x28(%rbp), %rax
jae 0x33c0b
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x33c13
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x33c83
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
movq -0x28(%rbp), %rdx
subq $0x1, %rdx
movl $0x2e, %esi
callq 0xffa0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x33c90
movq $0x0, -0x8(%rbp)
jmp 0x33d57
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rax, %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpq $0x1, -0x28(%rbp)
jbe 0x33ccb
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x33cd3
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x33cf7
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x33cff
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
callq 0x107a0
cmpq $0x0, -0x18(%rbp)
jbe 0x33d4f
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
cmpq -0x28(%rbp), %rax
jae 0x33d3b
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x33d43
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_d_skip
unsigned short dns_d_skip(unsigned short src, struct dns_packet *P) {
	unsigned short len;

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

			if (0 == len) {
/* success ==> */		return src;
			} else if (P->end - src > len) {
				src	+= len;

				break;
			} else
				goto invalid;

			/* NOT REACHED */
		case 0x01:	/* RESERVED */
			goto invalid;
		case 0x02:	/* RESERVED */
			goto invalid;
		case 0x03:	/* POINTER */
			if (P->end - src < 2)
				goto invalid;

			src	+= 2;

/* success ==> */	return src;
		} /* switch() */
	} /* while() */

invalid:
	return P->end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movzwl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jae 0x34449
movq -0x10(%rbp), %rax
movzwl -0x4(%rbp), %ecx
movzbl 0x5c(%rax,%rcx), %eax
shrl $0x6, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x34444
movq -0x20(%rbp), %rax
leaq 0x15b05(%rip), %rcx     # 0x49eb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movw -0x4(%rbp), %cx
movw %cx, %dx
addw $0x1, %dx
movw %dx, -0x4(%rbp)
movzwl %cx, %ecx
movzbl 0x5c(%rax,%rcx), %eax
andl $0x3f, %eax
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x343ea
movw -0x4(%rbp), %ax
movw %ax, -0x2(%rbp)
jmp 0x34457
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movzwl -0x4(%rbp), %ecx
subq %rcx, %rax
movzwl -0x12(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x34412
movzwl -0x12(%rbp), %ecx
movzwl -0x4(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x4(%rbp)
jmp 0x34444
jmp 0x3444b
jmp 0x3444b
jmp 0x3444b
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movzwl -0x4(%rbp), %ecx
subq %rcx, %rax
cmpq $0x2, %rax
jae 0x3442f
jmp 0x3444b
movzwl -0x4(%rbp), %eax
addl $0x2, %eax
movw %ax, -0x4(%rbp)
movw -0x4(%rbp), %ax
movw %ax, -0x2(%rbp)
jmp 0x34457
jmp 0x3436f
jmp 0x3444b
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
leaq -0x140(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
callq 0xfc50
movq %rax, %rcx
movl $0x100, %eax            # imm = 0x100
cmpq %rcx, %rax
ja 0x347d8
movl $0x24, -0x1b8(%rbp)
jmp 0x348b2
movl $0x0, -0x1b4(%rbp)
cmpl $0x7, -0x1b4(%rbp)
jae 0x34898
leaq -0x198(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0xf7d0
movq -0x30(%rbp), %rsi
leaq -0x198(%rbp), %rdi
callq 0x10750
movl $0xe, -0x198(%rbp)
leaq -0x140(%rbp), %rax
movq %rax, -0x190(%rbp)
movl $0x5, -0x188(%rbp)
movq -0x30(%rbp), %rcx
leaq -0x1b0(%rbp), %rdi
movl $0x1, %esi
leaq -0x198(%rbp), %rdx
leaq -0x1b8(%rbp), %r8
callq 0xfe80
cmpl $0x0, %eax
jne 0x3485e
jmp 0x34898
leaq -0x140(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq -0x1b0(%rbp), %rsi
callq 0xfab0
movl %eax, -0x1b8(%rbp)
cmpl $0x0, %eax
je 0x34882
jmp 0x348b2
jmp 0x34884
movl -0x1b4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1b4(%rbp)
jmp 0x347e2
movq -0x10(%rbp), %rdi
leaq -0x140(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf520
movq %rax, -0x8(%rbp)
jmp 0x348c6
movl -0x1b8(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x38c40
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x3496b
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x38cb0
movq -0x30(%rbp), %rcx
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movb $0x0, %al
callq *%rcx
movl %eax, -0x4(%rbp)
jmp 0x349c8
movq -0x18(%rbp), %rax
movzwl 0x16(%rax), %eax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x34985
movl $0x9b918cc1, -0x4(%rbp) # imm = 0x9B918CC1
jmp 0x349c8
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rsi
addq $0x5c, %rsi
movq -0x18(%rbp), %rax
movzwl 0x14(%rax), %eax
addq %rax, %rsi
movq -0x18(%rbp), %rax
movzwl 0x16(%rax), %eax
movl %eax, %edx
callq 0xfb40
movq -0x18(%rbp), %rax
movzwl 0x16(%rax), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movw $0xc, -0x12(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x10950
movl %eax, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x1d(%rbp)
jae 0x34d49
movzwl -0x12(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq 0x50(%rcx), %rax
setb %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x34d52
jmp 0x34db3
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
movw -0x12(%rbp), %ax
movq -0x10(%rbp), %rsi
movzwl %ax, %edi
callq 0x10400
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, -0x12(%rbp)
movzwl %cx, %ecx
cmpq %rcx, %rax
jne 0x34d83
jmp 0x34de1
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movzwl -0x12(%rbp), %ecx
subq %rcx, %rax
cmpq $0x4, %rax
jae 0x34d9a
jmp 0x34de1
movzwl -0x12(%rbp), %eax
addl $0x4, %eax
movw %ax, -0x12(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x34d2a
movzwl -0x12(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jae 0x34dcb
movzwl -0x12(%rbp), %eax
movq %rax, -0x30(%rbp)
jmp 0x34dd7
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movw %ax, -0x2(%rbp)
jmp 0x34ded
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_rr_len
static unsigned short dns_rr_len(const unsigned short src, struct dns_packet *P) {
	unsigned short rp, rdlen;

	rp	= dns_d_skip(src, P);

	if (P->end - rp < 4)
		return P->end - src;

	rp	+= 4;	/* TYPE, CLASS */

	if (rp <= dns_p_qend(P))
		return rp - src;

	if (P->end - rp < 6)
		return P->end - src;

	rp	+= 6;	/* TTL, RDLEN */

	rdlen	= ((0xff & P->data[rp - 2]) << 8)
		| ((0xff & P->data[rp - 1]) << 0);

	if (P->end - rp < rdlen)
		return P->end - src;

	rp	+= rdlen;

	return rp - src;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movw -0x4(%rbp), %ax
movq -0x10(%rbp), %rsi
movzwl %ax, %edi
callq 0x10400
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movzwl -0x12(%rbp), %ecx
subq %rcx, %rax
cmpq $0x4, %rax
jae 0x34e94
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movzwl -0x4(%rbp), %ecx
subq %rcx, %rax
movw %ax, -0x2(%rbp)
jmp 0x34f8d
movzwl -0x12(%rbp), %eax
addl $0x4, %eax
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x34d00
movw %ax, %cx
movl -0x18(%rbp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
jg 0x34ecf
movzwl -0x12(%rbp), %eax
movzwl -0x4(%rbp), %ecx
subl %ecx, %eax
movw %ax, -0x2(%rbp)
jmp 0x34f8d
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movzwl -0x12(%rbp), %ecx
subq %rcx, %rax
cmpq $0x6, %rax
jae 0x34efc
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movzwl -0x4(%rbp), %ecx
subq %rcx, %rax
movw %ax, -0x2(%rbp)
jmp 0x34f8d
movzwl -0x12(%rbp), %eax
addl $0x6, %eax
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movzbl 0x5c(%rax,%rcx), %eax
andl $0xff, %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movzwl -0x12(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movzbl 0x5c(%rcx,%rdx), %ecx
andl $0xff, %ecx
shll $0x0, %ecx
orl %ecx, %eax
movw %ax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movzwl -0x12(%rbp), %ecx
subq %rcx, %rax
movzwl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jae 0x34f71
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movzwl -0x4(%rbp), %ecx
subq %rcx, %rax
movw %ax, -0x2(%rbp)
jmp 0x34f8d
movzwl -0x14(%rbp), %ecx
movzwl -0x12(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %eax
movzwl -0x4(%rbp), %ecx
subl %ecx, %eax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl -0x14(%rbp), %eax
subl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x34fcc
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x34ffe
movl -0x14(%rbp), %edi
callq 0x38c40
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x34ff7
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movb $0x0, %al
callq *%rcx
movl %eax, -0x4(%rbp)
jmp 0x34ffe
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x35074
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x350b3
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x3509b
movq -0x10(%rbp), %rax
movzwl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
movzwl 0x4(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x350b3
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x10be0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x40(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x350eb
jmp 0x350fd
callq 0x10700
callq *(%rax)
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x40(%rax)
jmp 0x350d8
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x35119
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3515b
movq -0x10(%rbp), %rax
movw 0x4(%rax), %ax
movq -0x20(%rbp), %rcx
movl 0x40(%rcx), %esi
movzwl %ax, %edi
callq 0x35170
movzwl %ax, %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movw 0x4(%rax), %ax
movq -0x20(%rbp), %rcx
movl 0x40(%rcx), %esi
movzwl %ax, %edi
callq 0x35170
movw %ax, %cx
movl -0x30(%rbp), %eax
movzwl %cx, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)