LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_k_shuffle16
static unsigned short dns_k_shuffle16(unsigned short n, unsigned s) {
	static const unsigned char sbox[256] =
	{ 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5,
	  0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
	  0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
	  0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
	  0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc,
	  0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
	  0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a,
	  0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
	  0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
	  0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
	  0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b,
	  0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
	  0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85,
	  0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
	  0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
	  0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
	  0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17,
	  0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
	  0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88,
	  0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
	  0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
	  0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
	  0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9,
	  0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
	  0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6,
	  0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
	  0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
	  0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
	  0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94,
	  0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
	  0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68,
	  0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 };
	unsigned char a, b;
	unsigned i;

	a = 0xff & (n >> 0);
	b = 0xff & (n >> 8);

	for (i = 0; i < 4; i++) {
		a ^= 0xff & s;
		a = sbox[a] ^ b;
		b = sbox[b] ^ a;
		s >>= 8;
	}

	return ((0xff00 & (a << 8)) | (0x00ff & (b << 0)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl %esi, -0x8(%rbp)
movzwl -0x2(%rbp), %eax
sarl $0x0, %eax
andl $0xff, %eax
movb %al, -0x9(%rbp)
movzwl -0x2(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0xa(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jae 0x35203
movl -0x8(%rbp), %ecx
andl $0xff, %ecx
movzbl -0x9(%rbp), %eax
xorl %ecx, %eax
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
movl %eax, %ecx
leaq 0x179e8(%rip), %rax     # 0x4cbb0
movzbl (%rax,%rcx), %eax
movzbl -0xa(%rbp), %ecx
xorl %ecx, %eax
movb %al, -0x9(%rbp)
movzbl -0xa(%rbp), %eax
movl %eax, %ecx
leaq 0x179ce(%rip), %rax     # 0x4cbb0
movzbl (%rax,%rcx), %eax
movzbl -0x9(%rbp), %ecx
xorl %ecx, %eax
movb %al, -0xa(%rbp)
movl -0x8(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x8(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x351a3
movzbl -0x9(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzbl -0xa(%rbp), %ecx
shll $0x0, %ecx
andl $0xff, %ecx
orl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x6(%rbp)
movq %rsi, -0x10(%rbp)
movzwl -0x6(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x20(%rcx), %ecx
cmpl %ecx, %eax
jl 0x354af
movzwl -0x6(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x22(%rcx), %ecx
cmpl %ecx, %eax
jge 0x354af
movl $0x1, -0x4(%rbp)
jmp 0x355e6
movzwl -0x6(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x24(%rcx), %ecx
cmpl %ecx, %eax
jl 0x354db
movzwl -0x6(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x26(%rcx), %ecx
cmpl %ecx, %eax
jge 0x354db
movl $0x2, -0x4(%rbp)
jmp 0x355e6
movzwl -0x6(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x28(%rcx), %ecx
cmpl %ecx, %eax
jl 0x35507
movzwl -0x6(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x2a(%rcx), %ecx
cmpl %ecx, %eax
jge 0x35507
movl $0x4, -0x4(%rbp)
jmp 0x355e6
movzwl -0x6(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x2c(%rcx), %ecx
cmpl %ecx, %eax
jl 0x35533
movzwl -0x6(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x2e(%rcx), %ecx
cmpl %ecx, %eax
jge 0x35533
movl $0x8, -0x4(%rbp)
jmp 0x355e6
movw $0xc, -0x1e(%rbp)
movl $0x0, -0x1c(%rbp)
movzwl -0x1e(%rbp), %ecx
movzwl -0x6(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x1f(%rbp)
jge 0x35563
movzwl -0x1e(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq 0x50(%rcx), %rax
setb %al
movb %al, -0x1f(%rbp)
movb -0x1f(%rbp), %al
testb $0x1, %al
jne 0x3556c
jmp 0x3558b
movw -0x1e(%rbp), %ax
movq -0x10(%rbp), %rsi
movzwl %ax, %edi
callq 0xf320
movw %ax, -0x1e(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x35540
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x10950
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x18(%rbp), %ecx
movb %al, -0x20(%rbp)
jb 0x355b8
cmpl $0x8, -0x14(%rbp)
setbe %al
movb %al, -0x20(%rbp)
movb -0x20(%rbp), %al
testb $0x1, %al
jne 0x355c1
jmp 0x355dd
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x10950
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x355a1
movl -0x14(%rbp), %eax
andl $0xf, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x35b4c
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x9b918cc0, %edx       # imm = 0x9B918CC0
callq 0x434a0
movl %eax, -0x4(%rbp)
jmp 0x35b6b
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rdx
movq 0x8(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb %cl, (%rax)
movl $0x0, -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_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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
cmpq -0x20(%rbp), %rax
jae 0x35bc6
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x35bce
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xfb40
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x35c20
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
subq -0x28(%rbp), %rsi
movl $0x9b918cc0, %edx       # imm = 0x9B918CC0
callq 0x434a0
movl %eax, -0x4(%rbp)
jmp 0x35c27
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpq $0x1, %rax
jae 0x35ed2
movl -0x44(%rbp), %eax
movl %eax, %ecx
leaq 0x16d06(%rip), %rax     # 0x4cba0
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x35ec5
movl -0x44(%rbp), %eax
leaq 0x16ced(%rip), %rsi     # 0x4cba0
imulq $0xc, %rax, %rax
addq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x35e00
jmp 0x35ed2
jmp 0x35ec7
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x35e85
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jne 0x35ef3
movl -0x4(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
xorl %edx, %edx
callq 0x35c30
leaq -0x40(%rbp), %rdi
callq 0x42b90
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_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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpq $0xd, %rax
jae 0x35fa7
movl -0x44(%rbp), %eax
movl %eax, %ecx
leaq 0x25a46(%rip), %rax     # 0x5b9b0
shlq $0x6, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x35f9a
movl -0x44(%rbp), %eax
movl %eax, %ecx
leaq 0x25a2c(%rip), %rax     # 0x5b9b0
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x35e00
jmp 0x35fa7
jmp 0x35f9c
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x35f55
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jne 0x35fc8
movl -0x4(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
xorl %edx, %edx
callq 0x35c30
leaq -0x40(%rbp), %rdi
callq 0x42b90
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl -0x24(%rbp), %edi
callq 0x38c40
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x3602d
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movb $0x0, %al
callq *%rcx
movq %rax, -0x8(%rbp)
jmp 0x360bc
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
leaq -0x58(%rbp), %rdi
callq 0x38d10
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x80(%rbp), %rdi
callq 0x38d70
leaq -0x80(%rbp), %rdi
movl $0x22, %esi
callq 0x35b10
movq -0x50(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0x360a1
leaq -0x80(%rbp), %rdi
movl $0x5c, %esi
callq 0x35b10
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x50(%rbp)
movzbl (%rax), %eax
movl %eax, %esi
leaq -0x80(%rbp), %rdi
movl $0x3, %edx
callq 0x35c30
jmp 0x36065
leaq -0x80(%rbp), %rdi
movl $0x22, %esi
callq 0x35b10
leaq -0x80(%rbp), %rdi
callq 0x360d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_a_parse
int dns_a_parse(struct dns_a *a, struct dns_rr *rr, struct dns_packet *P) {
	unsigned long addr;

	if (rr->rd.len != 4)
		return DNS_EILLEGAL;

	addr	= ((0xffU & P->data[rr->rd.p + 0]) << 24)
		| ((0xffU & P->data[rr->rd.p + 1]) << 16)
		| ((0xffU & P->data[rr->rd.p + 2]) << 8)
		| ((0xffU & P->data[rr->rd.p + 3]) << 0);

	a->addr.s_addr	= htonl(addr);

	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
movzwl 0x16(%rax), %eax
cmpl $0x4, %eax
je 0x3612d
movl $0x9b918cc1, -0x4(%rbp) # imm = 0x9B918CC1
jmp 0x361d2
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movzwl 0x14(%rcx), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movzbl 0x5c(%rax,%rcx), %eax
andl $0xff, %eax
shll $0x18, %eax
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdx
movzwl 0x14(%rdx), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl 0x5c(%rcx,%rdx), %ecx
andl $0xff, %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdx
movzwl 0x14(%rdx), %edx
addl $0x2, %edx
movslq %edx, %rdx
movzbl 0x5c(%rcx,%rdx), %ecx
andl $0xff, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdx
movzwl 0x14(%rdx), %edx
addl $0x3, %edx
movslq %edx, %rdx
movzbl 0x5c(%rcx,%rdx), %ecx
andl $0xff, %ecx
shll $0x0, %ecx
orl %ecx, %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl %eax, %edi
callq 0xfa60
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_a_push
int dns_a_push(struct dns_packet *P, struct dns_a *a) {
	unsigned long addr;

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

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

	addr	= ntohl(a->addr.s_addr);

	P->data[P->end++]	= 0xffU & (addr >> 24);
	P->data[P->end++]	= 0xffU & (addr >> 16);
	P->data[P->end++]	= 0xffU & (addr >> 8);
	P->data[P->end++]	= 0xffU & (addr >> 0);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x50(%rcx), %rax
cmpq $0x6, %rax
jae 0x36212
movl $0x9b918cc0, -0x4(%rbp) # imm = 0x9B918CC0
jmp 0x3630e
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x50(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x50(%rdx)
movb $0x0, 0x5c(%rax,%rcx)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x50(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x50(%rdx)
movb $0x4, 0x5c(%rax,%rcx)
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x101c0
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shrq $0x18, %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 -0x20(%rbp), %rax
shrq $0x10, %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 -0x20(%rbp), %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 -0x20(%rbp), %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)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
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_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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x101c0
movl %eax, %eax
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
cmpl $0x4, -0x4c(%rbp)
jae 0x363b8
movq -0x48(%rbp), %rsi
andq $0xff, %rsi
leaq -0x40(%rbp), %rdi
xorl %edx, %edx
callq 0x35c30
leaq -0x40(%rbp), %rdi
movl $0x2e, %esi
callq 0x35b10
movq -0x48(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x48(%rbp)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x36377
leaq -0x40(%rbp), %rdi
leaq 0x1709a(%rip), %rsi     # 0x4d45d
callq 0x35e00
leaq -0x40(%rbp), %rdi
callq 0x360d0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x101c0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x101c0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jae 0x3641b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3644d
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x101c0
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x101c0
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jbe 0x36446
movl $0x1, -0x4(%rbp)
jmp 0x3644d
movl $0x0, -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_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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x16(%rax), %eax
cmpq $0x10, %rax
je 0x364f7
movl $0x9b918cc1, -0x4(%rbp) # imm = 0x9B918CC1
jmp 0x3651f
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdx
movzwl 0x14(%rdx), %edx
movq 0x5c(%rcx,%rdx), %rsi
movq %rsi, (%rax)
movq 0x64(%rcx,%rdx), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_aaaa_push
int dns_aaaa_push(struct dns_packet *P, struct dns_aaaa *aaaa) {
	if (P->size - P->end < 2 + sizeof aaaa->addr.s6_addr)
		return DNS_ENOBUFS;

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

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

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

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x50(%rcx), %rax
cmpq $0x12, %rax
jae 0x3655b
movl $0x9b918cc0, -0x4(%rbp) # imm = 0x9B918CC0
jmp 0x365cb
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x50(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x50(%rdx)
movb $0x0, 0x5c(%rax,%rcx)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x50(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x50(%rdx)
movb $0x10, 0x5c(%rax,%rcx)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rcx
movq -0x18(%rbp), %rdx
movq (%rdx), %rsi
movq %rsi, 0x5c(%rax,%rcx)
movq 0x8(%rdx), %rdx
movq %rdx, 0x64(%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x50(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpq $0x10, %rax
jae 0x36621
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %edx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
je 0x36614
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x36628
jmp 0x36616
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x365e3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movl $0xf, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
jl 0x366e5
movq -0x18(%rbp), %rax
movslq -0x48(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x44(%rbp)
movl $0x0, -0x4c(%rbp)
cmpl $0x2, -0x4c(%rbp)
jge 0x366d8
movl -0x44(%rbp), %eax
andl $0xf, %eax
movl %eax, %eax
movl %eax, %ecx
leaq -0x40(%rbp), %rdi
leaq 0x13ba3(%rip), %rax     # 0x4a250
movzbl (%rax,%rcx), %esi
callq 0x35b10
leaq -0x40(%rbp), %rdi
movl $0x2e, %esi
callq 0x35b10
movl -0x44(%rbp), %eax
shrl $0x4, %eax
movl %eax, -0x44(%rbp)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x36692
jmp 0x366da
movl -0x48(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x36676
leaq -0x40(%rbp), %rdi
leaq 0x16d7b(%rip), %rsi     # 0x4d46b
callq 0x35e00
leaq -0x40(%rbp), %rdi
callq 0x360d0
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_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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x16(%rax), %eax
cmpl $0x3, %eax
jge 0x3679d
movl $0x9b918cc1, -0x4(%rbp) # imm = 0x9B918CC1
jmp 0x3683e
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movzwl 0x14(%rcx), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movzbl 0x5c(%rax,%rcx), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdx
movzwl 0x14(%rdx), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl 0x5c(%rcx,%rdx), %ecx
shll $0x0, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movq -0x10(%rbp), %rdi
addq $0x2, %rdi
movq -0x18(%rbp), %rax
movzwl 0x14(%rax), %eax
addl $0x2, %eax
movq -0x20(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
leaq -0x2c(%rbp), %r8
movzwl %ax, %edx
callq 0xffd0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x36822
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3683e
cmpq $0x100, -0x28(%rbp)     # imm = 0x100
jb 0x36835
movl $0x9b918cc1, -0x4(%rbp) # imm = 0x9B918CC1
jmp 0x3683e
jmp 0x36837
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
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_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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x50(%rcx), %rax
cmpq $0x5, %rax
jae 0x36882
movl $0x9b918cc0, -0x4(%rbp) # imm = 0x9B918CC0
jmp 0x36998
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
sarl $0x8, %eax
andl $0xff, %eax
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
movzwl (%rax), %eax
sarl $0x0, %eax
andl $0xff, %eax
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), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x2, %rdi
callq 0xf5c0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0xf3d0
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x36931
jmp 0x36986
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
subq -0x20(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
shrq $0x8, %rax
andq $0xff, %rax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, 0x5c(%rax,%rcx)
movq -0x28(%rbp), %rax
shrq $0x0, %rax
andq $0xff, %rax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, 0x5d(%rax,%rcx)
movl $0x0, -0x4(%rbp)
jmp 0x36998
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movl -0x2c(%rbp), %eax
movl %eax, -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_mx_cmp
int dns_mx_cmp(const struct dns_mx *a, const struct dns_mx *b) {
	int cmp;

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

	return strcasecmp(a->host, b->host);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movq -0x18(%rbp), %rcx
movzwl (%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x369e0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x369f8
movq -0x10(%rbp), %rdi
addq $0x2, %rdi
movq -0x18(%rbp), %rsi
addq $0x2, %rsi
callq 0xff50
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_mx_print
size_t dns_mx_print(void *_dst, size_t lim, struct dns_mx *mx) {
	struct dns_buf dst = DNS_B_INTO(_dst, lim);

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

	return dns_b_strllen(&dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
xorl %edx, %edx
callq 0x35c30
leaq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x35b10
movq -0x18(%rbp), %rsi
addq $0x2, %rsi
leaq -0x40(%rbp), %rdi
callq 0x35e00
leaq -0x40(%rbp), %rdi
callq 0x360d0
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_ns_parse
int dns_ns_parse(struct dns_ns *ns, struct dns_rr *rr, struct dns_packet *P) {
	size_t len;
	int error;

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

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movw 0x14(%rax), %ax
movq -0x20(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
leaq -0x2c(%rbp), %r8
movzwl %ax, %edx
callq 0xffd0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x36b17
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x36b33
cmpq $0x100, -0x28(%rbp)     # imm = 0x100
jb 0x36b2a
movl $0x9b918cc1, -0x4(%rbp) # imm = 0x9B918CC1
jmp 0x36b33
jmp 0x36b2c
movl $0x0, -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_ns_push
int dns_ns_push(struct dns_packet *P, struct dns_ns *ns) {
	size_t end, len;
	int error;

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

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

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

	len	= P->end - end - 2;

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

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

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x50(%rcx), %rax
cmpq $0x3, %rax
jae 0x36b72
movl $0x9b918cc0, -0x4(%rbp) # imm = 0x9B918CC0
jmp 0x36c28
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf5c0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0xf3d0
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x36bc1
jmp 0x36c16
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
subq -0x20(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
shrq $0x8, %rax
andq $0xff, %rax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, 0x5c(%rax,%rcx)
movq -0x28(%rbp), %rax
shrq $0x0, %rax
andq $0xff, %rax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, 0x5d(%rax,%rcx)
movl $0x0, -0x4(%rbp)
jmp 0x36c28
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movl -0x2c(%rbp), %eax
movl %eax, -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_soa_cmp
int dns_soa_cmp(const struct dns_soa *a, const struct dns_soa *b) {
	int cmp;

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

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

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

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

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

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

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

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xff50
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x371e0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x37367
movq -0x10(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movq -0x18(%rbp), %rsi
addq $0x100, %rsi            # imm = 0x100
callq 0xff50
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x3720e
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x37367
movq -0x10(%rbp), %rax
movl 0x200(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x200(%rcx), %eax
jbe 0x37230
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x37367
movq -0x10(%rbp), %rax
movl 0x200(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x200(%rcx), %eax
jae 0x37252
movl $0x1, -0x4(%rbp)
jmp 0x37367
jmp 0x37254
movq -0x10(%rbp), %rax
movl 0x204(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x204(%rcx), %eax
jbe 0x37276
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x37367
movq -0x10(%rbp), %rax
movl 0x204(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x204(%rcx), %eax
jae 0x37298
movl $0x1, -0x4(%rbp)
jmp 0x37367
jmp 0x3729a
movq -0x10(%rbp), %rax
movl 0x208(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x208(%rcx), %eax
jbe 0x372bc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x37367
movq -0x10(%rbp), %rax
movl 0x208(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x208(%rcx), %eax
jae 0x372de
movl $0x1, -0x4(%rbp)
jmp 0x37367
jmp 0x372e0
movq -0x10(%rbp), %rax
movl 0x20c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x20c(%rcx), %eax
jbe 0x372ff
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x37367
movq -0x10(%rbp), %rax
movl 0x20c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x20c(%rcx), %eax
jae 0x3731e
movl $0x1, -0x4(%rbp)
jmp 0x37367
jmp 0x37320
movq -0x10(%rbp), %rax
movl 0x210(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x210(%rcx), %eax
jbe 0x3733f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x37367
movq -0x10(%rbp), %rax
movl 0x210(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x210(%rcx), %eax
jae 0x3735e
movl $0x1, -0x4(%rbp)
jmp 0x37367
jmp 0x37360
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_soa_print
size_t dns_soa_print(void *_dst, size_t lim, struct dns_soa *soa) {
	struct dns_buf dst = DNS_B_INTO(_dst, lim);

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

	return dns_b_strllen(&dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x35e00
leaq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x35b10
movq -0x18(%rbp), %rsi
addq $0x100, %rsi            # imm = 0x100
leaq -0x40(%rbp), %rdi
callq 0x35e00
leaq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x35b10
movq -0x18(%rbp), %rax
movl 0x200(%rax), %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
xorl %edx, %edx
callq 0x35c30
leaq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x35b10
movq -0x18(%rbp), %rax
movl 0x204(%rax), %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
xorl %edx, %edx
callq 0x35c30
leaq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x35b10
movq -0x18(%rbp), %rax
movl 0x208(%rax), %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
xorl %edx, %edx
callq 0x35c30
leaq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x35b10
movq -0x18(%rbp), %rax
movl 0x20c(%rax), %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
xorl %edx, %edx
callq 0x35c30
leaq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x35b10
movq -0x18(%rbp), %rax
movl 0x210(%rax), %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
xorl %edx, %edx
callq 0x35c30
leaq -0x40(%rbp), %rdi
callq 0x360d0
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_srv_parse
int dns_srv_parse(struct dns_srv *srv, struct dns_rr *rr, struct dns_packet *P) {
	unsigned short rp;
	unsigned i;
	size_t n;
	int error;

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

	rp	= rr->rd.p;

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

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

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

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

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

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x106, %edx            # imm = 0x106
callq 0xf7d0
movq -0x18(%rbp), %rax
movw 0x14(%rax), %ax
movw %ax, -0x22(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x16(%rax), %eax
cmpl $0x7, %eax
jge 0x374f9
movl $0x9b918cc1, -0x4(%rbp) # imm = 0x9B918CC1
jmp 0x37640
movl $0x0, -0x28(%rbp)
cmpl $0x2, -0x28(%rbp)
jae 0x37549
movq -0x10(%rbp), %rax
movzwl (%rax), %ecx
shll $0x8, %ecx
movw %cx, (%rax)
movq -0x20(%rbp), %rax
movzwl -0x22(%rbp), %ecx
movzbl 0x5c(%rax,%rcx), %edx
andl $0xff, %edx
movq -0x10(%rbp), %rax
movzwl (%rax), %ecx
orl %edx, %ecx
movw %cx, (%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movw -0x22(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x22(%rbp)
jmp 0x37500
movl $0x0, -0x28(%rbp)
cmpl $0x2, -0x28(%rbp)
jae 0x3759d
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %ecx
shll $0x8, %ecx
movw %cx, 0x2(%rax)
movq -0x20(%rbp), %rax
movzwl -0x22(%rbp), %ecx
movzbl 0x5c(%rax,%rcx), %edx
andl $0xff, %edx
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %ecx
orl %edx, %ecx
movw %cx, 0x2(%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movw -0x22(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x22(%rbp)
jmp 0x37550
movl $0x0, -0x28(%rbp)
cmpl $0x2, -0x28(%rbp)
jae 0x375f1
movq -0x10(%rbp), %rax
movzwl 0x4(%rax), %ecx
shll $0x8, %ecx
movw %cx, 0x4(%rax)
movq -0x20(%rbp), %rax
movzwl -0x22(%rbp), %ecx
movzbl 0x5c(%rax,%rcx), %edx
andl $0xff, %edx
movq -0x10(%rbp), %rax
movzwl 0x4(%rax), %ecx
orl %edx, %ecx
movw %cx, 0x4(%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movw -0x22(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x22(%rbp)
jmp 0x375a4
movq -0x10(%rbp), %rdi
addq $0x6, %rdi
movw -0x22(%rbp), %ax
movq -0x20(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
leaq -0x34(%rbp), %r8
movzwl %ax, %edx
callq 0xffd0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x37624
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x37640
cmpq $0x100, -0x30(%rbp)     # imm = 0x100
jb 0x37637
movl $0x9b918cc1, -0x4(%rbp) # imm = 0x9B918CC1
jmp 0x37640
jmp 0x37639
movl $0x0, -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_srv_cmp
int dns_srv_cmp(const struct dns_srv *a, const struct dns_srv *b) {
	int cmp;

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

	/*
	 * FIXME: We need some sort of random seed to implement the dynamic
	 * weighting required by RFC 2782.
	 */
	if ((cmp = a->weight - b->weight))
		return cmp;

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

	return strcasecmp(a->target, b->target);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movq -0x18(%rbp), %rcx
movzwl (%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x37910
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3796c
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %eax
movq -0x18(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x37932
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3796c
movq -0x10(%rbp), %rax
movzwl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
movzwl 0x4(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x37954
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3796c
movq -0x10(%rbp), %rdi
addq $0x6, %rdi
movq -0x18(%rbp), %rsi
addq $0x6, %rsi
callq 0xff50
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_srv_print
size_t dns_srv_print(void *_dst, size_t lim, struct dns_srv *srv) {
	struct dns_buf dst = DNS_B_INTO(_dst, lim);

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

	return dns_b_strllen(&dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
xorl %edx, %edx
callq 0x35c30
leaq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x35b10
movq -0x18(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
xorl %edx, %edx
callq 0x35c30
leaq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x35b10
movq -0x18(%rbp), %rax
movzwl 0x4(%rax), %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
xorl %edx, %edx
callq 0x35c30
leaq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x35b10
movq -0x18(%rbp), %rsi
addq $0x6, %rsi
leaq -0x40(%rbp), %rdi
callq 0x35e00
leaq -0x40(%rbp), %rdi
callq 0x360d0
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_opt_ttl
unsigned int dns_opt_ttl(const struct dns_opt *opt) {
	unsigned int ttl = 0;

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

	return ttl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
shll $0x18, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x4(%rax), %eax
andl $0xff, %eax
shll $0x10, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x6(%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
shll $0x0, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_opt_init
struct dns_opt *dns_opt_init(struct dns_opt *opt, size_t size) {
	assert(size >= offsetof(struct dns_opt, data));

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

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

	return opt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x20, -0x10(%rbp)
jb 0x37b19
jmp 0x37b38
leaq 0x15955(%rip), %rdi     # 0x4d475
leaq 0x158b6(%rip), %rsi     # 0x4d3dd
movl $0xe06, %edx            # imm = 0xE06
leaq 0x15969(%rip), %rcx     # 0x4d49c
callq 0xf920
movq -0x10(%rbp), %rcx
subq $0x20, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_b_get16
static inline intmax_t
dns_b_get16(const struct dns_buf *b, const intmax_t eof)
{
	intmax_t n;

	n = (dns_b_getc(b, 0) << 8);
	n |= (dns_b_getc(b, 0) << 0);

	return (!b->overflow)? n : eof;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x435f0
shll $0x8, %eax
cltq
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x435f0
shll $0x0, %eax
cltq
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x37db1
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x37db9
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
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_b_move
static inline dns_error_t
dns_b_move(struct dns_buf *dst, const struct dns_buf *_src, size_t n)
{
	struct dns_buf *src = (struct dns_buf *)_src;
	size_t src_n = DNS_PP_MIN((size_t)(src->pe - src->p), n);
	size_t src_r = n - src_n;

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

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

	return dst->error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
cmpq -0x20(%rbp), %rax
jae 0x37e5e
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0x37e66
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x30(%rbp), %rdx
callq 0x35b80
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x38(%rbp)
je 0x37ebd
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0x9b918cc1, %edx       # imm = 0x9B918CC1
callq 0x434a0
movl %eax, -0x4(%rbp)
jmp 0x37ec7
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq