LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %rax
callq 0xf2d0
testq %rax, %rax
je 0x2bc3a
movb $0x1, 0x5c1(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_resconf_pton
int dns_resconf_pton(struct sockaddr_storage *ss, const char *src) {
	struct { char buf[128], *p; } addr = { "", addr.buf };
	unsigned short port = 0;
	int ch, af = AF_INET, error;

	while ((ch = *src++)) {
		switch (ch) {
		case ' ':
			/* FALL THROUGH */
		case '\t':
			break;
		case '[':
			break;
		case ']':
			while ((ch = *src++)) {
				if (dns_isdigit(ch)) {
					port *= 10;
					port += ch - '0';
				}
			}

			goto inet;
		case ':':
			af = AF_INET6;

			/* FALL THROUGH */
		default:
			if (addr.p < endof(addr.buf) - 1)
				*addr.p++ = ch;

			break;
		} /* switch() */
	} /* while() */
inet:

	if ((error = dns_pton(af, addr.buf, dns_sa_addr(af, ss, NULL))))
		return error;

	port = (!port)? 53 : port;
	*dns_sa_port(af, ss) = htons(port);
	dns_sa_family(ss) = af;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, 0x70(%rax)
movaps %xmm0, 0x60(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rax, 0x80(%rax)
movl $0x2, %ebp
leaq 0x7f(%rsp), %rax
incq %r14
movb -0x1(%r14), %cl
movzbl %cl, %edx
cmpl $0x39, %edx
jg 0x2bca6
cmpl $0x9, %edx
je 0x2bc87
cmpl $0x20, %edx
je 0x2bc87
testl %edx, %edx
je 0x2bd19
jmp 0x2bcbc
cmpl $0x5b, %edx
je 0x2bc87
cmpl $0x3a, %edx
je 0x2bcb7
cmpl $0x5d, %edx
je 0x2bcd9
jmp 0x2bcbc
movl $0xa, %ebp
movq 0x80(%rsp), %rdx
cmpq %rax, %rdx
jae 0x2bc87
leaq 0x1(%rdx), %rsi
movq %rsi, 0x80(%rsp)
movb %cl, (%rdx)
jmp 0x2bc87
movb (%r14), %r12b
testb %r12b, %r12b
je 0x2bd19
incq %r14
callq 0xfe30
movq (%rax), %rax
xorl %ecx, %ecx
movsbl %r12b, %edx
movzbl %dl, %esi
leal (%rcx,%rcx), %edi
testb $0x8, 0x1(%rax,%rsi,2)
leal (%rdi,%rdi,4), %esi
leal -0x30(%rdx,%rsi), %r15d
cmovel %ecx, %r15d
movb (%r14), %r12b
incq %r14
movl %r15d, %ecx
testb %r12b, %r12b
jne 0x2bcee
jmp 0x2bd1c
xorl %r15d, %r15d
cmpl $0x2, %ebp
je 0x2bd2c
cmpl $0xa, %ebp
jne 0x2bd32
leaq 0x8(%rbx), %rdx
jmp 0x2bd34
leaq 0x4(%rbx), %rdx
jmp 0x2bd34
xorl %edx, %edx
movq %rsp, %rsi
movl %ebp, %edi
callq 0x2bd82
testl %eax, %eax
jne 0x2bd72
testw %r15w, %r15w
movl $0x35, %eax
cmovnel %r15d, %eax
rolw $0x8, %ax
cmpl $0x2, %ebp
je 0x2bd5d
cmpl $0xa, %ebp
jne 0x2bd63
leaq 0x2(%rbx), %rcx
jmp 0x2bd6a
leaq 0x1c8e6(%rip), %rcx     # 0x48650
movw %ax, (%rcx)
movw %bp, (%rbx)
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
callq 0x10960
cmpl $0x1, %eax
je 0x2bd9b
cmpl $-0x1, %eax
jne 0x2bd9f
callq 0xf0a0
movl (%rax), %eax
jmp 0x2bda4
xorl %eax, %eax
jmp 0x2bda4
movl $0x9b918cc5, %eax       # imm = 0x9B918CC5
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1a7f5(%rip), %r15     # 0x46ac0
xorl %r14d, %r14d
movl $0x87000, %r12d         # imm = 0x87000
btq %r14, %r12
jb 0x2c2ed
movq (%r15), %rdi
movq %rbx, %rsi
callq 0xfe40
testl %eax, %eax
je 0x2c37a
incq %r14
addq $0x8, %r15
cmpq $0x1a, %r14
jne 0x2c2d4
leaq 0xd0c6(%rip), %rsi      # 0x393c7
movl $0x6, %edx
movq %rbx, %rdi
callq 0x10050
testl %eax, %eax
je 0x2c364
leaq 0xd0b5(%rip), %rsi      # 0x393ce
movl $0x8, %edx
movq %rbx, %rdi
callq 0x10050
testl %eax, %eax
je 0x2c36c
leaq 0xd0a6(%rip), %rsi      # 0x393d7
movl $0x9, %edx
movq %rbx, %rdi
callq 0x10050
testl %eax, %eax
je 0x2c374
leaq 0xd098(%rip), %rsi      # 0x393e1
movl $0x4, %edx
movq %rbx, %rdi
callq 0x10050
xorl %r14d, %r14d
negl %eax
sbbl %r14d, %r14d
orl $0x13, %r14d
jmp 0x2c37a
movl $0xc, %r14d
jmp 0x2c37a
movl $0xd, %r14d
jmp 0x2c37a
movl $0xe, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x3a, %esi
callq 0xf4e0
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
leal 0x2(,%rcx,8), %r14d
leaq (%rbx,%rcx,4), %rdx
addq $0x5cc, %rdx            # imm = 0x5CC
movl %r14d, %edi
movq %r15, %rsi
callq 0x2bd82
testl %eax, %eax
jne 0x2c3e4
rolw $0x8, %bp
movw %bp, 0x5ca(%rbx)
movw %r14w, 0x5c8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0xf360
cmpl $-0x1, %eax
je 0x2c857
movl %eax, %ebp
xorl %r14d, %r14d
movq %r15, %rdi
movl %ebp, %esi
callq 0x33730
testb %al, %al
je 0x2c85c
incq %r14
movq %rbx, %rdi
callq 0xf360
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x2c835
jmp 0x2c866
xorl %r14d, %r14d
jmp 0x2c866
movl %ebp, %edi
movq %rbx, %rsi
callq 0xf1a0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq %rsi, %rdi
callq 0xf360
cmpl $-0x1, %eax
je 0x2c8f2
movl %eax, %ebp
leaq 0x484(%r15), %r14
leaq 0xc79a(%rip), %r13      # 0x3903f
movq %r13, %rdi
movl %ebp, %esi
callq 0x33730
testb %al, %al
je 0x2c8e8
movq 0x490(%r15), %rax
cmpq %r14, %rax
jae 0x2c960
leaq 0x1(%rax), %rcx
movq %rcx, 0x490(%r15)
movb %bpl, (%rax)
movl $0x0, (%rbx)
movq %r12, %rdi
callq 0xf360
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x2c8a5
jmp 0x2c8f2
movl %ebp, %edi
movq %r12, %rsi
callq 0xf1a0
movq 0x490(%r15), %rcx
movq %rcx, %rax
subq 0x488(%r15), %rax
je 0x2c95c
leaq 0x484(%r15), %rdx
movl $0xc, %esi
cmpq %rdx, %rcx
jae 0x2c965
cmpl $0xf, 0x80(%r15)
ja 0x2c965
leaq 0x1(%rcx), %rdx
movq %rdx, 0x490(%r15)
movb $0x0, (%rcx)
movq 0x488(%r15), %rsi
movl 0x80(%r15), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x80(%r15)
movq %rsi, (%r15,%rcx,8)
movq 0x490(%r15), %rcx
movq %rcx, 0x488(%r15)
xorl %esi, %esi
jmp 0x2c967
xorl %esi, %esi
jmp 0x2c965
movl $0xc, %esi
xorl %eax, %eax
movl %esi, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_nssconf_dump
int dns_nssconf_dump(struct dns_resolv_conf *resconf, FILE *fp) {
	struct dns_nssconf_source src;
	dns_nssconf_i i = 0;

	fputs("hosts:", fp);

	while (dns_nssconf_next(&src, resconf, &i)) {
		unsigned n = 0;

		fprintf(fp, " %s", dns_nssconf_k2s(src.source));

		dns_nssconf_dump_status(DNS_NSSCONF_SUCCESS, src.success, &n, fp);
		dns_nssconf_dump_status(DNS_NSSCONF_NOTFOUND, src.notfound, &n, fp);
		dns_nssconf_dump_status(DNS_NSSCONF_UNAVAIL, src.unavail, &n, fp);
		dns_nssconf_dump_status(DNS_NSSCONF_TRYAGAIN, src.tryagain, &n, fp);

		if (n)
			fputc(']', fp);
	}

	fputc('\n', fp);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0xc6cd(%rip), %rdi      # 0x3905d
movq %rsi, 0x8(%rsp)
callq 0xfea0
leaq 0xbdcf(%rip), %r8       # 0x38770
leaq 0xa20c(%rip), %r9       # 0x36bb4
xorl %r13d, %r13d
movq %r14, 0x10(%rsp)
movl $0x0, %ecx
cmpl $0x23, %r13d
ja 0x2c9c7
movl %r13d, %eax
movsbl 0x580(%r14,%rax), %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x2ca87
cmpl $0x6d, %ecx
ja 0x2c9dd
movl %ecx, %eax
movsbl (%rax,%r8), %eax
incl %r13d
leal -0x8(%rax), %ecx
cmpl $0x2, %ecx
ja 0x2c9b0
movl $0x7, %r12d
movl $0x6, %ebp
movl $0x6, %r15d
movl $0x6, %ebx
xorl %edx, %edx
cmpl $0x23, %r13d
ja 0x2ca12
movl %r13d, %ecx
movsbl 0x580(%r14,%rcx), %edx
testl %edx, %edx
je 0x2ca9d
leal 0x1(%r13), %ecx
xorl %edi, %edi
cmpl $0x23, %ecx
ja 0x2ca30
movl %ecx, %ecx
movsbl 0x580(%r14,%rcx), %edi
testl %edi, %edi
je 0x2ca9d
xorl %ecx, %ecx
movl $0x0, %esi
cmpl $0x6d, %edx
ja 0x2ca47
movl %edx, %edx
movsbl (%rdx,%r8), %esi
cmpl $0x6d, %edi
ja 0x2ca53
movl %edi, %ecx
movsbl (%rcx,%r8), %ecx
movl %ecx, %edx
andl $-0x2, %edx
cmpl $0x6, %edx
jne 0x2ca9d
addl $-0x2, %esi
cmpl $0x3, %esi
ja 0x2ca9d
movslq (%r9,%rsi,4), %rdx
addq %r9, %rdx
jmpq *%rdx
movl %ecx, %r12d
jmp 0x2ca7e
movl %ecx, %r15d
jmp 0x2ca7e
movl %ecx, %ebp
jmp 0x2ca7e
movl %ecx, %ebx
addl $0x2, %r13d
jmp 0x2c9fe
movl $0x7, %r12d
movl $0x6, %ebp
movl $0x6, %r15d
movl $0x6, %ebx
testl %eax, %eax
je 0x2cb5a
movl $0x0, 0x4(%rsp)
leal -0xb(%rax), %ecx
leaq 0xc594(%rip), %rdx      # 0x3904b
cmpl $-0x9, %ecx
jb 0x2cac9
movl %eax, %eax
leaq 0x1a12b(%rip), %rcx     # 0x46bf0
movq (%rcx,%rax,8), %rdx
movq 0x8(%rsp), %r14
movq %r14, %rdi
leaq 0x949c(%rip), %rsi      # 0x35f74
xorl %eax, %eax
callq 0x102e0
movl $0x2, %edi
movl %r12d, %esi
leaq 0x4(%rsp), %r12
movq %r12, %rdx
movq %r14, %rcx
callq 0x2cb7a
movl $0x3, %edi
movl %ebx, %esi
movq %r12, %rdx
movq %r14, %rcx
callq 0x2cb7a
movl $0x4, %edi
movl %r15d, %esi
movq %r12, %rdx
movq %r14, %rcx
callq 0x2cb7a
movl $0x5, %edi
movl %ebp, %esi
movq %r12, %rdx
movq %r14, %rcx
callq 0x2cb7a
cmpl $0x0, 0x4(%rsp)
je 0x2cb42
movl $0x5d, %edi
movq %r14, %rsi
callq 0x10000
leaq 0xbc27(%rip), %r8       # 0x38770
leaq 0xa064(%rip), %r9       # 0x36bb4
movq 0x10(%rsp), %r14
jmp 0x2c9b0
movl $0xa, %edi
movq 0x8(%rsp), %rsi
callq 0x10000
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_nssconf_dump_status
static int dns_nssconf_dump_status(int status, int action, unsigned *count, FILE *fp) {
	switch (status) {
	case DNS_NSSCONF_SUCCESS:
		if (action == DNS_NSSCONF_RETURN)
			return 0;
		break;
	default:
		if (action == DNS_NSSCONF_CONTINUE)
			return 0;
		break;
	}

	fputc(' ', fp);

	if (!*count)
		fputc('[', fp);

	fprintf(fp, "%s=%s", dns_nssconf_k2s(status), dns_nssconf_k2s(action));

	++*count;

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %r15d
movl %edi, %r12d
cmpl $0x2, %edi
jne 0x2cb9b
cmpl $0x7, %r15d
jne 0x2cba1
jmp 0x2cc0c
cmpl $0x6, %r15d
je 0x2cc0c
movl $0x20, %edi
movq %r14, %rsi
callq 0x10000
cmpl $0x0, (%rbx)
jne 0x2cbc0
movl $0x5b, %edi
movq %r14, %rsi
callq 0x10000
leal -0xb(%r12), %eax
leaq 0xc47f(%rip), %rcx      # 0x3904b
movq %rcx, %rdx
cmpl $-0x9, %eax
jb 0x2cbe2
movl %r12d, %eax
leaq 0x1a012(%rip), %rdx     # 0x46bf0
movq (%rdx,%rax,8), %rdx
leal -0xb(%r15), %eax
cmpl $-0x9, %eax
jb 0x2cbf9
movl %r15d, %eax
leaq 0x19ffb(%rip), %rcx     # 0x46bf0
movq (%rcx,%rax,8), %rcx
leaq 0xc845(%rip), %rsi      # 0x39445
movq %r14, %rdi
xorl %eax, %eax
callq 0x102e0
incl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_hints_close
void dns_hints_close(struct dns_hints *H) {
	struct dns_hints_soa *soa, *nxt;

	if (!H || 1 != dns_hints_release(H))
		return /* void */;

	for (soa = H->head; soa; soa = nxt) {
		nxt	= soa->next;

		free(soa);
	}

	free(H);

	return /* void */;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2d43c
movq %rdi, %rbx
movq $-0x1, %rax
lock
xaddq %rax, (%rdi)
cmpl $0x1, %eax
jne 0x2d43c
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2d42d
movq 0x988(%rdi), %r14
callq 0xff30
movq %r14, %rdi
testq %r14, %r14
jne 0x2d419
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xff30
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_hints_local
struct dns_hints *dns_hints_local(struct dns_resolv_conf *resconf, int *error_) {
	struct dns_hints *hints		= 0;
	int error;

	if (resconf)
		dns_resconf_acquire(resconf);
	else if (!(resconf = dns_resconf_local(&error)))
		goto error;

	if (!(hints = dns_hints_open(resconf, &error)))
		goto error;

	error	= 0;

	if (0 == dns_hints_insert_resconf(hints, ".", resconf, &error) && error)
		goto error;

	dns_resconf_close(resconf);

	return hints;
error:
	*error_	= error;

	dns_resconf_close(resconf);
	dns_hints_close(hints);

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
testq %rdi, %rdi
je 0x2d47e
movq %rdi, %rbx
lock
incq 0x648(%rdi)
jmp 0x2d490
leaq 0xc(%rsp), %rdi
callq 0xf2d0
movq %rax, %rbx
testq %rax, %rax
je 0x2d4e9
leaq 0xc(%rsp), %rsi
callq 0xf030
testq %rax, %rax
je 0x2d4eb
movq %rax, %r14
leaq 0xc(%rsp), %rcx
movl $0x0, (%rcx)
leaq 0xba9f(%rip), %rsi      # 0x38f53
movq %rax, %rdi
movq %rbx, %rdx
callq 0xf870
testl %eax, %eax
jne 0x2d4ca
cmpl $0x0, 0xc(%rsp)
jne 0x2d4ee
movq $-0x1, %rax
lock
xaddq %rax, 0x648(%rbx)
cmpl $0x1, %eax
jne 0x2d522
movq %rbx, %rdi
callq 0xff30
jmp 0x2d522
xorl %ebx, %ebx
xorl %r14d, %r14d
movl 0xc(%rsp), %eax
movl %eax, (%r15)
testq %rbx, %rbx
je 0x2d517
movq $-0x1, %rax
lock
xaddq %rax, 0x648(%rbx)
cmpl $0x1, %eax
jne 0x2d517
movq %rbx, %rdi
callq 0xff30
movq %r14, %rdi
callq 0xfba0
xorl %r14d, %r14d
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_hints_insert_resconf
unsigned dns_hints_insert_resconf(struct dns_hints *H, const char *zone, const struct dns_resolv_conf *resconf, int *error_) {
	unsigned i, n, p;
	int error;

	for (i = 0, n = 0, p = 1; i < lengthof(resconf->nameserver) && resconf->nameserver[i].ss_family != AF_UNSPEC; i++, n++) {
		union { struct sockaddr_in sin; } tmp;
		struct sockaddr *ns;

		/*
		 * dns_resconf_open initializes nameserver[0] to INADDR_ANY.
		 *
		 * Traditionally the semantics of 0.0.0.0 meant the default
		 * interface, which evolved to mean the loopback interface.
		 * See comment block preceding resolv/res_init.c:res_init in
		 * glibc 2.23. As of 2.23, glibc no longer translates
		 * 0.0.0.0 despite the code comment, but it does default to
		 * 127.0.0.1 when no nameservers are present.
		 *
		 * BIND9 as of 9.10.3 still translates 0.0.0.0 to 127.0.0.1.
		 * See lib/lwres/lwconfig.c:lwres_create_addr and the
		 * convert_zero flag. 127.0.0.1 is also the default when no
		 * nameservers are present.
		 */
		if (dns_hints_isinaddr_any(&resconf->nameserver[i])) {
			memcpy(&tmp.sin, &resconf->nameserver[i], sizeof tmp.sin);
			tmp.sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
			ns = (struct sockaddr *)&tmp.sin;
		} else {
			ns = (struct sockaddr *)&resconf->nameserver[i];
		}

		if ((error = dns_hints_insert(H, zone, ns, p)))
			goto error;

		p += !resconf->options.rotate;
	}

	return n;
error:
	*error_ = error;

	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
movl $0x1, %ebp
xorl %ebx, %ebx
movq %rdx, %r15
movzwl (%r15), %eax
testw %ax, %ax
je 0x2d5d0
movq %r15, %rdx
cmpw $0x2, %ax
jne 0x2d587
cmpl $0x0, 0x4(%r15)
movq %r15, %rdx
jne 0x2d587
movups (%r15), %xmm0
movaps %xmm0, 0x10(%rsp)
movl $0x100007f, 0x14(%rsp)  # imm = 0x100007F
leaq 0x10(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rsi
movl %ebp, %ecx
callq 0xf930
movl $0x5, %ecx
testl %eax, %eax
jne 0x2d5ac
movzbl 0x5c0(%r14), %ecx
xorl $0x1, %ecx
addl %ecx, %ebp
xorl %ecx, %ecx
testl %ecx, %ecx
jne 0x2d5c4
incq %rbx
subq $-0x80, %r15
cmpq $0x3, %rbx
jne 0x2d555
movl $0x3, %ebx
jmp 0x2d5d0
cmpl $0x5, %ecx
jne 0x2d5d0
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_hints_insert
int dns_hints_insert(struct dns_hints *H, const char *zone, const struct sockaddr *sa, unsigned priority) {
	static const struct dns_hints_soa soa_initializer;
	struct dns_hints_soa *soa;
	unsigned i;

	if (!(soa = dns_hints_fetch(H, zone))) {
		if (!(soa = malloc(sizeof *soa)))
			return dns_syerr();
		*soa = soa_initializer;
		dns_strlcpy((char *)soa->zone, zone, sizeof soa->zone);

		soa->next = H->head;
		H->head = soa;
	}

	i = soa->count % lengthof(soa->addrs);

	memcpy(&soa->addrs[i].ss, sa, dns_sa_len(sa));

	soa->addrs[i].priority = DNS_PP_MAX(1, priority);

	if (soa->count < lengthof(soa->addrs))
		soa->count++;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
movq 0x8(%rdi), %rbp
testq %rbp, %rbp
je 0x2d70d
movq %rbp, %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0xfe40
testl %eax, %eax
je 0x2d710
movq 0x988(%r15), %r15
testq %r15, %r15
jne 0x2d6f2
xorl %r15d, %r15d
testq %r15, %r15
jne 0x2d77f
movl $0x990, %edi            # imm = 0x990
callq 0x10110
testq %rax, %rax
je 0x2d7dd
movq %rax, %r15
movq %r12, (%rsp)
xorl %r12d, %r12d
movl $0x990, %edx            # imm = 0x990
movq %rax, %rdi
xorl %esi, %esi
callq 0xf750
movb (%r13,%r12), %al
movb %al, (%r15,%r12)
testb %al, %al
je 0x2d770
incq %r12
cmpq $0x100, %r12            # imm = 0x100
jne 0x2d741
movb $0x0, 0xff(%r15)
addq %r12, %r13
cmpb $0x0, (%r13)
leaq 0x1(%r13), %r13
jne 0x2d765
movq %rbp, 0x988(%r15)
movq (%rsp), %rax
movq %r15, 0x8(%rax)
movl 0x980(%r15), %eax
andl $0xf, %eax
movl %eax, %ecx
shll $0x7, %ecx
leal (%rcx,%rax,8), %eax
leaq (%r15,%rax), %r12
addq $0x100, %r12            # imm = 0x100
movzwl (%r14), %eax
leaq 0xb039(%rip), %rcx      # 0x387e0
movq (%rcx,%rax,8), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0xfa60
cmpl $0x1, %ebx
adcl $0x0, %ebx
movl %ebx, 0x80(%r12)
movl 0x980(%r15), %ecx
xorl %eax, %eax
cmpl $0xf, %ecx
ja 0x2d7e4
incl %ecx
movl %ecx, 0x980(%r15)
jmp 0x2d7e4
callq 0xf0a0
movl (%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_hints_grep
unsigned dns_hints_grep(struct sockaddr **sa, socklen_t *sa_len, unsigned lim, struct dns_hints_i *i, struct dns_hints *H) {
	struct dns_hints_soa *soa;
	unsigned n;

	if (!(soa = dns_hints_fetch(H, i->zone)))
		return 0;

	n	= 0;

	while (i->state.next < soa->count && n < lim) {
		*sa	= (struct sockaddr *)&soa->addrs[i->state.next].ss;
		*sa_len	= dns_sa_len(*sa);

		sa++;
		sa_len++;
		n++;

		i->state.next	= dns_hints_i_skip(i->state.next, i, soa);
	}

	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movl %edx, 0x4(%rsp)
movq %rsi, %r12
movq 0x8(%r8), %r13
xorl %ebx, %ebx
testq %r13, %r13
je 0x2d83f
movq %rdi, %rbp
movq (%r14), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0xfe40
testl %eax, %eax
je 0x2d83a
movq 0x988(%r13), %r13
testq %r13, %r13
jne 0x2d81c
xorl %r13d, %r13d
movq %rbp, %rdi
jmp 0x2d842
xorl %r13d, %r13d
testq %r13, %r13
je 0x2d953
movl 0x8(%r14), %ebp
cmpl 0x980(%r13), %ebp
setae %al
cmpl $0x0, 0x4(%rsp)
sete %cl
orb %al, %cl
jne 0x2d953
leaq 0x100(%r13), %rax
movq %rax, 0x8(%rsp)
xorl %ebx, %ebx
movq %rbx, 0x20(%rsp)
movl %ebp, %eax
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %rax
movq 0x8(%rsp), %rdx
leaq (%rdx,%rax), %rcx
movq %rdi, 0x10(%rsp)
movq %rcx, (%rdi)
movzwl (%rdx,%rax), %eax
leaq 0xaf3b(%rip), %rcx      # 0x387e0
movl (%rcx,%rax,8), %eax
movl %eax, (%r12)
movl 0x980(%r13), %ebx
testl %ebx, %ebx
movq %r12, 0x18(%rsp)
je 0x2d8dc
movl 0x8(%r14), %r15d
xorl %ebp, %ebp
movl %ebp, %edi
movl %r15d, %esi
movq %r14, %rdx
movq %r13, %rcx
callq 0x337e7
testl %eax, %eax
jg 0x2d910
incl %ebp
cmpl %ebp, %ebx
jne 0x2d8c2
movl %ebx, %ebp
movq 0x20(%rsp), %rbx
incl %ebx
movl %ebp, 0x8(%r14)
cmpl 0x980(%r13), %ebp
jae 0x2d953
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movq 0x18(%rsp), %r12
addq $0x4, %r12
cmpl 0x4(%rsp), %ebx
jb 0x2d877
jmp 0x2d953
leal 0x1(%rbp), %r12d
cmpl %ebx, %r12d
jae 0x2d8de
movl %r12d, %edi
movl %r15d, %esi
movq %r14, %rdx
movq %r13, %rcx
callq 0x337e7
testl %eax, %eax
jle 0x2d949
movl %r12d, %edi
movl %ebp, %esi
movq %r14, %rdx
movq %r13, %rcx
callq 0x337e7
movl %r12d, %ecx
testl %eax, %eax
js 0x2d947
movl %ebp, %ecx
movl %ecx, %ebp
incl %r12d
cmpl %r12d, %ebx
jne 0x2d919
jmp 0x2d8de
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_hints_dump
int dns_hints_dump(struct dns_hints *hints, FILE *fp) {
	struct dns_hints_soa *soa;
	char addr[INET6_ADDRSTRLEN];
	unsigned i;
	int af, error;

	for (soa = hints->head; soa; soa = soa->next) {
		fprintf(fp, "ZONE \"%s\"\n", soa->zone);

		for (i = 0; i < soa->count; i++) {
			af = soa->addrs[i].ss.ss_family;

			if ((error = dns_ntop(af, dns_sa_addr(af, &soa->addrs[i].ss, NULL), addr, sizeof addr)))
				return error;

			fprintf(fp, "\t(%d) [%s]:%hu\n", (int)soa->addrs[i].priority, addr, ntohs(*dns_sa_port(af, &soa->addrs[i].ss)));
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, 0x8(%rsp)
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x2dd8c
movq 0x8(%rsp), %rdi
leaq 0xb46c(%rip), %rsi      # 0x39116
movq %r14, %rdx
xorl %eax, %eax
callq 0x102e0
cmpl $0x0, 0x980(%r14)
je 0x2dd80
leaq 0x100(%r14), %r15
leaq 0x180(%r14), %r13
xorl %r12d, %r12d
movq %r12, %rax
shlq $0x7, %rax
leaq (%rax,%r12,8), %rbx
addq %r15, %rbx
movzwl -0x80(%r13), %ebp
cmpl $0x2, %ebp
je 0x2dcf6
cmpl $0xa, %ebp
jne 0x2dcfc
leaq -0x78(%r13), %rsi
jmp 0x2dcfe
leaq 0x4(%rbx), %rsi
jmp 0x2dcfe
xorl %esi, %esi
movl %ebp, %edi
leaq 0x10(%rsp), %rdx
movl $0x2e, %ecx
callq 0xfda0
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
jne 0x2dd20
callq 0xf0a0
movl (%rax), %eax
testl %eax, %eax
jne 0x2dd8e
cmpl $0x2, %ebp
je 0x2dd3b
leaq 0x1a920(%rip), %rbx     # 0x48650
cmpl $0xa, %ebp
jne 0x2dd3f
leaq -0x7e(%r13), %rbx
jmp 0x2dd3f
addq $0x2, %rbx
movl (%r13), %edx
movzwl (%rbx), %eax
rolw $0x8, %ax
movzwl %ax, %r8d
movq 0x8(%rsp), %rdi
leaq 0xb3c7(%rip), %rsi      # 0x39121
leaq 0x10(%rsp), %rcx
xorl %eax, %eax
callq 0x102e0
incq %r12
movl 0x980(%r14), %eax
addq $0x88, %r13
cmpq %rax, %r12
jb 0x2dcd3
movq 0x988(%r14), %r14
jmp 0x2dc95
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_so_open
struct dns_socket *dns_so_open(const struct sockaddr *local, int type, const struct dns_options *opts, int *error) {
	struct dns_socket *so;

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

	if (!dns_so_init(so, local, type, opts, error))
		goto error;

	return so;
syerr:
	*error	= dns_syerr();
error:
	dns_so_close(so);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
movl $0x300, %edi            # imm = 0x300
callq 0x10110
movq %rax, %rbx
testq %rax, %rax
je 0x2de2c
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x2de4c
testq %rax, %rax
jne 0x2de40
jmp 0x2de36
callq 0xf0a0
movl (%rax), %eax
movl %eax, (%r14)
movq %rbx, %rdi
callq 0xf6a0
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_so_init
static struct dns_socket *dns_so_init(struct dns_socket *so, const struct sockaddr *local, int type, const struct dns_options *opts, int *error) {
	static const struct dns_socket so_initializer = { .opts = DNS_OPTS_INITIALIZER, .udp = -1, .tcp = -1, };

	*so		= so_initializer;
	so->type	= type;

	if (opts)
		so->opts = *opts;

	if (local)
		memcpy(&so->local, local, dns_sa_len(local));

	if (-1 == (so->udp = dns_socket((struct sockaddr *)&so->local, SOCK_DGRAM, error)))
		goto error;

	dns_k_permutor_init(&so->qids, 1, 65535);

	return so;
error:
	dns_so_destroy(so);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xaae3(%rip), %rsi      # 0x38950
movl $0x300, %edx            # imm = 0x300
callq 0xfa60
movl %ebp, 0x30(%rbx)
testq %r12, %r12
je 0x2de90
movq 0x10(%r12), %rax
movq %rax, 0x10(%rbx)
movups (%r12), %xmm0
movups %xmm0, (%rbx)
testq %r15, %r15
je 0x2deb0
leaq 0x38(%rbx), %rdi
movzwl (%r15), %eax
leaq 0xa93c(%rip), %rcx      # 0x387e0
movq (%rcx,%rax,8), %rdx
movq %r15, %rsi
callq 0xfa60
leaq 0x38(%rbx), %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x2ea25
movl %eax, 0x18(%rbx)
cmpl $-0x1, %eax
je 0x2df15
movaps 0xadb0(%rip), %xmm0     # 0x38c80
movups %xmm0, 0x138(%rbx)
movabsq $0x8000000ff, %rax      # imm = 0x8000000FF
movq %rax, 0x148(%rbx)
xorl %r14d, %r14d
callq *0x1a3df(%rip)          # 0x482d0
movl %eax, (%rsp,%r14,4)
incq %r14
cmpq $0x4, %r14
jne 0x2deeb
movaps (%rsp), %xmm0
movups %xmm0, 0x150(%rbx)
movl $0x20, 0x160(%rbx)
jmp 0x2df43
movq 0x2e8(%rbx), %rdi
callq 0xff30
leaq 0x1b0(%rbx), %rdi
movl $0x150, %edx            # imm = 0x150
xorl %esi, %esi
callq 0xf750
movq %rbx, %rdi
movl $0x7, %esi
callq 0x2ec9f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_so_close
void dns_so_close(struct dns_socket *so) {
	if (!so)
		return;

	dns_so_destroy(so);

	free(so);
}

// Assembly:
testq %rdi, %rdi
je 0x2df91
pushq %rbx
movq %rdi, %rbx
movq 0x2e8(%rdi), %rdi
callq 0xff30
leaq 0x1b0(%rbx), %rdi
movl $0x150, %edx            # imm = 0x150
xorl %esi, %esi
callq 0xf750
movq %rbx, %rdi
movl $0x7, %esi
callq 0x2ec9f
movq %rbx, %rdi
popq %rbx
jmp 0xff30
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_so_submit
int dns_so_submit(struct dns_socket *so, struct dns_packet *Q, struct sockaddr *host) {
	struct dns_rr rr;
	int error = DNS_EUNKNOWN;

	dns_so_reset(so);

	if ((error = dns_rr_parse(&rr, 12, Q)))
		goto error;

	if (!(so->qlen = dns_d_expand(so->qname, sizeof so->qname, rr.dn.p, Q, &error)))
		goto error;
	/*
	 * NOTE: Don't bail if expansion is too long; caller may be
	 * intentionally sending long names. However, we won't be able to
	 * verify it on return.
	 */

	so->qtype	= rr.type;
	so->qclass	= rr.class;

	if ((error = dns_so_newanswer(so, (Q->memo.opt.maxudp)? Q->memo.opt.maxudp : DNS_SO_MINBUF)))
		goto syerr;

	memcpy(&so->remote, host, dns_sa_len(host));

	so->query	= Q;
	so->qout	= 0;

	dns_begin(&so->elapsed);

	if (dns_header(so->query)->qid == 0)
		dns_header(so->query)->qid	= dns_so_mkqid(so);

	so->qid		= dns_header(so->query)->qid;
	so->state	= (so->type == SOCK_STREAM)? DNS_SO_TCP_INIT : DNS_SO_UDP_INIT;

	so->stat.queries++;

	return 0;
syerr:
	error	= dns_syerr();
error:
	dns_so_reset(so);

	return error;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movl $0x9b918cc4, 0xc(%rsp)  # imm = 0x9B918CC4
movq 0x2e8(%rdi), %rdi
callq 0xff30
leaq 0x1b0(%rbx), %r15
movl $0x150, %edx            # imm = 0x150
movq %r15, %rdi
xorl %esi, %esi
callq 0xf750
leaq 0x10(%rsp), %rdi
movl $0xc, %esi
movq %r14, %rdx
callq 0xf710
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x2e1a6
movq 0x2e8(%rbx), %rdi
callq 0xff30
movl $0x150, %edx            # imm = 0x150
movq %r15, %rdi
xorl %esi, %esi
callq 0xf750
movl 0xc(%rsp), %r14d
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1b6(%rbx), %rdi
movzwl 0x14(%rsp), %edx
leaq 0xc(%rsp), %r8
movl $0x100, %esi            # imm = 0x100
movq %r14, %rcx
callq 0xfec0
movq %rax, 0x2b8(%rbx)
testq %rax, %rax
je 0x2e177
movl 0x18(%rsp), %eax
movl %eax, 0x2c0(%rbx)
movl 0x1c(%rsp), %eax
movl %eax, 0x2c4(%rbx)
movzwl 0x32(%r14), %eax
testw %ax, %ax
movl $0x300, %ecx            # imm = 0x300
cmovnel %eax, %ecx
movzwl %cx, %esi
movq %rbx, %rdi
callq 0x2e2af
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x2e217
callq 0xf0a0
movl (%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x2e177
leaq 0xb8(%rbx), %rdi
movzwl (%r12), %eax
leaq 0xa5b6(%rip), %rcx      # 0x387e0
movq (%rcx,%rax,8), %rdx
movq %r12, %rsi
callq 0xfa60
movq %r14, 0x2c8(%rbx)
xorl %r14d, %r14d
movq %r14, 0x2d0(%rbx)
xorl %edi, %edi
callq 0xfc20
movq %rax, 0x2d8(%rbx)
movq %r14, 0x2e0(%rbx)
movq 0x2c8(%rbx), %rax
cmpw $0x0, 0x5c(%rax)
jne 0x2e27d
movq %rbx, %rdi
callq 0x10340
movq 0x2c8(%rbx), %rcx
movw %ax, 0x5c(%rcx)
movq 0x2c8(%rbx), %rax
movzwl 0x5c(%rax), %eax
movw %ax, 0x1b4(%rbx)
xorl %eax, %eax
cmpl $0x1, 0x30(%rbx)
sete %al
leal (%rax,%rax,4), %eax
incl %eax
movl %eax, 0x1b0(%rbx)
incq 0x168(%rbx)
jmp 0x2e197
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_so_newanswer
static int dns_so_newanswer(struct dns_socket *so, size_t len) {
	size_t size	= offsetof(struct dns_packet, data) + DNS_PP_MAX(len, DNS_SO_MINBUF);
	void *p;

	if (!(p = realloc(so->answer, size)))
		return dns_syerr();

	so->answer	= dns_p_init(p, size);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x301, %rsi            # imm = 0x301
movl $0x300, %r14d           # imm = 0x300
cmovaeq %rsi, %r14
leaq 0x5c(%r14), %rsi
movq 0x2e8(%rdi), %rdi
callq 0x10620
testq %rax, %rax
je 0x2e31c
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
xorl %ecx, %ecx
movq %rcx, 0x60(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq %r14, 0x48(%rax)
movq $0xc, 0x50(%rax)
movq %rcx, 0x5c(%rax)
movl $0x0, 0x64(%rax)
movq %rax, 0x2e8(%rbx)
jmp 0x2e323
callq 0xf0a0
movl (%rax), %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_so_verify
static int dns_so_verify(struct dns_socket *so, struct dns_packet *P) {
	char qname[DNS_D_MAXNAME + 1];
	size_t qlen;
	struct dns_rr rr;
	int error = -1;

	if (so->qid != dns_header(so->answer)->qid)
		goto reject;

	if (!dns_p_count(so->answer, DNS_S_QD))
		goto reject;

	if (0 != dns_rr_parse(&rr, 12, so->answer))
		goto reject;

	if (rr.type != so->qtype || rr.class != so->qclass)
		goto reject;

	if (!(qlen = dns_d_expand(qname, sizeof qname, rr.dn.p, P, &error)))
		goto error;
	else if (qlen >= sizeof qname || qlen != so->qlen)
		goto reject;

	if (0 != strcasecmp(so->qname, qname))
		goto reject;

	return 0;
reject:
	error = DNS_EUNKNOWN;
error:
	DNS_SHOW(P, "rejecting packet (%s)", dns_strerror(error));

	return error;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
movq 0x2e8(%rdi), %rdx
movq 0x5c(%rdx), %rax
cmpw %ax, 0x1b4(%rdi)
setne %cl
shrq $0x20, %rax
testw %ax, %ax
sete %al
orb %cl, %al
jne 0x2e96a
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0xc, %esi
callq 0xf710
testl %eax, %eax
jne 0x2e96a
movl 0x10(%rsp), %eax
cmpl 0x2c0(%rbx), %eax
jne 0x2e96a
movl 0x14(%rsp), %eax
cmpl 0x2c4(%rbx), %eax
jne 0x2e96a
movzwl 0xc(%rsp), %edx
leaq 0x20(%rsp), %rdi
leaq 0x4(%rsp), %r8
movl $0x100, %esi            # imm = 0x100
movq %r14, %rcx
callq 0xfec0
testq %rax, %rax
je 0x2e972
cmpq $0xff, %rax
ja 0x2e96a
cmpq 0x2b8(%rbx), %rax
jne 0x2e96a
addq $0x1b6, %rbx            # imm = 0x1B6
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xfe40
testl %eax, %eax
je 0x2e981
movl $0x9b918cc4, 0x4(%rsp)  # imm = 0x9B918CC4
movl 0x4(%rsp), %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
retq
xorl %eax, %eax
jmp 0x2e976
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_so_closefd
static int dns_so_closefd(struct dns_socket *so, int *fd) {
	int error;

	if (*fd == -1)
		return 0;

	if (so->opts.closefd.cb) {
		if ((error = so->opts.closefd.cb(fd, so->opts.closefd.arg))) {
			return error;
		} else if (*fd == -1)
			return 0;
	}

	if (!(so->onum < so->olim)) {
		unsigned olim = DNS_PP_MAX(4, so->olim * 2);
		void *old;

		if (!(old = realloc(so->old, sizeof so->old[0] * olim)))
			return dns_syerr();

		so->old  = old;
		so->olim = olim;
	}

	so->old[so->onum++] = *fd;
	*fd = -1;

	return 0;
}

// Assembly:
cmpl $-0x1, (%rsi)
je 0x2e9ee
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2e9b2
movq (%r14), %rsi
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
jne 0x2ea19
cmpl $-0x1, (%rbx)
je 0x2ea17
movl 0x2c(%r14), %eax
cmpl %eax, 0x28(%r14)
jb 0x2e9fd
addl %eax, %eax
cmpl $0x5, %eax
movl $0x4, %r12d
cmovael %eax, %r12d
movq 0x20(%r14), %rdi
leaq (,%r12,4), %rsi
callq 0x10620
movq %rax, %r15
testq %rax, %rax
je 0x2e9f1
movq %r15, 0x20(%r14)
movl %r12d, 0x2c(%r14)
jmp 0x2e9f8
xorl %eax, %eax
retq
callq 0xf0a0
movl (%rax), %eax
testq %r15, %r15
je 0x2ea19
movl (%rbx), %eax
movq 0x20(%r14), %rcx
movl 0x28(%r14), %edx
leal 0x1(%rdx), %esi
movl %esi, 0x28(%r14)
movl %eax, (%rcx,%rdx,4)
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_so_query
struct dns_packet *dns_so_query(struct dns_socket *so, struct dns_packet *Q, struct sockaddr *host, int *error_) {
	struct dns_packet *A;
	int error;

	if (!so->state) {
		if ((error = dns_so_submit(so, Q, host)))
			goto error;
	}

	if ((error = dns_so_check(so)))
		goto error;

	if (!(A = dns_so_fetch(so, &error)))
		goto error;

	dns_so_reset(so);

	return A;
error:
	*error_	= error;

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
cmpl $0x0, 0x1b0(%rdi)
je 0x2ebfa
movq %r14, %rdi
callq 0xf3d0
testl %eax, %eax
jne 0x2ec32
leaq 0x1b0(%r14), %r15
movl (%r15), %ecx
cmpl $0xa, %ecx
je 0x2ebe6
cmpl $0x5, %ecx
jne 0x2ec08
movq 0x2e8(%r14), %r12
movq $0x0, 0x2e8(%r14)
jmp 0x2ec10
movq %r14, %rdi
callq 0x103d0
testl %eax, %eax
jne 0x2ec32
jmp 0x2ebc6
movl $0x9b918cc4, %eax       # imm = 0x9B918CC4
xorl %r12d, %r12d
testq %r12, %r12
je 0x2ec32
movq 0x2e8(%r14), %rdi
callq 0xff30
movl $0x150, %edx            # imm = 0x150
movq %r15, %rdi
xorl %esi, %esi
callq 0xf750
jmp 0x2ec37
movl %eax, (%rbx)
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_elapsed
static time_t dns_elapsed(struct dns_clock *clk) {
	time_t curtime;

	if ((time_t)-1 == time(&curtime))
		return clk->elapsed;

	if (curtime > clk->sample)
		clk->elapsed += (time_t)DNS_PP_MIN(difftime(curtime, clk->sample), DNS_MAXINTERVAL);

	clk->sample = curtime;

	return clk->elapsed;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rdi
callq 0xfc20
cmpq $-0x1, %rax
je 0x2ec8c
movq (%rsp), %r14
movq (%rbx), %rsi
cmpq %rsi, %r14
jle 0x2ec89
movq %r14, %rdi
callq 0xf640
minsd 0xa030(%rip), %xmm0     # 0x38cb0
cvttsd2si %xmm0, %rax
addq %rax, 0x8(%rbx)
movq %r14, (%rbx)
movq 0x8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_so_closefds
static void dns_so_closefds(struct dns_socket *so, int which) {
	if (DNS_SO_CLOSE_UDP & which)
		dns_socketclose(&so->udp, &so->opts);
	if (DNS_SO_CLOSE_TCP & which)
		dns_socketclose(&so->tcp, &so->opts);
	if (DNS_SO_CLOSE_OLD & which) {
		unsigned i;
		for (i = 0; i < so->onum; i++)
			dns_socketclose(&so->old[i], &so->opts);
		so->onum = 0;
		free(so->old);
		so->old  = 0;
		so->olim = 0;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testb $0x1, %bpl
je 0x2ecbd
leaq 0x18(%rbx), %rdi
movq %rbx, %rsi
callq 0x33898
testb $0x2, %bpl
je 0x2eccf
leaq 0x1c(%rbx), %rdi
movq %rbx, %rsi
callq 0x33898
cmpl $0x0, 0x28(%rbx)
je 0x2ecf9
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rdi
addq %r14, %rdi
movq %rbx, %rsi
callq 0x33898
incq %r15
movl 0x28(%rbx), %eax
addq $0x4, %r14
cmpq %rax, %r15
jb 0x2ecdb
xorl %ebp, %ebp
movl %ebp, 0x28(%rbx)
movq 0x20(%rbx), %rdi
callq 0xff30
movq $0x0, 0x20(%rbx)
movl %ebp, 0x2c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_so_pollfd
int dns_so_pollfd(struct dns_socket *so) {
	switch (so->state) {
	case DNS_SO_UDP_CONN:
	case DNS_SO_UDP_SEND:
	case DNS_SO_UDP_RECV:
		return so->udp;
	case DNS_SO_TCP_CONN:
	case DNS_SO_TCP_SEND:
	case DNS_SO_TCP_RECV:
		return so->tcp;
	} /* switch() */

	return -1;
}

// Assembly:
movl 0x1b0(%rdi), %eax
leal -0x7(%rax), %ecx
cmpl $0x3, %ecx
jb 0x2ed76
addl $-0x2, %eax
cmpl $0x2, %eax
ja 0x2ed7a
movl 0x18(%rdi), %eax
retq
movl 0x1c(%rdi), %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_poll
static int dns_poll(int fd, short events, int timeout) {
	fd_set rset, wset;

	if (!events)
		return 0;

	assert(fd >= 0 && (unsigned)fd < FD_SETSIZE);

	FD_ZERO(&rset);
	FD_ZERO(&wset);

	if (events & DNS_POLLIN)
		FD_SET(fd, &rset);

	if (events & DNS_POLLOUT)
		FD_SET(fd, &wset);

	select(fd + 1, &rset, &wset, 0, (timeout >= 0)? &(struct timeval){ timeout, 0 } : NULL);

	return 0;
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
testw %si, %si
je 0x2eeba
cmpl $0x3ff, %edi            # imm = 0x3FF
ja 0x2eec2
xorps %xmm0, %xmm0
movaps %xmm0, 0xf0(%rsp)
movaps %xmm0, 0xe0(%rsp)
movaps %xmm0, 0xd0(%rsp)
movaps %xmm0, 0xc0(%rsp)
movaps %xmm0, 0xb0(%rsp)
movaps %xmm0, 0xa0(%rsp)
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x70(%rsp)
movzwl %si, %eax
testb $0x1, %al
je 0x2ee71
movl $0x1, %esi
movl %edi, %ecx
shlq %cl, %rsi
movl %edi, %ecx
shrl $0x6, %ecx
orq %rsi, 0x80(%rsp,%rcx,8)
testb $0x4, %al
je 0x2ee88
movl $0x1, %eax
movl %edi, %ecx
shlq %cl, %rax
movl %edi, %ecx
shrl $0x6, %ecx
orq %rax, (%rsp,%rcx,8)
incl %edi
testl %edx, %edx
js 0x2eea5
movl %edx, %eax
leaq 0x108(%rsp), %r8
movq %rax, (%r8)
movq $0x0, 0x8(%r8)
jmp 0x2eea8
xorl %r8d, %r8d
leaq 0x80(%rsp), %rsi
movq %rsp, %rdx
xorl %ecx, %ecx
callq 0xfc60
addq $0x118, %rsp            # imm = 0x118
retq
leaq 0xa582(%rip), %rdi      # 0x3944b
leaq 0x9fed(%rip), %rsi      # 0x38ebd
leaq 0xa599(%rip), %rcx      # 0x39470
movl $0x452, %edx            # imm = 0x452
callq 0xf890
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_res_open
struct dns_resolver *dns_res_open(struct dns_resolv_conf *resconf, struct dns_hosts *hosts, struct dns_hints *hints, struct dns_cache *cache, const struct dns_options *opts, int *_error) {
	static const struct dns_resolver R_initializer
		= { .refcount = 1, };
	struct dns_resolver *R	= 0;
	int type, error;

	/*
	 * Grab ref count early because the caller may have passed us a mortal
	 * reference, and we want to do the right thing if we return early
	 * from an error.
	 */
	if (resconf)
		dns_resconf_acquire(resconf);
	if (hosts)
		dns_hosts_acquire(hosts);
	if (hints)
		dns_hints_acquire(hints);
	if (cache)
		dns_cache_acquire(cache);

	/*
	 * Don't try to load it ourselves because a NULL object might be an
	 * error from, say, dns_resconf_root(), and loading
	 * dns_resconf_local() by default would create undesirable surpises.
	 */
	if (!resconf || !hosts || !hints) {
		if (!*_error)
			*_error = EINVAL;
		goto _error;
	}

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

	*R	= R_initializer;
	type	= dns_res_tcp2type(resconf->options.tcp);

	if (!dns_so_init(&R->so, (struct sockaddr *)&resconf->iface, type, opts, &error))
		goto error;

	R->resconf	= resconf;
	R->hosts	= hosts;
	R->hints	= hints;
	R->cache	= cache;

	return R;
syerr:
	error	= dns_syerr();
error:
	*_error	= error;
_error:
	dns_res_close(R);

	dns_resconf_close(resconf);
	dns_hosts_close(hosts);
	dns_hints_close(hints);
	dns_cache_close(cache);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r13
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
testq %rdi, %rdi
je 0x2ef14
lock
incq 0x648(%r12)
testq %r15, %r15
je 0x2ef1e
lock
incq 0x10(%r15)
testq %r14, %r14
je 0x2ef27
lock
incq (%r14)
testq %rbx, %rbx
je 0x2ef31
lock
incq 0x68(%rbx)
testq %r14, %r14
setne %al
testq %r15, %r15
setne %cl
testq %r12, %r12
setne %dl
andb %cl, %dl
testb %al, %dl
je 0x2efcd
movq %r8, 0x10(%rsp)
movl $0xd38, %edi            # imm = 0xD38
callq 0x10110
movq %rax, %rbp
testq %rax, %rax
je 0x2efdd
leaq 0x8905(%rip), %rsi      # 0x37870
movl $0xd38, %edx            # imm = 0xD38
movq %rbp, %rdi
callq 0xfa60
movl 0x5c4(%r12), %eax
xorl %edx, %edx
cmpl $0x2, %eax
sete %dl
addl %edx, %edx
cmpl $0x1, %eax
cmovel %eax, %edx
leaq 0x5c8(%r12), %rsi
leaq 0xc(%rsp), %r8
movq %rbp, %rdi
movq 0x10(%rsp), %rcx
callq 0x2de4c
testq %rax, %rax
je 0x2efe8
movq %r12, 0x300(%rbp)
movq %r15, 0x308(%rbp)
movq %r14, 0x310(%rbp)
movq %rbx, 0x318(%rbp)
jmp 0x2f038
xorl %ebp, %ebp
cmpl $0x0, (%r13)
jne 0x2eff0
movl $0x16, %eax
jmp 0x2efec
callq 0xf0a0
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, (%r13)
movq %rbp, %rdi
callq 0xfde0
testq %r12, %r12
je 0x2f01b
movq $-0x1, %rax
lock
xaddq %rax, 0x648(%r12)
cmpl $0x1, %eax
jne 0x2f01b
movq %r12, %rdi
callq 0xff30
movq %r15, %rdi
callq 0x10730
movq %r14, %rdi
callq 0xfba0
testq %rbx, %rbx
je 0x2f036
movq %rbx, %rdi
callq *0x10(%rbx)
xorl %ebp, %ebp
movq %rbp, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_res_close
void dns_res_close(struct dns_resolver *R) {
	if (!R || 1 < dns_res_release(R))
		return;

	dns_res_reset(R);

	dns_so_destroy(&R->so);

	dns_hints_close(R->hints);
	dns_hosts_close(R->hosts);
	dns_resconf_close(R->resconf);
	dns_cache_close(R->cache);

	free(R);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x2f06a
movq %rdi, %rbx
movq $-0x1, %rax
lock
xaddq %rax, 0x320(%rdi)
testl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
je 0x2f06c
popq %rbx
retq
movq %rbx, %rdi
callq 0xfb10
movq 0x2e8(%rbx), %rdi
callq 0xff30
leaq 0x1b0(%rbx), %rdi
movl $0x150, %edx            # imm = 0x150
xorl %esi, %esi
callq 0xf750
movq %rbx, %rdi
movl $0x7, %esi
callq 0x2ec9f
movq 0x310(%rbx), %rdi
callq 0xfba0
movq 0x308(%rbx), %rdi
callq 0x10730
movq 0x300(%rbx), %rdi
testq %rdi, %rdi
je 0x2f0de
movq $-0x1, %rax
lock
xaddq %rax, 0x648(%rdi)
cmpl $0x1, %eax
jne 0x2f0de
callq 0xff30
movq 0x318(%rbx), %rdi
testq %rdi, %rdi
je 0x2f0ed
callq *0x10(%rdi)
movq %rbx, %rdi
popq %rbx
jmp 0xff30
// File: /workspace/github_c_makefile_star2_O1/wahern[P]cqueues/src/lib/dns.c
// Function: dns_res_stub
struct dns_resolver *dns_res_stub(const struct dns_options *opts, int *error) {
	struct dns_resolv_conf *resconf	= 0;
	struct dns_hosts *hosts		= 0;
	struct dns_hints *hints		= 0;
	struct dns_resolver *res	= 0;

	if (!(resconf = dns_resconf_local(error)))
		goto epilog;

	if (!(hosts = dns_hosts_local(error)))
		goto epilog;

	if (!(hints = dns_hints_local(resconf, error)))
		goto epilog;

	if (!(res = dns_res_open(resconf, hosts, hints, NULL, opts, error)))
		goto epilog;

epilog:
	dns_resconf_close(resconf);
	dns_hosts_close(hosts);
	dns_hints_close(hints);

	return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
callq 0xf2d0
movq %rax, %rbx
testq %rax, %rax
je 0x2f153
movq %r12, %rdi
callq 0x10210
testq %rax, %rax
je 0x2f153
movq %rax, %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf240
testq %rax, %rax
je 0x2f156
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
movq %r13, %r8
movq %r12, %r9
callq 0xf960
movq %rax, %r12
jmp 0x2f15c
xorl %r14d, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
testq %rbx, %rbx
je 0x2f17e
movq $-0x1, %rax
lock
xaddq %rax, 0x648(%rbx)
cmpl $0x1, %eax
jne 0x2f17e
movq %rbx, %rdi
callq 0xff30
movq %r14, %rdi
callq 0x10730
movq %r15, %rdi
callq 0xfba0
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq