LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: ckargs
void ckargs(cell x, int min, int max) {
	int	k;
	char	buf[100];

	k = length(x)-1;
	if (k < min || (k > max && max >= 0)) {
		sprintf(buf, "%s: wrong number of arguments",
			symname(car(x)));
		error(buf, x);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %edi, %ebx
xorl %eax, %eax
cmpl $-0x1, %edi
je 0x5ceb
movq 0x1366c(%rip), %rcx     # 0x19348
movl %ebx, %edi
incl %eax
movslq %edi, %rdi
movl (%rcx,%rdi,4), %edi
cmpl $-0x1, %edi
jne 0x5cde
cmpl %esi, %eax
jle 0x5d07
decl %eax
cmpl %edx, %eax
setle %al
testl %edx, %edx
sets %cl
orb %al, %cl
je 0x5d07
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq 0x1363a(%rip), %rax     # 0x19348
movq 0x1362b(%rip), %rcx     # 0x19340
movslq %ebx, %rdx
movslq (%rcx,%rdx,4), %rcx
movslq (%rax,%rcx,4), %rdx
shlq $0x2, %rdx
addq 0x1362d(%rip), %rdx     # 0x19358
leaq 0xd941(%rip), %rsi      # 0x13673
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: syncheck
int syncheck(cell x, int top) {
	cell	p;

	if (atomp(x)) return 0;
	for (p = x; pairp(p); p = cdr(p))
		;
	if (p != NIL)
		error("dotted list in program", x);
	if (car(x) == S_apply) return ckapply(x);
	if (car(x) == S_def) return ckdef(x, top);
	if (car(x) == S_if) return ckif(x);
	if (car(x) == S_ifstar) return ckifstar(x);
	if (car(x) == S_lambda) return cklambda(x);
	if (car(x) == S_macro) return ckmacro(x, top);
	if (car(x) == S_prog) return ckprog(x, top);
	if (car(x) == S_quote) return ckquote(x);
	if (car(x) == S_setq) return cksetq(x);
	return ckseq(x, top);
}

// Assembly:
pushq %rbx
testl %edi, %edi
js 0x5e64
movl %edi, %eax
movq 0x135af(%rip), %rcx     # 0x19350
movl %edi, %ebx
testb $0x9, (%rcx,%rbx)
jne 0x5e64
movq 0x13594(%rip), %rdx     # 0x19348
movl %eax, %edi
movl %edi, %r8d
testb $0x9, (%rcx,%r8)
jne 0x5dc8
movl (%rdx,%r8,4), %edi
testl %edi, %edi
jns 0x5db6
cmpl $-0x1, %edi
jne 0x5eaa
movq 0x13568(%rip), %rcx     # 0x19340
movl (%rcx,%rbx,4), %ecx
cmpl 0x13937(%rip), %ecx     # 0x19718
jne 0x5df6
movl %eax, %edi
movl $0x2, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5cc5
jmp 0x5e64
cmpl 0x13920(%rip), %ecx     # 0x1971c
jne 0x5e07
movl %eax, %edi
callq 0x5ecc
jmp 0x5e64
cmpl 0x13913(%rip), %ecx     # 0x19720
jne 0x5e33
movl %eax, %edi
movl $0x2, %esi
movl $0x3, %edx
callq 0x5cc5
movq 0x13521(%rip), %rax     # 0x19348
movl (%rax,%rbx,4), %edi
xorl %esi, %esi
callq 0x5d49
jmp 0x5e64
cmpl 0x138eb(%rip), %ecx     # 0x19724
jne 0x5e44
movl %eax, %edi
callq 0x5f84
jmp 0x5e64
cmpl 0x138de(%rip), %ecx     # 0x19728
jne 0x5e55
movl %eax, %edi
callq 0x6125
jmp 0x5e64
cmpl 0x138d1(%rip), %ecx     # 0x1972c
jne 0x5e68
movl %eax, %edi
callq 0x61d0
xorl %eax, %eax
popq %rbx
retq
cmpl 0x138c2(%rip), %ecx     # 0x19730
jne 0x5e7c
movq 0x134d1(%rip), %rax     # 0x19348
movl (%rax,%rbx,4), %edi
jmp 0x5e2c
cmpl 0x137b6(%rip), %ecx     # 0x19638
jne 0x5e95
movl %eax, %edi
movl $0x1, %esi
movl $0x1, %edx
jmp 0x5def
cmpl 0x13899(%rip), %ecx     # 0x19734
jne 0x5ea6
movl %eax, %edi
callq 0x6289
jmp 0x5e64
movl %eax, %edi
jmp 0x5e2c
leaq 0xd889(%rip), %rdi      # 0x1373a
movl %eax, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: ckdef
int ckdef(cell x, int top) {
	ckargs(x, 2, 2);
	if (!symbolp(cadr(x)))
		error("def: expected symbol", cadr(x));
	if (!top) error("def: must be at top level", x);
	return syncheck(caddr(x), 0);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
movl $0x2, %esi
movl $0x2, %edx
callq 0x5cc5
movq 0x13457(%rip), %rcx     # 0x19340
movq 0x13458(%rip), %rdx     # 0x19348
movslq %ebx, %rax
movslq (%rdx,%rax,4), %rdx
movslq (%rcx,%rdx,4), %rsi
testq %rsi, %rsi
js 0x5f40
movq 0x13449(%rip), %rdx     # 0x19350
testb $0x8, (%rdx,%rsi)
je 0x5f40
cmpl $-0x12, (%rcx,%rsi,4)
jne 0x5f40
testl %ebp, %ebp
je 0x5f4c
movq 0x13422(%rip), %rcx     # 0x19340
movq 0x13423(%rip), %rdx     # 0x19348
movslq (%rdx,%rax,4), %rax
movslq (%rdx,%rax,4), %rax
movl (%rcx,%rax,4), %edi
xorl %esi, %esi
callq 0x5d8f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xd74a(%rip), %rdi      # 0x13691
callq 0x264c
leaq 0xd753(%rip), %rdi      # 0x136a6
movl %ebx, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: symlistp
int symlistp(cell x) {
	cell	p;

	for (p = x; pairp(p); p = cdr(p)) {
		if (!symbolp(car(p)))
			return 0;
	}
	return symbolp(p) || NIL == p;
}

// Assembly:
testl %edi, %edi
js 0x600a
movq 0x13397(%rip), %rcx     # 0x19350
movq 0x13380(%rip), %rdx     # 0x19340
movq 0x13381(%rip), %rsi     # 0x19348
movl %edi, %r8d
movb (%rcx,%r8), %al
testb $0x9, %al
jne 0x5ff3
movslq (%rdx,%r8,4), %rdi
xorl %eax, %eax
testq %rdi, %rdi
js 0x6012
testb $0x8, (%rcx,%rdi)
je 0x6012
cmpl $-0x12, (%rdx,%rdi,4)
jne 0x6012
movl (%rsi,%r8,4), %edi
testl %edi, %edi
jns 0x5fc7
jmp 0x600a
testb $0x8, %al
je 0x600a
movq 0x13342(%rip), %rcx     # 0x19340
movl $0x1, %eax
cmpl $-0x12, (%rcx,%r8,4)
je 0x6012
xorl %eax, %eax
cmpl $-0x1, %edi
sete %al
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: uniqlistp
int uniqlistp(cell x) {
	if (NIL == x) return 1;
	while (cdr(x) != NIL) {
		if (memq(car(x), cdr(x)) != NIL)
			return 0;
		x = cdr(x);
	}
	return 1;
}

// Assembly:
movl $0x1, %eax
cmpl $-0x1, %edi
je 0x6085
movq 0x132f9(%rip), %rcx     # 0x19348
movq 0x132ea(%rip), %rdx     # 0x19340
movslq %edi, %rsi
movl (%rcx,%rsi,4), %edi
cmpl $-0x1, %edi
je 0x6085
movl (%rdx,%rsi,4), %r8d
movl %edi, %esi
movslq %esi, %r9
cmpl %r8d, (%rdx,%r9,4)
je 0x607e
movl (%rcx,%r9,4), %esi
cmpl $-0x1, %esi
jne 0x6067
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpl $-0x1, %esi
je 0x6056
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: flatargs
cell flatargs(cell a) {
	cell	n;

	protect(n = NIL);
	while (pairp(a)) {
		n = cons(car(a), n);
		car(Protected) = n;
		a = cdr(a);
	}
	if (a != NIL) n = cons(a, n);
	unprot(1);
	return nreverse(n);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
movl 0x130de(%rip), %esi     # 0x19170
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %eax, 0x130c7(%rip)     # 0x19170
testl %ebp, %ebp
js 0x60f9
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq 0x13297(%rip), %rax     # 0x19350
movl %ebp, %r14d
testb $0x9, (%rax,%r14)
jne 0x60f9
movq 0x13276(%rip), %rax     # 0x19340
movl (%rax,%r14,4), %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %ebx
movq 0x13260(%rip), %rax     # 0x19340
movslq 0x13089(%rip), %rcx     # 0x19170
movl %ebx, (%rax,%rcx,4)
movq 0x13257(%rip), %rax     # 0x19348
movl (%rax,%r14,4), %ebp
testl %ebp, %ebp
jns 0x60b2
cmpl $-0x1, %ebp
je 0x610b
movl %ebp, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %ebx
movl $0x1, %edi
callq 0x33d7
movl %ebx, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
jmp 0x3e6e
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: cklambda
int cklambda(cell x) {
	ckargs(x, 2, -1);
	if (!symlistp(cadr(x)))
		error("lambda: invalid formals", cadr(x));
	if (!uniqlistp(flatargs(cadr(x))))
		error("lambda: duplicate formal", cadr(x));
	return ckseq(cddr(x), 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x2, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5cc5
movq 0x131ff(%rip), %rax     # 0x19340
movq 0x13200(%rip), %rcx     # 0x19348
movslq %ebx, %r14
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %ebx
movl %ebx, %edi
callq 0x5fae
testl %eax, %eax
je 0x61a1
movq 0x131dc(%rip), %rax     # 0x19340
movq 0x131dd(%rip), %rcx     # 0x19348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x6086
movl %eax, %edi
callq 0x603e
testl %eax, %eax
je 0x61af
movq 0x131bf(%rip), %rax     # 0x19348
movslq (%rax,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x5d49
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xd518(%rip), %rdi      # 0x136c0
movl %ebx, %esi
callq 0x264c
movq 0x1318a(%rip), %rax     # 0x19340
movq 0x1318b(%rip), %rcx     # 0x19348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %esi
leaq 0xd50d(%rip), %rdi      # 0x136d8
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: ckmacro
int ckmacro(cell x, int top) {
	ckargs(x, 2, 2);
	if (!symbolp(cadr(x)))
		error("macro: expected symbol", cadr(x));
	if (!top) error("macro: must be at top level", x);
	return syncheck(caddr(x), 0);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
movl $0x2, %esi
movl $0x2, %edx
callq 0x5cc5
movq 0x13153(%rip), %rcx     # 0x19340
movq 0x13154(%rip), %rdx     # 0x19348
movslq %ebx, %rax
movslq (%rdx,%rax,4), %rdx
movslq (%rcx,%rdx,4), %rsi
testq %rsi, %rsi
js 0x6244
movq 0x13145(%rip), %rdx     # 0x19350
testb $0x8, (%rdx,%rsi)
je 0x6244
cmpl $-0x12, (%rcx,%rsi,4)
jne 0x6244
testl %ebp, %ebp
je 0x6250
movq 0x1311e(%rip), %rcx     # 0x19340
movq 0x1311f(%rip), %rdx     # 0x19348
movslq (%rdx,%rax,4), %rax
movslq (%rdx,%rax,4), %rax
movl (%rcx,%rax,4), %edi
xorl %esi, %esi
callq 0x5d8f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xd4a6(%rip), %rdi      # 0x136f1
callq 0x264c
leaq 0xd4b1(%rip), %rdi      # 0x13708
movl %ebx, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: cksetq
int cksetq(cell x) {
	ckargs(x, 2, 2);
	if (!symbolp(cadr(x)))
		error("setq: expected symbol", cadr(x));
	return ckseq(cddr(x), 0);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl $0x2, %esi
movl $0x2, %edx
callq 0x5cc5
movq 0x1309e(%rip), %rcx     # 0x19340
movq 0x1309f(%rip), %rdx     # 0x19348
movslq %ebx, %rax
movslq (%rdx,%rax,4), %rdx
movslq (%rcx,%rdx,4), %rsi
testq %rsi, %rsi
js 0x62e5
movq 0x13090(%rip), %rdx     # 0x19350
testb $0x8, (%rdx,%rsi)
je 0x62e5
cmpl $-0x12, (%rcx,%rsi,4)
jne 0x62e5
movq 0x13075(%rip), %rcx     # 0x19348
movslq (%rcx,%rax,4), %rax
movl (%rcx,%rax,4), %edi
xorl %esi, %esi
callq 0x5d49
xorl %eax, %eax
popq %rbx
retq
leaq 0xd438(%rip), %rdi      # 0x13724
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: set_union
cell set_union(cell a, cell b) {
	cell	n;

	a = reverse(a);
	protect(a);
	protect(n = b);
	while (pairp(a)) {
		if (memq(car(a), b) == NIL)
			n = cons(car(a), n);
		car(Protected) = n;
		a = cdr(a);
	}
	if (a != NIL && memq(a, b) == NIL)
		n = cons(a, n);
	unprot(2);
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3e21
movl %eax, %r14d
movl 0x12e63(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x12e54(%rip)     # 0x19170
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x12e43(%rip)     # 0x19170
movl %ebx, %ebp
testl %r14d, %r14d
js 0x63a1
movq 0x13015(%rip), %rax     # 0x19350
movl %r14d, %r15d
testb $0x9, (%rax,%r15)
jne 0x63a1
movq 0x12ff4(%rip), %rax     # 0x19340
movl (%rax,%r15,4), %edi
cmpl $-0x1, %ebx
je 0x6378
movq 0x12fec(%rip), %rdx     # 0x19348
movl %ebx, %ecx
movslq %ecx, %rsi
cmpl %edi, (%rax,%rsi,4)
je 0x6373
movl (%rdx,%rsi,4), %ecx
cmpl $-0x1, %ecx
jne 0x635e
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $-0x1, %ecx
jne 0x6383
movl %ebp, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %ebp
movq 0x12fb6(%rip), %rax     # 0x19340
movslq 0x12ddf(%rip), %rcx     # 0x19170
movl %ebp, (%rax,%rcx,4)
movq 0x12fad(%rip), %rax     # 0x19348
movl (%rax,%r15,4), %r14d
jmp 0x632f
cmpl $-0x1, %r14d
je 0x63e3
cmpl $-0x1, %ebx
je 0x63d5
movq 0x12f8d(%rip), %rax     # 0x19340
movq 0x12f8e(%rip), %rcx     # 0x19348
movslq %ebx, %rdx
cmpl %r14d, (%rax,%rdx,4)
je 0x63d0
movl (%rcx,%rdx,4), %ebx
cmpl $-0x1, %ebx
jne 0x63ba
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $-0x1, %ebx
jne 0x63e3
movl %r14d, %edi
movl %ebp, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %ebp
movl $0x2, %edi
callq 0x33d7
movl %ebp, %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: subrp
int subrp(cell x) {
	return	subr0(x) >= 0 ||
		subr1(x) >= 0 ||
		subr2(x) >= 0 ||
		subr3(x) >= 0 ||
		osubr0(x) >= 0 ||
		osubr1(x) >= 0 ||
		lsubr0(x) >= 0 ||
		lsubr1(x) >= 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
callq 0x7b00
movl $0x1, %ebx
testl %eax, %eax
jns 0x6697
movl %ebp, %edi
callq 0x7b7b
testl %eax, %eax
jns 0x6697
movl %ebp, %edi
callq 0x7efb
testl %eax, %eax
js 0x66a0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl %ebp, 0x1320a(%rip)     # 0x198b0
je 0x6697
cmpl %ebp, 0x13206(%rip)     # 0x198b4
je 0x6697
cmpl %ebp, 0x13202(%rip)     # 0x198b8
je 0x6697
cmpl %ebp, 0x131fe(%rip)     # 0x198bc
je 0x6697
cmpl %ebp, 0x131fa(%rip)     # 0x198c0
je 0x6697
cmpl %ebp, 0x131f6(%rip)     # 0x198c4
je 0x6697
cmpl %ebp, 0x131f2(%rip)     # 0x198c8
je 0x6697
movl %ebp, %edi
callq 0x80d6
testl %eax, %eax
jns 0x6697
movl %ebp, %edi
callq 0x8151
testl %eax, %eax
jns 0x6697
movl %ebp, %edi
callq 0x81a5
movl %eax, %ebx
notl %ebx
shrl $0x1f, %ebx
jmp 0x6697
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: posq
int posq(cell x, cell a) {
	int	n;

	n = 0;
	for (; a != NIL; a = cdr(a)) {
		if (car(a) == x) return n;
		n++;
	}
	return NIL;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $-0x1, %esi
je 0x672b
movq 0x12c31(%rip), %rdx     # 0x19340
xorl %ecx, %ecx
movq 0x12c30(%rip), %r8      # 0x19348
movslq %esi, %rsi
cmpl %edi, (%rdx,%rsi,4)
je 0x672c
incl %ecx
movl (%r8,%rsi,4), %esi
cmpl $-0x1, %esi
jne 0x6718
retq
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: newvar
void newvar(cell x) {
	cell	n;

	if (memq(x, Env) != NIL) return;
	if (NIL == Envp) Envp = lastpair(Env);
	n = cons(x, NIL);
	cdr(Envp) = n;
	Envp = n;
}

// Assembly:
pushq %rax
movl 0x12858(%rip), %eax     # 0x19194
cmpl $-0x1, %eax
je 0x696d
movq 0x129f8(%rip), %rdx     # 0x19340
movq 0x129f9(%rip), %rsi     # 0x19348
movl %eax, %ecx
movslq %ecx, %r8
cmpl %edi, (%rdx,%r8,4)
je 0x6968
movl (%rsi,%r8,4), %ecx
cmpl $-0x1, %ecx
jne 0x6951
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $-0x1, %ecx
jne 0x69be
cmpl $-0x1, 0x12824(%rip)    # 0x19198
jne 0x699b
cmpl $-0x1, %eax
je 0x6990
movq 0x129c6(%rip), %rdx     # 0x19348
movl %eax, %ecx
cltq
movl (%rdx,%rax,4), %eax
cmpl $-0x1, %eax
jne 0x6982
jmp 0x6995
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, 0x127fd(%rip)     # 0x19198
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movq 0x1299a(%rip), %rcx     # 0x19348
movslq 0x127e3(%rip), %rdx     # 0x19198
movl %eax, (%rcx,%rdx,4)
movl %eax, 0x127da(%rip)     # 0x19198
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: mapconv
cell mapconv(cell x, cell e, cell a) {
	cell	n, new;

	protect(n = NIL);
	while (pairp(x)) {
		new = cconv(car(x), e, a);
		n = cons(new, n);
		car(Protected) = n;
		x = cdr(x);
	}
	return nreverse(unprot(1));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r15d
movl 0x12773(%rip), %esi     # 0x19170
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %eax, 0x1275b(%rip)     # 0x19170
testl %r15d, %r15d
js 0x6a6d
movq 0x1292f(%rip), %rax     # 0x19350
movl %r15d, %r15d
testb $0x9, (%rax,%r15)
jne 0x6a6d
movq 0x1290e(%rip), %rax     # 0x19340
movl (%rax,%r15,4), %edi
movl %ebp, %esi
movl %ebx, %edx
callq 0x6a8d
movl %eax, %edi
movl %r14d, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %r14d
movq 0x128eb(%rip), %rax     # 0x19340
movslq 0x12714(%rip), %rcx     # 0x19170
movl %r14d, (%rax,%rcx,4)
movq 0x128e1(%rip), %rax     # 0x19348
movl (%rax,%r15,4), %r15d
jmp 0x6a15
movl $0x1, %edi
callq 0x33d7
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3e6e
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: lamconv
cell lamconv(cell x, cell e, cell a) {
	cell	cl, fv, args, m;

	fv = freevars(x, NIL);
	protect(fv);
	newvars(fv);
	args = flatargs(cadr(x));
	protect(args);
	m = initmap(fv, e, a);
	protect(m);
	cl = mapconv(cddr(x), fv, args);
	cl = cons(m, cl);
	cl = cons(cadr(x), cl);
	cl = cons(I_closure, cl);
	unprot(3);
	return cl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x63fa
movl %eax, %ebx
movl 0x123c8(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x123b9(%rip)     # 0x19170
cmpl $-0x1, %ebx
je 0x6de1
movl %ebx, %eax
movq 0x1257b(%rip), %rcx     # 0x19340
movslq %eax, %r12
movl (%rcx,%r12,4), %edi
callq 0x6935
movq 0x12570(%rip), %rax     # 0x19348
movl (%rax,%r12,4), %eax
cmpl $-0x1, %eax
jne 0x6dbe
movq 0x12558(%rip), %rax     # 0x19340
movq 0x12559(%rip), %rcx     # 0x19348
movslq %r15d, %r12
movslq (%rcx,%r12,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x6086
movl %eax, %r15d
movl 0x12369(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x1235a(%rip)     # 0x19170
movl %ebx, %edi
movl %r14d, %esi
movl %ebp, %edx
callq 0x672f
movl %eax, %ebp
movl 0x12346(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x12337(%rip)     # 0x19170
movq 0x12508(%rip), %rax     # 0x19348
movslq (%rax,%r12,4), %rcx
movl (%rax,%rcx,4), %edi
movl %ebx, %esi
movl %r15d, %edx
callq 0x69e9
movl %ebp, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3162
movq 0x124dd(%rip), %rcx     # 0x19340
movq 0x124de(%rip), %rdx     # 0x19348
movslq (%rdx,%r12,4), %rdx
movl (%rcx,%rdx,4), %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3162
movl 0x128c0(%rip), %edi     # 0x19740
movl %eax, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %ebx
movl $0x3, %edi
callq 0x33d7
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: contains
int contains(cell a, cell x) {
	if (a == x) return 1;
	if (pairp(a) && (contains(car(a), x) || contains(cdr(a), x)))
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl $0x1, %ebx
cmpl %esi, %edi
je 0x6ec4
testl %edi, %edi
js 0x6ec2
movq 0x12498(%rip), %rax     # 0x19350
movl %edi, %r14d
testb $0x9, (%rax,%r14)
je 0x6ecb
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl %esi, %ebp
movq 0x1246c(%rip), %rax     # 0x19340
movl (%rax,%r14,4), %edi
callq 0x6ea0
testl %eax, %eax
jne 0x6ec4
movq 0x12460(%rip), %rax     # 0x19348
movl (%rax,%r14,4), %edi
movl %ebp, %esi
callq 0x6ea0
testl %eax, %eax
jne 0x6ec4
jmp 0x6ec2
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: liftnames
cell liftnames(cell m) {
	#define name cadddr
	cell	a, n;

	protect(a = NIL);
	while (m != NIL) {
		if (caar(m) == I_a) {
			n = name(car(m));
			a = cons(n, a);
			car(Protected) = a;
		}
		m = cdr(m);
	}
	return nreverse(unprot(1));
	#undef name
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
movl 0x1225a(%rip), %esi     # 0x19170
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %eax, 0x12243(%rip)     # 0x19170
cmpl $-0x1, %ebp
je 0x6f8a
movq 0x12407(%rip), %rax     # 0x19340
movslq %ebp, %r14
movslq (%rax,%r14,4), %rcx
movl (%rax,%rcx,4), %edx
cmpl 0x127ef(%rip), %edx     # 0x19738
jne 0x6f7d
movq 0x123f6(%rip), %rdx     # 0x19348
movslq (%rdx,%rcx,4), %rcx
movslq (%rdx,%rcx,4), %rcx
movslq (%rdx,%rcx,4), %rcx
movl (%rax,%rcx,4), %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %ebx
movq 0x123cd(%rip), %rax     # 0x19340
movslq 0x121f6(%rip), %rcx     # 0x19170
movl %ebx, (%rax,%rcx,4)
movq 0x123c4(%rip), %rax     # 0x19348
movl (%rax,%r14,4), %ebp
jmp 0x6f2d
movl $0x1, %edi
callq 0x33d7
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
jmp 0x3e6e
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: liftargs
cell liftargs(cell m) {
	#define source	cadr
	cell	a, n;

	protect(a = NIL);
	while (m != NIL) {
		if (caar(m) == I_a) {
			n = source(car(m));
			n = cons(n, NIL);
			n = cons(caar(m) == I_a? I_arg: I_ref, n);
			a = cons(n, a);
			car(Protected) = a;
		}
		m = cdr(m);
	}
	return nreverse(unprot(1));
	#undef source
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebp
movl 0x121bc(%rip), %esi     # 0x19170
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %eax, 0x121a5(%rip)     # 0x19170
cmpl $-0x1, %ebp
je 0x706d
leaq 0x12769(%rip), %r14     # 0x19744
leaq 0x12766(%rip), %r15     # 0x19748
movq 0x12357(%rip), %rax     # 0x19340
movslq %ebp, %r12
movslq (%rax,%r12,4), %rcx
movl (%rax,%rcx,4), %edx
cmpl 0x1273f(%rip), %edx     # 0x19738
jne 0x7059
movq 0x12346(%rip), %rdx     # 0x19348
movslq (%rdx,%rcx,4), %rcx
movl (%rax,%rcx,4), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movq 0x12324(%rip), %rcx     # 0x19340
movslq (%rcx,%r12,4), %rdx
movl (%rcx,%rdx,4), %ecx
cmpl 0x1270f(%rip), %ecx     # 0x19738
movq %r15, %rcx
cmoveq %r14, %rcx
movl (%rcx), %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %ebx
movq 0x122f1(%rip), %rax     # 0x19340
movslq 0x1211a(%rip), %rcx     # 0x19170
movl %ebx, (%rax,%rcx,4)
movq 0x122e8(%rip), %rax     # 0x19348
movl (%rax,%r12,4), %ebp
cmpl $-0x1, %ebp
jne 0x6fe2
movl $0x1, %edi
callq 0x33d7
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3e6e
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: defconv
cell defconv(cell x, cell e, cell a) {
	cell	n, m;

	newvar(cadr(x));
	n = cons(cconv(caddr(x), e, a), NIL);
	protect(n);
	m = mkfix(posq(cadr(x), e));
	protect(m);
	m = cons(I_ref, cons(m, cons(cadr(x), NIL)));
	unprot(2);
	return cons(S_setq, cons(m, n));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq 0x12090(%rip), %rax     # 0x19340
movq 0x12091(%rip), %rcx     # 0x19348
movslq %edi, %r15
movslq (%rcx,%r15,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x6935
movq 0x12073(%rip), %rax     # 0x19340
movq 0x12074(%rip), %rcx     # 0x19348
movslq (%rcx,%r15,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl %ebp, %esi
movl %ebx, %edx
callq 0x6a8d
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
xorl %r12d, %r12d
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %eax, %ebx
movl 0x11e69(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x11e5a(%rip)     # 0x19170
cmpl $-0x1, %ebp
je 0x7348
movq 0x1201e(%rip), %rax     # 0x19340
movq 0x1201f(%rip), %rcx     # 0x19348
movslq (%rcx,%r15,4), %rdx
movl (%rax,%rdx,4), %edx
movslq %ebp, %rsi
cmpl %edx, (%rax,%rsi,4)
je 0x7345
incl %r12d
movl (%rcx,%rsi,4), %ebp
cmpl $-0x1, %ebp
jne 0x7330
jmp 0x7348
movl %r12d, %r14d
movl %r14d, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
movl %eax, %ebp
movl 0x11dfd(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x11dee(%rip)     # 0x19170
movl 0x123bf(%rip), %r14d    # 0x19748
movq 0x11fb0(%rip), %rax     # 0x19340
movq 0x11fb1(%rip), %rcx     # 0x19348
movslq (%rcx,%r15,4), %rcx
movl (%rax,%rcx,4), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %ebp, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3162
movl %r14d, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %ebp
movl $0x2, %edi
callq 0x33d7
movl 0x12360(%rip), %r14d    # 0x19734
movl %ebp, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x3162
movl %r14d, %edi
movl %eax, %esi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3162
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: carof
cell carof(cell a) {
	cell	n;

	protect(n = NIL);
	while (a != NIL) {
		n = cons(caar(a), n);
		car(Protected) = n;
		a = cdr(a);
	}
	unprot(1);
	return nreverse(n);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
movl 0x11d71(%rip), %esi     # 0x19170
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %eax, 0x11d5a(%rip)     # 0x19170
cmpl $-0x1, %ebp
je 0x745d
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq 0x11f19(%rip), %rax     # 0x19340
movslq %ebp, %r14
movslq (%rax,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %ebx
movq 0x11efd(%rip), %rax     # 0x19340
movslq 0x11d26(%rip), %rcx     # 0x19170
movl %ebx, (%rax,%rcx,4)
movq 0x11ef4(%rip), %rax     # 0x19348
movl (%rax,%r14,4), %ebp
cmpl $-0x1, %ebp
jne 0x7420
movl $0x1, %edi
callq 0x33d7
movl %ebx, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
jmp 0x3e6e
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: zipenv
cell zipenv(cell vs, cell oe) {
	cell	n, b;

	protect(n = NIL);
	while (vs != NIL) {
		if (NIL == oe) {
			b = cons(car(vs), cons(UNDEF, NIL));
		}
		else {
			b = car(oe);
			oe = cdr(oe);
		}
		n = cons(b, n);
		car(Protected) = n;
		vs = cdr(vs);
	}
	return nreverse(unprot(1));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %r14d
movl 0x11ce7(%rip), %esi     # 0x19170
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %eax, 0x11cd0(%rip)     # 0x19170
cmpl $-0x1, %r14d
je 0x7518
movq 0x11e93(%rip), %rax     # 0x19340
movslq %r14d, %r15
cmpl $-0x1, %ebx
je 0x74c7
movslq %ebx, %rcx
movl (%rax,%rcx,4), %edi
movq 0x11e86(%rip), %rax     # 0x19348
movl (%rax,%rcx,4), %ebx
jmp 0x74ef
movl (%rax,%r15,4), %r14d
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %r14d, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %edi
movl %ebp, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %ebp
movq 0x11e3f(%rip), %rax     # 0x19340
movslq 0x11c68(%rip), %rcx     # 0x19170
movl %ebp, (%rax,%rcx,4)
movq 0x11e36(%rip), %rax     # 0x19348
movl (%rax,%r15,4), %r14d
jmp 0x74a0
movl $0x1, %edi
callq 0x33d7
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3e6e
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: clsconv
cell clsconv(cell x) {
	cell	n;

	Env = carof(Glob);
	Envp = NIL;
	if (NIL == Env) Env = cons(UNDEF, NIL);
	n = cconv(x, Env, NIL);
	protect(n);
	Glob = zipenv(Env, Glob);
	return unprot(1);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl 0x11c03(%rip), %edi     # 0x19144
callq 0x73f3
movl %eax, 0x11c48(%rip)     # 0x19194
movl $0xffffffff, 0x11c42(%rip) # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
jne 0x7572
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %eax, 0x11c22(%rip)     # 0x19194
movl 0x11c1c(%rip), %esi     # 0x19194
movl %ebx, %edi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x6a8d
movl 0x11be6(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x11bd7(%rip)     # 0x19170
movl 0x11bf5(%rip), %edi     # 0x19194
movl 0x11b9f(%rip), %esi     # 0x19144
callq 0x7477
movl %eax, 0x11b94(%rip)     # 0x19144
movl $0x1, %edi
popq %rbx
jmp 0x33d7
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: obslot
int obslot(void) {
	int	i, j, k, m;
	byte	*s;
	cell	n;

	for (m = 0; m < 2; m++) {
		for (j = 0; j < 2; j++) {
			k = veclen(Obarray);
			s = string(Obmap);
			for (i=0; i<k; i++) {
				if (OBFREE == s[Obptr]) {
					s[Obptr] = OBALLOC;
					return Obptr;
				}
				Obptr++;
				if (Obptr >= k) Obptr = 0;
			}
			if (0 == j) gc();
		}
		if (k + CHUNKSIZE >= 64 * 1024) break;
		n = mkvec(k + CHUNKSIZE);
		memcpy(vector(n), vector(Obarray), k * sizeof(cell));
		Obarray = n;
		n = mkstr(NULL, k + CHUNKSIZE);
		memset(string(n), OBFREE, k+CHUNKSIZE);
		memcpy(string(n), string(Obmap), k);
		Obmap = n;
	}
	error("out of object space", UNDEF);
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x11d85(%rip), %rax     # 0x19358
movq 0x11d6e(%rip), %rcx     # 0x19348
movslq 0x11b83(%rip), %rdx     # 0x19164
movslq (%rcx,%rdx,4), %rdx
movslq -0x4(%rax,%rdx,4), %rbx
addq $0x3, %rbx
shrq $0x2, %rbx
testl %ebx, %ebx
jle 0x762c
movslq 0x11b5b(%rip), %rdx     # 0x19158
movslq (%rcx,%rdx,4), %rcx
leaq (%rax,%rcx,4), %rax
movl 0x12141(%rip), %ecx     # 0x1974c
movl %ebx, %edx
movslq %ecx, %rsi
cmpb $0x0, (%rax,%rsi)
je 0x771c
incl %ecx
cmpl %ebx, %ecx
cmovgel %r14d, %ecx
movl %ecx, 0x12124(%rip)     # 0x1974c
decl %edx
jne 0x760d
testl %r12d, %r12d
jne 0x7636
callq 0x2f2c
leal 0x1(%r12), %eax
testl %r12d, %r12d
movl %eax, %r12d
je 0x75cc
cmpl $0xfbff, %ebx           # imm = 0xFBFF
jg 0x770b
leal 0x400(%rbx), %ebp
movl %ebp, %edi
callq 0x3422
movq 0x11cf5(%rip), %rcx     # 0x19358
movq 0x11cde(%rip), %rdx     # 0x19348
movslq %eax, %r12
movslq (%rdx,%r12,4), %rax
leaq (%rcx,%rax,4), %rdi
movslq 0x11ae8(%rip), %rax     # 0x19164
movslq (%rdx,%rax,4), %rax
leaq (%rcx,%rax,4), %rsi
movslq %ebx, %rbx
leaq (,%rbx,4), %rdx
callq 0x2140
movl %r12d, 0x11ac9(%rip)    # 0x19164
xorl %edi, %edi
movl %ebp, %esi
callq 0x27dc
movq 0x11c9d(%rip), %rcx     # 0x19348
movslq %eax, %r12
movslq (%rcx,%r12,4), %rdi
shlq $0x2, %rdi
addq 0x11c9b(%rip), %rdi     # 0x19358
movslq %ebp, %rdx
xorl %esi, %esi
callq 0x20b0
movq 0x11c8a(%rip), %rax     # 0x19358
movq 0x11c73(%rip), %rcx     # 0x19348
movslq (%rcx,%r12,4), %rdx
leaq (%rax,%rdx,4), %rdi
movslq 0x11a74(%rip), %rdx     # 0x19158
movslq (%rcx,%rdx,4), %rcx
leaq (%rax,%rcx,4), %rsi
movq %rbx, %rdx
callq 0x2140
movl %r12d, 0x11a5d(%rip)    # 0x19158
leal 0x1(%r15), %eax
testl %r15d, %r15d
movl %eax, %r15d
je 0x75c9
leaq 0xc050(%rip), %rdi      # 0x13762
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x264c
movb $0x1, (%rax,%rsi)
movl 0x12026(%rip), %eax     # 0x1974c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: obindex
int obindex(cell x) {
	cell	n;
	int	i;

	if (pairp(x) || vectorp(x) || closurep(x))
		return obslot();
	n = htlookup(Obhash, x);
	if (n != UNDEF) {
		i = fixval(cdr(n));
		if (	string(Obmap)[i] != OBFREE &&
			match(x, vector(Obarray)[i])
		)
			return i;
		htrem(Obhash, x);
	}
	i = obslot();
	htadd(Obhash, x, mkfix(i));
	return i;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
testl %edi, %edi
js 0x7777
movq 0x11c10(%rip), %rcx     # 0x19350
movl %ebx, %eax
movb (%rcx,%rax), %cl
testb $0x9, %cl
je 0x776e
testb $0x8, %cl
je 0x775c
movq 0x11bea(%rip), %rdx     # 0x19340
cmpl $-0x13, (%rdx,%rax,4)
je 0x776e
testb $0x1, %cl
je 0x7777
movq 0x11bd8(%rip), %rcx     # 0x19340
cmpl $-0xd, (%rcx,%rax,4)
jne 0x7777
popq %rbx
popq %r14
popq %rbp
jmp 0x75bb
movl 0x11a1e(%rip), %r14d    # 0x1919c
movl %r14d, %edi
movl %ebx, %esi
callq 0x398f
cmpl $-0x4, %eax
je 0x77ee
movq 0x11bac(%rip), %rdx     # 0x19340
movq 0x11bad(%rip), %rcx     # 0x19348
cltq
movslq (%rcx,%rax,4), %rax
movslq (%rcx,%rax,4), %rax
movl (%rdx,%rax,4), %ebp
movq 0x11ba9(%rip), %rax     # 0x19358
movslq 0x119a2(%rip), %rdx     # 0x19158
movslq (%rcx,%rdx,4), %rdx
leaq (%rax,%rdx,4), %rsi
movslq %ebp, %rdx
cmpb $0x0, (%rdx,%rsi)
je 0x77e4
movslq 0x11996(%rip), %rsi     # 0x19164
movslq (%rcx,%rsi,4), %rcx
leaq (%rax,%rcx,4), %rax
movl (%rax,%rdx,4), %esi
movl %ebx, %edi
callq 0x36eb
testl %eax, %eax
jne 0x782a
movl %r14d, %edi
movl %ebx, %esi
callq 0x3b46
callq 0x75bb
movl %eax, %ebp
movl 0x119a0(%rip), %r14d    # 0x1919c
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
movl %r14d, %edi
movl %ebx, %esi
movl %eax, %edx
callq 0x3a18
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: emit
void emit(int x) {
	cell	n;
	byte	*vp, *vn;
	int	i, k;

	if (Here >= stringlen(cdr(Emitbuf))) {
		protect(x);
		k = stringlen(cdr(Emitbuf));
		n = mkstr(NULL, CHUNKSIZE + k);
		vp = string(cdr(Emitbuf));
		vn = string(n);
		for (i = 0; i < k; i++) vn[i] = vp[i];
		cdr(Emitbuf) = n;
		unprot(1);
	}
	string(cdr(Emitbuf))[Here] = x;
	Here++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl 0x11f13(%rip), %eax     # 0x19750
movq 0x11b14(%rip), %rcx     # 0x19358
movq 0x11afd(%rip), %rdx     # 0x19348
movslq 0x1194e(%rip), %rsi     # 0x191a0
movslq (%rdx,%rsi,4), %rsi
movslq (%rdx,%rsi,4), %rdx
cmpl -0x4(%rcx,%rdx,4), %eax
jl 0x7907
movl 0x11906(%rip), %esi     # 0x19170
movl %ebx, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x118f7(%rip)     # 0x19170
movq 0x11ad8(%rip), %rax     # 0x19358
movq 0x11ac1(%rip), %rcx     # 0x19348
movslq 0x11912(%rip), %rdx     # 0x191a0
movslq (%rcx,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movslq -0x4(%rax,%rcx,4), %r14
leal 0x400(%r14), %esi
xorl %edi, %edi
callq 0x27dc
testq %r14, %r14
jle 0x78ec
movq 0x11aa3(%rip), %rdx     # 0x19358
movq 0x11a8c(%rip), %rsi     # 0x19348
movslq 0x118dd(%rip), %rcx     # 0x191a0
movslq (%rsi,%rcx,4), %rcx
movslq (%rsi,%rcx,4), %rcx
leaq (%rdx,%rcx,4), %rcx
movslq %eax, %rdi
movslq (%rsi,%rdi,4), %rsi
leaq (%rdx,%rsi,4), %rdx
xorl %esi, %esi
movb (%rcx,%rsi), %dil
movb %dil, (%rdx,%rsi)
incq %rsi
cmpq %rsi, %r14
jne 0x78dc
movq 0x11a55(%rip), %rcx     # 0x19348
movslq 0x118a6(%rip), %rdx     # 0x191a0
movl %eax, (%rcx,%rdx,4)
movl $0x1, %edi
callq 0x33d7
movq 0x11a3a(%rip), %rax     # 0x19348
movslq 0x1188b(%rip), %rcx     # 0x191a0
movslq (%rax,%rcx,4), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq 0x11a30(%rip), %rax     # 0x19358
movslq 0x11e21(%rip), %rcx     # 0x19750
movb %bl, (%rcx,%rax)
incl 0x11e18(%rip)           # 0x19750
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: emitarg
void emitarg(int i) {
	if (i < 0 || i > 65535)
		error("bytecode argument out of range", mkfix(i));
	emit(i >> 8);
	emit(i & 255);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
cmpl $0x10000, %edi          # imm = 0x10000
jae 0x795e
movl %ebx, %edi
shrl $0x8, %edi
callq 0x7831
movzbl %bl, %edi
popq %rbx
jmp 0x7831
movl %ebx, %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 0xbdef(%rip), %rdi      # 0x13776
movl %eax, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: emitq
void emitq(cell x) {
	int	i;

	i = obindex(x);
	vector(Obarray)[i] = x;
	emitop(OP_QUOTE);
	emitarg(i);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
callq 0x772f
movq 0x119a8(%rip), %rcx     # 0x19348
movslq 0x117bd(%rip), %rdx     # 0x19164
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0x119a2(%rip), %rcx     # 0x19358
movslq %eax, %r14
movl %ebx, (%rcx,%r14,4)
movl $0x5, %edi
callq 0x7831
movl %r14d, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7940
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: patch
void patch(int a, int n) {
	if (n < 0 || n > 65535)
		error("bytecode argument out of range", mkfix(n));
	string(cdr(Emitbuf))[a] = n >> 8;
	string(cdr(Emitbuf))[a+1] = n & 255;
}

// Assembly:
movl %esi, %eax
cmpl $0x10000, %esi          # imm = 0x10000
jae 0x7a2d
movq 0x11961(%rip), %rcx     # 0x19348
movslq 0x117b2(%rip), %rdx     # 0x191a0
movslq (%rcx,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0x11957(%rip), %rcx     # 0x19358
movslq %edi, %rdx
movb %ah, (%rdx,%rcx)
movq 0x1193a(%rip), %rcx     # 0x19348
movslq 0x1178b(%rip), %rsi     # 0x191a0
movslq (%rcx,%rsi,4), %rsi
movslq (%rcx,%rsi,4), %rcx
shlq $0x2, %rcx
addq 0x11930(%rip), %rcx     # 0x19358
movb %al, 0x1(%rdx,%rcx)
retq
pushq %rax
movl %eax, %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 0xbd1f(%rip), %rdi      # 0x13776
movl %eax, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: cpopval
cell cpopval(void) {
	cell	n;

	if (NIL == Cts)
		error("oops: compile stack underflow", UNDEF);
	n = car(Cts);
	Cts = cdr(Cts);
	return fixval(n);
}

// Assembly:
cmpl $-0x1, 0x1173f(%rip)    # 0x191a4
je 0x7a91
movq 0x118d2(%rip), %rax     # 0x19340
movslq 0x1172f(%rip), %rcx     # 0x191a4
movslq (%rax,%rcx,4), %rdx
movq 0x118c8(%rip), %rsi     # 0x19348
movl (%rsi,%rcx,4), %ecx
movl %ecx, 0x1171b(%rip)     # 0x191a4
movslq (%rsi,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
retq
pushq %rax
leaq 0xbcfc(%rip), %rdi      # 0x13795
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: swap
void swap(void) {
	cell	x;

	if (NIL == Cts || NIL == cdr(Cts))
		error("oops: compile stack underflow", UNDEF);
	x = car(Cts);
	car(Cts) = cadr(Cts);
	cadr(Cts) = x;
}

// Assembly:
movslq 0x116fa(%rip), %rax     # 0x191a4
cmpq $-0x1, %rax
je 0x7aee
movq 0x11891(%rip), %rcx     # 0x19348
cmpl $-0x1, (%rcx,%rax,4)
je 0x7aee
movq 0x1187c(%rip), %rax     # 0x19340
movslq 0x116d9(%rip), %rcx     # 0x191a4
movl (%rax,%rcx,4), %edx
movq 0x11873(%rip), %rsi     # 0x19348
movslq (%rsi,%rcx,4), %rdi
movl (%rax,%rdi,4), %edi
movl %edi, (%rax,%rcx,4)
movslq 0x116be(%rip), %rcx     # 0x191a4
movslq (%rsi,%rcx,4), %rcx
movl %edx, (%rax,%rcx,4)
retq
pushq %rax
leaq 0xbc9f(%rip), %rdi      # 0x13795
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: subr0
int subr0(cell x) {
	if (x == P_cmdline)	return OP_CMDLINE;
	if (x == P_errport)	return OP_ERRPORT;
	if (x == P_gc)		return OP_GC;
	if (x == P_gensym)	return OP_GENSYM;
	if (x == P_inport)	return OP_INPORT;
	if (x == P_obtab)	return OP_OBTAB;
	if (x == P_outport)	return OP_OUTPORT;
	if (x == P_quit)	return OP_QUIT;
	if (x == P_symtab)	return OP_SYMTAB;
	return -1;
}

// Assembly:
movl $0x31, %eax
cmpl %edi, 0x11c49(%rip)     # 0x19754
je 0x7b7a
movl $0x3f, %eax
cmpl %edi, 0x11c40(%rip)     # 0x19758
je 0x7b7a
movl $0x46, %eax
cmpl %edi, 0x11c37(%rip)     # 0x1975c
je 0x7b7a
movl $0x47, %eax
cmpl %edi, 0x11c2e(%rip)     # 0x19760
je 0x7b7a
movl $0x4a, %eax
cmpl %edi, 0x11c25(%rip)     # 0x19764
je 0x7b7a
movl $0x5f, %eax
cmpl %edi, 0x11c1c(%rip)     # 0x19768
je 0x7b7a
movl $0x62, %eax
cmpl %edi, 0x11c13(%rip)     # 0x1976c
je 0x7b7a
movl $0x69, %eax
cmpl %edi, 0x11c0a(%rip)     # 0x19770
je 0x7b7a
xorl %eax, %eax
cmpl %edi, 0x11c04(%rip)     # 0x19774
setne %al
negl %eax
orl $0x8a, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: subr2
int subr2(cell x) {
	if (x == P_cons)	return OP_CONS;
	if (x == P_div)		return OP_DIV;
	if (x == P_eq)		return OP_EQ;
	if (x == P_nreconc)	return OP_NRECONC;
	if (x == P_reconc)	return OP_RECONC;
	if (x == P_rem)		return OP_REM;
	if (x == P_rename)	return OP_RENAME;
	if (x == P_sless)	return OP_SLESS;
	if (x == P_slteq)	return OP_SLTEQ;
	if (x == P_sequal)	return OP_SEQUAL;
	if (x == P_sgrtr)	return OP_SGRTR;
	if (x == P_sgteq)	return OP_SGTEQ;
	if (x == P_setcar)	return OP_SETCAR;
	if (x == P_setcdr)	return OP_SETCDR;
	if (x == P_sfill)	return OP_SFILL;
	if (x == P_siless)	return OP_SILESS;
	if (x == P_silteq)	return OP_SILTEQ;
	if (x == P_siequal)	return OP_SIEQUAL;
	if (x == P_sigrtr)	return OP_SIGRTR;
	if (x == P_sigteq)	return OP_SIGTEQ;
	if (x == P_sref)	return OP_SREF;
	if (x == P_throwstar)	return OP_THROWSTAR;
	if (x == P_vfill)	return OP_VFILL;
	if (x == P_vref)	return OP_VREF;
	return -1;
}

// Assembly:
movl $0x33, %eax
cmpl %edi, 0x1194a(%rip)     # 0x19850
je 0x8070
movl $0x37, %eax
cmpl %edi, 0x1193d(%rip)     # 0x19854
je 0x8070
movl $0x3b, %eax
cmpl %edi, 0x11930(%rip)     # 0x19858
je 0x8070
movl $0x5b, %eax
cmpl %edi, 0x11923(%rip)     # 0x1985c
je 0x8070
movl $0x6c, %eax
cmpl %edi, 0x11916(%rip)     # 0x19860
je 0x8070
movl $0x6d, %eax
cmpl %edi, 0x11909(%rip)     # 0x19864
je 0x8070
movl $0x6e, %eax
cmpl %edi, 0x118fc(%rip)     # 0x19868
je 0x8070
movl $0x7d, %eax
cmpl %edi, 0x118ef(%rip)     # 0x1986c
je 0x8070
movl $0x7e, %eax
cmpl %edi, 0x118e2(%rip)     # 0x19870
je 0x8070
movl $0x70, %eax
cmpl %edi, 0x118d5(%rip)     # 0x19874
je 0x8070
movl $0x76, %eax
cmpl %edi, 0x118c8(%rip)     # 0x19878
je 0x8070
movl $0x77, %eax
cmpl %edi, 0x118bb(%rip)     # 0x1987c
je 0x8070
movl $0x71, %eax
cmpl %edi, 0x118ae(%rip)     # 0x19880
je 0x8070
movl $0x72, %eax
cmpl %edi, 0x118a1(%rip)     # 0x19884
je 0x8070
movl $0x75, %eax
cmpl %edi, 0x11894(%rip)     # 0x19888
je 0x8070
movl $0x7b, %eax
cmpl %edi, 0x1188b(%rip)     # 0x1988c
je 0x8070
movl $0x7c, %eax
cmpl %edi, 0x11882(%rip)     # 0x19890
je 0x8070
movl $0x78, %eax
cmpl %edi, 0x11879(%rip)     # 0x19894
je 0x8070
movl $0x79, %eax
cmpl %edi, 0x11870(%rip)     # 0x19898
je 0x8070
movl $0x7a, %eax
cmpl %edi, 0x11867(%rip)     # 0x1989c
je 0x8070
movl $0x7f, %eax
cmpl %edi, 0x1185e(%rip)     # 0x198a0
je 0x8070
movl $0x12, %eax
cmpl %edi, 0x11855(%rip)     # 0x198a4
je 0x8070
movl $0x93, %eax
cmpl %edi, 0x1184c(%rip)     # 0x198a8
je 0x8070
xorl %eax, %eax
cmpl %edi, 0x11846(%rip)     # 0x198ac
setne %al
negl %eax
orl $0x94, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: subr3
int subr3(cell x) {
	if (x == P_sset)	return OP_SSET;
	if (x == P_substr)	return OP_SUBSTR;
	if (x == P_subvec)	return OP_SUBVEC;
	if (x == P_vset)	return OP_VSET;
	return -1;
}

// Assembly:
movl $0x80, %eax
cmpl %edi, 0x11834(%rip)     # 0x198b0
je 0x80aa
movl $0x85, %eax
cmpl %edi, 0x1182b(%rip)     # 0x198b4
je 0x80aa
movl $0x86, %eax
cmpl %edi, 0x11822(%rip)     # 0x198b8
je 0x80aa
xorl %eax, %eax
cmpl %edi, 0x1181c(%rip)     # 0x198bc
setne %al
negl %eax
orl $0x95, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: osubr0
int osubr0(cell x) {
	if (x == P_peekc)	return OP_PEEKC;
	if (x == P_read)	return OP_READ;
	if (x == P_readc)	return OP_READC;
	return -1;
}

// Assembly:
movl $0x65, %eax
cmpl %edi, 0x1180a(%rip)     # 0x198c0
je 0x80d5
movl $0x6a, %eax
cmpl %edi, 0x11801(%rip)     # 0x198c4
je 0x80d5
xorl %eax, %eax
cmpl %edi, 0x117fb(%rip)     # 0x198c8
setne %al
negl %eax
orl $0x6b, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: osubr1
int osubr1(cell x) {
	if (x == P_error)		return OP_ERROR;
	if (x == P_mkstr)		return OP_MKSTR;
	if (x == P_mkvec)		return OP_MKVEC;
	if (x == P_numstr)		return OP_NUMSTR;
	if (x == P_open_outfile)	return OP_OPEN_OUTFILE;
	if (x == P_prin)		return OP_PRIN;
	if (x == P_princ)		return OP_PRINC;
	if (x == P_strnum)		return OP_STRNUM;
	if (x == P_writec)		return OP_WRITEC;
	return -1;
}

// Assembly:
movl $0x3d, %eax
cmpl %edi, 0x117eb(%rip)     # 0x198cc
je 0x8150
movl $0x55, %eax
cmpl %edi, 0x117e2(%rip)     # 0x198d0
je 0x8150
movl $0x56, %eax
cmpl %edi, 0x117d9(%rip)     # 0x198d4
je 0x8150
movl $0x5e, %eax
cmpl %edi, 0x117d0(%rip)     # 0x198d8
je 0x8150
movl $0x61, %eax
cmpl %edi, 0x117c7(%rip)     # 0x198dc
je 0x8150
movl $0x67, %eax
cmpl %edi, 0x117be(%rip)     # 0x198e0
je 0x8150
movl $0x68, %eax
cmpl %edi, 0x117b5(%rip)     # 0x198e4
je 0x8150
movl $0x84, %eax
cmpl %edi, 0x117ac(%rip)     # 0x198e8
je 0x8150
xorl %eax, %eax
cmpl %edi, 0x117a6(%rip)     # 0x198ec
setne %al
negl %eax
orl $0x98, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: lsubr0
int lsubr0(cell x) {
	if (x == P_times)	return OP_TIMES;
	if (x == P_plus)	return OP_PLUS;
	if (x == P_conc)	return OP_CONC;
	if (x == P_nconc)	return OP_NCONC;
	if (x == P_sconc)	return OP_SCONC;
	if (x == P_vconc)	return OP_VCONC;
	return -1;
}

// Assembly:
movl $0x8c, %eax
cmpl %edi, 0x11794(%rip)     # 0x198f0
je 0x81a4
movl $0x66, %eax
cmpl %edi, 0x1178b(%rip)     # 0x198f4
je 0x81a4
movl $0x32, %eax
cmpl %edi, 0x11782(%rip)     # 0x198f8
je 0x81a4
movl $0x59, %eax
cmpl %edi, 0x11779(%rip)     # 0x198fc
je 0x81a4
movl $0x6f, %eax
cmpl %edi, 0x11770(%rip)     # 0x19900
je 0x81a4
xorl %eax, %eax
cmpl %edi, 0x1176a(%rip)     # 0x19904
setne %al
negl %eax
orl $0x90, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: lsubr1
int lsubr1(cell x) {
	if (x == P_bitop)	return OP_BITOP;
	if (x == P_max)		return OP_MAX;
	if (x == P_min)		return OP_MIN;
	if (x == P_minus)	return OP_MINUS;
	if (x == P_less)	return OP_LESS;
	if (x == P_lteq)	return OP_LTEQ;
	if (x == P_equal)	return OP_EQUAL;
	if (x == P_grtr)	return OP_GRTR;
	if (x == P_gteq)	return OP_GTEQ;
	if (x == P_cless)	return OP_CLESS;
	if (x == P_clteq)	return OP_CLTEQ;
	if (x == P_cequal)	return OP_CEQUAL;
	if (x == P_cgrtr)	return OP_CGRTR;
	if (x == P_cgteq)	return OP_CGTEQ;
	return -1;
}

// Assembly:
movl $0x21, %eax
cmpl %edi, 0x11758(%rip)     # 0x19908
je 0x826e
movl $0x52, %eax
cmpl %edi, 0x1174b(%rip)     # 0x1990c
je 0x826e
movl $0x53, %eax
cmpl %edi, 0x1173e(%rip)     # 0x19910
je 0x826e
movl $0x54, %eax
cmpl %edi, 0x11731(%rip)     # 0x19914
je 0x826e
movl $0x4c, %eax
cmpl %edi, 0x11724(%rip)     # 0x19918
je 0x826e
movl $0x51, %eax
cmpl %edi, 0x1171b(%rip)     # 0x1991c
je 0x826e
movl $0x3c, %eax
cmpl %edi, 0x11712(%rip)     # 0x19920
je 0x826e
movl $0x48, %eax
cmpl %edi, 0x11709(%rip)     # 0x19924
je 0x826e
movl $0x49, %eax
cmpl %edi, 0x11700(%rip)     # 0x19928
je 0x826e
movl $0x2e, %eax
cmpl %edi, 0x116f7(%rip)     # 0x1992c
je 0x826e
movl $0x30, %eax
cmpl %edi, 0x116ee(%rip)     # 0x19930
je 0x826e
movl $0x28, %eax
cmpl %edi, 0x116e5(%rip)     # 0x19934
je 0x826e
movl $0x29, %eax
cmpl %edi, 0x116dc(%rip)     # 0x19938
je 0x826e
xorl %eax, %eax
cmpl %edi, 0x116d6(%rip)     # 0x1993c
setne %al
negl %eax
orl $0x2a, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: compprog
void compprog(cell x, int t) {
	x = cdr(x);
	if (NIL == x) {
		emitq(NIL);
		return;
	}
	while (cdr(x) != NIL) {
		compexpr(car(x), 0);
		x = cdr(x);
	}
	compexpr(car(x), t);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x110ce(%rip), %rax     # 0x19348
movslq %edi, %rcx
movslq (%rax,%rcx,4), %r14
cmpq $-0x1, %r14
je 0x82cf
movl %esi, %ebx
movq 0x110b8(%rip), %rax     # 0x19348
cmpl $-0x1, (%rax,%r14,4)
je 0x82b6
movq 0x110a2(%rip), %rax     # 0x19340
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x82e0
movq 0x11098(%rip), %rax     # 0x19348
movslq (%rax,%r14,4), %r14
jmp 0x8290
movq 0x11083(%rip), %rax     # 0x19340
movl (%rax,%r14,4), %edi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x82e0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x798e