LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movw %si, %ax
movl %edi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl %edx, -0x10(%rbp)
cmpw $0x0, -0xa(%rbp)
jne 0x3e62b
movl $0x0, -0x4(%rbp)
jmp 0x3e7eb
cmpl $0x0, -0x8(%rbp)
jl 0x3e63c
cmpl $0x400, -0x8(%rbp)      # imm = 0x400
jae 0x3e63c
jmp 0x3e65b
leaq 0xf33a(%rip), %rdi      # 0x4d97d
leaq 0xed93(%rip), %rsi      # 0x4d3dd
movl $0x452, %edx            # imm = 0x452
leaq 0xf34c(%rip), %rcx      # 0x4d9a2
callq 0xf920
jmp 0x3e65d
leaq -0x90(%rbp), %rax
movq %rax, -0x120(%rbp)
movl $0x0, -0x114(%rbp)
movl -0x114(%rbp), %eax
cmpq $0x10, %rax
jae 0x3e6a7
movq -0x120(%rbp), %rax
movl -0x114(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x114(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x114(%rbp)
jmp 0x3e675
jmp 0x3e6a9
jmp 0x3e6ab
leaq -0x110(%rbp), %rax
movq %rax, -0x130(%rbp)
movl $0x0, -0x124(%rbp)
movl -0x124(%rbp), %eax
cmpq $0x10, %rax
jae 0x3e6f5
movq -0x130(%rbp), %rax
movl -0x124(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x124(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x124(%rbp)
jmp 0x3e6c3
jmp 0x3e6f7
movswl -0xa(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3e73a
movl -0x8(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movl -0x8(%rbp), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0x90(%rbp,%rax,8), %rcx
movq %rcx, -0x90(%rbp,%rax,8)
movswl -0xa(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x3e77d
movl -0x8(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movl -0x8(%rbp), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0x110(%rbp,%rax,8), %rcx
movq %rcx, -0x110(%rbp,%rax,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x144(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x3e7b5
movslq -0x10(%rbp), %rax
movq %rax, -0x140(%rbp)
movq $0x0, -0x138(%rbp)
leaq -0x140(%rbp), %rax
movq %rax, -0x150(%rbp)
jmp 0x3e7c0
xorl %eax, %eax
movq %rax, -0x150(%rbp)
jmp 0x3e7c0
movl -0x144(%rbp), %edi
movq -0x150(%rbp), %r8
leaq -0x90(%rbp), %rsi
leaq -0x110(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xfd60
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_res_tcp2type
static int dns_res_tcp2type(int tcp) {
	switch (tcp) {
	case DNS_RESCONF_TCP_ONLY:
		return SOCK_STREAM;
	case DNS_RESCONF_TCP_DISABLE:
		return SOCK_DGRAM;
	default:
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x1, %eax
je 0x3e9de
jmp 0x3e9d4
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x3e9e7
jmp 0x3e9f0
movl $0x1, -0x4(%rbp)
jmp 0x3e9f7
movl $0x2, -0x4(%rbp)
jmp 0x3e9f7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3ea29
movq -0x8(%rbp), %rdi
callq 0x10bc0
movq %rax, %rcx
movl $0x1, %eax
cmpq %rcx, %rax
jae 0x3ea2b
jmp 0x3ea86
movq -0x8(%rbp), %rdi
callq 0xfbf0
movq -0x8(%rbp), %rdi
callq 0x3d170
movq -0x8(%rbp), %rax
movq 0x310(%rax), %rdi
callq 0xfc90
movq -0x8(%rbp), %rax
movq 0x308(%rax), %rdi
callq 0x108f0
movq -0x8(%rbp), %rax
movq 0x300(%rax), %rdi
callq 0xfff0
movq -0x8(%rbp), %rax
movq 0x318(%rax), %rdi
callq 0x10640
movq -0x8(%rbp), %rdi
callq 0x10060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf310
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x3ead5
jmp 0x3eb2e
movq -0x10(%rbp), %rdi
callq 0x10360
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x3eaea
jmp 0x3eb2e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf260
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x3eb03
jmp 0x3eb2e
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %r8
movq -0x10(%rbp), %r9
xorl %eax, %eax
movl %eax, %ecx
callq 0xf9f0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x3eb2c
jmp 0x3eb2e
jmp 0x3eb2e
movq -0x18(%rbp), %rdi
callq 0xfff0
movq -0x20(%rbp), %rdi
callq 0x108f0
movq -0x28(%rbp), %rdi
callq 0xfc90
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_res_reset
void dns_res_reset(struct dns_resolver *R) {
	unsigned i;

	dns_so_reset(&R->so);
	dns_p_setptr(&R->nodata, NULL);

	for (i = 0; i < lengthof(R->stack); i++)
		dns_res_frame_destroy(R, &R->stack[i]);

	memset(&R->qname, '\0', sizeof *R - offsetof(struct dns_resolver, qname));

	for (i = 0; i < lengthof(R->stack); i++)
		dns_res_frame_init(R, &R->stack[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf110
movq -0x8(%rbp), %rdi
addq $0x4a8, %rdi            # imm = 0x4A8
xorl %eax, %eax
movl %eax, %esi
callq 0x328c0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpq $0x8, %rax
jae 0x3ebc5
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x4b8, %rsi            # imm = 0x4B8
movl -0xc(%rbp), %eax
imulq $0x110, %rax, %rax      # imm = 0x110
addq %rax, %rsi
callq 0x3ec20
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3eb90
movq -0x8(%rbp), %rdi
addq $0x328, %rdi            # imm = 0x328
xorl %esi, %esi
movl $0xa10, %edx            # imm = 0xA10
callq 0xf7d0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpq $0x8, %rax
jae 0x3ec18
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x4b8, %rsi            # imm = 0x4B8
movl -0xc(%rbp), %eax
imulq $0x110, %rax, %rax      # imm = 0x110
addq %rax, %rsi
callq 0x3ec70
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3ebe3
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_res_frame_destroy
static void dns_res_frame_destroy(struct dns_resolver *R, struct dns_res_frame *frame) {
	(void)R;

	dns_p_setptr(&frame->query, NULL);
	dns_p_setptr(&frame->answer, NULL);
	dns_p_setptr(&frame->hints, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x328c0
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x328c0
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x328c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_res_frame_init
static void dns_res_frame_init(struct dns_resolver *R, struct dns_res_frame *frame) {
	memset(frame, '\0', sizeof *frame);

	/*
	 * NB: Can be invoked from dns_res_open, before R->resconf has been
	 * initialized.
	 */
	if (R->resconf) {
		if (!R->resconf->options.recurse)
			frame->qflags |= DNS_Q_RD;
		if (R->resconf->options.edns0)
			frame->qflags |= DNS_Q_EDNS0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x110, %edx            # imm = 0x110
callq 0xf7d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x300(%rax)
je 0x3ece2
movq -0x8(%rbp), %rax
movq 0x300(%rax), %rax
testb $0x1, 0x5c1(%rax)
jne 0x3ecbf
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq 0x300(%rax), %rax
testb $0x1, 0x5b0(%rax)
je 0x3ece0
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0xc(%rax)
jmp 0x3ece2
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_res_clear
void dns_res_clear(struct dns_resolver *R) {
	switch (R->stack[R->sp].state) {
	case DNS_R_CHECK:
		R->cache->clear(R->cache);
		break;
	default:
		dns_so_clear(&R->so);
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4b0(%rax), %ecx
imulq $0x110, %rcx, %rcx      # imm = 0x110
movl 0x4b8(%rax,%rcx), %eax
subl $0x6, %eax
jne 0x3edc9
jmp 0x3edab
movq -0x8(%rbp), %rax
movq 0x318(%rax), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x318(%rcx), %rdi
callq *%rax
jmp 0x3edd2
movq -0x8(%rbp), %rdi
callq 0x10970
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_res_events2
static int dns_res_events2(struct dns_resolver *R, enum dns_events type) {
	int events;

	switch (R->stack[R->sp].state) {
	case DNS_R_CHECK:
		events = R->cache->events(R->cache);

		return (type == DNS_LIBEVENT)? DNS_POLL2EV(events) : events;
	default:
		return dns_so_events2(&R->so, type);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x4b0(%rax), %ecx
imulq $0x110, %rcx, %rcx      # imm = 0x110
movl 0x4b8(%rax,%rcx), %eax
subl $0x6, %eax
jne 0x3ee9f
jmp 0x3ee3e
movq -0x10(%rbp), %rax
movq 0x318(%rax), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x318(%rcx), %rdi
callq *%rax
cwtl
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x3ee91
movl -0x18(%rbp), %edx
andl $0x1, %edx
xorl %eax, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl -0x18(%rbp), %esi
andl $0x4, %esi
xorl %ecx, %ecx
movl $0x4, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
orl %ecx, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3ee97
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3eeae
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3e4c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_res_pollfd
int dns_res_pollfd(struct dns_resolver *R) {
	switch (R->stack[R->sp].state) {
	case DNS_R_CHECK:
		return R->cache->pollfd(R->cache);
	default:
		return dns_so_pollfd(&R->so);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4b0(%rax), %ecx
imulq $0x110, %rcx, %rcx      # imm = 0x110
movl 0x4b8(%rax,%rcx), %eax
subl $0x6, %eax
jne 0x3ef0c
jmp 0x3eeeb
movq -0x10(%rbp), %rax
movq 0x318(%rax), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x318(%rcx), %rdi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x3ef18
movq -0x10(%rbp), %rdi
callq 0xf2d0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_res_timeout
time_t dns_res_timeout(struct dns_resolver *R) {
	time_t elapsed;

	switch (R->stack[R->sp].state) {
#if 0
	case DNS_R_QUERY_AAAA:
#endif
	case DNS_R_QUERY_A:
		elapsed = dns_so_elapsed(&R->so);

		if (elapsed <= dns_resconf_timeout(R->resconf))
			return R->resconf->options.timeout - elapsed;

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

	/*
	 * NOTE: We're not in a pollable state, or the user code hasn't
	 * called dns_res_check properly. The calling code is probably
	 * broken. Put them into a slow-burn pattern.
	 */
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4b0(%rax), %ecx
imulq $0x110, %rcx, %rcx      # imm = 0x110
movl 0x4b8(%rax,%rcx), %eax
subl $0x10, %eax
jne 0x3efa9
jmp 0x3ef5b
movq -0x10(%rbp), %rdi
callq 0x10000
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x300(%rax), %rdi
callq 0x3efc0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jg 0x3efa7
movq -0x10(%rbp), %rax
movq 0x300(%rax), %rax
movl 0x5b8(%rax), %eax
subq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3efb3
jmp 0x3efab
jmp 0x3efab
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_res_submit2
int dns_res_submit2(struct dns_resolver *R, const char *qname, size_t qlen, enum dns_type qtype, enum dns_class qclass) {
	dns_res_reset(R);

	/* Don't anchor; that can conflict with searchlist generation. */
	dns_d_init(R->qname, sizeof R->qname, qname, (R->qlen = qlen), 0);

	R->qtype	= qtype;
	R->qclass	= qclass;

	dns_begin(&R->elapsed);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xfbf0
movq -0x8(%rbp), %rdi
addq $0x328, %rdi            # imm = 0x328
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x428(%rax)
movl $0x100, %esi            # imm = 0x100
xorl %r8d, %r8d
callq 0xf3e0
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x430(%rax)
movl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x434(%rax)
movq -0x8(%rbp), %rdi
addq $0x438, %rdi            # imm = 0x438
callq 0x3d510
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_res_check
int dns_res_check(struct dns_resolver *R) {
	int error;

	if (R->stack[0].state != DNS_R_DONE) {
		if ((error = dns_res_exec(R)))
			return error;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x16, 0x4b8(%rax)
je 0x3f184
movq -0x10(%rbp), %rdi
callq 0x3f1a0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x3f182
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3f18b
jmp 0x3f184
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_res_fetch
struct dns_packet *dns_res_fetch(struct dns_resolver *R, int *error) {
	struct dns_packet *P = NULL;

	if (R->stack[0].state != DNS_R_DONE)
		return *error = DNS_EUNKNOWN, (void *)0;

	if (!dns_p_movptr(&P, &R->stack[0].answer))
		return *error = DNS_EFETCHED, (void *)0;

	return P;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x16, 0x4b8(%rax)
je 0x40fe9
movq -0x18(%rbp), %rax
movl $0x9b918cc4, (%rax)     # imm = 0x9B918CC4
movq $0x0, -0x8(%rbp)
jmp 0x41023
movq -0x10(%rbp), %rsi
addq $0x4b8, %rsi            # imm = 0x4B8
addq $0x20, %rsi
leaq -0x20(%rbp), %rdi
callq 0x41030
cmpq $0x0, %rax
jne 0x4101b
movq -0x18(%rbp), %rax
movl $0x9b918cc8, (%rax)     # imm = 0x9B918CC8
movq $0x0, -0x8(%rbp)
jmp 0x41023
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_res_query
struct dns_packet *dns_res_query(struct dns_resolver *res, const char *qname, enum dns_type qtype, enum dns_class qclass, int timeout, int *error_) {
	int error;

	if ((error = dns_res_submit(res, qname, qtype, qclass)))
		goto error;

	while ((error = dns_res_check(res))) {
		if (dns_res_elapsed(res) > timeout)
			error = DNS_ETIMEDOUT;

		if (error != DNS_EAGAIN)
			goto error;

		if ((error = dns_res_poll(res, 1)))
			goto error;
	}

	return dns_res_fetch(res, error_);
error:
	*error_ = error;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
callq 0xf380
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x410ab
jmp 0x4110c
jmp 0x410ad
movq -0x10(%rbp), %rdi
callq 0xf560
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x410f9
movq -0x10(%rbp), %rdi
callq 0xf5b0
movslq -0x24(%rbp), %rcx
cmpq %rcx, %rax
jle 0x410d7
movl $0x6e, -0x34(%rbp)
cmpl $0xb, -0x34(%rbp)
je 0x410df
jmp 0x4110c
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xff00
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x410f7
jmp 0x4110c
jmp 0x410ad
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x101b0
movq %rax, -0x8(%rbp)
jmp 0x4111d
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_ai_parseport
static dns_error_t dns_ai_parseport(unsigned short *port, const char *serv, const struct addrinfo *hints) {
	const char *cp = serv;
	unsigned long n = 0;

	while (*cp >= '0' && *cp <= '9' && n < 65536) {
		n *= 10;
		n += *cp++ - '0';
	}

	if (*cp == '\0') {
		if (cp == serv || n >= 65536)
			return DNS_ESERVICE;

		*port = n;

		return 0;
	}

	if (hints->ai_flags & AI_NUMERICSERV)
		return DNS_ESERVICE;

	/* TODO: try getaddrinfo(NULL, serv, { .ai_flags = AI_NUMERICSERV }) */

	return DNS_ESERVICE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x31(%rbp)
jl 0x41400
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x39, %ecx
movb %al, -0x31(%rbp)
jg 0x41400
cmpq $0x10000, -0x30(%rbp)   # imm = 0x10000
setb %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x41409
jmp 0x41433
imulq $0xa, -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movsbl (%rax), %eax
subl $0x30, %eax
cltq
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x413d0
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x41473
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x41453
cmpq $0x10000, -0x30(%rbp)   # imm = 0x10000
jb 0x4145c
movl $0x9b918cc9, -0x4(%rbp) # imm = 0x9B918CC9
jmp 0x41493
movq -0x30(%rbp), %rax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x41493
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x4148c
movl $0x9b918cc9, -0x4(%rbp) # imm = 0x9B918CC9
jmp 0x41493
movl $0x9b918cc9, -0x4(%rbp) # imm = 0x9B918CC9
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_ai_close
void dns_ai_close(struct dns_addrinfo *ai) {
	if (!ai)
		return;

	dns_res_close(ai->res);

	if (ai->answer != ai->glue)
		dns_p_free(ai->glue);

	dns_p_free(ai->answer);
	free(ai);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x414b5
jmp 0x41503
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xfef0
movq -0x8(%rbp), %rax
movq 0x158(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x160(%rcx), %rax
je 0x414ea
movq -0x8(%rbp), %rax
movq 0x160(%rax), %rdi
callq 0x39a50
movq -0x8(%rbp), %rax
movq 0x158(%rax), %rdi
callq 0x39a50
movq -0x8(%rbp), %rdi
callq 0x10060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_res_fetch_and_study
static struct dns_packet *dns_res_fetch_and_study(struct dns_resolver *R, int *_error) {
	struct dns_packet *P = NULL;
	int error;

	if (!(P = dns_res_fetch(R, &error)))
		goto error;
	if ((error = dns_p_study(P)))
		goto error;

	return P;
error:
	*_error = error;

	dns_p_free(P);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x101b0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x424e1
jmp 0x424fe
movq -0x20(%rbp), %rdi
callq 0xf820
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x424f4
jmp 0x424fe
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x42518
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x39a50
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_strsection
const char *(dns_strsection)(enum dns_section section, void *_dst, size_t lim) {
	struct dns_buf dst = DNS_B_INTO(_dst, lim);
	unsigned i;

	for (i = 0; i < lengthof(dns_sections); i++) {
		if (dns_sections[i].type & section) {
			dns_b_puts(&dst, dns_sections[i].name);
			section &= ~dns_sections[i].type;
			if (section)
				dns_b_putc(&dst, '|');
		}
	}

	if (section || dst.p == dst.base)
		dns_b_fmtju(&dst, (0xffff & section), 0);

	return dns_b_tostring(&dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpq $0x8, %rax
jae 0x42b4b
movl -0x44(%rbp), %eax
movl %eax, %ecx
leaq 0xa026(%rip), %rax      # 0x4cb00
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
andl -0x4(%rbp), %eax
cmpl $0x0, %eax
je 0x42b3b
movl -0x44(%rbp), %eax
leaq 0xa00a(%rip), %rsi      # 0x4cb00
imulq $0x14, %rax, %rax
addq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x35e00
movl -0x44(%rbp), %eax
movl %eax, %ecx
leaq 0x9fee(%rip), %rax      # 0x4cb00
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
xorl $-0x1, %eax
andl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x42b39
leaq -0x40(%rbp), %rdi
movl $0x7c, %esi
callq 0x35b10
jmp 0x42b3b
jmp 0x42b3d
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x42ac5
cmpl $0x0, -0x4(%rbp)
jne 0x42b5b
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jne 0x42b72
movl -0x4(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
xorl %edx, %edx
callq 0x35c30
leaq -0x40(%rbp), %rdi
callq 0x42b90
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_isection
enum dns_section dns_isection(const char *src) {
	enum dns_section section = 0;
	char sbuf[128];
	char *name, *next;
	unsigned i;

	dns_strlcpy(sbuf, src, sizeof sbuf);
	next = sbuf;

	while ((name = dns_strsep(&next, "|+, \t"))) {
		for (i = 0; i < lengthof(dns_sections); i++) {
			if (!strcasecmp(dns_sections[i].name, name)) {
				section |= dns_sections[i].type;
				break;
			}
		}
	}

	return section;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq -0x90(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x80, %edx
callq 0xf520
leaq -0x90(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0xa0(%rbp), %rdi
leaq 0xaafb(%rip), %rsi      # 0x4d6f2
callq 0xf890
movq %rax, -0x98(%rbp)
cmpq $0x0, %rax
je 0x42c7d
movl $0x0, -0xa4(%rbp)
movl -0xa4(%rbp), %eax
cmpq $0x8, %rax
jae 0x42c78
movl -0xa4(%rbp), %eax
leaq 0x9ed4(%rip), %rdi      # 0x4cb00
imulq $0x14, %rax, %rax
addq %rax, %rdi
movq -0x98(%rbp), %rsi
callq 0xff50
cmpl $0x0, %eax
jne 0x42c65
movl -0xa4(%rbp), %eax
movl %eax, %ecx
leaq 0x9ead(%rip), %rax      # 0x4cb00
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x42c78
jmp 0x42c67
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0x42c13
jmp 0x42be9
movl -0xc(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_iclass
enum dns_class dns_iclass(const char *name) {
	unsigned i, class;

	for (i = 0; i < lengthof(dns_classes); i++) {
		if (!strcasecmp(dns_classes[i].name, name))
			return dns_classes[i].type;
	}

	class = 0;
	while (dns_isdigit(*name)) {
		class *= 10;
		class += *name++ - '0';
	}

	return DNS_PP_MIN(class, 0xffff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x1, %rax
jae 0x42cf3
movl -0x14(%rbp), %eax
leaq 0x9eea(%rip), %rdi      # 0x4cba0
imulq $0xc, %rax, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xff50
cmpl $0x0, %eax
jne 0x42ce6
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x9ec9(%rip), %rax      # 0x4cba0
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x42d51
jmp 0x42ce8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x42ca3
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %edi
callq 0x3a070
testb $0x1, %al
jne 0x42d0c
jmp 0x42d30
imull $0xa, -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
subl $0x30, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x42cfa
cmpl $0xffff, -0x18(%rbp)    # imm = 0xFFFF
jae 0x42d41
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x42d4b
movl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x1c(%rbp)
jmp 0x42d4b
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_itype
enum dns_type dns_itype(const char *name) {
	unsigned i, type;

	for (i = 0; i < lengthof(dns_rrtypes); i++) {
		if (!strcasecmp(dns_rrtypes[i].name, name))
			return dns_rrtypes[i].type;
	}

	type = 0;
	while (dns_isdigit(*name)) {
		type *= 10;
		type += *name++ - '0';
	}

	return DNS_PP_MIN(type, 0xffff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpq $0xd, %rax
jae 0x42dc8
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x18c28(%rip), %rax     # 0x5b9b0
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xff50
cmpl $0x0, %eax
jne 0x42dbb
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x18c03(%rip), %rax     # 0x5b9b0
shlq $0x6, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x42e26
jmp 0x42dbd
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x42d73
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %edi
callq 0x3a070
testb $0x1, %al
jne 0x42de1
jmp 0x42e05
imull $0xa, -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
subl $0x30, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x42dcf
cmpl $0xffff, -0x18(%rbp)    # imm = 0xFFFF
jae 0x42e16
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x42e20
movl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x1c(%rbp)
jmp 0x42e20
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_stropcode
const char *dns_stropcode(enum dns_opcode opcode) {
	opcode = (unsigned)opcode % lengthof(dns_opcodes);

	if ('\0' == dns_opcodes[opcode][0])
		return dns__strcode(opcode, dns_opcodes[opcode], sizeof dns_opcodes[opcode]);

	return dns_opcodes[opcode];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
andq $0xf, %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x1a6ff(%rip), %rax     # 0x5d550
shlq $0x4, %rcx
addq %rcx, %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x42e85
movl -0xc(%rbp), %edi
movl -0xc(%rbp), %eax
leaq 0x1a6e2(%rip), %rsi     # 0x5d550
shlq $0x4, %rax
addq %rax, %rsi
movl $0x10, %edx
callq 0x42eb0
movq %rax, -0x8(%rbp)
jmp 0x42e9c
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x1a6bf(%rip), %rax     # 0x5d550
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns__strcode
static const char *dns__strcode(int code, volatile char *dst, size_t lim) {
	char _tmp[48] = "";
	struct dns_buf tmp;
	size_t p;

	assert(lim > 0);
	dns_b_fmtju(dns_b_into(&tmp, _tmp, DNS_PP_MIN(sizeof _tmp, lim - 1)), code, 0);

	/* copy downwards so first byte is copied last (see below) */
	p = (size_t)(tmp.p - tmp.base);
	dst[p] = '\0';
	while (p--)
		dst[p] = _tmp[p];

	return (const char *)dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0xf7d0
cmpq $0x0, -0x18(%rbp)
jbe 0x42edf
jmp 0x42efe
leaq 0xab13(%rip), %rdi      # 0x4d9f9
leaq 0xa4f0(%rip), %rsi      # 0x4d3dd
movl $0x2238, %edx           # imm = 0x2238
leaq 0xab08(%rip), %rcx      # 0x4da01
callq 0xf920
leaq -0x50(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movl $0x30, %eax
cmpq %rcx, %rax
jae 0x42f29
movl $0x30, %eax
movq %rax, -0x90(%rbp)
jmp 0x42f38
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x90(%rbp)
movq -0x88(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0x38d70
movq %rax, %rdi
movslq -0x4(%rbp), %rsi
xorl %edx, %edx
callq 0x35c30
movq -0x70(%rbp), %rax
movq -0x78(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq -0x80(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x80(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x80(%rbp)
cmpq $0x0, %rax
je 0x42fa2
movq -0x80(%rbp), %rax
movb -0x50(%rbp,%rax), %dl
movq -0x10(%rbp), %rax
movq -0x80(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x42f78
movq -0x10(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_iopcode
enum dns_opcode dns_iopcode(const char *name) {
	unsigned opcode;

	for (opcode = 0; opcode < lengthof(dns_opcodes); opcode++) {
		if (!strcasecmp(name, dns_opcodes[opcode]))
			return opcode;
	}

	opcode = 0;
	while (dns_isdigit(*name)) {
		opcode *= 10;
		opcode += *name++ - '0';
	}

	return DNS_PP_MIN(opcode, 0x0f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x10, %rax
jae 0x43000
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
leaq 0x1a576(%rip), %rsi     # 0x5d550
shlq $0x4, %rax
addq %rax, %rsi
callq 0xff50
cmpl $0x0, %eax
jne 0x42ff3
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4305b
jmp 0x42ff5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x42fc3
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %edi
callq 0x3a070
testb $0x1, %al
jne 0x43019
jmp 0x4303d
imull $0xa, -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
subl $0x30, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x43007
cmpl $0xf, -0x14(%rbp)
jae 0x4304b
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x43055
movl $0xf, %eax
movl %eax, -0x18(%rbp)
jmp 0x43055
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_strrcode
const char *dns_strrcode(enum dns_rcode rcode) {
	rcode = (unsigned)rcode % lengthof(dns_rcodes);

	if ('\0' == dns_rcodes[rcode][0])
		return dns__strcode(rcode, dns_rcodes[rcode], sizeof dns_rcodes[rcode]);

	return dns_rcodes[rcode];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
andq $0x1f, %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x1a5bf(%rip), %rax     # 0x5d650
shlq $0x4, %rcx
addq %rcx, %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x430c5
movl -0xc(%rbp), %edi
movl -0xc(%rbp), %eax
leaq 0x1a5a2(%rip), %rsi     # 0x5d650
shlq $0x4, %rax
addq %rax, %rsi
movl $0x10, %edx
callq 0x42eb0
movq %rax, -0x8(%rbp)
jmp 0x430dc
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x1a57f(%rip), %rax     # 0x5d650
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_ircode
enum dns_rcode dns_ircode(const char *name) {
	unsigned rcode;

	for (rcode = 0; rcode < lengthof(dns_rcodes); rcode++) {
		if (!strcasecmp(name, dns_rcodes[rcode]))
			return rcode;
	}

	rcode = 0;
	while (dns_isdigit(*name)) {
		rcode *= 10;
		rcode += *name++ - '0';
	}

	return DNS_PP_MIN(rcode, 0xfff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x20, %rax
jae 0x43140
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
leaq 0x1a536(%rip), %rsi     # 0x5d650
shlq $0x4, %rax
addq %rax, %rsi
callq 0xff50
cmpl $0x0, %eax
jne 0x43133
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4319e
jmp 0x43135
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x43103
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %edi
callq 0x3a070
testb $0x1, %al
jne 0x43159
jmp 0x4317d
imull $0xa, -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
subl $0x30, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x43147
cmpl $0xfff, -0x14(%rbp)     # imm = 0xFFF
jae 0x4318e
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x43198
movl $0xfff, %eax            # imm = 0xFFF
movl %eax, -0x18(%rbp)
jmp 0x43198
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_s_study
static int dns_s_study(struct dns_s_memo *m, enum dns_section section, unsigned short base, struct dns_packet *P) {
	unsigned short count, rp;

	count = dns_p_count(P, section);

	for (rp = base; count && rp < P->end; count--)
		rp = dns_rr_skip(rp, P);

	m->base = base;
	m->end  = rp;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movw %ax, -0xe(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x10950
movw %ax, -0x1a(%rbp)
movw -0xe(%rbp), %ax
movw %ax, -0x1c(%rbp)
movzwl -0x1a(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
je 0x43202
movzwl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpq 0x50(%rcx), %rax
setb %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x4320b
jmp 0x4322d
movw -0x1c(%rbp), %ax
movq -0x18(%rbp), %rsi
movzwl %ax, %edi
callq 0xf320
movw %ax, -0x1c(%rbp)
movw -0x1a(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0x1a(%rbp)
jmp 0x431e2
movw -0xe(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, (%rax)
movw -0x1c(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_m_unstudy
static void dns_m_unstudy(struct dns_p_memo *m) {
	dns_s_unstudy(&m->qd);
	dns_s_unstudy(&m->an);
	dns_s_unstudy(&m->ns);
	dns_s_unstudy(&m->ar);
	m->opt.p = 0;
	m->opt.maxudp = 0;
	m->opt.ttl = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x432c0
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
callq 0x432c0
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x432c0
movq -0x8(%rbp), %rdi
addq $0xc, %rdi
callq 0x432c0
movq -0x8(%rbp), %rax
movw $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x12(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_rr_i_match
static _Bool dns_rr_i_match(struct dns_rr *rr, struct dns_rr_i *i, struct dns_packet *P) {
	if (i->section && !(rr->section & i->section))
		return 0;

	if (i->type && rr->type != i->type && i->type != DNS_T_ALL)
		return 0;

	if (i->class && rr->class != i->class && i->class != DNS_C_ANY)
		return 0;

	if (i->name) {
		char dn[DNS_D_MAXNAME + 1];
		size_t len;
		int error;

		if (!(len = dns_d_expand(dn, sizeof dn, rr->dn.p, P, &error))
		||  len >= sizeof dn)
			return 0;

		if (0 != strcasecmp(dn, i->name))
			return 0;
	}

	if (i->data && i->type && rr->section > DNS_S_QD) {
		union dns_any rd;
		int error;

		if ((error = dns_any_parse(&rd, rr, P)))
			return 0;

		if (0 != dns_any_cmp(&rd, rr->type, i->data, i->type))
			return 0;
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x550, %rsp            # imm = 0x550
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4331a
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
andl (%rcx), %eax
cmpl $0x0, %eax
jne 0x4331a
movb $0x0, -0x1(%rbp)
jmp 0x4346c
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x4334a
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
je 0x4334a
movq -0x18(%rbp), %rax
cmpl $0xff, 0x10(%rax)
je 0x4334a
movb $0x0, -0x1(%rbp)
jmp 0x4346c
movq -0x18(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x4337a
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x14(%rcx), %eax
je 0x4337a
movq -0x18(%rbp), %rax
cmpl $0xff, 0x14(%rax)
je 0x4337a
movb $0x0, -0x1(%rbp)
jmp 0x4346c
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x433f3
leaq -0x120(%rbp), %rdi
movq -0x10(%rbp), %rax
movw 0x4(%rax), %ax
movq -0x20(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
leaq -0x12c(%rbp), %r8
movzwl %ax, %edx
callq 0xffd0
movq %rax, -0x128(%rbp)
cmpq $0x0, %rax
je 0x433c6
cmpq $0x100, -0x128(%rbp) # imm = 0x100
jb 0x433cf
movb $0x0, -0x1(%rbp)
jmp 0x4346c
leaq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xff50
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x433f1
movb $0x0, -0x1(%rbp)
jmp 0x4346c
jmp 0x433f3
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x43468
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x43468
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jbe 0x43468
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x540(%rbp), %rdi
callq 0xff80
movl %eax, -0x544(%rbp)
cmpl $0x0, %eax
je 0x43436
movb $0x0, -0x1(%rbp)
jmp 0x4346c
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
leaq -0x540(%rbp), %rdi
callq 0xfda0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x43466
movb $0x0, -0x1(%rbp)
jmp 0x4346c
jmp 0x43468
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x550, %rsp            # imm = 0x550
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_b_tolstring
static inline const char *
dns_b_tolstring(struct dns_buf *b, size_t *n)
{
	if (b->p < b->pe) {
		*b->p = '\0';
		*n = b->p - b->base;

		return (const char *)b->base;
	} else if (b->p > b->base) {
		if (b->p[-1] != '\0') {
			dns_b_setoverflow(b, 1, DNS_ENOBUFS);
			b->p[-1] = '\0';
		}
		*n = &b->p[-1] - b->base;

		return (const char *)b->base;
	} else {
		*n = 0;

		return "";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x43556
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x435d7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x435c1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movzbl -0x1(%rax), %eax
cmpl $0x0, %eax
je 0x43597
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x9b918cc0, %edx       # imm = 0x9B918CC0
callq 0x434a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x0, -0x1(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x435d7
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
leaq 0x9f98(%rip), %rax      # 0x4d56b
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_b_getc
static inline int
dns_b_getc(const struct dns_buf *_b, const int eof)
{
	struct dns_buf *b = (struct dns_buf *)_b;

	if (!(b->p < b->pe))
		return dns_b_setoverflow(b, 1, DNS_EILLEGAL), eof;

	return *b->p++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x43634
movq -0x20(%rbp), %rdi
movl $0x1, %esi
movl $0x9b918cc1, %edx       # imm = 0x9B918CC1
callq 0x434a0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4364d
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_b_pputc
static dns_error_t
dns_b_pputc(struct dns_buf *b, unsigned char uc, size_t p)
{
	size_t pe = b->pe - b->base;
	if (pe <= p)
		return dns_b_setoverflow(b, p - pe + 1, DNS_ENOBUFS);

	*((unsigned char *)b->base + p) = uc;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0x436b5
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
subq -0x28(%rbp), %rsi
addq $0x1, %rsi
movl $0x9b918cc0, %edx       # imm = 0x9B918CC0
callq 0x434a0
movl %eax, -0x4(%rbp)
jmp 0x436cd
movb -0x11(%rbp), %dl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_fopen_addflag
static dns_error_t dns_fopen_addflag(char *dst, const char *src, size_t lim, int fc) {
	char *p = dst, *pe = dst + lim;

	/* copy standard flags */
	while (*src && strchr(DNS_FOPEN_STDFLAGS, *src)) {
		if (!(p < pe))
			return ENOMEM;
		*p++ = *src++;
	}

	/* append flag to standard flags */
	if (!(p < pe))
		return ENOMEM;
	*p++ = fc;

	/* copy remaining mode string, including '\0' */
	do {
		if (!(p < pe))
			return ENOMEM;
	} while ((*p++ = *src++));

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0x43759
movq -0x18(%rbp), %rax
movsbl (%rax), %esi
leaq 0xa171(%rip), %rdi      # 0x4d8bb
callq 0xf530
cmpq $0x0, %rax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x43762
jmp 0x4379c
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jb 0x43778
movl $0xc, -0x4(%rbp)
jmp 0x43807
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
jmp 0x4372b
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jb 0x437af
movl $0xc, -0x4(%rbp)
jmp 0x43807
movl -0x24(%rbp), %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jb 0x437d8
movl $0xc, -0x4(%rbp)
jmp 0x43807
jmp 0x437da
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %al
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %al, (%rcx)
cmpb $0x0, %al
jne 0x437c5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq