LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: b_symname
cell b_symname(cell x) {
	cell    n, k;

	/*
	 * Cannot pass name to mkstr(), because
	 * symname(x) may move during GC.
	*/
	k = symlen(x);
	n = mkstr(NULL, k-1);
	Tag[n] |= CONST_TAG;
	memcpy(string(n), symname(x), k);
	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0xc883(%rip), %rax      # 0x17358
movq 0xc86c(%rip), %rcx      # 0x17348
movslq %edi, %r15
movslq (%rcx,%r15,4), %rcx
movslq -0x4(%rax,%rcx,4), %rbx
leal -0x1(%rbx), %esi
xorl %edi, %edi
callq 0x2698
movq 0xc857(%rip), %rcx      # 0x17350
movslq %eax, %r14
orb $-0x80, (%rcx,%r14)
movq 0xc850(%rip), %rax      # 0x17358
movq 0xc839(%rip), %rcx      # 0x17348
movslq (%rcx,%r14,4), %rdx
leaq (%rax,%rdx,4), %rdi
movslq (%rcx,%r15,4), %rcx
leaq (%rax,%rcx,4), %rsi
movq %rbx, %rdx
callq 0x2140
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: liststr
cell liststr(cell x) {
	cell	n, v;
	int	k;
	byte	*s;

	k = 0;
	for (n = x; n != NIL; n = cdr(n))
		k++;
	v = mkstr(NULL, k);
	s = string(v);
	for (n = x; n != NIL; n = cdr(n)) {
		if (atomp(n)) error("liststr: dotted list", x);
		if (!charp(car(n))) expect("liststr", "char", car(n));
		*s = charval(car(n));
		s++;
	}
	return v;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
xorl %esi, %esi
movq 0xc80c(%rip), %rax      # 0x17348
movl %edi, %ecx
cmpl $-0x1, %ecx
je 0xab4d
incl %esi
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
jmp 0xab3e
xorl %edi, %edi
callq 0x2698
movq 0xc7ed(%rip), %rsi      # 0x17348
movslq %eax, %rcx
movslq (%rsi,%rcx,4), %rcx
shlq $0x2, %rcx
addq 0xc7eb(%rip), %rcx      # 0x17358
movl %ebx, %edx
cmpl $-0x1, %edx
je 0xabbf
testl %edx, %edx
js 0xabd4
movq 0xc7d1(%rip), %r9       # 0x17350
movl %edx, %edi
testb $0x9, (%r9,%rdi)
jne 0xabd4
movq 0xc7b1(%rip), %r8       # 0x17340
movslq (%r8,%rdi,4), %rdx
testq %rdx, %rdx
js 0xabc1
testb $0x1, (%r9,%rdx)
je 0xabc1
cmpl $-0xc, (%r8,%rdx,4)
jne 0xabc1
movslq (%rsi,%rdx,4), %rdx
movb (%r8,%rdx,4), %dl
movb %dl, (%rcx)
incq %rcx
movq 0xc78e(%rip), %rsi      # 0x17348
movl (%rsi,%rdi,4), %edx
jmp 0xab6f
popq %rbx
retq
leaq 0x5ec8(%rip), %rdi      # 0x10a90
leaq 0x596d(%rip), %rsi      # 0x1053c
callq 0x2720
leaq 0x5ea0(%rip), %rdi      # 0x10a7b
movl %ebx, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xc764(%rip), %rax      # 0x17358
movq 0xc74d(%rip), %rcx      # 0x17348
movslq %edi, %rdx
movq %rdx, (%rsp)
movslq (%rcx,%rdx,4), %rcx
movslq -0x4(%rax,%rcx,4), %r15
movl %r15d, %r13d
decl %r13d
je 0xaccd
pushq $-0x1
popq %rdi
xorl %r12d, %r12d
movl %edi, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebp
movl 0xc542(%rip), %esi      # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xc533(%rip)      # 0x17170
addq $-0x2, %r15
testl %r13d, %r13d
cmovlel %r12d, %r13d
pushq $0x1
popq %r14
cmpq %r12, %r13
je 0xacb7
movq 0xc6f0(%rip), %rax      # 0x17348
movq (%rsp), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq 0xc6ed(%rip), %rax      # 0x17358
movzbl (%r12,%rax), %edi
pushq $-0x1
popq %rsi
movl %r14d, %edx
callq 0x2f8c
pushq $-0xc
popq %rdi
movl %eax, %esi
movl %r14d, %edx
callq 0x2f8c
movq 0xc6b1(%rip), %rcx      # 0x17340
movslq %ebp, %rbx
movl %eax, (%rcx,%rbx,4)
cmpq %r15, %r12
jge 0xacb2
pushq $-0x1
popq %rdi
movl %edi, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebp
movq 0xc699(%rip), %rax      # 0x17348
movl %ebp, (%rax,%rbx,4)
incq %r12
jmp 0xac4c
pushq $0x1
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31a9
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xc667(%rip), %rax      # 0x17358
movq 0xc650(%rip), %rcx      # 0x17348
movslq %edi, %r14
movslq (%rcx,%r14,4), %rcx
movslq -0x4(%rax,%rcx,4), %rbx
addq $0x3, %rbx
shrq $0x2, %rbx
testl %ebx, %ebx
je 0xadb1
pushq $-0x1
popq %rdi
xorl %r15d, %r15d
movl %edi, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebp
movl 0xc445(%rip), %esi      # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xc436(%rip)      # 0x17170
movl %ebx, %eax
decl %eax
movslq %eax, %r12
testl %ebx, %ebx
movl $0x0, %r13d
cmovgl %ebx, %r13d
cmpq %r15, %r13
je 0xad9b
movq 0xc5ef(%rip), %rax      # 0x17348
movslq (%rax,%r14,4), %rax
shlq $0x2, %rax
addq 0xc5f0(%rip), %rax      # 0x17358
movl (%rax,%r15,4), %eax
movq 0xc5cd(%rip), %rcx      # 0x17340
movslq %ebp, %rbx
movl %eax, (%rcx,%rbx,4)
cmpq %r12, %r15
jge 0xad96
pushq $-0x1
popq %rdi
movl %edi, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebp
movq 0xc5b5(%rip), %rax      # 0x17348
movl %ebp, (%rax,%rbx,4)
incq %r15
jmp 0xad4d
pushq $0x1
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31a9
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: 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 0xadff
movq 0xc56d(%rip), %rax      # 0x17340
movq 0xc56e(%rip), %rcx      # 0x17348
movslq %edi, %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edi
callq 0x2532
movq %rax, %rbx
movq %rax, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
jmp 0x2698
pushq $-0x1
popq %rax
pushq $0x1
popq %rbx
movl %esi, %edi
movl %eax, %esi
movl %ebx, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %ebx, %edx
callq 0x2f8c
leaq 0x5ca8(%rip), %rdi      # 0x10acb
movl %eax, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %r14
callq 0x3b7d
testl %eax, %eax
js 0xaf28
movl %eax, %ebx
cmpl $0x13, %eax
ja 0xae90
movl %ebx, %eax
leaq 0xc774(%rip), %rcx      # 0x17600
orb $0x40, (%rax,%rcx)
movl 0xc6b1(%rip), %r15d     # 0x17548
movl 0xc297(%rip), %ebp      # 0x17134
movq %r14, %rdi
callq 0x2080
movq %r14, %rdi
movl %eax, %esi
callq 0x2698
movl 0xc283(%rip), %esi      # 0x17138
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xc274(%rip)      # 0x17138
movl $0x1, 0xc266(%rip)      # 0x17134
callq 0xaf48
movl %ebx, 0xc66f(%rip)      # 0x17548
callq 0x4a47
movl %r15d, 0xc663(%rip)     # 0x17548
cmpl $-0x3, %eax
je 0xaef5
movl %eax, %edi
xorl %esi, %esi
callq 0x8adb
jmp 0xaed3
callq 0xb019
movq 0xc447(%rip), %rax      # 0x17348
movslq 0xc230(%rip), %rcx      # 0x17138
movl (%rax,%rcx,4), %eax
movl %eax, 0xc227(%rip)      # 0x17138
movl %ebp, 0xc21d(%rip)      # 0x17134
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3c26
movq %r14, %rdi
callq 0x2080
movq %r14, %rdi
movl %eax, %esi
callq 0x2698
leaq 0x5bae(%rip), %rdi      # 0x10aef
movl %eax, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl 0xc26a(%rip), %edi      # 0x171bc
movl 0xc218(%rip), %esi      # 0x17170
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xc20b(%rip)      # 0x17170
movl 0xc265(%rip), %edi      # 0x171d0
movl %eax, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xc1f6(%rip)      # 0x17170
movl 0xc9d8(%rip), %edi      # 0x17958
pushq $-0x1
popq %rbp
pushq $0x1
popq %rbx
movl %ebp, %esi
movl %ebx, %edx
callq 0x2f8c
pushq $-0xe
popq %r14
movl %r14d, %edi
movl %eax, %esi
movl %ebx, %edx
callq 0x2f8c
movl 0xc1cb(%rip), %esi      # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xc1bc(%rip)      # 0x17170
movl 0xc1a6(%rip), %edi      # 0x17160
movl %ebp, %esi
movl %ebx, %edx
callq 0x2f8c
movl %r14d, %edi
movl %eax, %esi
movl %ebx, %edx
callq 0x2f8c
movl 0xc19b(%rip), %esi      # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xc18c(%rip)      # 0x17170
movl 0xc1de(%rip), %edi      # 0x171c8
movl %ebp, %esi
movl %ebx, %edx
callq 0x2f8c
movl %r14d, %edi
movl %eax, %esi
movl %ebx, %edx
callq 0x2f8c
movl 0xc16b(%rip), %esi      # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xc15c(%rip)      # 0x17170
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq 0xc31b(%rip), %r14      # 0x17340
movq 0xc31c(%rip), %r15      # 0x17348
pushq $0x1
popq %rbx
movl %ebx, %edi
callq 0x31a9
cltq
movslq (%r15,%rax,4), %rax
movl (%r14,%rax,4), %eax
movl %eax, 0xc182(%rip)      # 0x171c8
movq 0xc2f3(%rip), %r14      # 0x17340
movq 0xc2f4(%rip), %r15      # 0x17348
movl %ebx, %edi
callq 0x31a9
cltq
movslq (%r15,%rax,4), %rax
movl (%r14,%rax,4), %eax
movl %eax, 0xc0f5(%rip)      # 0x17160
movq 0xc2ce(%rip), %r14      # 0x17340
movq 0xc2cf(%rip), %r15      # 0x17348
movl %ebx, %edi
callq 0x31a9
cltq
movslq (%r15,%rax,4), %rax
movl (%r14,%rax,4), %eax
movl %eax, 0xc8c8(%rip)      # 0x17958
movl %ebx, %edi
callq 0x31a9
movl %eax, 0xc133(%rip)      # 0x171d0
movl %ebx, %edi
callq 0x31a9
movl %eax, 0xc112(%rip)      # 0x171bc
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x60, %rsp
movl %edi, %edx
testl %edi, %edi
js 0xb10d
movq 0xc28e(%rip), %rcx      # 0x17350
movl %edx, %eax
testb $0x8, (%rcx,%rax)
je 0xb10d
movq 0xc26f(%rip), %rcx      # 0x17340
cmpl $-0x11, (%rcx,%rax,4)
jne 0xb10d
movq 0xc27a(%rip), %rcx      # 0x17358
movq 0xc263(%rip), %rsi      # 0x17348
movslq (%rsi,%rax,4), %rax
cmpl $0x51, -0x4(%rcx,%rax,4)
jge 0xb120
leaq (%rcx,%rax,4), %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x2040
movq %rbx, %rdi
callq 0xae65
addq $0x60, %rsp
popq %rbx
retq
leaq 0x546f(%rip), %rdi      # 0x10583
leaq 0x5412(%rip), %rsi      # 0x1052d
callq 0x2720
leaq 0x59df(%rip), %rdi      # 0x10b06
movl %edx, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/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 0xb1cb
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2040
pushq $0x2e
popq %rsi
movq %r14, %rdi
callq 0x20a0
testq %rax, %rax
jne 0xb194
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 0x595f(%rip), %rdi      # 0x10b31
pushq $-0x4
popq %rsi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edi, %ebp
movq 0xbd79(%rip), %rax      # 0x17348
movslq %edi, %rbx
movslq (%rax,%rbx,4), %rdi
shlq $0x2, %rdi
addq 0xbd77(%rip), %rdi      # 0x17358
callq 0xb1da
testq %rax, %rax
jne 0xb5fc
movl 0xc35f(%rip), %edi      # 0x17950
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x266c
movq %rax, %r14
movq 0xbd42(%rip), %rax      # 0x17348
movslq (%rax,%rbx,4), %rdi
shlq $0x2, %rdi
addq 0xbd43(%rip), %rdi      # 0x17358
callq 0x2030
movq %r14, %rdi
movl %ebx, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
callq 0x3047
movl $0x40000, %edi          # imm = 0x40000
subl 0xbd28(%rip), %edi      # 0x17360
pushq $-0x1
popq %rbp
pushq $0x1
popq %rbx
movl %ebp, %esi
movl %ebx, %edx
callq 0x2f8c
pushq $-0xe
popq %r14
movl %r14d, %edi
movl %eax, %esi
movl %ebx, %edx
callq 0x2f8c
movl %eax, %edi
movl %ebp, %esi
xorl %edx, %edx
callq 0x2f8c
movl 0xbb08(%rip), %esi      # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xbaf9(%rip)      # 0x17170
movl 0xbab3(%rip), %edi      # 0x17130
callq 0x5190
movl %eax, %edi
movl %ebp, %esi
movl %ebx, %edx
callq 0x2f8c
movl %r14d, %edi
movl %eax, %esi
movl %ebx, %edx
callq 0x2f8c
movl %eax, %ebp
movl %ebx, %edi
callq 0x31a9
movl %ebp, %edi
movl %eax, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x2f8c
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x70, %rsp
movl 0xc298(%rip), %edx      # 0x17954
incl %edx
movl %edx, 0xc290(%rip)      # 0x17954
leaq 0x5569(%rip), %rsi      # 0x10c34
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movl %eax, %esi
callq 0x3875
addq $0x70, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb748
movq 0xbc53(%rip), %rcx      # 0x17350
movl %eax, %eax
movzbl (%rcx,%rax), %ecx
testb $0x8, %cl
jne 0xb737
testb $0x1, %cl
je 0xb73b
movq 0xbc2c(%rip), %rcx      # 0x17340
cmpl $-0xd, (%rcx,%rax,4)
jne 0xb73b
movq 0xbc27(%rip), %rdx      # 0x17348
movslq (%rdx,%rax,4), %rax
movslq (%rdx,%rax,4), %rax
movslq (%rdx,%rax,4), %rax
movslq (%rcx,%rax,4), %rax
leaq (%rdx,%rax,4), %rax
jmp 0xb746
pushq $-0x1
popq %rax
retq
shlq $0x2, %rax
addq 0xbc02(%rip), %rax      # 0x17348
movl (%rax), %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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, %ecx
movl 0xba0f(%rip), %eax      # 0x17160
addl %edi, %eax
movl 0xba6b(%rip), %edi      # 0x171c4
subl %edi, %eax
jl 0xb7cf
pushq %rbx
movl $0x400, %ebx            # imm = 0x400
cmpl $0x400, %ecx            # imm = 0x400
jl 0xb77a
movl $0x400, %ecx            # imm = 0x400
cltd
idivl %ecx
movl %eax, %ebx
shll $0xa, %ebx
addl %ecx, %ebx
addl %ebx, %edi
callq 0x31ed
movq 0xbbd0(%rip), %rdx      # 0x17358
movq 0xbbb9(%rip), %rsi      # 0x17348
movslq 0xb9c6(%rip), %rcx      # 0x1715c
movslq (%rsi,%rcx,4), %rcx
leaq (%rdx,%rcx,4), %rcx
movslq %eax, %rdi
movslq (%rsi,%rdi,4), %rsi
leaq (%rdx,%rsi,4), %rdx
xorl %esi, %esi
movslq 0xb9ae(%rip), %rdi      # 0x17160
cmpq %rdi, %rsi
jg 0xb7c2
movl (%rcx,%rsi,4), %edi
movl %edi, (%rdx,%rsi,4)
incq %rsi
jmp 0xb7ab
addl %ebx, 0xb9fc(%rip)      # 0x171c4
movl %eax, 0xb98e(%rip)      # 0x1715c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0xb99b(%rip)      # 0x17174
pushq $0x1
popq %rdi
callq 0xb749
orl $-0x1, 0xb98c(%rip)     # 0x17174
movslq 0xb971(%rip), %rax      # 0x17160
leaq 0x1(%rax), %rcx
movl %ecx, 0xb967(%rip)      # 0x17160
movq 0xbb48(%rip), %rcx      # 0x17348
movslq 0xb955(%rip), %rdx      # 0x1715c
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0xbb42(%rip), %rcx      # 0x17358
movl %ebx, 0x4(%rcx,%rax,4)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl 0xb949(%rip), %edi      # 0x171bc
pushq $-0x1
popq %r14
movl %r14d, %esi
xorl %edx, %edx
callq 0x2f8c
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebx
movl 0xb8dc(%rip), %esi      # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0xb8cd(%rip)      # 0x17170
pushq $0x1
popq %r15
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %r15d, %edx
callq 0x2f8c
movl %eax, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %ebx
movl %r15d, %edi
callq 0x31a9
pushq $-0xd
popq %rdi
movl %ebx, %esi
movl %r15d, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2f8c
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0xb7d7(%rip), %rcx      # 0x17350
xorl %eax, %eax
movq 0xb7c6(%rip), %rdx      # 0x17348
testl %edi, %edi
js 0xbb95
movl %edi, %esi
testb $0x9, (%rcx,%rsi)
jne 0xbb95
incl %eax
movl (%rdx,%rsi,4), %edi
jmp 0xbb82
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0xb796(%rip), %rax      # 0x17340
movq 0xb797(%rip), %rcx      # 0x17348
movslq 0xb5a4(%rip), %rdx      # 0x1715c
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0xb791(%rip), %rcx      # 0x17358
movslq 0xb592(%rip), %rdx      # 0x17160
movslq (%rcx,%rdx,4), %rcx
movslq (%rax,%rcx,4), %r14
testq %r14, %r14
js 0xbcdd
movq 0xb76a(%rip), %rax      # 0x17350
testb $0x9, (%rax,%r14)
jne 0xbce7
movl %r14d, %edi
callq 0xbb72
movl %eax, %ebp
movl %eax, %edi
callq 0xb749
movl %ebp, %eax
addl 0xb556(%rip), %eax      # 0x17160
movl %eax, 0xb550(%rip)      # 0x17160
cltq
leaq -0x4(,%rax,4), %r12
pushq $-0x1
popq %r15
movl %r14d, %eax
cmpl $-0x1, %eax
je 0xbc83
testl %eax, %eax
js 0xbcf0
movq 0xb71b(%rip), %rcx      # 0x17350
movl %eax, %r13d
testb $0x9, (%rcx,%r13)
jne 0xbcf0
movq 0xb6f6(%rip), %rax      # 0x17340
movl (%rax,%r13,4), %edi
movl %r15d, %esi
xorl %edx, %edx
callq 0x2f8c
movq 0xb6e9(%rip), %rcx      # 0x17348
movslq 0xb4f6(%rip), %rdx      # 0x1715c
movslq (%rcx,%rdx,4), %rdx
shlq $0x2, %rdx
addq 0xb6e3(%rip), %rdx      # 0x17358
movl %eax, (%r12,%rdx)
movl (%rcx,%r13,4), %eax
addq $-0x4, %r12
jmp 0xbc21
pushq $-0x1
popq %rsi
pushq $0x1
popq %r14
movl %ebp, %edi
movl %r14d, %edx
callq 0x2f8c
pushq $-0xe
popq %rdi
movl %eax, %esi
movl %r14d, %edx
callq 0x2f8c
movq 0xb6a0(%rip), %rcx      # 0x17348
movslq 0xb4ad(%rip), %rdx      # 0x1715c
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0xb69a(%rip), %rcx      # 0x17358
movslq 0xb49b(%rip), %rdx      # 0x17160
movl %eax, (%rcx,%rdx,4)
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb8ed
cmpl $-0x1, %r14d
je 0xbbf1
leaq 0x4f7c(%rip), %rdi      # 0x10c6a
jmp 0xbcf7
leaq 0x4f88(%rip), %rdi      # 0x10c7f
movl %r14d, %esi
callq 0x258a
// File: /workspace/github_c_makefile_star2_O2/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 0xb642(%rip), %rax      # 0x17348
movslq 0xb44f(%rip), %rcx      # 0x1715c
movslq (%rax,%rcx,4), %rcx
shlq $0x2, %rcx
addq 0xb63c(%rip), %rcx      # 0x17358
movq 0xb61d(%rip), %rdx      # 0x17340
movslq 0xb436(%rip), %rsi      # 0x17160
movslq (%rcx,%rsi,4), %rdi
movslq (%rax,%rdi,4), %rdi
movl (%rdx,%rdi,4), %edi
movl %edi, 0xb48d(%rip)      # 0x171c8
movslq -0x4(%rcx,%rsi,4), %rdi
movl (%rax,%rdi,4), %r8d
movl %r8d, 0xb471(%rip)      # 0x171bc
movl -0x8(%rcx,%rsi,4), %r8d
movl %r8d, 0xb479(%rip)      # 0x171d0
movslq -0xc(%rcx,%rsi,4), %rcx
movslq (%rax,%rcx,4), %rcx
movl (%rdx,%rcx,4), %ecx
subl %ecx, %esi
addl $-0x4, %esi
movl %esi, 0xb3f2(%rip)      # 0x17160
movslq (%rdx,%rdi,4), %rcx
movslq (%rax,%rcx,4), %rax
movl (%rdx,%rax,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0xb202(%rip), %edi      # 0x171d0
movl 0xb1e8(%rip), %esi      # 0x171bc
xorl %edx, %edx
callq 0x2f8c
movl %eax, %r15d
movl %eax, 0xb190(%rip)      # 0x17174
movl 0xb1de(%rip), %edi      # 0x171c8
pushq $-0x1
popq %rbp
pushq $0x1
popq %rbx
movl %ebp, %esi
movl %ebx, %edx
callq 0x2f8c
pushq $-0xe
popq %r14
movl %r14d, %edi
movl %eax, %esi
movl %ebx, %edx
callq 0x2f8c
movl %eax, %edi
movl %r15d, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %r15d
movl %eax, 0xb156(%rip)      # 0x17174
movl 0xb13c(%rip), %edi      # 0x17160
movl %ebp, %esi
movl %ebx, %edx
callq 0x2f8c
movl %r14d, %edi
movl %eax, %esi
movl %ebx, %edx
callq 0x2f8c
movl %eax, %edi
movl %r15d, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %r15d
movl %eax, 0xb126(%rip)      # 0x17174
movl 0xb904(%rip), %edi      # 0x17958
addl $0x2, %edi
movl %ebp, %esi
movl %ebx, %edx
callq 0x2f8c
movl %r14d, %edi
movl %eax, %esi
movl %ebx, %edx
callq 0x2f8c
movl %eax, %edi
movl %r15d, %esi
xorl %edx, %edx
callq 0x2f8c
orl $-0x1, 0xb0f5(%rip)     # 0x17174
pushq $-0xb
popq %rdi
movl %eax, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2f8c
// File: /workspace/github_c_makefile_star2_O2/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:
movl %edi, %edx
testl %edi, %edi
js 0xc122
movq 0xb2aa(%rip), %rcx      # 0x17350
movl %edx, %eax
testb $0x1, (%rcx,%rax)
je 0xc122
movq 0xb28b(%rip), %rcx      # 0x17340
cmpl $-0xb, (%rcx,%rax,4)
jne 0xc122
movq 0xb286(%rip), %rdx      # 0x17348
movslq (%rdx,%rax,4), %rdi
movslq (%rcx,%rdi,4), %rax
movslq (%rdx,%rax,4), %rax
movl (%rcx,%rax,4), %eax
movl %eax, 0xb881(%rip)      # 0x17958
movslq (%rdx,%rdi,4), %rdi
movslq (%rcx,%rdi,4), %r8
movslq (%rdx,%r8,4), %r8
movl (%rcx,%r8,4), %r8d
movl %r8d, 0xb072(%rip)      # 0x17160
movslq (%rdx,%rdi,4), %rdi
movslq (%rcx,%rdi,4), %r8
movslq (%rdx,%r8,4), %r8
movl (%rcx,%r8,4), %r8d
movl %r8d, 0xb0c3(%rip)      # 0x171c8
movslq (%rdx,%rdi,4), %rdi
movl (%rcx,%rdi,4), %ecx
movl %ecx, 0xb0be(%rip)      # 0x171d0
movl (%rdx,%rdi,4), %ecx
movl %ecx, 0xb0a1(%rip)      # 0x171bc
movl %esi, 0xb09f(%rip)      # 0x171c0
retq
pushq %rax
leaq 0x4b68(%rip), %rdi      # 0x10c92
leaq 0x4b67(%rip), %rsi      # 0x10c98
callq 0x2720
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %edi, %ebx
movl 0xb261(%rip), %edi      # 0x173a0
movl 0xafff(%rip), %esi      # 0x17144
callq 0x2640
cmpl $-0x1, %eax
je 0xc168
movq 0xb1ea(%rip), %rcx      # 0x17340
movq 0xb1eb(%rip), %rdx      # 0x17348
cltq
movslq (%rdx,%rax,4), %rax
movl (%rcx,%rax,4), %esi
jmp 0xc16b
pushq $-0x1
popq %rsi
movl %ebx, %edi
popq %rbx
jmp 0xc095
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x8b0e(%rip), %r14      # 0x17144
movl 0x8b08(%rip), %edi      # 0x17144
callq 0x5190
movl %eax, %edi
callq 0x31ed
movl %eax, 0x8b7e(%rip)      # 0x171cc
movq 0x8cf3(%rip), %rax      # 0x17348
movq 0x8ce4(%rip), %rcx      # 0x17340
movq 0x8cf5(%rip), %rdx      # 0x17358
movslq (%r14), %rsi
cmpq $-0x1, %rsi
je 0xe68c
movslq (%rcx,%rsi,4), %rdi
movl (%rax,%rdi,4), %edi
movslq 0x8b52(%rip), %r8       # 0x171cc
movslq (%rax,%r8,4), %r8
movl %edi, (%rdx,%r8,4)
leaq (%rax,%rsi,4), %r14
addq $0x4, %rdx
jmp 0xe663
movl 0x8b3a(%rip), %eax      # 0x171cc
movl %eax, 0x8b38(%rip)      # 0x171d0
movl %ebx, %edi
callq 0xc173
movl 0x8b1b(%rip), %eax      # 0x171c0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/blakemcbride[P]LISP9/ls9.c
// Function: initrts
void initrts(void) {
	Rts = NIL;
	Rts = mkvec(CHUNKSIZE);
	Sz = CHUNKSIZE;
	Sp = -1;
	Fp = -1;
}

// Assembly:
pushq %rax
orl $-0x1, 0x8a88(%rip)     # 0x1715c
movl $0x400, %edi            # imm = 0x400
callq 0x31ed
movl %eax, 0x8a78(%rip)      # 0x1715c
orl $-0x1, 0x8a75(%rip)     # 0x17160
movl $0x400, 0x8acf(%rip)    # imm = 0x400
orl $-0x1, 0x8acc(%rip)     # 0x171c8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x8d74(%rip), %rdi      # 0x17480
callq 0x20f0
testl %eax, %eax
setne %cl
movl 0x9244(%rip), %eax      # 0x17960
testl %eax, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
je 0xe7f2
testl %eax, %eax
jne 0xe73f
leaq -0x8a(%rip), %rsi       # 0xe6ad
pushq $0x2
popq %rdi
callq 0x2110
pushq $-0x1
popq %rbx
xorl %ebp, %ebp
leaq 0x2720(%rip), %r14      # 0x10e6b
callq 0x3c5e
callq 0x233c
callq 0xe6cc
movl 0x8c3c(%rip), %edi      # 0x1739c
movl %ebx, %esi
callq 0x266c
orl $-0x1, 0x8a02(%rip)     # 0x17170
movl %ebp, 0x91e8(%rip)      # 0x1795c
movl %ebp, 0x8eb6(%rip)      # 0x17630
cmpl %ebp, 0x91e0(%rip)      # 0x17960
jne 0xe78f
movq %r14, %rdi
callq 0x2514
callq 0x2815
callq 0x4a47
cmpl $-0x3, %eax
jne 0xe7a2
cmpl $0x0, 0x8e90(%rip)      # 0x17630
je 0xe7d2
movl %eax, %edi
movl $0x0, 0x919a(%rip)      # 0x17948
movl %ebp, %esi
callq 0x8adb
movl %eax, %r15d
movl 0x91a6(%rip), %edi      # 0x17964
movl %eax, %esi
callq 0x266c
movl %r15d, %edi
callq 0x517d
jmp 0xe74b
cmpl $0x0, 0x9187(%rip)      # 0x17960
jne 0xe7e7
leaq 0x29e6(%rip), %rdi      # 0x111c8
callq 0x2514
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rdi
callq 0x21f0
// File: /workspace/github_c_makefile_star2_O2/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 0x7fff(%rip), %rdi      # 0x17480
callq 0x20f0
testl %eax, %eax
je 0xf48c
popq %rbx
retq
cmpl $0x0, 0x84cd(%rip)      # 0x17960
jne 0xf4a4
leaq -0xdef(%rip), %rsi      # 0xe6ad
pushq $0x2
popq %rdi
callq 0x2110
movl 0x84c2(%rip), %edi      # 0x1796c
movl 0x7c94(%rip), %esi      # 0x17144
callq 0x2640
cmpl $-0x1, %eax
je 0xf48a
movq 0x7e7f(%rip), %rcx      # 0x17340
movq 0x7e80(%rip), %rdx      # 0x17348
cltq
movslq (%rdx,%rax,4), %rax
movslq (%rcx,%rax,4), %rax
testq %rax, %rax
js 0xf48a
movq 0x7e72(%rip), %rdx      # 0x17350
testb $0x1, (%rdx,%rax)
je 0xf48a
cmpl $-0xd, (%rcx,%rax,4)
jne 0xf48a
movl %eax, %edi
pushq $-0x1
popq %rsi
xorl %ebx, %ebx
movl %ebx, %edx
callq 0x2f8c
movl %eax, %edi
movl %ebx, %esi
callq 0x8adb
jmp 0xf48a
// File: /workspace/github_c_makefile_star2_O2/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 0x1c42(%rip), %rbx      # 0x111c8
movq %rbx, %rdi
callq 0x2514
leaq 0x1c35(%rip), %rdi      # 0x111ca
callq 0x2514
leaq 0x15c6(%rip), %rdi      # 0x10b67
callq 0x2514
leaq 0x1c24(%rip), %rdi      # 0x111d1
callq 0x2514
movq %rbx, %rdi
callq 0x2514
movq %rbx, %rdi
callq 0x2514
xorl %edi, %edi
callq 0x21f0
// File: /workspace/github_c_makefile_star2_O2/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 0xf5d2
movq %rdi, %rax
retq
pushq %rax
callq 0xf503
pushq $0x1
popq %rdi
callq 0x21f0
// File: /workspace/github_c_makefile_star2_O2/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 0xf68d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $-0x1
popq %rbp
xorl %r15d, %r15d
movl %ebp, %edi
movl %ebp, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %r14d
movl 0x7b5e(%rip), %esi      # 0x17170
movl %eax, %edi
xorl %edx, %edx
callq 0x2f8c
movl %eax, 0x7b4f(%rip)      # 0x17170
movslq %r14d, %r12
movq %r15, %r13
movq (%rbx,%r13,8), %r14
testq %r14, %r14
je 0xf677
movq %r14, %rdi
callq 0x2080
movq %r14, %rdi
movl %eax, %esi
callq 0x2698
movq 0x7cf7(%rip), %rcx      # 0x17340
movl %eax, (%rcx,%r12,4)
leaq 0x1(%r13), %r15
cmpq $0x0, 0x8(%rbx,%r13,8)
movq %r15, %r13
je 0xf627
movl %ebp, %edi
movl %ebp, %esi
xorl %edx, %edx
callq 0x2f8c
movl %eax, %r14d
movq 0x7cd7(%rip), %rax      # 0x17348
movl %r14d, (%rax,%r12,4)
jmp 0xf621
pushq $0x1
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31a9
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rsi), %rdi
callq 0x10b0
movq %rax, %r15
movb $0x0, (%rax,%rbx)
movq %rax, %rdi
callq 0x1286
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O2/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 0x2df4(%rip), %r14      # 0x4088
movq 0x2df5(%rip), %rsi      # 0x4090
movq 0x2dde(%rip), %rax      # 0x4080
cmpq %rsi, %r14
jb 0x12c5
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x2dde(%rip)      # 0x4090
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x10c0
movq %rax, 0x2dbb(%rip)      # 0x4080
leaq 0x1(%r14), %rcx
movq %rcx, 0x2db8(%rip)      # 0x4088
movq %rbx, (%rax,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq $0x20, 0x8(%rdi)
andq $0x0, (%rdi)
movb $0x0, 0x18(%rdi)
pushq $0x20
popq %rdi
callq 0x10b0
movq %rax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1391
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 0x1487
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
movabsq $0x3000000010, %r13     # imm = 0x3000000010
movq %rsp, %r15
cmpl $0x2, %ebp
je 0x1451
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 0x143a
movl %eax, %ecx
cmpl %r12d, %eax
jl 0x1437
testl %ebp, %ebp
jne 0x1430
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
cmpq %rax, %rsi
jbe 0x146a
notq %rax
leaq (%rsi,%rax), %rdx
cmpq %rcx, %rdx
jae 0x1423
addq %rsi, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1411
movq 0x10(%rbx), %rdi
callq 0x10c0
movq %rax, 0x10(%rbx)
incl %ebp
jmp 0x13b3
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 0xfad(%rip), %rdi       # 0x2405
leaq 0xbba(%rip), %rsi       # 0x2019
leaq 0xbbf(%rip), %rcx       # 0x2025
pushq $0x64
jmp 0x1481
leaq 0xb93(%rip), %rdi       # 0x2004
leaq 0xba1(%rip), %rsi       # 0x2019
leaq 0xc33(%rip), %rcx       # 0x20b2
pushq $0x42
popq %rdx
callq 0x1080
leaq 0xb76(%rip), %rdi       # 0x2004
leaq 0xb84(%rip), %rsi       # 0x2019
leaq 0xb89(%rip), %rcx       # 0x2025
pushq $0x4b
jmp 0x1481
// File: /workspace/github_c_makefile_star2_O2/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 0x14c8
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
movb $0x0, (%rcx,%rax)
movb $0x1, 0x18(%rdi)
movq 0x10(%rdi), %rdi
callq 0x1286
movq 0x10(%rbx), %rax
popq %rbx
retq
leaq 0xb35(%rip), %rdi       # 0x2004
leaq 0xb43(%rip), %rsi       # 0x2019
leaq 0xb86(%rip), %rcx       # 0x2063
pushq $0x69
popq %rdx
callq 0x1080
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/Astor-Bizard[P]ProjetS5_Groupe2/src/displayCorrectionSymbols.c
// Function: recuperer_donnees
Elf32_Addr recuperer_donnees(char argv[], char nom[])
{
	int taille,i=0;
	char nb[42];
	Elf32_Addr addr;
	
	
	while(argv[i]!='=')
	{
		nom[i]=argv[i];
		i++;
	}
	nom[i]='\0';

	i++;
	taille=i;


	if(argv[i] != '0' && argv[i+1] != 'x')
	{
		printf("Erreur d'argument. Forme attendue : <section>=0x<addr>\n");
		exit(1);
	}

	i+=2;
	while(argv[i]!='\0')
	{
		nb[i-taille-2] = argv[i];
		i++;
	}
	nb[i-taille-2]='\0';

	addr = strtol(nb,NULL,16);
	return addr;
}

// Assembly:
subq $0x38, %rsp
pushq $0x3
popq %rax
xorl %ecx, %ecx
movb (%rdi,%rcx), %dl
cmpb $0x3d, %dl
je 0x1297
movb %dl, (%rsi,%rcx)
incq %rcx
incl %eax
jmp 0x1285
movb $0x0, (%rsi,%rcx)
movl %ecx, %edx
cmpb $0x30, 0x1(%rdi,%rdx)
je 0x12ab
cmpb $0x78, 0x2(%rdi,%rcx)
jne 0x1303
leaq 0x3(%rcx), %rdx
movslq %edx, %rdx
subl %ecx, %eax
shlq $0x20, %rax
movabsq $-0x300000000, %rcx     # imm = 0xFFFFFFFD00000000
addq %rax, %rcx
addq %rdx, %rdi
movabsq $0x100000000, %rax      # imm = 0x100000000
movb (%rdi), %sil
movq %rcx, %rdx
sarq $0x20, %rdx
testb %sil, %sil
je 0x12ed
movb %sil, (%rsp,%rdx)
addq %rax, %rcx
incq %rdi
jmp 0x12d2
movb $0x0, (%rsp,%rdx)
movq %rsp, %rdi
pushq $0x10
popq %rdx
xorl %esi, %esi
callq 0x10f0
addq $0x38, %rsp
retq
leaq 0x3d15(%rip), %rdi      # 0x501f
callq 0x1060
pushq $0x1
popq %rdi
callq 0x1160
// File: /workspace/github_c_makefile_star2_O2/Astor-Bizard[P]ProjetS5_Groupe2/src/displayCorrectionSymbols.c
// Function: remplirDonnees
Table_Donnees remplirDonnees(int argc,char *argv[],
		Elf32_Ehdr Old_elfHeaders,SectionsHeadersList Old_section_headers)
{
	int i;
	char nom[42];
	Elf32_Addr addr;
	Table_Donnees tab_donnees;


	tab_donnees.nbSecRel = argc-3;
	tab_donnees.table_Addr = malloc(sizeof(Elf32_Addr)*tab_donnees.nbSecRel);
	if (tab_donnees.table_Addr==NULL) {
		printf("\nErreur lors de l'allocation initiale de tab_donnees.table_Addr.\n");
		exit(1);
	}
	tab_donnees.table_Num_Addr = malloc(sizeof(int)*tab_donnees.nbSecRel);
	if (tab_donnees.table_Num_Addr==NULL) {
		printf("\nErreur lors de l'allocation initiale de tab_donnees.table_Num_Addr.\n");
		free(tab_donnees.table_Addr);
		exit(1);
	}

	for(i=0;i<tab_donnees.nbSecRel;i++)
	{
		addr = recuperer_donnees(argv[i+3],nom);
		
		tab_donnees.table_Num_Addr[i]=index_Shdr(nom, Old_section_headers); 
		tab_donnees.table_Addr[i]=addr;
	}

	return tab_donnees;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, 0x28(%rsp)
movq %rdi, %rbx
leal -0x3(%rsi), %r14d
movl %r14d, (%rdi)
movslq %esi, %rax
leaq -0xc(,%rax,4), %r12
movq %r12, %rdi
callq 0x1100
movq %rax, 0x8(%rbx)
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x13e0
movq %r12, %rdi
callq 0x1100
movq %rbx, 0x20(%rsp)
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x13ee
movq %rax, %r12
leaq 0xd8(%rsp), %rbx
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
leaq 0x30(%rsp), %r13
cmpq %r15, %r14
je 0x13cc
movq 0x28(%rsp), %rax
movq 0x18(%rax,%r15,8), %rdi
movq %r13, %rsi
callq 0x127c
movl %eax, %ebp
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
movq %r13, %rdi
callq 0x253f
movl %eax, (%r12,%r15,4)
movq 0x18(%rsp), %rax
movl %ebp, (%rax,%r15,4)
incq %r15
jmp 0x1389
movq 0x20(%rsp), %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3cb4(%rip), %rdi      # 0x509b
callq 0x1060
jmp 0x1404
leaq 0x3c61(%rip), %rdi      # 0x5056
callq 0x1060
movq 0x18(%rsp), %rdi
callq 0x1030
pushq $0x1
popq %rdi
callq 0x1160
// File: /workspace/github_c_makefile_star2_O2/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 %rsi, %r14
movq %rdi, 0x30(%rsp)
movslq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x70(%rsp), %rbp
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
pushq $0x1
popq %r15
cmpq 0x20(%rsp), %r15
jge 0x390c
imulq $0x28, %r15, %rbx
movl (%rbp,%rbx), %edi
addq 0x28(%rsp), %rdi
leaq 0x88(%rsp), %r12
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
callq 0x253f
movq 0x10(%r12), %rcx
movq %rcx, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
movq 0x30(%rsp), %rdi
movl %eax, %esi
callq 0x2890
movq %rax, %r12
movl 0x10(%rbp,%rbx), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1110
testl %eax, %eax
jne 0x392f
addq %rbp, %rbx
addq $0x14, %rbx
xorl %r13d, %r13d
movl (%rbx), %eax
cmpq %rax, %r13
jae 0x38fc
movzbl (%r12,%r13), %edi
movq %r14, %rsi
callq 0x10c0
incq %r13
jmp 0x38e3
movq %r12, %rdi
callq 0x1030
incq %r15
jmp 0x386d
movq 0x20(%rsp), %rsi
decl %esi
leaq 0x28cc(%rip), %rdi      # 0x61e6
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1090
leaq 0x2939(%rip), %rdi      # 0x626f
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1060
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 $0x18, %rsp
movq %rdi, %rbx
leaq 0x26ab(%rip), %rdi      # 0x62b1
callq 0x1060
movq 0x98(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x88(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x1f48(%rip), %rdi      # 0x5b73
callq 0x253f
movq 0x88(%rsp), %rcx
cltq
imulq $0x28, %rax, %rax
movl 0x10(%rcx,%rax), %r14d
leaq 0x2670(%rip), %rdi      # 0x62ba
callq 0x1060
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1110
movslq 0xb0(%rsp), %r13
movzbl 0x55(%rsp), %ebp
movq 0xa0(%rsp), %r14
addq $0xe, %r14
leaq 0x2627(%rip), %r15      # 0x62a3
xorl %r12d, %r12d
cmpq %r13, %r12
jge 0x3cfd
leaq 0x260a(%rip), %rdi      # 0x6295
movl %r12d, %esi
xorl %eax, %eax
callq 0x1090
movl -0xe(%r14), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x394c
movl -0xa(%r14), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x394c
movl -0x6(%r14), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x394c
movzbl -0x2(%r14), %edx
movq %rbx, %rdi
callq 0x3993
movzbl -0x1(%r14), %edx
movq %rbx, %rdi
callq 0x3993
movzwl (%r14), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x396e
movq %r15, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x1090
incq %r12
addq $0x10, %r14
jmp 0x3c7f
leaq 0x25bf(%rip), %rdi      # 0x62c3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1060
nop
// File: /workspace/github_c_makefile_star2_O2/Astor-Bizard[P]ProjetS5_Groupe2/src/reimpl_R_ARM.c
// Function: r_arm_abs32
void r_arm_abs32(FILE* oldF, FILE *newF, Elf32_Ehdr oldElfHeader, ListeSymboles symbList, Str_Reloc tableReloc, int index, Elf32_Addr addrDest, unsigned char *sectionARecopier) {
	// (S + A) | T , addresse du symbole + relocation, T = 1 si symbole est du type STT_FUNC sinon 0
	// S = valeur du symbole 
	// A = addend de la relocalisation
	// T = 0
	uint16_t addrSymbole = (255<<8 & tableReloc.Rel[index].r_info)>>8;
	uint32_t addend = (uint32_t) lire_octets(oldElfHeader.e_ident[EI_DATA], oldF, 4);
	uint32_t valeurSymb = (uint32_t) symbList.symboles[addrSymbole].st_value;
	uint32_t res = valeurSymb + addend;
	fwrite32(newF, oldElfHeader.e_ident[EI_DATA], ByteSwap32(res));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rsi
movq 0x78(%rsp), %rax
movslq %edx, %rcx
movzbl 0x25(%rsp), %ebp
movzbl 0x5(%rax,%rcx,8), %r14d
movsbl %bpl, %edi
pushq $0x4
popq %rdx
callq 0x188c
movq 0x58(%rsp), %rcx
shll $0x4, %r14d
addl 0x4(%rcx,%r14), %eax
bswapl %eax
movq %rbx, %rdi
movl %ebp, %esi
movl %eax, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x394c