LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, 0x1b93a(%rip)     # 0x20174
movl -0xc(%rbp), %edi
movl 0x1b92d(%rip), %esi     # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0x1b920(%rip)     # 0x20170
movl -0x8(%rbp), %edi
movl 0x1b917(%rip), %esi     # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0x1b90a(%rip)     # 0x20170
movl $0xffffffff, 0x1b904(%rip) # imm = 0xFFFFFFFF
movq 0x1bac9(%rip), %rax     # 0x20340
movq 0x1baca(%rip), %rcx     # 0x20348
movq 0x1babb(%rip), %rdx     # 0x20340
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movslq (%rax,%rcx,4), %rax
movq 0x1babc(%rip), %rcx     # 0x20358
movq 0x1baa5(%rip), %rdx     # 0x20348
movq 0x1ba9e(%rip), %rsi     # 0x20348
movslq -0x4(%rbp), %rdi
movslq (%rsi,%rdi,4), %rsi
movl (%rdx,%rsi,4), %edx
subl $0x1, %edx
movslq %edx, %rdx
movslq (%rcx,%rdx,4), %rcx
addq $0x4, %rcx
subq $0x1, %rcx
shrq $0x2, %rcx
addq $0x2, %rcx
subq $0x2, %rcx
cmpq %rcx, %rax
jb 0x48e0
movl -0x4(%rbp), %edi
callq 0x44f0
movl -0x8(%rbp), %edi
movq 0x1ba6e(%rip), %rax     # 0x20358
movq 0x1ba57(%rip), %rcx     # 0x20348
movq 0x1ba50(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movslq (%rax,%rcx,4), %rax
addq $0x4, %rax
subq $0x1, %rax
shrq $0x2, %rax
addq $0x2, %rax
subq $0x2, %rax
movl %eax, %esi
callq 0x3f70
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
movq 0x1ba13(%rip), %rax     # 0x20358
movq 0x1b9fc(%rip), %rcx     # 0x20348
movq 0x1b9f5(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edx
movq 0x1b9d7(%rip), %rax     # 0x20358
movq 0x1b9c0(%rip), %rcx     # 0x20348
movq 0x1b9b9(%rip), %rsi     # 0x20348
movslq -0x4(%rbp), %rdi
movslq (%rsi,%rdi,4), %rsi
movslq (%rcx,%rsi,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x1b990(%rip), %rax     # 0x20340
movq 0x1b991(%rip), %rcx     # 0x20348
movq 0x1b982(%rip), %rdx     # 0x20340
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl $0x2, %edi
callq 0x3d00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %edi
movq 0x1b950(%rip), %rax     # 0x20358
movq 0x1b939(%rip), %rcx     # 0x20348
movq 0x1b932(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movslq (%rax,%rcx,4), %rax
addq $0x4, %rax
subq $0x1, %rax
shrq $0x2, %rax
addq $0x2, %rax
subq $0x2, %rax
movl %eax, %esi
callq 0x3f70
movl %eax, -0x1c(%rbp)
movq 0x1b908(%rip), %rax     # 0x20358
movq 0x1b8f1(%rip), %rcx     # 0x20348
movq 0x1b8ea(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x4b1f
movq 0x1b8a4(%rip), %rax     # 0x20340
movq 0x1b89d(%rip), %rcx     # 0x20340
movq -0x10(%rbp), %rdx
movslq (%rdx), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl -0x8(%rbp), %esi
callq 0x4120
cmpl $0x0, %eax
je 0x4b01
movq 0x1b883(%rip), %rax     # 0x20348
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq 0x1b864(%rip), %rax     # 0x20340
movq 0x1b865(%rip), %rcx     # 0x20348
movq 0x1b856(%rip), %rdx     # 0x20340
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x4b1f
movq 0x1b840(%rip), %rax     # 0x20348
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x4a88
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %esi
addl $0x1, %esi
movl $0xffffffee, %edi       # imm = 0xFFFFFFEE
callq 0x3c40
movl %eax, -0x10(%rbp)
movq 0x1b7ff(%rip), %rdi     # 0x20358
movq 0x1b7e8(%rip), %rax     # 0x20348
movslq -0x10(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x2050
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2090
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x4b30
movl %eax, -0x14(%rbp)
movl 0x1b5bf(%rip), %edi     # 0x20180
movl -0x14(%rbp), %esi
callq 0x4730
movl %eax, -0x14(%rbp)
cmpl $-0x4, -0x14(%rbp)
je 0x4be5
movq 0x1b767(%rip), %rax     # 0x20340
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x4bec
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl 0x1b55c(%rip), %esi     # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0x1b54f(%rip)     # 0x20170
movl 0x1b559(%rip), %eax     # 0x20180
movl %eax, -0x28(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x24(%rbp)
movl 0x1b9e2(%rip), %edi     # 0x20618
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl $0x1, %edx
callq 0x3990
movl -0x28(%rbp), %edi
movl -0x24(%rbp), %esi
movl %eax, %edx
callq 0x4820
movl $0x1, %edi
callq 0x3d00
movq 0x1b6e4(%rip), %rax     # 0x20358
movq 0x1b6cd(%rip), %rcx     # 0x20348
movslq 0x1b4ba(%rip), %rdx     # 0x2013c
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movslq (%rax,%rcx,4), %rax
addq $0x4, %rax
subq $0x1, %rax
shrq $0x2, %rax
addq $0x2, %rax
subq $0x2, %rax
movl %eax, -0x20(%rbp)
movl 0x1b96c(%rip), %eax     # 0x20618
cmpl -0x20(%rbp), %eax
jl 0x4d44
movl -0x20(%rbp), %edi
addl $0x400, %edi            # imm = 0x400
callq 0x3d80
movl %eax, -0x8(%rbp)
movq 0x1b68b(%rip), %rax     # 0x20358
movq 0x1b674(%rip), %rcx     # 0x20348
movslq 0x1b461(%rip), %rdx     # 0x2013c
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq 0x1b667(%rip), %rax     # 0x20358
movq 0x1b650(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x4d3b
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4d12
movl -0x8(%rbp), %eax
movl %eax, 0x1b3f8(%rip)     # 0x2013c
movl -0x4(%rbp), %edx
movq 0x1b60a(%rip), %rax     # 0x20358
movq 0x1b5f3(%rip), %rcx     # 0x20348
movslq 0x1b3e0(%rip), %rsi     # 0x2013c
movslq (%rcx,%rsi,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x1b8aa(%rip), %rcx     # 0x20618
movl %edx, (%rax,%rcx,4)
movl 0x1b8a1(%rip), %eax     # 0x20618
addl $0x1, %eax
movl %eax, 0x1b898(%rip)     # 0x20618
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4b90
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x4db6
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4de0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2090
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x4b30
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
callq 0x4c00
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $-0x1, -0x4(%rbp)
je 0x4e75
cmpl $0x0, -0x4(%rbp)
jl 0x4e38
movq 0x1b53f(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x4e38
movq 0x1b528(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4e47
movl -0x4(%rbp), %esi
leaq 0x166bd(%rip), %rdi     # 0x1b4ff
callq 0x26c0
movq 0x1b4f2(%rip), %rax     # 0x20340
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl -0x8(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x8(%rbp)
movq 0x1b4df(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x4dfe
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $-0x1, -0x4(%rbp)
je 0x4f07
cmpl $0x0, -0x4(%rbp)
jl 0x4ec8
movq 0x1b4af(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x4ec8
movq 0x1b498(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4ed7
movl -0x4(%rbp), %esi
leaq 0x1662c(%rip), %rdi     # 0x1b4fe
callq 0x26c0
movq 0x1b46a(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %edx
movq 0x1b456(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4e8e
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4df0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl 0x1b239(%rip), %esi     # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0x1b22c(%rip)     # 0x20170
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0x4(%rbp)
je 0x4f7e
movq 0x1b3e9(%rip), %rax     # 0x20340
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0xc(%rbp)
movq 0x1b3d6(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x4f4a
movl $0x1, %edi
callq 0x3d00
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: nconc
cell nconc(cell a, cell b) {
	cell	n;

	n = a;
	if (NIL == a) return b;
	while (cdr(a) != NIL) a = cdr(a);
	cdr(a) = b;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x8(%rbp), %eax
jne 0x4fc2
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4fff
jmp 0x4fc4
movq 0x1b37d(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x4fe8
movq 0x1b36c(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
jmp 0x4fc4
movl -0xc(%rbp), %edx
movq 0x1b356(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jge 0x5073
movl $0x0, -0x8(%rbp)
cmpl $0x14, -0x8(%rbp)
jge 0x505a
movslq -0x8(%rbp), %rdx
xorl %eax, %eax
leaq 0x1b521(%rip), %rcx     # 0x20560
cmpq (%rcx,%rdx,8), %rax
jne 0x504d
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x507a
jmp 0x504f
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x502c
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jne 0x5066
callq 0x3580
jmp 0x5068
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x501f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x5010
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x50b3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x50f7
movq -0x10(%rbp), %rdi
leaq 0x16cbf(%rip), %rsi     # 0x1bd7d
callq 0x21c0
movq %rax, %rdx
movslq -0x14(%rbp), %rcx
leaq 0x1b48f(%rip), %rax     # 0x20560
movq %rdx, (%rax,%rcx,8)
movslq -0x14(%rbp), %rdx
xorl %eax, %eax
leaq 0x1b47e(%rip), %rcx     # 0x20560
cmpq (%rcx,%rdx,8), %rax
jne 0x50f1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x50f7
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
callq 0x5010
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x5126
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x517b
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %ecx
leaq 0x16bd0(%rip), %rsi     # 0x1bd04
leaq 0x16e48(%rip), %rax     # 0x1bf83
cmpl $0x0, %ecx
cmovneq %rax, %rsi
callq 0x21c0
movq %rax, %rdx
movslq -0x18(%rbp), %rcx
leaq 0x1b40b(%rip), %rax     # 0x20560
movq %rdx, (%rax,%rcx,8)
movslq -0x18(%rbp), %rdx
xorl %eax, %eax
leaq 0x1b3fa(%rip), %rcx     # 0x20560
cmpq (%rcx,%rdx,8), %rax
jne 0x5175
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x517b
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x51c7
cmpl $0x14, -0x4(%rbp)
jl 0x51c9
jmp 0x5223
movslq -0x4(%rbp), %rdx
xorl %eax, %eax
leaq 0x1b38a(%rip), %rcx     # 0x20560
cmpq (%rcx,%rdx,8), %rax
jne 0x51ed
movslq -0x4(%rbp), %rcx
leaq 0x1b419(%rip), %rax     # 0x20600
movb $0x0, (%rax,%rcx)
jmp 0x5223
movslq -0x4(%rbp), %rcx
leaq 0x1b368(%rip), %rax     # 0x20560
movq (%rax,%rcx,8), %rdi
callq 0x2080
movslq -0x4(%rbp), %rcx
leaq 0x1b354(%rip), %rax     # 0x20560
movq $0x0, (%rax,%rcx,8)
movslq -0x4(%rbp), %rcx
leaq 0x1b3e1(%rip), %rax     # 0x20600
movb $0x0, (%rax,%rcx)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq 0x1ad9d(%rip), %rax     # 0x1ffd8
movq (%rax), %rdi
callq 0x2140
movq 0x1ad86(%rip), %rax     # 0x1ffd0
movq (%rax), %rdi
callq 0x2140
movq 0x1ad9f(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
callq 0x2140
movl $0x0, 0x1b2dd(%rip)     # 0x20548
movl $0x1, 0x1aed3(%rip)     # 0x20148
movl $0x2, 0x1aecd(%rip)     # 0x2014c
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: lock_port
int lock_port(int port) {
	if (port < 0 || port >= NPORTS)
		return -1;
	Port_flags[port] |= LOCK_TAG;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x52a3
cmpl $0x14, -0x8(%rbp)
jl 0x52ac
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x52d1
movslq -0x8(%rbp), %rcx
leaq 0x1b349(%rip), %rax     # 0x20600
movsbl (%rax,%rcx), %eax
orl $0x40, %eax
movb %al, %dl
leaq 0x1b339(%rip), %rax     # 0x20600
movb %dl, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: unlock_port
int unlock_port(int port) {
	if (port < 0 || port >= NPORTS)
		return -1;
	Port_flags[port] &= ~LOCK_TAG;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x52f3
cmpl $0x14, -0x8(%rbp)
jl 0x52fc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5321
movslq -0x8(%rbp), %rcx
leaq 0x1b2f9(%rip), %rax     # 0x20600
movsbl (%rax,%rcx), %eax
andl $-0x41, %eax
movb %al, %dl
leaq 0x1b2e9(%rip), %rax     # 0x20600
movb %dl, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %edi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
movl 0x1addb(%rip), %esi     # 0x20144
xorl %edx, %edx
callq 0x3990
movl %eax, 0x1adce(%rip)     # 0x20144
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
je 0x541b
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movl $0x31, %eax
cmpl %ecx, %eax
je 0x541b
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movl $0x32, %eax
cmpl %ecx, %eax
je 0x541b
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movl $0x33, %eax
cmpl %ecx, %eax
je 0x541b
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movl $0x34, %eax
cmpl %ecx, %eax
je 0x541b
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movl $0x35, %eax
cmpl %ecx, %eax
je 0x541b
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movl $0x36, %eax
cmpl %ecx, %eax
je 0x541b
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movl $0x37, %eax
cmpl %ecx, %eax
je 0x541b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5522
jmp 0x541d
movq -0x10(%rbp), %rax
movsbl (%rax), %edx
movb $0x1, %al
movl $0x30, %ecx
cmpl %edx, %ecx
movb %al, -0x15(%rbp)
je 0x54c8
movq -0x10(%rbp), %rax
movsbl (%rax), %edx
movb $0x1, %al
movl $0x31, %ecx
cmpl %edx, %ecx
movb %al, -0x15(%rbp)
je 0x54c8
movq -0x10(%rbp), %rax
movsbl (%rax), %edx
movb $0x1, %al
movl $0x32, %ecx
cmpl %edx, %ecx
movb %al, -0x15(%rbp)
je 0x54c8
movq -0x10(%rbp), %rax
movsbl (%rax), %edx
movb $0x1, %al
movl $0x33, %ecx
cmpl %edx, %ecx
movb %al, -0x15(%rbp)
je 0x54c8
movq -0x10(%rbp), %rax
movsbl (%rax), %edx
movb $0x1, %al
movl $0x34, %ecx
cmpl %edx, %ecx
movb %al, -0x15(%rbp)
je 0x54c8
movq -0x10(%rbp), %rax
movsbl (%rax), %edx
movb $0x1, %al
movl $0x35, %ecx
cmpl %edx, %ecx
movb %al, -0x15(%rbp)
je 0x54c8
movq -0x10(%rbp), %rax
movsbl (%rax), %edx
movb $0x1, %al
movl $0x36, %ecx
cmpl %edx, %ecx
movb %al, -0x15(%rbp)
je 0x54c8
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movl $0x37, %eax
cmpl %ecx, %eax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x54d1
jmp 0x54f7
movl -0x14(%rbp), %eax
shll $0x3, %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x541d
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x550c
cmpl $0xff, -0x14(%rbp)
jle 0x5516
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x1c(%rbp)
jmp 0x551c
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %edi
callq 0x2160
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %edi
callq 0x2160
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x5588
cmpl $0x0, -0x18(%rbp)
je 0x5588
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
je 0x558a
jmp 0x558c
jmp 0x5540
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edx
leaq 0x15cfe(%rip), %rax     # 0x1bb66
leaq 0x15cd9(%rip), %rcx     # 0x1bb48
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0x10(%rbp)
je 0x5ea9
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq 0x1a4ab(%rip), %rax     # 0x20348
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
jmp 0x5e87
xorl %eax, %eax
cmpl -0x18(%rbp), %eax
jne 0x5ebe
movl 0x1a2c6(%rip), %eax     # 0x2017c
movl %eax, -0x4(%rbp)
jmp 0x5f8d
movl -0x18(%rbp), %edi
callq 0x3d80
movl %eax, -0x14(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x5ee7
movq 0x1a47a(%rip), %rax     # 0x20350
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %edx
orl $0x80, %edx
movb %dl, (%rax,%rcx)
movq 0x1a46a(%rip), %rax     # 0x20358
movq 0x1a453(%rip), %rcx     # 0x20348
movslq -0x14(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0x10(%rbp)
je 0x5f87
cmpl $0x0, -0x10(%rbp)
jl 0x5f48
movq 0x1a42f(%rip), %rax     # 0x20350
movslq -0x10(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x5f48
movq 0x1a418(%rip), %rax     # 0x20350
movslq -0x10(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x5f54
movq -0x28(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x26c0
movq 0x1a3e5(%rip), %rax     # 0x20340
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq 0x1a3cd(%rip), %rax     # 0x20348
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
jmp 0x5f0e
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x5fe8
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x5fd1
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5fef
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5fb2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x74(%rbp)
cmpl $0x50, -0x74(%rbp)
jge 0x62b7
callq 0x2230
movq (%rax), %rax
movslq -0x8(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x6292
callq 0x2230
movq (%rax), %rax
movslq -0x8(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x6292
cmpl $0x0, -0x8(%rbp)
je 0x6290
movl -0x8(%rbp), %esi
leaq 0x152d5(%rip), %rdi     # 0x1b55a
callq 0x20b0
cmpq $0x0, %rax
jne 0x6292
jmp 0x62b7
movl -0x8(%rbp), %edi
callq 0x2160
movb %al, %cl
movslq -0x74(%rbp), %rax
movb %cl, -0x70(%rbp,%rax)
callq 0x29f0
movl %eax, -0x8(%rbp)
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x623b
movslq -0x74(%rbp), %rax
movb $0x0, -0x70(%rbp,%rax)
movl -0x8(%rbp), %edi
callq 0x2ab0
movl $0x50, %eax
cmpl -0x74(%rbp), %eax
jne 0x62fc
leaq -0x70(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2090
movq -0x80(%rbp), %rdi
movl %eax, %esi
callq 0x2880
movl %eax, %esi
leaq 0x15275(%rip), %rdi     # 0x1b56c
callq 0x55a0
leaq -0x70(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
callq 0x6000
movl %eax, -0x78(%rbp)
cmpl $-0x1, -0x78(%rbp)
je 0x6321
movl -0x78(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x63a1
cmpl $0x0, -0x10(%rbp)
jne 0x6357
leaq -0x70(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2090
movq -0x88(%rbp), %rdi
movl %eax, %esi
callq 0x2880
movl %eax, %esi
leaq 0x15234(%rip), %rdi     # 0x1b586
callq 0x55a0
movsbl -0x70(%rbp), %ecx
movl $0x74, %eax
cmpl %ecx, %eax
jne 0x6377
movsbl -0x6f(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x6377
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x63a1
leaq -0x70(%rbp), %rdi
leaq 0x15221(%rip), %rsi     # 0x1b5a3
callq 0x2110
cmpl $0x0, %eax
jne 0x6395
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x63a1
leaq -0x70(%rbp), %rdi
callq 0x4d90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
callq 0x2230
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x63f3
imull $0xa, -0x8(%rbp), %eax
addl -0x4(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x8(%rbp)
callq 0x29f0
movl %eax, -0x4(%rbp)
jmp 0x63c2
cmpl $0x72, -0x4(%rbp)
je 0x640a
leaq 0x151a7(%rip), %rdi     # 0x1b5a7
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x55a0
cmpl $0x2, -0x8(%rbp)
jl 0x6416
cmpl $0x24, -0x8(%rbp)
jle 0x6447
movl -0x8(%rbp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
leaq 0x1517f(%rip), %rdi     # 0x1b5c1
callq 0x55a0
callq 0x29f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
xorl %edx, %edx
callq 0x6220
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x19e5f(%rip), %eax     # 0x20620
addl $0x1, %eax
movl %eax, 0x19e56(%rip)     # 0x20620
callq 0x5a80
movl %eax, -0x8(%rbp)
movl 0x19e48(%rip), %eax     # 0x20620
addl $-0x1, %eax
movl %eax, 0x19e3f(%rip)     # 0x20620
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl -0xc(%rbp), %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3990
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, 0x19bea(%rip)     # 0x2061c
movl $0x0, 0x19be4(%rip)     # 0x20620
movq $0x0, 0x19be1(%rip) # 0x20628
callq 0x5a80
movl %eax, -0x4(%rbp)
movl 0x19bdb(%rip), %eax     # 0x20630
cmpl $0x0, %eax
je 0x6a6b
leaq 0x14c1e(%rip), %rdi     # 0x1b67f
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x26c0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x6bce
leaq 0x14be8(%rip), %rdi     # 0x1b687
callq 0x25a0
movq 0x19895(%rip), %rcx     # 0x20340
movq 0x19896(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rax,%rdx,4), %rdx
movl $0x9, %eax
cmpl (%rcx,%rdx,4), %eax
jne 0x6ad5
leaq 0x14a5b(%rip), %rdi     # 0x1b526
callq 0x25a0
jmp 0x6bcc
movq 0x19864(%rip), %rcx     # 0x20340
movq 0x19865(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rax,%rdx,4), %rdx
movl $0xa, %eax
cmpl (%rcx,%rdx,4), %eax
jne 0x6b06
leaq 0x14a2d(%rip), %rdi     # 0x1b529
callq 0x25a0
jmp 0x6bca
movq 0x19833(%rip), %rcx     # 0x20340
movq 0x19834(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rax,%rdx,4), %rdx
movl $0x20, %eax
cmpl (%rcx,%rdx,4), %eax
jne 0x6b37
leaq 0x152c8(%rip), %rdi     # 0x1bdf5
callq 0x25a0
jmp 0x6bc8
movq 0x19802(%rip), %rax     # 0x20340
movq 0x19803(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
cmpl $0x20, (%rax,%rcx,4)
jl 0x6b6f
movq 0x197e6(%rip), %rax     # 0x20340
movq 0x197e7(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
cmpl $0x7e, (%rax,%rcx,4)
jle 0x6ba8
leaq 0x14b12(%rip), %rdi     # 0x1b688
callq 0x25a0
movq 0x197be(%rip), %rax     # 0x20340
movq 0x197bf(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl $0x8, %esi
callq 0x25f0
movq %rax, %rdi
callq 0x25a0
jmp 0x6bc6
movq 0x19791(%rip), %rax     # 0x20340
movq 0x19792(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x2de0
jmp 0x6bc8
jmp 0x6bca
jmp 0x6bcc
jmp 0x6bec
movq 0x1976b(%rip), %rax     # 0x20340
movq 0x1976c(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x2de0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl $0x28, %edi
callq 0x2de0
xorl %eax, %eax
cmpl $-0x1, -0x8(%rbp)
movb %al, -0xd(%rbp)
je 0x6f93
cmpl $0x1, 0x1940b(%rip)     # 0x20398
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x6f9f
jmp 0x7036
movl -0x4(%rbp), %edi
movq 0x19397(%rip), %rax     # 0x20340
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movl -0xc(%rbp), %edx
addl $0x1, %edx
callq 0x7050
movq 0x19386(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
je 0x7031
movl $0x20, %edi
callq 0x2de0
cmpl $0x0, -0x8(%rbp)
jl 0x7010
movq 0x19367(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x7010
movq 0x19350(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x702f
leaq 0x1467c(%rip), %rdi     # 0x1b693
callq 0x25a0
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
addl $0x1, %edx
callq 0x7050
jmp 0x7036
jmp 0x7031
jmp 0x6f7b
movl $0x29, %edi
callq 0x2de0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
leaq 0x140ce(%rip), %rdi     # 0x1b696
callq 0x25a0
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq 0x18d79(%rip), %rcx     # 0x20358
movq 0x18d62(%rip), %rdx     # 0x20348
movslq -0x8(%rbp), %rsi
movl (%rdx,%rsi,4), %edx
subl $0x1, %edx
movslq %edx, %rdx
movslq (%rcx,%rdx,4), %rcx
addq $0x4, %rcx
subq $0x1, %rcx
shrq $0x2, %rcx
addq $0x2, %rcx
subq $0x2, %rcx
cmpq %rcx, %rax
jae 0x76a0
movl -0x4(%rbp), %edi
movq 0x18d3a(%rip), %rax     # 0x20358
movq 0x18d23(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movl -0xc(%rbp), %edx
addl $0x1, %edx
callq 0x7050
movslq -0x10(%rbp), %rax
movq 0x18d07(%rip), %rcx     # 0x20358
movq 0x18cf0(%rip), %rdx     # 0x20348
movslq -0x8(%rbp), %rsi
movl (%rdx,%rsi,4), %edx
subl $0x1, %edx
movslq %edx, %rdx
movslq (%rcx,%rdx,4), %rcx
addq $0x4, %rcx
subq $0x1, %rcx
shrq $0x2, %rcx
addq $0x2, %rcx
subq $0x2, %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x7690
movl $0x20, %edi
callq 0x2de0
jmp 0x7692
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x75d4
movl $0x29, %edi
callq 0x2de0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x13fd4(%rip), %rdi     # 0x1b699
callq 0x25a0
movl -0x4(%rbp), %ecx
leaq 0x14946(%rip), %rdi     # 0x1c01a
leaq 0x13fc1(%rip), %rax     # 0x1b69c
cmpl $0x0, %ecx
cmovneq %rax, %rdi
callq 0x25a0
leaq 0x13fb2(%rip), %rdi     # 0x1b6a0
callq 0x25a0
movq 0x18c46(%rip), %rax     # 0x20340
movq 0x18c47(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl $0xa, %esi
callq 0x25f0
movq %rax, %rdi
callq 0x25a0
leaq 0x1425a(%rip), %rdi     # 0x1b97f
callq 0x25a0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq 0x18b68(%rip), %rax     # 0x20340
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x18e53(%rip), %eax     # 0x20638
jne 0x77f3
movl $0x27, %edi
callq 0x2de0
jmp 0x785f
movq 0x18b46(%rip), %rax     # 0x20340
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x18e35(%rip), %eax     # 0x2063c
jne 0x7815
movl $0x40, %edi
callq 0x2de0
jmp 0x785d
movq 0x18b24(%rip), %rax     # 0x20340
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x18e1b(%rip), %eax     # 0x20644
jne 0x7837
movl $0x2c, %edi
callq 0x2de0
jmp 0x785b
movq 0x18b02(%rip), %rax     # 0x20340
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x18df5(%rip), %eax     # 0x20640
jne 0x7859
leaq 0x13e6c(%rip), %rdi     # 0x1b6c0
callq 0x25a0
jmp 0x785b
jmp 0x785d
jmp 0x785f
movl -0x4(%rbp), %edi
movq 0x18ad7(%rip), %rax     # 0x20340
movq 0x18ad8(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %esi
movl -0xc(%rbp), %edx
callq 0x7050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
xorl %edx, %edx
callq 0x7050
movl $0x1, %eax
cmpl 0x18ae2(%rip), %eax     # 0x20398
jne 0x78ce
movl $0x0, 0x18ad6(%rip)     # 0x20398
leaq 0x13e46(%rip), %rdi     # 0x1b70f
callq 0x25a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $-0x1, -0x4(%rbp)
je 0x7960
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movq 0x189f4(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x793e
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %edi
callq 0x7930
subl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x8(%rbp), %eax
jl 0x79a8
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x79ee
cmpl $0x0, -0xc(%rbp)
jl 0x79ee
leaq -0x80(%rbp), %rdi
movq 0x189a5(%rip), %rdx     # 0x20358
movq 0x1898e(%rip), %rax     # 0x20348
movq 0x1897f(%rip), %rcx     # 0x20340
movslq -0x4(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdx
leaq 0x13d38(%rip), %rsi     # 0x1b713
movb $0x0, %al
callq 0x21f0
leaq -0x80(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x26c0
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl $0x2, %edx
movl %edx, %esi
callq 0x7970
movq 0x1861c(%rip), %rax     # 0x20340
movq 0x1861d(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0x7d91
movq 0x18610(%rip), %rax     # 0x20350
movq 0x185f9(%rip), %rcx     # 0x20340
movq 0x185fa(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x7d91
movq 0x185d3(%rip), %rcx     # 0x20340
movq 0x185cc(%rip), %rax     # 0x20340
movq 0x185cd(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rax,%rdx,4), %rdx
movl $0xffffffee, %eax       # imm = 0xFFFFFFEE
cmpl (%rcx,%rdx,4), %eax
je 0x7db6
movq 0x185a8(%rip), %rax     # 0x20340
movq 0x185a9(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x13980(%rip), %rdi     # 0x1b731
callq 0x26c0
cmpl $0x0, -0x8(%rbp)
jne 0x7dcb
movl -0x4(%rbp), %esi
leaq 0x13980(%rip), %rdi     # 0x1b746
callq 0x26c0
movq 0x1856e(%rip), %rax     # 0x20340
movq 0x1856f(%rip), %rcx     # 0x20348
movq 0x18568(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x7a90
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movb $0x1, %al
cmpl $0x0, -0xc(%rbp)
movb %al, -0xd(%rbp)
jl 0x7ecf
movq 0x184b1(%rip), %rax     # 0x20350
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
andl $0x1, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0xd(%rbp)
jne 0x7ecf
movq 0x18495(%rip), %rax     # 0x20350
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x7eda
jmp 0x7f4e
movq 0x1845f(%rip), %rax     # 0x20340
movslq -0xc(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0x7f2d
movq 0x1845e(%rip), %rax     # 0x20350
movq 0x18447(%rip), %rcx     # 0x20340
movslq -0xc(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x7f2d
movq 0x1842c(%rip), %rcx     # 0x20340
movq 0x18425(%rip), %rax     # 0x20340
movslq -0xc(%rbp), %rdx
movslq (%rax,%rdx,4), %rdx
movl $0xffffffee, %eax       # imm = 0xFFFFFFEE
cmpl (%rcx,%rdx,4), %eax
je 0x7f36
movl $0x0, -0x4(%rbp)
jmp 0x7f9e
jmp 0x7f38
movq 0x18409(%rip), %rax     # 0x20348
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
jmp 0x7e8d
cmpl $0x0, -0xc(%rbp)
jl 0x7f85
movq 0x183f5(%rip), %rax     # 0x20350
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x7f85
movq 0x183ce(%rip), %rdx     # 0x20340
movslq -0xc(%rbp), %rsi
movb $0x1, %al
movl $0xffffffee, %ecx       # imm = 0xFFFFFFEE
cmpl (%rdx,%rsi,4), %ecx
movb %al, -0xe(%rbp)
je 0x7f93
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0xc(%rbp), %eax
sete %al
movb %al, -0xe(%rbp)
movb -0xe(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x8(%rbp), %eax
jne 0x801e
movl $0x1, -0x4(%rbp)
jmp 0x807a
jmp 0x8020
movq 0x18321(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x8073
movq 0x18308(%rip), %rax     # 0x20340
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movq 0x18302(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x7fb0
cmpl $-0x1, %eax
je 0x8060
movl $0x0, -0x4(%rbp)
jmp 0x807a
movq 0x182e1(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
jmp 0x8020
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)