LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_anyconf_match
static _Bool dns_anyconf_match(const char *pat, int mc) {
	_Bool match;
	int pc;

	if (*pat == '^') {
		match = 0;
		++pat;
	} else {
		match = 1;
	}

	while ((pc = *(const unsigned char *)pat++)) {
		switch (pc) {
		case '%':
			if (!(pc = *(const unsigned char *)pat++))
				return !match;

			switch (pc) {
			case 'a':
				if (dns_isalpha(mc))
					return match;
				break;
			case 'd':
				if (dns_isdigit(mc))
					return match;
				break;
			case 'w':
				if (dns_isalnum(mc))
					return match;
				break;
			case 's':
				if (dns_isspace(mc))
					return match;
				break;
			default:
				if (mc == pc)
					return match;
				break;
			} /* switch() */

			break;
		default:
			if (mc == pc)
				return match;
			break;
		} /* switch() */
	} /* while() */

	return !match;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5e, %eax
jne 0x4383d
movb $0x0, -0x15(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x43841
movb $0x1, -0x15(%rbp)
jmp 0x43843
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x43967
movl -0x1c(%rbp), %eax
subl $0x25, %eax
jne 0x4394e
jmp 0x4386f
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jne 0x43898
movb -0x15(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x43971
movl -0x1c(%rbp), %eax
addl $-0x61, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x16, %eax
ja 0x43938
movq -0x28(%rbp), %rax
leaq 0x68b8(%rip), %rcx      # 0x4a170
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x14(%rbp), %eax
movzbl %al, %edi
callq 0x43980
testb $0x1, %al
jne 0x438d2
jmp 0x438df
movb -0x15(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x43971
jmp 0x4394c
movl -0x14(%rbp), %eax
movzbl %al, %edi
callq 0x3a070
testb $0x1, %al
jne 0x438f2
jmp 0x438fc
movb -0x15(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x43971
jmp 0x4394c
movl -0x14(%rbp), %eax
movzbl %al, %edi
callq 0x439c0
testb $0x1, %al
jne 0x4390f
jmp 0x43919
movb -0x15(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x43971
jmp 0x4394c
movl -0x14(%rbp), %eax
movzbl %al, %edi
callq 0x393a0
testb $0x1, %al
jne 0x4392c
jmp 0x43936
movb -0x15(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x43971
jmp 0x4394c
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x4394a
movb -0x15(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x43971
jmp 0x4394c
jmp 0x43962
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x43960
movb -0x15(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x43971
jmp 0x43962
jmp 0x43843
movb -0x15(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_anyconf_addc
static int dns_anyconf_addc(struct dns_anyconf *cf, int ch) {
	if (!(cf->cp < endof(cf->buffer)))
		return ENOMEM;

	*cf->cp++ = ch;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x490(%rax), %rax
movq -0x10(%rbp), %rcx
addq $0x84, %rcx
addq $0x400, %rcx            # imm = 0x400
cmpq %rcx, %rax
jb 0x43a36
movl $0xc, -0x4(%rbp)
jmp 0x43a5d
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rdx
movq 0x490(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x490(%rdx)
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_anyconf_push
static int dns_anyconf_push(struct dns_anyconf *cf) {
	if (!(cf->cp < endof(cf->buffer) && cf->count < lengthof(cf->token)))
		return ENOMEM;

	*cf->cp++ = '\0';
	cf->token[cf->count++] = cf->tp;
	cf->tp = cf->cp;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x490(%rax), %rax
movq -0x10(%rbp), %rcx
addq $0x84, %rcx
addq $0x400, %rcx            # imm = 0x400
cmpq %rcx, %rax
jae 0x43aaa
movq -0x10(%rbp), %rax
movl 0x80(%rax), %eax
cmpq $0x10, %rax
jb 0x43ab3
movl $0xc, -0x4(%rbp)
jmp 0x43b16
movq -0x10(%rbp), %rcx
movq 0x490(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x490(%rcx)
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x488(%rax), %rdx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rsi
movl 0x80(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x80(%rsi)
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x490(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x488(%rax)
movl $0x0, -0x4(%rbp)
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_hints_i_cmp
static int dns_hints_i_cmp(unsigned a, unsigned b, struct dns_hints_i *i, struct dns_hints_soa *soa) {
	int cmp;

	if ((cmp = soa->addrs[a].priority - soa->addrs[b].priority))
		return cmp;

	return dns_k_shuffle16(a, i->state.seed) - dns_k_shuffle16(b, i->state.seed);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
movl -0x8(%rbp), %ecx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movl 0x80(%rax), %eax
movq -0x20(%rbp), %rcx
addq $0x100, %rcx            # imm = 0x100
movl -0xc(%rbp), %edx
imulq $0x88, %rdx, %rdx
addq %rdx, %rcx
subl 0x80(%rcx), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x43c11
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x43c49
movl -0x8(%rbp), %eax
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %esi
movzwl %ax, %edi
callq 0x35170
movzwl %ax, %eax
movl %eax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %esi
movzwl %ax, %edi
callq 0x35170
movw %ax, %cx
movl -0x28(%rbp), %eax
movzwl %cx, %ecx
subl %ecx, %eax
movl %eax, -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_hints_i_start
static unsigned dns_hints_i_start(struct dns_hints_i *i, struct dns_hints_soa *soa) {
	unsigned p0, p;

	p0	= 0;

	for (p = 1; p < soa->count; p++) {
		if (dns_hints_i_cmp(p, p0, i, soa) < 0)
			p0	= p;
	}

	return p0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x980(%rcx), %eax
jae 0x43cb8
movl -0x18(%rbp), %edi
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x43bb0
cmpl $0x0, %eax
jge 0x43cab
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x43cad
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x43c7e
movl -0x14(%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_k_permutor_init
static void dns_k_permutor_init(struct dns_k_permutor *p, unsigned low, unsigned high) {
	uint32_t key[DNS_K_TEA_KEY_SIZE / sizeof (uint32_t)];
	unsigned width, i;

	p->stepi	= 0;

	p->length	= (high - low) + 1;
	p->limit	= high;

	width		= dns_k_permutor_powof(p->length);
	width		+= width % 2;

	p->shift	= width / 2;
	p->mask		= (1U << p->shift) - 1;
	p->rounds	= DNS_K_PERMUTOR_ROUNDS;

	for (i = 0; i < lengthof(key); i++)
		key[i]	= dns_random();

	dns_k_tea_init(&p->tea, key, 0);

	return /* void */;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movl -0x10(%rbp), %ecx
subl -0xc(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x43da0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
andl $0x1, %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
shrl %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0x14(%rax)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpq $0x4, %rax
jae 0x43d7d
callq 0x10700
callq *(%rax)
movl %eax, %ecx
movl -0x28(%rbp), %eax
movl %ecx, -0x20(%rbp,%rax,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x43d59
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
leaq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x43de0
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_k_permutor_E
static unsigned dns_k_permutor_E(struct dns_k_permutor *p, unsigned n) {
	unsigned l[2], r[2];
	unsigned i;

	i	= 0;
	l[i]	= p->mask & (n >> p->shift);
	r[i]	= p->mask & (n >> 0);

	do {
		l[(i + 1) % 2]	= r[i % 2];
		r[(i + 1) % 2]	= l[i % 2] ^ dns_k_permutor_F(p, i, r[i % 2]);

		i++;
	} while (i < p->rounds - 1);

	return ((l[i % 2] & p->mask) << p->shift) | ((r[i % 2] & p->mask) << 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %ecx
shrl %cl, %eax
movl -0x24(%rbp), %ecx
andl %eax, %ecx
movl -0x20(%rbp), %eax
movl %ecx, -0x14(%rbp,%rax,4)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movl -0xc(%rbp), %eax
shrl $0x0, %eax
andl %eax, %ecx
movl -0x20(%rbp), %eax
movl %ecx, -0x1c(%rbp,%rax,4)
movl -0x20(%rbp), %eax
andl $0x1, %eax
movl %eax, %eax
movl -0x1c(%rbp,%rax,4), %ecx
movl -0x20(%rbp), %eax
addl $0x1, %eax
andl $0x1, %eax
movl %eax, %eax
movl %ecx, -0x14(%rbp,%rax,4)
movl -0x20(%rbp), %eax
andl $0x1, %eax
movl %eax, %eax
movl -0x14(%rbp,%rax,4), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x20(%rbp), %eax
andl $0x1, %eax
movl %eax, %eax
movl -0x1c(%rbp,%rax,4), %edx
callq 0x43f30
movl -0x28(%rbp), %ecx
xorl %eax, %ecx
movl -0x20(%rbp), %eax
addl $0x1, %eax
andl $0x1, %eax
movl %eax, %eax
movl %ecx, -0x1c(%rbp,%rax,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x14(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jb 0x43e7e
movl -0x20(%rbp), %eax
andl $0x1, %eax
movl %eax, %eax
movl -0x14(%rbp,%rax,4), %eax
movq -0x8(%rbp), %rcx
andl 0x10(%rcx), %eax
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %ecx
shll %cl, %eax
movl -0x20(%rbp), %ecx
andl $0x1, %ecx
movl %ecx, %ecx
movl -0x1c(%rbp,%rcx,4), %ecx
movq -0x8(%rbp), %rdx
andl 0x10(%rdx), %ecx
shll $0x0, %ecx
orl %ecx, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_k_permutor_F
static unsigned dns_k_permutor_F(struct dns_k_permutor *p, unsigned k, unsigned x) {
	uint32_t in[DNS_K_TEA_BLOCK_SIZE / sizeof (uint32_t)], out[DNS_K_TEA_BLOCK_SIZE / sizeof (uint32_t)];

	memset(in, '\0', sizeof in);

	in[0]	= k;
	in[1]	= x;

	dns_k_tea_encrypt(&p->tea, in, out);

	return p->mask & out[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0xf7d0
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x43f90
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
andl -0x20(%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_k_tea_encrypt
static void dns_k_tea_encrypt(struct dns_k_tea *tea, uint32_t v[], uint32_t *w) {
	uint32_t y, z, sum, n;

	y	= v[0];
	z	= v[1];
	sum	= 0;

	for (n = 0; n < tea->cycles; n++) {
		sum	+= DNS_K_TEA_MAGIC;
		y	+= ((z << 4) + tea->key[0]) ^ (z + sum) ^ ((z >> 5) + tea->key[1]);
		z	+= ((y << 4) + tea->key[2]) ^ (y + sum) ^ ((y >> 5) + tea->key[3]);
	}

	w[0]	= y;
	w[1]	= z;

	return /* void */;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x44036
movl -0x24(%rbp), %eax
addl $0x9e3779b9, %eax       # imm = 0x9E3779B9
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
shll $0x4, %eax
movq -0x8(%rbp), %rcx
addl (%rcx), %eax
movl -0x20(%rbp), %ecx
addl -0x24(%rbp), %ecx
xorl %ecx, %eax
movl -0x20(%rbp), %ecx
shrl $0x5, %ecx
movq -0x8(%rbp), %rdx
addl 0x4(%rdx), %ecx
xorl %ecx, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shll $0x4, %eax
movq -0x8(%rbp), %rcx
addl 0x8(%rcx), %eax
movl -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
xorl %ecx, %eax
movl -0x1c(%rbp), %ecx
shrl $0x5, %ecx
movq -0x8(%rbp), %rdx
addl 0xc(%rdx), %ecx
xorl %ecx, %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x43fc1
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_strnlcpy
DNS_NOTUSED static size_t dns_strnlcpy(char *dst, size_t lim, const char *src, size_t max) {
	size_t len = dns_strnlen(src, max), n;

	if (lim > 0) {
		n = DNS_PP_MIN(lim - 1, len);
		memcpy(dst, src, n);
		dst[n] = '\0';
	}

	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x44430
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0x44399
movq -0x10(%rbp), %rax
subq $0x1, %rax
cmpq -0x28(%rbp), %rax
jae 0x4436c
movq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x44374
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xfb40
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_sa_path
DNS_NOTUSED static void *dns_sa_path(void *sa, socklen_t *size) {
	switch (dns_sa_family(sa)) {
#if DNS_HAVE_SOCKADDR_UN
	case AF_UNIX: {
		char *path = ((struct sockaddr_un *)sa)->sun_path;

		if (size)
			*size = dns_strnlen(path, DNS_SUNPATHMAX);

		return path;
	}
#endif
	default:
		if (size)
			*size = 0;

		return NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movw (%rax), %ax
subw $0x1, %ax
jne 0x44402
jmp 0x443cf
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x443f8
movq -0x20(%rbp), %rdi
movl $0x6c, %esi
callq 0x44430
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4441b
cmpq $0x0, -0x18(%rbp)
je 0x44413
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_strnlen
DNS_NOTUSED static size_t dns_strnlen(const char *src, size_t m) {
	size_t n = 0;

	while (*src++ && n < m)
		++n;

	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x4446e
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
setb %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x44477
jmp 0x44485
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x44444
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_socketclose
static void dns_socketclose(int *fd, const struct dns_options *opts) {
	if (opts && opts->closefd.cb)
		opts->closefd.cb(fd, opts->closefd.arg);

	if (*fd != -1) {
#if _WIN32
		closesocket(*fd);
#else
		close(*fd);
#endif
		*fd	= -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x444c7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x444c7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
movq -0x8(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x444e5
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x10c10
movq -0x8(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
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_rr_type
static enum dns_type dns_rr_type(unsigned short src, struct dns_packet *P) {
	struct dns_rr rr;
	int error;

	if ((error = dns_rr_parse(&rr, src, P)))
		return 0;

	return rr.type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %di, %ax
movw %ax, -0x6(%rbp)
movq %rsi, -0x10(%rbp)
movw -0x6(%rbp), %ax
movq -0x10(%rbp), %rdx
leaq -0x28(%rbp), %rdi
movzwl %ax, %esi
callq 0xf790
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x449d8
movl $0x0, -0x4(%rbp)
jmp 0x449de
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_q_make2
static dns_error_t
dns_q_make2(struct dns_packet **_Q, const char *qname, size_t qlen, enum dns_type qtype, enum dns_class qclass, int qflags)
{
	struct dns_packet *Q = NULL;
	int error;

	if (dns_p_movptr(&Q, _Q)) {
		dns_p_reset(Q);
	} else if (!(Q = dns_p_make(DNS_P_QBUFSIZ, &error))) {
		goto error;
	}

	if ((error = dns_p_push(Q, DNS_S_QD, qname, qlen, qtype, qclass, 0, 0)))
		goto error;

	dns_header(Q)->rd = !!(qflags & DNS_Q_RD);

	if (qflags & DNS_Q_EDNS0) {
		struct dns_opt opt = DNS_OPT_INIT(&opt);

		opt.version = 0; /* RFC 6891 version */
		opt.maxudp = 4096;

		if ((error = dns_p_push(Q, DNS_S_AR, ".", 1, DNS_T_OPT, dns_opt_class(&opt), dns_opt_ttl(&opt), &opt)))
			goto error;
	}

	*_Q = Q;

	return 0;
error:
	dns_p_free(Q);

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x41030
cmpq $0x0, %rax
je 0x44a38
movq -0x38(%rbp), %rdi
callq 0x455d0
jmp 0x44a57
movl $0x160, %edi            # imm = 0x160
leaq -0x3c(%rbp), %rsi
callq 0xfb10
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x44a55
jmp 0x44b93
jmp 0x44a57
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movl -0x28(%rbp), %r9d
movl $0x1, %esi
xorl %eax, %eax
xorl %eax, %eax
movl $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x10880
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x44a96
jmp 0x44b93
movl -0x2c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x38(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq 0x5c(%rax), %rcx
andq $0x1, %rdx
shlq $0x10, %rdx
andq $-0x10001, %rcx         # imm = 0xFFFEFFFF
orq %rdx, %rcx
movq %rcx, 0x5c(%rax)
movl -0x2c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x44b7f
leaq -0x160(%rbp), %rdi
xorl %esi, %esi
movl $0x120, %edx            # imm = 0x120
callq 0xf7d0
movq $0x100, -0x150(%rbp) # imm = 0x100
movb $0x0, -0x15c(%rbp)
movw $0x1000, -0x158(%rbp)   # imm = 0x1000
movq -0x38(%rbp), %rax
movq %rax, -0x170(%rbp)
leaq -0x160(%rbp), %rdi
callq 0xfce0
movzwl %ax, %eax
movl %eax, -0x164(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x10070
movq -0x170(%rbp), %rdi
movl -0x164(%rbp), %r9d
movl %eax, %r10d
movl $0x8, %esi
leaq 0x8920(%rip), %rdx      # 0x4d473
movl $0x1, %ecx
movl $0x29, %r8d
leaq -0x160(%rbp), %rax
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x10880
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x44b7d
jmp 0x44b93
jmp 0x44b7f
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x44ba2
movq -0x38(%rbp), %rdi
callq 0x39a50
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_res_frame_prepare
static dns_error_t dns_res_frame_prepare(struct dns_resolver *R, struct dns_res_frame *F, const char *qname, enum dns_type qtype, enum dns_class qclass) {
	struct dns_packet *P = NULL;

	if (!(F < endof(R->stack)))
		return DNS_EUNKNOWN;

	dns_p_movptr(&P, &F->query);
	dns_res_frame_reset(R, F);
	dns_p_movptr(&F->query, &P);

	return dns_q_make(&F->query, qname, qtype, qclass, F->qflags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x4b8, %rcx            # imm = 0x4B8
addq $0x880, %rcx            # imm = 0x880
cmpq %rcx, %rax
jb 0x44e77
movl $0x9b918cc4, -0x4(%rbp) # imm = 0x9B918CC4
jmp 0x44ec8
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
leaq -0x30(%rbp), %rdi
callq 0x41030
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x45600
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
leaq -0x30(%rbp), %rsi
callq 0x41030
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl 0xc(%rax), %r8d
callq 0x44bb0
movl %eax, -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_hints_port
static unsigned short dns_hints_port(struct dns_hints *hints, int af, void *addr) {
	struct dns_hints_soa *soa;
	void *addrsoa;
	socklen_t addrlen;
	unsigned short port;
	unsigned i;

	for (soa = hints->head; soa; soa = soa->next) {
		for (i = 0; i < soa->count; i++) {
			if (af != soa->addrs[i].ss.ss_family)
				continue;

			if (!(addrsoa = dns_sa_addr(af, &soa->addrs[i].ss, &addrlen)))
				continue;

			if (memcmp(addr, addrsoa, addrlen))
				continue;

			port = *dns_sa_port(af, &soa->addrs[i].ss);

			return (port)? port : htons(53);
		}
	}

	return htons(53);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4500a
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x980(%rcx), %eax
jae 0x44ff4
movl -0x14(%rbp), %eax
movq -0x28(%rbp), %rcx
addq $0x100, %rcx            # imm = 0x100
movl -0x3c(%rbp), %edx
imulq $0x88, %rdx, %rdx
addq %rdx, %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
je 0x44f4b
jmp 0x44fe6
movl -0x14(%rbp), %edi
movq -0x28(%rbp), %rsi
addq $0x100, %rsi            # imm = 0x100
movl -0x3c(%rbp), %eax
imulq $0x88, %rax, %rax
addq %rax, %rsi
leaq -0x34(%rbp), %rdx
callq 0x3a110
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x44f7b
jmp 0x44fe6
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %eax
movl %eax, %edx
callq 0xf5e0
cmpl $0x0, %eax
je 0x44f94
jmp 0x44fe6
movl -0x14(%rbp), %edi
movq -0x28(%rbp), %rsi
addq $0x100, %rsi            # imm = 0x100
movl -0x3c(%rbp), %eax
imulq $0x88, %rax, %rax
addq %rax, %rsi
callq 0x3a1b0
movw (%rax), %ax
movw %ax, -0x36(%rbp)
movzwl -0x36(%rbp), %eax
cmpl $0x0, %eax
je 0x44fcd
movzwl -0x36(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0x44fdd
movl $0x35, %edi
callq 0xf0e0
movzwl %ax, %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movw %ax, -0x2(%rbp)
jmp 0x45018
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x44f11
jmp 0x44ff6
movq -0x28(%rbp), %rax
movq 0x988(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x44eff
movl $0x35, %edi
callq 0xf0e0
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_q_remake
static dns_error_t
dns_q_remake(struct dns_packet **Q, int qflags)
{
	char qname[DNS_D_MAXNAME + 1];
	size_t qlen;
	struct dns_rr rr;
	int error;

	assert(Q && *Q);
	if ((error = dns_rr_parse(&rr, 12, *Q)))
		return error;
	if (!(qlen = dns_d_expand(qname, sizeof qname, rr.dn.p, *Q, &error)))
		return error;
	if (qlen >= sizeof qname)
		return DNS_EILLEGAL;
	return dns_q_make2(Q, qname, qlen, rr.type, rr.class, qflags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x45055
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x45055
jmp 0x45074
leaq 0x8964(%rip), %rdi      # 0x4d9c0
leaq 0x837a(%rip), %rsi      # 0x4d3dd
movl $0x7f4, %edx            # imm = 0x7F4
leaq 0x8959(%rip), %rcx      # 0x4d9c8
callq 0xf920
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq -0x140(%rbp), %rdi
movl $0xc, %esi
callq 0xf790
movl %eax, -0x144(%rbp)
cmpl $0x0, %eax
je 0x450a5
movl -0x144(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x45127
leaq -0x120(%rbp), %rdi
movw -0x13c(%rbp), %ax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movl $0x100, %esi            # imm = 0x100
leaq -0x144(%rbp), %r8
movzwl %ax, %edx
callq 0xffd0
movq %rax, -0x128(%rbp)
cmpq $0x0, %rax
jne 0x450e6
movl -0x144(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x45127
cmpq $0x100, -0x128(%rbp) # imm = 0x100
jb 0x450fc
movl $0x9b918cc1, -0x4(%rbp) # imm = 0x9B918CC1
jmp 0x45127
movq -0x10(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movq -0x128(%rbp), %rdx
movl -0x138(%rbp), %ecx
movl -0x134(%rbp), %r8d
movl -0x14(%rbp), %r9d
callq 0x449f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_rr_exists
static _Bool dns_rr_exists(struct dns_rr *rr0, struct dns_packet *P0, struct dns_packet *P1) {
	struct dns_rr rr1;

	dns_rr_foreach(&rr1, P1, .section = rr0->section, .type = rr0->type) {
		if (0 == dns_rr_cmp(rr0, P0, &rr1, P1))
			return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0xe8(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0xf7d0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xe8(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0xd8(%rbp)
movq -0x20(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
callq 0x10750
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
movl $0x58, %edx
callq 0xfb40
movq -0x20(%rbp), %rcx
movl $0x0, -0xec(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
leaq -0x90(%rbp), %rdx
leaq -0xec(%rbp), %r8
callq 0xfe80
cmpl $0x0, %eax
je 0x455bb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq -0x38(%rbp), %rdx
callq 0x10be0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x455b9
movb $0x1, -0x1(%rbp)
jmp 0x455bf
jmp 0x45567
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/dns.c
// Function: dns_ai_setaf
static int dns_ai_setaf(struct dns_addrinfo *ai, int af, int qtype) {
	ai->af.atype = af;
	ai->af.qtype = qtype;

	ai->af.todo &= ~dns_ai_af2index(af);

	return af;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14c(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x150(%rax)
movl -0xc(%rbp), %edi
callq 0x45690
movq %rax, %rcx
xorq $-0x1, %rcx
movq -0x8(%rbp), %rax
andq 0x140(%rax), %rcx
movq %rcx, 0x140(%rax)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/notify.c
// Function: cloexec
static int cloexec(int fd) {
	int flags;
	if (-1 == (flags = fcntl(fd, F_GETFD)))
		return errno;
	if (-1 == fcntl(fd, F_SETFD, flags|FD_CLOEXEC))
		return errno;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
movl $0x1, %esi
movb $0x0, %al
callq 0xf830
movl %eax, %ecx
movl %ecx, -0xc(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x45964
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x45997
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %edx
orl $0x1, %edx
movl $0x2, %esi
movb $0x0, %al
callq 0xf830
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x45990
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x45997
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/notify.c
// Function: nonblock
static int nonblock(int fd) {
	int flags;
	if (-1 == (flags = fcntl(fd, F_GETFL)))
		return errno;
	if (-1 == fcntl(fd, F_SETFL, flags|O_NONBLOCK))
		return errno;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
movl $0x3, %esi
movb $0x0, %al
callq 0xf830
movl %eax, %ecx
movl %ecx, -0xc(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x459d4
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x45a0a
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %edx
orl $0x800, %edx            # imm = 0x800
movl $0x4, %esi
movb $0x0, %al
callq 0xf830
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x45a03
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x45a0a
movl $0x0, -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/notify.c
// Function: notify_close
void notify_close(struct notify *nfy) {
	struct file *file, *next;

	if (!nfy)
		return;

	for (file = LLRB_MIN(files, &nfy->files); file != NULL; file = next) {
		next = LLRB_NEXT(files, &nfy->files, file);

		discard(nfy, file);
	}

	closefd(&nfy->fd);
	closefd(&nfy->dirfd);

#if ENABLE_FEN
	port_dissociate(nfy->fd, PORT_SOURCE_FILE, (intptr_t)&nfy->dirfo);
#endif

	free(nfy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x45a35
jmp 0x45a90
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x45aa0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x45a71
movq -0x10(%rbp), %rdi
callq 0x45ae0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x45ba0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x45a46
movq -0x8(%rbp), %rdi
callq 0x45c40
movq -0x8(%rbp), %rdi
addq $0x54, %rdi
callq 0x45c40
movq -0x8(%rbp), %rdi
callq 0x10060
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/notify.c
// Function: discard
static void discard(struct notify *nfy, struct file *file) {
	closefd(&file->fd);

#if ENABLE_FEN
	port_dissociate(nfy->fd, PORT_SOURCE_FILE, (intptr_t)&file->fo);
#endif

	LLRB_REMOVE(files, &nfy->files, file);
	LIST_REMOVE(file, le);
	LIST_REMOVE(file, sle);

	free(file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x45c40
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x46520
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x45be9
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
jmp 0x45bfe
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x45c1d
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x10060
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/notify.c
// Function: closefd
static int closefd(int *fd) {
	while (*fd >= 0 && 0 != close(*fd)) {
		if (errno != EINTR)
			return errno;
	}

	*fd = -1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, -0x11(%rbp)
jl 0x45c71
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x10c10
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x45c7a
jmp 0x45c92
callq 0xf0a0
cmpl $0x4, (%rax)
je 0x45c90
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x45ca3
jmp 0x45c4c
movq -0x10(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/notify.c
// Function: notify_timeout
int notify_timeout(struct notify *nfy) {
	if (nfy->dirty || !LIST_EMPTY(&nfy->pending) || !LIST_EMPTY(&nfy->changed))
		return 0;
	else
		return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x50(%rax)
jne 0x45ce8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x45ce8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x45cf1
movl $0x0, -0x4(%rbp)
jmp 0x45cf8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/notify.c
// Function: notify_step
int notify_step(struct notify *nfy, int timeout) {
	int error;

	if (nfy->dirty || !LIST_EMPTY(&nfy->pending))
		goto post;

	if (nfy->changes || !LIST_EMPTY(&nfy->changed))
		return 0;

	if ((error = NFY_STEP(nfy, timeout)))
		return error;

post:
	if ((error = NFY_POST(nfy)))
		return error;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x50(%rax)
jne 0x45d24
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x45d26
jmp 0x45d62
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
jne 0x45d3b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x45d44
movl $0x0, -0x4(%rbp)
jmp 0x45d82
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x45d90
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x45d60
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x45d82
jmp 0x45d62
movq -0x10(%rbp), %rdi
callq 0x45e70
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x45d7b
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x45d82
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/notify.c
// Function: in_step
static int in_step(struct notify *nfy, int timeout) {
	int error;

	if (!(error = in_step1(nfy)))
		return 0;
	else if (error != EAGAIN)
		goto error;
	else if (timeout == 0)
		return 0;

	if (-1 == poll(&(struct pollfd){ nfy->fd, POLLIN, 0 }, 1, timeout))
		goto syerr;

	if ((error = in_step1(nfy)))
		goto error;

	return 0;
syerr:
	error = errno;
error:
	switch (error) {
	case EINTR:
		/* FALL THROUGH */
	case EAGAIN:
		return 0;
	default:
		return error;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x46da0
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jne 0x45dbc
movl $0x0, -0x4(%rbp)
jmp 0x45e59
cmpl $0xb, -0x18(%rbp)
je 0x45dc4
jmp 0x45e33
cmpl $0x0, -0x14(%rbp)
jne 0x45dd6
movl $0x0, -0x4(%rbp)
jmp 0x45e59
jmp 0x45dd8
jmp 0x45dda
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movw $0x1, -0x1c(%rbp)
movw $0x0, -0x1a(%rbp)
movl -0x14(%rbp), %edx
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x105b0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x45e0d
jmp 0x45e29
movq -0x10(%rbp), %rdi
callq 0x46da0
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x45e20
jmp 0x45e33
movl $0x0, -0x4(%rbp)
jmp 0x45e59
callq 0xf0a0
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x4, %eax
je 0x45e4a
jmp 0x45e40
movl -0x24(%rbp), %eax
subl $0xb, %eax
jne 0x45e53
jmp 0x45e4a
movl $0x0, -0x4(%rbp)
jmp 0x45e59
movl -0x18(%rbp), %eax
movl %eax, -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/notify.c
// Function: in_post
static int in_post(struct notify *nfy) {
	struct file *file, *next;

	for (file = LIST_FIRST(&nfy->pending); file; file = next) {
		next = LIST_NEXT(file, le);

		file->changes &= file->flags;

		if (file->changes)
			NFY_LIST_MOVE(&nfy->changed, file, le);
		else
			NFY_LIST_MOVE(&nfy->dormant, file, le);
	}

	nfy->dirty = 0;
	nfy->changes &= nfy->flags;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x45fd0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
andl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x45f3f
jmp 0x45ebc
jmp 0x45ebe
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x45edd
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
jmp 0x45ef2
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq %rax, 0x18(%rcx)
cmpq $0x0, %rax
je 0x45f1c
movq -0x10(%rbp), %rcx
addq $0x18, %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rcx
addq $0x20, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x45f3a
jmp 0x45fc1
jmp 0x45f41
jmp 0x45f43
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x45f62
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
jmp 0x45f77
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq %rax, 0x18(%rcx)
cmpq $0x0, %rax
je 0x45fa1
movq -0x10(%rbp), %rcx
addq $0x18, %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
addq $0x10, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x45fbf
jmp 0x45fc1
jmp 0x45fc3
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x45e84
movq -0x8(%rbp), %rax
movb $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
movl 0x48(%rax), %ecx
movq -0x8(%rbp), %rax
andl 0x4c(%rax), %ecx
movl %ecx, 0x4c(%rax)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/notify.c
// Function: lookup
static struct file *lookup(struct notify *nfy, const char *name, size_t namelen) {
#if ENABLE_FEN
	struct file key = { .name = (char *)name, .namelen = namelen };

	return LLRB_FIND(files, &nfy->files, &key);
#else
	struct file *key = &((union { char pad[offsetof(struct file, name) + NAME_MAX + 1]; struct file file; }){ { 0 } }).file;

	if (namelen > NAME_MAX)
		return NULL;

	memcpy(key->name, name, namelen);
	key->namelen = namelen;

	return LLRB_FIND(files, &nfy->files, key);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x188(%rbp), %rdi
xorl %esi, %esi
movl $0x160, %edx            # imm = 0x160
callq 0xf7d0
leaq -0x188(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0xff, -0x20(%rbp)
jbe 0x461d9
movq $0x0, -0x8(%rbp)
jmp 0x4620f
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xfb40
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rsi
callq 0x47060
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wahern[P]cqueues/src/lib/notify.c
// Function: notify_get
int notify_get(struct notify *nfy, const char **name) {
	struct file *file;
	int changes;

	if ((file = LIST_FIRST(&nfy->changed))) {
		NFY_LIST_MOVE(&nfy->dormant, file, le);

		if (name)
			*name = file->name;

		changes = file->changes;
		file->changes = 0;

		return changes;
	}

	if (!nfy->dirty && nfy->changes) {
		if (name)
			*name = ".";

		changes = nfy->changes;
		nfy->changes = 0;

		return changes;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x464c5
jmp 0x46414
jmp 0x46416
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x46435
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
jmp 0x4644a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq %rax, 0x18(%rcx)
cmpq $0x0, %rax
je 0x46474
movq -0x20(%rbp), %rcx
addq $0x18, %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x46492
cmpq $0x0, -0x18(%rbp)
je 0x464a8
movq -0x20(%rbp), %rcx
addq $0x60, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x46512
movq -0x10(%rbp), %rax
testb $0x1, 0x50(%rax)
jne 0x4650b
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
je 0x4650b
cmpq $0x0, -0x18(%rbp)
je 0x464ee
movq -0x18(%rbp), %rax
leaq 0x6f88(%rip), %rcx      # 0x4d473
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x4c(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x4c(%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x46512
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryo[P]shmqueue/shmserver.c
// Function: reap_items
int
reap_items()
{
	int i, nexpire;
	struct keyvalue kv;

	shmqueue_dump(shmqueue);

	nexpire = 0;
	for (i = 0; i < 5000; i++) {
#if 1
		if (!shmqueue_watermark(shmqueue))
			break;
#else
		if (shmqueue_inuse(shmqueue) < 5000)
			break;
#endif

		/* XXX: TODO */

		/* fetch from expire queue, and store to db */
		if (shmqueue_getoldest(shmqueue, &kv) != 0)
			break;

		if ((i & 0xff) == 0) {
			fprintf(stderr, "EXPIRE: key=<%s>, storage_size=%u, storage=<%s>\n",
			    KEYVALUE_KEY(&kv),
			    kv.kv_storagesize,
			    KEYVALUE_STORAGE(&kv));
			fflush(stdout);
		}

		nexpire++;
	}

	fflush(stdout);

	return nexpire;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7e0, %rsp            # imm = 0x7E0
movq 0x4e66(%rip), %rdi      # 0x6098
callq 0x1570
movl $0x0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x1388, -0x4(%rbp)     # imm = 0x1388
jge 0x12f2
movq 0x4e3f(%rip), %rdi      # 0x6098
callq 0x3940
cmpl $0x0, %eax
jne 0x1268
jmp 0x12f2
movq 0x4e29(%rip), %rdi      # 0x6098
leaq -0x7e0(%rbp), %rsi
callq 0x39a0
cmpl $0x0, %eax
je 0x1282
jmp 0x12f2
movl -0x4(%rbp), %eax
andl $0xff, %eax
cmpl $0x0, %eax
jne 0x12db
movq 0x4d62(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq -0x7e0(%rbp), %rdx
addq $0x8, %rdx
movl -0x7dc(%rbp), %ecx
leaq -0x7e0(%rbp), %r8
addq $0x8, %r8
movl -0x7e0(%rbp), %eax
addq %rax, %r8
leaq 0x2d58(%rip), %rsi      # 0x401d
movb $0x0, %al
callq 0x1070
movq 0x4cfd(%rip), %rax      # 0x5fd0
movq (%rax), %rdi
callq 0x10b0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1245
movq 0x4cd7(%rip), %rax      # 0x5fd0
movq (%rax), %rdi
callq 0x10b0
movl -0x8(%rbp), %eax
addq $0x7e0, %rsp            # imm = 0x7E0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryo[P]shmqueue/shmserver.c
// Function: main
int
main(int argc, char *argv[])
{
	int ch;
	int opt_a = 0, opt_f = 0, opt_i = 0;

	while ((ch = getopt(argc, argv, "afi")) != -1) {
		switch (ch) {
		case 'a':
			opt_a = 1;
			break;
		case 'f':
			opt_f = 1;
			break;
		case 'i':
			opt_i = 1;
			break;
		default:
			usage();
			return 1;
		}
	}
	argc -= optind;
	argv += optind;

	shmqueue = shmqueue_new(MEMID, MEMSIZE, !opt_i, 1);
	if (shmqueue == NULL) {
		shmqueue = shmqueue_new(MEMID, 0, !opt_i, 1);
		if (shmqueue == NULL)
			err(1, "shmqueue_new");
	}

	while (1) {
		if (reap_items() == 0) {
//			sleep(1);
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x2d05(%rip), %rdx      # 0x404e
callq 0x10d0
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x13a4
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x61, %eax
je 0x1377
jmp 0x1363
movl -0x24(%rbp), %eax
subl $0x66, %eax
je 0x1380
jmp 0x136d
movl -0x24(%rbp), %eax
subl $0x69, %eax
je 0x1389
jmp 0x1392
movl $0x1, -0x18(%rbp)
jmp 0x13a2
movl $0x1, -0x1c(%rbp)
jmp 0x13a2
movl $0x1, -0x20(%rbp)
jmp 0x13a2
callq 0x1200
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
jmp 0x133b
movq 0x4c2d(%rip), %rax      # 0x5fd8
movl (%rax), %ecx
movl -0x8(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x8(%rbp)
movq 0x4c1c(%rip), %rax      # 0x5fd8
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %edx
movl $0x186a0, %edi          # imm = 0x186A0
movl $0x10000000, %esi       # imm = 0x10000000
movl $0x1, %ecx
callq 0x1dc0
movq %rax, 0x4c9f(%rip)      # 0x6098
cmpq $0x0, 0x4c97(%rip)      # 0x6098
jne 0x144a
cmpl $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %edx
movl $0x186a0, %edi          # imm = 0x186A0
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %ecx
callq 0x1dc0
movq %rax, 0x4c6d(%rip)      # 0x6098
cmpq $0x0, 0x4c65(%rip)      # 0x6098
jne 0x1448
movl $0x1, %edi
leaq 0x2c11(%rip), %rsi      # 0x4052
movb $0x0, %al
callq 0x1090
jmp 0x144a
jmp 0x144c
callq 0x1220
cmpl $0x0, %eax
jne 0x1458
jmp 0x1458
jmp 0x144c
nopw (%rax,%rax)