LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: htsize
int htsize(int n) {
	if (n < 47) return 47;
	if (n < 97) return 97;
	if (n < 199) return 199;
	if (n < 499) return 499;
	if (n < 997) return 997;
	if (n < 9973) return 9973;
	if (n < 19997) return 19997;
	return 39989;
}

// Assembly:
movl $0x2f, %eax
cmpl $0x2f, %edi
jl 0x345e
movl $0x61, %eax
cmpl $0x61, %edi
jb 0x345e
movl $0xc7, %eax
cmpl $0xc7, %edi
jb 0x345e
movl $0x1f3, %eax            # imm = 0x1F3
cmpl $0x1f3, %edi            # imm = 0x1F3
jb 0x345e
movl $0x3e5, %eax            # imm = 0x3E5
cmpl $0x3e5, %edi            # imm = 0x3E5
jb 0x345e
movl $0x26f5, %eax           # imm = 0x26F5
cmpl $0x26f5, %edi           # imm = 0x26F5
jb 0x345e
movl $0x4e1d, %ecx           # imm = 0x4E1D
cmpl %ecx, %edi
movl $0x9c35, %eax           # imm = 0x9C35
cmovbl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: mkht
cell mkht(int k) {
	cell	n;

	n = mkfix(0); /* mutable, can't use Zero */
	protect(n);
	n = cons(n, mkvec(htsize(k)));
	unprot(1);
	return n;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %edi, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
movl %eax, %ebp
movl 0x15ce2(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x15cd3(%rip)     # 0x19170
movl $0x2f, %edi
cmpl $0x2f, %ebx
jl 0x34f4
movl $0x61, %edi
cmpl $0x61, %ebx
jb 0x34f4
movl $0xc7, %edi
cmpl $0xc7, %ebx
jb 0x34f4
movl $0x1f3, %edi            # imm = 0x1F3
cmpl $0x1f3, %ebx            # imm = 0x1F3
jb 0x34f4
movl $0x3e5, %edi            # imm = 0x3E5
cmpl $0x3e5, %ebx            # imm = 0x3E5
jb 0x34f4
movl $0x26f5, %edi           # imm = 0x26F5
cmpl $0x26f5, %ebx           # imm = 0x26F5
jb 0x34f4
movl $0x4e1d, %eax           # imm = 0x4E1D
cmpl %eax, %ebx
movl $0x9c35, %edi           # imm = 0x9C35
cmovbl %eax, %edi
callq 0x33a7
movl %ebp, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebx
movl $0x1, %edi
callq 0x335c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: obhash
uint obhash(cell x, uint k) {
	if (specialp(x))
		return abs(x) % k;
	if (symbolp(x))
		return hash(symname(x), k);
	if (fixp(x))
		return abs(fixval(x)) % k;
	if (charp(x))
		return charval(x) % k;
	if (stringp(x))
		return hash(string(x), k);
	return 0;
}

// Assembly:
testl %edi, %edi
js 0x35e0
movq 0x15df7(%rip), %rax     # 0x19350
movl %edi, %ecx
movb (%rax,%rcx), %dl
testb $0x8, %dl
je 0x35b0
movq 0x15dd6(%rip), %rax     # 0x19340
cmpl $-0x12, (%rax,%rcx,4)
jne 0x35b0
movq 0x15de1(%rip), %rdx     # 0x19358
movq 0x15dca(%rip), %rax     # 0x19348
movslq (%rax,%rcx,4), %rcx
movb (%rdx,%rcx,4), %al
testb %al, %al
je 0x363b
leaq (%rdx,%rcx,4), %rcx
incq %rcx
movl $0xabcd, %edi           # imm = 0xABCD
movl %edi, %edx
shll $0x5, %edx
addl %edi, %edx
movzbl %al, %edi
xorl %edx, %edi
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x3599
jmp 0x35e2
testb $0x1, %dl
je 0x35eb
movq 0x15d84(%rip), %rax     # 0x19340
movl (%rax,%rcx,4), %edi
cmpl $-0xc, %edi
je 0x3642
cmpl $-0xe, %edi
jne 0x35eb
movq 0x15d78(%rip), %rdx     # 0x19348
movslq (%rdx,%rcx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %edi
negl %edi
cmovsl %eax, %edi
jmp 0x35e2
negl %edi
movl %edi, %eax
xorl %edx, %edx
divl %esi
movl %edx, %eax
retq
xorl %eax, %eax
testb $0x8, %dl
je 0x35ea
movq 0x15d47(%rip), %rdx     # 0x19340
cmpl $-0x11, (%rdx,%rcx,4)
jne 0x35ea
movq 0x15d52(%rip), %rdx     # 0x19358
movq 0x15d3b(%rip), %rax     # 0x19348
movslq (%rax,%rcx,4), %rcx
movb (%rdx,%rcx,4), %al
testb %al, %al
je 0x363b
leaq (%rdx,%rcx,4), %rcx
incq %rcx
movl $0xabcd, %edi           # imm = 0xABCD
movl %edi, %edx
shll $0x5, %edx
addl %edi, %edx
movzbl %al, %edi
xorl %edx, %edi
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x3624
jmp 0x35e2
movl $0xabcd, %edi           # imm = 0xABCD
jmp 0x35e2
movq 0x15cff(%rip), %rdx     # 0x19348
movslq (%rdx,%rcx,4), %rcx
movl (%rax,%rcx,4), %edi
jmp 0x35e2
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: match
int match(cell a, cell b) {
	int	k;

	if (a == b) {
		return 1;
	}
	if (fixp(a) && fixp(b)) {
		return fixval(a) == fixval(b);
	}
	if (charp(a) && charp(b)) {
		return charval(a) == charval(b);
	}
	if (symbolp(a) && symbolp(b)) {
		k = symlen(a);
		if (symlen(b) != k) return 0;
		return memcmp(symname(a), symname(b), k) == 0;
	}
	if (stringp(a) && stringp(b)) {
		k = stringlen(a);
		if (stringlen(b) != k) return 0;
		return memcmp(string(a), string(b), k) == 0;
	}
	return 0;
}

// Assembly:
movb $0x1, %al
cmpl %esi, %edi
je 0x3680
testl %edi, %edi
js 0x367e
pushq %rax
movq 0x15cec(%rip), %rcx     # 0x19350
movl %edi, %eax
movb (%rcx,%rax), %dil
testb $0x1, %dil
jne 0x3684
testb $0x8, %dil
jne 0x36c8
xorl %eax, %eax
addq $0x8, %rsp
jmp 0x3680
xorl %eax, %eax
movzbl %al, %eax
retq
movq 0x15cb5(%rip), %rdx     # 0x19340
movl (%rdx,%rax,4), %r8d
cmpl $-0xe, %r8d
setne %r9b
testl %esi, %esi
sets %r10b
orb %r9b, %r10b
je 0x370e
testl %esi, %esi
sets %r9b
cmpl $-0xc, %r8d
setne %r8b
orb %r9b, %r8b
jne 0x3670
movl %esi, %r8d
testb $0x1, (%rcx,%r8)
je 0x3670
cmpl $-0xc, (%rdx,%r8,4)
jne 0x3670
jmp 0x3727
movq 0x15c71(%rip), %rdx     # 0x19340
movl (%rdx,%rax,4), %edi
cmpl $-0x12, %edi
setne %r8b
testl %esi, %esi
sets %r9b
orb %r8b, %r9b
je 0x373e
testl %esi, %esi
sets %r8b
cmpl $-0x11, %edi
setne %dil
orb %r8b, %dil
jne 0x3676
movl %esi, %esi
testb $0x8, (%rcx,%rsi)
je 0x3676
cmpl $-0x11, (%rdx,%rsi,4)
jne 0x3676
jmp 0x3754
movl %esi, %r8d
testb $0x1, (%rcx,%r8)
je 0x3670
cmpl $-0xe, (%rdx,%r8,4)
jne 0x3670
movq 0x15c1a(%rip), %rcx     # 0x19348
movslq (%rcx,%rax,4), %rax
movl (%rdx,%rax,4), %eax
movslq (%rcx,%r8,4), %rcx
cmpl (%rdx,%rcx,4), %eax
jmp 0x3788
movl %esi, %esi
testb $0x8, (%rcx,%rsi)
je 0x3676
cmpl $-0x12, (%rdx,%rsi,4)
jne 0x3676
movq 0x15bfd(%rip), %rcx     # 0x19358
movq 0x15be6(%rip), %rdi     # 0x19348
movslq (%rdi,%rax,4), %rax
movslq -0x4(%rcx,%rax,4), %rdx
movslq (%rdi,%rsi,4), %rsi
cmpl %edx, -0x4(%rcx,%rsi,4)
jne 0x3676
leaq (%rcx,%rax,4), %rdi
leaq (%rcx,%rsi,4), %rsi
callq 0x2190
testl %eax, %eax
sete %al
jmp 0x3678
// File: /workspace/github_c_makefile_star2_O3/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 $0x28, %rsp
movq 0x15bb3(%rip), %rax     # 0x19358
movq 0x15b9c(%rip), %rcx     # 0x19348
movslq %edi, %rdx
movq %rdx, 0x8(%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 0x345f
movl %eax, %ebx
movl 0x15996(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x15987(%rip)     # 0x19170
movq 0x15b58(%rip), %rbp     # 0x19348
movslq %ebx, %rcx
movslq (%rbp,%rcx,4), %rax
testl %r14d, %r14d
jle 0x38d2
movq %rcx, 0x10(%rsp)
movq 0x15b4b(%rip), %rdx     # 0x19358
movslq (%rbp,%rax,4), %rax
movslq -0x4(%rdx,%rax,4), %r13
addq $0x3, %r13
shrq $0x2, %r13
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movq %r14, 0x18(%rsp)
movq 0x10(%rsp), %r15
movq 0x8(%rsp), %rax
movslq (%rbp,%rax,4), %rax
movslq (%rbp,%rax,4), %rax
leaq (%rdx,%rax,4), %rax
movq %rcx, 0x20(%rsp)
movl (%rax,%rcx,4), %eax
cmpl $-0x1, %eax
je 0x38b3
movq 0x15ae7(%rip), %rcx     # 0x19340
movslq %eax, %r12
movslq (%rcx,%r12,4), %r14
movl (%rcx,%r14,4), %edi
movl %r13d, %esi
movq %rdx, %rbx
callq 0x354a
movslq (%rbp,%r15,4), %rcx
movslq (%rbp,%rcx,4), %rcx
leaq (%rbx,%rcx,4), %rcx
movslq %eax, %rbx
movl (%rcx,%rbx,4), %esi
movl %r14d, %edi
xorl %edx, %edx
callq 0x30e7
movq 0x15ac4(%rip), %rdx     # 0x19358
movq 0x15aad(%rip), %rbp     # 0x19348
movslq (%rbp,%r15,4), %rcx
movslq (%rbp,%rcx,4), %rcx
leaq (%rdx,%rcx,4), %rcx
movl %eax, (%rcx,%rbx,4)
movl (%rbp,%r12,4), %eax
jmp 0x384d
movq 0x20(%rsp), %rcx
incq %rcx
movq 0x18(%rsp), %r14
cmpq %r14, %rcx
jne 0x3832
movq 0x10(%rsp), %rax
movl (%rbp,%rax,4), %eax
movq 0x8(%rsp), %rcx
movl %eax, (%rbp,%rcx,4)
movl $0x1, %edi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x335c
// File: /workspace/github_c_makefile_star2_O3/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 0x15a51(%rip), %rax     # 0x19358
movq 0x15a3a(%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 0x354a
cltq
movl (%r15,%rax,4), %eax
movl $0xfffffffc, %ebp       # imm = 0xFFFFFFFC
cmpl $-0x1, %eax
je 0x396b
movq 0x159f9(%rip), %r15     # 0x19340
movslq %eax, %r12
movslq (%r15,%r12,4), %r13
movl (%r15,%r13,4), %edi
movl %ebx, %esi
callq 0x3652
testl %eax, %eax
jne 0x3968
movl (%r14,%r12,4), %eax
cmpl $-0x1, %eax
jne 0x3947
jmp 0x396b
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_O3/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, %ebp
movl %esi, %r14d
movl %edi, %ebx
movl %esi, 0x157e4(%rip)     # 0x19174
movl 0x157da(%rip), %esi     # 0x19170
movl %edx, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x157cb(%rip)     # 0x19170
movl %r14d, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x157b9(%rip)     # 0x19170
movl $0xffffffff, 0x157b3(%rip) # imm = 0xFFFFFFFF
movq 0x15978(%rip), %rax     # 0x19340
movq 0x15979(%rip), %rcx     # 0x19348
movslq %ebx, %rbx
movslq (%rax,%rbx,4), %rdx
movslq (%rcx,%rdx,4), %rdx
movslq (%rax,%rdx,4), %rax
movq 0x15973(%rip), %rdx     # 0x19358
movslq (%rcx,%rbx,4), %rsi
movslq (%rcx,%rsi,4), %rcx
movslq -0x4(%rdx,%rcx,4), %rsi
addq $0x3, %rsi
shrq $0x2, %rsi
cmpq %rax, %rsi
ja 0x3a29
movl %ebx, %edi
callq 0x3790
movq 0x1594b(%rip), %rax     # 0x19358
movq 0x15934(%rip), %rcx     # 0x19348
movslq (%rcx,%rbx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movslq -0x4(%rax,%rcx,4), %rsi
addq $0x3, %rsi
shrq $0x2, %rsi
movl %r14d, %edi
callq 0x354a
movl %eax, %r15d
movl %r14d, %edi
movl %ebp, %esi
xorl %edx, %edx
callq 0x30e7
movq 0x15901(%rip), %rcx     # 0x19348
movslq (%rcx,%rbx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0x158fe(%rip), %rcx     # 0x19358
movslq %r15d, %r14
movl (%rcx,%r14,4), %esi
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movq 0x158d7(%rip), %rcx     # 0x19348
movslq (%rcx,%rbx,4), %rdx
movslq (%rcx,%rdx,4), %rdx
shlq $0x2, %rdx
addq 0x158d4(%rip), %rdx     # 0x19358
movl %eax, (%rdx,%r14,4)
movq 0x158b1(%rip), %rax     # 0x19340
movslq (%rax,%rbx,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 0x335c
// File: /workspace/github_c_makefile_star2_O3/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 0x15893(%rip), %rax     # 0x19358
movq 0x1587c(%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 0x354a
movslq %eax, %rbx
movslq (%r15,%rbx,4), %r13
cmpq $-0x1, %r13
je 0x3b61
movq 0x15835(%rip), %r12     # 0x19340
movslq (%r12,%r13,4), %rax
movl (%r12,%rax,4), %edi
movl %ebp, %esi
callq 0x3652
testl %eax, %eax
je 0x3b37
leaq (%r15,%rbx,4), %rax
jmp 0x3b4a
movslq (%r12,%r13,4), %rax
movl (%r12,%rax,4), %edi
movl %ebp, %esi
callq 0x3652
testl %eax, %eax
jne 0x3b46
movq %r13, %r15
movslq (%r14,%r13,4), %r13
cmpq $-0x1, %r13
jne 0x3b24
jmp 0x3b61
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_O3/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 0x32cf
movq 0x157ba(%rip), %rcx     # 0x19348
movslq %eax, %r14
movslq (%rcx,%r14,4), %rdi
shlq $0x2, %rdi
addq 0x157b8(%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_O3/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 0x32cf
movq 0x15775(%rip), %rcx     # 0x19348
movslq %eax, %r14
movslq (%rcx,%r14,4), %rdi
shlq $0x2, %rdi
addq 0x15773(%rip), %rdi     # 0x19358
movq %rbx, %rsi
callq 0x2040
movl 0x1558d(%rip), %edi     # 0x19180
movl %r14d, %esi
callq 0x38f3
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $-0x4, %ecx
je 0x3c14
movq 0x15732(%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_O3/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 0x15548(%rip), %esi     # 0x19170
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x1553b(%rip)     # 0x19170
movl 0x15545(%rip), %ebp     # 0x19180
movl 0x159d7(%rip), %edi     # 0x19618
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
movl %ebp, %edi
movl %ebx, %esi
movl %eax, %edx
callq 0x397c
movl $0x1, %edi
callq 0x335c
movq 0x156db(%rip), %rcx     # 0x19358
movq 0x156c4(%rip), %rax     # 0x19348
movslq 0x154b1(%rip), %rdx     # 0x1913c
movslq (%rax,%rdx,4), %rax
movslq -0x4(%rcx,%rax,4), %r14
addq $0x3, %r14
shrq $0x2, %r14
movl 0x15976(%rip), %edx     # 0x19618
cmpl %r14d, %edx
jl 0x3d0a
leal 0x400(%r14), %edi
callq 0x33a7
movq 0x1569e(%rip), %rcx     # 0x19358
movq 0x15687(%rip), %rdx     # 0x19348
movslq %eax, %rsi
testl %r14d, %r14d
jle 0x3cfa
movslq 0x1546c(%rip), %rdi     # 0x1913c
movslq (%rdx,%rdi,4), %rdi
leaq (%rcx,%rdi,4), %rdi
movslq (%rdx,%rsi,4), %r8
leaq (%rcx,%r8,4), %r8
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r9d, %r9d
movl (%rdi,%r9,4), %r10d
movl %r10d, (%r8,%r9,4)
incq %r9
cmpq %r9, %r14
jne 0x3cea
movl %eax, 0x1543c(%rip)     # 0x1913c
movslq (%rdx,%rsi,4), %rax
movl 0x1590e(%rip), %edx     # 0x19618
leaq (%rcx,%rax,4), %rax
movslq %edx, %rcx
movl %ebx, (%rax,%rcx,4)
incl 0x158fe(%rip)           # 0x19618
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3bb3
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x3d74
movq %rbx, %rdi
callq 0x2080
leal 0x1(%rax), %esi
movl $0xffffffee, %edi       # imm = 0xFFFFFFEE
callq 0x32cf
movl %eax, %ebp
movq 0x155f6(%rip), %rax     # 0x19348
movslq %ebp, %r14
movslq (%rax,%r14,4), %rdi
shlq $0x2, %rdi
addq 0x155f4(%rip), %rdi     # 0x19358
movq %rbx, %rsi
callq 0x2040
movl %r14d, %edi
callq 0x3c1c
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3dba
movl %edi, %esi
testl %esi, %esi
js 0x3dbc
movq 0x155c0(%rip), %rcx     # 0x19350
movl %esi, %ebx
testb $0x9, (%rcx,%rbx)
jne 0x3dbc
movq 0x155a1(%rip), %rcx     # 0x19340
movl (%rcx,%rbx,4), %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
movq 0x15596(%rip), %rcx     # 0x19348
movl (%rcx,%rbx,4), %esi
cmpl $-0x1, %esi
jne 0x3d85
popq %rbx
retq
leaq 0xf6cc(%rip), %rdi      # 0x1348f
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 0x3dfd
movq 0x1557b(%rip), %rcx     # 0x19350
movq 0x1556c(%rip), %rdx     # 0x19348
movl %edi, %eax
testl %edi, %edi
js 0x3e01
movl %eax, %r8d
testb $0x9, (%rcx,%r8)
jne 0x3e01
movl (%rdx,%r8,4), %edi
movl %esi, (%rdx,%r8,4)
movl %eax, %esi
cmpl $-0x1, %edi
jne 0x3ddc
jmp 0x3dff
movl %esi, %eax
popq %rcx
retq
leaq 0xf686(%rip), %rdi      # 0x1348e
movl %eax, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 0x3d7b
movl %eax, %ebp
movl 0x15349(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x1533a(%rip)     # 0x19170
cmpl $-0x1, %ebp
je 0x3e61
movq 0x154fe(%rip), %rax     # 0x19340
movslq %ebp, %r14
movl (%rax,%r14,4), %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebx
movq 0x154ed(%rip), %rax     # 0x19348
movl (%rax,%r14,4), %ebp
jmp 0x3e36
movl $0x1, %edi
callq 0x335c
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movb $0x1, %cl
leaq 0x156c2(%rip), %rbx     # 0x19560
movq %rbx, %rdx
xorl %eax, %eax
cmpq $0x0, (%rdx)
je 0x3ec9
incq %rax
addq $0x8, %rdx
cmpq $0x14, %rax
jne 0x3ea3
testb $0x1, %cl
je 0x3ec4
callq 0x2ec4
xorl %ecx, %ecx
jmp 0x3e9e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, %al
leaq 0x15681(%rip), %r14     # 0x19560
movq %r14, %r12
xorl %r15d, %r15d
cmpq $0x0, (%r12)
je 0x3f06
incq %r15
addq $0x8, %r12
cmpq $0x14, %r15
jne 0x3ee5
testb $0x1, %al
je 0x3f33
callq 0x2ec4
xorl %eax, %eax
jmp 0x3edf
leaq 0xfdf8(%rip), %rsi      # 0x13d05
movq %rbx, %rdi
callq 0x21c0
movq %rax, %rcx
movq %rax, (%r12)
xorl %eax, %eax
cmpq $0x1, %rcx
sbbl %eax, %eax
orl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3f27
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movb $0x1, %al
leaq 0x15610(%rip), %r15     # 0x19560
movq %r15, %r12
xorl %r14d, %r14d
cmpq $0x0, (%r12)
je 0x3f77
incq %r14
addq $0x8, %r12
cmpq $0x14, %r14
jne 0x3f56
testb $0x1, %al
je 0x3fae
callq 0x2ec4
xorl %eax, %eax
jmp 0x3f50
testl %ebp, %ebp
leaq 0xfd0c(%rip), %rax      # 0x13c8c
leaq 0xff84(%rip), %rsi      # 0x13f0b
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x21c0
movq %rax, %rcx
movq %rax, (%r12)
xorl %eax, %eax
cmpq $0x1, %rcx
sbbl %eax, %eax
orl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3fa5
// File: /workspace/github_c_makefile_star2_O3/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 0x3ffc
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x1558c(%rip), %r14     # 0x19560
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0x3fea
callq 0x2070
movq $0x0, (%r14,%rbx,8)
leaq 0x1560f(%rip), %rax     # 0x19600
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x14fd3(%rip), %rax     # 0x18fd8
movq (%rax), %rdi
callq 0x2130
movq 0x14fbc(%rip), %rax     # 0x18fd0
movq (%rax), %rdi
callq 0x2130
movq 0x14fd5(%rip), %rax     # 0x18ff8
movq (%rax), %rdi
callq 0x2130
movl $0x0, 0x15513(%rip)     # 0x19548
movl $0x1, 0x15109(%rip)     # 0x19148
movl $0x2, 0x15103(%rip)     # 0x1914c
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x30e7
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
movl 0x150a3(%rip), %esi     # 0x19144
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x15094(%rip)     # 0x19144
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl %ecx, %edx
andb $-0x8, %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x30, %dl
jne 0x40f5
incq %rdi
xorl %eax, %eax
movzbl %cl, %ecx
leal (%rcx,%rax,8), %eax
addl $-0x30, %eax
movb (%rdi), %cl
movl %ecx, %edx
andb $-0x8, %dl
incq %rdi
cmpb $0x30, %dl
je 0x40c8
cmpl $0x100, %eax            # imm = 0x100
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmovll %eax, %edx
xorl %eax, %eax
negb %cl
sbbl %eax, %eax
orl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x412b
testl %eax, %eax
je 0x412b
incq %r15
cmpl %eax, %ebp
je 0x4106
subl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
incl 0x152d2(%rip)           # 0x1961c
callq 0x44d5
cmpl $-0x5, %eax
jne 0x435f
decl 0x152c2(%rip)           # 0x1961c
jmp 0x44ab
movl %eax, %ebx
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x80, %edx
callq 0x30e7
movl %eax, %ebp
movl 0x14df6(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x14de7(%rip)     # 0x19170
cmpl $0x0, 0x152a0(%rip)     # 0x19630
jne 0x441c
cmpq $0x0, 0x1528a(%rip)     # 0x19628
jne 0x441c
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl $-0x6, %ebx
je 0x4448
cmpl $-0x3, %ebx
je 0x442b
movl %ebp, %r14d
movq 0x14f82(%rip), %rax     # 0x19340
movslq %ebp, %r15
movl %ebx, (%rax,%r15,4)
callq 0x44d5
cmpl $-0x5, %eax
je 0x446f
movl %eax, %ebx
movl %eax, 0x14d99(%rip)     # 0x19174
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x80, %edx
callq 0x30e7
movl %eax, %ebp
movl $0xffffffff, 0x14d79(%rip) # imm = 0xFFFFFFFF
movq 0x14f46(%rip), %rax     # 0x19348
movl %ebp, (%rax,%r15,4)
cmpl $0x0, 0x15223(%rip)     # 0x19630
jne 0x441c
cmpq $0x0, 0x15211(%rip)     # 0x19628
movl %r14d, %r15d
je 0x43a6
movl $0x1, %edi
callq 0x335c
jmp 0x44ab
movl $0x1, %edi
callq 0x335c
cmpq $0x0, 0x1511b(%rip)     # 0x19558
je 0x44bb
leaq 0xf089(%rip), %rax      # 0x134cf
jmp 0x44a4
cmpl $-0x1, %r15d
je 0x4489
callq 0x44d5
movq 0x14eee(%rip), %rcx     # 0x19348
movslq %r15d, %rdx
movl %eax, (%rcx,%rdx,4)
cmpl $-0x5, %eax
je 0x4489
callq 0x44d5
cmpl $-0x5, %eax
jne 0x4489
decl 0x151a7(%rip)           # 0x1961c
movl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x335c
movl $0x1, %edi
callq 0x335c
cmpq $0x0, 0x150bd(%rip)     # 0x19558
je 0x44c4
leaq 0x14ce0(%rip), %rax     # 0x19184
movq %rax, 0x1517d(%rip)     # 0x19628
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf00d(%rip), %rdi      # 0x134cf
jmp 0x44cb
leaq 0x14cb9(%rip), %rdi     # 0x19184
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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
cmpl $-0x1, %edi
je 0x487a
movl %esi, %ebp
movl %edi, %ebx
xorl %edi, %edi
movq 0x14b46(%rip), %rax     # 0x19348
movl %ebx, %ecx
incl %edi
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
cmpl $-0x1, %ecx
jne 0x4804
callq 0x33a7
movslq %eax, %rdx
testl %ebp, %ebp
je 0x4828
movq 0x14b2c(%rip), %rcx     # 0x19350
orb $-0x80, (%rcx,%rdx)
cmpl $-0x1, %ebx
je 0x4880
movq 0x14b14(%rip), %rcx     # 0x19348
movslq (%rcx,%rdx,4), %rdx
shlq $0x2, %rdx
addq 0x14b15(%rip), %rdx     # 0x19358
movq 0x14b06(%rip), %rsi     # 0x19350
movq 0x14aef(%rip), %rdi     # 0x19340
movl %ebx, %r8d
testl %r8d, %r8d
js 0x4887
movl %r8d, %r8d
testb $0x9, (%rsi,%r8)
jne 0x4887
movl (%rdi,%r8,4), %r9d
movl %r9d, (%rdx)
addq $0x4, %rdx
movl (%rcx,%r8,4), %r8d
cmpl $-0x1, %r8d
jne 0x4854
jmp 0x4880
movl 0x148fc(%rip), %eax     # 0x1917c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
testl %ebp, %ebp
leaq 0xf266(%rip), %rax      # 0x13af6
leaq 0xf241(%rip), %rdi      # 0x13ad8
cmoveq %rax, %rdi
movl %ebx, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 $0x28, %rsp
movl %edx, 0x1c(%rsp)
movq %rdi, 0x8(%rsp)
movzbl (%rdi), %r14d
movl $0x1, %r15d
cmpl $0x2b, %r14d
je 0x48fd
movq 0x8(%rsp), %r13
cmpl $0x2d, %r14d
jne 0x490a
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %r13
movb 0x1(%rax), %r14b
testb %r14b, %r14b
je 0x4a92
xorl %r12d, %r12d
movl %esi, 0x4(%rsp)
callq 0x2220
movl 0x4(%rsp), %esi
movq %rax, %rdi
leaq 0xebae(%rip), %rbx      # 0x134db
leaq 0xf9fc(%rip), %rbp      # 0x14330
movl %r14d, %eax
movq (%rdi), %rcx
movsbq %al, %rax
movl (%rcx,%rax,4), %eax
movb $0x30, %dl
xorl %ecx, %ecx
movsbl %dl, %edx
cmpl %edx, %eax
je 0x495d
movb 0x1(%rcx,%rbp), %dl
incq %rcx
cmpl $0x24, %ecx
jne 0x4945
jmp 0x4a92
cmpl %esi, %ecx
jge 0x4a92
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
divl %esi
cmpl %eax, %r12d
jle 0x49d4
cmpl $0x0, 0x1c(%rsp)
je 0x4a92
movq %r13, 0x20(%rsp)
movl %r15d, 0x18(%rsp)
movl %r14d, 0x14(%rsp)
movq 0x8(%rsp), %r14
movq %rdi, %r15
movq %r14, %rdi
callq 0x2080
movq %r14, %rdi
movl %eax, %esi
callq 0x27b0
cmpq $0x0, 0x14ba9(%rip)     # 0x19558
je 0x4aa6
movq %rbx, 0x14c6c(%rip)     # 0x19628
movl 0x4(%rsp), %esi
movq %r15, %rdi
movl 0x14(%rsp), %r14d
movl 0x18(%rsp), %r15d
movq 0x20(%rsp), %r13
jmp 0x4a38
testl %r12d, %r12d
setle %al
testl %ecx, %ecx
sete %dl
orb %al, %dl
je 0x4a00
testl %ecx, %ecx
sete %al
testl %r12d, %r12d
setns %dl
orb %al, %dl
je 0x4a1d
testl %r12d, %r12d
js 0x4a31
imull %esi, %r12d
movl %r12d, %eax
jmp 0x4a16
movl %r12d, %eax
imull %esi, %eax
movl %ecx, %edx
xorl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
cmpl %edx, %eax
jg 0x4973
addl %eax, %ecx
movl %ecx, %r12d
jmp 0x4a38
movl %r12d, %eax
imull %esi, %eax
leal -0x80000000(%rcx), %edx
cmpl %edx, %eax
jl 0x4973
imull %esi, %r12d
subl %ecx, %r12d
movl %r12d, %ecx
movb 0x1(%r13), %al
incq %r13
cmpl $0x1, %r15d
adcl $0x0, %r15d
movl %r15d, %r12d
imull %ecx, %r12d
xorl %r15d, %r15d
testb %al, %al
jne 0x4937
testb %r14b, %r14b
je 0x4a92
movl %r12d, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30e7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xea2e(%rip), %rdi      # 0x134db
movl %eax, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 0xea0f(%rip), %r12      # 0x134ea
movq (%r15), %rax
movslq %r14d, %rcx
testb $0xc, 0x1(%rax,%rcx,2)
jne 0x4b02
testl %r14d, %r14d
je 0x4b27
movl $0x12, %edx
movq %r12, %rdi
movl %r14d, %esi
callq 0x20d0
testq %rax, %rax
je 0x4b2a
movl %r14d, %edi
callq 0x2150
movb %al, (%rsp,%r13)
callq 0x28ac
movl %eax, %r14d
incq %r13
cmpq $0x50, %r13
jne 0x4adb
movl $0x50, %r13d
jmp 0x4b2a
xorl %r14d, %r14d
movl %r13d, %eax
movb $0x0, (%rsp,%rax)
cmpq $0x0, 0x14a1f(%rip)     # 0x19558
je 0x4b44
movb %r14b, 0x14612(%rip)    # 0x19154
jmp 0x4b5e
movslq 0x149fd(%rip), %rax     # 0x19548
leaq 0x14a0e(%rip), %rcx     # 0x19560
movq (%rcx,%rax,8), %rsi
movl %r14d, %edi
callq 0x2180
cmpl $0x50, %r13d
jne 0x4b95
movq %rsp, %r14
movq %r14, %rdi
callq 0x2080
movq %r14, %rdi
movl %eax, %esi
callq 0x27b0
cmpq $0x0, 0x149d7(%rip)     # 0x19558
je 0x4c11
leaq 0xe96e(%rip), %rax      # 0x134fc
movq %rax, 0x14a93(%rip)     # 0x19628
movq %rsp, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x48c5
cmpl $-0x1, %eax
jne 0x4c02
testl %ebx, %ebx
jne 0x4bda
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
callq 0x27b0
cmpq $0x0, 0x1498e(%rip)     # 0x19558
je 0x4c1a
leaq 0xe943(%rip), %rax      # 0x13516
movq %rax, 0x14a4e(%rip)     # 0x19628
cmpb $0x74, (%rsp)
jne 0x4bec
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpb $0x0, 0x1(%rsp)
je 0x4c02
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x6c696e, (%rsp)       # imm = 0x6C696E
je 0x4c02
movq %rsp, %rdi
callq 0x3d21
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe8e4(%rip), %rdi      # 0x134fc
jmp 0x4c21
leaq 0xe8f5(%rip), %rdi      # 0x13516
movl %eax, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 0x4c68
xorl %ebx, %ebx
leal (%rbx,%rbx,4), %eax
leal (%r14,%rax,2), %ebx
addl $-0x30, %ebx
callq 0x28ac
movl %eax, %r14d
movq (%r15), %rax
movslq %r14d, %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x4c49
cmpl $0x72, %r14d
je 0x4c86
cmpq $0x0, 0x148e2(%rip)     # 0x19558
je 0x4cdd
leaq 0xe8b8(%rip), %rax      # 0x13537
movq %rax, 0x149a2(%rip)     # 0x19628
leal -0x25(%rbx), %eax
cmpl $-0x24, %eax
ja 0x4cc8
movl %ebx, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
cmpq $0x0, 0x148a0(%rip)     # 0x19558
je 0x4cee
leaq 0xe890(%rip), %rax      # 0x13551
movq %rax, 0x14960(%rip)     # 0x19628
callq 0x28ac
movl %eax, %edi
movl %ebx, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x4ab4
leaq 0xe853(%rip), %rdi      # 0x13537
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x2643
leaq 0xe85c(%rip), %rdi      # 0x13551
movl %eax, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 0x146b8(%rip)           # 0x19620
callq 0x44d5
decl 0x146ad(%rip)           # 0x19620
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
popq %rbx
jmp 0x30e7
// File: /workspace/github_c_makefile_star2_O3/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 0x28ac
movl %eax, %edi
callq 0x2150
movl %eax, %ebx
callq 0x28ac
cmpl $0x20, %eax
je 0x4fa6
xorl %ebp, %ebp
cmpl $-0x1, %eax
je 0x4fcf
cmpl $0xa, %eax
je 0x4fcf
cmpl $0x79, %ebp
ja 0x4fc8
movl %ebp, %ecx
incl %ebp
movb %al, (%rsp,%rcx)
callq 0x28ac
jmp 0x4fb2
cmpq $0x0, 0x14581(%rip)     # 0x19558
je 0x4fe1
movb %al, 0x14175(%rip)      # 0x19154
jmp 0x4ffa
movslq 0x14560(%rip), %rcx     # 0x19548
leaq 0x14571(%rip), %rdx     # 0x19560
movq (%rdx,%rcx,8), %rsi
movl %eax, %edi
callq 0x2180
movslq %ebp, %rax
movb $0x0, (%rsp,%rax)
cmpl $0x6c, %ebx
jne 0x501a
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 0x27b0
testl %ebp, %ebp
je 0x5045
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebp
jmp 0x504a
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl 0x14120(%rip), %esi     # 0x19170
movl %ebp, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x14111(%rip)     # 0x19170
cmpl $0x6c, %ebx
je 0x5087
cmpl $0x68, %ebx
je 0x5077
cmpl $0x63, %ebx
jne 0x50a4
leaq 0xe538(%rip), %rdi      # 0x135ad
jmp 0x507e
leaq 0xe53b(%rip), %rdi      # 0x135b9
callq 0x3d21
movl %eax, %ebx
jmp 0x508d
movl 0x145a7(%rip), %ebx     # 0x19634
movl $0x1, %edi
callq 0x335c
movl %ebx, %edi
movl %ebp, %esi
xorl %edx, %edx
callq 0x30e7
jmp 0x510a
leaq 0xe4fd(%rip), %rdi      # 0x135a8
movl $0xb, %esi
callq 0x29c1
leaq 0xf14c(%rip), %rbx      # 0x14208
movq %rbx, %rdi
movl $0x1, %esi
callq 0x29c1
leaq 0xe4e4(%rip), %rdi      # 0x135b4
movl $0x9, %esi
callq 0x29c1
movq %rbx, %rdi
movl $0x1, %esi
callq 0x29c1
leaq 0xe4d0(%rip), %rdi      # 0x135be
movl $0x9, %esi
callq 0x29c1
movq %rbx, %rdi
movl $0x1, %esi
callq 0x29c1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x144fd(%rip)     # 0x1961c
movl %ebx, 0x144fb(%rip)     # 0x19620
movq $0x0, 0x144f8(%rip) # 0x19628
callq 0x44d5
cmpl %ebx, 0x144f5(%rip)     # 0x19630
jne 0x513f
popq %rbx
retq
leaq 0xe4c9(%rip), %rdi      # 0x1360f
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 0x519c
leaq 0xe4b5(%rip), %rdi      # 0x13617
movl $0x2, %esi
callq 0x29c1
movq 0x141cd(%rip), %rax     # 0x19340
movq 0x141ce(%rip), %rcx     # 0x19348
movslq %ebx, %rbx
movslq (%rcx,%rbx,4), %rcx
movl (%rax,%rcx,4), %eax
cmpl $0x20, %eax
je 0x51d4
cmpl $0xa, %eax
je 0x51cb
cmpl $0x9, %eax
jne 0x51ea
leaq 0xe31c(%rip), %rdi      # 0x134b6
jmp 0x51db
movq 0x1419d(%rip), %rax     # 0x19340
movq 0x1419e(%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 0x29c1
addq $0x10, %rsp
popq %rbx
retq
leaq 0xe2e7(%rip), %rdi      # 0x134b9
jmp 0x51db
leaq 0xeba2(%rip), %rdi      # 0x13d7d
movl $0x2, %esi
addq $0x10, %rsp
popq %rbx
jmp 0x29c1
leal -0x7f(%rax), %ecx
cmpl $-0x60, %ecx
ja 0x5269
leaq 0xe41f(%rip), %rdi      # 0x13618
movl $0x1, %esi
callq 0x29c1
movq 0x14136(%rip), %rax     # 0x19340
movq 0x14137(%rip), %rcx     # 0x19348
movslq (%rcx,%rbx,4), %rcx
movl (%rax,%rcx,4), %eax
movb $0x0, 0x144f8(%rip)     # 0x19717
leaq 0x144f0(%rip), %rbx     # 0x19716
leaq 0xf103(%rip), %rcx      # 0x14330
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 0x522f
testl %eax, %eax
js 0x5275
incq %rbx
jmp 0x5278
leaq 0xe(%rsp), %rdi
movb %al, (%rdi)
jmp 0x51bb
movb $0x2d, (%rbx)
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
jmp 0x51e0
// File: /workspace/github_c_makefile_star2_O3/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 0x54cf
leaq 0x6(%rsp), %rdi
movb $0x22, (%rdi)
movl $0x1, %esi
callq 0x29c1
movslq %ebx, %r12
movq 0x14010(%rip), %rax     # 0x19358
movq 0x13ff9(%rip), %rcx     # 0x19348
movslq (%rcx,%r12,4), %rcx
cmpl $0x2, -0x4(%rax,%rcx,4)
jl 0x54ae
leaq (%rax,%rcx,4), %rax
xorl %ebp, %ebp
leaq 0xe2b5(%rip), %r13      # 0x13620
leaq 0xe2ab(%rip), %r15      # 0x1361d
leaq 0xefb7(%rip), %rbx      # 0x14330
movzbl (%rax,%rbp), %r14d
cmpl $0xa, %r14d
je 0x539e
cmpl $0x5c, %r14d
je 0x5399
cmpl $0x22, %r14d
jne 0x53d5
leaq 0xe283(%rip), %rdi      # 0x1361a
jmp 0x53a1
movq %r15, %rdi
jmp 0x53a1
movq %r13, %rdi
movl $0x2, %esi
callq 0x29c1
incq %rbp
movq 0x13fa3(%rip), %rax     # 0x19358
movq 0x13f8c(%rip), %rcx     # 0x19348
movslq (%rcx,%r12,4), %rcx
leaq (%rax,%rcx,4), %rax
movslq -0x4(%rax), %rcx
decq %rcx
cmpq %rcx, %rbp
jl 0x5379
jmp 0x54ae
leal -0x7f(%r14), %eax
cmpb $-0x60, %al
ja 0x549a
movq %r13, %r15
movb $0x5c, 0x2(%rsp)
leaq 0x2(%rsp), %rdi
movl $0x1, %esi
callq 0x29c1
cmpb $0x63, %r14b
ja 0x544c
movq 0x13f43(%rip), %rax     # 0x19348
movslq (%rax,%r12,4), %rax
shlq $0x2, %rax
addq 0x13f44(%rip), %rax     # 0x19358
movb 0x1(%rbp,%rax), %al
andb $-0x8, %al
cmpb $0x30, %al
jne 0x544c
movb $0x30, 0x3(%rsp)
leaq 0x3(%rsp), %rdi
movl $0x1, %esi
callq 0x29c1
cmpb $0x9, %r14b
ja 0x544c
movb $0x30, 0x4(%rsp)
leaq 0x4(%rsp), %rdi
movl $0x1, %esi
callq 0x29c1
movb $0x0, 0x142c4(%rip)     # 0x19717
leaq 0x142bd(%rip), %r13     # 0x19717
movl %r14d, %eax
movl %r14d, %ecx
andl $0x7, %ecx
movb (%rcx,%rbx), %cl
movb %cl, -0x1(%r13)
decq %r13
shrl $0x3, %eax
cmpl $0x7, %r14d
movl %eax, %r14d
ja 0x545d
movq %r13, %rdi
callq 0x2080
movq %r13, %rdi
movl %eax, %esi
callq 0x29c1
movq %r15, %r13
leaq 0xe188(%rip), %r15      # 0x1361d
jmp 0x53ab
movb %r14b, 0x5(%rsp)
leaq 0x5(%rsp), %rdi
movl $0x1, %esi
jmp 0x53a6
leaq 0x7(%rsp), %rdi
movb $0x22, (%rdi)
movl $0x1, %esi
callq 0x29c1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x13e72(%rip), %rax     # 0x19348
movslq %ebx, %rcx
movslq (%rax,%rcx,4), %rbx
shlq $0x2, %rbx
addq 0x13e70(%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 0x29c1
// File: /workspace/github_c_makefile_star2_O3/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 0x29c1
cmpl $-0x1, %r14d
je 0x55c5
cmpl $0x1, 0x13e5a(%rip)     # 0x19398
je 0x55c5
incl %ebx
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
leaq 0xd(%rsp), %r15
movq 0x13de8(%rip), %rax     # 0x19340
movslq %r14d, %r14
movl (%rax,%r14,4), %esi
movl %ebp, %edi
movl %ebx, %edx
callq 0x55e4
movq 0x13dd9(%rip), %rax     # 0x19348
movl (%rax,%r14,4), %r14d
cmpq %r12, %r14
je 0x55c5
movb $0x20, 0xd(%rsp)
movq %r15, %rdi
movl $0x1, %esi
callq 0x29c1
testl %r14d, %r14d
js 0x55a8
movq 0x13dba(%rip), %rax     # 0x19350
testb $0x9, (%rax,%r14)
jne 0x55a8
cmpl $0x1, 0x13df4(%rip)     # 0x19398
jne 0x5551
jmp 0x55c5
leaq 0xe074(%rip), %rdi      # 0x13623
movl $0x2, %esi
callq 0x29c1
movl %ebp, %edi
movl %r14d, %esi
movl %ebx, %edx
callq 0x55e4
leaq 0xf(%rsp), %rdi
movb $0x29, (%rdi)
movl $0x1, %esi
callq 0x29c1
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xddd1(%rip), %rdi      # 0x13626
movl $0x2, %esi
callq 0x29c1
movslq %r14d, %r15
movq 0x13aef(%rip), %rax     # 0x19358
movq 0x13ad8(%rip), %rcx     # 0x19348
movslq (%rcx,%r15,4), %rcx
movslq -0x4(%rax,%rcx,4), %rdx
addq $0x3, %rdx
cmpq $0x4, %rdx
jb 0x5907
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 0x55e4
movq 0x13aaf(%rip), %rax     # 0x19358
movq 0x13a98(%rip), %rcx     # 0x19348
movslq (%rcx,%r15,4), %rcx
movslq -0x4(%rax,%rcx,4), %rdx
addq $0x3, %rdx
shrq $0x2, %rdx
leaq -0x1(%rdx), %rsi
cmpq %r12, %rsi
jbe 0x58fb
movb $0x20, 0xe(%rsp)
movq %r14, %rdi
movl $0x1, %esi
callq 0x29c1
movq 0x13a75(%rip), %rax     # 0x19358
movq 0x13a5e(%rip), %rcx     # 0x19348
movslq (%rcx,%r15,4), %rcx
movslq -0x4(%rax,%rcx,4), %rdx
addq $0x3, %rdx
shrq $0x2, %rdx
incq %r12
leaq (%rax,%rcx,4), %rax
cmpq %r12, %rdx
ja 0x5895
leaq 0xf(%rsp), %rdi
movb $0x29, (%rdi)
movl $0x1, %esi
callq 0x29c1
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq