LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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, 0x1192c(%rip)     # 0x198b0
je 0x7fb2
movl $0x85, %eax
cmpl %edi, 0x11923(%rip)     # 0x198b4
je 0x7fb2
movl $0x86, %eax
cmpl %edi, 0x1191a(%rip)     # 0x198b8
je 0x7fb2
xorl %eax, %eax
cmpl %edi, 0x11914(%rip)     # 0x198bc
setne %al
negl %eax
orl $0x95, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: osubr0
int osubr0(cell x) {
	if (x == P_peekc)	return OP_PEEKC;
	if (x == P_read)	return OP_READ;
	if (x == P_readc)	return OP_READC;
	return -1;
}

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

// Assembly:
movl $0x3d, %eax
cmpl %edi, 0x118e3(%rip)     # 0x198cc
je 0x8058
movl $0x55, %eax
cmpl %edi, 0x118da(%rip)     # 0x198d0
je 0x8058
movl $0x56, %eax
cmpl %edi, 0x118d1(%rip)     # 0x198d4
je 0x8058
movl $0x5e, %eax
cmpl %edi, 0x118c8(%rip)     # 0x198d8
je 0x8058
movl $0x61, %eax
cmpl %edi, 0x118bf(%rip)     # 0x198dc
je 0x8058
movl $0x67, %eax
cmpl %edi, 0x118b6(%rip)     # 0x198e0
je 0x8058
movl $0x68, %eax
cmpl %edi, 0x118ad(%rip)     # 0x198e4
je 0x8058
movl $0x84, %eax
cmpl %edi, 0x118a4(%rip)     # 0x198e8
je 0x8058
xorl %eax, %eax
cmpl %edi, 0x1189e(%rip)     # 0x198ec
setne %al
negl %eax
orl $0x98, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x1188c(%rip)     # 0x198f0
je 0x80ac
movl $0x66, %eax
cmpl %edi, 0x11883(%rip)     # 0x198f4
je 0x80ac
movl $0x32, %eax
cmpl %edi, 0x1187a(%rip)     # 0x198f8
je 0x80ac
movl $0x59, %eax
cmpl %edi, 0x11871(%rip)     # 0x198fc
je 0x80ac
movl $0x6f, %eax
cmpl %edi, 0x11868(%rip)     # 0x19900
je 0x80ac
xorl %eax, %eax
cmpl %edi, 0x11862(%rip)     # 0x19904
setne %al
negl %eax
orl $0x90, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: lsubr1
int lsubr1(cell x) {
	if (x == P_bitop)	return OP_BITOP;
	if (x == P_max)		return OP_MAX;
	if (x == P_min)		return OP_MIN;
	if (x == P_minus)	return OP_MINUS;
	if (x == P_less)	return OP_LESS;
	if (x == P_lteq)	return OP_LTEQ;
	if (x == P_equal)	return OP_EQUAL;
	if (x == P_grtr)	return OP_GRTR;
	if (x == P_gteq)	return OP_GTEQ;
	if (x == P_cless)	return OP_CLESS;
	if (x == P_clteq)	return OP_CLTEQ;
	if (x == P_cequal)	return OP_CEQUAL;
	if (x == P_cgrtr)	return OP_CGRTR;
	if (x == P_cgteq)	return OP_CGTEQ;
	return -1;
}

