LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: prport
void prport(int out, cell x) {
	prints("#<");
	prints(out? "out": "in");
	prints("port ");
	prints(ntoa(portno(x), 10));
	prints(">");
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
leaq 0xdcf5(%rip), %rdi      # 0x13629
movl $0x2, %esi
callq 0x29c1
xorl %esi, %esi
testl %ebp, %ebp
sete %sil
leaq 0xe655(%rip), %rax      # 0x13fa2
leaq 0xdcd8(%rip), %rdi      # 0x1362c
cmoveq %rax, %rdi
xorl $0x3, %esi
callq 0x29c1
leaq 0xdcc9(%rip), %rdi      # 0x13630
movl $0x5, %esi
callq 0x29c1
movq 0x139c8(%rip), %rax     # 0x19340
movq 0x139c9(%rip), %rcx     # 0x19348
movslq %ebx, %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movb $0x0, 0x13d87(%rip)     # 0x19717
leaq 0x13d7f(%rip), %rbx     # 0x19716
leaq 0xe992(%rip), %rcx      # 0x14330
movl %eax, %edx
movslq %edx, %rsi
imulq $0x66666667, %rsi, %rdx # imm = 0x66666667
movq %rdx, %rdi
shrq $0x3f, %rdi
sarq $0x22, %rdx
addl %edi, %edx
leal (%rdx,%rdx), %edi
leal (%rdi,%rdi,4), %edi
movl %esi, %r8d
subl %edi, %r8d
movl %r8d, %edi
negl %edi
cmovsl %r8d, %edi
movb (%rdi,%rcx), %dil
movb %dil, (%rbx)
addl $0x9, %esi
decq %rbx
cmpl $0x12, %esi
ja 0x59a0
testl %eax, %eax
js 0x59e7
incq %rbx
jmp 0x59ea
movb $0x2d, (%rbx)
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
callq 0x29c1
leaq 0xdf0c(%rip), %rdi      # 0x1390f
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x29c1
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: prquote
void prquote(int sl, cell x, int d) {
	if (car(x) == S_quote) writec('\'');
	else if (car(x) == S_qquote) writec('@');
	else if (car(x) == S_unquote) writec(',');
	else if (car(x) == S_splice) prints(",@");
	prex(sl, cadr(x), d);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %edi, %ebp
movq 0x137d8(%rip), %rax     # 0x19340
movslq %esi, %r14
movl (%rax,%r14,4), %eax
cmpl 0x13ac3(%rip), %eax     # 0x19638
jne 0x5b81
leaq 0xd(%rsp), %rdi
movb $0x27, (%rdi)
jmp 0x5ba3
cmpl 0x13ab5(%rip), %eax     # 0x1963c
jne 0x5b93
leaq 0xe(%rsp), %rdi
movb $0x40, (%rdi)
jmp 0x5ba3
cmpl 0x13aab(%rip), %eax     # 0x19644
jne 0x5bd3
leaq 0xf(%rsp), %rdi
movb $0x2c, (%rdi)
movl $0x1, %esi
callq 0x29c1
movq 0x1378c(%rip), %rax     # 0x19340
movq 0x1378d(%rip), %rcx     # 0x19348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %esi
movl %ebp, %edi
movl %ebx, %edx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x55e4
cmpl 0x13a67(%rip), %eax     # 0x19640
jne 0x5bad
leaq 0xda6e(%rip), %rdi      # 0x13650
movl $0x2, %esi
jmp 0x5ba8
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: xprint
void xprint(int sl, cell x) {
	prex(sl, x, 0);
	if (1 == Plimit) {
		Plimit = 0;
		prints("...");
	}
}

// Assembly:
pushq %rax
xorl %edx, %edx
callq 0x55e4
cmpl $0x1, 0x137a0(%rip)     # 0x19398
jne 0x5c16
movl $0x0, 0x13794(%rip)     # 0x19398
leaq 0xda94(%rip), %rdi      # 0x1369f
movl $0x3, %esi
popq %rax
jmp 0x29c1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: length
int length(cell n) {
	int	k;

	for (k = 0; n != NIL; n = cdr(n))
		k++;
	return k;
}

// Assembly:
xorl %eax, %eax
cmpl $-0x1, %edi
je 0x5c5b
movq 0x136fa(%rip), %rcx     # 0x19348
incl %eax
movslq %edi, %rdx
movl (%rcx,%rdx,4), %edi
cmpl $-0x1, %edi
jne 0x5c4e
retq
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: ckargs
void ckargs(cell x, int min, int max) {
	int	k;
	char	buf[100];

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %edi, %ebx
xorl %eax, %eax
cmpl $-0x1, %edi
je 0x5c82
movq 0x136d5(%rip), %rcx     # 0x19348
movl %ebx, %edi
incl %eax
movslq %edi, %rdi
movl (%rcx,%rdi,4), %edi
cmpl $-0x1, %edi
jne 0x5c75
cmpl %esi, %eax
jle 0x5c9e
decl %eax
cmpl %edx, %eax
setle %al
testl %edx, %edx
sets %cl
orb %al, %cl
je 0x5c9e
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq 0x136a3(%rip), %rax     # 0x19348
movq 0x13694(%rip), %rcx     # 0x19340
movslq %ebx, %rdx
movslq (%rcx,%rdx,4), %rcx
movslq (%rax,%rcx,4), %rdx
shlq $0x2, %rdx
addq 0x13696(%rip), %rdx     # 0x19358
leaq 0xd9da(%rip), %rsi      # 0x136a3
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: syncheck
int syncheck(cell x, int top) {
	cell	p;

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

// Assembly:
pushq %rbx
testl %edi, %edi
js 0x5dfc
movl %edi, %eax
movq 0x13618(%rip), %rcx     # 0x19350
movl %edi, %ebx
testb $0x9, (%rcx,%rbx)
jne 0x5dfc
movq 0x135fd(%rip), %rdx     # 0x19348
movl %eax, %edi
movl %edi, %edi
testb $0x9, (%rcx,%rdi)
jne 0x5e42
movl (%rdx,%rdi,4), %edi
testl %edi, %edi
jns 0x5d4d
cmpl $-0x1, %edi
jne 0x5e42
movq 0x135d0(%rip), %rcx     # 0x19340
movl (%rcx,%rbx,4), %ecx
cmpl 0x1399f(%rip), %ecx     # 0x19718
jne 0x5d8e
movl %eax, %edi
movl $0x2, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5c5c
jmp 0x5dfc
cmpl 0x13988(%rip), %ecx     # 0x1971c
jne 0x5d9f
movl %eax, %edi
callq 0x5e64
jmp 0x5dfc
cmpl 0x1397b(%rip), %ecx     # 0x19720
jne 0x5dcb
movl %eax, %edi
movl $0x2, %esi
movl $0x3, %edx
callq 0x5c5c
movq 0x13589(%rip), %rax     # 0x19348
movl (%rax,%rbx,4), %edi
xorl %esi, %esi
callq 0x5ce0
jmp 0x5dfc
cmpl 0x13953(%rip), %ecx     # 0x19724
jne 0x5ddc
movl %eax, %edi
callq 0x5f0a
jmp 0x5dfc
cmpl 0x13946(%rip), %ecx     # 0x19728
jne 0x5ded
movl %eax, %edi
callq 0x60a7
jmp 0x5dfc
cmpl 0x13939(%rip), %ecx     # 0x1972c
jne 0x5e00
movl %eax, %edi
callq 0x613f
xorl %eax, %eax
popq %rbx
retq
cmpl 0x1392a(%rip), %ecx     # 0x19730
jne 0x5e14
movq 0x13539(%rip), %rax     # 0x19348
movl (%rax,%rbx,4), %edi
jmp 0x5dc4
cmpl 0x1381e(%rip), %ecx     # 0x19638
jne 0x5e2d
movl %eax, %edi
movl $0x1, %esi
movl $0x1, %edx
jmp 0x5d87
cmpl 0x13901(%rip), %ecx     # 0x19734
jne 0x5e3e
movl %eax, %edi
callq 0x61e6
jmp 0x5dfc
movl %eax, %edi
jmp 0x5dc4
leaq 0xd921(%rip), %rdi      # 0x1376a
movl %eax, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: ckdef
int ckdef(cell x, int top) {
	ckargs(x, 2, 2);
	if (!symbolp(cadr(x)))
		error("def: expected symbol", cadr(x));
	if (!top) error("def: must be at top level", x);
	return syncheck(caddr(x), 0);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
movl $0x2, %esi
movl $0x2, %edx
callq 0x5c5c
movq 0x134bf(%rip), %rax     # 0x19340
movq 0x134c0(%rip), %rcx     # 0x19348
movslq %ebx, %rdx
movslq (%rcx,%rdx,4), %rdx
movslq (%rax,%rdx,4), %rsi
testq %rsi, %rsi
js 0x5ec6
movq 0x134b1(%rip), %rdi     # 0x19350
testb $0x8, (%rdi,%rsi)
je 0x5ec6
cmpl $-0x12, (%rax,%rsi,4)
jne 0x5ec6
testl %ebp, %ebp
je 0x5ed2
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x5d26
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xd7f4(%rip), %rdi      # 0x136c1
callq 0x2643
leaq 0xd7fd(%rip), %rdi      # 0x136d6
movl %ebx, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: symlistp
int symlistp(cell x) {
	cell	p;

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

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

// Assembly:
movl $0x1, %eax
cmpl $-0x1, %edi
je 0x6004
movq 0x1337a(%rip), %rcx     # 0x19348
movslq %edi, %rdi
movl (%rcx,%rdi,4), %edx
cmpl $-0x1, %edx
je 0x6004
movq 0x13360(%rip), %rsi     # 0x19340
movl (%rsi,%rdi,4), %edi
movl %edx, %r8d
movslq %r8d, %r8
cmpl %edi, (%rsi,%r8,4)
je 0x6005
movl (%rcx,%r8,4), %r8d
cmpl $-0x1, %r8d
jne 0x5fe6
movslq %edx, %rdi
movl (%rcx,%rdi,4), %edx
cmpl $-0x1, %edx
jne 0x5fe0
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: flatargs
cell flatargs(cell a) {
	cell	n;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
movl 0x1315c(%rip), %esi     # 0x19170
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x13145(%rip)     # 0x19170
testl %ebp, %ebp
js 0x607b
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq 0x13315(%rip), %rax     # 0x19350
movl %ebp, %r14d
testb $0x9, (%rax,%r14)
jne 0x6080
movq 0x132f4(%rip), %rax     # 0x19340
movl (%rax,%r14,4), %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebx
movq 0x132de(%rip), %rax     # 0x19340
movslq 0x13107(%rip), %rcx     # 0x19170
movl %ebx, (%rax,%rcx,4)
movq 0x132d5(%rip), %rax     # 0x19348
movl (%rax,%r14,4), %ebp
testl %ebp, %ebp
jns 0x6034
cmpl $-0x1, %ebp
je 0x608d
movl %ebp, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebx
movl $0x1, %edi
callq 0x335c
movl %ebx, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
jmp 0x3dc8
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: cklambda
int cklambda(cell x) {
	ckargs(x, 2, -1);
	if (!symlistp(cadr(x)))
		error("lambda: invalid formals", cadr(x));
	if (!uniqlistp(flatargs(cadr(x))))
		error("lambda: duplicate formal", cadr(x));
	return ckseq(cddr(x), 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x2, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5c5c
movq 0x1327d(%rip), %rax     # 0x19340
movq 0x1327e(%rip), %rcx     # 0x19348
movslq %ebx, %r14
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %ebx
movl %ebx, %edi
callq 0x5f34
testl %eax, %eax
je 0x6110
movl %ebx, %edi
callq 0x6008
movl %eax, %edi
callq 0x5fbd
testl %eax, %eax
je 0x611e
movq 0x13250(%rip), %rax     # 0x19348
movslq (%rax,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x5ce0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xd5d9(%rip), %rdi      # 0x136f0
movl %ebx, %esi
callq 0x2643
movq 0x1321b(%rip), %rax     # 0x19340
movq 0x1321c(%rip), %rcx     # 0x19348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %esi
leaq 0xd5ce(%rip), %rdi      # 0x13708
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: ckmacro
int ckmacro(cell x, int top) {
	ckargs(x, 2, 2);
	if (!symbolp(cadr(x)))
		error("macro: expected symbol", cadr(x));
	if (!top) error("macro: must be at top level", x);
	return syncheck(caddr(x), 0);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
movl $0x2, %esi
movl $0x2, %edx
callq 0x5c5c
movq 0x131e4(%rip), %rax     # 0x19340
movq 0x131e5(%rip), %rcx     # 0x19348
movslq %ebx, %rdx
movslq (%rcx,%rdx,4), %rdx
movslq (%rax,%rdx,4), %rsi
testq %rsi, %rsi
js 0x61a1
movq 0x131d6(%rip), %rdi     # 0x19350
testb $0x8, (%rdi,%rsi)
je 0x61a1
cmpl $-0x12, (%rax,%rsi,4)
jne 0x61a1
testl %ebp, %ebp
je 0x61ad
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x5d26
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xd579(%rip), %rdi      # 0x13721
callq 0x2643
leaq 0xd584(%rip), %rdi      # 0x13738
movl %ebx, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: cksetq
int cksetq(cell x) {
	ckargs(x, 2, 2);
	if (!symbolp(cadr(x)))
		error("setq: expected symbol", cadr(x));
	return ckseq(cddr(x), 0);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl $0x2, %esi
movl $0x2, %edx
callq 0x5c5c
movq 0x13141(%rip), %rdx     # 0x19340
movq 0x13142(%rip), %rax     # 0x19348
movslq %ebx, %rcx
movslq (%rax,%rcx,4), %rcx
movslq (%rdx,%rcx,4), %rsi
testq %rsi, %rsi
js 0x6237
movq 0x13133(%rip), %rdi     # 0x19350
testb $0x8, (%rdi,%rsi)
je 0x6237
cmpl $-0x12, (%rdx,%rsi,4)
jne 0x6237
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x5ce0
xorl %eax, %eax
popq %rbx
retq
leaq 0xd516(%rip), %rdi      # 0x13754
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: set_union
cell set_union(cell a, cell b) {
	cell	n;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3d7b
movl %eax, %r14d
movl 0x12f11(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x12f02(%rip)     # 0x19170
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x12ef1(%rip)     # 0x19170
testl %r14d, %r14d
js 0x62f5
movq 0x130c5(%rip), %rax     # 0x19350
movl %ebx, %ebp
movl %r14d, %r15d
testb $0x9, (%rax,%r15)
jne 0x62fd
movq 0x130a2(%rip), %rcx     # 0x19340
movl (%rcx,%r15,4), %edi
cmpl $-0x1, %ebx
je 0x62c0
movq 0x1309a(%rip), %rdx     # 0x19348
movl %ebx, %esi
movslq %esi, %rsi
cmpl %edi, (%rcx,%rsi,4)
je 0x62e0
movl (%rdx,%rsi,4), %esi
cmpl $-0x1, %esi
jne 0x62b0
movl %ebp, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebp
movq 0x1307e(%rip), %rax     # 0x19350
movq 0x13067(%rip), %rcx     # 0x19340
movq 0x13068(%rip), %rdx     # 0x19348
movslq 0x12e89(%rip), %rsi     # 0x19170
movl %ebp, (%rcx,%rsi,4)
movl (%rdx,%r15,4), %r14d
testl %r14d, %r14d
jns 0x628d
jmp 0x62f7
movl %ebx, %ebp
cmpl $-0x1, %r14d
je 0x632f
cmpl $-0x1, %ebx
je 0x6321
movq 0x13037(%rip), %rax     # 0x19340
movq 0x13038(%rip), %rcx     # 0x19348
movslq %ebx, %rdx
cmpl %r14d, (%rax,%rdx,4)
je 0x632f
movl (%rcx,%rdx,4), %ebx
cmpl $-0x1, %ebx
jne 0x6310
movl %r14d, %edi
movl %ebp, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebp
movl $0x2, %edi
callq 0x335c
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: subrp
int subrp(cell x) {
	return	subr0(x) >= 0 ||
		subr1(x) >= 0 ||
		subr2(x) >= 0 ||
		subr3(x) >= 0 ||
		osubr0(x) >= 0 ||
		osubr1(x) >= 0 ||
		lsubr0(x) >= 0 ||
		lsubr1(x) >= 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
callq 0x7a08
movl $0x1, %ebx
testl %eax, %eax
jns 0x65cc
movl %ebp, %edi
callq 0x7a83
testl %eax, %eax
js 0x65d5
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %ebp, %edi
callq 0x7e03
testl %eax, %eax
jns 0x65cc
cmpl %ebp, 0x132ca(%rip)     # 0x198b0
je 0x65cc
cmpl %ebp, 0x132c6(%rip)     # 0x198b4
je 0x65cc
cmpl %ebp, 0x132c2(%rip)     # 0x198b8
je 0x65cc
cmpl %ebp, 0x132be(%rip)     # 0x198bc
je 0x65cc
cmpl %ebp, 0x132ba(%rip)     # 0x198c0
je 0x65cc
cmpl %ebp, 0x132b6(%rip)     # 0x198c4
je 0x65cc
cmpl %ebp, 0x132b2(%rip)     # 0x198c8
je 0x65cc
movl %ebp, %edi
callq 0x7fde
testl %eax, %eax
jns 0x65cc
movl %ebp, %edi
callq 0x8059
testl %eax, %eax
jns 0x65cc
movl %ebp, %edi
callq 0x80ad
movl %eax, %ebx
notl %ebx
shrl $0x1f, %ebx
jmp 0x65cc
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: posq
int posq(cell x, cell a) {
	int	n;

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

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $-0x1, %esi
je 0x666b
movq 0x12cf1(%rip), %rdx     # 0x19340
xorl %ecx, %ecx
movq 0x12cf0(%rip), %r8      # 0x19348
movslq %esi, %rsi
cmpl %edi, (%rdx,%rsi,4)
je 0x666c
incl %ecx
movl (%r8,%rsi,4), %esi
cmpl $-0x1, %esi
jne 0x6658
retq
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: initmap
cell initmap(cell fv, cell e, cell a) {
	cell	m, n, p;
	int	i, j;

	protect(m = NIL);
	i = 0;
	while (fv != NIL) {
		p = cons(car(fv), NIL);
		protect(p);
		n = mkfix(i);
		p = cons(n, p);
		car(Protected) = p;
		if ((j = posq(car(fv), a)) != NIL) {
			n = mkfix(j);
			p = cons(n, p);
			unprot(1);
			p = cons(I_a, p);
		}
		else if ((j = posq(car(fv), e)) != NIL) {
			n = mkfix(j);
			p = cons(n, p);
			unprot(1);
			p = cons(I_e, p);
		}
		else {
			error("undefined symbol", car(fv));
		}
		m = cons(p, m);
		car(Protected) = m;
		i++;
		fv = cdr(fv);
	}
	return nreverse(unprot(1));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, 0x4(%rsp)
movl %edi, %r12d
movl 0x12ae7(%rip), %esi     # 0x19170
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
xorl %r14d, %r14d
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x12acc(%rip)     # 0x19170
cmpl $-0x1, %r12d
je 0x6808
movq 0x12c8b(%rip), %rax     # 0x19340
movslq %r12d, %r13
movl (%rax,%r13,4), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %eax, %r12d
movl 0x12a9f(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x12a90(%rip)     # 0x19170
movl %r14d, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
movl %eax, %edi
movl %r12d, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %r12d
movq 0x12c27(%rip), %rax     # 0x19340
movslq 0x12a50(%rip), %rcx     # 0x19170
movl %r12d, (%rax,%rcx,4)
movl (%rax,%r13,4), %esi
cmpl $-0x1, %ebx
je 0x674a
xorl %edi, %edi
movq 0x12c12(%rip), %rcx     # 0x19348
movl %ebx, %edx
movslq %edx, %rdx
cmpl %esi, (%rax,%rdx,4)
je 0x6782
incl %edi
movl (%rcx,%rdx,4), %edx
cmpl $-0x1, %edx
jne 0x6738
cmpl $-0x1, 0x4(%rsp)
je 0x682c
xorl %edi, %edi
movq 0x12bea(%rip), %rcx     # 0x19348
movl 0x4(%rsp), %edx
movslq %edx, %rdx
cmpl %esi, (%rax,%rdx,4)
je 0x6779
incl %edi
movl (%rcx,%rdx,4), %edx
cmpl $-0x1, %edx
jne 0x6762
jmp 0x682c
leaq 0x12fbc(%rip), %rbp     # 0x1973c
jmp 0x6789
leaq 0x12faf(%rip), %rbp     # 0x19738
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
movl %eax, %edi
movl %r12d, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %r12d
movl $0x1, %edi
callq 0x335c
movl (%rbp), %edi
movl %r12d, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %edi
movl %r15d, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %r15d
movq 0x12b5b(%rip), %rax     # 0x19340
movslq 0x12984(%rip), %rcx     # 0x19170
movl %r15d, (%rax,%rcx,4)
incl %r14d
movq 0x12b4e(%rip), %rcx     # 0x19348
movl (%rcx,%r13,4), %r12d
cmpl $-0x1, %r12d
jne 0x66b5
movl $0x1, %edi
callq 0x335c
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3dc8
leaq 0xcf4e(%rip), %rdi      # 0x13781
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: newvar
void newvar(cell x) {
	cell	n;

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

// Assembly:
pushq %rax
movl 0x12935(%rip), %eax     # 0x19194
cmpl $-0x1, %eax
je 0x689b
movq 0x12ad5(%rip), %rdx     # 0x19340
movq 0x12ad6(%rip), %rcx     # 0x19348
movl %eax, %esi
movslq %esi, %rsi
cmpl %edi, (%rdx,%rsi,4)
je 0x68d2
movl (%rcx,%rsi,4), %esi
cmpl $-0x1, %esi
jne 0x6874
cmpl $-0x1, 0x1290d(%rip)    # 0x19198
jne 0x68af
movl %eax, %edx
cltq
movl (%rcx,%rax,4), %eax
cmpl $-0x1, %eax
jne 0x688d
jmp 0x68a9
cmpl $-0x1, 0x128f6(%rip)    # 0x19198
jne 0x68af
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %edx, 0x128e9(%rip)     # 0x19198
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movq 0x12a86(%rip), %rcx     # 0x19348
movslq 0x128cf(%rip), %rdx     # 0x19198
movl %eax, (%rcx,%rdx,4)
movl %eax, 0x128c6(%rip)     # 0x19198
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: mapconv
cell mapconv(cell x, cell e, cell a) {
	cell	n, new;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r15d
movl 0x1285f(%rip), %esi     # 0x19170
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x12847(%rip)     # 0x19170
testl %r15d, %r15d
js 0x6981
movq 0x12a1b(%rip), %rax     # 0x19350
movl %r15d, %r15d
testb $0x9, (%rax,%r15)
jne 0x6981
movq 0x129fa(%rip), %rax     # 0x19340
movl (%rax,%r15,4), %edi
movl %ebp, %esi
movl %ebx, %edx
callq 0x69a1
movl %eax, %edi
movl %r14d, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %r14d
movq 0x129d7(%rip), %rax     # 0x19340
movslq 0x12800(%rip), %rcx     # 0x19170
movl %r14d, (%rax,%rcx,4)
movq 0x129cd(%rip), %rax     # 0x19348
movl (%rax,%r15,4), %r15d
jmp 0x6929
movl $0x1, %edi
callq 0x335c
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3dc8
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: lamconv
cell lamconv(cell x, cell e, cell a) {
	cell	cl, fv, args, m;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6346
movl %eax, %ebx
movl 0x124c6(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x124b7(%rip)     # 0x19170
cmpl $-0x1, %ebx
je 0x6ce5
movl %ebx, %ecx
movq 0x12679(%rip), %rax     # 0x19340
movslq %ecx, %r12
movl (%rax,%r12,4), %edi
callq 0x6858
movq 0x1266e(%rip), %rax     # 0x19348
movl (%rax,%r12,4), %ecx
cmpl $-0x1, %ecx
jne 0x6cc0
jmp 0x6cec
movq 0x1265c(%rip), %rax     # 0x19348
movq 0x1264d(%rip), %rcx     # 0x19340
movslq %r15d, %r12
movslq (%rax,%r12,4), %rax
movl (%rcx,%rax,4), %edi
callq 0x6008
movl %eax, %r15d
movl 0x12465(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x12456(%rip)     # 0x19170
movl %ebx, %edi
movl %r14d, %esi
movl %ebp, %edx
callq 0x666f
movl %eax, %ebp
movl 0x12442(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x12433(%rip)     # 0x19170
movq 0x12604(%rip), %rax     # 0x19348
movslq (%rax,%r12,4), %rcx
movl (%rax,%rcx,4), %edi
movl %ebx, %esi
movl %r15d, %edx
callq 0x68fd
movl %ebp, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
movq 0x125d9(%rip), %rcx     # 0x19340
movq 0x125da(%rip), %rdx     # 0x19348
movslq (%rdx,%r12,4), %rdx
movl (%rcx,%rdx,4), %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
movl 0x129bc(%rip), %edi     # 0x19740
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebx
movl $0x3, %edi
callq 0x335c
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: contains
int contains(cell a, cell x) {
	if (a == x) return 1;
	if (pairp(a) && (contains(car(a), x) || contains(cdr(a), x)))
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl $0x1, %ebx
cmpl %esi, %edi
je 0x6dc8
testl %edi, %edi
js 0x6dc6
movq 0x12594(%rip), %rax     # 0x19350
movl %edi, %r14d
testb $0x9, (%rax,%r14)
je 0x6dcf
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl %esi, %ebp
movq 0x12568(%rip), %rax     # 0x19340
movl (%rax,%r14,4), %edi
callq 0x6da4
testl %eax, %eax
jne 0x6dc8
movq 0x1255c(%rip), %rax     # 0x19348
movl (%rax,%r14,4), %edi
movl %ebp, %esi
callq 0x6da4
testl %eax, %eax
jne 0x6dc8
jmp 0x6dc6
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: liftnames
cell liftnames(cell m) {
	#define name cadddr
	cell	a, n;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
movl 0x12356(%rip), %esi     # 0x19170
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x1233f(%rip)     # 0x19170
cmpl $-0x1, %ebp
je 0x6e97
movq 0x12503(%rip), %rax     # 0x19340
movl 0x128f5(%rip), %edx     # 0x19738
movq 0x124fe(%rip), %rcx     # 0x19348
movslq %ebp, %r14
movslq (%rax,%r14,4), %rsi
cmpl %edx, (%rax,%rsi,4)
jne 0x6e8e
movslq (%rcx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebx
movq 0x124c9(%rip), %rax     # 0x19340
movslq 0x122f2(%rip), %rcx     # 0x19170
movl %ebx, (%rax,%rcx,4)
movl 0x128b1(%rip), %edx     # 0x19738
movq 0x124ba(%rip), %rcx     # 0x19348
movl (%rcx,%r14,4), %ebp
cmpl $-0x1, %ebp
jne 0x6e4a
movl $0x1, %edi
callq 0x335c
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
jmp 0x3dc8
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: liftargs
cell liftargs(cell m) {
	#define source	cadr
	cell	a, n;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebp
movl 0x122af(%rip), %esi     # 0x19170
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x12298(%rip)     # 0x19170
cmpl $-0x1, %ebp
je 0x6f7c
movq 0x12458(%rip), %rax     # 0x19340
movl 0x1284a(%rip), %ecx     # 0x19738
movq 0x12453(%rip), %rdx     # 0x19348
leaq 0x12848(%rip), %r14     # 0x19744
leaq 0x12845(%rip), %r15     # 0x19748
movslq %ebp, %r12
movslq (%rax,%r12,4), %rsi
cmpl %ecx, (%rax,%rsi,4)
jne 0x6f73
movslq (%rdx,%rsi,4), %rcx
movl (%rax,%rcx,4), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movq 0x12417(%rip), %rcx     # 0x19340
movslq (%rcx,%r12,4), %rdx
movl (%rcx,%rdx,4), %ecx
cmpl 0x12802(%rip), %ecx     # 0x19738
movq %r15, %rcx
cmoveq %r14, %rcx
movl (%rcx), %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebx
movq 0x123e4(%rip), %rax     # 0x19340
movslq 0x1220d(%rip), %rcx     # 0x19170
movl %ebx, (%rax,%rcx,4)
movl 0x127cc(%rip), %ecx     # 0x19738
movq 0x123d5(%rip), %rdx     # 0x19348
movl (%rdx,%r12,4), %ebp
cmpl $-0x1, %ebp
jne 0x6f03
movl $0x1, %edi
callq 0x335c
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3dc8
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: defconv
cell defconv(cell x, cell e, cell a) {
	cell	n, m;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq 0x12181(%rip), %rax     # 0x19340
movq 0x12182(%rip), %rcx     # 0x19348
movslq %edi, %r15
movslq (%rcx,%r15,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x6858
movq 0x12164(%rip), %rax     # 0x19340
movq 0x12165(%rip), %rcx     # 0x19348
movslq (%rcx,%r15,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl %ebp, %esi
movl %ebx, %edx
callq 0x69a1
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
xorl %r12d, %r12d
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebx
movl 0x11f5a(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x11f4b(%rip)     # 0x19170
cmpl $-0x1, %ebp
je 0x7257
movq 0x1210f(%rip), %rax     # 0x19340
movq 0x12110(%rip), %rcx     # 0x19348
movslq (%rcx,%r15,4), %rdx
movl (%rax,%rdx,4), %edx
movslq %ebp, %rsi
cmpl %edx, (%rax,%rsi,4)
je 0x7254
incl %r12d
movl (%rcx,%rsi,4), %ebp
cmpl $-0x1, %ebp
jne 0x723f
jmp 0x7257
movl %r12d, %r14d
movl %r14d, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
movl %eax, %ebp
movl 0x11eee(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x11edf(%rip)     # 0x19170
movl 0x124b0(%rip), %r14d    # 0x19748
movq 0x120a1(%rip), %rax     # 0x19340
movq 0x120a2(%rip), %rcx     # 0x19348
movslq (%rcx,%r15,4), %rcx
movl (%rax,%rcx,4), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %ebp, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
movl %r14d, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebp
movl $0x2, %edi
callq 0x335c
movl 0x12451(%rip), %r14d    # 0x19734
movl %ebp, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x30e7
movl %r14d, %edi
movl %eax, %esi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x30e7
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: carof
cell carof(cell a) {
	cell	n;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
movl 0x11e62(%rip), %esi     # 0x19170
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x11e4b(%rip)     # 0x19170
cmpl $-0x1, %ebp
je 0x736c
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq 0x1200a(%rip), %rax     # 0x19340
movslq %ebp, %r14
movslq (%rax,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebx
movq 0x11fee(%rip), %rax     # 0x19340
movslq 0x11e17(%rip), %rcx     # 0x19170
movl %ebx, (%rax,%rcx,4)
movq 0x11fe5(%rip), %rcx     # 0x19348
movl (%rcx,%r14,4), %ebp
cmpl $-0x1, %ebp
jne 0x7336
movl $0x1, %edi
callq 0x335c
movl %ebx, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
jmp 0x3dc8
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: zipenv
cell zipenv(cell vs, cell oe) {
	cell	n, b;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %r14d
movl 0x11dd8(%rip), %esi     # 0x19170
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x11dc1(%rip)     # 0x19170
cmpl $-0x1, %r14d
je 0x7427
movq 0x11f84(%rip), %rax     # 0x19340
movslq %r14d, %r15
cmpl $-0x1, %ebx
je 0x73d6
movslq %ebx, %rcx
movl (%rax,%rcx,4), %edi
movq 0x11f77(%rip), %rax     # 0x19348
movl (%rax,%rcx,4), %ebx
jmp 0x73fe
movl (%rax,%r15,4), %r14d
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %r14d, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %edi
movl %ebp, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebp
movq 0x11f30(%rip), %rax     # 0x19340
movslq 0x11d59(%rip), %rcx     # 0x19170
movl %ebp, (%rax,%rcx,4)
movq 0x11f27(%rip), %rax     # 0x19348
movl (%rax,%r15,4), %r14d
jmp 0x73af
movl $0x1, %edi
callq 0x335c
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3dc8
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: clsconv
cell clsconv(cell x) {
	cell	n;

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

// Assembly:
pushq %rbx
movl %edi, %ebx
movl 0x11cf4(%rip), %edi     # 0x19144
callq 0x7302
movl %eax, 0x11d39(%rip)     # 0x19194
movl $0xffffffff, 0x11d33(%rip) # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
jne 0x7481
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x11d13(%rip)     # 0x19194
movl %ebx, %edi
movl %eax, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x69a1
movl 0x11cdb(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x11ccc(%rip)     # 0x19170
movl 0x11cea(%rip), %edi     # 0x19194
movl 0x11c94(%rip), %esi     # 0x19144
callq 0x7386
movl %eax, 0x11c89(%rip)     # 0x19144
movl $0x1, %edi
popq %rbx
jmp 0x335c
// File: /workspace/github_c_makefile_star2_O3/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
movb $0x1, %r12b
movl 0x11c7e(%rip), %ebx     # 0x19158
xorl %r15d, %r15d
movb $0x1, %al
movq 0x11e72(%rip), %rcx     # 0x19358
movq 0x11e5b(%rip), %rdx     # 0x19348
movslq 0x11c70(%rip), %rsi     # 0x19164
movslq (%rdx,%rsi,4), %rsi
movslq -0x4(%rcx,%rsi,4), %r14
addq $0x3, %r14
shrq $0x2, %r14
testl %r14d, %r14d
jle 0x753e
movslq %ebx, %rsi
movslq (%rdx,%rsi,4), %rdx
leaq (%rcx,%rdx,4), %rcx
movl 0x12231(%rip), %edx     # 0x1974c
movl %r14d, %esi
movslq %edx, %rdi
cmpb $0x0, (%rcx,%rdi)
je 0x762d
incl %edx
cmpl %r14d, %edx
cmovgel %r15d, %edx
movl %edx, 0x12212(%rip)     # 0x1974c
decl %esi
jne 0x751e
testb $0x1, %al
je 0x7551
callq 0x2ec4
xorl %eax, %eax
movl 0x11c09(%rip), %ebx     # 0x19158
jmp 0x74df
cmpl $0xfbff, %r14d          # imm = 0xFBFF
jg 0x761c
leal 0x400(%r14), %ebp
movl %ebp, %edi
callq 0x33a7
movq 0x11de5(%rip), %rcx     # 0x19358
movq 0x11dce(%rip), %rdx     # 0x19348
movslq %eax, %rbx
movslq (%rdx,%rbx,4), %rax
leaq (%rcx,%rax,4), %rdi
movslq 0x11bd8(%rip), %rax     # 0x19164
movslq (%rdx,%rax,4), %rax
leaq (%rcx,%rax,4), %rsi
movslq %r14d, %r14
leaq (,%r14,4), %rdx
callq 0x2140
movl %ebx, 0x11bba(%rip)     # 0x19164
xorl %edi, %edi
movl %ebp, %esi
callq 0x27b0
movl %eax, %ebx
movq 0x11d8c(%rip), %rax     # 0x19348
movslq %ebx, %r13
movslq (%rax,%r13,4), %rdi
shlq $0x2, %rdi
addq 0x11d8a(%rip), %rdi     # 0x19358
movslq %ebp, %rdx
xorl %esi, %esi
callq 0x20b0
movq 0x11d79(%rip), %rax     # 0x19358
movq 0x11d62(%rip), %rcx     # 0x19348
movslq (%rcx,%r13,4), %rdx
leaq (%rax,%rdx,4), %rdi
movslq 0x11b63(%rip), %rdx     # 0x19158
movslq (%rcx,%rdx,4), %rcx
leaq (%rax,%rcx,4), %rsi
movq %r14, %rdx
callq 0x2140
movl %r13d, 0x11b4c(%rip)    # 0x19158
testb $0x1, %r12b
movl $0x0, %r12d
jne 0x74dd
leaq 0xc16f(%rip), %rdi      # 0x13792
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x2643
movb $0x1, (%rcx,%rdi)
movl 0x12115(%rip), %eax     # 0x1974c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: obindex
int obindex(cell x) {
	cell	n;
	int	i;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
testl %edi, %edi
js 0x768e
movq 0x11cf9(%rip), %rcx     # 0x19350
movl %ebx, %eax
movb (%rcx,%rax), %cl
testb $0x9, %cl
je 0x7685
testb $0x8, %cl
je 0x7673
movq 0x11cd3(%rip), %rdx     # 0x19340
cmpl $-0x13, (%rdx,%rax,4)
je 0x7685
testb $0x1, %cl
je 0x768e
movq 0x11cc1(%rip), %rcx     # 0x19340
cmpl $-0xd, (%rcx,%rax,4)
jne 0x768e
popq %rbx
popq %r14
popq %rbp
jmp 0x74c6
movl 0x11b07(%rip), %r14d    # 0x1919c
movl %r14d, %edi
movl %ebx, %esi
callq 0x38f3
cmpl $-0x4, %eax
je 0x7705
movq 0x11c95(%rip), %rdx     # 0x19340
movq 0x11c96(%rip), %rcx     # 0x19348
cltq
movslq (%rcx,%rax,4), %rax
movslq (%rcx,%rax,4), %rax
movl (%rdx,%rax,4), %ebp
movq 0x11c92(%rip), %rax     # 0x19358
movslq 0x11a8b(%rip), %rdx     # 0x19158
movslq (%rcx,%rdx,4), %rdx
leaq (%rax,%rdx,4), %rsi
movslq %ebp, %rdx
cmpb $0x0, (%rdx,%rsi)
je 0x76fb
movslq 0x11a7f(%rip), %rsi     # 0x19164
movslq (%rcx,%rsi,4), %rcx
leaq (%rax,%rcx,4), %rax
movl (%rax,%rdx,4), %esi
movl %ebx, %edi
callq 0x3652
testl %eax, %eax
jne 0x7741
movl %r14d, %edi
movl %ebx, %esi
callq 0x3aae
callq 0x74c6
movl %eax, %ebp
movl 0x11a89(%rip), %r14d    # 0x1919c
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
movl %r14d, %edi
movl %ebx, %esi
movl %eax, %edx
callq 0x397c
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: emit
void emit(int x) {
	cell	n;
	byte	*vp, *vn;
	int	i, k;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl 0x11ffc(%rip), %ecx     # 0x19750
movq 0x11bfd(%rip), %rax     # 0x19358
movq 0x11be6(%rip), %rdx     # 0x19348
movslq 0x11a37(%rip), %rsi     # 0x191a0
movslq (%rdx,%rsi,4), %rsi
movslq (%rdx,%rsi,4), %rdx
cmpl -0x4(%rax,%rdx,4), %ecx
jl 0x7841
movl 0x119ef(%rip), %esi     # 0x19170
movl %ebx, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x119e0(%rip)     # 0x19170
movq 0x11bc1(%rip), %rax     # 0x19358
movq 0x11baa(%rip), %rcx     # 0x19348
movslq 0x119fb(%rip), %rdx     # 0x191a0
movslq (%rcx,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movslq -0x4(%rax,%rcx,4), %r14
leal 0x400(%r14), %esi
xorl %edi, %edi
callq 0x27b0
movq 0x11b81(%rip), %rcx     # 0x19348
movslq 0x119d2(%rip), %rdx     # 0x191a0
testq %r14, %r14
jle 0x7811
movq 0x11b7e(%rip), %rsi     # 0x19358
movslq (%rcx,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rdx
leaq (%rsi,%rdx,4), %rdx
movslq %eax, %rdi
movslq (%rcx,%rdi,4), %rcx
leaq (%rsi,%rcx,4), %rcx
xorl %esi, %esi
movb (%rdx,%rsi), %dil
movb %dil, (%rcx,%rsi)
incq %rsi
cmpq %rsi, %r14
jne 0x77f3
movq 0x11b3e(%rip), %rcx     # 0x19348
movslq 0x1198f(%rip), %rdx     # 0x191a0
movl %eax, (%rcx,%rdx,4)
movl $0x1, %edi
callq 0x335c
movq 0x11b33(%rip), %rax     # 0x19358
movq 0x11b1c(%rip), %rcx     # 0x19348
movslq 0x1196d(%rip), %rdx     # 0x191a0
movslq (%rcx,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rdx
movl 0x11f0f(%rip), %ecx     # 0x19750
leaq (%rax,%rdx,4), %rax
movslq %ecx, %rcx
movb %bl, (%rcx,%rax)
incl 0x11eff(%rip)           # 0x19750
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: emitarg
void emitarg(int i) {
	if (i < 0 || i > 65535)
		error("bytecode argument out of range", mkfix(i));
	emit(i >> 8);
	emit(i & 255);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
cmpl $0x10000, %edi          # imm = 0x10000
jae 0x7877
movl %ebx, %edi
shrl $0x8, %edi
callq 0x7748
movzbl %bl, %edi
popq %rbx
jmp 0x7748
movl %ebx, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
leaq 0xbf06(%rip), %rdi      # 0x137a6
movl %eax, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 0x7646
movq 0x11a8f(%rip), %rcx     # 0x19348
movslq 0x118a4(%rip), %rdx     # 0x19164
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0x11a89(%rip), %rcx     # 0x19358
movslq %eax, %r14
movl %ebx, (%rcx,%r14,4)
movl $0x5, %edi
callq 0x7748
movl %r14d, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7859
// File: /workspace/github_c_makefile_star2_O3/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 0x7946
movq 0x11a48(%rip), %rcx     # 0x19348
movslq 0x11899(%rip), %rdx     # 0x191a0
movslq (%rcx,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0x11a3e(%rip), %rcx     # 0x19358
movslq %edi, %rdx
movb %ah, (%rdx,%rcx)
movq 0x11a21(%rip), %rcx     # 0x19348
movslq 0x11872(%rip), %rsi     # 0x191a0
movslq (%rcx,%rsi,4), %rsi
movslq (%rcx,%rsi,4), %rcx
shlq $0x2, %rcx
addq 0x11a17(%rip), %rcx     # 0x19358
movb %al, 0x1(%rdx,%rcx)
retq
pushq %rax
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
leaq 0xbe36(%rip), %rdi      # 0x137a6
movl %eax, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 0x11826(%rip), %rax     # 0x191a4
cmpq $-0x1, %rax
je 0x79a7
movq 0x119b5(%rip), %rcx     # 0x19340
movslq (%rcx,%rax,4), %rdx
movq 0x119b2(%rip), %rsi     # 0x19348
movl (%rsi,%rax,4), %eax
movl %eax, 0x11805(%rip)     # 0x191a4
movslq (%rsi,%rdx,4), %rax
movl (%rcx,%rax,4), %eax
retq
pushq %rax
leaq 0xbe16(%rip), %rdi      # 0x137c5
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 0x117e4(%rip), %rax     # 0x191a4
cmpq $-0x1, %rax
je 0x79f6
movq 0x1197b(%rip), %rcx     # 0x19348
movslq (%rcx,%rax,4), %rdx
cmpq $-0x1, %rdx
je 0x79f6
movq 0x11962(%rip), %rsi     # 0x19340
movl (%rsi,%rax,4), %edi
movl (%rsi,%rdx,4), %edx
movl %edx, (%rsi,%rax,4)
movslq 0x117b6(%rip), %rax     # 0x191a4
movslq (%rcx,%rax,4), %rax
movl %edi, (%rsi,%rax,4)
retq
pushq %rax
leaq 0xbdc7(%rip), %rdi      # 0x137c5
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: subr0
int subr0(cell x) {
	if (x == P_cmdline)	return OP_CMDLINE;
	if (x == P_errport)	return OP_ERRPORT;
	if (x == P_gc)		return OP_GC;
	if (x == P_gensym)	return OP_GENSYM;
	if (x == P_inport)	return OP_INPORT;
	if (x == P_obtab)	return OP_OBTAB;
	if (x == P_outport)	return OP_OUTPORT;
	if (x == P_quit)	return OP_QUIT;
	if (x == P_symtab)	return OP_SYMTAB;
	return -1;
}

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

// Assembly:
movl $0x33, %eax
cmpl %edi, 0x11a42(%rip)     # 0x19850
je 0x7f78
movl $0x37, %eax
cmpl %edi, 0x11a35(%rip)     # 0x19854
je 0x7f78
movl $0x3b, %eax
cmpl %edi, 0x11a28(%rip)     # 0x19858
je 0x7f78
movl $0x5b, %eax
cmpl %edi, 0x11a1b(%rip)     # 0x1985c
je 0x7f78
movl $0x6c, %eax
cmpl %edi, 0x11a0e(%rip)     # 0x19860
je 0x7f78
movl $0x6d, %eax
cmpl %edi, 0x11a01(%rip)     # 0x19864
je 0x7f78
movl $0x6e, %eax
cmpl %edi, 0x119f4(%rip)     # 0x19868
je 0x7f78
movl $0x7d, %eax
cmpl %edi, 0x119e7(%rip)     # 0x1986c
je 0x7f78
movl $0x7e, %eax
cmpl %edi, 0x119da(%rip)     # 0x19870
je 0x7f78
movl $0x70, %eax
cmpl %edi, 0x119cd(%rip)     # 0x19874
je 0x7f78
movl $0x76, %eax
cmpl %edi, 0x119c0(%rip)     # 0x19878
je 0x7f78
movl $0x77, %eax
cmpl %edi, 0x119b3(%rip)     # 0x1987c
je 0x7f78
movl $0x71, %eax
cmpl %edi, 0x119a6(%rip)     # 0x19880
je 0x7f78
movl $0x72, %eax
cmpl %edi, 0x11999(%rip)     # 0x19884
je 0x7f78
movl $0x75, %eax
cmpl %edi, 0x1198c(%rip)     # 0x19888
je 0x7f78
movl $0x7b, %eax
cmpl %edi, 0x11983(%rip)     # 0x1988c
je 0x7f78
movl $0x7c, %eax
cmpl %edi, 0x1197a(%rip)     # 0x19890
je 0x7f78
movl $0x78, %eax
cmpl %edi, 0x11971(%rip)     # 0x19894
je 0x7f78
movl $0x79, %eax
cmpl %edi, 0x11968(%rip)     # 0x19898
je 0x7f78
movl $0x7a, %eax
cmpl %edi, 0x1195f(%rip)     # 0x1989c
je 0x7f78
movl $0x7f, %eax
cmpl %edi, 0x11956(%rip)     # 0x198a0
je 0x7f78
movl $0x12, %eax
cmpl %edi, 0x1194d(%rip)     # 0x198a4
je 0x7f78
movl $0x93, %eax
cmpl %edi, 0x11944(%rip)     # 0x198a8
je 0x7f78
xorl %eax, %eax
cmpl %edi, 0x1193e(%rip)     # 0x198ac
setne %al
negl %eax
orl $0x94, %eax
retq