LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: expanddef
cell expanddef(cell x) {
	char	b[100];
	cell	n;

	if (!pairp(cadr(x))) {
		sprintf(b, "%s: expected signature", symname(car(x)));
		error(b, cadr(x));
	}
	n = cons(cdadr(x), expandbody(cddr(x)));
	n = cons(S_lambda, n);
	n = cons(n, NIL);
	n = cons(caadr(x), n);
	n = cons(car(x) == S_defun? S_def: S_macro, n);
	return n;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq 0xe95d(%rip), %rcx      # 0x17340
movq 0xe95e(%rip), %rax      # 0x17348
movslq %edi, %r14
movslq (%rax,%r14,4), %rdx
movslq (%rcx,%rdx,4), %rsi
testq %rsi, %rsi
js 0x8a97
movq 0xe94b(%rip), %rdi      # 0x17350
testb $0x9, (%rdi,%rsi)
jne 0x8a97
movl (%rax,%rsi,4), %ebx
movl (%rax,%rdx,4), %edi
callq 0x877b
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x2f8c
movl 0xecfd(%rip), %edi      # 0x17728
movl %eax, %esi
xorl %edx, %edx
callq 0x2f8c
pushq $-0x1
popq %rsi
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movq 0xe8f9(%rip), %rcx      # 0x17340
movq 0xe8fa(%rip), %rdx      # 0x17348
movslq (%rdx,%r14,4), %rdx
movslq (%rcx,%rdx,4), %rdx
movl (%rcx,%rdx,4), %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x2f8c
movq 0xe8d7(%rip), %rcx      # 0x17340
movl (%rcx,%r14,4), %ecx
cmpl 0xeecd(%rip), %ecx      # 0x17940
leaq 0xeca2(%rip), %rcx      # 0x1771c
leaq 0xecab(%rip), %rdx      # 0x1772c
cmoveq %rcx, %rdx
movl (%rdx), %edi
movl %eax, %esi
xorl %edx, %edx
addq $0x68, %rsp
popq %rbx
popq %r14
jmp 0x2f8c
movslq (%rcx,%r14,4), %rcx
movslq (%rax,%rcx,4), %rdx
shlq $0x2, %rdx
addq 0xe8ae(%rip), %rdx      # 0x17358
leaq 0x7d6e(%rip), %rsi      # 0x1081f
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq 0xe87b(%rip), %rax      # 0x17340
movq 0xe87c(%rip), %rcx      # 0x17348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %esi
movq %rbx, %rdi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: eval
cell eval(cell x, int r) {
	Tmp = x;
	if (r) begin_rec();
	protect(x);
	Tmp = NIL;
	x = expand(x, 1);  car(Protected) = x;
	syncheck(x, 1);
	x = clsconv(x);    car(Protected) = x;
	x = compile(x);    car(Protected) = x;
	x = interpret(x);
	unprot(1);
	if (r) end_rec();
	return x;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %r14d
movl %edi, 0xe68a(%rip)      # 0x17174
testl %esi, %esi
je 0x8af3
callq 0xaf48
movl 0xe677(%rip), %esi      # 0x17170
movl %r14d, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xe667(%rip)      # 0x17170
orl $-0x1, 0xe664(%rip)     # 0x17174
pushq $0x1
popq %rbp
movl %r14d, %edi
movl %ebp, %esi
callq 0x84c2
movl %eax, %r14d
movq 0xe819(%rip), %rax      # 0x17340
movslq 0xe642(%rip), %rcx      # 0x17170
movl %r14d, (%rax,%rcx,4)
movl %r14d, %edi
movl %ebp, %esi
callq 0x5261
movl %r14d, %edi
callq 0x66fa
movq 0xe7f5(%rip), %rcx      # 0x17340
movslq 0xe61e(%rip), %rdx      # 0x17170
movl %eax, (%rcx,%rdx,4)
movl %eax, %edi
callq 0x82e0
movq 0xe7dd(%rip), %rcx      # 0x17340
movslq 0xe606(%rip), %rdx      # 0x17170
movl %eax, (%rcx,%rdx,4)
movl %eax, %edi
callq 0xe629
movl %eax, %r14d
movl %ebp, %edi
callq 0x31a9
testl %ebx, %ebx
je 0x8b87
callq 0xb019
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: add
cell add(cell x, cell y) {
	if (!fixp(x)) expect("+", "fixnum", x);
	if (!fixp(y)) expect("+", "fixnum", y);
	if (add_ovfl(fixval(x), fixval(y))) fixover("+", x, y);
	return mkfix(fixval(x) + fixval(y));
}

// Assembly:
pushq %rbx
movl %edi, %eax
testl %edi, %edi
js 0x8c68
movq 0xe76b(%rip), %rdi      # 0x17350
movl %eax, %ecx
testb $0x1, (%rdi,%rcx)
je 0x8c68
movl %esi, %edx
movq 0xe74a(%rip), %rsi      # 0x17340
cmpl $-0xe, (%rsi,%rcx,4)
jne 0x8c68
testl %edx, %edx
js 0x8c7d
movl %edx, %r8d
testb $0x1, (%rdi,%r8)
je 0x8c7d
cmpl $-0xe, (%rsi,%r8,4)
jne 0x8c7d
movq 0xe730(%rip), %r9       # 0x17348
movslq (%r9,%r8,4), %rdi
movl (%rsi,%rdi,4), %edi
testl %edi, %edi
jle 0x8c38
movslq (%r9,%rcx,4), %rcx
movl (%rsi,%rcx,4), %ecx
movl %edi, %esi
xorl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
cmpl %esi, %ecx
jle 0x8c4c
jmp 0x8c90
movslq (%r9,%rcx,4), %rcx
movl (%rsi,%rcx,4), %ecx
je 0x8c4c
movl $0x80000000, %esi       # imm = 0x80000000
subl %edi, %esi
cmpl %esi, %ecx
jl 0x8c90
addl %ecx, %edi
pushq $-0x1
popq %rsi
pushq $0x1
popq %rbx
movl %ebx, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %ebx, %edx
popq %rbx
jmp 0x2f8c
leaq 0x7bfe(%rip), %rdi      # 0x1086d
leaq 0x7bf9(%rip), %rsi      # 0x1086f
movl %eax, %edx
callq 0x2720
leaq 0x7be9(%rip), %rdi      # 0x1086d
leaq 0x7be4(%rip), %rsi      # 0x1086f
callq 0x2720
leaq 0x7bd6(%rip), %rdi      # 0x1086d
movl %eax, %esi
callq 0x8b8f
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: xsub
cell xsub(cell x, cell y) {
	if (!fixp(x)) expect("-", "fixnum", x);
	if (!fixp(y)) expect("-", "fixnum", y);
	if (sub_ovfl(fixval(y), fixval(x))) fixover("+", y, x);
	return mkfix(fixval(y) - fixval(x));
}

// Assembly:
pushq %rbx
movl %edi, %edx
testl %edi, %edi
js 0x8d45
movq 0xe6a0(%rip), %r8       # 0x17350
movl %edx, %ecx
testb $0x1, (%r8,%rcx)
je 0x8d45
movl %esi, %eax
movq 0xe67a(%rip), %rsi      # 0x17340
cmpl $-0xe, (%rsi,%rcx,4)
jne 0x8d45
testl %eax, %eax
js 0x8d58
movl %eax, %edi
testb $0x1, (%r8,%rdi)
je 0x8d58
cmpl $-0xe, (%rsi,%rdi,4)
jne 0x8d58
movq 0xe65e(%rip), %r8       # 0x17348
movslq (%r8,%rcx,4), %rcx
movl (%rsi,%rcx,4), %ecx
testl %ecx, %ecx
js 0x8d18
movslq (%r8,%rdi,4), %rdi
movl (%rsi,%rdi,4), %edi
je 0x8d29
movl %ecx, %esi
orl $0x80000000, %esi       # imm = 0x80000000
cmpl %esi, %edi
jge 0x8d29
leaq 0x7b5c(%rip), %rdi      # 0x1086d
movl %eax, %esi
callq 0x8b8f
movslq (%r8,%rdi,4), %rdi
movl (%rsi,%rdi,4), %edi
leal 0x7fffffff(%rcx), %esi
cmpl %esi, %edi
jg 0x8d0a
subl %ecx, %edi
pushq $-0x1
popq %rsi
pushq $0x1
popq %rbx
movl %ebx, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %ebx, %edx
popq %rbx
jmp 0x2f8c
leaq 0x7b2a(%rip), %rdi      # 0x10876
leaq 0x7b1c(%rip), %rsi      # 0x1086f
callq 0x2720
leaq 0x7b17(%rip), %rdi      # 0x10876
leaq 0x7b09(%rip), %rsi      # 0x1086f
movl %eax, %edx
callq 0x2720
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: mul
cell mul(cell x, cell y) {
	int	a, b;

	if (!fixp(x)) expect("*", "fixnum", x);
	if (!fixp(y)) expect("*", "fixnum", y);
	a = fixval(x);
	b = fixval(y);
	/*
	 * Overflow of a*b is undefined, sooo
	 */
	/* Shortcuts, also protect later division */
	if (0 == a || 0 == b) return Zero;
	if (1 == a) return y;
	if (1 == b) return x;
	/* abs(INT_MIN) is undefined using two's complement, so */
	if (INT_MIN == a || INT_MIN == b) fixover("*", x, y);
	/* Catch the rest */
	/* Bug: result may not be INT_MIN */
	if (abs(a) > INT_MAX / abs(b)) fixover("*", x, y);
	return mkfix(a * b);
}

// Assembly:
pushq %rbx
movl %edi, %r8d
testl %edi, %edi
js 0x8e40
movl %esi, %ecx
movq 0xe5ce(%rip), %rsi      # 0x17350
movl %r8d, %edx
testb $0x1, (%rsi,%rdx)
je 0x8e40
movq 0xe5aa(%rip), %rax      # 0x17340
cmpl $-0xe, (%rax,%rdx,4)
jne 0x8e40
testl %ecx, %ecx
js 0x8e56
movl %ecx, %edi
testb $0x1, (%rsi,%rdi)
je 0x8e56
cmpl $-0xe, (%rax,%rdi,4)
jne 0x8e56
movq 0xe583(%rip), %r9       # 0x17348
movslq (%r9,%rdx,4), %rdx
movl (%rax,%rdx,4), %esi
testl %esi, %esi
je 0x8dea
movslq (%r9,%rdi,4), %rdx
movl (%rax,%rdx,4), %edi
testl %edi, %edi
je 0x8dea
cmpl $0x1, %esi
je 0x8df0
cmpl $0x1, %edi
jne 0x8df4
movl %r8d, %ecx
jmp 0x8df0
movl 0xe3bc(%rip), %ecx      # 0x171ac
movl %ecx, %eax
popq %rbx
retq
movl %esi, %eax
negl %eax
jo 0x8e6b
movl %edi, %eax
negl %eax
jo 0x8e6b
movl %esi, %r9d
negl %r9d
cmovsl %esi, %r9d
movl %edi, %r10d
negl %r10d
cmovsl %edi, %r10d
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
divl %r10d
cmpl %eax, %r9d
ja 0x8e6b
imull %esi, %edi
pushq $-0x1
popq %rsi
pushq $0x1
popq %rbx
movl %ebx, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %ebx, %edx
popq %rbx
jmp 0x2f8c
leaq 0x80aa(%rip), %rdi      # 0x10ef1
leaq 0x7a21(%rip), %rsi      # 0x1086f
movl %r8d, %edx
callq 0x2720
leaq 0x8094(%rip), %rdi      # 0x10ef1
leaq 0x7a0b(%rip), %rsi      # 0x1086f
movl %ecx, %edx
callq 0x2720
leaq 0x807f(%rip), %rdi      # 0x10ef1
movl %r8d, %esi
movl %ecx, %edx
callq 0x8b8f
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: intdiv
cell intdiv(cell x, cell y) {
	if (!fixp(x)) expect("div", "fixnum", x);
	if (!fixp(y)) expect("div", "fixnum", y);
	if (0 == fixval(y)) error("div: divide by zero", UNDEF);
	return mkfix(fixval(x) / fixval(y));
}

// Assembly:
pushq %rbx
movl %edi, %eax
testl %edi, %edi
js 0x8eeb
movq 0xe4c6(%rip), %rdi      # 0x17350
movl %eax, %ecx
testb $0x1, (%rdi,%rcx)
je 0x8eeb
movl %esi, %edx
movq 0xe4a5(%rip), %rsi      # 0x17340
cmpl $-0xe, (%rsi,%rcx,4)
jne 0x8eeb
testl %edx, %edx
js 0x8f00
movl %edx, %eax
testb $0x1, (%rdi,%rax)
je 0x8f00
cmpl $-0xe, (%rsi,%rax,4)
jne 0x8f00
movq 0xe48e(%rip), %rdx      # 0x17348
movslq (%rdx,%rax,4), %rax
movl (%rsi,%rax,4), %edi
testl %edi, %edi
je 0x8f13
movslq (%rdx,%rcx,4), %rax
movl (%rsi,%rax,4), %eax
cltd
idivl %edi
pushq $-0x1
popq %rsi
pushq $0x1
popq %rbx
movl %eax, %edi
movl %ebx, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %ebx, %edx
popq %rbx
jmp 0x2f8c
leaq 0x7986(%rip), %rdi      # 0x10878
leaq 0x7976(%rip), %rsi      # 0x1086f
movl %eax, %edx
callq 0x2720
leaq 0x7971(%rip), %rdi      # 0x10878
leaq 0x7961(%rip), %rsi      # 0x1086f
callq 0x2720
leaq 0x7962(%rip), %rdi      # 0x1087c
pushq $-0x4
popq %rsi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: intrem
cell intrem(cell x, cell y) {
	if (!fixp(x)) expect("rem", "fixnum", x);
	if (!fixp(y)) expect("rem", "fixnum", y);
	if (0 == fixval(y)) error("rem: divide by zero", UNDEF);
	return mkfix(fixval(x) % fixval(y));
}

// Assembly:
pushq %rbx
movl %edi, %eax
testl %edi, %edi
js 0x8f91
movq 0xe420(%rip), %rdi      # 0x17350
movl %eax, %ecx
testb $0x1, (%rdi,%rcx)
je 0x8f91
movl %esi, %edx
movq 0xe3ff(%rip), %rsi      # 0x17340
cmpl $-0xe, (%rsi,%rcx,4)
jne 0x8f91
testl %edx, %edx
js 0x8fa6
movl %edx, %eax
testb $0x1, (%rdi,%rax)
je 0x8fa6
cmpl $-0xe, (%rsi,%rax,4)
jne 0x8fa6
movq 0xe3e8(%rip), %rdx      # 0x17348
movslq (%rdx,%rax,4), %rax
movl (%rsi,%rax,4), %edi
testl %edi, %edi
je 0x8fb9
movslq (%rdx,%rcx,4), %rax
movl (%rsi,%rax,4), %eax
cltd
idivl %edi
movl %edx, %edi
pushq $-0x1
popq %rsi
pushq $0x1
popq %rbx
movl %ebx, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %ebx, %edx
popq %rbx
jmp 0x2f8c
leaq 0x78f8(%rip), %rdi      # 0x10890
leaq 0x78d0(%rip), %rsi      # 0x1086f
movl %eax, %edx
callq 0x2720
leaq 0x78e3(%rip), %rdi      # 0x10890
leaq 0x78bb(%rip), %rsi      # 0x1086f
callq 0x2720
leaq 0x78d4(%rip), %rdi      # 0x10894
pushq $-0x4
popq %rsi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: bitop
cell bitop(cell x, cell y, cell o) {
	uint	op, a, b;
	int	i;

	if (!fixp(o)) expect("bitop", "fixnum", o);
	if (!fixp(x)) expect("bitop", "fixnum", x);
	if (!fixp(y)) expect("bitop", "fixnum", y);
	op = fixval(o);
	b = fixval(x);
	a = i = fixval(y);
	switch (op) {
	case  0: a =  0;        break;
	case  1: a =   a &  b;  break;
	case  2: a =   a & ~b;  break;
	case  3: /* a =   a; */ break;
	case  4: a =  ~a &  b;  break;
	case  5: a =        b;  break;
	case  6: a =   a ^  b;  break;
	case  7: a =   a |  b;  break;
	case  8: a = ~(a |  b); break;
	case  9: a = ~(a ^  b); break;
	case 10: a =       ~b;  break;
	case 11: a =   a | ~b;  break;
	case 12: a =  ~a;       break;
	case 13: a =  ~a |  b;  break;
	case 14: a = ~(a &  b); break;
	case 15: a = ~0;        break;
	case 16: a = a  <<  b;  break;
	case 17: a = i  >>  b;  break;
	case 18: a = a  >>  b;  break;
	default: error("bitop: invalid opcode", o);
		 break;
	}
	return mkfix(a);
}

// Assembly:
pushq %rbx
testl %edx, %edx
js 0x93d0
movl %edi, %ecx
movq 0xe074(%rip), %r8       # 0x17350
movl %edx, %edi
testb $0x1, (%r8,%rdi)
je 0x93d0
movl %esi, %eax
movq 0xe04e(%rip), %rsi      # 0x17340
cmpl $-0xe, (%rsi,%rdi,4)
jne 0x93d0
testl %ecx, %ecx
js 0x93e3
movl %ecx, %r9d
testb $0x1, (%r8,%r9)
je 0x93e3
cmpl $-0xe, (%rsi,%r9,4)
jne 0x93e3
testl %eax, %eax
js 0x93f8
movl %eax, %ecx
testb $0x1, (%r8,%rcx)
je 0x93f8
cmpl $-0xe, (%rsi,%rcx,4)
jne 0x93f8
movq 0xe005(%rip), %rax      # 0x17348
movslq (%rax,%rdi,4), %rdi
movl (%rsi,%rdi,4), %r8d
cmpq $0x12, %r8
ja 0x940d
movslq (%rax,%r9,4), %rdx
movl (%rsi,%rdx,4), %edi
movslq (%rax,%rcx,4), %rax
movl (%rsi,%rax,4), %eax
leaq 0x6cca(%rip), %rcx      # 0x10034
movslq (%rcx,%r8,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
xorl %edi, %edi
jmp 0x93b6
movl %edi, %ecx
shll %cl, %eax
jmp 0x93b4
andl %edi, %eax
jmp 0x938d
xorl %eax, %edi
notl %edi
jmp 0x93b6
notl %edi
jmp 0x93a8
orl %edi, %eax
notl %eax
jmp 0x93b4
pushq $-0x1
popq %rdi
jmp 0x93b6
notl %edi
jmp 0x93a2
movl %edi, %ecx
sarl %cl, %eax
jmp 0x93b4
notl %eax
andl %eax, %edi
jmp 0x93b6
notl %eax
orl %eax, %edi
jmp 0x93b6
xorl %eax, %edi
jmp 0x93b6
movl %edi, %ecx
shrl %cl, %eax
movl %eax, %edi
pushq $-0x1
popq %rsi
pushq $0x1
popq %rbx
movl %ebx, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %ebx, %edx
popq %rbx
jmp 0x2f8c
leaq 0x74d1(%rip), %rdi      # 0x108a8
leaq 0x7491(%rip), %rsi      # 0x1086f
callq 0x2720
leaq 0x74be(%rip), %rdi      # 0x108a8
leaq 0x747e(%rip), %rsi      # 0x1086f
movl %ecx, %edx
callq 0x2720
leaq 0x74a9(%rip), %rdi      # 0x108a8
leaq 0x7469(%rip), %rsi      # 0x1086f
movl %eax, %edx
callq 0x2720
leaq 0x749a(%rip), %rdi      # 0x108ae
movl %edx, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: memcmp_ci
int memcmp_ci(char *a, char *b, int k) {
	int	i, d;

	for (i=0; i<k; i++) {
		d = tolower(a[i]) - tolower(b[i]);
		if (d) return d;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
testl %edx, %edx
cmovlel %r12d, %ebx
cmpq %r12, %rbx
je 0x979a
callq 0x2220
movq (%rax), %rcx
movsbq (%r15,%r12), %rax
movl (%rcx,%rax,4), %eax
movsbq (%r14,%r12), %rdx
incq %r12
subl (%rcx,%rdx,4), %eax
je 0x9776
jmp 0x979c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: sequal
cell sequal(cell x, cell y) {
	if (!string(x)) expect("s=", "string", x);
	if (!string(y)) expect("s=", "string", y);
	if (stringlen(x) != stringlen(y)) return NIL;
	return scomp(x, y) == 0? TRUE: NIL;
}

// Assembly:
pushq %rax
movl %edi, %edx
movq 0xdafb(%rip), %rax      # 0x17358
testq %rax, %rax
je 0x9898
movslq %edx, %rcx
movslq %esi, %rdi
movq 0xdad9(%rip), %r8       # 0x17348
movslq (%r8,%rcx,4), %rcx
movl -0x4(%rax,%rcx,4), %ecx
movslq (%r8,%rdi,4), %rdi
cmpl -0x4(%rax,%rdi,4), %ecx
jne 0x9893
movl %edx, %edi
callq 0x971d
cmpl $0x1, %eax
pushq $-0x1
popq %rax
sbbl $0x0, %eax
jmp 0x9896
pushq $-0x1
popq %rax
popq %rcx
retq
leaq 0x703d(%rip), %rdi      # 0x108dc
leaq 0x6c87(%rip), %rsi      # 0x1052d
callq 0x2720
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: siequal
cell siequal(cell x, cell y) {
	if (!string(x)) expect("si=", "string", x);
	if (!string(y)) expect("si=", "string", y);
	if (stringlen(x) != stringlen(y)) return NIL;
	return scomp_ci(x, y) == 0? TRUE: NIL;
}

// Assembly:
pushq %rax
movl %edi, %edx
movq 0xd9d6(%rip), %rax      # 0x17358
testq %rax, %rax
je 0x99bd
movslq %edx, %rcx
movslq %esi, %rdi
movq 0xd9b4(%rip), %r8       # 0x17348
movslq (%r8,%rcx,4), %rcx
movl -0x4(%rax,%rcx,4), %ecx
movslq (%r8,%rdi,4), %rdi
cmpl -0x4(%rax,%rdi,4), %ecx
jne 0x99b8
movl %edx, %edi
callq 0x97a8
cmpl $0x1, %eax
pushq $-0x1
popq %rax
sbbl $0x0, %eax
jmp 0x99bb
pushq $-0x1
popq %rax
popq %rcx
retq
leaq 0x6f2b(%rip), %rdi      # 0x108ef
leaq 0x6b62(%rip), %rsi      # 0x1052d
callq 0x2720
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: b_mkstr
cell b_mkstr(cell x, cell a) {
	cell	n;
	int	i, c, k;
	byte	*s;

	if (!fixp(x)) expect("mkstr", "fixnum", x);
	if (!charp(a)) expect("mkstr", "char", a);
	c = charval(a);
	k = fixval(x);
	n = mkstr(NULL, k);
	s = string(n);
	for (i=0; i<k; i++) s[i] = c;
	return n;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %eax
testl %edi, %edi
js 0x9aca
movq 0xd907(%rip), %rdi      # 0x17350
movl %eax, %ecx
testb $0x1, (%rdi,%rcx)
je 0x9aca
movl %esi, %edx
movq 0xd8e6(%rip), %rsi      # 0x17340
cmpl $-0xe, (%rsi,%rcx,4)
jne 0x9aca
testl %edx, %edx
js 0x9adf
movl %edx, %eax
testb $0x1, (%rdi,%rax)
je 0x9adf
cmpl $-0xc, (%rsi,%rax,4)
jne 0x9adf
movq 0xd8cf(%rip), %rdx      # 0x17348
movslq (%rdx,%rax,4), %rax
movb (%rsi,%rax,4), %bpl
movslq (%rdx,%rcx,4), %rax
movl (%rsi,%rax,4), %ebx
xorl %r14d, %r14d
xorl %edi, %edi
movl %ebx, %esi
callq 0x2698
movq 0xd8ad(%rip), %rcx      # 0x17348
movslq %eax, %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0xd8ab(%rip), %rcx      # 0x17358
testl %ebx, %ebx
movl $0x0, %edx
cmovgl %ebx, %edx
cmpq %r14, %rdx
je 0x9ac5
movb %bpl, (%rcx,%r14)
incq %r14
jmp 0x9ab7
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6e2b(%rip), %rdi      # 0x108fc
leaq 0x6d97(%rip), %rsi      # 0x1086f
movl %eax, %edx
callq 0x2720
leaq 0x6e16(%rip), %rdi      # 0x108fc
leaq 0x6a4f(%rip), %rsi      # 0x1053c
callq 0x2720
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: sconc
cell sconc(cell x) {
	cell	p, n;
	int	k, m;
	byte	*s;

	k = 0;
	for (p = x; p != NIL; p = cdr(p)) {
		if (!stringp(car(p)))
			expect("sconc", "string", car(p));
		k += stringlen(car(p))-1;
	}
	n = mkstr(NULL, k);
	s = string(n);
	k = 0;
	for (p = x; p != NIL; p = cdr(p)) {
		m = stringlen(car(p));
		memcpy(&s[k], string(car(p)), m);
		k += m-1;
	}
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
movq 0xd83d(%rip), %rax      # 0x17340
movq 0xd846(%rip), %rcx      # 0x17350
movq 0xd847(%rip), %rdi      # 0x17358
xorl %esi, %esi
movq 0xd82e(%rip), %r8       # 0x17348
movl %ebx, %edx
cmpl $-0x1, %edx
je 0x9b57
movslq %edx, %r9
movslq (%rax,%r9,4), %rdx
testq %rdx, %rdx
js 0x9bcf
testb $0x8, (%rcx,%rdx)
je 0x9bcf
cmpl $-0x11, (%rax,%rdx,4)
jne 0x9bcf
movslq (%r8,%rdx,4), %rdx
movl -0x4(%rdi,%rdx,4), %edx
addl %edx, %esi
decl %esi
movl (%r8,%r9,4), %edx
jmp 0x9b1c
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x2698
movl %eax, %ebp
movq 0xd7de(%rip), %rax      # 0x17348
movslq %ebp, %rcx
movslq (%rax,%rcx,4), %r14
shlq $0x2, %r14
addq 0xd7dc(%rip), %r14      # 0x17358
cmpl $-0x1, %ebx
je 0x9bc4
movq 0xd7d0(%rip), %rcx      # 0x17358
movq 0xd7b1(%rip), %rdx      # 0x17340
movslq %ebx, %r12
movslq (%rdx,%r12,4), %rdx
movslq (%rax,%rdx,4), %rax
leaq (%rcx,%rax,4), %rsi
movslq -0x4(%rsi), %rbx
movslq %r15d, %r15
leaq (%r14,%r15), %rdi
movq %rbx, %rdx
callq 0x2140
addl %ebx, %r15d
decl %r15d
movq 0xd78a(%rip), %rax      # 0x17348
movl (%rax,%r12,4), %ebx
jmp 0x9b7c
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6d2c(%rip), %rdi      # 0x10902
leaq 0x6950(%rip), %rsi      # 0x1052d
callq 0x2720
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: sref
cell sref(cell s, cell n) {
	int	i;

	if (!stringp(s)) expect("sref", "string", s);
	if (!fixp(n)) expect("sref", "fixnum", n);
	i = fixval(n);
	if (i < 0 || i >= stringlen(s)-1)
		error("sref: index out of range", n);
	return mkchar(string(s)[i]);
}

// Assembly:
pushq %rbx
movl %edi, %eax
testl %edi, %edi
js 0x9c64
movq 0xd760(%rip), %rdi      # 0x17350
movl %eax, %ecx
testb $0x8, (%rdi,%rcx)
je 0x9c64
movl %esi, %edx
movq 0xd73f(%rip), %rsi      # 0x17340
cmpl $-0x11, (%rsi,%rcx,4)
jne 0x9c64
testl %edx, %edx
js 0x9c79
movl %edx, %eax
testb $0x1, (%rdi,%rax)
je 0x9c79
cmpl $-0xe, (%rsi,%rax,4)
jne 0x9c79
movq 0xd728(%rip), %rdi      # 0x17348
movslq (%rdi,%rax,4), %rax
movslq (%rsi,%rax,4), %rax
testq %rax, %rax
js 0x9c8c
movq 0xd724(%rip), %rsi      # 0x17358
movslq (%rdi,%rcx,4), %rcx
movl -0x4(%rsi,%rcx,4), %edi
decl %edi
cmpl %edi, %eax
jge 0x9c8c
leaq (%rsi,%rcx,4), %rcx
movzbl (%rcx,%rax), %edi
pushq $-0x1
popq %rsi
pushq $0x1
popq %rbx
movl %ebx, %edx
callq 0x2f8c
pushq $-0xc
popq %rdi
movl %eax, %esi
movl %ebx, %edx
popq %rbx
jmp 0x2f8c
leaq 0x6c9d(%rip), %rdi      # 0x10908
leaq 0x68bb(%rip), %rsi      # 0x1052d
movl %eax, %edx
callq 0x2720
leaq 0x6c88(%rip), %rdi      # 0x10908
leaq 0x6be8(%rip), %rsi      # 0x1086f
callq 0x2720
leaq 0x6c7a(%rip), %rdi      # 0x1090d
movl %edx, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: sset
void sset(cell s, cell n, cell r) {
	int	i;

	if (!stringp(s)) expect("sset", "string", s);
	if (constp(s)) error("sset: immutable", s);
	if (!fixp(n)) expect("sset", "fixnum", n);
	if (!charp(r)) expect("sset", "char", r);
	i = fixval(n);
	if (i < 0 || i >= stringlen(s)-1)
		error("sset: index out of range", n);
	string(s)[i] = charval(r);
}

// Assembly:
pushq %rax
movl %edi, %ecx
testl %edi, %edi
js 0x9d35
movq 0xd6a4(%rip), %r8       # 0x17350
movl %ecx, %edi
movb (%r8,%rdi), %r9b
testb $0x8, %r9b
je 0x9d35
movl %esi, %eax
movq 0xd67f(%rip), %rsi      # 0x17340
cmpl $-0x11, (%rsi,%rdi,4)
jne 0x9d35
testb %r9b, %r9b
js 0x9d80
testl %eax, %eax
js 0x9d4a
movl %eax, %r9d
testb $0x1, (%r8,%r9)
je 0x9d4a
cmpl $-0xe, (%rsi,%r9,4)
jne 0x9d4a
testl %edx, %edx
js 0x9d5f
movl %edx, %ecx
testb $0x1, (%r8,%rcx)
je 0x9d5f
cmpl $-0xc, (%rsi,%rcx,4)
jne 0x9d5f
movq 0xd649(%rip), %rdx      # 0x17348
movslq (%rdx,%r9,4), %r8
movslq (%rsi,%r8,4), %r8
testq %r8, %r8
js 0x9d72
movq 0xd645(%rip), %r9       # 0x17358
movslq (%rdx,%rdi,4), %rdi
movl -0x4(%r9,%rdi,4), %r10d
decl %r10d
cmpl %r10d, %r8d
jge 0x9d72
leaq (%r9,%rdi,4), %rax
movslq (%rdx,%rcx,4), %rcx
movb (%rsi,%rcx,4), %cl
movb %cl, (%rax,%r8)
popq %rax
retq
leaq 0x6bea(%rip), %rdi      # 0x10926
leaq 0x67ea(%rip), %rsi      # 0x1052d
movl %ecx, %edx
callq 0x2720
leaq 0x6bd5(%rip), %rdi      # 0x10926
leaq 0x6b17(%rip), %rsi      # 0x1086f
movl %eax, %edx
callq 0x2720
leaq 0x6bc0(%rip), %rdi      # 0x10926
leaq 0x67cf(%rip), %rsi      # 0x1053c
callq 0x2720
leaq 0x6bc2(%rip), %rdi      # 0x1093b
movl %eax, %esi
callq 0x258a
leaq 0x6ba4(%rip), %rdi      # 0x1092b
movl %ecx, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: substr
cell substr(cell s, cell n0, cell n1) {
	int	k, k0, k1, i, j;
	cell	n;
	byte	*s0, *s1;

	if (!stringp(s)) expect("substr", "string", s);
	if (!fixp(n0)) expect("substr", "fixnum", n0);
	if (!fixp(n1)) expect("substr", "fixnum", n1);
	k0 = fixval(n0);
	k1 = fixval(n1);
	if (k0 < 0 || k1 < 0 || k0 > k1 || k1 >= stringlen(s))
		error("substr: invalid range", cons(n0, cons(n1, NIL)));
	k = k1-k0;
	n = mkstr(NULL, k);
	j = 0;
	s0 = string(s);
	s1 = string(n);
	for (i=k0; i<k1; i++) {
		s1[j] = s0[i];
		j++;
	}
	s1[j] = 0;
	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %eax
testl %edi, %edi
js 0x9ea3
movl %esi, %ebx
movq 0xd5a7(%rip), %rsi      # 0x17350
movl %eax, %r15d
testb $0x8, (%rsi,%r15)
je 0x9ea3
movq 0xd582(%rip), %rcx      # 0x17340
cmpl $-0x11, (%rcx,%r15,4)
jne 0x9ea3
testl %ebx, %ebx
js 0x9eb8
movl %ebx, %eax
testb $0x1, (%rsi,%rax)
je 0x9eb8
cmpl $-0xe, (%rcx,%rax,4)
jne 0x9eb8
testl %edx, %edx
js 0x9ecd
movl %edx, %edi
testb $0x1, (%rsi,%rdi)
je 0x9ecd
cmpl $-0xe, (%rcx,%rdi,4)
jne 0x9ecd
movq 0xd53c(%rip), %rsi      # 0x17348
movslq (%rsi,%rax,4), %rax
movl (%rcx,%rax,4), %r12d
testl %r12d, %r12d
js 0x9ee0
movslq (%rsi,%rdi,4), %rax
movl (%rcx,%rax,4), %r14d
testl %r14d, %r14d
js 0x9ee0
cmpl %r12d, %r14d
jl 0x9ee0
movq 0xd51a(%rip), %rax      # 0x17358
movslq (%rsi,%r15,4), %rcx
cmpl -0x4(%rax,%rcx,4), %r14d
jge 0x9ee0
subl %r12d, %r14d
xorl %ebx, %ebx
xorl %edi, %edi
movl %r14d, %esi
callq 0x2698
movq 0xd4f5(%rip), %rsi      # 0x17358
movq 0xd4de(%rip), %rcx      # 0x17348
movslq (%rcx,%r15,4), %rdx
movslq %eax, %rdi
movslq (%rcx,%rdi,4), %rcx
leaq (%rsi,%rcx,4), %rcx
leaq (%r12,%rdx,4), %rdx
addq %rsi, %rdx
cmpq %rbx, %r14
je 0x9e92
movb (%rdx,%rbx), %sil
movb %sil, (%rcx,%rbx)
incq %rbx
jmp 0x9e80
movb $0x0, (%rcx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x6aaa(%rip), %rdi      # 0x10954
leaq 0x667c(%rip), %rsi      # 0x1052d
movl %eax, %edx
callq 0x2720
leaq 0x6a95(%rip), %rdi      # 0x10954
leaq 0x69a9(%rip), %rsi      # 0x1086f
movl %ebx, %edx
callq 0x2720
leaq 0x6a80(%rip), %rdi      # 0x10954
leaq 0x6994(%rip), %rsi      # 0x1086f
callq 0x2720
pushq $-0x1
popq %rsi
movl %edx, %edi
xorl %edx, %edx
callq 0x2f8c
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x2f8c
leaq 0x6a5d(%rip), %rdi      # 0x1095b
movl %eax, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: sfill
void sfill(cell x, cell a) {
	int	c, i, k;
	byte	*s;

	if (!stringp(x)) expect("sfill", "string", x);
	if (constp(x)) error("sfill: immutable", x);
	if (!charp(a)) expect("sfill", "char", a);
	c = charval(a);
	k = stringlen(x)-1;
	s = string(x);
	for (i=0; i<k; i++) s[i] = c;
}

// Assembly:
pushq %rax
movl %edi, %eax
testl %edi, %edi
js 0x9f81
movq 0xd43d(%rip), %rdi      # 0x17350
movl %eax, %ecx
movb (%rdi,%rcx), %r8b
testb $0x8, %r8b
je 0x9f81
movl %esi, %edx
movq 0xd418(%rip), %rsi      # 0x17340
cmpl $-0x11, (%rsi,%rcx,4)
jne 0x9f81
testb %r8b, %r8b
js 0x9fa9
testl %edx, %edx
js 0x9f96
movl %edx, %eax
testb $0x1, (%rdi,%rax)
je 0x9f96
cmpl $-0xc, (%rsi,%rax,4)
jne 0x9f96
movq 0xd3fc(%rip), %rdx      # 0x17348
movslq (%rdx,%rax,4), %rax
movb (%rsi,%rax,4), %al
movq 0xd3fe(%rip), %rsi      # 0x17358
movslq (%rdx,%rcx,4), %rcx
leaq (%rsi,%rcx,4), %rcx
movl -0x4(%rcx), %esi
cmpl $0x2, %esi
pushq $0x1
popq %rdx
cmovgel %esi, %edx
decl %edx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x9f7f
movb %al, (%rcx,%rsi)
incq %rsi
jmp 0x9f72
popq %rax
retq
leaq 0x69e9(%rip), %rdi      # 0x10971
leaq 0x659e(%rip), %rsi      # 0x1052d
movl %eax, %edx
callq 0x2720
leaq 0x69d4(%rip), %rdi      # 0x10971
leaq 0x6598(%rip), %rsi      # 0x1053c
callq 0x2720
leaq 0x69c7(%rip), %rdi      # 0x10977
movl %eax, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: b_mkvec
cell b_mkvec(cell x, cell a) {
	cell	n;
	int	i, k;
	cell	*v;

	if (!fixp(x)) expect("mkvec", "fixnum", x);
	k = fixval(x);
	n = mkvec(k);
	v = vector(n);
	for (i=0; i<k; i++) v[i] = a;
	return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %edx
testl %edi, %edi
js 0xa02d
movq 0xd388(%rip), %rcx      # 0x17350
movl %edx, %eax
testb $0x1, (%rcx,%rax)
je 0xa02d
movq 0xd369(%rip), %rcx      # 0x17340
cmpl $-0xe, (%rcx,%rax,4)
jne 0xa02d
movl %esi, %ebx
movq 0xd362(%rip), %rdx      # 0x17348
movslq (%rdx,%rax,4), %rax
movl (%rcx,%rax,4), %r14d
movl %r14d, %edi
callq 0x31ed
movq 0xd34b(%rip), %rcx      # 0x17348
movslq %eax, %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0xd349(%rip), %rcx      # 0x17358
xorl %edx, %edx
testl %r14d, %r14d
cmovlel %edx, %r14d
cmpq %rdx, %r14
je 0xa025
movl %ebx, (%rcx,%rdx,4)
incq %rdx
jmp 0xa018
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x6954(%rip), %rdi      # 0x10988
leaq 0x6834(%rip), %rsi      # 0x1086f
callq 0x2720
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: vconc
cell vconc(cell x) {
	cell	p, n, *v;
	int	k, m;

	k = 0;
	for (p = x; p != NIL; p = cdr(p)) {
		if (!vectorp(car(p)))
			expect("vconc", "vector", car(p));
		k += veclen(car(p));
	}
	n = mkvec(k);
	v = vector(n);
	k = 0;
	for (p = x; p != NIL; p = cdr(p)) {
		m = veclen(car(p));
		memcpy(&v[k], vector(car(p)), m*sizeof(cell));
		k += m;
	}
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
movq 0xd2ef(%rip), %rax      # 0x17340
movq 0xd2f8(%rip), %rcx      # 0x17350
movq 0xd2f9(%rip), %rsi      # 0x17358
xorl %edi, %edi
movq 0xd2e0(%rip), %r8       # 0x17348
movl %ebx, %edx
cmpl $-0x1, %edx
je 0xa0ac
movslq %edx, %r9
movslq (%rax,%r9,4), %rdx
testq %rdx, %rdx
js 0xa12a
testb $0x8, (%rcx,%rdx)
je 0xa12a
cmpl $-0x13, (%rax,%rdx,4)
jne 0xa12a
movslq (%r8,%rdx,4), %rdx
movslq -0x4(%rsi,%rdx,4), %rdx
addq $0x3, %rdx
shrq $0x2, %rdx
addl %edx, %edi
movl (%r8,%r9,4), %edx
jmp 0xa06a
callq 0x31ed
movl %eax, %ebp
movq 0xd28e(%rip), %rax      # 0x17348
movslq %ebp, %rcx
movslq (%rax,%rcx,4), %r14
shlq $0x2, %r14
addq 0xd28c(%rip), %r14      # 0x17358
xorl %r15d, %r15d
cmpl $-0x1, %ebx
je 0xa11f
movq 0xd27d(%rip), %rcx      # 0x17358
movq 0xd25e(%rip), %rdx      # 0x17340
movslq %ebx, %rbx
movslq (%rdx,%rbx,4), %rdx
movslq (%rax,%rdx,4), %rax
leaq (%rcx,%rax,4), %rsi
movslq -0x4(%rsi), %rdx
addq $0x3, %rdx
movq %rdx, %r12
shrq $0x2, %r12
movslq %r15d, %r15
leaq (%r14,%r15,4), %rdi
andq $-0x4, %rdx
callq 0x2140
addl %r12d, %r15d
movq 0xd22e(%rip), %rax      # 0x17348
movl (%rax,%rbx,4), %ebx
jmp 0xa0cf
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x685d(%rip), %rdi      # 0x1098e
leaq 0x685c(%rip), %rsi      # 0x10994
callq 0x2720
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: vref
cell vref(cell x, cell n) {
	int	i;

	if (!vectorp(x)) expect("vref", "vector", x);
	if (!fixp(n)) expect("vref", "fixnum", n);
	i = fixval(n);
	if (i < 0 || i >= veclen(x))
		error("vref: index out of range", n);
	return vector(x)[i];
}

// Assembly:
pushq %rax
movl %edi, %eax
testl %edi, %edi
js 0xa1ae
movq 0xd205(%rip), %rdi      # 0x17350
movl %eax, %ecx
testb $0x8, (%rdi,%rcx)
je 0xa1ae
movl %esi, %edx
movq 0xd1e4(%rip), %rsi      # 0x17340
cmpl $-0x13, (%rsi,%rcx,4)
jne 0xa1ae
testl %edx, %edx
js 0xa1c3
movl %edx, %eax
testb $0x1, (%rdi,%rax)
je 0xa1c3
cmpl $-0xe, (%rsi,%rax,4)
jne 0xa1c3
movq 0xd1cd(%rip), %rdi      # 0x17348
movslq (%rdi,%rax,4), %rax
movslq (%rsi,%rax,4), %rax
testq %rax, %rax
js 0xa1d6
movq 0xd1c9(%rip), %rsi      # 0x17358
movslq (%rdi,%rcx,4), %rcx
movslq -0x4(%rsi,%rcx,4), %rdi
addq $0x3, %rdi
shrq $0x2, %rdi
cmpq %rax, %rdi
jbe 0xa1d6
leaq (%rsi,%rcx,4), %rcx
movl (%rcx,%rax,4), %eax
popq %rcx
retq
leaq 0x67e6(%rip), %rdi      # 0x1099b
leaq 0x67d8(%rip), %rsi      # 0x10994
movl %eax, %edx
callq 0x2720
leaq 0x67d1(%rip), %rdi      # 0x1099b
leaq 0x669e(%rip), %rsi      # 0x1086f
callq 0x2720
leaq 0x67c3(%rip), %rdi      # 0x109a0
movl %edx, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: vfill
void vfill(cell x, cell a) {
	int	i, k;
	cell	*v;

	if (!vectorp(x)) expect("vfill", "vector", x);
	if (constp(x)) error("vfill: immutable", x);
	k = veclen(x);
	v = vector(x);
	for (i=0; i<k; i++) v[i] = a;
}

// Assembly:
pushq %rax
movl %edi, %edx
testl %edi, %edi
js 0xa245
movq 0xd15e(%rip), %rcx      # 0x17350
movl %edx, %eax
movb (%rcx,%rax), %cl
testb $0x8, %cl
je 0xa245
movq 0xd13d(%rip), %rdi      # 0x17340
cmpl $-0x13, (%rdi,%rax,4)
jne 0xa245
testb %cl, %cl
js 0xa258
movq 0xd144(%rip), %rcx      # 0x17358
movq 0xd12d(%rip), %rdx      # 0x17348
movslq (%rdx,%rax,4), %rax
leaq (%rcx,%rax,4), %rax
movslq -0x4(%rax), %rcx
addq $0x3, %rcx
shrq $0x2, %rcx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rdx, %rcx
je 0xa243
movl %esi, (%rax,%rdx,4)
incq %rdx
jmp 0xa236
popq %rax
retq
leaq 0x676d(%rip), %rdi      # 0x109b9
leaq 0x6741(%rip), %rsi      # 0x10994
callq 0x2720
leaq 0x6760(%rip), %rdi      # 0x109bf
movl %edx, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: vset
void vset(cell v, cell n, cell r) {
	int	i;

	if (!vectorp(v)) expect("vset", "vector", v);
	if (constp(v)) error("vset: immutable", v);
	if (!fixp(n)) expect("vset", "fixnum", n);
	i = fixval(n);
	if (i < 0 || i >= veclen(v))
		error("vset: index out of range", n);
	vector(v)[i] = r;
}

// Assembly:
pushq %rax
movl %edi, %ecx
testl %edi, %edi
js 0xa2e5
movl %esi, %eax
movq 0xd0da(%rip), %r8       # 0x17350
movl %ecx, %esi
movb (%r8,%rsi), %r9b
testb $0x8, %r9b
je 0xa2e5
movq 0xd0b7(%rip), %rdi      # 0x17340
cmpl $-0x13, (%rdi,%rsi,4)
jne 0xa2e5
testb %r9b, %r9b
js 0xa31d
testl %eax, %eax
js 0xa2fa
movl %eax, %ecx
testb $0x1, (%r8,%rcx)
je 0xa2fa
cmpl $-0xe, (%rdi,%rcx,4)
jne 0xa2fa
movq 0xd096(%rip), %r8       # 0x17348
movslq (%r8,%rcx,4), %rcx
movslq (%rdi,%rcx,4), %rcx
testq %rcx, %rcx
js 0xa30f
movq 0xd092(%rip), %rdi      # 0x17358
movslq (%r8,%rsi,4), %rsi
movslq -0x4(%rdi,%rsi,4), %r8
addq $0x3, %r8
shrq $0x2, %r8
cmpq %rcx, %r8
jbe 0xa30f
leaq (%rdi,%rsi,4), %rax
movl %edx, (%rax,%rcx,4)
popq %rax
retq
leaq 0x66e4(%rip), %rdi      # 0x109d0
leaq 0x66a1(%rip), %rsi      # 0x10994
movl %ecx, %edx
callq 0x2720
leaq 0x66cf(%rip), %rdi      # 0x109d0
leaq 0x6567(%rip), %rsi      # 0x1086f
movl %eax, %edx
callq 0x2720
leaq 0x66cf(%rip), %rdi      # 0x109e5
movl %eax, %esi
callq 0x258a
leaq 0x66b1(%rip), %rdi      # 0x109d5
movl %ecx, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: subvec
cell subvec(cell v, cell n0, cell n1) {
	int	k, k0, k1, i, j;
	cell	n;
	cell	*v0, *v1;

	if (!vectorp(v)) expect("subvec", "vector", v);
	if (!fixp(n0)) expect("subvec", "fixnum", n0);
	if (!fixp(n1)) expect("subvec", "fixnum", n1);
	k0 = fixval(n0);
	k1 = fixval(n1);
	if (k0 < 0 || k1 < 0 || k0 > k1 || k1 > veclen(v))
		error("subvec: invalid range", cons(n0, cons(n1, NIL)));
	k = k1-k0;
	n = mkvec(k);
	j = 0;
	v0 = vector(v);
	v1 = vector(n);
	for (i=k0; i<k1; i++) {
		v1[j] = v0[i];
		j++;
	}
	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %eax
testl %edi, %edi
js 0xa446
movl %esi, %ebx
movq 0xd00a(%rip), %rsi      # 0x17350
movl %eax, %r15d
testb $0x8, (%rsi,%r15)
je 0xa446
movq 0xcfe5(%rip), %rcx      # 0x17340
cmpl $-0x13, (%rcx,%r15,4)
jne 0xa446
testl %ebx, %ebx
js 0xa45b
movl %ebx, %eax
testb $0x1, (%rsi,%rax)
je 0xa45b
cmpl $-0xe, (%rcx,%rax,4)
jne 0xa45b
testl %edx, %edx
js 0xa470
movl %edx, %edi
testb $0x1, (%rsi,%rdi)
je 0xa470
cmpl $-0xe, (%rcx,%rdi,4)
jne 0xa470
movq 0xcf9f(%rip), %rsi      # 0x17348
movslq (%rsi,%rax,4), %rax
movl (%rcx,%rax,4), %r12d
testl %r12d, %r12d
js 0xa483
movslq (%rsi,%rdi,4), %rax
movl (%rcx,%rax,4), %r14d
testl %r14d, %r14d
js 0xa483
cmpl %r12d, %r14d
jl 0xa483
movq 0xcf7d(%rip), %rax      # 0x17358
movslq (%rsi,%r15,4), %rcx
movslq -0x4(%rax,%rcx,4), %rax
addq $0x3, %rax
shrq $0x2, %rax
cmpq %r14, %rax
jb 0xa483
subl %r12d, %r14d
movl %r14d, %edi
callq 0x31ed
movq 0xcf51(%rip), %rsi      # 0x17358
movq 0xcf3a(%rip), %rcx      # 0x17348
movslq (%rcx,%r15,4), %rdx
movslq %eax, %rdi
movslq (%rcx,%rdi,4), %rcx
leaq (%rsi,%rcx,4), %rcx
shlq $0x2, %r12
leaq (%r12,%rdx,4), %rdx
addq %rsi, %rdx
xorl %esi, %esi
cmpq %rsi, %r14
je 0xa43a
movl (%rdx,%rsi,4), %edi
movl %edi, (%rcx,%rsi,4)
incq %rsi
jmp 0xa42a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x65b1(%rip), %rdi      # 0x109fe
leaq 0x6540(%rip), %rsi      # 0x10994
movl %eax, %edx
callq 0x2720
leaq 0x659c(%rip), %rdi      # 0x109fe
leaq 0x6406(%rip), %rsi      # 0x1086f
movl %ebx, %edx
callq 0x2720
leaq 0x6587(%rip), %rdi      # 0x109fe
leaq 0x63f1(%rip), %rsi      # 0x1086f
callq 0x2720
pushq $-0x1
popq %rsi
movl %edx, %edi
xorl %edx, %edx
callq 0x2f8c
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x2f8c
leaq 0x6564(%rip), %rdi      # 0x10a05
movl %eax, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: existsp
cell existsp(char *s) {
	FILE	*f;

	f = fopen(s, "r");
	if (f != NULL) fclose(f);
	return NULL == f? NIL: TRUE;
}

// Assembly:
pushq %rax
leaq 0x6815(%rip), %rsi      # 0x10cc5
callq 0x21c0
testq %rax, %rax
je 0xa4c6
movq %rax, %rdi
callq 0x2070
pushq $-0x2
jmp 0xa4c8
pushq $-0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: openfile
cell openfile(cell x, int mode) {
	int	p;

	switch (mode) {
	case 0:
		p = open_inport((char *) string(x));
		break;
	case 1:
		p = open_outport((char *) string(x), 0);
		break;
	case 2:
		p = open_outport((char *) string(x), 1);
		break;
	}
	if (p < 0) {
		if (0 == mode)
			error("open-infile: cannot open", x);
		else
			error("open-outfile: cannot open", x);
	}
	return mkport(p, 0 == mode? T_INPORT: T_OUTPORT);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movq 0xce6f(%rip), %rax      # 0x17348
movslq %edi, %rcx
movslq (%rax,%rcx,4), %rdi
shlq $0x2, %rdi
addq 0xce6d(%rip), %rdi      # 0x17358
testl %esi, %esi
je 0xa50b
xorl %esi, %esi
cmpl $0x1, %ebx
je 0xa4f9
pushq $0x1
popq %rsi
callq 0x3bc5
testl %eax, %eax
jns 0xa514
leaq 0x652b(%rip), %rdi      # 0x10a34
jmp 0xa533
callq 0x3b7d
testl %eax, %eax
js 0xa52c
xorl %esi, %esi
testl %ebx, %ebx
sete %sil
orl $-0x10, %esi
movl %eax, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x284f
leaq 0x64e8(%rip), %rdi      # 0x10a1b
movl %ebp, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: b_readc
cell b_readc(cell p, int rej) {
	int	pp, c;

	pp = Inport;
	if (p != pp) set_inport(p);
	c = readc();
	if (rej) rejectc(c);
	if (p != pp) set_inport(pp);
	if (EOF == c) return EOFMARK;
	return mkchar(c);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movl %edi, %ebp
movl 0xcffb(%rip), %r15d     # 0x17548
cmpl %edi, %r15d
je 0xa558
movl %ebp, 0xcff0(%rip)      # 0x17548
callq 0x278c
movl %eax, %ebx
testl %r14d, %r14d
je 0xa56b
movl %ebx, %edi
callq 0x27ec
cmpl %ebp, %r15d
je 0xa577
movl %r15d, 0xcfd1(%rip)     # 0x17548
cmpl $-0x1, %ebx
je 0xa5a2
movzbl %bl, %edi
pushq $-0x1
popq %rsi
pushq $0x1
popq %rbx
movl %ebx, %edx
callq 0x2f8c
pushq $-0xc
popq %rdi
movl %eax, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2f8c
pushq $-0x3
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: b_read
cell b_read(cell ps) {
	int	pp;
	cell	n;

	if (stringp(ps)) {
		Instr = (char *) string(ps);
		Rejected = -1;
		n = xread();
		Instr = NULL;
		if (Readerr) return mkstr(Readerr, strlen(Readerr));
		return cons(n, NIL);
	}
	ps = portno(ps);
	pp = Inport;
	if (ps != pp) set_inport(ps);
	n = xread();
	if (ps != pp) set_inport(pp);
	return n;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testl %edi, %edi
js 0xa628
movq 0xcd92(%rip), %rax      # 0x17350
movl %edi, %ecx
testb $0x8, (%rax,%rcx)
movq 0xcd75(%rip), %rax      # 0x17340
je 0xa62f
cmpl $-0x11, (%rax,%rcx,4)
jne 0xa62f
movq 0xcd6e(%rip), %rax      # 0x17348
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq 0xcd6f(%rip), %rax      # 0x17358
movq %rax, 0xcf68(%rip)      # 0x17558
movb $-0x1, 0xcb5d(%rip)     # 0x17154
callq 0x4a47
andq $0x0, 0xcf54(%rip)      # 0x17558
movq 0xd01d(%rip), %rbx      # 0x17628
testq %rbx, %rbx
je 0xa666
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2698
movq 0xcd11(%rip), %rax      # 0x17340
movq 0xcd12(%rip), %rcx      # 0x17348
movslq %edi, %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %ebp
movl 0xcf02(%rip), %ebx      # 0x17548
cmpl %ebx, %ebp
je 0xa650
movl %ebp, 0xcef8(%rip)      # 0x17548
callq 0x4a47
cmpl %ebx, %ebp
je 0xa65f
movl %ebx, 0xcee9(%rip)      # 0x17548
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq $-0x1
popq %rsi
movl %eax, %edi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2f8c
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: b_prin
void b_prin(cell x, int p, int sl) {
	int	pp;

	pp = Outport;
	if (p != pp) set_outport(p);
	prex(sl, x, 0);
	if (p != pp) set_outport(pp);
}

// Assembly:
pushq %rbx
movl %edi, %eax
movl 0xcac7(%rip), %ebx      # 0x17148
cmpl %esi, %ebx
jne 0xa691
movl %edx, %edi
movl %eax, %esi
xorl %edx, %edx
popq %rbx
jmp 0x4d2d
movl %esi, 0xcab1(%rip)      # 0x17148
movl %edx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x4d2d
movl %ebx, 0xcaa0(%rip)      # 0x17148
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: format
cell format(cell x) {
	cell	n;

	Outstr = mkstr(NULL, 1000);
	Outmax = 1000;
	Outptr = 0;
	prex(1, x, 0);
	n = mkstr(NULL, Outptr);
	memcpy(string(n), string(Outstr), Outptr+1);
	Outstr = NIL;
	return n;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
xorl %edi, %edi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x2698
movl %eax, 0xca91(%rip)      # 0x17150
movl $0x3e8, 0xce83(%rip)    # imm = 0x3E8
andl $0x0, 0xce80(%rip)      # 0x17550
pushq $0x1
popq %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x4d2d
movl 0xce6e(%rip), %esi      # 0x17550
xorl %edi, %edi
callq 0x2698
movq 0xcc68(%rip), %rcx      # 0x17358
movq 0xcc51(%rip), %rdx      # 0x17348
movslq %eax, %rbx
movslq (%rdx,%rbx,4), %rax
leaq (%rcx,%rax,4), %rdi
movslq 0xca47(%rip), %rax      # 0x17150
movslq (%rdx,%rax,4), %rax
leaq (%rcx,%rax,4), %rsi
movslq 0xce38(%rip), %rdx      # 0x17550
incq %rdx
callq 0x2140
orl $-0x1, 0xca29(%rip)     # 0x17150
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: b_writec
void b_writec(int c, cell p) {
	int	pp;

	pp = Outport;
	if (p != pp) set_outport(p);
	writec(c);
	if (p != pp) set_outport(pp);
}

// Assembly:
pushq %rbx
movl 0xca16(%rip), %ebx      # 0x17148
cmpl %esi, %ebx
jne 0xa73c
popq %rbx
jmp 0x2a1c
movl %esi, 0xca06(%rip)      # 0x17148
callq 0x2a1c
movl %ebx, 0xc9fb(%rip)      # 0x17148
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: b_rename
void b_rename(int old, int new) {
	if (!stringp(old)) expect("rename", "string", old);
	if (!stringp(new)) expect("rename", "string", new);
	if (rename((char *) string(old), (char *) string(new)) < 0)
		error("rename: cannot rename",
			cons(old, cons(new, NIL)));
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %edi, %edi
js 0xa7b6
movq 0xcbf1(%rip), %rcx      # 0x17350
movl %ebx, %eax
testb $0x8, (%rcx,%rax)
je 0xa7b6
movq 0xcbd2(%rip), %rdx      # 0x17340
cmpl $-0x11, (%rdx,%rax,4)
jne 0xa7b6
movl %esi, %ebp
testl %esi, %esi
js 0xa7cb
movl %ebp, %esi
testb $0x8, (%rcx,%rsi)
je 0xa7cb
cmpl $-0x11, (%rdx,%rsi,4)
jne 0xa7cb
movq 0xcbc9(%rip), %rcx      # 0x17358
movq 0xcbb2(%rip), %rdx      # 0x17348
movslq (%rdx,%rax,4), %rax
leaq (%rcx,%rax,4), %rdi
movslq (%rdx,%rsi,4), %rax
leaq (%rcx,%rax,4), %rsi
callq 0x21d0
testl %eax, %eax
js 0xa7e0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x62a0(%rip), %rdi      # 0x10a5d
leaq 0x5d69(%rip), %rsi      # 0x1052d
movl %ebx, %edx
callq 0x2720
leaq 0x628b(%rip), %rdi      # 0x10a5d
leaq 0x5d54(%rip), %rsi      # 0x1052d
movl %ebp, %edx
callq 0x2720
pushq $-0x1
popq %rsi
movl %ebp, %edi
xorl %edx, %edx
callq 0x2f8c
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x2f8c
leaq 0x6250(%rip), %rdi      # 0x10a4e
movl %eax, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: lconc
cell lconc(cell x) {
	cell	p, q, n, m;
	int	k;

	if (NIL == cdr(x)) return car(x);
	protect(n = cons(NIL, NIL));
	k = 0;
	for (p = x; cdr(p) != NIL; p = cdr(p)) {
		if (NIL == car(p)) continue;
		for (q = car(p); q != NIL; q = cdr(q)) {
			if (!pairp(q))
				expect("conc", "list", car(p));
			if (k != 0) {
				m = cons(NIL, NIL);
				cdr(n) = m;
				n = cdr(n);
			}
			car(n) = car(q);
			k++;
		}
	}
	m = unprot(1);
	if (0 == k) return car(p);
	cdr(n) = car(p);
	return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0xcb34(%rip), %rcx      # 0x17348
movslq %edi, %rax
cmpl $-0x1, (%rcx,%rax,4)
je 0xa8fc
movl %edi, %r14d
pushq $-0x1
popq %rbp
xorl %r15d, %r15d
movl %ebp, %edi
movl %ebp, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebx
movl 0xc933(%rip), %esi      # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xc924(%rip)      # 0x17170
movq 0xcaf5(%rip), %rcx      # 0x17348
movq 0xcae6(%rip), %rdx      # 0x17340
movslq %r14d, %r12
movl (%rcx,%r12,4), %r14d
cmpl $-0x1, %r14d
je 0xa8d1
movl (%rdx,%r12,4), %eax
cmpl $-0x1, %eax
je 0xa85a
jmp 0xa8c6
testl %eax, %eax
js 0xa90f
movq 0xcacf(%rip), %rsi      # 0x17350
movl %eax, %r14d
testb $0x9, (%rsi,%r14)
jne 0xa90f
testl %r15d, %r15d
je 0xa8b5
movl %ebp, %edi
movl %ebp, %esi
xorl %edx, %edx
callq 0x2f8c
movslq %ebx, %rdx
movq 0xca9f(%rip), %rcx      # 0x17348
movl %eax, (%rcx,%rdx,4)
movq 0xca8d(%rip), %rdx      # 0x17340
movl %eax, %ebx
movl (%rdx,%r14,4), %eax
movslq %ebx, %rsi
movl %eax, (%rdx,%rsi,4)
incl %r15d
movl (%rcx,%r14,4), %eax
cmpl $-0x1, %eax
jne 0xa872
movl (%rcx,%r12,4), %r14d
jmp 0xa853
pushq $0x1
popq %rdi
callq 0x31a9
movl %eax, %ecx
movq 0xca5e(%rip), %rax      # 0x17340
movl (%rax,%r12,4), %eax
testl %r15d, %r15d
je 0xa906
movq 0xca56(%rip), %rdx      # 0x17348
movslq %ebx, %rsi
movl %eax, (%rdx,%rsi,4)
movl %ecx, %eax
jmp 0xa906
movq 0xca3d(%rip), %rcx      # 0x17340
movl (%rcx,%rax,4), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl (%rdx,%r12,4), %edx
leaq 0x64e1(%rip), %rdi      # 0x10dfb
leaq 0x6359(%rip), %rsi      # 0x10c7a
callq 0x2720
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: nlconc
cell nlconc(cell x) {
	cell	p, q;

	while (pairp(cdr(x)) && NIL == car(x)) x = cdr(x);
	if (NIL == cdr(x)) return car(x);
	for (p = x; cdr(p) != NIL; p = cdr(p)) {
		if (NIL == car(p)) continue;
		if (constp(car(p))) error("nconc: immutable", car(p));
		for (q = car(p); cdr(q) != NIL; q = cdr(q)) {
			if (!pairp(q))
				expect("nconc", "list", car(p));
		}
		while (pairp(cdr(p)) && NIL == cadr(p))
			p = cdr(p);
		if (NIL == cdr(p)) break;
		cdr(q) = cadr(p);
	}
	return car(x);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0xca16(%rip), %rdx      # 0x17348
movq 0xca17(%rip), %r8       # 0x17350
movq 0xca00(%rip), %rax      # 0x17340
movl %edi, %r9d
movslq %edi, %rcx
movslq (%rdx,%rcx,4), %rdi
testq %rdi, %rdi
js 0xa95e
testb $0x9, (%r8,%rdi)
jne 0xa967
cmpl $-0x1, (%rax,%rcx,4)
je 0xa940
jmp 0xa967
cmpl $-0x1, %edi
je 0xaa03
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
movq %rax, %r10
cmpl $-0x1, %edi
je 0xa9fc
movslq %r9d, %r14
movl (%rax,%r14,4), %esi
cmpq %r11, %rsi
je 0xa9ee
testl %esi, %esi
js 0xa994
cmpb $0x0, (%r8,%rsi)
js 0xaa28
movq 0xc9b5(%rip), %rdi      # 0x17350
movq 0xc9a6(%rip), %r15      # 0x17348
movslq %esi, %rbx
cmpl $-0x1, (%rdx,%rbx,4)
je 0xa9bb
testl %esi, %esi
js 0xaa11
testb $0x9, (%rdi,%rbx)
jne 0xaa11
movl (%r15,%rbx,4), %esi
jmp 0xa9a2
movq 0xc97e(%rip), %r10      # 0x17340
movslq %r9d, %rsi
movslq (%rdx,%rsi,4), %r9
testq %r9, %r9
js 0xa9de
testb $0x9, (%rdi,%r9)
jne 0xa9e4
cmpl $-0x1, (%r10,%r9,4)
je 0xa9c2
jmp 0xa9e4
cmpl $-0x1, %r9d
je 0xaa0c
movl (%rax,%r9,4), %edi
movl %edi, (%rdx,%rbx,4)
movl (%rdx,%rsi,4), %edi
movl %edi, %r9d
movslq %edi, %rsi
movl (%rdx,%rsi,4), %edi
jmp 0xa970
movq 0xc93d(%rip), %rax      # 0x17340
movl (%rax,%rcx,4), %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r10, %rax
jmp 0xaa03
movl (%r10,%r14,4), %edx
leaq 0x6059(%rip), %rdi      # 0x10a75
leaq 0x6257(%rip), %rsi      # 0x10c7a
callq 0x2720
leaq 0x6035(%rip), %rdi      # 0x10a64
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: b_symbol
cell b_symbol(cell x) {
	cell	y, n, k;

	y = findsym((char *) string(x));
	if (y != NIL) return y;
	/*
	 * Cannot pass content to mksym(), because
	 * string(x) may move during GC.
	 */
	k = stringlen(x);
	n = mksym("", k-1);
	memcpy(symname(n), string(x), k);
	return intern(n);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0xc905(%rip), %rax      # 0x17348
movslq %edi, %r12
movslq (%rax,%r12,4), %rdi
shlq $0x2, %rdi
addq 0xc903(%rip), %rdi      # 0x17358
callq 0x38b2
movl %eax, %ebx
cmpl $-0x1, %eax
jne 0xaabb
movq 0xc8f0(%rip), %rax      # 0x17358
movq 0xc8d9(%rip), %rcx      # 0x17348
movslq (%rcx,%r12,4), %rcx
movslq -0x4(%rax,%rcx,4), %r14
leal -0x1(%r14), %esi
leaq 0x6746(%rip), %rdi      # 0x111c9
callq 0x3875
movl %eax, %ebx
movq 0xc8c7(%rip), %rax      # 0x17358
movq 0xc8b0(%rip), %rcx      # 0x17348
movslq %ebx, %r15
movslq (%rcx,%r15,4), %rdx
leaq (%rax,%rdx,4), %rdi
movslq (%rcx,%r12,4), %rcx
leaq (%rax,%rcx,4), %rsi
movq %r14, %rdx
callq 0x2140
movl %r15d, %edi
callq 0x38ea
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq