LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: htgrow
void htgrow(cell d) {
	int	nk, i, h, k;
	cell	nd, e, n;

	k = htlen(d);
	nk = 1 + htlen(d);
	nd = mkht(nk);
	protect(nd);
	nk = htlen(nd);
	for (i = 0; i < k; i++) {
		for (e = htslots(d)[i]; e != NIL; e = cdr(e)) {
			h = obhash(caar(e), nk);
			n = cons(car(e), htslots(nd)[h]);
			htslots(nd)[h] = n;
		}
	}
	htdata(d) = htdata(nd);
	unprot(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x15b1a(%rip), %rax     # 0x19358
movq 0x15b03(%rip), %rcx     # 0x19348
movslq %edi, %rdx
movq %rdx, 0x10(%rsp)
movslq (%rcx,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movslq -0x4(%rax,%rcx,4), %r14
addq $0x3, %r14
shrq $0x2, %r14
leal 0x1(%r14), %edi
callq 0x34da
movl %eax, %ebx
movl 0x158fd(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x158ee(%rip)     # 0x19170
movslq %ebx, %r13
movq %r14, 0x8(%rsp)
testl %r14d, %r14d
jle 0x3964
movq 0x15abe(%rip), %rax     # 0x19358
movq 0x15aa7(%rip), %rcx     # 0x19348
movslq (%rcx,%r13,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movslq -0x4(%rax,%rcx,4), %rbx
addq $0x3, %rbx
shrq $0x2, %rbx
movq 0x8(%rsp), %rax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, 0x8(%rsp)
xorl %ebp, %ebp
movq 0x15a7a(%rip), %rax     # 0x19348
movq 0x10(%rsp), %rcx
movslq (%rax,%rcx,4), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq 0x15a72(%rip), %rax     # 0x19358
movl (%rax,%rbp,4), %eax
cmpl $-0x1, %eax
je 0x3956
movq 0x15a4b(%rip), %rcx     # 0x19340
movslq %eax, %r15
movslq (%rcx,%r15,4), %r14
movl (%rcx,%r14,4), %edi
movl %ebx, %esi
callq 0x35c5
movq 0x15a3a(%rip), %rcx     # 0x19348
movslq (%rcx,%r13,4), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0x15a37(%rip), %rcx     # 0x19358
movslq %eax, %r12
movl (%rcx,%r12,4), %esi
movl %r14d, %edi
xorl %edx, %edx
callq 0x3162
movq 0x15a0f(%rip), %rcx     # 0x19348
movslq (%rcx,%r13,4), %rdx
movslq (%rcx,%rdx,4), %rdx
shlq $0x2, %rdx
addq 0x15a0c(%rip), %rdx     # 0x19358
movl %eax, (%rdx,%r12,4)
movl (%rcx,%r15,4), %eax
jmp 0x38e9
incq %rbp
cmpq 0x8(%rsp), %rbp
jne 0x38c7
movq 0x159dd(%rip), %rax     # 0x19348
movl (%rax,%r13,4), %ecx
movq 0x10(%rsp), %rdx
movl %ecx, (%rax,%rdx,4)
movl $0x1, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x33d7
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: htlookup
int htlookup(cell d, cell k) {
	cell	x;
	int	h;

	h = obhash(k, htlen(d));
	x = htslots(d)[h];
	while (x != NIL) {
		if (match(caar(x), k)) return car(x);
		x = cdr(x);
	}
	return UNDEF;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x159b5(%rip), %rax     # 0x19358
movq 0x1599e(%rip), %r14     # 0x19348
movslq %edi, %rcx
movslq (%r14,%rcx,4), %rcx
movslq (%r14,%rcx,4), %rcx
leaq (%rax,%rcx,4), %r15
movslq -0x4(%r15), %rsi
addq $0x3, %rsi
shrq $0x2, %rsi
movl %ebx, %edi
callq 0x35c5
cltq
movl (%r15,%rax,4), %eax
movl $0xfffffffc, %ebp       # imm = 0xFFFFFFFC
cmpl $-0x1, %eax
je 0x3a07
movq 0x1595d(%rip), %r15     # 0x19340
movslq %eax, %r12
movslq (%r15,%r12,4), %r13
movl (%r15,%r13,4), %edi
movl %ebx, %esi
callq 0x36eb
testl %eax, %eax
jne 0x3a04
movl (%r14,%r12,4), %eax
cmpl $-0x1, %eax
jne 0x39e3
jmp 0x3a07
movl %r13d, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: htadd
void htadd(cell d, cell k, cell v) {
	cell	e;
	int	h;

	Tmp = k;
	protect(v);
	protect(k);
	Tmp = NIL;
	if (htelts(d) >= htlen(d))
		htgrow(d);
	h = obhash(k, htlen(d));
	e = cons(k, v);
	e = cons(e, htslots(d)[h]);
	htslots(d)[h] = e;
	htelts(d)++;
	unprot(2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
movl %esi, 0x15748(%rip)     # 0x19174
movl 0x1573e(%rip), %esi     # 0x19170
movl %edx, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x1572f(%rip)     # 0x19170
movl %ebp, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x1571e(%rip)     # 0x19170
movl $0xffffffff, 0x15718(%rip) # imm = 0xFFFFFFFF
movq 0x158dd(%rip), %rax     # 0x19340
movq 0x158de(%rip), %rcx     # 0x19348
movslq %r14d, %r15
movslq (%rax,%r15,4), %rdx
movslq (%rcx,%rdx,4), %rdx
movslq (%rax,%rdx,4), %rax
movq 0x158d8(%rip), %rdx     # 0x19358
movslq (%rcx,%r15,4), %rsi
movslq (%rcx,%rsi,4), %rcx
movslq -0x4(%rdx,%rcx,4), %rcx
addq $0x3, %rcx
shrq $0x2, %rcx
cmpq %rax, %rcx
ja 0x3aa2
movl %r14d, %edi
callq 0x3829
movq 0x158af(%rip), %rax     # 0x19358
movq 0x15898(%rip), %rcx     # 0x19348
movslq (%rcx,%r15,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movslq -0x4(%rax,%rcx,4), %rsi
addq $0x3, %rsi
shrq $0x2, %rsi
movl %ebp, %edi
callq 0x35c5
movl %eax, %r14d
movl %ebp, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x3162
movq 0x15867(%rip), %rcx     # 0x19348
movslq (%rcx,%r15,4), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0x15864(%rip), %rcx     # 0x19358
movslq %r14d, %rbx
movl (%rcx,%rbx,4), %esi
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movq 0x1583e(%rip), %rcx     # 0x19348
movslq (%rcx,%r15,4), %rdx
movslq (%rcx,%rdx,4), %rdx
shlq $0x2, %rdx
addq 0x1583b(%rip), %rdx     # 0x19358
movl %eax, (%rdx,%rbx,4)
movq 0x15819(%rip), %rax     # 0x19340
movslq (%rax,%r15,4), %rdx
movslq (%rcx,%rdx,4), %rcx
incl (%rax,%rcx,4)
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x33d7
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: htrem
cell htrem(cell d, cell k) {
	cell	*x, *v;
	int	h;

	h = obhash(k, htlen(d));
	v = htslots(d);
	x = &v[h];
	while (*x != NIL) {
		if (match(caar(*x), k)) {
			*x = cdr(*x);
			htelts(d)--;
			break;
		}
		x = &cdr(*x);
	}
	return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq 0x157fb(%rip), %rax     # 0x19358
movq 0x157e4(%rip), %r14     # 0x19348
movl %edi, 0xc(%rsp)
movslq %edi, %rcx
movq %rcx, 0x10(%rsp)
movslq (%r14,%rcx,4), %rcx
movslq (%r14,%rcx,4), %rcx
leaq (%rax,%rcx,4), %r15
movslq -0x4(%r15), %rsi
addq $0x3, %rsi
shrq $0x2, %rsi
movl %ebp, %edi
callq 0x35c5
movslq %eax, %rbx
movslq (%r15,%rbx,4), %r13
cmpq $-0x1, %r13
je 0x3bf9
movq 0x1579d(%rip), %r12     # 0x19340
movslq (%r12,%r13,4), %rax
movl (%r12,%rax,4), %edi
movl %ebp, %esi
callq 0x36eb
testl %eax, %eax
je 0x3bcf
leaq (%r15,%rbx,4), %rax
jmp 0x3be2
movslq (%r12,%r13,4), %rax
movl (%r12,%rax,4), %edi
movl %ebp, %esi
callq 0x36eb
testl %eax, %eax
jne 0x3bde
movq %r13, %r15
movslq (%r14,%r13,4), %r13
cmpq $-0x1, %r13
jne 0x3bbc
jmp 0x3bf9
leaq (%r14,%r15,4), %rax
movl (%r14,%r13,4), %ecx
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
movslq (%r12,%rax,4), %rax
movslq (%r14,%rax,4), %rax
decl (%r12,%rax,4)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: mksym
cell mksym(char *s, int k) {
	cell	n;

	n = newvec(T_SYMBOL, k+1);
	strcpy((char *) symname(n), s);
	return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
incl %esi
movl $0xffffffee, %edi       # imm = 0xFFFFFFEE
callq 0x334b
movq 0x15722(%rip), %rcx     # 0x19348
movslq %eax, %r14
movslq (%rcx,%r14,4), %rdi
shlq $0x2, %rdi
addq 0x15720(%rip), %rdi     # 0x19358
movq %rbx, %rsi
callq 0x2040
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: findsym
cell findsym(char *s) {
	cell	y;

	y = mksym(s, strlen(s));
	y = htlookup(Symhash, y);
	if (y != UNDEF) return car(y);
	return NIL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2080
leal 0x1(%rax), %esi
movl $0xffffffee, %edi       # imm = 0xFFFFFFEE
callq 0x334b
movq 0x156dd(%rip), %rcx     # 0x19348
movslq %eax, %r14
movslq (%rcx,%r14,4), %rdi
shlq $0x2, %rdi
addq 0x156db(%rip), %rdi     # 0x19358
movq %rbx, %rsi
callq 0x2040
movl 0x154f5(%rip), %edi     # 0x19180
movl %r14d, %esi
callq 0x398f
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $-0x4, %ecx
je 0x3cac
movq 0x1569a(%rip), %rax     # 0x19340
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: intern
cell intern(cell y) {
	cell	n, *vn, *vs;
	int	i, k;

	protect(y);
	htadd(Symhash, y, mkfix(Symptr));
	unprot(1);
	k = veclen(Symbols);
	if (Symptr >= k) {
		n = mkvec(k + CHUNKSIZE);
		vs = vector(Symbols);
		vn = vector(n);
		for (i=0; i<k; i++) vn[i] = vs[i];
		Symbols = n;
	}
	vector(Symbols)[Symptr] = y;
	Symptr++;
	return y;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movl 0x154b0(%rip), %esi     # 0x19170
xorl %edx, %edx
callq 0x3162
movl %eax, 0x154a3(%rip)     # 0x19170
movl 0x154ad(%rip), %ebp     # 0x19180
movl 0x1593f(%rip), %edi     # 0x19618
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
movl %ebp, %edi
movl %ebx, %esi
movl %eax, %edx
callq 0x3a18
movl $0x1, %edi
callq 0x33d7
movq 0x15643(%rip), %rax     # 0x19358
movq 0x1562c(%rip), %rcx     # 0x19348
movslq 0x15419(%rip), %rdx     # 0x1913c
movslq (%rcx,%rdx,4), %rcx
movslq -0x4(%rax,%rcx,4), %r14
addq $0x3, %r14
shrq $0x2, %r14
cmpl %r14d, 0x158dd(%rip)    # 0x19618
jl 0x3d93
leal 0x400(%r14), %edi
callq 0x3422
testl %r14d, %r14d
jle 0x3d8d
movq 0x15603(%rip), %rdx     # 0x19358
movq 0x155ec(%rip), %rsi     # 0x19348
movslq 0x153d9(%rip), %rcx     # 0x1913c
movslq (%rsi,%rcx,4), %rcx
leaq (%rdx,%rcx,4), %rcx
movslq %eax, %rdi
movslq (%rsi,%rdi,4), %rsi
leaq (%rdx,%rsi,4), %rdx
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %esi, %esi
movl (%rcx,%rsi,4), %edi
movl %edi, (%rdx,%rsi,4)
incq %rsi
cmpq %rsi, %r14
jne 0x3d7f
movl %eax, 0x153a9(%rip)     # 0x1913c
movq 0x155ae(%rip), %rax     # 0x19348
movslq 0x1539b(%rip), %rcx     # 0x1913c
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq 0x155a8(%rip), %rax     # 0x19358
movslq 0x15861(%rip), %rcx     # 0x19618
movl %ebx, (%rax,%rcx,4)
incl 0x15858(%rip)           # 0x19618
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: symref
cell symref(char *s) {
	cell	y, new;

	y = findsym(s);
	if (y != NIL) return y;
	new = mksym(s, strlen(s));
	return intern(new);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x3c4b
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x3e1a
movq %rbx, %rdi
callq 0x2080
leal 0x1(%rax), %esi
movl $0xffffffee, %edi       # imm = 0xFFFFFFEE
callq 0x334b
movl %eax, %ebp
movq 0x15550(%rip), %rax     # 0x19348
movslq %ebp, %r14
movslq (%rax,%r14,4), %rdi
shlq $0x2, %rdi
addq 0x1554e(%rip), %rdi     # 0x19358
movq %rbx, %rsi
callq 0x2040
movl %r14d, %edi
callq 0x3cb4
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: reconc
cell reconc(cell n, cell m) {
	while (n != NIL) {
		if (atomp(n)) error("reconc: dotted list", n);
                m = cons(car(n), m);
		n = cdr(n);
        }
        return m;
}

// Assembly:
pushq %rbx
movl %esi, %eax
cmpl $-0x1, %edi
je 0x3e60
movl %edi, %esi
testl %esi, %esi
js 0x3e62
movq 0x1551a(%rip), %rcx     # 0x19350
movl %esi, %ebx
testb $0x9, (%rcx,%rbx)
jne 0x3e62
movq 0x154fb(%rip), %rcx     # 0x19340
movl (%rcx,%rbx,4), %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3162
movq 0x154f0(%rip), %rcx     # 0x19348
movl (%rcx,%rbx,4), %esi
cmpl $-0x1, %esi
jne 0x3e2b
popq %rbx
retq
leaq 0xf5f6(%rip), %rdi      # 0x1345f
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: nreconc
cell nreconc(cell n, cell m) {
	cell	h;

	while (n != NIL) {
		if (atomp(n)) error("nreconc: dotted list", n);
		h = cdr(n);
		cdr(n) = m;
		m = n;
		n = h;
	}
	return m;
}

// Assembly:
pushq %rax
cmpl $-0x1, %edi
je 0x3ea3
movq 0x154d5(%rip), %rcx     # 0x19350
movq 0x154c6(%rip), %rdx     # 0x19348
movl %edi, %eax
testl %edi, %edi
js 0x3ea7
movl %eax, %r8d
testb $0x9, (%rcx,%r8)
jne 0x3ea7
movl (%rdx,%r8,4), %edi
movl %esi, (%rdx,%r8,4)
movl %eax, %esi
cmpl $-0x1, %edi
jne 0x3e82
jmp 0x3ea5
movl %esi, %eax
popq %rcx
retq
leaq 0xf5b0(%rip), %rdi      # 0x1345e
movl %eax, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: conc
cell conc(cell a, cell b) {
	cell	n;

	a = reverse(a);
	protect(a);
	n = b;
	while (a != NIL) {
		n = cons(car(a), n);
		a = cdr(a);
	}
	unprot(1);
	return n;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3e21
movl %eax, %ebp
movl 0x152a3(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x15294(%rip)     # 0x19170
cmpl $-0x1, %ebp
je 0x3f07
movq 0x15458(%rip), %rax     # 0x19340
movslq %ebp, %r14
movl (%rax,%r14,4), %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %ebx
movq 0x15447(%rip), %rax     # 0x19348
movl (%rax,%r14,4), %ebp
jmp 0x3edc
movl $0x1, %edi
callq 0x33d7
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: newport
int newport(void) {
	int	i, n;

	for (n=0; n<2; n++) {
		for (i=0; i<NPORTS; i++) {
			if (NULL == Ports[i])
				return i;
		}
		if (0 == n) gc();
	}
	return -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %r14d, %r14d
leaq 0x15618(%rip), %rbx     # 0x19560
movq %rbx, %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
je 0x3f7b
incq %rax
addq $0x8, %rcx
cmpq $0x14, %rax
jne 0x3f4d
testl %r14d, %r14d
jne 0x3f6a
callq 0x2f2c
leal 0x1(%r14), %eax
testl %r14d, %r14d
movl %eax, %r14d
je 0x3f48
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: open_inport
int open_inport(char *path) {
	int	i;

	i = newport();
	if (i < 0) return -1;
	Ports[i] = fopen(path, "r");
	if (NULL == Ports[i]) return -1;
	return i;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x3f3a
testl %eax, %eax
js 0x3fc0
movl %eax, %ebx
leaq 0xfd39(%rip), %rsi      # 0x13cd5
movq %r14, %rdi
callq 0x21c0
movq %rax, %rcx
movl %ebx, %eax
leaq 0x155b0(%rip), %rdx     # 0x19560
movq %rcx, (%rdx,%rax,8)
xorl %eax, %eax
cmpq $0x1, %rcx
sbbl %eax, %eax
orl %ebx, %eax
jmp 0x3fc5
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: open_outport
int open_outport(char *path, int append) {
	int	i;

	i = newport();
	if (i < 0) return -1;
	Ports[i] = fopen(path, append? "a": "w");
	if (NULL == Ports[i]) return -1;
	return i;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x3f3a
testl %eax, %eax
js 0x4019
movl %eax, %ebx
testl %ebp, %ebp
leaq 0xfc72(%rip), %rax      # 0x13c5c
leaq 0xfeea(%rip), %rsi      # 0x13edb
cmoveq %rax, %rsi
movq %r14, %rdi
callq 0x21c0
movq %rax, %rcx
movl %ebx, %eax
leaq 0x15557(%rip), %rdx     # 0x19560
movq %rcx, (%rdx,%rax,8)
xorl %eax, %eax
cmpq $0x1, %rcx
sbbl %eax, %eax
orl %ebx, %eax
jmp 0x401e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: close_port
void close_port(int port) {
	if (port < 0 || port >= NPORTS)
		return;
	if (NULL == Ports[port]) {
		Port_flags[port] = 0;
		return;
	}
	fclose(Ports[port]);
	Ports[port] = NULL;
	Port_flags[port] = 0;
}

// Assembly:
cmpl $0x13, %edi
ja 0x406a
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x1551e(%rip), %r14     # 0x19560
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0x4058
callq 0x2070
movq $0x0, (%r14,%rbx,8)
leaq 0x155a1(%rip), %rax     # 0x19600
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: reset_stdports
void reset_stdports(void) {
	clearerr(stdin);
	clearerr(stdout);
	clearerr(stderr);
	Inport = 0;
	Outport = 1;
	Errport = 2;
}

// Assembly:
pushq %rax
movq 0x14f65(%rip), %rax     # 0x18fd8
movq (%rax), %rdi
callq 0x2130
movq 0x14f4e(%rip), %rax     # 0x18fd0
movq (%rax), %rdi
callq 0x2130
movq 0x14f67(%rip), %rax     # 0x18ff8
movq (%rax), %rdi
callq 0x2130
movl $0x0, 0x154a5(%rip)     # 0x19548
movl $0x1, 0x1509b(%rip)     # 0x19148
movl $0x2, 0x15095(%rip)     # 0x1914c
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: bindnew
void bindnew(cell v, cell a) {
	cell	n;

	n = cons(a, NIL);
	n = cons(v, n);
	Glob = cons(n, Glob);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl %esi, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3162
movl 0x15035(%rip), %esi     # 0x19144
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x15026(%rip)     # 0x19144
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: octchar
int octchar(char *s) {
	int	v = 0;

	if (!octalp(*s)) return -1;
	while (octalp(*s)) {
		v = 8*v + *s - '0';
		s++;
	}
	return (*s || v > 255)? -1: v;
}

// Assembly:
movb (%rdi), %cl
andb $-0x8, %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x30, %cl
jne 0x4174
movb (%rdi), %cl
movl %ecx, %edx
andb $-0x8, %dl
xorl %eax, %eax
cmpb $0x30, %dl
jne 0x415e
incq %rdi
xorl %edx, %edx
movzbl %cl, %ecx
leal (%rcx,%rdx,8), %edx
addl $-0x30, %edx
movb (%rdi), %cl
movl %ecx, %esi
andb $-0x8, %sil
incq %rdi
cmpb $0x30, %sil
je 0x4142
jmp 0x4160
xorl %edx, %edx
cmpl $0x100, %edx            # imm = 0x100
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmovll %edx, %esi
negb %cl
sbbl %eax, %eax
orl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: strcmp_ci
int strcmp_ci(char *s1, char *s2) {
	int	c1, c2;

	while (1) {
		c1 = tolower((int) *s1++);
		c2 = tolower((int) *s2++);
		if (!c1 || !c2 || c1 != c2)
			break;
	}
	return c1-c2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0x2150
movl %eax, %ebp
movsbl (%rbx,%r15), %edi
callq 0x2150
testl %ebp, %ebp
je 0x41aa
testl %eax, %eax
je 0x41aa
incq %r15
cmpl %eax, %ebp
je 0x4185
subl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: rdchar
cell rdchar(void) {
	char	name[TOKLEN+1];
	int	i, c, v;

	c = readc();
	name[0] = c;
	c = readc();
	for (i=1; i<TOKLEN; i++) {
		if (Intr || Readerr) return NIL;
		if (!isalpha(c) && !isdigit(c)) break;
		name[i] = c;
		c = readc();
	}
	name[i] = 0;
	rejectc(c);
	if (TOKLEN == i)
		rderror("char name too long",
			mkstr(name, strlen(name)));
	if (!strcmp_ci(name, "ht")) return mkchar(9);
	if (!strcmp_ci(name, "nl")) return mkchar(10);
	if (!strcmp_ci(name, "sp")) return mkchar(' ');
	v = octchar(&name[1]);
	if ('\\' == *name && v >= 0) return mkchar(v);
	if (i != 1) rderror("bad character name",
			mkstr(name, strlen(name)));
	return mkchar(name[0]);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
callq 0x28d8
movb %al, (%rsp)
movl $0x1, %r14d
callq 0x28d8
movl %eax, %ebx
cmpl $0x0, 0x1543c(%rip)     # 0x19630
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x436c
cmpq $0x0, 0x15421(%rip)     # 0x19628
jne 0x436c
callq 0x2230
movq (%rax), %rax
movslq %ebx, %rcx
testb $0xc, 0x1(%rax,%rcx,2)
je 0x4239
movb %bl, (%rsp,%r14)
callq 0x28d8
movl %eax, %ebx
incq %r14
cmpq $0x50, %r14
jne 0x41ed
movl $0x50, %r14d
movl %r14d, %eax
movb $0x0, (%rsp,%rax)
cmpq $0x0, 0x15310(%rip)     # 0x19558
je 0x4252
movb %bl, 0x14f04(%rip)      # 0x19154
jmp 0x426b
movslq 0x152ef(%rip), %rax     # 0x19548
leaq 0x15300(%rip), %rcx     # 0x19560
movq (%rcx,%rax,8), %rsi
movl %ebx, %edi
callq 0x2180
cmpl $0x50, %r14d
jne 0x42a2
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
callq 0x27dc
cmpq $0x0, 0x152ca(%rip)     # 0x19558
je 0x4374
leaq 0xf1d8(%rip), %rax      # 0x13473
movq %rax, 0x15386(%rip)     # 0x19628
leaq 0xf1dd(%rip), %rsi      # 0x13486
movq %rsp, %rdi
callq 0x4175
testl %eax, %eax
je 0x4300
leaq 0xf1cd(%rip), %rsi      # 0x13489
movq %rsp, %rdi
callq 0x4175
testl %eax, %eax
je 0x4307
leaq 0xfa7e(%rip), %rsi      # 0x13d4d
movq %rsp, %rdi
callq 0x4175
testl %eax, %eax
je 0x430e
leaq 0x1(%rsp), %rbx
movq %rbx, %rdi
callq 0x4120
cmpb $0x5c, -0x1(%rbx)
sete %cl
testl %eax, %eax
setns %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x4315
movzbl %al, %edi
jmp 0x434c
movl $0x9, %edi
jmp 0x434c
movl $0xa, %edi
jmp 0x434c
movl $0x20, %edi
jmp 0x434c
cmpl $0x1, %r14d
je 0x4348
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
callq 0x27dc
cmpq $0x0, 0x15220(%rip)     # 0x19558
je 0x4382
leaq 0xf14b(%rip), %rax      # 0x1348c
movq %rax, 0x152e0(%rip)     # 0x19628
movzbl (%rsp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff4, %edi       # imm = 0xFFFFFFF4
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
addq $0x58, %rsp
popq %rbx
popq %r14
retq
leaq 0xf0f8(%rip), %rdi      # 0x13473
movl %eax, %esi
callq 0x264c
leaq 0xf103(%rip), %rdi      # 0x1348c
jmp 0x437b
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: rdlist
cell rdlist(void) {
	cell		n, a, p;
	cell		new;
	static char	badpair[] = "malformed pair";

	Inlist++;
	n = xread2();
	if (RPAREN == n) {
		Inlist--;
		return NIL;
	}
	p = NIL;
	a = cons3(n, NIL, CONST_TAG);
	protect(a);
	while (n != RPAREN) {
		if (Intr || Readerr) {
			unprot(1);
			return NIL;
		}
		if (EOFMARK == n)  {
			unprot(1);
			rderror("missing ')'", UNDEF);
			return NIL;
		}
		else if (DOT == n) {
			if (NIL == p) {
				unprot(1);
				rderror(badpair, UNDEF);
				return NIL;
			}
			n = xread2();
			cdr(p) = n;
			if (RPAREN == n || xread2() != RPAREN) {
				unprot(1);
				rderror(badpair, UNDEF);
				return NIL;
			}
			Inlist--;
			return unprot(1);
		}
		car(a) = n;
		p = a;
		n = xread2();
		if (n != RPAREN) {
			Tmp = n;
			new = cons3(NIL, NIL, CONST_TAG);
			Tmp = NIL;
			cdr(a) = new;
			a = cdr(a);
		}
	}
	Inlist--;
	return unprot(1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
incl 0x15287(%rip)           # 0x1961c
callq 0x44fe
cmpl $-0x5, %eax
jne 0x43aa
decl 0x15277(%rip)           # 0x1961c
jmp 0x44da
movl %eax, %ebx
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x80, %edx
callq 0x3162
movl %eax, %ebp
movl 0x14da5(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x14d96(%rip)     # 0x19170
cmpl $0x0, 0x1524f(%rip)     # 0x19630
jne 0x4468
cmpq $0x0, 0x15239(%rip)     # 0x19628
jne 0x4468
cmpl $-0x6, %ebx
je 0x4474
cmpl $-0x3, %ebx
je 0x44b8
movq 0x14f3a(%rip), %rax     # 0x19340
movslq %ebp, %r14
movl %ebx, (%rax,%r14,4)
callq 0x44fe
movl %eax, %ebx
movl %ebp, %eax
cmpl $-0x5, %ebx
je 0x444a
movl %ebx, 0x14d53(%rip)     # 0x19174
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x80, %edx
callq 0x3162
movl $0xffffffff, 0x14d35(%rip) # imm = 0xFFFFFFFF
movq 0x14f02(%rip), %rcx     # 0x19348
movl %eax, (%rcx,%r14,4)
movl %ebp, %r14d
movl %eax, %ebp
cmpl $-0x5, %ebx
jne 0x43da
decl 0x151c2(%rip)           # 0x1961c
movl $0x1, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x33d7
movl $0x1, %edi
callq 0x33d7
jmp 0x44da
cmpl $-0x1, %r14d
je 0x449b
callq 0x44fe
movq 0x14ec2(%rip), %rcx     # 0x19348
movslq %r14d, %rdx
movl %eax, (%rcx,%rdx,4)
cmpl $-0x5, %eax
je 0x449b
callq 0x44fe
cmpl $-0x5, %eax
je 0x4454
movl $0x1, %edi
callq 0x33d7
cmpq $0x0, 0x150ab(%rip)     # 0x19558
je 0x44ed
leaq 0x14cce(%rip), %rax     # 0x19184
jmp 0x44d3
movl $0x1, %edi
callq 0x33d7
cmpq $0x0, 0x1508e(%rip)     # 0x19558
je 0x44e4
leaq 0xefcc(%rip), %rax      # 0x1349f
movq %rax, 0x1514e(%rip)     # 0x19628
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xefb4(%rip), %rdi      # 0x1349f
jmp 0x44f4
leaq 0x14c90(%rip), %rdi     # 0x19184
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $-0x1, %edi
je 0x4834
xorl %edi, %edi
movq 0x14b25(%rip), %rax     # 0x19348
movl %ebx, %ecx
incl %edi
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
cmpl $-0x1, %ecx
jne 0x4825
jmp 0x4836
xorl %edi, %edi
testl %edi, %edi
je 0x48a3
callq 0x3422
movslq %eax, %rdx
testl %ebp, %ebp
je 0x4851
movq 0x14b03(%rip), %rcx     # 0x19350
orb $-0x80, (%rcx,%rdx)
cmpl $-0x1, %ebx
je 0x48a9
movq 0x14aeb(%rip), %rcx     # 0x19348
movslq (%rcx,%rdx,4), %rdx
shlq $0x2, %rdx
addq 0x14aec(%rip), %rdx     # 0x19358
movq 0x14add(%rip), %rsi     # 0x19350
movq 0x14ac6(%rip), %rdi     # 0x19340
movl %ebx, %r8d
testl %r8d, %r8d
js 0x48b0
movl %r8d, %r8d
testb $0x9, (%rsi,%r8)
jne 0x48b0
movl (%rdi,%r8,4), %r9d
movl %r9d, (%rdx)
addq $0x4, %rdx
movl (%rcx,%r8,4), %r8d
cmpl $-0x1, %r8d
jne 0x487d
jmp 0x48a9
movl 0x148d3(%rip), %eax     # 0x1917c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
testl %ebp, %ebp
leaq 0xf20d(%rip), %rax      # 0x13ac6
leaq 0xf1e8(%rip), %rdi      # 0x13aa8
cmoveq %rax, %rdi
movl %ebx, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movl %edx, 0xc(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x491e
movl $0x1, %r13d
cmpl $0x2b, %eax
jne 0x492a
leaq 0x1(%rbx), %r14
jmp 0x492d
leaq 0x1(%rbx), %r14
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
jmp 0x492d
movq %rbx, %r14
movb (%r14), %sil
xorl %r15d, %r15d
testb %sil, %sil
je 0x4a5e
movb %sil, 0xb(%rsp)
callq 0x2220
movb 0xb(%rsp), %sil
movq %rax, 0x10(%rsp)
leaq 0xf9b9(%rip), %r12      # 0x14310
movl %esi, %eax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movsbq %al, %rax
movl (%rcx,%rax,4), %eax
movb $0x30, %dl
xorl %ecx, %ecx
movsbl %dl, %edx
cmpl %edx, %eax
je 0x4985
movb 0x1(%rcx,%r12), %dl
incq %rcx
cmpl $0x24, %ecx
jne 0x496c
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testl %ecx, %ecx
js 0x4a94
cmpl %ebp, %ecx
jge 0x4a94
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
divl %ebp
cmpl %eax, %r15d
jle 0x49e3
cmpl $0x0, 0xc(%rsp)
je 0x4a94
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
callq 0x27dc
cmpq $0x0, 0x14b90(%rip)     # 0x19558
je 0x4aa8
leaq 0xead6(%rip), %rax      # 0x134ab
movq %rax, 0x14c4c(%rip)     # 0x19628
movb 0xb(%rsp), %sil
jmp 0x4a40
testl %r15d, %r15d
setle %al
testl %ecx, %ecx
sete %dl
orb %al, %dl
jne 0x4a04
movl %r15d, %eax
imull %ebp, %eax
movl %ecx, %edx
xorl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
cmpl %edx, %eax
jg 0x49a3
testl %ecx, %ecx
sete %al
testl %r15d, %r15d
setns %dl
orb %al, %dl
jne 0x4a29
movl %r15d, %eax
imull %ebp, %eax
movl %ecx, %edx
orl $0x80000000, %edx       # imm = 0x80000000
cmpl %edx, %eax
jl 0x49a3
movl %r15d, %eax
imull %ebp, %eax
testl %r15d, %r15d
js 0x4a3b
addl %eax, %ecx
movl %ecx, %r15d
jmp 0x4a40
subl %ecx, %eax
movl %eax, %r15d
movb 0x1(%r14), %al
incq %r14
cmpl $0x1, %r13d
adcl $0x0, %r13d
imull %r13d, %r15d
xorl %r13d, %r13d
testb %al, %al
jne 0x4959
testb %sil, %sil
je 0x4a94
movl %r15d, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3162
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe9fc(%rip), %rdi      # 0x134ab
movl %eax, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 $0x58, %rsp
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
xorl %r13d, %r13d
callq 0x2230
movq %rax, %r15
leaq 0xe9dd(%rip), %r12      # 0x134ba
movq (%r15), %rax
movslq %r14d, %rcx
testb $0xc, 0x1(%rax,%rcx,2)
jne 0x4b04
testl %r14d, %r14d
je 0x4b27
movl $0x12, %edx
movq %r12, %rdi
movl %r14d, %esi
callq 0x20d0
testq %rax, %rax
je 0x4b27
movl %r14d, %edi
callq 0x2150
movb %al, (%rsp,%r13)
callq 0x28d8
movl %eax, %r14d
incq %r13
cmpq $0x50, %r13
jne 0x4add
movl $0x50, %r13d
movl %r13d, %eax
movb $0x0, (%rsp,%rax)
cmpq $0x0, 0x14a22(%rip)     # 0x19558
je 0x4b41
movb %r14b, 0x14615(%rip)    # 0x19154
jmp 0x4b5b
movslq 0x14a00(%rip), %rax     # 0x19548
leaq 0x14a11(%rip), %rcx     # 0x19560
movq (%rcx,%rax,8), %rsi
movl %r14d, %edi
callq 0x2180
cmpl $0x50, %r13d
jne 0x4b92
movq %rsp, %r14
movq %r14, %rdi
callq 0x2080
movq %r14, %rdi
movl %eax, %esi
callq 0x27dc
cmpq $0x0, 0x149da(%rip)     # 0x19558
je 0x4c0e
leaq 0xe941(%rip), %rax      # 0x134cc
movq %rax, 0x14a96(%rip)     # 0x19628
movq %rsp, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x48ee
cmpl $-0x1, %eax
jne 0x4bff
testl %ebx, %ebx
jne 0x4bd7
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
callq 0x27dc
cmpq $0x0, 0x14991(%rip)     # 0x19558
je 0x4c17
leaq 0xe916(%rip), %rax      # 0x134e6
movq %rax, 0x14a51(%rip)     # 0x19628
cmpb $0x74, (%rsp)
jne 0x4be9
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpb $0x0, 0x1(%rsp)
je 0x4bff
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x6c696e, (%rsp)       # imm = 0x6C696E
je 0x4bff
movq %rsp, %rdi
callq 0x3dc7
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe8b7(%rip), %rdi      # 0x134cc
jmp 0x4c1e
leaq 0xe8c8(%rip), %rdi      # 0x134e6
movl %eax, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movl %edi, %r14d
callq 0x2230
movq %rax, %r15
movq (%rax), %rax
movslq %r14d, %rcx
xorl %ebx, %ebx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x4c65
xorl %ebx, %ebx
leal (%rbx,%rbx,4), %eax
leal (%r14,%rax,2), %ebx
addl $-0x30, %ebx
callq 0x28d8
movl %eax, %r14d
movq (%r15), %rax
movslq %r14d, %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x4c46
cmpl $0x72, %r14d
je 0x4c83
cmpq $0x0, 0x148e5(%rip)     # 0x19558
je 0x4cda
leaq 0xe88b(%rip), %rax      # 0x13507
movq %rax, 0x149a5(%rip)     # 0x19628
leal -0x25(%rbx), %eax
cmpl $-0x24, %eax
ja 0x4cc5
movl %ebx, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
cmpq $0x0, 0x148a3(%rip)     # 0x19558
je 0x4ceb
leaq 0xe863(%rip), %rax      # 0x13521
movq %rax, 0x14963(%rip)     # 0x19628
callq 0x28d8
movl %eax, %edi
movl %ebx, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x4ab6
leaq 0xe826(%rip), %rdi      # 0x13507
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x264c
leaq 0xe82f(%rip), %rdi      # 0x13521
movl %eax, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0x146b1(%rip)           # 0x19620
callq 0x44fe
decl 0x146a6(%rip)           # 0x19620
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
popq %rbx
jmp 0x3162
// File: /workspace/github_c_makefile_star2_O1/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 0x28d8
movl %eax, %edi
callq 0x2150
movl %eax, %ebx
callq 0x28d8
cmpl $0x20, %eax
je 0x4fad
xorl %ebp, %ebp
cmpl $-0x1, %eax
je 0x4fd6
cmpl $0xa, %eax
je 0x4fd6
cmpl $0x79, %ebp
ja 0x4fcf
movl %ebp, %ecx
incl %ebp
movb %al, (%rsp,%rcx)
callq 0x28d8
jmp 0x4fb9
cmpq $0x0, 0x1457a(%rip)     # 0x19558
je 0x4fe8
movb %al, 0x1416e(%rip)      # 0x19154
jmp 0x5001
movslq 0x14559(%rip), %rcx     # 0x19548
leaq 0x1456a(%rip), %rdx     # 0x19560
movq (%rdx,%rcx,8), %rsi
movl %eax, %edi
callq 0x2180
movslq %ebp, %rax
movb $0x0, (%rsp,%rax)
cmpl $0x6c, %ebx
jne 0x5021
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 0x27dc
testl %ebp, %ebp
je 0x504c
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %eax, %ebp
jmp 0x5051
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl 0x14119(%rip), %esi     # 0x19170
movl %ebp, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x1410a(%rip)     # 0x19170
cmpl $0x6c, %ebx
je 0x508e
cmpl $0x68, %ebx
je 0x507e
cmpl $0x63, %ebx
jne 0x50ab
leaq 0xe501(%rip), %rdi      # 0x1357d
jmp 0x5085
leaq 0xe504(%rip), %rdi      # 0x13589
callq 0x3dc7
movl %eax, %ebx
jmp 0x5094
movl 0x145a0(%rip), %ebx     # 0x19634
movl $0x1, %edi
callq 0x33d7
movl %ebx, %edi
movl %ebp, %esi
xorl %edx, %edx
callq 0x3162
jmp 0x5111
leaq 0xe4c6(%rip), %rdi      # 0x13578
movl $0xb, %esi
callq 0x29f6
leaq 0xf115(%rip), %rbx      # 0x141d8
movq %rbx, %rdi
movl $0x1, %esi
callq 0x29f6
leaq 0xe4ad(%rip), %rdi      # 0x13584
movl $0x9, %esi
callq 0x29f6
movq %rbx, %rdi
movl $0x1, %esi
callq 0x29f6
leaq 0xe499(%rip), %rdi      # 0x1358e
movl $0x9, %esi
callq 0x29f6
movq %rbx, %rdi
movl $0x1, %esi
callq 0x29f6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
xorl %ebx, %ebx
movl %ebx, 0x144f6(%rip)     # 0x1961c
movl %ebx, 0x144f4(%rip)     # 0x19620
movq $0x0, 0x144f1(%rip) # 0x19628
callq 0x44fe
cmpl %ebx, 0x144ee(%rip)     # 0x19630
jne 0x5146
popq %rbx
retq
leaq 0xe492(%rip), %rdi      # 0x135df
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x10, %rsp
movl %esi, %ebx
testl %edi, %edi
je 0x51a3
leaq 0xe47e(%rip), %rdi      # 0x135e7
movl $0x2, %esi
callq 0x29f6
movq 0x141c6(%rip), %rax     # 0x19340
movq 0x141c7(%rip), %rcx     # 0x19348
movslq %ebx, %rbx
movslq (%rcx,%rbx,4), %rcx
movl (%rax,%rcx,4), %eax
cmpl $0x20, %eax
je 0x51db
cmpl $0xa, %eax
je 0x51d2
cmpl $0x9, %eax
jne 0x51f1
leaq 0xe2e5(%rip), %rdi      # 0x13486
jmp 0x51e2
movq 0x14196(%rip), %rax     # 0x19340
movq 0x14197(%rip), %rcx     # 0x19348
movslq %ebx, %rdx
movslq (%rcx,%rdx,4), %rcx
movb (%rax,%rcx,4), %al
leaq 0xf(%rsp), %rdi
movb %al, (%rdi)
movl $0x1, %esi
callq 0x29f6
addq $0x10, %rsp
popq %rbx
retq
leaq 0xe2b0(%rip), %rdi      # 0x13489
jmp 0x51e2
leaq 0xeb6b(%rip), %rdi      # 0x13d4d
movl $0x2, %esi
addq $0x10, %rsp
popq %rbx
jmp 0x29f6
leal -0x7f(%rax), %ecx
cmpl $-0x60, %ecx
ja 0x5270
leaq 0xe3e8(%rip), %rdi      # 0x135e8
movl $0x1, %esi
callq 0x29f6
movq 0x1412f(%rip), %rax     # 0x19340
movq 0x14130(%rip), %rcx     # 0x19348
movslq (%rcx,%rbx,4), %rcx
movl (%rax,%rcx,4), %eax
movb $0x0, 0x144f1(%rip)     # 0x19717
leaq 0x144e9(%rip), %rbx     # 0x19716
leaq 0xf0dc(%rip), %rcx      # 0x14310
movl %eax, %edx
leal 0x7(%rdx), %esi
testl %edx, %edx
movl %edx, %edi
cmovsl %esi, %edi
movl %edi, %r8d
andl $-0x8, %r8d
subl %r8d, %edx
movl %edx, %r8d
negl %r8d
cmovsl %edx, %r8d
movb (%r8,%rcx), %dl
movb %dl, (%rbx)
sarl $0x3, %edi
decq %rbx
movl %edi, %edx
cmpl $0xe, %esi
ja 0x5236
testl %eax, %eax
js 0x527c
incq %rbx
jmp 0x527f
leaq 0xe(%rsp), %rdi
movb %al, (%rdi)
jmp 0x51c2
movb $0x2d, (%rbx)
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
jmp 0x51e7
// File: /workspace/github_c_makefile_star2_O1/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 0x54d7
leaq 0x6(%rsp), %rdi
movb $0x22, (%rdi)
movl $0x1, %esi
callq 0x29f6
movslq %ebx, %r12
movq 0x14009(%rip), %rax     # 0x19358
movq 0x13ff2(%rip), %rcx     # 0x19348
movslq (%rcx,%r12,4), %rcx
cmpl $0x2, -0x4(%rax,%rcx,4)
jl 0x54b6
leaq (%rax,%rcx,4), %rax
xorl %r13d, %r13d
leaq 0xe27d(%rip), %rbp      # 0x135f0
leaq 0xe273(%rip), %r15      # 0x135ed
leaq 0xef8f(%rip), %rbx      # 0x14310
movzbl (%rax,%r13), %r14d
cmpl $0xa, %r14d
je 0x53a6
cmpl $0x5c, %r14d
je 0x53a1
cmpl $0x22, %r14d
jne 0x53dd
leaq 0xe24b(%rip), %rdi      # 0x135ea
jmp 0x53a9
movq %r15, %rdi
jmp 0x53a9
movq %rbp, %rdi
movl $0x2, %esi
callq 0x29f6
incq %r13
movq 0x13f9b(%rip), %rax     # 0x19358
movq 0x13f84(%rip), %rcx     # 0x19348
movslq (%rcx,%r12,4), %rcx
leaq (%rax,%rcx,4), %rax
movslq -0x4(%rax), %rcx
decq %rcx
cmpq %rcx, %r13
jl 0x5381
jmp 0x54b6
leal -0x7f(%r14), %eax
cmpb $-0x60, %al
ja 0x54a2
movb $0x5c, 0x2(%rsp)
leaq 0x2(%rsp), %rdi
movl $0x1, %esi
callq 0x29f6
movq 0x13f44(%rip), %rax     # 0x19348
movslq (%rax,%r12,4), %rax
shlq $0x2, %rax
addq 0x13f45(%rip), %rax     # 0x19358
movb 0x1(%r13,%rax), %al
andb $-0x8, %al
cmpb $0x30, %al
jne 0x5452
cmpb $0x63, %r14b
ja 0x5438
movb $0x30, 0x3(%rsp)
leaq 0x3(%rsp), %rdi
movl $0x1, %esi
callq 0x29f6
cmpb $0x9, %r14b
ja 0x5452
movb $0x30, 0x4(%rsp)
leaq 0x4(%rsp), %rdi
movl $0x1, %esi
callq 0x29f6
movq %rbp, %r15
movb $0x0, 0x142bb(%rip)     # 0x19717
leaq 0x142b4(%rip), %rbp     # 0x19717
movl %r14d, %eax
movl %r14d, %ecx
andl $0x7, %ecx
movb (%rcx,%rbx), %cl
movb %cl, -0x1(%rbp)
decq %rbp
shrl $0x3, %eax
cmpl $0x7, %r14d
movl %eax, %r14d
ja 0x5466
movq %rbp, %rdi
callq 0x2080
movq %rbp, %rdi
movl %eax, %esi
callq 0x29f6
movq %r15, %rbp
leaq 0xe150(%rip), %r15      # 0x135ed
jmp 0x53b3
movb %r14b, 0x5(%rsp)
leaq 0x5(%rsp), %rdi
movl $0x1, %esi
jmp 0x53ae
leaq 0x7(%rsp), %rdi
movb $0x22, (%rdi)
movl $0x1, %esi
callq 0x29f6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x13e6a(%rip), %rax     # 0x19348
movslq %ebx, %rcx
movslq (%rax,%rcx,4), %rbx
shlq $0x2, %rbx
addq 0x13e68(%rip), %rbx     # 0x19358
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29f6
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %ebp
leaq 0xe(%rsp), %rdi
movb $0x28, (%rdi)
movl $0x1, %esi
callq 0x29f6
cmpl $-0x1, %r14d
je 0x55d3
cmpl $0x1, 0x13e52(%rip)     # 0x19398
je 0x55d3
incl %ebx
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
leaq 0xd(%rsp), %r15
movq 0x13de0(%rip), %rax     # 0x19340
movslq %r14d, %r14
movl (%rax,%r14,4), %esi
movl %ebp, %edi
movl %ebx, %edx
callq 0x55f2
movq 0x13dd1(%rip), %rax     # 0x19348
movl (%rax,%r14,4), %r14d
cmpq %r12, %r14
je 0x55a5
movb $0x20, 0xd(%rsp)
movq %r15, %rdi
movl $0x1, %esi
callq 0x29f6
testl %r14d, %r14d
js 0x55b6
movq 0x13db2(%rip), %rax     # 0x19350
testb $0x9, (%rax,%r14)
jne 0x55b6
cmpl $-0x1, %r14d
je 0x55d3
cmpl $0x1, 0x13de6(%rip)     # 0x19398
jne 0x5559
jmp 0x55d3
leaq 0xe036(%rip), %rdi      # 0x135f3
movl $0x2, %esi
callq 0x29f6
movl %ebp, %edi
movl %r14d, %esi
movl %ebx, %edx
callq 0x55f2
leaq 0xf(%rsp), %rdi
movb $0x29, (%rdi)
movl $0x1, %esi
callq 0x29f6
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %ebp
leaq 0xdd32(%rip), %rdi      # 0x135f6
movl $0x2, %esi
callq 0x29f6
movslq %r14d, %r15
movq 0x13a80(%rip), %rax     # 0x19358
movq 0x13a69(%rip), %rcx     # 0x19348
movslq (%rcx,%r15,4), %rcx
movslq -0x4(%rax,%rcx,4), %rdx
addq $0x3, %rdx
cmpq $0x4, %rdx
jb 0x5970
leaq (%rax,%rcx,4), %rax
incl %ebx
xorl %r12d, %r12d
leaq 0xe(%rsp), %r14
movl (%rax,%r12,4), %esi
movl %ebp, %edi
movl %ebx, %edx
callq 0x55f2
movq 0x13a44(%rip), %rax     # 0x19358
movq 0x13a2d(%rip), %rcx     # 0x19348
movslq (%rcx,%r15,4), %rcx
movslq -0x4(%rax,%rcx,4), %rax
addq $0x3, %rax
shrq $0x2, %rax
decq %rax
cmpq %r12, %rax
jbe 0x5946
movb $0x20, 0xe(%rsp)
movq %r14, %rdi
movl $0x1, %esi
callq 0x29f6
incq %r12
movq 0x13a08(%rip), %rax     # 0x19358
movq 0x139f1(%rip), %rcx     # 0x19348
movslq (%rcx,%r15,4), %rcx
leaq (%rax,%rcx,4), %rax
movslq -0x4(%rax), %rcx
addq $0x3, %rcx
shrq $0x2, %rcx
cmpq %r12, %rcx
ja 0x5900
leaq 0xf(%rsp), %rdi
movb $0x29, (%rdi)
movl $0x1, %esi
callq 0x29f6
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xdc5c(%rip), %rdi      # 0x135f9
movl $0x2, %esi
callq 0x29f6
xorl %esi, %esi
testl %ebp, %ebp
sete %sil
leaq 0xe5bc(%rip), %rax      # 0x13f72
leaq 0xdc3f(%rip), %rdi      # 0x135fc
cmoveq %rax, %rdi
xorl $0x3, %esi
callq 0x29f6
leaq 0xdc30(%rip), %rdi      # 0x13600
movl $0x5, %esi
callq 0x29f6
movq 0x1395f(%rip), %rax     # 0x19340
movq 0x13960(%rip), %rcx     # 0x19348
movslq %ebx, %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movb $0x0, 0x13d1e(%rip)     # 0x19717
leaq 0x13d16(%rip), %rbx     # 0x19716
leaq 0xe909(%rip), %rcx      # 0x14310
movl %eax, %edx
movslq %edx, %rsi
imulq $0x66666667, %rsi, %rdx # imm = 0x66666667
movq %rdx, %rdi
shrq $0x3f, %rdi
sarq $0x22, %rdx
addl %edi, %edx
leal (%rdx,%rdx), %edi
leal (%rdi,%rdi,4), %edi
movl %esi, %r8d
subl %edi, %r8d
movl %r8d, %edi
negl %edi
cmovsl %r8d, %edi
movb (%rdi,%rcx), %dil
movb %dil, (%rbx)
addl $0x9, %esi
decq %rbx
cmpl $0x12, %esi
ja 0x5a09
testl %eax, %eax
js 0x5a50
incq %rbx
jmp 0x5a53
movb $0x2d, (%rbx)
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
callq 0x29f6
leaq 0xde73(%rip), %rdi      # 0x138df
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x29f6
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x10, %rsp
movl %edx, %ebx
movl %edi, %ebp
movq 0x1376f(%rip), %rax     # 0x19340
movslq %esi, %r14
movl (%rax,%r14,4), %eax
cmpl 0x13a5a(%rip), %eax     # 0x19638
jne 0x5bea
leaq 0xd(%rsp), %rdi
movb $0x27, (%rdi)
jmp 0x5c0c
cmpl 0x13a4c(%rip), %eax     # 0x1963c
jne 0x5bfc
leaq 0xe(%rsp), %rdi
movb $0x40, (%rdi)
jmp 0x5c0c
cmpl 0x13a42(%rip), %eax     # 0x19644
jne 0x5c3c
leaq 0xf(%rsp), %rdi
movb $0x2c, (%rdi)
movl $0x1, %esi
callq 0x29f6
movq 0x13723(%rip), %rax     # 0x19340
movq 0x13724(%rip), %rcx     # 0x19348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %esi
movl %ebp, %edi
movl %ebx, %edx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x55f2
cmpl 0x139fe(%rip), %eax     # 0x19640
jne 0x5c16
leaq 0xd9d5(%rip), %rdi      # 0x13620
movl $0x2, %esi
jmp 0x5c11
// File: /workspace/github_c_makefile_star2_O1/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 0x55f2
cmpl $0x1, 0x13737(%rip)     # 0x19398
jne 0x5c7f
movl $0x0, 0x1372b(%rip)     # 0x19398
leaq 0xd9fb(%rip), %rdi      # 0x1366f
movl $0x3, %esi
popq %rax
jmp 0x29f6
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $-0x1, %edi
je 0x5cc4
movq 0x13691(%rip), %rcx     # 0x19348
incl %eax
movslq %edi, %rdx
movl (%rcx,%rdx,4), %edi
cmpl $-0x1, %edi
jne 0x5cb7
retq