LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/footobar.c
// Function: list2array
extern char **list2array(List *s, bool print) {
	char **argv, **av;

	if (print)
		fprint(2, "%L\n", s, " ");
	/*
	   Allocate 3 extra spots (2 for the fake execve & 1 for defaulting to
	   sh) and hide these from exec().
	*/
	argv = av = (char **) nalloc((listnel(s) + 4) * sizeof *av) + 3;
	while (s != NULL) {
		*av++ = s->w;
		s = s->n;
	}
	*av = NULL;
	return argv;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x5235
leaq 0xf482(%rip), %rsi      # 0x146a1
leaq 0xf34b(%rip), %rcx      # 0x14571
movl $0x2, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xb06f
movq %rbx, %rdi
callq 0x9802
cltq
leaq 0x20(,%rax,8), %rdi
callq 0x9f28
addq $0x18, %rax
movq %rax, %rcx
testq %rbx, %rbx
je 0x526e
movq %rax, %rcx
movq (%rbx), %rdx
movq %rdx, (%rcx)
addq $0x8, %rcx
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x525b
movq $0x0, (%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/footobar.c
// Function: get_name
extern char *get_name(char *s) {
	char *eq = strchr(s, '=');
	char *r, *result;
	int c;
	
	if (eq == NULL)
		return NULL;
	r = result = nalloc(eq - s + 1);
	while (1)
		switch (c = *s++) {
		case '=':
			*r++ = '\0';
			return result;
#if PROTECT_ENV
		case '_':
			if (*s == '_') {
				static const char hexchar[] = "0123456789abcdef";
				char *h1 = strchr(hexchar, s[1]);
				char *h2 = strchr(hexchar, s[2]);
				if (h1 != NULL && h2 != NULL) {
					*r++ = ((h1 - hexchar) << 4) | (h2 - hexchar);
					s += 3;
					break;
				}
			}
			/* FALLTHROUGH */
#endif
		default:
			*r++ = c;
			break;
		}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movl $0x3d, %esi
callq 0x3120
testq %rax, %rax
je 0x533c
subq %r15, %rax
incq %rax
movq %rax, %rdi
callq 0x9f28
leaq 0xa283(%rip), %r14      # 0xf530
movq %rax, (%rsp)
movq %rax, %r13
leaq 0x1(%r15), %rbx
movzbl (%r15), %ebp
cmpl $0x5f, %ebp
je 0x52c8
cmpl $0x3d, %ebp
jne 0x5325
jmp 0x5331
cmpb $0x5f, (%rbx)
jne 0x5325
movsbl 0x2(%r15), %esi
movl $0x11, %edx
movq %r14, %rdi
callq 0x31b0
movq %rax, %r12
movsbl 0x3(%r15), %esi
movl $0x11, %edx
movq %r14, %rdi
callq 0x31b0
testq %r12, %r12
sete %dl
testq %rax, %rax
sete %cl
orb %dl, %cl
je 0x5309
movq %rbx, %r15
jmp 0x5321
shll $0x4, %r12d
subl %r14d, %eax
orl %r12d, %eax
movb %al, (%r13)
incq %r13
addq $0x4, %r15
movq %r15, %rbx
testb %cl, %cl
je 0x52b4
movb %bpl, (%r13)
incq %r13
movq %rbx, %r15
jmp 0x52b4
movb $0x0, (%r13)
movq (%rsp), %rax
jmp 0x533e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/footobar.c
// Function: parse_var
extern List *parse_var(char *extdef) {
	char *begin, *end, *from, *to;
	int len;
	List *first, *last, *new;

	first = last = NULL;
	begin = strchr(extdef, '=');
	assert(begin); /* guaranteed by initenv() */
	while (*begin) {
		++begin;
		end = begin;
		len = 0;
		while (*end != ENV_SEP && *end != '\0') {
			if (*end == ENV_ESC) {
				++end;
				if (*end != ENV_SEP && *end != ENV_ESC) --end;
			}
			++end; ++len;
		}
		new = enew(List);
		if (last)
			last->n = new;
		else
			first = new;
		last = new;
		new->w = ealloc(len + 1);
		new->m = NULL;
		new->n = NULL;
		to = new->w;
		for (from = begin; from < end; ++from) {
			if (*from == ENV_ESC) {
				++from;
				if (*from != ENV_SEP && *from != ENV_ESC)
					--from;
			}
			*to = *from;
			++to;
		}
		*to = '\0';
		begin = end;
	}
	return first;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x3d, %esi
callq 0x3120
testq %rax, %rax
je 0x542e
movq %rax, %rbx
cmpb $0x0, (%rax)
je 0x5419
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %r15, (%rsp)
movq %r14, %rbp
movq %rbx, %r13
incq %r13
movl $0x1, %r12d
movq %r13, %rbx
movzbl (%rbx), %eax
cmpl $0x2, %eax
je 0x539f
jae 0x53ab
jmp 0x53b3
movb 0x1(%rbx), %al
decb %al
cmpb $0x2, %al
jae 0x53ab
incq %rbx
incq %rbx
incq %r12
jmp 0x5393
movl $0x18, %edi
callq 0xa0c4
movq %rax, %r14
movq %rax, %r15
testq %rbp, %rbp
je 0x53d0
movq %r14, 0x10(%rbp)
movq (%rsp), %r15
movq %r12, %rdi
callq 0xa0c4
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
cmpq %rbx, %r13
jae 0x540b
cmpb $0x2, (%r13)
jne 0x53fd
movb 0x1(%r13), %cl
decb %cl
cmpb $0x2, %cl
jae 0x53fd
incq %r13
movb (%r13), %cl
movb %cl, (%rax)
incq %rax
incq %r13
jmp 0x53e3
movb $0x0, (%rax)
cmpb $0x0, (%rbx)
jne 0x537d
jmp 0x541c
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa123(%rip), %rdi      # 0xf558
leaq 0xa122(%rip), %rsi      # 0xf55e
leaq 0xa126(%rip), %rcx      # 0xf569
movl $0xf2, %edx
callq 0x3140
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/footobar.c
// Function: parse_fn
extern Node *parse_fn(char *extdef) {
	Node *def;
	char *s, old[PRELEN];
	if ((s = strchr(extdef, '=')) == NULL)
		return NULL;
	memcpy(old, s -= (PRELEN-1), PRELEN);
	memcpy(s, PREFIX, PRELEN);
	def = parseline(s);
	memcpy(s, old, PRELEN);
	return (def == NULL || def->type != nNewfn) ? NULL : def->u[1].p;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl $0x3d, %esi
callq 0x3120
testq %rax, %rax
je 0x548b
movq %rax, %rbx
movq %rax, %rdi
addq $-0x3, %rdi
movl -0x3(%rax), %ebp
movl $0x78206e66, -0x3(%rax) # imm = 0x78206E66
callq 0x8744
movl %ebp, -0x3(%rbx)
testq %rax, %rax
je 0x548b
cmpl $0xe, (%rax)
jne 0x548b
movq 0x10(%rax), %rax
jmp 0x548d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/footobar.c
// Function: initprint
void initprint(void) {
	fmtinstall('A', Aconv);
	fmtinstall('L', Lconv);
	fmtinstall('S', Sconv);
	fmtinstall('T', Tconv);
	fmtinstall('D', Dconv);
	fmtinstall('W', Wconv);
#if PROTECT_ENV
	fmtinstall('F', Fconv);
#else
	fmtinstall('F', fmtinstall('s', NULL));
#endif
}

// Assembly:
pushq %rax
leaq 0x71(%rip), %rsi        # 0x550d
movl $0x41, %edi
callq 0xad44
leaq 0xd2(%rip), %rsi        # 0x557f
movl $0x4c, %edi
callq 0xad44
leaq 0x1a9(%rip), %rsi       # 0x5667
movl $0x53, %edi
callq 0xad44
leaq 0x2f9(%rip), %rsi       # 0x57c8
movl $0x54, %edi
callq 0xad44
leaq 0x7e8(%rip), %rsi       # 0x5cc8
movl $0x44, %edi
callq 0xad44
leaq 0x822(%rip), %rsi       # 0x5d13
movl $0x57, %edi
callq 0xad44
leaq 0x8ef(%rip), %rsi       # 0x5df1
movl $0x46, %edi
popq %rax
jmp 0xad44
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/footobar.c
// Function: Aconv
static bool Aconv(Format *f, int ignore) {
	char **a = va_arg(f->args, char **);
	if (*a != NULL) {
		fmtcat(f, *a);
		while (*++a != NULL)
			fmtprint(f, " %s", *a);
	}
	return FALSE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %ecx
cmpq $0x28, %rcx
ja 0x552b
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x5537
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq (%rax), %r15
movq (%r15), %rsi
testq %rsi, %rsi
je 0x5577
movq %rbx, %rdi
callq 0xaecb
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x5577
addq $0x10, %r15
leaq 0xa023(%rip), %r14      # 0xf581
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xaf9d
movq (%r15), %rdx
addq $0x8, %r15
testq %rdx, %rdx
jne 0x555e
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/footobar.c
// Function: Lconv
static bool Lconv(Format *f, int ignore) {
	bool plain;
	char *sep;
	List *l, *n;

	plain = f->flags & FMT_leftside;
	l = va_arg(f->args, List *);
	sep = va_arg(f->args, char *);
	if (l == NULL && (f->flags & FMT_leftside) == 0)
		fmtprint(f, "()");
	else {
		for (; l != NULL; l = n) {
			n = l->n;
			fmtprint(f, plain ? "%s" : "%-S", l->w);
			if (n != NULL) fmtputc(f, *sep);
		}
	}
	return FALSE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %ecx
cmpq $0x28, %rcx
ja 0x55a0
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x55ac
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq 0x18(%rbx), %rcx
movq (%rax), %rax
movl (%rbx), %esi
cmpq $0x28, %rsi
ja 0x55c9
movq %rsi, %rdx
addq 0x10(%rbx), %rdx
addl $0x8, %esi
movl %esi, (%rbx)
jmp 0x55d5
movq 0x8(%rbx), %rdx
leaq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rbx)
movl %ecx, %esi
andl $0x20, %esi
orq %rax, %rsi
jne 0x55f2
leaq 0x9f9f(%rip), %rsi      # 0xf585
movq %rbx, %rdi
xorl %eax, %eax
callq 0xaf9d
jmp 0x5659
testq %rax, %rax
je 0x5659
movq (%rdx), %r15
testb $0x20, %cl
leaq 0x9f84(%rip), %rcx      # 0xf588
leaq 0x9f77(%rip), %r14      # 0xf582
cmoveq %rcx, %r14
movq (%rax), %rdx
movq 0x10(%rax), %r12
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xaf9d
testq %r12, %r12
je 0x5659
movq 0x30(%rbx), %rax
cmpq 0x40(%rbx), %rax
jb 0x563d
movl $0x1, %esi
movq %rbx, %rdi
callq *0x50(%rbx)
movb (%r15), %al
movq 0x30(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x30(%rbx)
movb %al, (%rcx)
movq (%r12), %rdx
movq 0x10(%r12), %r12
jmp 0x5616
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/footobar.c
// Function: Sconv
static bool Sconv(Format *f, int ignore) {
	int c;
	unsigned char *s = va_arg(f->args, unsigned char *), *t = s;
	bool quoted    = (f->flags & FMT_altform)  != 0;	/* '#' */
	bool metaquote = (f->flags & FMT_leftside) != 0;	/* '-' */
	if (*s == '\0') {
		fmtprint(f, "''");
		return FALSE;
	}
	if (!quoted) {
		while ((c = *t++) != '\0')
			if (nw[c] == 1 || (metaquote && ISMETA(c)))
				goto quoteit;
		fmtprint(f, "%s", s);
		return FALSE;
	}
quoteit:
	fmtputc(f, '\'');
	while ((c = *s++) != '\0') {
		fmtputc(f, c);
		if (c == '\'')
			fmtputc(f, '\'');

	}
	fmtputc(f, '\'');
	return FALSE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %ecx
cmpq $0x28, %rcx
ja 0x5684
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x5690
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq (%rax), %r14
cmpb $0x0, (%r14)
je 0x57b0
movq 0x18(%rbx), %rax
testb $0x40, %al
jne 0x5702
movb (%r14), %dil
testb %dil, %dil
je 0x56e9
leaq 0x1(%r14), %rcx
leaq 0xa2b8(%rip), %rdx      # 0xf970
movabsq $0x2000000200001, %rsi  # imm = 0x2000000200001
movzbl %dil, %edi
cmpb $0x1, (%rdx,%rdi)
je 0x5702
testb $0x20, %al
je 0x56de
addl $-0x2a, %edi
cmpl $0x31, %edi
ja 0x56de
btq %rdi, %rsi
jb 0x5702
movb (%rcx), %dil
incq %rcx
testb %dil, %dil
jne 0x56c2
leaq 0x9e92(%rip), %rsi      # 0xf582
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xaf9d
jmp 0x57c1
movq 0x30(%rbx), %rax
cmpq 0x40(%rbx), %rax
jb 0x5717
movl $0x1, %esi
movq %rbx, %rdi
callq *0x50(%rbx)
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
movb $0x27, (%rax)
movb (%r14), %bpl
testb %bpl, %bpl
je 0x578a
incq %r14
movq 0x30(%rbx), %rax
cmpq 0x40(%rbx), %rax
jb 0x5746
movl $0x1, %esi
movq %rbx, %rdi
callq *0x50(%rbx)
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
movb %bpl, (%rax)
cmpb $0x27, %bpl
jne 0x577f
movq 0x30(%rbx), %rax
cmpq 0x40(%rbx), %rax
jb 0x5770
movl $0x1, %esi
movq %rbx, %rdi
callq *0x50(%rbx)
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
movb $0x27, (%rax)
movb (%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0x5731
movq 0x30(%rbx), %rax
cmpq 0x40(%rbx), %rax
jb 0x579f
movl $0x1, %esi
movq %rbx, %rdi
callq *0x50(%rbx)
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
movb $0x27, (%rax)
jmp 0x57c1
leaq 0x9dd5(%rip), %rsi      # 0xf58c
movq %rbx, %rdi
xorl %eax, %eax
callq 0xaf9d
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/footobar.c
// Function: Dconv
static bool Dconv(Format *f, int ignore) {
	const char *name = "?";
	int n = va_arg(f->args, int);
	switch (n) {
	case rCreate:		name = ">";	break;
	case rAppend:		name = ">>";	break;
	case rFrom:		name = "<";	break;
	case rHeredoc:		name = "<<";	break;
	case rHerestring:	name = "<<<";	break;
	}
	fmtcat(f, name);
	return FALSE;
}

// Assembly:
movl (%rdi), %ecx
cmpq $0x28, %rcx
ja 0x5cde
movq %rcx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x5cea
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movl (%rax), %eax
cmpq $0x4, %rax
ja 0x5d02
leaq 0x984b(%rip), %rcx      # 0xf544
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
jmp 0x5d09
leaq 0x9981(%rip), %rsi      # 0xf68a
pushq %rax
callq 0xaecb
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/footobar.c
// Function: Wconv
static bool Wconv(Format *f, int ignore) {
	List *l, *n;

	l = va_arg(f->args, List *);
	for (; l != NULL; l = n) {
		char c, *s;

		for (s = l->w; (c = *s) != '\0'; ++s) {
			if (c == ENV_SEP || c == ENV_ESC)
				fmtputc(f, ENV_ESC);
			fmtputc(f, c);
		}
		n = l->n;
		if (n != NULL) fmtputc(f, ENV_SEP);
	}
	return FALSE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %ecx
cmpq $0x28, %rcx
ja 0x5d33
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x5d3f
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq (%rax), %r14
testq %r14, %r14
je 0x5de4
movq (%r14), %r15
movb (%r15), %bpl
testb %bpl, %bpl
je 0x5db2
incq %r15
cmpb $0x2, %bpl
ja 0x5d83
movq 0x30(%rbx), %rax
cmpq 0x40(%rbx), %rax
jb 0x5d74
movl $0x1, %esi
movq %rbx, %rdi
callq *0x50(%rbx)
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
movb $0x2, (%rax)
movq 0x30(%rbx), %rax
cmpq 0x40(%rbx), %rax
jb 0x5d98
movl $0x1, %esi
movq %rbx, %rdi
callq *0x50(%rbx)
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
movb %bpl, (%rax)
movb (%r15), %bpl
incq %r15
testb %bpl, %bpl
jne 0x5d59
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x5de4
movq 0x30(%rbx), %rax
cmpq 0x40(%rbx), %rax
jb 0x5dd0
movl $0x1, %esi
movq %rbx, %rdi
callq *0x50(%rbx)
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
movb $0x1, (%rax)
jmp 0x5d4b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/footobar.c
// Function: Fconv
static bool Fconv(Format *f, int ignore) {
	unsigned const char *s = va_arg(f->args, unsigned const char *);
	int c;

	while ((c = *s++) != '\0')
		if (dnw[c] || c == '*' || (c == '_' && *s == '_'))
			fmtprint(f, "__%02x", c);
		else
			fmtputc(f, c);
	return FALSE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %ecx
cmpq $0x28, %rcx
ja 0x5e12
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x5e1e
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq (%rax), %r15
movb (%r15), %bpl
testb %bpl, %bpl
je 0x5e94
incq %r15
leaq 0x9c3d(%rip), %r12      # 0xfa70
leaq 0x9859(%rip), %r14      # 0xf693
movzbl %bpl, %edx
cmpb $0x2a, %dl
je 0x5e56
cmpb $0x0, (%r12,%rdx)
jne 0x5e56
cmpb $0x5f, %bpl
jne 0x5e65
cmpb $0x5f, (%r15)
jne 0x5e65
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xaf9d
jmp 0x5e89
movq 0x30(%rbx), %rax
cmpq 0x40(%rbx), %rax
jb 0x5e7a
movl $0x1, %esi
movq %rbx, %rdi
callq *0x50(%rbx)
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
movb %bpl, (%rax)
movb (%r15), %bpl
incq %r15
testb %bpl, %bpl
jne 0x5e3a
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/glob.c
// Function: lmatch
extern bool lmatch(List *s, List *p) {
	List *q;
	if (s == NULL) {
		if (p == NULL) /* null matches null */
			return TRUE;
		for (; p != NULL; p = p->n) /* one or more stars match null */
			if (strspn(p->w, "*") == strlen(p->w) &&
			    p->m != NULL && strlen(p->m) == strlen(p->w))
				return TRUE;
		return FALSE;
	}
	for (; s != NULL; s = s->n)
		for (q = p; q != NULL; q = q->n)
			if (match(q->w, q->m, s->w))
				return TRUE;
	return FALSE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x60a1
movq %rdi, %r14
testq %rbx, %rbx
je 0x608f
movq %rbx, %r15
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq (%r14), %rdx
callq 0x9d6c
testl %eax, %eax
jne 0x609a
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x6073
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x606b
jmp 0x60ef
movl $0x1, %ebp
jmp 0x60f1
movl $0x1, %ebp
testq %rbx, %rbx
je 0x60f1
leaq 0x8faa(%rip), %r14      # 0xf05c
movq (%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3190
movq %rax, %r12
movq %r15, %rdi
callq 0x30f0
cmpq %rax, %r12
jne 0x60e6
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x60e6
movq %rax, %r15
callq 0x30f0
cmpq %r15, %rax
je 0x60f1
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x60b2
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/glob.c
// Function: glob
extern List *glob(List *s) {
	List *top, *r;
	bool meta;
	for (r = s, meta = FALSE; r != NULL; r = r->n)
		if (r->m != NULL)
			meta = TRUE;
	if (!meta)
		return s; /* don't copy lists with no metacharacters in them */
	for (top = r = NULL; s != NULL; s = s->n) {
		if (s->m == NULL) { /* no metacharacters; just tack on to the return list */
			if (top == NULL)
				top = r = nnew(List);
			else
				r = r->n = nnew(List);
			r->w = s->w;
		} else {
			if (top == NULL)
				top = r = sort(doglob(s->w, s->m));
			else
				r->n = sort(doglob(s->w, s->m));
			while (r->n != NULL)
				r = r->n;
		}
	}
	r->n = NULL;
	return top;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x61ae
xorl %eax, %eax
movl $0x1, %ecx
movq %rbx, %rdx
cmpq $0x0, 0x8(%rdx)
cmovnel %ecx, %eax
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
jne 0x611a
testl %eax, %eax
je 0x61ae
xorl %r12d, %r12d
xorl %r14d, %r14d
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x615d
movq (%rbx), %rdi
callq 0x621d
movq %rax, %r15
movq %rax, %rdi
callq 0x61c0
testq %r14, %r14
je 0x6185
movq %r15, 0x10(%r12)
jmp 0x618b
movl $0x18, %edi
callq 0x9f28
movq %rax, %rcx
testq %r14, %r14
je 0x6177
movq %rax, 0x10(%r12)
movq %r14, %rcx
movq (%rbx), %rdx
movq %rdx, (%rax)
movq %rcx, %r14
movq %rax, %r12
jmp 0x619a
movq %r15, %r14
movq %r15, %r12
movq %r12, %rax
movq %rax, %r12
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x618e
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x6135
movq $0x0, 0x10(%r12)
jmp 0x61b1
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/glob.c
// Function: sort
static List *sort(List *s) {
	size_t nel = listnel(s);
	if (nel > 1) {
		char **a;
		List *t;
		qsort(a = list2array(s, FALSE), nel, sizeof(char *), starstrcmp);
		for (t = s; t != NULL; t = t->n)
			t->w = *a++;
	}
	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x9802
cmpl $0x2, %eax
jb 0x6214
movslq %eax, %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5210
movq %rax, %r14
leaq 0x66d4(%rip), %rcx      # 0xc8bd
movl $0x8, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3080
testq %rbx, %rbx
je 0x6214
movq %rbx, %rax
movq (%r14), %rcx
addq $0x8, %r14
movq %rcx, (%rax)
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x6201
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/glom.c
// Function: word
extern List *word(char *w, char *m) {
	List *s = NULL;
	if (w != NULL) {
		s = nnew(List);
		s->w = w;
		s->m = m;
		s->n = NULL;
	}
	return s;
}

// Assembly:
testq %rdi, %rdi
je 0x6744
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x18, %edi
callq 0x9f28
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq $0x0, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/glom.c
// Function: append
extern List *append(List *s1, List *s2) {
	List *r, *top;
	if (s1 == NULL)
		return s2;
	if (s2 == NULL)
		return s1;
	for (r = top = nnew(List); 1; r = r->n = nnew(List)) {
		r->w = s1->w;
		r->m = s1->m;
		if ((s1 = s1->n) == NULL)
			break;
	}
	r->n = s2;
	return top;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x67b8
movq %rdi, %r15
testq %rbx, %rbx
je 0x67bd
movl $0x18, %edi
callq 0x9f28
movq %rax, %r14
movq (%r15), %rax
movq %rax, (%r14)
movq 0x8(%r15), %rax
movq %rax, 0x8(%r14)
movq 0x10(%r15), %r15
movq %r14, %rax
testq %r15, %r15
je 0x67b2
movq %r14, %r12
movl $0x18, %edi
callq 0x9f28
movq %rax, 0x10(%r12)
movq (%r15), %rcx
movq %rcx, (%rax)
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%r15), %r15
movq %rax, %r12
testq %r15, %r15
jne 0x6789
movq %rbx, 0x10(%rax)
jmp 0x67c0
movq %rbx, %r14
jmp 0x67c0
movq %r15, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/glom.c
// Function: concat
extern List *concat(List *s1, List *s2) {
	int n1, n2;
	List *r, *top;
	if (s1 == NULL)
		return s2;
	if (s2 == NULL)
		return s1;
	if ((n1 = listnel(s1)) != (n2 = listnel(s2)) && n1 != 1 && n2 != 1)
		rc_error("bad concatenation");
	for (r = top = nnew(List); 1; r = r->n = nnew(List)) {
		size_t x = strlen(s1->w);
		size_t y = strlen(s2->w);
		size_t z = x + y + 1;
		r->w = nalloc(z);
		strcpy(r->w, s1->w);
		strcat(r->w, s2->w);
		if (s1->m == NULL && s2->m == NULL) {
			r->m = NULL;
		} else {
			r->m = nalloc(z);
			if (s1->m == NULL)
				memzero(r->m, x);
			else
				memcpy(r->m, s1->m, x);
			if (s2->m == NULL)
				memzero(&r->m[x], y);
			else
				memcpy(&r->m[x], s2->m, y);
			r->m[z] = 0;
		}
		if (n1 > 1)
			s1 = s1->n;
		if (n2 > 1)
			s2 = s2->n;
		if (s1 == NULL || s2 == NULL || (n1 == 1 && n2 == 1))
			break;
	}
	r->n = NULL;
	return top;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x6955
movq %rdi, %r14
testq %rbx, %rbx
je 0x695a
movq %r14, %rdi
callq 0x9802
movl %eax, %ebp
movq %rbx, %rdi
callq 0x9802
movl %eax, 0x8(%rsp)
cmpl $0x1, %eax
je 0x6827
cmpl $0x1, %ebp
je 0x6827
cmpl 0x8(%rsp), %ebp
je 0x6827
leaq 0x8eba(%rip), %rdi      # 0xf6dc
callq 0x47be
movl $0x18, %edi
callq 0x9f28
movq %rax, %r15
movl %ebp, 0xc(%rsp)
xorl $0x1, %ebp
movl 0x8(%rsp), %ecx
xorl $0x1, %ecx
orl %ebp, %ecx
setne 0x7(%rsp)
movq %rax, 0x10(%rsp)
movq (%r14), %rdi
callq 0x30f0
movq %rax, %r12
movq (%rbx), %rdi
callq 0x30f0
movq %rax, %rbp
leaq (%r12,%rax), %r13
incq %r13
movq %r13, %rdi
callq 0x9f28
movq %rax, (%r15)
movq (%r14), %rsi
movq %rax, %rdi
callq 0x3070
movq (%r15), %rdi
movq (%rbx), %rsi
callq 0x3310
cmpq $0x0, 0x8(%r14)
jne 0x689e
cmpq $0x0, 0x8(%rbx)
je 0x693c
movq %r13, %rdi
callq 0x9f28
movq %rax, 0x8(%r15)
movq 0x8(%r14), %rsi
movq %rax, %rdi
testq %rsi, %rsi
je 0x68c0
movq %r12, %rdx
callq 0x3230
jmp 0x68ca
xorl %esi, %esi
movq %r12, %rdx
callq 0x3150
movq 0x8(%rbx), %rsi
addq 0x8(%r15), %r12
movq %r12, %rdi
testq %rsi, %rsi
je 0x68e4
movq %rbp, %rdx
callq 0x3230
jmp 0x68ee
xorl %esi, %esi
movq %rbp, %rdx
callq 0x3150
movq 0x8(%r15), %rax
movb $0x0, (%rax,%r13)
movl 0xc(%rsp), %eax
cmpl $0x2, %eax
jl 0x6904
movq 0x10(%r14), %r14
cmpl $0x2, 0x8(%rsp)
jl 0x690f
movq 0x10(%rbx), %rbx
testq %r14, %r14
setne %al
testq %rbx, %rbx
setne %cl
andb %al, %cl
andb 0x7(%rsp), %cl
cmpb $0x1, %cl
jne 0x6946
movl $0x18, %edi
callq 0x9f28
movq %rax, 0x10(%r15)
movq %rax, %r15
jmp 0x684e
movq $0x0, 0x8(%r15)
jmp 0x68f7
movq $0x0, 0x10(%r15)
movq 0x10(%rsp), %rax
jmp 0x695d
movq %rbx, %rax
jmp 0x695d
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/glom.c
// Function: varsub
extern List *varsub(List *var, List *subs) {
	List *r, *top;
	int n = listnel(var);
	for (top = r = NULL; subs != NULL; subs = subs->n) {
		int i = a2u(subs->w);
		if (i < 1)
			rc_error("bad subscript");
		if (i <= n) {
			List *sub = var;
			while (--i)
				sub = sub->n; /* loop until sub == var(i) */
			if (top == NULL)
				top = r = nnew(List);
			else
				r = r->n = nnew(List);
			r->w = sub->w;
			r->m = sub->m;
		}
	}
	if (top != NULL)
		r->n = NULL;
	return top;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, (%rsp)
callq 0x9802
testq %rbx, %rbx
je 0x6a0d
movl %eax, %ebp
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rbx), %rdi
movl $0xa, %esi
callq 0xc890
movl %eax, %r13d
testl %eax, %eax
jg 0x69b4
leaq 0x8d3f(%rip), %rdi      # 0xf6ee
callq 0x47be
cmpl %ebp, %r13d
jle 0x69be
movq %r12, %rax
jmp 0x6a02
movq (%rsp), %r14
decl %r13d
je 0x69d4
movq (%rsp), %r14
movq 0x10(%r14), %r14
decl %r13d
jne 0x69cb
movl $0x18, %edi
callq 0x9f28
movq %rax, %rcx
testq %r15, %r15
je 0x69ee
movq %rax, 0x10(%r12)
movq %r15, %rcx
movq (%r14), %rdx
movq %rdx, (%rax)
movq 0x8(%r14), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, %r15
movq %rax, %r12
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x6994
jmp 0x6a12
xorl %eax, %eax
xorl %r15d, %r15d
testq %r15, %r15
je 0x6a1f
movq $0x0, 0x10(%rax)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/glom.c
// Function: flatten
extern List *flatten(List *s) {
	List *r;
	size_t step;
	char *f;
	if (s == NULL || s->n == NULL)
		return s;
	r = nnew(List);
	f = r->w = nalloc(listlen(s) + 1);
	r->m = NULL; /* flattened lists come from variables, so no meta */
	r->n = NULL;
	strcpy(f, s->w);
	f += strlen(s->w);
	do {
		*f++ = ' ';
		s = s->n;
		step = strlen(s->w);
		memcpy(f, s->w, step);
		f += step;
	} while (s->n != NULL);
	*f = '\0';
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x6ad3
cmpq $0x0, 0x10(%rbx)
je 0x6ad3
movl $0x18, %edi
callq 0x9f28
movq %rax, %r14
movq %rbx, %rdi
callq 0x97ce
leaq 0x1(%rax), %rdi
callq 0x9f28
movq %rax, %r12
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x3070
movq (%rbx), %rdi
callq 0x30f0
movq %rax, %r15
addq %r12, %r15
leaq 0x1(%r15), %r12
movb $0x20, (%r15)
movq 0x10(%rbx), %rbx
movq (%rbx), %r13
movq %r13, %rdi
callq 0x30f0
movq %rax, %rbp
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x3230
addq %rbp, %r15
incq %r15
cmpq $0x0, 0x10(%rbx)
jne 0x6a98
movb $0x0, (%r15)
jmp 0x6ad6
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/glom.c
// Function: assign
extern void assign(List *s1, List *s2, bool stack) {
	List *val = s2;
	if (s1 == NULL)
		rc_error("null variable name");
	if (s1->n != NULL)
		rc_error("multi-word variable name");
	if (*s1->w == '\0')
		rc_error("zero-length variable name");
	if (a2u(s1->w) != -1)
		rc_error("numeric variable name");
	if (strchr(s1->w, '=') != NULL)
		rc_error("'=' in variable name");
	if (*s1->w == '*' && s1->w[1] == '\0')
		val = append(varlookup("0"), s2); /* preserve $0 when * is assigned explicitly */
	if (s2 != NULL || stack) {
		if (dashex)
			prettyprint_var(2, s1->w, val);
		varassign(s1->w, val, stack);
		alias(s1->w, varlookup(s1->w), stack);
	} else {
		if (dashex)
			prettyprint_var(2, s1->w, NULL);
		varrm(s1->w, stack);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x6b08
leaq 0x8bf9(%rip), %rdi      # 0xf6fc
callq 0x47be
cmpq $0x0, 0x10(%rbx)
je 0x6b1b
leaq 0x8bf9(%rip), %rdi      # 0xf70f
callq 0x47be
movq (%rbx), %rax
cmpb $0x0, (%rax)
jne 0x6b2f
leaq 0x8bfe(%rip), %rdi      # 0xf728
callq 0x47be
movq (%rbx), %rdi
movl $0xa, %esi
callq 0xc890
cmpl $-0x1, %eax
je 0x6b4d
leaq 0x8bfa(%rip), %rdi      # 0xf742
callq 0x47be
movq (%rbx), %rdi
movl $0x3d, %esi
callq 0x3120
testq %rax, %rax
je 0x6b6b
leaq 0x8bf2(%rip), %rdi      # 0xf758
callq 0x47be
movq (%rbx), %rax
cmpb $0x2a, (%rax)
movq %r14, %r15
jne 0x6b99
cmpb $0x0, 0x1(%rax)
movq %r14, %r15
jne 0x6b99
leaq 0xd3eb(%rip), %rdi      # 0x13f71
callq 0xcaf4
movq %rax, %rdi
movq %r14, %rsi
callq 0x6747
movq %rax, %r15
testq %r14, %r14
sete %cl
testl %ebp, %ebp
sete %dl
leaq 0x13045(%rip), %rax     # 0x19bf0
movl (%rax), %eax
testb %dl, %cl
jne 0x6bf4
testl %eax, %eax
je 0x6bc5
movq (%rbx), %rsi
movl $0x2, %edi
movq %r15, %rdx
callq 0xcebb
movq (%rbx), %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xc918
movq (%rbx), %rbx
movq %rbx, %rdi
callq 0xcaf4
movq %rbx, %rdi
movq %rax, %rsi
movl %ebp, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xcaaf
testl %eax, %eax
je 0x6c07
movq (%rbx), %rsi
movl $0x2, %edi
xorl %edx, %edx
callq 0xcebb
movq (%rbx), %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xcc64
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/glom.c
// Function: qredir
extern void qredir(Node *n) {
	Rq *next;
	if (redirq == NULL) {
		next = redirq = nnew(Rq);
	} else {
		for (next = redirq; next->n != NULL; next = next->n)
			;
		next->n = nnew(Rq);
		next = next->n;
	}
	next->r = n;
	next->n = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x12e9f(%rip), %rax     # 0x19ac8
testq %rax, %rax
je 0x6c40
movq %rax, %r14
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x6c2e
addq $0x8, %r14
jmp 0x6c47
leaq 0x12e81(%rip), %r14     # 0x19ac8
movl $0x10, %edi
callq 0x9f28
movq %rax, (%r14)
movq %rbx, (%rax)
movq $0x0, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/glom.c
// Function: count
static List *count(List *l) {
	List *s = nnew(List);
	s->w = nprint("%d", listnel(l));
	s->n = NULL;
	s->m = NULL;
	return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x18, %edi
callq 0x9f28
movq %rax, %r14
movq %rbx, %rdi
callq 0x9802
leaq 0x84a2(%rip), %rdi      # 0xf7a5
movl %eax, %esi
xorl %eax, %eax
callq 0xb274
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/hash.c
// Function: inithash
extern void inithash() {
	Htab *fpp, *vpp;
	int i;
	fp = ealloc(sizeof(Htab) * HASHSIZE);
	vp = ealloc(sizeof(Htab) * HASHSIZE);
	fused = vused = 0;
	fsize = vsize = HASHSIZE;
	for (vpp = vp, fpp = fp, i = 0; i < HASHSIZE; i++, vpp++, fpp++)
		vpp->name = fpp->name = NULL;
}

// Assembly:
pushq %rax
movl $0x400, %edi            # imm = 0x400
callq 0xa0c4
movq %rax, 0x1279a(%rip)     # 0x19ad0
movl $0x400, %edi            # imm = 0x400
callq 0xa0c4
movq %rax, 0x12791(%rip)     # 0x19ad8
xorl %ecx, %ecx
movl %ecx, 0x12791(%rip)     # 0x19ae0
movl %ecx, 0x1278f(%rip)     # 0x19ae4
movl $0x40, %edx
movl %edx, 0x12788(%rip)     # 0x19ae8
movl %edx, 0x12786(%rip)     # 0x19aec
movq 0x12763(%rip), %rdx     # 0x19ad0
xorl %esi, %esi
movq %rcx, (%rdx,%rsi)
movq %rcx, (%rax,%rsi)
addq $0x10, %rsi
cmpl $0x400, %esi            # imm = 0x400
jne 0x736f
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/hash.c
// Function: find
static int find(char *s, Htab *ht, int size) {
	int h = hash(s, size);
	while (ht[h].name != NULL && !streq(ht[h].name, s)) {
		h++;
		h &= size - 1;
	}
	return h;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %esi
callq 0x7e55
movl %eax, %ebx
movl %eax, %eax
shlq $0x4, %rax
movq (%r14,%rax), %rdi
testq %rdi, %rdi
je 0x7415
movb (%r15), %r12b
decl %ebp
cmpb %r12b, (%rdi)
jne 0x7401
movq %r15, %rsi
callq 0x31f0
testl %eax, %eax
je 0x7415
incl %ebx
andl %ebp, %ebx
movq %rbx, %rax
shlq $0x4, %rax
movq (%r14,%rax), %rdi
testq %rdi, %rdi
jne 0x73f0
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/hash.c
// Function: get_fn_place
extern rc_Function *get_fn_place(char *s) {
	int h = fnfind(s);
	env_dirty = TRUE;
	if (fp[h].name == NULL) {
		if (rehash(fp))
			h = fnfind(s);
		fused++;
		fp[h].name = ecpy(s);
		fp[h].p = enew(rc_Function);
	} else
		free_fn(fp[h].p);
	return fp[h].p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x126a1(%rip), %r15     # 0x19ad0
movl 0x126b7(%rip), %edx     # 0x19aec
movq %r15, %rsi
callq 0x73c3
movl %eax, %ebx
movb $0x0, 0x126aa(%rip)     # 0x19af0
movl %eax, %eax
shlq $0x4, %rax
cmpq $0x0, (%r15,%rax)
je 0x746d
addq %rax, %r15
movq 0x8(%r15), %r14
movq (%r14), %rdi
callq 0xc724
movq 0x8(%r14), %rdi
callq 0xa095
jmp 0x74dd
movq %r15, %rdi
callq 0x74f5
testl %eax, %eax
je 0x7490
movq 0x12650(%rip), %rsi     # 0x19ad0
movl 0x12666(%rip), %edx     # 0x19aec
movq %r14, %rdi
callq 0x73c3
movl %eax, %ebx
incl 0x1264e(%rip)           # 0x19ae4
movq %r14, %rdi
callq 0x30f0
leaq 0x1(%rax), %rdi
callq 0xa0c4
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x3070
movq 0x12614(%rip), %rax     # 0x19ad0
movl %ebx, %r14d
shlq $0x4, %r14
movq %r15, (%rax,%r14)
movl $0x10, %edi
callq 0xa0c4
movq 0x125f8(%rip), %rcx     # 0x19ad0
movq %rax, 0x8(%rcx,%r14)
movq 0x125ec(%rip), %rax     # 0x19ad0
movl %ebx, %ecx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/hash.c
// Function: rehash
static bool rehash(Htab *ht) {
	int i, j, size;
	int newsize, newused;
	Htab *newhtab;
	if (ht == fp) {
		if (fsize > 2 * fused)
			return FALSE;
		size = fsize;
	} else {
		if (vsize > 2 * vused)
			return FALSE;
		size = vsize;
	}
	newsize = 2 * size;
	newhtab = ealloc(newsize * sizeof(Htab));
	for (i = 0; i < newsize; i++)
		newhtab[i].name = NULL;
	for (i = newused = 0; i < size; i++)
		if (ht[i].name != NULL && ht[i].name != dead) {
			newused++;
			j = hash(ht[i].name, newsize);
			while (newhtab[j].name != NULL) {
				j++;
				j &= (newsize - 1);
			}
			newhtab[j].name = ht[i].name;
			newhtab[j].p = ht[i].p;
		}
	if (ht == fp) {
		fused = newused;
		fp = newhtab;
		fsize = newsize;
	} else {
		vused = newused;
		vp = newhtab;
		vsize = newsize;
	}
	efree(ht);
	return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq %rdi, 0x125c6(%rip)     # 0x19ad0
je 0x751b
movl 0x125d5(%rip), %r14d    # 0x19ae8
movl 0x125c7(%rip), %eax     # 0x19ae0
jmp 0x7528
movl 0x125ca(%rip), %r14d    # 0x19aec
movl 0x125bc(%rip), %eax     # 0x19ae4
addl %eax, %eax
cmpl %eax, %r14d
jle 0x7536
xorl %eax, %eax
jmp 0x766a
movq %rdi, 0x8(%rsp)
leal (%r14,%r14), %eax
movq %rax, (%rsp)
movslq %eax, %rdi
shlq $0x4, %rdi
callq 0xa0c4
movq %rax, %r15
testl %r14d, %r14d
jle 0x757d
movq (%rsp), %rcx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
shlq $0x4, %rax
xorl %ecx, %ecx
movq $0x0, (%r15,%rcx)
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x756c
testl %r14d, %r14d
movq 0x8(%rsp), %rdi
jle 0x7614
movq (%rsp), %rax
leal -0x1(%rax), %r13d
movl %r14d, %edx
xorl %ebp, %ebp
leaq 0x8838(%rip), %rsi      # 0xfdd7
xorl %r14d, %r14d
movq %rdx, 0x10(%rsp)
movq %rbp, %rbx
shlq $0x4, %rbx
movq (%rdi,%rbx), %r12
testq %r12, %r12
sete %al
cmpq %rsi, %r12
sete %cl
orb %al, %cl
jne 0x760a
movq %r12, %rdi
movq (%rsp), %rsi
callq 0x7e55
movl %eax, %ecx
shlq $0x4, %rcx
cmpq $0x0, (%r15,%rcx)
je 0x75e5
incl %eax
andl %r13d, %eax
movq %rax, %rcx
jmp 0x75d0
addq %r15, %rcx
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x87de(%rip), %rsi      # 0xfdd7
addq %rdi, %rbx
incl %r14d
movq %r12, (%rcx)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%rcx)
incq %rbp
cmpq %rdx, %rbp
jne 0x75a7
jmp 0x7617
xorl %r14d, %r14d
cmpq %rdi, 0x124b2(%rip)     # 0x19ad0
leaq 0x124bf(%rip), %rax     # 0x19ae4
leaq 0x124b4(%rip), %rcx     # 0x19ae0
cmoveq %rax, %rcx
leaq 0x12499(%rip), %rax     # 0x19ad0
leaq 0x1249a(%rip), %rdx     # 0x19ad8
cmoveq %rax, %rdx
leaq 0x124a3(%rip), %rax     # 0x19aec
leaq 0x12498(%rip), %rsi     # 0x19ae8
cmoveq %rax, %rsi
movl %r14d, (%rcx)
movq %r15, (%rdx)
movq (%rsp), %rax
movl %eax, (%rsi)
callq 0xa095
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/hash.c
// Function: get_var_place
extern Variable *get_var_place(char *s, bool stack) {
	Variable *new;
	int h = varfind(s);

	env_dirty = TRUE;

	if (vp[h].name == NULL) {
		if (rehash(vp))
			h = varfind(s);
		vused++;
		vp[h].name = ecpy(s);
		vp[h].p = enew(Variable);
		((Variable *)vp[h].p)->n = NULL;
		return vp[h].p;
	} else {
		if (stack) {	/* increase the stack by 1 */
			new = enew(Variable);
			new->n = vp[h].p;
			return vp[h].p = new;
		} else {	/* trample the top of the stack */
			new = vp[h].p;
			efree(new->extdef);
			listfree(new->def);
			return new;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r15d
movq %rdi, %rbx
movq 0x1244a(%rip), %r14     # 0x19ad8
movl 0x12454(%rip), %edx     # 0x19ae8
movq %r14, %rsi
callq 0x73c3
movb $0x0, 0x1244d(%rip)     # 0x19af0
movl %eax, %r12d
shlq $0x4, %r12
cmpq $0x0, (%r14,%r12)
je 0x76e1
testl %r15d, %r15d
je 0x7768
movl $0x18, %edi
callq 0xa0c4
movq %rax, %rbx
movq 0x1240a(%rip), %rax     # 0x19ad8
movq 0x8(%rax,%r12), %rcx
movq %rcx, 0x10(%rbx)
movq %rbx, 0x8(%rax,%r12)
jmp 0x7780
movl %eax, %ebp
movq %r14, %rdi
callq 0x74f5
testl %eax, %eax
je 0x7706
movq 0x123e2(%rip), %rsi     # 0x19ad8
movl 0x123ec(%rip), %edx     # 0x19ae8
movq %rbx, %rdi
callq 0x73c3
movl %eax, %ebp
incl 0x123d4(%rip)           # 0x19ae0
movq %rbx, %rdi
callq 0x30f0
leaq 0x1(%rax), %rdi
callq 0xa0c4
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3070
movq 0x123a6(%rip), %rax     # 0x19ad8
movl %ebp, %ebx
shlq $0x4, %rbx
movq %r14, (%rax,%rbx)
movl $0x18, %edi
callq 0xa0c4
movq 0x1238b(%rip), %rcx     # 0x19ad8
movq %rax, 0x8(%rcx,%rbx)
movq 0x1237f(%rip), %rax     # 0x19ad8
movq 0x8(%rax,%rbx), %rbx
movq $0x0, 0x10(%rbx)
jmp 0x7780
addq %r12, %r14
movq 0x8(%r14), %rbx
movq 0x8(%rbx), %rdi
callq 0xa095
movq (%rbx), %rdi
callq 0x9710
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/hash.c
// Function: delete_fn
extern void delete_fn(char *s) {
	int h = fnfind(s);
	if (fp[h].name == NULL)
		return; /* not found */
	env_dirty = TRUE;
	free_fn(fp[h].p);
	efree(fp[h].p);
	efree(fp[h].name);
	if (fp[(h+1)&(fsize-1)].name == NULL) {
		--fused;
		fp[h].name = NULL;
	} else {
		fp[h].name = dead;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x12338(%rip), %rbx     # 0x19ad0
movl 0x1234e(%rip), %edx     # 0x19aec
movq %rbx, %rsi
callq 0x73c3
movl %eax, %r15d
movq %r15, %r14
shlq $0x4, %r14
cmpq $0x0, (%rbx,%r14)
je 0x782d
movb $0x0, 0x12332(%rip)     # 0x19af0
movq 0x8(%rbx,%r14), %rbx
movq (%rbx), %rdi
callq 0xc724
movq 0x8(%rbx), %rdi
callq 0xa095
movq 0x122f5(%rip), %rax     # 0x19ad0
movq 0x8(%rax,%r14), %rdi
callq 0xa095
movq 0x122e4(%rip), %rax     # 0x19ad0
movq (%rax,%r14), %rdi
callq 0xa095
movq 0x122d4(%rip), %rax     # 0x19ad0
incl %r15d
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
addl 0x122e2(%rip), %ecx     # 0x19aec
andl %r15d, %ecx
shlq $0x4, %rcx
cmpq $0x0, (%rax,%rcx)
je 0x7821
leaq 0x85b8(%rip), %rcx      # 0xfdd7
jmp 0x7829
decl 0x122bd(%rip)           # 0x19ae4
xorl %ecx, %ecx
movq %rcx, (%rax,%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/hash.c
// Function: delete_var
extern void delete_var(char *s, bool stack) {
	int h = varfind(s);
	Variable *v;
	if (vp[h].name == NULL)
		return; /* not found */
	env_dirty = TRUE;
	v = vp[h].p;
	efree(v->extdef);
	listfree(v->def);
	if (v->n != NULL) { /* This is the top of a stack */
		if (stack) { /* pop */
			vp[h].p = v->n;
			efree(v);
		} else { /* else just empty */
			v->extdef = NULL;
			v->def = NULL;
		}
	} else { /* needs to be removed from the hash table */
		efree(v);
		vp[h].p = NULL;
		efree(vp[h].name);
		if (vp[(h+1)&(vsize-1)].name == NULL) {
			--vused;
			vp[h].name = NULL;
		} else {
			vp[h].name = dead;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x12294(%rip), %r14     # 0x19ad8
movl 0x1229e(%rip), %edx     # 0x19ae8
movq %r14, %rsi
callq 0x73c3
movl %eax, %r12d
movq %r12, %r15
shlq $0x4, %r15
cmpq $0x0, (%r14,%r15)
je 0x791f
movb $0x0, 0x12282(%rip)     # 0x19af0
movq 0x8(%r14,%r15), %r14
movq 0x8(%r14), %rdi
callq 0xa095
movq (%r14), %rdi
callq 0x9710
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x78b0
testl %ebx, %ebx
je 0x7908
movq 0x12240(%rip), %rcx     # 0x19ad8
movq %rax, 0x8(%rcx,%r15)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa095
movq %r14, %rdi
callq 0xa095
movq 0x12219(%rip), %rax     # 0x19ad8
movq $0x0, 0x8(%rax,%r15)
movq 0x12209(%rip), %rax     # 0x19ad8
movq (%rax,%r15), %rdi
callq 0xa095
movq 0x121f9(%rip), %rax     # 0x19ad8
incl %r12d
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
addl 0x121fb(%rip), %ecx     # 0x19ae8
andl %r12d, %ecx
shlq $0x4, %rcx
cmpq $0x0, (%rax,%rcx)
je 0x7911
leaq 0x84d5(%rip), %rcx      # 0xfdd7
movq %rcx, (%rax,%r15)
jmp 0x791f
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
jmp 0x791f
decl 0x121c9(%rip)           # 0x19ae0
movq $0x0, (%rax,%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/hash.c
// Function: initenv
extern void initenv(char **envp) {
	int n;
	for (n = 0; envp[n] != NULL; n++)
		;
	n++; /* one for the null terminator */
	if (n < HASHSIZE)
		n = HASHSIZE;
	env = ealloc((envsize = 2 * n) * sizeof (char *));
	for (; *envp != NULL; envp++)
		if (strncmp(*envp, "fn_", conststrlen("fn_")) == 0) {
			if (!dashpee)
				fnassign_string(*envp);
		} else {
			if (!varassign_string(*envp)) /* add to bozo env */
				env[bozosize++] = *envp;
		}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
cmpq $0x0, (%rbx,%rax,8)
leaq 0x1(%rax), %rax
jne 0x7938
decl %eax
cmpl $0x40, %eax
movl $0x3f, %ecx
cmovael %eax, %ecx
leal 0x2(,%rcx,2), %eax
movl %eax, 0x12197(%rip)     # 0x19af4
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0xa0c4
movq %rax, 0x12188(%rip)     # 0x19af8
movq (%rbx), %r15
testq %r15, %r15
je 0x79e6
addq $0x8, %rbx
leaq 0x7e25(%rip), %r14      # 0xf7a8
leaq 0x1225a(%rip), %r12     # 0x19be4
movl $0x3, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3060
testl %eax, %eax
je 0x79cb
movq %r15, %rdi
callq 0xc99b
testl %eax, %eax
jne 0x79da
movq -0x8(%rbx), %rax
movq 0x12143(%rip), %rcx     # 0x19af8
movslq 0x12144(%rip), %rdx     # 0x19b00
leal 0x1(%rdx), %esi
movl %esi, 0x1213b(%rip)     # 0x19b00
movq %rax, (%rcx,%rdx,8)
jmp 0x79da
cmpl $0x0, (%r12)
jne 0x79da
movq %r15, %rdi
callq 0x5048
movq (%rbx), %r15
addq $0x8, %rbx
testq %r15, %r15
jne 0x798a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/hash.c
// Function: set_exportable
void set_exportable(char *s, bool b) {
	int i;
	for (i = 0; i < arraysize(maybeexport); ++i)
		if (maybeexport[i].flag != b && streq(s, maybeexport[i].name))
			maybeexport[i].flag = b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0x118f7(%rip), %r12     # 0x19300
cmpl %ebx, 0x8(%r15,%r12)
je 0x7a2c
movb (%r14), %al
movq (%r15,%r12), %rsi
cmpb (%rsi), %al
jne 0x7a2c
movq %r14, %rdi
callq 0x31f0
testl %eax, %eax
jne 0x7a2c
movl %ebx, 0x8(%r15,%r12)
addq $0x10, %r15
cmpq $0x10, %r15
je 0x7a09
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/hash.c
// Function: whatare_all_vars
extern void whatare_all_vars(bool showfn, bool showvar) {
	int i;
	List *s;
	if (showvar)
		for (i = 0; i < vsize; i++)
			if (vp[i].name != NULL && (s = varlookup(vp[i].name)) != NULL)
				prettyprint_var(1, vp[i].name, s);
	if (showfn)
		for (i = 0; i < fsize; i++)
			if (fp[i].name != NULL && fp[i].name != dead)
				prettyprint_fn(1, fp[i].name, fnlookup(fp[i].name));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %esi, %esi
je 0x7d06
cmpl $0x0, 0x11e2f(%rip)     # 0x19ae8
jle 0x7d06
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x11e10(%rip), %rax     # 0x19ad8
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x7cf3
callq 0xcaf4
testq %rax, %rax
je 0x7cf3
movq 0x11df6(%rip), %rcx     # 0x19ad8
movq (%rcx,%r14), %rsi
movl $0x1, %edi
movq %rax, %rdx
callq 0xcebb
incq %r15
movslq 0x11deb(%rip), %rax     # 0x19ae8
addq $0x10, %r14
cmpq %rax, %r15
jl 0x7cc1
testl %ebx, %ebx
je 0x7d66
cmpl $0x0, 0x11ddb(%rip)     # 0x19aec
jle 0x7d66
xorl %r14d, %r14d
leaq 0x80ba(%rip), %r15      # 0xfdd7
xorl %r12d, %r12d
movq 0x11da9(%rip), %rax     # 0x19ad0
movq (%rax,%r14), %rbx
testq %rbx, %rbx
sete %al
cmpq %r15, %rbx
sete %cl
orb %al, %cl
jne 0x7d53
movq %rbx, %rdi
callq 0x5099
movl $0x1, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x51fa
incq %r12
movslq 0x11d8f(%rip), %rax     # 0x19aec
addq $0x10, %r14
cmpq %rax, %r12
jl 0x7d20
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/hash.c
// Function: compl_name
extern char *compl_name(const char *text, int state, char **p, size_t count, ssize_t inc) {
	static char **n;
	static size_t i, len;
	char *name;

	if (!state) {
		n = p;
		i = 0;
		len = strlen(text);
	}
	for (name = NULL; name == NULL && i < count; i++, n += inc)
		if (*n != NULL && strncmp(*n, text, len) == 0)
			name = strdup(*n);
	return name;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, (%rsp)
testl %esi, %esi
jne 0x7dad
movq %rdx, 0x11d76(%rip)     # 0x19b08
movq $0x0, 0x11d73(%rip) # 0x19b10
movq (%rsp), %rdi
callq 0x30f0
movq %rax, 0x11d6b(%rip)     # 0x19b18
movq 0x11d5c(%rip), %rbp     # 0x19b10
cmpq %r14, %rbp
jae 0x7e12
movq 0x11d48(%rip), %r15     # 0x19b08
movq 0x11d51(%rip), %r12     # 0x19b18
shlq $0x3, %rbx
movq (%r15), %r13
testq %r13, %r13
je 0x7de6
movq %r13, %rdi
movq (%rsp), %rsi
movq %r12, %rdx
callq 0x3060
testl %eax, %eax
je 0x7dea
xorl %eax, %eax
jmp 0x7df2
movq %r13, %rdi
callq 0x3350
incq %rbp
addq %rbx, %r15
testq %rax, %rax
jne 0x7e02
cmpq %r14, %rbp
jb 0x7dcb
movq %rbp, 0x11d07(%rip)     # 0x19b10
movq %r15, 0x11cf8(%rip)     # 0x19b08
jmp 0x7e14
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/hash.c
// Function: hash
static int hash(char *s, int size) {
	int c, n = 0;
	while (1) {
		ADV();
		n += (c << 17) ^ (c << 11) ^ (c << 5) ^ (c >> 1);
		ADV();
		n ^= (c << 14) + (c << 7) + (c << 4) + c;
		ADV();
		n ^= (~c << 11) | ((c << 3) ^ (c >> 1));
		ADV();
		n -= (c << 16) | (c << 9) | (c << 2) | (c & 3);
	}
	if (n < 0)
		n = ~n;
	return n & (size - 1); /* need power of 2 size */
}

// Assembly:
movl %esi, %eax
movb (%rdi), %dl
testb %dl, %dl
je 0x7eef
addq $0x4, %rdi
xorl %ecx, %ecx
movsbl %dl, %edx
movl %edx, %esi
shll $0x11, %esi
movl %edx, %r8d
shll $0xb, %r8d
xorl %esi, %r8d
movl %edx, %esi
shll $0x5, %esi
sarl %edx
xorl %esi, %edx
xorl %r8d, %edx
addl %ecx, %edx
movsbl -0x3(%rdi), %ecx
testl %ecx, %ecx
je 0x7ef3
imull $0x4091, %ecx, %esi     # imm = 0x4091
xorl %edx, %esi
movsbl -0x2(%rdi), %ecx
testl %ecx, %ecx
je 0x7ef7
movl %ecx, %edx
notl %edx
shll $0xb, %edx
leal (,%rcx,8), %r8d
sarl %ecx
xorl %r8d, %ecx
orl %edx, %ecx
xorl %esi, %ecx
movsbl -0x1(%rdi), %edx
testl %edx, %edx
je 0x7ef9
movl %edx, %esi
shll $0x10, %esi
movl %edx, %r8d
shll $0x9, %r8d
orl %esi, %r8d
leal (,%rdx,4), %esi
orl %r8d, %esi
andl $0x3, %edx
orl %esi, %edx
subl %edx, %ecx
movb (%rdi), %dl
addq $0x4, %rdi
testb %dl, %dl
jne 0x7e67
jmp 0x7ef9
xorl %ecx, %ecx
jmp 0x7ef9
movl %edx, %ecx
jmp 0x7ef9
movl %esi, %ecx
movl %ecx, %edx
sarl $0x1f, %edx
xorl %ecx, %edx
decl %eax
andl %edx, %eax
retq
nopl (%rax)