LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: report
void report(char *s, cell x) {
	int	i, j, o;

	o = set_outport(2);
	prints("*** error: ");
	prints(s);
	if (x != UNDEF) {
		prints(": ");
		Plimit = 100;
		prin(x);
		Plimit = 0;
	}
	nl();
	if (Files != NIL) {
		prints("*** file: ");
		printb(string(car(Files)));
		prints(", line: ");
		prints(ntoa(Line, 10));
		nl();
	}
	if (gottrace()) {
		prints("*** trace:");
		i = Tp;
		for (j=0; j<NTRACE; j++) {
			if (i >= NTRACE) i = 0;
			if (Trace[i] != -1) {
				prints(" ");
				printb(symname(vector(Symbols)[Trace[i]]));
			}
			i++;
		}
		nl();
	}
	set_outport(o);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x14dbb(%rip), %ebp     # 0x17148
movl $0x2, 0x14db1(%rip)     # 0x17148
leaq 0xdf42(%rip), %rdi      # 0x102e0
callq 0x2514
movq %r14, %rdi
callq 0x2514
cmpl $-0x4, %ebx
je 0x23d4
leaq 0xdf3d(%rip), %rdi      # 0x102f4
callq 0x2514
movl $0x64, 0x14fd2(%rip)    # 0x17398
movl %ebx, %edi
callq 0x2528
andl $0x0, 0x14fc4(%rip)     # 0x17398
leaq 0xeded(%rip), %rdi      # 0x111c8
callq 0x2514
cmpl $-0x1, 0x14d51(%rip)    # 0x17138
je 0x2450
leaq 0xdefc(%rip), %rdi      # 0x102ec
callq 0x2514
movq 0x14f4c(%rip), %rax     # 0x17348
movq 0x14f3d(%rip), %rcx     # 0x17340
movslq 0x14d2e(%rip), %rdx     # 0x17138
movslq (%rcx,%rdx,4), %rcx
movslq (%rax,%rcx,4), %rdi
shlq $0x2, %rdi
addq 0x14f3b(%rip), %rdi     # 0x17358
callq 0x2514
leaq 0xdece(%rip), %rdi      # 0x102f7
callq 0x2514
movl 0x14d00(%rip), %edi     # 0x17134
pushq $0xa
popq %rsi
callq 0x2532
movq %rax, %rdi
callq 0x2514
leaq 0xed7d(%rip), %rdi      # 0x111c8
callq 0x2514
callq 0x2356
testl %eax, %eax
je 0x24f2
movl %ebp, 0x4(%rsp)
pushq $0xa
popq %r14
leaq 0xde94(%rip), %rdi      # 0x10300
callq 0x2514
movl 0x14eec(%rip), %r15d    # 0x17364
xorl %r12d, %r12d
leaq 0x14eee(%rip), %r13     # 0x17370
leaq 0xe9e3(%rip), %rbx      # 0x10e6c
subl $0x1, %r14d
jb 0x24e2
cmpl $0xa, %r15d
cmovgel %r12d, %r15d
movslq %r15d, %rbp
cmpl $-0x1, (%r13,%rbp,4)
je 0x24dd
movq %rbx, %rdi
callq 0x2514
movq 0x14ea7(%rip), %rax     # 0x17358
movq 0x14e90(%rip), %rcx     # 0x17348
movslq 0x14c7d(%rip), %rdx     # 0x1713c
movslq (%rcx,%rdx,4), %rdx
leaq (%rax,%rdx,4), %rdx
movslq (%r13,%rbp,4), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
leaq (%rax,%rcx,4), %rdi
callq 0x2514
incl %r15d
jmp 0x2489
leaq 0xecdf(%rip), %rdi      # 0x111c8
callq 0x2514
movl 0x4(%rsp), %ebp
movl %ebp, 0x14c50(%rip)     # 0x17148
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: ntoa
char *ntoa(int x, int r) {
	static char	buf[200];
	int		i = 0, neg;
	char		*p = &buf[sizeof(buf)-1];
	char		d[] = "0123456789abcdefghijklmnopqrstuvwxyz";

	neg = x<0;
	*p = 0;
	while (x || 0 == i) {
		i++;
		p--;
		*p = d[abs(x % r)];
		x = x / r;
	}
	if (neg) {
		p--;
		*p = '-';
	}
	return p;
}

// Assembly:
movb $0x0, 0x151de(%rip)     # 0x17717
xorl %r8d, %r8d
leaq 0x151d3(%rip), %rcx     # 0x17716
leaq 0xeda6(%rip), %r9       # 0x112f0
movl %edi, %eax
testl %eax, %eax
setne %dl
subl $0x1, %r8d
setb %r10b
orb %dl, %r10b
testb $0x1, %r10b
je 0x257a
cltd
idivl %esi
movl %edx, %r10d
negl %r10d
cmovsl %edx, %r10d
movb (%r10,%r9), %dl
movb %dl, (%rcx)
decq %rcx
jmp 0x254c
testl %edi, %edi
js 0x2583
incq %rcx
jmp 0x2586
movb $0x2d, (%rcx)
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: error
void error(char *s, cell x) {
	cell	n;

	n = assq(S_errtag, Glob);
	Handler = (NIL == n)? NIL: cadr(n);
	if (Handler != NIL) {
		n = assq(S_errval, Glob);
		if (n != NIL && cadr(n) == Handler)
			bindset(S_errval, mkstr(s, strlen(s)));
		longjmp(Errtag, 1);
	}
	report(s, x);
	longjmp(Restart, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x14dfc(%rip), %edi     # 0x1739c
movl 0x14b9d(%rip), %r14d    # 0x17144
movl %r14d, %esi
callq 0x2640
cmpl $-0x1, %eax
jne 0x25bd
orl $-0x1, 0x14b85(%rip)    # 0x17140
jmp 0x25e2
movq 0x14d7c(%rip), %r15     # 0x17340
movq 0x14d7d(%rip), %r12     # 0x17348
cltq
movslq (%r12,%rax,4), %rax
movl (%r15,%rax,4), %r13d
movl %r13d, 0x14b64(%rip)    # 0x17140
cmpl $-0x1, %r13d
jne 0x25f5
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2377
leaq 0x14e8d(%rip), %rdi     # 0x17480
jmp 0x2638
movl 0x14da5(%rip), %ebp     # 0x173a0
movl %ebp, %edi
movl %r14d, %esi
callq 0x2640
cmpl $-0x1, %eax
je 0x2631
cltq
movslq (%r12,%rax,4), %rax
cmpl %r13d, (%r15,%rax,4)
jne 0x2631
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
callq 0x2698
movl %ebp, %edi
movl %eax, %esi
callq 0x266c
leaq 0x14d78(%rip), %rdi     # 0x173b0
pushq $0x1
popq %rsi
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: mkstr
cell mkstr(char *s, int k) {
	cell	n;

	if (0 == k) return Nullstr;
	n = newvec(T_STRING, k+1);
	if (NULL == s) {
		memset(string(n), 0, k+1);
	}
	else {
		memcpy(string(n), s, k);
		string(n)[k] = 0;
	}
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %esi, %esi
je 0x2703
movl %esi, %r15d
movq %rdi, %r14
leal 0x1(%r15), %ebp
pushq $-0x11
popq %rdi
movl %ebp, %esi
callq 0x3120
movl %eax, %ebx
movq 0x14c87(%rip), %rax     # 0x17348
movslq %ebx, %r12
movslq (%rax,%r12,4), %rdi
shlq $0x2, %rdi
addq 0x14c85(%rip), %rdi     # 0x17358
testq %r14, %r14
je 0x270b
movslq %r15d, %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x2140
movq 0x14c5b(%rip), %rax     # 0x17348
movslq (%rax,%r12,4), %rax
shlq $0x2, %rax
addq 0x14c5c(%rip), %rax     # 0x17358
movb $0x0, (%r15,%rax)
jmp 0x2715
movl 0x14a6f(%rip), %ebx     # 0x17178
jmp 0x2715
movslq %ebp, %rdx
xorl %esi, %esi
callq 0x20b0
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: readc
int readc(void) {
	int	c;

	if (Instr != NULL) {
		if (Rejected > -1) {
			c = Rejected;
			Rejected = -1;
			return c;
		}
		if (0 == *Instr) {
			return EOF;
		}
		else {
			return *Instr++;
		}
	}
	else {
		if (NULL == Ports[Inport])
			fatal("readc: input port is not open");
		return getc(Ports[Inport]);
	}
}

// Assembly:
movq 0x14dc5(%rip), %rcx     # 0x17558
testq %rcx, %rcx
je 0x27ab
movsbl 0x149b5(%rip), %eax     # 0x17154
testl %eax, %eax
js 0x27c7
movb $-0x1, 0x149aa(%rip)    # 0x17154
retq
movslq 0x14d96(%rip), %rax     # 0x17548
leaq 0x14da7(%rip), %rcx     # 0x17560
movq (%rcx,%rax,8), %rdi
testq %rdi, %rdi
je 0x27df
jmp 0x2210
cmpb $0x0, (%rcx)
je 0x27db
leaq 0x1(%rcx), %rax
movq %rax, 0x14d81(%rip)     # 0x17558
movsbl (%rcx), %eax
retq
pushq $-0x1
popq %rax
retq
pushq %rax
leaq 0xdb4a(%rip), %rdi      # 0x10331
callq 0x274d
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: mkport
cell mkport(int portno, cell type) {
	cell	n;
	int	pf;

	pf = Port_flags[portno];
	Port_flags[portno] |= LOCK_TAG;
	n = mkatom(portno, NIL);
	n = cons3(type, n, ATOM_TAG|PORT_TAG);
	Port_flags[portno] = pf;
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movslq %edi, %r14
leaq 0x14d9e(%rip), %r15     # 0x17600
movb (%r14,%r15), %bpl
movl %ebp, %eax
orb $0x40, %al
movb %al, (%r14,%r15)
pushq $-0x1
popq %rsi
pushq $0x1
popq %rdx
movl %r14d, %edi
callq 0x2f8c
pushq $0x11
popq %rdx
movl %ebx, %edi
movl %eax, %esi
callq 0x2f8c
movb %bpl, (%r14,%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: blockwrite
void blockwrite(char *s, int k) {
	cell	n;

	if (1 == Plimit) return;
	if (Outstr != NIL) {
		while (Outptr + k >= Outmax) {
			n = mkstr(NULL, Outmax+1000);
			memcpy(string(n), string(Outstr), Outptr);
			Outmax += 1000;
			Outstr = n;
		}
		memcpy(&string(Outstr)[Outptr], s, k);
		Outptr += k;
		string(Outstr)[Outptr] = 0;
		return;
	}
	if (NULL == Ports[Outport])
		fatal("blockwrite: output port is not open");
	if (fwrite(s, 1, k, Ports[Outport]) != k)
		error("file write error, port",
			mkport(Outport, T_OUTPORT));
	if ((1 == Outport || 2 == Outport) && '\n' == s[k-1])
		flush();
	if (Plimit) {
		Plimit -= k;
		if (Plimit < 1) Plimit = 1;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x1, 0x14af2(%rip)     # 0x17398
je 0x29f1
movl %esi, %ebx
movq %rdi, %r14
movl 0x14899(%rip), %ebp     # 0x17150
cmpl $-0x1, %ebp
je 0x298f
movl 0x14c86(%rip), %esi     # 0x1754c
movl $0x3e8, %r15d           # imm = 0x3E8
movslq 0x14c7d(%rip), %rax     # 0x17550
leal (%rax,%rbx), %ecx
cmpl %esi, %ecx
jl 0x2932
addl %r15d, %esi
xorl %edi, %edi
callq 0x2698
movl %eax, %ebp
movq 0x14a6b(%rip), %rax     # 0x17358
movq 0x14a54(%rip), %rcx     # 0x17348
movslq %ebp, %r12
movslq (%rcx,%r12,4), %rdx
leaq (%rax,%rdx,4), %rdi
movslq 0x1484a(%rip), %rdx     # 0x17150
movslq (%rcx,%rdx,4), %rcx
leaq (%rax,%rcx,4), %rsi
movslq 0x14c3b(%rip), %rdx     # 0x17550
callq 0x2140
movl 0x14c2c(%rip), %esi     # 0x1754c
addl %r15d, %esi
movl %esi, 0x14c23(%rip)     # 0x1754c
movl %r12d, 0x14820(%rip)    # 0x17150
jmp 0x28cc
movq 0x14a0f(%rip), %rcx     # 0x17348
movslq %ebp, %rdx
movslq (%rcx,%rdx,4), %rdi
shlq $0x2, %rdi
addq 0x14a0d(%rip), %rdi     # 0x17358
addq %rax, %rdi
movslq %ebx, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2140
movslq 0x14bed(%rip), %rax     # 0x17550
addq %rbx, %rax
movl %eax, 0x14be4(%rip)     # 0x17550
movq 0x149d5(%rip), %rcx     # 0x17348
movslq 0x147d6(%rip), %rdx     # 0x17150
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0x149cf(%rip), %rcx     # 0x17358
movb $0x0, (%rcx,%rax)
jmp 0x29f1
movslq 0x147b2(%rip), %rax     # 0x17148
leaq 0x14bc3(%rip), %rcx     # 0x17560
movq (%rcx,%rax,8), %rcx
testq %rcx, %rcx
je 0x29fa
movslq %ebx, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x2200
movl 0x1478b(%rip), %edi     # 0x17148
cmpq %r15, %rax
jne 0x2a06
decl %edi
cmpl $0x1, %edi
ja 0x29d6
cmpb $0xa, -0x1(%r14,%r15)
jne 0x29d6
callq 0x2815
movl 0x149bc(%rip), %eax     # 0x17398
testl %eax, %eax
je 0x29f1
subl %ebx, %eax
cmpl $0x2, %eax
pushq $0x1
popq %rcx
cmovgel %eax, %ecx
movl %ecx, 0x149a7(%rip)     # 0x17398
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd965(%rip), %rdi      # 0x10366
callq 0x274d
pushq $-0x10
popq %rsi
callq 0x284f
leaq 0xd93a(%rip), %rdi      # 0x1034f
movl %eax, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: alloc_nodepool
void alloc_nodepool(void) {
	Car = malloc(sizeof(cell) * NNODES);
	Cdr = malloc(sizeof(cell) * NNODES);
	Tag = malloc(NNODES);
	if (NULL == Car || NULL == Cdr || NULL == Tag)
		fatal("alloc_nodepool: out of physical memory");
	memset(Car, 0, sizeof(cell) * NNODES);
	memset(Cdr, 0, sizeof(cell) * NNODES);
	memset(Tag, 0, NNODES);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0x100000, %edi         # imm = 0x100000
callq 0x2160
movq %rax, %r15
movq %rax, 0x148f5(%rip)     # 0x17340
movl $0x100000, %edi         # imm = 0x100000
callq 0x2160
movq %rax, %r14
movq %rax, 0x148e9(%rip)     # 0x17348
movl $0x40000, %edi          # imm = 0x40000
callq 0x2160
movq %rax, 0x148e0(%rip)     # 0x17350
testq %r15, %r15
je 0x2ab4
testq %r14, %r14
je 0x2ab4
movq %rax, %rbx
testq %rax, %rax
je 0x2ab4
movl $0x100000, %edx         # imm = 0x100000
movq %r15, %rdi
xorl %esi, %esi
callq 0x20b0
movl $0x100000, %edx         # imm = 0x100000
movq %r14, %rdi
xorl %esi, %esi
callq 0x20b0
movl $0x40000, %edx          # imm = 0x40000
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x20b0
leaq 0xd8cf(%rip), %rdi      # 0x1038a
callq 0x274d
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: alloc_vecpool
void alloc_vecpool(void) {
	Vectors = malloc(sizeof(cell) * NVCELLS);
	if (NULL == Vectors)
		fatal("alloc_vecpool: out of physical memory");
	memset(Vectors, 0, sizeof(cell) * NVCELLS);
}

// Assembly:
pushq %rax
pushq $0x1
popq %rdi
movl $0x100000, %esi         # imm = 0x100000
callq 0x2100
movq %rax, 0x14883(%rip)     # 0x17358
testq %rax, %rax
je 0x2adc
popq %rax
retq
leaq 0xd8ce(%rip), %rdi      # 0x103b1
callq 0x274d
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: marklit
void marklit(cell p) {
	int	i, k, op;
	byte	*v, *m;

	k = stringlen(p);
	v = string(p);
	m = string(Obmap);
	for (i=0; i<k; ) {
		op = v[i];
		if (OP_QUOTE == op) {
			m[fetcharg(v, i+1)] = OBUSED;
			i += ISIZE1;
		}
		else if (OP_ARG == op || OP_PUSHVAL == op || OP_JMP == op ||
			 OP_BRF == op || OP_BRT == op || OP_CLOSURE == op ||
			 OP_MKENV == op || OP_ENTER == op || OP_ENTCOL == op ||
			 OP_SETARG == op || OP_SETREF == op || OP_MACRO == op)
		{
			i += ISIZE1;
		}
		else if (OP_REF == op || OP_CPARG == op || OP_CPREF == op) {
			i += ISIZE2;
		}
		else {
			i += ISIZE0;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x14865(%rip), %rdx     # 0x17358
movq 0x1484e(%rip), %rsi     # 0x17348
movslq %edi, %rax
movslq (%rsi,%rax,4), %rax
leaq (%rdx,%rax,4), %rax
movl -0x4(%rax), %ecx
movslq 0x14649(%rip), %rdi     # 0x17158
movslq (%rsi,%rdi,4), %rsi
leaq (%rdx,%rsi,4), %rdx
xorl %esi, %esi
movl $0x3, %edi
movl $0x1, %r8d
movl $0x3b18e440, %r9d       # imm = 0x3B18E440
movl $0xc00080, %r10d        # imm = 0xC00080
movl $0x5, %r11d
cmpl %ecx, %esi
jge 0x2b7d
movl %esi, %ebx
movzbl (%rax,%rbx), %ebp
cmpl $0x1d, %ebp
ja 0x2b78
btl %ebp, %r9d
movl %edi, %r14d
jae 0x2b53
addl %r14d, %esi
jmp 0x2b36
btl %ebp, %r10d
jae 0x2b5e
movl %r11d, %r14d
jmp 0x2b4e
cmpl $0x5, %ebp
jne 0x2b78
movzwl 0x1(%rax,%rbx), %ebx
rolw $0x8, %bx
movzwl %bx, %ebx
movb $0x2, (%rdx,%rbx)
movl %edi, %r14d
jmp 0x2b4e
movl %r8d, %r14d
jmp 0x2b4e
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: cons3
cell cons3(cell pcar, cell pcdr, int ptag) {
	cell	n;
	int	k;

	if (NIL == Freelist) {
		if (0 == (ptag & ~CONST_TAG))
			Tmp_car = pcar;
		if (!(ptag & VECTOR_TAG))
			Tmp_cdr = pcdr;
		k = gc();
		if (k < NNODES / 2) {
			/* memory low! */
		}
		Tmp_car = Tmp_cdr = NIL;
		if (NIL == Freelist)
			error("cons3: out of nodes", UNDEF);
	}
	n = Freelist;
	Freelist = cdr(Freelist);
	car(n) = pcar;
	cdr(n) = pcdr;
	tag(n) = ptag;
	return n;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
movl 0x14193(%rip), %eax     # 0x17130
cmpl $-0x1, %eax
jne 0x2fdc
testl $0xffffff7f, %ebx       # imm = 0xFFFFFF7F
jne 0x2fb1
movl %r14d, 0x141b7(%rip)    # 0x17168
testb $0x8, %bl
jne 0x2fbc
movl %ebp, 0x141b0(%rip)     # 0x1716c
callq 0x2d8b
orl $-0x1, 0x141a4(%rip)    # 0x1716c
orl $-0x1, 0x14199(%rip)    # 0x17168
movl 0x1415b(%rip), %eax     # 0x17130
pushq $-0x1
popq %rcx
cmpl %ecx, %eax
je 0x300b
movq 0x14365(%rip), %rcx     # 0x17348
cltq
movl (%rcx,%rax,4), %edx
movl %edx, 0x14142(%rip)     # 0x17130
movq 0x1434b(%rip), %rdx     # 0x17340
movl %r14d, (%rdx,%rax,4)
movl %ebp, (%rcx,%rax,4)
movq 0x1434d(%rip), %rcx     # 0x17350
movb %bl, (%rcx,%rax)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xd3dc(%rip), %rdi      # 0x103ee
pushq $-0x4
popq %rsi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: unmark_vecs
void unmark_vecs(void) {
	int	p, k, link;

	p = 0;
	while (p < Freevec) {
		link = p;
		k = Vectors[p + RAW_VECSIZE];
		p += vecsize(k);
		Vectors[link] = NIL;
	}
}

// Assembly:
xorl %eax, %eax
movq 0x14335(%rip), %rcx     # 0x17358
cmpl 0x14337(%rip), %eax     # 0x17360
jge 0x3046
movslq %eax, %rdx
movslq 0x4(%rcx,%rdx,4), %rsi
addq $0x3, %rsi
shrq $0x2, %rsi
addl %esi, %eax
addl $0x2, %eax
orl $-0x1, (%rcx,%rdx,4)
jmp 0x3023
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: gcv
int gcv(void) {
	int	v, k, to, from;
	char	buf[100];

	unmark_vecs();
	gc();		/* re-mark live vectors */
	to = from = 0;
	while (from < Freevec) {
		v = Vectors[from + RAW_VECSIZE];
		k = vecsize(v);
		if (Vectors[from + RAW_VECLINK] != NIL) {
			if (to != from) {
				memmove(&Vectors[to], &Vectors[from],
					k * sizeof(cell));
				cdr(Vectors[to + RAW_VECLINK]) =
					to + RAW_VECDATA;
			}
			to += k;
		}
		from += k;
	}
	k = Freevec - to;
	if (GC_verbose) {
		sprintf(buf, "GCV: %d cells reclaimed", k);
		prints(buf); nl();
		flush();
	}
	Freevec = to;
	return k;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
callq 0x301a
callq 0x2d8b
xorl %r15d, %r15d
movl 0x142fc(%rip), %ebx     # 0x17360
xorl %ebp, %ebp
cmpl %ebx, %ebp
jge 0x30d1
movq 0x142e7(%rip), %rax     # 0x17358
movslq %ebp, %rcx
movslq 0x4(%rax,%rcx,4), %r14
addq $0x3, %r14
shrq $0x2, %r14
addl $0x2, %r14d
cmpl $-0x1, (%rax,%rcx,4)
je 0x30c9
cmpl %ebp, %r15d
je 0x30c6
leaq (%rax,%rcx,4), %rsi
movslq %r15d, %rbx
leaq (%rax,%rbx,4), %rdi
movslq %r14d, %rdx
shlq $0x2, %rdx
callq 0x21b0
leal 0x2(%r15), %eax
movq 0x14296(%rip), %rcx     # 0x17348
movq 0x1429f(%rip), %rdx     # 0x17358
movslq (%rdx,%rbx,4), %rdx
movl %eax, (%rcx,%rdx,4)
movl 0x1429a(%rip), %ebx     # 0x17360
addl %r14d, %r15d
addl %ebp, %r14d
movl %r14d, %ebp
jmp 0x3066
subl %r15d, %ebx
cmpl $0x0, 0x14539(%rip)     # 0x17614
je 0x310c
leaq 0xd31e(%rip), %rsi      # 0x10402
movq %rsp, %r14
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
callq 0x2514
leaq 0xe0c6(%rip), %rdi      # 0x111c8
callq 0x2514
callq 0x2815
movl %r15d, 0x1424d(%rip)    # 0x17360
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: newvec
cell newvec(cell type, int size) {
	cell	n;
	int	v, wsize;

	wsize = vecsize(size);
	if (Freevec + wsize >= NVCELLS) {
		gcv();
		if (Freevec + wsize >= NVCELLS)
			error("newvec: out of vector space", UNDEF);
	}
	v = Freevec;
	Freevec += wsize;
	n = cons3(type, v + RAW_VECDATA, VECTOR_TAG);
	Vectors[v + RAW_VECLINK] = n;
	Vectors[v + RAW_VECSIZE] = size;
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movslq %esi, %r15
addq $0x3, %r15
shrq $0x2, %r15
movl 0x14223(%rip), %r14d    # 0x17360
leal (%r14,%r15), %eax
addl $0x2, %eax
cmpl $0x40000, %eax          # imm = 0x40000
jl 0x316a
addl $0x2, %r15d
callq 0x3047
movl 0x14205(%rip), %r14d    # 0x17360
addl %r14d, %r15d
movl %r15d, %eax
cmpl $0x40000, %r15d         # imm = 0x40000
jge 0x319a
movl %eax, 0x141f0(%rip)     # 0x17360
leal 0x2(%r14), %esi
pushq $0x8
popq %rdx
movl %ebp, %edi
callq 0x2f8c
movq 0x141d3(%rip), %rcx     # 0x17358
movslq %r14d, %rdx
movl %eax, (%rcx,%rdx,4)
movl %ebx, 0x4(%rcx,%rdx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd279(%rip), %rdi      # 0x1041a
pushq $-0x4
popq %rsi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: unprot
cell unprot(int k) {
	cell	n = NIL; /*LINT*/

	while (k) {
		if (NIL == Protected)
			error("unprot: stack underflow", UNDEF);
		n = car(Protected);
		Protected = cdr(Protected);
		k--;
	}
	return n;
}

// Assembly:
pushq %rax
movl 0x13fc0(%rip), %edx     # 0x17170
movq 0x14189(%rip), %rcx     # 0x17340
pushq $-0x1
popq %rax
movq 0x14187(%rip), %rsi     # 0x17348
subl $0x1, %edi
jb 0x31dc
cmpl $-0x1, %edx
je 0x31de
movslq %edx, %rdx
movl (%rcx,%rdx,4), %eax
movl (%rsi,%rdx,4), %edx
movl %edx, 0x13f96(%rip)     # 0x17170
jmp 0x31c1
popq %rcx
retq
leaq 0xd251(%rip), %rdi      # 0x10436
pushq $-0x4
popq %rsi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: mkvec
cell mkvec(int k) {
	cell	n, *v;
	int	i;

	if (0 == k) return Nullvec;
	n = newvec(T_VECTOR, k * sizeof(cell));
	v = vector(n);
	for (i=0; i<k; i++) v[i] = NIL;
	return n;
}

// Assembly:
testl %edi, %edi
je 0x3233
pushq %rbx
movl %edi, %ebx
leal (,%rbx,4), %esi
pushq $-0x13
popq %rdi
callq 0x3120
movq 0x1413e(%rip), %rcx     # 0x17348
movslq %eax, %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0x1413c(%rip), %rcx     # 0x17358
xorl %edx, %edx
testl %ebx, %ebx
cmovlel %edx, %ebx
cmpq %rdx, %rbx
je 0x3231
orl $-0x1, (%rcx,%rdx,4)
incq %rdx
jmp 0x3223
popq %rbx
retq
movl 0x13f43(%rip), %eax     # 0x1717c
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: htsize
int htsize(int n) {
	if (n < 47) return 47;
	if (n < 97) return 97;
	if (n < 199) return 199;
	if (n < 499) return 499;
	if (n < 997) return 997;
	if (n < 9973) return 9973;
	if (n < 19997) return 19997;
	return 39989;
}

// Assembly:
cmpl $0x2f, %edi
jge 0x3243
pushq $0x2f
jmp 0x324a
cmpl $0x61, %edi
jae 0x324c
pushq $0x61
popq %rax
retq
movl $0xc7, %eax
cmpl $0xc7, %edi
jb 0x328f
movl $0x1f3, %eax            # imm = 0x1F3
cmpl $0x1f3, %edi            # imm = 0x1F3
jb 0x328f
movl $0x3e5, %eax            # imm = 0x3E5
cmpl $0x3e5, %edi            # imm = 0x3E5
jb 0x328f
movl $0x26f5, %eax           # imm = 0x26F5
cmpl $0x26f5, %edi           # imm = 0x26F5
jb 0x328f
movl $0x4e1d, %ecx           # imm = 0x4E1D
cmpl %ecx, %edi
movl $0x9c35, %eax           # imm = 0x9C35
cmovbl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: mkht
cell mkht(int k) {
	cell	n;

	n = mkfix(0); /* mutable, can't use Zero */
	protect(n);
	n = cons(n, mkvec(htsize(k)));
	unprot(1);
	return n;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
pushq $-0x1
popq %rsi
pushq $0x1
popq %rbx
xorl %edi, %edi
movl %ebx, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %ebx, %edx
callq 0x2f8c
movl %eax, %r14d
movl 0x13eb6(%rip), %esi     # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x13ea7(%rip)     # 0x17170
movl %ebp, %edi
callq 0x323a
movl %eax, %edi
callq 0x31ed
movl %r14d, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebp
movl %ebx, %edi
callq 0x31a9
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: obhash
uint obhash(cell x, uint k) {
	if (specialp(x))
		return abs(x) % k;
	if (symbolp(x))
		return hash(symname(x), k);
	if (fixp(x))
		return abs(fixval(x)) % k;
	if (charp(x))
		return charval(x) % k;
	if (stringp(x))
		return hash(string(x), k);
	return 0;
}

// Assembly:
testl %edi, %edi
js 0x3362
movq 0x14035(%rip), %rax     # 0x17350
movl %edi, %ecx
movb (%rax,%rcx), %dl
testb $0x8, %dl
je 0x3332
movq 0x14014(%rip), %rax     # 0x17340
cmpl $-0x12, (%rax,%rcx,4)
je 0x3381
testb $0x1, %dl
je 0x336d
movq 0x14002(%rip), %rax     # 0x17340
movl (%rax,%rcx,4), %edi
cmpl $-0xc, %edi
je 0x339d
cmpl $-0xe, %edi
jne 0x336d
movq 0x13ff6(%rip), %rdx     # 0x17348
movslq (%rdx,%rcx,4), %rcx
movl (%rax,%rcx,4), %ecx
movl %ecx, %eax
negl %eax
cmovsl %ecx, %eax
jmp 0x3366
negl %edi
movl %edi, %eax
xorl %edx, %edx
divl %esi
movl %edx, %eax
retq
xorl %eax, %eax
testb $0x8, %dl
je 0x339c
movq 0x13fc5(%rip), %rdx     # 0x17340
cmpl $-0x11, (%rdx,%rcx,4)
jne 0x339c
movq 0x13fc0(%rip), %rax     # 0x17348
movslq (%rax,%rcx,4), %rdi
shlq $0x2, %rdi
addq 0x13fc1(%rip), %rdi     # 0x17358
jmp 0x32f3
retq
movq 0x13fa4(%rip), %rdx     # 0x17348
movslq (%rdx,%rcx,4), %rcx
movl (%rax,%rcx,4), %eax
jmp 0x3366
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: match
int match(cell a, cell b) {
	int	k;

	if (a == b) {
		return 1;
	}
	if (fixp(a) && fixp(b)) {
		return fixval(a) == fixval(b);
	}
	if (charp(a) && charp(b)) {
		return charval(a) == charval(b);
	}
	if (symbolp(a) && symbolp(b)) {
		k = symlen(a);
		if (symlen(b) != k) return 0;
		return memcmp(symname(a), symname(b), k) == 0;
	}
	if (stringp(a) && stringp(b)) {
		k = stringlen(a);
		if (stringlen(b) != k) return 0;
		return memcmp(string(a), string(b), k) == 0;
	}
	return 0;
}

// Assembly:
movb $0x1, %al
cmpl %esi, %edi
je 0x33dd
testl %edi, %edi
js 0x33db
pushq %rax
movq 0x13f91(%rip), %rdx     # 0x17350
movl %edi, %ecx
movb (%rdx,%rcx), %r8b
movl %esi, %eax
testb $0x1, %r8b
jne 0x33e1
testb $0x8, %r8b
jne 0x3420
xorl %eax, %eax
addq $0x8, %rsp
jmp 0x33dd
xorl %eax, %eax
movzbl %al, %eax
retq
movq 0x13f58(%rip), %rdi     # 0x17340
movl (%rdi,%rcx,4), %r9d
cmpl $-0xe, %r9d
setne %r10b
testl %esi, %esi
sets %r11b
orb %r10b, %r11b
je 0x3467
testl %esi, %esi
sets %r10b
cmpl $-0xc, %r9d
setne %r9b
orb %r10b, %r9b
jne 0x33cd
testb $0x1, (%rdx,%rax)
je 0x33cd
cmpl $-0xc, (%rdi,%rax,4)
jne 0x33cd
jmp 0x347b
movq 0x13f19(%rip), %rdi     # 0x17340
movl (%rdi,%rcx,4), %r8d
cmpl $-0x12, %r8d
setne %r9b
testl %esi, %esi
sets %r10b
orb %r9b, %r10b
je 0x3492
testl %esi, %esi
sets %sil
cmpl $-0x11, %r8d
setne %r8b
orb %sil, %r8b
jne 0x33d3
testb $0x8, (%rdx,%rax)
je 0x33d3
cmpl $-0x11, (%rdi,%rax,4)
jne 0x33d3
jmp 0x34a6
testb $0x1, (%rdx,%rax)
je 0x33cd
cmpl $-0xe, (%rdi,%rax,4)
jne 0x33cd
movq 0x13ec6(%rip), %rdx     # 0x17348
movslq (%rdx,%rcx,4), %rcx
movl (%rdi,%rcx,4), %ecx
movslq (%rdx,%rax,4), %rax
cmpl (%rdi,%rax,4), %ecx
jmp 0x34da
testb $0x8, (%rdx,%rax)
je 0x33d3
cmpl $-0x12, (%rdi,%rax,4)
jne 0x33d3
movq 0x13eab(%rip), %rsi     # 0x17358
movq 0x13e94(%rip), %rdi     # 0x17348
movslq (%rdi,%rcx,4), %rcx
movslq -0x4(%rsi,%rcx,4), %rdx
movslq (%rdi,%rax,4), %rax
cmpl %edx, -0x4(%rsi,%rax,4)
jne 0x33d3
leaq (%rsi,%rcx,4), %rdi
leaq (%rsi,%rax,4), %rsi
callq 0x2190
testl %eax, %eax
sete %al
jmp 0x33d5
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: htgrow
void htgrow(cell d) {
	int	nk, i, h, k;
	cell	nd, e, n;

	k = htlen(d);
	nk = 1 + htlen(d);
	nd = mkht(nk);
	protect(nd);
	nk = htlen(nd);
	for (i = 0; i < k; i++) {
		for (e = htslots(d)[i]; e != NIL; e = cdr(e)) {
			h = obhash(caar(e), nk);
			n = cons(car(e), htslots(nd)[h]);
			htslots(nd)[h] = n;
		}
	}
	htdata(d) = htdata(nd);
	unprot(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x13e61(%rip), %rax     # 0x17358
movq 0x13e4a(%rip), %rcx     # 0x17348
movslq %edi, %rdx
movq %rdx, 0x8(%rsp)
movslq (%rcx,%rdx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movslq -0x4(%rax,%rcx,4), %r14
addq $0x3, %r14
shrq $0x2, %r14
leal 0x1(%r14), %edi
callq 0x3290
movl %eax, %ebx
movl 0x13c44(%rip), %esi     # 0x17170
xorl %r13d, %r13d
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x13c32(%rip)     # 0x17170
movq 0x13e13(%rip), %r15     # 0x17358
movq 0x13dfc(%rip), %r12     # 0x17348
movslq %ebx, %rbp
movslq (%r12,%rbp,4), %rax
movslq (%r12,%rax,4), %rax
movslq -0x4(%r15,%rax,4), %rax
addq $0x3, %rax
shrq $0x2, %rax
movq %rax, 0x20(%rsp)
testl %r14d, %r14d
cmovlel %r13d, %r14d
movq %r14, 0x10(%rsp)
cmpq 0x10(%rsp), %r13
je 0x3608
movq 0x8(%rsp), %rax
movslq (%r12,%rax,4), %rax
movslq (%r12,%rax,4), %rax
leaq (%r15,%rax,4), %rax
movq %r13, 0x18(%rsp)
leaq (%rax,%r13,4), %rax
movslq (%rax), %r13
cmpq $-0x1, %r13
je 0x35fb
movq 0x13d96(%rip), %rax     # 0x17340
movslq (%rax,%r13,4), %r14
movl (%rax,%r14,4), %edi
movq 0x20(%rsp), %rsi
callq 0x3310
movslq (%r12,%rbp,4), %rcx
movslq (%r12,%rcx,4), %rcx
leaq (%r15,%rcx,4), %rcx
movslq %eax, %rbx
movl (%rcx,%rbx,4), %esi
movl %r14d, %edi
xorl %edx, %edx
callq 0x2f8c
movq 0x13d79(%rip), %r15     # 0x17358
movq 0x13d62(%rip), %r12     # 0x17348
movslq (%r12,%rbp,4), %rcx
movslq (%r12,%rcx,4), %rcx
leaq (%r15,%rcx,4), %rcx
movl %eax, (%rcx,%rbx,4)
leaq (%r12,%r13,4), %rax
jmp 0x359a
movq 0x18(%rsp), %r13
incq %r13
jmp 0x3575
movl (%r12,%rbp,4), %eax
movq 0x8(%rsp), %rcx
movl %eax, (%r12,%rcx,4)
pushq $0x1
popq %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31a9
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: htlookup
int htlookup(cell d, cell k) {
	cell	x;
	int	h;

	h = obhash(k, htlen(d));
	x = htslots(d)[h];
	while (x != NIL) {
		if (match(caar(x), k)) return car(x);
		x = cdr(x);
	}
	return UNDEF;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x13d19(%rip), %rax     # 0x17358
movq 0x13d02(%rip), %r14     # 0x17348
movslq %edi, %rcx
movslq (%r14,%rcx,4), %rcx
movslq (%r14,%rcx,4), %rcx
leaq (%rax,%rcx,4), %r15
movslq -0x4(%r15), %rsi
addq $0x3, %rsi
shrq $0x2, %rsi
movl %ebx, %edi
callq 0x3310
cltq
leaq (%r15,%rax,4), %rax
movq 0x13ccb(%rip), %r15     # 0x17340
pushq $-0x4
popq %rbp
movslq (%rax), %r12
cmpq $-0x1, %r12
je 0x369d
movslq (%r15,%r12,4), %r13
movl (%r15,%r13,4), %edi
movl %ebx, %esi
callq 0x33ad
testl %eax, %eax
jne 0x369a
leaq (%r14,%r12,4), %rax
jmp 0x3678
movl %r13d, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: htadd
void htadd(cell d, cell k, cell v) {
	cell	e;
	int	h;

	Tmp = k;
	protect(v);
	protect(k);
	Tmp = NIL;
	if (htelts(d) >= htlen(d))
		htgrow(d);
	h = obhash(k, htlen(d));
	e = cons(k, v);
	e = cons(e, htslots(d)[h]);
	htslots(d)[h] = e;
	htelts(d)++;
	unprot(2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %ebx
movl %esi, 0x13ab2(%rip)     # 0x17174
movl 0x13aa8(%rip), %esi     # 0x17170
movl %edx, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x13a99(%rip)     # 0x17170
movl %r14d, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x13a87(%rip)     # 0x17170
orl $-0x1, 0x13a84(%rip)    # 0x17174
movq 0x13c49(%rip), %rax     # 0x17340
movq 0x13c4a(%rip), %rcx     # 0x17348
movslq %ebx, %rbx
movslq (%rax,%rbx,4), %rdx
movslq (%rcx,%rdx,4), %rdx
movslq (%rax,%rdx,4), %rax
movq 0x13c44(%rip), %rdx     # 0x17358
movslq (%rcx,%rbx,4), %rsi
movslq (%rcx,%rsi,4), %rcx
movslq -0x4(%rdx,%rcx,4), %rsi
addq $0x3, %rsi
shrq $0x2, %rsi
cmpq %rax, %rsi
ja 0x3758
movl %ebx, %edi
callq 0x34e2
movq 0x13c1c(%rip), %rax     # 0x17358
movq 0x13c05(%rip), %rcx     # 0x17348
movslq (%rcx,%rbx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movslq -0x4(%rax,%rcx,4), %rsi
addq $0x3, %rsi
shrq $0x2, %rsi
movl %r14d, %edi
callq 0x3310
movl %eax, %r15d
movl %r14d, %edi
movl %ebp, %esi
xorl %edx, %edx
callq 0x2f8c
movq 0x13bd2(%rip), %rcx     # 0x17348
movslq (%rcx,%rbx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0x13bcf(%rip), %rcx     # 0x17358
movslq %r15d, %r14
movl (%rcx,%r14,4), %esi
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movq 0x13ba8(%rip), %rcx     # 0x17348
movslq (%rcx,%rbx,4), %rdx
movslq (%rcx,%rdx,4), %rdx
shlq $0x2, %rdx
addq 0x13ba5(%rip), %rdx     # 0x17358
movl %eax, (%rdx,%r14,4)
movq 0x13b82(%rip), %rax     # 0x17340
movslq (%rax,%rbx,4), %rdx
movslq (%rcx,%rdx,4), %rcx
incl (%rax,%rcx,4)
pushq $0x2
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x31a9
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: htrem
cell htrem(cell d, cell k) {
	cell	*x, *v;
	int	h;

	h = obhash(k, htlen(d));
	v = htslots(d);
	x = &v[h];
	while (*x != NIL) {
		if (match(caar(*x), k)) {
			*x = cdr(*x);
			htelts(d)--;
			break;
		}
		x = &cdr(*x);
	}
	return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
movq 0x13b67(%rip), %rax     # 0x17358
movq 0x13b50(%rip), %r14     # 0x17348
movslq %edi, %rcx
movq %rcx, (%rsp)
movslq (%r14,%rcx,4), %rcx
movslq (%r14,%rcx,4), %rcx
leaq (%rax,%rcx,4), %r15
movslq -0x4(%r15), %rsi
addq $0x3, %rsi
shrq $0x2, %rsi
movl %ebp, %edi
callq 0x3310
cltq
leaq (%r15,%rax,4), %rcx
movq 0x13b15(%rip), %r12     # 0x17340
movslq (%rcx), %r15
cmpq $-0x1, %r15
je 0x3864
movq %rcx, %r13
movslq (%r12,%r15,4), %rax
movl (%r12,%rax,4), %edi
movl %ebp, %esi
callq 0x33ad
leaq (%r14,%r15,4), %rcx
testl %eax, %eax
je 0x382b
movl (%rcx), %eax
movl %eax, (%r13)
movq (%rsp), %rax
movslq (%r12,%rax,4), %rax
movslq (%r14,%rax,4), %rax
decl (%r12,%rax,4)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: mksym
cell mksym(char *s, int k) {
	cell	n;

	n = newvec(T_SYMBOL, k+1);
	strcpy((char *) symname(n), s);
	return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
incl %esi
pushq $-0x12
popq %rdi
callq 0x3120
movq 0x13abb(%rip), %rcx     # 0x17348
movslq %eax, %r14
movslq (%rcx,%r14,4), %rdi
shlq $0x2, %rdi
addq 0x13ab9(%rip), %rdi     # 0x17358
movq %rbx, %rsi
callq 0x2040
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: findsym
cell findsym(char *s) {
	cell	y;

	y = mksym(s, strlen(s));
	y = htlookup(Symhash, y);
	if (y != UNDEF) return car(y);
	return NIL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
callq 0x3875
movl 0x138b5(%rip), %edi     # 0x17180
movl %eax, %esi
callq 0x362b
cmpl $-0x4, %eax
jne 0x38dc
pushq $-0x1
popq %rax
jmp 0x38e8
movq 0x13a5d(%rip), %rcx     # 0x17340
cltq
movl (%rcx,%rax,4), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: intern
cell intern(cell y) {
	cell	n, *vn, *vs;
	int	i, k;

	protect(y);
	htadd(Symhash, y, mkfix(Symptr));
	unprot(1);
	k = veclen(Symbols);
	if (Symptr >= k) {
		n = mkvec(k + CHUNKSIZE);
		vs = vector(Symbols);
		vn = vector(n);
		for (i=0; i<k; i++) vn[i] = vs[i];
		Symbols = n;
	}
	vector(Symbols)[Symptr] = y;
	Symptr++;
	return y;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl 0x13877(%rip), %esi     # 0x17170
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x13867(%rip)     # 0x17170
movl 0x13871(%rip), %ebp     # 0x17180
movl 0x13d03(%rip), %edi     # 0x17618
pushq $-0x1
popq %rsi
pushq $0x1
popq %r14
movl %r14d, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %r14d, %edx
callq 0x2f8c
movl %ebp, %edi
movl %ebx, %esi
movl %eax, %edx
callq 0x36ae
movl %r14d, %edi
callq 0x31a9
movq 0x13a0d(%rip), %rcx     # 0x17358
movq 0x139f6(%rip), %rax     # 0x17348
movslq 0x137e3(%rip), %rdx     # 0x1713c
movslq (%rax,%rdx,4), %rax
movslq -0x4(%rcx,%rax,4), %r14
addq $0x3, %r14
shrq $0x2, %r14
movl 0x13ca8(%rip), %edx     # 0x17618
cmpl %r14d, %edx
jl 0x39d2
leal 0x400(%r14), %edi
callq 0x31ed
movq 0x139d0(%rip), %rcx     # 0x17358
movq 0x139b9(%rip), %rdx     # 0x17348
movslq 0x137a6(%rip), %rsi     # 0x1713c
movslq (%rdx,%rsi,4), %rsi
leaq (%rcx,%rsi,4), %rdi
movslq %eax, %rsi
movslq (%rdx,%rsi,4), %r8
leaq (%rcx,%r8,4), %r8
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0x39c2
movl (%rdi,%r15,4), %r9d
movl %r9d, (%r8,%r15,4)
incq %r15
jmp 0x39b0
movl %eax, 0x13774(%rip)     # 0x1713c
movslq (%rdx,%rsi,4), %rax
movl 0x13c46(%rip), %edx     # 0x17618
leaq (%rcx,%rax,4), %rax
movslq %edx, %rcx
movl %ebx, (%rax,%rcx,4)
incl 0x13c36(%rip)           # 0x17618
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: symref
cell symref(char *s) {
	cell	y, new;

	y = findsym(s);
	if (y != NIL) return y;
	new = mksym(s, strlen(s));
	return intern(new);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x38b2
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x3a1c
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
callq 0x3875
movl %eax, %ebp
movl %eax, %edi
callq 0x38ea
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: reconc
cell reconc(cell n, cell m) {
	while (n != NIL) {
		if (atomp(n)) error("reconc: dotted list", n);
                m = cons(car(n), m);
		n = cdr(n);
        }
        return m;
}

// Assembly:
pushq %rbx
movl %edi, %eax
cmpl $-0x1, %eax
je 0x3a5f
testl %eax, %eax
js 0x3a63
movq 0x13918(%rip), %rcx     # 0x17350
movl %eax, %ebx
testb $0x9, (%rcx,%rbx)
jne 0x3a63
movq 0x138f9(%rip), %rax     # 0x17340
movl (%rax,%rbx,4), %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %esi
movq 0x138ee(%rip), %rax     # 0x17348
movl (%rax,%rbx,4), %eax
jmp 0x3a28
movl %esi, %eax
popq %rbx
retq
leaq 0xc9e5(%rip), %rdi      # 0x1044f
movl %eax, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: nreconc
cell nreconc(cell n, cell m) {
	cell	h;

	while (n != NIL) {
		if (atomp(n)) error("nreconc: dotted list", n);
		h = cdr(n);
		cdr(n) = m;
		m = n;
		n = h;
	}
	return m;
}

// Assembly:
pushq %rax
movl %esi, %eax
movl %edi, %esi
movq 0x138d3(%rip), %rcx     # 0x17350
movq 0x138c4(%rip), %rdx     # 0x17348
cmpl $-0x1, %esi
je 0x3aa3
testl %esi, %esi
js 0x3aa5
movl %esi, %edi
testb $0x9, (%rcx,%rdi)
jne 0x3aa5
movl (%rdx,%rdi,4), %r8d
movl %eax, (%rdx,%rdi,4)
movl %esi, %eax
movl %r8d, %esi
jmp 0x3a84
popq %rcx
retq
leaq 0xc9a2(%rip), %rdi      # 0x1044e
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: conc
cell conc(cell a, cell b) {
	cell	n;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
pushq $-0x1
popq %rsi
callq 0x3a25
movl %eax, %ebp
movl 0x136a9(%rip), %esi     # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x1369a(%rip)     # 0x17170
cmpl $-0x1, %ebp
je 0x3b01
movq 0x1385e(%rip), %rax     # 0x17340
movslq %ebp, %r14
movl (%rax,%r14,4), %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebx
movq 0x1384d(%rip), %rax     # 0x17348
movl (%rax,%r14,4), %ebp
jmp 0x3ad6
pushq $0x1
popq %rdi
callq 0x31a9
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: newport
int newport(void) {
	int	i, n;

	for (n=0; n<2; n++) {
		for (i=0; i<NPORTS; i++) {
			if (NULL == Ports[i])
				return i;
		}
		if (0 == n) gc();
	}
	return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %r14d, %r14d
pushq $-0x1
popq %rbx
leaq 0x13a1c(%rip), %r15     # 0x17560
cmpl $0x2, %r14d
je 0x3b75
movq %r15, %rcx
xorl %eax, %eax
cmpq $0x14, %rax
je 0x3b64
cmpq $0x0, (%rcx)
je 0x3b73
incq %rax
addq $0x8, %rcx
jmp 0x3b4f
testl %r14d, %r14d
jne 0x3b6e
callq 0x2d8b
incl %r14d
jmp 0x3b44
movl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: open_inport
int open_inport(char *path) {
	int	i;

	i = newport();
	if (i < 0) return -1;
	Ports[i] = fopen(path, "r");
	if (NULL == Ports[i]) return -1;
	return i;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x3b32
testl %eax, %eax
js 0x3bba
movl %eax, %ebx
leaq 0xd12f(%rip), %rsi      # 0x10cc5
movq %r14, %rdi
callq 0x21c0
movq %rax, %rcx
movl %ebx, %eax
leaq 0x139b6(%rip), %rdx     # 0x17560
movq %rcx, (%rdx,%rax,8)
xorl %eax, %eax
cmpq $0x1, %rcx
sbbl %eax, %eax
orl %ebx, %eax
jmp 0x3bbd
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: open_outport
int open_outport(char *path, int append) {
	int	i;

	i = newport();
	if (i < 0) return -1;
	Ports[i] = fopen(path, append? "a": "w");
	if (NULL == Ports[i]) return -1;
	return i;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x3b32
testl %eax, %eax
js 0x3c11
movl %eax, %ebx
testl %ebp, %ebp
leaq 0xd06a(%rip), %rax      # 0x10c4c
leaq 0xd2e2(%rip), %rsi      # 0x10ecb
cmoveq %rax, %rsi
movq %r14, %rdi
callq 0x21c0
movq %rax, %rcx
movl %ebx, %eax
leaq 0x1395f(%rip), %rdx     # 0x17560
movq %rcx, (%rdx,%rax,8)
xorl %eax, %eax
cmpq $0x1, %rcx
sbbl %eax, %eax
orl %ebx, %eax
jmp 0x3c14
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: close_port
void close_port(int port) {
	if (port < 0 || port >= NPORTS)
		return;
	if (NULL == Ports[port]) {
		Port_flags[port] = 0;
		return;
	}
	fclose(Ports[port]);
	Ports[port] = NULL;
	Port_flags[port] = 0;
}

// Assembly:
cmpl $0x13, %edi
ja 0x3c5d
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x13928(%rip), %r14     # 0x17560
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0x3c4b
callq 0x2070
andq $0x0, (%r14,%rbx,8)
leaq 0x139ae(%rip), %rax     # 0x17600
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: reset_stdports
void reset_stdports(void) {
	clearerr(stdin);
	clearerr(stdout);
	clearerr(stderr);
	Inport = 0;
	Outport = 1;
	Errport = 2;
}

// Assembly:
pushq %rax
movq 0x13372(%rip), %rax     # 0x16fd8
movq (%rax), %rdi
callq 0x2130
movq 0x1335b(%rip), %rax     # 0x16fd0
movq (%rax), %rdi
callq 0x2130
movq 0x13374(%rip), %rax     # 0x16ff8
movq (%rax), %rdi
callq 0x2130
andl $0x0, 0x138b5(%rip)     # 0x17548
movl $0x1, 0x134ab(%rip)     # 0x17148
movl $0x2, 0x134a5(%rip)     # 0x1714c
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: bindnew
void bindnew(cell v, cell a) {
	cell	n;

	n = cons(a, NIL);
	n = cons(v, n);
	Glob = cons(n, Glob);
}

// Assembly:
pushq %rbx
movl %esi, %eax
movl %edi, %ebx
pushq $-0x1
popq %rsi
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x2f8c
movl 0x13447(%rip), %esi     # 0x17144
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x13438(%rip)     # 0x17144
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: octchar
int octchar(char *s) {
	int	v = 0;

	if (!octalp(*s)) return -1;
	while (octalp(*s)) {
		v = 8*v + *s - '0';
		s++;
	}
	return (*s || v > 255)? -1: v;
}

// Assembly:
movb (%rdi), %cl
movl %ecx, %eax
andb $-0x8, %al
cmpb $0x30, %al
jne 0x3d4b
incq %rdi
xorl %eax, %eax
movl %ecx, %edx
andb $-0x8, %dl
cmpb $0x30, %dl
jne 0x3d37
movzbl %cl, %ecx
leal (%rcx,%rax,8), %eax
addl $-0x30, %eax
movb (%rdi), %cl
incq %rdi
jmp 0x3d1d
cmpl $0x100, %eax            # imm = 0x100
pushq $-0x1
popq %rdx
cmovll %eax, %edx
xorl %eax, %eax
negb %cl
sbbl %eax, %eax
orl %edx, %eax
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: strcmp_ci
int strcmp_ci(char *s1, char *s2) {
	int	c1, c2;

	while (1) {
		c1 = tolower((int) *s1++);
		c2 = tolower((int) *s2++);
		if (!c1 || !c2 || c1 != c2)
			break;
	}
	return c1-c2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0x2150
movl %eax, %ebp
movsbl (%rbx,%r15), %edi
callq 0x2150
testl %ebp, %ebp
je 0x3d84
testl %eax, %eax
je 0x3d84
incq %r15
cmpl %eax, %ebp
je 0x3d5f
subl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: rdchar
cell rdchar(void) {
	char	name[TOKLEN+1];
	int	i, c, v;

	c = readc();
	name[0] = c;
	c = readc();
	for (i=1; i<TOKLEN; i++) {
		if (Intr || Readerr) return NIL;
		if (!isalpha(c) && !isdigit(c)) break;
		name[i] = c;
		c = readc();
	}
	name[i] = 0;
	rejectc(c);
	if (TOKLEN == i)
		rderror("char name too long",
			mkstr(name, strlen(name)));
	if (!strcmp_ci(name, "ht")) return mkchar(9);
	if (!strcmp_ci(name, "nl")) return mkchar(10);
	if (!strcmp_ci(name, "sp")) return mkchar(' ');
	v = octchar(&name[1]);
	if ('\\' == *name && v >= 0) return mkchar(v);
	if (i != 1) rderror("bad character name",
			mkstr(name, strlen(name)));
	return mkchar(name[0]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
callq 0x278c
movb %al, (%rsp)
pushq $0x1
popq %r15
callq 0x278c
movl %eax, %ebx
pushq $0x50
popq %r14
pushq $-0x1
popq %rbp
cmpq $0x50, %r15
je 0x3e15
cmpl $0x0, 0x13854(%rip)     # 0x17630
jne 0x3ed5
cmpq $0x0, 0x1383e(%rip)     # 0x17628
jne 0x3ed5
callq 0x2230
movq (%rax), %rax
movslq %ebx, %rcx
testb $0xc, 0x1(%rax,%rcx,2)
je 0x3e12
movb %bl, (%rsp,%r15)
callq 0x278c
movl %eax, %ebx
incq %r15
jmp 0x3dcf
movl %r15d, %r14d
movl %r14d, %eax
movb $0x0, (%rsp,%rax)
movl %ebx, %edi
callq 0x27ec
cmpl $0x50, %r14d
jne 0x3e4c
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
callq 0x2698
leaq 0xc61e(%rip), %rdi      # 0x10463
movl %eax, %esi
callq 0x3d93
leaq 0xc623(%rip), %rsi      # 0x10476
movq %rsp, %rdi
callq 0x3d4f
testl %eax, %eax
je 0x3eaf
leaq 0xc613(%rip), %rsi      # 0x10479
movq %rsp, %rdi
callq 0x3d4f
testl %eax, %eax
je 0x3eb3
leaq 0xcec4(%rip), %rsi      # 0x10d3d
movq %rsp, %rdi
callq 0x3d4f
testl %eax, %eax
je 0x3eb7
leaq 0x1(%rsp), %rbx
movq %rbx, %rdi
callq 0x3d0e
movb -0x1(%rbx), %cl
cmpb $0x5c, %cl
sete %dl
testl %eax, %eax
setns %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x3ee2
movzbl %al, %edi
jmp 0x3eba
pushq $0x9
jmp 0x3eb9
pushq $0xa
jmp 0x3eb9
pushq $0x20
popq %rdi
pushq $-0x1
popq %rsi
pushq $0x1
popq %rbx
movl %ebx, %edx
callq 0x2f8c
pushq $-0xc
popq %rdi
movl %eax, %esi
movl %ebx, %edx
callq 0x2f8c
movl %eax, %ebp
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1, %r14d
je 0x3f0d
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
callq 0x2698
leaq 0xc578(%rip), %rdi      # 0x1047c
movl %eax, %esi
callq 0x3d93
movb (%rbx), %cl
movzbl %cl, %edi
jmp 0x3eba
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: rdlist
cell rdlist(void) {
	cell		n, a, p;
	cell		new;
	static char	badpair[] = "malformed pair";

	Inlist++;
	n = xread2();
	if (RPAREN == n) {
		Inlist--;
		return NIL;
	}
	p = NIL;
	a = cons3(n, NIL, CONST_TAG);
	protect(a);
	while (n != RPAREN) {
		if (Intr || Readerr) {
			unprot(1);
			return NIL;
		}
		if (EOFMARK == n)  {
			unprot(1);
			rderror("missing ')'", UNDEF);
			return NIL;
		}
		else if (DOT == n) {
			if (NIL == p) {
				unprot(1);
				rderror(badpair, UNDEF);
				return NIL;
			}
			n = xread2();
			cdr(p) = n;
			if (RPAREN == n || xread2() != RPAREN) {
				unprot(1);
				rderror(badpair, UNDEF);
				return NIL;
			}
			Inlist--;
			return unprot(1);
		}
		car(a) = n;
		p = a;
		n = xread2();
		if (n != RPAREN) {
			Tmp = n;
			new = cons3(NIL, NIL, CONST_TAG);
			Tmp = NIL;
			cdr(a) = new;
			a = cdr(a);
		}
	}
	Inlist--;
	return unprot(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
incl 0x136f9(%rip)           # 0x1761c
callq 0x4065
cmpl $-0x5, %eax
jne 0x3f38
decl 0x136e9(%rip)           # 0x1761c
jmp 0x4053
movl %eax, %ebx
pushq $-0x1
popq %rbp
movl %eax, %edi
movl %ebp, %esi
movl $0x80, %edx
callq 0x2f8c
movl %eax, %r14d
movl 0x1321c(%rip), %esi     # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x1320d(%rip)     # 0x17170
movl %ebp, %r15d
movl %r15d, %r13d
movl %r14d, %r15d
movslq %r14d, %r12
cmpl $-0x5, %ebx
je 0x400f
cmpl $0x0, 0x136b1(%rip)     # 0x17630
jne 0x3fde
cmpq $0x0, 0x1369f(%rip)     # 0x17628
jne 0x3fde
cmpl $-0x6, %ebx
je 0x3fe8
cmpl $-0x3, %ebx
je 0x402b
movq 0x133a0(%rip), %rax     # 0x17340
movl %ebx, (%rax,%r12,4)
callq 0x4065
movl %eax, %ebx
movl %r15d, %r13d
cmpl $-0x5, %eax
je 0x3f6f
movl %ebx, 0x131bb(%rip)     # 0x17174
movl %ebp, %edi
movl %ebp, %esi
movl $0x80, %edx
callq 0x2f8c
orl $-0x1, 0x131a6(%rip)    # 0x17174
movl %eax, %r14d
movq 0x13370(%rip), %rax     # 0x17348
movl %r14d, (%rax,%r12,4)
jmp 0x3f66
pushq $0x1
popq %rdi
callq 0x31a9
jmp 0x4053
cmpl $-0x1, %r13d
je 0x403c
callq 0x4065
movq 0x1334e(%rip), %rcx     # 0x17348
movslq %r13d, %rdx
movl %eax, (%rcx,%rdx,4)
cmpl $-0x5, %eax
je 0x403c
callq 0x4065
cmpl $-0x5, %eax
jne 0x403c
decl 0x13607(%rip)           # 0x1761c
pushq $0x1
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31a9
pushq $0x1
popq %rdi
callq 0x31a9
leaq 0xc455(%rip), %rdi      # 0x1048f
jmp 0x404b
pushq $0x1
popq %rdi
callq 0x31a9
leaq 0x13139(%rip), %rdi     # 0x17184
pushq $-0x4
popq %rsi
callq 0x3d93
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq