LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: compsetq
void compsetq(cell x) {
	compexpr(caddr(x), 0);
	if (caadr(x) == I_ref) {
		emitop(OP_SETREF);
		emitarg(fixval(cadadr(x)));
	}
	else if (caadr(x) == I_arg) {
		emitop(OP_SETARG);
		emitarg(fixval(cadadr(x)));
	}
	else {
		error("oops: unknown location in setq", x);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x14cce(%rip), %rax     # 0x20340
movq 0x14ccf(%rip), %rcx     # 0x20348
movq 0x14cc8(%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 0xb170
movq 0x14ca3(%rip), %rax     # 0x20340
movq 0x14c9c(%rip), %rcx     # 0x20340
movq 0x14c9d(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x15088(%rip), %eax     # 0x20748
jne 0xb71b
movl $0x1c, %edi
callq 0xa120
movq 0x14c6d(%rip), %rax     # 0x20340
movq 0x14c6e(%rip), %rcx     # 0x20348
movq 0x14c5f(%rip), %rdx     # 0x20340
movq 0x14c60(%rip), %rsi     # 0x20348
movq 0x14c51(%rip), %rdi     # 0x20340
movq 0x14c52(%rip), %r8      # 0x20348
movslq -0x4(%rbp), %r9
movslq (%r8,%r9,4), %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), %edi
callq 0xa2b0
jmp 0xb7ae
movq 0x14c1e(%rip), %rax     # 0x20340
movq 0x14c17(%rip), %rcx     # 0x20340
movq 0x14c18(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x14fff(%rip), %eax     # 0x20744
jne 0xb79d
movl $0x1b, %edi
callq 0xa120
movq 0x14be8(%rip), %rax     # 0x20340
movq 0x14be9(%rip), %rcx     # 0x20348
movq 0x14bda(%rip), %rdx     # 0x20340
movq 0x14bdb(%rip), %rsi     # 0x20348
movq 0x14bcc(%rip), %rdi     # 0x20340
movq 0x14bcd(%rip), %r8      # 0x20348
movslq -0x4(%rbp), %r9
movslq (%r8,%r9,4), %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), %edi
callq 0xa2b0
jmp 0xb7ac
movl -0x4(%rbp), %esi
leaq 0x100ac(%rip), %rdi     # 0x1b853
callq 0x26c0
jmp 0xb7ae
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: compif
void compif(cell x, int t, int star) {
	compexpr(cadr(x), 0);
	emitop(star? OP_BRT: OP_BRF);
	cpushval(Here);
	emitarg(0);
	compexpr(caddr(x), t);
	if (cdddr(x) != NIL) {
		emitop(OP_JMP);
		cpushval(Here);
		emitarg(0);
		swap();
		patch(cpopval(), Here);
		compexpr(cadddr(x), t);
	}
	patch(cpopval(), Here);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq 0x14b68(%rip), %rax     # 0x20340
movq 0x14b69(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0xb170
movl -0xc(%rbp), %ecx
movl $0xe, %edi
movl $0xf, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edi
callq 0xa120
movl 0x14f41(%rip), %edi     # 0x20750
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, %edi
movl 0x1496d(%rip), %esi     # 0x201a4
xorl %edx, %edx
callq 0x3990
movl %eax, 0x14960(%rip)     # 0x201a4
xorl %edi, %edi
callq 0xa2b0
movq 0x14aee(%rip), %rax     # 0x20340
movq 0x14aef(%rip), %rcx     # 0x20348
movq 0x14ae8(%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
callq 0xb170
movq 0x14aca(%rip), %rax     # 0x20348
movq 0x14ac3(%rip), %rcx     # 0x20348
movq 0x14abc(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0xb93c
movl $0xd, %edi
callq 0xa120
movl 0x14e9e(%rip), %edi     # 0x20750
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, %edi
movl 0x148ca(%rip), %esi     # 0x201a4
xorl %edx, %edx
callq 0x3990
movl %eax, 0x148bd(%rip)     # 0x201a4
xorl %edi, %edi
callq 0xa2b0
callq 0xa4c0
callq 0xa450
movl %eax, %edi
movl 0x14e50(%rip), %esi     # 0x20750
callq 0xa380
movq 0x14a34(%rip), %rax     # 0x20340
movq 0x14a35(%rip), %rcx     # 0x20348
movq 0x14a2e(%rip), %rdx     # 0x20348
movq 0x14a27(%rip), %rsi     # 0x20348
movslq -0x4(%rbp), %rdi
movslq (%rsi,%rdi,4), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl -0x8(%rbp), %esi
callq 0xb170
callq 0xa450
movl %eax, %edi
movl 0x14e07(%rip), %esi     # 0x20750
callq 0xa380
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: setupenv
void setupenv(cell m) {
	while (m != NIL) {
		if (caar(m) == I_e)
			emitop(OP_CPREF);
		else if (caar(m) == I_a)
			emitop(OP_CPARG);
		else
			error("oops: unknown location in closure", m);
		emitarg(fixval(cadar(m)));
		emitarg(fixval(caddar(m)));
		m = cdr(m);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $-0x1, -0x4(%rbp)
je 0xba7f
movq 0x149c4(%rip), %rax     # 0x20340
movq 0x149bd(%rip), %rcx     # 0x20340
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x14da8(%rip), %eax     # 0x2073c
jne 0xb9a2
movl $0x16, %edi
callq 0xa120
jmp 0xb9e0
movq 0x14997(%rip), %rax     # 0x20340
movq 0x14990(%rip), %rcx     # 0x20340
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x14d77(%rip), %eax     # 0x20738
jne 0xb9cf
movl $0x17, %edi
callq 0xa120
jmp 0xb9de
movl -0x4(%rbp), %esi
leaq 0xfe99(%rip), %rdi      # 0x1b872
callq 0x26c0
jmp 0xb9e0
movq 0x14959(%rip), %rax     # 0x20340
movq 0x1495a(%rip), %rcx     # 0x20348
movq 0x1494b(%rip), %rdx     # 0x20340
movq 0x1494c(%rip), %rsi     # 0x20348
movq 0x1493d(%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), %edi
callq 0xa2b0
movq 0x1491a(%rip), %rax     # 0x20340
movq 0x1491b(%rip), %rcx     # 0x20348
movq 0x1490c(%rip), %rdx     # 0x20340
movq 0x1490d(%rip), %rsi     # 0x20348
movq 0x14906(%rip), %rdi     # 0x20348
movq 0x148f7(%rip), %r8      # 0x20340
movslq -0x4(%rbp), %r9
movslq (%r8,%r9,4), %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), %edi
callq 0xa2b0
movq 0x148d8(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0xb96b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: compcls
void compcls(cell x) {
	int	a, na;
	cell	b, m;

	emitop(OP_JMP);
	cpushval(Here);
	emitarg(0);
	a = Here;
	na = length(flatargs(cadr(x)));
	if (dottedp(cadr(x))) {
		emitop(OP_ENTCOL);
		emitarg(na-1);
	}
	else {
		emitop(OP_ENTER);
		emitarg(na);
	}
	b = cons(S_prog, cdddr(x));
	protect(b);
	compexpr(b, 1);
	unprot(1);
	emitop(OP_RETURN);
	patch(cpopval(), Here);
	m = caddr(x);
	if (m != NIL) {
		emitop(OP_MKENV);
		emitarg(length(m));
		setupenv(m);
	}
	else {
		emitop(OP_PROPENV);
	}
	emitop(OP_CLOSURE);
	emitarg(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0xd, %edi
callq 0xa120
movl 0x14c25(%rip), %edi     # 0x20750
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, %edi
movl 0x14651(%rip), %esi     # 0x201a4
xorl %edx, %edx
callq 0x3990
movl %eax, 0x14644(%rip)     # 0x201a4
xorl %edi, %edi
callq 0xa2b0
movl 0x14be3(%rip), %eax     # 0x20750
movl %eax, -0x8(%rbp)
movq 0x147c9(%rip), %rax     # 0x20340
movq 0x147ca(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x8090
movl %eax, %edi
callq 0x7930
movl %eax, -0xc(%rbp)
movq 0x147a1(%rip), %rax     # 0x20340
movq 0x147a2(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0xba90
cmpl $0x0, %eax
je 0xbbd2
movl $0x19, %edi
callq 0xa120
movl -0xc(%rbp), %edi
subl $0x1, %edi
callq 0xa2b0
jmp 0xbbe4
movl $0x18, %edi
callq 0xa120
movl -0xc(%rbp), %edi
callq 0xa2b0
movl 0x14b46(%rip), %edi     # 0x20730
movq 0x14757(%rip), %rax     # 0x20348
movq 0x14750(%rip), %rcx     # 0x20348
movq 0x14749(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
movl 0x1454f(%rip), %esi     # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0x14542(%rip)     # 0x20170
movl -0x10(%rbp), %edi
movl $0x1, %esi
callq 0xb170
movl $0x1, %edi
callq 0x3d00
movl $0x1a, %edi
callq 0xa120
callq 0xa450
movl %eax, %edi
movl 0x14af4(%rip), %esi     # 0x20750
callq 0xa380
movq 0x146d8(%rip), %rax     # 0x20340
movq 0x146d9(%rip), %rcx     # 0x20348
movq 0x146d2(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0xbcb1
movl $0x14, %edi
callq 0xa120
movl -0x14(%rbp), %edi
callq 0x7930
movl %eax, %edi
callq 0xa2b0
movl -0x14(%rbp), %edi
callq 0xb960
jmp 0xbcbb
movl $0x15, %edi
callq 0xa120
movl $0x13, %edi
callq 0xa120
movl -0x8(%rbp), %edi
callq 0xa2b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: compapply
void compapply(cell x, int t) {
	cell	xs;

	xs = reverse(cddr(x));
	protect(xs);
	compexpr(car(xs), 0);
	for (xs = cdr(xs); xs != NIL; xs = cdr(xs)) {
		emitop(OP_PUSH);
		compexpr(car(xs), 0);
		emitop(OP_CONS);
	}
	emitop(OP_PUSH);
	unprot(1);
	compexpr(cadr(x), 0);
	emitop(t? OP_APPLIST: OP_APPLIS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq 0x14653(%rip), %rax     # 0x20348
movq 0x1464c(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4df0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
movl 0x14453(%rip), %esi     # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0x14446(%rip)     # 0x20170
movq 0x1460f(%rip), %rax     # 0x20340
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0xb170
movq 0x14602(%rip), %rax     # 0x20348
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0xbd92
movl $0x8, %edi
callq 0xa120
movq 0x145d9(%rip), %rax     # 0x20340
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0xb170
movl $0x33, %edi
callq 0xa120
movq 0x145c2(%rip), %rax     # 0x20348
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
jmp 0xbd50
movl $0x8, %edi
callq 0xa120
movl $0x1, %edi
callq 0x3d00
movq 0x14593(%rip), %rax     # 0x20340
movq 0x14594(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0xb170
movl -0x8(%rbp), %ecx
movl $0x1, %edi
movl $0x2, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edi
callq 0xa120
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: compapp
void compapp(cell x, int t) {
	cell	xs;

	xs = reverse(cdr(x));
	protect(xs);
	while (xs != NIL) {
		compexpr(car(xs), 0);
		emitop(OP_PUSH);
		xs = cdr(xs);
	}
	unprot(1);
	emitop(OP_PUSHVAL);
	emitarg(length(cdr(x)));
	compexpr(car(x), 0);
	emitop(t? OP_TAILAPP: OP_APPLY);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq 0x14543(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4df0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
movl 0x1434e(%rip), %esi     # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0x14341(%rip)     # 0x20170
cmpl $-0x1, -0xc(%rbp)
je 0xbe67
movq 0x14504(%rip), %rax     # 0x20340
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0xb170
movl $0x8, %edi
callq 0xa120
movq 0x144ed(%rip), %rax     # 0x20348
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
jmp 0xbe2f
movl $0x1, %edi
callq 0x3d00
movl $0xa, %edi
callq 0xa120
movq 0x144c6(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x7930
movl %eax, %edi
callq 0xa2b0
movq 0x144a4(%rip), %rax     # 0x20340
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0xb170
movl -0x8(%rbp), %ecx
movl $0x3, %edi
movl $0x4, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edi
callq 0xa120
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: compsubr1
void compsubr1(cell x, int op) {
	ckargs(x, 1, 1);
	compexpr(cadr(x), 0);
	emitop(op);
	if (OP_CATCHSTAR == op) emitop(OP_APPLY);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl $0x1, %edx
movl %edx, %esi
callq 0x7970
movq 0x1441c(%rip), %rax     # 0x20340
movq 0x1441d(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0xb170
movl -0x8(%rbp), %edi
callq 0xa120
movl $0x11, %eax
cmpl -0x8(%rbp), %eax
jne 0xbf59
movl $0x3, %edi
callq 0xa120
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: compsubr2
void compsubr2(cell x, int op) {
	ckargs(x, 2, 2);
	compexpr(caddr(x), 0);
	emitop(OP_PUSH);
	compexpr(cadr(x), 0);
	emitop(op);
}

// 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 0x143bc(%rip), %rax     # 0x20340
movq 0x143bd(%rip), %rcx     # 0x20348
movq 0x143b6(%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 0xb170
movl $0x8, %edi
callq 0xa120
movq 0x14387(%rip), %rax     # 0x20340
movq 0x14388(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0xb170
movl -0x8(%rbp), %edi
callq 0xa120
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: compsubr3
void compsubr3(cell x, int op) {
	ckargs(x, 3, 3);
	compexpr(cadddr(x), 0);
	emitop(OP_PUSH);
	compexpr(caddr(x), 0);
	emitop(OP_PUSH);
	compexpr(cadr(x), 0);
	emitop(op);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl $0x3, %edx
movl %edx, %esi
callq 0x7970
movq 0x1433c(%rip), %rax     # 0x20340
movq 0x1433d(%rip), %rcx     # 0x20348
movq 0x14336(%rip), %rdx     # 0x20348
movq 0x1432f(%rip), %rsi     # 0x20348
movslq -0x4(%rbp), %rdi
movslq (%rsi,%rdi,4), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0xb170
movl $0x8, %edi
callq 0xa120
movq 0x142fc(%rip), %rax     # 0x20340
movq 0x142fd(%rip), %rcx     # 0x20348
movq 0x142f6(%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 0xb170
movl $0x8, %edi
callq 0xa120
movq 0x142c7(%rip), %rax     # 0x20340
movq 0x142c8(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0xb170
movl -0x8(%rbp), %edi
callq 0xa120
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: composubr0
void composubr0(cell x, int op) {
	ckargs(x, 0, 1);
	if (NIL == cdr(x))
		emitop(OP_INPORT);
	else
		compexpr(cadr(x), 0);
	emitop(op);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
xorl %esi, %esi
movl $0x1, %edx
callq 0x7970
movq 0x14284(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl (%rcx,%rdx,4), %eax
jne 0xc0de
movl $0x4a, %edi
callq 0xa120
jmp 0xc0fe
movq 0x1425b(%rip), %rax     # 0x20340
movq 0x1425c(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0xb170
movl -0x8(%rbp), %edi
callq 0xa120
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: composubr1
void composubr1(cell x, int op) {
	ckargs(x, 1, 2);
	if (NIL == cddr(x)) {
		if (OP_ERROR == op) {
			/**/
		}
		else if (OP_MKSTR == op) {
			emitq(Blank);
		}
		else if (OP_MKVEC == op) {
			emitq(NIL);
		}
		else if (OP_OPEN_OUTFILE == op) {
			emitq(NIL);
		}
		else if (OP_NUMSTR == op || OP_STRNUM == op) {
			emitq(Ten);
		}
		else if (OP_WRITEC == op ||
			 OP_PRIN == op ||
			 OP_PRINC == op)
		{
			emitop(OP_OUTPORT);
		}
	}
	else {
		if (OP_ERROR == op) op = OP_ERROR2;
		compexpr(caddr(x), 0);
	}
	emitop(OP_PUSH);
	compexpr(cadr(x), 0);
	emitop(op);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
callq 0x7970
movq 0x14211(%rip), %rcx     # 0x20348
movq 0x1420a(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rax,%rdx,4), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl (%rcx,%rdx,4), %eax
jne 0xc1fb
movl $0x3d, %eax
cmpl -0x8(%rbp), %eax
jne 0xc163
jmp 0xc1f9
movl $0x55, %eax
cmpl -0x8(%rbp), %eax
jne 0xc17a
movl 0x14035(%rip), %edi     # 0x201a8
callq 0xa320
jmp 0xc1f7
movl $0x56, %eax
cmpl -0x8(%rbp), %eax
jne 0xc190
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xa320
jmp 0xc1f5
movl $0x61, %eax
cmpl -0x8(%rbp), %eax
jne 0xc1a6
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xa320
jmp 0xc1f3
movl $0x5e, %eax
cmpl -0x8(%rbp), %eax
je 0xc1ba
movl $0x84, %eax
cmpl -0x8(%rbp), %eax
jne 0xc1c7
movl 0x13ff4(%rip), %edi     # 0x201b4
callq 0xa320
jmp 0xc1f1
movl $0x98, %eax
cmpl -0x8(%rbp), %eax
je 0xc1e5
movl $0x67, %eax
cmpl -0x8(%rbp), %eax
je 0xc1e5
movl $0x68, %eax
cmpl -0x8(%rbp), %eax
jne 0xc1ef
movl $0x62, %edi
callq 0xa120
jmp 0xc1f1
jmp 0xc1f3
jmp 0xc1f5
jmp 0xc1f7
jmp 0xc1f9
jmp 0xc237
movl $0x3d, %eax
cmpl -0x8(%rbp), %eax
jne 0xc20c
movl $0x3e, -0x8(%rbp)
movq 0x1412d(%rip), %rax     # 0x20340
movq 0x1412e(%rip), %rcx     # 0x20348
movq 0x14127(%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 0xb170
movl $0x8, %edi
callq 0xa120
movq 0x140f8(%rip), %rax     # 0x20340
movq 0x140f9(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0xb170
movl -0x8(%rbp), %edi
callq 0xa120
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: compbitop
void compbitop(cell x) {
	if (NIL == cddr(x) || NIL == cdddr(x))
		error("bitop: too few arguments", cdr(x));
	compexpr(cadr(x), 0);
	emitop(OP_PUSH);
	x = cddr(x);
	compexpr(car(x), 0);
	for (x = cdr(x); x != NIL; x = cdr(x)) {
		emitop(OP_PUSH);
		compexpr(car(x), 0);
		emitop(OP_BITOP);
	}
	emitop(OP_DROP);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x13e56(%rip), %rcx     # 0x20348
movq 0x13e4f(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rax,%rdx,4), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl (%rcx,%rdx,4), %eax
je 0xc536
movq 0x13e36(%rip), %rcx     # 0x20348
movq 0x13e2f(%rip), %rax     # 0x20348
movq 0x13e28(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rax,%rdx,4), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl (%rcx,%rdx,4), %eax
jne 0xc550
movq 0x13e0b(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0xf349(%rip), %rdi      # 0x1b894
callq 0x26c0
movq 0x13de9(%rip), %rax     # 0x20340
movq 0x13dea(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0xb170
movl $0x8, %edi
callq 0xa120
movq 0x13dc7(%rip), %rax     # 0x20348
movq 0x13dc0(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movq 0x13da3(%rip), %rax     # 0x20340
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0xb170
movq 0x13d96(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
cmpl $-0x1, -0x4(%rbp)
je 0xc5fe
movl $0x8, %edi
callq 0xa120
movq 0x13d6d(%rip), %rax     # 0x20340
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0xb170
movl $0x21, %edi
callq 0xa120
movq 0x13d56(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0xc5bc
movl $0xc, %edi
callq 0xa120
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: complsubr1
void complsubr1(cell x, int op) {
	ckargs(x, 1, -1);
	if (OP_BITOP == op) {
		compbitop(x);
		return;
	}
	if (NIL == cddr(x)) {
		if (OP_MIN == op || OP_MAX == op) {
			compexpr(cadr(x), 0);
		}
		else if (OP_MINUS == op) {
			compexpr(cadr(x), 0);
			emitop(OP_NEGATE);
		}
		else {
			emitq(TRUE);
		}
	}
	else {
		if (op != OP_MINUS && op != OP_MIN && op != OP_MAX) {
			emitop(OP_PUSHTRUE);
		}
		x = cdr(x);
		compexpr(car(x), 0);
		for (x = cdr(x); x != NIL; x = cdr(x)) {
			emitop(OP_PUSH);
			compexpr(car(x), 0);
			emitop(op);
		}
		if (op != OP_MINUS && op != OP_MIN && op != OP_MAX)
			emitop(OP_POP);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7970
movl $0x21, %eax
cmpl -0x8(%rbp), %eax
jne 0xc647
movl -0x4(%rbp), %edi
callq 0xc4e0
jmp 0xc795
movq 0x13cfa(%rip), %rcx     # 0x20348
movq 0x13cf3(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rax,%rdx,4), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl (%rcx,%rdx,4), %eax
jne 0xc6e4
movl $0x53, %eax
cmpl -0x8(%rbp), %eax
je 0xc67b
movl $0x52, %eax
cmpl -0x8(%rbp), %eax
jne 0xc69d
movq 0x13cbe(%rip), %rax     # 0x20340
movq 0x13cbf(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0xb170
jmp 0xc6df
movl $0x54, %eax
cmpl -0x8(%rbp), %eax
jne 0xc6d3
movq 0x13c92(%rip), %rax     # 0x20340
movq 0x13c93(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0xb170
movl $0x5a, %edi
callq 0xa120
jmp 0xc6dd
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0xa320
jmp 0xc6df
jmp 0xc795
cmpl $0x54, -0x8(%rbp)
je 0xc700
cmpl $0x53, -0x8(%rbp)
je 0xc700
cmpl $0x52, -0x8(%rbp)
je 0xc700
movl $0x9, %edi
callq 0xa120
movq 0x13c41(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movq 0x13c28(%rip), %rax     # 0x20340
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0xb170
movq 0x13c1b(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
cmpl $-0x1, -0x4(%rbp)
je 0xc777
movl $0x8, %edi
callq 0xa120
movq 0x13bf2(%rip), %rax     # 0x20340
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0xb170
movl -0x8(%rbp), %edi
callq 0xa120
movq 0x13bdd(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0xc737
cmpl $0x54, -0x8(%rbp)
je 0xc793
cmpl $0x53, -0x8(%rbp)
je 0xc793
cmpl $0x52, -0x8(%rbp)
je 0xc793
movl $0xb, %edi
callq 0xa120
jmp 0xc795
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: subprog
cell subprog(cell x, int k) {
	cell	n;
	byte	*sx, *sn;
	int	i, j;

	n = mkstr(NULL, k);
	sx = string(x);
	sn = string(n);
	j = 0;
	for (i=0; i<k; i++) {
		sn[j] = sx[i];
		j++;
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %esi
xorl %eax, %eax
movl %eax, %edi
callq 0x2880
movl %eax, -0xc(%rbp)
movq 0x13b94(%rip), %rax     # 0x20358
movq 0x13b7d(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq 0x13b73(%rip), %rax     # 0x20358
movq 0x13b5c(%rip), %rcx     # 0x20348
movslq -0xc(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0xc83f
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc80d
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: compile
cell compile(cell x) {
	cell	n;

	Emitbuf = mkatom(T_BYTECODE, mkstr(NULL, CHUNKSIZE));
	Here = 0;
	Cts = NIL;
	compexpr(x, 0);
	emitop(OP_HALT);
	n = mkatom(T_BYTECODE, subprog(cdr(Emitbuf), Here));
	Emitbuf = NIL;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
xorl %eax, %eax
movl %eax, %edi
movl $0x400, %esi            # imm = 0x400
callq 0x2880
movl %eax, %esi
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
movl $0x1, %edx
callq 0x3990
movl %eax, 0x13920(%rip)     # 0x201a0
movl $0x0, 0x13ec6(%rip)     # 0x20750
movl $0xffffffff, 0x13910(%rip) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %edi
xorl %esi, %esi
callq 0xb170
movl $0x10, %edi
callq 0xa120
movq 0x13a99(%rip), %rax     # 0x20348
movslq 0x138ea(%rip), %rcx     # 0x201a0
movl (%rax,%rcx,4), %edi
movl 0x13e91(%rip), %esi     # 0x20750
callq 0xc7a0
movl %eax, %esi
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
movl $0x1, %edx
callq 0x3990
movl %eax, -0x8(%rbp)
movl $0xffffffff, 0x138be(%rip) # imm = 0xFFFFFFFF
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: newmacro
void newmacro(int id, cell fn) {
	cell	n, name;

	if (!closurep(fn)) expect("macro", "closure", fn);
	name = vector(Symbols)[id];
	n = assq(name, Macros);
	if (NIL == n) {
		n = cons(name, fn);
		Macros = cons(n, Macros);
	}
	else {
		cdr(n) = fn;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0xc930
movq 0x13a45(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xc930
movq 0x13a1e(%rip), %rcx     # 0x20340
movslq -0x8(%rbp), %rdx
movl $0xfffffff3, %eax       # imm = 0xFFFFFFF3
cmpl (%rcx,%rdx,4), %eax
je 0xc946
movl -0x8(%rbp), %edx
leaq 0xef8f(%rip), %rdi      # 0x1b8c9
leaq 0xef4b(%rip), %rsi      # 0x1b88c
callq 0x2950
movq 0x13a0b(%rip), %rax     # 0x20358
movq 0x139f4(%rip), %rcx     # 0x20348
movslq 0x137e1(%rip), %rdx     # 0x2013c
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
movl 0x1383f(%rip), %esi     # 0x201b8
callq 0x27c0
movl %eax, -0xc(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0xc(%rbp), %eax
jne 0xc9b3
movl -0x10(%rbp), %edi
movl -0x8(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
movl 0x13814(%rip), %esi     # 0x201b8
xorl %edx, %edx
callq 0x3990
movl %eax, 0x13807(%rip)     # 0x201b8
jmp 0xc9c4
movl -0x8(%rbp), %edx
movq 0x1398b(%rip), %rax     # 0x20348
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: mapexp
cell mapexp(cell x, int r) {
	cell	p, n, new;

	protect(x);
	protect(n = NIL);
	p = x;
	while (pairp(p)) {
		new = expand(car(p), r);
		n = cons(new, n);
		car(Protected) = n;
		p = cdr(p);
	}
	if (p != NIL) error("dotted list in program", x);
	n = nreverse(unprot(1));
	unprot(1);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl 0x13789(%rip), %esi     # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0x1377c(%rip)     # 0x20170
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl 0x1376f(%rip), %esi     # 0x20170
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl %eax, 0x1375d(%rip)     # 0x20170
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movb $0x1, %al
cmpl $0x0, -0xc(%rbp)
movb %al, -0x15(%rbp)
jl 0xca5b
movq 0x13925(%rip), %rax     # 0x20350
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
andl $0x1, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
jne 0xca5b
movq 0x13909(%rip), %rax     # 0x20350
movslq -0xc(%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 0xca66
jmp 0xcab9
movq 0x138d3(%rip), %rax     # 0x20340
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl -0x8(%rbp), %esi
callq 0xcb00
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 0x138a7(%rip), %rax     # 0x20340
movslq 0x136d0(%rip), %rcx     # 0x20170
movl %edx, (%rax,%rcx,4)
movq 0x1389e(%rip), %rax     # 0x20348
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
jmp 0xca19
cmpl $-0x1, -0xc(%rbp)
je 0xcace
movl -0x4(%rbp), %esi
leaq 0xed11(%rip), %rdi      # 0x1b7da
callq 0x26c0
movl $0x1, %edi
callq 0x3d00
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4e80
movl %eax, -0x10(%rbp)
movl $0x1, %edi
callq 0x3d00
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: zip
cell zip(cell a, cell b) {
	cell	n, p;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl 0x132b5(%rip), %esi     # 0x20170
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl %eax, 0x132a3(%rip)     # 0x20170
xorl %eax, %eax
cmpl $-0x1, -0x4(%rbp)
movb %al, -0x11(%rbp)
je 0xcee2
cmpl $-0x1, -0x8(%rbp)
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xceeb
jmp 0xcf5c
movq 0x1344e(%rip), %rax     # 0x20340
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movq 0x13440(%rip), %rax     # 0x20340
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edx
movq 0x13415(%rip), %rax     # 0x20340
movslq 0x1323e(%rip), %rcx     # 0x20170
movl %edx, (%rax,%rcx,4)
movq 0x1340c(%rip), %rax     # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movq 0x133fb(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
jmp 0xcecd
movl $0x1, %edi
callq 0x3d00
movl -0xc(%rbp), %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: expanddef
cell expanddef(cell x) {
	char	b[100];
	cell	n;

	if (!pairp(cadr(x))) {
		sprintf(b, "%s: expected signature", symname(car(x)));
		error(b, cadr(x));
	}
	n = cons(cdadr(x), expandbody(cddr(x)));
	n = cons(S_lambda, n);
	n = cons(n, NIL);
	n = cons(caadr(x), n);
	n = cons(car(x) == S_defun? S_def: S_macro, n);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movq 0x12fab(%rip), %rax     # 0x20340
movq 0x12fac(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0xd404
movq 0x12f9f(%rip), %rax     # 0x20350
movq 0x12f88(%rip), %rcx     # 0x20340
movq 0x12f89(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xd404
movq 0x12f72(%rip), %rax     # 0x20350
movq 0x12f5b(%rip), %rcx     # 0x20340
movq 0x12f5c(%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 0xd460
leaq -0x70(%rbp), %rdi
movq 0x12f49(%rip), %rdx     # 0x20358
movq 0x12f32(%rip), %rax     # 0x20348
movq 0x12f23(%rip), %rcx     # 0x20340
movslq -0x4(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdx
leaq 0xe498(%rip), %rsi      # 0x1b8cf
movb $0x0, %al
callq 0x21f0
leaq -0x70(%rbp), %rdi
movq 0x12ef7(%rip), %rax     # 0x20340
movq 0x12ef8(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %esi
callq 0x26c0
movq 0x12ee1(%rip), %rax     # 0x20348
movq 0x12ed2(%rip), %rcx     # 0x20340
movq 0x12ed3(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x78(%rbp)
movq 0x12eba(%rip), %rax     # 0x20348
movq 0x12eb3(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0xcf80
movl -0x78(%rbp), %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x74(%rbp)
movl 0x1326e(%rip), %edi     # 0x20728
movl -0x74(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl %eax, -0x74(%rbp)
movq 0x12e60(%rip), %rax     # 0x20340
movq 0x12e59(%rip), %rcx     # 0x20340
movq 0x12e5a(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl -0x74(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x74(%rbp)
movq 0x12e2f(%rip), %rax     # 0x20340
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x13422(%rip), %eax     # 0x20940
jne 0xd52b
movl 0x131f6(%rip), %eax     # 0x2071c
movl %eax, -0x7c(%rbp)
jmp 0xd534
movl 0x131fb(%rip), %eax     # 0x2072c
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %edi
movl -0x74(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: eval
cell eval(cell x, int r) {
	Tmp = x;
	if (r) begin_rec();
	protect(x);
	Tmp = NIL;
	x = expand(x, 1);  car(Protected) = x;
	syncheck(x, 1);
	x = clsconv(x);    car(Protected) = x;
	x = compile(x);    car(Protected) = x;
	x = interpret(x);
	unprot(1);
	if (r) end_rec();
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x12c0d(%rip)     # 0x20174
cmpl $0x0, -0x8(%rbp)
je 0xd572
callq 0x11a30
movl -0x4(%rbp), %edi
movl 0x12bf5(%rip), %esi     # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0x12be8(%rip)     # 0x20170
movl $0xffffffff, 0x12be2(%rip) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %edi
movl $0x1, %esi
callq 0xcb00
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edx
movq 0x12d94(%rip), %rax     # 0x20340
movslq 0x12bbd(%rip), %rcx     # 0x20170
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %edi
movl $0x1, %esi
callq 0x7a90
movl -0x4(%rbp), %edi
callq 0x9c70
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edx
movq 0x12d68(%rip), %rax     # 0x20340
movslq 0x12b91(%rip), %rcx     # 0x20170
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %edi
callq 0xc850
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edx
movq 0x12d49(%rip), %rax     # 0x20340
movslq 0x12b72(%rip), %rcx     # 0x20170
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %edi
callq 0x18f60
movl %eax, -0x4(%rbp)
movl $0x1, %edi
callq 0x3d00
cmpl $0x0, -0x8(%rbp)
je 0xd621
callq 0x11b20
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: add
cell add(cell x, cell y) {
	if (!fixp(x)) expect("+", "fixnum", x);
	if (!fixp(y)) expect("+", "fixnum", y);
	if (add_ovfl(fixval(x), fixval(y))) fixover("+", x, y);
	return mkfix(fixval(x) + fixval(y));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0xd6f0
movq 0x12c85(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xd6f0
movq 0x12c5e(%rip), %rcx     # 0x20340
movslq -0x4(%rbp), %rdx
movl $0xfffffff2, %eax       # imm = 0xFFFFFFF2
cmpl (%rcx,%rdx,4), %eax
je 0xd706
movl -0x4(%rbp), %edx
leaq 0xe223(%rip), %rdi      # 0x1b91d
leaq 0xe21e(%rip), %rsi      # 0x1b91f
callq 0x2950
cmpl $0x0, -0x8(%rbp)
jl 0xd738
movq 0x12c3d(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xd738
movq 0x12c16(%rip), %rcx     # 0x20340
movslq -0x8(%rbp), %rdx
movl $0xfffffff2, %eax       # imm = 0xFFFFFFF2
cmpl (%rcx,%rdx,4), %eax
je 0xd74e
movl -0x8(%rbp), %edx
leaq 0xe1db(%rip), %rdi      # 0x1b91d
leaq 0xe1d6(%rip), %rsi      # 0x1b91f
callq 0x2950
movq 0x12beb(%rip), %rax     # 0x20340
movq 0x12bec(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0xd7a5
movq 0x12bcf(%rip), %rax     # 0x20340
movq 0x12bd0(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movq 0x12bb6(%rip), %rdx     # 0x20340
movq 0x12bb7(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rsi
movslq (%rcx,%rsi,4), %rsi
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
subl (%rdx,%rsi,4), %ecx
cmpl %ecx, %eax
jg 0xd7fc
movq 0x12b94(%rip), %rax     # 0x20340
movq 0x12b95(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
cmpl $0x0, (%rax,%rcx,4)
jge 0xd80e
movq 0x12b78(%rip), %rax     # 0x20340
movq 0x12b79(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movq 0x12b5f(%rip), %rdx     # 0x20340
movq 0x12b60(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rsi
movslq (%rcx,%rsi,4), %rsi
movl $0x80000000, %ecx       # imm = 0x80000000
subl (%rdx,%rsi,4), %ecx
cmpl %ecx, %eax
jge 0xd80e
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
leaq 0xe114(%rip), %rdi      # 0x1b91d
callq 0xd630
movq 0x12b2b(%rip), %rax     # 0x20340
movq 0x12b2c(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movq 0x12b12(%rip), %rax     # 0x20340
movq 0x12b13(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
addl (%rax,%rcx,4), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl $0x1, %edx
callq 0x3990
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: xsub
cell xsub(cell x, cell y) {
	if (!fixp(x)) expect("-", "fixnum", x);
	if (!fixp(y)) expect("-", "fixnum", y);
	if (sub_ovfl(fixval(y), fixval(x))) fixover("+", y, x);
	return mkfix(fixval(y) - fixval(x));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0xd8b0
movq 0x12ac5(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xd8b0
movq 0x12a9e(%rip), %rcx     # 0x20340
movslq -0x4(%rbp), %rdx
movl $0xfffffff2, %eax       # imm = 0xFFFFFFF2
cmpl (%rcx,%rdx,4), %eax
je 0xd8c6
movl -0x4(%rbp), %edx
leaq 0xe06c(%rip), %rdi      # 0x1b926
leaq 0xe05e(%rip), %rsi      # 0x1b91f
callq 0x2950
cmpl $0x0, -0x8(%rbp)
jl 0xd8f8
movq 0x12a7d(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xd8f8
movq 0x12a56(%rip), %rcx     # 0x20340
movslq -0x8(%rbp), %rdx
movl $0xfffffff2, %eax       # imm = 0xFFFFFFF2
cmpl (%rcx,%rdx,4), %eax
je 0xd90e
movl -0x8(%rbp), %edx
leaq 0xe024(%rip), %rdi      # 0x1b926
leaq 0xe016(%rip), %rsi      # 0x1b91f
callq 0x2950
movq 0x12a2b(%rip), %rax     # 0x20340
movq 0x12a2c(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
cmpl $0x0, (%rax,%rcx,4)
jge 0xd966
movq 0x12a0f(%rip), %rax     # 0x20340
movq 0x12a10(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movq 0x129f6(%rip), %rcx     # 0x20340
movq 0x129f7(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movl (%rcx,%rdx,4), %ecx
addl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpl %ecx, %eax
jg 0xd9be
movq 0x129d3(%rip), %rax     # 0x20340
movq 0x129d4(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0xd9d0
movq 0x129b7(%rip), %rax     # 0x20340
movq 0x129b8(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movq 0x1299e(%rip), %rcx     # 0x20340
movq 0x1299f(%rip), %rdx     # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movl (%rcx,%rdx,4), %ecx
addl $0x80000000, %ecx       # imm = 0x80000000
cmpl %ecx, %eax
jge 0xd9d0
movl -0x8(%rbp), %esi
movl -0x4(%rbp), %edx
leaq 0xdf52(%rip), %rdi      # 0x1b91d
callq 0xd630
movq 0x12969(%rip), %rax     # 0x20340
movq 0x1296a(%rip), %rcx     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movq 0x12950(%rip), %rax     # 0x20340
movq 0x12951(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
subl (%rax,%rcx,4), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl $0x1, %edx
callq 0x3990
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: intdiv
cell intdiv(cell x, cell y) {
	if (!fixp(x)) expect("div", "fixnum", x);
	if (!fixp(y)) expect("div", "fixnum", y);
	if (0 == fixval(y)) error("div: divide by zero", UNDEF);
	return mkfix(fixval(x) / fixval(y));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0xdc20
movq 0x12755(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xdc20
movq 0x1272e(%rip), %rcx     # 0x20340
movslq -0x4(%rbp), %rdx
movl $0xfffffff2, %eax       # imm = 0xFFFFFFF2
cmpl (%rcx,%rdx,4), %eax
je 0xdc36
movl -0x4(%rbp), %edx
leaq 0xdcfe(%rip), %rdi      # 0x1b928
leaq 0xdcee(%rip), %rsi      # 0x1b91f
callq 0x2950
cmpl $0x0, -0x8(%rbp)
jl 0xdc68
movq 0x1270d(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xdc68
movq 0x126e6(%rip), %rcx     # 0x20340
movslq -0x8(%rbp), %rdx
movl $0xfffffff2, %eax       # imm = 0xFFFFFFF2
cmpl (%rcx,%rdx,4), %eax
je 0xdc7e
movl -0x8(%rbp), %edx
leaq 0xdcb6(%rip), %rdi      # 0x1b928
leaq 0xdca6(%rip), %rsi      # 0x1b91f
callq 0x2950
movq 0x126bb(%rip), %rcx     # 0x20340
movq 0x126bc(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rax,%rdx,4), %rdx
xorl %eax, %eax
cmpl (%rcx,%rdx,4), %eax
jne 0xdcac
leaq 0xdc8a(%rip), %rdi      # 0x1b92c
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x26c0
movq 0x1268d(%rip), %rax     # 0x20340
movq 0x1268e(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movq 0x12674(%rip), %rcx     # 0x20340
movq 0x12675(%rip), %rdx     # 0x20348
movslq -0x8(%rbp), %rsi
movslq (%rdx,%rsi,4), %rsi
cltd
idivl (%rcx,%rsi,4)
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
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: intrem
cell intrem(cell x, cell y) {
	if (!fixp(x)) expect("rem", "fixnum", x);
	if (!fixp(y)) expect("rem", "fixnum", y);
	if (0 == fixval(y)) error("rem: divide by zero", UNDEF);
	return mkfix(fixval(x) % fixval(y));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0xdd50
movq 0x12625(%rip), %rax     # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xdd50
movq 0x125fe(%rip), %rcx     # 0x20340
movslq -0x4(%rbp), %rdx
movl $0xfffffff2, %eax       # imm = 0xFFFFFFF2
cmpl (%rcx,%rdx,4), %eax
je 0xdd66
movl -0x4(%rbp), %edx
leaq 0xdbe6(%rip), %rdi      # 0x1b940
leaq 0xdbbe(%rip), %rsi      # 0x1b91f
callq 0x2950
cmpl $0x0, -0x8(%rbp)
jl 0xdd98
movq 0x125dd(%rip), %rax     # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xdd98
movq 0x125b6(%rip), %rcx     # 0x20340
movslq -0x8(%rbp), %rdx
movl $0xfffffff2, %eax       # imm = 0xFFFFFFF2
cmpl (%rcx,%rdx,4), %eax
je 0xddae
movl -0x8(%rbp), %edx
leaq 0xdb9e(%rip), %rdi      # 0x1b940
leaq 0xdb76(%rip), %rsi      # 0x1b91f
callq 0x2950
movq 0x1258b(%rip), %rcx     # 0x20340
movq 0x1258c(%rip), %rax     # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rax,%rdx,4), %rdx
xorl %eax, %eax
cmpl (%rcx,%rdx,4), %eax
jne 0xdddc
leaq 0xdb72(%rip), %rdi      # 0x1b944
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x26c0
movq 0x1255d(%rip), %rax     # 0x20340
movq 0x1255e(%rip), %rcx     # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movq 0x12544(%rip), %rcx     # 0x20340
movq 0x12545(%rip), %rdx     # 0x20348
movslq -0x8(%rbp), %rsi
movslq (%rdx,%rsi,4), %rsi
cltd
idivl (%rcx,%rsi,4)
movl %edx, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl $0x1, %edx
callq 0x3990
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)