// Assembly:
movl $0x21, %eax
cmpl %edi, 0x11850(%rip)     # 0x19908
je 0x8176
movl $0x52, %eax
cmpl %edi, 0x11843(%rip)     # 0x1990c
je 0x8176
movl $0x53, %eax
cmpl %edi, 0x11836(%rip)     # 0x19910
je 0x8176
movl $0x54, %eax
cmpl %edi, 0x11829(%rip)     # 0x19914
je 0x8176
movl $0x4c, %eax
cmpl %edi, 0x1181c(%rip)     # 0x19918
je 0x8176
movl $0x51, %eax
cmpl %edi, 0x11813(%rip)     # 0x1991c
je 0x8176
movl $0x3c, %eax
cmpl %edi, 0x1180a(%rip)     # 0x19920
je 0x8176
movl $0x48, %eax
cmpl %edi, 0x11801(%rip)     # 0x19924
je 0x8176
movl $0x49, %eax
cmpl %edi, 0x117f8(%rip)     # 0x19928
je 0x8176
movl $0x2e, %eax
cmpl %edi, 0x117ef(%rip)     # 0x1992c
je 0x8176
movl $0x30, %eax
cmpl %edi, 0x117e6(%rip)     # 0x19930
je 0x8176
movl $0x28, %eax
cmpl %edi, 0x117dd(%rip)     # 0x19934
je 0x8176
movl $0x29, %eax
cmpl %edi, 0x117d4(%rip)     # 0x19938
je 0x8176
xorl %eax, %eax
cmpl %edi, 0x117ce(%rip)     # 0x1993c
setne %al
negl %eax
orl $0x2a, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: compprog
void compprog(cell x, int t) {
	x = cdr(x);
	if (NIL == x) {
		emitq(NIL);
		return;
	}
	while (cdr(x) != NIL) {
		compexpr(car(x), 0);
		x = cdr(x);
	}
	compexpr(car(x), t);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x111c6(%rip), %rax     # 0x19348
movslq %edi, %rcx
movslq (%rax,%rcx,4), %r14
cmpq $-0x1, %r14
je 0x81d0
movl %esi, %ebx
cmpl $-0x1, (%rax,%r14,4)
je 0x81b7
movq 0x111a1(%rip), %rax     # 0x19340
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x81e1
movq 0x11197(%rip), %rax     # 0x19348
movslq (%rax,%r14,4), %r14
jmp 0x8191
movq 0x11182(%rip), %rax     # 0x19340
movl (%rax,%r14,4), %edi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x81e1
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x78a7
// File: /workspace/github_c_makefile_star2_O3/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 0x10dec(%rip), %rax     # 0x19340
movq 0x10ded(%rip), %rcx     # 0x19348
movslq %edi, %r14
movslq (%rcx,%r14,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x81e1
movq 0x10dc9(%rip), %rax     # 0x19340
movq 0x10dca(%rip), %rcx     # 0x19348
movslq (%rcx,%r14,4), %rcx
movslq (%rax,%rcx,4), %rcx
movl (%rax,%rcx,4), %eax
movl $0x1c, %edi
cmpl 0x111b4(%rip), %eax     # 0x19748
je 0x85a3
movl $0x1b, %edi
cmpl 0x111a3(%rip), %eax     # 0x19744
jne 0x85d9
callq 0x7748
movq 0x10d91(%rip), %rax     # 0x19340
movq 0x10d92(%rip), %rcx     # 0x19348
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 0x7859
leaq 0xb203(%rip), %rdi      # 0x137e3
movl %ebx, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 0x10d4a(%rip), %rax     # 0x19340
movq 0x10d4b(%rip), %rcx     # 0x19348
movslq %edi, %r14
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x81e1
cmpl $0x1, %ebp
movl $0xf, %edi
sbbl $0x0, %edi
callq 0x7748
movl 0x1112c(%rip), %edi     # 0x19750
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
movl 0x10b5a(%rip), %esi     # 0x191a4
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x10b4b(%rip)     # 0x191a4
xorl %edi, %edi
callq 0x7748
xorl %edi, %edi
callq 0x7748
movq 0x10cd2(%rip), %rax     # 0x19340
movq 0x10cd3(%rip), %rcx     # 0x19348
movslq (%rcx,%r14,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl %ebx, %esi
callq 0x81e1
movq 0x10cba(%rip), %rax     # 0x19348
movslq (%rax,%r14,4), %rcx
movslq (%rax,%rcx,4), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x872e
movl $0xd, %edi
callq 0x7748
movl 0x110a0(%rip), %edi     # 0x19750
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
movl 0x10ace(%rip), %esi     # 0x191a4
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x10abf(%rip)     # 0x191a4
xorl %edi, %edi
callq 0x7748
xorl %edi, %edi
callq 0x7748
callq 0x79b9
callq 0x7977
movl 0x1104d(%rip), %esi     # 0x19750
movl %eax, %edi
callq 0x78ef
movq 0x10c2f(%rip), %rax     # 0x19340
movq 0x10c30(%rip), %rcx     # 0x19348
movslq (%rcx,%r14,4), %rdx
movslq (%rcx,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl %ebx, %esi
callq 0x81e1
callq 0x7977
movl 0x11017(%rip), %esi     # 0x19750
movl %eax, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x78ef
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
cmpl $-0x1, %edi
je 0x87e3
movl %edi, %esi
movq 0x10be9(%rip), %rax     # 0x19340
movslq %esi, %rbx
movslq (%rax,%rbx,4), %rcx
movl (%rax,%rcx,4), %eax
movl $0x16, %edi
cmpl 0x10fd0(%rip), %eax     # 0x1973c
je 0x877b
movl $0x17, %edi
cmpl 0x10fbf(%rip), %eax     # 0x19738
jne 0x87e5
callq 0x7748
movq 0x10bb9(%rip), %rax     # 0x19340
movq 0x10bba(%rip), %rcx     # 0x19348
movslq (%rax,%rbx,4), %rdx
movslq (%rcx,%rdx,4), %rdx
movslq (%rax,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x7859
movq 0x10b93(%rip), %rax     # 0x19340
movq 0x10b94(%rip), %rcx     # 0x19348
movslq (%rax,%rbx,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 0x7859
movq 0x10b71(%rip), %rax     # 0x19348
movl (%rax,%rbx,4), %esi
cmpl $-0x1, %esi
jne 0x8750
popq %rbx
retq
leaq 0xb016(%rip), %rdi      # 0x13802
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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, %r14d
movl $0xd, %edi
callq 0x7748
movl 0x10f1b(%rip), %edi     # 0x19750
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
movl 0x10949(%rip), %esi     # 0x191a4
xorl %ebp, %ebp
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x10938(%rip)     # 0x191a4
xorl %edi, %edi
callq 0x7748
xorl %edi, %edi
callq 0x7748
movl 0x10ed0(%rip), %ebx     # 0x19750
movq 0x10ab9(%rip), %rax     # 0x19340
movq 0x10aba(%rip), %rcx     # 0x19348
movslq %r14d, %r15
movslq (%rcx,%r15,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x6008
movq 0x10aa4(%rip), %rcx     # 0x19348
cmpl $-0x1, %eax
je 0x88b7
xorl %ebp, %ebp
incl %ebp
cltq
movl (%rcx,%rax,4), %eax
cmpl $-0x1, %eax
jne 0x88ab
movq 0x10a82(%rip), %rax     # 0x19340
movslq (%rcx,%r15,4), %rdx
movl (%rax,%rdx,4), %eax
testl %eax, %eax
js 0x88df
movq 0x10a80(%rip), %rdx     # 0x19350
movl %eax, %eax
testb $0x9, (%rdx,%rax)
jne 0x88e4
movl (%rcx,%rax,4), %eax
testl %eax, %eax
jns 0x88d0
cmpl $-0x1, %eax
je 0x88f2
movl $0x19, %edi
callq 0x7748
decl %ebp
jmp 0x88fc
movl $0x18, %edi
callq 0x7748
movl %ebp, %edi
callq 0x7859
movl 0x10e27(%rip), %edi     # 0x19730
movq 0x10a38(%rip), %rax     # 0x19348
movslq (%rax,%r15,4), %rcx
movslq (%rax,%rcx,4), %rcx
movl (%rax,%rcx,4), %esi
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x30e7
movl %eax, %r14d
movl 0x10843(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x10834(%rip)     # 0x19170
movl %r14d, %edi
movl $0x1, %esi
callq 0x81e1
movl $0x1, %edi
callq 0x335c
movl $0x1a, %edi
callq 0x7748
callq 0x7977
movl 0x10de8(%rip), %esi     # 0x19750
movl %eax, %edi
callq 0x78ef
movq 0x109ca(%rip), %rax     # 0x19340
movq 0x109cb(%rip), %rcx     # 0x19348
movslq (%rcx,%r15,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %r14d
cmpl $-0x1, %r14d
je 0x89c1
movl $0x14, %edi
callq 0x7748
movq 0x109a8(%rip), %rax     # 0x19348
movl %r14d, %ecx
incl %ebp
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
cmpl $-0x1, %ecx
jne 0x89a3
movl %ebp, %edi
callq 0x7859
movl %r14d, %edi
callq 0x8744
jmp 0x89cb
movl $0x15, %edi
callq 0x7748
movl $0x13, %edi
callq 0x7748
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7859
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movl %esi, %ebx
movq 0x10952(%rip), %rax     # 0x19348
movslq %edi, %r14
movslq (%rax,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3d7b
movl %eax, %ebp
movl 0x1075e(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x1074f(%rip)     # 0x19170
movq 0x10918(%rip), %rax     # 0x19340
movslq %ebp, %r15
movl (%rax,%r15,4), %edi
xorl %esi, %esi
callq 0x81e1
movq 0x1090b(%rip), %rax     # 0x19348
movl (%rax,%r15,4), %ebp
movl $0x8, %edi
cmpl $-0x1, %ebp
je 0x8a71
callq 0x7748
movq 0x108e9(%rip), %rax     # 0x19340
movslq %ebp, %r15
movl (%rax,%r15,4), %edi
xorl %esi, %esi
callq 0x81e1
movl $0x33, %edi
callq 0x7748
jmp 0x8a36
callq 0x7748
movl $0x1, %edi
callq 0x335c
movq 0x108b9(%rip), %rax     # 0x19340
movq 0x108ba(%rip), %rcx     # 0x19348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x81e1
cmpl $0x1, %ebx
movl $0x2, %edi
sbbl $0x0, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7748
// File: /workspace/github_c_makefile_star2_O3/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 0x10882(%rip), %rax     # 0x19348
movslq %edi, %r15
movl (%rax,%r15,4), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3d7b
movl %eax, %r14d
movl 0x10690(%rip), %esi     # 0x19170
xorl %ebp, %ebp
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x1067f(%rip)     # 0x19170
cmpl $-0x1, %r14d
je 0x8b23
movq 0x10842(%rip), %rax     # 0x19340
movslq %r14d, %r14
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x81e1
movl $0x8, %edi
callq 0x7748
movq 0x1082b(%rip), %rax     # 0x19348
movl (%rax,%r14,4), %r14d
jmp 0x8af1
movl $0x1, %edi
callq 0x335c
movl $0xa, %edi
callq 0x7748
movq 0x1080a(%rip), %rax     # 0x19348
movl (%rax,%r15,4), %ecx
cmpl $-0x1, %ecx
je 0x8b56
xorl %ebp, %ebp
incl %ebp
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
cmpl $-0x1, %ecx
jne 0x8b49
movl %ebp, %edi
callq 0x7859
movq 0x107dc(%rip), %rax     # 0x19340
movl (%rax,%r15,4), %edi
xorl %esi, %esi
callq 0x81e1
cmpl $0x1, %ebx
movl $0x4, %edi
sbbl $0x0, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7748
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
movl $0x1, %edx
callq 0x5c5c
movq 0x10786(%rip), %rax     # 0x19340
movq 0x10787(%rip), %rcx     # 0x19348
movslq %ebp, %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x81e1
movl %ebx, %edi
callq 0x7748
cmpl $0x11, %ebx
jne 0x8bee
movl $0x3, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7748
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x2, %esi
movl $0x2, %edx
callq 0x5c5c
movq 0x1072d(%rip), %rax     # 0x19340
movq 0x1072e(%rip), %rcx     # 0x19348
movslq %ebp, %r14
movslq (%rcx,%r14,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x81e1
movl $0x8, %edi
callq 0x7748
movq 0x10700(%rip), %rax     # 0x19340
movq 0x10701(%rip), %rcx     # 0x19348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x81e1
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x7748
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x3, %esi
movl $0x3, %edx
callq 0x5c5c
movq 0x106c2(%rip), %rax     # 0x19340
movq 0x106c3(%rip), %rcx     # 0x19348
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 0x81e1
movl $0x8, %edi
callq 0x7748
movq 0x10691(%rip), %rax     # 0x19340
movq 0x10692(%rip), %rcx     # 0x19348
movslq (%rcx,%r14,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x81e1
movl $0x8, %edi
callq 0x7748
movq 0x10667(%rip), %rax     # 0x19340
movq 0x10668(%rip), %rcx     # 0x19348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x81e1
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x7748
// File: /workspace/github_c_makefile_star2_O3/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
xorl %esi, %esi
movl $0x1, %edx
callq 0x5c5c
movq 0x10635(%rip), %rax     # 0x19348
movslq %ebp, %rcx
movslq (%rax,%rcx,4), %rax
cmpq $-0x1, %rax
je 0x8d33
movq 0x10619(%rip), %rcx     # 0x19340
movl (%rcx,%rax,4), %edi
xorl %esi, %esi
callq 0x81e1
jmp 0x8d3d
movl $0x4a, %edi
callq 0x7748
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7748
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
movl $0x2, %edx
callq 0x5c5c
movq 0x105e0(%rip), %rax     # 0x19348
movslq %ebp, %r14
movslq (%rax,%r14,4), %rcx
movslq (%rax,%rcx,4), %rax
cmpq $-0x1, %rax
je 0x8dc8
cmpl $0x3d, %ebx
movl $0x3e, %ebp
cmovnel %ebx, %ebp
movq 0x105b5(%rip), %rcx     # 0x19340
movl (%rcx,%rax,4), %edi
xorl %esi, %esi
callq 0x81e1
movl %ebp, %ebx
movl $0x8, %edi
callq 0x7748
movq 0x10598(%rip), %rax     # 0x19340
movq 0x10599(%rip), %rcx     # 0x19348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x81e1
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x7748
leal -0x5e(%rbx), %eax
cmpl $0x3a, %eax
ja 0x8e23
movabsq $0x400000000000600, %rcx # imm = 0x400000000000600
btq %rax, %rcx
jb 0x8dfd
movabsq $0x4000000001, %rcx     # imm = 0x4000000001
btq %rax, %rcx
jae 0x8e09
movl 0x103be(%rip), %edi     # 0x191b4
callq 0x78a7
jmp 0x8d97
movl $0x62, %edi
callq 0x7748
jmp 0x8d97
cmpq $0x3, %rax
jne 0x8e23
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x78a7
movl $0x61, %ebx
jmp 0x8d97
cmpl $0x56, %ebx
je 0x8e46
cmpl $0x55, %ebx
jne 0x8d97
movl 0x10371(%rip), %edi     # 0x191a8
callq 0x78a7
movl $0x55, %ebx
jmp 0x8d97
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x78a7
movl $0x56, %ebx
jmp 0x8d97
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
movl %esi, %ebx
movq 0x104e1(%rip), %rax     # 0x19348
movslq %edi, %rcx
movslq (%rax,%rcx,4), %r14
cmpq $-0x1, %r14
je 0x8f0d
cmpl $-0x1, (%rax,%r14,4)
je 0x8f45
leal -0x59(%rbx), %eax
cmpl $0x37, %eax
ja 0x8e9b
movabsq $0x80000000400001, %rcx # imm = 0x80000000400001
btq %rax, %rcx
jb 0x8ea4
cmpl $0x32, %ebx
jne 0x8f91
movl %r14d, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3d7b
movl %eax, %ebp
movl 0x102b7(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x102a8(%rip)     # 0x19170
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x78a7
cmpl $-0x1, %ebp
je 0x8f30
movl $0x8, %edi
callq 0x7748
movq 0x10458(%rip), %rax     # 0x19340
movslq %ebp, %r14
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x81e1
movl $0x33, %edi
callq 0x7748
movq 0x10441(%rip), %rax     # 0x19348
movl (%rax,%r14,4), %ebp
jmp 0x8ed2
cmpl $0x6e, %ebx
jg 0x8f5b
cmpl $0x32, %ebx
je 0x8f87
cmpl $0x59, %ebx
je 0x8f87
cmpl $0x66, %ebx
jne 0x9007
movl 0x10281(%rip), %edi     # 0x191ac
jmp 0x9012
movl $0x1, %edi
callq 0x335c
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x7748
movq 0x103f4(%rip), %rax     # 0x19340
movl (%rax,%r14,4), %edi
xorl %esi, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x81e1
cmpl $0x6f, %ebx
je 0x8fff
cmpl $0x8c, %ebx
je 0x900c
cmpl $0x90, %ebx
jne 0x9007
movl 0x101fa(%rip), %edi     # 0x1917c
jmp 0x9012
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
jmp 0x9012
movl 0x101d9(%rip), %esi     # 0x19170
movl %r14d, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x101c9(%rip)     # 0x19170
movq 0x10392(%rip), %rax     # 0x19340
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x81e1
movq 0x10388(%rip), %rax     # 0x19348
movl (%rax,%r14,4), %ebp
cmpl $-0x1, %ebp
je 0x8ff1
movl $0x8, %edi
callq 0x7748
movq 0x10366(%rip), %rax     # 0x19340
movslq %ebp, %r14
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x81e1
movl %ebx, %edi
callq 0x7748
jmp 0x8fb9
movl $0x1, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x335c
movl 0x10173(%rip), %edi     # 0x19178
jmp 0x9012
popq %rbx
popq %r14
popq %rbp
retq
movl 0x1019e(%rip), %edi     # 0x191b0
popq %rbx
popq %r14
popq %rbp
jmp 0x78a7
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq 0x10325(%rip), %rax     # 0x19348
movslq %edi, %rbx
movslq (%rax,%rbx,4), %rsi
movslq (%rax,%rsi,4), %rcx
cmpq $-0x1, %rcx
je 0x90bd
cmpl $-0x1, (%rax,%rcx,4)
je 0x90bd
movq 0x102fb(%rip), %rax     # 0x19340
movl (%rax,%rsi,4), %edi
xorl %esi, %esi
callq 0x81e1
movl $0x8, %edi
callq 0x7748
movq 0x102e8(%rip), %rax     # 0x19348
movslq (%rax,%rbx,4), %rcx
movslq (%rax,%rcx,4), %rbx
movq 0x102d1(%rip), %rax     # 0x19340
movl (%rax,%rbx,4), %edi
xorl %esi, %esi
callq 0x81e1
movq 0x102c8(%rip), %rax     # 0x19348
movl (%rax,%rbx,4), %ebx
cmpl $-0x1, %ebx
je 0x90b2
movl $0x8, %edi
callq 0x7748
movq 0x102a7(%rip), %rax     # 0x19340
movslq %ebx, %rbx
movl (%rax,%rbx,4), %edi
xorl %esi, %esi
callq 0x81e1
movl $0x21, %edi
callq 0x7748
jmp 0x9079
movl $0xc, %edi
popq %rbx
jmp 0x7748
leaq 0xa760(%rip), %rdi      # 0x13824
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5c5c
cmpl $0x21, %ebx
jne 0x90f9
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x901b
movq 0x10248(%rip), %rax     # 0x19348
movslq %ebp, %r15
movslq (%rax,%r15,4), %r14
cmpl $-0x1, (%rax,%r14,4)
je 0x9182
leal -0x55(%rbx), %ebp
cmpl $-0x4, %ebp
ja 0x912b
movl $0x9, %edi
callq 0x7748
movq 0x10221(%rip), %rax     # 0x19348
movslq (%rax,%r15,4), %r14
movq 0x1020e(%rip), %rax     # 0x19340
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x81e1
movq 0x10204(%rip), %rax     # 0x19348
movl (%rax,%r14,4), %r14d
cmpl $-0x1, %r14d
je 0x9176
movl $0x8, %edi
callq 0x7748
movq 0x101e1(%rip), %rax     # 0x19340
movslq %r14d, %r14
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x81e1
movl %ebx, %edi
callq 0x7748
jmp 0x913d
cmpl $-0x4, %ebp
ja 0x91a8
movl $0xb, %edi
jmp 0x91cf
movl %ebx, %eax
andl $-0x2, %eax
cmpl $0x52, %eax
jne 0x91b3
movq 0x101ad(%rip), %rax     # 0x19340
movl (%rax,%r14,4), %edi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x81e1
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x54, %ebx
jne 0x91de
movq 0x10181(%rip), %rax     # 0x19340
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x81e1
movl $0x5a, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7748
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x78a7
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
xorl %edi, %edi
callq 0x27b0
testl %ebx, %ebx
jle 0x923c
movq 0x1014d(%rip), %rdx     # 0x19358
movq 0x10136(%rip), %rsi     # 0x19348
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
movl %ebx, %esi
xorl %edi, %edi
movb (%rcx,%rdi), %r8b
movb %r8b, (%rdx,%rdi)
incq %rdi
cmpq %rdi, %rsi
jne 0x922c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %ebx
movl $0xffffffef, %edi       # imm = 0xFFFFFFEF
movl $0x401, %esi            # imm = 0x401
callq 0x32cf
movq 0x100e9(%rip), %rcx     # 0x19348
movslq %eax, %r14
movslq (%rcx,%r14,4), %rdi
shlq $0x2, %rdi
addq 0x100e7(%rip), %rdi     # 0x19358
movl $0x401, %edx            # imm = 0x401
xorl %esi, %esi
callq 0x20b0
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
movl %r14d, %esi
movl $0x1, %edx
callq 0x30e7
movl %eax, 0xff0b(%rip)      # 0x191a0
movl $0x0, 0x104b1(%rip)     # 0x19750
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, 0xfefa(%rip)      # 0x191a4
movl %ebx, %edi
xorl %esi, %esi
callq 0x81e1
movl $0x10, %edi
callq 0x7748
movq 0x10084(%rip), %rax     # 0x19348
movslq 0xfed5(%rip), %rcx      # 0x191a0
movl (%rax,%rcx,4), %edi
movl 0x1047c(%rip), %esi     # 0x19750
callq 0x91f2
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
movl %ebp, 0xfeb0(%rip)      # 0x191a0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebx
testl %esi, %esi
js 0x9391
movq 0x10043(%rip), %rcx     # 0x19350
movl %ebx, %eax
testb $0x1, (%rcx,%rax)
je 0x9391
movq 0x10024(%rip), %rcx     # 0x19340
cmpl $-0xd, (%rcx,%rax,4)
jne 0x9391
movq 0x1001f(%rip), %rax     # 0x19348
movslq 0xfe0c(%rip), %rdx      # 0x1913c
movslq (%rax,%rdx,4), %rdx
shlq $0x2, %rdx
addq 0x10019(%rip), %rdx     # 0x19358
movslq %edi, %rsi
movl (%rdx,%rsi,4), %edi
movl 0xfe6d(%rip), %edx      # 0x191b8
cmpl $-0x1, %edx
je 0x936b
movslq %edx, %rsi
movslq (%rcx,%rsi,4), %rdx
cmpl %edi, (%rcx,%rdx,4)
je 0x9361
movl (%rax,%rsi,4), %edx
jmp 0x934b
cmpl $-0x1, %edx
je 0x936b
movl %ebx, (%rax,%rdx,4)
jmp 0x9389
movl %ebx, %esi
xorl %edx, %edx
callq 0x30e7
movl 0xfe3e(%rip), %esi      # 0x191b8
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0xfe2f(%rip)      # 0x191b8
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x9fb3(%rip), %rsi      # 0x1334b
leaq 0xa4ba(%rip), %rdx      # 0x13859
leaq 0xa476(%rip), %rcx      # 0x1381c
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: 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 0xfda2(%rip), %esi      # 0x19170
xorl %edx, %edx
callq 0x30e7
movl %eax, 0xfd95(%rip)      # 0x19170
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0xfd7b(%rip)      # 0x19170
movl %ebx, %eax
testl %ebx, %ebx
js 0x9450
movl %ebx, %eax
movq 0xff4c(%rip), %rcx      # 0x19350
movl %eax, %r15d
testb $0x9, (%rcx,%r15)
jne 0x9484
movq 0xff2b(%rip), %rax      # 0x19340
movl (%rax,%r15,4), %edi
movl %ebp, %esi
callq 0x9492
movl %eax, %edi
movl %r14d, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %r14d
movq 0xff0a(%rip), %rax      # 0x19340
movslq 0xfd33(%rip), %rcx      # 0x19170
movl %r14d, (%rax,%rcx,4)
movq 0xff00(%rip), %rax      # 0x19348
movl (%rax,%r15,4), %eax
testl %eax, %eax
jns 0x93fd
cmpl $-0x1, %eax
jne 0x9484
movl $0x1, %edi
callq 0x335c
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3dc8
movl %eax, %ebx
movl $0x1, %edi
callq 0x335c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa2df(%rip), %rdi      # 0x1376a
movl %ebx, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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, %r14d
movl %edi, %ebp
movl 0xfa7d(%rip), %esi      # 0x19170
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %eax, 0xfa66(%rip)      # 0x19170
cmpl $-0x1, %ebp
sete %al
cmpl $-0x1, %r14d
sete %cl
orb %al, %cl
jne 0x9774
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq 0xfc19(%rip), %rax      # 0x19340
movslq %ebp, %r15
movl (%rax,%r15,4), %edi
movslq %r14d, %r14
movl (%rax,%r14,4), %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebx
movq 0xfbf0(%rip), %rax      # 0x19340
movslq 0xfa19(%rip), %rcx      # 0x19170
movl %ebx, (%rax,%rcx,4)
movq 0xfbe7(%rip), %rcx      # 0x19348
movl (%rcx,%r15,4), %ebp
cmpl $-0x1, %ebp
je 0x9774
movl (%rcx,%r14,4), %r14d
cmpl $-0x1, %r14d
jne 0x9727
movl $0x1, %edi
callq 0x335c
movl %ebx, %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: expanddef
cell expanddef(cell x) {
	char	b[100];
	cell	n;

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq 0xf93b(%rip), %rcx      # 0x19340
movq 0xf93c(%rip), %rax      # 0x19348
movslq %edi, %r14
movslq (%rax,%r14,4), %rdx
movslq (%rcx,%rdx,4), %rsi
testq %rsi, %rsi
js 0x9abb
movq 0xf929(%rip), %rdi      # 0x19350
testb $0x9, (%rdi,%rsi)
jne 0x9abb
movl (%rax,%rsi,4), %ebx
movl (%rax,%rdx,4), %edi
callq 0x9794
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
movl 0xfcdb(%rip), %edi      # 0x19728
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movq 0xf8d5(%rip), %rcx      # 0x19340
movq 0xf8d6(%rip), %rdx      # 0x19348
movslq (%rdx,%r14,4), %rdx
movslq (%rcx,%rdx,4), %rdx
movl (%rcx,%rdx,4), %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
movq 0xf8b3(%rip), %rcx      # 0x19340
movl (%rcx,%r14,4), %ecx
cmpl 0xfea9(%rip), %ecx      # 0x19940
leaq 0xfc7e(%rip), %rcx      # 0x1971c
leaq 0xfc87(%rip), %rdx      # 0x1972c
cmoveq %rcx, %rdx
movl (%rdx), %edi
movl %eax, %esi
xorl %edx, %edx
addq $0x68, %rsp
popq %rbx
popq %r14
jmp 0x30e7
movslq (%rcx,%r14,4), %rcx
movslq (%rax,%rcx,4), %rdx
shlq $0x2, %rdx
addq 0xf88a(%rip), %rdx      # 0x19358
leaq 0x9d8a(%rip), %rsi      # 0x1385f
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq 0xf857(%rip), %rax      # 0x19340
movq 0xf858(%rip), %rcx      # 0x19348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %esi
movq %rbx, %rdi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: eval
cell eval(cell x, int r) {
	Tmp = x;
	if (r) begin_rec();
	protect(x);
	Tmp = NIL;
	x = expand(x, 1);  car(Protected) = x;
	syncheck(x, 1);
	x = clsconv(x);    car(Protected) = x;
	x = compile(x);    car(Protected) = x;
	x = interpret(x);
	unprot(1);
	if (r) end_rec();
	return x;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl %edi, 0xf668(%rip)      # 0x19174
testl %esi, %esi
je 0x9b15
callq 0xcdcb
movl 0xf655(%rip), %esi      # 0x19170
movl %ebp, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0xf646(%rip)      # 0x19170
movl $0xffffffff, 0xf640(%rip) # imm = 0xFFFFFFFF
movl %ebp, %edi
movl $0x1, %esi
callq 0x9492
movl %eax, %ebp
movq 0xf7f7(%rip), %rax      # 0x19340
movslq 0xf620(%rip), %rcx      # 0x19170
movl %ebp, (%rax,%rcx,4)
movl %ebp, %edi
movl $0x1, %esi
callq 0x5d26
movl %ebp, %edi
callq 0x7447
movq 0xf7d3(%rip), %rcx      # 0x19340
movslq 0xf5fc(%rip), %rdx      # 0x19170
movl %eax, (%rcx,%rdx,4)
movl %eax, %edi
callq 0x9243
movq 0xf7bb(%rip), %rcx      # 0x19340
movslq 0xf5e4(%rip), %rdx      # 0x19170
movl %eax, (%rcx,%rdx,4)
movl %eax, %edi
callq 0x10a75
movl %eax, %ebp
movl $0x1, %edi
callq 0x335c
testl %ebx, %ebx
je 0x9bab
callq 0xcead
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: add
cell add(cell x, cell y) {
	if (!fixp(x)) expect("+", "fixnum", x);
	if (!fixp(y)) expect("+", "fixnum", y);
	if (add_ovfl(fixval(x), fixval(y))) fixover("+", x, y);
	return mkfix(fixval(x) + fixval(y));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edi, %ebp
testl %edi, %edi
js 0x9cbc
movq 0xf73d(%rip), %rdx      # 0x19350
movl %ebp, %eax
testb $0x1, (%rdx,%rax)
je 0x9cbc
movq 0xf71a(%rip), %rcx      # 0x19340
cmpl $-0xe, (%rcx,%rax,4)
jne 0x9cbc
movl %esi, %ebx
testl %esi, %esi
js 0x9ce8
movl %ebx, %esi
testb $0x1, (%rdx,%rsi)
je 0x9ce8
cmpl $-0xe, (%rcx,%rsi,4)
jne 0x9ce8
movq 0xf6f1(%rip), %rdx      # 0x19348
movslq (%rdx,%rsi,4), %rsi
movl (%rcx,%rsi,4), %edi
testl %edi, %edi
jle 0x9c7a
movslq (%rdx,%rax,4), %rax
movl (%rcx,%rax,4), %eax
movl %edi, %ecx
xorl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpl %ecx, %eax
jle 0x9c92
jmp 0x9d14
movslq (%rdx,%rax,4), %rax
movl (%rcx,%rax,4), %eax
je 0x9c92
movl $0x80000000, %ecx       # imm = 0x80000000
subl %edi, %ecx
cmpl %ecx, %eax
jl 0x9d14
addl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x30e7
leaq 0x9688(%rip), %rsi      # 0x1334b
leaq 0x9be3(%rip), %rdx      # 0x138ad
leaq 0x9bde(%rip), %rcx      # 0x138af
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2643
leaq 0x965c(%rip), %rsi      # 0x1334b
leaq 0x9bb7(%rip), %rdx      # 0x138ad
leaq 0x9bb2(%rip), %rcx      # 0x138af
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x2643
leaq 0x9b92(%rip), %rdi      # 0x138ad
movl %ebp, %esi
movl %ebx, %edx
callq 0x9bb4
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: xsub
cell xsub(cell x, cell y) {
	if (!fixp(x)) expect("-", "fixnum", x);
	if (!fixp(y)) expect("-", "fixnum", y);
	if (sub_ovfl(fixval(y), fixval(x))) fixover("+", y, x);
	return mkfix(fixval(y) - fixval(x));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edi, %ebx
testl %edi, %edi
js 0x9dec
movl %esi, %ebp
movq 0xf611(%rip), %rsi      # 0x19350
movl %ebx, %eax
testb $0x1, (%rsi,%rax)
je 0x9dec
movq 0xf5ee(%rip), %rcx      # 0x19340
cmpl $-0xe, (%rcx,%rax,4)
jne 0x9dec
testl %ebp, %ebp
js 0x9e18
movl %ebp, %edx
testb $0x1, (%rsi,%rdx)
je 0x9e18
cmpl $-0xe, (%rcx,%rdx,4)
jne 0x9e18
movq 0xf5c7(%rip), %rsi      # 0x19348
movslq (%rsi,%rax,4), %rax
movl (%rcx,%rax,4), %eax
testl %eax, %eax
js 0x9db1
movslq (%rsi,%rdx,4), %rdx
movl (%rcx,%rdx,4), %edi
je 0x9dc2
movl %eax, %ecx
orl $0x80000000, %ecx       # imm = 0x80000000
cmpl %ecx, %edi
jge 0x9dc2
leaq 0x9b05(%rip), %rdi      # 0x138ad
movl %ebp, %esi
movl %ebx, %edx
callq 0x9bb4
movslq (%rsi,%rdx,4), %rdx
movl (%rcx,%rdx,4), %edi
leal 0x7fffffff(%rax), %ecx
cmpl %ecx, %edi
jg 0x9da1
subl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x30e7
leaq 0x9558(%rip), %rsi      # 0x1334b
leaq 0x9abc(%rip), %rdx      # 0x138b6
leaq 0x9aae(%rip), %rcx      # 0x138af
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x2643
leaq 0x952c(%rip), %rsi      # 0x1334b
leaq 0x9a90(%rip), %rdx      # 0x138b6
leaq 0x9a82(%rip), %rcx      # 0x138af
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: mul
cell mul(cell x, cell y) {
	int	a, b;

	if (!fixp(x)) expect("*", "fixnum", x);
	if (!fixp(y)) expect("*", "fixnum", y);
	a = fixval(x);
	b = fixval(y);
	/*
	 * Overflow of a*b is undefined, sooo
	 */
	/* Shortcuts, also protect later division */
	if (0 == a || 0 == b) return Zero;
	if (1 == a) return y;
	if (1 == b) return x;
	/* abs(INT_MIN) is undefined using two's complement, so */
	if (INT_MIN == a || INT_MIN == b) fixover("*", x, y);
	/* Catch the rest */
	/* Bug: result may not be INT_MIN */
	if (abs(a) > INT_MAX / abs(b)) fixover("*", x, y);
	return mkfix(a * b);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edi, %ebp
testl %edi, %edi
js 0x9f38
movq 0xf4f3(%rip), %rdx      # 0x19350
movl %ebp, %ecx
testb $0x1, (%rdx,%rcx)
je 0x9f38
movq 0xf4d0(%rip), %rax      # 0x19340
cmpl $-0xe, (%rax,%rcx,4)
jne 0x9f38
movl %esi, %ebx
testl %esi, %esi
js 0x9f64
movl %ebx, %esi
testb $0x1, (%rdx,%rsi)
je 0x9f64
cmpl $-0xe, (%rax,%rsi,4)
jne 0x9f64
movq 0xf4a7(%rip), %rdx      # 0x19348
movslq (%rdx,%rcx,4), %rcx
movl (%rax,%rcx,4), %ecx
testl %ecx, %ecx
je 0x9ec5
movslq (%rdx,%rsi,4), %rdx
movl (%rax,%rdx,4), %edi
testl %edi, %edi
je 0x9ec5
cmpl $0x1, %ecx
je 0x9ecb
cmpl $0x1, %edi
jne 0x9ed6
movl %ebp, %ebx
jmp 0x9ecb
movl 0xf2e1(%rip), %ebx      # 0x191ac
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl %ecx, %eax
negl %eax
jo 0x9f90
movl %edi, %eax
negl %eax
jo 0x9f90
movl %ecx, %esi
negl %esi
cmovsl %ecx, %esi
movl %edi, %r8d
negl %r8d
cmovsl %edi, %r8d
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
divl %r8d
cmpl %eax, %esi
ja 0x9f90
imull %ecx, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x30e7
leaq 0x940c(%rip), %rsi      # 0x1334b
leaq 0x9feb(%rip), %rdx      # 0x13f31
leaq 0x9962(%rip), %rcx      # 0x138af
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2643
leaq 0x93e0(%rip), %rsi      # 0x1334b
leaq 0x9fbf(%rip), %rdx      # 0x13f31
leaq 0x9936(%rip), %rcx      # 0x138af
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x2643
leaq 0x9f9a(%rip), %rdi      # 0x13f31
movl %ebp, %esi
movl %ebx, %edx
callq 0x9bb4
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: intdiv
cell intdiv(cell x, cell y) {
	if (!fixp(x)) expect("div", "fixnum", x);
	if (!fixp(y)) expect("div", "fixnum", y);
	if (0 == fixval(y)) error("div: divide by zero", UNDEF);
	return mkfix(fixval(x) / fixval(y));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edi, %ebp
testl %edi, %edi
js 0xa02c
movq 0xf39b(%rip), %rdx      # 0x19350
movl %ebp, %eax
testb $0x1, (%rdx,%rax)
je 0xa02c
movq 0xf37c(%rip), %rcx      # 0x19340
cmpl $-0xe, (%rcx,%rax,4)
jne 0xa02c
movl %esi, %ebx
testl %esi, %esi
js 0xa058
movl %ebx, %esi
testb $0x1, (%rdx,%rsi)
je 0xa058
cmpl $-0xe, (%rcx,%rsi,4)
jne 0xa058
movq 0xf35f(%rip), %rdx      # 0x19348
movslq (%rdx,%rsi,4), %rsi
movl (%rcx,%rsi,4), %esi
testl %esi, %esi
je 0xa084
movslq (%rdx,%rax,4), %rax
movl (%rcx,%rax,4), %eax
cltd
idivl %esi
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x30e7
leaq 0x9318(%rip), %rsi      # 0x1334b
leaq 0x987e(%rip), %rdx      # 0x138b8
leaq 0x986e(%rip), %rcx      # 0x138af
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2643
leaq 0x92ec(%rip), %rsi      # 0x1334b
leaq 0x9852(%rip), %rdx      # 0x138b8
leaq 0x9842(%rip), %rcx      # 0x138af
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x2643
leaq 0x9831(%rip), %rdi      # 0x138bc
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: intrem
cell intrem(cell x, cell y) {
	if (!fixp(x)) expect("rem", "fixnum", x);
	if (!fixp(y)) expect("rem", "fixnum", y);
	if (0 == fixval(y)) error("rem: divide by zero", UNDEF);
	return mkfix(fixval(x) % fixval(y));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edi, %ebp
testl %edi, %edi
js 0xa121
movq 0xf2a6(%rip), %rdx      # 0x19350
movl %ebp, %eax
testb $0x1, (%rdx,%rax)
je 0xa121
movq 0xf287(%rip), %rcx      # 0x19340
cmpl $-0xe, (%rcx,%rax,4)
jne 0xa121
movl %esi, %ebx
testl %esi, %esi
js 0xa14d
movl %ebx, %esi
testb $0x1, (%rdx,%rsi)
je 0xa14d
cmpl $-0xe, (%rcx,%rsi,4)
jne 0xa14d
movq 0xf26a(%rip), %rdx      # 0x19348
movslq (%rdx,%rsi,4), %rsi
movl (%rcx,%rsi,4), %esi
testl %esi, %esi
je 0xa179
movslq (%rdx,%rax,4), %rax
movl (%rcx,%rax,4), %eax
cltd
idivl %esi
movl %edx, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x30e7
leaq 0x9223(%rip), %rsi      # 0x1334b
leaq 0x97a1(%rip), %rdx      # 0x138d0
leaq 0x9779(%rip), %rcx      # 0x138af
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2643
leaq 0x91f7(%rip), %rsi      # 0x1334b
leaq 0x9775(%rip), %rdx      # 0x138d0
leaq 0x974d(%rip), %rcx      # 0x138af
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x2643
leaq 0x9754(%rip), %rdi      # 0x138d4
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: memcmp_ci
int memcmp_ci(char *a, char *b, int k) {
	int	i, d;

	for (i=0; i<k; i++) {
		d = tolower(a[i]) - tolower(b[i]);
		if (d) return d;
	}
	return 0;
}

// Assembly:
testl %edx, %edx
jle 0xac41
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2220
movq (%rax), %rcx
movl %ebp, %edx
xorl %esi, %esi
movsbq (%r14,%rsi), %rax
movl (%rcx,%rax,4), %eax
movsbq (%rbx,%rsi), %rdi
subl (%rcx,%rdi,4), %eax
jne 0xac3c
incq %rsi
cmpq %rsi, %rdx
jne 0xac20
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
retq