LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/status.c
// Function: strstatus
extern char *strstatus(int s) {
	if (WIFSIGNALED(s)) {
		int t = WTERMSIG(s);
		const char *core = myWIFDUMPED(s) ? "+core" : "";
		if ((t > 0) && (t < NUMOFSIGNALS) && *signals[t].name != '\0')
			return nprint("%s%s", signals[t].name, core);
		else
			return nprint("-%d%s", t, core); /* unknown signals are negated */
	} else
		return nprint("%d", WEXITSTATUS(s));
}

// Assembly:
movl %edi, %eax
movl %edi, %esi
andl $0x7f, %esi
movl %esi, %ecx
shll $0x18, %ecx
addl $0x1000000, %ecx        # imm = 0x1000000
cmpl $0x2000000, %ecx        # imm = 0x2000000
jl 0xb653
testb %al, %al
leaq 0x380d(%rip), %rax      # 0xee27
leaq 0x7d3c(%rip), %rdx      # 0x1335d
cmovnsq %rax, %rdx
leal -0x1(%rsi), %eax
cmpl $0x3f, %eax
ja 0xb664
movl %esi, %eax
shll $0x4, %eax
leaq 0xdd17(%rip), %rcx      # 0x19350
movq (%rcx,%rax), %rax
cmpb $0x0, (%rax)
je 0xb664
leaq 0x7d1a(%rip), %rdi      # 0x13363
movq %rax, %rsi
xorl %eax, %eax
jmp 0xaaee
movzbl %ah, %esi
leaq 0x3138(%rip), %rdi      # 0xe795
xorl %eax, %eax
jmp 0xaaee
leaq 0x7cfd(%rip), %rdi      # 0x13368
xorl %eax, %eax
jmp 0xaaee
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/status.c
// Function: ssetstatus
extern void ssetstatus(char **av) {
	int i, j, k, l;
	bool found;
	for (l = 0; av[l] != NULL; l++)
		; /* count up array length */
	--l;
	for (i = 0; av[i] != NULL; i++) {
		j = a2u(av[i]);
		if (j >= 0) {
			statuses[l - i] = j << 8;
			continue;
		}
		found = FALSE;
		for (k = 0; k < NUMOFSIGNALS; k++) {
			if (streq(signals[k].name, av[i])) {
				statuses[l - i] = k;
				found = TRUE;
				break;
			}
			else {
				size_t len = strlen(signals[k].name);
				if (strncmp(signals[k].name, av[i], len) == 0 && streq(av[i] + len, "+core")) {
					statuses[l - i] = k + 0x80;
					found = TRUE;
					break;
				}
			}
		}
		if (!found) {
			fprint(2, "bad status\n");
			set(FALSE);
			return;
		}
	}
	pipelength = i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movabsq $-0x200000000, %r14     # imm = 0xFFFFFFFE00000000
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rdi, %rcx
addq %rax, %r14
cmpq $0x0, (%rcx)
leaq 0x8(%rcx), %rcx
jne 0xb69a
sarq $0x20, %r14
xorl %r12d, %r12d
leaq 0xf0fb(%rip), %r13      # 0x1a7b0
movq %rbx, 0x8(%rsp)
movq (%rbx,%r12,8), %rdi
testq %rdi, %rdi
je 0xb7aa
pushq $0xa
popq %rsi
callq 0xbf32
testl %eax, %eax
js 0xb6ea
movl %eax, %r15d
shll $0x8, %r15d
movq %r14, %rax
subq %r12, %rax
movl %r15d, (%r13,%rax,4)
incq %r12
jmp 0xb6ba
movq %r12, 0x10(%rsp)
movq (%rbx,%r12,8), %r12
movb (%r12), %al
movb %al, 0x7(%rsp)
leaq 0xdc4e(%rip), %rbx      # 0x19350
xorl %r15d, %r15d
cmpq $0x41, %r15
je 0xb784
movq (%rbx), %r13
movb 0x7(%rsp), %al
cmpb %al, (%r13)
jne 0xb727
movq %r13, %rdi
movq %r12, %rsi
callq 0x31f0
testl %eax, %eax
je 0xb76e
movq %r13, %rdi
callq 0x30f0
movq %rax, %rbp
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x3060
testl %eax, %eax
jne 0xb761
cmpb $0x2b, (%r12,%rbp)
jne 0xb761
addq %r12, %rbp
movq %rbp, %rdi
leaq 0x7c05(%rip), %rsi      # 0x1335d
callq 0x31f0
testl %eax, %eax
je 0xb76a
incq %r15
addq $0x10, %rbx
jmp 0xb705
subl $-0x80, %r15d
movq 0x8(%rsp), %rbx
movq 0x10(%rsp), %r12
leaq 0xf031(%rip), %r13      # 0x1a7b0
jmp 0xb6da
leaq 0x7be3(%rip), %rsi      # 0x1336e
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0xa8f6
xorl %edi, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb43a
movl %r12d, 0xdfaf(%rip)     # 0x19760
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/system.c
// Function: writeall
extern void writeall(int fd, char *buf, size_t remain) {
	int i;

	for (i = 0; remain > 0; buf += i, remain -= i)
		if ((i = write(fd, buf, remain)) <= 0)
			break; /* abort silently on errors in write() */
	sigchk();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
testq %rbx, %rbx
je 0xb7ef
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x30c0
testl %eax, %eax
jle 0xb7ef
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, %r14
subq %rax, %rbx
jmp 0xb7cc
popq %rbx
popq %r14
popq %rbp
jmp 0xb266
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/utils.c
// Function: pr_error
extern void pr_error(char *s, int offset) {
	if (s != NULL) {
		if (interactive)
			fprint(2, RC "%s\n", s);
		else
			fprint(2, RC "line %d: %s\n", lineno + offset, s);
	}
}

// Assembly:
testq %rdi, %rdi
je 0xbe80
movq %rdi, %rcx
leaq 0xdd6d(%rip), %rax      # 0x19bd4
cmpl $0x0, (%rax)
je 0xbe81
leaq 0x2ed1(%rip), %rsi      # 0xed44
pushq $0x2
popq %rdi
movq %rcx, %rdx
xorl %eax, %eax
jmp 0xa8f6
retq
movl %esi, %edx
leaq 0xdd0e(%rip), %rax      # 0x19b98
addl (%rax), %edx
leaq 0x76fa(%rip), %rsi      # 0x1358d
pushq $0x2
popq %rdi
xorl %eax, %eax
jmp 0xa8f6
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/utils.c
// Function: uerror
extern void uerror(char *s) {
	char *err;

	err = strerror(errno);
	if (!err) err = "unknown error";

	if (s)
		fprint(2, RC "%s: %s\n", s, err);
	else
		fprint(2, RC "%s\n", err);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3040
movl (%rax), %edi
callq 0x3360
testq %rax, %rax
leaq 0x76e7(%rip), %rcx      # 0x1359e
cmovneq %rax, %rcx
testq %rbx, %rbx
je 0xbed5
leaq 0x76e5(%rip), %rsi      # 0x135ac
pushq $0x2
popq %rdi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
jmp 0xa8f6
leaq 0x2e68(%rip), %rsi      # 0xed44
pushq $0x2
popq %rdi
movq %rcx, %rdx
xorl %eax, %eax
popq %rbx
jmp 0xa8f6
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/utils.c
// Function: panic
extern void panic(char *s) {
	write(2, PANICMSG, conststrlen(PANICMSG));
	write(2, s, strlen(s));
	write(2, "!\n", 2);
	exit(1);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x76c1(%rip), %rsi      # 0x135b8
pushq $0x2
popq %rbp
pushq $0xa
popq %rdx
movl %ebp, %edi
callq 0x30c0
movq %rbx, %rdi
callq 0x30f0
movl %ebp, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x30c0
leaq 0x76a3(%rip), %rsi      # 0x135c3
pushq $0x2
popq %rdx
movl %ebp, %edi
callq 0x30c0
pushq $0x1
popq %rdi
callq 0x3330
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/utils.c
// Function: n2u
extern int n2u(char *s, unsigned int base) {
	unsigned int i;
	for (i = 0; *s != '\0'; s++) {
		unsigned int j = (unsigned int) *s - '0';
		if (j >= base) /* small hack with unsigned ints -- one compare for range test */
			return -1;
		i = i * base + j;
	}
	return (int) i;
}

// Assembly:
xorl %eax, %eax
pushq $-0x1
popq %rcx
movsbl (%rdi), %edx
testl %edx, %edx
je 0xbf51
addl $-0x30, %edx
cmpl %esi, %edx
jae 0xbf4f
imull %esi, %eax
addl %edx, %eax
incq %rdi
jmp 0xbf37
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/var.c
// Function: varassign
extern void varassign(char *name, List *def, bool stack) {
	Variable *new;
	List *newdef = listcpy(def, ealloc); /* important to do the listcpy first; get_var_place() frees old values */
	new = get_var_place(name, stack);
	new->def = newdef;
	new->extdef = NULL;
	set_exportable(name, TRUE);
	if (streq(name, "TERM") || streq(name, "TERMCAP"))
		termchange();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rax
movq %rdi, %rbx
leaq -0x253c(%rip), %rsi     # 0x9a83
movq %rax, %rdi
callq 0x9185
movq %rax, %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0x729c
movq %r14, (%rax)
andq $0x0, 0x8(%rax)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x75d7
cmpb $0x54, (%rbx)
jne 0xc012
leaq 0x75d3(%rip), %rsi      # 0x135c6
movq %rbx, %rdi
callq 0x31f0
testl %eax, %eax
je 0xc017
leaq 0x75c5(%rip), %rsi      # 0x135cb
movq %rbx, %rdi
callq 0x31f0
testl %eax, %eax
je 0xc017
popq %rbx
popq %r14
popq %rbp
retq
popq %rbx
popq %r14
popq %rbp
jmp 0x7ea8
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/var.c
// Function: varassign_string
extern bool varassign_string(char *extdef) {
	static bool aliasset[arraysize(aliases)] = {
		FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
	};
	char *name = get_name(extdef);
	Variable *new;
	int i;
	if (name == NULL)
		return FALSE; /* add it to bozo env */
	if ((i = hasalias(name)) != -1) {
		aliasset[i] = TRUE;
		i ^= 1;			 	/* set i to the "opposite" case subscript and */
		if (i&1 && aliasset[i])		/* don't alias variables that are already set in upper case */
			return TRUE;
	}
	new = get_var_place(name, FALSE);
	new->def = NULL;
	new->extdef = ealloc(strlen(extdef) + 1);
	strcpy(new->extdef, extdef);
	if (i != -1)
		alias(name, varlookup(name), FALSE);
	set_exportable(name, TRUE);
	return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x5008
testq %rax, %rax
je 0xc06f
movq %rax, %rbx
movq %rax, %rdi
callq 0xc0db
cmpl $-0x1, %eax
je 0xc073
movl %eax, %ebp
movl %eax, %ecx
movslq %eax, %rdx
leaq 0xef5e(%rip), %rax      # 0x1afb0
movl $0x1, (%rax,%rdx,4)
xorl $0x1, %ebp
testb $0x1, %cl
jne 0xc076
movslq %ebp, %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0xc076
pushq $0x1
popq %rbp
jmp 0xc0ce
xorl %ebp, %ebp
jmp 0xc0ce
pushq $-0x1
popq %rbp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x729c
movq %rax, %r15
andq $0x0, (%rax)
movq %r14, %rdi
callq 0x30f0
leaq 0x1(%rax), %rdi
callq 0x9a83
movq %rax, 0x8(%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3070
cmpl $-0x1, %ebp
je 0xc0c1
movq %rbx, %rdi
callq 0xc16d
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xc128
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x75d7
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/var.c
// Function: hasalias
static int hasalias(char *name) {
	int i;
	for (i = 0; i < arraysize(aliases); i++)
		if (streq(name, aliases[i]))
			return i;
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movb (%rdi), %bpl
leaq 0xcc60(%rip), %r12      # 0x18d50
xorl %r15d, %r15d
pushq $-0x1
popq %rbx
cmpq $0x6, %r15
je 0xc11d
movq (%r12), %rsi
cmpb (%rsi), %bpl
jne 0xc111
movq %r14, %rdi
callq 0x31f0
testl %eax, %eax
je 0xc11a
incq %r15
addq $0x8, %r12
jmp 0xc0f6
movl %r15d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/var.c
// Function: alias
extern void alias(char *name, List *s, bool stack) {
	static void (*vectors[])(char *, List *, bool) = {
		varassign, varassign, colonassign, listassign, colonassign, listassign
	};
	int i = hasalias(name);
	if (i != -1)
		(*vectors[i])(aliases[i^1], s, stack); /* xor hack to reverse case of alias entry */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
callq 0xc0db
cmpl $-0x1, %eax
je 0xc165
movslq %eax, %rcx
leaq 0xcc3b(%rip), %r8       # 0x18d80
xorl $0x1, %eax
cltq
leaq 0xcbff(%rip), %rdx      # 0x18d50
movq (%rdx,%rax,8), %rdi
movq %r14, %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%r8,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/var.c
// Function: varlookup
extern List *varlookup(char *name) {
	Variable *look;
	List *ret, *l;
	int sub;
	if (streq(name, "apids"))
		return sgetapids();
	if (streq(name, "status"))
		return sgetstatus();
	if (*name != '\0' && (sub = a2u(name)) != -1) { /* handle $1, $2, etc. */
		for (l = varlookup("*"); l != NULL && sub != 0; --sub)
			l = l->n;
		if (l == NULL)
			return NULL;
		ret = nnew(List);
		ret->w = l->w;
		ret->m = NULL;
		ret->n = NULL;
		return ret;
	}
	look = lookup_var(name);
	if (look == NULL)
		return NULL; /* not found */
	if (look->def != NULL)
		return look->def;
	if (look->extdef == NULL)
		return NULL; /* variable was set to null, e.g., a=() echo foo */
	ret = parse_var(look->extdef);
	if (ret == NULL) {
		look->extdef = NULL;
		return NULL;
	}
	return look->def = ret;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl (%rdi), %eax
testl %eax, %eax
je 0xc1ef
cmpl $0x73, %eax
je 0xc1a2
cmpl $0x61, %eax
jne 0xc1b9
leaq 0x2621(%rip), %rsi      # 0xe7ac
movq %rbx, %rdi
callq 0x31f0
testl %eax, %eax
jne 0xc1b9
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc766
leaq 0x25ce(%rip), %rsi      # 0xe777
movq %rbx, %rdi
callq 0x31f0
testl %eax, %eax
je 0xc245
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0xbf32
cmpl $-0x1, %eax
je 0xc1ef
movl %eax, %ebp
leaq 0x1e8a(%rip), %rdi      # 0xe05c
callq 0xc16d
movq %rax, %rbx
addl $-0x1, %ebp
setb %al
testq %rbx, %rbx
je 0xc229
testb %al, %al
je 0xc229
movq 0x10(%rbx), %rbx
jmp 0xc1da
leaq 0xd8e2(%rip), %rax      # 0x19ad8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x6fc7
testq %rax, %rax
je 0xc255
movq %rax, %rbx
movq (%rax), %rax
testq %rax, %rax
jne 0xc257
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xc255
callq 0x50d9
testq %rax, %rax
je 0xc250
movq %rax, (%rbx)
jmp 0xc257
testq %rbx, %rbx
je 0xc255
pushq $0x18
popq %rdi
callq 0x9928
movq (%rbx), %rcx
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
jmp 0xc257
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb599
andq $0x0, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/var.c
// Function: varlookup_string
extern char *varlookup_string(char *name) {
	Variable *look;
	look = lookup_var(name);
	if (look == NULL)
		return NULL;
	if (look->extdef != NULL)
		return look->extdef;
	if (look->def == NULL)
		return NULL;
	return look->extdef = mprint("%F=%W", name, look->def);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xd86c(%rip), %rax      # 0x19ad8
movq (%rax), %rsi
callq 0x6fc7
testq %rax, %rax
je 0xc2a4
movq %rax, %r14
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0xc2a6
movq (%r14), %rdx
testq %rdx, %rdx
je 0xc2a4
leaq 0x733f(%rip), %rdi      # 0x135d3
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa9f3
movq %rax, 0x8(%r14)
jmp 0xc2a6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/var.c
// Function: varrm
extern void varrm(char *name, bool stack) {
	int i = hasalias(name);
	if (streq(name, "*") && !stack) { /* when assigning () to $*, we want to preserve $0 */
		varassign("*", varlookup("0"), FALSE);
		return;
	}
	delete_var(name, stack);
	if (i != -1)
		delete_var(aliases[i^1], stack);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0xc0db
movl %eax, %ebp
cmpb $0x2a, (%r14)
jne 0xc2d7
leaq 0x1d91(%rip), %rsi      # 0xe05c
movq %r14, %rdi
callq 0x31f0
orl %ebx, %eax
je 0xc307
movq %r14, %rdi
movl %ebx, %esi
callq 0x7441
cmpl $-0x1, %ebp
je 0xc302
xorl $0x1, %ebp
movslq %ebp, %rax
leaq 0xca5d(%rip), %rcx      # 0x18d50
movq (%rcx,%rax,8), %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x7441
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6cb3(%rip), %rdi      # 0x12fc1
callq 0xc16d
leaq 0x1d42(%rip), %rdi      # 0xe05c
movq %rax, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0xbfac
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/var.c
// Function: starassign
extern void starassign(char *dollarzero, char **a, bool stack) {
	List *s, *var;
	var = nnew(List);
	var->w = dollarzero;
	if (*a == NULL) {
		var->n = NULL;
		varassign("*", var, stack);
		return;
	}
	var->n = s = nnew(List);
	while (1) {
		s->w = *a++;
		if (*a == NULL) {
			s->n = NULL;
			break;
		} else
			s = s->n = nnew(List);
	}
	varassign("*", var, stack);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
pushq $0x18
popq %rdi
callq 0x9928
movq %rax, %r15
movq %r12, (%rax)
cmpq $0x0, (%r14)
je 0xc378
addq $0x8, %r14
pushq $0x18
popq %r12
movq %r15, %r13
movq %r12, %rdi
callq 0x9928
movq %rax, 0x10(%r13)
movq -0x8(%r14), %rcx
movq %rcx, (%rax)
cmpq $0x0, (%r14)
leaq 0x8(%r14), %r14
movq %rax, %r13
jne 0xc358
andq $0x0, 0x10(%rax)
leaq 0x1cd8(%rip), %rdi      # 0xe05c
movq %r15, %rsi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xbfac
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/var.c
// Function: colonassign
static void colonassign(char *name, List *def, bool stack) {
	List dud;
	if (def == NULL) {
		varassign(name, NULL, stack);
		return;
	}
	dud.w = nprint("%-L", def, ":");
	dud.n = NULL;
	varassign(name, &dud, stack);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rdi, %r14
testq %rsi, %rsi
je 0xc3da
leaq 0x724c(%rip), %rdi      # 0x135fb
leaq 0x7249(%rip), %rdx      # 0x135ff
xorl %eax, %eax
callq 0xaaee
movq %rsp, %rsi
movq %rax, (%rsi)
andq $0x0, 0x10(%rsi)
movq %r14, %rdi
movl %ebx, %edx
callq 0xbfac
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
xorl %esi, %esi
movl %ebx, %edx
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0xbfac
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/var.c
// Function: listassign
static void listassign(char *name, List *def, bool stack) {
	List *val, *r;
	char *v, *w;
	if (def == NULL) {
		varassign(name, NULL, stack);
		return;
	}
	v = def->w;
	r = val = nnew(List);
	while ((w = strchr(v, ':')) != NULL) {
		*w = '\0';
		r->w = ncpy(v);
		*w = ':';
		v = w + 1;
		r = r->n = nnew(List);
	}
	r->w = ncpy(v);
	r->n = NULL;
	varassign(name, val, stack);
}

// Assembly:
testq %rsi, %rsi
je 0xc4c2
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %edx, 0x4(%rsp)
movq (%rsi), %rbx
pushq $0x18
popq %r13
movq %r13, %rdi
callq 0x9928
movq %rax, %r15
pushq $0x3a
popq %rbp
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3120
testq %rax, %rax
je 0xc47a
movq %rax, %r12
movb $0x0, (%rax)
movq %rbx, %rdi
callq 0x30f0
leaq 0x1(%rax), %rdi
callq 0x9928
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3070
movq %r14, (%r15)
movb $0x3a, (%r12)
incq %r12
movq %r13, %rdi
callq 0x9928
movq %rax, 0x10(%r15)
movq %r12, %rbx
movq %rax, %r15
jmp 0xc427
movq %rbx, %rdi
callq 0x30f0
leaq 0x1(%rax), %rdi
callq 0x9928
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3070
movq %r14, (%r15)
andq $0x0, 0x10(%r15)
movl 0x4(%rsp), %edx
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xbfac
xorl %esi, %esi
jmp 0xbfac
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/var.c
// Function: prettyprint_var
extern void prettyprint_var(int fd, char *name, List *s) {
	int i;
	static const char * const keywords[] = {
		"if", "in", "fn", "for", "else", "switch", "while", "case"
	};
	if (s == NULL) {
		fprint(fd, "%S=()\n", name);
		return;
	}
	if (streq(name, "*")) {
		s = s->n;
		if (s == NULL)
			return; /* Don't print $0, and if $* is not set, skip it */
	}
	for (i = 0; i < arraysize(keywords); i++)
		if (streq(keywords[i], name)) {
			fprint(fd, "%#S=", name);
			goto value;
		}
	fprint(fd, "%S=", name);
value:
	fprint(fd, s->n == NULL ? "%L\n" : "(%L)\n", s, " ");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movl %edi, %ebx
testq %rdx, %rdx
je 0xc533
movq %rdx, %r14
movb (%r15), %bpl
cmpb $0x2a, %bpl
jne 0xc4fe
cmpb $0x0, 0x1(%r15)
jne 0xc4fe
movq 0x10(%r14), %r14
testq %r14, %r14
je 0xc59f
xorl %r13d, %r13d
leaq 0xc8a8(%rip), %r12      # 0x18db0
cmpq $0x40, %r13
je 0xc52a
movq (%r13,%r12), %rdi
cmpb %bpl, (%rdi)
jne 0xc524
movq %r15, %rsi
callq 0x31f0
testl %eax, %eax
je 0xc554
addq $0x8, %r13
jmp 0xc508
leaq 0x70b4(%rip), %rsi      # 0x135e5
jmp 0xc55b
leaq 0x709f(%rip), %rsi      # 0x135d9
movl %ebx, %edi
movq %r15, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa8f6
leaq 0x7085(%rip), %rsi      # 0x135e0
movl %ebx, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0xa8f6
cmpq $0x0, 0x10(%r14)
leaq 0x717e(%rip), %rax      # 0x136f1
leaq 0x706f(%rip), %rsi      # 0x135e9
cmoveq %rax, %rsi
leaq 0x703c(%rip), %rcx      # 0x135c1
movl %ebx, %edi
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa8f6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/wait.c
// Function: rc_fork
extern pid_t rc_fork() {
	Pid *new;
	struct Pid *p, *q;
	pid_t pid = fork();

	switch (pid) {
	case -1:
		uerror("fork");
		rc_error(NULL);
		/* NOTREACHED */
	case 0:
		forked = TRUE;
		sigchk();
		clearflow();
		p = plist; q = 0;
		while (p) {
			if (q) efree(q);
			q = p;
			p = p->n;
		}
		if (q) efree(q);
		plist = 0;
		return 0;
	default:
		new = enew(Pid);
		new->pid = pid;
		new->alive = TRUE;
		new->waiting = FALSE;
		new->n = plist;
		plist = new;
		return pid;
	}
}

// Assembly:
pushq %rbx
callq 0x3390
testl %eax, %eax
je 0xc5d4
movl %eax, %ebx
cmpl $-0x1, %eax
jne 0xc61c
leaq 0x1e32(%rip), %rdi      # 0xe3fa
callq 0xbe9d
xorl %edi, %edi
callq 0x45b7
movl $0x1, 0xe9ea(%rip)      # 0x1afc8
callq 0xb266
callq 0x45e4
leaq 0xe9e1(%rip), %rax      # 0x1afd0
xorl %edi, %edi
movq (%rax), %rbx
testq %rbx, %rbx
je 0xc60c
testq %rdi, %rdi
je 0xc603
callq 0x9a5c
leaq 0x10(%rbx), %rax
movq %rbx, %rdi
jmp 0xc5f1
testq %rdi, %rdi
je 0xc616
callq 0x9a5c
xorl %eax, %eax
xorl %ebx, %ebx
jmp 0xc639
pushq $0x18
popq %rdi
callq 0x9a83
movl %ebx, (%rax)
movq $0x1, 0x8(%rax)
movq 0xe99b(%rip), %rcx      # 0x1afd0
movq %rcx, 0x10(%rax)
movq %rax, 0xe990(%rip)      # 0x1afd0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/wait.c
// Function: rc_wait4
extern pid_t rc_wait4(pid_t pid, int *stat, bool nointr) {
	if (markwaiting(pid, TRUE) == 0) {
		/* Uh-oh, not there. */
		errno = ECHILD; /* no children */
		uerror("wait");
		*stat = 0x100; /* exit(1) */
		return -1;
	}
	return dowait(stat, nointr);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
pushq $0x1
popq %rsi
callq 0xc68c
testl %eax, %eax
je 0xc665
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc6c0
callq 0x3040
movl $0xa, (%rax)
leaq 0x1a2b(%rip), %rdi      # 0xe0a2
callq 0xbe9d
movl $0x100, (%rbx)          # imm = 0x100
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/wait.c
// Function: markwaiting
static int markwaiting(pid_t pid, bool clear) {
	Pid *p;
	int n = 0;
	for (p = plist; p != NULL; p = p->n)
		if (pid == -1 || p->pid == pid) {
			p->waiting = TRUE;
			n++;
		} else if (clear)
			p->waiting = FALSE;
	return n;
}

// Assembly:
xorl %eax, %eax
leaq 0xe93b(%rip), %rcx      # 0x1afd0
movq (%rcx), %rcx
testq %rcx, %rcx
je 0xc6bf
cmpl $-0x1, %edi
je 0xc6a6
cmpl %edi, (%rcx)
jne 0xc6b1
movl $0x1, 0xc(%rcx)
incl %eax
jmp 0xc6b9
testl %esi, %esi
je 0xc6b9
andl $0x0, 0xc(%rcx)
addq $0x10, %rcx
jmp 0xc695
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/wait.c
// Function: dowait
static pid_t dowait(int *stat, bool nointr) {
	Pid **p, *q;
	pid_t pid;
	for (;;) {
		for (p = &plist; *p != NULL; p = &(*p)->n) {
			q = *p;
			if (q->waiting && !q->alive) {
				pid = q->pid;
				*stat = q->stat;
				*p = q->n; /* remove element from list */
				efree(q);
				return pid;
			}
		}
		pid = rc_wait(stat);
		if (pid < 0) {
			if (errno == ECHILD)
				panic("lost child");
			if (nointr)
				continue;
			else
				return pid;
		}
		for (q = plist; q != NULL; q = q->n)
			if (q->pid == pid) {
				q->alive = FALSE;
				q->stat = *stat;
				break;
			}
	}
	/* never reached */
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xe8fc(%rip), %r12      # 0x1afd0
leaq 0x6f5f(%rip), %r14      # 0x1363a
movq %r12, %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0xc6fb
cmpl $0x0, 0xc(%rdi)
je 0xc6f2
cmpl $0x0, 0x8(%rdi)
je 0xc746
addq $0x10, %rdi
movq %rdi, %rax
jmp 0xc6de
movq %rbx, %rdi
callq 0x3380
movl %eax, %r15d
testl %eax, %eax
jns 0xc725
callq 0x3040
cmpl $0xa, (%rax)
jne 0xc71c
movq %r14, %rdi
callq 0xbeea
movq %r12, %rax
testl %ebp, %ebp
jne 0xc6de
jmp 0xc75a
movq %r12, %rax
movq (%rax), %rax
testq %rax, %rax
je 0xc6db
cmpl %r15d, (%rax)
je 0xc73b
addq $0x10, %rax
jmp 0xc728
andl $0x0, 0x8(%rax)
movl (%rbx), %ecx
movl %ecx, 0x4(%rax)
jmp 0xc6db
movl (%rdi), %r15d
movl 0x4(%rdi), %ecx
movl %ecx, (%rbx)
movq 0x10(%rdi), %rcx
movq %rcx, (%rax)
callq 0x9a5c
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/wait.c
// Function: sgetapids
extern List *sgetapids() {
	List *r;
	Pid *p;
	for (r = NULL, p = plist; p != NULL; p = p->n) {
		List *q;
		if (!p->alive)
			continue;
		q = nnew(List);
		q->w = nprint("%d", p->pid);
		q->m = NULL;
		q->n = r;
		r = q;
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0xe85a(%rip), %r13      # 0x1afd0
pushq $0x18
popq %rbx
leaq 0x2015(%rip), %r14      # 0xe795
xorl %r15d, %r15d
movq (%r13), %r13
testq %r13, %r13
je 0xc7c4
cmpl $0x0, 0x8(%r13)
je 0xc7be
movq %rbx, %rdi
callq 0x9928
movq %rax, %r12
movl (%r13), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0xaaee
movq %rax, (%r12)
andq $0x0, 0x8(%r12)
movq %r15, 0x10(%r12)
movq %r12, %r15
addq $0x10, %r13
jmp 0xc783
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/wait.c
// Function: waitforall
extern void waitforall() {
	int stat;
	markwaiting(-1, TRUE);
	while (plist != NULL) {
		pid_t pid = dowait(&stat, FALSE);
		if (pid > 0)
			setstatus(pid, stat);
		else {
			set(FALSE);
			if (errno == EINTR)
				return;
		}
		sigchk();
	}
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
pushq $-0x1
popq %rdi
pushq $0x1
popq %rsi
callq 0xc68c
leaq 0xc(%rsp), %rbx
cmpq $0x0, 0xe7e2(%rip)      # 0x1afd0
je 0xc823
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc6c0
testl %eax, %eax
jle 0xc80b
movl 0xc(%rsp), %esi
movl %eax, %edi
callq 0xb44d
jmp 0xc81c
xorl %edi, %edi
callq 0xb43a
callq 0x3040
cmpl $0x4, (%rax)
je 0xc823
callq 0xb266
jmp 0xc7e6
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/wait.c
// Function: waitfor
extern void waitfor(char **av) {
	int alive, count, i, stat;
	pid_t pid;
	for (i = 0; av[i] != NULL; i++)
		if ((pid = a2u(av[i])) < 0) {
			fprint(2, RC "`%s' is a bad number\n", av[i]);
			set(FALSE);
			return;
		} else if (markwaiting(pid, i == 0) == 0) {
			fprint(2, RC "`%s' is not a child\n", av[i]);
			set(FALSE);
			return;
		}
	alive = count = i;
	if (count >= MAX_PIPELINE) {
		fprint(2, RC "too many arguments to wait\n");
		set(FALSE);
		return;
	}
	setpipestatuslength(count);
	while (alive > 0) {
		pid = dowait(&stat, FALSE);
		if (pid > 0) {
			alive--;
			for (i = 0; av[i] != NULL; i++)
				if (a2u(av[i]) == pid) {
					setpipestatus(count - i - 1, pid, stat);
					break;
				}
		} else if (errno == EINTR) {
			set(FALSE);
			return;
		}
		sigchk();
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
xorl %r14d, %r14d
pushq $0xa
popq %rbp
movq (%r15,%r14,8), %rdi
testq %rdi, %rdi
je 0xc86d
movl %ebp, %esi
callq 0xbf32
testl %eax, %eax
js 0xc889
xorl %esi, %esi
testq %r14, %r14
sete %sil
movl %eax, %edi
callq 0xc68c
testl %eax, %eax
je 0xc896
incq %r14
jmp 0xc840
cmpq $0x200, %r14            # imm = 0x200
jb 0xc8c0
leaq 0x6d9d(%rip), %rsi      # 0x1361a
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0xa8f6
jmp 0xc8ab
movq (%r15,%r14,8), %rdx
leaq 0x198c(%rip), %rsi      # 0xe220
jmp 0xc8a1
movq (%r15,%r14,8), %rdx
leaq 0x6d60(%rip), %rsi      # 0x13601
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0xa8f6
xorl %edi, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb43a
leaq -0x1(%r14), %rax
movq %rax, 0x10(%rsp)
movl %r14d, %edi
callq 0xb57c
pushq $0xa
popq %rbp
testl %r14d, %r14d
jle 0xc940
leaq 0xc(%rsp), %rdi
xorl %esi, %esi
callq 0xc6c0
testl %eax, %eax
jle 0xc917
movl %eax, %r12d
decl %r14d
movq %r15, %rbx
movq 0x10(%rsp), %rax
movl %eax, %r13d
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xc932
movl %ebp, %esi
callq 0xbf32
cmpl %r12d, %eax
je 0xc923
decl %r13d
addq $0x8, %rbx
jmp 0xc8fa
callq 0x3040
cmpl $0x4, (%rax)
jne 0xc932
jmp 0xc939
movl 0xc(%rsp), %edx
movl %r13d, %edi
movl %r12d, %esi
callq 0xb583
callq 0xb266
jmp 0xc8d4
xorl %edi, %edi
callq 0xb43a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/walk.c
// Function: loop_body
static void loop_body(Node* nd)
{
	Node *volatile n = nd;
	Jbwrap cont_jb;
	Edata  cont_data;
	Estack cont_stack;

	if (sigsetjmp(cont_jb.j, 1) == 0) {
		cont_data.jb = &cont_jb;
		except(eContinue, cont_data, &cont_stack);
		walk(n, TRUE);
		unexcept(eContinue);
	}
}

// Assembly:
pushq %rbx
subq $0xf0, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x3370
testl %eax, %eax
jne 0xd166
pushq $0x7
popq %rbx
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movl %ebx, %edi
callq 0x43bc
movq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0xc950
movl %ebx, %edi
callq 0x43f0
addq $0xf0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/walk.c
// Function: dofork
static bool dofork(bool parent) {
	int pid, sp;
	struct termios t;

	if (interactive)
		tcgetattr(0, &t);
	if (!parent || (pid = rc_fork()) == 0)
		return TRUE;
	redirq = NULL; /* clear out the pre-redirection queue in the parent */
	rc_wait4(pid, &sp, TRUE);
	if (interactive && WIFSIGNALED(sp))
		tcsetattr(0, TCSANOW, &t);
	setstatus(-1, sp);
	sigchk();
	return FALSE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edi, %ebp
leaq 0xca54(%rip), %r14      # 0x19bd4
cmpl $0x0, (%r14)
je 0xd192
leaq 0x4(%rsp), %rsi
xorl %edi, %edi
callq 0x32c0
pushq $0x1
popq %rbx
testl %ebp, %ebp
je 0xd1f9
callq 0xc5b0
testl %eax, %eax
je 0xd1f9
leaq 0xc91f(%rip), %rcx      # 0x19ac8
andq $0x0, (%rcx)
movq %rsp, %rbx
pushq $0x1
popq %rdx
movl %eax, %edi
movq %rbx, %rsi
callq 0xc644
cmpl $0x0, (%r14)
movl (%rbx), %esi
je 0xd1ea
movl %esi, %eax
andl $0x7f, %eax
shll $0x18, %eax
addl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x2000000, %eax        # imm = 0x2000000
jl 0xd1ea
leaq 0x4(%rsp), %rdx
xorl %edi, %edi
xorl %esi, %esi
callq 0x32f0
movl (%rsp), %esi
pushq $-0x1
popq %rdi
callq 0xb44d
callq 0xb266
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/rakitzis[P]rc/which.c
// Function: rc_access
bool rc_access(char *path, bool verbose, struct stat *stp) {
	int mask;
	if (stat(path, stp) != 0) {
		if (verbose) /* verbose flag only set for absolute pathname */
			uerror(path);
		return FALSE;
	}
	if (uid == 0)
		mask = X_ALL;
	else if (uid == stp->st_uid)
		mask = X_USR;
	else if (gid == stp->st_gid || ingidset(stp->st_gid))
		mask = X_GRP;
	else
		mask = X_OTH;
	if (((stp->st_mode & S_IFMT) == S_IFREG) && (stp->st_mode & mask))
		return TRUE;
	errno = EACCES;
	if (verbose)
		uerror(path);
	return FALSE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x3210
testl %eax, %eax
jne 0xd43d
movl 0xdbe2(%rip), %ecx      # 0x1afe0
pushq $0x1
popq %rax
testl %ecx, %ecx
je 0xd40f
cmpl 0x1c(%r14), %ecx
jne 0xd450
pushq $0x40
jmp 0xd411
pushq $0x49
popq %rcx
movl 0x18(%r14), %edx
movl %edx, %esi
andl $0xf000, %esi           # imm = 0xF000
cmpl $0x8000, %esi           # imm = 0x8000
sete %sil
testl %ecx, %edx
setne %cl
testb %cl, %sil
jne 0xd44b
callq 0x3040
movl $0xd, (%rax)
testl %ebp, %ebp
je 0xd449
movq %rbx, %rdi
callq 0xbe9d
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl 0x20(%r14), %edx
pushq $0x8
popq %rcx
cmpl %edx, 0xdb87(%rip)      # 0x1afe4
je 0xd412
movl 0xdb97(%rip), %esi      # 0x1affc
movq 0xdb94(%rip), %rdi      # 0x1b000
xorl %r8d, %r8d
testl %esi, %esi
cmovlel %r8d, %esi
cmpq %r8, %rsi
je 0xd489
leaq 0x1(%r8), %r9
cmpl %edx, (%rdi,%r8,4)
movq %r9, %r8
jne 0xd475
jmp 0xd412
movl %eax, %ecx
jmp 0xd412
// File: /workspace/github_c_makefile_star2_O2/chbarts[P]aa-tree/nuniq.c
// Function: dofile
static void dofile(char *fname, FILE * fin, aa * tree)
{
    char *ln;

    while (fggets(&ln, fin) == 0) {
        switch (aa_add(tree, (void *) ln, duplicate)) {
        case 0:                /* No error */
            break;
        case 2:                /* Memory error */
            free(ln);
            error(tree);
            break;
        default:               /* Can't happen */
            fprintf(stderr, "Can't happen\n");
            free(ln);
            cleanup(tree);
            exit(EXIT_FAILURE);
            break;
        }

        if (1 == print) {
            puts(ln);
        } else {
            print = 1;
        }
    }

    if (ferror(fin) != 0)
        handle_ferr(fname, "nuniq");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r12
leaq 0x1b6(%rip), %r13       # 0x1efb
movq %r12, %rdi
movq %r15, %rsi
callq 0x125c
testl %eax, %eax
jne 0x1d86
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x139c
testl %eax, %eax
jne 0x1daf
cmpb $0x0, 0x2359(%rip)      # 0x40c8
je 0x1d7a
movb $0x0, 0x2350(%rip)      # 0x40c8
jmp 0x1d45
movq 0x8(%rsp), %rdi
callq 0x1050
jmp 0x1d45
movq %r15, %rdi
callq 0x1060
testl %eax, %eax
je 0x1da1
leaq 0x346(%rip), %rsi       # 0x20df
movq %r14, %rdi
callq 0x133c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
cmpl $0x2, %eax
jne 0x1ddc
movq 0x8(%rsp), %rdi
callq 0x1030
movq 0x2233(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0x328(%rip), %rdi       # 0x20f7
pushq $0xd
popq %rsi
pushq $0x1
popq %rdx
callq 0x1140
jmp 0x1e02
movq 0x2215(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0x2f8(%rip), %rdi       # 0x20e5
pushq $0xd
popq %rsi
pushq $0x1
popq %rdx
callq 0x1140
movq 0x8(%rsp), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1e12
pushq $0x1
popq %rdi
callq 0x1130
// File: /workspace/github_c_makefile_star2_O2/chbarts[P]aa-tree/nuniq.c
// Function: usage
static void usage(char *pname)
{
    printf("Usage: %s [OPTION] [FILE...]\n", pname);
    puts("Print uniqified version of file(s) to standard output without sorting them.");
    puts("Only prints lines unique to all of the files, if multiple are specified, and doesn't separate by file");
    puts("With no files specified, uniqify standard input.");
    puts("");
    puts("  -h, --help        Print this help");
    puts("  -v, --version     Print version information");
    puts("  -d, --duplicates  Print duplicate lines to stderr (cannot print first duplicated line)");
    puts("");
    puts("Report bugs to <chbarts@gmail.com>.");
}

// Assembly:
pushq %rbx
movq %rdi, %rsi
leaq 0x2cd(%rip), %rdi       # 0x2105
xorl %eax, %eax
callq 0x1090
leaq 0x2dd(%rip), %rdi       # 0x2123
callq 0x1050
leaq 0x31d(%rip), %rdi       # 0x216f
callq 0x1050
leaq 0x377(%rip), %rdi       # 0x21d5
callq 0x1050
pushq $0xa
popq %rbx
movl %ebx, %edi
callq 0x1040
leaq 0x392(%rip), %rdi       # 0x2206
callq 0x1050
leaq 0x3aa(%rip), %rdi       # 0x222a
callq 0x1050
leaq 0x3cc(%rip), %rdi       # 0x2258
callq 0x1050
movl %ebx, %edi
callq 0x1040
leaq 0x412(%rip), %rdi       # 0x22b1
popq %rbx
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O2/chbarts[P]aa-tree/nuniq.c
// Function: version
static void version(void)
{
    puts("nuniq version 0.1.0");
    puts("Copyright 2016 Chris Barts.");
    puts("nuniq comes with NO WARRANTY to the extent permitted by law.");
    puts("You may redistribute this software under the terms");
    puts("of the GNU General Public License.");
    puts("For more information, see the file named COPYING");
    puts("in this program's distribution file.");
}

// Assembly:
pushq %rax
leaq 0x428(%rip), %rdi       # 0x22d5
callq 0x1050
leaq 0x430(%rip), %rdi       # 0x22e9
callq 0x1050
leaq 0x440(%rip), %rdi       # 0x2305
callq 0x1050
leaq 0x471(%rip), %rdi       # 0x2342
callq 0x1050
leaq 0x498(%rip), %rdi       # 0x2375
callq 0x1050
leaq 0x4af(%rip), %rdi       # 0x2398
callq 0x1050
leaq 0x4d4(%rip), %rdi       # 0x23c9
popq %rax
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O2/chbarts[P]aa-tree/nuniq.c
// Function: duplicate
static int duplicate(void *orig, void *new)
{
    char *ln = (char *) new;

    if (1 == d) {
       fprintf(stderr, "%s\n", ln);
    }

    free(ln);
    print = 0;
    return 0;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
cmpb $0x1, 0x21be(%rip)      # 0x40c4
je 0x1f1b
movq %rbx, %rdi
callq 0x1030
movb $0x1, 0x21b1(%rip)      # 0x40c8
xorl %eax, %eax
popq %rbx
retq
movq 0x20d6(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x1c7(%rip), %rsi       # 0x20f3
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10d0
jmp 0x1f08
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-cmd.c
// Function: our_specialmsgfn
static void our_specialmsgfn(deark *c, unsigned int flags, unsigned int code,
	u32 param1)
{
	struct cmdctx *cc;

	cc = de_get_userdata(c);
	if(cc->color_method==CM_NOCOLOR) return;

	if(!cc->have_initialized_output_stream) {
		initialize_output_stream(cc);
	}

#ifdef DE_WINDOWS
	if(cc->color_method==CM_WINCONSOLE) {
		if(code==DE_MSGCODE_HL) {
			de_winconsole_highlight(cc->plctx, 1);
		}
		else if(code==DE_MSGCODE_UNHL) {
			de_winconsole_highlight(cc->plctx, 0);
		}
		else if(code==DE_MSGCODE_RGBSAMPLE) {
			// There's no way to get 24-bit color using Windows console
			// commands. Have to use ANSI24 instead.
			;
		}
		return;
	}
#endif

	// TODO: Maybe move the DE_COLOR_* macros to deark.h.
#define X_DE_COLOR_R(x)  (unsigned int)(((x)>>16)&0xff)
#define X_DE_COLOR_G(x)  (unsigned int)(((x)>>8)&0xff)
#define X_DE_COLOR_B(x)  (unsigned int)((x)&0xff)
	if(code==DE_MSGCODE_HL) {
		emit_sz(cc, "\x1b[7m");
	}
	else if(code==DE_MSGCODE_UNHL) {
		emit_sz(cc, "\x1b[27m");
	}
	else if(code==DE_MSGCODE_RGBSAMPLE && cc->color_method==CM_ANSI24) {
		char buf[64];

		de_snprintf(buf, sizeof(buf), "\x1b[48;2;%u;%u;%um  \x1b[0m",
			X_DE_COLOR_R(param1), X_DE_COLOR_G(param1), X_DE_COLOR_B(param1));
		emit_sz(cc, buf);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %ecx, %ebp
movl %edx, %r14d
callq 0xfc30e
cmpl $0x0, 0x88(%rax)
je 0x18ff3
movq %rax, %rbx
cmpl $0x0, 0x2c(%rax)
jne 0x18f72
movq %rbx, %rdi
callq 0x19099
cmpl $0x2000, %r14d          # imm = 0x2000
je 0x18fad
cmpl $0x1100, %r14d          # imm = 0x1100
je 0x18f96
cmpl $0x1000, %r14d          # imm = 0x1000
jne 0x18ff3
leaq 0xea199(%rip), %rsi     # 0x10312d
jmp 0x18f9d
leaq 0xea195(%rip), %rsi     # 0x103132
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x190f8
cmpl $0x3, 0x88(%rbx)
jne 0x18ff3
movl %ebp, %ecx
shrl $0x10, %ecx
movl $0xff, %eax
andl %eax, %ecx
movl %ebp, %r8d
shrl $0x8, %r8d
andl %eax, %r8d
andl %eax, %ebp
leaq 0xea163(%rip), %rdx     # 0x103138
movq %rsp, %r14
pushq $0x40
popq %rsi
movq %r14, %rdi
movl %ebp, %r9d
xorl %eax, %eax
callq 0xde40c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x190f8
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-cmd.c
// Function: print_version
static void print_version(deark *c, int verbose)
{
	char vbuf[80];

	de_printf(c, DE_MSGTYPE_MESSAGE, "Deark version: %s\n",
		de_get_version_string(vbuf, sizeof(vbuf)));
	if(!verbose) return;
	de_printf(c, DE_MSGTYPE_MESSAGE, "platform API: %s\n",
#ifdef DE_WINDOWS
		"Windows"
#else
		"Unix-like"
#endif
		);
	de_printf(c, DE_MSGTYPE_MESSAGE, "platform bits: %u\n",
		(unsigned int)(8*sizeof(void*)));
#ifdef _DEBUG
	de_printf(c, DE_MSGTYPE_MESSAGE, "build type: debug\n");
#endif
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %rdi
pushq $0x50
popq %rsi
callq 0xde3a8
leaq 0xea71c(%rip), %rdx     # 0x10376b
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0xde7db
testl %ebp, %ebp
je 0x19092
leaq 0xea715(%rip), %rdx     # 0x10377e
leaq 0xea720(%rip), %rcx     # 0x103790
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0xde7db
leaq 0xea717(%rip), %rdx     # 0x10379a
pushq $0x40
popq %rcx
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0xde7db
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-cmd.c
// Function: colormode_opt
static void colormode_opt(struct cmdctx *cc, const char *modestr)
{
	if(!strcmp(modestr, "auto")) {
		cc->color_method_req = CM_AUTOCOLOR;
	}
	else if(!strcmp(modestr, "ansi")) {
		cc->color_method_req = CM_ANSI;
	}
	else if(!strcmp(modestr, "ansi24")) {
		cc->color_method_req = CM_ANSI24;
	}
	else if(!strcmp(modestr, "winconsole")) {
		cc->color_method_req = CM_WINCONSOLE;
	}
	else  if(!strcmp(modestr, "none")) {
		cc->color_method_req = CM_NOCOLOR;
	}
	else {
		de_printf(cc->c, DE_MSGTYPE_MESSAGE, "Invalid colormode: %s\n", modestr);
		cc->error_flag = 1;
		return;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xea451(%rip), %rsi     # 0x103577
movq %r14, %rdi
callq 0x181a0
testl %eax, %eax
je 0x1919d
leaq 0xea5c1(%rip), %rsi     # 0x1036fa
movq %r14, %rdi
callq 0x181a0
testl %eax, %eax
je 0x191a9
leaq 0xea5b3(%rip), %rsi     # 0x1036ff
movq %r14, %rdi
callq 0x181a0
testl %eax, %eax
je 0x191b5
leaq 0xea5a7(%rip), %rsi     # 0x103706
movq %r14, %rdi
callq 0x181a0
testl %eax, %eax
je 0x191c1
leaq 0xea59f(%rip), %rsi     # 0x103711
movq %r14, %rdi
callq 0x181a0
testl %eax, %eax
je 0x191cd
movq (%rbx), %rdi
leaq 0xea58e(%rip), %rdx     # 0x103716
xorl %esi, %esi
movq %r14, %rcx
xorl %eax, %eax
callq 0xde7db
movl $0x1, 0x18(%rbx)
jmp 0x191d4
movl $0x1, 0x84(%rbx)
jmp 0x191d4
movl $0x2, 0x84(%rbx)
jmp 0x191d4
movl $0x3, 0x84(%rbx)
jmp 0x191d4
movl $0x4, 0x84(%rbx)
jmp 0x191d4
andl $0x0, 0x84(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-cmd.c
// Function: handle_an_input_filename
static void handle_an_input_filename(struct cmdctx *cc, char *fn)
{
	if(!cc->input_filename) {
		cc->input_filename = fn;
		de_set_input_filename(cc->c, cc->input_filename, 0);
		return;
	}

	if(cc->mp_mode) {
		de_set_input_filename(cc->c, fn, 0x1);
		return;
	}

	cc->error_flag = 1;
	cc->show_usage_message = 1;
}

// Assembly:
cmpq $0x0, 0x10(%rdi)
je 0x191f7
cmpb $0x0, 0x80(%rdi)
je 0x19205
movq (%rdi), %rdi
pushq $0x1
popq %rdx
jmp 0xfc6b3
movq %rsi, 0x10(%rdi)
movq (%rdi), %rdi
xorl %edx, %edx
jmp 0xfc6b3
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-modules.c
// Function: de_register_modules_internal
static void de_register_modules_internal(deark *c)
{
	static const de_module_getinfo_fn infofunc_list[] = {
#define DE_MODULE(x)      x,
#define DE_MODULE_LAST(x) x
#include "deark-modules.h"
#undef DE_MODULE
#undef DE_MODULE_LAST
	};
	size_t num_modules;
	size_t i;

	if(c->module_info) return; // Already done.

	num_modules = DE_ARRAYCOUNT(infofunc_list);

	c->module_info = de_mallocarray(c, num_modules, sizeof(struct deark_module_info));

	for(i=0; i<num_modules; i++) {
		register_a_module(c, infofunc_list[i]);
	}

	disable_modules_as_requested(c);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x1b0(%rdi)
je 0x1923f
popq %rbx
popq %r14
popq %r15
retq
movq %rdi, %rbx
pushq $0x48
popq %rdx
movl $0x179, %esi            # imm = 0x179
callq 0xdf66f
movq %rax, 0x1b0(%rbx)
xorl %r14d, %r14d
leaq 0x166a20(%rip), %r15    # 0x17fc80
cmpq $0xbc8, %r14            # imm = 0xBC8
je 0x19291
movslq 0x1a8(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x1a8(%rbx)
imulq $0x48, %rax, %rsi
addq 0x1b0(%rbx), %rsi
movq %rbx, %rdi
callq *(%r14,%r15)
addq $0x8, %r14
jmp 0x19260
cmpq $0x0, 0x170(%rbx)
jne 0x192b9
cmpq $0x0, 0x178(%rbx)
jne 0x192b9
cmpq $0x0, 0x180(%rbx)
jne 0x192b9
cmpq $0x0, 0x188(%rbx)
je 0x19239
movslq 0x1a8(%rbx), %rsi
movq %rbx, %rdi
callq 0xdecaf
movq %rax, %r14
movq 0x170(%rbx), %rsi
testq %rsi, %rsi
je 0x19313
pushq $0x18
popq %r15
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1944c
xorl %eax, %eax
xorps %xmm0, %xmm0
movslq 0x1a8(%rbx), %rcx
cmpq %rcx, %rax
jge 0x19313
cmpb $0x0, (%r14,%rax)
jne 0x1930a
movq 0x1b0(%rbx), %rcx
movups %xmm0, (%rcx,%r15)
incq %rax
addq $0x48, %r15
jmp 0x192eb
cmpq $0x0, 0x178(%rbx)
je 0x19370
movslq 0x1a8(%rbx), %rdx
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
callq 0x18140
movq 0x178(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1944c
pushq $0x18
popq %rax
xorps %xmm0, %xmm0
movslq 0x1a8(%rbx), %rcx
cmpq %rcx, %r15
jge 0x19370
cmpb $0x0, (%r14,%r15)
je 0x19367
movq 0x1b0(%rbx), %rcx
movups %xmm0, (%rcx,%rax)
incq %r15
addq $0x48, %rax
jmp 0x19349
cmpq $0x0, 0x180(%rbx)
je 0x193d6
movslq 0x1a8(%rbx), %rdx
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
callq 0x18140
movq 0x180(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1944c
movl 0x1a8(%rbx), %eax
testl %eax, %eax
cmovlel %r15d, %eax
imulq $0x48, %rax, %rax
movq %r14, %rcx
cmpq %r15, %rax
je 0x193d6
cmpb $0x0, (%rcx)
jne 0x193cd
movq 0x1b0(%rbx), %rdx
orl $0x100, 0x30(%rdx,%r15) # imm = 0x100
addq $0x48, %r15
incq %rcx
jmp 0x193b3
cmpq $0x0, 0x188(%rbx)
je 0x1943c
movslq 0x1a8(%rbx), %rdx
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
callq 0x18140
movq 0x188(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1944c
movl 0x1a8(%rbx), %eax
testl %eax, %eax
cmovlel %r15d, %eax
imulq $0x48, %rax, %rax
movq %r14, %rcx
cmpq %r15, %rax
je 0x1943c
cmpb $0x0, (%rcx)
je 0x19433
movq 0x1b0(%rbx), %rdx
orl $0x100, 0x30(%rdx,%r15) # imm = 0x100
addq $0x48, %r15
incq %rcx
jmp 0x19419
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xded32
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/src/deark-modules.c
// Function: module_list_string_to_set
static void module_list_string_to_set(deark *c, const char *s, u8 *mod_set)
{
	char tmpname[80];
	const char *ptr1, *ptr2;

	if(!s) return;

	ptr1 = s;
	while(1) {
		int idx;

		tmpname[0] = '\0';
		ptr2 = de_strchr(ptr1, ',');
		if(ptr2) {
			size_t len;
			len = (size_t)(ptr2-ptr1);
			if(len<sizeof(tmpname)) {
				de_memcpy(tmpname, ptr1, len);
				tmpname[len] = '\0';
			}
			ptr1 = ptr2 + 1;
		}
		else {
			de_strlcpy(tmpname, ptr1, sizeof(tmpname));
		}

		idx = de_get_module_idx_by_id(c, tmpname);
		if(idx>=0) {
			mod_set[idx] = 1;
		}

		if(!ptr2) break;
	}
}

// Assembly:
testq %rsi, %rsi
je 0x194e1
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %r12
movb $0x0, (%rsp)
movq %r15, %rdi
pushq $0x2c
popq %rsi
callq 0xde55b
movq %rax, %rbp
testq %rax, %rax
je 0x194ab
movq %rbp, %r13
subq %r15, %r13
cmpq $0x4f, %r13
ja 0x194a5
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x181e0
movb $0x0, (%rsp,%r13)
leaq 0x1(%rbp), %r15
jmp 0x194b9
movq %r12, %rdi
movq %r15, %rsi
pushq $0x50
popq %rdx
callq 0xde492
movq %r14, %rdi
movq %r12, %rsi
callq 0xdf7c6
testl %eax, %eax
js 0x194ce
movl %eax, %eax
movb $0x1, (%rbx,%rax)
testq %rbp, %rbp
jne 0x1946f
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/jsummers[P]deark/modules/abk.c
// Function: de_module_abk
void de_module_abk(deark *c, struct deark_module_info *mi)
{
	mi->id = "abk";
	mi->desc = "AMOS resource (AmBk, sprite, icon, AmBs)";
	mi->run_fn = de_run_abk;
	mi->identify_fn = de_identify_abk;
	mi->help_fn = de_help_abk;
}

// Assembly:
leaq 0xeac97(%rip), %rax     # 0x104182
movq %rax, (%rsi)
leaq 0xea878(%rip), %rax     # 0x103d6d
movq %rax, 0x8(%rsi)
leaq 0x1b(%rip), %rax        # 0x1951b
movq %rax, 0x18(%rsi)
leaq 0x222(%rip), %rax       # 0x1972d
movq %rax, 0x20(%rsi)
leaq 0x2b5(%rip), %rax       # 0x197cb
movq %rax, 0x28(%rsi)
retq