LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: listvec
cell listvec(cell x, int veclit) {
	cell	n, v;
	int	k;
	cell	*p;
	char	*msg;

	msg = veclit? "vector literal contains a dot":
		      "listvec: dotted list";
	k = 0;
	for (n = x; n != NIL; n = cdr(n))
		k++;
	if (0 == k) return Nullvec;
	v = mkvec(k);
	if (veclit) tag(v) |= CONST_TAG;
	p = vector(v);
	for (n = x; n != NIL; n = cdr(n)) {
		if (atomp(n)) error(msg, x);
		*p = car(n);
		p++;
	}
	return v;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
xorl %edi, %edi
movq 0x1303b(%rip), %rax     # 0x17348
movl %ebx, %ecx
cmpl $-0x1, %ecx
je 0x431e
incl %edi
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
jmp 0x430f
testl %edi, %edi
je 0x433b
callq 0x31ed
testl %ebp, %ebp
je 0x4348
movq 0x1301e(%rip), %rcx     # 0x17350
movslq %eax, %rdx
orb $-0x80, (%rcx,%rdx)
jmp 0x434b
movl 0x12e3b(%rip), %eax     # 0x1717c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movslq %eax, %rdx
movq 0x12ff6(%rip), %rcx     # 0x17348
movslq (%rcx,%rdx,4), %rdx
shlq $0x2, %rdx
addq 0x12ff7(%rip), %rdx     # 0x17358
movq 0x12fe8(%rip), %rsi     # 0x17350
movq 0x12fd1(%rip), %rdi     # 0x17340
movl %ebx, %r8d
cmpl $-0x1, %r8d
je 0x4341
testl %r8d, %r8d
js 0x4398
movl %r8d, %r8d
testb $0x9, (%rsi,%r8)
jne 0x4398
movl (%rdi,%r8,4), %r9d
movl %r9d, (%rdx)
addq $0x4, %rdx
movl (%rcx,%r8,4), %r8d
jmp 0x4372
testl %ebp, %ebp
leaq 0xc715(%rip), %rax      # 0x10ab6
leaq 0xc6f0(%rip), %rdi      # 0x10a98
cmoveq %rax, %rdi
movl %ebx, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: pos
int pos(int p, char *s) {
	int	i;

	i = 0;
	for (; *s; s++) {
		if (p == *s) return i;
		i++;
	}
	return -1;
}

// Assembly:
xorl %ecx, %ecx
pushq $-0x1
popq %rax
movsbl (%rsi,%rcx), %edx
testl %edx, %edx
je 0x43cb
cmpl %edi, %edx
je 0x43c9
incq %rcx
jmp 0x43b8
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: scanfix
cell scanfix(char *s, int r, int of) {
	int	v, g, i;
	char	*p;
	char	d[] = "0123456789abcdefghijklmnopqrstuvwxyz";

	g = 1;
	p = s;
	if ('+' == *p) {
		p++;
	}
	else if ('-' == *p) {
		p++;
		g = -1;
	}
	v = 0;
	while (*p) {
		i = pos(tolower(*p), d);
		if (i < 0 || i >= r) return NIL;
		if (	v > INT_MAX/r ||
			(v > 0 && add_ovfl(v*r, i)) ||
			(v < 0 && sub_ovfl(v*r, i)))
		{
			if (!of) return NIL;
			rderror("fixnum too big", mkstr(s, strlen(s)));
		}
		else if (v < 0)
			v = v*r - i;
		else
			v = v*r + i;
		p++;
		if (g) v *= g;
		g = 0;
	}
	if (g) return NIL;
	return mkfix(v);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, 0x4(%rsp)
movl %esi, %ebp
movq %rdi, %r12
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x43f6
pushq $0x1
popq %r13
cmpl $0x2b, %eax
je 0x43fa
movq %r12, %r14
jmp 0x43ff
pushq $-0x1
popq %r13
leaq 0x1(%r12), %r14
xorl %r15d, %r15d
movsbq (%r14), %rbx
testq %rbx, %rbx
je 0x44de
callq 0x2220
movq (%rax), %rax
movl (%rax,%rbx,4), %edi
leaq 0xcecf(%rip), %rsi      # 0x112f0
callq 0x43b3
testl %eax, %eax
js 0x44e3
movl %eax, %ecx
cmpl %ebp, %eax
jge 0x44e3
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
divl %ebp
cmpl %eax, %r15d
jle 0x4473
cmpl $0x0, 0x4(%rsp)
je 0x44e3
movq %r12, %rdi
callq 0x2080
movq %r12, %rdi
movl %eax, %esi
callq 0x2698
leaq 0xc031(%rip), %rdi      # 0x1049b
movl %eax, %esi
callq 0x3d93
jmp 0x44c7
testl %r15d, %r15d
jle 0x4490
testl %ecx, %ecx
je 0x4490
movl %r15d, %eax
imull %ebp, %eax
movl %ecx, %edx
xorl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
cmpl %edx, %eax
jg 0x4446
jmp 0x44b9
testl %r15d, %r15d
jns 0x44ad
testl %ecx, %ecx
je 0x44ad
movl %r15d, %eax
imull %ebp, %eax
movl %ecx, %edx
orl $0x80000000, %edx       # imm = 0x80000000
cmpl %edx, %eax
jl 0x4446
jmp 0x44c0
testl %r15d, %r15d
js 0x44c0
imull %ebp, %r15d
movl %r15d, %eax
addl %eax, %ecx
movl %ecx, %r15d
jmp 0x44c7
imull %ebp, %r15d
subl %ecx, %r15d
incq %r14
cmpl $0x1, %r13d
adcl $0x0, %r13d
imull %r13d, %r15d
xorl %r13d, %r13d
jmp 0x4402
testl %r13d, %r13d
je 0x44f5
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rsi
pushq $0x1
popq %rbx
movl %r15d, %edi
movl %ebx, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2f8c
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: rdsymfix
cell rdsymfix(int c, int r, int sym) {
	char	name[TOKLEN+1];
	int	i;
	cell	n;

	for (i=0; i<TOKLEN; i++) {
		if (!symbolic(c)) break;
		name[i] = tolower(c);
		c = readc();
	}
	name[i] = 0;
	rejectc(c);
	if (TOKLEN == i) rderror("symbol or fixnum too long",
				mkstr(name, strlen(name)));
	n = scanfix(name, r, 1);
	if (n != NIL) return n;
	if (!sym) rderror("invalid digits after #radixR",
				mkstr(name, strlen(name)));
	if ('t' == name[0] && 0 == name[1])
		return TRUE;
	if (!strcmp(name, "nil"))
		return NIL;
	return symref(name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, 0x8(%rsp)
movl %esi, 0xc(%rsp)
movl %edi, %r14d
xorl %ebp, %ebp
callq 0x2230
movq %rax, %r15
pushq $0x50
popq %rbx
leaq 0xbf5e(%rip), %r12      # 0x104aa
pushq $0x12
popq %r13
cmpq $0x50, %rbp
je 0x4599
movq (%r15), %rax
movslq %r14d, %rcx
testb $0xc, 0x1(%rax,%rcx,2)
jne 0x457b
testl %r14d, %r14d
je 0x4594
movq %r12, %rdi
movl %r14d, %esi
movq %r13, %rdx
callq 0x20d0
testq %rax, %rax
je 0x4597
movl %r14d, %edi
callq 0x2150
movb %al, 0x10(%rsp,%rbp)
callq 0x278c
movl %eax, %r14d
incq %rbp
jmp 0x4550
xorl %r14d, %r14d
movl %ebp, %ebx
movl %ebx, %eax
movb $0x0, 0x10(%rsp,%rax)
movl %r14d, %edi
callq 0x27ec
cmpl $0x50, %ebx
jne 0x45d2
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x2080
movq %r14, %rdi
movl %eax, %esi
callq 0x2698
leaq 0xbef1(%rip), %rdi      # 0x104bc
movl %eax, %esi
callq 0x3d93
leaq 0x10(%rsp), %rdi
pushq $0x1
popq %rdx
movl 0xc(%rsp), %esi
callq 0x43cc
cmpl $-0x1, %eax
jne 0x463f
cmpl $0x0, 0x8(%rsp)
jne 0x4614
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
callq 0x2698
leaq 0xbec9(%rip), %rdi      # 0x104d6
movl %eax, %esi
callq 0x3d93
cmpb $0x74, 0x10(%rsp)
jne 0x4626
cmpb $0x0, 0x11(%rsp)
jne 0x4626
pushq $-0x2
jmp 0x4632
cmpl $0x6c696e, 0x10(%rsp)   # imm = 0x6C696E
jne 0x4635
pushq $-0x1
popq %rax
jmp 0x463f
leaq 0x10(%rsp), %rdi
callq 0x39ef
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: rdfix
cell rdfix(int c) {
	int	r;

	r = 0;
	while (isdigit(c)) {
		r = r*10 + c - '0';
		c = readc();
	}
	if (c != 'r') rderror("'R' expected after #radix", UNDEF);
	if (r < 2 || r > 36) rderror("bad radix in #radixR", mkfix(r));
	c = readc();
	return rdsymfix(c, r, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %r14d
xorl %ebx, %ebx
callq 0x2230
movq %rax, %r15
movq (%r15), %rax
movslq %r14d, %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x4683
imull $0xa, %ebx, %eax
leal (%r14,%rax), %ebx
addl $-0x30, %ebx
callq 0x278c
movl %eax, %r14d
jmp 0x4662
cmpl $0x72, %r14d
je 0x4698
leaq 0xbe67(%rip), %rdi      # 0x104f7
pushq $-0x4
popq %rsi
callq 0x3d93
leal -0x25(%rbx), %eax
cmpl $-0x24, %eax
ja 0x46c9
pushq $-0x1
popq %rsi
pushq $0x1
popq %rbp
movl %ebx, %edi
movl %ebp, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %ebp, %edx
callq 0x2f8c
leaq 0xbe4f(%rip), %rdi      # 0x10511
movl %eax, %esi
callq 0x3d93
callq 0x278c
movl %eax, %edi
movl %ebx, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x451f
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: rdquote
cell rdquote(cell q) {
	cell	n;

	Quoting++;
	n = xread2();
	Quoting--;
	return cons(q, cons(n, NIL));
}

// Assembly:
pushq %rbx
movl %edi, %ebx
incl 0x12d3b(%rip)           # 0x17620
callq 0x4065
decl 0x12d30(%rip)           # 0x17620
pushq $-0x1
popq %rsi
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
popq %rbx
jmp 0x2f8c
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: meta
cell meta(void) {
	int	c, cmd, i;
	cell	n, cmdsym;
	char	s[128];

	cmd = tolower(readc());
	c = readc();
	while (' ' == c) c = readc();
	i = 0;
	while (c != '\n' && c != EOF) {
		if (i < sizeof(s) - 6)
			s[i++] = c;
		c = readc();
	}
	rejectc(c);
	s[i] = 0;
	if ('l' == cmd) strcat(s, ".ls9");
	n = mkstr(s, strlen(s));
	n = 0 == i? NIL: cons(n, NIL);
	protect(n);
	switch (cmd) {
	case 'c':	cmdsym = symref("syscmd"); break;
	case 'h':	cmdsym = symref("help"); break;
	case 'l':	cmdsym = P_load; break;
	default: 	prints(",c = syscmd"); nl();
			prints(",h = help"); nl();
			prints(",l = load"); nl();
			return NIL;
	}
	unprot(1);
	return cons(cmdsym, n);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
callq 0x278c
movl %eax, %edi
callq 0x2150
movl %eax, %ebx
callq 0x278c
cmpl $0x20, %eax
je 0x4921
xorl %ebp, %ebp
cmpl $-0x1, %eax
je 0x494a
cmpl $0xa, %eax
je 0x494a
cmpl $0x79, %ebp
ja 0x4943
movl %ebp, %ecx
incl %ebp
movb %al, (%rsp,%rcx)
callq 0x278c
jmp 0x492d
movl %eax, %edi
callq 0x27ec
movslq %ebp, %rax
movb $0x0, (%rsp,%rax)
cmpl $0x6c, %ebx
jne 0x4971
movq %rsp, %rdi
callq 0x2080
movl $0x39736c2e, (%rsp,%rax) # imm = 0x39736C2E
movb $0x0, 0x4(%rsp,%rax)
movq %rsp, %r14
movq %r14, %rdi
callq 0x2080
movq %r14, %rdi
movl %eax, %esi
callq 0x2698
testl %ebp, %ebp
je 0x499a
pushq $-0x1
popq %rsi
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebp
jmp 0x499d
pushq $-0x1
popq %rbp
movl 0x127cd(%rip), %esi     # 0x17170
movl %ebp, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x127be(%rip)     # 0x17170
cmpl $0x6c, %ebx
je 0x49da
cmpl $0x68, %ebx
je 0x49ca
cmpl $0x63, %ebx
jne 0x49f5
leaq 0xbba5(%rip), %rdi      # 0x1056d
jmp 0x49d1
leaq 0xbba8(%rip), %rdi      # 0x10579
callq 0x39ef
movl %eax, %ebx
jmp 0x49e0
movl 0x12c54(%rip), %ebx     # 0x17634
pushq $0x1
popq %rdi
callq 0x31a9
movl %ebx, %edi
movl %ebp, %esi
xorl %edx, %edx
callq 0x2f8c
jmp 0x4a3b
leaq 0xbb6c(%rip), %rdi      # 0x10568
callq 0x2514
leaq 0xc7c0(%rip), %rbx      # 0x111c8
movq %rbx, %rdi
callq 0x2514
leaq 0xbb5d(%rip), %rdi      # 0x10574
callq 0x2514
movq %rbx, %rdi
callq 0x2514
leaq 0xbb53(%rip), %rdi      # 0x1057e
callq 0x2514
movq %rbx, %rdi
callq 0x2514
pushq $-0x1
popq %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: xread
cell xread(void) {
	cell	x;

	Inlist = 0;
	Quoting = 0;
	Readerr = NULL;
	x = xread2();
	if (Intr) error("aborted", UNDEF);
	return x;
}

// Assembly:
pushq %rax
andl $0x0, 0x12bcd(%rip)     # 0x1761c
andl $0x0, 0x12bca(%rip)     # 0x17620
andq $0x0, 0x12bca(%rip)     # 0x17628
callq 0x4065
xorl %ecx, %ecx
cmpl %ecx, 0x12bc5(%rip)     # 0x17630
jne 0x4a6f
popq %rcx
retq
leaq 0xbb59(%rip), %rdi      # 0x105cf
pushq $-0x4
popq %rsi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: prchar
void prchar(int sl, cell x) {
	if (sl) {
		prints("#\\");
		if (9 == charval(x)) prints("ht");
		else if (10 == charval(x)) prints("nl");
		else if (' ' == charval(x)) prints("sp");
		else if (charval(x) < 32 || charval(x) > 126) {
			prints("\\");
			prints(ntoa(fixval(x), 8));
		}
		else writec(charval(x));
	}
	else {
		writec(charval(x));
	}
}

// Assembly:
pushq %rbx
movl %esi, %ebx
testl %edi, %edi
je 0x4ac1
leaq 0xbb4b(%rip), %rdi      # 0x105d7
callq 0x2514
movq 0x128a8(%rip), %rax     # 0x17340
movq 0x128a9(%rip), %rcx     # 0x17348
movslq %ebx, %rbx
movslq (%rcx,%rbx,4), %rcx
movl (%rax,%rcx,4), %edi
cmpl $0x20, %edi
je 0x4ae8
cmpl $0xa, %edi
je 0x4adf
cmpl $0x9, %edi
jne 0x4af1
leaq 0xb9b7(%rip), %rdi      # 0x10476
jmp 0x4b25
movq 0x12878(%rip), %rax     # 0x17340
movq 0x12879(%rip), %rcx     # 0x17348
movslq %ebx, %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
popq %rbx
jmp 0x2a1c
leaq 0xb993(%rip), %rdi      # 0x10479
jmp 0x4b25
leaq 0xc24e(%rip), %rdi      # 0x10d3d
jmp 0x4b25
leal -0x7f(%rdi), %eax
cmpl $-0x60, %eax
ja 0x4b2b
leaq 0xbad8(%rip), %rdi      # 0x105d8
callq 0x2514
movq 0x12834(%rip), %rax     # 0x17340
movq 0x12835(%rip), %rcx     # 0x17348
movslq (%rcx,%rbx,4), %rcx
movl (%rax,%rcx,4), %edi
pushq $0x8
popq %rsi
callq 0x2532
movq %rax, %rdi
popq %rbx
jmp 0x2514
jmp 0x4ad9
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: prstr
void prstr(int sl, cell x) {
	int	i, c;

	if (sl) {
		writec('"');
		for (i=0; i<stringlen(x)-1; i++) {
			c = (byte) string(x)[i];
			if ('"' == c)
				prints("\\\"");
			else if ('\\' == c)
				prints("\\\\");
			else if (10 == c)
				prints("\\n");
			else if (c < ' ' || c > 126) {
				writec('\\');
				if (octalp(string(x)[i+1])) {
					if (c < 100) writec('0');
					if (c < 10) writec('0');
				}
				prints(ntoa(c, 8));
			}
			else
				writec(c);
		}
		writec('"');
	}
	else {
		printb(string(x));
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
testl %edi, %edi
je 0x4c65
pushq $0x22
popq %rdi
callq 0x2a1c
movslq %ebx, %rbp
xorl %r13d, %r13d
leaq 0xba5f(%rip), %rbx      # 0x105e0
leaq 0xba55(%rip), %r14      # 0x105dd
leaq 0xba4b(%rip), %r15      # 0x105da
movq 0x127c2(%rip), %rax     # 0x17358
movq 0x127ab(%rip), %rcx     # 0x17348
movslq (%rcx,%rbp,4), %rcx
movslq -0x4(%rax,%rcx,4), %rdx
decq %rdx
cmpq %rdx, %r13
jge 0x4c4f
leaq (%rax,%rcx,4), %rax
movzbl (%rax,%r13), %r12d
cmpl $0xa, %r12d
je 0x4bd7
cmpl $0x5c, %r12d
je 0x4bd2
cmpl $0x22, %r12d
jne 0x4bdc
movq %r15, %rdi
jmp 0x4c38
movq %r14, %rdi
jmp 0x4c38
movq %rbx, %rdi
jmp 0x4c38
leal -0x7f(%r12), %eax
cmpb $-0x60, %al
ja 0x4c45
pushq $0x5c
popq %rdi
callq 0x2a1c
cmpb $0x63, %r12b
ja 0x4c2a
movq 0x1274e(%rip), %rax     # 0x17348
movslq (%rax,%rbp,4), %rax
shlq $0x2, %rax
addq 0x1274f(%rip), %rax     # 0x17358
movb 0x1(%r13,%rax), %al
andb $-0x8, %al
cmpb $0x30, %al
jne 0x4c2a
pushq $0x30
popq %rdi
callq 0x2a1c
cmpb $0x9, %r12b
ja 0x4c2a
pushq $0x30
popq %rdi
callq 0x2a1c
movl %r12d, %edi
pushq $0x8
popq %rsi
callq 0x2532
movq %rax, %rdi
callq 0x2514
incq %r13
jmp 0x4b8f
movl %r12d, %edi
callq 0x2a1c
jmp 0x4c3d
pushq $0x22
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a1c
movq 0x126dc(%rip), %rax     # 0x17348
movslq %ebx, %rcx
movslq (%rax,%rcx,4), %rdi
shlq $0x2, %rdi
addq 0x126da(%rip), %rdi     # 0x17358
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2514
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: prlist
void prlist(int sl, cell x, int d) {
	writec(LP);
	while (x != NIL && Plimit != 1) {
		prex(sl, car(x), d+1);
		x = cdr(x);
		if (x != NIL) {
			writec(' ');
			if (atomp(x)) {
				prints(". ");
				prex(sl, x, d+1);
				break;
			}
		}
	}
	writec(RP);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %ebp
pushq $0x28
popq %rdi
callq 0x2a1c
incl %ebx
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
pushq $0x20
popq %r15
cmpl $-0x1, %r14d
je 0x4d1d
cmpl $0x1, 0x126d7(%rip)     # 0x17398
je 0x4d1d
movq 0x12676(%rip), %rax     # 0x17340
movslq %r14d, %r14
movl (%rax,%r14,4), %esi
movl %ebp, %edi
movl %ebx, %edx
callq 0x4d2d
movq 0x12667(%rip), %rax     # 0x17348
movl (%rax,%r14,4), %r14d
cmpq %r12, %r14
je 0x4cb4
movl %r15d, %edi
callq 0x2a1c
testl %r14d, %r14d
js 0x4d05
movq 0x12652(%rip), %rax     # 0x17350
testb $0x9, (%rax,%r14)
je 0x4cb4
leaq 0xb8d7(%rip), %rdi      # 0x105e3
callq 0x2514
movl %ebp, %edi
movl %r14d, %esi
movl %ebx, %edx
callq 0x4d2d
pushq $0x29
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2a1c
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: prvec
void prvec(int sl, cell x, int d) {
	int	i;

	prints("#(");
	for (i=0; i<veclen(x); i++) {
		prex(sl, vector(x)[i], d+1);
		if (i < veclen(x)-1) writec(' ');
	}
	writec(')');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %ebp
leaq 0xb680(%rip), %rdi      # 0x105e6
callq 0x2514
movslq %r14d, %r15
incl %ebx
movq 0x123e1(%rip), %rax     # 0x17358
xorl %r12d, %r12d
movq 0x123c7(%rip), %rcx     # 0x17348
pushq $0x20
popq %r14
movslq (%rcx,%r15,4), %rcx
movslq -0x4(%rax,%rcx,4), %rdx
addq $0x3, %rdx
shrq $0x2, %rdx
cmpq %r12, %rdx
jbe 0x4fee
leaq (%rax,%rcx,4), %rax
movl (%rax,%r12,4), %esi
movl %ebp, %edi
movl %ebx, %edx
callq 0x4d2d
movq 0x123a5(%rip), %rax     # 0x17358
movq 0x1238e(%rip), %rcx     # 0x17348
movslq (%rcx,%r15,4), %rdx
movslq -0x4(%rax,%rdx,4), %rdx
addq $0x3, %rdx
shrq $0x2, %rdx
decq %rdx
cmpq %r12, %rdx
jbe 0x4fe9
movl %r14d, %edi
callq 0x2a1c
movq 0x12376(%rip), %rax     # 0x17358
movq 0x1235f(%rip), %rcx     # 0x17348
incq %r12
jmp 0x4f85
pushq $0x29
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2a1c
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: prport
void prport(int out, cell x) {
	prints("#<");
	prints(out? "out": "in");
	prints("port ");
	prints(ntoa(portno(x), 10));
	prints(">");
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
leaq 0xb5dd(%rip), %rdi      # 0x105e9
callq 0x2514
testl %ebp, %ebp
leaq 0xbf48(%rip), %rax      # 0x10f62
leaq 0xb5cb(%rip), %rdi      # 0x105ec
cmoveq %rax, %rdi
callq 0x2514
leaq 0xb5bf(%rip), %rdi      # 0x105f0
callq 0x2514
movq 0x12303(%rip), %rax     # 0x17340
movq 0x12304(%rip), %rcx     # 0x17348
movslq %ebx, %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
pushq $0xa
popq %rsi
callq 0x2532
movq %rax, %rdi
callq 0x2514
leaq 0xb86a(%rip), %rdi      # 0x108cf
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2514
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: prquote
void prquote(int sl, cell x, int d) {
	if (car(x) == S_quote) writec('\'');
	else if (car(x) == S_qquote) writec('@');
	else if (car(x) == S_unquote) writec(',');
	else if (car(x) == S_splice) prints(",@");
	prex(sl, cadr(x), d);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %edi, %ebp
movq 0x1225a(%rip), %rax     # 0x17340
movslq %esi, %r14
movl (%rax,%r14,4), %eax
cmpl 0x12545(%rip), %eax     # 0x17638
jne 0x50f9
pushq $0x27
jmp 0x510f
cmpl 0x1253d(%rip), %eax     # 0x1763c
jne 0x5105
pushq $0x40
jmp 0x510f
cmpl 0x12539(%rip), %eax     # 0x17644
jne 0x5137
pushq $0x2c
popq %rdi
callq 0x2a1c
movq 0x12224(%rip), %rax     # 0x17340
movq 0x12225(%rip), %rcx     # 0x17348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %esi
movl %ebp, %edi
movl %ebx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x4d2d
cmpl 0x12503(%rip), %eax     # 0x17640
jne 0x5115
leaq 0xb4ca(%rip), %rdi      # 0x10610
callq 0x2514
jmp 0x5115
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: xprint
void xprint(int sl, cell x) {
	prex(sl, x, 0);
	if (1 == Plimit) {
		Plimit = 0;
		prints("...");
	}
}

// Assembly:
pushq %rax
xorl %edx, %edx
callq 0x4d2d
cmpl $0x1, 0x1223c(%rip)     # 0x17398
jne 0x5172
andl $0x0, 0x12233(%rip)     # 0x17398
leaq 0xb4f3(%rip), %rdi      # 0x1065f
popq %rax
jmp 0x2514
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: length
int length(cell n) {
	int	k;

	for (k = 0; n != NIL; n = cdr(n))
		k++;
	return k;
}

// Assembly:
xorl %eax, %eax
movq 0x121af(%rip), %rcx     # 0x17348
cmpl $-0x1, %edi
je 0x51a8
incl %eax
movslq %edi, %rdx
movl (%rcx,%rdx,4), %edi
jmp 0x5199
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: ckargs
void ckargs(cell x, int min, int max) {
	int	k;
	char	buf[100];

	k = length(x)-1;
	if (k < min || (k > max && max >= 0)) {
		sprintf(buf, "%s: wrong number of arguments",
			symname(car(x)));
		error(buf, x);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %ebx
callq 0x5190
cmpl %r14d, %eax
jle 0x51db
decl %eax
cmpl %ebp, %eax
setle %al
testl %ebp, %ebp
sets %cl
orb %al, %cl
je 0x51db
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x12166(%rip), %rax     # 0x17348
movq 0x12157(%rip), %rcx     # 0x17340
movslq %ebx, %rdx
movslq (%rcx,%rdx,4), %rcx
movslq (%rax,%rcx,4), %rdx
shlq $0x2, %rdx
addq 0x12159(%rip), %rdx     # 0x17358
leaq 0xb45d(%rip), %rsi      # 0x10663
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: syncheck
int syncheck(cell x, int top) {
	cell	p;

	if (atomp(x)) return 0;
	for (p = x; pairp(p); p = cdr(p))
		;
	if (p != NIL)
		error("dotted list in program", x);
	if (car(x) == S_apply) return ckapply(x);
	if (car(x) == S_def) return ckdef(x, top);
	if (car(x) == S_if) return ckif(x);
	if (car(x) == S_ifstar) return ckifstar(x);
	if (car(x) == S_lambda) return cklambda(x);
	if (car(x) == S_macro) return ckmacro(x, top);
	if (car(x) == S_prog) return ckprog(x, top);
	if (car(x) == S_quote) return ckquote(x);
	if (car(x) == S_setq) return cksetq(x);
	return ckseq(x, top);
}

// Assembly:
pushq %rax
testl %edi, %edi
js 0x5359
movl %edi, %eax
movq 0x120dd(%rip), %rdx     # 0x17350
movl %edi, %ecx
testb $0x9, (%rdx,%rcx)
jne 0x5359
movq 0x120c2(%rip), %rdi     # 0x17348
movl %eax, %r8d
testl %r8d, %r8d
js 0x52a2
movl %r8d, %r8d
testb $0x9, (%rdx,%r8)
jne 0x535d
movl (%rdi,%r8,4), %r8d
jmp 0x5289
cmpl $-0x1, %r8d
jne 0x535d
movq 0x1208d(%rip), %rdx     # 0x17340
movl (%rdx,%rcx,4), %ecx
cmpl 0x1245c(%rip), %ecx     # 0x17718
jne 0x52ca
movl %eax, %edi
callq 0x536b
jmp 0x5359
cmpl 0x1244c(%rip), %ecx     # 0x1771c
jne 0x52db
movl %eax, %edi
callq 0x537b
jmp 0x5359
cmpl 0x1243f(%rip), %ecx     # 0x17720
jne 0x52ec
movl %eax, %edi
callq 0x53f2
jmp 0x5359
cmpl 0x12432(%rip), %ecx     # 0x17724
jne 0x52fd
movl %eax, %edi
callq 0x5418
jmp 0x5359
cmpl 0x12425(%rip), %ecx     # 0x17728
jne 0x530e
movl %eax, %edi
callq 0x5592
jmp 0x5359
cmpl 0x12418(%rip), %ecx     # 0x1772c
jne 0x531f
movl %eax, %edi
callq 0x5626
jmp 0x5359
cmpl 0x1240b(%rip), %ecx     # 0x17730
jne 0x5330
movl %eax, %edi
callq 0x569d
jmp 0x5359
cmpl 0x12302(%rip), %ecx     # 0x17638
jne 0x5341
movl %eax, %edi
callq 0x56b4
jmp 0x5359
cmpl 0x123ed(%rip), %ecx     # 0x17734
jne 0x5352
movl %eax, %edi
callq 0x56c3
jmp 0x5359
movl %eax, %edi
callq 0x521d
xorl %eax, %eax
popq %rcx
retq
leaq 0xb3c6(%rip), %rdi      # 0x1072a
movl %eax, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: ckdef
int ckdef(cell x, int top) {
	ckargs(x, 2, 2);
	if (!symbolp(cadr(x)))
		error("def: expected symbol", cadr(x));
	if (!top) error("def: must be at top level", x);
	return syncheck(caddr(x), 0);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
pushq $0x2
popq %rdx
movl %edx, %esi
callq 0x51a9
movq 0x11fad(%rip), %rax     # 0x17340
movq 0x11fae(%rip), %rcx     # 0x17348
movslq %ebx, %rdx
movslq (%rcx,%rdx,4), %rdx
movslq (%rax,%rdx,4), %rsi
testq %rsi, %rsi
js 0x53d8
movq 0x11f9f(%rip), %rdi     # 0x17350
testb $0x8, (%rdi,%rsi)
je 0x53d8
cmpl $-0x12, (%rax,%rsi,4)
jne 0x53d8
testl %ebp, %ebp
je 0x53e4
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x5261
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xb2a2(%rip), %rdi      # 0x10681
callq 0x258a
leaq 0xb2ab(%rip), %rdi      # 0x10696
movl %ebx, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: symlistp
int symlistp(cell x) {
	cell	p;

	for (p = x; pairp(p); p = cdr(p)) {
		if (!symbolp(car(p)))
			return 0;
	}
	return symbolp(p) || NIL == p;
}

// Assembly:
movq 0x11f0c(%rip), %rdx     # 0x17350
movq 0x11ef5(%rip), %rcx     # 0x17340
movq 0x11ef6(%rip), %rsi     # 0x17348
testl %edi, %edi
js 0x548d
movl %edi, %r8d
movb (%rdx,%r8), %al
testb $0x9, %al
jne 0x547e
movslq (%rcx,%r8,4), %rdi
xorl %eax, %eax
testq %rdi, %rdi
js 0x5495
testb $0x8, (%rdx,%rdi)
je 0x5495
cmpl $-0x12, (%rcx,%rdi,4)
jne 0x5495
movl (%rsi,%r8,4), %edi
jmp 0x5452
testb $0x8, %al
je 0x548d
cmpl $-0x12, (%rcx,%r8,4)
jne 0x548d
pushq $0x1
popq %rax
retq
xorl %eax, %eax
cmpl $-0x1, %edi
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: uniqlistp
int uniqlistp(cell x) {
	if (NIL == x) return 1;
	while (cdr(x) != NIL) {
		if (memq(car(x), cdr(x)) != NIL)
			return 0;
		x = cdr(x);
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
pushq $0x1
popq %rbx
cmpl $-0x1, %edi
je 0x54f6
movl %edi, %ebp
movq 0x11e77(%rip), %r14     # 0x17348
movq 0x11e68(%rip), %r15     # 0x17340
movslq %ebp, %rax
movl (%r14,%rax,4), %ebp
cmpl $-0x1, %ebp
je 0x54f6
movl (%r15,%rax,4), %edi
movl %ebp, %esi
callq 0x5496
cmpl $-0x1, %eax
je 0x54d8
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: flatargs
cell flatargs(cell a) {
	cell	n;

	protect(n = NIL);
	while (pairp(a)) {
		n = cons(car(a), n);
		car(Protected) = n;
		a = cdr(a);
	}
	if (a != NIL) n = cons(a, n);
	unprot(1);
	return nreverse(n);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
movl 0x11c61(%rip), %esi     # 0x17170
pushq $-0x1
popq %rbx
movl %ebx, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x11c4f(%rip)     # 0x17170
testl %ebp, %ebp
js 0x556a
movq 0x11e24(%rip), %rax     # 0x17350
movl %ebp, %r14d
testb $0x9, (%rax,%r14)
jne 0x556f
movq 0x11e03(%rip), %rax     # 0x17340
movl (%rax,%r14,4), %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebx
movq 0x11ded(%rip), %rax     # 0x17340
movslq 0x11c16(%rip), %rcx     # 0x17170
movl %ebx, (%rax,%rcx,4)
movq 0x11de4(%rip), %rax     # 0x17348
movl (%rax,%r14,4), %ebp
jmp 0x5521
cmpl $-0x1, %ebp
je 0x557c
movl %ebp, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebx
pushq $0x1
popq %rdi
callq 0x31a9
pushq $-0x1
popq %rsi
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x3a71
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: cklambda
int cklambda(cell x) {
	ckargs(x, 2, -1);
	if (!symlistp(cadr(x)))
		error("lambda: invalid formals", cadr(x));
	if (!uniqlistp(flatargs(cadr(x))))
		error("lambda: duplicate formal", cadr(x));
	return ckseq(cddr(x), 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
pushq $0x2
popq %rsi
pushq $-0x1
popq %rdx
callq 0x51a9
movq 0x11d96(%rip), %rax     # 0x17340
movq 0x11d97(%rip), %rcx     # 0x17348
movslq %ebx, %r14
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %ebx
movl %ebx, %edi
callq 0x543d
testl %eax, %eax
je 0x55f7
movl %ebx, %edi
callq 0x5503
movl %eax, %edi
callq 0x54b9
testl %eax, %eax
je 0x5605
movq 0x11d69(%rip), %rax     # 0x17348
movslq (%rax,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x521d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xb0b2(%rip), %rdi      # 0x106b0
movl %ebx, %esi
callq 0x258a
movq 0x11d34(%rip), %rax     # 0x17340
movq 0x11d35(%rip), %rcx     # 0x17348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %esi
leaq 0xb0a7(%rip), %rdi      # 0x106c8
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: ckmacro
int ckmacro(cell x, int top) {
	ckargs(x, 2, 2);
	if (!symbolp(cadr(x)))
		error("macro: expected symbol", cadr(x));
	if (!top) error("macro: must be at top level", x);
	return syncheck(caddr(x), 0);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
pushq $0x2
popq %rdx
movl %edx, %esi
callq 0x51a9
movq 0x11d02(%rip), %rax     # 0x17340
movq 0x11d03(%rip), %rcx     # 0x17348
movslq %ebx, %rdx
movslq (%rcx,%rdx,4), %rdx
movslq (%rax,%rdx,4), %rsi
testq %rsi, %rsi
js 0x5683
movq 0x11cf4(%rip), %rdi     # 0x17350
testb $0x8, (%rdi,%rsi)
je 0x5683
cmpl $-0x12, (%rax,%rsi,4)
jne 0x5683
testl %ebp, %ebp
je 0x568f
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x5261
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xb057(%rip), %rdi      # 0x106e1
callq 0x258a
leaq 0xb062(%rip), %rdi      # 0x106f8
movl %ebx, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: cksetq
int cksetq(cell x) {
	ckargs(x, 2, 2);
	if (!symbolp(cadr(x)))
		error("setq: expected symbol", cadr(x));
	return ckseq(cddr(x), 0);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
pushq $0x2
popq %rdx
movl %edx, %esi
callq 0x51a9
movq 0x11c69(%rip), %rdx     # 0x17340
movq 0x11c6a(%rip), %rax     # 0x17348
movslq %ebx, %rcx
movslq (%rax,%rcx,4), %rcx
movslq (%rdx,%rcx,4), %rsi
testq %rsi, %rsi
js 0x570f
movq 0x11c5b(%rip), %rdi     # 0x17350
testb $0x8, (%rdi,%rsi)
je 0x570f
cmpl $-0x12, (%rdx,%rsi,4)
jne 0x570f
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x521d
xorl %eax, %eax
popq %rbx
retq
leaq 0xaffe(%rip), %rdi      # 0x10714
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: set_union
cell set_union(cell a, cell b) {
	cell	n;

	a = reverse(a);
	protect(a);
	protect(n = b);
	while (pairp(a)) {
		if (memq(car(a), b) == NIL)
			n = cons(car(a), n);
		car(Protected) = n;
		a = cdr(a);
	}
	if (a != NIL && memq(a, b) == NIL)
		n = cons(a, n);
	unprot(2);
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
pushq $-0x1
popq %rsi
callq 0x3a25
movl %eax, %r14d
movl 0x11a3a(%rip), %esi     # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x11a2b(%rip)     # 0x17170
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x11a1a(%rip)     # 0x17170
movl %ebx, %ebp
testl %r14d, %r14d
js 0x57b5
movq 0x11bec(%rip), %rax     # 0x17350
movl %r14d, %r15d
testb $0x9, (%rax,%r15)
jne 0x57bb
movq 0x11bcb(%rip), %r12     # 0x17340
movl (%r12,%r15,4), %r14d
movl %r14d, %edi
movl %ebx, %esi
callq 0x5496
cmpl $-0x1, %eax
jne 0x579d
movl %r14d, %edi
movl %ebp, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebp
movq 0x11ba3(%rip), %r12     # 0x17340
movslq 0x119cc(%rip), %rax     # 0x17170
movl %ebp, (%r12,%rax,4)
movq 0x11b99(%rip), %rax     # 0x17348
movl (%rax,%r15,4), %r14d
jmp 0x5758
cmpl $-0x1, %r14d
je 0x57d8
movl %r14d, %edi
movl %ebx, %esi
callq 0x5496
cmpl $-0x1, %eax
jne 0x57d8
movl %r14d, %edi
movl %ebp, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebp
pushq $0x2
popq %rdi
callq 0x31a9
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: subrp
int subrp(cell x) {
	return	subr0(x) >= 0 ||
		subr1(x) >= 0 ||
		subr2(x) >= 0 ||
		subr3(x) >= 0 ||
		osubr0(x) >= 0 ||
		osubr1(x) >= 0 ||
		lsubr0(x) >= 0 ||
		lsubr1(x) >= 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
callq 0x6cb9
pushq $0x1
popq %rbx
testl %eax, %eax
jns 0x5a88
movl %ebp, %edi
callq 0x6d2c
testl %eax, %eax
jns 0x5a88
movl %ebp, %edi
callq 0x7041
testl %eax, %eax
jns 0x5a88
movl %ebp, %edi
callq 0x718a
testl %eax, %eax
jns 0x5a88
movl %ebp, %edi
callq 0x71c4
testl %eax, %eax
jns 0x5a88
movl %ebp, %edi
callq 0x71ed
testl %eax, %eax
jns 0x5a88
movl %ebp, %edi
callq 0x7261
testl %eax, %eax
jns 0x5a88
movl %ebp, %edi
callq 0x72b2
movl %eax, %ebx
notl %ebx
shrl $0x1f, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: posq
int posq(cell x, cell a) {
	int	n;

	n = 0;
	for (; a != NIL; a = cdr(a)) {
		if (car(a) == x) return n;
		n++;
	}
	return NIL;
}

// Assembly:
movq 0x118a8(%rip), %rdx     # 0x17340
xorl %ecx, %ecx
movq 0x118a7(%rip), %r8      # 0x17348
pushq $-0x1
popq %rax
cmpl $-0x1, %esi
je 0x5abb
movslq %esi, %rsi
cmpl %edi, (%rdx,%rsi,4)
je 0x5ab9
incl %ecx
movl (%r8,%rsi,4), %esi
jmp 0x5aa4
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: initmap
cell initmap(cell fv, cell e, cell a) {
	cell	m, n, p;
	int	i, j;

	protect(m = NIL);
	i = 0;
	while (fv != NIL) {
		p = cons(car(fv), NIL);
		protect(p);
		n = mkfix(i);
		p = cons(n, p);
		car(Protected) = p;
		if ((j = posq(car(fv), a)) != NIL) {
			n = mkfix(j);
			p = cons(n, p);
			unprot(1);
			p = cons(I_a, p);
		}
		else if ((j = posq(car(fv), e)) != NIL) {
			n = mkfix(j);
			p = cons(n, p);
			unprot(1);
			p = cons(I_e, p);
		}
		else {
			error("undefined symbol", car(fv));
		}
		m = cons(p, m);
		car(Protected) = m;
		i++;
		fv = cdr(fv);
	}
	return nreverse(unprot(1));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, 0x4(%rsp)
movl %esi, (%rsp)
movl %edi, %ebx
movl 0x1169a(%rip), %esi     # 0x17170
pushq $-0x1
popq %r14
xorl %r15d, %r15d
movl %r14d, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x11683(%rip)     # 0x17170
pushq $0x1
popq %r12
cmpl $-0x1, %ebx
je 0x5c0d
movq 0x1183f(%rip), %rax     # 0x17340
movslq %ebx, %rbp
movl (%rax,%rbp,4), %edi
pushq $-0x1
popq %r13
movl %r13d, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebx
movl 0x11653(%rip), %esi     # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x11644(%rip)     # 0x17170
movl %r15d, %edi
movl %r13d, %esi
movl %r12d, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %r12d, %edx
callq 0x2f8c
movl %eax, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebx
movq 0x117e5(%rip), %rax     # 0x17340
movslq 0x1160e(%rip), %rcx     # 0x17170
movl %ebx, (%rax,%rcx,4)
movl (%rax,%rbp,4), %r13d
movl %r13d, %edi
movl 0x4(%rsp), %esi
callq 0x5a91
cmpl $-0x1, %eax
je 0x5b83
leaq 0x11bb7(%rip), %r13     # 0x17738
jmp 0x5b9e
movl %r13d, %edi
movl (%rsp), %esi
callq 0x5a91
cmpl $-0x1, %eax
je 0x5c2d
leaq 0x11b9e(%rip), %r13     # 0x1773c
movl %eax, %edi
pushq $-0x1
popq %rsi
movl %r12d, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %r12d, %edx
callq 0x2f8c
movl %eax, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebx
movl %r12d, %edi
callq 0x31a9
movl (%r13), %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %edi
movl %r14d, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %r14d
movq 0x11750(%rip), %rax     # 0x17340
movslq 0x11579(%rip), %rcx     # 0x17170
movl %r14d, (%rax,%rcx,4)
incl %r15d
movq 0x11743(%rip), %rax     # 0x17348
movl (%rax,%rbp,4), %ebx
jmp 0x5af1
pushq $0x1
popq %rdi
callq 0x31a9
pushq $-0x1
popq %rsi
movl %eax, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a71
leaq 0xab0d(%rip), %rdi      # 0x10741
movl %r13d, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: newvar
void newvar(cell x) {
	cell	n;

	if (memq(x, Env) != NIL) return;
	if (NIL == Envp) Envp = lastpair(Env);
	n = cons(x, NIL);
	cdr(Envp) = n;
	Envp = n;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl 0x1152f(%rip), %ebp     # 0x17194
movl %ebp, %esi
callq 0x5496
cmpl $-0x1, %eax
jne 0x5caa
cmpl $-0x1, 0x11520(%rip)    # 0x17198
jne 0x5c87
movl %ebp, %edi
callq 0x5c3c
movl %eax, 0x11511(%rip)     # 0x17198
pushq $-0x1
popq %rsi
movl %ebx, %edi
xorl %edx, %edx
callq 0x2f8c
movq 0x116ae(%rip), %rcx     # 0x17348
movslq 0x114f7(%rip), %rdx     # 0x17198
movl %eax, (%rcx,%rdx,4)
movl %eax, 0x114ee(%rip)     # 0x17198
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: mapconv
cell mapconv(cell x, cell e, cell a) {
	cell	n, new;

	protect(n = NIL);
	while (pairp(x)) {
		new = cconv(car(x), e, a);
		n = cons(new, n);
		car(Protected) = n;
		x = cdr(x);
	}
	return nreverse(unprot(1));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r15d
movl 0x11485(%rip), %esi     # 0x17170
pushq $-0x1
popq %r14
movl %r14d, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x11471(%rip)     # 0x17170
testl %r15d, %r15d
js 0x5d57
movq 0x11645(%rip), %rax     # 0x17350
movl %r15d, %r15d
testb $0x9, (%rax,%r15)
jne 0x5d57
movq 0x11624(%rip), %rax     # 0x17340
movl (%rax,%r15,4), %edi
movl %ebp, %esi
movl %ebx, %edx
callq 0x5d73
movl %eax, %edi
movl %r14d, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %r14d
movq 0x11601(%rip), %rax     # 0x17340
movslq 0x1142a(%rip), %rcx     # 0x17170
movl %r14d, (%rax,%rcx,4)
movq 0x115f7(%rip), %rax     # 0x17348
movl (%rax,%r15,4), %r15d
jmp 0x5cff
pushq $0x1
popq %rdi
callq 0x31a9
pushq $-0x1
popq %rsi
movl %eax, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3a71
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: lamconv
cell lamconv(cell x, cell e, cell a) {
	cell	cl, fv, args, m;

	fv = freevars(x, NIL);
	protect(fv);
	newvars(fv);
	args = flatargs(cadr(x));
	protect(args);
	m = initmap(fv, e, a);
	protect(m);
	cl = mapconv(cddr(x), fv, args);
	cl = cons(m, cl);
	cl = cons(cadr(x), cl);
	cl = cons(I_closure, cl);
	unprot(3);
	return cl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
pushq $-0x1
popq %rsi
callq 0x57eb
movl %eax, %ebx
movl 0x11142(%rip), %esi     # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x11133(%rip)     # 0x17170
movl %ebx, %edi
callq 0x5cb1
movq 0x112f5(%rip), %rax     # 0x17340
movq 0x112f6(%rip), %rcx     # 0x17348
movslq %r15d, %r12
movslq (%rcx,%r12,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x5503
movl %eax, %r15d
movl 0x11106(%rip), %esi     # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x110f7(%rip)     # 0x17170
movl %ebx, %edi
movl %r14d, %esi
movl %ebp, %edx
callq 0x5abc
movl %eax, %ebp
movl 0x110e3(%rip), %esi     # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x110d4(%rip)     # 0x17170
movq 0x112a5(%rip), %rax     # 0x17348
movslq (%rax,%r12,4), %rcx
movl (%rax,%rcx,4), %edi
movl %ebx, %esi
movl %r15d, %edx
callq 0x5cd7
movl %ebp, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x2f8c
movq 0x1127a(%rip), %rcx     # 0x17340
movq 0x1127b(%rip), %rdx     # 0x17348
movslq (%rdx,%r12,4), %rdx
movl (%rcx,%rdx,4), %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x2f8c
movl 0x1165d(%rip), %edi     # 0x17740
movl %eax, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebx
pushq $0x3
popq %rdi
callq 0x31a9
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: contains
int contains(cell a, cell x) {
	if (a == x) return 1;
	if (pairp(a) && (contains(car(a), x) || contains(cdr(a), x)))
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
pushq $0x1
popq %rbx
cmpl %esi, %edi
je 0x6123
testl %edi, %edi
js 0x6121
movq 0x11239(%rip), %rax     # 0x17350
movl %edi, %r14d
testb $0x9, (%rax,%r14)
je 0x612a
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl %esi, %ebp
movq 0x1120d(%rip), %rax     # 0x17340
movl (%rax,%r14,4), %edi
callq 0x6101
testl %eax, %eax
jne 0x6123
movq 0x11201(%rip), %rax     # 0x17348
movl (%rax,%r14,4), %edi
movl %ebp, %esi
callq 0x6101
testl %eax, %eax
jne 0x6123
jmp 0x6121
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: liftnames
cell liftnames(cell m) {
	#define name cadddr
	cell	a, n;

	protect(a = NIL);
	while (m != NIL) {
		if (caar(m) == I_a) {
			n = name(car(m));
			a = cons(n, a);
			car(Protected) = a;
		}
		m = cdr(m);
	}
	return nreverse(unprot(1));
	#undef name
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
movl 0x10ffb(%rip), %esi     # 0x17170
pushq $-0x1
popq %rbx
movl %ebx, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x10fe9(%rip)     # 0x17170
cmpl $-0x1, %ebp
je 0x61e4
movq 0x111ad(%rip), %rcx     # 0x17340
movslq %ebp, %r14
movslq (%rcx,%r14,4), %rdx
movl (%rcx,%rdx,4), %esi
movq 0x111a4(%rip), %rax     # 0x17348
cmpl 0x1158e(%rip), %esi     # 0x17738
jne 0x61de
movslq (%rax,%rdx,4), %rdx
movslq (%rax,%rdx,4), %rdx
movslq (%rax,%rdx,4), %rax
movl (%rcx,%rax,4), %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebx
movq 0x11173(%rip), %rax     # 0x17340
movslq 0x10f9c(%rip), %rcx     # 0x17170
movl %ebx, (%rax,%rcx,4)
movq 0x1116a(%rip), %rax     # 0x17348
movl (%rax,%r14,4), %ebp
jmp 0x6187
pushq $0x1
popq %rdi
callq 0x31a9
pushq $-0x1
popq %rsi
movl %eax, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x3a71
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: liftargs
cell liftargs(cell m) {
	#define source	cadr
	cell	a, n;

	protect(a = NIL);
	while (m != NIL) {
		if (caar(m) == I_a) {
			n = source(car(m));
			n = cons(n, NIL);
			n = cons(caar(m) == I_a? I_arg: I_ref, n);
			a = cons(n, a);
			car(Protected) = a;
		}
		m = cdr(m);
	}
	return nreverse(unprot(1));
	#undef source
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %r14d
movl 0x10f65(%rip), %esi     # 0x17170
pushq $-0x1
popq %rbx
movl %ebx, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x10f53(%rip)     # 0x17170
leaq 0x11520(%rip), %r15     # 0x17744
leaq 0x1151d(%rip), %r12     # 0x17748
movl %ebx, %ebp
cmpl $-0x1, %r14d
je 0x62bb
movq 0x11102(%rip), %rcx     # 0x17340
movslq %r14d, %r14
movslq (%rcx,%r14,4), %rdx
movl (%rcx,%rdx,4), %esi
movq 0x110f9(%rip), %rax     # 0x17348
cmpl 0x114e3(%rip), %esi     # 0x17738
jne 0x62b2
movslq (%rax,%rdx,4), %rax
movl (%rcx,%rax,4), %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x2f8c
movq 0x110d2(%rip), %rcx     # 0x17340
movslq (%rcx,%r14,4), %rdx
movl (%rcx,%rdx,4), %ecx
cmpl 0x114bd(%rip), %ecx     # 0x17738
movq %r12, %rcx
cmoveq %r15, %rcx
movl (%rcx), %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %edi
movl %ebp, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebp
movq 0x1109f(%rip), %rax     # 0x17340
movslq 0x10ec8(%rip), %rcx     # 0x17170
movl %ebp, (%rax,%rcx,4)
movq 0x11096(%rip), %rax     # 0x17348
movl (%rax,%r14,4), %r14d
jmp 0x622d
pushq $0x1
popq %rdi
callq 0x31a9
pushq $-0x1
popq %rsi
movl %eax, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3a71
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: defconv
cell defconv(cell x, cell e, cell a) {
	cell	n, m;

	newvar(cadr(x));
	n = cons(cconv(caddr(x), e, a), NIL);
	protect(n);
	m = mkfix(posq(cadr(x), e));
	protect(m);
	m = cons(I_ref, cons(m, cons(cadr(x), NIL)));
	unprot(2);
	return cons(S_setq, cons(m, n));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movq 0x10e91(%rip), %rax     # 0x17340
movq 0x10e92(%rip), %rcx     # 0x17348
movslq %edi, %r12
movslq (%rcx,%r12,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x5c5a
movq 0x10e74(%rip), %rax     # 0x17340
movq 0x10e75(%rip), %rcx     # 0x17348
movslq (%rcx,%r12,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl %r14d, %esi
movl %ebx, %edx
callq 0x5d73
pushq $-0x1
popq %rbp
movl %eax, %edi
movl %ebp, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebx
movl 0x10c72(%rip), %esi     # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x10c63(%rip)     # 0x17170
movq 0x10e2c(%rip), %rax     # 0x17340
movq 0x10e2d(%rip), %rcx     # 0x17348
movslq (%rcx,%r12,4), %rcx
movl (%rax,%rcx,4), %edi
movl %r14d, %esi
callq 0x5a91
pushq $0x1
popq %r14
movl %eax, %edi
movl %ebp, %esi
movl %r14d, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %r14d, %edx
callq 0x2f8c
movl %eax, %r14d
movl 0x10c20(%rip), %esi     # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x10c11(%rip)     # 0x17170
movl 0x111e2(%rip), %r15d    # 0x17748
movq 0x10dd3(%rip), %rax     # 0x17340
movq 0x10dd4(%rip), %rcx     # 0x17348
movslq (%rcx,%r12,4), %rcx
movl (%rax,%rcx,4), %edi
movl %ebp, %esi
xorl %edx, %edx
callq 0x2f8c
movl %r14d, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x2f8c
movl %r15d, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebp
pushq $0x2
popq %rdi
callq 0x31a9
movl 0x11187(%rip), %r14d    # 0x17734
movl %ebp, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x2f8c
movl %r14d, %edi
movl %eax, %esi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2f8c
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: carof
cell carof(cell a) {
	cell	n;

	protect(n = NIL);
	while (a != NIL) {
		n = cons(caar(a), n);
		car(Protected) = n;
		a = cdr(a);
	}
	unprot(1);
	return nreverse(n);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
movl 0x10b98(%rip), %esi     # 0x17170
pushq $-0x1
popq %rbx
movl %ebx, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x10b86(%rip)     # 0x17170
cmpl $-0x1, %ebp
je 0x6629
movq 0x10d4a(%rip), %rax     # 0x17340
movslq %ebp, %r14
movslq (%rax,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebx
movq 0x10d2e(%rip), %rax     # 0x17340
movslq 0x10b57(%rip), %rcx     # 0x17170
movl %ebx, (%rax,%rcx,4)
movq 0x10d25(%rip), %rax     # 0x17348
movl (%rax,%r14,4), %ebp
jmp 0x65ea
pushq $0x1
popq %rdi
callq 0x31a9
pushq $-0x1
popq %rsi
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x3a71
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: zipenv
cell zipenv(cell vs, cell oe) {
	cell	n, b;

	protect(n = NIL);
	while (vs != NIL) {
		if (NIL == oe) {
			b = cons(car(vs), cons(UNDEF, NIL));
		}
		else {
			b = car(oe);
			oe = cdr(oe);
		}
		n = cons(b, n);
		car(Protected) = n;
		vs = cdr(vs);
	}
	return nreverse(unprot(1));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r15d
movl %edi, %r12d
movl 0x10b1d(%rip), %esi     # 0x17170
pushq $-0x1
popq %rbx
movl %ebx, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x10b0b(%rip)     # 0x17170
pushq $-0x4
popq %rbp
movl %ebx, %r14d
cmpl $-0x1, %r12d
je 0x66e0
movq 0x10cc8(%rip), %rax     # 0x17340
movslq %r12d, %r12
cmpl $-0x1, %r15d
je 0x6694
movslq %r15d, %rcx
movl (%rax,%rcx,4), %edi
movq 0x10cba(%rip), %rax     # 0x17348
movl (%rax,%rcx,4), %r15d
jmp 0x66b4
movl (%rax,%r12,4), %r15d
movl %ebp, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x2f8c
movl %r15d, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %edi
movl %ebx, %r15d
movl %r14d, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %r14d
movq 0x10c78(%rip), %rax     # 0x17340
movslq 0x10aa1(%rip), %rcx     # 0x17170
movl %r14d, (%rax,%rcx,4)
movq 0x10c6e(%rip), %rax     # 0x17348
movl (%rax,%r12,4), %r12d
jmp 0x666b
pushq $0x1
popq %rdi
callq 0x31a9
pushq $-0x1
popq %rsi
movl %eax, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3a71
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: clsconv
cell clsconv(cell x) {
	cell	n;

	Env = carof(Glob);
	Envp = NIL;
	if (NIL == Env) Env = cons(UNDEF, NIL);
	n = cconv(x, Env, NIL);
	protect(n);
	Glob = zipenv(Env, Glob);
	return unprot(1);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl 0x10a41(%rip), %edi     # 0x17144
callq 0x65cc
movl %eax, 0x10a86(%rip)     # 0x17194
orl $-0x1, 0x10a83(%rip)    # 0x17198
cmpl $-0x1, %eax
jne 0x672d
pushq $-0x4
popq %rdi
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x10a67(%rip)     # 0x17194
pushq $-0x1
popq %rdx
movl %ebx, %edi
movl %eax, %esi
callq 0x5d73
movl 0x10a31(%rip), %esi     # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x10a22(%rip)     # 0x17170
movl 0x10a40(%rip), %edi     # 0x17194
movl 0x109ea(%rip), %esi     # 0x17144
callq 0x663f
movl %eax, 0x109df(%rip)     # 0x17144
pushq $0x1
popq %rdi
popq %rbx
jmp 0x31a9