LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: obslot
int obslot(void) {
	int	i, j, k, m;
	byte	*s;
	cell	n;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpl $0x2, %r15d
je 0x68e3
xorl %ebx, %ebx
cmpl $0x2, %ebx
je 0x6807
movq 0x10bc1(%rip), %rax     # 0x17358
movq 0x10baa(%rip), %rcx     # 0x17348
movslq 0x109bf(%rip), %rdx     # 0x17164
movslq (%rcx,%rdx,4), %rdx
movslq -0x4(%rax,%rdx,4), %r12
addq $0x3, %r12
shrq $0x2, %r12
movslq 0x1099b(%rip), %rdx     # 0x17158
movslq (%rcx,%rdx,4), %rcx
leaq (%rax,%rcx,4), %rax
movl 0x10f81(%rip), %ecx     # 0x1774c
testl %r12d, %r12d
movl $0x0, %edx
cmovgl %r12d, %edx
subl $0x1, %edx
jb 0x67fa
movslq %ecx, %rsi
cmpb $0x0, (%rax,%rsi)
je 0x68ca
incl %ecx
cmpl %r12d, %ecx
cmovgel %r14d, %ecx
movl %ecx, 0x10f54(%rip)     # 0x1774c
jmp 0x67d7
testl %ebx, %ebx
jne 0x6803
callq 0x2d8b
incl %ebx
jmp 0x678b
cmpl $0xfbff, %r12d          # imm = 0xFBFF
jg 0x68e3
leal 0x400(%r12), %ebp
movl %ebp, %edi
callq 0x31ed
movq 0x10b2e(%rip), %rcx     # 0x17358
movq 0x10b17(%rip), %rdx     # 0x17348
movslq %eax, %r13
movslq (%rdx,%r13,4), %rax
leaq (%rcx,%rax,4), %rdi
movslq 0x10921(%rip), %rax     # 0x17164
movslq (%rdx,%rax,4), %rax
leaq (%rcx,%rax,4), %rsi
movslq %r12d, %rbx
leaq (,%rbx,4), %rdx
callq 0x2140
movl %r13d, 0x10902(%rip)    # 0x17164
xorl %edi, %edi
movl %ebp, %esi
callq 0x2698
movq 0x10ad6(%rip), %rcx     # 0x17348
movslq %eax, %r13
movslq (%rcx,%r13,4), %rdi
shlq $0x2, %rdi
addq 0x10ad4(%rip), %rdi     # 0x17358
movslq %ebp, %rdx
xorl %esi, %esi
callq 0x20b0
movq 0x10ac3(%rip), %rax     # 0x17358
movq 0x10aac(%rip), %rcx     # 0x17348
movslq (%rcx,%r13,4), %rdx
leaq (%rax,%rdx,4), %rdi
movslq 0x108ad(%rip), %rdx     # 0x17158
movslq (%rcx,%rdx,4), %rcx
leaq (%rax,%rcx,4), %rsi
movq %rbx, %rdx
callq 0x2140
movl %r13d, 0x10896(%rip)    # 0x17158
incl %r15d
jmp 0x677f
movb $0x1, (%rax,%rsi)
movl 0x10e78(%rip), %eax     # 0x1774c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9e68(%rip), %rdi      # 0x10752
pushq $-0x4
popq %rsi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: obindex
int obindex(cell x) {
	cell	n;
	int	i;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %edi, %edi
js 0x6943
movq 0x10a4a(%rip), %rcx     # 0x17350
movl %ebx, %eax
movb (%rcx,%rax), %cl
testb $0x9, %cl
je 0x6934
testb $0x8, %cl
je 0x6922
movq 0x10a24(%rip), %rdx     # 0x17340
cmpl $-0x13, (%rdx,%rax,4)
je 0x6934
testb $0x1, %cl
je 0x6943
movq 0x10a12(%rip), %rcx     # 0x17340
cmpl $-0xd, (%rcx,%rax,4)
jne 0x6943
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x676e
movl 0x10852(%rip), %r14d    # 0x1719c
movl %r14d, %edi
movl %ebx, %esi
callq 0x362b
cmpl $-0x4, %eax
je 0x69ba
movq 0x109e0(%rip), %rdx     # 0x17340
movq 0x109e1(%rip), %rcx     # 0x17348
cltq
movslq (%rcx,%rax,4), %rax
movslq (%rcx,%rax,4), %rax
movl (%rdx,%rax,4), %ebp
movq 0x109dd(%rip), %rax     # 0x17358
movslq 0x107d6(%rip), %rdx     # 0x17158
movslq (%rcx,%rdx,4), %rdx
leaq (%rax,%rdx,4), %rsi
movslq %ebp, %rdx
cmpb $0x0, (%rdx,%rsi)
je 0x69b0
movslq 0x107ca(%rip), %rsi     # 0x17164
movslq (%rcx,%rsi,4), %rcx
leaq (%rax,%rcx,4), %rax
movl (%rax,%rdx,4), %esi
movl %ebx, %edi
callq 0x33ad
testl %eax, %eax
jne 0x69f2
movl %r14d, %edi
movl %ebx, %esi
callq 0x37db
callq 0x676e
movl %eax, %ebp
movl 0x107d4(%rip), %r14d    # 0x1719c
pushq $-0x1
popq %rsi
pushq $0x1
popq %r15
movl %eax, %edi
movl %r15d, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %r15d, %edx
callq 0x2f8c
movl %r14d, %edi
movl %ebx, %esi
movl %eax, %edx
callq 0x36ae
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
movl 0x10d44(%rip), %ecx     # 0x17750
movq 0x10945(%rip), %rax     # 0x17358
movq 0x1092e(%rip), %rdx     # 0x17348
movslq 0x1077f(%rip), %rsi     # 0x171a0
movslq (%rdx,%rsi,4), %rsi
movslq (%rdx,%rsi,4), %rdx
cmpl -0x4(%rax,%rdx,4), %ecx
jl 0x6b01
movl 0x10737(%rip), %esi     # 0x17170
xorl %r14d, %r14d
movl %ebx, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x10725(%rip)     # 0x17170
movq 0x10906(%rip), %rax     # 0x17358
movq 0x108ef(%rip), %rcx     # 0x17348
movslq 0x10740(%rip), %rdx     # 0x171a0
movslq (%rcx,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl -0x4(%rax,%rcx,4), %r15d
leal 0x400(%r15), %esi
xorl %edi, %edi
callq 0x2698
movq 0x108d6(%rip), %rdx     # 0x17358
movq 0x108bf(%rip), %rsi     # 0x17348
movslq 0x10710(%rip), %rcx     # 0x171a0
movslq (%rsi,%rcx,4), %rcx
movslq (%rsi,%rcx,4), %rcx
leaq (%rdx,%rcx,4), %rcx
movslq %eax, %rdi
movslq (%rsi,%rdi,4), %rsi
leaq (%rdx,%rsi,4), %rdx
testl %r15d, %r15d
movl $0x0, %esi
cmovgl %r15d, %esi
cmpq %r14, %rsi
je 0x6ac5
movb (%rcx,%r14), %dil
movb %dil, (%rdx,%r14)
incq %r14
jmp 0x6ab3
movq 0x1087c(%rip), %rcx     # 0x17348
movslq 0x106cd(%rip), %rdx     # 0x171a0
movl %eax, (%rcx,%rdx,4)
pushq $0x1
popq %rdi
callq 0x31a9
movq 0x10873(%rip), %rax     # 0x17358
movq 0x1085c(%rip), %rcx     # 0x17348
movslq 0x106ad(%rip), %rdx     # 0x171a0
movslq (%rcx,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rdx
movl 0x10c4f(%rip), %ecx     # 0x17750
leaq (%rax,%rdx,4), %rax
movslq %ecx, %rcx
movb %bl, (%rcx,%rax)
incl 0x10c3f(%rip)           # 0x17750
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %edi, %ebx
cmpl $0x10000, %edi          # imm = 0x10000
jae 0x6b3c
movl %ebx, %edi
shrl $0x8, %edi
callq 0x69ff
movzbl %bl, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x69ff
pushq $-0x1
popq %rsi
pushq $0x1
popq %rbp
movl %ebx, %edi
movl %ebp, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %ebp, %edx
callq 0x2f8c
leaq 0x9c08(%rip), %rdi      # 0x10766
movl %eax, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: emitq
void emitq(cell x) {
	int	i;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
callq 0x68f2
movq 0x107d1(%rip), %rcx     # 0x17348
movslq 0x105e6(%rip), %rdx     # 0x17164
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0x107cb(%rip), %rcx     # 0x17358
movslq %eax, %r14
movl %ebx, (%rcx,%r14,4)
pushq $0x5
popq %rdi
callq 0x69ff
movl %r14d, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6b17
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: patch
void patch(int a, int n) {
	if (n < 0 || n > 65535)
		error("bytecode argument out of range", mkfix(n));
	string(cdr(Emitbuf))[a] = n >> 8;
	string(cdr(Emitbuf))[a+1] = n & 255;
}

// Assembly:
movl %esi, %eax
cmpl $0x10000, %esi          # imm = 0x10000
jae 0x6c02
movq 0x1078c(%rip), %rcx     # 0x17348
movslq 0x105dd(%rip), %rdx     # 0x171a0
movslq (%rcx,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0x10782(%rip), %rcx     # 0x17358
movslq %edi, %rdx
movb %ah, (%rdx,%rcx)
movq 0x10765(%rip), %rcx     # 0x17348
movslq 0x105b6(%rip), %rsi     # 0x171a0
movslq (%rcx,%rsi,4), %rsi
movslq (%rcx,%rsi,4), %rcx
shlq $0x2, %rcx
addq 0x1075b(%rip), %rcx     # 0x17358
movb %al, 0x1(%rdx,%rcx)
retq
pushq %rbx
pushq $-0x1
popq %rsi
pushq $0x1
popq %rbx
movl %eax, %edi
movl %ebx, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %ebx, %edx
callq 0x2f8c
leaq 0x9b41(%rip), %rdi      # 0x10766
movl %eax, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/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:
movslq 0x10571(%rip), %rax     # 0x171a4
cmpq $-0x1, %rax
je 0x6c5c
movq 0x10700(%rip), %rcx     # 0x17340
movslq (%rcx,%rax,4), %rdx
movq 0x106fd(%rip), %rsi     # 0x17348
movl (%rsi,%rax,4), %eax
movl %eax, 0x10550(%rip)     # 0x171a4
movslq (%rsi,%rdx,4), %rax
movl (%rcx,%rax,4), %eax
retq
pushq %rax
leaq 0x9b21(%rip), %rdi      # 0x10785
pushq $-0x4
popq %rsi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: swap
void swap(void) {
	cell	x;

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

// Assembly:
movslq 0x10531(%rip), %rax     # 0x171a4
cmpq $-0x1, %rax
je 0x6ca9
movq 0x106c8(%rip), %rcx     # 0x17348
movslq (%rcx,%rax,4), %rdx
cmpq $-0x1, %rdx
je 0x6ca9
movq 0x106af(%rip), %rsi     # 0x17340
movl (%rsi,%rax,4), %edi
movl (%rsi,%rdx,4), %edx
movl %edx, (%rsi,%rax,4)
movslq 0x10503(%rip), %rax     # 0x171a4
movslq (%rcx,%rax,4), %rax
movl %edi, (%rsi,%rax,4)
retq
pushq %rax
leaq 0x9ad4(%rip), %rdi      # 0x10785
pushq $-0x4
popq %rsi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl %edi, 0x10a95(%rip)     # 0x17754
jne 0x6cc5
pushq $0x31
jmp 0x6d17
cmpl %edi, 0x10a8d(%rip)     # 0x17758
jne 0x6cd1
pushq $0x3f
jmp 0x6d17
cmpl %edi, 0x10a85(%rip)     # 0x1775c
jne 0x6cdd
pushq $0x46
jmp 0x6d17
cmpl %edi, 0x10a7d(%rip)     # 0x17760
jne 0x6ce9
pushq $0x47
jmp 0x6d17
cmpl %edi, 0x10a75(%rip)     # 0x17764
jne 0x6cf5
pushq $0x4a
jmp 0x6d17
cmpl %edi, 0x10a6d(%rip)     # 0x17768
jne 0x6d01
pushq $0x5f
jmp 0x6d17
cmpl %edi, 0x10a65(%rip)     # 0x1776c
jne 0x6d0d
pushq $0x62
jmp 0x6d17
cmpl %edi, 0x10a5d(%rip)     # 0x17770
jne 0x6d19
pushq $0x69
popq %rax
retq
xorl %eax, %eax
cmpl %edi, 0x10a53(%rip)     # 0x17774
setne %al
negl %eax
orl $0x8a, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: subr2
int subr2(cell x) {
	if (x == P_cons)	return OP_CONS;
	if (x == P_div)		return OP_DIV;
	if (x == P_eq)		return OP_EQ;
	if (x == P_nreconc)	return OP_NRECONC;
	if (x == P_reconc)	return OP_RECONC;
	if (x == P_rem)		return OP_REM;
	if (x == P_rename)	return OP_RENAME;
	if (x == P_sless)	return OP_SLESS;
	if (x == P_slteq)	return OP_SLTEQ;
	if (x == P_sequal)	return OP_SEQUAL;
	if (x == P_sgrtr)	return OP_SGRTR;
	if (x == P_sgteq)	return OP_SGTEQ;
	if (x == P_setcar)	return OP_SETCAR;
	if (x == P_setcdr)	return OP_SETCDR;
	if (x == P_sfill)	return OP_SFILL;
	if (x == P_siless)	return OP_SILESS;
	if (x == P_silteq)	return OP_SILTEQ;
	if (x == P_siequal)	return OP_SIEQUAL;
	if (x == P_sigrtr)	return OP_SIGRTR;
	if (x == P_sigteq)	return OP_SIGTEQ;
	if (x == P_sref)	return OP_SREF;
	if (x == P_throwstar)	return OP_THROWSTAR;
	if (x == P_vfill)	return OP_VFILL;
	if (x == P_vref)	return OP_VREF;
	return -1;
}

// Assembly:
cmpl %edi, 0x10809(%rip)     # 0x17850
jne 0x7050
pushq $0x33
jmp 0x7168
cmpl %edi, 0x107fe(%rip)     # 0x17854
jne 0x705f
pushq $0x37
jmp 0x7168
cmpl %edi, 0x107f3(%rip)     # 0x17858
jne 0x706e
pushq $0x3b
jmp 0x7168
cmpl %edi, 0x107e8(%rip)     # 0x1785c
jne 0x707d
pushq $0x5b
jmp 0x7168
cmpl %edi, 0x107dd(%rip)     # 0x17860
jne 0x708c
pushq $0x6c
jmp 0x7168
cmpl %edi, 0x107d2(%rip)     # 0x17864
jne 0x709b
pushq $0x6d
jmp 0x7168
cmpl %edi, 0x107c7(%rip)     # 0x17868
jne 0x70aa
pushq $0x6e
jmp 0x7168
cmpl %edi, 0x107bc(%rip)     # 0x1786c
jne 0x70b9
pushq $0x7d
jmp 0x7168
cmpl %edi, 0x107b1(%rip)     # 0x17870
jne 0x70c8
pushq $0x7e
jmp 0x7168
cmpl %edi, 0x107a6(%rip)     # 0x17874
jne 0x70d7
pushq $0x70
jmp 0x7168
cmpl %edi, 0x1079b(%rip)     # 0x17878
jne 0x70e6
pushq $0x76
jmp 0x7168
cmpl %edi, 0x10790(%rip)     # 0x1787c
jne 0x70f2
pushq $0x77
jmp 0x7168
cmpl %edi, 0x10788(%rip)     # 0x17880
jne 0x70fe
pushq $0x71
jmp 0x7168
cmpl %edi, 0x10780(%rip)     # 0x17884
jne 0x710a
pushq $0x72
jmp 0x7168
cmpl %edi, 0x10778(%rip)     # 0x17888
jne 0x7116
pushq $0x75
jmp 0x7168
cmpl %edi, 0x10770(%rip)     # 0x1788c
jne 0x7122
pushq $0x7b
jmp 0x7168
cmpl %edi, 0x10768(%rip)     # 0x17890
jne 0x712e
pushq $0x7c
jmp 0x7168
cmpl %edi, 0x10760(%rip)     # 0x17894
jne 0x713a
pushq $0x78
jmp 0x7168
cmpl %edi, 0x10758(%rip)     # 0x17898
jne 0x7146
pushq $0x79
jmp 0x7168
cmpl %edi, 0x10750(%rip)     # 0x1789c
jne 0x7152
pushq $0x7a
jmp 0x7168
cmpl %edi, 0x10748(%rip)     # 0x178a0
jne 0x715e
pushq $0x7f
jmp 0x7168
cmpl %edi, 0x10740(%rip)     # 0x178a4
jne 0x716a
pushq $0x12
popq %rax
retq
movl $0x93, %eax
cmpl %edi, 0x10733(%rip)     # 0x178a8
je 0x7189
xorl %eax, %eax
cmpl %edi, 0x1072d(%rip)     # 0x178ac
setne %al
negl %eax
orl $0x94, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: subr3
int subr3(cell x) {
	if (x == P_sset)	return OP_SSET;
	if (x == P_substr)	return OP_SUBSTR;
	if (x == P_subvec)	return OP_SUBVEC;
	if (x == P_vset)	return OP_VSET;
	return -1;
}

// Assembly:
movl $0x80, %eax
cmpl %edi, 0x1071b(%rip)     # 0x178b0
je 0x71c3
movl $0x85, %eax
cmpl %edi, 0x10712(%rip)     # 0x178b4
je 0x71c3
movl $0x86, %eax
cmpl %edi, 0x10709(%rip)     # 0x178b8
je 0x71c3
xorl %eax, %eax
cmpl %edi, 0x10703(%rip)     # 0x178bc
setne %al
negl %eax
orl $0x95, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl %edi, 0x106d9(%rip)     # 0x178cc
jne 0x71f9
pushq $0x3d
jmp 0x723f
cmpl %edi, 0x106d1(%rip)     # 0x178d0
jne 0x7205
pushq $0x55
jmp 0x723f
cmpl %edi, 0x106c9(%rip)     # 0x178d4
jne 0x7211
pushq $0x56
jmp 0x723f
cmpl %edi, 0x106c1(%rip)     # 0x178d8
jne 0x721d
pushq $0x5e
jmp 0x723f
cmpl %edi, 0x106b9(%rip)     # 0x178dc
jne 0x7229
pushq $0x61
jmp 0x723f
cmpl %edi, 0x106b1(%rip)     # 0x178e0
jne 0x7235
pushq $0x67
jmp 0x723f
cmpl %edi, 0x106a9(%rip)     # 0x178e4
jne 0x7241
pushq $0x68
popq %rax
retq
movl $0x84, %eax
cmpl %edi, 0x1069c(%rip)     # 0x178e8
je 0x7260
xorl %eax, %eax
cmpl %edi, 0x10696(%rip)     # 0x178ec
setne %al
negl %eax
orl $0x98, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: lsubr0
int lsubr0(cell x) {
	if (x == P_times)	return OP_TIMES;
	if (x == P_plus)	return OP_PLUS;
	if (x == P_conc)	return OP_CONC;
	if (x == P_nconc)	return OP_NCONC;
	if (x == P_sconc)	return OP_SCONC;
	if (x == P_vconc)	return OP_VCONC;
	return -1;
}

// Assembly:
movl $0x8c, %eax
cmpl %edi, 0x10684(%rip)     # 0x178f0
jne 0x726f
retq
cmpl %edi, 0x1067f(%rip)     # 0x178f4
jne 0x727b
pushq $0x66
jmp 0x729d
cmpl %edi, 0x10677(%rip)     # 0x178f8
jne 0x7287
pushq $0x32
jmp 0x729d
cmpl %edi, 0x1066f(%rip)     # 0x178fc
jne 0x7293
pushq $0x59
jmp 0x729d
cmpl %edi, 0x10667(%rip)     # 0x17900
jne 0x729f
pushq $0x6f
popq %rax
retq
xorl %eax, %eax
cmpl %edi, 0x1065d(%rip)     # 0x17904
setne %al
negl %eax
orl $0x90, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl %edi, 0x10650(%rip)     # 0x17908
jne 0x72c1
pushq $0x21
jmp 0x7352
cmpl %edi, 0x10645(%rip)     # 0x1790c
jne 0x72d0
pushq $0x52
jmp 0x7352
cmpl %edi, 0x1063a(%rip)     # 0x17910
jne 0x72dc
pushq $0x53
jmp 0x7352
cmpl %edi, 0x10632(%rip)     # 0x17914
jne 0x72e8
pushq $0x54
jmp 0x7352
cmpl %edi, 0x1062a(%rip)     # 0x17918
jne 0x72f4
pushq $0x4c
jmp 0x7352
cmpl %edi, 0x10622(%rip)     # 0x1791c
jne 0x7300
pushq $0x51
jmp 0x7352
cmpl %edi, 0x1061a(%rip)     # 0x17920
jne 0x730c
pushq $0x3c
jmp 0x7352
cmpl %edi, 0x10612(%rip)     # 0x17924
jne 0x7318
pushq $0x48
jmp 0x7352
cmpl %edi, 0x1060a(%rip)     # 0x17928
jne 0x7324
pushq $0x49
jmp 0x7352
cmpl %edi, 0x10602(%rip)     # 0x1792c
jne 0x7330
pushq $0x2e
jmp 0x7352
cmpl %edi, 0x105fa(%rip)     # 0x17930
jne 0x733c
pushq $0x30
jmp 0x7352
cmpl %edi, 0x105f2(%rip)     # 0x17934
jne 0x7348
pushq $0x28
jmp 0x7352
cmpl %edi, 0x105ea(%rip)     # 0x17938
jne 0x7354
pushq $0x29
popq %rax
retq
xorl %eax, %eax
cmpl %edi, 0x105e0(%rip)     # 0x1793c
setne %al
negl %eax
orl $0x2a, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0xffdc(%rip), %rax      # 0x17348
movslq %edi, %rcx
movl (%rax,%rcx,4), %ecx
cmpl $-0x1, %ecx
je 0x73b4
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movslq %ecx, %r14
cmpl $-0x1, (%rax,%r14,4)
movq 0xffb4(%rip), %rax      # 0x17340
movl (%rax,%r14,4), %edi
je 0x73a6
xorl %esi, %esi
callq 0x73bc
movq 0xffa8(%rip), %rax      # 0x17348
movl (%rax,%r14,4), %ecx
jmp 0x737d
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x73bc
pushq $-0x1
popq %rdi
jmp 0x6b65
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0xfc76(%rip), %rax      # 0x17340
movq 0xfc77(%rip), %rcx      # 0x17348
movslq %edi, %r14
movslq (%rcx,%r14,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x73bc
movq 0xfc53(%rip), %rax      # 0x17340
movq 0xfc54(%rip), %rcx      # 0x17348
movslq (%rcx,%r14,4), %rcx
movslq (%rax,%rcx,4), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x10043(%rip), %eax     # 0x17748
jne 0x770b
pushq $0x1c
jmp 0x7715
cmpl 0x10033(%rip), %eax     # 0x17744
jne 0x774c
pushq $0x1b
popq %rdi
callq 0x69ff
movq 0xfc1e(%rip), %rax      # 0x17340
movq 0xfc1f(%rip), %rcx      # 0x17348
movslq (%rcx,%r14,4), %rdx
movslq (%rax,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rdx
movslq (%rax,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6b17
leaq 0x9050(%rip), %rdi      # 0x107a3
movl %ebx, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %ebx
movq 0xfbd7(%rip), %rax      # 0x17340
movq 0xfbd8(%rip), %rcx      # 0x17348
movslq %edi, %r14
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x73bc
cmpl $0x1, %ebp
pushq $0xf
popq %rdi
sbbl $0x0, %edi
callq 0x69ff
movl 0xffbb(%rip), %edi      # 0x17750
pushq $-0x1
popq %rsi
pushq $0x1
popq %rbp
movl %ebp, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %ebp, %edx
callq 0x2f8c
movl 0xf9f0(%rip), %esi      # 0x171a4
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xf9e1(%rip)      # 0x171a4
xorl %edi, %edi
callq 0x6b17
movq 0xfb6f(%rip), %rax      # 0x17340
movq 0xfb70(%rip), %rcx      # 0x17348
movslq (%rcx,%r14,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl %ebx, %esi
callq 0x73bc
movq 0xfb57(%rip), %rax      # 0x17348
movslq (%rax,%r14,4), %rcx
movslq (%rax,%rcx,4), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x787d
pushq $0xd
popq %rdi
callq 0x69ff
movl 0xff43(%rip), %edi      # 0x17750
pushq $-0x1
popq %rsi
pushq $0x1
popq %rbp
movl %ebp, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %ebp, %edx
callq 0x2f8c
movl 0xf978(%rip), %esi      # 0x171a4
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xf969(%rip)      # 0x171a4
xorl %edi, %edi
callq 0x6b17
callq 0x6c6c
callq 0x6c2c
movl 0xfefe(%rip), %esi      # 0x17750
movl %eax, %edi
callq 0x6bab
movq 0xfae0(%rip), %rax      # 0x17340
movq 0xfae1(%rip), %rcx      # 0x17348
movslq (%rcx,%r14,4), %rdx
movslq (%rcx,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl %ebx, %esi
callq 0x73bc
callq 0x6c2c
movl 0xfec8(%rip), %esi      # 0x17750
movl %eax, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x6bab
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edi, %esi
pushq $0x16
popq %rbx
pushq $0x17
popq %rbp
cmpl $-0x1, %esi
je 0x7932
movq 0xfa91(%rip), %rax      # 0x17340
movslq %esi, %r14
movslq (%rax,%r14,4), %rcx
movl (%rax,%rcx,4), %eax
movl %ebx, %edi
cmpl 0xfe7b(%rip), %eax      # 0x1773c
je 0x78cd
movl %ebp, %edi
cmpl 0xfe6d(%rip), %eax      # 0x17738
jne 0x7937
callq 0x69ff
movq 0xfa67(%rip), %rax      # 0x17340
movq 0xfa68(%rip), %rcx      # 0x17348
movslq (%rax,%r14,4), %rdx
movslq (%rcx,%rdx,4), %rdx
movslq (%rax,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x6b17
movq 0xfa41(%rip), %rax      # 0x17340
movq 0xfa42(%rip), %rcx      # 0x17348
movslq (%rax,%r14,4), %rdx
movslq (%rcx,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rdx
movslq (%rax,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x6b17
movq 0xfa1f(%rip), %rax      # 0x17348
movl (%rax,%r14,4), %esi
jmp 0x789f
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x8e84(%rip), %rdi      # 0x107c2
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
pushq $0xd
popq %rdi
callq 0x69ff
movl 0xfdce(%rip), %edi      # 0x17750
pushq $-0x1
popq %rsi
pushq $0x1
popq %rbx
movl %ebx, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %ebx, %edx
callq 0x2f8c
movl 0xf803(%rip), %esi      # 0x171a4
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xf7f4(%rip)      # 0x171a4
xorl %edi, %edi
callq 0x6b17
movl 0xfd93(%rip), %ebx      # 0x17750
movq 0xf97c(%rip), %rax      # 0x17340
movq 0xf97d(%rip), %rcx      # 0x17348
movslq %ebp, %r15
movslq (%rcx,%r15,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x5503
movl %eax, %edi
callq 0x5190
movl %eax, %ebp
movq 0xf956(%rip), %rax      # 0x17340
movq 0xf957(%rip), %rcx      # 0x17348
movslq (%rcx,%r15,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x7943
testl %eax, %eax
je 0x7a0d
pushq $0x19
popq %rdi
callq 0x69ff
decl %ebp
jmp 0x7a15
pushq $0x18
popq %rdi
callq 0x69ff
movl %ebp, %edi
callq 0x6b17
movl 0xfd0e(%rip), %edi      # 0x17730
movq 0xf91f(%rip), %rax      # 0x17348
movslq (%rax,%r15,4), %rcx
movslq (%rax,%rcx,4), %rcx
movl (%rax,%rcx,4), %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebp
movl 0xf72d(%rip), %esi      # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xf71e(%rip)      # 0x17170
pushq $0x1
popq %r14
movl %ebp, %edi
movl %r14d, %esi
callq 0x73bc
movl %r14d, %edi
callq 0x31a9
pushq $0x1a
popq %rdi
callq 0x69ff
callq 0x6c2c
movl 0xfcd5(%rip), %esi      # 0x17750
movl %eax, %edi
callq 0x6bab
movq 0xf8b7(%rip), %rax      # 0x17340
movq 0xf8b8(%rip), %rcx      # 0x17348
movslq (%rcx,%r15,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %ebp
cmpl $-0x1, %ebp
je 0x7abf
pushq $0x14
popq %rdi
callq 0x69ff
movl %ebp, %edi
callq 0x5190
movl %eax, %edi
callq 0x6b17
movl %ebp, %edi
callq 0x7893
jmp 0x7ac7
pushq $0x15
popq %rdi
callq 0x69ff
pushq $0x13
popq %rdi
callq 0x69ff
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6b17
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq 0xf857(%rip), %rax      # 0x17348
movslq %edi, %r15
movslq (%rax,%r15,4), %rcx
movl (%rax,%rcx,4), %edi
pushq $-0x1
popq %rsi
callq 0x3a25
movl %eax, %ebp
movl 0xf665(%rip), %esi      # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xf656(%rip)      # 0x17170
movq 0xf81f(%rip), %rax      # 0x17340
movslq %ebp, %r12
movl (%rax,%r12,4), %edi
xorl %esi, %esi
callq 0x73bc
pushq $0x8
popq %rbp
pushq $0x33
popq %r14
movq 0xf80b(%rip), %rax      # 0x17348
movslq (%rax,%r12,4), %r12
movl %ebp, %edi
callq 0x69ff
cmpq $-0x1, %r12
je 0x7b6a
movq 0xf7eb(%rip), %rax      # 0x17340
movl (%rax,%r12,4), %edi
xorl %esi, %esi
callq 0x73bc
movl %r14d, %edi
callq 0x69ff
jmp 0x7b36
pushq $0x1
popq %rdi
callq 0x31a9
movq 0xf7c7(%rip), %rax      # 0x17340
movq 0xf7c8(%rip), %rcx      # 0x17348
movslq (%rcx,%r15,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x73bc
cmpl $0x1, %ebx
pushq $0x2
popq %rdi
sbbl $0x0, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x69ff
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0xf794(%rip), %rax      # 0x17348
movslq %edi, %r15
movl (%rax,%r15,4), %edi
pushq $-0x1
popq %rsi
callq 0x3a25
movl %eax, %r14d
movl 0xf5a4(%rip), %esi      # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xf595(%rip)      # 0x17170
pushq $0x8
popq %rbp
cmpl $-0x1, %r14d
je 0x7c0d
movq 0xf755(%rip), %rax      # 0x17340
movslq %r14d, %r14
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x73bc
movl %ebp, %edi
callq 0x69ff
movq 0xf741(%rip), %rax      # 0x17348
movl (%rax,%r14,4), %r14d
jmp 0x7bde
pushq $0x1
popq %rdi
callq 0x31a9
pushq $0xa
popq %rdi
callq 0x69ff
movq 0xf724(%rip), %rax      # 0x17348
movl (%rax,%r15,4), %edi
callq 0x5190
movl %eax, %edi
callq 0x6b17
movq 0xf705(%rip), %rax      # 0x17340
movl (%rax,%r15,4), %edi
xorl %esi, %esi
callq 0x73bc
cmpl $0x1, %ebx
pushq $0x4
popq %rdi
sbbl $0x0, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x69ff
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
pushq $0x1
popq %rdx
movl %edx, %esi
callq 0x51a9
movq 0xf6b6(%rip), %rax      # 0x17340
movq 0xf6b7(%rip), %rcx      # 0x17348
movslq %ebp, %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x73bc
movl %ebx, %edi
callq 0x69ff
cmpl $0x11, %ebx
jne 0x7cbc
pushq $0x3
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x69ff
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
pushq $0x2
popq %rdx
movl %edx, %esi
callq 0x51a9
movq 0xf664(%rip), %rax      # 0x17340
movq 0xf665(%rip), %rcx      # 0x17348
movslq %ebp, %r14
movslq (%rcx,%r14,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x73bc
pushq $0x8
popq %rdi
callq 0x69ff
movq 0xf639(%rip), %rax      # 0x17340
movq 0xf63a(%rip), %rcx      # 0x17348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x73bc
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x69ff
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
pushq $0x3
popq %rdx
movl %edx, %esi
callq 0x51a9
movq 0xf600(%rip), %rax      # 0x17340
movq 0xf601(%rip), %rcx      # 0x17348
movslq %ebp, %r14
movslq (%rcx,%r14,4), %rdx
movslq (%rcx,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x73bc
pushq $0x8
popq %rbp
movl %ebp, %edi
callq 0x69ff
movq 0xf5cf(%rip), %rax      # 0x17340
movq 0xf5d0(%rip), %rcx      # 0x17348
movslq (%rcx,%r14,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x73bc
movl %ebp, %edi
callq 0x69ff
movq 0xf5a8(%rip), %rax      # 0x17340
movq 0xf5a9(%rip), %rcx      # 0x17348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x73bc
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x69ff
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
pushq $0x1
popq %rdx
xorl %esi, %esi
callq 0x51a9
movq 0xf578(%rip), %rax      # 0x17348
movslq %ebp, %rcx
movslq (%rax,%rcx,4), %rax
cmpq $-0x1, %rax
je 0x7df0
movq 0xf55c(%rip), %rcx      # 0x17340
movl (%rcx,%rax,4), %edi
xorl %esi, %esi
callq 0x73bc
jmp 0x7df8
pushq $0x4a
popq %rdi
callq 0x69ff
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x69ff
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
callq 0x51a9
movq 0xf529(%rip), %rax      # 0x17348
movslq %ebp, %r14
movslq (%rax,%r14,4), %rcx
movslq (%rax,%rcx,4), %rax
cmpq $-0x1, %rax
je 0x7e7b
cmpl $0x3d, %ebx
pushq $0x3e
popq %rbp
cmovnel %ebx, %ebp
movq 0xf500(%rip), %rcx      # 0x17340
movl (%rcx,%rax,4), %edi
xorl %esi, %esi
callq 0x73bc
movl %ebp, %ebx
pushq $0x8
popq %rdi
callq 0x69ff
movq 0xf4e5(%rip), %rax      # 0x17340
movq 0xf4e6(%rip), %rcx      # 0x17348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x73bc
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x69ff
leal -0x5e(%rbx), %eax
cmpl $0x3a, %eax
ja 0x7ecc
movabsq $0x400000000000600, %rcx # imm = 0x400000000000600
btq %rax, %rcx
jb 0x7eb0
movabsq $0x4000000001, %rcx     # imm = 0x4000000001
btq %rax, %rcx
jae 0x7eba
movl 0xf30b(%rip), %edi      # 0x171b4
callq 0x6b65
jmp 0x7e4c
pushq $0x62
popq %rdi
callq 0x69ff
jmp 0x7e4c
cmpq $0x3, %rax
jne 0x7ecc
pushq $-0x1
popq %rdi
callq 0x6b65
pushq $0x61
jmp 0x7ef3
cmpl $0x56, %ebx
je 0x7ee9
cmpl $0x55, %ebx
jne 0x7e4c
movl 0xf2c8(%rip), %edi      # 0x171a8
callq 0x6b65
pushq $0x55
jmp 0x7ef3
pushq $-0x1
popq %rdi
callq 0x6b65
pushq $0x56
popq %rbx
jmp 0x7e4c
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: complsubr0
void complsubr0(cell x, int op) {
	if (NIL == cdr(x)) {
		if (OP_PLUS == op)
			emitq(Zero);
		else if (OP_TIMES == op)
			emitq(One);
		else if (OP_VCONC == op)
			emitq(Nullvec);
		else if (OP_SCONC == op)
			emitq(Nullstr);
		else if (OP_CONC == op)
			emitq(NIL);
		else if (OP_NCONC == op)
			emitq(NIL);
	}
	else if (NIL == cddr(x)) {
		compexpr(cadr(x), 0);
	}
	else if (OP_CONC == op || OP_SCONC == op ||
		 OP_VCONC == op || OP_NCONC == op)
	{
		x = reverse(cdr(x));
		protect(x);
		emitq(NIL);
		while (x != NIL) {
			emitop(OP_PUSH);
			compexpr(car(x), 0);
			emitop(OP_CONS);
			x = cdr(x);
		}
		unprot(1);
		emitop(op);
	}
	else {
		x = cdr(x);
		protect(x);
		compexpr(car(x), 0);
		x = cdr(x);
		while (x != NIL) {
			emitop(OP_PUSH);
			compexpr(car(x), 0);
			emitop(op);
			x = cdr(x);
		}
		unprot(1);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq 0xf43e(%rip), %rax      # 0x17348
movslq %edi, %rcx
movslq (%rax,%rcx,4), %r14
cmpq $-0x1, %r14
je 0x7fb4
cmpl $-0x1, (%rax,%r14,4)
je 0x800a
leal -0x59(%rbx), %eax
cmpl $0x37, %eax
ja 0x7f3e
movabsq $0x80000000400001, %rcx # imm = 0x80000000400001
btq %rax, %rcx
jb 0x7f47
cmpl $0x32, %ebx
jne 0x802c
pushq $-0x1
popq %r15
movl %r14d, %edi
movl %r15d, %esi
callq 0x3a25
movl %eax, %ebp
movl 0xf212(%rip), %esi      # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xf203(%rip)      # 0x17170
movl %r15d, %edi
callq 0x6b65
pushq $0x8
popq %r14
pushq $0x33
popq %r15
cmpl $-0x1, %ebp
je 0x7ff3
movl %r14d, %edi
callq 0x69ff
movq 0xf3af(%rip), %rax      # 0x17340
movslq %ebp, %r12
movl (%rax,%r12,4), %edi
xorl %esi, %esi
callq 0x73bc
movl %r15d, %edi
callq 0x69ff
movq 0xf39a(%rip), %rax      # 0x17348
movl (%rax,%r12,4), %ebp
jmp 0x7f7d
cmpl $0x32, %ebx
je 0x8024
cmpl $0x59, %ebx
je 0x8024
cmpl $0x90, %ebx
je 0x809a
cmpl $0x6f, %ebx
je 0x80aa
cmpl $0x8c, %ebx
je 0x80a2
cmpl $0x66, %ebx
jne 0x80bd
movl 0xf1be(%rip), %edi      # 0x171ac
jmp 0x80b0
pushq $0x1
popq %rdi
callq 0x31a9
movl %ebx, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x69ff
movq 0xf32f(%rip), %rax      # 0x17340
movl (%rax,%r14,4), %edi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x73bc
pushq $-0x1
popq %rdi
jmp 0x80b0
movl 0xf13e(%rip), %esi      # 0x17170
movl %r14d, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xf12e(%rip)      # 0x17170
movq 0xf2f7(%rip), %rax      # 0x17340
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x73bc
pushq $0x8
popq %rbp
movq 0xf2ea(%rip), %rax      # 0x17348
movslq (%rax,%r14,4), %r14
cmpq $-0x1, %r14
je 0x808a
movl %ebp, %edi
callq 0x69ff
movq 0xf2ca(%rip), %rax      # 0x17340
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x73bc
movl %ebx, %edi
callq 0x69ff
jmp 0x8057
pushq $0x1
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x31a9
movl 0xf0dc(%rip), %edi      # 0x1717c
jmp 0x80b0
movl 0xf108(%rip), %edi      # 0x171b0
jmp 0x80b0
movl 0xf0c8(%rip), %edi      # 0x17178
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6b65
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq 0xf277(%rip), %rax      # 0x17348
movslq %edi, %r14
movslq (%rax,%r14,4), %rsi
movslq (%rax,%rsi,4), %rcx
cmpq $-0x1, %rcx
je 0x816a
cmpl $-0x1, (%rax,%rcx,4)
je 0x816a
movq 0xf24d(%rip), %rax      # 0x17340
movl (%rax,%rsi,4), %edi
xorl %esi, %esi
callq 0x73bc
pushq $0x8
popq %rbx
movl %ebx, %edi
callq 0x69ff
movq 0xf23a(%rip), %rax      # 0x17348
movslq (%rax,%r14,4), %rcx
movslq (%rax,%rcx,4), %r14
movq 0xf223(%rip), %rax      # 0x17340
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x73bc
pushq $0x21
popq %rbp
movq 0xf216(%rip), %rax      # 0x17348
movslq (%rax,%r14,4), %r14
cmpq $-0x1, %r14
je 0x815e
movl %ebx, %edi
callq 0x69ff
movq 0xf1f6(%rip), %rax      # 0x17340
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x73bc
movl %ebp, %edi
callq 0x69ff
jmp 0x812b
pushq $0xc
popq %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x69ff
leaq 0x8673(%rip), %rdi      # 0x107e4
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
pushq $0x1
popq %rsi
pushq $-0x1
popq %rdx
callq 0x51a9
cmpl $0x21, %ebx
jne 0x81a1
movl %ebp, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x80c6
movq 0xf1a0(%rip), %rax      # 0x17348
movslq %ebp, %r12
movslq (%rax,%r12,4), %r14
cmpl $-0x1, (%rax,%r14,4)
je 0x8225
leal -0x55(%rbx), %r15d
cmpl $-0x4, %r15d
ja 0x81d3
pushq $0x9
popq %rdi
callq 0x69ff
movq 0xf179(%rip), %rax      # 0x17348
movslq (%rax,%r12,4), %r14
movq 0xf166(%rip), %rax      # 0x17340
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x73bc
pushq $0x8
popq %rbp
movq 0xf159(%rip), %rax      # 0x17348
movslq (%rax,%r14,4), %r14
cmpq $-0x1, %r14
je 0x821b
movl %ebp, %edi
callq 0x69ff
movq 0xf139(%rip), %rax      # 0x17340
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x73bc
movl %ebx, %edi
callq 0x69ff
jmp 0x81e8
cmpl $-0x4, %r15d
ja 0x8249
pushq $0xb
jmp 0x826b
movl %ebx, %eax
andl $-0x2, %eax
cmpl $0x52, %eax
jne 0x8252
movq 0xf10a(%rip), %rax      # 0x17340
movl (%rax,%r14,4), %edi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x73bc
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x54, %ebx
jne 0x8279
movq 0xf0e2(%rip), %rax      # 0x17340
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x73bc
pushq $0x5a
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x69ff
pushq $-0x2
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6b65
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x2698
movq 0xf0b6(%rip), %rdx      # 0x17358
movq 0xf09f(%rip), %rsi      # 0x17348
movslq %ebp, %rcx
movslq (%rsi,%rcx,4), %rcx
leaq (%rdx,%rcx,4), %rcx
movslq %eax, %rdi
movslq (%rsi,%rdi,4), %rsi
leaq (%rdx,%rsi,4), %rdx
testl %ebx, %ebx
movl $0x0, %esi
cmovgl %ebx, %esi
cmpq %r14, %rsi
je 0x82db
movb (%rcx,%r14), %dil
movb %dil, (%rdx,%r14)
incq %r14
jmp 0x82c9
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edi, %r14d
xorl %edi, %edi
movl $0x400, %esi            # imm = 0x400
callq 0x2698
pushq $-0xa
popq %rbp
pushq $0x1
popq %rbx
movl %ebp, %edi
movl %eax, %esi
movl %ebx, %edx
callq 0x2f8c
andl $0x0, 0xf445(%rip)      # 0x17750
movl %eax, 0xee8f(%rip)      # 0x171a0
orl $-0x1, 0xee8c(%rip)     # 0x171a4
movl %r14d, %edi
xorl %esi, %esi
callq 0x73bc
pushq $0x10
popq %rdi
callq 0x69ff
movq 0xf017(%rip), %rax      # 0x17348
movslq 0xee68(%rip), %rcx      # 0x171a0
movl (%rax,%rcx,4), %edi
movl 0xf40f(%rip), %esi      # 0x17750
callq 0x8289
movl %ebp, %edi
movl %eax, %esi
movl %ebx, %edx
callq 0x2f8c
orl $-0x1, 0xee48(%rip)     # 0x171a0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebx
testl %esi, %esi
js 0x83e5
movq 0xefe2(%rip), %rcx      # 0x17350
movl %ebx, %eax
testb $0x1, (%rcx,%rax)
je 0x83e5
movq 0xefc3(%rip), %rcx      # 0x17340
cmpl $-0xd, (%rcx,%rax,4)
jne 0x83e5
movq 0xefbe(%rip), %r14      # 0x17348
movslq 0xedab(%rip), %rax      # 0x1713c
movslq (%r14,%rax,4), %rax
shlq $0x2, %rax
addq 0xefb8(%rip), %rax      # 0x17358
movslq %edi, %rcx
movl (%rax,%rcx,4), %ebp
movl 0xee0c(%rip), %esi      # 0x171b8
movl %ebp, %edi
callq 0x2640
cmpl $-0x1, %eax
je 0x83c0
cltq
movl %ebx, (%r14,%rax,4)
jmp 0x83e0
movl %ebp, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x2f8c
movl 0xede7(%rip), %esi      # 0x171b8
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xedd8(%rip)      # 0x171b8
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x842d(%rip), %rdi      # 0x10819
leaq 0x83e9(%rip), %rsi      # 0x107dc
movl %ebx, %edx
callq 0x2720
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
movl 0xed65(%rip), %esi      # 0x17170
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xed58(%rip)      # 0x17170
pushq $-0x1
popq %r14
movl %r14d, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xed42(%rip)      # 0x17170
movl %ebx, %eax
testl %eax, %eax
js 0x8485
movq 0xef15(%rip), %rcx      # 0x17350
movl %eax, %r15d
testb $0x9, (%rcx,%r15)
jne 0x84b4
movq 0xeef4(%rip), %rax      # 0x17340
movl (%rax,%r15,4), %edi
movl %ebp, %esi
callq 0x84c2
movl %eax, %edi
movl %r14d, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %r14d
movq 0xeed3(%rip), %rax      # 0x17340
movslq 0xecfc(%rip), %rcx      # 0x17170
movl %r14d, (%rax,%rcx,4)
movq 0xeec9(%rip), %rax      # 0x17348
movl (%rax,%r15,4), %eax
jmp 0x8430
cmpl $-0x1, %eax
jne 0x84b4
pushq $0x1
popq %rbx
movl %ebx, %edi
callq 0x31a9
pushq $-0x1
popq %rsi
movl %eax, %edi
callq 0x3a71
movl %eax, %ebp
movl %ebx, %edi
callq 0x31a9
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x826f(%rip), %rdi      # 0x1072a
movl %ebx, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %r14d
movl 0xea79(%rip), %esi      # 0x17170
pushq $-0x1
popq %rbx
movl %ebx, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xea67(%rip)      # 0x17170
cmpl $-0x1, %r14d
je 0x875f
cmpl $-0x1, %ebp
je 0x875f
movq 0xec25(%rip), %rax      # 0x17340
movslq %r14d, %r14
movl (%rax,%r14,4), %edi
movslq %ebp, %r15
movl (%rax,%r15,4), %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebx
movq 0xebfc(%rip), %rax      # 0x17340
movslq 0xea25(%rip), %rcx      # 0x17170
movl %ebx, (%rax,%rcx,4)
movq 0xebf3(%rip), %rax      # 0x17348
movl (%rax,%r14,4), %r14d
movl (%rax,%r15,4), %ebp
jmp 0x8709
pushq $0x1
popq %rdi
callq 0x31a9
pushq $-0x1
popq %rsi
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3a71