LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leal -0x25(%rsi), %eax
cmpl $-0x24, %eax
jbe 0xcc4f
movq 0xc752(%rip), %rax      # 0x19340
movq 0xc753(%rip), %rcx      # 0x19348
movslq %edi, %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %ecx
movb $0x0, 0xcb11(%rip)      # 0x19717
leaq 0xcb09(%rip), %rbx      # 0x19716
leaq 0x771c(%rip), %rdi      # 0x14330
movl %ecx, %eax
cltd
idivl %esi
movl %edx, %r8d
negl %r8d
cmovsl %edx, %r8d
movb (%r8,%rdi), %dl
movb %dl, (%rbx)
decq %rbx
testl %eax, %eax
jne 0xcc16
testl %ecx, %ecx
js 0xcc39
incq %rbx
jmp 0xcc3c
movb $0x2d, (%rbx)
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
jmp 0x27b0
movl %esi, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
leaq 0x6e93(%rip), %rdi      # 0x13b0b
movl %eax, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
callq 0x3ecb
testl %eax, %eax
js 0xcdab
movl %eax, %ebx
movl %eax, %r15d
cmpl $0x13, %eax
ja 0xcced
leaq 0xc918(%rip), %rax      # 0x19600
orb $0x40, (%r15,%rax)
movl 0xc854(%rip), %r12d     # 0x19548
movl 0xc43a(%rip), %ebp      # 0x19134
movq %r14, %rdi
callq 0x2080
movq %r14, %rdi
movl %eax, %esi
callq 0x27b0
movl 0xc426(%rip), %esi      # 0x19138
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0xc417(%rip)      # 0x19138
movl $0x1, 0xc409(%rip)      # 0x19134
callq 0xcdcb
movl %ebx, 0xc812(%rip)      # 0x19548
callq 0x5116
movl %r12d, 0xc806(%rip)     # 0x19548
cmpl $-0x3, %eax
je 0xcd52
movl %eax, %edi
xorl %esi, %esi
callq 0x9aff
jmp 0xcd30
callq 0xcead
movq 0xc5ea(%rip), %rax      # 0x19348
movslq 0xc3d3(%rip), %rcx      # 0x19138
movl (%rax,%rcx,4), %eax
movl %eax, 0xc3ca(%rip)      # 0x19138
movl %ebp, 0xc3c0(%rip)      # 0x19134
cmpl $0x13, %ebx
ja 0xcda2
leaq 0xc7e0(%rip), %rbx      # 0x19560
movq (%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0xcd96
callq 0x2070
movq $0x0, (%rbx,%r15,8)
leaq 0xc863(%rip), %rax      # 0x19600
movb $0x0, (%r15,%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x2080
movq %r14, %rdi
movl %eax, %esi
callq 0x27b0
leaq 0x6d6b(%rip), %rdi      # 0x13b2f
movl %eax, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movl 0xc3ea(%rip), %edi      # 0x191bc
movl 0xc398(%rip), %esi      # 0x19170
xorl %edx, %edx
callq 0x30e7
movl %eax, 0xc38b(%rip)      # 0x19170
movl 0xc3e5(%rip), %edi      # 0x191d0
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0xc376(%rip)      # 0x19170
movl 0xcb58(%rip), %edi      # 0x19958
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
movl 0xc34a(%rip), %esi      # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0xc33b(%rip)      # 0x19170
movl 0xc325(%rip), %edi      # 0x19160
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
movl 0xc30f(%rip), %esi      # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0xc300(%rip)      # 0x19170
movl 0xc352(%rip), %edi      # 0x191c8
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
movl 0xc2d4(%rip), %esi      # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0xc2c5(%rip)      # 0x19170
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq 0xc488(%rip), %rbx      # 0x19340
movq 0xc489(%rip), %r14      # 0x19348
movl $0x1, %edi
callq 0x335c
cltq
movslq (%r14,%rax,4), %rax
movl (%rbx,%rax,4), %eax
movl %eax, 0xc2f0(%rip)      # 0x191c8
movq 0xc461(%rip), %rbx      # 0x19340
movq 0xc462(%rip), %r14      # 0x19348
movl $0x1, %edi
callq 0x335c
cltq
movslq (%r14,%rax,4), %rax
movl (%rbx,%rax,4), %eax
movl %eax, 0xc261(%rip)      # 0x19160
movq 0xc43a(%rip), %rbx      # 0x19340
movq 0xc43b(%rip), %r14      # 0x19348
movl $0x1, %edi
callq 0x335c
cltq
movslq (%r14,%rax,4), %rax
movl (%rbx,%rax,4), %eax
movl %eax, 0xca32(%rip)      # 0x19958
movl $0x1, %edi
callq 0x335c
movl %eax, 0xc29a(%rip)      # 0x191d0
movl $0x1, %edi
callq 0x335c
movl %eax, 0xc276(%rip)      # 0x191bc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x68, %rsp
movl %edi, %ebx
testl %edi, %edi
js 0xcfaf
movq 0xc3ee(%rip), %rcx      # 0x19350
movl %ebx, %eax
testb $0x8, (%rcx,%rax)
je 0xcfaf
movq 0xc3cf(%rip), %rcx      # 0x19340
cmpl $-0x11, (%rcx,%rax,4)
jne 0xcfaf
movq 0xc3da(%rip), %rcx      # 0x19358
movq 0xc3c3(%rip), %rdx      # 0x19348
movslq (%rdx,%rax,4), %rax
cmpl $0x51, -0x4(%rcx,%rax,4)
jge 0xcfd6
leaq (%rcx,%rax,4), %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x2040
movq %rbx, %rdi
callq 0xccbf
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x6395(%rip), %rsi      # 0x1334b
leaq 0x6606(%rip), %rdx      # 0x135c3
leaq 0x65a9(%rip), %rcx      # 0x1356d
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
jmp 0xcfdd
leaq 0x6b69(%rip), %rdi      # 0x13b46
movl %ebx, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
callq 0x2080
addq $-0x49, %rax
cmpq $-0x51, %rax
jbe 0xd083
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2040
movq %r14, %rdi
movl $0x2e, %esi
callq 0x20a0
testq %rax, %rax
jne 0xd04c
movq %rsp, %rdi
callq 0x2080
addq %rsp, %rax
movb $0x0, (%rax)
movq %rsp, %r14
movq %r14, %rdi
callq 0x2080
movabsq $0x6567616d696f2e, %rcx # imm = 0x6567616D696F2E
movq %rcx, (%rsp,%rax)
movq %r14, %rdi
callq 0x2030
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21d0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
leaq 0x6ae7(%rip), %rdi      # 0x13b71
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
movq 0xbe86(%rip), %rax      # 0x19348
movslq %edi, %r14
movslq (%rax,%r14,4), %rdi
shlq $0x2, %rdi
addq 0xbe84(%rip), %rdi      # 0x19358
callq 0xd094
testq %rax, %rax
jne 0xd525
movl 0xbc60(%rip), %esi      # 0x19144
cmpl $-0x1, %esi
je 0xd51f
movl 0xc461(%rip), %edx      # 0x19950
movq 0xbe4a(%rip), %rax      # 0x19340
movq 0xbe4b(%rip), %rcx      # 0x19348
movslq %esi, %rdi
movslq (%rax,%rdi,4), %rsi
cmpl %edx, (%rax,%rsi,4)
je 0xd513
movl (%rcx,%rdi,4), %esi
cmpl $-0x1, %esi
jne 0xd4fd
jmp 0xd51f
cmpl $-0x1, %esi
je 0xd51f
movslq (%rcx,%rsi,4), %rcx
movl %ebx, (%rax,%rcx,4)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq 0xbe19(%rip), %rax      # 0x19348
movslq (%rax,%r14,4), %rdi
shlq $0x2, %rdi
addq 0xbe1a(%rip), %rdi      # 0x19358
callq 0x2030
movq %r15, %rdi
movl %r14d, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
callq 0x31ae
movl $0x40000, %edi          # imm = 0x40000
subl 0xbe01(%rip), %edi      # 0x19360
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
xorl %ebx, %ebx
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl 0xbbdb(%rip), %esi      # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0xbbcc(%rip)      # 0x19170
movl 0xbb86(%rip), %eax      # 0x19130
cmpl $-0x1, %eax
je 0xd5c4
xorl %ebx, %ebx
movq 0xbd90(%rip), %rcx      # 0x19348
incl %ebx
cltq
movl (%rcx,%rax,4), %eax
cmpl $-0x1, %eax
jne 0xd5b8
movl %ebx, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
movl %eax, %ebx
movl $0x1, %edi
callq 0x335c
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
popq %rbx
jmp 0x30e7
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x68, %rsp
movl 0xc349(%rip), %edx      # 0x19954
incl %edx
movl %edx, 0xc341(%rip)      # 0x19954
leaq 0x665a(%rip), %rsi      # 0x13c74
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
callq 0x2080
leal 0x1(%rax), %esi
movl $0xffffffee, %edi       # imm = 0xFFFFFFEE
callq 0x32cf
movq 0xbd05(%rip), %rcx      # 0x19348
movslq %eax, %r14
movslq (%rcx,%r14,4), %rdi
shlq $0x2, %rdi
addq 0xbd03(%rip), %rdi      # 0x19358
movq %rbx, %rsi
callq 0x2040
movl %r14d, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl %edi, %eax
testl %edi, %edi
js 0xd6c1
movq 0xbcdb(%rip), %rdx      # 0x19350
movl %eax, %ecx
movzbl (%rdx,%rcx), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb $0x8, %dl
jne 0xd6c1
testb $0x1, %dl
je 0xd6b4
movq 0xbcaf(%rip), %rax      # 0x19340
cmpl $-0xd, (%rax,%rcx,4)
jne 0xd6b4
movq 0xbcaa(%rip), %rdx      # 0x19348
movslq (%rdx,%rcx,4), %rcx
movslq (%rdx,%rcx,4), %rcx
movslq (%rdx,%rcx,4), %rcx
movslq (%rax,%rcx,4), %rax
leaq (%rdx,%rax,4), %rcx
jmp 0xd6bf
shlq $0x2, %rcx
addq 0xbc89(%rip), %rcx      # 0x19348
movl (%rcx), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl %edi, %eax
movl 0xba96(%rip), %ecx      # 0x19160
addl %edi, %ecx
movl 0xbaf2(%rip), %edi      # 0x191c4
subl %edi, %ecx
jl 0xd761
pushq %rbx
movl $0x400, %ebx            # imm = 0x400
cmpl $0x400, %eax            # imm = 0x400
jl 0xd6fe
leal 0x3ff(%rcx), %ebx
testl %ecx, %ecx
cmovnsl %ecx, %ebx
andl $0xfffffc00, %ebx       # imm = 0xFFFFFC00
addl $0x400, %ebx            # imm = 0x400
addl %ebx, %edi
callq 0x33a7
cmpl $0x0, 0xba54(%rip)      # 0x19160
js 0xd754
movq 0xbc43(%rip), %rdx      # 0x19358
movq 0xbc2c(%rip), %rsi      # 0x19348
movslq 0xba39(%rip), %rcx      # 0x1915c
movslq (%rsi,%rcx,4), %rcx
leaq (%rdx,%rcx,4), %rcx
movslq %eax, %rdi
movslq (%rsi,%rdi,4), %rsi
leaq (%rdx,%rsi,4), %rdx
movq $-0x1, %rsi
movl 0x4(%rcx,%rsi,4), %edi
movl %edi, 0x4(%rdx,%rsi,4)
movslq 0xba14(%rip), %rdi      # 0x19160
incq %rsi
cmpq %rdi, %rsi
jl 0xd73d
addl %ebx, 0xba6a(%rip)      # 0x191c4
movl %eax, 0xb9fc(%rip)      # 0x1915c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: push
void push(cell x) {
	Tmp = x;
	stkalloc(1);
	Tmp = NIL;
	Sp++;
	stackset(Sp, x);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl %edi, 0xba09(%rip)      # 0x19174
movl $0x1, %edi
callq 0xd6c2
movl $0xffffffff, 0xb9f5(%rip) # imm = 0xFFFFFFFF
movslq 0xb9da(%rip), %rax      # 0x19160
leaq 0x1(%rax), %rcx
movl %ecx, 0xb9d0(%rip)      # 0x19160
movq 0xbbb1(%rip), %rcx      # 0x19348
movslq 0xb9be(%rip), %rdx      # 0x1915c
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0xbbab(%rip), %rcx      # 0x19358
movl %ebx, 0x4(%rcx,%rax,4)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl 0xb9b4(%rip), %edi      # 0x191bc
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebx
movl 0xb949(%rip), %esi      # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0xb93a(%rip)      # 0x19170
movl %ebp, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
movl %eax, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebx
movl $0x1, %edi
callq 0x335c
movl $0xfffffff3, %edi       # imm = 0xFFFFFFF3
movl %ebx, %esi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x30e7
// File: /workspace/github_c_makefile_star2_O3/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:
testl %edi, %edi
js 0xdba4
movq 0xb7c7(%rip), %rcx      # 0x19350
xorl %eax, %eax
movq 0xb7b6(%rip), %rdx      # 0x19348
movl %edi, %esi
testb $0x9, (%rcx,%rsi)
jne 0xdba3
incl %eax
movl (%rdx,%rsi,4), %edi
testl %edi, %edi
jns 0xdb92
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: applis
int applis(int tail) {
	cell	a, p, new;
	int	k, i;

	a = boxref(stackref(Sp));
	if (!pairp(a) && a != NIL) error("apply: expected list", a);
	k = conses(a);
	stkalloc(k);
	Sp += k;
	i = Sp-1;
	for (p = a; p != NIL; p = cdr(p)) {
		if (atomp(p)) error("apply: dotted list", a);
		new = box(car(p));
		stackset(i, new);
		i--;
	}
	new = mkfix(k);
	stackset(Sp, new);
	return apply(tail);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
movq 0xb788(%rip), %rcx      # 0x19340
movq 0xb789(%rip), %rax      # 0x19348
movslq 0xb596(%rip), %rdx      # 0x1915c
movslq (%rax,%rdx,4), %rdx
shlq $0x2, %rdx
addq 0xb783(%rip), %rdx      # 0x19358
movslq 0xb584(%rip), %rsi      # 0x19160
movslq (%rdx,%rsi,4), %rdx
movslq (%rcx,%rdx,4), %r14
testq %r14, %r14
js 0xdc1f
movq 0xb760(%rip), %rcx      # 0x19350
movzbl (%rcx,%r14), %edx
testb $0x1, %dl
jne 0xdd1c
testb $0x8, %dl
jne 0xdd1c
xorl %ebp, %ebp
movl %r14d, %edx
movl %edx, %edx
testb $0x9, (%rcx,%rdx)
jne 0xdc2b
incl %ebp
movl (%rax,%rdx,4), %edx
testl %edx, %edx
jns 0xdc0c
jmp 0xdc2b
xorl %ebp, %ebp
cmpl $-0x1, %r14d
jne 0xdd1c
movl %ebp, %edi
callq 0xd6c2
movl 0xb528(%rip), %eax      # 0x19160
addl %ebp, %eax
movl %eax, 0xb520(%rip)      # 0x19160
cmpl $-0x1, %r14d
je 0xdcb5
cltq
leaq -0x4(,%rax,4), %r15
movl %r14d, %eax
testl %eax, %eax
js 0xdd0d
movq 0xb6ee(%rip), %rcx      # 0x19350
movl %eax, %r12d
testb $0x9, (%rcx,%r12)
jne 0xdd0d
movq 0xb6c9(%rip), %rax      # 0x19340
movl (%rax,%r12,4), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movq 0xb6ba(%rip), %rcx      # 0x19348
movslq 0xb4c7(%rip), %rdx      # 0x1915c
movslq (%rcx,%rdx,4), %rdx
shlq $0x2, %rdx
addq 0xb6b4(%rip), %rdx      # 0x19358
movl %eax, (%r15,%rdx)
movl (%rcx,%r12,4), %eax
addq $-0x4, %r15
cmpl $-0x1, %eax
jne 0xdc53
movl %ebp, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
movq 0xb66a(%rip), %rcx      # 0x19348
movslq 0xb477(%rip), %rdx      # 0x1915c
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0xb664(%rip), %rcx      # 0x19358
movslq 0xb465(%rip), %rdx      # 0x19160
movl %eax, (%rcx,%rdx,4)
movl %ebx, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xd886
leaq 0x5fab(%rip), %rdi      # 0x13cbf
movl %r14d, %esi
callq 0x2643
leaq 0x5f87(%rip), %rdi      # 0x13caa
jmp 0xdd14
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0xb61c(%rip), %rax      # 0x19348
movslq 0xb429(%rip), %rcx      # 0x1915c
movslq (%rax,%rcx,4), %rcx
shlq $0x2, %rcx
addq 0xb616(%rip), %rcx      # 0x19358
movq 0xb5f7(%rip), %rdx      # 0x19340
movslq 0xb410(%rip), %rsi      # 0x19160
movslq (%rcx,%rsi,4), %rdi
movslq (%rax,%rdi,4), %rdi
movl (%rdx,%rdi,4), %edi
movl %edi, 0xb467(%rip)      # 0x191c8
movslq -0x4(%rcx,%rsi,4), %rdi
movl (%rax,%rdi,4), %r8d
movl %r8d, 0xb44b(%rip)      # 0x191bc
movl -0x8(%rcx,%rsi,4), %r8d
movl %r8d, 0xb453(%rip)      # 0x191d0
movslq -0xc(%rcx,%rsi,4), %rcx
movslq (%rax,%rcx,4), %rcx
movl (%rdx,%rcx,4), %ecx
subl %ecx, %esi
addl $-0x4, %esi
movl %esi, 0xb3cc(%rip)      # 0x19160
movslq (%rdx,%rdi,4), %rcx
movslq (%rax,%rcx,4), %rax
movl (%rdx,%rax,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movl 0xb153(%rip), %edi      # 0x191d0
movl 0xb139(%rip), %esi      # 0x191bc
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebx
movl %eax, 0xb0e2(%rip)      # 0x19174
movl 0xb130(%rip), %edi      # 0x191c8
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
movl %eax, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebx
movl %eax, 0xb0a9(%rip)      # 0x19174
movl 0xb08f(%rip), %edi      # 0x19160
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
movl %eax, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebx
movl %eax, 0xb070(%rip)      # 0x19174
movl 0xb84e(%rip), %edi      # 0x19958
addl $0x2, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x30e7
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x30e7
movl %eax, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x30e7
movl $0xffffffff, 0xb032(%rip) # imm = 0xFFFFFFFF
movl $0xfffffff5, %edi       # imm = 0xFFFFFFF5
movl %eax, %esi
movl $0x1, %edx
popq %rbx
jmp 0x30e7
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x68, %rsp
movl %edi, %ebx
testl %edi, %edi
js 0xe1ef
movq 0xb1e4(%rip), %rcx      # 0x19350
movl %ebx, %eax
testb $0x1, (%rcx,%rax)
je 0xe1ef
movq 0xb1c5(%rip), %rcx      # 0x19340
cmpl $-0xb, (%rcx,%rax,4)
jne 0xe1ef
movq 0xb1c0(%rip), %rdx      # 0x19348
movslq (%rdx,%rax,4), %rdi
movslq (%rcx,%rdi,4), %rax
movslq (%rdx,%rax,4), %rax
movl (%rcx,%rax,4), %eax
movl %eax, 0xb7bb(%rip)      # 0x19958
movslq (%rdx,%rdi,4), %rdi
movslq (%rcx,%rdi,4), %r8
movslq (%rdx,%r8,4), %r8
movl (%rcx,%r8,4), %r8d
movl %r8d, 0xafac(%rip)      # 0x19160
movslq (%rdx,%rdi,4), %rdi
movslq (%rcx,%rdi,4), %r8
movslq (%rdx,%r8,4), %r8
movl (%rcx,%r8,4), %r8d
movl %r8d, 0xaffd(%rip)      # 0x191c8
movslq (%rdx,%rdi,4), %rdi
movl (%rcx,%rdi,4), %ecx
movl %ecx, 0xaff8(%rip)      # 0x191d0
movl (%rdx,%rdi,4), %ecx
movl %ecx, 0xafdb(%rip)      # 0x191bc
movl %esi, 0xafd9(%rip)      # 0x191c0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x5155(%rip), %rsi      # 0x1334b
leaq 0x5ad5(%rip), %rdx      # 0x13cd2
leaq 0x5ad4(%rip), %rcx      # 0x13cd8
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x2643
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: throwerr
int throwerr(cell ct) {
	cell	n;

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

// Assembly:
movl 0xaf22(%rip), %r8d      # 0x19144
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpl $-0x1, %r8d
je 0xe154
movl 0xb169(%rip), %edx      # 0x193a0
movq 0xb102(%rip), %rax      # 0x19340
movq 0xb103(%rip), %rcx      # 0x19348
movslq %r8d, %r9
movslq (%rax,%r9,4), %r8
cmpl %edx, (%rax,%r8,4)
je 0xe261
movl (%rcx,%r9,4), %r8d
cmpl $-0x1, %r8d
jne 0xe245
jmp 0xe154
cmpl $-0x1, %r8d
je 0xe154
movslq (%rcx,%r8,4), %rcx
movl (%rax,%rcx,4), %esi
jmp 0xe154
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movl %edi, %ebx
movl 0x86c6(%rip), %eax      # 0x19144
xorl %edi, %edi
cmpl $-0x1, %eax
je 0x10a98
movq 0x88bc(%rip), %rcx      # 0x19348
incl %edi
cltq
movl (%rcx,%rax,4), %eax
cmpl $-0x1, %eax
jne 0x10a8c
callq 0x33a7
movl %eax, 0x8729(%rip)      # 0x191cc
movl 0x869b(%rip), %esi      # 0x19144
cmpl $-0x1, %esi
je 0x10aee
movq 0x8893(%rip), %rax      # 0x19348
movq 0x8884(%rip), %rcx      # 0x19340
movq 0x8895(%rip), %rdx      # 0x19358
movslq %esi, %rsi
movslq (%rcx,%rsi,4), %rdi
movl (%rax,%rdi,4), %edi
movslq 0x86f8(%rip), %r8       # 0x191cc
movslq (%rax,%r8,4), %r8
movl %edi, (%rdx,%r8,4)
movl (%rax,%rsi,4), %esi
addq $0x4, %rdx
cmpl $-0x1, %esi
jne 0x10ac3
movl 0x86de(%rip), %eax      # 0x191cc
movl %eax, 0x86dc(%rip)      # 0x191d0
movl %ebx, %edi
callq 0xe277
movl 0x86bf(%rip), %eax      # 0x191c0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: initrts
void initrts(void) {
	Rts = NIL;
	Rts = mkvec(CHUNKSIZE);
	Sz = CHUNKSIZE;
	Sp = -1;
	Fp = -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, 0x862b(%rip)      # 0x1915c
movl $0xffffffed, %edi       # imm = 0xFFFFFFED
movl $0x1000, %esi           # imm = 0x1000
callq 0x32cf
movq 0x8801(%rip), %rcx      # 0x19348
movslq %eax, %r14
movslq (%rcx,%r14,4), %rdi
shlq $0x2, %rdi
addq 0x87ff(%rip), %rdi      # 0x19358
movl $0x1000, %edx           # imm = 0x1000
movl $0xff, %esi
callq 0x20b0
movl %r14d, 0x85ed(%rip)     # 0x1915c
movl $0x400, 0x864b(%rip)    # imm = 0x400
movl %ebx, 0x85e1(%rip)      # 0x19160
movl %ebx, 0x8643(%rip)      # 0x191c8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq 0x7925(%rip), %rdi      # 0x19480
callq 0x20f0
testl %eax, %eax
je 0x11b66
popq %rbx
retq
cmpl $0x0, 0x7df3(%rip)      # 0x19960
jne 0x11b80
leaq -0x1073(%rip), %rsi     # 0x10b03
movl $0x2, %edi
callq 0x2110
movl 0x75be(%rip), %esi      # 0x19144
cmpl $-0x1, %esi
je 0x11b64
movl 0x7ddb(%rip), %edx      # 0x1996c
movq 0x77a8(%rip), %rax      # 0x19340
movq 0x77a9(%rip), %rcx      # 0x19348
movslq %esi, %rdi
movslq (%rax,%rdi,4), %rsi
cmpl %edx, (%rax,%rsi,4)
je 0x11bb7
movl (%rcx,%rdi,4), %edi
movl %edi, %esi
cmpl $-0x1, %edi
jne 0x11b9f
jmp 0x11b64
cmpl $-0x1, %esi
je 0x11b64
movslq (%rcx,%rsi,4), %rcx
movslq (%rax,%rcx,4), %rcx
testq %rcx, %rcx
js 0x11b64
movq 0x7780(%rip), %rdx      # 0x19350
testb $0x1, (%rdx,%rcx)
je 0x11b64
cmpl $-0xd, (%rax,%rcx,4)
jne 0x11b64
movl %ecx, %edi
xorl %ebx, %ebx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %ebx, %edx
callq 0x30e7
movl %eax, %edi
movl %ebx, %esi
callq 0x9aff
jmp 0x11b64
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq 0x2581(%rip), %rbx      # 0x14208
movq %rbx, %rdi
callq 0x25e2
leaq 0x2574(%rip), %rdi      # 0x1420a
callq 0x25e2
leaq 0x1f05(%rip), %rdi      # 0x13ba7
callq 0x25e2
leaq 0x2563(%rip), %rdi      # 0x14211
callq 0x25e2
movq %rbx, %rdi
callq 0x25e2
movq %rbx, %rdi
callq 0x25e2
xorl %edi, %edi
callq 0x21f0
// File: /workspace/github_c_makefile_star2_O3/blakemcbride[P]LISP9/ls9.c
// Function: cmdarg
char *cmdarg(char *s) {
	if (NULL == s) {
		usage();
		exit(EXIT_FAILURE);
	}
	return s;
}

// Assembly:
testq %rdi, %rdi
je 0x11cd3
movq %rdi, %rax
retq
pushq %rax
callq 0x11bfa
movl $0x1, %edi
callq 0x21f0
// File: /workspace/github_c_makefile_star2_O3/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:
cmpq $0x0, (%rdi)
je 0x11d86
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebp
movl 0x7463(%rip), %esi      # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x30e7
movl %eax, 0x7454(%rip)      # 0x19170
movq (%rbx), %r14
testq %r14, %r14
je 0x11d78
addq $0x8, %rbx
movq %r14, %rdi
callq 0x2080
movq %r14, %rdi
movl %eax, %esi
callq 0x27b0
movq 0x75ff(%rip), %rcx      # 0x19340
movslq %ebp, %r14
movl %eax, (%rcx,%r14,4)
cmpq $0x0, (%rbx)
je 0x11d78
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x30e7
movl %eax, %ebp
movq 0x75e0(%rip), %rax      # 0x19348
movl %ebp, (%rax,%r14,4)
movq (%rbx), %r14
addq $0x8, %rbx
testq %r14, %r14
jne 0x11d28
movl $0x1, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x335c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/samtools-0.1.19/misc/ace2sam.c
// Function: remove_pads
static void remove_pads(const kstring_t *src, kstring_t *dst)
{
	int i, j;
	dst->l = 0;
	kputsn(src->s, src->l, dst);
	for (i = j = 0; i < dst->l; ++i)
		if (dst->s[i] != '*') dst->s[j++] = dst->s[i];
	dst->s[j] = 0;
	dst->l = j;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq $0x0, (%rsi)
movq 0x10(%rdi), %r15
movslq (%rdi), %r14
leaq 0x1(%r14), %rax
cmpq 0x8(%rsi), %rax
jae 0x33ab
movq 0x10(%rbx), %rax
xorl %edi, %edi
jmp 0x33f3
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rsi
shrq $0x10, %rsi
orq %rax, %rsi
incq %rsi
movq %rsi, 0x8(%rbx)
movq 0x10(%rbx), %rdi
callq 0x1100
movq %rax, 0x10(%rbx)
movq (%rbx), %rdi
addq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x10d0
addq (%rbx), %r14
movq %r14, (%rbx)
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r14)
movq (%rbx), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x3440
xorl %edx, %edx
movq 0x10(%rbx), %rsi
movb (%rsi,%rdx), %dil
cmpb $0x2a, %dil
je 0x3436
movslq %eax, %rcx
incl %eax
movb %dil, (%rsi,%rcx)
movq (%rbx), %rcx
incq %rdx
cmpq %rdx, %rcx
ja 0x341c
cltq
movq 0x10(%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x297a(%rip), %r14      # 0x4088
movq 0x297b(%rip), %rsi      # 0x4090
movq 0x2964(%rip), %rax      # 0x4080
cmpq %rsi, %r14
jb 0x173f
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x2964(%rip)      # 0x4090
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x10c0
movq %rax, 0x2941(%rip)      # 0x4080
leaq 0x1(%r14), %rcx
movq %rcx, 0x293e(%rip)      # 0x4088
movq %rbx, (%rax,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x1812
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x8(%rdi), %rax
cmpq (%rdi), %rax
jbe 0x191b
movq %rsi, %r14
movq %rdi, %rbx
movb $0x1, %bpl
movabsq $0x3000000010, %r13     # imm = 0x3000000010
movq %rsp, %r15
movq (%rbx), %rdi
movq 0x8(%rbx), %r12
subq %rdi, %r12
addq 0x10(%rbx), %rdi
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r13, (%rsp)
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x1060
testl %eax, %eax
js 0x18e5
cmpl %r12d, %eax
jl 0x18e0
testb $0x1, %bpl
je 0x18c1
movq (%rbx), %rcx
movq 0x8(%rbx), %rsi
cmpq %rcx, %rsi
jbe 0x18fc
movl %eax, %eax
notq %rcx
leaq (%rsi,%rcx), %rdx
cmpq %rax, %rdx
jae 0x18a5
leaq (%rcx,%rsi,2), %rdx
addq %rsi, %rsi
cmpq %rax, %rdx
jb 0x1895
movq %rsi, 0x8(%rbx)
movq 0x10(%rbx), %rdi
callq 0x10c0
movq %rax, 0x10(%rbx)
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x1835
leaq 0xb3d(%rip), %rdi       # 0x2405
leaq 0x74a(%rip), %rsi       # 0x2019
leaq 0x74f(%rip), %rcx       # 0x2025
movl $0x64, %edx
callq 0x1080
movl %eax, %ecx
addq %rcx, (%rbx)
testl %eax, %eax
setns %al
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x701(%rip), %rdi       # 0x2004
leaq 0x70f(%rip), %rsi       # 0x2019
leaq 0x7a1(%rip), %rcx       # 0x20b2
movl $0x42, %edx
callq 0x1080
leaq 0x6e2(%rip), %rdi       # 0x2004
leaq 0x6f0(%rip), %rsi       # 0x2019
leaq 0x6f5(%rip), %rcx       # 0x2025
movl $0x4b, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
jbe 0x1962
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
movb $0x0, (%rcx,%rax)
movb $0x1, 0x18(%rdi)
movq 0x10(%rdi), %rdi
callq 0x1700
movq 0x10(%rbx), %rax
popq %rbx
retq
leaq 0x69b(%rip), %rdi       # 0x2004
leaq 0x6a9(%rip), %rsi       # 0x2019
leaq 0x6ec(%rip), %rcx       # 0x2063
movl $0x69, %edx
callq 0x1080
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Astor-Bizard[P]ProjetS5_Groupe2/src/renum_section.c
// Function: nbSecRel
int nbSecRel(Elf32_Ehdr elfHeaders, Elf32_Shdr *section_headers)
{
	
	int i;
	int retour = 0;	
	for(i=0; i<elfHeaders.e_shnum; i++)
	{
		if(section_headers[i].sh_type == SHT_REL)
		{
			retour++;
		}
	}
	return retour;

}

// Assembly:
movzwl 0x38(%rsp), %eax
testq %rax, %rax
je 0x3a25
shll $0x3, %eax
leaq (%rax,%rax,4), %rcx
xorl %edx, %edx
xorl %eax, %eax
xorl %esi, %esi
cmpl $0x9, 0x4(%rdi,%rdx)
sete %sil
addl %esi, %eax
addq $0x28, %rdx
cmpq %rdx, %rcx
jne 0x3a0e
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/Astor-Bizard[P]ProjetS5_Groupe2/src/renum_section.c
// Function: ecrire_nouvelles_sections
void ecrire_nouvelles_sections(FILE *f_read, FILE *f_write, SectionsHeadersList NewShList, SectionsHeadersList OldShList){
	int i,num_sh_new,num_sh_old;
	unsigned char *section;
	// pour chaque section
	for(num_sh_new=1; num_sh_new<NewShList.size; num_sh_new++){
		// on récupère son contenu
		num_sh_old=index_Shdr(NewShList.names+NewShList.headers[num_sh_new].sh_name,OldShList);
		section=recuperer_section_num(f_read,OldShList,num_sh_old);
		// on se place au bon endroit pour l'écrire (on rajoute des 0 si c'est trop loin)
		if(fseek(f_write,NewShList.headers[num_sh_new].sh_offset,0)){
			printf("## Erreur d'écriture des sections ##\n");
			return;
		}
		for(i=0;i<NewShList.headers[num_sh_new].sh_size;i++){
			fputc(section[i],f_write);
		}
		free(section);
	}
	printf("%d sections ont été copiées (section NULL non prise en compte)\n",NewShList.size-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movslq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x2, %rax
jl 0x3b0f
movq %rsi, %r14
leaq 0x70(%rsp), %rax
movq (%rax), %rbp
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movl $0x1, %r15d
leaq (%r15,%r15,4), %rbx
movl (%rbp,%rbx,8), %edi
addq 0x28(%rsp), %rdi
leaq 0x88(%rsp), %r12
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
callq 0x2610
movq 0x10(%r12), %rcx
movq %rcx, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
movq 0x30(%rsp), %rdi
movl %eax, %esi
callq 0x2989
movq %rax, %r12
movl 0x10(%rbp,%rbx,8), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1110
testl %eax, %eax
jne 0x3b32
cmpl $0x0, 0x14(%rbp,%rbx,8)
je 0x3af9
leaq 0x14(,%rbx,8), %rbx
addq %rbp, %rbx
xorl %r13d, %r13d
movzbl (%r12,%r13), %edi
movq %r14, %rsi
callq 0x10c0
incq %r13
movl (%rbx), %eax
cmpq %rax, %r13
jb 0x3ae2
movq %r12, %rdi
callq 0x1030
incq %r15
cmpq 0x20(%rsp), %r15
jne 0x3a6c
movq 0x20(%rsp), %rsi
decl %esi
leaq 0x26d9(%rip), %rdi      # 0x61f6
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1090
leaq 0x2746(%rip), %rdi      # 0x627f
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O3/Astor-Bizard[P]ProjetS5_Groupe2/src/correctionSymboles.c
// Function: writeSymbolsToFile
void writeSymbolsToFile(FILE* file, Elf32_Ehdr elfHeader, SectionsHeadersList shList, ListeSymboles symbolsTable) {
	int i;
	uint32_t writingOffset;

	printf("MARQUE 1\n");
	// Recherche de la table des symboles dans le nouveau fichier pour récupérer son offset
	i = index_Shdr(".symtab", shList);
	writingOffset = shList.headers[i].sh_offset;

	printf("MARQUE 2\n");

	// Réecriture de la table des symboles dans le nouveau fichier.
	fseek(file, writingOffset, 0);
	for(i = 0; i<symbolsTable.nbSymboles; i++)
	{
		printf("MARQUE 3a:%d\n", i);
		fwrite32(file, elfHeader.e_ident[EI_DATA], symbolsTable.symboles[i].st_name);
		fwrite32(file, elfHeader.e_ident[EI_DATA], symbolsTable.symboles[i].st_value);
		fwrite32(file, elfHeader.e_ident[EI_DATA], symbolsTable.symboles[i].st_size);
		fwrite8(file, elfHeader.e_ident[EI_DATA], symbolsTable.symboles[i].st_info);
		fwrite8(file, elfHeader.e_ident[EI_DATA], symbolsTable.symboles[i].st_other);
		fwrite16(file, elfHeader.e_ident[EI_DATA], symbolsTable.symboles[i].st_shndx);
		printf("MARQUE 3b:%d\n", i);
	}

	printf("MARQUE 4\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x24a3(%rip), %rdi      # 0x62c1
callq 0x1060
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x98(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x1d40(%rip), %rdi      # 0x5b83
callq 0x2610
movq 0x98(%rsp), %rcx
cltq
leaq (%rax,%rax,4), %rax
movl 0x10(%rcx,%rax,8), %r14d
leaq 0x2468(%rip), %rdi      # 0x62ca
callq 0x1060
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1110
movslq 0xc0(%rsp), %r12
testq %r12, %r12
jle 0x3f95
leaq 0xb0(%rsp), %rax
leaq 0x60(%rsp), %rcx
movb 0x5(%rcx), %r13b
movq (%rax), %rbp
addq $0xe, %rbp
leaq 0x240f(%rip), %r14      # 0x62b3
xorl %r15d, %r15d
leaq 0x23f7(%rip), %rdi      # 0x62a5
movl %r15d, %esi
xorl %eax, %eax
callq 0x1090
cmpb $0x1, %r13b
movl -0xe(%rbp), %eax
movl %eax, %ecx
bswapl %ecx
cmovnel %eax, %ecx
movl %ecx, 0x1c(%rsp)
movl $0x4, %esi
movl $0x1, %edx
leaq 0x1c(%rsp), %rdi
movq %rbx, %rcx
callq 0x1170
cmpb $0x1, %r13b
movl -0xa(%rbp), %eax
movl %eax, %ecx
bswapl %ecx
cmovnel %eax, %ecx
movl %ecx, 0x20(%rsp)
movl $0x4, %esi
movl $0x1, %edx
leaq 0x20(%rsp), %rdi
movq %rbx, %rcx
callq 0x1170
cmpb $0x1, %r13b
movl -0x6(%rbp), %eax
movl %eax, %ecx
bswapl %ecx
cmovnel %eax, %ecx
movl %ecx, 0x24(%rsp)
movl $0x4, %esi
movl $0x1, %edx
leaq 0x24(%rsp), %rdi
movq %rbx, %rcx
callq 0x1170
movsbl -0x2(%rbp), %edi
movq %rbx, %rsi
callq 0x10c0
movsbl -0x1(%rbp), %edi
movq %rbx, %rsi
callq 0x10c0
movzwl (%rbp), %eax
movl %eax, %ecx
rolw $0x8, %cx
cmpb $0x1, %r13b
cmovnel %eax, %ecx
movw %cx, 0x1a(%rsp)
movl $0x2, %esi
movl $0x1, %edx
leaq 0x1a(%rsp), %rdi
movq %rbx, %rcx
callq 0x1170
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x1090
incq %r15
addq $0x10, %rbp
cmpq %r15, %r12
jne 0x3ea7
leaq 0x2337(%rip), %rdi      # 0x62d3
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1060
nop
// File: /workspace/github_c_makefile_star2_O3/Astor-Bizard[P]ProjetS5_Groupe2/src/ecritureSH.c
// Function: writeSectionsHeadersToFile
void writeSectionsHeadersToFile(FILE *f, Elf32_Ehdr elfHeader, SectionsHeadersList shList) {
	int i;

	fseek(f, elfHeader.e_shoff, 0);
	for(i=0; i<shList.size; i++) {
		fwrite32(f, elfHeader.e_ident[EI_DATA], shList.headers[i].sh_name);
		fwrite32(f, elfHeader.e_ident[EI_DATA], shList.headers[i].sh_type);
		fwrite32(f, elfHeader.e_ident[EI_DATA], shList.headers[i].sh_flags);
		fwrite32(f, elfHeader.e_ident[EI_DATA], shList.headers[i].sh_addr);
		fwrite32(f, elfHeader.e_ident[EI_DATA], shList.headers[i].sh_offset);
		fwrite32(f, elfHeader.e_ident[EI_DATA], shList.headers[i].sh_size);
		fwrite32(f, elfHeader.e_ident[EI_DATA], shList.headers[i].sh_link);
		fwrite32(f, elfHeader.e_ident[EI_DATA], shList.headers[i].sh_info);
		fwrite32(f, elfHeader.e_ident[EI_DATA], shList.headers[i].sh_addralign);
		fwrite32(f, elfHeader.e_ident[EI_DATA], shList.headers[i].sh_entsize);
	}

	printf("%d en-têtes de sections écrites\n", i);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x60(%rsp), %esi
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x1110
movslq 0x88(%rsp), %r14
testq %r14, %r14
jle 0x46e0
leaq 0x78(%rsp), %rax
leaq 0x40(%rsp), %rcx
movzbl 0x5(%rcx), %ebp
movq (%rax), %r15
movq %r14, %rax
shlq $0x3, %rax
leaq (%rax,%rax,4), %r12
xorl %r13d, %r13d
movl (%r15,%r13), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3b4c
movl 0x4(%r15,%r13), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3b4c
movl 0x8(%r15,%r13), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3b4c
movl 0xc(%r15,%r13), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3b4c
movl 0x10(%r15,%r13), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3b4c
movl 0x14(%r15,%r13), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3b4c
movl 0x18(%r15,%r13), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3b4c
movl 0x1c(%r15,%r13), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3b4c
movl 0x20(%r15,%r13), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3b4c
movl 0x24(%r15,%r13), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3b4c
addq $0x28, %r13
cmpq %r13, %r12
jne 0x463b
movl %r14d, %ebp
leaq 0x1c3a(%rip), %rdi      # 0x6321
movl %ebp, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1090
// File: /workspace/github_c_makefile_star2_O3/Arlu[P]RDMA-Hello-World/client.c
// Function: chat
void chat()
{
    struct RemoteMR remote_mr = {
            .remote_addr = (uint64_t)ib_res.buf,
            .rkey = ib_res.mr->rkey
    };

    // Send Hello World via send and receive request:
    memcpy(ib_res.buf, MSG_SEND_RECV, sizeof(MSG_SEND_RECV));
    post_send(BUFFER_SIZE);
    wait_completions(SEND_WRID);

    // Send remote address and rkey:
    memcpy(ib_res.buf, &remote_mr, sizeof(struct RemoteMR));
    post_send(sizeof(struct RemoteMR));
    wait_completions(SEND_WRID);

    // Send Hello World via RDMA Read:
    memcpy(ib_res.buf, MSG_READ, sizeof(MSG_READ));
    post_send(1); // Notify the server for read.
    wait_completions(SEND_WRID);

    // Get remote address and rkey:
    post_recv(sizeof(struct RemoteMR));
    wait_completions(RECV_WRID);
    memcpy(&remote_mr, ib_res.buf, sizeof(struct RemoteMR));

    // Send Hello World via RDMA Write:
    memcpy(ib_res.buf, MSG_WRITE, sizeof(MSG_WRITE));
    post_send_write(remote_mr, BUFFER_SIZE);
    wait_completions(WRITE_WRID);

    post_send(1); // Notify the server for continue.
    wait_completions(SEND_WRID);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2d6b(%rip), %rbx      # 0x4188
movq 0x10(%rbx), %rax
movq 0x60(%rbx), %r14
movl 0x28(%rax), %r15d
movups 0xbe4(%rip), %xmm0      # 0x2014
movups %xmm0, 0x10(%r14)
movups 0xbc8(%rip), %xmm0      # 0x2004
movups %xmm0, (%r14)
movl $0xa2165, 0x1f(%r14)    # imm = 0xA2165
movl $0x400, %edi            # imm = 0x400
callq 0x1d2c
movl $0x2, %edi
callq 0x1ed6
movq 0x60(%rbx), %rax
movq %r14, (%rax)
movl %r15d, 0x8(%rax)
movl $0x10, %edi
callq 0x1d2c
movl $0x2, %edi
callq 0x1ed6
movq 0x60(%rbx), %rax
movups 0xba1(%rip), %xmm0      # 0x2027
movups %xmm0, (%rax)
movups 0xba3(%rip), %xmm0      # 0x2033
movups %xmm0, 0xc(%rax)
movl $0x1, %edi
callq 0x1d2c
movl $0x2, %edi
callq 0x1ed6
movl $0x10, %edi
callq 0x1cd0
movl $0x1, %edi
callq 0x1ed6
movq 0x60(%rbx), %rax
movq (%rax), %rdi
movl 0x8(%rax), %esi
movups 0xb83(%rip), %xmm0      # 0x2050
movups %xmm0, 0xd(%rax)
movups 0xb6b(%rip), %xmm0      # 0x2043
movups %xmm0, (%rax)
movl $0x400, %edx            # imm = 0x400
callq 0x1e4b
movl $0x8, %edi
callq 0x1ed6
movl $0x1, %edi
callq 0x1d2c
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1ed6
// File: /workspace/github_c_makefile_star2_O3/Arlu[P]RDMA-Hello-World/client.c
// Function: main
int main(int argc, char *argv[])
{
    if (argc < 2)
    {
        printf("It must get hostname!\n");
        exit(EXIT_FAILURE);
    }

    server_name = strdup(argv[1]);

    if (setup_ib())
    {
        perror("Failed to setup IB.");
    }

    chat();

    close_ib_connection();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x1, %edi
jle 0x1552
movq 0x8(%rsi), %rdi
callq 0x1270
leaq 0x2c42(%rip), %rcx      # 0x4168
movq %rax, (%rcx)
xorl %eax, %eax
callq 0x18ba
testl %eax, %eax
jne 0x1544
callq 0x140c
xorl %eax, %eax
callq 0x1c61
xorl %eax, %eax
popq %rbp
retq
leaq 0xb15(%rip), %rdi       # 0x2060
callq 0x11d0
jmp 0x1534
leaq 0xb1b(%rip), %rdi       # 0x2074
callq 0x1070
movl $0x1, %edi
callq 0x1200