LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_opt_push
int dns_opt_push(struct dns_packet *P, struct dns_opt *opt) {
	const struct dns_buf src = DNS_B_FROM(opt->data, opt->len);
	struct dns_buf dst = DNS_B_INTO(&P->data[P->end], (P->size - P->end));
	int error;

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

	/* ... push known options here */

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

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

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

	return 0;
error:
	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq -0x18(%rbp), %rcx
addq 0x18(%rcx), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x5c, %rax
movq -0x10(%rbp), %rcx
addq 0x50(%rcx), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
addq $0x5c, %rax
movq -0x10(%rbp), %rcx
addq 0x50(%rcx), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
addq $0x5c, %rax
movq -0x10(%rbp), %rcx
addq 0x50(%rcx), %rax
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rcx
movq -0x10(%rbp), %rdx
subq 0x50(%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
callq 0x37dd0
movl %eax, -0x6c(%rbp)
cmpl $0x0, %eax
je 0x37f8e
jmp 0x37ff8
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rax
subq %rax, %rdx
leaq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x37e10
movl %eax, -0x6c(%rbp)
cmpl $0x0, %eax
je 0x37fb0
jmp 0x37ff8
leaq -0x68(%rbp), %rdi
callq 0x38080
subq $0x2, %rax
leaq -0x68(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
movzwl %ax, %esi
callq 0x38010
movl %eax, -0x6c(%rbp)
cmpl $0x0, %eax
je 0x37fd7
jmp 0x37ff8
leaq -0x68(%rbp), %rdi
callq 0x38080
movq %rax, %rcx
movq -0x10(%rbp), %rax
addq 0x50(%rax), %rcx
movq %rcx, 0x50(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x37ffe
movl -0x6c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_opt_print
size_t dns_opt_print(void *_dst, size_t lim, struct dns_opt *opt) {
	struct dns_buf dst = DNS_B_INTO(_dst, lim);
	size_t p;

	dns_b_putc(&dst, '"');

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

	dns_b_putc(&dst, '"');

	return dns_b_strllen(&dst);
}

// Assembly:
pushq %rbp
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)
leaq -0x40(%rbp), %rdi
movl $0x22, %esi
callq 0x35b10
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x3815c
leaq -0x40(%rbp), %rdi
movl $0x5c, %esi
callq 0x35b10
movq -0x18(%rbp), %rax
movq -0x48(%rbp), %rcx
movzbl 0x20(%rax,%rcx), %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
movl $0x3, %edx
callq 0x35c30
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x38115
leaq -0x40(%rbp), %rdi
movl $0x22, %esi
callq 0x35b10
leaq -0x40(%rbp), %rdi
callq 0x360d0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_ptr_qname
size_t dns_ptr_qname(void *dst, size_t lim, int af, void *addr) {
	switch (af) {
	case AF_INET6:
		return dns_aaaa_arpa(dst, lim, addr);
	case AF_INET:
		return dns_a_arpa(dst, lim, addr);
	default: {
		struct dns_a a;
		a.addr.s_addr = INADDR_NONE;
		return dns_a_arpa(dst, lim, &a);
	}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
subl $0x2, %eax
je 0x38225
jmp 0x38204
movl -0x30(%rbp), %eax
subl $0xa, %eax
jne 0x3823c
jmp 0x3820e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x107c0
movq %rax, -0x8(%rbp)
jmp 0x38258
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x10080
movq %rax, -0x8(%rbp)
jmp 0x38258
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x10080
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
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_sshfp_parse
int dns_sshfp_parse(struct dns_sshfp *fp, struct dns_rr *rr, struct dns_packet *P) {
	unsigned p = rr->rd.p, pe = rr->rd.p + rr->rd.len;

	if (pe - p < 2)
		return DNS_EILLEGAL;

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

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

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

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

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x14(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x14(%rax), %eax
movq -0x18(%rbp), %rcx
movzwl 0x16(%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
subl -0x24(%rbp), %eax
cmpl $0x2, %eax
jae 0x38347
movl $0x9b918cc1, -0x4(%rbp) # imm = 0x9B918CC1
jmp 0x383ce
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
incl %edx
movl %edx, -0x24(%rbp)
movzbl 0x5c(%rax,%rcx), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
incl %edx
movl %edx, -0x24(%rbp)
movzbl 0x5c(%rax,%rcx), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
jne 0x383c5
jmp 0x38388
movl -0x28(%rbp), %eax
subl -0x24(%rbp), %eax
movl %eax, %eax
cmpq $0x14, %rax
jae 0x3839f
movl $0x9b918cc1, -0x4(%rbp) # imm = 0x9B918CC1
jmp 0x383ce
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %edx
movq 0x5c(%rcx,%rdx), %rsi
movq %rsi, 0x8(%rax)
movq 0x64(%rcx,%rdx), %rsi
movq %rsi, 0x10(%rax)
movl 0x6c(%rcx,%rdx), %ecx
movl %ecx, 0x18(%rax)
jmp 0x383c7
jmp 0x383c7
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_sshfp_push
int dns_sshfp_push(struct dns_packet *P, struct dns_sshfp *fp) {
	unsigned p = P->end, pe = P->size, n;

	if (pe - p < 4)
		return DNS_ENOBUFS;

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

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

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

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

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

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %eax
cmpl $0x4, %eax
jae 0x38419
movl $0x9b918cc0, -0x4(%rbp) # imm = 0x9B918CC0
jmp 0x3852a
movl -0x1c(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %dl
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
incl %esi
movl %esi, -0x1c(%rbp)
movb %dl, 0x5c(%rax,%rcx)
movq -0x18(%rbp), %rax
movb 0x4(%rax), %dl
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
incl %esi
movl %esi, -0x1c(%rbp)
movb %dl, 0x5c(%rax,%rcx)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
jne 0x384ab
jmp 0x38461
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %eax
movl %eax, %eax
cmpq $0x14, %rax
jae 0x3847b
movl $0x9b918cc0, -0x4(%rbp) # imm = 0x9B918CC0
jmp 0x3852a
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rdx
movq 0x8(%rdx), %rsi
movq %rsi, 0x5c(%rax,%rcx)
movq 0x10(%rdx), %rsi
movq %rsi, 0x64(%rax,%rcx)
movl 0x18(%rdx), %edx
movl %edx, 0x6c(%rax,%rcx)
movl -0x1c(%rbp), %eax
addq $0x14, %rax
movl %eax, -0x1c(%rbp)
jmp 0x384b4
movl $0x9b918cc1, -0x4(%rbp) # imm = 0x9B918CC1
jmp 0x3852a
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
subq 0x50(%rcx), %rax
subq $0x2, %rax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
shrl $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)
movl -0x24(%rbp), %eax
shrl $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)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_sshfp_cmp
int dns_sshfp_cmp(const struct dns_sshfp *a, const struct dns_sshfp *b) {
	int cmp;

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

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

	/* NOT REACHED */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jne 0x3856a
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
subl 0x4(%rcx), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x38572
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x385a6
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
jne 0x3859f
jmp 0x38580
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movl $0x14, %edx
callq 0xf5e0
movl %eax, -0x4(%rbp)
jmp 0x385a6
movl $0x0, -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_sshfp_print
size_t dns_sshfp_print(void *_dst, size_t lim, struct dns_sshfp *fp) {
	static const unsigned char hex[16] = "0123456789abcdef";
	struct dns_buf dst = DNS_B_INTO(_dst, lim);
	size_t i;

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

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

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

		break;
	} /* switch() */

	return dns_b_strllen(&dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %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
movq -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
xorl %edx, %edx
movl %edx, -0x5c(%rbp)
callq 0x35c30
movq -0x58(%rbp), %rdi
movl $0x20, %esi
movl %esi, -0x4c(%rbp)
callq 0x35b10
movl -0x5c(%rbp), %edx
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
callq 0x35c30
movq -0x58(%rbp), %rdi
movl -0x4c(%rbp), %esi
callq 0x35b10
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
jne 0x386bf
jmp 0x3864c
movq $0x0, -0x48(%rbp)
cmpq $0x14, -0x48(%rbp)
jae 0x386bd
movq -0x18(%rbp), %rax
movq -0x48(%rbp), %rcx
movzbl 0x8(%rax,%rcx), %eax
sarl $0x4, %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq -0x40(%rbp), %rdi
leaq 0x11be4(%rip), %rax     # 0x4a260
movzbl (%rax,%rcx), %esi
callq 0x35b10
movq -0x18(%rbp), %rax
movq -0x48(%rbp), %rcx
movzbl 0x8(%rax,%rcx), %eax
sarl $0x0, %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq -0x40(%rbp), %rdi
leaq 0x11bba(%rip), %rax     # 0x4a260
movzbl (%rax,%rcx), %esi
callq 0x35b10
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x38654
jmp 0x386cd
leaq -0x40(%rbp), %rdi
movl $0x30, %esi
callq 0x35b10
leaq -0x40(%rbp), %rdi
callq 0x360d0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_txt_init
struct dns_txt *dns_txt_init(struct dns_txt *txt, size_t size) {
	assert(size > offsetof(struct dns_txt, data));

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

	return txt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x10, -0x10(%rbp)
jbe 0x386f9
jmp 0x38718
leaq 0x14dd3(%rip), %rdi     # 0x4d4d3
leaq 0x14cd6(%rip), %rsi     # 0x4d3dd
movl $0xefd, %edx            # imm = 0xEFD
leaq 0x14de6(%rip), %rcx     # 0x4d4f9
callq 0xf920
movq -0x10(%rbp), %rcx
subq $0x10, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_txt_parse
int dns_txt_parse(struct dns_txt *txt, struct dns_rr *rr, struct dns_packet *P) {
	struct { unsigned char *b; size_t p, end; } dst, src;
	unsigned n;

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

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

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

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

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

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

	txt->len	= dst.p;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x5c, %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x14(%rax), %eax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
movzwl 0x16(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x38826
movq -0x20(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x48(%rbp)
movzbl 0x5c(%rax,%rcx), %eax
andl $0xff, %eax
movl %eax, -0x54(%rbp)
movq -0x40(%rbp), %rax
subq -0x48(%rbp), %rax
movl -0x54(%rbp), %ecx
cmpq %rcx, %rax
jb 0x387e8
movq -0x28(%rbp), %rax
subq -0x30(%rbp), %rax
movl -0x54(%rbp), %ecx
cmpq %rcx, %rax
jae 0x387f1
movl $0x9b918cc1, -0x4(%rbp) # imm = 0x9B918CC1
jmp 0x38839
movq -0x38(%rbp), %rdi
addq -0x30(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq -0x48(%rbp), %rsi
movl -0x54(%rbp), %eax
movl %eax, %edx
callq 0xfb40
movl -0x54(%rbp), %eax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x54(%rbp), %eax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x3879e
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
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_txt_print
size_t dns_txt_print(void *_dst, size_t lim, struct dns_txt *txt) {
	struct dns_buf src = DNS_B_FROM(txt->data, txt->len);
	struct dns_buf dst = DNS_B_INTO(_dst, lim);
	unsigned i;

	if (src.p < src.pe) {
		do {
			dns_b_putc(&dst, '"');

			for (i = 0; i < 256 && src.p < src.pe; i++, src.p++) {
				if (*src.p < 32 || *src.p > 126 || *src.p == '"' || *src.p == '\\') {
					dns_b_putc(&dst, '\\');
					dns_b_fmtju(&dst, *src.p, 3);
				} else {
					dns_b_putc(&dst, *src.p);
				}
			}

			dns_b_putc(&dst, '"');
			dns_b_putc(&dst, ' ');
		} while (src.p < src.pe);

		dns_b_popc(&dst);
	} else {
		dns_b_putc(&dst, '"');
		dns_b_putc(&dst, '"');
	}

	return dns_b_strllen(&dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq -0x18(%rbp), %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x38baf
jmp 0x38aba
leaq -0x68(%rbp), %rdi
movl $0x22, %esi
callq 0x35b10
movl $0x0, -0x6c(%rbp)
xorl %eax, %eax
cmpl $0x100, -0x6c(%rbp)     # imm = 0x100
movb %al, -0x6d(%rbp)
jae 0x38aeb
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
setb %al
movb %al, -0x6d(%rbp)
movb -0x6d(%rbp), %al
testb $0x1, %al
jne 0x38af7
jmp 0x38b7a
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jl 0x38b27
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x7e, %eax
jg 0x38b27
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x22, %eax
je 0x38b27
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x38b4e
leaq -0x68(%rbp), %rdi
movl $0x5c, %esi
callq 0x35b10
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %esi
leaq -0x68(%rbp), %rdi
movl $0x3, %edx
callq 0x35c30
jmp 0x38b5e
movq -0x38(%rbp), %rax
leaq -0x68(%rbp), %rdi
movzbl (%rax), %esi
callq 0x35b10
jmp 0x38b60
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x38acf
leaq -0x68(%rbp), %rdi
movl $0x22, %esi
callq 0x35b10
leaq -0x68(%rbp), %rdi
movl $0x20, %esi
callq 0x35b10
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jb 0x38aba
leaq -0x68(%rbp), %rdi
callq 0x38be0
jmp 0x38bcb
leaq -0x68(%rbp), %rdi
movl $0x22, %esi
callq 0x35b10
leaq -0x68(%rbp), %rdi
movl $0x22, %esi
callq 0x35b10
leaq -0x68(%rbp), %rdi
callq 0x360d0
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_b_popc
static void
dns_b_popc(struct dns_buf *b)
{
	if (b->overflow && !--b->overflow)
		b->error = 0;
	if (b->p > b->base)
		b->p--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x38c14
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rax
addq $-0x1, %rax
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
jne 0x38c14
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x38c35
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_rrtype
static const struct dns_rrtype *dns_rrtype(enum dns_type type) {
	const struct dns_rrtype *t;

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

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
leaq 0x22d62(%rip), %rax     # 0x5b9b0
movq %rax, -0x18(%rbp)
leaq 0x22d57(%rip), %rax     # 0x5b9b0
addq $0x340, %rax            # imm = 0x340
cmpq %rax, -0x18(%rbp)
jae 0x38c95
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x38c85
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x38c85
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x38c9d
jmp 0x38c87
movq -0x18(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x18(%rbp)
jmp 0x38c52
movq $0x0, -0x8(%rbp)
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_any_cname
size_t dns_any_cname(void *dst, size_t lim, union dns_any *any, enum dns_type type) {
	const struct dns_rrtype *t;

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

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %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 0x38e22
movq -0x30(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x38e22
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movb $0x0, %al
callq *%rcx
movq %rax, -0x8(%rbp)
jmp 0x38e2a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
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_hosts_open
struct dns_hosts *dns_hosts_open(int *error) {
	static const struct dns_hosts hosts_initializer	= { .refcount = 1 };
	struct dns_hosts *hosts;

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

	*hosts	= hosts_initializer;

	hosts->tail	= &hosts->head;

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

	free(hosts);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x18, %edi
callq 0x10260
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x38e62
jmp 0x38e9c
movq -0x18(%rbp), %rax
movq 0x11403(%rip), %rcx     # 0x4a270
movq %rcx, (%rax)
movq 0x11401(%rip), %rcx     # 0x4a278
movq %rcx, 0x8(%rax)
movq 0x113fe(%rip), %rcx     # 0x4a280
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x38eba
callq 0xf0a0
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x10060
movq $0x0, -0x8(%rbp)
movq -0x8(%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_hosts_close
void dns_hosts_close(struct dns_hosts *hosts) {
	struct dns_hosts_entry *ent, *xnt;

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

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

		free(ent);
	}

	free(hosts);

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x38ef9
movq -0x8(%rbp), %rdi
callq 0x10a40
movq %rax, %rcx
movl $0x1, %eax
cmpq %rcx, %rax
je 0x38efb
jmp 0x38f38
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x38f2f
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10060
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x38f06
movq -0x8(%rbp), %rdi
callq 0x10060
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_hosts_local
struct dns_hosts *dns_hosts_local(int *error_) {
	struct dns_hosts *hosts;
	int error;

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

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

	return hosts;
error:
	*error_	= error;

	dns_hosts_close(hosts);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0xf810
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x39051
jmp 0x39075
movq -0x18(%rbp), %rdi
leaq 0x144d4(%rip), %rsi     # 0x4d530
callq 0x106c0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x3906b
jmp 0x39075
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3908f
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x108f0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_hosts_loadpath
int dns_hosts_loadpath(struct dns_hosts *hosts, const char *path) {
	FILE *fp;
	int error;

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

	error = dns_hosts_loadfile(hosts, fp);

	fclose(fp);

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x14547(%rip), %rsi     # 0x4d602
leaq -0x24(%rbp), %rdx
callq 0x39540
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x390d6
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x390f5
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x104f0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0xfdf0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_hosts_insert
int dns_hosts_insert(struct dns_hosts *hosts, int af, const void *addr, const void *host, _Bool alias) {
	struct dns_hosts_entry *ent;
	int error;

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

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

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

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

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

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

		break;
	default:
		error	= EINVAL;

		goto error;
	} /* switch() */

	ent->alias	= alias;

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

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

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movl $0x170, %edi            # imm = 0x170
callq 0x10260
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x39418
jmp 0x39519
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xf5c0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq %rax, %rcx
movl $0x100, %esi            # imm = 0x100
callq 0xfc50
movl -0x14(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x38(%rbp), %rcx
movl %eax, 0x14c(%rcx)
subl $0x2, %eax
je 0x3949b
jmp 0x39459
movl -0x40(%rbp), %eax
subl $0xa, %eax
jne 0x394c6
jmp 0x39463
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x150(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x158(%rax)
movq -0x38(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movq -0x20(%rbp), %rdx
movl $0x4a, %esi
callq 0x107c0
jmp 0x394cf
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x150(%rax)
movq -0x38(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movq -0x20(%rbp), %rdx
movl $0x4a, %esi
callq 0x10080
jmp 0x394cf
movl $0x16, -0x3c(%rbp)
jmp 0x39523
movb -0x29(%rbp), %cl
movq -0x38(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x160(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x168(%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
addq $0x168, %rcx            # imm = 0x168
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x39532
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x10060
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_fopen
static FILE *dns_fopen(const char *path, const char *mode, dns_error_t *_error) {
	FILE *fp;
	char mode_cloexec[32];
	int error;

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

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

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

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x39570
cmpq $0x0, -0x18(%rbp)
je 0x39570
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x39570
jmp 0x3958f
leaq 0x142fb(%rip), %rdi     # 0x4d872
leaq 0x13e5f(%rip), %rsi     # 0x4d3dd
movl $0x4c3, %edx            # imm = 0x4C3
leaq 0x142fe(%rip), %rcx     # 0x4d888
callq 0xf920
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x395a1
movl $0x16, -0x54(%rbp)
jmp 0x39614
leaq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x20, %edx
movl $0x65, %ecx
callq 0x43700
movl %eax, -0x54(%rbp)
cmpl $0x0, %eax
je 0x395c2
jmp 0x39614
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x10030
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x39600
callq 0xf0a0
cmpl $0x16, (%rax)
je 0x395e5
jmp 0x3960a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10030
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x395fe
jmp 0x3960a
jmp 0x39600
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x39625
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_hosts_dump
int dns_hosts_dump(struct dns_hosts *hosts, FILE *fp) {
	struct dns_hosts_entry *ent, *xnt;
	char addr[INET6_ADDRSTRLEN + 1];
	unsigned i;

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

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

		fputs(addr, fp);

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

		fputc(' ', fp);

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

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x396f6
movq -0x18(%rbp), %rax
movq 0x168(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x14c(%rax), %edi
movq -0x18(%rbp), %rsi
addq $0x150, %rsi            # imm = 0x150
leaq -0x50(%rbp), %rdx
movl $0x2f, %ecx
callq 0xfeb0
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xffb0
leaq -0x50(%rbp), %rdi
callq 0xf5c0
movl %eax, -0x54(%rbp)
cmpl $0x10, -0x54(%rbp)
jae 0x396c0
movq -0x10(%rbp), %rsi
movl $0x20, %edi
callq 0x10140
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x396a1
movq -0x10(%rbp), %rsi
movl $0x20, %edi
callq 0x10140
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xffb0
movq -0x10(%rbp), %rsi
movl $0xa, %edi
callq 0x10140
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3964b
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_resconf_open
struct dns_resolv_conf *dns_resconf_open(int *error) {
	static const struct dns_resolv_conf resconf_initializer = {
		.lookup = "bf",
		.family = { AF_INET, AF_INET6 },
		.options = { .ndots = 1, .timeout = 5, .attempts = 2, .tcp = DNS_RESCONF_TCP_ENABLE, },
		.iface = { .ss_family = AF_INET },
	};
	struct dns_resolv_conf *resconf;
	struct sockaddr_in *sin;
	size_t len;

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

	*resconf = resconf_initializer;

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

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

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

	dns_resconf_acquire(resconf);

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

	free(resconf);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x650, %edi            # imm = 0x650
callq 0x10260
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x39a95
jmp 0x39b8a
movq -0x18(%rbp), %rdi
leaq 0x107e8(%rip), %rsi     # 0x4a288
movl $0x650, %edx            # imm = 0x650
callq 0xfb40
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movw $0x2, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
movl $0x35, %edi
callq 0xf0e0
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x18(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
movl $0x100, %esi            # imm = 0x100
callq 0x10590
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x39afd
jmp 0x39b8a
movq -0x18(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
callq 0xf5c0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
movq -0x18(%rbp), %rdx
addq $0x180, %rdx            # imm = 0x180
movq -0x28(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
callq 0xfc50
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
movq -0x18(%rbp), %rdx
addq $0x180, %rdx            # imm = 0x180
movq -0x28(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
callq 0x10690
movq %rax, -0x28(%rbp)
movl $0x1, %eax
cmpq -0x28(%rbp), %rax
jne 0x39b77
movq -0x18(%rbp), %rax
movb $0x0, 0x180(%rax)
movq -0x18(%rbp), %rdi
callq 0xfb90
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x39ba8
callq 0xf0a0
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x10060
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
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_resconf_local
struct dns_resolv_conf *dns_resconf_local(int *error_) {
	struct dns_resolv_conf *resconf;
	int error;

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

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

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

	return resconf;
error:
	*error_	= error;

	dns_resconf_close(resconf);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0xf7c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x39cb1
jmp 0x39cff
movq -0x18(%rbp), %rdi
leaq 0x1387f(%rip), %rsi     # 0x4d53b
callq 0xfba0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x39cd3
cmpl $0x2, -0x1c(%rbp)
je 0x39cd1
jmp 0x39cff
jmp 0x39cd3
movq -0x18(%rbp), %rdi
leaq 0x1386e(%rip), %rsi     # 0x4d54c
callq 0xfd90
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x39cf5
cmpl $0x2, -0x1c(%rbp)
je 0x39cf3
jmp 0x39cff
jmp 0x39cf5
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x39d19
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
callq 0xfff0
movq $0x0, -0x8(%rbp)
movq -0x8(%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_resconf_loadpath
int dns_resconf_loadpath(struct dns_resolv_conf *resconf, const char *path) {
	FILE *fp;
	int error;

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

	error = dns_resconf_loadfile(resconf, fp);

	fclose(fp);

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x138b7(%rip), %rsi     # 0x4d602
leaq -0x24(%rbp), %rdx
callq 0x39540
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x39d66
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x39d85
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x10c00
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0xfdf0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_nssconf_loadpath
int dns_nssconf_loadpath(struct dns_resolv_conf *resconf, const char *path) {
	FILE *fp;
	int error;

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

	error = dns_nssconf_loadfile(resconf, fp);

	fclose(fp);

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x13857(%rip), %rsi     # 0x4d602
leaq -0x24(%rbp), %rdx
callq 0x39540
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x39dc6
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x39de5
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xf850
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0xfdf0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_resconf_root
struct dns_resolv_conf *dns_resconf_root(int *error) {
	struct dns_resolv_conf *resconf;

	if ((resconf = dns_resconf_local(error)))
		resconf->options.recurse = 1;

	return resconf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf310
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x39e1a
movq -0x10(%rbp), %rax
movb $0x1, 0x5c1(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_pton
static dns_error_t dns_pton(int af, const void *src, void *dst) {
	switch (dns_inet_pton(af, src, dst)) {
	case 1:
		return 0;
	case -1:
		return dns_soerr();
	default:
		return DNS_EADDRESS;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10b60
movl %eax, %ecx
movl %ecx, -0x1c(%rbp)
subl $-0x1, %eax
je 0x3a0f2
jmp 0x3a0df
movl -0x1c(%rbp), %eax
subl $0x1, %eax
jne 0x3a0fe
jmp 0x3a0e9
movl $0x0, -0x4(%rbp)
jmp 0x3a105
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3a105
movl $0x9b918cc5, -0x4(%rbp) # imm = 0x9B918CC5
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_sa_addr
static void *dns_sa_addr(int af, const void *sa, socklen_t *size) {
	switch (af) {
	case AF_INET6: {
		struct in6_addr *in6 = &((struct sockaddr_in6 *)sa)->sin6_addr;

		if (size)
			*size = sizeof *in6;

		return in6;
	}
	case AF_INET: {
		struct in_addr *in = &((struct sockaddr_in *)sa)->sin_addr;

		if (size)
			*size = sizeof *in;

		return in;
	}
	default:
		if (size)
			*size = 0;

		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x2, %eax
je 0x3a15d
jmp 0x3a12c
movl -0x34(%rbp), %eax
subl $0xa, %eax
jne 0x3a184
jmp 0x3a136
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3a153
movq -0x20(%rbp), %rax
movl $0x10, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3a19d
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3a17a
movq -0x20(%rbp), %rax
movl $0x4, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3a19d
cmpq $0x0, -0x20(%rbp)
je 0x3a195
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, -0x8(%rbp)
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_sa_port
static unsigned short *dns_sa_port(int af, void *sa) {
	switch (af) {
	case AF_INET6:
		return &((struct sockaddr_in6 *)sa)->sin6_port;
	case AF_INET:
		return &((struct sockaddr_in *)sa)->sin_port;
	default:
		return DNS_SA_NOPORT;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x2, %eax
je 0x3a1e0
jmp 0x3a1c8
movl -0x1c(%rbp), %eax
subl $0xa, %eax
jne 0x3a1ee
jmp 0x3a1d2
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x3a1f9
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x3a1f9
leaq 0x237d3(%rip), %rax     # 0x5d9c8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_resconf_keyword
static enum dns_resconf_keyword dns_resconf_keyword(const char *word) {
	static const char *words[]	= {
		[DNS_RESCONF_NAMESERVER]	= "nameserver",
		[DNS_RESCONF_DOMAIN]		= "domain",
		[DNS_RESCONF_SEARCH]		= "search",
		[DNS_RESCONF_LOOKUP]		= "lookup",
		[DNS_RESCONF_FILE]		= "file",
		[DNS_RESCONF_BIND]		= "bind",
		[DNS_RESCONF_CACHE]		= "cache",
		[DNS_RESCONF_FAMILY]		= "family",
		[DNS_RESCONF_INET4]		= "inet4",
		[DNS_RESCONF_INET6]		= "inet6",
		[DNS_RESCONF_OPTIONS]		= "options",
		[DNS_RESCONF_EDNS0]		= "edns0",
		[DNS_RESCONF_ROTATE]		= "rotate",
		[DNS_RESCONF_RECURSE]		= "recurse",
		[DNS_RESCONF_SMART]		= "smart",
		[DNS_RESCONF_TCP]		= "tcp",
		[DNS_RESCONF_INTERFACE]		= "interface",
		[DNS_RESCONF_ZERO]		= "0",
		[DNS_RESCONF_ONE]		= "1",
		[DNS_RESCONF_ENABLE]		= "enable",
		[DNS_RESCONF_ONLY]		= "only",
		[DNS_RESCONF_DISABLE]		= "disable",
	};
	unsigned i;

	for (i = 0; i < lengthof(words); i++) {
		if (words[i] && 0 == strcasecmp(words[i], word))
			return i;
	}

	if (0 == strncasecmp(word, "ndots:", sizeof "ndots:" - 1))
		return DNS_RESCONF_NDOTS;

	if (0 == strncasecmp(word, "timeout:", sizeof "timeout:" - 1))
		return DNS_RESCONF_TIMEOUT;

	if (0 == strncasecmp(word, "attempts:", sizeof "attempts:" - 1))
		return DNS_RESCONF_ATTEMPTS;

	if (0 == strncasecmp(word, "tcp:", sizeof "tcp:" - 1))
		return DNS_RESCONF_TCPx;

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x1a, %rax
jae 0x3ab58
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x22908(%rip), %rax     # 0x5d420
cmpq $0x0, (%rax,%rcx,8)
je 0x3ab4b
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x228f5(%rip), %rax     # 0x5d420
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0xff50
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x3ab4b
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3abf7
jmp 0x3ab4d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3ab03
movq -0x10(%rbp), %rdi
leaq 0x12d96(%rip), %rsi     # 0x4d8f9
movl $0x6, %edx
callq 0x10190
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x3ab7e
movl $0xc, -0x4(%rbp)
jmp 0x3abf7
movq -0x10(%rbp), %rdi
leaq 0x12d77(%rip), %rsi     # 0x4d900
movl $0x8, %edx
callq 0x10190
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x3aba4
movl $0xd, -0x4(%rbp)
jmp 0x3abf7
movq -0x10(%rbp), %rdi
leaq 0x12d5a(%rip), %rsi     # 0x4d909
movl $0x9, %edx
callq 0x10190
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x3abca
movl $0xe, -0x4(%rbp)
jmp 0x3abf7
movq -0x10(%rbp), %rdi
leaq 0x12d3e(%rip), %rsi     # 0x4d913
movl $0x4, %edx
callq 0x10190
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x3abf0
movl $0x13, -0x4(%rbp)
jmp 0x3abf7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
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_resconf_setiface
int dns_resconf_setiface(struct dns_resolv_conf *resconf, const char *addr, unsigned short port) {
	int af = (strchr(addr, ':'))? AF_INET6 : AF_INET;
	int error;

	if ((error = dns_pton(af, addr, dns_sa_addr(af, &resconf->iface, NULL))))
		return error;

	*dns_sa_port(af, &resconf->iface)	= htons(port);
	resconf->iface.ss_family		= af;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %dx, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movq -0x18(%rbp), %rdi
movl $0x3a, %esi
callq 0xf530
movq %rax, %rdx
movl $0x2, %eax
movl $0xa, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x20(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x5c8, %rsi            # imm = 0x5C8
xorl %eax, %eax
movl %eax, %edx
callq 0x3a110
movl -0x34(%rbp), %edi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x3a0b0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x3ac80
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3acbf
movzwl -0x1a(%rbp), %edi
callq 0xf0e0
movw %ax, -0x36(%rbp)
movl -0x20(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x5c8, %rsi            # imm = 0x5C8
callq 0x3a1b0
movw -0x36(%rbp), %cx
movw %cx, (%rax)
movl -0x20(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x5c8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_anyconf_skip
static size_t dns_anyconf_skip(const char *pat, FILE *fp) {
	size_t count = 0;
	int ch;

	while (EOF != (ch = getc(fp))) {
		if (dns_anyconf_match(pat, ch)) {
			count++;
			continue;
		}

		ungetc(ch, fp);

		break;
	}

	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf3a0
movl %eax, %ecx
movl %ecx, -0x1c(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
je 0x3b0fb
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x43810
testb $0x1, %al
jne 0x3b0e1
jmp 0x3b0ef
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3b0b8
movl -0x1c(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xf1c0
movq -0x18(%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_anyconf_scan
static size_t dns_anyconf_scan(struct dns_anyconf *cf, const char *pat, FILE *fp, int *error) {
	size_t len;
	int ch;

	while (EOF != (ch = getc(fp))) {
		if (dns_anyconf_match(pat, ch)) {
			if ((*error = dns_anyconf_addc(cf, ch)))
				return 0;

			continue;
		} else {
			ungetc(ch, fp);

			break;
		}
	}

	if ((len = cf->cp - cf->tp)) {
		if ((*error = dns_anyconf_push(cf)))
			return 0;

		return len;
	} else {
		*error = 0;

		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xf3a0
movl %eax, %ecx
movl %ecx, -0x34(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
je 0x3b180
movq -0x18(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x43810
testb $0x1, %al
jne 0x3b151
jmp 0x3b174
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x43a00
movq -0x28(%rbp), %rcx
movl %eax, (%rcx)
cmpl $0x0, %eax
je 0x3b172
movq $0x0, -0x8(%rbp)
jmp 0x3b1dd
jmp 0x3b128
movl -0x34(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0xf1c0
movq -0x10(%rbp), %rax
movq 0x490(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x488(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x3b1cb
movq -0x10(%rbp), %rdi
callq 0x43a70
movq -0x28(%rbp), %rcx
movl %eax, (%rcx)
cmpl $0x0, %eax
je 0x3b1c1
movq $0x0, -0x8(%rbp)
jmp 0x3b1dd
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3b1dd
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)