LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: scomp
int scomp(cell x, cell y) {
	int	kx, ky;

	kx = stringlen(x);
	ky = stringlen(y);
	if (kx == ky) return memcmp(string(x), string(y), kx);
	return memcmp(string(x), string(y), 1+(kx<ky? kx: ky));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x117c3(%rip), %rax     # 0x20358
movq 0x117ac(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
movq 0x117a2(%rip), %rax     # 0x20358
movq 0x1178b(%rip), %rcx     # 0x20348
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0xec20
movq 0x11779(%rip), %rdi     # 0x20358
movq 0x11762(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x1175c(%rip), %rsi     # 0x20358
movq 0x11745(%rip), %rax     # 0x20348
movslq -0xc(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rsi
movslq -0x10(%rbp), %rdx
callq 0x20f0
movl %eax, -0x4(%rbp)
jmp 0xec91
movq 0x11731(%rip), %rax     # 0x20358
movq 0x1171a(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq 0x11710(%rip), %rax     # 0x20358
movq 0x116f9(%rip), %rcx     # 0x20348
movslq -0xc(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xec72
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0xec78
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x20f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: memcmp_ci
int memcmp_ci(char *a, char *b, int k) {
	int	i, d;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xed0c
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2160
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2160
movl %eax, %ecx
movl -0x28(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0xecff
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xed13
jmp 0xed01
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xecba
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: scomp_ci
int scomp_ci(cell x, cell y) {
	int	kx, ky;

	kx = stringlen(x);
	ky = stringlen(y);
	if (kx == ky)
		return memcmp_ci((char *) string(x),
				(char *) string(y), kx);
	return memcmp_ci((char *) string(x), (char *) string(y),
			1+(kx<ky? kx: ky));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x11623(%rip), %rax     # 0x20358
movq 0x1160c(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
movq 0x11602(%rip), %rax     # 0x20358
movq 0x115eb(%rip), %rcx     # 0x20348
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0xedbf
movq 0x115d9(%rip), %rdi     # 0x20358
movq 0x115c2(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x115bc(%rip), %rsi     # 0x20358
movq 0x115a5(%rip), %rax     # 0x20348
movslq -0xc(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rsi
movl -0x10(%rbp), %edx
callq 0xeca0
movl %eax, -0x4(%rbp)
jmp 0xee2d
movq 0x11592(%rip), %rax     # 0x20358
movq 0x1157b(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq 0x11571(%rip), %rax     # 0x20358
movq 0x1155a(%rip), %rcx     # 0x20348
movslq -0xc(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xee11
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0xee17
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %edx
addl $0x1, %edx
callq 0xeca0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x113a3(%rip), %rax     # 0x20358
movq 0x1138c(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
cmpq $0x0, %rax
jne 0xefe7
movl -0x8(%rbp), %edx
leaq 0xc9b1(%rip), %rdi      # 0x1b98c
leaq 0xc5fb(%rip), %rsi      # 0x1b5dd
callq 0x2950
movq 0x1136a(%rip), %rax     # 0x20358
movq 0x11353(%rip), %rcx     # 0x20348
movslq -0xc(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
cmpq $0x0, %rax
jne 0xf020
movl -0xc(%rbp), %edx
leaq 0xc978(%rip), %rdi      # 0x1b98c
leaq 0xc5c2(%rip), %rsi      # 0x1b5dd
callq 0x2950
movq 0x11331(%rip), %rax     # 0x20358
movq 0x1131a(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq 0x11313(%rip), %rcx     # 0x20358
movq 0x112fc(%rip), %rdx     # 0x20348
movslq -0xc(%rbp), %rsi
movl (%rdx,%rsi,4), %edx
subl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
je 0xf067
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf087
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0xeb80
movl %eax, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x10ff3(%rip), %rax     # 0x20358
movq 0x10fdc(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
cmpq $0x0, %rax
jne 0xf397
movl -0x8(%rbp), %edx
leaq 0xc614(%rip), %rdi      # 0x1b99f
leaq 0xc24b(%rip), %rsi      # 0x1b5dd
callq 0x2950
movq 0x10fba(%rip), %rax     # 0x20358
movq 0x10fa3(%rip), %rcx     # 0x20348
movslq -0xc(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
cmpq $0x0, %rax
jne 0xf3d0
movl -0xc(%rbp), %edx
leaq 0xc5db(%rip), %rdi      # 0x1b99f
leaq 0xc212(%rip), %rsi      # 0x1b5dd
callq 0x2950
movq 0x10f81(%rip), %rax     # 0x20358
movq 0x10f6a(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq 0x10f63(%rip), %rcx     # 0x20358
movq 0x10f4c(%rip), %rdx     # 0x20348
movslq -0xc(%rbp), %rsi
movl (%rdx,%rsi,4), %edx
subl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
je 0xf417
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf437
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0xed20
movl %eax, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0xf5e0
movq 0x10d95(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xf5e0
movq 0x10d6e(%rip), %rcx     # 0x20340
movslq -0x4(%rbp), %rdx
movl $0xfffffff2, %eax       # imm = 0xFFFFFFF2
cmpl (%rcx,%rdx,4), %eax
je 0xf5f6
movl -0x4(%rbp), %edx
leaq 0xc3c2(%rip), %rdi      # 0x1b9ac
leaq 0xc32e(%rip), %rsi      # 0x1b91f
callq 0x2950
cmpl $0x0, -0x8(%rbp)
jl 0xf628
movq 0x10d4d(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xf628
movq 0x10d26(%rip), %rcx     # 0x20340
movslq -0x8(%rbp), %rdx
movl $0xfffffff4, %eax       # imm = 0xFFFFFFF4
cmpl (%rcx,%rdx,4), %eax
je 0xf63e
movl -0x8(%rbp), %edx
leaq 0xc37a(%rip), %rdi      # 0x1b9ac
leaq 0xbfb3(%rip), %rsi      # 0x1b5ec
callq 0x2950
movq 0x10cfb(%rip), %rax     # 0x20340
movq 0x10cfc(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movq 0x10cdf(%rip), %rax     # 0x20340
movq 0x10ce0(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
xorl %eax, %eax
movl %eax, %edi
callq 0x2880
movl %eax, -0xc(%rbp)
movq 0x10ccc(%rip), %rax     # 0x20358
movq 0x10cb5(%rip), %rcx     # 0x20348
movslq -0xc(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xf6d0
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xf6ad
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
je 0xf7be
movq 0x10c37(%rip), %rax     # 0x20340
movslq -0x8(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0xf755
movq 0x10c36(%rip), %rax     # 0x20350
movq 0x10c1f(%rip), %rcx     # 0x20340
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xf755
movq 0x10c04(%rip), %rcx     # 0x20340
movq 0x10bfd(%rip), %rax     # 0x20340
movslq -0x8(%rbp), %rdx
movslq (%rax,%rdx,4), %rdx
movl $0xffffffef, %eax       # imm = 0xFFFFFFEF
cmpl (%rcx,%rdx,4), %eax
je 0xf776
movq 0x10be4(%rip), %rax     # 0x20340
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0xc248(%rip), %rdi      # 0x1b9b2
leaq 0xbe6c(%rip), %rsi      # 0x1b5dd
callq 0x2950
movq 0x10bdb(%rip), %rax     # 0x20358
movq 0x10bc4(%rip), %rcx     # 0x20348
movq 0x10bb5(%rip), %rdx     # 0x20340
movslq -0x8(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
subl $0x1, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movq 0x10b99(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
jmp 0xf6f8
movl -0x10(%rbp), %esi
xorl %eax, %eax
movl %eax, %edi
callq 0x2880
movl %eax, -0xc(%rbp)
movq 0x10b84(%rip), %rax     # 0x20358
movq 0x10b6d(%rip), %rcx     # 0x20348
movslq -0xc(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
je 0xf88f
movq 0x10b4c(%rip), %rax     # 0x20358
movq 0x10b35(%rip), %rcx     # 0x20348
movq 0x10b26(%rip), %rdx     # 0x20340
movslq -0x8(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x10(%rbp), %rax
addq %rax, %rdi
movq 0x10b15(%rip), %rsi     # 0x20358
movq 0x10afe(%rip), %rax     # 0x20348
movq 0x10aef(%rip), %rcx     # 0x20340
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rsi
movslq -0x14(%rbp), %rdx
callq 0x2150
movl -0x14(%rbp), %eax
subl $0x1, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movq 0x10ac8(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
jmp 0xf7fb
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0xf8e0
movq 0x10a95(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xf8e0
movq 0x10a6e(%rip), %rcx     # 0x20340
movslq -0x4(%rbp), %rdx
movl $0xffffffef, %eax       # imm = 0xFFFFFFEF
cmpl (%rcx,%rdx,4), %eax
je 0xf8f6
movl -0x4(%rbp), %edx
leaq 0xc0ce(%rip), %rdi      # 0x1b9b8
leaq 0xbcec(%rip), %rsi      # 0x1b5dd
callq 0x2950
cmpl $0x0, -0x8(%rbp)
jl 0xf928
movq 0x10a4d(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xf928
movq 0x10a26(%rip), %rcx     # 0x20340
movslq -0x8(%rbp), %rdx
movl $0xfffffff2, %eax       # imm = 0xFFFFFFF2
cmpl (%rcx,%rdx,4), %eax
je 0xf93e
movl -0x8(%rbp), %edx
leaq 0xc086(%rip), %rdi      # 0x1b9b8
leaq 0xbfe6(%rip), %rsi      # 0x1b91f
callq 0x2950
movq 0x109fb(%rip), %rax     # 0x20340
movq 0x109fc(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0xf988
movl -0xc(%rbp), %eax
movq 0x109ee(%rip), %rcx     # 0x20358
movq 0x109d7(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movl (%rdx,%rsi,4), %edx
subl $0x1, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jl 0xf997
movl -0x8(%rbp), %esi
leaq 0xc02b(%rip), %rdi      # 0x1b9bd
callq 0x26c0
movq 0x109ba(%rip), %rax     # 0x20358
movq 0x109a3(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %edi
andl $0xff, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff4, %edi       # imm = 0xFFFFFFF4
movl $0x1, %edx
callq 0x3990
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: 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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0xfa33
movq 0x10942(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xfa33
movq 0x1091b(%rip), %rcx     # 0x20340
movslq -0x4(%rbp), %rdx
movl $0xffffffef, %eax       # imm = 0xFFFFFFEF
cmpl (%rcx,%rdx,4), %eax
je 0xfa49
movl -0x4(%rbp), %edx
leaq 0xbf99(%rip), %rdi      # 0x1b9d6
leaq 0xbb99(%rip), %rsi      # 0x1b5dd
callq 0x2950
cmpl $0x0, -0x4(%rbp)
jl 0xfa77
movq 0x108fa(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xfa77
movl -0x4(%rbp), %esi
leaq 0xbf69(%rip), %rdi      # 0x1b9db
callq 0x26c0
cmpl $0x0, -0x8(%rbp)
jl 0xfaa9
movq 0x108cc(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xfaa9
movq 0x108a5(%rip), %rcx     # 0x20340
movslq -0x8(%rbp), %rdx
movl $0xfffffff2, %eax       # imm = 0xFFFFFFF2
cmpl (%rcx,%rdx,4), %eax
je 0xfabf
movl -0x8(%rbp), %edx
leaq 0xbf23(%rip), %rdi      # 0x1b9d6
leaq 0xbe65(%rip), %rsi      # 0x1b91f
callq 0x2950
cmpl $0x0, -0xc(%rbp)
jl 0xfaf1
movq 0x10884(%rip), %rax     # 0x20350
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xfaf1
movq 0x1085d(%rip), %rcx     # 0x20340
movslq -0xc(%rbp), %rdx
movl $0xfffffff4, %eax       # imm = 0xFFFFFFF4
cmpl (%rcx,%rdx,4), %eax
je 0xfb07
movl -0xc(%rbp), %edx
leaq 0xbedb(%rip), %rdi      # 0x1b9d6
leaq 0xbaea(%rip), %rsi      # 0x1b5ec
callq 0x2950
movq 0x10832(%rip), %rax     # 0x20340
movq 0x10833(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0xfb51
movl -0x10(%rbp), %eax
movq 0x10825(%rip), %rcx     # 0x20358
movq 0x1080e(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movl (%rdx,%rsi,4), %edx
subl $0x1, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jl 0xfb60
movl -0x8(%rbp), %esi
leaq 0xbe90(%rip), %rdi      # 0x1b9eb
callq 0x26c0
movq 0x107d9(%rip), %rax     # 0x20340
movq 0x107da(%rip), %rcx     # 0x20348
movslq -0xc(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movb %al, %dl
movq 0x107d6(%rip), %rax     # 0x20358
movq 0x107bf(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0xfe30
movq 0x10545(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xfe30
movq 0x1051e(%rip), %rcx     # 0x20340
movslq -0x4(%rbp), %rdx
movl $0xffffffef, %eax       # imm = 0xFFFFFFEF
cmpl (%rcx,%rdx,4), %eax
je 0xfe46
movl -0x4(%rbp), %edx
leaq 0xbbe7(%rip), %rdi      # 0x1ba21
leaq 0xb79c(%rip), %rsi      # 0x1b5dd
callq 0x2950
cmpl $0x0, -0x4(%rbp)
jl 0xfe74
movq 0x104fd(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xfe74
movl -0x4(%rbp), %esi
leaq 0xbbb8(%rip), %rdi      # 0x1ba27
callq 0x26c0
cmpl $0x0, -0x8(%rbp)
jl 0xfea6
movq 0x104cf(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xfea6
movq 0x104a8(%rip), %rcx     # 0x20340
movslq -0x8(%rbp), %rdx
movl $0xfffffff4, %eax       # imm = 0xFFFFFFF4
cmpl (%rcx,%rdx,4), %eax
je 0xfebc
movl -0x8(%rbp), %edx
leaq 0xbb71(%rip), %rdi      # 0x1ba21
leaq 0xb735(%rip), %rsi      # 0x1b5ec
callq 0x2950
movq 0x1047d(%rip), %rax     # 0x20340
movq 0x1047e(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movq 0x10479(%rip), %rax     # 0x20358
movq 0x10462(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movq 0x10455(%rip), %rax     # 0x20358
movq 0x1043e(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xff47
movl -0xc(%rbp), %eax
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xff24
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0xff90
movq 0x103e5(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xff90
movq 0x103be(%rip), %rcx     # 0x20340
movslq -0x4(%rbp), %rdx
movl $0xfffffff2, %eax       # imm = 0xFFFFFFF2
cmpl (%rcx,%rdx,4), %eax
je 0xffa6
movl -0x4(%rbp), %edx
leaq 0xba9e(%rip), %rdi      # 0x1ba38
leaq 0xb97e(%rip), %rsi      # 0x1b91f
callq 0x2950
movq 0x10393(%rip), %rax     # 0x20340
movq 0x10394(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x3d80
movl %eax, -0xc(%rbp)
movq 0x10384(%rip), %rax     # 0x20358
movq 0x1036d(%rip), %rcx     # 0x20348
movslq -0xc(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x10016
movl -0x8(%rbp), %edx
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xfff5
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
je 0x10114
movq 0x102f7(%rip), %rax     # 0x20340
movslq -0x8(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0x10095
movq 0x102f6(%rip), %rax     # 0x20350
movq 0x102df(%rip), %rcx     # 0x20340
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x10095
movq 0x102c4(%rip), %rcx     # 0x20340
movq 0x102bd(%rip), %rax     # 0x20340
movslq -0x8(%rbp), %rdx
movslq (%rax,%rdx,4), %rdx
movl $0xffffffed, %eax       # imm = 0xFFFFFFED
cmpl (%rcx,%rdx,4), %eax
je 0x100b6
movq 0x102a4(%rip), %rax     # 0x20340
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0xb994(%rip), %rdi      # 0x1ba3e
leaq 0xb993(%rip), %rsi      # 0x1ba44
callq 0x2950
movq 0x1029b(%rip), %rax     # 0x20358
movq 0x10284(%rip), %rcx     # 0x20348
movq 0x10275(%rip), %rdx     # 0x20340
movslq -0x8(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movslq (%rax,%rcx,4), %rcx
addq $0x4, %rcx
subq $0x1, %rcx
shrq $0x2, %rcx
addq $0x2, %rcx
subq $0x2, %rcx
movslq -0x1c(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
movq 0x10243(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
jmp 0x10038
movl -0x1c(%rbp), %edi
callq 0x3d80
movl %eax, -0xc(%rbp)
movq 0x10232(%rip), %rax     # 0x20358
movq 0x1021b(%rip), %rcx     # 0x20348
movslq -0xc(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
je 0x101fb
movq 0x101fa(%rip), %rax     # 0x20358
movq 0x101e3(%rip), %rcx     # 0x20348
movq 0x101d4(%rip), %rdx     # 0x20340
movslq -0x8(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movslq (%rax,%rcx,4), %rax
addq $0x4, %rax
subq $0x1, %rax
shrq $0x2, %rax
addq $0x2, %rax
subq $0x2, %rax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x101aa(%rip), %rsi     # 0x20358
movq 0x10193(%rip), %rax     # 0x20348
movq 0x10184(%rip), %rcx     # 0x20340
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rsi
movslq -0x20(%rbp), %rdx
shlq $0x2, %rdx
callq 0x2150
movl -0x20(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq 0x1015c(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
jmp 0x1014d
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: 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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x10250
movq 0x10125(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x10250
movq 0x100fe(%rip), %rcx     # 0x20340
movslq -0x4(%rbp), %rdx
movl $0xffffffed, %eax       # imm = 0xFFFFFFED
cmpl (%rcx,%rdx,4), %eax
je 0x10266
movl -0x4(%rbp), %edx
leaq 0xb7f1(%rip), %rdi      # 0x1ba4b
leaq 0xb7e3(%rip), %rsi      # 0x1ba44
callq 0x2950
cmpl $0x0, -0x8(%rbp)
jl 0x10298
movq 0x100dd(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x10298
movq 0x100b6(%rip), %rcx     # 0x20340
movslq -0x8(%rbp), %rdx
movl $0xfffffff2, %eax       # imm = 0xFFFFFFF2
cmpl (%rcx,%rdx,4), %eax
je 0x102ae
movl -0x8(%rbp), %edx
leaq 0xb7a9(%rip), %rdi      # 0x1ba4b
leaq 0xb676(%rip), %rsi      # 0x1b91f
callq 0x2950
movq 0x1008b(%rip), %rax     # 0x20340
movq 0x1008c(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x1030c
movslq -0xc(%rbp), %rax
movq 0x1007d(%rip), %rcx     # 0x20358
movq 0x10066(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movl (%rdx,%rsi,4), %edx
subl $0x1, %edx
movslq %edx, %rdx
movslq (%rcx,%rdx,4), %rcx
addq $0x4, %rcx
subq $0x1, %rcx
shrq $0x2, %rcx
addq $0x2, %rcx
subq $0x2, %rcx
cmpq %rcx, %rax
jb 0x1031b
movl -0x8(%rbp), %esi
leaq 0xb73a(%rip), %rdi      # 0x1ba50
callq 0x26c0
movq 0x10036(%rip), %rax     # 0x20358
movq 0x1001f(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x10390
movq 0xffe5(%rip), %rax      # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x10390
movq 0xffbe(%rip), %rcx      # 0x20340
movslq -0x4(%rbp), %rdx
movl $0xffffffed, %eax       # imm = 0xFFFFFFED
cmpl (%rcx,%rdx,4), %eax
je 0x103a6
movl -0x4(%rbp), %edx
leaq 0xb6cf(%rip), %rdi      # 0x1ba69
leaq 0xb6a3(%rip), %rsi      # 0x1ba44
callq 0x2950
cmpl $0x0, -0x4(%rbp)
jl 0x103d4
movq 0xff9d(%rip), %rax      # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x103d4
movl -0x4(%rbp), %esi
leaq 0xb6a0(%rip), %rdi      # 0x1ba6f
callq 0x26c0
movq 0xff7d(%rip), %rax      # 0x20358
movq 0xff66(%rip), %rcx      # 0x20348
movslq -0x4(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movslq (%rax,%rcx,4), %rax
addq $0x4, %rax
subq $0x1, %rax
shrq $0x2, %rax
addq $0x2, %rax
subq $0x2, %rax
movl %eax, -0x10(%rbp)
movq 0xff47(%rip), %rax      # 0x20358
movq 0xff30(%rip), %rcx      # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x10453
movl -0x8(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x10432
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x104a3
movq 0xfed2(%rip), %rax      # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x104a3
movq 0xfeab(%rip), %rcx      # 0x20340
movslq -0x4(%rbp), %rdx
movl $0xffffffed, %eax       # imm = 0xFFFFFFED
cmpl (%rcx,%rdx,4), %eax
je 0x104b9
movl -0x4(%rbp), %edx
leaq 0xb5d3(%rip), %rdi      # 0x1ba80
leaq 0xb590(%rip), %rsi      # 0x1ba44
callq 0x2950
cmpl $0x0, -0x4(%rbp)
jl 0x104e7
movq 0xfe8a(%rip), %rax      # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x104e7
movl -0x4(%rbp), %esi
leaq 0xb5a3(%rip), %rdi      # 0x1ba85
callq 0x26c0
cmpl $0x0, -0x8(%rbp)
jl 0x10519
movq 0xfe5c(%rip), %rax      # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x10519
movq 0xfe35(%rip), %rcx      # 0x20340
movslq -0x8(%rbp), %rdx
movl $0xfffffff2, %eax       # imm = 0xFFFFFFF2
cmpl (%rcx,%rdx,4), %eax
je 0x1052f
movl -0x8(%rbp), %edx
leaq 0xb55d(%rip), %rdi      # 0x1ba80
leaq 0xb3f5(%rip), %rsi      # 0x1b91f
callq 0x2950
movq 0xfe0a(%rip), %rax      # 0x20340
movq 0xfe0b(%rip), %rcx      # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x1058d
movslq -0x10(%rbp), %rax
movq 0xfdfc(%rip), %rcx      # 0x20358
movq 0xfde5(%rip), %rdx      # 0x20348
movslq -0x4(%rbp), %rsi
movl (%rdx,%rsi,4), %edx
subl $0x1, %edx
movslq %edx, %rdx
movslq (%rcx,%rdx,4), %rcx
addq $0x4, %rcx
subq $0x1, %rcx
shrq $0x2, %rcx
addq $0x2, %rcx
subq $0x2, %rcx
cmpq %rcx, %rax
jb 0x1059c
movl -0x8(%rbp), %esi
leaq 0xb4fe(%rip), %rdi      # 0x1ba95
callq 0x26c0
movl -0xc(%rbp), %edx
movq 0xfdb2(%rip), %rax      # 0x20358
movq 0xfd9b(%rip), %rcx      # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xb556(%rip), %rsi      # 0x1bd7d
callq 0x21c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x10840
movq -0x10(%rbp), %rdi
callq 0x2080
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovel %ecx, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x1088e
jmp 0x1087a
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x108b5
jmp 0x10884
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x108de
jmp 0x10908
movq 0xfac3(%rip), %rdi      # 0x20358
movq 0xfaac(%rip), %rax      # 0x20348
movslq -0x4(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x5090
movl %eax, -0xc(%rbp)
jmp 0x10908
movq 0xfa9c(%rip), %rdi      # 0x20358
movq 0xfa85(%rip), %rax      # 0x20348
movslq -0x4(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdi
xorl %esi, %esi
callq 0x5100
movl %eax, -0xc(%rbp)
jmp 0x10908
movq 0xfa73(%rip), %rdi      # 0x20358
movq 0xfa5c(%rip), %rax      # 0x20348
movslq -0x4(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdi
movl $0x1, %esi
callq 0x5100
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x10937
xorl %eax, %eax
cmpl -0x8(%rbp), %eax
jne 0x10926
movl -0x4(%rbp), %esi
leaq 0xb1ac(%rip), %rdi      # 0x1bacb
callq 0x26c0
jmp 0x10935
movl -0x4(%rbp), %esi
leaq 0xb1b4(%rip), %rdi      # 0x1bae4
callq 0x26c0
jmp 0x10937
movl -0xc(%rbp), %edi
movl -0x8(%rbp), %edx
xorl %ecx, %ecx
movl $0xfffffff0, %esi       # imm = 0xFFFFFFF0
movl $0xfffffff1, %eax       # imm = 0xFFFFFFF1
cmpl %edx, %ecx
cmovel %eax, %esi
callq 0x2b30
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl 0xfbd4(%rip), %eax      # 0x20548
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x10987
movl -0x8(%rbp), %edi
callq 0x5190
callq 0x29f0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x1099d
movl -0x14(%rbp), %edi
callq 0x2ab0
movl -0x8(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x109ad
movl -0x10(%rbp), %edi
callq 0x5190
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x14(%rbp), %eax
jne 0x109c0
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x109ec
movl -0x14(%rbp), %edi
andl $0xff, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff4, %edi       # imm = 0xFFFFFFF4
movl $0x1, %edx
callq 0x3990
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: 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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x10acc
movq 0xf934(%rip), %rax      # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x10acc
movq 0xf909(%rip), %rcx      # 0x20340
movslq -0x8(%rbp), %rdx
movl $0xffffffef, %eax       # imm = 0xFFFFFFEF
cmpl (%rcx,%rdx,4), %eax
jne 0x10acc
movq 0xf908(%rip), %rax      # 0x20358
movq 0xf8f1(%rip), %rcx      # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0xfaeb(%rip)      # 0x20558
movb $-0x1, 0xf6e0(%rip)     # 0x20154
callq 0x6a20
movl %eax, -0x10(%rbp)
movq $0x0, 0xfad1(%rip) # 0x20558
cmpq $0x0, 0xfb99(%rip)      # 0x20628
je 0x10ab8
movq 0xfb90(%rip), %rax      # 0x20628
movq %rax, -0x18(%rbp)
movq 0xfb85(%rip), %rdi      # 0x20628
callq 0x2090
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x2880
movl %eax, -0x4(%rbp)
jmp 0x10b1f
movl -0x10(%rbp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl %eax, -0x4(%rbp)
jmp 0x10b1f
movq 0xf86d(%rip), %rax      # 0x20340
movq 0xf86e(%rip), %rcx      # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
movl 0xfa5a(%rip), %eax      # 0x20548
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x10b01
movl -0x8(%rbp), %edi
callq 0x5190
callq 0x6a20
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x10b19
movl -0xc(%rbp), %edi
callq 0x5190
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl 0xf601(%rip), %eax      # 0x20148
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x10b5a
movl -0x8(%rbp), %edi
callq 0x2580
movl -0xc(%rbp), %edi
movl -0x4(%rbp), %esi
xorl %edx, %edx
callq 0x7050
movl -0x8(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x10b77
movl -0x10(%rbp), %edi
callq 0x2580
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
xorl %eax, %eax
movl %eax, %edi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x2880
movl %eax, 0xf5b1(%rip)      # 0x20150
movl $0x3e8, 0xf9a3(%rip)    # imm = 0x3E8
movl $0x0, 0xf99d(%rip)      # 0x20550
movl -0x4(%rbp), %esi
movl $0x1, %edi
xorl %edx, %edx
callq 0x7050
movl 0xf988(%rip), %esi      # 0x20550
xorl %eax, %eax
movl %eax, %edi
callq 0x2880
movl %eax, -0x8(%rbp)
movq 0xf77d(%rip), %rdi      # 0x20358
movq 0xf766(%rip), %rax      # 0x20348
movslq -0x8(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0xf760(%rip), %rsi      # 0x20358
movq 0xf749(%rip), %rax      # 0x20348
movslq 0xf54a(%rip), %rcx      # 0x20150
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rsi
movl 0xf939(%rip), %eax      # 0x20550
addl $0x1, %eax
movslq %eax, %rdx
callq 0x2150
movl $0xffffffff, 0xf524(%rip) # imm = 0xFFFFFFFF
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl 0xf4f4(%rip), %eax      # 0x20148
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x10c67
movl -0x8(%rbp), %edi
callq 0x2580
movl -0x4(%rbp), %edi
callq 0x2de0
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x10c7f
movl -0xc(%rbp), %edi
callq 0x2580
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x10cd0
movq 0xf6a5(%rip), %rax      # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x10cd0
movq 0xf67e(%rip), %rcx      # 0x20340
movslq -0x4(%rbp), %rdx
movl $0xffffffef, %eax       # imm = 0xFFFFFFEF
cmpl (%rcx,%rdx,4), %eax
je 0x10ce6
movl -0x4(%rbp), %edx
leaq 0xae33(%rip), %rdi      # 0x1bb0d
leaq 0xa8fc(%rip), %rsi      # 0x1b5dd
callq 0x2950
cmpl $0x0, -0x8(%rbp)
jl 0x10d18
movq 0xf65d(%rip), %rax      # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x10d18
movq 0xf636(%rip), %rcx      # 0x20340
movslq -0x8(%rbp), %rdx
movl $0xffffffef, %eax       # imm = 0xFFFFFFEF
cmpl (%rcx,%rdx,4), %eax
je 0x10d2e
movl -0x8(%rbp), %edx
leaq 0xadeb(%rip), %rdi      # 0x1bb0d
leaq 0xa8b4(%rip), %rsi      # 0x1b5dd
callq 0x2950
movq 0xf623(%rip), %rdi      # 0x20358
movq 0xf60c(%rip), %rax      # 0x20348
movslq -0x4(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0xf606(%rip), %rsi      # 0x20358
movq 0xf5ef(%rip), %rax      # 0x20348
movslq -0x8(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x21d0
cmpl $0x0, %eax
jge 0x10da1
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl -0xc(%rbp), %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3990
movl %eax, %esi
leaq 0xad62(%rip), %rdi      # 0x1bafe
callq 0x26c0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq 0xf0a6(%rip), %rdi      # 0x20358
movq 0xf08f(%rip), %rax      # 0x20348
movslq -0x8(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x4b90
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0x112e1
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x11365
movq 0xf070(%rip), %rax      # 0x20358
movq 0xf059(%rip), %rcx      # 0x20348
movslq -0x8(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
subl $0x1, %esi
leaq 0xaf72(%rip), %rdi      # 0x1c281
callq 0x4b30
movl %eax, -0x10(%rbp)
movq 0xf03a(%rip), %rdi      # 0x20358
movq 0xf023(%rip), %rax      # 0x20348
movslq -0x10(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0xf01d(%rip), %rsi      # 0x20358
movq 0xf006(%rip), %rax      # 0x20348
movslq -0x8(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rsi
movslq -0x14(%rbp), %rdx
callq 0x2150
movl -0x10(%rbp), %edi
callq 0x4c00
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0xefd6(%rip), %rax      # 0x20358
movq 0xefbf(%rip), %rcx      # 0x20348
movslq -0x4(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
subl $0x1, %esi
xorl %eax, %eax
movl %eax, %edi
callq 0x2880
movl %eax, -0x8(%rbp)
movq 0xef9b(%rip), %rax      # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %edx
orl $0x80, %edx
movb %dl, (%rax,%rcx)
movq 0xef8b(%rip), %rdi      # 0x20358
movq 0xef74(%rip), %rax      # 0x20348
movslq -0x8(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0xef6e(%rip), %rsi      # 0x20358
movq 0xef57(%rip), %rax      # 0x20348
movslq -0x4(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rsi
movslq -0xc(%rbp), %rdx
callq 0x2150
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
je 0x1145a
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq 0xeefa(%rip), %rax      # 0x20348
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
jmp 0x11438
movl -0x10(%rbp), %esi
xorl %eax, %eax
movl %eax, %edi
callq 0x2880
movl %eax, -0xc(%rbp)
movq 0xeee8(%rip), %rax      # 0x20358
movq 0xeed1(%rip), %rcx      # 0x20348
movslq -0xc(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
je 0x1159f
cmpl $0x0, -0x8(%rbp)
jl 0x114ce
movq 0xeea9(%rip), %rax      # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x114ce
movq 0xee92(%rip), %rax      # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x114dd
movl -0x4(%rbp), %esi
leaq 0xa653(%rip), %rdi      # 0x1bb2b
callq 0x26c0
movq 0xee5c(%rip), %rax      # 0x20340
movslq -0x8(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0x11530
movq 0xee5b(%rip), %rax      # 0x20350
movq 0xee44(%rip), %rcx      # 0x20340
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x11530
movq 0xee29(%rip), %rcx      # 0x20340
movq 0xee22(%rip), %rax      # 0x20340
movslq -0x8(%rbp), %rdx
movslq (%rax,%rdx,4), %rdx
movl $0xfffffff4, %eax       # imm = 0xFFFFFFF4
cmpl (%rcx,%rdx,4), %eax
je 0x11551
movq 0xee09(%rip), %rax      # 0x20340
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0xa5fb(%rip), %rdi      # 0x1bb40
leaq 0xa0a0(%rip), %rsi      # 0x1b5ec
callq 0x2950
movq 0xede8(%rip), %rax      # 0x20340
movq 0xede9(%rip), %rcx      # 0x20348
movq 0xedda(%rip), %rdx      # 0x20340
movslq -0x8(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq 0xedb8(%rip), %rax      # 0x20348
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
jmp 0x11490
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)