LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
movl 0x180c8(%rip), %esi     # 0x20170
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl %eax, 0x180b6(%rip)     # 0x20170
movb $0x1, %al
cmpl $0x0, -0x4(%rbp)
movb %al, -0x9(%rbp)
jl 0x80fc
movq 0x18284(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
andl $0x1, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x9(%rbp)
jne 0x80fc
movq 0x18268(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8107
jmp 0x814c
movq 0x18232(%rip), %rax     # 0x20340
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl -0x8(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edx
movq 0x18214(%rip), %rax     # 0x20340
movslq 0x1803d(%rip), %rcx     # 0x20170
movl %edx, (%rax,%rcx,4)
movq 0x1820b(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x80ba
cmpl $-0x1, -0x4(%rbp)
je 0x8162
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x8(%rbp)
movl $0x1, %edi
callq 0x3d00
movl -0x8(%rbp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4e80
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl $0x2, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7970
movq 0x1819c(%rip), %rax     # 0x20340
movq 0x1819d(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x7e80
cmpl $0x0, %eax
jne 0x81e5
movq 0x18179(%rip), %rax     # 0x20340
movq 0x1817a(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x13580(%rip), %rdi     # 0x1b760
callq 0x26c0
movq 0x18154(%rip), %rax     # 0x20340
movq 0x18155(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x8090
movl %eax, %edi
callq 0x8000
cmpl $0x0, %eax
jne 0x8234
movq 0x1812a(%rip), %rax     # 0x20340
movq 0x1812b(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x13549(%rip), %rdi     # 0x1b778
callq 0x26c0
movq 0x1810d(%rip), %rax     # 0x20348
movq 0x18106(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x7a00
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl $0x2, %edx
movl %edx, %esi
callq 0x7970
movq 0x180bc(%rip), %rax     # 0x20340
movq 0x180bd(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0x82f1
movq 0x180b0(%rip), %rax     # 0x20350
movq 0x18099(%rip), %rcx     # 0x20340
movq 0x1809a(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x82f1
movq 0x18073(%rip), %rcx     # 0x20340
movq 0x1806c(%rip), %rax     # 0x20340
movq 0x1806d(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rax,%rdx,4), %rdx
movl $0xffffffee, %eax       # imm = 0xFFFFFFEE
cmpl (%rcx,%rdx,4), %eax
je 0x8316
movq 0x18048(%rip), %rax     # 0x20340
movq 0x18049(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x13480(%rip), %rdi     # 0x1b791
callq 0x26c0
cmpl $0x0, -0x8(%rbp)
jne 0x832b
movl -0x4(%rbp), %esi
leaq 0x13482(%rip), %rdi     # 0x1b7a8
callq 0x26c0
movq 0x1800e(%rip), %rax     # 0x20340
movq 0x1800f(%rip), %rcx     # 0x20348
movq 0x18008(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x7a90
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl $0x2, %edx
movl %edx, %esi
callq 0x7970
movq 0x17f5f(%rip), %rax     # 0x20340
movq 0x17f60(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0x844e
movq 0x17f53(%rip), %rax     # 0x20350
movq 0x17f3c(%rip), %rcx     # 0x20340
movq 0x17f3d(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x844e
movq 0x17f16(%rip), %rcx     # 0x20340
movq 0x17f0f(%rip), %rax     # 0x20340
movq 0x17f10(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rax,%rdx,4), %rdx
movl $0xffffffee, %eax       # imm = 0xFFFFFFEE
cmpl (%rcx,%rdx,4), %eax
je 0x8473
movq 0x17eeb(%rip), %rax     # 0x20340
movq 0x17eec(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x13356(%rip), %rdi     # 0x1b7c4
callq 0x26c0
movq 0x17ece(%rip), %rax     # 0x20348
movq 0x17ec7(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x7a00
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4df0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl 0x17ca9(%rip), %esi     # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0x17c9c(%rip)     # 0x20170
movl -0x8(%rbp), %edi
movl %edi, -0xc(%rbp)
movl 0x17c90(%rip), %esi     # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0x17c83(%rip)     # 0x20170
movb $0x1, %al
cmpl $0x0, -0x4(%rbp)
movb %al, -0xd(%rbp)
jl 0x852f
movq 0x17e51(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
andl $0x1, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0xd(%rbp)
jne 0x852f
movq 0x17e35(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x853a
jmp 0x859a
movq 0x17dff(%rip), %rax     # 0x20340
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl -0x8(%rbp), %esi
callq 0x7fb0
cmpl $-0x1, %eax
jne 0x8570
movq 0x17de4(%rip), %rax     # 0x20340
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edx
movq 0x17dc6(%rip), %rax     # 0x20340
movslq 0x17bef(%rip), %rcx     # 0x20170
movl %edx, (%rax,%rcx,4)
movq 0x17dbd(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x84ed
cmpl $-0x1, -0x4(%rbp)
je 0x85c0
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x7fb0
cmpl $-0x1, %eax
jne 0x85c0
movl -0x4(%rbp), %edi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0xc(%rbp)
movl $0x2, %edi
callq 0x3d00
movl -0xc(%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: 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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0xa570
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x5(%rbp)
jge 0x8a3c
movl -0x4(%rbp), %edi
callq 0xa640
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x5(%rbp)
jge 0x8a3c
movl -0x4(%rbp), %edi
callq 0xab50
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x5(%rbp)
jge 0x8a3c
movl -0x4(%rbp), %edi
callq 0xad80
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x5(%rbp)
jge 0x8a3c
movl -0x4(%rbp), %edi
callq 0xadf0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x5(%rbp)
jge 0x8a3c
movl -0x4(%rbp), %edi
callq 0xae40
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x5(%rbp)
jge 0x8a3c
movl -0x4(%rbp), %edi
callq 0xaf10
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x5(%rbp)
jge 0x8a3c
movl -0x4(%rbp), %edi
callq 0xafa0
cmpl $0x0, %eax
setge %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0x8a9e
movq 0x178d2(%rip), %rax     # 0x20340
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jne 0x8a82
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8aa5
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq 0x178b6(%rip), %rax     # 0x20348
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
jmp 0x8a61
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: lastpair
cell lastpair(cell x) {
	if (NIL == x) return NIL;
	while (cdr(x) != NIL)
		x = cdr(x);
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x8(%rbp), %eax
jne 0x8cfa
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8d26
jmp 0x8cfc
movq 0x17645(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x8d20
movq 0x17634(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
jmp 0x8cfc
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl 0x17450(%rip), %esi     # 0x20194
callq 0x7fb0
cmpl $-0x1, %eax
je 0x8d50
jmp 0x8d9d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x1743d(%rip), %eax     # 0x20198
jne 0x8d6e
movl 0x17431(%rip), %edi     # 0x20194
callq 0x8ce0
movl %eax, 0x1742a(%rip)     # 0x20198
movl -0x4(%rbp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edx
movq 0x175be(%rip), %rax     # 0x20348
movslq 0x17407(%rip), %rcx     # 0x20198
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
movl %eax, 0x173fb(%rip)     # 0x20198
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl 0x17362(%rip), %esi     # 0x20170
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl %eax, 0x17350(%rip)     # 0x20170
movb $0x1, %al
cmpl $0x0, -0x4(%rbp)
movb %al, -0x15(%rbp)
jl 0x8e62
movq 0x1751e(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
andl $0x1, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
jne 0x8e62
movq 0x17502(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8e6d
jmp 0x8ec3
movq 0x174cc(%rip), %rax     # 0x20340
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x8ee0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
movl -0x10(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edx
movq 0x1749d(%rip), %rax     # 0x20340
movslq 0x172c6(%rip), %rcx     # 0x20170
movl %edx, (%rax,%rcx,4)
movq 0x17494(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x8e20
movl $0x1, %edi
callq 0x3d00
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4e80
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x85e0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
movl 0x16e16(%rip), %esi     # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0x16e09(%rip)     # 0x20170
movl -0x14(%rbp), %edi
callq 0x8db0
movq 0x16fca(%rip), %rax     # 0x20340
movq 0x16fcb(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x8090
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
movl 0x16dd7(%rip), %esi     # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0x16dca(%rip)     # 0x20170
movl -0x14(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x8ab0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
movl 0x16db0(%rip), %esi     # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0x16da3(%rip)     # 0x20170
movq 0x16f74(%rip), %rax     # 0x20348
movq 0x16f6d(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x8df0
movl %eax, -0x10(%rbp)
movl -0x1c(%rbp), %edi
movl -0x10(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x10(%rbp)
movq 0x16f35(%rip), %rax     # 0x20340
movq 0x16f36(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl -0x10(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x10(%rbp)
movl 0x17310(%rip), %edi     # 0x20740
movl -0x10(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x10(%rbp)
movl $0x3, %edi
callq 0x3d00
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x946f
movl $0x1, -0x4(%rbp)
jmp 0x94e9
cmpl $0x0, -0x8(%rbp)
jl 0x94e2
movq 0x16ed4(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x94e2
movq 0x16ebd(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x94e2
movq 0x16e96(%rip), %rax     # 0x20340
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl -0xc(%rbp), %esi
callq 0x9450
cmpl $0x0, %eax
jne 0x94d9
movq 0x16e83(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl -0xc(%rbp), %esi
callq 0x9450
cmpl $0x0, %eax
je 0x94e2
movl $0x1, -0x4(%rbp)
jmp 0x94e9
movl $0x0, -0x4(%rbp)
movl -0x4(%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: 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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
movl 0x16c28(%rip), %esi     # 0x20170
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl %eax, 0x16c16(%rip)     # 0x20170
cmpl $-0x1, -0x4(%rbp)
je 0x95fc
movq 0x16dd5(%rip), %rax     # 0x20340
movq 0x16dce(%rip), %rcx     # 0x20340
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x171b5(%rip), %eax     # 0x20738
jne 0x95e6
movq 0x16db4(%rip), %rax     # 0x20340
movq 0x16db5(%rip), %rcx     # 0x20348
movq 0x16dae(%rip), %rdx     # 0x20348
movq 0x16da7(%rip), %rsi     # 0x20348
movq 0x16d98(%rip), %rdi     # 0x20340
movslq -0x4(%rbp), %r8
movslq (%rdi,%r8,4), %rdi
movslq (%rsi,%rdi,4), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
movl -0x8(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edx
movq 0x16d64(%rip), %rax     # 0x20340
movslq 0x16b8d(%rip), %rcx     # 0x20170
movl %edx, (%rax,%rcx,4)
movq 0x16d5b(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x955a
movl $0x1, %edi
callq 0x3d00
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4e80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
movl 0x16b38(%rip), %esi     # 0x20170
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl %eax, 0x16b26(%rip)     # 0x20170
cmpl $-0x1, -0x4(%rbp)
je 0x9731
movq 0x16ce5(%rip), %rax     # 0x20340
movq 0x16cde(%rip), %rcx     # 0x20340
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x170c5(%rip), %eax     # 0x20738
jne 0x971b
movq 0x16cc0(%rip), %rax     # 0x20340
movq 0x16cc1(%rip), %rcx     # 0x20348
movq 0x16cb2(%rip), %rdx     # 0x20340
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl %eax, -0xc(%rbp)
movq 0x16c87(%rip), %rax     # 0x20340
movq 0x16c80(%rip), %rcx     # 0x20340
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x17067(%rip), %eax     # 0x20738
jne 0x96de
movl 0x1706b(%rip), %eax     # 0x20744
movl %eax, -0x10(%rbp)
jmp 0x96e7
movl 0x17064(%rip), %eax     # 0x20748
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
movl -0x8(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edx
movq 0x16c2f(%rip), %rax     # 0x20340
movslq 0x16a58(%rip), %rcx     # 0x20170
movl %edx, (%rax,%rcx,4)
movq 0x16c26(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x964a
movl $0x1, %edi
callq 0x3d00
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4e80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq 0x169b8(%rip), %rax     # 0x20340
movq 0x169b9(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x8d30
movq 0x1699a(%rip), %rax     # 0x20340
movq 0x1699b(%rip), %rcx     # 0x20348
movq 0x16994(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x8ee0
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
movl 0x16788(%rip), %esi     # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0x1677b(%rip)     # 0x20170
movq 0x16944(%rip), %rax     # 0x20340
movq 0x16945(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl -0x8(%rbp), %esi
callq 0x8a50
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl $0x1, %edx
callq 0x3990
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
movl 0x1672c(%rip), %esi     # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0x1671f(%rip)     # 0x20170
movl 0x16cf1(%rip), %eax     # 0x20748
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movq 0x168d9(%rip), %rax     # 0x20340
movq 0x168da(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl -0x20(%rbp), %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3990
movl -0x1c(%rbp), %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x14(%rbp)
movl $0x2, %edi
callq 0x3d00
movl 0x16c84(%rip), %eax     # 0x20734
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %edi
movl -0x10(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl -0x18(%rbp), %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3990
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
movl 0x16678(%rip), %esi     # 0x20170
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl %eax, 0x16666(%rip)     # 0x20170
cmpl $-0x1, -0x4(%rbp)
je 0x9b5d
movq 0x16829(%rip), %rax     # 0x20340
movq 0x16822(%rip), %rcx     # 0x20340
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl -0x8(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edx
movq 0x16800(%rip), %rax     # 0x20340
movslq 0x16629(%rip), %rcx     # 0x20170
movl %edx, (%rax,%rcx,4)
movq 0x167f7(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x9b0a
movl $0x1, %edi
callq 0x3d00
movl -0x8(%rbp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4e80
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl 0x165d5(%rip), %esi     # 0x20170
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl %eax, 0x165c3(%rip)     # 0x20170
cmpl $-0x1, -0x4(%rbp)
je 0x9c50
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x8(%rbp), %eax
jne 0x9bf4
movq 0x16778(%rip), %rax     # 0x20340
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl -0x14(%rbp), %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x10(%rbp)
jmp 0x9c16
movq 0x16745(%rip), %rax     # 0x20340
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
movq 0x1673c(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
movl -0x10(%rbp), %edi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edx
movq 0x16710(%rip), %rax     # 0x20340
movslq 0x16539(%rip), %rcx     # 0x20170
movl %edx, (%rax,%rcx,4)
movq 0x16707(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x9bad
movl $0x1, %edi
callq 0x3d00
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4e80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x164c3(%rip), %edi     # 0x20144
callq 0x9ae0
movl %eax, 0x16508(%rip)     # 0x20194
movl $0xffffffff, 0x16502(%rip) # imm = 0xFFFFFFFF
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x164f3(%rip), %eax     # 0x20194
jne 0x9cba
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl %eax, 0x164da(%rip)     # 0x20194
movl -0x4(%rbp), %edi
movl 0x164d1(%rip), %esi     # 0x20194
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x8ee0
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
movl 0x16497(%rip), %esi     # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0x1648a(%rip)     # 0x20170
movl 0x164a8(%rip), %edi     # 0x20194
movl 0x16452(%rip), %esi     # 0x20144
callq 0x9b80
movl %eax, 0x16447(%rip)     # 0x20144
movl $0x1, %edi
callq 0x3d00
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x9f9f
movq 0x163d8(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x9f9f
movq 0x163c1(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xa003
cmpl $0x0, -0x8(%rbp)
jl 0x9fd1
movq 0x163a4(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x9fd1
movq 0x1637d(%rip), %rcx     # 0x20340
movslq -0x8(%rbp), %rdx
movl $0xffffffed, %eax       # imm = 0xFFFFFFED
cmpl (%rcx,%rdx,4), %eax
je 0xa003
cmpl $0x0, -0x8(%rbp)
jl 0xa010
movq 0x16372(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xa010
movq 0x1634b(%rip), %rcx     # 0x20340
movslq -0x8(%rbp), %rdx
movl $0xfffffff3, %eax       # imm = 0xFFFFFFF3
cmpl (%rcx,%rdx,4), %eax
jne 0xa010
callq 0x9d10
movl %eax, -0x4(%rbp)
jmp 0xa116
movl 0x16186(%rip), %edi     # 0x2019c
movl -0x8(%rbp), %esi
callq 0x4730
movl %eax, -0xc(%rbp)
cmpl $-0x4, -0xc(%rbp)
je 0xa0c9
movq 0x1630e(%rip), %rax     # 0x20340
movq 0x1630f(%rip), %rcx     # 0x20348
movq 0x16308(%rip), %rdx     # 0x20348
movslq -0xc(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
movq 0x162ff(%rip), %rax     # 0x20358
movq 0x162e8(%rip), %rcx     # 0x20348
movslq 0x160f1(%rip), %rdx     # 0x20158
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xa0bb
movl -0x8(%rbp), %edi
movq 0x162cf(%rip), %rax     # 0x20358
movq 0x162b8(%rip), %rcx     # 0x20348
movslq 0x160cd(%rip), %rdx     # 0x20164
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x4120
cmpl $0x0, %eax
je 0xa0bb
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa116
movl 0x160db(%rip), %edi     # 0x2019c
movl -0x8(%rbp), %esi
callq 0x49f0
callq 0x9d10
movl %eax, -0x10(%rbp)
movl 0x160c5(%rip), %eax     # 0x2019c
movl %eax, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl $0x1, %edx
callq 0x3990
movl -0x18(%rbp), %edi
movl -0x14(%rbp), %esi
movl %eax, %edx
callq 0x4820
movl -0x10(%rbp), %eax
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: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl 0x1661f(%rip), %eax     # 0x20750
movq 0x16220(%rip), %rcx     # 0x20358
movq 0x16209(%rip), %rdx     # 0x20348
movq 0x16202(%rip), %rsi     # 0x20348
movslq 0x16053(%rip), %rdi     # 0x201a0
movslq (%rsi,%rdi,4), %rsi
movl (%rdx,%rsi,4), %edx
subl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jl 0xa25b
movl -0x4(%rbp), %edi
movl 0x16004(%rip), %esi     # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0x15ff7(%rip)     # 0x20170
movq 0x161d8(%rip), %rax     # 0x20358
movq 0x161c1(%rip), %rcx     # 0x20348
movq 0x161ba(%rip), %rdx     # 0x20348
movslq 0x1600b(%rip), %rsi     # 0x201a0
movslq (%rdx,%rsi,4), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
addl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
movl %eax, %edi
callq 0x2880
movl %eax, -0x8(%rbp)
movq 0x16194(%rip), %rax     # 0x20358
movq 0x1617d(%rip), %rcx     # 0x20348
movq 0x16176(%rip), %rdx     # 0x20348
movslq 0x15fc7(%rip), %rsi     # 0x201a0
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq 0x16165(%rip), %rax     # 0x20358
movq 0x1614e(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xa23d
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa214
movl -0x8(%rbp), %edx
movq 0x16101(%rip), %rax     # 0x20348
movslq 0x15f52(%rip), %rcx     # 0x201a0
movl %edx, (%rax,%rcx,4)
movl $0x1, %edi
callq 0x3d00
movl -0x4(%rbp), %eax
movb %al, %dl
movq 0x160f1(%rip), %rax     # 0x20358
movq 0x160da(%rip), %rcx     # 0x20348
movq 0x160d3(%rip), %rsi     # 0x20348
movslq 0x15f24(%rip), %rdi     # 0x201a0
movslq (%rsi,%rdi,4), %rsi
movslq (%rcx,%rsi,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0x164be(%rip), %rcx     # 0x20750
movb %dl, (%rax,%rcx)
movl 0x164b5(%rip), %eax     # 0x20750
addl $0x1, %eax
movl %eax, 0x164ac(%rip)     # 0x20750
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0xa2ca
cmpl $0xffff, -0x4(%rbp)     # imm = 0xFFFF
jle 0xa2fb
movl -0x4(%rbp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
leaq 0x11520(%rip), %rdi     # 0x1b816
callq 0x26c0
movl -0x4(%rbp), %edi
sarl $0x8, %edi
callq 0xa120
movl -0x4(%rbp), %edi
andl $0xff, %edi
callq 0xa120
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x9f60
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edx
movq 0x16018(%rip), %rax     # 0x20358
movq 0x16001(%rip), %rcx     # 0x20348
movslq 0x15e16(%rip), %rsi     # 0x20164
movslq (%rcx,%rsi,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl $0x5, %edi
callq 0xa120
movl -0x8(%rbp), %edi
callq 0xa2b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0xa39d
cmpl $0xffff, -0x8(%rbp)     # imm = 0xFFFF
jle 0xa3ce
movl -0x8(%rbp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
leaq 0x1144d(%rip), %rdi     # 0x1b816
callq 0x26c0
movl -0x8(%rbp), %eax
sarl $0x8, %eax
movb %al, %dl
movq 0x15f7b(%rip), %rax     # 0x20358
movq 0x15f64(%rip), %rcx     # 0x20348
movq 0x15f5d(%rip), %rsi     # 0x20348
movslq 0x15dae(%rip), %rdi     # 0x201a0
movslq (%rsi,%rdi,4), %rsi
movslq (%rcx,%rsi,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x4(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x8(%rbp), %eax
andl $0xff, %eax
movb %al, %dl
movq 0x15f3f(%rip), %rax     # 0x20358
movq 0x15f28(%rip), %rcx     # 0x20348
movq 0x15f21(%rip), %rsi     # 0x20348
movslq 0x15d72(%rip), %rdi     # 0x201a0
movslq (%rsi,%rdi,4), %rsi
movslq (%rcx,%rsi,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x15d41(%rip), %eax     # 0x201a4
jne 0xa476
leaq 0x113c9(%rip), %rdi     # 0x1b835
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x26c0
movq 0x15ec3(%rip), %rax     # 0x20340
movslq 0x15d20(%rip), %rcx     # 0x201a4
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movq 0x15eb7(%rip), %rax     # 0x20348
movslq 0x15d0c(%rip), %rcx     # 0x201a4
movl (%rax,%rcx,4), %eax
movl %eax, 0x15d03(%rip)     # 0x201a4
movq 0x15e98(%rip), %rax     # 0x20340
movq 0x15e99(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x15cd1(%rip), %eax     # 0x201a4
je 0xa4ed
movq 0x15e6c(%rip), %rcx     # 0x20348
movslq 0x15cc1(%rip), %rdx     # 0x201a4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl (%rcx,%rdx,4), %eax
jne 0xa4fe
leaq 0x11341(%rip), %rdi     # 0x1b835
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x26c0
movq 0x15e3b(%rip), %rax     # 0x20340
movslq 0x15c98(%rip), %rcx     # 0x201a4
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movq 0x15e27(%rip), %rax     # 0x20340
movq 0x15e28(%rip), %rcx     # 0x20348
movslq 0x15c7d(%rip), %rdx     # 0x201a4
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
movq 0x15e0b(%rip), %rax     # 0x20340
movslq 0x15c68(%rip), %rcx     # 0x201a4
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %edx
movq 0x15df7(%rip), %rax     # 0x20340
movq 0x15df8(%rip), %rcx     # 0x20348
movslq 0x15c4d(%rip), %rsi     # 0x201a4
movslq (%rcx,%rsi,4), %rcx
movl %edx, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x161d4(%rip), %eax     # 0x20754
jne 0xa58e
movl $0x31, -0x4(%rbp)
jmp 0xa638
movl -0x8(%rbp), %eax
cmpl 0x161c1(%rip), %eax     # 0x20758
jne 0xa5a5
movl $0x3f, -0x4(%rbp)
jmp 0xa638
movl -0x8(%rbp), %eax
cmpl 0x161ae(%rip), %eax     # 0x2075c
jne 0xa5b9
movl $0x46, -0x4(%rbp)
jmp 0xa638
movl -0x8(%rbp), %eax
cmpl 0x1619e(%rip), %eax     # 0x20760
jne 0xa5cd
movl $0x47, -0x4(%rbp)
jmp 0xa638
movl -0x8(%rbp), %eax
cmpl 0x1618e(%rip), %eax     # 0x20764
jne 0xa5e1
movl $0x4a, -0x4(%rbp)
jmp 0xa638
movl -0x8(%rbp), %eax
cmpl 0x1617e(%rip), %eax     # 0x20768
jne 0xa5f5
movl $0x5f, -0x4(%rbp)
jmp 0xa638
movl -0x8(%rbp), %eax
cmpl 0x1616e(%rip), %eax     # 0x2076c
jne 0xa609
movl $0x62, -0x4(%rbp)
jmp 0xa638
movl -0x8(%rbp), %eax
cmpl 0x1615e(%rip), %eax     # 0x20770
jne 0xa61d
movl $0x69, -0x4(%rbp)
jmp 0xa638
movl -0x8(%rbp), %eax
cmpl 0x1614e(%rip), %eax     # 0x20774
jne 0xa631
movl $0x8a, -0x4(%rbp)
jmp 0xa638
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x15b20(%rip), %eax     # 0x208b0
jne 0xad9b
movl $0x80, -0x4(%rbp)
jmp 0xadde
movl -0x8(%rbp), %eax
cmpl 0x15b10(%rip), %eax     # 0x208b4
jne 0xadaf
movl $0x85, -0x4(%rbp)
jmp 0xadde
movl -0x8(%rbp), %eax
cmpl 0x15b00(%rip), %eax     # 0x208b8
jne 0xadc3
movl $0x86, -0x4(%rbp)
jmp 0xadde
movl -0x8(%rbp), %eax
cmpl 0x15af0(%rip), %eax     # 0x208bc
jne 0xadd7
movl $0x95, -0x4(%rbp)
jmp 0xadde
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x15ac0(%rip), %eax     # 0x208c0
jne 0xae0b
movl $0x65, -0x4(%rbp)
jmp 0xae3a
movl -0x8(%rbp), %eax
cmpl 0x15ab0(%rip), %eax     # 0x208c4
jne 0xae1f
movl $0x6a, -0x4(%rbp)
jmp 0xae3a
movl -0x8(%rbp), %eax
cmpl 0x15aa0(%rip), %eax     # 0x208c8
jne 0xae33
movl $0x6b, -0x4(%rbp)
jmp 0xae3a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x15a7c(%rip), %eax     # 0x208cc
jne 0xae5e
movl $0x3d, -0x4(%rbp)
jmp 0xaf08
movl -0x8(%rbp), %eax
cmpl 0x15a69(%rip), %eax     # 0x208d0
jne 0xae75
movl $0x55, -0x4(%rbp)
jmp 0xaf08
movl -0x8(%rbp), %eax
cmpl 0x15a56(%rip), %eax     # 0x208d4
jne 0xae89
movl $0x56, -0x4(%rbp)
jmp 0xaf08
movl -0x8(%rbp), %eax
cmpl 0x15a46(%rip), %eax     # 0x208d8
jne 0xae9d
movl $0x5e, -0x4(%rbp)
jmp 0xaf08
movl -0x8(%rbp), %eax
cmpl 0x15a36(%rip), %eax     # 0x208dc
jne 0xaeb1
movl $0x61, -0x4(%rbp)
jmp 0xaf08
movl -0x8(%rbp), %eax
cmpl 0x15a26(%rip), %eax     # 0x208e0
jne 0xaec5
movl $0x67, -0x4(%rbp)
jmp 0xaf08
movl -0x8(%rbp), %eax
cmpl 0x15a16(%rip), %eax     # 0x208e4
jne 0xaed9
movl $0x68, -0x4(%rbp)
jmp 0xaf08
movl -0x8(%rbp), %eax
cmpl 0x15a06(%rip), %eax     # 0x208e8
jne 0xaeed
movl $0x84, -0x4(%rbp)
jmp 0xaf08
movl -0x8(%rbp), %eax
cmpl 0x159f6(%rip), %eax     # 0x208ec
jne 0xaf01
movl $0x98, -0x4(%rbp)
jmp 0xaf08
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x159d0(%rip), %eax     # 0x208f0
jne 0xaf2b
movl $0x8c, -0x4(%rbp)
jmp 0xaf96
movl -0x8(%rbp), %eax
cmpl 0x159c0(%rip), %eax     # 0x208f4
jne 0xaf3f
movl $0x66, -0x4(%rbp)
jmp 0xaf96
movl -0x8(%rbp), %eax
cmpl 0x159b0(%rip), %eax     # 0x208f8
jne 0xaf53
movl $0x32, -0x4(%rbp)
jmp 0xaf96
movl -0x8(%rbp), %eax
cmpl 0x159a0(%rip), %eax     # 0x208fc
jne 0xaf67
movl $0x59, -0x4(%rbp)
jmp 0xaf96
movl -0x8(%rbp), %eax
cmpl 0x15990(%rip), %eax     # 0x20900
jne 0xaf7b
movl $0x6f, -0x4(%rbp)
jmp 0xaf96
movl -0x8(%rbp), %eax
cmpl 0x15980(%rip), %eax     # 0x20904
jne 0xaf8f
movl $0x90, -0x4(%rbp)
jmp 0xaf96
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x15958(%rip), %eax     # 0x20908
jne 0xafbe
movl $0x21, -0x4(%rbp)
jmp 0xb0db
movl -0x8(%rbp), %eax
cmpl 0x15945(%rip), %eax     # 0x2090c
jne 0xafd5
movl $0x52, -0x4(%rbp)
jmp 0xb0db
movl -0x8(%rbp), %eax
cmpl 0x15932(%rip), %eax     # 0x20910
jne 0xafec
movl $0x53, -0x4(%rbp)
jmp 0xb0db
movl -0x8(%rbp), %eax
cmpl 0x1591f(%rip), %eax     # 0x20914
jne 0xb003
movl $0x54, -0x4(%rbp)
jmp 0xb0db
movl -0x8(%rbp), %eax
cmpl 0x1590c(%rip), %eax     # 0x20918
jne 0xb01a
movl $0x4c, -0x4(%rbp)
jmp 0xb0db
movl -0x8(%rbp), %eax
cmpl 0x158f9(%rip), %eax     # 0x2091c
jne 0xb031
movl $0x51, -0x4(%rbp)
jmp 0xb0db
movl -0x8(%rbp), %eax
cmpl 0x158e6(%rip), %eax     # 0x20920
jne 0xb048
movl $0x3c, -0x4(%rbp)
jmp 0xb0db
movl -0x8(%rbp), %eax
cmpl 0x158d3(%rip), %eax     # 0x20924
jne 0xb05c
movl $0x48, -0x4(%rbp)
jmp 0xb0db
movl -0x8(%rbp), %eax
cmpl 0x158c3(%rip), %eax     # 0x20928
jne 0xb070
movl $0x49, -0x4(%rbp)
jmp 0xb0db
movl -0x8(%rbp), %eax
cmpl 0x158b3(%rip), %eax     # 0x2092c
jne 0xb084
movl $0x2e, -0x4(%rbp)
jmp 0xb0db
movl -0x8(%rbp), %eax
cmpl 0x158a3(%rip), %eax     # 0x20930
jne 0xb098
movl $0x30, -0x4(%rbp)
jmp 0xb0db
movl -0x8(%rbp), %eax
cmpl 0x15893(%rip), %eax     # 0x20934
jne 0xb0ac
movl $0x28, -0x4(%rbp)
jmp 0xb0db
movl -0x8(%rbp), %eax
cmpl 0x15883(%rip), %eax     # 0x20938
jne 0xb0c0
movl $0x29, -0x4(%rbp)
jmp 0xb0db
movl -0x8(%rbp), %eax
cmpl 0x15873(%rip), %eax     # 0x2093c
jne 0xb0d4
movl $0x2a, -0x4(%rbp)
jmp 0xb0db
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq 0x15253(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x4(%rbp), %eax
jne 0xb115
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xa320
jmp 0xb166
jmp 0xb117
movq 0x1522a(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0xb150
movq 0x15211(%rip), %rax     # 0x20340
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0xb170
movq 0x15204(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0xb117
movq 0x151e9(%rip), %rax     # 0x20340
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl -0x8(%rbp), %esi
callq 0xb170
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)