LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xb39d
movq 0xdffd(%rip), %rax      # 0x19340
movq 0xe006(%rip), %rcx      # 0x19350
movq 0xe007(%rip), %rdx      # 0x19358
xorl %esi, %esi
movq 0xdfee(%rip), %rdi      # 0x19348
movl %ebx, %r8d
movslq %r8d, %r8
movslq (%rax,%r8,4), %r14
testq %r14, %r14
js 0xb425
testb $0x8, (%rcx,%r14)
je 0xb425
cmpl $-0x11, (%rax,%r14,4)
jne 0xb425
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 0xb35d
jmp 0xb39f
xorl %esi, %esi
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x27dc
movl %eax, %ebp
cmpl $-0x1, %ebx
je 0xb416
movq 0xdf91(%rip), %rax      # 0x19348
movslq %ebp, %rcx
movslq (%rax,%rcx,4), %r15
shlq $0x2, %r15
addq 0xdf8f(%rip), %r15      # 0x19358
movq 0xdf88(%rip), %rax      # 0x19358
movq 0xdf71(%rip), %rcx      # 0x19348
movq 0xdf62(%rip), %rdx      # 0x19340
movslq %ebx, %r12
movslq (%rdx,%r12,4), %rdx
movslq (%rcx,%rdx,4), %rcx
leaq (%rax,%rcx,4), %rsi
movslq -0x4(%rsi), %rbx
movslq %r14d, %r14
leaq (%r15,%r14), %rdi
movq %rbx, %rdx
callq 0x2140
addl %ebx, %r14d
decl %r14d
movq 0xdf3b(%rip), %rax      # 0x19348
movl (%rax,%r12,4), %ebx
cmpl $-0x1, %ebx
jne 0xb3c9
movl %ebp, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7eef(%rip), %rsi      # 0x1331b
leaq 0x84df(%rip), %rdx      # 0x13912
leaq 0x8103(%rip), %rcx      # 0x1353d
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xb51b
movq 0xdee5(%rip), %rdx      # 0x19350
movl %ebp, %eax
testb $0x8, (%rdx,%rax)
je 0xb51b
movq 0xdec2(%rip), %rcx      # 0x19340
cmpl $-0x11, (%rcx,%rax,4)
jne 0xb51b
movl %esi, %ebx
testl %esi, %esi
js 0xb547
movl %ebx, %esi
testb $0x1, (%rdx,%rsi)
je 0xb547
cmpl $-0xe, (%rcx,%rsi,4)
jne 0xb547
movq 0xde99(%rip), %rdx      # 0x19348
movslq (%rdx,%rsi,4), %rsi
movslq (%rcx,%rsi,4), %rcx
testq %rcx, %rcx
js 0xb56e
movq 0xde91(%rip), %rsi      # 0x19358
movslq (%rdx,%rax,4), %rdx
movl -0x4(%rsi,%rdx,4), %edx
decl %edx
cmpl %edx, %ecx
jge 0xb56e
movq 0xde68(%rip), %rdx      # 0x19348
movslq (%rdx,%rax,4), %rax
shlq $0x2, %rax
addq 0xde69(%rip), %rax      # 0x19358
movzbl (%rcx,%rax), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff4, %edi       # imm = 0xFFFFFFF4
movl %eax, %esi
movl $0x1, %edx
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3162
leaq 0x7df9(%rip), %rsi      # 0x1331b
leaq 0x83ef(%rip), %rdx      # 0x13918
leaq 0x800d(%rip), %rcx      # 0x1353d
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x264c
leaq 0x7dcd(%rip), %rsi      # 0x1331b
leaq 0x83c3(%rip), %rdx      # 0x13918
leaq 0x8323(%rip), %rcx      # 0x1387f
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
jmp 0xb575
leaq 0x83a8(%rip), %rdi      # 0x1391d
movl %ebx, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xb66d
movq 0xddba(%rip), %rcx      # 0x19350
movl %r14d, %eax
movb (%rcx,%rax), %cl
testb $0x8, %cl
je 0xb66d
movl %edx, %ebp
movq 0xdd92(%rip), %rdx      # 0x19340
cmpl $-0x11, (%rdx,%rax,4)
jne 0xb66d
testb %cl, %cl
js 0xb6f5
movl %esi, %ebx
testl %esi, %esi
js 0xb694
movq 0xdd7f(%rip), %rdi      # 0x19350
movl %ebx, %edx
testb $0x1, (%rdi,%rdx)
je 0xb694
movq 0xdd5c(%rip), %rsi      # 0x19340
cmpl $-0xe, (%rsi,%rdx,4)
jne 0xb694
testl %ebp, %ebp
js 0xb6bb
movl %ebp, %ecx
testb $0x1, (%rdi,%rcx)
je 0xb6bb
cmpl $-0xc, (%rsi,%rcx,4)
jne 0xb6bb
movq 0xdd35(%rip), %rdi      # 0x19348
movslq (%rdi,%rdx,4), %rdx
movslq (%rsi,%rdx,4), %rdx
testq %rdx, %rdx
js 0xb6e7
movq 0xdd2d(%rip), %rsi      # 0x19358
movslq (%rdi,%rax,4), %rdi
movl -0x4(%rsi,%rdi,4), %esi
decl %esi
cmpl %esi, %edx
jge 0xb6e7
movq 0xdcfc(%rip), %rsi      # 0x19340
movq 0xdcfd(%rip), %rdi      # 0x19348
movslq (%rdi,%rcx,4), %rcx
movb (%rsi,%rcx,4), %cl
movslq (%rdi,%rax,4), %rax
shlq $0x2, %rax
addq 0xdcf7(%rip), %rax      # 0x19358
movb %cl, (%rdx,%rax)
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7ca7(%rip), %rsi      # 0x1331b
leaq 0x82bb(%rip), %rdx      # 0x13936
leaq 0x7ebb(%rip), %rcx      # 0x1353d
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
jmp 0xb6fc
leaq 0x7c80(%rip), %rsi      # 0x1331b
leaq 0x8294(%rip), %rdx      # 0x13936
leaq 0x81d6(%rip), %rcx      # 0x1387f
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
jmp 0xb6ee
leaq 0x7c59(%rip), %rsi      # 0x1331b
leaq 0x826d(%rip), %rdx      # 0x13936
leaq 0x7e7c(%rip), %rcx      # 0x1354c
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x264c
leaq 0x825d(%rip), %rdi      # 0x1394b
movl %ebx, %esi
callq 0x264c
leaq 0x823f(%rip), %rdi      # 0x1393b
movl %r14d, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xb82a
movq 0xdc2e(%rip), %rcx      # 0x19350
movl %r14d, %r15d
testb $0x8, (%rcx,%r15)
je 0xb82a
movq 0xdc09(%rip), %rax      # 0x19340
cmpl $-0x11, (%rax,%r15,4)
jne 0xb82a
movl %esi, %ebx
testl %esi, %esi
js 0xb857
movl %edx, %ebp
movl %ebx, %edx
testb $0x1, (%rcx,%rdx)
je 0xb857
cmpl $-0xe, (%rax,%rdx,4)
jne 0xb857
testl %ebp, %ebp
js 0xb883
movl %ebp, %esi
testb $0x1, (%rcx,%rsi)
je 0xb883
cmpl $-0xe, (%rax,%rsi,4)
jne 0xb883
movq 0xdbbf(%rip), %rcx      # 0x19348
movslq (%rcx,%rdx,4), %rdx
movl (%rax,%rdx,4), %r12d
testl %r12d, %r12d
js 0xb8af
movslq (%rcx,%rsi,4), %rdx
movl (%rax,%rdx,4), %r14d
testl %r14d, %r14d
js 0xb8af
cmpl %r12d, %r14d
jl 0xb8af
movq 0xdb9d(%rip), %rax      # 0x19358
movslq (%rcx,%r15,4), %rcx
cmpl -0x4(%rax,%rcx,4), %r14d
jge 0xb8af
movl %r14d, %esi
subl %r12d, %esi
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x27dc
movq 0xdb78(%rip), %rdx      # 0x19358
movq 0xdb61(%rip), %rsi      # 0x19348
movslq %eax, %rcx
movslq (%rsi,%rcx,4), %rcx
leaq (%rdx,%rcx,4), %rcx
cmpl %r12d, %r14d
jle 0xb819
movslq (%rsi,%r15,4), %rsi
subl %r12d, %r14d
leaq (%r12,%rsi,4), %rsi
addq %rsi, %rdx
xorl %esi, %esi
movb (%rdx,%rsi), %dil
movb %dil, (%rcx,%rsi)
incq %rsi
cmpq %rsi, %r14
jne 0xb807
movl %esi, %ebx
movb $0x0, (%rcx,%rbx)
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7aea(%rip), %rsi      # 0x1331b
leaq 0x812c(%rip), %rdx      # 0x13964
leaq 0x7cfe(%rip), %rcx      # 0x1353d
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x264c
leaq 0x7abd(%rip), %rsi      # 0x1331b
leaq 0x80ff(%rip), %rdx      # 0x13964
leaq 0x8013(%rip), %rcx      # 0x1387f
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x264c
leaq 0x7a91(%rip), %rsi      # 0x1331b
leaq 0x80d3(%rip), %rdx      # 0x13964
leaq 0x7fe7(%rip), %rcx      # 0x1387f
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x264c
movl %ebp, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3162
leaq 0x809c(%rip), %rdi      # 0x1396b
movl %eax, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xb972
movq 0xda61(%rip), %rcx      # 0x19350
movl %ebp, %eax
movb (%rcx,%rax), %cl
testb $0x8, %cl
je 0xb972
movq 0xda40(%rip), %rdx      # 0x19340
cmpl $-0x11, (%rdx,%rax,4)
jne 0xb972
testb %cl, %cl
js 0xb9c5
movl %esi, %ebx
testl %esi, %esi
js 0xb999
movq 0xda31(%rip), %rdx      # 0x19350
movl %ebx, %ecx
testb $0x1, (%rdx,%rcx)
je 0xb999
movq 0xda12(%rip), %rsi      # 0x19340
cmpl $-0xc, (%rsi,%rcx,4)
jne 0xb999
movq 0xda0d(%rip), %r8       # 0x19348
movq 0xda16(%rip), %rdi      # 0x19358
movslq (%r8,%rax,4), %rax
movl -0x4(%rdi,%rax,4), %edx
cmpl $0x2, %edx
jl 0xb969
leaq (%rdi,%rax,4), %rdi
decl %edx
movslq (%r8,%rcx,4), %rax
movl (%rsi,%rax,4), %esi
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x20b0
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x79a2(%rip), %rsi      # 0x1331b
leaq 0x8001(%rip), %rdx      # 0x13981
leaq 0x7bb6(%rip), %rcx      # 0x1353d
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
jmp 0xb9cc
leaq 0x797b(%rip), %rsi      # 0x1331b
leaq 0x7fda(%rip), %rdx      # 0x13981
leaq 0x7b9e(%rip), %rcx      # 0x1354c
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x264c
leaq 0x7fbb(%rip), %rdi      # 0x13987
movl %ebp, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xba4a
movq 0xd968(%rip), %rcx      # 0x19350
movl %ebp, %eax
testb $0x1, (%rcx,%rax)
je 0xba4a
movq 0xd949(%rip), %rcx      # 0x19340
cmpl $-0xe, (%rcx,%rax,4)
jne 0xba4a
movl %esi, %ebx
movq 0xd942(%rip), %rdx      # 0x19348
movslq (%rdx,%rax,4), %rax
movslq (%rcx,%rax,4), %r14
movl %r14d, %edi
callq 0x3422
testq %r14, %r14
jle 0xba41
movq 0xd926(%rip), %rcx      # 0x19348
movslq %eax, %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0xd924(%rip), %rcx      # 0x19358
xorl %edx, %edx
movl %ebx, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %r14
jne 0xba36
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x78ca(%rip), %rsi      # 0x1331b
leaq 0x7f40(%rip), %rdx      # 0x13998
leaq 0x7e20(%rip), %rcx      # 0x1387f
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xbaf0
movq 0xd8b0(%rip), %rax      # 0x19340
movq 0xd8b9(%rip), %rcx      # 0x19350
movq 0xd8ba(%rip), %rdx      # 0x19358
xorl %edi, %edi
movq 0xd8a1(%rip), %rsi      # 0x19348
movl %ebx, %r8d
movslq %r8d, %r8
movslq (%rax,%r8,4), %r14
testq %r14, %r14
js 0xbb7e
testb $0x8, (%rcx,%r14)
je 0xbb7e
cmpl $-0x13, (%rax,%r14,4)
jne 0xbb7e
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 0xbaaa
jmp 0xbaf2
xorl %edi, %edi
callq 0x3422
movl %eax, %ebp
cmpl $-0x1, %ebx
je 0xbb6f
movq 0xd843(%rip), %rax      # 0x19348
movslq %ebp, %rcx
movslq (%rax,%rcx,4), %r14
shlq $0x2, %r14
addq 0xd841(%rip), %r14      # 0x19358
xorl %r15d, %r15d
movq 0xd837(%rip), %rax      # 0x19358
movq 0xd820(%rip), %rcx      # 0x19348
movq 0xd811(%rip), %rdx      # 0x19340
movslq %ebx, %rbx
movslq (%rdx,%rbx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
leaq (%rax,%rcx,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 0xd7e1(%rip), %rax      # 0x19348
movl (%rax,%rbx,4), %ebx
cmpl $-0x1, %ebx
jne 0xbb1a
movl %ebp, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7796(%rip), %rsi      # 0x1331b
leaq 0x7e12(%rip), %rdx      # 0x1399e
leaq 0x7e11(%rip), %rcx      # 0x139a4
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xbc54
movq 0xd78c(%rip), %rdx      # 0x19350
movl %ebp, %eax
testb $0x8, (%rdx,%rax)
je 0xbc54
movq 0xd769(%rip), %rcx      # 0x19340
cmpl $-0x13, (%rcx,%rax,4)
jne 0xbc54
movl %esi, %ebx
testl %esi, %esi
js 0xbc80
movl %ebx, %esi
testb $0x1, (%rdx,%rsi)
je 0xbc80
cmpl $-0xe, (%rcx,%rsi,4)
jne 0xbc80
movq 0xd744(%rip), %rdx      # 0x19348
movslq (%rdx,%rsi,4), %rsi
movslq (%rcx,%rsi,4), %rcx
testq %rcx, %rcx
js 0xbca7
movq 0xd73c(%rip), %rsi      # 0x19358
movslq (%rdx,%rax,4), %rdx
movslq -0x4(%rsi,%rdx,4), %rdx
addq $0x3, %rdx
shrq $0x2, %rdx
cmpq %rcx, %rdx
jbe 0xbca7
movq 0xd70f(%rip), %rdx      # 0x19348
movslq (%rdx,%rax,4), %rax
shlq $0x2, %rax
addq 0xd710(%rip), %rax      # 0x19358
movl (%rax,%rcx,4), %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x76c0(%rip), %rsi      # 0x1331b
leaq 0x7d49(%rip), %rdx      # 0x139ab
leaq 0x7d3b(%rip), %rcx      # 0x139a4
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x264c
leaq 0x7694(%rip), %rsi      # 0x1331b
leaq 0x7d1d(%rip), %rdx      # 0x139ab
leaq 0x7bea(%rip), %rcx      # 0x1387f
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
jmp 0xbcae
leaq 0x7d02(%rip), %rdi      # 0x139b0
movl %ebx, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xbd25
movq 0xd687(%rip), %rcx      # 0x19350
movl %ebx, %eax
movb (%rcx,%rax), %cl
testb $0x8, %cl
je 0xbd25
movq 0xd666(%rip), %rdx      # 0x19340
cmpl $-0x13, (%rdx,%rax,4)
jne 0xbd25
testb %cl, %cl
js 0xbd4c
movq 0xd66d(%rip), %rcx      # 0x19358
movq 0xd656(%rip), %rdx      # 0x19348
movslq (%rdx,%rax,4), %rdx
movslq -0x4(%rcx,%rdx,4), %rax
addq $0x3, %rax
shrq $0x2, %rax
testl %eax, %eax
jle 0xbd1d
leaq (%rcx,%rdx,4), %rcx
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
movl %esi, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %rax
jne 0xbd12
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x75ef(%rip), %rsi      # 0x1331b
leaq 0x7c96(%rip), %rdx      # 0x139c9
leaq 0x7c6a(%rip), %rcx      # 0x139a4
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
jmp 0xbd53
leaq 0x7c7c(%rip), %rdi      # 0x139cf
movl %ebx, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xbe1b
movq 0xd5dd(%rip), %rcx      # 0x19350
movl %ebp, %eax
movb (%rcx,%rax), %cl
testb $0x8, %cl
je 0xbe1b
movl %esi, %ebx
movq 0xd5b6(%rip), %rsi      # 0x19340
cmpl $-0x13, (%rsi,%rax,4)
jne 0xbe1b
testb %cl, %cl
js 0xbe77
testl %ebx, %ebx
js 0xbe42
movq 0xd5a5(%rip), %rsi      # 0x19350
movl %ebx, %ecx
testb $0x1, (%rsi,%rcx)
je 0xbe42
movq 0xd582(%rip), %rdi      # 0x19340
cmpl $-0xe, (%rdi,%rcx,4)
jne 0xbe42
movq 0xd57d(%rip), %rsi      # 0x19348
movslq (%rsi,%rcx,4), %rcx
movslq (%rdi,%rcx,4), %rcx
testq %rcx, %rcx
js 0xbe69
movq 0xd575(%rip), %rdi      # 0x19358
movslq (%rsi,%rax,4), %rsi
movslq -0x4(%rdi,%rsi,4), %rsi
addq $0x3, %rsi
shrq $0x2, %rsi
cmpq %rcx, %rsi
jbe 0xbe69
movq 0xd548(%rip), %rsi      # 0x19348
movslq (%rsi,%rax,4), %rax
shlq $0x2, %rax
addq 0xd549(%rip), %rax      # 0x19358
movl %edx, (%rax,%rcx,4)
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x74f9(%rip), %rsi      # 0x1331b
leaq 0x7bb7(%rip), %rdx      # 0x139e0
leaq 0x7b74(%rip), %rcx      # 0x139a4
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
jmp 0xbe7e
leaq 0x74d2(%rip), %rsi      # 0x1331b
leaq 0x7b90(%rip), %rdx      # 0x139e0
leaq 0x7a28(%rip), %rcx      # 0x1387f
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
jmp 0xbe70
leaq 0x7b85(%rip), %rdi      # 0x139f5
movl %ebx, %esi
callq 0x264c
leaq 0x7b67(%rip), %rdi      # 0x139e5
movl %ebp, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xbfae
movq 0xd4ad(%rip), %rcx      # 0x19350
movl %r14d, %r15d
testb $0x8, (%rcx,%r15)
je 0xbfae
movq 0xd488(%rip), %rax      # 0x19340
cmpl $-0x13, (%rax,%r15,4)
jne 0xbfae
movl %esi, %ebx
testl %esi, %esi
js 0xbfdb
movl %edx, %ebp
movl %ebx, %edx
testb $0x1, (%rcx,%rdx)
je 0xbfdb
cmpl $-0xe, (%rax,%rdx,4)
jne 0xbfdb
testl %ebp, %ebp
js 0xc007
movl %ebp, %esi
testb $0x1, (%rcx,%rsi)
je 0xc007
cmpl $-0xe, (%rax,%rsi,4)
jne 0xc007
movq 0xd43e(%rip), %rcx      # 0x19348
movslq (%rcx,%rdx,4), %rdx
movl (%rax,%rdx,4), %r12d
testl %r12d, %r12d
js 0xc033
movslq (%rcx,%rsi,4), %rdx
movl (%rax,%rdx,4), %r14d
testl %r14d, %r14d
js 0xc033
cmpl %r12d, %r14d
jl 0xc033
movq 0xd41c(%rip), %rax      # 0x19358
movslq (%rcx,%r15,4), %rcx
movslq -0x4(%rax,%rcx,4), %rax
addq $0x3, %rax
shrq $0x2, %rax
cmpq %r14, %rax
jb 0xc033
movl %r14d, %edi
subl %r12d, %edi
callq 0x3422
cmpl %r12d, %r14d
jle 0xbfa1
movq 0xd3eb(%rip), %rsi      # 0x19358
movq 0xd3d4(%rip), %rcx      # 0x19348
movslq (%rcx,%r15,4), %rdx
movslq %eax, %rdi
movslq (%rcx,%rdi,4), %rcx
leaq (%rsi,%rcx,4), %rcx
subl %r12d, %r14d
shlq $0x2, %r12
leaq (%r12,%rdx,4), %rdx
addq %rsi, %rdx
xorl %esi, %esi
movl (%rdx,%rsi,4), %edi
movl %edi, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %r14
jne 0xbf93
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7366(%rip), %rsi      # 0x1331b
leaq 0x7a52(%rip), %rdx      # 0x13a0e
leaq 0x79e1(%rip), %rcx      # 0x139a4
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x264c
leaq 0x7339(%rip), %rsi      # 0x1331b
leaq 0x7a25(%rip), %rdx      # 0x13a0e
leaq 0x788f(%rip), %rcx      # 0x1387f
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x264c
leaq 0x730d(%rip), %rsi      # 0x1331b
leaq 0x79f9(%rip), %rdx      # 0x13a0e
leaq 0x7863(%rip), %rcx      # 0x1387f
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x264c
movl %ebp, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3162
leaq 0x79c2(%rip), %rdi      # 0x13a15
movl %eax, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0x7c73(%rip), %rsi      # 0x13cd5
callq 0x21c0
testq %rax, %rax
je 0xc07b
movq %rax, %rdi
callq 0x2070
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0xc080
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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, %ebp
movl %edi, %ebx
cmpl $0x2, %esi
je 0xc0d4
cmpl $0x1, %ebp
je 0xc0b7
testl %ebp, %ebp
jne 0xc0f9
movq 0xd2aa(%rip), %rax      # 0x19348
movslq %ebx, %rcx
movslq (%rax,%rcx,4), %rdi
shlq $0x2, %rdi
addq 0xd2a8(%rip), %rdi      # 0x19358
callq 0x3f83
jmp 0xc0f7
movq 0xd28a(%rip), %rax      # 0x19348
movslq %ebx, %rcx
movslq (%rax,%rcx,4), %rdi
shlq $0x2, %rdi
addq 0xd288(%rip), %rdi      # 0x19358
xorl %esi, %esi
jmp 0xc0f2
movq 0xd26d(%rip), %rax      # 0x19348
movslq %ebx, %rcx
movslq (%rax,%rcx,4), %rdi
shlq $0x2, %rdi
addq 0xd26b(%rip), %rdi      # 0x19358
movl $0x1, %esi
callq 0x3fcd
movl %eax, %edi
testl %edi, %edi
js 0xc113
xorl %esi, %esi
testl %ebp, %ebp
sete %sil
orl $-0x10, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x29a8
testl %ebp, %ebp
jne 0xc120
leaq 0x790d(%rip), %rdi      # 0x13a2b
jmp 0xc127
leaq 0x791d(%rip), %rdi      # 0x13a44
movl %ebx, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xd407(%rip), %r15d     # 0x19548
cmpl %edi, %r15d
je 0xc14c
movl %ebp, 0xd3fc(%rip)      # 0x19548
callq 0x28d8
movl %eax, %ebx
testl %r14d, %r14d
je 0xc183
cmpq $0x0, 0xd3f8(%rip)      # 0x19558
je 0xc16a
movb %bl, 0xcfec(%rip)       # 0x19154
jmp 0xc183
movslq 0xd3d7(%rip), %rax      # 0x19548
leaq 0xd3e8(%rip), %rcx      # 0x19560
movq (%rcx,%rax,8), %rsi
movl %ebx, %edi
callq 0x2180
cmpl %ebp, %r15d
je 0xc18f
movl %r15d, 0xd3b9(%rip)     # 0x19548
cmpl $-0x1, %ebx
je 0xc1c1
movzbl %bl, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff4, %edi       # imm = 0xFFFFFFF4
movl %eax, %esi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3162
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: 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 0xc24c
movq 0xd171(%rip), %rcx      # 0x19350
movl %edi, %eax
testb $0x8, (%rcx,%rax)
je 0xc24c
movq 0xd152(%rip), %rcx      # 0x19340
cmpl $-0x11, (%rcx,%rax,4)
jne 0xc24c
movq 0xd14d(%rip), %rcx      # 0x19348
movslq (%rcx,%rax,4), %rax
shlq $0x2, %rax
addq 0xd14e(%rip), %rax      # 0x19358
movq %rax, 0xd347(%rip)      # 0x19558
movb $-0x1, 0xcf3c(%rip)     # 0x19154
callq 0x511d
movq $0x0, 0xd330(%rip) # 0x19558
movq 0xd3f9(%rip), %rbx      # 0x19628
testq %rbx, %rbx
je 0xc28a
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x27dc
movq 0xd0ed(%rip), %rax      # 0x19340
movq 0xd0ee(%rip), %rcx      # 0x19348
movslq %edi, %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %ebp
movl 0xd2de(%rip), %ebx      # 0x19548
cmpl %ebx, %ebp
je 0xc274
movl %ebp, 0xd2d4(%rip)      # 0x19548
callq 0x511d
cmpl %ebx, %ebp
je 0xc283
movl %ebx, 0xd2c5(%rip)      # 0x19548
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3162
// File: /workspace/github_c_makefile_star2_O1/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 0xcea1(%rip), %ebx      # 0x19148
cmpl %esi, %ebx
jne 0xc2b7
movl %edx, %edi
movl %eax, %esi
xorl %edx, %edx
popq %rbx
jmp 0x55f2
movl %esi, 0xce8b(%rip)      # 0x19148
movl %edx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x55f2
movl %ebx, 0xce7a(%rip)      # 0x19148
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x334b
movq 0xd05c(%rip), %rcx      # 0x19348
movslq %eax, %r14
movslq (%rcx,%r14,4), %rdi
shlq $0x2, %rdi
addq 0xd05a(%rip), %rdi      # 0x19358
movl $0x3e9, %edx            # imm = 0x3E9
xorl %esi, %esi
callq 0x20b0
movl %r14d, 0xce3f(%rip)     # 0x19150
movl $0x3e8, 0xd231(%rip)    # imm = 0x3E8
movl $0x0, 0xd22b(%rip)      # 0x19550
movl $0x1, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x55f2
movl 0xd217(%rip), %esi      # 0x19550
xorl %edi, %edi
callq 0x27dc
movq 0xd011(%rip), %rcx      # 0x19358
movq 0xcffa(%rip), %rdx      # 0x19348
movslq %eax, %rbx
movslq (%rdx,%rbx,4), %rax
leaq (%rcx,%rax,4), %rdi
movslq 0xcdf0(%rip), %rax      # 0x19150
movslq (%rdx,%rax,4), %rax
leaq (%rcx,%rax,4), %rsi
movslq 0xd1e1(%rip), %rdx      # 0x19550
incq %rdx
callq 0x2140
movl $0xffffffff, 0xcdcf(%rip) # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcdb2(%rip), %ebx      # 0x19148
cmpl %esi, %ebx
jne 0xc3b1
leaq 0xf(%rsp), %rax
movb %dil, (%rax)
movq %rax, %rdi
movl $0x1, %esi
callq 0x29f6
jmp 0xc3d2
movl %esi, 0xcd91(%rip)      # 0x19148
leaq 0xe(%rsp), %rax
movb %dil, (%rax)
movq %rax, %rdi
movl $0x1, %esi
callq 0x29f6
movl %ebx, 0xcd76(%rip)      # 0x19148
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc446
movq 0xcf63(%rip), %rcx      # 0x19350
movl %ebx, %eax
testb $0x8, (%rcx,%rax)
je 0xc446
movl %esi, %ebp
movq 0xcf42(%rip), %rsi      # 0x19340
cmpl $-0x11, (%rsi,%rax,4)
jne 0xc446
testl %ebp, %ebp
js 0xc472
movl %ebp, %edx
testb $0x8, (%rcx,%rdx)
je 0xc472
cmpl $-0x11, (%rsi,%rdx,4)
jne 0xc472
movq 0xcf3b(%rip), %rcx      # 0x19358
movq 0xcf24(%rip), %rsi      # 0x19348
movslq (%rsi,%rax,4), %rax
leaq (%rcx,%rax,4), %rdi
movslq (%rsi,%rdx,4), %rax
leaq (%rcx,%rax,4), %rsi
callq 0x21d0
testl %eax, %eax
js 0xc49e
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6ece(%rip), %rsi      # 0x1331b
leaq 0x7619(%rip), %rdx      # 0x13a6d
leaq 0x70e2(%rip), %rcx      # 0x1353d
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x264c
leaq 0x6ea2(%rip), %rsi      # 0x1331b
leaq 0x75ed(%rip), %rdx      # 0x13a6d
leaq 0x70b6(%rip), %rcx      # 0x1353d
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x264c
movl %ebp, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3162
leaq 0x75a0(%rip), %rdi      # 0x13a5e
movl %eax, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xce72(%rip), %rax      # 0x19348
movslq %edi, %r14
cmpl $-0x1, (%rax,%r14,4)
je 0xc5af
xorl %ebp, %ebp
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %eax, %ebx
movl 0xcc71(%rip), %esi      # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0xcc62(%rip)      # 0x19170
movq 0xce33(%rip), %rax      # 0x19348
cmpl $-0x1, (%rax,%r14,4)
je 0xc5bc
movq 0xce19(%rip), %rax      # 0x19340
movl (%rax,%r14,4), %eax
cmpl $-0x1, %eax
je 0xc591
testl %eax, %eax
js 0xc5f5
movq 0xce11(%rip), %rcx      # 0x19350
movl %eax, %r15d
testb $0x9, (%rcx,%r15)
jne 0xc5f5
testl %ebp, %ebp
je 0xc571
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movslq %ebx, %rcx
movq 0xcddc(%rip), %rdx      # 0x19348
movl %eax, (%rdx,%rcx,4)
movl %eax, %ebx
movq 0xcdc8(%rip), %rax      # 0x19340
movl (%rax,%r15,4), %ecx
movslq %ebx, %rdx
movl %ecx, (%rax,%rdx,4)
incl %ebp
movq 0xcdbd(%rip), %rax      # 0x19348
movl (%rax,%r15,4), %eax
jmp 0xc52b
movq 0xcdb0(%rip), %rax      # 0x19348
movslq (%rax,%r14,4), %r14
cmpl $-0x1, (%rax,%r14,4)
jne 0xc520
testl %ebp, %ebp
sete %bpl
jmp 0xc5bf
movq 0xcd8a(%rip), %rax      # 0x19340
movl (%rax,%r14,4), %eax
jmp 0xc5ea
movb $0x1, %bpl
movl $0x1, %edi
callq 0x33d7
movl %eax, %ecx
movq 0xcd6e(%rip), %rax      # 0x19340
movl (%rax,%r14,4), %eax
testb %bpl, %bpl
jne 0xc5ea
movq 0xcd66(%rip), %rdx      # 0x19348
movslq %ebx, %rsi
movl %eax, (%rdx,%rsi,4)
movl %ecx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xcd44(%rip), %rax      # 0x19340
movl (%rax,%r14,4), %ebx
leaq 0x6d14(%rip), %rsi      # 0x1331b
leaq 0x77fd(%rip), %rdx      # 0x13e0b
leaq 0x7675(%rip), %rcx      # 0x13c8a
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x68, %rsp
movq 0xcd0e(%rip), %rdx      # 0x19348
movq 0xcd0f(%rip), %rsi      # 0x19350
movq 0xccf8(%rip), %r8       # 0x19340
movl %edi, %ecx
movslq %edi, %rax
movslq (%rdx,%rax,4), %rdi
testq %rdi, %rdi
js 0xc663
testb $0x9, (%rsi,%rdi)
jne 0xc663
cmpl $-0x1, (%r8,%rax,4)
je 0xc648
cmpl $-0x1, %edi
je 0xc721
movq 0xccd5(%rip), %rdx      # 0x19348
cmpl $-0x1, (%rdx,%rax,4)
je 0xc721
movq 0xccbc(%rip), %rdi      # 0x19340
movq 0xccc5(%rip), %r8       # 0x19350
movq 0xccb6(%rip), %r9       # 0x19348
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
movq %rax, %r11
movl (%rdi,%r11,4), %esi
cmpq %r10, %rsi
je 0xc709
testl %esi, %esi
js 0xc6b3
cmpb $0x0, (%r8,%rsi)
js 0xc762
leaq (%rdi,%r11,4), %r11
movq 0xcc92(%rip), %rbx      # 0x19350
movq %r11, %rsi
movslq (%rsi), %r14
leaq (%r9,%r14,4), %rsi
cmpl $-0x1, (%rsi)
je 0xc6db
testl %r14d, %r14d
js 0xc733
testb $0x9, (%rbx,%r14)
je 0xc6c1
jmp 0xc733
movq 0xcc6e(%rip), %rbx      # 0x19350
movl %ecx, %r11d
movslq %ecx, %rcx
movslq (%r9,%rcx,4), %rcx
testq %rcx, %rcx
js 0xc6fd
testb $0x9, (%rbx,%rcx)
jne 0xc6fd
cmpl $-0x1, (%rdi,%rcx,4)
je 0xc6e2
cmpl $-0x1, %ecx
je 0xc721
movl (%rdi,%rcx,4), %ecx
movl %ecx, (%rsi)
jmp 0xc70c
movl %ecx, %r11d
movslq %r11d, %rcx
movl (%r9,%rcx,4), %ecx
movslq %ecx, %r11
cmpl $-0x1, (%rdx,%r11,4)
jne 0xc69b
movq 0xcc18(%rip), %rcx      # 0x19340
movl (%rcx,%rax,4), %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movl (%r11), %ebx
leaq 0x6bde(%rip), %rsi      # 0x1331b
leaq 0x7341(%rip), %rdx      # 0x13a85
leaq 0x753f(%rip), %rcx      # 0x13c8a
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x264c
leaq 0x730b(%rip), %rdi      # 0x13a74
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xcbcc(%rip), %rax      # 0x19348
movslq %edi, %r15
movslq (%rax,%r15,4), %rdi
shlq $0x2, %rdi
addq 0xcbca(%rip), %rdi      # 0x19358
callq 0x3c4b
movl %eax, %ebx
cmpl $-0x1, %eax
jne 0xc805
movq 0xcbb7(%rip), %rax      # 0x19358
movq 0xcba0(%rip), %rcx      # 0x19348
movslq (%rcx,%r15,4), %rcx
movl -0x4(%rax,%rcx,4), %ebp
movl $0xffffffee, %edi       # imm = 0xFFFFFFEE
movl %ebp, %esi
callq 0x334b
movl %eax, %ebx
movq 0xcb93(%rip), %rax      # 0x19358
movq 0xcb7c(%rip), %rcx      # 0x19348
movslq %ebx, %r14
movslq (%rcx,%r14,4), %rcx
movb $0x0, (%rax,%rcx,4)
movq 0xcb7a(%rip), %rax      # 0x19358
movq 0xcb63(%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 0x3cb4
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: 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 0xcb3a(%rip), %rax      # 0x19358
movq 0xcb23(%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 0x27dc
movq 0xcb0e(%rip), %rcx      # 0x19350
movslq %eax, %r14
orb $-0x80, (%rcx,%r14)
movq 0xcb07(%rip), %rax      # 0x19358
movq 0xcaf0(%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_O1/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
movl %edi, %ebx
xorl %esi, %esi
cmpl $-0x1, %edi
je 0xc89f
movq 0xcab8(%rip), %rax      # 0x19348
movl %ebx, %ecx
incl %esi
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
cmpl $-0x1, %ecx
jne 0xc892
xorl %edi, %edi
callq 0x27dc
cmpl $-0x1, %ebx
je 0xc926
movq 0xca96(%rip), %rcx      # 0x19348
movslq %eax, %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0xca94(%rip), %rcx      # 0x19358
movl %ebx, %edx
testl %edx, %edx
js 0xc95b
movq 0xca7b(%rip), %rsi      # 0x19350
movl %edx, %edx
testb $0x9, (%rsi,%rdx)
jne 0xc95b
movq 0xca5c(%rip), %rsi      # 0x19340
movslq (%rsi,%rdx,4), %r14
testq %r14, %r14
js 0xc92e
movq 0xca5c(%rip), %rdi      # 0x19350
testb $0x1, (%rdi,%r14)
je 0xc92e
cmpl $-0xc, (%rsi,%r14,4)
jne 0xc92e
movq 0xca3f(%rip), %rdi      # 0x19348
movslq (%rdi,%r14,4), %rdi
movb (%rsi,%rdi,4), %sil
movb %sil, (%rcx)
incq %rcx
movq 0xca2a(%rip), %rsi      # 0x19348
movl (%rsi,%rdx,4), %edx
cmpl $-0x1, %edx
jne 0xc8c6
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x69e6(%rip), %rsi      # 0x1331b
leaq 0x7164(%rip), %rdx      # 0x13aa0
leaq 0x6c09(%rip), %rcx      # 0x1354c
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x264c
leaq 0x7129(%rip), %rdi      # 0x13a8b
movl %ebx, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xc9dd(%rip), %rax      # 0x19358
movq 0xc9c6(%rip), %rcx      # 0x19348
movslq %edi, %r14
movslq (%rcx,%r14,4), %rcx
movslq -0x4(%rax,%rcx,4), %r15
movl %r15d, %ebp
decl %ebp
je 0xca5c
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %eax, %ebx
movl 0xc7be(%rip), %esi      # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0xc7af(%rip)      # 0x19170
cmpl $0x2, %r15d
jl 0xca44
addq $-0x2, %r15
movl %ebp, %r12d
xorl %r13d, %r13d
movq 0xc970(%rip), %rax      # 0x19348
movslq (%rax,%r14,4), %rax
shlq $0x2, %rax
addq 0xc971(%rip), %rax      # 0x19358
movzbl (%r13,%rax), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff4, %edi       # imm = 0xFFFFFFF4
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
movq 0xc92c(%rip), %rcx      # 0x19340
movslq %ebx, %rbp
movl %eax, (%rcx,%rbp,4)
cmpq %r15, %r13
jge 0xca3c
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %eax, %ebx
movq 0xc90f(%rip), %rax      # 0x19348
movl %ebx, (%rax,%rbp,4)
incq %r13
cmpq %r13, %r12
jne 0xc9d1
movl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x33d7
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_O1/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 0xc8d6(%rip), %rax      # 0x19358
movq 0xc8bf(%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 0xcb4d
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %eax, %ebx
movl 0xc6b1(%rip), %esi      # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0xc6a2(%rip)      # 0x19170
testl %r15d, %r15d
jle 0xcb35
leal -0x1(%r15), %eax
movslq %eax, %r12
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq 0xc85d(%rip), %rax      # 0x19348
movslq (%rax,%r14,4), %rax
shlq $0x2, %rax
addq 0xc85e(%rip), %rax      # 0x19358
movl (%rax,%r13,4), %eax
movq 0xc83b(%rip), %rcx      # 0x19340
movslq %ebx, %rbp
movl %eax, (%rcx,%rbp,4)
cmpq %r12, %r13
jge 0xcb2d
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %eax, %ebx
movq 0xc81e(%rip), %rax      # 0x19348
movl %ebx, (%rax,%rbp,4)
incq %r13
cmpq %r13, %r15
jne 0xcae4
movl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x33d7
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_O1/blakemcbride[P]LISP9/ls9.c
// Function: numstr
cell numstr(cell x, int r) {
	char	*p;

	if (r < 2 || r > 36)
		error("numstr: bad radix", mkfix(r));
	p = ntoa(fixval(x), r);
	return mkstr(p, strlen(p));
}

// Assembly:
pushq %rbx
leal -0x25(%rsi), %eax
cmpl $-0x24, %eax
jbe 0xcbd2
movq 0xc7cf(%rip), %rax      # 0x19340
movq 0xc7d0(%rip), %rcx      # 0x19348
movslq %edi, %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %ecx
movb $0x0, 0xcb8e(%rip)      # 0x19717
leaq 0xcb86(%rip), %rbx      # 0x19716
leaq 0x7779(%rip), %rdi      # 0x14310
movl %ecx, %eax
cltd
idivl %esi
movl %edx, %r8d
negl %r8d
cmovsl %edx, %r8d
movb (%r8,%rdi), %dl
movb %dl, (%rbx)
decq %rbx
testl %eax, %eax
jne 0xcb99
testl %ecx, %ecx
js 0xcbbc
incq %rbx
jmp 0xcbbf
movb $0x2d, (%rbx)
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
jmp 0x27dc
movl %esi, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
leaq 0x6ee0(%rip), %rdi      # 0x13adb
movl %eax, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: loadfile
void loadfile(char *s) {
	int	ldport, rdport, oline;
	cell	x;

	ldport = open_inport(s);
	if (ldport < 0)
		error("load: cannot open file",
			mkstr(s, strlen(s)));
	lock_port(ldport);
	rdport = Inport;
	oline = Line;
	Files = cons(mkstr(s, strlen(s)), Files);
	Line = 1;
	begin_rec();
	for (;;) {
		set_inport(ldport);
		x = xread();
		set_inport(rdport);
		if (EOFMARK == x) break;
		eval(x, 0);
	}
	end_rec();
	Files = cdr(Files);
	Line = oline;
	close_port(ldport);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
callq 0x3f83
testl %eax, %eax
js 0xcd2e
movl %eax, %ebx
movl %eax, %r15d
cmpl $0x13, %eax
ja 0xcc70
leaq 0xc995(%rip), %rax      # 0x19600
orb $0x40, (%r15,%rax)
movl 0xc8d1(%rip), %r12d     # 0x19548
movl 0xc4b7(%rip), %ebp      # 0x19134
movq %r14, %rdi
callq 0x2080
movq %r14, %rdi
movl %eax, %esi
callq 0x27dc
movl 0xc4a3(%rip), %esi      # 0x19138
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0xc494(%rip)      # 0x19138
movl $0x1, 0xc486(%rip)      # 0x19134
callq 0xcd4e
movl %ebx, 0xc88f(%rip)      # 0x19548
callq 0x511d
movl %r12d, 0xc883(%rip)     # 0x19548
cmpl $-0x3, %eax
je 0xccd5
movl %eax, %edi
xorl %esi, %esi
callq 0x9c5e
jmp 0xccb3
callq 0xce30
movq 0xc667(%rip), %rax      # 0x19348
movslq 0xc450(%rip), %rcx      # 0x19138
movl (%rax,%rcx,4), %eax
movl %eax, 0xc447(%rip)      # 0x19138
movl %ebp, 0xc43d(%rip)      # 0x19134
cmpl $0x13, %ebx
ja 0xcd25
leaq 0xc85d(%rip), %rbx      # 0x19560
movq (%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0xcd19
callq 0x2070
movq $0x0, (%rbx,%r15,8)
leaq 0xc8e0(%rip), %rax      # 0x19600
movb $0x0, (%r15,%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x2080
movq %r14, %rdi
movl %eax, %esi
callq 0x27dc
leaq 0x6db8(%rip), %rdi      # 0x13aff
movl %eax, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: begin_rec
void begin_rec(void) {
	protect(Prog);
	protect(Ep);
	protect(mkfix(Ip));
	protect(mkfix(Sp));
	protect(mkfix(Fp));
}

// Assembly:
pushq %rax
movl 0xc467(%rip), %edi      # 0x191bc
movl 0xc415(%rip), %esi      # 0x19170
xorl %edx, %edx
callq 0x3162
movl %eax, 0xc408(%rip)      # 0x19170
movl 0xc462(%rip), %edi      # 0x191d0
movl %eax, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, 0xc3f3(%rip)      # 0x19170
movl 0xcbd5(%rip), %edi      # 0x19958
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
movl 0xc3c7(%rip), %esi      # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0xc3b8(%rip)      # 0x19170
movl 0xc3a2(%rip), %edi      # 0x19160
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
movl 0xc38c(%rip), %esi      # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0xc37d(%rip)      # 0x19170
movl 0xc3cf(%rip), %edi      # 0x191c8
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
movl 0xc351(%rip), %esi      # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0xc342(%rip)      # 0x19170
popq %rax
retq