LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xc505(%rip), %rbx      # 0x19340
movq 0xc506(%rip), %r14      # 0x19348
movl $0x1, %edi
callq 0x33d7
cltq
movslq (%r14,%rax,4), %rax
movl (%rbx,%rax,4), %eax
movl %eax, 0xc36d(%rip)      # 0x191c8
movq 0xc4de(%rip), %rbx      # 0x19340
movq 0xc4df(%rip), %r14      # 0x19348
movl $0x1, %edi
callq 0x33d7
cltq
movslq (%r14,%rax,4), %rax
movl (%rbx,%rax,4), %eax
movl %eax, 0xc2de(%rip)      # 0x19160
movq 0xc4b7(%rip), %rbx      # 0x19340
movq 0xc4b8(%rip), %r14      # 0x19348
movl $0x1, %edi
callq 0x33d7
cltq
movslq (%r14,%rax,4), %rax
movl (%rbx,%rax,4), %eax
movl %eax, 0xcaaf(%rip)      # 0x19958
movl $0x1, %edi
callq 0x33d7
movl %eax, 0xc317(%rip)      # 0x191d0
movl $0x1, %edi
callq 0x33d7
movl %eax, 0xc2f3(%rip)      # 0x191bc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcf44
movq 0xc46b(%rip), %rcx      # 0x19350
movl %ebx, %eax
testb $0x8, (%rcx,%rax)
je 0xcf44
movq 0xc44c(%rip), %rcx      # 0x19340
cmpl $-0x11, (%rcx,%rax,4)
jne 0xcf44
movq 0xc457(%rip), %rcx      # 0x19358
movq 0xc440(%rip), %rdx      # 0x19348
movslq (%rdx,%rax,4), %rdx
cmpl $0x51, -0x4(%rcx,%rdx,4)
jge 0xcf6b
movq 0xc42e(%rip), %rcx      # 0x19348
movslq (%rcx,%rax,4), %rsi
shlq $0x2, %rsi
addq 0xc42f(%rip), %rsi      # 0x19358
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x2040
movq %rbx, %rdi
callq 0xcc42
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x63d0(%rip), %rsi      # 0x1331b
leaq 0x6641(%rip), %rdx      # 0x13593
leaq 0x65e4(%rip), %rcx      # 0x1353d
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
jmp 0xcf72
leaq 0x6ba4(%rip), %rdi      # 0x13b16
movl %ebx, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xd018
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2040
movq %r14, %rdi
movl $0x2e, %esi
callq 0x20a0
testq %rax, %rax
jne 0xcfe1
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 0x6b22(%rip), %rdi      # 0x13b41
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xbec7(%rip), %rax      # 0x19348
movslq %edi, %rbx
movslq (%rax,%rbx,4), %rdi
shlq $0x2, %rdi
addq 0xbec5(%rip), %rdi      # 0x19358
callq 0xd029
testq %rax, %rax
jne 0xd4ae
movl 0xc4ad(%rip), %edi      # 0x19950
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x2786
movq %rax, %r14
movq 0xbe90(%rip), %rax      # 0x19348
movslq (%rax,%rbx,4), %rdi
shlq $0x2, %rdi
addq 0xbe91(%rip), %rdi      # 0x19358
callq 0x2030
movq %r14, %rdi
movl %ebx, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0x322a
movl $0x40000, %edi          # imm = 0x40000
subl 0xbe79(%rip), %edi      # 0x19360
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
xorl %ebx, %ebx
movl %eax, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl 0xbc53(%rip), %esi      # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0xbc44(%rip)      # 0x19170
movl 0xbbfe(%rip), %eax      # 0x19130
cmpl $-0x1, %eax
je 0xd54c
xorl %ebx, %ebx
movq 0xbe08(%rip), %rcx      # 0x19348
incl %ebx
cltq
movl (%rcx,%rax,4), %eax
cmpl $-0x1, %eax
jne 0xd540
movl %ebx, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
movl %eax, %ebx
movl $0x1, %edi
callq 0x33d7
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
popq %rbx
jmp 0x3162
// File: /workspace/github_c_makefile_star2_O1/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 0xc3c1(%rip), %edx      # 0x19954
incl %edx
movl %edx, 0xc3b9(%rip)      # 0x19954
leaq 0x66a2(%rip), %rsi      # 0x13c44
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 0x334b
movq 0xbd7d(%rip), %rcx      # 0x19348
movslq %eax, %r14
movslq (%rcx,%r14,4), %rdi
shlq $0x2, %rdi
addq 0xbd7b(%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_O1/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 0xd649
movq 0xbd53(%rip), %rdx      # 0x19350
movl %eax, %ecx
movzbl (%rdx,%rcx), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb $0x8, %dl
jne 0xd649
testb $0x1, %dl
je 0xd63c
movq 0xbd27(%rip), %rax      # 0x19340
cmpl $-0xd, (%rax,%rcx,4)
jne 0xd63c
movq 0xbd22(%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 0xd647
shlq $0x2, %rcx
addq 0xbd01(%rip), %rcx      # 0x19348
movl (%rcx), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbb0e(%rip), %ecx      # 0x19160
addl %edi, %ecx
movl 0xbb6a(%rip), %edi      # 0x191c4
subl %edi, %ecx
jl 0xd6e9
pushq %rbx
movl $0x400, %ebx            # imm = 0x400
cmpl $0x400, %eax            # imm = 0x400
jl 0xd686
leal 0x3ff(%rcx), %ebx
testl %ecx, %ecx
cmovnsl %ecx, %ebx
andl $0xfffffc00, %ebx       # imm = 0xFFFFFC00
addl $0x400, %ebx            # imm = 0x400
addl %ebx, %edi
callq 0x3422
cmpl $0x0, 0xbacc(%rip)      # 0x19160
js 0xd6dc
movq 0xbcbb(%rip), %rdx      # 0x19358
movq 0xbca4(%rip), %rsi      # 0x19348
movslq 0xbab1(%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 0xba8c(%rip), %rdi      # 0x19160
incq %rsi
cmpq %rdi, %rsi
jl 0xd6c5
addl %ebx, 0xbae2(%rip)      # 0x191c4
movl %eax, 0xba74(%rip)      # 0x1915c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0xba81(%rip)      # 0x19174
movl $0x1, %edi
callq 0xd64a
movl $0xffffffff, 0xba6d(%rip) # imm = 0xFFFFFFFF
movslq 0xba52(%rip), %rax      # 0x19160
leaq 0x1(%rax), %rcx
movl %ecx, 0xba48(%rip)      # 0x19160
movq 0xbc29(%rip), %rcx      # 0x19348
movslq 0xba36(%rip), %rdx      # 0x1915c
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0xbc23(%rip), %rcx      # 0x19358
movl %ebx, 0x4(%rcx,%rax,4)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xba28(%rip), %edi      # 0x191bc
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %ebx, %edi
movl %eax, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %ebx
movl 0xb9bd(%rip), %esi      # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0xb9ae(%rip)      # 0x19170
movl %ebp, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
movl %eax, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %ebx
movl $0x1, %edi
callq 0x33d7
movl $0xfffffff3, %edi       # imm = 0xFFFFFFF3
movl %ebx, %esi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3162
// File: /workspace/github_c_makefile_star2_O1/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 0xdb61
movq 0xb80a(%rip), %rcx      # 0x19350
xorl %eax, %eax
movq 0xb7f9(%rip), %rdx      # 0x19348
movl %edi, %esi
testb $0x9, (%rcx,%rsi)
jne 0xdb60
incl %eax
movl (%rdx,%rsi,4), %edi
testl %edi, %edi
jns 0xdb4f
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb7cb(%rip), %rax      # 0x19340
movq 0xb7cc(%rip), %rcx      # 0x19348
movslq 0xb5d9(%rip), %rdx      # 0x1915c
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0xb7c6(%rip), %rcx      # 0x19358
movslq 0xb5c7(%rip), %rdx      # 0x19160
movslq (%rcx,%rdx,4), %rcx
movslq (%rax,%rcx,4), %r14
testq %r14, %r14
js 0xdbc6
movq 0xb7a3(%rip), %rax      # 0x19350
movzbl (%rax,%r14), %eax
testb $0x1, %al
jne 0xdbc6
testb $0x8, %al
je 0xdbcc
leaq 0x60b9(%rip), %rdi      # 0x13c7a
jmp 0xdce2
cmpl $-0x1, %r14d
jne 0xdbba
testl %r14d, %r14d
js 0xdbf7
movq 0xb778(%rip), %rax      # 0x19350
xorl %ebp, %ebp
movq 0xb767(%rip), %rcx      # 0x19348
movl %r14d, %edx
movl %edx, %edx
testb $0x9, (%rax,%rdx)
jne 0xdbf9
incl %ebp
movl (%rcx,%rdx,4), %edx
testl %edx, %edx
jns 0xdbe4
jmp 0xdbf9
xorl %ebp, %ebp
movl %ebp, %edi
callq 0xd64a
movl 0xb55a(%rip), %eax      # 0x19160
addl %ebp, %eax
movl %eax, 0xb552(%rip)      # 0x19160
cmpl $-0x1, %r14d
je 0xdc83
cltq
leaq -0x4(,%rax,4), %r15
movl %r14d, %eax
testl %eax, %eax
js 0xdcdb
movq 0xb720(%rip), %rcx      # 0x19350
movl %eax, %r12d
testb $0x9, (%rcx,%r12)
jne 0xdcdb
movq 0xb6fb(%rip), %rax      # 0x19340
movl (%rax,%r12,4), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movq 0xb6ec(%rip), %rcx      # 0x19348
movslq 0xb4f9(%rip), %rdx      # 0x1915c
movslq (%rcx,%rdx,4), %rdx
shlq $0x2, %rdx
addq 0xb6e6(%rip), %rdx      # 0x19358
movl %eax, (%r15,%rdx)
movl (%rcx,%r12,4), %eax
addq $-0x4, %r15
cmpl $-0x1, %eax
jne 0xdc21
movl %ebp, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
movq 0xb69c(%rip), %rcx      # 0x19348
movslq 0xb4a9(%rip), %rdx      # 0x1915c
movslq (%rcx,%rdx,4), %rcx
shlq $0x2, %rcx
addq 0xb696(%rip), %rcx      # 0x19358
movslq 0xb497(%rip), %rdx      # 0x19160
movl %eax, (%rcx,%rdx,4)
movl %ebx, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xd812
leaq 0x5fad(%rip), %rdi      # 0x13c8f
movl %r14d, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/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 0xb657(%rip), %rax      # 0x19348
movslq 0xb464(%rip), %rcx      # 0x1915c
movslq (%rax,%rcx,4), %rcx
shlq $0x2, %rcx
addq 0xb651(%rip), %rcx      # 0x19358
movq 0xb632(%rip), %rdx      # 0x19340
movslq 0xb44b(%rip), %rsi      # 0x19160
movslq (%rcx,%rsi,4), %rdi
movslq (%rax,%rdi,4), %rdi
movl (%rdx,%rdi,4), %edi
movl %edi, 0xb4a2(%rip)      # 0x191c8
movslq -0x4(%rcx,%rsi,4), %rdi
movl (%rax,%rdi,4), %r8d
movl %r8d, 0xb486(%rip)      # 0x191bc
movl -0x8(%rcx,%rsi,4), %r8d
movl %r8d, 0xb48e(%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, 0xb407(%rip)      # 0x19160
movslq (%rdx,%rdi,4), %rcx
movslq (%rax,%rcx,4), %rax
movl (%rdx,%rax,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb18e(%rip), %edi      # 0x191d0
movl 0xb174(%rip), %esi      # 0x191bc
xorl %edx, %edx
callq 0x3162
movl %eax, %ebx
movl %eax, 0xb11d(%rip)      # 0x19174
movl 0xb16b(%rip), %edi      # 0x191c8
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
movl %eax, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %ebx
movl %eax, 0xb0e4(%rip)      # 0x19174
movl 0xb0ca(%rip), %edi      # 0x19160
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
movl %eax, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x3162
movl %eax, %ebx
movl %eax, 0xb0ab(%rip)      # 0x19174
movl 0xb889(%rip), %edi      # 0x19958
addl $0x2, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x3162
movl $0xfffffff2, %edi       # imm = 0xFFFFFFF2
movl %eax, %esi
movl $0x1, %edx
callq 0x3162
movl %eax, %edi
movl %ebx, %esi
xorl %edx, %edx
callq 0x3162
movl $0xffffffff, 0xb06d(%rip) # imm = 0xFFFFFFFF
movl $0xfffffff5, %edi       # imm = 0xFFFFFFF5
movl %eax, %esi
movl $0x1, %edx
popq %rbx
jmp 0x3162
// File: /workspace/github_c_makefile_star2_O1/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 0xe1b4
movq 0xb21f(%rip), %rcx      # 0x19350
movl %ebx, %eax
testb $0x1, (%rcx,%rax)
je 0xe1b4
movq 0xb200(%rip), %rcx      # 0x19340
cmpl $-0xb, (%rcx,%rax,4)
jne 0xe1b4
movq 0xb1fb(%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, 0xb7f6(%rip)      # 0x19958
movslq (%rdx,%rdi,4), %rdi
movslq (%rcx,%rdi,4), %r8
movslq (%rdx,%r8,4), %r8
movl (%rcx,%r8,4), %r8d
movl %r8d, 0xafe7(%rip)      # 0x19160
movslq (%rdx,%rdi,4), %rdi
movslq (%rcx,%rdi,4), %r8
movslq (%rdx,%r8,4), %r8
movl (%rcx,%r8,4), %r8d
movl %r8d, 0xb038(%rip)      # 0x191c8
movslq (%rdx,%rdi,4), %rdi
movl (%rcx,%rdi,4), %ecx
movl %ecx, 0xb033(%rip)      # 0x191d0
movl (%rdx,%rdi,4), %ecx
movl %ecx, 0xb016(%rip)      # 0x191bc
movl %esi, 0xb014(%rip)      # 0x191c0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x5160(%rip), %rsi      # 0x1331b
leaq 0x5ae0(%rip), %rdx      # 0x13ca2
leaq 0x5adf(%rip), %rcx      # 0x13ca8
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x264c
// File: /workspace/github_c_makefile_star2_O1/blakemcbride[P]LISP9/ls9.c
// Function: throwerr
int throwerr(cell ct) {
	cell	n;

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

// Assembly:
movl 0xaf5e(%rip), %ecx      # 0x19144
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $-0x1, %ecx
je 0xe224
movl 0xb1a5(%rip), %edx      # 0x193a0
movq 0xb13e(%rip), %r8       # 0x19340
movq 0xb13f(%rip), %r9       # 0x19348
movslq %ecx, %rcx
movslq (%r8,%rcx,4), %rax
cmpl %edx, (%r8,%rax,4)
je 0xe224
movl (%r9,%rcx,4), %ecx
cmpl $-0x1, %ecx
jne 0xe209
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0xe119
movq 0xb10c(%rip), %rcx      # 0x19340
movq 0xb10d(%rip), %rdx      # 0x19348
cltq
movslq (%rdx,%rax,4), %rax
movl (%rcx,%rax,4), %esi
jmp 0xe119
// File: /workspace/github_c_makefile_star2_O1/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 0x852a(%rip), %eax      # 0x19144
xorl %edi, %edi
cmpl $-0x1, %eax
je 0x10c34
movq 0x8720(%rip), %rcx      # 0x19348
incl %edi
cltq
movl (%rcx,%rax,4), %eax
cmpl $-0x1, %eax
jne 0x10c28
callq 0x3422
movl %eax, 0x858d(%rip)      # 0x191cc
movl 0x84ff(%rip), %edx      # 0x19144
cmpl $-0x1, %edx
je 0x10c84
movq 0x86f7(%rip), %rax      # 0x19348
movq 0x86e8(%rip), %rcx      # 0x19340
movq 0x86f9(%rip), %rsi      # 0x19358
movslq %edx, %rdx
movslq (%rcx,%rdx,4), %rdi
movl (%rax,%rdi,4), %edi
movslq 0x855c(%rip), %r8       # 0x191cc
movslq (%rax,%r8,4), %r8
movl %edi, (%rsi,%r8,4)
movl (%rax,%rdx,4), %edx
addq $0x4, %rsi
cmpl $-0x1, %edx
jne 0x10c5f
movl 0x8542(%rip), %eax      # 0x191cc
movl %eax, 0x8540(%rip)      # 0x191d0
movl %ebx, %edi
callq 0xe249
movl 0x8523(%rip), %eax      # 0x191c0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x848f(%rip)      # 0x1915c
movl $0xffffffed, %edi       # imm = 0xFFFFFFED
movl $0x1000, %esi           # imm = 0x1000
callq 0x334b
movq 0x8665(%rip), %rcx      # 0x19348
movslq %eax, %r14
movslq (%rcx,%r14,4), %rdi
shlq $0x2, %rdi
addq 0x8663(%rip), %rdi      # 0x19358
movl $0x1000, %edx           # imm = 0x1000
movl $0xff, %esi
callq 0x20b0
movl %r14d, 0x8451(%rip)     # 0x1915c
movl $0x400, 0x84af(%rip)    # imm = 0x400
movl %ebx, 0x8445(%rip)      # 0x19160
movl %ebx, 0x84a7(%rip)      # 0x191c8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x8745(%rip), %rdi      # 0x19480
callq 0x20f0
testl %eax, %eax
setne %cl
movl 0x8c15(%rip), %eax      # 0x19960
testl %eax, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
je 0x10ec2
testl %eax, %eax
jne 0x10d70
leaq -0xc7(%rip), %rsi       # 0x10c9f
movl $0x2, %edi
callq 0x2110
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0x1000, %r12d          # imm = 0x1000
xorl %r13d, %r13d
movl $0x1, %ebp
leaq 0x344e(%rip), %r14      # 0x141d8
callq 0x406b
pcmpeqd %xmm0, %xmm0
movdqa %xmm0, 0x85e5(%rip)     # 0x19380
movdqa %xmm0, 0x85cd(%rip)     # 0x19370
movq $-0x1, 0x85e2(%rip) # 0x19390
movl %ebx, 0x83a8(%rip)      # 0x1915c
movl $0xffffffed, %edi       # imm = 0xFFFFFFED
movl $0x1000, %esi           # imm = 0x1000
callq 0x334b
movq 0x857e(%rip), %rcx      # 0x19348
movslq %eax, %r15
movslq (%rcx,%r15,4), %rax
shlq $0x2, %rax
movq %rax, %rdi
addq 0x8579(%rip), %rdi      # 0x19358
movl $0xff, %esi
movq %r12, %rdx
callq 0x20b0
movl %r15d, 0x8369(%rip)     # 0x1915c
movl $0x400, 0x83c7(%rip)    # imm = 0x400
movl %ebx, 0x835d(%rip)      # 0x19160
movl %ebx, 0x83bf(%rip)      # 0x191c8
movl 0x858d(%rip), %edi      # 0x1939c
movl %ebx, %esi
callq 0x2786
movl %ebx, 0x8354(%rip)      # 0x19170
movl %r13d, 0x8b39(%rip)     # 0x1995c
movl %r13d, 0x8806(%rip)     # 0x19630
cmpl %r13d, 0x8b2f(%rip)     # 0x19960
jne 0x10e49
leaq 0x3041(%rip), %rdi      # 0x13e7b
movl $0x2, %esi
callq 0x29f6
callq 0x296c
callq 0x511d
cmpl $-0x3, %eax
jne 0x10e5c
cmpl $0x0, 0x87d6(%rip)      # 0x19630
je 0x10e99
movl %eax, %edi
movl $0x0, 0x8ae0(%rip)      # 0x19948
movl %r13d, %esi
callq 0x9c5e
movl %eax, %r15d
movl 0x8aeb(%rip), %edi      # 0x19964
movl %eax, %esi
callq 0x2786
movl %ebp, %edi
movl %r15d, %esi
callq 0x5c52
movq %r14, %rdi
movl %ebp, %esi
callq 0x29f6
jmp 0x10d8a
cmpl $0x0, 0x8ac0(%rip)      # 0x19960
jne 0x10eb3
leaq 0x332f(%rip), %rdi      # 0x141d8
movl $0x1, %esi
callq 0x29f6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
callq 0x21f0
// File: /workspace/github_c_makefile_star2_O1/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 0x77f4(%rip), %rdi      # 0x19480
callq 0x20f0
testl %eax, %eax
je 0x11c97
popq %rbx
retq
cmpl $0x0, 0x7cc2(%rip)      # 0x19960
jne 0x11cb1
leaq -0x1008(%rip), %rsi     # 0x10c9f
movl $0x2, %edi
callq 0x2110
movl 0x748d(%rip), %edi      # 0x19144
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $-0x1, %edi
je 0x11cef
movl 0x7ca5(%rip), %ecx      # 0x1996c
movq 0x7672(%rip), %rdx      # 0x19340
movq 0x7673(%rip), %rsi      # 0x19348
movslq %edi, %rdi
movslq (%rdx,%rdi,4), %r8
cmpl %ecx, (%rdx,%r8,4)
je 0x11cf3
movl (%rsi,%rdi,4), %r8d
movl %r8d, %edi
cmpl $-0x1, %r8d
jne 0x11cd5
movl %eax, %ecx
jmp 0x11cf6
movl %r8d, %ecx
cmpl $-0x1, %ecx
je 0x11c95
movq 0x763e(%rip), %rax      # 0x19340
movq 0x763f(%rip), %rdx      # 0x19348
movslq %ecx, %rcx
movslq (%rdx,%rcx,4), %rcx
movslq (%rax,%rcx,4), %rcx
testq %rcx, %rcx
js 0x11c95
movq 0x762c(%rip), %rdx      # 0x19350
testb $0x1, (%rdx,%rcx)
je 0x11c95
cmpl $-0xd, (%rax,%rcx,4)
jne 0x11c95
movl %ecx, %edi
xorl %ebx, %ebx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %ebx, %edx
callq 0x3162
movl %eax, %edi
movl %ebx, %esi
callq 0x9c5e
jmp 0x11c95
// File: /workspace/github_c_makefile_star2_O1/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 0x23f5(%rip), %rbx      # 0x141d8
movq %rbx, %rdi
callq 0x25eb
leaq 0x23e8(%rip), %rdi      # 0x141da
callq 0x25eb
leaq 0x1d79(%rip), %rdi      # 0x13b77
callq 0x25eb
leaq 0x23d7(%rip), %rdi      # 0x141e1
callq 0x25eb
movq %rbx, %rdi
callq 0x25eb
movq %rbx, %rdi
callq 0x25eb
xorl %edi, %edi
callq 0x21f0
// File: /workspace/github_c_makefile_star2_O1/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 0x11e2f
movq %rdi, %rax
retq
pushq %rax
callq 0x11d56
movl $0x1, %edi
callq 0x21f0
// File: /workspace/github_c_makefile_star2_O1/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 0x11ee2
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %eax, %ebp
movl 0x7307(%rip), %esi      # 0x19170
movl %eax, %edi
xorl %edx, %edx
callq 0x3162
movl %eax, 0x72f8(%rip)      # 0x19170
movq (%rbx), %r14
testq %r14, %r14
je 0x11ed4
addq $0x8, %rbx
movq %r14, %rdi
callq 0x2080
movq %r14, %rdi
movl %eax, %esi
callq 0x27dc
movq 0x74a3(%rip), %rcx      # 0x19340
movslq %ebp, %r14
movl %eax, (%rcx,%r14,4)
cmpq $0x0, (%rbx)
je 0x11ec8
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x3162
movl %eax, %ebp
movq 0x7484(%rip), %rax      # 0x19348
movl %ebp, (%rax,%r14,4)
movq (%rbx), %r14
addq $0x8, %rbx
testq %r14, %r14
jne 0x11e84
movl $0x1, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x33d7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/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
jb 0x3350
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 0x1110
movq %rax, 0x10(%rbx)
movq 0x10(%rbx), %rdi
addq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x10e0
addq (%rbx), %r14
movq %r14, (%rbx)
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r14)
xorl %eax, %eax
cmpq $0x0, (%rbx)
je 0x339c
xorl %ecx, %ecx
movq 0x10(%rbx), %rdx
movb (%rdx,%rcx), %sil
cmpb $0x2a, %sil
je 0x3392
movslq %eax, %rdi
incl %eax
movb %sil, (%rdx,%rdi)
incq %rcx
cmpq %rcx, (%rbx)
ja 0x337b
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_O1/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 0x1702
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O1/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 0x2978(%rip), %r14      # 0x4088
movq 0x2979(%rip), %rsi      # 0x4090
cmpq %rsi, %r14
jb 0x173e
leaq (%rsi,%rsi), %rax
movq %rax, 0x2969(%rip)      # 0x4090
movq 0x2952(%rip), %rdi      # 0x4080
shlq $0x4, %rsi
callq 0x10c0
movq %rax, 0x2942(%rip)      # 0x4080
movq 0x293b(%rip), %rax      # 0x4080
leaq 0x1(%r14), %rcx
movq %rcx, 0x2938(%rip)      # 0x4088
movq %rbx, (%rax,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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)
movq $0x0, (%rdi)
movb $0x0, 0x18(%rdi)
movl $0x20, %edi
callq 0x10b0
movq %rax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1818
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 0x1924
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
xorl %r15d, %r15d
movq (%r14), %rdi
movq 0x8(%r14), %r12
subq %rdi, %r12
addq 0x10(%r14), %rdi
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
movq %r12, %rsi
movq %rbx, %rdx
movq %rsp, %rcx
callq 0x1060
testl %eax, %eax
js 0x1888
cmpl %r12d, %eax
jge 0x188f
movl %eax, %eax
addq %rax, (%r14)
movb $0x1, %bpl
xorl %r12d, %r12d
jmp 0x18ce
xorl %r12d, %r12d
xorl %ebp, %ebp
jmp 0x18ce
movb $0x1, %r12b
testl %r15d, %r15d
jne 0x18ce
movq (%r14), %rcx
movq 0x8(%r14), %rsi
cmpq %rcx, %rsi
jbe 0x1905
movl %eax, %eax
notq %rcx
leaq (%rsi,%rcx), %rdx
cmpq %rax, %rdx
jae 0x18c1
leaq (%rcx,%rsi,2), %rdx
addq %rsi, %rsi
cmpq %rax, %rdx
jb 0x18b1
movq %rsi, 0x8(%r14)
movq 0x10(%r14), %rdi
callq 0x10c0
movq %rax, 0x10(%r14)
testb %r12b, %r12b
je 0x18e7
leal 0x1(%r15), %eax
testl %r15d, %r15d
setne %r13b
movl %eax, %r15d
je 0x1831
testb $0x1, %r13b
jne 0x1943
andb $0x1, %bpl
movl %ebp, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6f8(%rip), %rdi       # 0x2004
leaq 0x706(%rip), %rsi       # 0x2019
leaq 0x798(%rip), %rcx       # 0x20b2
movl $0x42, %edx
callq 0x1080
leaq 0x6d9(%rip), %rdi       # 0x2004
leaq 0x6e7(%rip), %rsi       # 0x2019
leaq 0x6ec(%rip), %rcx       # 0x2025
movl $0x4b, %edx
callq 0x1080
leaq 0xabb(%rip), %rdi       # 0x2405
leaq 0x6c8(%rip), %rsi       # 0x2019
leaq 0x6cd(%rip), %rcx       # 0x2025
movl $0x64, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O1/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 0x198a
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
movb $0x0, (%rcx,%rax)
movb $0x1, 0x18(%rdi)
movq 0x10(%rdi), %rdi
callq 0x1702
movq 0x10(%rbx), %rax
popq %rbx
retq
leaq 0x673(%rip), %rdi       # 0x2004
leaq 0x681(%rip), %rsi       # 0x2019
leaq 0x6c4(%rip), %rcx       # 0x2063
movl $0x69, %edx
callq 0x1080
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
movb (%rdi), %al
xorl %ecx, %ecx
cmpb $0x3d, %al
jne 0x12dc
xorl %eax, %eax
jmp 0x12ec
movb %al, (%rsi,%rcx)
movb 0x1(%rdi,%rcx), %al
incq %rcx
cmpb $0x3d, %al
jne 0x12dc
movl %ecx, %eax
movb $0x0, (%rsi,%rcx)
movslq %eax, %rdx
cmpb $0x30, 0x1(%rdi,%rdx)
je 0x1301
cmpb $0x78, 0x2(%rdi,%rcx)
jne 0x134d
movl %eax, %ecx
movb 0x3(%rdi,%rcx), %dl
addq $0x3, %rcx
testb %dl, %dl
je 0x132d
movslq %ecx, %rsi
addq %rsi, %rdi
incq %rdi
xorl %esi, %esi
movslq %esi, %r8
movb %dl, (%rsp,%r8)
movb (%rdi,%rsi), %dl
incq %rsi
testb %dl, %dl
jne 0x131a
addl %esi, %ecx
subl %eax, %ecx
addl $-0x3, %ecx
movslq %ecx, %rax
movb $0x0, (%rsp,%rax)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10f0
addq $0x38, %rsp
retq
leaq 0x3ccb(%rip), %rdi      # 0x501f
callq 0x1060
movl $0x1, %edi
callq 0x1160
// File: /workspace/github_c_makefile_star2_O1/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, %rbp
movl %esi, %r13d
movq %rdi, %r14
leal -0x3(%r13), %ebx
movl %ebx, (%rdi)
movslq %esi, %rax
leaq -0xc(,%rax,4), %r12
movq %r12, %rdi
callq 0x1100
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x1439
movq %rax, %r15
movq %r12, %rdi
callq 0x1100
movq %r14, 0x20(%rsp)
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x1447
cmpl $0x4, %r13d
jl 0x1425
movq %rax, %rcx
movq %r15, %r12
movl %ebx, %edx
movq %rdx, 0x28(%rsp)
xorl %r15d, %r15d
leaq 0x30(%rsp), %r13
movq 0x18(%rbp,%r15,8), %rdi
movq %r13, %rsi
movq %rcx, %rbx
callq 0x12cc
movq %rbp, %r14
movl %eax, %ebp
leaq 0xd8(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x10(%rsp)
movups (%rcx), %xmm0
movups %xmm0, (%rsp)
movq %r13, %rdi
callq 0x2617
movq %rbx, %rcx
movl %eax, (%rbx,%r15,4)
movl %ebp, (%r12,%r15,4)
movq %r14, %rbp
incq %r15
cmpq %r15, 0x28(%rsp)
jne 0x13d8
movq 0x20(%rsp), %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3c5b(%rip), %rdi      # 0x509b
callq 0x1060
jmp 0x145b
leaq 0x3c08(%rip), %rdi      # 0x5056
callq 0x1060
movq %r15, %rdi
callq 0x1030
movl $0x1, %edi
callq 0x1160
// File: /workspace/github_c_makefile_star2_O1/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 0x3a79
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 0x3a62
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3b63
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 0x2617
movq 0x10(%r12), %rcx
movq %rcx, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
movq 0x30(%rsp), %rdi
movl %eax, %esi
callq 0x2980
movq %rax, %r12
movl 0x10(%rbp,%rbx,8), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1110
testl %eax, %eax
jne 0x3b86
cmpl $0x0, 0x14(%rbp,%rbx,8)
je 0x3b4d
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 0x3b36
movq %r12, %rdi
callq 0x1030
incq %r15
cmpq 0x20(%rsp), %r15
jne 0x3ac0
movq 0x20(%rsp), %rsi
decl %esi
leaq 0x26c5(%rip), %rdi      # 0x6236
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1090
leaq 0x2732(%rip), %rdi      # 0x62bf
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0x24a2(%rip), %rdi      # 0x6301
callq 0x1060
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x98(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x1d3f(%rip), %rdi      # 0x5bc3
callq 0x2617
movq 0x98(%rsp), %rcx
cltq
leaq (%rax,%rax,4), %rax
movl 0x10(%rcx,%rax,8), %r14d
leaq 0x2467(%rip), %rdi      # 0x630a
callq 0x1060
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1110
movslq 0xc0(%rsp), %r12
testq %r12, %r12
jle 0x3fd6
leaq 0xb0(%rsp), %rax
leaq 0x60(%rsp), %rcx
movb 0x5(%rcx), %r13b
movq (%rax), %rbp
addq $0xe, %rbp
leaq 0x240e(%rip), %r14      # 0x62f3
xorl %r15d, %r15d
leaq 0x23f6(%rip), %rdi      # 0x62e5
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 0x3ee8
leaq 0x2336(%rip), %rdi      # 0x6313
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x4, %edx
callq 0x18e8
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 0x3ba0
// File: /workspace/github_c_makefile_star2_O1/Astor-Bizard[P]ProjetS5_Groupe2/src/reimpl_R_ARM.c
// Function: r_arm_abs16
void r_arm_abs16(FILE* oldF, FILE *newF, Elf32_Ehdr oldElfHeader, ListeSymboles symbList, Str_Reloc tableReloc, int index, Elf32_Addr addrDest, unsigned char *sectionARecopier) {
	uint16_t addrSymbole = (255<<8 & tableReloc.Rel[index].r_info)>>8;
	uint16_t addend = (uint16_t) lire_octets(oldElfHeader.e_ident[EI_DATA], oldF, 2);
	uint16_t valeurSymb = (uint16_t) symbList.symboles[addrSymbole].st_value;
	uint16_t res = valeurSymb + addend;
	fwrite16(newF, oldElfHeader.e_ident[EI_DATA], ByteSwap16(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
movl $0x2, %edx
callq 0x18e8
movq 0x58(%rsp), %rcx
shll $0x4, %r14d
addl 0x4(%rcx,%r14), %eax
rolw $0x8, %ax
movzwl %ax, %edx
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x3bc6
// File: /workspace/github_c_makefile_star2_O1/Astor-Bizard[P]ProjetS5_Groupe2/src/reimpl_R_ARM.c
// Function: r_arm_abs8
void r_arm_abs8(FILE* oldF, FILE *newF, Elf32_Ehdr oldElfHeader, ListeSymboles symbList, Str_Reloc tableReloc, int index, Elf32_Addr addrDest, unsigned char *sectionARecopier) {
	uint16_t addrSymbole = (255<<8 & tableReloc.Rel[index].r_info)>>8;
	uint8_t addend = (uint8_t) lire_octets(oldElfHeader.e_ident[EI_DATA], oldF, 1);
	uint8_t valeurSymb = (uint8_t) symbList.symboles[addrSymbole].st_value;
	uint8_t res = valeurSymb + addend;
	fwrite8(newF, oldElfHeader.e_ident[EI_DATA], 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
movl $0x1, %edx
callq 0x18e8
movq 0x58(%rsp), %rcx
shll $0x4, %r14d
addl 0x4(%rcx,%r14), %eax
movzbl %al, %edx
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x3bef
// File: /workspace/github_c_makefile_star2_O1/Astor-Bizard[P]ProjetS5_Groupe2/src/reimpl_R_ARM.c
// Function: r_arm_jump24
void r_arm_jump24(FILE* oldF, FILE *newF, Elf32_Ehdr oldElfHeader, ListeSymboles symbList, Str_Reloc tableReloc, int index, Elf32_Addr addrDest, unsigned char *sectionARecopier) {
	// ((S+A) | T) - P
	// P correspond au qqchose dérivé de r_offset du REL (en clair faut juste redécaler sur offset)
	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 keep = addend & 0xFF000000;
	addend = (addend & 0x00FFFFFF) << 2;
	uint32_t valeurSymb = (uint32_t) symbList.symboles[addrSymbole].st_value;
	uint32_t p = (uint32_t) addrDest + (uint32_t) tableReloc.Rel[index].r_offset; 
	uint32_t res = ((((((valeurSymb + addend) - p) & 0x0FFFFFFE) >> 2) & 0x00FFFFFF) | keep);
	fwrite32(newF, oldElfHeader.e_ident[EI_DATA], ByteSwap32(res));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movq %rsi, %rbx
movq %rdi, %rsi
movq 0x98(%rsp), %r15
movslq %edx, %r12
movzbl 0x45(%rsp), %ebp
movzbl 0x5(%r15,%r12,8), %r13d
movsbl %bpl, %edi
movl $0x4, %edx
callq 0x18e8
leal (,%rax,4), %edx
movq 0x78(%rsp), %rcx
shll $0x4, %r13d
addl 0x4(%rcx,%r13), %edx
addl (%r15,%r12,8), %r14d
subl %r14d, %edx
movl %edx, %ecx
andl $-0x4, %ecx
shll $0x16, %ecx
movl %edx, %esi
shll $0x6, %esi
andl $0xff0000, %esi         # imm = 0xFF0000
orl %ecx, %esi
shrl $0xa, %edx
andl $0xff00, %edx           # imm = 0xFF00
orl %esi, %edx
shrl $0x18, %eax
orl %eax, %edx
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3ba0