LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/except.c
// Function: sigint
extern void sigint(int s) {
	if (s != SIGINT)
		panic("s != SIGINT in sigint catcher");
	/* this is the newline you see when you hit ^C while typing a command */
	if (interactive && nl_on_intr)
		fprint(2, "\n");
	nl_on_intr = TRUE;
	redirq = NULL;
	cond = FALSE;
	rc_raise(eError);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x2, -0x4(%rbp)
je 0x524d
leaq 0x101f4(%rip), %rdi     # 0x1543c
callq 0x11c80
leaq 0x1aa10(%rip), %rax     # 0x1fc64
cmpl $0x0, (%rax)
je 0x5275
cmpl $0x0, 0x1a090(%rip)     # 0x1f2f0
je 0x5275
movl $0x2, %edi
leaq 0x155ee(%rip), %rsi     # 0x1a85c
movb $0x0, %al
callq 0xf3a0
movl $0x1, 0x1a071(%rip)     # 0x1f2f0
leaq 0x1a8d2(%rip), %rax     # 0x1fb58
movq $0x0, (%rax)
leaq 0x1bdd4(%rip), %rax     # 0x21068
movl $0x0, (%rax)
xorl %edi, %edi
callq 0x4ef0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/fn.c
// Function: inithandler
extern void inithandler() {
	int i;
	null.type = nBody;
	null.u[0].p = null.u[1].p = NULL;
	for (i = 1; i < NUMOFSIGNALS; i++)
		if (i != SIGCHLD && sighandlers[i] == SIG_IGN)
			fnassign(signals[i].name, NULL); /* ignore incoming ignored signals */
	if (interactive || sighandlers[SIGINT] != SIG_IGN) {
		def_sigint = sigint;
		fnrm("sigint"); /* installs SIGINT catcher if not inherited ignored */
	}
	if (!dashdee) {
		if (interactive || sighandlers[SIGQUIT] != SIG_IGN) {
			def_sigquit = dud_handler;
			fnrm("sigquit"); /* "ignores" SIGQUIT unless inherited ignored */
		}
		if (interactive) {
			def_sigterm = dud_handler;
			fnrm("sigterm"); /* ditto for SIGTERM */
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x4, 0x1a17e(%rip)     # 0x1f810
movq $0x0, 0x1a183(%rip) # 0x1f820
movq $0x0, 0x1a170(%rip) # 0x1f818
movl $0x1, -0x4(%rbp)
cmpl $0x41, -0x4(%rbp)
jge 0x56fc
cmpl $0x11, -0x4(%rbp)
je 0x56ef
movslq -0x4(%rbp), %rcx
movl $0x1, %edx
leaq 0x1af65(%rip), %rax     # 0x20630
cmpq %rdx, (%rax,%rcx,8)
jne 0x56ef
movslq -0x4(%rbp), %rcx
leaq 0x19cd4(%rip), %rax     # 0x1f3b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x57b0
jmp 0x56f1
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x56af
leaq 0x1a561(%rip), %rax     # 0x1fc64
cmpl $0x0, (%rax)
jne 0x571a
movl $0x1, %ecx
leaq 0x1af1c(%rip), %rax     # 0x20630
cmpq %rcx, 0x10(%rax)
je 0x5734
leaq -0x4f1(%rip), %rax      # 0x5230
movq %rax, 0x1a110(%rip)     # 0x1f838
leaq 0xfd38(%rip), %rdi      # 0x15467
callq 0x5970
leaq 0x1a51d(%rip), %rax     # 0x1fc58
cmpl $0x0, (%rax)
jne 0x57a0
leaq 0x1a51d(%rip), %rax     # 0x1fc64
cmpl $0x0, (%rax)
jne 0x575e
movl $0x1, %ecx
leaq 0x1aed8(%rip), %rax     # 0x20630
cmpq %rcx, 0x18(%rax)
je 0x5778
leaq 0x33b(%rip), %rax       # 0x5aa0
movq %rax, 0x1a0d4(%rip)     # 0x1f840
leaq 0xfcfb(%rip), %rdi      # 0x1546e
callq 0x5970
leaq 0x1a4e5(%rip), %rax     # 0x1fc64
cmpl $0x0, (%rax)
je 0x579e
leaq 0x315(%rip), %rax       # 0x5aa0
movq %rax, 0x1a0b6(%rip)     # 0x1f848
leaq 0xfcdd(%rip), %rdi      # 0x15476
callq 0x5970
jmp 0x57a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/fn.c
// Function: fnassign
extern void fnassign(char *name, Node *def) {
	Node *newdef = treecpy(def == NULL ? &null : def, ealloc); /* important to do the treecopy first */
	rc_Function *new = get_fn_place(name);
	int i;
	new->def = newdef;
	new->extdef = NULL;
	if (strncmp(name, "sig", conststrlen("sig")) == 0) { /* slight optimization */
		if (streq(name, "sigchld") || streq(name, "sigcld"))
			rc_error("can't trap SIGCHLD");
		if (streq(name, "sigexit"))
			runexit = TRUE;
		for (i = 1; i < NUMOFSIGNALS; i++) /* zero is a bogus signal */
			if (streq(signals[i].name, name)) {
				handlers[i] = newdef;
				if (def == NULL)
					rc_signal(i, SIG_IGN);
				else
					rc_signal(i, fn_handler);
				break;
			}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x57d4
leaq 0x1a042(%rip), %rax     # 0x1f810
movq %rax, -0x30(%rbp)
jmp 0x57dc
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x8039(%rip), %rsi      # 0xd820
callq 0x11780
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9670
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
leaq 0xfc67(%rip), %rsi      # 0x15486
movl $0x3, %edx
callq 0x3060
cmpl $0x0, %eax
jne 0x5960
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0xfc4a(%rip), %ecx      # 0x1548a
cmpl %ecx, %eax
jne 0x5859
movq -0x8(%rbp), %rdi
leaq 0xfc3b(%rip), %rsi      # 0x1548a
callq 0x31e0
cmpl $0x0, %eax
je 0x5880
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0xfc2b(%rip), %ecx      # 0x15492
cmpl %ecx, %eax
jne 0x588c
movq -0x8(%rbp), %rdi
leaq 0xfc1c(%rip), %rsi      # 0x15492
callq 0x31e0
cmpl $0x0, %eax
jne 0x588c
leaq 0xfc12(%rip), %rdi      # 0x15499
callq 0x50d0
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0xfbe4(%rip), %ecx      # 0x1547e
cmpl %ecx, %eax
jne 0x58bd
movq -0x8(%rbp), %rdi
leaq 0xfbd5(%rip), %rsi      # 0x1547e
callq 0x31e0
cmpl $0x0, %eax
jne 0x58bd
movl $0x1, 0x1a19b(%rip)     # 0x1fa58
movl $0x1, -0x24(%rbp)
cmpl $0x41, -0x24(%rbp)
jge 0x595e
movslq -0x24(%rbp), %rcx
leaq 0x19ad7(%rip), %rax     # 0x1f3b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsbl (%rax), %eax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x594e
movslq -0x24(%rbp), %rcx
leaq 0x19ab4(%rip), %rax     # 0x1f3b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x31e0
cmpl $0x0, %eax
jne 0x594e
movq -0x18(%rbp), %rdx
movslq -0x24(%rbp), %rcx
leaq 0x19f2d(%rip), %rax     # 0x1f850
movq %rdx, (%rax,%rcx,8)
cmpq $0x0, -0x10(%rbp)
jne 0x593d
movl -0x24(%rbp), %edi
movl $0x1, %esi
callq 0x10590
jmp 0x594c
movl -0x24(%rbp), %edi
leaq 0x309(%rip), %rsi       # 0x5c50
callq 0x10590
jmp 0x595e
jmp 0x5950
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x58c4
jmp 0x5960
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/fn.c
// Function: fnrm
extern void fnrm(char *name) {
	int i;
	for (i = 1; i < NUMOFSIGNALS; i++)
		if (streq(signals[i].name, name)) {
			handlers[i] = NULL;
			switch (i) {
			case SIGINT:
				rc_signal(i, def_sigint);
				break;
			case SIGQUIT:
				rc_signal(i, def_sigquit);
				break;
			case SIGTERM:
				rc_signal(i, def_sigterm);
				break;
			default:
				rc_signal(i, SIG_DFL);
			}
		}
	if (streq(name, "sigexit"))
		runexit = FALSE;
	delete_fn(name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
cmpl $0x41, -0xc(%rbp)
jge 0x5a5c
movslq -0xc(%rbp), %rcx
leaq 0x19a18(%rip), %rax     # 0x1f3b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsbl (%rax), %eax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x5a4c
movslq -0xc(%rbp), %rcx
leaq 0x199f1(%rip), %rax     # 0x1f3b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x31e0
cmpl $0x0, %eax
jne 0x5a4c
movslq -0xc(%rbp), %rcx
leaq 0x19e6e(%rip), %rax     # 0x1f850
movq $0x0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x2, %eax
je 0x5a0b
jmp 0x59f7
movl -0x10(%rbp), %eax
subl $0x3, %eax
je 0x5a1c
jmp 0x5a01
movl -0x10(%rbp), %eax
subl $0xf, %eax
je 0x5a2d
jmp 0x5a3e
movl -0xc(%rbp), %edi
movq 0x19e23(%rip), %rsi     # 0x1f838
callq 0x10590
jmp 0x5a4a
movl -0xc(%rbp), %edi
movq 0x19e1a(%rip), %rsi     # 0x1f840
callq 0x10590
jmp 0x5a4a
movl -0xc(%rbp), %edi
movq 0x19e11(%rip), %rsi     # 0x1f848
callq 0x10590
jmp 0x5a4a
movl -0xc(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x10590
jmp 0x5a4c
jmp 0x5a4e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5983
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0xfa14(%rip), %ecx      # 0x1547e
cmpl %ecx, %eax
jne 0x5a8d
movq -0x8(%rbp), %rdi
leaq 0xfa05(%rip), %rsi      # 0x1547e
callq 0x31e0
cmpl $0x0, %eax
jne 0x5a8d
movl $0x0, 0x19fcb(%rip)     # 0x1fa58
movq -0x8(%rbp), %rdi
callq 0x9ba0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/fn.c
// Function: setsigdefaults
extern void setsigdefaults(bool sysvbackground) {
	int i;
	/*
	   General housekeeping: setsigdefaults happens after fork(),
	   so it's a convenient place to clean up open file descriptors.
	   (history file, scripts, etc.)
	*/
	closefds();
	/*
	   Restore signals to SIG_DFL, paying close attention to
	   a few quirks: SIGINT, SIGQUIT and are treated specially
	   depending on whether we are doing v7-style backgrounding
	   or not; the default action for SIGINT, SIGQUIT and SIGTERM
	   must be set to the appropriate action; finally, care must
	   be taken not to set to SIG_DFL any signals which are being
	   ignored.
	*/
	for (i = 1; i < NUMOFSIGNALS; i++)
		if (sighandlers[i] != SIG_IGN) {
			handlers[i] = NULL;
			switch (i) {
			case SIGINT:
				if (sysvbackground) {
					def_sigint = SIG_IGN;
					fnassign("sigint", NULL); /* ignore */
				} else {
					def_sigint = SIG_DFL;
					goto sigcommon;
				}
				break;
			case SIGQUIT:
				if (sysvbackground) {
					def_sigquit = SIG_IGN;
					fnassign("sigquit", NULL); /* ignore */
				} else {
					def_sigquit = SIG_DFL;
					goto sigcommon;
				}
				break;
			case SIGTERM:
				def_sigterm = SIG_DFL;
				/* FALLTHROUGH */
			sigcommon:
			default:
				if (sighandlers[i] != SIG_DFL) {
					rc_signal(i, SIG_DFL);
					delete_fn(signals[i].name);
				}
			}
		}
	delete_fn("sigexit");
	runexit = FALSE; /* No sigexit on subshells */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0xb510
movl $0x1, -0x8(%rbp)
cmpl $0x41, -0x8(%rbp)
jge 0x5bde
movslq -0x8(%rbp), %rcx
movl $0x1, %edx
leaq 0x1ab4f(%rip), %rax     # 0x20630
cmpq %rdx, (%rax,%rcx,8)
je 0x5bce
movslq -0x8(%rbp), %rcx
leaq 0x19d5a(%rip), %rax     # 0x1f850
movq $0x0, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x2, %eax
je 0x5b1f
jmp 0x5b0b
movl -0xc(%rbp), %eax
subl $0x3, %eax
je 0x5b52
jmp 0x5b15
movl -0xc(%rbp), %eax
subl $0xf, %eax
je 0x5b85
jmp 0x5b92
cmpl $0x0, -0x4(%rbp)
je 0x5b43
movl $0x1, %eax
movq %rax, 0x19d07(%rip)     # 0x1f838
leaq 0xf92f(%rip), %rdi      # 0x15467
xorl %eax, %eax
movl %eax, %esi
callq 0x57b0
jmp 0x5b50
movq $0x0, 0x19cea(%rip) # 0x1f838
jmp 0x5b90
jmp 0x5bcc
cmpl $0x0, -0x4(%rbp)
je 0x5b76
movl $0x1, %eax
movq %rax, 0x19cdc(%rip)     # 0x1f840
leaq 0xf903(%rip), %rdi      # 0x1546e
xorl %eax, %eax
movl %eax, %esi
callq 0x57b0
jmp 0x5b83
movq $0x0, 0x19cbf(%rip) # 0x1f840
jmp 0x5b90
jmp 0x5bcc
movq $0x0, 0x19cb8(%rip) # 0x1f848
jmp 0x5b92
movslq -0x8(%rbp), %rcx
leaq 0x1aa93(%rip), %rax     # 0x20630
cmpq $0x0, (%rax,%rcx,8)
je 0x5bca
movl -0x8(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x10590
movslq -0x8(%rbp), %rcx
leaq 0x197f5(%rip), %rax     # 0x1f3b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x9ba0
jmp 0x5bcc
jmp 0x5bce
jmp 0x5bd0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x5ac7
leaq 0xf899(%rip), %rdi      # 0x1547e
callq 0x9ba0
movl $0x0, 0x19e64(%rip)     # 0x1fa58
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/fn.c
// Function: rc_exit
extern void rc_exit(int stat) {
	if (runexit) {
		char *sig[2];
		sig[0] = "sigexit";
		sig[1] = NULL;
		runexit = FALSE;
		funcall(sig);
		stat = getstatus();
	}
	exit(stat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, 0x19e46(%rip)     # 0x1fa58
je 0x5c42
leaq 0xf863(%rip), %rax      # 0x1547e
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, 0x19e27(%rip)     # 0x1fa58
leaq -0x20(%rbp), %rdi
callq 0x3530
callq 0x10730
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x3320
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/fn.c
// Function: fn_handler
static void fn_handler(int s) {
	char *sig[2];
	int olderrno;
	if (s < 1 || s >= NUMOFSIGNALS)
		panic("unknown signal");
	olderrno = errno;
	sig[0] = signals[s].name;
	sig[1] = NULL;
	funcall(sig);
	errno = olderrno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x1, -0x4(%rbp)
jl 0x5c67
cmpl $0x41, -0x4(%rbp)
jl 0x5c73
leaq 0xf866(%rip), %rdi      # 0x154d4
callq 0x11c80
callq 0x3040
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x19728(%rip), %rax     # 0x1f3b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3530
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
callq 0x3040
movl -0x28(%rbp), %ecx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/fn.c
// Function: fnassign_string
extern void fnassign_string(char *extdef) {
	char *name = get_name(extdef+3); /* +3 to skip over "fn_" */
	rc_Function *new;
	if (name == NULL)
		return;
	new = get_fn_place(name);
	new->def = NULL;
	new->extdef = ecpy(extdef);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x3, %rdi
callq 0x6070
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5ce6
jmp 0x5d2a
movq -0x10(%rbp), %rdi
callq 0x9670
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0xd820
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x3070
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/fn.c
// Function: fnlookup
extern Node *fnlookup(char *name) {
	rc_Function *look = lookup_fn(name);
	Node *ret;
	if (look == NULL)
		return NULL; /* not found */
	if (look->def != NULL)
		return look->def;
	if (look->extdef == NULL) /* function was set to null, e.g., fn foo {} */
		return &null;
	ret = parse_fn(look->extdef);
	if (ret == NULL) {
		efree(look->extdef);
		look->extdef = NULL;
		return &null;
	} else {
		return look->def = treecpy(ret, ealloc); /* Need to take it out of nalloc space */
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x19e19(%rip), %rax     # 0x1fb60
movq (%rax), %rsi
callq 0x9510
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5d67
movq $0x0, -0x8(%rbp)
jmp 0x5def
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5d7e
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x5def
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x5d96
leaq 0x19a80(%rip), %rax     # 0x1f810
movq %rax, -0x8(%rbp)
jmp 0x5def
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x63e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5dd4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xd7a0
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
leaq 0x19a42(%rip), %rax     # 0x1f810
movq %rax, -0x8(%rbp)
jmp 0x5def
movq -0x20(%rbp), %rdi
leaq 0x7a41(%rip), %rsi      # 0xd820
callq 0x11780
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/fn.c
// Function: fnlookup_string
extern char *fnlookup_string(char *name) {
	rc_Function *look = lookup_fn(name);

	if (look == NULL)
		return NULL;
	if (look->extdef != NULL)
		return look->extdef;
	return look->extdef = mprint("fn_%F={%T}", name, look->def);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x19d49(%rip), %rax     # 0x1fb60
movq (%rax), %rsi
callq 0x9510
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5e34
movq $0x0, -0x8(%rbp)
jmp 0x5e72
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5e4d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x5e72
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0xf64d(%rip), %rdi      # 0x154ac
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
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/fn.c
// Function: whatare_all_signals
extern void whatare_all_signals() {
	int i;
	for (i = 1; i < NUMOFSIGNALS; i++)
		if (*signals[i].name != '\0') {
			if (sighandlers[i] == SIG_IGN)
				fprint(1, "fn %s {}\n", signals[i].name);
			else if (sighandlers[i] == fn_handler)
				fprint(1, "fn %S {%T}\n", signals[i].name, handlers[i]);
			else
				fprint(1, "fn %s\n", signals[i].name);
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, -0x4(%rbp)
cmpl $0x41, -0x4(%rbp)
jge 0x5f87
movslq -0x4(%rbp), %rcx
leaq 0x1950c(%rip), %rax     # 0x1f3b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x5f77
movslq -0x4(%rbp), %rcx
movl $0x1, %edx
leaq 0x1a766(%rip), %rax     # 0x20630
cmpq %rdx, (%rax,%rcx,8)
jne 0x5efa
movslq -0x4(%rbp), %rcx
leaq 0x194d5(%rip), %rax     # 0x1f3b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movl $0x1, %edi
leaq 0xf5c6(%rip), %rsi      # 0x154b7
movb $0x0, %al
callq 0xf3a0
jmp 0x5f75
movslq -0x4(%rbp), %rcx
leaq -0x2b5(%rip), %rdx      # 0x5c50
leaq 0x1a724(%rip), %rax     # 0x20630
cmpq %rdx, (%rax,%rcx,8)
jne 0x5f4b
movslq -0x4(%rbp), %rcx
leaq 0x19493(%rip), %rax     # 0x1f3b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x1991e(%rip), %rax     # 0x1f850
movq (%rax,%rcx,8), %rcx
movl $0x1, %edi
leaq 0xf57f(%rip), %rsi      # 0x154c1
movb $0x0, %al
callq 0xf3a0
jmp 0x5f73
movslq -0x4(%rbp), %rcx
leaq 0x1945a(%rip), %rax     # 0x1f3b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movl $0x1, %edi
leaq 0xf561(%rip), %rsi      # 0x154cd
movb $0x0, %al
callq 0xf3a0
jmp 0x5f75
jmp 0x5f77
jmp 0x5f79
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x5e8f
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/footobar.c
// Function: list2array
extern char **list2array(List *s, bool print) {
	char **argv, **av;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x6003
movq -0x8(%rbp), %rdx
movl $0x2, %edi
leaq 0x14994(%rip), %rsi     # 0x1a989
leaq 0x1485d(%rip), %rcx     # 0x1a859
movb $0x0, %al
callq 0xf3a0
movq -0x8(%rbp), %rdi
callq 0xca80
addl $0x4, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0xd4c0
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6055
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x20(%rbp)
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6027
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/footobar.c
// Function: get_name
extern char *get_name(char *s) {
	char *eq = strchr(s, '=');
	char *r, *result;
	int c;
	
	if (eq == NULL)
		return NULL;
	r = result = nalloc(eq - s + 1);
	while (1)
		switch (c = *s++) {
		case '=':
			*r++ = '\0';
			return result;
#if PROTECT_ENV
		case '_':
			if (*s == '_') {
				static const char hexchar[] = "0123456789abcdef";
				char *h1 = strchr(hexchar, s[1]);
				char *h2 = strchr(hexchar, s[2]);
				if (h1 != NULL && h2 != NULL) {
					*r++ = ((h1 - hexchar) << 4) | (h2 - hexchar);
					s += 3;
					break;
				}
			}
			/* FALLTHROUGH */
#endif
		default:
			*r++ = c;
			break;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3d, %esi
callq 0x3120
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x60a2
movq $0x0, -0x8(%rbp)
jmp 0x61b9
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
subq %rax, %rdi
addq $0x1, %rdi
callq 0xd4c0
movq %rax, -0x28(%rbp)
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
movl %eax, -0x44(%rbp)
movl %eax, -0x2c(%rbp)
subl $0x3d, %eax
je 0x60e9
jmp 0x60dc
movl -0x44(%rbp), %eax
subl $0x5f, %eax
je 0x6108
jmp 0x619e
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x61b9
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
jne 0x619c
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %esi
leaq 0xf469(%rip), %rdi      # 0x15590
callq 0x3120
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %esi
leaq 0xf451(%rip), %rdi      # 0x15590
callq 0x3120
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x619a
cmpq $0x0, -0x40(%rbp)
je 0x619a
movq -0x38(%rbp), %rax
leaq 0xf42f(%rip), %rcx      # 0x15590
subq %rcx, %rax
shlq $0x4, %rax
movq -0x40(%rbp), %rcx
leaq 0xf41d(%rip), %rdx      # 0x15590
subq %rdx, %rcx
orq %rcx, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x10(%rbp)
jmp 0x61b4
jmp 0x619c
jmp 0x619e
movl -0x2c(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0x60be
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/footobar.c
// Function: parse_fn
extern Node *parse_fn(char *extdef) {
	Node *def;
	char *s, old[PRELEN];
	if ((s = strchr(extdef, '=')) == NULL)
		return NULL;
	memcpy(old, s -= (PRELEN-1), PRELEN);
	memcpy(s, PREFIX, PRELEN);
	def = parseline(s);
	memcpy(s, old, PRELEN);
	return (def == NULL || def->type != nNewfn) ? NULL : def->u[1].p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3d, %esi
callq 0x3120
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x640e
movq $0x0, -0x8(%rbp)
jmp 0x6471
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x3, %rcx
movq %rcx, -0x20(%rbp)
movl -0x3(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl 0xf19d(%rip), %ecx      # 0x155ca
movl %ecx, (%rax)
movq -0x20(%rbp), %rdi
callq 0xb4a0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x6455
movq -0x18(%rbp), %rax
cmpl $0xe, (%rax)
je 0x645d
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x6469
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/footobar.c
// Function: initprint
void initprint(void) {
	fmtinstall('A', Aconv);
	fmtinstall('L', Lconv);
	fmtinstall('S', Sconv);
	fmtinstall('T', Tconv);
	fmtinstall('D', Dconv);
	fmtinstall('W', Wconv);
#if PROTECT_ENV
	fmtinstall('F', Fconv);
#else
	fmtinstall('F', fmtinstall('s', NULL));
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x41, %edi
leaq 0x70(%rip), %rsi        # 0x6500
callq 0xef00
movl $0x4c, %edi
leaq 0x11f(%rip), %rsi       # 0x65c0
callq 0xef00
movl $0x53, %edi
leaq 0x29e(%rip), %rsi       # 0x6750
callq 0xef00
movl $0x54, %edi
leaq 0x4fd(%rip), %rsi       # 0x69c0
callq 0xef00
movl $0x44, %edi
leaq 0xd8c(%rip), %rsi       # 0x7260
callq 0xef00
movl $0x57, %edi
leaq 0xe5b(%rip), %rsi       # 0x7340
callq 0xef00
movl $0x46, %edi
leaq 0xfda(%rip), %rsi       # 0x74d0
callq 0xef00
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/footobar.c
// Function: Aconv
static bool Aconv(Format *f, int ignore) {
	char **a = va_arg(f->args, char **);
	if (*a != NULL) {
		fmtcat(f, *a);
		while (*++a != NULL)
			fmtprint(f, " %s", *a);
	}
	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x28, %eax
ja 0x653a
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x30(%rbp)
jmp 0x6551
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x65a9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0xf140
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x65a7
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0xf031(%rip), %rsi      # 0x155cf
movb $0x0, %al
callq 0xf2a0
jmp 0x6576
jmp 0x65a9
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/footobar.c
// Function: Lconv
static bool Lconv(Format *f, int ignore) {
	bool plain;
	char *sep;
	List *l, *n;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
andq $0x20, %rax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x28, %eax
ja 0x6609
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x40(%rbp)
jmp 0x6620
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl (%rax), %eax
movl %eax, -0x44(%rbp)
cmpl $0x28, %eax
ja 0x6656
movq -0x50(%rbp), %rcx
movl -0x44(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x58(%rbp)
jmp 0x666d
movq -0x50(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x66a8
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
andq $0x20, %rax
cmpq $0x0, %rax
jne 0x66a8
movq -0x8(%rbp), %rdi
leaq 0xef37(%rip), %rsi      # 0x155d3
movb $0x0, %al
callq 0xf2a0
jmp 0x6743
jmp 0x66aa
cmpq $0x0, -0x20(%rbp)
je 0x6741
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %ecx
leaq 0xef07(%rip), %rsi      # 0x155d6
leaq 0xeefa(%rip), %rax      # 0x155d0
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movb $0x0, %al
callq 0xf2a0
cmpq $0x0, -0x28(%rbp)
je 0x6732
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jb 0x6717
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq *%rax
movq -0x18(%rbp), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rdx
movq 0x30(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x30(%rdx)
movb %cl, (%rax)
jmp 0x6734
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x66aa
jmp 0x6743
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/footobar.c
// Function: Dconv
static bool Dconv(Format *f, int ignore) {
	const char *name = "?";
	int n = va_arg(f->args, int);
	switch (n) {
	case rCreate:		name = ">";	break;
	case rAppend:		name = ">>";	break;
	case rFrom:		name = "<";	break;
	case rHeredoc:		name = "<<";	break;
	case rHerestring:	name = "<<<";	break;
	}
	fmtcat(f, name);
	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0xe462(%rip), %rax      # 0x156d8
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl (%rax), %eax
movl %eax, -0x20(%rbp)
cmpl $0x28, %eax
ja 0x72a5
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x30(%rbp)
jmp 0x72bc
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x38(%rbp)
subq $0x4, %rax
ja 0x7325
movq -0x38(%rbp), %rax
leaq 0xe297(%rip), %rcx      # 0x15574
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xe3ee(%rip), %rax      # 0x156db
movq %rax, -0x18(%rbp)
jmp 0x7325
leaq 0xe3e0(%rip), %rax      # 0x156da
movq %rax, -0x18(%rbp)
jmp 0x7325
leaq 0xe3d8(%rip), %rax      # 0x156df
movq %rax, -0x18(%rbp)
jmp 0x7325
leaq 0xe3ca(%rip), %rax      # 0x156de
movq %rax, -0x18(%rbp)
jmp 0x7325
leaq 0xe3bc(%rip), %rax      # 0x156dd
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf140
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/footobar.c
// Function: Wconv
static bool Wconv(Format *f, int ignore) {
	List *l, *n;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl (%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $0x28, %eax
ja 0x737a
movq -0x40(%rbp), %rcx
movl -0x34(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x48(%rbp)
jmp 0x7391
movq -0x40(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x74bf
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x7462
movsbl -0x21(%rbp), %eax
cmpl $0x1, %eax
je 0x73d9
movsbl -0x21(%rbp), %eax
cmpl $0x2, %eax
jne 0x7414
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jb 0x73fe
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq *%rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x30(%rcx)
movb $0x2, (%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jb 0x7439
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq *%rax
movb -0x21(%rbp), %cl
movq -0x8(%rbp), %rdx
movq 0x30(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x30(%rdx)
movb %cl, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x73b2
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x74b0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jb 0x749a
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq *%rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x30(%rcx)
movb $0x1, (%rax)
jmp 0x74b2
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x739c
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/footobar.c
// Function: Fconv
static bool Fconv(Format *f, int ignore) {
	unsigned const char *s = va_arg(f->args, unsigned const char *);
	int c;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl (%rax), %eax
movl %eax, -0x20(%rbp)
cmpl $0x28, %eax
ja 0x750a
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x30(%rbp)
jmp 0x7521
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x75d1
movslq -0x1c(%rbp), %rcx
leaq 0xe72b(%rip), %rax      # 0x15c80
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x7576
cmpl $0x2a, -0x1c(%rbp)
je 0x7576
cmpl $0x5f, -0x1c(%rbp)
jne 0x758d
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x5f, %eax
jne 0x758d
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0xe15d(%rip), %rsi      # 0x156e1
movb $0x0, %al
callq 0xf2a0
jmp 0x75cc
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jb 0x75b2
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq *%rax
movl -0x1c(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rdx
movq 0x30(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x30(%rdx)
movb %cl, (%rax)
jmp 0x752c
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/glob.c
// Function: lmatch
extern bool lmatch(List *s, List *p) {
	List *q;
	if (s == NULL) {
		if (p == NULL) /* null matches null */
			return TRUE;
		for (; p != NULL; p = p->n) /* one or more stars match null */
			if (strspn(p->w, "*") == strlen(p->w) &&
			    p->m != NULL && strlen(p->m) == strlen(p->w))
				return TRUE;
		return FALSE;
	}
	for (; s != NULL; s = s->n)
		for (q = p; q != NULL; q = q->n)
			if (match(q->w, q->m, s->w))
				return TRUE;
	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7996
cmpq $0x0, -0x18(%rbp)
jne 0x78fe
movl $0x1, -0x4(%rbp)
jmp 0x79fe
jmp 0x7900
cmpq $0x0, -0x18(%rbp)
je 0x798d
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0xd797(%rip), %rsi      # 0x150b0
callq 0x3190
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x30f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jne 0x797a
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x797a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x30f0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x30f0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jne 0x797a
movl $0x1, -0x4(%rbp)
jmp 0x79fe
jmp 0x797c
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7900
movl $0x0, -0x4(%rbp)
jmp 0x79fe
jmp 0x7998
cmpq $0x0, -0x10(%rbp)
je 0x79f7
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x79e7
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
callq 0xd110
cmpl $0x0, %eax
je 0x79d7
movl $0x1, -0x4(%rbp)
jmp 0x79fe
jmp 0x79d9
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x79a7
jmp 0x79e9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x7998
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/glob.c
// Function: glob
extern List *glob(List *s) {
	List *top, *r;
	bool meta;
	for (r = s, meta = FALSE; r != NULL; r = r->n)
		if (r->m != NULL)
			meta = TRUE;
	if (!meta)
		return s; /* don't copy lists with no metacharacters in them */
	for (top = r = NULL; s != NULL; s = s->n) {
		if (s->m == NULL) { /* no metacharacters; just tack on to the return list */
			if (top == NULL)
				top = r = nnew(List);
			else
				r = r->n = nnew(List);
			r->w = s->w;
		} else {
			if (top == NULL)
				top = r = sort(doglob(s->w, s->m));
			else
				r->n = sort(doglob(s->w, s->m));
			while (r->n != NULL)
				r = r->n;
		}
	}
	r->n = NULL;
	return top;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7a54
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7a44
movl $0x1, -0x24(%rbp)
jmp 0x7a46
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x7a2b
cmpl $0x0, -0x24(%rbp)
jne 0x7a67
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7b66
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7b52
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x7ace
cmpq $0x0, -0x18(%rbp)
jne 0x7aa8
movl $0x18, %edi
callq 0xd4c0
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
jmp 0x7abe
movl $0x18, %edi
callq 0xd4c0
movq -0x20(%rbp), %rcx
movq %rax, 0x10(%rcx)
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x7b3f
cmpq $0x0, -0x18(%rbp)
jne 0x7afb
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x7c00
movq %rax, %rdi
callq 0x7b70
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
jmp 0x7b22
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x7c00
movq %rax, %rdi
callq 0x7b70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x7b24
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x7b3d
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x7b24
jmp 0x7b3f
jmp 0x7b41
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x7a77
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/glob.c
// Function: sort
static List *sort(List *s) {
	size_t nel = listnel(s);
	if (nel > 1) {
		char **a;
		List *t;
		qsort(a = list2array(s, FALSE), nel, sizeof(char *), starstrcmp);
		for (t = s; t != NULL; t = t->n)
			t->w = *a++;
	}
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xca80
cltq
movq %rax, -0x10(%rbp)
cmpq $0x1, -0x10(%rbp)
jbe 0x7bf1
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x5fd0
movq %rax, %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movl $0x8, %edx
leaq 0xa1ac(%rip), %rcx      # 0x11d60
callq 0x3080
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7bef
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x7bc1
jmp 0x7bf1
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/glob.c
// Function: lglob
static List *lglob(List *s, char *p, char *m, size_t slashcount) {
	List *q, *r, *top, foo;
	static struct {
		List l;
		size_t size;
	} slash;
	if (slashcount+1 > slash.size) {
		slash.size = 2*(slashcount+1);
		slash.l.w = erealloc(slash.l.w, slash.size);
	}
	slash.l.w[slashcount] = '\0';
	while (slashcount > 0)
		slash.l.w[--slashcount] = '/';
	for (top = r = NULL; s != NULL; s = s->n) {
		q = dmatch(s->w, p, m);
		if (q != NULL) {
			foo.w = s->w;
			foo.m = NULL;
			foo.n = NULL;
			if (!(s->w[0] == '/' && s->w[1] == '\0')) /* need to separate */
				q = concat(&slash.l, q);	  /* dir/name with slash */
			q = concat(&foo, q);
			if (r == NULL)
				top = r = q;
			else
				r->n = q;
			while (r->n != NULL)
				r = r->n;
		}
	}
	return top;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
cmpq 0x17959(%rip), %rax     # 0x1fb50
jbe 0x8225
movq -0x20(%rbp), %rax
addq $0x1, %rax
shlq %rax
movq %rax, 0x17945(%rip)     # 0x1fb50
movq 0x17926(%rip), %rdi     # 0x1fb38
movq 0x17937(%rip), %rsi     # 0x1fb50
callq 0xd890
movq %rax, 0x17913(%rip)     # 0x1fb38
movq 0x1790c(%rip), %rax     # 0x1fb38
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpq $0x0, -0x20(%rbp)
jbe 0x8258
movq 0x178f6(%rip), %rax     # 0x1fb38
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x20(%rbp)
movb $0x2f, -0x1(%rax,%rcx)
jmp 0x8234
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8346
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7f20
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x8333
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x82d0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x82e4
movq -0x28(%rbp), %rsi
leaq 0x1785d(%rip), %rdi     # 0x1fb38
callq 0x8470
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x8470
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x830a
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x38(%rbp)
jmp 0x8316
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x8318
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x8331
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x8318
jmp 0x8333
jmp 0x8335
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x8268
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/glom.c
// Function: word
extern List *word(char *w, char *m) {
	List *s = NULL;
	if (w != NULL) {
		s = nnew(List);
		s->w = w;
		s->m = m;
		s->n = NULL;
	}
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x83a0
movl $0x18, %edi
callq 0xd4c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/glom.c
// Function: append
extern List *append(List *s1, List *s2) {
	List *r, *top;
	if (s1 == NULL)
		return s2;
	if (s2 == NULL)
		return s1;
	for (r = top = nnew(List); 1; r = r->n = nnew(List)) {
		r->w = s1->w;
		r->m = s1->m;
		if ((s1 = s1->n) == NULL)
			break;
	}
	r->n = s2;
	return top;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x83d4
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x845f
cmpq $0x0, -0x18(%rbp)
jne 0x83e5
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x845f
movl $0x18, %edi
callq 0xd4c0
movq %rax, -0x28(%rbp)
movq %rax, -0x20(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x83ff
jmp 0x844b
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x8431
jmp 0x844b
jmp 0x8433
movl $0x18, %edi
callq 0xd4c0
movq -0x20(%rbp), %rcx
movq %rax, 0x10(%rcx)
movq %rax, -0x20(%rbp)
jmp 0x83f7
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/glom.c
// Function: varsub
extern List *varsub(List *var, List *subs) {
	List *r, *top;
	int n = listnel(var);
	for (top = r = NULL; subs != NULL; subs = subs->n) {
		int i = a2u(subs->w);
		if (i < 1)
			rc_error("bad subscript");
		if (i <= n) {
			List *sub = var;
			while (--i)
				sub = sub->n; /* loop until sub == var(i) */
			if (top == NULL)
				top = r = nnew(List);
			else
				r = r->n = nnew(List);
			r->w = sub->w;
			r->m = sub->m;
		}
	}
	if (top != NULL)
		r->n = NULL;
	return top;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xca80
movl %eax, -0x24(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x879b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xa, %esi
callq 0x11cf0
movl %eax, -0x28(%rbp)
cmpl $0x1, -0x28(%rbp)
jge 0x870d
leaq 0xd102(%rip), %rdi      # 0x1580a
callq 0x50d0
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jg 0x8788
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
je 0x8739
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x871d
cmpq $0x0, -0x20(%rbp)
jne 0x8754
movl $0x18, %edi
callq 0xd4c0
movq %rax, -0x18(%rbp)
movq %rax, -0x20(%rbp)
jmp 0x876a
movl $0x18, %edi
callq 0xd4c0
movq -0x18(%rbp), %rcx
movq %rax, 0x10(%rcx)
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x878a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x86dc
cmpq $0x0, -0x20(%rbp)
je 0x87ae
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/glom.c
// Function: flatten
extern List *flatten(List *s) {
	List *r;
	size_t step;
	char *f;
	if (s == NULL || s->n == NULL)
		return s;
	r = nnew(List);
	f = r->w = nalloc(listlen(s) + 1);
	r->m = NULL; /* flattened lists come from variables, so no meta */
	r->n = NULL;
	strcpy(f, s->w);
	f += strlen(s->w);
	do {
		*f++ = ' ';
		s = s->n;
		step = strlen(s->w);
		memcpy(f, s->w, step);
		f += step;
	} while (s->n != NULL);
	*f = '\0';
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x87de
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x87eb
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x88bd
movl $0x18, %edi
callq 0xd4c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xca30
movq %rax, %rdi
addq $0x1, %rdi
callq 0xd4c0
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x3070
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x30f0
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x20, (%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x30f0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x3220
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x8855
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)