LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x10caf(%rip), %rax     # 0x19340
movq 0x10cb0(%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 0x82e0
movq 0x10c8c(%rip), %rax     # 0x19340
movq 0x10c8d(%rip), %rcx     # 0x19348
movslq (%rcx,%r14,4), %rcx
movslq (%rax,%rcx,4), %rcx
movl (%rax,%rcx,4), %eax
movl $0x1c, %edi
cmpl 0x11077(%rip), %eax     # 0x19748
je 0x86e0
movl $0x1b, %edi
cmpl 0x11066(%rip), %eax     # 0x19744
jne 0x8716
callq 0x7831
movq 0x10c54(%rip), %rax     # 0x19340
movq 0x10c55(%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 0x7940
leaq 0xb096(%rip), %rdi      # 0x137b3
movl %ebx, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0x10c0d(%rip), %rax     # 0x19340
movq 0x10c0e(%rip), %rcx     # 0x19348
movslq %edi, %r14
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x82e0
cmpl $0x1, %ebp
movl $0xf, %edi
sbbl $0x0, %edi
callq 0x7831
movl 0x10fef(%rip), %edi     # 0x19750
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
movl 0x10a1d(%rip), %esi     # 0x191a4
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x10a0e(%rip)     # 0x191a4
xorl %edi, %edi
callq 0x7831
xorl %edi, %edi
callq 0x7831
movq 0x10b95(%rip), %rax     # 0x19340
movq 0x10b96(%rip), %rcx     # 0x19348
movslq (%rcx,%r14,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl %ebx, %esi
callq 0x82e0
movq 0x10b7d(%rip), %rax     # 0x19348
movslq (%rax,%r14,4), %rcx
movslq (%rax,%rcx,4), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x886b
movl $0xd, %edi
callq 0x7831
movl 0x10f63(%rip), %edi     # 0x19750
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
movl 0x10991(%rip), %esi     # 0x191a4
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x10982(%rip)     # 0x191a4
xorl %edi, %edi
callq 0x7831
xorl %edi, %edi
callq 0x7831
callq 0x7aa3
callq 0x7a5e
movl 0x10f10(%rip), %esi     # 0x19750
movl %eax, %edi
callq 0x79d6
movq 0x10af2(%rip), %rax     # 0x19340
movq 0x10af3(%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 0x82e0
callq 0x7a5e
movl 0x10eda(%rip), %esi     # 0x19750
movl %eax, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x79d6
// File: /workspace/github_c_makefile_star2_O1/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 0x8920
movl %edi, %esi
movq 0x10aac(%rip), %rax     # 0x19340
movslq %esi, %rbx
movslq (%rax,%rbx,4), %rcx
movl (%rax,%rcx,4), %eax
movl $0x16, %edi
cmpl 0x10e93(%rip), %eax     # 0x1973c
je 0x88b8
movl $0x17, %edi
cmpl 0x10e82(%rip), %eax     # 0x19738
jne 0x8922
callq 0x7831
movq 0x10a7c(%rip), %rax     # 0x19340
movq 0x10a7d(%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 0x7940
movq 0x10a56(%rip), %rax     # 0x19340
movq 0x10a57(%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 0x7940
movq 0x10a34(%rip), %rax     # 0x19348
movl (%rax,%rbx,4), %esi
cmpl $-0x1, %esi
jne 0x888d
popq %rbx
retq
leaq 0xaea9(%rip), %rdi      # 0x137d2
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0x7831
movl 0x10dde(%rip), %edi     # 0x19750
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
movl 0x1080c(%rip), %esi     # 0x191a4
xorl %ebp, %ebp
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x107fb(%rip)     # 0x191a4
xorl %edi, %edi
callq 0x7831
xorl %edi, %edi
callq 0x7831
movl 0x10d93(%rip), %ebx     # 0x19750
movq 0x1097c(%rip), %rax     # 0x19340
movq 0x1097d(%rip), %rcx     # 0x19348
movslq %r14d, %r15
movslq (%rcx,%r15,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x6086
cmpl $-0x1, %eax
je 0x89f4
xorl %ebp, %ebp
movq 0x10960(%rip), %rcx     # 0x19348
incl %ebp
cltq
movl (%rcx,%rax,4), %eax
cmpl $-0x1, %eax
jne 0x89e8
movq 0x10945(%rip), %rax     # 0x19340
movq 0x10946(%rip), %rcx     # 0x19348
movslq (%rcx,%r15,4), %rdx
movl (%rax,%rdx,4), %eax
testl %eax, %eax
js 0x8a23
movq 0x1093c(%rip), %rdx     # 0x19350
movl %eax, %esi
testb $0x9, (%rdx,%rsi)
jne 0x8a23
movl (%rcx,%rsi,4), %eax
testl %eax, %eax
jns 0x8a14
cmpl $-0x1, %eax
je 0x8a36
movl $0x19, %edi
callq 0x7831
decl %ebp
jmp 0x8a40
movl $0x18, %edi
callq 0x7831
movl %ebp, %edi
callq 0x7940
movl 0x10ce3(%rip), %edi     # 0x19730
movq 0x108f4(%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 0x3162
movl %eax, %r14d
movl 0x106ff(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x106f0(%rip)     # 0x19170
movl %r14d, %edi
movl $0x1, %esi
callq 0x82e0
movl $0x1, %edi
callq 0x33d7
movl $0x1a, %edi
callq 0x7831
callq 0x7a5e
movl 0x10ca4(%rip), %esi     # 0x19750
movl %eax, %edi
callq 0x79d6
movq 0x10886(%rip), %rax     # 0x19340
movq 0x10887(%rip), %rcx     # 0x19348
movslq (%rcx,%r15,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %r14d
cmpl $-0x1, %r14d
je 0x8b05
movl $0x14, %edi
callq 0x7831
movq 0x10864(%rip), %rax     # 0x19348
movl %r14d, %ecx
incl %ebp
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
cmpl $-0x1, %ecx
jne 0x8ae7
movl %ebp, %edi
callq 0x7940
movl %r14d, %edi
callq 0x8881
jmp 0x8b0f
movl $0x15, %edi
callq 0x7831
movl $0x13, %edi
callq 0x7831
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7940
// File: /workspace/github_c_makefile_star2_O1/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 0x1080e(%rip), %rax     # 0x19348
movslq %edi, %r14
movslq (%rax,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3e21
movl %eax, %ebp
movl 0x1061a(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x1060b(%rip)     # 0x19170
movq 0x107d4(%rip), %rax     # 0x19340
movslq %ebp, %r15
movl (%rax,%r15,4), %edi
xorl %esi, %esi
callq 0x82e0
movq 0x107c7(%rip), %rax     # 0x19348
movl (%rax,%r15,4), %ebp
movl $0x8, %edi
cmpl $-0x1, %ebp
je 0x8bb5
callq 0x7831
movq 0x107a5(%rip), %rax     # 0x19340
movslq %ebp, %r15
movl (%rax,%r15,4), %edi
xorl %esi, %esi
callq 0x82e0
movl $0x33, %edi
callq 0x7831
jmp 0x8b7a
callq 0x7831
movl $0x1, %edi
callq 0x33d7
movq 0x10775(%rip), %rax     # 0x19340
movq 0x10776(%rip), %rcx     # 0x19348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x82e0
cmpl $0x1, %ebx
movl $0x2, %edi
sbbl $0x0, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7831
// File: /workspace/github_c_makefile_star2_O1/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 0x1073e(%rip), %rax     # 0x19348
movslq %edi, %r15
movl (%rax,%r15,4), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3e21
movl %eax, %r14d
movl 0x1054c(%rip), %esi     # 0x19170
xorl %ebp, %ebp
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x1053b(%rip)     # 0x19170
cmpl $-0x1, %r14d
je 0x8c67
movq 0x106fe(%rip), %rax     # 0x19340
movslq %r14d, %r14
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x82e0
movl $0x8, %edi
callq 0x7831
movq 0x106e7(%rip), %rax     # 0x19348
movl (%rax,%r14,4), %r14d
jmp 0x8c35
movl $0x1, %edi
callq 0x33d7
movl $0xa, %edi
callq 0x7831
movq 0x106c6(%rip), %rax     # 0x19348
movl (%rax,%r15,4), %ecx
cmpl $-0x1, %ecx
je 0x8c9a
xorl %ebp, %ebp
incl %ebp
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
cmpl $-0x1, %ecx
jne 0x8c8d
movl %ebp, %edi
callq 0x7940
movq 0x10698(%rip), %rax     # 0x19340
movl (%rax,%r15,4), %edi
xorl %esi, %esi
callq 0x82e0
cmpl $0x1, %ebx
movl $0x4, %edi
sbbl $0x0, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7831
// File: /workspace/github_c_makefile_star2_O1/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 0x5cc5
movq 0x10642(%rip), %rax     # 0x19340
movq 0x10643(%rip), %rcx     # 0x19348
movslq %ebp, %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x82e0
movl %ebx, %edi
callq 0x7831
cmpl $0x11, %ebx
jne 0x8d32
movl $0x3, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7831
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5cc5
movq 0x105e9(%rip), %rax     # 0x19340
movq 0x105ea(%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 0x82e0
movl $0x8, %edi
callq 0x7831
movq 0x105bc(%rip), %rax     # 0x19340
movq 0x105bd(%rip), %rcx     # 0x19348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x82e0
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x7831
// File: /workspace/github_c_makefile_star2_O1/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 0x5cc5
movq 0x1057e(%rip), %rax     # 0x19340
movq 0x1057f(%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 0x82e0
movl $0x8, %edi
callq 0x7831
movq 0x1054d(%rip), %rax     # 0x19340
movq 0x1054e(%rip), %rcx     # 0x19348
movslq (%rcx,%r14,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x82e0
movl $0x8, %edi
callq 0x7831
movq 0x10523(%rip), %rax     # 0x19340
movq 0x10524(%rip), %rcx     # 0x19348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x82e0
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x7831
// File: /workspace/github_c_makefile_star2_O1/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 0x5cc5
movq 0x104f1(%rip), %rax     # 0x19348
movslq %ebp, %rcx
movslq (%rax,%rcx,4), %rax
cmpq $-0x1, %rax
je 0x8e77
movq 0x104d5(%rip), %rcx     # 0x19340
movl (%rcx,%rax,4), %edi
xorl %esi, %esi
callq 0x82e0
jmp 0x8e81
movl $0x4a, %edi
callq 0x7831
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7831
// File: /workspace/github_c_makefile_star2_O1/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 0x5cc5
movq 0x1049c(%rip), %rax     # 0x19348
movslq %ebp, %r14
movslq (%rax,%r14,4), %rcx
movslq (%rax,%rcx,4), %rax
cmpq $-0x1, %rax
je 0x8f0c
cmpl $0x3d, %ebx
movl $0x3e, %ebp
cmovnel %ebx, %ebp
movq 0x10471(%rip), %rcx     # 0x19340
movl (%rcx,%rax,4), %edi
xorl %esi, %esi
callq 0x82e0
movl %ebp, %ebx
movl $0x8, %edi
callq 0x7831
movq 0x10454(%rip), %rax     # 0x19340
movq 0x10455(%rip), %rcx     # 0x19348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x82e0
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x7831
leal -0x5e(%rbx), %eax
cmpl $0x3a, %eax
ja 0x8f67
movabsq $0x400000000000600, %rcx # imm = 0x400000000000600
btq %rax, %rcx
jb 0x8f41
movabsq $0x4000000001, %rcx     # imm = 0x4000000001
btq %rax, %rcx
jae 0x8f4d
movl 0x1027a(%rip), %edi     # 0x191b4
callq 0x798e
jmp 0x8edb
movl $0x62, %edi
callq 0x7831
jmp 0x8edb
cmpq $0x3, %rax
jne 0x8f67
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x798e
movl $0x61, %ebx
jmp 0x8edb
cmpl $0x56, %ebx
je 0x8f8a
cmpl $0x55, %ebx
jne 0x8edb
movl 0x1022d(%rip), %edi     # 0x191a8
callq 0x798e
movl $0x55, %ebx
jmp 0x8edb
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x798e
movl $0x56, %ebx
jmp 0x8edb
// File: /workspace/github_c_makefile_star2_O1/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 0x1039d(%rip), %rax     # 0x19348
movslq %edi, %rcx
movslq (%rax,%rcx,4), %r14
cmpq $-0x1, %r14
je 0x9051
cmpl $-0x1, (%rax,%r14,4)
je 0x9089
leal -0x59(%rbx), %eax
cmpl $0x37, %eax
ja 0x8fdf
movabsq $0x80000000400001, %rcx # imm = 0x80000000400001
btq %rax, %rcx
jb 0x8fe8
cmpl $0x32, %ebx
jne 0x90d5
movl %r14d, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3e21
movl %eax, %ebp
movl 0x10173(%rip), %esi     # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x10164(%rip)     # 0x19170
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x798e
cmpl $-0x1, %ebp
je 0x9074
movl $0x8, %edi
callq 0x7831
movq 0x10314(%rip), %rax     # 0x19340
movslq %ebp, %r14
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x82e0
movl $0x33, %edi
callq 0x7831
movq 0x102fd(%rip), %rax     # 0x19348
movl (%rax,%r14,4), %ebp
jmp 0x9016
cmpl $0x6e, %ebx
jg 0x909f
cmpl $0x32, %ebx
je 0x90cb
cmpl $0x59, %ebx
je 0x90cb
cmpl $0x66, %ebx
jne 0x914b
movl 0x1013d(%rip), %edi     # 0x191ac
jmp 0x9156
movl $0x1, %edi
callq 0x33d7
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x7831
movq 0x102b0(%rip), %rax     # 0x19340
movl (%rax,%r14,4), %edi
xorl %esi, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x82e0
cmpl $0x6f, %ebx
je 0x9143
cmpl $0x8c, %ebx
je 0x9150
cmpl $0x90, %ebx
jne 0x914b
movl 0x100b6(%rip), %edi     # 0x1917c
jmp 0x9156
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
jmp 0x9156
movl 0x10095(%rip), %esi     # 0x19170
movl %r14d, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x10085(%rip)     # 0x19170
movq 0x1024e(%rip), %rax     # 0x19340
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x82e0
movq 0x10244(%rip), %rax     # 0x19348
movl (%rax,%r14,4), %ebp
cmpl $-0x1, %ebp
je 0x9135
movl $0x8, %edi
callq 0x7831
movq 0x10222(%rip), %rax     # 0x19340
movslq %ebp, %r14
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x82e0
movl %ebx, %edi
callq 0x7831
jmp 0x90fd
movl $0x1, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x33d7
movl 0x1002f(%rip), %edi     # 0x19178
jmp 0x9156
popq %rbx
popq %r14
popq %rbp
retq
movl 0x1005a(%rip), %edi     # 0x191b0
popq %rbx
popq %r14
popq %rbp
jmp 0x798e
// File: /workspace/github_c_makefile_star2_O1/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 0x101e1(%rip), %rax     # 0x19348
movslq %edi, %rbx
movslq (%rax,%rbx,4), %rsi
movslq (%rax,%rsi,4), %rcx
cmpq $-0x1, %rcx
je 0x9210
cmpl $-0x1, (%rax,%rcx,4)
je 0x9210
movq 0x101b3(%rip), %rax     # 0x19340
movq 0x101b4(%rip), %rcx     # 0x19348
movslq (%rcx,%rbx,4), %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x82e0
movl $0x8, %edi
callq 0x7831
movq 0x10195(%rip), %rax     # 0x19348
movslq (%rax,%rbx,4), %rcx
movslq (%rax,%rcx,4), %rbx
movq 0x1017e(%rip), %rax     # 0x19340
movl (%rax,%rbx,4), %edi
xorl %esi, %esi
callq 0x82e0
movq 0x10175(%rip), %rax     # 0x19348
movl (%rax,%rbx,4), %ebx
cmpl $-0x1, %ebx
je 0x9205
movl $0x8, %edi
callq 0x7831
movq 0x10154(%rip), %rax     # 0x19340
movslq %ebx, %rbx
movl (%rax,%rbx,4), %edi
xorl %esi, %esi
callq 0x82e0
movl $0x21, %edi
callq 0x7831
jmp 0x91cc
movl $0xc, %edi
popq %rbx
jmp 0x7831
leaq 0xa5dd(%rip), %rdi      # 0x137f4
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5cc5
cmpl $0x21, %ebx
jne 0x9243
movl %ebp, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x915f
movq 0x100fe(%rip), %rcx     # 0x19348
movslq %ebp, %r14
movslq (%rcx,%r14,4), %rax
cmpl $-0x1, (%rcx,%rax,4)
je 0x92cb
leal -0x55(%rbx), %ebp
cmpl $-0x4, %ebp
ja 0x9269
movl $0x9, %edi
callq 0x7831
movq 0x100d8(%rip), %rax     # 0x19348
movslq (%rax,%r14,4), %r14
movq 0x100c5(%rip), %rax     # 0x19340
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x82e0
movq 0x100bb(%rip), %rax     # 0x19348
movl (%rax,%r14,4), %r14d
cmpl $-0x1, %r14d
je 0x92bf
movl $0x8, %edi
callq 0x7831
movq 0x10098(%rip), %rax     # 0x19340
movslq %r14d, %r14
movl (%rax,%r14,4), %edi
xorl %esi, %esi
callq 0x82e0
movl %ebx, %edi
callq 0x7831
jmp 0x9286
cmpl $-0x4, %ebp
ja 0x92ea
movl $0xb, %edi
jmp 0x930a
movl %ebx, %ecx
andl $-0x2, %ecx
cmpl $0x52, %ecx
jne 0x92ef
movq 0x10064(%rip), %rcx     # 0x19340
movl (%rcx,%rax,4), %edi
xorl %esi, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x82e0
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x54, %ebx
jne 0x9313
movq 0x10045(%rip), %rcx     # 0x19340
movl (%rcx,%rax,4), %edi
xorl %esi, %esi
callq 0x82e0
movl $0x5a, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x7831
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
popq %rbx
popq %r14
popq %rbp
jmp 0x798e
// File: /workspace/github_c_makefile_star2_O1/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 0x27dc
testl %ebx, %ebx
jle 0x936b
movq 0x1001e(%rip), %rdx     # 0x19358
movq 0x10007(%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 0x935b
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x334b
movq 0xffba(%rip), %rcx      # 0x19348
movslq %eax, %r14
movslq (%rcx,%r14,4), %rdi
shlq $0x2, %rdi
addq 0xffb8(%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 0x3162
movl %eax, 0xfddc(%rip)      # 0x191a0
movl $0x0, 0x10382(%rip)     # 0x19750
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, 0xfdcb(%rip)      # 0x191a4
movl %ebx, %edi
xorl %esi, %esi
callq 0x82e0
movl $0x10, %edi
callq 0x7831
movq 0xff55(%rip), %rax      # 0x19348
movslq 0xfda6(%rip), %rcx      # 0x191a0
movl (%rax,%rcx,4), %edi
movl 0x1034d(%rip), %esi     # 0x19750
callq 0x9321
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
movl %ebp, 0xfd81(%rip)      # 0x191a0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x94d0
movq 0xff14(%rip), %rcx      # 0x19350
movl %ebx, %eax
testb $0x1, (%rcx,%rax)
je 0x94d0
movq 0xfef1(%rip), %rcx      # 0x19340
cmpl $-0xd, (%rcx,%rax,4)
jne 0x94d0
movq 0xfeec(%rip), %rax      # 0x19348
movslq 0xfcd9(%rip), %rdx      # 0x1913c
movslq (%rax,%rdx,4), %rdx
shlq $0x2, %rdx
addq 0xfee6(%rip), %rdx      # 0x19358
movslq %edi, %rsi
movl (%rdx,%rsi,4), %edi
movl 0xfd3a(%rip), %esi      # 0x191b8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpl $-0x1, %esi
je 0x949d
movslq %esi, %rsi
movslq (%rcx,%rsi,4), %r8
cmpl %edi, (%rcx,%r8,4)
je 0x949a
movl (%rax,%rsi,4), %esi
jmp 0x9483
movl %r8d, %edx
cmpl $-0x1, %edx
je 0x94aa
movslq %edx, %rcx
movl %ebx, (%rax,%rcx,4)
jmp 0x94c8
movl %ebx, %esi
xorl %edx, %edx
callq 0x3162
movl 0xfcff(%rip), %esi      # 0x191b8
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0xfcf0(%rip)      # 0x191b8
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x9e44(%rip), %rsi      # 0x1331b
leaq 0xa34b(%rip), %rdx      # 0x13829
leaq 0xa307(%rip), %rcx      # 0x137ec
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xfc63(%rip), %esi      # 0x19170
xorl %edx, %edx
callq 0x3162
movl %eax, 0xfc56(%rip)      # 0x19170
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl %eax, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, 0xfc3c(%rip)      # 0x19170
movl %ebx, %eax
testl %ebx, %ebx
js 0x958f
movl %ebx, %eax
movq 0xfe0d(%rip), %rcx      # 0x19350
movl %eax, %r15d
testb $0x9, (%rcx,%r15)
jne 0x958f
movq 0xfdec(%rip), %rax      # 0x19340
movl (%rax,%r15,4), %edi
movl %ebp, %esi
callq 0x95d1
movl %eax, %edi
movl %r14d, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %r14d
movq 0xfdcb(%rip), %rax      # 0x19340
movslq 0xfbf4(%rip), %rcx      # 0x19170
movl %r14d, (%rax,%rcx,4)
movq 0xfdc1(%rip), %rax      # 0x19348
movl (%rax,%r15,4), %eax
testl %eax, %eax
jns 0x953c
cmpl $-0x1, %eax
jne 0x95c3
movl $0x1, %edi
callq 0x33d7
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3e6e
movl %eax, %ebx
movl $0x1, %edi
callq 0x33d7
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa170(%rip), %rdi      # 0x1373a
movl %ebx, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xf93b(%rip), %esi      # 0x19170
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %eax, 0xf924(%rip)      # 0x19170
cmpl $-0x1, %ebp
sete %al
cmpl $-0x1, %r14d
sete %cl
orb %al, %cl
jne 0x98b6
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq 0xfad7(%rip), %rax      # 0x19340
movslq %ebp, %r15
movl (%rax,%r15,4), %edi
movslq %r14d, %r14
movl (%rax,%r14,4), %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %ebx
movq 0xfaae(%rip), %rax      # 0x19340
movslq 0xf8d7(%rip), %rcx      # 0x19170
movl %ebx, (%rax,%rcx,4)
movq 0xfaa5(%rip), %rax      # 0x19348
movl (%rax,%r15,4), %ebp
cmpl $-0x1, %ebp
je 0x98b6
movl (%rax,%r14,4), %r14d
cmpl $-0x1, %r14d
jne 0x9862
movl $0x1, %edi
callq 0x33d7
movl %ebx, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3e6e
// File: /workspace/github_c_makefile_star2_O1/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 0xf7f2(%rip), %rax      # 0x19340
movq 0xf7f3(%rip), %rcx      # 0x19348
movslq %edi, %r14
movslq (%rcx,%r14,4), %rdx
movslq (%rax,%rdx,4), %rdx
testq %rdx, %rdx
js 0x9c1a
movq 0xf7e0(%rip), %rsi      # 0x19350
testb $0x9, (%rsi,%rdx)
jne 0x9c1a
movq 0xf7c7(%rip), %rax      # 0x19348
movq 0xf7b8(%rip), %rcx      # 0x19340
movslq (%rax,%r14,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %ebx
movl (%rax,%rdx,4), %edi
callq 0x98d6
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3162
movl 0xfb7c(%rip), %edi      # 0x19728
movl %eax, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movq 0xf776(%rip), %rcx      # 0x19340
movq 0xf777(%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 0x3162
movq 0xf754(%rip), %rcx      # 0x19340
movl (%rcx,%r14,4), %ecx
cmpl 0xfd4a(%rip), %ecx      # 0x19940
leaq 0xfb1f(%rip), %rcx      # 0x1971c
leaq 0xfb28(%rip), %rdx      # 0x1972c
cmoveq %rcx, %rdx
movl (%rdx), %edi
movl %eax, %esi
xorl %edx, %edx
addq $0x68, %rsp
popq %rbx
popq %r14
jmp 0x3162
movslq (%rax,%r14,4), %rax
movslq (%rcx,%rax,4), %rdx
shlq $0x2, %rdx
addq 0xf72b(%rip), %rdx      # 0x19358
leaq 0x9bfb(%rip), %rsi      # 0x1382f
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq 0xf6f8(%rip), %rax      # 0x19340
movq 0xf6f9(%rip), %rcx      # 0x19348
movslq (%rcx,%r14,4), %rcx
movl (%rax,%rcx,4), %esi
movq %rbx, %rdi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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, 0xf509(%rip)      # 0x19174
testl %esi, %esi
je 0x9c74
callq 0xcd4e
movl 0xf4f6(%rip), %esi      # 0x19170
movl %ebp, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0xf4e7(%rip)      # 0x19170
movl $0xffffffff, 0xf4e1(%rip) # imm = 0xFFFFFFFF
movl %ebp, %edi
movl $0x1, %esi
callq 0x95d1
movl %eax, %ebp
movq 0xf698(%rip), %rax      # 0x19340
movslq 0xf4c1(%rip), %rcx      # 0x19170
movl %ebp, (%rax,%rcx,4)
movl %ebp, %edi
movl $0x1, %esi
callq 0x5d8f
movl %ebp, %edi
callq 0x7538
movq 0xf674(%rip), %rcx      # 0x19340
movslq 0xf49d(%rip), %rdx      # 0x19170
movl %eax, (%rcx,%rdx,4)
movl %eax, %edi
callq 0x9372
movq 0xf65c(%rip), %rcx      # 0x19340
movslq 0xf485(%rip), %rdx      # 0x19170
movl %eax, (%rcx,%rdx,4)
movl %eax, %edi
callq 0x10c11
movl %eax, %ebp
movl $0x1, %edi
callq 0x33d7
testl %ebx, %ebx
je 0x9d0a
callq 0xce30
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9e38
movl %esi, %ebx
movq 0xf5dc(%rip), %rsi      # 0x19350
movl %ebp, %eax
testb $0x1, (%rsi,%rax)
je 0x9e38
movq 0xf5b9(%rip), %rcx      # 0x19340
cmpl $-0xe, (%rcx,%rax,4)
jne 0x9e38
testl %ebx, %ebx
js 0x9e64
movl %ebx, %edx
testb $0x1, (%rsi,%rdx)
je 0x9e64
cmpl $-0xe, (%rcx,%rdx,4)
jne 0x9e64
movq 0xf592(%rip), %rsi      # 0x19348
movslq (%rsi,%rdx,4), %rdi
movl (%rcx,%rdi,4), %edi
testl %edi, %edi
jle 0x9dd9
movslq (%rsi,%rax,4), %r8
movl %edi, %r9d
xorl $0x7fffffff, %r9d       # imm = 0x7FFFFFFF
cmpl %r9d, (%rcx,%r8,4)
jg 0x9e90
testl %edi, %edi
jns 0x9df4
movslq (%rsi,%rax,4), %rsi
movl $0x80000000, %r8d       # imm = 0x80000000
subl %edi, %r8d
cmpl %r8d, (%rcx,%rsi,4)
jl 0x9e90
movq 0xf545(%rip), %rcx      # 0x19340
movq 0xf546(%rip), %rsi      # 0x19348
movslq (%rsi,%rax,4), %rax
movslq (%rsi,%rdx,4), %rdx
movl (%rcx,%rdx,4), %edi
addl (%rcx,%rax,4), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3162
leaq 0x94dc(%rip), %rsi      # 0x1331b
leaq 0x9a37(%rip), %rdx      # 0x1387d
leaq 0x9a32(%rip), %rcx      # 0x1387f
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x264c
leaq 0x94b0(%rip), %rsi      # 0x1331b
leaq 0x9a0b(%rip), %rdx      # 0x1387d
leaq 0x9a06(%rip), %rcx      # 0x1387f
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x264c
leaq 0x99e6(%rip), %rdi      # 0x1387d
movl %ebp, %esi
movl %ebx, %edx
callq 0x9d13
// File: /workspace/github_c_makefile_star2_O1/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 0x9f78
movl %esi, %ebp
movq 0xf495(%rip), %rsi      # 0x19350
movl %ebx, %eax
testb $0x1, (%rsi,%rax)
je 0x9f78
movq 0xf472(%rip), %rcx      # 0x19340
cmpl $-0xe, (%rcx,%rax,4)
jne 0x9f78
testl %ebp, %ebp
js 0x9fa4
movl %ebp, %edx
testb $0x1, (%rsi,%rdx)
je 0x9fa4
cmpl $-0xe, (%rcx,%rdx,4)
jne 0x9fa4
movq 0xf44b(%rip), %rsi      # 0x19348
movslq (%rsi,%rax,4), %rdi
movl (%rcx,%rdi,4), %edi
testl %edi, %edi
jns 0x9f1d
movslq (%rsi,%rdx,4), %r8
leal 0x7fffffff(%rdi), %r9d
cmpl %r9d, (%rcx,%r8,4)
jg 0x9fd0
testl %edi, %edi
jle 0x9f34
movslq (%rsi,%rdx,4), %rsi
orl $0x80000000, %edi       # imm = 0x80000000
cmpl %edi, (%rcx,%rsi,4)
jl 0x9fd0
movq 0xf405(%rip), %rcx      # 0x19340
movq 0xf406(%rip), %rsi      # 0x19348
movslq (%rsi,%rdx,4), %rdx
movl (%rcx,%rdx,4), %edi
movslq (%rsi,%rax,4), %rax
subl (%rcx,%rax,4), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3162
leaq 0x939c(%rip), %rsi      # 0x1331b
leaq 0x9900(%rip), %rdx      # 0x13886
leaq 0x98f2(%rip), %rcx      # 0x1387f
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x264c
leaq 0x9370(%rip), %rsi      # 0x1331b
leaq 0x98d4(%rip), %rdx      # 0x13886
leaq 0x98c6(%rip), %rcx      # 0x1387f
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x264c
leaq 0x98a6(%rip), %rdi      # 0x1387d
movl %ebp, %esi
movl %ebx, %edx
callq 0x9d13
// File: /workspace/github_c_makefile_star2_O1/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 0xa0d4
movl %esi, %ebx
movq 0xf355(%rip), %rsi      # 0x19350
movl %ebp, %ecx
testb $0x1, (%rsi,%rcx)
je 0xa0d4
movq 0xf332(%rip), %rax      # 0x19340
cmpl $-0xe, (%rax,%rcx,4)
jne 0xa0d4
testl %ebx, %ebx
js 0xa100
movl %ebx, %edx
testb $0x1, (%rsi,%rdx)
je 0xa100
cmpl $-0xe, (%rax,%rdx,4)
jne 0xa100
movq 0xf30b(%rip), %rsi      # 0x19348
movslq (%rsi,%rcx,4), %rcx
movl (%rax,%rcx,4), %ecx
testl %ecx, %ecx
je 0xa061
movslq (%rsi,%rdx,4), %rdx
movl (%rax,%rdx,4), %edi
testl %edi, %edi
je 0xa061
cmpl $0x1, %ecx
je 0xa067
cmpl $0x1, %edi
jne 0xa072
movl %ebp, %ebx
jmp 0xa067
movl 0xf145(%rip), %ebx      # 0x191ac
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl %ecx, %eax
negl %eax
jo 0xa12c
movl %edi, %eax
negl %eax
jo 0xa12c
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 0xa12c
imull %ecx, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3162
leaq 0x9240(%rip), %rsi      # 0x1331b
leaq 0x9e1f(%rip), %rdx      # 0x13f01
leaq 0x9796(%rip), %rcx      # 0x1387f
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x264c
leaq 0x9214(%rip), %rsi      # 0x1331b
leaq 0x9df3(%rip), %rdx      # 0x13f01
leaq 0x976a(%rip), %rcx      # 0x1387f
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x264c
leaq 0x9dce(%rip), %rdi      # 0x13f01
movl %ebp, %esi
movl %ebx, %edx
callq 0x9d13
// File: /workspace/github_c_makefile_star2_O1/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 0xa1ea
movl %esi, %ebx
movq 0xf1f9(%rip), %rsi      # 0x19350
movl %ebp, %eax
testb $0x1, (%rsi,%rax)
je 0xa1ea
movq 0xf1d6(%rip), %rcx      # 0x19340
cmpl $-0xe, (%rcx,%rax,4)
jne 0xa1ea
testl %ebx, %ebx
js 0xa216
movl %ebx, %edx
testb $0x1, (%rsi,%rdx)
je 0xa216
cmpl $-0xe, (%rcx,%rdx,4)
jne 0xa216
movq 0xf1b3(%rip), %rsi      # 0x19348
movslq (%rsi,%rdx,4), %rsi
cmpl $0x0, (%rcx,%rsi,4)
je 0xa242
movq 0xf196(%rip), %rcx      # 0x19340
movq 0xf197(%rip), %rsi      # 0x19348
movslq (%rsi,%rax,4), %rax
movl (%rcx,%rax,4), %eax
movslq (%rsi,%rdx,4), %rsi
cltd
idivl (%rcx,%rsi,4)
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3162
leaq 0x912a(%rip), %rsi      # 0x1331b
leaq 0x9690(%rip), %rdx      # 0x13888
leaq 0x9680(%rip), %rcx      # 0x1387f
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x264c
leaq 0x90fe(%rip), %rsi      # 0x1331b
leaq 0x9664(%rip), %rdx      # 0x13888
leaq 0x9654(%rip), %rcx      # 0x1387f
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x264c
leaq 0x9643(%rip), %rdi      # 0x1388c
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xa301
movl %esi, %ebx
movq 0xf0e2(%rip), %rsi      # 0x19350
movl %ebp, %eax
testb $0x1, (%rsi,%rax)
je 0xa301
movq 0xf0bf(%rip), %rcx      # 0x19340
cmpl $-0xe, (%rcx,%rax,4)
jne 0xa301
testl %ebx, %ebx
js 0xa32d
movl %ebx, %edx
testb $0x1, (%rsi,%rdx)
je 0xa32d
cmpl $-0xe, (%rcx,%rdx,4)
jne 0xa32d
movq 0xf09c(%rip), %rsi      # 0x19348
movslq (%rsi,%rdx,4), %rsi
cmpl $0x0, (%rcx,%rsi,4)
je 0xa359
movq 0xf07f(%rip), %rcx      # 0x19340
movq 0xf080(%rip), %rsi      # 0x19348
movslq (%rsi,%rax,4), %rax
movl (%rcx,%rax,4), %eax
movslq (%rsi,%rdx,4), %rsi
cltd
idivl (%rcx,%rsi,4)
movl %edx, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3162
leaq 0x9013(%rip), %rsi      # 0x1331b
leaq 0x9591(%rip), %rdx      # 0x138a0
leaq 0x9569(%rip), %rcx      # 0x1387f
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x264c
leaq 0x8fe7(%rip), %rsi      # 0x1331b
leaq 0x9565(%rip), %rdx      # 0x138a0
leaq 0x953d(%rip), %rcx      # 0x1387f
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x264c
leaq 0x9544(%rip), %rdi      # 0x138a4
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xae21
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 0xae1c
incq %rsi
cmpq %rsi, %rdx
jne 0xae00
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: sequal
cell sequal(cell x, cell y) {
	if (!string(x)) expect("s=", "string", x);
	if (!string(y)) expect("s=", "string", y);
	if (stringlen(x) != stringlen(y)) return NIL;
	return scomp(x, y) == 0? TRUE: NIL;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %edi, %ebx
movq 0xe42f(%rip), %rcx      # 0x19358
testq %rcx, %rcx
je 0xaf6e
movslq %ebx, %rax
movslq %esi, %rdx
movq 0xe40d(%rip), %rdi      # 0x19348
movslq (%rdi,%rax,4), %rax
movl -0x4(%rcx,%rax,4), %r8d
movslq (%rdi,%rdx,4), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x4(%rcx,%rdx,4), %r8d
jne 0xaf66
movl %ebx, %edi
callq 0xada4
cmpl $0x1, %eax
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
sbbl $0x0, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x83a6(%rip), %rsi      # 0x1331b
leaq 0x8970(%rip), %rdx      # 0x138ec
leaq 0x85ba(%rip), %rcx      # 0x1353d
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: siequal
cell siequal(cell x, cell y) {
	if (!string(x)) expect("si=", "string", x);
	if (!string(y)) expect("si=", "string", y);
	if (stringlen(x) != stringlen(y)) return NIL;
	return scomp_ci(x, y) == 0? TRUE: NIL;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %edi, %ebx
movq 0xe24d(%rip), %rcx      # 0x19358
testq %rcx, %rcx
je 0xb150
movslq %ebx, %rax
movslq %esi, %rdx
movq 0xe22b(%rip), %rdi      # 0x19348
movslq (%rdi,%rax,4), %rax
movl -0x4(%rcx,%rax,4), %r8d
movslq (%rdi,%rdx,4), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x4(%rcx,%rdx,4), %r8d
jne 0xb148
movl %ebx, %edi
callq 0xae24
cmpl $0x1, %eax
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
sbbl $0x0, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x81c4(%rip), %rsi      # 0x1331b
leaq 0x87a1(%rip), %rdx      # 0x138ff
leaq 0x83d8(%rip), %rcx      # 0x1353d
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: b_mkstr
cell b_mkstr(cell x, cell a) {
	cell	n;
	int	i, c, k;
	byte	*s;

	if (!fixp(x)) expect("mkstr", "fixnum", x);
	if (!charp(a)) expect("mkstr", "char", a);
	c = charval(a);
	k = fixval(x);
	n = mkstr(NULL, k);
	s = string(n);
	for (i=0; i<k; i++) s[i] = c;
	return n;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edi, %ebp
testl %edi, %edi
js 0xb2d1
movq 0xe10d(%rip), %rdx      # 0x19350
movl %ebp, %eax
testb $0x1, (%rdx,%rax)
je 0xb2d1
movq 0xe0ea(%rip), %rcx      # 0x19340
cmpl $-0xe, (%rcx,%rax,4)
jne 0xb2d1
movl %esi, %ebx
testl %esi, %esi
js 0xb2fd
movl %ebx, %esi
testb $0x1, (%rdx,%rsi)
je 0xb2fd
cmpl $-0xc, (%rcx,%rsi,4)
jne 0xb2fd
movq 0xe0c5(%rip), %rdx      # 0x19348
movslq (%rdx,%rsi,4), %rsi
movl (%rcx,%rsi,4), %ebx
movslq (%rdx,%rax,4), %rax
movslq (%rcx,%rax,4), %r14
xorl %edi, %edi
movl %r14d, %esi
callq 0x27dc
movl %eax, %ebp
testq %r14, %r14
jle 0xb2c6
movq 0xe09e(%rip), %rax      # 0x19348
movslq %ebp, %rcx
movslq (%rax,%rcx,4), %rdi
shlq $0x2, %rdi
addq 0xe09c(%rip), %rdi      # 0x19358
movl %ebx, %esi
movq %r14, %rdx
callq 0x20b0
movl %ebp, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x8043(%rip), %rsi      # 0x1331b
leaq 0x862d(%rip), %rdx      # 0x1390c
leaq 0x8599(%rip), %rcx      # 0x1387f
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x264c
leaq 0x8017(%rip), %rsi      # 0x1331b
leaq 0x8601(%rip), %rdx      # 0x1390c
leaq 0x823a(%rip), %rcx      # 0x1354c
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x264c