LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl $0x650, %edi            # imm = 0x650
callq 0x101a0
movq %rax, %rbx
testq %rax, %rax
je 0x277f0
movq %rax, %r14
leaq 0xa4fc(%rip), %rsi      # 0x31cc0
movl $0x650, %edx            # imm = 0x650
movq %rbx, %rdi
callq 0xfad0
movq $0x35000002, (%rbx)     # imm = 0x35000002
addq $0x180, %r14            # imm = 0x180
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
callq 0x104d0
testl %eax, %eax
je 0x27806
callq 0xf0a0
movl (%rax), %eax
movl %eax, (%r15)
movq %rbx, %rdi
callq 0xffc0
xorl %ebx, %ebx
jmp 0x27846
movq %r14, %rdi
callq 0xf580
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movq %r14, %rdx
movq %rax, %rcx
callq 0xfbe0
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movq %r14, %rdx
movq %rax, %rcx
callq 0x105a0
cmpq $0x1, %rax
jne 0x2783e
movb $0x0, (%r14)
lock
incq 0x648(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x273b4
testq %rax, %rax
je 0x27932
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10ae0
movq %r14, %rdi
callq 0xfd70
xorl %eax, %eax
jmp 0x27936
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x273b4
testq %rax, %rax
je 0x27974
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf810
movq %r14, %rdi
callq 0xfd70
xorl %eax, %eax
jmp 0x27978
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_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 0xf2e0
testq %rax, %rax
je 0x27992
movb $0x1, 0x5c1(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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)
pushq $0x2
popq %rbp
leaq 0x7f(%rsp), %rax
pushq $0xa
popq %rcx
incq %r14
movzbl -0x1(%r14), %edx
cmpl $0x9, %edx
je 0x279e0
cmpl $0x20, %edx
je 0x279e0
cmpl $0x5b, %edx
je 0x279e0
testl %edx, %edx
je 0x27a26
cmpl $0x3a, %edx
je 0x27a07
cmpl $0x5d, %edx
je 0x27a39
jmp 0x27a09
movl %ecx, %ebp
movq 0x80(%rsp), %rsi
cmpq %rax, %rsi
jae 0x279e0
leaq 0x1(%rsi), %rdi
movq %rdi, 0x80(%rsp)
movb %dl, (%rsi)
jmp 0x279e0
xorl %r15d, %r15d
cmpl $0x2, %ebp
je 0x27a69
cmpl $0xa, %ebp
jne 0x27a6f
leaq 0x8(%rbx), %rdx
jmp 0x27a71
xorl %r15d, %r15d
movsbl (%r14), %eax
testw %ax, %ax
je 0x27a29
movswl %ax, %r12d
incq %r14
movzbl %al, %edi
callq 0x27abb
imull $0xa, %r15d, %ecx
addl %r12d, %ecx
addl $-0x30, %ecx
testb %al, %al
cmovel %r15d, %ecx
movl %ecx, %r15d
jmp 0x27a3c
leaq 0x4(%rbx), %rdx
jmp 0x27a71
xorl %edx, %edx
movq %rsp, %rsi
movl %ebp, %edi
callq 0x27ad3
testl %eax, %eax
jne 0x27aab
testw %r15w, %r15w
pushq $0x35
popq %rcx
cmovnel %r15d, %ecx
rolw $0x8, %cx
cmpl $0x2, %ebp
je 0x27a98
cmpl $0xa, %ebp
jne 0x27a9e
leaq 0x2(%rbx), %rdx
jmp 0x27aa5
leaq 0x1ec1b(%rip), %rdx     # 0x466c0
movw %cx, (%rdx)
movw %bp, (%rbx)
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_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 0x10a40
cmpl $0x1, %eax
je 0x27aec
cmpl $-0x1, %eax
jne 0x27af0
callq 0xf0a0
movl (%rax), %eax
jmp 0x27af5
xorl %eax, %eax
jmp 0x27af5
movl $0x9b918cc5, %eax       # imm = 0x9B918CC5
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1cb75(%rip), %r15     # 0x44ac0
xorl %r14d, %r14d
movl $0x87000, %r12d         # imm = 0x87000
cmpq $0x1a, %r14
je 0x27f78
btq %r14, %r12
jb 0x27f6f
movq (%r15), %rdi
movq %rbx, %rsi
callq 0xfed0
testl %eax, %eax
je 0x27fe6
incq %r14
addq $0x8, %r15
jmp 0x27f54
leaq 0xc3f8(%rip), %rsi      # 0x34377
pushq $0x6
popq %rdx
movq %rbx, %rdi
callq 0x100e0
testl %eax, %eax
je 0x27fda
leaq 0xc3e9(%rip), %rsi      # 0x3437e
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x100e0
testl %eax, %eax
je 0x27fde
leaq 0xc3dc(%rip), %rsi      # 0x34387
pushq $0x9
popq %rdx
movq %rbx, %rdi
callq 0x100e0
testl %eax, %eax
je 0x27fe2
leaq 0xc3d0(%rip), %rsi      # 0x34391
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x100e0
xorl %r14d, %r14d
negl %eax
sbbl %r14d, %r14d
orl $0x13, %r14d
jmp 0x27fe6
pushq $0xc
jmp 0x27fe4
pushq $0xd
jmp 0x27fe4
pushq $0xe
popq %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_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
pushq $0x3a
popq %rsi
movq %r15, %rdi
callq 0xf500
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 0x27ad3
testl %eax, %eax
jne 0x2804c
rolw $0x8, %bp
movw %bp, 0x5ca(%rbx)
movw %r14w, 0x5c8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_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, %r14
movq %rdi, %r15
xorl %ebx, %ebx
movq %r14, %rdi
callq 0xf370
cmpl $-0x1, %eax
je 0x2834d
movl %eax, %ebp
movq %r15, %rdi
movl %eax, %esi
callq 0x2e082
testb %al, %al
je 0x28343
incq %rbx
jmp 0x28321
movl %ebp, %edi
movq %r14, %rsi
callq 0xf1b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_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
leaq 0x484(%rdi), %r14
leaq 0xbc72(%rip), %r13      # 0x33fef
movq %r12, %rdi
callq 0xf370
cmpl $-0x1, %eax
je 0x283c3
movl %eax, %ebp
movq %r13, %rdi
movl %eax, %esi
callq 0x2e082
testb %al, %al
je 0x283b9
movq 0x490(%r15), %rax
cmpq %r14, %rax
jae 0x28421
leaq 0x1(%rax), %rcx
movq %rcx, 0x490(%r15)
movb %bpl, (%rax)
andl $0x0, (%rbx)
jmp 0x2837d
movl %ebp, %edi
movq %r12, %rsi
callq 0xf1b0
movq 0x490(%r15), %rax
movq %rax, %rsi
subq 0x488(%r15), %rsi
je 0x2842d
cmpq %r14, %rax
jae 0x28426
cmpl $0xf, 0x80(%r15)
ja 0x28426
leaq 0x1(%rax), %rcx
movq %rcx, 0x490(%r15)
movb $0x0, (%rax)
movq 0x488(%r15), %rax
movl 0x80(%r15), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x80(%r15)
movq %rax, (%r15,%rcx,8)
movq 0x490(%r15), %rax
movq %rax, 0x488(%r15)
xorl %eax, %eax
jmp 0x28431
pushq $0xc
popq %rax
jmp 0x2842f
xorl %esi, %esi
pushq $0xc
popq %rax
jmp 0x28431
xorl %eax, %eax
xorl %esi, %esi
movl %eax, (%rbx)
movq %rsi, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_nssconf_keyword
static enum dns_nssconf_keyword dns_nssconf_keyword(const char *word) {
	static const char *list[] = {
		[DNS_NSSCONF_HOSTS]    = "hosts",
		[DNS_NSSCONF_SUCCESS]  = "success",
		[DNS_NSSCONF_NOTFOUND] = "notfound",
		[DNS_NSSCONF_UNAVAIL]  = "unavail",
		[DNS_NSSCONF_TRYAGAIN] = "tryagain",
		[DNS_NSSCONF_CONTINUE] = "continue",
		[DNS_NSSCONF_RETURN]   = "return",
		[DNS_NSSCONF_FILES]    = "files",
		[DNS_NSSCONF_DNS]      = "dns",
		[DNS_NSSCONF_MDNS]     = "mdns",
	};
	unsigned i;

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

	return DNS_NSSCONF_INVALID;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x1
popq %rbx
leaq 0x1c739(%rip), %r15     # 0x44b90
cmpq $0xb, %rbx
je 0x28472
movq (%r15,%rbx,8), %rdi
movq %r14, %rsi
callq 0xfed0
testl %eax, %eax
je 0x28474
incq %rbx
jmp 0x28457
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_anyconf_pop
static void dns_anyconf_pop(struct dns_anyconf *cf) {
	if (cf->count > 0) {
		--cf->count;
		cf->tp = cf->cp = cf->token[cf->count];
		cf->token[cf->count] = 0;
	}
}

// Assembly:
movl 0x80(%rdi), %eax
testl %eax, %eax
je 0x284a5
decl %eax
movl %eax, 0x80(%rdi)
movq (%rdi,%rax,8), %rcx
movq %rcx, 0x490(%rdi)
movq %rcx, 0x488(%rdi)
andq $0x0, (%rdi,%rax,8)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rsi, %rbx
movq %rdi, %r14
leaq 0xbb4c(%rip), %rdi      # 0x3400d
callq 0xff30
pushq $0x6
popq %rax
leaq 0xb250(%rip), %r15      # 0x33720
leaq 0x10(%rsp), %rdi
leaq 0x9688(%rip), %r12      # 0x31b64
leaq 0xc(%rsp), %r8
leaq 0x8(%rsp), %r9
leaq 0x4(%rsp), %r10
leaq 0xbb09(%rip), %r11      # 0x33ffb
leaq 0x1c6f7(%rip), %r13     # 0x44bf0
xorl %ebp, %ebp
movl $0x7, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movl %eax, 0x8(%rsp)
movl %eax, 0x4(%rsp)
movl %ebp, %ecx
cmpq $0x23, %rcx
ja 0x28670
movsbq 0x580(%r14,%rcx), %rdx
testq %rdx, %rdx
je 0x28670
xorl %eax, %eax
cmpb $0x6d, %dl
ja 0x28539
movsbl (%rdx,%r15), %eax
incq %rcx
leal -0x8(%rax), %edx
cmpl $0x2, %edx
ja 0x28511
movl %ecx, %ebp
cmpq $0x23, %rbp
ja 0x285b7
je 0x285b7
movb 0x580(%r14,%rbp), %sil
testb %sil, %sil
je 0x285b7
movsbq 0x581(%r14,%rbp), %rcx
testq %rcx, %rcx
je 0x285b7
xorl %edx, %edx
cmpb $0x6d, %sil
ja 0x2857a
movsbq %sil, %rdx
movsbl (%rdx,%r15), %edx
cmpb $0x6d, %cl
ja 0x285b7
movsbl (%rcx,%r15), %ecx
movl %ecx, %esi
andl $-0x2, %esi
cmpl $0x6, %esi
jne 0x285b7
addl $-0x2, %edx
cmpl $0x3, %edx
ja 0x285b7
movslq (%r12,%rdx,4), %rsi
addq %r12, %rsi
movq %rdi, %rdx
jmpq *%rsi
movq %r8, %rdx
jmp 0x285af
movq %r9, %rdx
jmp 0x285af
movq %r10, %rdx
movl %ecx, (%rdx)
addq $0x2, %rbp
jmp 0x28546
testl %eax, %eax
je 0x28670
andl $0x0, 0x14(%rsp)
leal -0xb(%rax), %ecx
movq %r11, %rdx
cmpl $-0x9, %ecx
jb 0x285d6
movl %eax, %eax
movq (%r13,%rax,8), %rdx
movq %rbx, %rdi
leaq 0x896c(%rip), %rsi      # 0x30f4c
xorl %eax, %eax
callq 0x10380
movl 0x10(%rsp), %esi
pushq $0x2
popq %rdi
leaq 0x14(%rsp), %r13
movq %r13, %rdx
movq %rbx, %rcx
callq 0x2868c
movl 0xc(%rsp), %esi
pushq $0x3
popq %rdi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x2868c
movl 0x8(%rsp), %esi
pushq $0x4
popq %rdi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x2868c
movl 0x4(%rsp), %esi
pushq $0x5
popq %rdi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x2868c
cmpl $0x0, 0x14(%rsp)
pushq $0x5d
popq %rdi
je 0x28646
movq %rbx, %rsi
callq 0x10090
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %r8
leaq 0x8(%rsp), %r9
leaq 0x4(%rsp), %r10
leaq 0xb99a(%rip), %r11      # 0x33ffb
pushq $0x6
popq %rax
leaq 0x1c585(%rip), %r13     # 0x44bf0
jmp 0x284fb
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x10090
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_O2/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 0x286ad
cmpl $0x7, %r15d
jne 0x286b3
jmp 0x2871a
cmpl $0x6, %r15d
je 0x2871a
pushq $0x20
popq %rdi
movq %r14, %rsi
callq 0x10090
cmpl $0x0, (%rbx)
jne 0x286ce
pushq $0x5b
popq %rdi
movq %r14, %rsi
callq 0x10090
leal -0xb(%r12), %eax
leaq 0xb921(%rip), %rcx      # 0x33ffb
movq %rcx, %rdx
cmpl $-0x9, %eax
jb 0x286f0
movl %r12d, %eax
leaq 0x1c504(%rip), %rdx     # 0x44bf0
movq (%rdx,%rax,8), %rdx
leal -0xb(%r15), %eax
cmpl $-0x9, %eax
jb 0x28707
movl %r15d, %eax
leaq 0x1c4ed(%rip), %rcx     # 0x44bf0
movq (%rcx,%rax,8), %rcx
leaq 0xbce7(%rip), %rsi      # 0x343f5
movq %r14, %rdi
xorl %eax, %eax
callq 0x10380
incl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_hints_open
struct dns_hints *dns_hints_open(struct dns_resolv_conf *resconf, int *error) {
	static const struct dns_hints H_initializer;
	struct dns_hints *H;

	(void)resconf;

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

	*H	= H_initializer;

	dns_hints_acquire(H);

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

	free(H);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0xf8f0
movq %rax, %r14
testq %rax, %rax
je 0x28d50
lock
incq (%r14)
jmp 0x28d59
callq 0xf0a0
movl (%rax), %eax
movl %eax, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x28da2
movq %rdi, %rbx
pushq $-0x1
popq %rax
lock
xaddq %rax, (%rdi)
cmpl $0x1, %eax
jne 0x28da2
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x28daa
movq 0x988(%rdi), %r14
callq 0xffc0
movq %r14, %rdi
jmp 0x28d8c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xffc0
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
testq %rdi, %rdi
je 0x28def
movq %rdi, %r14
lock
incq 0x648(%rdi)
jmp 0x28e01
leaq 0xc(%rsp), %rdi
callq 0xf2e0
movq %rax, %r14
testq %rax, %rax
je 0x28e42
leaq 0xc(%rsp), %rsi
callq 0xf030
testq %rax, %rax
je 0x28e45
movq %rax, %r15
leaq 0xc(%rsp), %rcx
andl $0x0, (%rcx)
leaq 0xb0e1(%rip), %rsi      # 0x33f03
movq %rax, %rdi
movq %r14, %rdx
callq 0xf8c0
testl %eax, %eax
jne 0x28e38
cmpl $0x0, 0xc(%rsp)
jne 0x28e48
movq %r14, %rdi
callq 0xff70
jmp 0x28e61
xorl %r14d, %r14d
xorl %r15d, %r15d
movl 0xc(%rsp), %eax
movl %eax, (%rbx)
movq %r14, %rdi
callq 0xff70
movq %r15, %rdi
callq 0xfc20
xorl %r15d, %r15d
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_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, %rbx
movq %rsi, %r12
movq %rdi, %r13
pushq $0x1
popq %rbp
xorl %r14d, %r14d
movq %rdx, %r15
cmpq $0x3, %r14
je 0x28ef8
movzwl (%r15), %eax
testw %ax, %ax
je 0x28ef8
movq %r15, %rdx
cmpw $0x2, %ax
jne 0x28ecb
cmpl $0x0, 0x4(%r15)
movq %r15, %rdx
jne 0x28ecb
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 0xf980
testl %eax, %eax
jne 0x28ef1
movzbl 0x5c0(%rbx), %eax
xorl $0x1, %eax
addl %eax, %ebp
incq %r14
subq $-0x80, %r15
jmp 0x28e93
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
callq 0x290c8
movq %rax, %r15
testq %rax, %rax
jne 0x2905a
pushq $0x1
popq %rdi
movl $0x990, %esi            # imm = 0x990
callq 0xf8f0
testq %rax, %rax
je 0x290b7
movq %rax, %r15
movl $0x100, %edx            # imm = 0x100
movq %rax, %rdi
movq %r13, %rsi
callq 0xf4f0
movq 0x8(%r12), %rax
movq %rax, 0x988(%r15)
movq %r15, 0x8(%r12)
movl 0x980(%r15), %eax
andl $0xf, %eax
imulq $0x88, %rax, %rax
leaq (%r15,%rax), %r12
addq $0x100, %r12            # imm = 0x100
movzwl (%r14), %eax
leaq 0xa70f(%rip), %rcx      # 0x33790
movq (%rcx,%rax,8), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0xfad0
cmpl $0x1, %ebx
adcl $0x0, %ebx
movl %ebx, 0x80(%r12)
movl 0x980(%r15), %ecx
xorl %eax, %eax
cmpl $0xf, %ecx
ja 0x290be
incl %ecx
movl %ecx, 0x980(%r15)
jmp 0x290be
callq 0xf0a0
movl (%rax), %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_hints_fetch
static struct dns_hints_soa *dns_hints_fetch(struct dns_hints *H, const char *zone) {
	struct dns_hints_soa *soa;

	for (soa = H->head; soa; soa = soa->next) {
		if (0 == strcasecmp(zone, (char *)soa->zone))
			return soa;
	}

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x290f6
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfed0
testl %eax, %eax
je 0x290f6
addq $0x988, %rbx            # imm = 0x988
jmp 0x290d6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq (%rcx), %rsi
movq %r8, %rdi
callq 0x290c8
testq %rax, %rax
je 0x2922b
movq %rax, %r13
movq %r15, 0x10(%rsp)
addq $0x100, %rax            # imm = 0x100
movq %rax, 0x18(%rsp)
movl 0x8(%rbx), %r15d
movl 0x980(%r13), %r12d
movl $0x0, 0x8(%rsp)
movl %ebp, 0xc(%rsp)
cmpl %r12d, %r15d
jae 0x2922f
movl 0x8(%rsp), %eax
cmpl %ebp, %eax
jae 0x29233
movl %r15d, %ecx
imulq $0x88, %rcx, %rsi
movq 0x18(%rsp), %rdi
leaq (%rdi,%rsi), %rcx
movq 0x10(%rsp), %rdx
movq %rcx, (%rdx)
movzwl (%rdi,%rsi), %ecx
leaq 0xa5fd(%rip), %rsi      # 0x33790
movl (%rsi,%rcx,8), %ecx
movl %ecx, (%r14)
addq $0x8, %rdx
movq %rdx, 0x10(%rsp)
addq $0x4, %r14
movq %r14, 0x20(%rsp)
incl %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rbx), %r14d
movl 0x980(%r13), %r12d
xorl %r15d, %r15d
cmpl %r15d, %r12d
je 0x291de
movl %r15d, %edi
movl %r14d, %esi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x2e124
testl %eax, %eax
jg 0x291e3
incl %r15d
jmp 0x291bf
movl %r12d, %r15d
jmp 0x2921d
movl %r15d, %ebp
incl %ebp
cmpl %r12d, %ebp
jae 0x29219
movl %ebp, %edi
movl %r14d, %esi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x2e124
testl %eax, %eax
jle 0x291e6
movl %ebp, %edi
movl %r15d, %esi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x2e124
testl %eax, %eax
cmovsl %ebp, %r15d
jmp 0x291e6
movl 0xc(%rsp), %ebp
movl %r15d, 0x8(%rbx)
movq 0x20(%rsp), %r14
jmp 0x29158
xorl %eax, %eax
jmp 0x29233
movl 0x8(%rsp), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_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 %rdi, %r14
addq $0x8, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x295ef
movq 0x8(%rsp), %rdi
leaq 0xabaa(%rip), %rsi      # 0x340c6
movq %r14, %rdx
xorl %eax, %eax
callq 0x10380
leaq 0x100(%r14), %rbp
leaq 0x180(%r14), %r13
xorl %r12d, %r12d
movl 0x980(%r14), %eax
cmpq %rax, %r12
jae 0x295e3
imulq $0x88, %r12, %rbx
addq %rbp, %rbx
movzwl -0x80(%r13), %r15d
cmpl $0x2, %r15d
je 0x29568
cmpl $0xa, %r15d
jne 0x2956e
leaq -0x78(%r13), %rsi
jmp 0x29570
leaq 0x4(%rbx), %rsi
jmp 0x29570
xorl %esi, %esi
movl %r15d, %edi
leaq 0x10(%rsp), %rdx
pushq $0x2e
popq %rcx
callq 0xfe30
testq %rax, %rax
jne 0x29590
callq 0xf0a0
movl (%rax), %eax
testl %eax, %eax
jne 0x295f1
cmpl $0x2, %r15d
je 0x295a9
leaq 0x1d123(%rip), %rbx     # 0x466c0
cmpl $0xa, %r15d
jne 0x295ad
leaq -0x7e(%r13), %rbx
jmp 0x295ad
addq $0x2, %rbx
movl (%r13), %edx
movzwl (%rbx), %eax
rolw $0x8, %ax
movzwl %ax, %r8d
movq 0x8(%rsp), %rdi
leaq 0xab09(%rip), %rsi      # 0x340d1
leaq 0x10(%rsp), %rcx
xorl %eax, %eax
callq 0x10380
incq %r12
addq $0x88, %r13
jmp 0x29537
addq $0x988, %r14            # imm = 0x988
jmp 0x29504
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_O2/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 0x101a0
movq %rax, %rbx
testq %rax, %rax
je 0x29685
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x296a5
testq %rax, %rax
jne 0x29699
jmp 0x2968f
callq 0xf0a0
movl (%rax), %eax
movl %eax, (%r14)
movq %rbx, %rdi
callq 0xf6e0
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_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 0xa23a(%rip), %rsi      # 0x33900
movl $0x300, %edx            # imm = 0x300
callq 0xfad0
movl %ebp, 0x30(%rbx)
testq %r12, %r12
je 0x296e9
movq 0x10(%r12), %rax
movq %rax, 0x10(%rbx)
movups (%r12), %xmm0
movups %xmm0, (%rbx)
testq %r15, %r15
je 0x29709
leaq 0x38(%rbx), %rdi
movzwl (%r15), %eax
leaq 0xa093(%rip), %rcx      # 0x33790
movq (%rcx,%rax,8), %rdx
movq %r15, %rsi
callq 0xfad0
leaq 0x38(%rbx), %rdi
pushq $0x2
popq %rsi
movq %r14, %rdx
callq 0x2a135
movl %eax, 0x18(%rbx)
cmpl $-0x1, %eax
je 0x2976e
movaps 0xa509(%rip), %xmm0     # 0x33c30
movups %xmm0, 0x138(%rbx)
movabsq $0x8000000ff, %rax      # imm = 0x8000000FF
movq %rax, 0x148(%rbx)
xorl %r14d, %r14d
cmpq $0x4, %r14
je 0x29757
callq *0x1cbf2(%rip)          # 0x46340
movl %eax, (%rsp,%r14,4)
incq %r14
jmp 0x29742
movaps (%rsp), %xmm0
movups %xmm0, 0x150(%rbx)
movl $0x20, 0x160(%rbx)
jmp 0x29778
movq %rbx, %rdi
callq 0x297a0
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_O2/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 0x2979f
pushq %rbx
movq %rdi, %rbx
callq 0x297a0
movq %rbx, %rdi
popq %rbx
jmp 0xffc0
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0xf100
leaq 0x10(%rsp), %rdi
pushq $0xc
popq %rsi
movq %r14, %rdx
callq 0xf750
movl %eax, %ebp
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x29962
movq %rbx, %rdi
callq 0xf100
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b6(%rbx), %rdi
movzwl 0x14(%rsp), %edx
leaq 0xc(%rsp), %r8
movl $0x100, %esi            # imm = 0x100
movq %r14, %rcx
callq 0xff50
movq %rax, 0x2b8(%rbx)
testq %rax, %rax
je 0x299c0
movq 0x18(%rsp), %rax
movq %rax, 0x2c0(%rbx)
movzwl 0x32(%r14), %eax
testw %ax, %ax
movl $0x300, %ecx            # imm = 0x300
cmovnel %eax, %ecx
movzwl %cx, %esi
movq %rbx, %rdi
callq 0x29a56
testl %eax, %eax
je 0x299c6
callq 0xf0a0
movl (%rax), %ebp
jmp 0x2994d
movl 0xc(%rsp), %ebp
jmp 0x2994d
leaq 0xb8(%rbx), %rdi
movzwl (%r15), %eax
leaq 0x9db8(%rip), %rcx      # 0x33790
movq (%rcx,%rax,8), %rdx
movq %r15, %rsi
callq 0xfad0
movq %r14, 0x2c8(%rbx)
andq $0x0, 0x2d0(%rbx)
leaq 0x2d8(%rbx), %rdi
callq 0x29aad
movq 0x2c8(%rbx), %rax
movzwl 0x5c(%rax), %eax
testq %rax, %rax
jne 0x29a2d
movq %rbx, %rdi
callq 0x103e0
movq 0x2c8(%rbx), %rcx
movw %ax, 0x5c(%rcx)
movq 0x2c8(%rbx), %rax
movq 0x5c(%rax), %rax
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)
xorl %ebp, %ebp
jmp 0x29955
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x301, %rsi            # imm = 0x301
movl $0x300, %r14d           # imm = 0x300
cmovaeq %rsi, %r14
addq $0x5c, %r14
movq 0x2e8(%rdi), %rdi
movq %r14, %rsi
callq 0x106d0
testq %rax, %rax
je 0x29aa0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x10b10
movq %r15, 0x2e8(%rbx)
xorl %eax, %eax
jmp 0x29aa7
callq 0xf0a0
movl (%rax), %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
orl $-0x1, 0x4(%rsp)
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 0x2a087
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
pushq $0xc
popq %rsi
callq 0xf750
testl %eax, %eax
jne 0x2a087
movl 0x10(%rsp), %eax
cmpl 0x2c0(%rbx), %eax
jne 0x2a087
movl 0x14(%rsp), %eax
cmpl 0x2c4(%rbx), %eax
jne 0x2a087
movzwl 0xc(%rsp), %edx
leaq 0x20(%rsp), %rdi
leaq 0x4(%rsp), %r8
movl $0x100, %esi            # imm = 0x100
movq %r14, %rcx
callq 0xff50
testq %rax, %rax
je 0x2a097
cmpq $0xff, %rax
ja 0x2a087
cmpq 0x2b8(%rbx), %rax
jne 0x2a087
addq $0x1b6, %rbx            # imm = 0x1B6
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xfed0
testl %eax, %eax
je 0x2a09d
movl $0x9b918cc4, %eax       # imm = 0x9B918CC4
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
retq
movl 0x4(%rsp), %eax
jmp 0x2a08c
xorl %eax, %eax
jmp 0x2a08c
// File: /workspace/github_c_makefile_star2_O2/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:
movl (%rsi), %ecx
cmpl $-0x1, %ecx
je 0x2a0e1
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2a0cf
movq (%r14), %rsi
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
jne 0x2a126
movl (%rbx), %ecx
cmpl $-0x1, %ecx
je 0x2a124
movl 0x28(%r14), %edx
movl 0x2c(%r14), %eax
cmpl %eax, %edx
jae 0x2a0e4
movq 0x20(%r14), %rax
jmp 0x2a115
xorl %eax, %eax
retq
addl %eax, %eax
cmpl $0x5, %eax
pushq $0x4
popq %r15
cmovael %eax, %r15d
movq 0x20(%r14), %rdi
leaq (,%r15,4), %rsi
callq 0x106d0
testq %rax, %rax
je 0x2a12c
movq %rax, 0x20(%r14)
movl %r15d, 0x2c(%r14)
movl (%rbx), %ecx
movl 0x28(%r14), %edx
leal 0x1(%rdx), %esi
movl %esi, 0x28(%r14)
movl %edx, %edx
movl %ecx, (%rax,%rdx,4)
orl $-0x1, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0xf0a0
movl (%rax), %eax
jmp 0x2a126
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rcx, %rbx
movq %rdi, %r14
cmpl $0x0, 0x1b0(%rdi)
je 0x2a2dc
movq %r14, %rdi
callq 0xf3f0
testl %eax, %eax
jne 0x2a2ec
movl 0x1b0(%r14), %ecx
cmpl $0xa, %ecx
je 0x2a2be
movl $0x9b918cc4, %eax       # imm = 0x9B918CC4
cmpl $0x5, %ecx
jne 0x2a2ec
movq 0x2e8(%r14), %r15
andq $0x0, 0x2e8(%r14)
testq %r15, %r15
je 0x2a2ea
movq %r14, %rdi
callq 0xf100
jmp 0x2a2f1
movq %r14, %rdi
callq 0x10480
testl %eax, %eax
jne 0x2a2ec
jmp 0x2a29c
xorl %eax, %eax
movl %eax, (%rbx)
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfca0
cmpq $-0x1, %rax
je 0x2a340
movq (%rsp), %r14
movq (%rbx), %rsi
cmpq %rsi, %r14
jle 0x2a33d
movq %r14, %rdi
callq 0xf680
minsd 0x992c(%rip), %xmm0     # 0x33c60
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_O2/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 0x2a36f
leaq 0x18(%rbx), %rdi
movq %rbx, %rsi
callq 0x2e1ba
testb $0x2, %bpl
je 0x2a381
leaq 0x1c(%rbx), %rdi
movq %rbx, %rsi
callq 0x2e1ba
xorl %r14d, %r14d
xorl %r15d, %r15d
movl 0x28(%rbx), %eax
cmpq %rax, %r15
jae 0x2a3a7
movq 0x20(%rbx), %rdi
addq %r14, %rdi
movq %rbx, %rsi
callq 0x2e1ba
incq %r15
addq $0x4, %r14
jmp 0x2a387
andl $0x0, 0x28(%rbx)
movq 0x20(%rbx), %rdi
callq 0xffc0
andq $0x0, 0x20(%rbx)
andl $0x0, 0x2c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wahern[P]cqueues/src/lib/dns.c
// Function: dns_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 0x2a421
addl $-0x2, %eax
cmpl $0x2, %eax
ja 0x2a425
movl 0x18(%rdi), %eax
retq
movl 0x1c(%rdi), %eax
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2a516
cmpl $0x3ff, %edi            # imm = 0x3FF
ja 0x2a51e
xorl %eax, %eax
cmpq $0x10, %rax
je 0x2a49f
andq $0x0, 0x98(%rsp,%rax,8)
incq %rax
jmp 0x2a48b
xorl %eax, %eax
cmpq $0x10, %rax
je 0x2a4b2
andq $0x0, 0x18(%rsp,%rax,8)
incq %rax
jmp 0x2a4a1
movzwl %si, %esi
pushq $0x1
popq %rax
testb $0x1, %sil
je 0x2a4d3
movq %rax, %r8
movl %edi, %ecx
shlq %cl, %r8
movl %edi, %ecx
shrl $0x6, %ecx
orq %r8, 0x98(%rsp,%rcx,8)
testb $0x4, %sil
je 0x2a4e8
movl %edi, %ecx
shlq %cl, %rax
movl %edi, %ecx
shrl $0x6, %ecx
orq %rax, 0x18(%rsp,%rcx,8)
incl %edi
testl %edx, %edx
js 0x2a4ff
movl %edx, %eax
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
andq $0x0, 0x8(%r8)
jmp 0x2a502
xorl %r8d, %r8d
leaq 0x98(%rsp), %rsi
leaq 0x18(%rsp), %rdx
xorl %ecx, %ecx
callq 0xfce0
addq $0x118, %rsp            # imm = 0x118
retq
leaq 0x9ed6(%rip), %rdi      # 0x343fb
leaq 0x9941(%rip), %rsi      # 0x33e6d
leaq 0x9eed(%rip), %rcx      # 0x34420
movl $0x452, %edx            # imm = 0x452
callq 0xf8e0
// File: /workspace/github_c_makefile_star2_O2/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 0x2a570
lock
incq 0x648(%r12)
testq %r15, %r15
je 0x2a57a
lock
incq 0x10(%r15)
testq %r14, %r14
je 0x2a583
lock
incq (%r14)
testq %rbx, %rbx
je 0x2a58d
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 0x2a629
movq %r8, 0x10(%rsp)
movl $0xd38, %edi            # imm = 0xD38
callq 0x101a0
movq %rax, %rbp
testq %rax, %rax
je 0x2a637
leaq 0x8259(%rip), %rsi      # 0x32820
movl $0xd38, %edx            # imm = 0xD38
movq %rbp, %rdi
callq 0xfad0
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 0x296a5
testq %rax, %rax
je 0x2a640
movq %r12, 0x300(%rbp)
movq %r15, 0x308(%rbp)
movq %r14, 0x310(%rbp)
movq %rbx, 0x318(%rbp)
jmp 0x2a675
xorl %ebp, %ebp
cmpl $0x0, (%r13)
jne 0x2a648
pushq $0x16
popq %rax
jmp 0x2a644
callq 0xf0a0
movl (%rax), %eax
jmp 0x2a644
movl 0xc(%rsp), %eax
movl %eax, (%r13)
movq %rbp, %rdi
callq 0xfe70
movq %r12, %rdi
callq 0xff70
movq %r15, %rdi
callq 0x107f0
movq %r14, %rdi
callq 0xfc20
testq %rbx, %rbx
je 0x2a673
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