LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: strlist
cell strlist(cell x) {
	cell	a, new;
	int	k, i;

	k = stringlen(x)-1;
	if (0 == k) return NIL;
	protect(a = cons(NIL, NIL));
	for (i=0; i<k; i++) {
		new = mkchar(string(x)[i]);
		car(a) = new;
		if (i < k-1) {
			new = cons(NIL, NIL);
			cdr(a) = new;
			a = cdr(a);
		}
	}
	return unprot(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq 0xed96(%rip), %rax      # 0x20358
movq 0xed7f(%rip), %rcx      # 0x20348
movslq -0x8(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jne 0x115f2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x116e7
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
movl %esi, %edi
callq 0x3990
movl %eax, %edi
movl %edi, -0xc(%rbp)
movl 0xeb65(%rip), %esi      # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0xeb58(%rip)      # 0x20170
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x116da
movq 0xed26(%rip), %rax      # 0x20358
movq 0xed0f(%rip), %rcx      # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %edi
andl $0xff, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff4, %edi       # imm = 0xFFFFFFF4
movl $0x1, %edx
callq 0x3990
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edx
movq 0xecbd(%rip), %rax      # 0x20340
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x116ca
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
movl %esi, %edi
callq 0x3990
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edx
movq 0xec96(%rip), %rax      # 0x20348
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0xec88(%rip), %rax      # 0x20348
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
jmp 0x116cc
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1161f
movl $0x1, %edi
callq 0x3d00
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: veclist
cell veclist(cell x) {
	cell	a, new;
	int	k, i;

	k = veclen(x);
	if (0 == k) return NIL;
	protect(a = cons(NIL, NIL));
	for (i=0; i<k; i++) {
		car(a) = vector(x)[i];
		if (i < k-1) {
			new = cons(NIL, NIL);
			cdr(a) = new;
			a = cdr(a);
		}
	}
	return unprot(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq 0xec56(%rip), %rax      # 0x20358
movq 0xec3f(%rip), %rcx      # 0x20348
movslq -0x8(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movslq (%rax,%rcx,4), %rax
addq $0x4, %rax
subq $0x1, %rax
shrq $0x2, %rax
addq $0x2, %rax
subq $0x2, %rax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jne 0x11744
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1180c
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
movl %esi, %edi
callq 0x3990
movl %eax, %edi
movl %edi, -0xc(%rbp)
movl 0xea13(%rip), %esi      # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0xea06(%rip)      # 0x20170
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x117ff
movq 0xebd4(%rip), %rax      # 0x20358
movq 0xebbd(%rip), %rcx      # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq 0xeb98(%rip), %rax      # 0x20340
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x117ef
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
movl %esi, %edi
callq 0x3990
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edx
movq 0xeb71(%rip), %rax      # 0x20348
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0xeb63(%rip), %rax      # 0x20348
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
jmp 0x117f1
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x11771
movl $0x1, %edi
callq 0x3d00
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: numstr
cell numstr(cell x, int r) {
	char	*p;

	if (r < 2 || r > 36)
		error("numstr: bad radix", mkfix(r));
	p = ntoa(fixval(x), r);
	return mkstr(p, strlen(p));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x2, -0x8(%rbp)
jl 0x1183a
cmpl $0x24, -0x8(%rbp)
jle 0x1186b
movl -0x8(%rbp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
leaq 0xa315(%rip), %rdi      # 0x1bb7b
callq 0x26c0
movq 0xeace(%rip), %rax      # 0x20340
movq 0xeacf(%rip), %rcx      # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl -0x8(%rbp), %esi
callq 0x25f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2090
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x2880
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: loadfile
void loadfile(char *s) {
	int	ldport, rdport, oline;
	cell	x;

	ldport = open_inport(s);
	if (ldport < 0)
		error("load: cannot open file",
			mkstr(s, strlen(s)));
	lock_port(ldport);
	rdport = Inport;
	oline = Line;
	Files = cons(mkstr(s, strlen(s)), Files);
	Line = 1;
	begin_rec();
	for (;;) {
		set_inport(ldport);
		x = xread();
		set_inport(rdport);
		if (EOFMARK == x) break;
		eval(x, 0);
	}
	end_rec();
	Files = cdr(Files);
	Line = oline;
	close_port(ldport);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5090
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x11968
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2090
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x2880
movl %eax, %esi
leaq 0xa23c(%rip), %rdi      # 0x1bb9f
callq 0x26c0
movl -0xc(%rbp), %edi
callq 0x5290
movl 0xebd2(%rip), %eax      # 0x20548
movl %eax, -0x10(%rbp)
movl 0xe7b5(%rip), %eax      # 0x20134
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2090
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x2880
movl %eax, %edi
movl 0xe792(%rip), %esi      # 0x20138
xorl %edx, %edx
callq 0x3990
movl %eax, 0xe785(%rip)      # 0x20138
movl $0x1, 0xe777(%rip)      # 0x20134
callq 0x11a30
movl -0xc(%rbp), %edi
callq 0x5190
callq 0x6a20
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %edi
callq 0x5190
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
cmpl -0x18(%rbp), %eax
jne 0x119e6
jmp 0x119f2
movl -0x18(%rbp), %edi
xorl %esi, %esi
callq 0xd550
jmp 0x119c2
callq 0x11b20
movq 0xe94a(%rip), %rax      # 0x20348
movslq 0xe733(%rip), %rcx      # 0x20138
movl (%rax,%rcx,4), %eax
movl %eax, 0xe72a(%rip)      # 0x20138
movl -0x14(%rbp), %eax
movl %eax, 0xe71d(%rip)      # 0x20134
movl -0xc(%rbp), %edi
callq 0x51b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: begin_rec
void begin_rec(void) {
	protect(Prog);
	protect(Ep);
	protect(mkfix(Ip));
	protect(mkfix(Sp));
	protect(mkfix(Fp));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xe782(%rip), %edi      # 0x201bc
movl 0xe730(%rip), %esi      # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0xe723(%rip)      # 0x20170
movl 0xe77d(%rip), %edi      # 0x201d0
movl 0xe717(%rip), %esi      # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0xe70a(%rip)      # 0x20170
movl 0xeeec(%rip), %edi      # 0x20958
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl $0x1, %edx
callq 0x3990
movl %eax, %edi
movl 0xe6dc(%rip), %esi      # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0xe6cf(%rip)      # 0x20170
movl 0xe6b9(%rip), %edi      # 0x20160
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl $0x1, %edx
callq 0x3990
movl %eax, %edi
movl 0xe6a1(%rip), %esi      # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0xe694(%rip)      # 0x20170
movl 0xe6e6(%rip), %edi      # 0x201c8
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl $0x1, %edx
callq 0x3990
movl %eax, %edi
movl 0xe666(%rip), %esi      # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0xe659(%rip)      # 0x20170
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: end_rec
void end_rec(void) {
	Fp = fixval(unprot(1));
	Sp = fixval(unprot(1));
	Ip = fixval(unprot(1));
	Ep = unprot(1);
	Prog = unprot(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0xe811(%rip), %rax      # 0x20340
movq %rax, -0x28(%rbp)
movq 0xe80e(%rip), %rax      # 0x20348
movq %rax, -0x30(%rbp)
movl $0x1, %edi
callq 0x3d00
movq -0x30(%rbp), %rcx
movl %eax, %edx
movq -0x28(%rbp), %rax
movslq %edx, %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xe666(%rip)      # 0x201c8
movq 0xe7d7(%rip), %rax      # 0x20340
movq %rax, -0x18(%rbp)
movq 0xe7d4(%rip), %rax      # 0x20348
movq %rax, -0x20(%rbp)
movl $0x1, %edi
callq 0x3d00
movq -0x20(%rbp), %rcx
movl %eax, %edx
movq -0x18(%rbp), %rax
movslq %edx, %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xe5c4(%rip)      # 0x20160
movq 0xe79d(%rip), %rax      # 0x20340
movq %rax, -0x8(%rbp)
movq 0xe79a(%rip), %rax      # 0x20348
movq %rax, -0x10(%rbp)
movl $0x1, %edi
callq 0x3d00
movq -0x10(%rbp), %rcx
movl %eax, %edx
movq -0x8(%rbp), %rax
movslq %edx, %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xed82(%rip)      # 0x20958
movl $0x1, %edi
callq 0x3d00
movl %eax, 0xe5ea(%rip)      # 0x201d0
movl $0x1, %edi
callq 0x3d00
movl %eax, 0xe5c6(%rip)      # 0x201bc
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: load
void load(cell x) {
	char	path[TOKLEN+1];

	if (!stringp(x))
		expect("load", "string", x);
	if (stringlen(x) > TOKLEN)
		error("load: path too long", x);
	strcpy(path, (char *) string(x));
	loadfile(path);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x11c3d
movq 0xe738(%rip), %rax      # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x11c3d
movq 0xe711(%rip), %rcx      # 0x20340
movslq -0x4(%rbp), %rdx
movl $0xffffffef, %eax       # imm = 0xFFFFFFEF
cmpl (%rcx,%rdx,4), %eax
je 0x11c53
movl -0x4(%rbp), %edx
leaq 0x99ec(%rip), %rdi      # 0x1b633
leaq 0x998f(%rip), %rsi      # 0x1b5dd
callq 0x2950
movq 0xe6fe(%rip), %rax      # 0x20358
movq 0xe6e7(%rip), %rcx      # 0x20348
movslq -0x4(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpl $0x50, (%rax,%rcx,4)
jle 0x11c83
movl -0x4(%rbp), %esi
leaq 0x9f38(%rip), %rdi      # 0x1bbb6
callq 0x26c0
leaq -0x60(%rbp), %rdi
movq 0xe6ca(%rip), %rsi      # 0x20358
movq 0xe6b3(%rip), %rax      # 0x20348
movslq -0x4(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x2050
leaq -0x60(%rbp), %rdi
callq 0x11920
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: saveimg
void saveimg(char *path) {
	char	b[TOKLEN+1], *p;

	if (strlen(path)+7 >= TOKLEN)
		error("image path too long", UNDEF);
	strcpy(b, path);
	p = strrchr(b, '.');
	if (NULL == p) p = b+strlen(b);
	*p = 0;
	strcat(b, ".oimage");
	remove(b);
	rename(path, b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2090
addq $0x7, %rax
cmpq $0x50, %rax
jb 0x11d50
leaq 0x9e9b(%rip), %rdi      # 0x1bbe1
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x26c0
leaq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2050
leaq -0x60(%rbp), %rdi
movl $0x2e, %esi
callq 0x20c0
movq %rax, -0x68(%rbp)
xorl %eax, %eax
cmpq -0x68(%rbp), %rax
jne 0x11d96
leaq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2090
movq %rax, %rcx
movq -0x70(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movb $0x0, (%rax)
leaq -0x60(%rbp), %rdi
leaq 0x9e4d(%rip), %rsi      # 0x1bbf5
callq 0x21e0
leaq -0x60(%rbp), %rdi
callq 0x2040
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x21d0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: dump_image
void dump_image(cell s) {
	char	*rc;

	rc = dumpimg((char *) string(s));
	if (rc != NULL) {
		remove((char *) string(s));
		error(rc, s);
	}
	bindset(S_imagefile, s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0xdf66(%rip), %rdi      # 0x20358
movq 0xdf4f(%rip), %rax      # 0x20348
movslq -0x4(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x11dd0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12446
movq 0xdf39(%rip), %rdi      # 0x20358
movq 0xdf22(%rip), %rax      # 0x20348
movslq -0x4(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x2040
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x26c0
movl 0xe504(%rip), %edi      # 0x20950
movl -0x4(%rbp), %esi
callq 0x2830
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: b_gc
cell b_gc(void) {
	cell	n;

	gcv();
	n = cons(mkfix(NVCELLS-Freevec), NIL);
	protect(n);
	n = mkfix(length(Freelist));
	return cons(n, unprot(1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x3af0
movl $0x40000, %edi          # imm = 0x40000
subl 0xdee8(%rip), %edi      # 0x20360
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl $0x1, %edx
callq 0x3990
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl 0xdcbe(%rip), %esi      # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0xdcb1(%rip)      # 0x20170
movl 0xdc6b(%rip), %edi      # 0x20130
callq 0x7930
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl $0x1, %edx
callq 0x3990
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl $0x1, %edi
callq 0x3d00
movl -0x8(%rbp), %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3990
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: gensym
cell gensym(void) {
	static int	id = 0;
	char		b[100];

	id++;
	sprintf(b, "G%d", id);
	return mksym(b, strlen(b));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl 0xe423(%rip), %eax      # 0x20954
addl $0x1, %eax
movl %eax, 0xe41a(%rip)      # 0x20954
leaq -0x70(%rbp), %rdi
movl 0xe410(%rip), %edx      # 0x20954
leaq 0x97a1(%rip), %rsi      # 0x1bcec
movb $0x0, %al
callq 0x21f0
leaq -0x70(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2090
movq -0x78(%rbp), %rdi
movl %eax, %esi
callq 0x4b30
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: untag
cell untag(cell x) {
	if (specialp(x)) return x;
	if (tag(x) & VECTOR_TAG) return NIL;
	if (closurep(x)) return cdr(cadddr(x));
	return cdr(x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x12598
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1263d
movq 0xddb1(%rip), %rax      # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x125bb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1263d
cmpl $0x0, -0x8(%rbp)
jl 0x1262c
movq 0xdd88(%rip), %rax      # 0x20350
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1262c
movq 0xdd61(%rip), %rcx      # 0x20340
movslq -0x8(%rbp), %rdx
movl $0xfffffff3, %eax       # imm = 0xFFFFFFF3
cmpl (%rcx,%rdx,4), %eax
jne 0x1262c
movq 0xdd54(%rip), %rax      # 0x20348
movq 0xdd45(%rip), %rcx      # 0x20340
movq 0xdd46(%rip), %rdx      # 0x20348
movq 0xdd3f(%rip), %rsi      # 0x20348
movq 0xdd38(%rip), %rdi      # 0x20348
movslq -0x8(%rbp), %r8
movslq (%rdi,%r8,4), %rdi
movslq (%rsi,%rdi,4), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x1263d
movq 0xdd15(%rip), %rax      # 0x20348
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: stkalloc
void stkalloc(int k) {
	cell	n, *vs, *vn;
	int	i;

	if (Sp + k >= Sz) {
		/* allocate multiples of CHUNKSIZE */
		if (k >= CHUNKSIZE) {
			k = Sp+k-Sz;
			k = CHUNKSIZE * (1 + (k / CHUNKSIZE));
		}
		else {
			k = CHUNKSIZE;
		}
		n = mkvec(Sz + k);
		vs = vector(Rts);
		vn = vector(n);
		for (i=0; i<=Sp; i++) vn[i] = vs[i];
		Sz += k;
		Rts = n;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl 0xdaff(%rip), %eax      # 0x20160
addl -0x4(%rbp), %eax
cmpl 0xdb5a(%rip), %eax      # 0x201c4
jl 0x12749
cmpl $0x400, -0x4(%rbp)      # imm = 0x400
jl 0x126a1
movl 0xdae1(%rip), %eax      # 0x20160
addl -0x4(%rbp), %eax
subl 0xdb3c(%rip), %eax      # 0x201c4
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl $0x400, %ecx            # imm = 0x400
cltd
idivl %ecx
addl $0x1, %eax
shll $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x126a8
movl $0x400, -0x4(%rbp)      # imm = 0x400
movl 0xdb16(%rip), %edi      # 0x201c4
addl -0x4(%rbp), %edi
callq 0x3d80
movl %eax, -0x8(%rbp)
movq 0xdc98(%rip), %rax      # 0x20358
movq 0xdc81(%rip), %rcx      # 0x20348
movslq 0xda8e(%rip), %rdx      # 0x2015c
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq 0xdc74(%rip), %rax      # 0x20358
movq 0xdc5d(%rip), %rcx      # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0xda52(%rip), %eax      # 0x20160
jg 0x12731
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12705
movl -0x4(%rbp), %eax
addl 0xda8a(%rip), %eax      # 0x201c4
movl %eax, 0xda84(%rip)      # 0x201c4
movl -0x8(%rbp), %eax
movl %eax, 0xda13(%rip)      # 0x2015c
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: push
void push(cell x) {
	Tmp = x;
	stkalloc(1);
	Tmp = NIL;
	Sp++;
	stackset(Sp, x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0xda10(%rip)      # 0x20174
movl $0x1, %edi
callq 0x12650
movl $0xffffffff, 0xd9fc(%rip) # imm = 0xFFFFFFFF
movl 0xd9e2(%rip), %eax      # 0x20160
addl $0x1, %eax
movl %eax, 0xd9d9(%rip)      # 0x20160
movl -0x4(%rbp), %edx
movq 0xdbc7(%rip), %rax      # 0x20358
movq 0xdbb0(%rip), %rcx      # 0x20348
movslq 0xd9bd(%rip), %rsi      # 0x2015c
movslq (%rcx,%rsi,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq 0xd9af(%rip), %rcx      # 0x20160
movl %edx, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: closure
cell closure(cell i, cell e) {
	cell	c;

	c = cons(Prog, NIL);
	c = cons(e, c);
	protect(c);
	c = cons(mkfix(i), c);
	unprot(1);
	return mkatom(T_CLOSURE, c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl 0xd988(%rip), %edi      # 0x201bc
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
movl 0xd914(%rip), %esi      # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0xd907(%rip)      # 0x20170
movl -0x4(%rbp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl $0x1, %edx
callq 0x3990
movl %eax, %edi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0xc(%rbp)
movl $0x1, %edi
callq 0x3d00
movl -0xc(%rbp), %esi
movl $0xfffffff3, %edi       # imm = 0xFFFFFFF3
movl $0x1, %edx
callq 0x3990
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: conses
int conses(cell n) {
	int	k;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movb $0x1, %al
cmpl $0x0, -0x4(%rbp)
movb %al, -0x9(%rbp)
jl 0x12e00
movq 0xd580(%rip), %rax      # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
andl $0x1, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x9(%rbp)
jne 0x12e00
movq 0xd564(%rip), %rax      # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x12e0b
jmp 0x12e27
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movq 0xd52d(%rip), %rax      # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x12dbe
movl -0x8(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: ret
int ret(void) {
	int	r, n;
	cell	*v;

	v = vector(Rts);
	Fp = fixval(v[Sp]);
	r = v[Sp-1];
	Prog = cdr(r);
	Ep = v[Sp-2];
	n = fixval(v[Sp-3]);
	Sp -= n+4;
	return fixval(car(r));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xd33d(%rip), %rax      # 0x20358
movq 0xd326(%rip), %rcx      # 0x20348
movslq 0xd133(%rip), %rdx      # 0x2015c
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq 0xd301(%rip), %rax      # 0x20340
movq 0xd302(%rip), %rcx      # 0x20348
movq -0x10(%rbp), %rdx
movslq 0xd10f(%rip), %rsi      # 0x20160
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xd166(%rip)      # 0x201c8
movq -0x10(%rbp), %rax
movl 0xd0f4(%rip), %ecx      # 0x20160
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movq 0xd2c9(%rip), %rax      # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xd130(%rip)      # 0x201bc
movq -0x10(%rbp), %rax
movl 0xd0ca(%rip), %ecx      # 0x20160
subl $0x2, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xd12b(%rip)      # 0x201d0
movq 0xd294(%rip), %rax      # 0x20340
movq 0xd295(%rip), %rcx      # 0x20348
movq -0x10(%rbp), %rdx
movl 0xd0a3(%rip), %esi      # 0x20160
subl $0x3, %esi
movslq %esi, %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %ecx
addl $0x4, %ecx
movl 0xd083(%rip), %eax      # 0x20160
subl %ecx, %eax
movl %eax, 0xd07b(%rip)      # 0x20160
movq 0xd254(%rip), %rax      # 0x20340
movq 0xd255(%rip), %rcx      # 0x20348
movq 0xd246(%rip), %rdx      # 0x20340
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: mkctag
cell mkctag(void) {
	cell	n;

	n = cons(Ep, Prog);
	Tmp = n; n = cons(mkfix(Fp), n);
	Tmp = n; n = cons(mkfix(Sp), n);
	Tmp = n; n = cons(mkfix(Ip+2), n);
	Tmp = NIL;
	return mkatom(T_CATCHTAG, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0xcd82(%rip), %edi      # 0x201d0
movl 0xcd68(%rip), %esi      # 0x201bc
xorl %edx, %edx
callq 0x3990
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0xcd0d(%rip)      # 0x20174
movl 0xcd5b(%rip), %edi      # 0x201c8
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl $0x1, %edx
callq 0x3990
movl %eax, %edi
movl -0x4(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0xcccf(%rip)      # 0x20174
movl 0xccb5(%rip), %edi      # 0x20160
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl $0x1, %edx
callq 0x3990
movl %eax, %edi
movl -0x4(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0xcc91(%rip)      # 0x20174
movl 0xd46f(%rip), %edi      # 0x20958
addl $0x2, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3990
movl %eax, %esi
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl $0x1, %edx
callq 0x3990
movl %eax, %edi
movl -0x4(%rbp), %esi
xorl %edx, %edx
callq 0x3990
movl %eax, -0x4(%rbp)
movl $0xffffffff, 0xcc4f(%rip) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %esi
movl $0xfffffff5, %edi       # imm = 0xFFFFFFF5
movl $0x1, %edx
callq 0x3990
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: throw
int throw(cell ct, cell v) {
	if (!ctagp(ct)) expect("throw", "catch tag", ct);
	ct = cdr(ct);
	Ip = fixval(car(ct)); ct = cdr(ct);
	Sp = fixval(car(ct)); ct = cdr(ct);
	Fp = fixval(car(ct)); ct = cdr(ct);
	Ep = car(ct);         ct = cdr(ct);
	Prog = ct;
	Acc = v;
	return Ip;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x13580
movq 0xcdf5(%rip), %rax      # 0x20350
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x13580
movq 0xcdce(%rip), %rcx      # 0x20340
movslq -0x4(%rbp), %rdx
movl $0xfffffff5, %eax       # imm = 0xFFFFFFF5
cmpl (%rcx,%rdx,4), %eax
je 0x13596
movl -0x4(%rbp), %edx
leaq 0x87c0(%rip), %rdi      # 0x1bd4a
leaq 0x87bf(%rip), %rsi      # 0x1bd50
callq 0x2950
movq 0xcdab(%rip), %rax      # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movq 0xcd92(%rip), %rax      # 0x20340
movq 0xcd93(%rip), %rcx      # 0x20348
movq 0xcd84(%rip), %rdx      # 0x20340
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xd387(%rip)      # 0x20958
movq 0xcd70(%rip), %rax      # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movq 0xcd57(%rip), %rax      # 0x20340
movq 0xcd58(%rip), %rcx      # 0x20348
movq 0xcd49(%rip), %rdx      # 0x20340
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xcb54(%rip)      # 0x20160
movq 0xcd35(%rip), %rax      # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movq 0xcd1c(%rip), %rax      # 0x20340
movq 0xcd1d(%rip), %rcx      # 0x20348
movq 0xcd0e(%rip), %rdx      # 0x20340
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xcb81(%rip)      # 0x201c8
movq 0xccfa(%rip), %rax      # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movq 0xcce1(%rip), %rax      # 0x20340
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xcb64(%rip)      # 0x201d0
movq 0xccd5(%rip), %rax      # 0x20348
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0xcb36(%rip)      # 0x201bc
movl -0x8(%rbp), %eax
movl %eax, 0xcb31(%rip)      # 0x201c0
movl 0xd2c3(%rip), %eax      # 0x20958
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: throwerr
int throwerr(cell ct) {
	cell	n;

	n = assq(S_errval, Glob);
	n = NIL == n? NIL: cadr(n);
	return throw(ct, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0xccef(%rip), %edi      # 0x203a0
movl 0xca8d(%rip), %esi      # 0x20144
callq 0x27c0
movl %eax, -0x8(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x8(%rbp), %eax
jne 0x136d3
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0xc(%rbp)
jmp 0x136ef
movq 0xcc66(%rip), %rax      # 0x20340
movq 0xcc67(%rip), %rcx      # 0x20348
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x13540
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: interpret
cell interpret(cell x) {
	cell	n;
	int	i;

	E0 = mkvec(length(Glob));
	i = 0;
	for (n = Glob; n != NIL; n = cdr(n)) {
		vector(E0)[i] = cdar(n);
		i++;
	}
	Ep = E0;
	run(x);
	return Acc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x71d3(%rip), %edi      # 0x20144
callq 0x7930
movl %eax, %edi
callq 0x3d80
movl %eax, 0x7249(%rip)      # 0x201cc
movl $0x0, -0xc(%rbp)
movl 0x71b4(%rip), %eax      # 0x20144
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
je 0x18ff5
movq 0x73a8(%rip), %rax      # 0x20348
movq 0x7399(%rip), %rcx      # 0x20340
movslq -0x8(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
movq 0x739f(%rip), %rax      # 0x20358
movq 0x7388(%rip), %rcx      # 0x20348
movslq 0x7205(%rip), %rsi      # 0x201cc
movslq (%rcx,%rsi,4), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq 0x735f(%rip), %rax      # 0x20348
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
jmp 0x18f93
movl 0x71d1(%rip), %eax      # 0x201cc
movl %eax, 0x71cf(%rip)      # 0x201d0
movl -0x4(%rbp), %edi
callq 0x13710
movl 0x71b1(%rip), %eax      # 0x201c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: initrts
void initrts(void) {
	Rts = NIL;
	Rts = mkvec(CHUNKSIZE);
	Sz = CHUNKSIZE;
	Sp = -1;
	Fp = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xffffffff, 0x70fe(%rip) # imm = 0xFFFFFFFF
movl $0x400, %edi            # imm = 0x400
callq 0x3d80
movl %eax, 0x70ee(%rip)      # 0x2015c
movl $0x400, 0x714c(%rip)    # imm = 0x400
movl $0xffffffff, 0x70de(%rip) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x713c(%rip) # imm = 0xFFFFFFFF
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: repl
void repl(void) {
	cell	x;

	if (setjmp(Restart) && Quiet)
		exit(EXIT_FAILURE);
	if (!Quiet) signal(SIGINT, kbdintr);
	for (;;) {
		reset_stdports();
		clrtrace();
		initrts();
		bindset(S_errtag, NIL);
		Protected = NIL;
		Run = 0;
		Intr = 0;
		if (!Quiet) {
			prints("* ");
			flush();
		}
		x = xread();
		if (EOFMARK == x && !Intr) break;
		Mxlev = 0;
		x = eval(x, 0);
		bindset(S_starstar, x);
		print(x);
	}
	if (!Quiet) nl();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x73e1(%rip), %rdi      # 0x20480
callq 0x2100
cmpl $0x0, %eax
je 0x190bc
cmpl $0x0, 0x78b0(%rip)      # 0x20960
je 0x190bc
movl $0x1, %edi
callq 0x2200
cmpl $0x0, 0x789d(%rip)      # 0x20960
jne 0x190d6
movl $0x2, %edi
leaq -0xb1(%rip), %rsi       # 0x19020
callq 0x2120
jmp 0x190d8
callq 0x5230
callq 0x2340
callq 0x19050
movl 0x72af(%rip), %edi      # 0x2039c
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2830
movl $0xffffffff, 0x706f(%rip) # imm = 0xFFFFFFFF
movl $0x0, 0x7851(%rip)      # 0x2095c
movl $0x0, 0x751b(%rip)      # 0x20630
cmpl $0x0, 0x7844(%rip)      # 0x20960
jne 0x1912f
leaq 0x2dfe(%rip), %rdi      # 0x1bf23
callq 0x25a0
callq 0x2af0
callq 0x6a20
movl %eax, -0x4(%rbp)
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
cmpl -0x4(%rbp), %eax
jne 0x1914e
movl 0x74e9(%rip), %eax      # 0x20630
cmpl $0x0, %eax
jne 0x1914e
jmp 0x19180
movl $0x0, 0x77f0(%rip)      # 0x20948
movl -0x4(%rbp), %edi
xorl %esi, %esi
callq 0xd550
movl %eax, -0x4(%rbp)
movl 0x77f9(%rip), %edi      # 0x20964
movl -0x4(%rbp), %esi
callq 0x2830
movl -0x4(%rbp), %edi
callq 0x7900
jmp 0x190d8
cmpl $0x0, 0x77d9(%rip)      # 0x20960
jne 0x19195
leaq 0x30f0(%rip), %rdi      # 0x1c280
callq 0x25a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: start
void start(void) {
	cell	n;

	if (setjmp(Restart)) return;
	if (!Quiet) signal(SIGINT, kbdintr);
	n = assq(S_start, Glob);
	if (NIL == n || closurep(cadr(n)) == 0) return;
	n = cons(cadr(n), NIL);
	eval(n, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x65e1(%rip), %rdi      # 0x20480
callq 0x2100
cmpl $0x0, %eax
je 0x19eae
jmp 0x19fad
cmpl $0x0, 0x6aab(%rip)      # 0x20960
jne 0x19ec8
movl $0x2, %edi
leaq -0xea3(%rip), %rsi      # 0x19020
callq 0x2120
movl 0x6a9e(%rip), %edi      # 0x2096c
movl 0x6270(%rip), %esi      # 0x20144
callq 0x27c0
movl %eax, -0x4(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x4(%rbp), %eax
je 0x19f79
movq 0x644f(%rip), %rcx      # 0x20340
movq 0x6450(%rip), %rax      # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rax,%rdx,4), %rdx
xorl %eax, %eax
cmpl $0x0, (%rcx,%rdx,4)
movb %al, -0x5(%rbp)
jl 0x19f6c
movq 0x643e(%rip), %rax      # 0x20350
movq 0x6427(%rip), %rcx      # 0x20340
movq 0x6428(%rip), %rdx      # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %rcx
movzbl (%rax,%rcx), %ecx
andl $0x1, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x5(%rbp)
je 0x19f6c
movq 0x63fc(%rip), %rcx      # 0x20340
movq 0x63f5(%rip), %rax      # 0x20340
movq 0x63f6(%rip), %rdx      # 0x20348
movslq -0x4(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movslq (%rax,%rdx,4), %rdx
movl $0xfffffff3, %eax       # imm = 0xFFFFFFF3
cmpl (%rcx,%rdx,4), %eax
sete %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x19f7b
jmp 0x19fad
movq 0x63be(%rip), %rax      # 0x20340
movq 0x63bf(%rip), %rcx      # 0x20348
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3990
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
xorl %esi, %esi
callq 0xd550
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: longusage
void longusage(void) {
	nl();
	usage();
	prints(	"\n"
		"-h         print help (also -v, -?)\n"
		"-L         print terms of use\n"
		"-i file    restart image from file (default: ");
	prints(	IMAGEFILE);
	prints(	")\n"
		"-i -       compile initial image from sources (");
	prints(	IMAGESRC);
	prints(	")\n"
		"           (-i must be the first option!)\n");
	prints(	"-l file    load program from file, can be repeated\n"
		"-q         quiet (no banner, no prompt, exit on errors)\n"
		"-- args    bind remaining arguments to (cmdline)\n"
		"file args  run program, args in (cmdline), implies -q\n"
		"\n");
	exit(EXIT_SUCCESS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2295(%rip), %rdi      # 0x1c280
callq 0x25a0
callq 0x19fc0
leaq 0x20d0(%rip), %rdi      # 0x1c0cc
callq 0x25a0
leaq 0x2135(%rip), %rdi      # 0x1c13d
callq 0x25a0
leaq 0x2133(%rip), %rdi      # 0x1c147
callq 0x25a0
leaq 0x2159(%rip), %rdi      # 0x1c179
callq 0x25a0
leaq 0x2155(%rip), %rdi      # 0x1c181
callq 0x25a0
leaq 0x2176(%rip), %rdi      # 0x1c1ae
callq 0x25a0
xorl %edi, %edi
callq 0x2200
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: terms
void terms(void) {
	nl();
	prints(	"LISP9 ");
	prints(VERSION);
	prints(	" by Nils M Holm, 2018,2019\n\n"
		"This program is in the public domain. In countries\n"
		"where the concept of the public domain does not exist,\n"
		"the Creative Commons Zero (CC0) license applies.\n"
		"See: https://creativecommons.org/publicdomain/zero/1.0/");
	nl();
	nl();
	exit(EXIT_SUCCESS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2225(%rip), %rdi      # 0x1c280
callq 0x25a0
leaq 0x221b(%rip), %rdi      # 0x1c282
callq 0x25a0
leaq 0x1bac(%rip), %rdi      # 0x1bc1f
callq 0x25a0
leaq 0x220a(%rip), %rdi      # 0x1c289
callq 0x25a0
leaq 0x21f5(%rip), %rdi      # 0x1c280
callq 0x25a0
leaq 0x21e9(%rip), %rdi      # 0x1c280
callq 0x25a0
xorl %edi, %edi
callq 0x2200
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: cmdarg
char *cmdarg(char *s) {
	if (NULL == s) {
		usage();
		exit(EXIT_FAILURE);
	}
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
jne 0x1a0d3
callq 0x19fc0
movl $0x1, %edi
callq 0x2200
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/blakemcbride[P]LISP9/ls9.c
// Function: argvec
cell argvec(char **argv) {
	int	i;
	cell	a, n;

	if (NULL == argv[0]) return NIL;
	a = cons(NIL, NIL);
	protect(a);
	for (i = 0; argv[i] != NULL; i++) {
		n = mkstr(argv[i], strlen(argv[i]));
		car(a) = n;
		if (argv[i+1] != NULL) {
			n = cons(NIL, NIL);
			cdr(a) = n;
			a = cdr(a);
		}
	}
	return unprot(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x1a103
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1a1e8
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
movl %esi, %edi
callq 0x3990
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
movl 0x6053(%rip), %esi      # 0x20170
xorl %edx, %edx
callq 0x3990
movl %eax, 0x6046(%rip)      # 0x20170
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1a1db
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2090
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x2880
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edx
movq 0x61c3(%rip), %rax      # 0x20340
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1a1cb
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
movl %esi, %edi
callq 0x3990
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edx
movq 0x6195(%rip), %rax      # 0x20348
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x6187(%rip), %rax      # 0x20348
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
jmp 0x1a1cd
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1a131
movl $0x1, %edi
callq 0x3d00
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yangtau[P]hedgehog/src/test/../string.c
// Function: hg_str_new
hg_str hg_str_new(const char* from, size_t len) {
    char* s = hg_alloc(sizeof(char) * (len + 1));
    s[len]  = '\0';
    _strtable_append(s);

    return strncpy(s, from, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
shlq $0x0, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rdi
callq 0x1310
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1040
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yangtau[P]hedgehog/src/test/../string.c
// Function: strtable_append
static void _strtable_append(hg_str s) {
    if (_string_table.len >= _string_table.cap) {
        _string_table.cap *= 2;
        _string_table.arr = hg_realloc(_string_table.arr, sizeof(hg_str) * _string_table.cap);
    }

    _string_table.arr[_string_table.len++] = s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq 0x2d5d(%rip), %rax      # 0x4080
cmpq 0x2d5e(%rip), %rax      # 0x4088
jb 0x136b
movq 0x2d55(%rip), %rax      # 0x4088
shlq %rax
movq %rax, 0x2d4b(%rip)      # 0x4088
movq 0x2d34(%rip), %rcx      # 0x4078
movq 0x2d3d(%rip), %rax      # 0x4088
shlq $0x3, %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10b0
movq %rax, 0x2d0d(%rip)      # 0x4078
movq -0x18(%rbp), %rdx
movq 0x2d02(%rip), %rax      # 0x4078
movq 0x2d03(%rip), %rcx      # 0x4080
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x2cf5(%rip)      # 0x4080
movq %rdx, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yangtau[P]hedgehog/src/test/../string.c
// Function: hg_strbuf_init
void hg_strbuf_init(struct hg_strbuf* buf) {
    assert(_start_cap > 0);
    buf->_cap   = _start_cap;
    buf->len    = 0;
    buf->_moved = false;
    buf->_str   = hg_alloc(sizeof(char) * buf->_cap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x20, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shlq $0x0, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yangtau[P]hedgehog/src/test/../string.c
// Function: hg_strbuf_append
bool hg_strbuf_append(struct hg_strbuf* buf, const char* fmt, ...) {
    va_list args;
    assert(buf->_cap > buf->len);

    for (int i = 0; i < 2; i++) {
        size_t left = buf->_cap - buf->len;
        char* start = buf->_str + buf->len;

        va_start(args, fmt);
        int written = vsnprintf(start, left, fmt, args);
        va_end(args);

        if (written < 0) {
            return false; // error
        }
        if (written < (int)(left)) {
            buf->len += written;
            return true;
        }

        if (i == 0) {
            // buf is not enough, retry
            // only extend buffer at the first try
            _strbuf_expend(buf, written);
        }
    }

    assert(0);
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x149e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x14d5
jmp 0x14f4
leaq 0xb28(%rip), %rdi       # 0x2004
leaq 0xb36(%rip), %rsi       # 0x2019
movl $0x4b, %edx
leaq 0xb36(%rip), %rcx       # 0x2025
callq 0x1070
movl $0x0, -0x34(%rbp)
cmpl $0x2, -0x34(%rbp)
jge 0x15b9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
subq (%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
addq (%rcx), %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x1050
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rax
cmpl $0x0, -0x4c(%rbp)
jge 0x1577
movb $0x0, -0x1(%rbp)
jmp 0x15d8
movl -0x4c(%rbp), %eax
movq -0x40(%rbp), %rcx
cmpl %ecx, %eax
jge 0x1596
movslq -0x4c(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x15d8
cmpl $0x0, -0x34(%rbp)
jne 0x15a9
movq -0x10(%rbp), %rdi
movslq -0x4c(%rbp), %rsi
callq 0x15f0
jmp 0x15ab
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x14fb
leaq 0xe45(%rip), %rdi       # 0x2405
leaq 0xa52(%rip), %rsi       # 0x2019
movl $0x64, %edx
leaq 0xa52(%rip), %rcx       # 0x2025
callq 0x1070
movb -0x1(%rbp), %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yangtau[P]hedgehog/src/test/../string.c
// Function: strbuf_expend
static void _strbuf_expend(struct hg_strbuf* buf, size_t want) {
    assert(buf->_cap > buf->len);
    while ((buf->_cap - buf->len - 1) < want)
        buf->_cap *= 2;

    buf->_str = hg_realloc(buf->_str, sizeof(char) * buf->_cap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x1613
jmp 0x1632
leaq 0x9ea(%rip), %rdi       # 0x2004
leaq 0x9f8(%rip), %rsi       # 0x2019
movl $0x42, %edx
leaq 0xa85(%rip), %rcx       # 0x20b2
callq 0x1070
jmp 0x1634
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
subq (%rcx), %rax
subq $0x1, %rax
cmpq -0x20(%rbp), %rax
jae 0x165e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
shlq %rcx
movq %rcx, 0x8(%rax)
jmp 0x1634
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
shlq $0x0, %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yangtau[P]hedgehog/src/test/../string.c
// Function: hg_strbuf_to_str
hg_str hg_strbuf_to_str(struct hg_strbuf* buf) {
    assert(buf->_cap > buf->len);

    buf->_str[buf->len] = '\0';
    buf->_moved         = true;

    _strtable_append(buf->_str);
    return buf->_str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x16bf
jmp 0x16de
leaq 0x93e(%rip), %rdi       # 0x2004
leaq 0x94c(%rip), %rsi       # 0x2019
movl $0x69, %edx
leaq 0x98a(%rip), %rcx       # 0x2063
callq 0x1070
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movb $0x1, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1310
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop