LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x68, %rsp
movl %edi, %ebx
movq 0xe5a7(%rip), %rcx      # 0x19358
testq %rcx, %rcx
je 0xadfc
movslq %ebx, %rax
movslq %esi, %rdi
movq 0xe585(%rip), %r8       # 0x19348
movslq (%r8,%rax,4), %rsi
movslq -0x4(%rcx,%rsi,4), %rdx
movslq (%r8,%rdi,4), %r8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x4(%rcx,%r8,4), %edx
jne 0xadf4
leaq (%rcx,%rsi,4), %rdi
leaq (%rcx,%r8,4), %rsi
callq 0x2190
cmpl $0x1, %eax
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
sbbl $0x0, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x8548(%rip), %rsi      # 0x1334b
leaq 0x8b12(%rip), %rdx      # 0x1391c
leaq 0x875c(%rip), %rcx      # 0x1356d
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x68, %rsp
movl %edi, %ebx
movq 0xe2eb(%rip), %rcx      # 0x19358
testq %rcx, %rcx
je 0xb0b7
movslq %ebx, %rax
movslq %esi, %rdi
movq 0xe2c9(%rip), %r8       # 0x19348
movslq (%r8,%rax,4), %rsi
movl -0x4(%rcx,%rsi,4), %edx
movslq (%r8,%rdi,4), %r8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x4(%rcx,%r8,4), %edx
jne 0xb0af
leaq (%rcx,%rsi,4), %rdi
leaq (%rcx,%r8,4), %rsi
callq 0xac04
cmpl $0x1, %eax
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
sbbl $0x0, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x828d(%rip), %rsi      # 0x1334b
leaq 0x886a(%rip), %rdx      # 0x1392f
leaq 0x84a1(%rip), %rcx      # 0x1356d
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x70, %rsp
movl %edi, %ebp
testl %edi, %edi
js 0xb2a4
movq 0xe13a(%rip), %rdx      # 0x19350
movl %ebp, %eax
testb $0x1, (%rdx,%rax)
je 0xb2a4
movq 0xe117(%rip), %rcx      # 0x19340
cmpl $-0xe, (%rcx,%rax,4)
jne 0xb2a4
movl %esi, %ebx
testl %esi, %esi
js 0xb2d0
movl %ebx, %esi
testb $0x1, (%rdx,%rsi)
je 0xb2d0
cmpl $-0xc, (%rcx,%rsi,4)
jne 0xb2d0
movq 0xe0f2(%rip), %rdx      # 0x19348
movslq (%rdx,%rsi,4), %rsi
movl (%rcx,%rsi,4), %ebx
movslq (%rdx,%rax,4), %rax
movslq (%rcx,%rax,4), %r14
xorl %edi, %edi
movl %r14d, %esi
callq 0x27b0
movl %eax, %ebp
testq %r14, %r14
jle 0xb299
movq 0xe0cb(%rip), %rax      # 0x19348
movslq %ebp, %rcx
movslq (%rax,%rcx,4), %rdi
shlq $0x2, %rdi
addq 0xe0c9(%rip), %rdi      # 0x19358
movl %ebx, %esi
movq %r14, %rdx
callq 0x20b0
movl %ebp, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x80a0(%rip), %rsi      # 0x1334b
leaq 0x868a(%rip), %rdx      # 0x1393c
leaq 0x85f6(%rip), %rcx      # 0x138af
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2643
leaq 0x8074(%rip), %rsi      # 0x1334b
leaq 0x865e(%rip), %rdx      # 0x1393c
leaq 0x8297(%rip), %rcx      # 0x1357c
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x70, %rsp
movl %edi, %ebx
cmpl $-0x1, %edi
je 0xb370
movq 0xe02a(%rip), %rax      # 0x19340
movq 0xe033(%rip), %rcx      # 0x19350
movq 0xe034(%rip), %rdx      # 0x19358
xorl %esi, %esi
movq 0xe01b(%rip), %rdi      # 0x19348
movl %ebx, %r8d
movslq %r8d, %r8
movslq (%rax,%r8,4), %r14
testq %r14, %r14
js 0xb3f1
testb $0x8, (%rcx,%r14)
je 0xb3f1
cmpl $-0x11, (%rax,%r14,4)
jne 0xb3f1
movslq (%rdi,%r14,4), %r9
movl -0x4(%rdx,%r9,4), %r9d
addl %r9d, %esi
decl %esi
movl (%rdi,%r8,4), %r8d
cmpl $-0x1, %r8d
jne 0xb330
jmp 0xb372
xorl %esi, %esi
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x27b0
movl %eax, %ebp
cmpl $-0x1, %ebx
je 0xb3e2
movq 0xdfbe(%rip), %rax      # 0x19348
movslq %ebp, %rcx
movslq (%rax,%rcx,4), %r15
shlq $0x2, %r15
addq 0xdfbc(%rip), %r15      # 0x19358
movq 0xdfb5(%rip), %rcx      # 0x19358
movq 0xdf96(%rip), %rdx      # 0x19340
movslq %ebx, %r12
movslq (%rdx,%r12,4), %rdx
movslq (%rax,%rdx,4), %rax
leaq (%rcx,%rax,4), %rsi
movslq -0x4(%rsi), %rbx
movslq %r14d, %r14
leaq (%r15,%r14), %rdi
movq %rbx, %rdx
callq 0x2140
addl %ebx, %r14d
decl %r14d
movq 0xdf6f(%rip), %rax      # 0x19348
movl (%rax,%r12,4), %ebx
cmpl $-0x1, %ebx
jne 0xb39c
movl %ebp, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7f53(%rip), %rsi      # 0x1334b
leaq 0x8543(%rip), %rdx      # 0x13942
leaq 0x8167(%rip), %rcx      # 0x1356d
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edi, %ebp
testl %edi, %edi
js 0xb4d5
movq 0xdf19(%rip), %rdx      # 0x19350
movl %ebp, %eax
testb $0x8, (%rdx,%rax)
je 0xb4d5
movq 0xdef6(%rip), %rcx      # 0x19340
cmpl $-0x11, (%rcx,%rax,4)
jne 0xb4d5
movl %esi, %ebx
testl %esi, %esi
js 0xb501
movl %ebx, %esi
testb $0x1, (%rdx,%rsi)
je 0xb501
cmpl $-0xe, (%rcx,%rsi,4)
jne 0xb501
movq 0xdecd(%rip), %rdx      # 0x19348
movslq (%rdx,%rsi,4), %rsi
movslq (%rcx,%rsi,4), %rcx
testq %rcx, %rcx
js 0xb528
movq 0xdec5(%rip), %rsi      # 0x19358
movslq (%rdx,%rax,4), %rax
movl -0x4(%rsi,%rax,4), %edx
decl %edx
cmpl %edx, %ecx
jge 0xb528
leaq (%rsi,%rax,4), %rax
movzbl (%rax,%rcx), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff4, %edi       # imm = 0xFFFFFFF4
movl %eax, %esi
movl $0x1, %edx
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x30e7
leaq 0x7e6f(%rip), %rsi      # 0x1334b
leaq 0x8465(%rip), %rdx      # 0x13948
leaq 0x8083(%rip), %rcx      # 0x1356d
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2643
leaq 0x7e43(%rip), %rsi      # 0x1334b
leaq 0x8439(%rip), %rdx      # 0x13948
leaq 0x8399(%rip), %rcx      # 0x138af
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
jmp 0xb52f
leaq 0x841e(%rip), %rdi      # 0x1394d
movl %ebx, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edi, %r14d
testl %edi, %edi
js 0xb606
movl %edx, %ebp
movl %esi, %ebx
movq 0xddfc(%rip), %rdx      # 0x19350
movl %r14d, %ecx
movb (%rdx,%rcx), %sil
testb $0x8, %sil
je 0xb606
movq 0xddd4(%rip), %rax      # 0x19340
cmpl $-0x11, (%rax,%rcx,4)
jne 0xb606
testb %sil, %sil
js 0xb68e
testl %ebx, %ebx
js 0xb62d
movl %ebx, %edi
testb $0x1, (%rdx,%rdi)
je 0xb62d
cmpl $-0xe, (%rax,%rdi,4)
jne 0xb62d
testl %ebp, %ebp
js 0xb654
movl %ebp, %esi
testb $0x1, (%rdx,%rsi)
je 0xb654
cmpl $-0xc, (%rax,%rsi,4)
jne 0xb654
movq 0xdd86(%rip), %rdx      # 0x19348
movslq (%rdx,%rdi,4), %rdi
movslq (%rax,%rdi,4), %rdi
testq %rdi, %rdi
js 0xb680
movq 0xdd7e(%rip), %r8       # 0x19358
movslq (%rdx,%rcx,4), %rcx
movl -0x4(%r8,%rcx,4), %r9d
decl %r9d
cmpl %r9d, %edi
jge 0xb680
leaq (%r8,%rcx,4), %rcx
movslq (%rdx,%rsi,4), %rdx
movb (%rax,%rdx,4), %al
movb %al, (%rcx,%rdi)
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7d3e(%rip), %rsi      # 0x1334b
leaq 0x8352(%rip), %rdx      # 0x13966
leaq 0x7f52(%rip), %rcx      # 0x1356d
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
jmp 0xb695
leaq 0x7d17(%rip), %rsi      # 0x1334b
leaq 0x832b(%rip), %rdx      # 0x13966
leaq 0x826d(%rip), %rcx      # 0x138af
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
jmp 0xb687
leaq 0x7cf0(%rip), %rsi      # 0x1334b
leaq 0x8304(%rip), %rdx      # 0x13966
leaq 0x7f13(%rip), %rcx      # 0x1357c
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2643
leaq 0x82f4(%rip), %rdi      # 0x1397b
movl %ebx, %esi
callq 0x2643
leaq 0x82d6(%rip), %rdi      # 0x1396b
movl %r14d, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %edi, %r14d
testl %edi, %edi
js 0xb7c1
movq 0xdc95(%rip), %rcx      # 0x19350
movl %r14d, %r15d
testb $0x8, (%rcx,%r15)
je 0xb7c1
movq 0xdc70(%rip), %rax      # 0x19340
cmpl $-0x11, (%rax,%r15,4)
jne 0xb7c1
movl %esi, %ebx
testl %esi, %esi
js 0xb7ee
movl %edx, %ebp
movl %ebx, %edx
testb $0x1, (%rcx,%rdx)
je 0xb7ee
cmpl $-0xe, (%rax,%rdx,4)
jne 0xb7ee
testl %ebp, %ebp
js 0xb81a
movl %ebp, %esi
testb $0x1, (%rcx,%rsi)
je 0xb81a
cmpl $-0xe, (%rax,%rsi,4)
jne 0xb81a
movq 0xdc26(%rip), %rcx      # 0x19348
movslq (%rcx,%rdx,4), %rdx
movl (%rax,%rdx,4), %r14d
testl %r14d, %r14d
js 0xb846
movslq (%rcx,%rsi,4), %rdx
movl (%rax,%rdx,4), %r12d
testl %r12d, %r12d
js 0xb846
cmpl %r14d, %r12d
jl 0xb846
movq 0xdc04(%rip), %rax      # 0x19358
movslq (%rcx,%r15,4), %rcx
cmpl -0x4(%rax,%rcx,4), %r12d
jge 0xb846
movl %r12d, %esi
subl %r14d, %esi
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x27b0
movq 0xdbdf(%rip), %rdx      # 0x19358
movq 0xdbc8(%rip), %rsi      # 0x19348
movslq %eax, %rcx
movslq (%rsi,%rcx,4), %rcx
leaq (%rdx,%rcx,4), %rcx
subl %r14d, %r12d
jbe 0xb7b0
movslq (%rsi,%r15,4), %rsi
movl %r12d, %ebx
leaq (%r14,%rsi,4), %rsi
addq %rsi, %rdx
xorl %esi, %esi
movb (%rdx,%rsi), %dil
movb %dil, (%rcx,%rsi)
incq %rsi
cmpq %rsi, %rbx
jne 0xb7a0
movb $0x0, (%rcx,%rbx)
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7b83(%rip), %rsi      # 0x1334b
leaq 0x81c5(%rip), %rdx      # 0x13994
leaq 0x7d97(%rip), %rcx      # 0x1356d
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2643
leaq 0x7b56(%rip), %rsi      # 0x1334b
leaq 0x8198(%rip), %rdx      # 0x13994
leaq 0x80ac(%rip), %rcx      # 0x138af
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x2643
leaq 0x7b2a(%rip), %rsi      # 0x1334b
leaq 0x816c(%rip), %rdx      # 0x13994
leaq 0x8080(%rip), %rcx      # 0x138af
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2643
movl %ebp, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
leaq 0x8135(%rip), %rdi      # 0x1399b
movl %eax, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edi, %ebp
testl %edi, %edi
js 0xb8f6
movl %esi, %ebx
movq 0xdacc(%rip), %rdx      # 0x19350
movl %ebp, %ecx
movb (%rdx,%rcx), %sil
testb $0x8, %sil
je 0xb8f6
movq 0xdaa9(%rip), %rax      # 0x19340
cmpl $-0x11, (%rax,%rcx,4)
jne 0xb8f6
testb %sil, %sil
js 0xb949
testl %ebx, %ebx
js 0xb91d
movl %ebx, %esi
testb $0x1, (%rdx,%rsi)
je 0xb91d
cmpl $-0xc, (%rax,%rsi,4)
jne 0xb91d
movq 0xda89(%rip), %r8       # 0x19348
movq 0xda92(%rip), %rdi      # 0x19358
movslq (%r8,%rcx,4), %rcx
movl -0x4(%rdi,%rcx,4), %edx
cmpl $0x2, %edx
jl 0xb8ed
leaq (%rdi,%rcx,4), %rdi
decl %edx
movslq (%r8,%rsi,4), %rcx
movl (%rax,%rcx,4), %esi
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x20b0
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7a4e(%rip), %rsi      # 0x1334b
leaq 0x80ad(%rip), %rdx      # 0x139b1
leaq 0x7c62(%rip), %rcx      # 0x1356d
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
jmp 0xb950
leaq 0x7a27(%rip), %rsi      # 0x1334b
leaq 0x8086(%rip), %rdx      # 0x139b1
leaq 0x7c4a(%rip), %rcx      # 0x1357c
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x2643
leaq 0x8067(%rip), %rdi      # 0x139b7
movl %ebp, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edi, %ebp
testl %edi, %edi
js 0xbac2
movq 0xd9e0(%rip), %rcx      # 0x19350
movl %ebp, %eax
testb $0x1, (%rcx,%rax)
je 0xbac2
movq 0xd9bd(%rip), %rcx      # 0x19340
cmpl $-0xe, (%rcx,%rax,4)
jne 0xbac2
movl %esi, %ebx
movq 0xd9b2(%rip), %rdx      # 0x19348
movslq (%rdx,%rax,4), %rax
movslq (%rcx,%rax,4), %r14
movl %r14d, %edi
callq 0x33a7
testq %r14, %r14
jle 0xbab9
movq 0xd9a2(%rip), %rdx      # 0x19358
movq 0xd98b(%rip), %rcx      # 0x19348
movslq %eax, %rsi
movslq (%rcx,%rsi,4), %rsi
leal 0x3(%r14), %ecx
decq %r14
movq %r14, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%rdx,%rsi,4), %rdx
addq $0xc, %rdx
shrl $0x2, %ecx
shlq $0x4, %rcx
movdqa 0x78f4(%rip), %xmm1     # 0x132e0
movdqa 0x78fc(%rip), %xmm2     # 0x132f0
xorl %esi, %esi
movdqa 0x7902(%rip), %xmm3     # 0x13300
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0x7902(%rip), %xmm5     # 0x13310
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edi
notl %edi
testb $0x1, %dil
je 0xba47
movl %ebx, -0xc(%rdx,%rsi)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0xba5a
movl %ebx, -0x8(%rdx,%rsi)
movdqa %xmm1, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm4, %xmm6
pextrw $0x0, %xmm6, %edi
testb $0x1, %dil
je 0xba96
movl %ebx, -0x4(%rdx,%rsi)
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0xbaa4
movl %ebx, (%rdx,%rsi)
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
addq $0x10, %rsi
cmpq %rsi, %rcx
jne 0xba0e
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7882(%rip), %rsi      # 0x1334b
leaq 0x7ef8(%rip), %rdx      # 0x139c8
leaq 0x7dd8(%rip), %rcx      # 0x138af
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x70, %rsp
movl %edi, %ebx
cmpl $-0x1, %edi
je 0xbb68
movq 0xd838(%rip), %rax      # 0x19340
movq 0xd841(%rip), %rcx      # 0x19350
movq 0xd842(%rip), %rdx      # 0x19358
xorl %edi, %edi
movq 0xd829(%rip), %rsi      # 0x19348
movl %ebx, %r8d
movslq %r8d, %r8
movslq (%rax,%r8,4), %r14
testq %r14, %r14
js 0xbbef
testb $0x8, (%rcx,%r14)
je 0xbbef
cmpl $-0x13, (%rax,%r14,4)
jne 0xbbef
movslq (%rsi,%r14,4), %r9
movslq -0x4(%rdx,%r9,4), %r9
addq $0x3, %r9
shrq $0x2, %r9
addl %r9d, %edi
movl (%rsi,%r8,4), %r8d
cmpl $-0x1, %r8d
jne 0xbb22
jmp 0xbb6a
xorl %edi, %edi
callq 0x33a7
movl %eax, %ebp
cmpl $-0x1, %ebx
je 0xbbe0
movq 0xd7cb(%rip), %rax      # 0x19348
movslq %ebp, %rcx
movslq (%rax,%rcx,4), %r14
shlq $0x2, %r14
addq 0xd7c9(%rip), %r14      # 0x19358
xorl %r15d, %r15d
movq 0xd7bf(%rip), %rcx      # 0x19358
movq 0xd7a0(%rip), %rdx      # 0x19340
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 0xd770(%rip), %rax      # 0x19348
movl (%rax,%rbx,4), %ebx
cmpl $-0x1, %ebx
jne 0xbb92
movl %ebp, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7755(%rip), %rsi      # 0x1334b
leaq 0x7dd1(%rip), %rdx      # 0x139ce
leaq 0x7dd0(%rip), %rcx      # 0x139d4
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edi, %ebp
testl %edi, %edi
js 0xbc9f
movq 0xd71f(%rip), %rdx      # 0x19350
movl %ebp, %eax
testb $0x8, (%rdx,%rax)
je 0xbc9f
movq 0xd700(%rip), %rcx      # 0x19340
cmpl $-0x13, (%rcx,%rax,4)
jne 0xbc9f
movl %esi, %ebx
testl %esi, %esi
js 0xbccb
movl %ebx, %esi
testb $0x1, (%rdx,%rsi)
je 0xbccb
cmpl $-0xe, (%rcx,%rsi,4)
jne 0xbccb
movq 0xd6e7(%rip), %rdi      # 0x19348
movslq (%rdi,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
testq %rcx, %rcx
js 0xbcf2
movq 0xd6df(%rip), %rdx      # 0x19358
movslq (%rdi,%rax,4), %rax
movslq -0x4(%rdx,%rax,4), %rsi
addq $0x3, %rsi
shrq $0x2, %rsi
cmpq %rcx, %rsi
jbe 0xbcf2
leaq (%rdx,%rax,4), %rax
movl (%rax,%rcx,4), %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x76a5(%rip), %rsi      # 0x1334b
leaq 0x7d2e(%rip), %rdx      # 0x139db
leaq 0x7d20(%rip), %rcx      # 0x139d4
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2643
leaq 0x7679(%rip), %rsi      # 0x1334b
leaq 0x7d02(%rip), %rdx      # 0x139db
leaq 0x7bcf(%rip), %rcx      # 0x138af
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
jmp 0xbcf9
leaq 0x7ce7(%rip), %rdi      # 0x139e0
movl %ebx, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x68, %rsp
movl %edi, %ebx
testl %edi, %edi
js 0xbe66
movq 0xd638(%rip), %rcx      # 0x19350
movl %ebx, %eax
movb (%rcx,%rax), %cl
testb $0x8, %cl
je 0xbe66
movq 0xd613(%rip), %rdx      # 0x19340
cmpl $-0x13, (%rdx,%rax,4)
jne 0xbe66
testb %cl, %cl
js 0xbe8d
movq 0xd612(%rip), %rcx      # 0x19358
movq 0xd5fb(%rip), %rdx      # 0x19348
movslq (%rdx,%rax,4), %rdx
movslq -0x4(%rcx,%rdx,4), %rax
addq $0x3, %rax
shrq $0x2, %rax
testl %eax, %eax
jle 0xbe5e
movl %eax, %edi
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
addl $0x3, %eax
andl $-0x4, %eax
decq %rdi
movq %rdi, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%rcx,%rdx,4), %rcx
addq $0xc, %rcx
movdqa 0x754f(%rip), %xmm1     # 0x132e0
movdqa 0x7557(%rip), %xmm2     # 0x132f0
xorl %edx, %edx
movdqa 0x755d(%rip), %xmm3     # 0x13300
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0x755d(%rip), %xmm5     # 0x13310
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edi
notl %edi
testb $0x1, %dil
je 0xbdec
movl %esi, -0xc(%rcx,%rdx,4)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0xbdff
movl %esi, -0x8(%rcx,%rdx,4)
movdqa %xmm1, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm4, %xmm6
pextrw $0x0, %xmm6, %edi
testb $0x1, %dil
je 0xbe3b
movl %esi, -0x4(%rcx,%rdx,4)
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0xbe49
movl %esi, (%rcx,%rdx,4)
addq $0x4, %rdx
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
cmpq %rdx, %rax
jne 0xbdb3
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x74de(%rip), %rsi      # 0x1334b
leaq 0x7b85(%rip), %rdx      # 0x139f9
leaq 0x7b59(%rip), %rcx      # 0x139d4
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
jmp 0xbe94
leaq 0x7b6b(%rip), %rdi      # 0x139ff
movl %ebx, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edi, %ebp
testl %edi, %edi
js 0xbf27
movl %esi, %ebx
movq 0xd49e(%rip), %rsi      # 0x19350
movl %ebp, %eax
movb (%rsi,%rax), %dil
testb $0x8, %dil
je 0xbf27
movq 0xd47b(%rip), %rcx      # 0x19340
cmpl $-0x13, (%rcx,%rax,4)
jne 0xbf27
testb %dil, %dil
js 0xbf83
testl %ebx, %ebx
js 0xbf4e
movl %ebx, %edi
testb $0x1, (%rsi,%rdi)
je 0xbf4e
cmpl $-0xe, (%rcx,%rdi,4)
jne 0xbf4e
movq 0xd45b(%rip), %r8       # 0x19348
movslq (%r8,%rdi,4), %rsi
movslq (%rcx,%rsi,4), %rcx
testq %rcx, %rcx
js 0xbf75
movq 0xd457(%rip), %rsi      # 0x19358
movslq (%r8,%rax,4), %rax
movslq -0x4(%rsi,%rax,4), %rdi
addq $0x3, %rdi
shrq $0x2, %rdi
cmpq %rcx, %rdi
jbe 0xbf75
leaq (%rsi,%rax,4), %rax
movl %edx, (%rax,%rcx,4)
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x741d(%rip), %rsi      # 0x1334b
leaq 0x7adb(%rip), %rdx      # 0x13a10
leaq 0x7a98(%rip), %rcx      # 0x139d4
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
jmp 0xbf8a
leaq 0x73f6(%rip), %rsi      # 0x1334b
leaq 0x7ab4(%rip), %rdx      # 0x13a10
leaq 0x794c(%rip), %rcx      # 0x138af
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
jmp 0xbf7c
leaq 0x7aa9(%rip), %rdi      # 0x13a25
movl %ebx, %esi
callq 0x2643
leaq 0x7a8b(%rip), %rdi      # 0x13a15
movl %ebp, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %edi, %r14d
testl %edi, %edi
js 0xc0bc
movq 0xd3a1(%rip), %rcx      # 0x19350
movl %r14d, %r15d
testb $0x8, (%rcx,%r15)
je 0xc0bc
movq 0xd37c(%rip), %rax      # 0x19340
cmpl $-0x13, (%rax,%r15,4)
jne 0xc0bc
movl %esi, %ebx
testl %esi, %esi
js 0xc0e9
movl %edx, %ebp
movl %ebx, %edx
testb $0x1, (%rcx,%rdx)
je 0xc0e9
cmpl $-0xe, (%rax,%rdx,4)
jne 0xc0e9
testl %ebp, %ebp
js 0xc115
movl %ebp, %esi
testb $0x1, (%rcx,%rsi)
je 0xc115
cmpl $-0xe, (%rax,%rsi,4)
jne 0xc115
movq 0xd332(%rip), %rcx      # 0x19348
movslq (%rcx,%rdx,4), %rdx
movl (%rax,%rdx,4), %r14d
testl %r14d, %r14d
js 0xc141
movslq (%rcx,%rsi,4), %rdx
movl (%rax,%rdx,4), %r12d
testl %r12d, %r12d
js 0xc141
cmpl %r14d, %r12d
jl 0xc141
movq 0xd310(%rip), %rax      # 0x19358
movslq (%rcx,%r15,4), %rcx
movslq -0x4(%rax,%rcx,4), %rax
addq $0x3, %rax
shrq $0x2, %rax
cmpq %r12, %rax
jb 0xc141
movl %r12d, %edi
subl %r14d, %edi
callq 0x33a7
subl %r14d, %r12d
jbe 0xc0af
movq 0xd2df(%rip), %rdi      # 0x19358
movq 0xd2c8(%rip), %rcx      # 0x19348
movslq (%rcx,%r15,4), %rsi
movslq %eax, %rdx
movslq (%rcx,%rdx,4), %rcx
leaq (%rdi,%rcx,4), %rcx
movl %r12d, %edx
shlq $0x2, %r14
leaq (%r14,%rsi,4), %rsi
addq %rdi, %rsi
xorl %edi, %edi
movl (%rsi,%rdi,4), %r8d
movl %r8d, (%rcx,%rdi,4)
incq %rdi
cmpq %rdi, %rdx
jne 0xc09f
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7288(%rip), %rsi      # 0x1334b
leaq 0x7974(%rip), %rdx      # 0x13a3e
leaq 0x7903(%rip), %rcx      # 0x139d4
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2643
leaq 0x725b(%rip), %rsi      # 0x1334b
leaq 0x7947(%rip), %rdx      # 0x13a3e
leaq 0x77b1(%rip), %rcx      # 0x138af
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x2643
leaq 0x722f(%rip), %rsi      # 0x1334b
leaq 0x791b(%rip), %rdx      # 0x13a3e
leaq 0x7785(%rip), %rcx      # 0x138af
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2643
movl %ebp, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
leaq 0x78e4(%rip), %rdi      # 0x13a45
movl %eax, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 0x7b95(%rip), %rsi      # 0x13d05
callq 0x21c0
testq %rax, %rax
je 0xc189
movq %rax, %rdi
callq 0x2070
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0xc18e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd1aa(%rip), %rax      # 0x19348
movslq %edi, %rcx
movslq (%rax,%rcx,4), %rdi
shlq $0x2, %rdi
addq 0xd1a8(%rip), %rdi      # 0x19358
testl %esi, %esi
je 0xc1d2
xorl %esi, %esi
cmpl $0x1, %ebx
je 0xc1c0
movl $0x1, %esi
callq 0x3f3a
testl %eax, %eax
jns 0xc1db
leaq 0x78a4(%rip), %rdi      # 0x13a74
jmp 0xc1fa
callq 0x3ecb
testl %eax, %eax
js 0xc1f3
xorl %esi, %esi
testl %ebx, %ebx
sete %sil
orl $-0x10, %esi
movl %eax, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2973
leaq 0x7861(%rip), %rdi      # 0x13a5b
movl %ebp, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 0xd334(%rip), %r15d     # 0x19548
cmpl %edi, %r15d
je 0xc21f
movl %ebp, 0xd329(%rip)      # 0x19548
callq 0x28ac
movl %eax, %ebx
testl %r14d, %r14d
je 0xc256
cmpq $0x0, 0xd325(%rip)      # 0x19558
je 0xc23d
movb %bl, 0xcf19(%rip)       # 0x19154
jmp 0xc256
movslq 0xd304(%rip), %rax      # 0x19548
leaq 0xd315(%rip), %rcx      # 0x19560
movq (%rcx,%rax,8), %rsi
movl %ebx, %edi
callq 0x2180
cmpl %ebp, %r15d
je 0xc262
movl %r15d, 0xd2e6(%rip)     # 0x19548
cmpl $-0x1, %ebx
je 0xc294
movzbl %bl, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff4, %edi       # imm = 0xFFFFFFF4
movl %eax, %esi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30e7
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
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: 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 %rbx
testl %edi, %edi
js 0xc318
movq 0xd0a0(%rip), %rax      # 0x19350
movl %edi, %ecx
testb $0x8, (%rax,%rcx)
movq 0xd083(%rip), %rax      # 0x19340
je 0xc31f
cmpl $-0x11, (%rax,%rcx,4)
jne 0xc31f
movq 0xd07c(%rip), %rax      # 0x19348
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq 0xd07d(%rip), %rax      # 0x19358
movq %rax, 0xd276(%rip)      # 0x19558
movb $-0x1, 0xce6b(%rip)     # 0x19154
callq 0x5116
movq $0x0, 0xd25f(%rip) # 0x19558
movq 0xd328(%rip), %rbx      # 0x19628
testq %rbx, %rbx
je 0xc353
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
jmp 0x27b0
movq 0xd021(%rip), %rax      # 0x19340
movq 0xd022(%rip), %rcx      # 0x19348
movslq %edi, %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl 0xd212(%rip), %ebx      # 0x19548
cmpl %ebx, %eax
jne 0xc340
popq %rbx
jmp 0x5116
movl %eax, 0xd202(%rip)      # 0x19548
callq 0x5116
movl %ebx, 0xd1f7(%rip)      # 0x19548
popq %rbx
retq
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
popq %rbx
jmp 0x30e7
// File: /workspace/github_c_makefile_star2_O3/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 0xcddd(%rip), %ebx      # 0x19148
cmpl %esi, %ebx
jne 0xc37b
movl %edx, %edi
movl %eax, %esi
xorl %edx, %edx
popq %rbx
jmp 0x55e4
movl %esi, 0xcdc7(%rip)      # 0x19148
movl %edx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x55e4
movl %ebx, 0xcdb6(%rip)      # 0x19148
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0xffffffef, %edi       # imm = 0xFFFFFFEF
movl $0x3e9, %esi            # imm = 0x3E9
callq 0x32cf
movq 0xcf98(%rip), %rcx      # 0x19348
movslq %eax, %r14
movslq (%rcx,%r14,4), %rdi
shlq $0x2, %rdi
addq 0xcf96(%rip), %rdi      # 0x19358
movl $0x3e9, %edx            # imm = 0x3E9
xorl %esi, %esi
callq 0x20b0
movl %r14d, 0xcd7b(%rip)     # 0x19150
movl $0x3e8, 0xd16d(%rip)    # imm = 0x3E8
movl $0x0, 0xd167(%rip)      # 0x19550
movl $0x1, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x55e4
movl 0xd153(%rip), %esi      # 0x19550
xorl %edi, %edi
callq 0x27b0
movq 0xcf4d(%rip), %rcx      # 0x19358
movq 0xcf36(%rip), %rdx      # 0x19348
movslq %eax, %rbx
movslq (%rdx,%rbx,4), %rax
leaq (%rcx,%rax,4), %rdi
movslq 0xcd2c(%rip), %rax      # 0x19150
movslq (%rdx,%rax,4), %rax
leaq (%rcx,%rax,4), %rsi
movslq 0xd11d(%rip), %rdx      # 0x19550
incq %rdx
callq 0x2140
movl $0xffffffff, 0xcd0b(%rip) # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x10, %rsp
movl 0xccee(%rip), %ebx      # 0x19148
cmpl %esi, %ebx
jne 0xc475
leaq 0xf(%rsp), %rax
movb %dil, (%rax)
movq %rax, %rdi
movl $0x1, %esi
callq 0x29c1
jmp 0xc496
movl %esi, 0xcccd(%rip)      # 0x19148
leaq 0xe(%rsp), %rax
movb %dil, (%rax)
movq %rax, %rdi
movl $0x1, %esi
callq 0x29c1
movl %ebx, 0xccb2(%rip)      # 0x19148
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x70, %rsp
movl %edi, %ebx
testl %edi, %edi
js 0xc50a
movq 0xce9f(%rip), %rcx      # 0x19350
movl %ebx, %eax
testb $0x8, (%rcx,%rax)
je 0xc50a
movq 0xce80(%rip), %rdx      # 0x19340
cmpl $-0x11, (%rdx,%rax,4)
jne 0xc50a
movl %esi, %ebp
testl %esi, %esi
js 0xc536
movl %ebp, %esi
testb $0x8, (%rcx,%rsi)
je 0xc536
cmpl $-0x11, (%rdx,%rsi,4)
jne 0xc536
movq 0xce77(%rip), %rcx      # 0x19358
movq 0xce60(%rip), %rdx      # 0x19348
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 0xc562
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6e3a(%rip), %rsi      # 0x1334b
leaq 0x7585(%rip), %rdx      # 0x13a9d
leaq 0x704e(%rip), %rcx      # 0x1356d
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x2643
leaq 0x6e0e(%rip), %rsi      # 0x1334b
leaq 0x7559(%rip), %rdx      # 0x13a9d
leaq 0x7022(%rip), %rcx      # 0x1356d
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2643
movl %ebp, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
leaq 0x750c(%rip), %rdi      # 0x13a8e
movl %eax, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x68, %rsp
movq 0xcdae(%rip), %rax      # 0x19348
movslq %edi, %r14
cmpl $-0x1, (%rax,%r14,4)
je 0xc68b
xorl %ebp, %ebp
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebx
movl 0xcbad(%rip), %esi      # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0xcb9e(%rip)      # 0x19170
movq 0xcd6f(%rip), %rcx      # 0x19348
cmpl $-0x1, (%rcx,%r14,4)
je 0xc681
movq 0xcd55(%rip), %rdx      # 0x19340
movl (%rdx,%r14,4), %eax
cmpl $-0x1, %eax
je 0xc64e
testl %eax, %eax
js 0xc6a1
movq 0xcd4d(%rip), %rsi      # 0x19350
movl %eax, %r15d
testb $0x9, (%rsi,%r15)
jne 0xc6a1
testl %ebp, %ebp
je 0xc63c
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movslq %ebx, %rdx
movq 0xcd18(%rip), %rcx      # 0x19348
movl %eax, (%rcx,%rdx,4)
movq 0xcd06(%rip), %rdx      # 0x19340
movl %eax, %ebx
movl (%rdx,%r15,4), %eax
movslq %ebx, %rsi
movl %eax, (%rdx,%rsi,4)
incl %ebp
movl (%rcx,%r15,4), %eax
jmp 0xc5ef
movslq (%rcx,%r14,4), %r14
cmpl $-0x1, (%rcx,%r14,4)
jne 0xc5eb
movl $0x1, %edi
callq 0x335c
testl %ebp, %ebp
je 0xc68b
movq 0xccd2(%rip), %rcx      # 0x19340
movl (%rcx,%r14,4), %ecx
movq 0xcccf(%rip), %rdx      # 0x19348
movslq %ebx, %rsi
movl %ecx, (%rdx,%rsi,4)
jmp 0xc696
movl $0x1, %edi
callq 0x335c
movq 0xccae(%rip), %rax      # 0x19340
movl (%rax,%r14,4), %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl (%rdx,%r14,4), %ebx
leaq 0x6c9f(%rip), %rsi      # 0x1334b
leaq 0x7788(%rip), %rdx      # 0x13e3b
leaq 0x7600(%rip), %rcx      # 0x13cba
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq 0xcc68(%rip), %rax      # 0x19348
movq 0xcc69(%rip), %rdx      # 0x19350
movq 0xcc52(%rip), %rcx      # 0x19340
movl %edi, %r8d
movslq %edi, %rsi
movslq (%rax,%rsi,4), %rdi
testq %rdi, %rdi
js 0xc70b
testb $0x9, (%rdx,%rdi)
jne 0xc714
cmpl $-0x1, (%rcx,%rsi,4)
je 0xc6ee
jmp 0xc714
cmpl $-0x1, %edi
je 0xc797
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %rsi, %r9
movl (%rcx,%r9,4), %ebx
cmpq %rdi, %rbx
je 0xc776
testl %ebx, %ebx
js 0xc733
cmpb $0x0, (%rdx,%rbx)
js 0xc7cf
movq 0xcc16(%rip), %r9       # 0x19350
movl %ebx, %r11d
movslq %r11d, %r10
movl (%rax,%r10,4), %ebp
cmpl $-0x1, %ebp
je 0xc75a
testl %r11d, %r11d
js 0xc7a3
testb $0x9, (%r9,%r10)
movl %ebp, %r11d
je 0xc73d
jmp 0xc7a3
movslq %r8d, %r11
movslq (%rax,%r11,4), %r8
testq %r8, %r8
js 0xc77b
testb $0x9, (%r9,%r8)
jne 0xc781
cmpl $-0x1, (%rcx,%r8,4)
je 0xc75a
jmp 0xc781
movslq %r8d, %r11
jmp 0xc789
cmpl $-0x1, %r8d
je 0xc797
movl (%rcx,%r8,4), %r8d
movl %r8d, (%rax,%r10,4)
movl (%rax,%r11,4), %r8d
movslq %r8d, %r9
cmpl $-0x1, (%rax,%r9,4)
jne 0xc71c
movl (%rcx,%rsi,4), %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6ba1(%rip), %rsi      # 0x1334b
leaq 0x7304(%rip), %rdx      # 0x13ab5
leaq 0x7502(%rip), %rcx      # 0x13cba
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x2643
leaq 0x72ce(%rip), %rdi      # 0x13aa4
jmp 0xc7c8
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xcb62(%rip), %rax      # 0x19348
movslq %edi, %r15
movslq (%rax,%r15,4), %rdi
shlq $0x2, %rdi
addq 0xcb60(%rip), %rdi      # 0x19358
callq 0x3bb3
movl %eax, %ebx
cmpl $-0x1, %eax
jne 0xc86f
movq 0xcb4d(%rip), %rax      # 0x19358
movq 0xcb36(%rip), %rcx      # 0x19348
movslq (%rcx,%r15,4), %rcx
movl -0x4(%rax,%rcx,4), %ebp
movl $0xffffffee, %edi       # imm = 0xFFFFFFEE
movl %ebp, %esi
callq 0x32cf
movl %eax, %ebx
movq 0xcb29(%rip), %rax      # 0x19358
movq 0xcb12(%rip), %rcx      # 0x19348
movslq %ebx, %r14
movslq (%rcx,%r14,4), %rcx
movb $0x0, (%rax,%rcx,4)
movq 0xcb10(%rip), %rax      # 0x19358
movq 0xcaf9(%rip), %rcx      # 0x19348
movslq (%rcx,%r14,4), %rdx
leaq (%rax,%rdx,4), %rdi
movslq (%rcx,%r15,4), %rcx
leaq (%rax,%rcx,4), %rsi
movslq %ebp, %rdx
callq 0x2140
movl %r14d, %edi
callq 0x3c1c
movl %ebx, %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: b_symname
cell b_symname(cell x) {
	cell    n, k;

	/*
	 * Cannot pass name to mkstr(), because
	 * symname(x) may move during GC.
	*/
	k = symlen(x);
	n = mkstr(NULL, k-1);
	Tag[n] |= CONST_TAG;
	memcpy(string(n), symname(x), k);
	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0xcad0(%rip), %rax      # 0x19358
movq 0xcab9(%rip), %rcx      # 0x19348
movslq %edi, %r15
movslq (%rcx,%r15,4), %rcx
movslq -0x4(%rax,%rcx,4), %rbx
leal -0x1(%rbx), %esi
xorl %edi, %edi
callq 0x27b0
movq 0xcaa4(%rip), %rcx      # 0x19350
movslq %eax, %r14
orb $-0x80, (%rcx,%r14)
movq 0xca9d(%rip), %rax      # 0x19358
movq 0xca86(%rip), %rcx      # 0x19348
movslq (%rcx,%r14,4), %rdx
leaq (%rax,%rdx,4), %rdi
movslq (%rcx,%r15,4), %rcx
leaq (%rax,%rcx,4), %rsi
movq %rbx, %rdx
callq 0x2140
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: liststr
cell liststr(cell x) {
	cell	n, v;
	int	k;
	byte	*s;

	k = 0;
	for (n = x; n != NIL; n = cdr(n))
		k++;
	v = mkstr(NULL, k);
	s = string(v);
	for (n = x; n != NIL; n = cdr(n)) {
		if (atomp(n)) error("liststr: dotted list", x);
		if (!charp(car(n))) expect("liststr", "char", car(n));
		*s = charval(car(n));
		s++;
	}
	return v;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
cmpl $-0x1, %edi
je 0xc98d
movl %edi, %ebx
xorl %esi, %esi
movq 0xca4a(%rip), %rax      # 0x19348
movl %edi, %ecx
incl %esi
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
cmpl $-0x1, %ecx
jne 0xc900
xorl %edi, %edi
callq 0x27b0
cmpl $-0x1, %ebx
je 0xc985
movq 0xca28(%rip), %rdx      # 0x19348
movslq %eax, %rcx
movslq (%rdx,%rcx,4), %rcx
shlq $0x2, %rcx
addq 0xca26(%rip), %rcx      # 0x19358
movl %ebx, %esi
testl %esi, %esi
js 0xc9ca
movq 0xca0d(%rip), %r8       # 0x19350
movl %esi, %esi
testb $0x9, (%r8,%rsi)
jne 0xc9ca
movq 0xc9ed(%rip), %rdi      # 0x19340
movslq (%rdi,%rsi,4), %r14
testq %r14, %r14
js 0xc99d
testb $0x1, (%r8,%r14)
je 0xc99d
cmpl $-0xc, (%rdi,%r14,4)
jne 0xc99d
movslq (%rdx,%r14,4), %rdx
movb (%rdi,%rdx,4), %dl
movb %dl, (%rcx)
incq %rcx
movq 0xc9cb(%rip), %rdx      # 0x19348
movl (%rdx,%rsi,4), %esi
cmpl $-0x1, %esi
jne 0xc934
addq $0x68, %rsp
popq %rbx
popq %r14
retq
xorl %edi, %edi
xorl %esi, %esi
addq $0x68, %rsp
popq %rbx
popq %r14
jmp 0x27b0
leaq 0x69a7(%rip), %rsi      # 0x1334b
leaq 0x7125(%rip), %rdx      # 0x13ad0
leaq 0x6bca(%rip), %rcx      # 0x1357c
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2643
leaq 0x70ea(%rip), %rdi      # 0x13abb
movl %ebx, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: strlist
cell strlist(cell x) {
	cell	a, new;
	int	k, i;

	k = stringlen(x)-1;
	if (0 == k) return NIL;
	protect(a = cons(NIL, NIL));
	for (i=0; i<k; i++) {
		new = mkchar(string(x)[i]);
		car(a) = new;
		if (i < k-1) {
			new = cons(NIL, NIL);
			cdr(a) = new;
			a = cdr(a);
		}
	}
	return unprot(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xc96e(%rip), %rax      # 0x19358
movq 0xc957(%rip), %rcx      # 0x19348
movslq %edi, %r14
movslq (%rcx,%r14,4), %rcx
movl -0x4(%rax,%rcx,4), %r15d
movl %r15d, %ebp
decl %ebp
je 0xcacb
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebx
movl 0xc74f(%rip), %esi      # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0xc740(%rip)      # 0x19170
cmpl $0x2, %r15d
jl 0xcab3
addl $-0x2, %r15d
movl %ebp, %r12d
xorl %r13d, %r13d
movq 0xc901(%rip), %rax      # 0x19348
movslq (%rax,%r14,4), %rax
shlq $0x2, %rax
addq 0xc902(%rip), %rax      # 0x19358
movzbl (%r13,%rax), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff4, %edi       # imm = 0xFFFFFFF4
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
movq 0xc8bd(%rip), %rcx      # 0x19340
movslq %ebx, %rbp
movl %eax, (%rcx,%rbp,4)
cmpq %r15, %r13
jae 0xcaab
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebx
movq 0xc8a0(%rip), %rax      # 0x19348
movl %ebx, (%rax,%rbp,4)
incq %r13
cmpq %r13, %r12
jne 0xca40
movl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x335c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
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: veclist
cell veclist(cell x) {
	cell	a, new;
	int	k, i;

	k = veclen(x);
	if (0 == k) return NIL;
	protect(a = cons(NIL, NIL));
	for (i=0; i<k; i++) {
		car(a) = vector(x)[i];
		if (i < k-1) {
			new = cons(NIL, NIL);
			cdr(a) = new;
			a = cdr(a);
		}
	}
	return unprot(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xc867(%rip), %rax      # 0x19358
movq 0xc850(%rip), %rcx      # 0x19348
movslq %edi, %r14
movslq (%rcx,%r14,4), %rcx
movslq -0x4(%rax,%rcx,4), %r15
addq $0x3, %r15
shrq $0x2, %r15
testl %r15d, %r15d
je 0xcbca
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebx
movl 0xc642(%rip), %esi      # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0xc633(%rip)      # 0x19170
testl %r15d, %r15d
jle 0xcbb2
leal -0x1(%r15), %eax
movslq %eax, %r12
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
movq 0xc801(%rip), %rcx      # 0x19358
movq 0xc7ea(%rip), %rax      # 0x19348
movq 0xc7db(%rip), %rdx      # 0x19340
xorl %r13d, %r13d
movslq (%rax,%r14,4), %rsi
leaq (%rcx,%rsi,4), %rsi
movl (%rsi,%r13,4), %esi
movslq %ebx, %rbp
movl %esi, (%rdx,%rbp,4)
cmpq %r12, %r13
jge 0xcbaa
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebx
movq 0xc7af(%rip), %rax      # 0x19348
movl %ebx, (%rax,%rbp,4)
movq 0xc7b5(%rip), %rcx      # 0x19358
movq 0xc796(%rip), %rdx      # 0x19340
incq %r13
cmpq %r13, %r15
jne 0xcb68
movl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x335c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq