LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/print.c
// Function: memprint_grow
static void memprint_grow(Format *format, size_t more) {
	char *buf;
	size_t len = format->bufend - format->bufbegin + 1;
	size_t used = format->buf - format->bufbegin;

	len = (len >= more)
		? len * 2
		: ((len + more) + PRINT_ALLOCSIZE) &~ (PRINT_ALLOCSIZE - 1);
	if (format->u.n)
		buf = erealloc(format->bufbegin, len);
	else {
		buf = nalloc(len);
		memcpy(buf, format->bufbegin, used);
	}
	format->buf = buf + used;
	format->bufbegin = buf;
	format->bufend = buf + len - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0x100b9
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x30(%rbp)
jmp 0x100cd
movq -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
addq $0x40, %rax
andq $-0x40, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x58(%rax)
je 0x100f6
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xd890
movq %rax, -0x18(%rbp)
jmp 0x10118
movq -0x20(%rbp), %rdi
callq 0xd4c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x3220
movq -0x18(%rbp), %rcx
addq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
addq -0x20(%rbp), %rcx
addq $-0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/signal.c
// Function: sys_signal
void (*sys_signal(int signum, void (*handler)(int)))(int) {
	struct sigaction new, old;

	new.sa_handler = handler;
	new.sa_flags = 0; /* clear SA_RESTART */
	sigfillset(&new.sa_mask);
	if (sigaction(signum, &new, &old) == 0)
		return old.sa_handler;
	return SIG_DFL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl $0x0, -0x28(%rbp)
leaq -0xb0(%rbp), %rdi
addq $0x8, %rdi
callq 0x3210
movl -0xc(%rbp), %edi
leaq -0xb0(%rbp), %rsi
leaq -0x148(%rbp), %rdx
callq 0x30a0
cmpl $0x0, %eax
jne 0x1041c
movq -0x148(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10424
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/signal.c
// Function: catcher
extern void catcher(int s) {
	if (caught[s] == 0) {
		sigcount++;
		caught[s] = 1;
	}
	sys_signal(s, catcher);

#if HAVE_RESTARTABLE_SYSCALLS
	if (slow) {
		siglongjmp(slowbuf.j, s);
	}
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x100ca(%rip), %rax     # 0x20520
movl (%rax,%rcx,4), %eax
cmpl $0x0, %eax
jne 0x1047f
movl 0x101c0(%rip), %eax     # 0x20624
addl $0x1, %eax
movl %eax, 0x101b7(%rip)     # 0x20624
movslq -0x4(%rbp), %rcx
leaq 0x100a8(%rip), %rax     # 0x20520
movl $0x1, (%rax,%rcx,4)
movl -0x4(%rbp), %edi
leaq -0x49(%rip), %rsi       # 0x10440
callq 0x103c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/signal.c
// Function: sigchk
extern void sigchk() {
	void (*h)(int);
	int s, i;

	if (sigcount == 0)
		return; /* ho hum; life as usual */
	if (forked)
		exit(1); /* exit unconditionally on a signal in a child process */
	for (i = 0, s = -1; i < NUMOFSIGNALS; i++)
		if (caught[i] != 0) {
			s = i;
			--sigcount;
			caught[s] = 0;
			break;
		}
	if (s == -1)
		panic("all-zero sig vector with nonzero sigcount");
	if ((h = sighandlers[s]) == SIG_DFL)
		panic("caught signal set to SIG_DFL");
	if (h == SIG_IGN)
		panic("caught signal set to SIG_IGN");
	(*h)(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x10176(%rip), %eax     # 0x20624
cmpl $0x0, %eax
jne 0x104b8
jmp 0x10582
leaq 0x10b99(%rip), %rax     # 0x21058
cmpl $0x0, (%rax)
je 0x104ce
movl $0x1, %edi
callq 0x3320
movl $0x0, -0x10(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
cmpl $0x41, -0x10(%rbp)
jge 0x1052b
movslq -0x10(%rbp), %rcx
leaq 0x10033(%rip), %rax     # 0x20520
movl (%rax,%rcx,4), %eax
cmpl $0x0, %eax
je 0x1051e
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl 0x10123(%rip), %eax     # 0x20624
addl $-0x1, %eax
movl %eax, 0x1011a(%rip)     # 0x20624
movslq -0xc(%rbp), %rcx
leaq 0x1000b(%rip), %rax     # 0x20520
movl $0x0, (%rax,%rcx,4)
jmp 0x1052b
jmp 0x10520
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x104dc
cmpl $-0x1, -0xc(%rbp)
jne 0x1053d
leaq 0xa056(%rip), %rdi      # 0x1a58e
callq 0x11c80
movslq -0xc(%rbp), %rcx
leaq 0x100e8(%rip), %rax     # 0x20630
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jne 0x10562
leaq 0xa05b(%rip), %rdi      # 0x1a5b8
callq 0x11c80
movl $0x1, %eax
cmpq %rax, -0x8(%rbp)
jne 0x10579
leaq 0xa061(%rip), %rdi      # 0x1a5d5
callq 0x11c80
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %edi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/signal.c
// Function: rc_signal
extern void (*rc_signal(int s, void (*h)(int)))(int) {
	void (*old)(int);
	sigchk();
	old = sighandlers[s];
	sighandlers[s] = h;
	if (h == SIG_DFL || h == SIG_IGN)
		sys_signal(s, h);
	else
		sys_signal(s, catcher);
	return old;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x104a0
movslq -0x4(%rbp), %rcx
leaq 0x10081(%rip), %rax     # 0x20630
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x1006a(%rip), %rax     # 0x20630
movq %rdx, (%rax,%rcx,8)
cmpq $0x0, -0x10(%rbp)
je 0x105dc
movl $0x1, %eax
cmpq %rax, -0x10(%rbp)
jne 0x105ea
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x103c0
jmp 0x105f9
movl -0x4(%rbp), %edi
leaq -0x1b4(%rip), %rsi      # 0x10440
callq 0x103c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/signal.c
// Function: initsignal
extern void initsignal() {
	void (*h)(int);
	int i;

	/* Ensure that SIGCHLD is not SIG_IGN.  Solaris's rshd does this.  :-( */
	h = sys_signal(SIGCHLD, SIG_IGN);
	if (h != SIG_IGN && h != SIG_ERR)
		sys_signal(SIGCHLD, h);
	else
		sys_signal(SIGCHLD, SIG_DFL);

	for (i = 1; i < NUMOFSIGNALS; i++) {
#ifdef SIGKILL
		if (i == SIGKILL) continue;
#endif
#ifdef SIGSTOP
		if (i == SIGSTOP) continue;
#endif
		h = sys_signal(i, SIG_IGN);
		if (h != SIG_IGN && h != SIG_ERR)
			sys_signal(i, h);
		sighandlers[i] = h;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x11, %edi
movl $0x1, %esi
callq 0x103c0
movq %rax, -0x8(%rbp)
movl $0x1, %eax
cmpq %rax, -0x8(%rbp)
je 0x10653
movq $-0x1, %rax
cmpq %rax, -0x8(%rbp)
je 0x10653
movq -0x8(%rbp), %rsi
movl $0x11, %edi
callq 0x103c0
jmp 0x10661
movl $0x11, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x103c0
movl $0x1, -0xc(%rbp)
cmpl $0x41, -0xc(%rbp)
jge 0x106d1
cmpl $0x9, -0xc(%rbp)
jne 0x10676
jmp 0x106c6
cmpl $0x13, -0xc(%rbp)
jne 0x1067e
jmp 0x106c6
movl -0xc(%rbp), %edi
movl $0x1, %esi
callq 0x103c0
movq %rax, -0x8(%rbp)
movl $0x1, %eax
cmpq %rax, -0x8(%rbp)
je 0x106b3
movq $-0x1, %rax
cmpq %rax, -0x8(%rbp)
je 0x106b3
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x103c0
movq -0x8(%rbp), %rdx
movslq -0xc(%rbp), %rcx
leaq 0xff6e(%rip), %rax      # 0x20630
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x10668
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/status.c
// Function: istrue
extern int istrue() {
	int i;
	for (i = 0; i < pipelength; i++)
		if (statuses[i] != 0)
			return FALSE;
	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0xf0cc(%rip), %eax      # 0x1f7c0
jge 0x1071d
movslq -0x8(%rbp), %rcx
leaq 0x1013f(%rip), %rax     # 0x20840
cmpl $0x0, (%rax,%rcx,4)
je 0x10710
movl $0x0, -0x4(%rbp)
jmp 0x10724
jmp 0x10712
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x106eb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/status.c
// Function: getstatus
extern int getstatus() {
	int s;
	if (pipelength > 1)
		return !istrue();
	s = statuses[0];
	if (WIFSIGNALED(s))
		return 1;
	return WEXITSTATUS(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x1, 0xf081(%rip)      # 0x1f7c0
jle 0x10758
callq 0x106e0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x1078b
movl 0x100e2(%rip), %eax     # 0x20840
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x1077d
movl $0x1, -0x4(%rbp)
jmp 0x1078b
movl -0x8(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/status.c
// Function: statprint
static void statprint(pid_t pid, int i) {
	int t = WIFSIGNALED(i) ? WTERMSIG(i) : 0;
	const char *core = ((t > 0) && myWIFDUMPED(i) ? "--core dumped" : "");
	if ((interactive && pid != -1) || (t > 0 && (*core || (t != SIGINT && t != SIGPIPE)))) {
		if (pid != -1)
			fprint(2, "%ld: ", (long)pid);
		if (t == 0)
			fprint(2, "done (%d)\n", WEXITSTATUS(i));
		else if ((t > 0) && (t < NUMOFSIGNALS) && *signals[t].msg != '\0')
			fprint(2, "%s%s\n", signals[t].msg, core);
		else
			fprint(2, "unknown signal %d%s\n", t, core);
	}
	if (i != 0 && dashee && !cond)
		rc_exit(getstatus());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x1083c
movl -0x8(%rbp), %eax
andl $0x7f, %eax
movl %eax, -0x1c(%rbp)
jmp 0x10843
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0x10843
movl -0x1c(%rbp), %eax
movl %eax, -0xc(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x1d(%rbp)
jle 0x10865
movl -0x8(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %dl
leaq 0x5808(%rip), %rax      # 0x16077
leaq 0x9d99(%rip), %rcx      # 0x1a60f
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x18(%rbp)
leaq 0xf3dc(%rip), %rax      # 0x1fc64
cmpl $0x0, (%rax)
je 0x10893
cmpl $-0x1, -0x4(%rbp)
jne 0x108bd
cmpl $0x0, -0xc(%rbp)
jle 0x10978
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x108bd
cmpl $0x2, -0xc(%rbp)
je 0x10978
cmpl $0xd, -0xc(%rbp)
je 0x10978
cmpl $-0x1, -0x4(%rbp)
je 0x108da
movslq -0x4(%rbp), %rdx
movl $0x2, %edi
leaq 0x9d4a(%rip), %rsi      # 0x1a61d
movb $0x0, %al
callq 0xf3a0
cmpl $0x0, -0xc(%rbp)
jne 0x10901
movl -0x8(%rbp), %edx
andl $0xff00, %edx           # imm = 0xFF00
sarl $0x8, %edx
movl $0x2, %edi
leaq 0x9d2b(%rip), %rsi      # 0x1a623
movb $0x0, %al
callq 0xf3a0
jmp 0x10976
cmpl $0x0, -0xc(%rbp)
jle 0x1095a
cmpl $0x41, -0xc(%rbp)
jge 0x1095a
movslq -0xc(%rbp), %rcx
leaq 0xea98(%rip), %rax      # 0x1f3b0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1095a
movslq -0xc(%rbp), %rcx
leaq 0xea7a(%rip), %rax      # 0x1f3b0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rcx
movl $0x2, %edi
leaq 0x9cdd(%rip), %rsi      # 0x1a62e
movb $0x0, %al
callq 0xf3a0
jmp 0x10974
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movl $0x2, %edi
leaq 0x9cc7(%rip), %rsi      # 0x1a634
movb $0x0, %al
callq 0xf3a0
jmp 0x10976
jmp 0x10978
cmpl $0x0, -0x8(%rbp)
je 0x109a2
leaq 0xf2d7(%rip), %rax      # 0x1fc5c
cmpl $0x0, (%rax)
je 0x109a2
leaq 0x106d7(%rip), %rax     # 0x21068
cmpl $0x0, (%rax)
jne 0x109a2
callq 0x10730
movl %eax, %edi
callq 0x5c00
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/status.c
// Function: sgetstatus
extern List *sgetstatus() {
	List *r = NULL;
	int i;

	for (i = 0; i < pipelength; i++) {
		List *q = nnew(List);
		q->w = strstatus(statuses[i]);
		q->m = NULL;
		q->n = r;
		r = q;
	}

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0xed90(%rip), %eax      # 0x1f7c0
jge 0x10a88
movl $0x18, %edi
callq 0xd4c0
movq %rax, -0x18(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0xfdf5(%rip), %rax      # 0x20840
movl (%rax,%rcx,4), %edi
callq 0x10aa0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x10a27
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x10b5e
movl -0xc(%rbp), %eax
andl $0x7f, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edx
andl $0x80, %edx
leaq 0x559c(%rip), %rax      # 0x16077
leaq 0x9b10(%rip), %rcx      # 0x1a5f2
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0x10b43
cmpl $0x41, -0x10(%rbp)
jge 0x10b43
movslq -0x10(%rbp), %rcx
leaq 0xe8ac(%rip), %rax      # 0x1f3b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x10b43
movslq -0x10(%rbp), %rcx
leaq 0xe88f(%rip), %rax      # 0x1f3b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
leaq 0x9ac2(%rip), %rdi      # 0x1a5f8
movb $0x0, %al
callq 0xf6d0
movq %rax, -0x8(%rbp)
jmp 0x10b7c
movl -0x10(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq 0x9aac(%rip), %rdi      # 0x1a5fd
movb $0x0, %al
callq 0xf6d0
movq %rax, -0x8(%rbp)
jmp 0x10b7c
movl -0xc(%rbp), %esi
andl $0xff00, %esi           # imm = 0xFF00
sarl $0x8, %esi
leaq 0x4d50(%rip), %rdi      # 0x158c1
movb $0x0, %al
callq 0xf6d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x10e1f
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x30c0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jg 0x10dfb
jmp 0x10e1f
jmp 0x10dfd
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movslq -0x1c(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x10dda
callq 0x104a0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/tree.c
// Function: treefree
extern void treefree(Node *s) {
	if (s == NULL)
		return;
	switch (s->type) {
	default:
		panic("unexpected node in treefree");
		/* NOTREACHED */
	case nDup:
		break;
	case nWord:
		efree(s->u[0].s);
		efree(s->u[1].s);
		break;
	case nBang: case nNowait:
	case nCount: case nFlat: case nRmfn:
	case nSubshell: case nVar: case nCase:
		treefree(s->u[0].p);
		break;
	case nAndalso: case nAssign: case nBackq: case nBody: case nBrace: case nConcat:
	case nElse: case nEpilog: case nIf: case nNewfn:
	case nOrelse: case nPre: case nArgs: case nCbody:
	case nSwitch: case nMatch:  case nVarsub: case nWhile:
	case nLappend:
		treefree(s->u[1].p);
		treefree(s->u[0].p);
		break;
	case nForin:
		treefree(s->u[2].p);
		treefree(s->u[1].p);
		treefree(s->u[0].p);
		break;
	case nPipe:
		treefree(s->u[2].p);
		treefree(s->u[3].p);
		break;
	case nRedir:
	case nNmpipe:
		treefree(s->u[2].p);
	}
	efree(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x11ab8
jmp 0x11b8f
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x20, %rax
ja 0x11adc
movq -0x10(%rbp), %rax
leaq 0x8c81(%rip), %rcx      # 0x1a754
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8d26(%rip), %rdi      # 0x1a809
callq 0x11c80
jmp 0x11b86
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xd7a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xd7a0
jmp 0x11b86
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11aa0
jmp 0x11b86
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x11aa0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11aa0
jmp 0x11b86
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x11aa0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x11aa0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11aa0
jmp 0x11b86
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x11aa0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x11aa0
jmp 0x11b86
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x11aa0
movq -0x8(%rbp), %rdi
callq 0xd7a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11c00
leaq 0xe0a7(%rip), %rax      # 0x1fc64
cmpl $0x0, (%rax)
je 0x11bdb
movq -0x8(%rbp), %rdx
movl $0x2, %edi
leaq 0x4332(%rip), %rsi      # 0x15f04
movb $0x0, %al
callq 0xf3a0
jmp 0x11bfe
leaq 0xe046(%rip), %rax      # 0x1fc28
movl (%rax), %edx
addl -0xc(%rbp), %edx
movq -0x8(%rbp), %rcx
movl $0x2, %edi
leaq 0x8c2e(%rip), %rsi      # 0x1a825
movb $0x0, %al
callq 0xf3a0
jmp 0x11c00
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x3040
movl (%rax), %edi
callq 0x3350
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x11c3e
leaq 0x8bfc(%rip), %rax      # 0x1a836
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11c62
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x2, %edi
leaq 0x8beb(%rip), %rsi      # 0x1a844
movb $0x0, %al
callq 0xf3a0
jmp 0x11c79
movq -0x10(%rbp), %rdx
movl $0x2, %edi
leaq 0x4292(%rip), %rsi      # 0x15f04
movb $0x0, %al
callq 0xf3a0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x2, %edi
leaq 0x8bb8(%rip), %rsi      # 0x1a850
movl $0xa, %edx
callq 0x30c0
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30f0
movq -0x10(%rbp), %rsi
movq %rax, %rdx
movl $0x2, %edi
callq 0x30c0
movl $0x2, %edi
leaq 0x8b8b(%rip), %rsi      # 0x1a85b
movl $0x2, %edx
callq 0x30c0
movl $0x1, %edi
callq 0x3320
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x11d47
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jb 0x11d2c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11d4d
movl -0x18(%rbp), %eax
imull -0x14(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x11d02
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/utils.c
// Function: mvfd
extern int mvfd(int i, int j) {
	if (i != j) {
		int s = dup2(i, j);
		close(i);
		return s;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x11e44
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x3110
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %edi
callq 0x3170
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x11e4b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x465e(%rip), %rsi     # 0xd820
callq 0xc960
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x99e0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x9f40
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x8994(%rip), %ecx      # 0x1a85e
cmpl %ecx, %eax
jne 0x11ee3
movq -0x8(%rbp), %rdi
leaq 0x8985(%rip), %rsi      # 0x1a85e
callq 0x31e0
cmpl $0x0, %eax
je 0x11f0a
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x8972(%rip), %ecx      # 0x1a863
cmpl %ecx, %eax
jne 0x11f0f
movq -0x8(%rbp), %rdi
leaq 0x8963(%rip), %rsi      # 0x1a863
callq 0x31e0
cmpl $0x0, %eax
jne 0x11f0f
callq 0xaed0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6070
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x11f4c
movl $0x0, -0x4(%rbp)
jmp 0x12027
movq -0x18(%rbp), %rdi
callq 0x12030
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
je 0x11fa2
movslq -0x24(%rbp), %rcx
leaq 0xf0d8(%rip), %rax      # 0x21040
movl $0x1, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
xorl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x11fa0
movslq -0x24(%rbp), %rcx
leaq 0xf0b2(%rip), %rax      # 0x21040
cmpl $0x0, (%rax,%rcx,4)
je 0x11fa0
movl $0x1, -0x4(%rbp)
jmp 0x12027
jmp 0x11fa2
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x99e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0xd820
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3070
cmpl $-0x1, -0x24(%rbp)
je 0x12012
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12110
movq -0x30(%rbp), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x120b0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x9f40
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x6, -0x14(%rbp)
jge 0x12098
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movslq -0x14(%rbp), %rdx
leaq 0xcd25(%rip), %rcx      # 0x1ed80
movq (%rcx,%rdx,8), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x1208b
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0xcd0b(%rip), %rax      # 0x1ed80
movq (%rax,%rcx,8), %rsi
callq 0x31e0
cmpl $0x0, %eax
jne 0x1208b
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1209f
jmp 0x1208d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12043
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12030
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
je 0x12101
movslq -0x18(%rbp), %rcx
leaq 0xd6f0(%rip), %rax      # 0x1f7d0
movq (%rax,%rcx,8), %rax
movl -0x18(%rbp), %ecx
xorl $0x1, %ecx
movslq %ecx, %rdx
leaq 0xcc8c(%rip), %rcx      # 0x1ed80
movq (%rcx,%rdx,8), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x37b2(%rip), %ecx      # 0x158dc
cmpl %ecx, %eax
jne 0x12151
movq -0x10(%rbp), %rdi
leaq 0x37a3(%rip), %rsi      # 0x158dc
callq 0x31e0
cmpl $0x0, %eax
jne 0x12151
callq 0x12ad0
movq %rax, -0x8(%rbp)
jmp 0x122dc
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x3744(%rip), %ecx      # 0x158a3
cmpl %ecx, %eax
jne 0x12186
movq -0x10(%rbp), %rdi
leaq 0x3735(%rip), %rsi      # 0x158a3
callq 0x31e0
cmpl $0x0, %eax
jne 0x12186
callq 0x10a10
movq %rax, -0x8(%rbp)
jmp 0x122dc
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1224b
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0x11cf0
movl %eax, -0x2c(%rbp)
cmpl $-0x1, %eax
je 0x1224b
leaq 0x2ef9(%rip), %rdi      # 0x150b0
callq 0x12110
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x2d(%rbp)
je 0x121d6
cmpl $0x0, -0x2c(%rbp)
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x121df
jmp 0x121f6
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x121c0
cmpq $0x0, -0x28(%rbp)
jne 0x1220a
movq $0x0, -0x8(%rbp)
jmp 0x122dc
movl $0x18, %edi
callq 0xd4c0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x122dc
movq -0x10(%rbp), %rdi
leaq 0xd912(%rip), %rax      # 0x1fb68
movq (%rax), %rsi
callq 0x9510
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x12273
movq $0x0, -0x8(%rbp)
jmp 0x122dc
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1228a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x122dc
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1229f
movq $0x0, -0x8(%rbp)
jmp 0x122dc
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x61d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x122cd
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x122dc
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xd861(%rip), %rax      # 0x1fb68
movq (%rax), %rsi
callq 0x9510
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x12324
movq $0x0, -0x8(%rbp)
jmp 0x12376
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1233d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x12376
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x12351
movq $0x0, -0x8(%rbp)
jmp 0x12376
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x8508(%rip), %rdi      # 0x1a86b
movb $0x0, %al
callq 0xf540
movq -0x18(%rbp), %rcx
movq %rax, 0x8(%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12030
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x2d07(%rip), %ecx      # 0x150b0
cmpl %ecx, %eax
jne 0x123e7
movq -0x8(%rbp), %rdi
leaq 0x2cf8(%rip), %rsi      # 0x150b0
callq 0x31e0
cmpl $0x0, %eax
jne 0x123e7
cmpl $0x0, -0xc(%rbp)
jne 0x123e7
leaq 0x3d17(%rip), %rdi      # 0x160e6
callq 0x12110
movq %rax, %rsi
leaq 0x2cd2(%rip), %rdi      # 0x150b0
xorl %edx, %edx
callq 0x11e60
jmp 0x12415
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x9cb0
cmpl $-0x1, -0x10(%rbp)
je 0x12415
movl -0x10(%rbp), %eax
xorl $0x1, %eax
movslq %eax, %rcx
leaq 0xc977(%rip), %rax      # 0x1ed80
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
callq 0x9cb0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x18, %edi
callq 0xd4c0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x12477
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x28(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0x2c40(%rip), %rdi      # 0x150b0
callq 0x11e60
jmp 0x124ec
movl $0x18, %edi
callq 0xd4c0
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x124c1
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x124d9
movl $0x18, %edi
callq 0xd4c0
movq -0x20(%rbp), %rcx
movq %rax, 0x10(%rcx)
movq %rax, -0x20(%rbp)
jmp 0x12490
movq -0x28(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0x2bc9(%rip), %rdi      # 0x150b0
callq 0x11e60
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1252c
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
xorl %eax, %eax
movl %eax, %esi
callq 0x11e60
jmp 0x12561
movq -0x10(%rbp), %rsi
leaq 0x835c(%rip), %rdi      # 0x1a893
leaq 0x8359(%rip), %rdx      # 0x1a897
movb $0x0, %al
callq 0xf6d0
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0x30(%rbp), %rsi
callq 0x11e60
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1259f
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
xorl %eax, %eax
movl %eax, %esi
callq 0x11e60
jmp 0x12678
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x18, %edi
callq 0xd4c0
movq %rax, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movl $0x3a, %esi
callq 0x3120
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x12631
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x30(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0xd4c0
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x3070
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movb $0x3a, (%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movl $0x18, %edi
callq 0xd4c0
movq -0x28(%rbp), %rcx
movq %rax, 0x10(%rcx)
movq %rax, -0x28(%rbp)
jmp 0x125bc
movq -0x30(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0xd4c0
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x3070
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x11e60
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x126b4
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rdx
leaq 0x81c9(%rip), %rsi      # 0x1a871
movb $0x0, %al
callq 0xf3a0
jmp 0x127a8
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x29ee(%rip), %ecx      # 0x150b0
cmpl %ecx, %eax
jne 0x126f5
movq -0x10(%rbp), %rdi
leaq 0x29df(%rip), %rsi      # 0x150b0
callq 0x31e0
cmpl $0x0, %eax
jne 0x126f5
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x126f3
jmp 0x127a8
jmp 0x126f5
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0x12760
movslq -0x1c(%rbp), %rcx
leaq 0xc6a3(%rip), %rax      # 0x1edb0
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x12753
movslq -0x1c(%rbp), %rcx
leaq 0xc686(%rip), %rax      # 0x1edb0
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x31e0
cmpl $0x0, %eax
jne 0x12753
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rdx
leaq 0x812e(%rip), %rsi      # 0x1a878
movb $0x0, %al
callq 0xf3a0
jmp 0x12775
jmp 0x12755
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x126fc
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rdx
leaq 0x810f(%rip), %rsi      # 0x1a87d
movb $0x0, %al
callq 0xf3a0
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0x80fa(%rip), %rsi      # 0x1a881
leaq 0x81fb(%rip), %rax      # 0x1a989
cmpq $0x0, %rcx
cmoveq %rax, %rsi
movq -0x18(%rbp), %rdx
leaq 0x80b8(%rip), %rcx      # 0x1a859
movb $0x0, %al
callq 0xf3a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x3380
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $-0x1, %eax
je 0x127d9
jmp 0x127cd
movl -0x28(%rbp), %eax
testl %eax, %eax
je 0x127ee
jmp 0x12866
leaq 0x2c7a(%rip), %rdi      # 0x1545a
callq 0x11c10
xorl %eax, %eax
movl %eax, %edi
callq 0x50d0
movl $0x1, 0xe860(%rip)      # 0x21058
callq 0x104a0
callq 0x5120
movq 0xe857(%rip), %rax      # 0x21060
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x12842
cmpq $0x0, -0x20(%rbp)
je 0x1282c
movq -0x20(%rbp), %rdi
callq 0xd7a0
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x12815
cmpq $0x0, -0x20(%rbp)
je 0x12852
movq -0x20(%rbp), %rdi
callq 0xd7a0
movq $0x0, 0xe803(%rip) # 0x21060
movl $0x0, -0x4(%rbp)
jmp 0x128b3
movl $0x18, %edi
callq 0xd820
movq %rax, -0x10(%rbp)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq 0xe7c6(%rip), %rcx      # 0x21060
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0xe7b3(%rip)      # 0x21060
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x8(%rbp), %edi
movl $0x1, %esi
callq 0x12930
cmpl $0x0, %eax
jne 0x1290e
callq 0x3040
movl $0xa, (%rax)
leaq 0x2803(%rip), %rdi      # 0x150f9
callq 0x11c10
movq -0x10(%rbp), %rax
movl $0x100, (%rax)          # imm = 0x100
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1291d
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x129b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq 0xe718(%rip), %rax      # 0x21060
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1299d
cmpl $-0x1, -0x4(%rbp)
je 0x12964
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x1297a
movq -0x10(%rbp), %rax
movl $0x1, 0xc(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1298d
cmpl $0x0, -0x8(%rbp)
je 0x1298b
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
jmp 0x1298d
jmp 0x1298f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1294c
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0xe69a(%rip), %rax      # 0x21060
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x12a3f
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x12a2c
movq -0x28(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x12a2c
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0xd7a0
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12ac6
jmp 0x12a2e
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0x129ca
movq -0x10(%rbp), %rdi
callq 0x3370
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x12a7a
callq 0x3040
cmpl $0xa, (%rax)
jne 0x12a67
leaq 0x7e70(%rip), %rdi      # 0x1a8d2
callq 0x11c80
cmpl $0x0, -0x14(%rbp)
je 0x12a72
jmp 0x129bf
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12ac6
movq 0xe5df(%rip), %rax      # 0x21060
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x12ac1
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0x2c(%rbp), %eax
jne 0x12ab1
movq -0x28(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x12ac1
jmp 0x12ab3
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x12a85
jmp 0x129bf
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x8(%rbp)
movq 0xe579(%rip), %rax      # 0x21060
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12b58
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x12afe
jmp 0x12b4a
movl $0x18, %edi
callq 0xd4c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq 0x2da8(%rip), %rdi      # 0x158c1
movb $0x0, %al
callq 0xf6d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x12aeb
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x1, %esi
callq 0x12930
cmpq $0x0, 0xe4d1(%rip)      # 0x21060
je 0x12bce
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x129b0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jle 0x12bb2
movl -0x8(%rbp), %edi
movl -0x4(%rbp), %esi
callq 0x107d0
jmp 0x12bc7
xorl %edi, %edi
callq 0x107a0
callq 0x3040
cmpl $0x4, (%rax)
jne 0x12bc5
jmp 0x12bce
jmp 0x12bc7
callq 0x104a0
jmp 0x12b87
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)