LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/anachronic[P]st/st.c
// Function: tclearregion
void
tclearregion(int x1, int y1, int x2, int y2, int usecurattr)
{
	int x, y;

	/* regionselected() takes relative coordinates */
	if (regionselected(x1+term.scr, y1+term.scr, x2+term.scr, y2+term.scr))
		selremove();

	for (y = y1; y <= y2; y++) {
		term.dirty[y] = 1;
		for (x = x1; x <= x2; x++)
			tclearglyph(&term.line[y][x], usecurattr);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r14d
movl %esi, %r12d
movl %edi, %r15d
movl 0x11ac1(%rip), %ecx     # 0x1c778
leal (%rcx,%r15), %edi
leal (%rcx,%r12), %esi
leal (%rcx,%r14), %edx
addl %ebx, %ecx
callq 0x665c
testl %eax, %eax
je 0xace2
movl $0x0, 0xdbd8(%rip)      # 0x188b0
movl $0xffffffff, 0xdbea(%rip) # imm = 0xFFFFFFFF
cmpl %ebx, %r12d
jg 0xad4b
movq 0x11a9a(%rip), %rax     # 0x1c788
movq 0xdbf3(%rip), %rcx      # 0x188e8
movslq %r15d, %rdi
movslq %r12d, %rdx
incl %ebx
movl %r14d, %esi
subl %edi, %esi
shlq $0x4, %rdi
orq $0x8, %rdi
incl %esi
movl $0x1, (%rax,%rdx,4)
cmpl %r14d, %r15d
jg 0xad44
movq (%rcx,%rdx,8), %r8
addq %rdi, %r8
movl %esi, %r9d
movq 0x11a6f(%rip), %r10     # 0x1c798
movq %r10, (%r8)
movw $0x0, -0x4(%r8)
movl $0x20, -0x8(%r8)
addq $0x10, %r8
decl %r9d
jne 0xad22
incq %rdx
cmpl %edx, %ebx
jne 0xad0c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/anachronic[P]st/st.c
// Function: tscrolldown
void
tscrolldown(int top, int n)
{
	int i, bot = term.bot;
	Line temp;

	if (n <= 0)
		return;
	n = MIN(n, bot-top+1);

	tsetdirt(top, bot-n);
	tclearregion(0, bot-n+1, term.col-1, bot, 1);

	for (i = bot; i >= top+n; i--) {
		temp = term.line[i];
		term.line[i] = term.line[i-n];
		term.line[i-n] = temp;
	}

	if (sel.ob.x != -1 && sel.alt == IS_SET(MODE_ALTSCREEN))
		selscroll(top, bot, n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0xb07d
movl %edi, %ebx
movslq 0x117eb(%rip), %r14     # 0x1c7b8
movl %r14d, %eax
subl %edi, %eax
leal 0x1(%rax), %r15d
cmpl %esi, %eax
cmovgel %esi, %r15d
movl %r14d, %ebp
subl %r15d, %ebp
movl %ebp, %esi
callq 0x641b
incl %ebp
movl 0xd8f3(%rip), %edx      # 0x188e4
decl %edx
xorl %edi, %edi
movl %ebp, %esi
movl %r14d, %ecx
callq 0xac9e
leal (%r15,%rbx), %ecx
cmpl %ecx, %r14d
jl 0xb04a
movslq %r15d, %rax
movslq %ecx, %rcx
leaq 0x1(%r14), %rdx
shlq $0x3, %rax
negq %rax
movq 0xd8c8(%rip), %rsi      # 0x188e8
leaq (%rsi,%rdx,8), %rdi
movq -0x8(%rsi,%rdx,8), %r8
movq -0x8(%rax,%rdi), %rdi
movq %rdi, -0x8(%rsi,%rdx,8)
movq 0xd8ae(%rip), %rsi      # 0x188e8
addq %rax, %rsi
movq %r8, -0x8(%rsi,%rdx,8)
decq %rdx
cmpq %rcx, %rdx
jg 0xb019
cmpl $-0x1, 0xd87b(%rip)     # 0x188cc
je 0xb07d
movl 0xd883(%rip), %eax      # 0x188dc
btl $0x2, 0x1175b(%rip)     # 0x1c7bc
sbbl $0x0, %eax
jne 0xb07d
movl %ebx, %edi
movl %r14d, %esi
movl %r15d, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb802
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/anachronic[P]st/st.c
// Function: tdeletechar
void
tdeletechar(int n)
{
	int src, dst, size;
	Line line;

	if (n <= 0)
		return;
	dst = term.c.x;
	src = MIN(term.c.x + n, term.col);
	size = term.col - src;
	if (size > 0) { /* otherwise src would point beyond the array
	                   https://stackoverflow.com/questions/29844298 */
		line = term.line[term.c.y];
		memmove(&line[dst], &line[src], size * sizeof(Glyph));
	}
	tclearregion(dst + size, term.c.y, term.col - 1, term.c.y, 1);
}

// Assembly:
testl %edi, %edi
jle 0xb656
pushq %r14
pushq %rbx
pushq %rax
movslq 0x111b3(%rip), %r14     # 0x1c7a0
addl %r14d, %edi
movl 0xd2ee(%rip), %edx      # 0x188e4
cmpl %edx, %edi
cmovgel %edx, %edi
movl %edx, %ebx
subl %edi, %ebx
jle 0xb63b
movq 0xd2e0(%rip), %rax      # 0x188e8
movslq 0x11195(%rip), %rcx     # 0x1c7a4
movq (%rax,%rcx,8), %rcx
movq %r14, %rax
shlq $0x4, %rax
addq %rcx, %rax
movslq %edi, %rsi
shlq $0x4, %rsi
addq %rcx, %rsi
movl %ebx, %edx
shlq $0x4, %rdx
movq %rax, %rdi
callq 0x5510
movl 0xd2a9(%rip), %edx      # 0x188e4
addl %r14d, %ebx
movl 0x11160(%rip), %ecx     # 0x1c7a4
decl %edx
movl %ebx, %edi
movl %ecx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xac9e
retq
// File: /workspace/github_c_makefile_star2_O3/anachronic[P]st/st.c
// Function: selscroll
void
selscroll(int top, int bot, int n)
{
	/* turn absolute coordinates into relative */
	top += term.scr, bot += term.scr;

	if (BETWEEN(sel.nb.y, top, bot) != BETWEEN(sel.ne.y, top, bot)) {
		selclear();
	} else if (BETWEEN(sel.nb.y, top, bot)) {
		selmove(n);
		if (sel.nb.y < top || sel.ne.y > bot)
			selclear();
	}
}

// Assembly:
movl %esi, %eax
movl %edi, %ecx
movl 0x10f6c(%rip), %esi     # 0x1c778
addl %esi, %ecx
addl %esi, %eax
movl 0xd0aa(%rip), %edi      # 0x188c0
cmpl %edi, %ecx
setle %sil
cmpl %eax, %edi
setle %r8b
andb %sil, %r8b
movl 0xd09d(%rip), %esi      # 0x188c8
cmpl %esi, %ecx
setg %r9b
cmpl %eax, %esi
setg %r10b
orb %r9b, %r10b
cmpb %r10b, %r8b
je 0xb86e
testb %r8b, %r8b
je 0xb890
addl %edx, 0xd086(%rip)      # 0x188d0
addl %edx, %edi
movl %edi, 0xd06e(%rip)      # 0x188c0
addl %edx, 0xd080(%rip)      # 0x188d8
addl %edx, %esi
movl %esi, 0xd068(%rip)      # 0x188c8
cmpl %ecx, %edi
setge %cl
cmpl %eax, %esi
setle %al
testb %al, %cl
jne 0xb890
cmpl $-0x1, 0xd057(%rip)     # 0x188cc
je 0xb890
movl $0x0, 0xd02f(%rip)      # 0x188b0
movl $0xffffffff, 0xd041(%rip) # imm = 0xFFFFFFFF
jmp 0x641b
retq
// File: /workspace/github_c_makefile_star2_O3/anachronic[P]st/x.c
// Function: xsettitle
void
xsettitle(char *p, int pop)
{
 	XTextProperty prop;
 
	free(titlestack[tstki]);
	if (pop) {
		titlestack[tstki] = NULL;
		tstki = (tstki - 1 + TITLESTACKSIZE) % TITLESTACKSIZE;
		p = titlestack[tstki] ? titlestack[tstki] : opt_title;
	} else if (p) {
		titlestack[tstki] = xstrdup(p);
	} else {
		titlestack[tstki] = NULL;
		p = opt_title;
	}

	if (Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle,
	                                &prop) != Success)
		return;
	XSetWMName(xw.dpy, xw.win, &prop);
	XSetTextProperty(xw.dpy, xw.win, &prop, xw.netwmname);
	XFree(prop.value);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq %rdi, (%rsp)
movl 0x12caf(%rip), %r15d    # 0x1ede0
leaq 0x12c68(%rip), %r14     # 0x1eda0
movq (%r14,%r15,8), %rdi
callq 0x5340
testl %ebp, %ebp
je 0xc165
movq $0x0, (%r14,%r15,8)
leal -0x1(%r15), %eax
andl $0x7, %eax
movl %eax, 0x12c86(%rip)     # 0x1ede0
movq (%r14,%rax,8), %rax
testq %rax, %rax
je 0xc186
jmp 0xc18d
testq %rbx, %rbx
je 0xc17e
movq %rbx, %rdi
callq 0x5fca
movl 0x12c68(%rip), %ecx     # 0x1ede0
movq %rax, (%r14,%rcx,8)
jmp 0xc191
movq $0x0, (%r14,%r15,8)
movq 0x12c03(%rip), %rax     # 0x1ed90
movq %rax, (%rsp)
movq 0x12ac8(%rip), %rdi     # 0x1ec60
movq %rsp, %rsi
leaq 0x8(%rsp), %r8
movl $0x1, %edx
movl $0x4, %ecx
callq 0x5430
testl %eax, %eax
jne 0xc1f3
movq 0x12aa6(%rip), %rdi     # 0x1ec60
movq 0x12aaf(%rip), %rsi     # 0x1ec70
leaq 0x8(%rsp), %rbx
movq %rbx, %rdx
callq 0x53e0
movq 0x12a8b(%rip), %rdi     # 0x1ec60
movq 0x12a94(%rip), %rsi     # 0x1ec70
movq 0x12ab5(%rip), %rcx     # 0x1ec98
movq %rbx, %rdx
callq 0x5450
movq (%rbx), %rdi
callq 0x5090
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/anachronic[P]st/x.c
// Function: xpushtitle
void
xpushtitle(void)
{
	int tstkin = (tstki + 1) % TITLESTACKSIZE;

	free(titlestack[tstkin]);
	titlestack[tstkin] = titlestack[tstki] ? xstrdup(titlestack[tstki]) : NULL;
	tstki = tstkin;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x12bd6(%rip), %r15d    # 0x1ede0
leal 0x1(%r15), %ebx
andl $0x7, %ebx
leaq 0x12b88(%rip), %r14     # 0x1eda0
movq (%r14,%rbx,8), %rdi
callq 0x5340
movq (%r14,%r15,8), %rdi
testq %rdi, %rdi
je 0xc231
callq 0x5fca
jmp 0xc233
xorl %eax, %eax
movq %rax, (%r14,%rbx,8)
movl %ebx, 0x12ba3(%rip)     # 0x1ede0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/anachronic[P]st/x.c
// Function: mouseaction
int
mouseaction(XEvent *e, uint release)
{
	MouseShortcut *ms;

	/* ignore Button<N>mask for Button<N> - it's set on release */
	uint state = e->xbutton.state & ~buttonmask(e->xbutton.button);

	for (ms = mshortcuts; ms < mshortcuts + LEN(mshortcuts); ms++) {
		if (ms->release == release &&
		    ms->button == e->xbutton.button &&
		    (!ms->altscrn || (ms->altscrn == (tisaltscreen() ? 1 : -1))) &&
		    (match(ms->mod, state) ||  /* exact or forced */
		     match(ms->mod, state & ~forcemousemod))) {
			ms->func(&(ms->arg));
			return 1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x50(%rdi), %eax
movl 0x54(%rdi), %ecx
leal -0x1(%rcx), %edx
cmpl $0x4, %edx
jae 0xf635
movl %edx, %ecx
leaq 0x2fa4(%rip), %rdx      # 0x125d4
movl (%rdx,%rcx,4), %ebp
jmp 0xf646
xorl %ebp, %ebp
cmpl $0x5, %ecx
setne %bpl
negl %ebp
orl $0xffffefff, %ebp       # imm = 0xFFFFEFFF
andl %eax, %ebp
movl %ebp, %eax
andl $0xffff9fef, %eax       # imm = 0xFFFF9FEF
movl %eax, 0x4(%rsp)
andl $0xffff9fee, %ebp       # imm = 0xFFFF9FEE
movq $-0x20, %r12
leaq 0x9159(%rip), %r13      # 0x187c0
cmpl %ebx, 0x38(%r12,%r13)
jne 0xf6ae
movl 0x24(%r12,%r13), %eax
cmpl 0x54(%r14), %eax
jne 0xf6ae
movl 0x3c(%r12,%r13), %r15d
testl %r15d, %r15d
je 0xf69a
callq 0x7728
cmpl $0x1, %eax
movl $0x0, %eax
sbbl %eax, %eax
orl $0x1, %eax
cmpl %eax, %r15d
jne 0xf6ae
movl 0x20(%r12,%r13), %eax
cmpl $-0x1, %eax
je 0xf6cc
cmpl %eax, 0x4(%rsp)
je 0xf6cc
cmpl %eax, %ebp
je 0xf6cc
addq $0x20, %r12
cmpq $0xc0, %r12
jb 0xf667
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq (%r12,%r13), %rdi
addq $0x30, %rdi
callq *-0x8(%rdi)
movl $0x1, %eax
jmp 0xf6bd
// File: /workspace/github_c_makefile_star2_O3/simh[P]simtools/converters/m8376/m8376.c
// Function: main
int main (int argc, char *argv[])
{
FILE *fi[8], *outf;
char fname[256];
int c, i, j;
unsigned int wd[1024];

for (i = 0; i < 8; i++) {
	sprintf (fname, "C:\\temp\\m8376\\m8376e%03d.bin", fnum[i]);
	fi[i] = fopen (fname, "rb");
	if (fi[i] == NULL) {
	    printf ("Can't open file %s\n", fname);
	    return 0;
	    }
	}

for (i = 0; i < 1024; i++) {
	wd[i] = 0;
	for (j = 7; j >=0; j--) {
	    c = fgetc (fi[j]);
	    if (c == EOF) {
		printf ("Premature end of file on file %d\n", i);
		return 0;
		}
	    wd[i] = (wd[i] << 4) | (c & 0xF);
	    }
	}

for (i = 0; i < 8; i++) fclose (fi[i]);
outf = fopen ("c:\\prom.bin", "wb");
if (outf == NULL) {
	printf ("Can't open output file\n");
	return 0;
	}
fwrite (wd, 1024, sizeof (int), outf);
fclose (outf);
return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1148, %rsp           # imm = 0x1148
leaq 0xecc(%rip), %r12       # 0x2080
leaq 0xe49(%rip), %rbx       # 0x2004
leaq 0x40(%rsp), %r14
leaq 0xe5a(%rip), %r15       # 0x2021
xorl %r13d, %r13d
movl (%r13,%r12), %edx
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1080
movq %r14, %rdi
movq %r15, %rsi
callq 0x1070
movq %rax, (%rsp,%r13,2)
testq %rax, %rax
je 0x1299
addq $0x4, %r13
cmpq $0x20, %r13
jne 0x11ca
xorl %ebx, %ebx
movl $0x0, 0x140(%rsp,%rbx,4)
movl $0x7, %r14d
xorl %ebp, %ebp
movq (%rsp,%r14,8), %rdi
callq 0x1060
cmpl $-0x1, %eax
je 0x12ae
shll $0x4, %ebp
andl $0xf, %eax
orl %eax, %ebp
movl %ebp, 0x140(%rsp,%rbx,4)
addq $-0x1, %r14
jb 0x1213
incq %rbx
cmpq $0x400, %rbx            # imm = 0x400
jne 0x1200
xorl %ebx, %ebx
movq (%rsp,%rbx,8), %rdi
callq 0x1040
incq %rbx
cmpq $0x8, %rbx
jne 0x1248
leaq 0xdf9(%rip), %rdi       # 0x205a
leaq 0xdfe(%rip), %rsi       # 0x2066
callq 0x1070
testq %rax, %rax
je 0x12d2
movq %rax, %rbx
leaq 0x140(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
movl $0x4, %edx
movq %rax, %rcx
callq 0x1090
movq %rbx, %rdi
callq 0x1040
jmp 0x12be
leaq 0xd84(%rip), %rdi       # 0x2024
leaq 0x40(%rsp), %rsi
xorl %eax, %eax
callq 0x1050
jmp 0x12be
leaq 0xd83(%rip), %rdi       # 0x2038
movl %ebx, %esi
xorl %eax, %eax
callq 0x1050
xorl %eax, %eax
addq $0x1148, %rsp           # imm = 0x1148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd90(%rip), %rdi       # 0x2069
callq 0x1030
jmp 0x12be
// File: /workspace/github_c_makefile_star2_O3/mflatt[P]gc-demo/cgc/cgc.c
// Function: find_roots
static void find_roots(jmp_buf env)
{
  num_roots = 0;

  /* Since a frame was pushed to call find_roots,
     stack variables during original_main() are definitely
     deeper than `stack_now` */
  void **stack_now = (void **)&stack_now;

  /* Scan the stack for pointers */
  while ((void *)stack_now < stack_init) {
    if (looks_like_allocated(*stack_now))
      root_addrs[num_roots++] = (struct node **)stack_now;
    stack_now++;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x2dbe(%rip), %rax      # 0x4078
movl $0x0, (%rax)
movq 0x2da1(%rip), %rcx      # 0x4068
leaq -0x8(%rsp), %rdx
movq %rdx, (%rdx)
cmpq %rcx, %rdx
jae 0x136e
leaq 0x2da1(%rip), %rsi      # 0x4080
movq (%rsi), %rsi
xorl %r10d, %r10d
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
movabsq $-0x5555555555555558, %r8 # imm = 0xAAAAAAAAAAAAAAA8
movabsq $0xaaaaaaaaaaaaaab, %r9 # imm = 0xAAAAAAAAAAAAAAB
leaq 0x2d86(%rip), %r11      # 0x4090
testq %rsi, %rsi
je 0x1360
movq (%rdx), %rbx
movq %rsi, %r14
movq 0x8(%r14), %r15
cmpq %rbx, %r15
seta %bpl
leaq 0xc0000(%r15), %r12
cmpq %rbx, %r12
setb %r12b
orb %bpl, %r12b
jne 0x1349
movq %rbx, %r12
subq %r15, %r12
imulq %rdi, %r12
addq %r8, %r12
rorq $0x3, %r12
cmpq %r9, %r12
jb 0x1353
movq (%r14), %r14
testq %r14, %r14
jne 0x1315
jmp 0x1360
movslq %r10d, %rbx
incl %r10d
movl %r10d, (%rax)
movq %rdx, (%r11,%rbx,8)
addq $0x8, %rdx
movq %rdx, -0x8(%rsp)
cmpq %rcx, %rdx
jb 0x130a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/FirestonnneTFM[P]tfm_key_parser/src/main_sniffer.cpp
// Function: keys::print()
void keys::print() {
	std::cout << "version = " << version << std::endl;
	std::cout << "login = " << login << std::endl;
	std::cout << "handshake = " << handshake << std::endl;
	std::cout << "hash =";
	for (unsigned i = 0; i < 20; ++i) {
		printf(" %02x", hash[i]);
	}
	std::cout << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x50e8(%rip), %rbx      # 0x9fd0
leaq 0x2448(%rip), %rsi      # 0x7337
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2220
movzwl (%r14), %esi
movq %rbx, %rdi
callq 0x2140
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
leaq 0x2409(%rip), %rsi      # 0x7342
movl $0x8, %r12d
movl $0x8, %edx
movq %rbx, %rdi
callq 0x2220
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0x22d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
leaq 0x23c2(%rip), %rsi      # 0x734b
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2220
leaq 0x1c(%r14), %r15
movq %r15, %rdi
callq 0x20e0
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2220
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
leaq 0x237a(%rip), %rsi      # 0x7358
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2220
leaq 0x236d(%rip), %r15      # 0x735f
movzbl (%r14,%r12), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2050
incq %r12
cmpq $0x1c, %r12
jne 0x4ff2
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2150
// File: /workspace/github_c_makefile_star2_O3/FirestonnneTFM[P]tfm_key_parser/src/main_sniffer.cpp
// Function: executer::get_lex_int()
int32_t executer::get_lex_int() {
	uint32_t index, arg_count;
	*this >> index;
	if (strlen(abc_file::get_multiname(index)->ns_str))
		fatal("class is out of our namespace");
	class_info *c = abc_file::get_class_by_name(index);
	c->do_static_init();
	assert(next() == OP_callproperty);
	*this >> index;
	*this >> arg_count;
	assert(arg_count == 0);
	traits_info *tm = c->get_trait_by_name(abc_file::get_multiname(index));
	method_info *m = abc_file::get_method(tm->vindex);
	executer exec(m);
	assert(exec.step() == OP_getlocal_0);
	assert(exec.step() == OP_pushscope);
	int32_t a = exec.get_push();
	int32_t b = exec.get_push();
	assert(exec.step() == OP_add);
	assert(exec.step() == OP_returnvalue);
	return a + b;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x30b0
movl (%r14), %edi
callq 0x2ece
movq 0x8(%rax), %rax
cmpb $0x0, (%rax)
jne 0x51b7
movl 0xc(%rsp), %edi
callq 0x2f42
movq %rax, %r14
movq %rax, %rdi
callq 0x3822
movq %rbx, %rdi
callq 0x305a
cmpb $0x46, %al
jne 0x51db
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x30b0
leaq 0x24(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x30b0
cmpl $0x0, (%r15)
jne 0x51ed
movl 0xc(%rsp), %edi
callq 0x2ece
movq %r14, %rdi
movq %rax, %rsi
callq 0x3b24
movl 0xc(%rax), %edi
callq 0x2f12
movq 0x40(%rax), %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x304c
movq %rbx, %rdi
callq 0x2808
cmpb $-0x30, %al
jne 0x51ff
leaq 0x10(%rsp), %rdi
callq 0x2808
cmpb $0x30, %al
jne 0x5211
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x29bc
movl %eax, %ebx
movq %r14, %rdi
callq 0x29bc
movl %eax, %ebp
movq %r14, %rdi
callq 0x2808
cmpb $-0x60, %al
jne 0x5223
leaq 0x10(%rsp), %rdi
callq 0x2808
cmpb $0x48, %al
jne 0x5235
addl %ebx, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x18, %edi
callq 0x2100
movl $0x3c, (%rax)
leaq 0x21b5(%rip), %rcx      # 0x7383
movq %rcx, 0x8(%rax)
leaq 0x218c(%rip), %rcx      # 0x7365
jmp 0x5257
movl $0x18, %edi
callq 0x2100
movl $0x3f, (%rax)
jmp 0x5245
movl $0x18, %edi
callq 0x2100
movl $0x42, (%rax)
jmp 0x5245
movl $0x18, %edi
callq 0x2100
movl $0x46, (%rax)
jmp 0x5245
movl $0x18, %edi
callq 0x2100
movl $0x47, (%rax)
jmp 0x5245
movl $0x18, %edi
callq 0x2100
movl $0x4a, (%rax)
jmp 0x5245
movl $0x18, %edi
callq 0x2100
movl $0x4b, (%rax)
leaq 0x2137(%rip), %rcx      # 0x7383
movq %rcx, 0x8(%rax)
leaq 0x2141(%rip), %rcx      # 0x7398
movq %rcx, 0x10(%rax)
leaq 0x4b2e(%rip), %rsi      # 0x9d90
movq %rax, %rdi
xorl %edx, %edx
callq 0x22c0
// File: /workspace/github_c_makefile_star2_O3/FirestonnneTFM[P]tfm_key_parser/src/main_sniffer.cpp
// Function: executer::get_lex_bool()
bool executer::get_lex_bool() {
	uint32_t index;
	*this >> index;
	if (strlen(abc_file::get_multiname(index)->ns_str))
		fatal("class is out of our namespace");
	class_info *c = abc_file::get_class_by_name(index);
	c->do_static_init();
	assert(next() == OP_getproperty);
	*this >> index;
	traits_info *trait = c->get_trait_by_name(abc_file::get_multiname(index));
	if (! trait->has_loaded_value)
		fatal("The static trait does not have a loaded value");
	return trait->loaded_value != 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x30b0
movl (%r14), %edi
callq 0x2ece
movq 0x8(%rax), %rax
cmpb $0x0, (%rax)
jne 0x52f0
movl 0xc(%rsp), %edi
callq 0x2f42
movq %rax, %r14
movq %rax, %rdi
callq 0x3822
movq %rbx, %rdi
callq 0x305a
cmpb $0x66, %al
jne 0x5314
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x30b0
movl (%r15), %edi
callq 0x2ece
movq %r14, %rdi
movq %rax, %rsi
callq 0x3b24
cmpb $0x0, 0x10(%rax)
je 0x5338
cmpl $0x0, 0x14(%rax)
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x18, %edi
callq 0x2100
movl $0x53, (%rax)
leaq 0x207c(%rip), %rcx      # 0x7383
movq %rcx, 0x8(%rax)
leaq 0x2053(%rip), %rcx      # 0x7365
jmp 0x535a
movl $0x18, %edi
callq 0x2100
movl $0x56, (%rax)
leaq 0x2058(%rip), %rcx      # 0x7383
movq %rcx, 0x8(%rax)
leaq 0x2062(%rip), %rcx      # 0x7398
jmp 0x535a
movl $0x18, %edi
callq 0x2100
movl $0x5a, (%rax)
leaq 0x2034(%rip), %rcx      # 0x7383
movq %rcx, 0x8(%rax)
leaq 0x204c(%rip), %rcx      # 0x73a6
movq %rcx, 0x10(%rax)
leaq 0x4a2b(%rip), %rsi      # 0x9d90
movq %rax, %rdi
xorl %edx, %edx
callq 0x22c0
nop
// File: /workspace/github_c_makefile_star2_O3/FirestonnneTFM[P]tfm_key_parser/src/main_sniffer.cpp
// Function: executer::get_lex_str()
char *executer::get_lex_str() {
	uint32_t index;
	*this >> index;
	if (strlen(abc_file::get_multiname(index)->ns_str))
		return abc_file::get_str(0);
	class_info *c = abc_file::get_class_by_name(index);
	c->do_static_init();
	assert(next() == OP_getproperty);
	*this >> index;
	traits_info *trait = c->get_trait_by_name(abc_file::get_multiname(index));
	return abc_file::get_str(trait->vindex);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x30b0
movl (%r14), %edi
callq 0x2ece
movq 0x8(%rax), %rax
xorl %edi, %edi
cmpb $0x0, (%rax)
jne 0x53e2
movl 0xc(%rsp), %edi
callq 0x2f42
movq %rax, %r14
movq %rax, %rdi
callq 0x3822
movq %rbx, %rdi
callq 0x305a
cmpb $0x66, %al
jne 0x53f1
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x30b0
movl (%r15), %edi
callq 0x2ece
movq %r14, %rdi
movq %rax, %rsi
callq 0x3b24
movl 0xc(%rax), %edi
callq 0x2e82
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x18, %edi
callq 0x2100
movl $0x65, (%rax)
leaq 0x1f7b(%rip), %rcx      # 0x7383
movq %rcx, 0x8(%rax)
leaq 0x1f85(%rip), %rcx      # 0x7398
movq %rcx, 0x10(%rax)
leaq 0x4972(%rip), %rsi      # 0x9d90
movq %rax, %rdi
xorl %edx, %edx
callq 0x22c0
// File: /workspace/github_c_makefile_star2_O3/ravenexp[P]aatrace/testdiff.c
// Function: main
int main(int argc, char* argv[])
{
	struct aatrace_pic src, dst;
	struct aatrace_diff_ctx ctx;
	int c;

	aatrace_diff_ctx_init(&ctx);

	while ((c = getopt(argc, argv, ":l:d:t:")) != -1) {
		switch(c) {
		case 'l':
			ctx.scale = atoi(optarg);
			break;
		case 'd':
			ctx.kernel = (enum aatrace_diff_kernel)atoi(optarg);
			break;
		case 't':
			ctx.threshold = (unsigned)atoi(optarg);
			break;
		case ':':
			fprintf(stderr, "Option -%c requires an operand\n", optopt);
			return 2;
		default:
		case '?':
			fprintf(stderr, "Unrecognized option: -%c\n", optopt);
			return 1;
		}
	}

	if (optind != argc - 2) {
		puts(usage);
		return 3;
	}

	if (util_load_pic(&src, argv[optind]) < 0)
		return 4;

	aatrace_diff(&dst, &src, &ctx);

	if (util_store_pic(argv[optind + 1], &dst) < 0)
		return 5;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xc(%rsp), %rdi
callq 0x1c14
leaq 0x1c08(%rip), %r14      # 0x3004
movq 0x3bcd(%rip), %r15      # 0x4fd0
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1120
cmpl $0x6b, %eax
jle 0x1431
cmpl $0x74, %eax
je 0x1444
cmpl $0x6c, %eax
jne 0x14d4
movq (%r15), %rdi
callq 0x1130
movl %eax, 0x10(%rsp)
jmp 0x1403
cmpl $0x64, %eax
jne 0x1452
movq (%r15), %rdi
callq 0x1130
movl %eax, 0xc(%rsp)
jmp 0x1403
movq (%r15), %rdi
callq 0x1130
movl %eax, 0x14(%rsp)
jmp 0x1403
cmpl $-0x1, %eax
jne 0x14c3
movq 0x3b6a(%rip), %r15      # 0x4fc8
movslq (%r15), %rax
addl $-0x2, %ebp
cmpl %ebp, %eax
jne 0x14a9
movq (%rbx,%rax,8), %rsi
leaq 0x18(%rsp), %rdi
callq 0x1a2b
testl %eax, %eax
js 0x14bc
leaq 0x30(%rsp), %r14
leaq 0x18(%rsp), %rsi
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
callq 0x1c29
movslq (%r15), %rax
movq 0x8(%rbx,%rax,8), %rdi
movq %r14, %rsi
callq 0x1b17
sarl $0x1f, %eax
andl $0x5, %eax
jmp 0x14de
leaq 0x1ba0(%rip), %rdi      # 0x3050
callq 0x1060
movl $0x3, %eax
jmp 0x14de
movl $0x4, %eax
jmp 0x14de
cmpl $0x3a, %eax
jne 0x14d4
callq 0x1170
movl $0x2, %eax
jmp 0x14de
callq 0x1197
movl $0x1, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/tests/daemonize/main.c
// Function: main
int
main(int argc, char * argv[])
{
	const char * pidfile;

	/*
	 * This will allocate some memory for the program name, which will be
	 * freed by an atexit() function.  The non-daemonized fork of this
	 * program will call _exit() to quit without calling that function.
	 * This might cause a memory checker to issue an invalid warning
	 * which should be suppressed.
	 */
	WARNP_INIT;

	/* Parse command-line argument. */
	if (argc != 2) {
		fprintf(stderr, "usage: test_daemonize pidfile\n");
		goto err0;
	}
	pidfile = argv[1];

	/* Print current pid. */
	warn0("before daemonize, pid:\t%jd", (intmax_t)getpid());

	/* Launch daemon. */
	if (daemonize(pidfile))
		goto err0;

	/* Print current pid. */
	warn0("after daemonize, pid:\t%jd", (intmax_t)getpid());

	/* Success! */
	exit(0);

err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x1422
callq 0x1a8c
cmpl $0x2, %ebp
je 0x1451
movq 0x2bca(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xbcc(%rip), %rdi       # 0x2004
movl $0x1e, %esi
movl $0x1, %edx
callq 0x11b0
movl $0x1, %edi
callq 0x11a0
movq 0x8(%rbx), %r14
callq 0x10a0
movslq %eax, %rsi
leaq 0xbbf(%rip), %rdi       # 0x2023
xorl %eax, %eax
callq 0x1c2b
callq 0x1060
movq %rax, %rbx
movl $0x0, (%rax)
movq %r14, %rdi
callq 0x14a8
testl %eax, %eax
jne 0x1447
callq 0x10a0
movslq %eax, %rsi
leaq 0xbaa(%rip), %rdi       # 0x203e
xorl %eax, %eax
callq 0x1c2b
movl $0x0, (%rbx)
xorl %edi, %edi
callq 0x11a0
// File: /workspace/github_c_makefile_star2_O3/zefie[P]zefie_3k_iso_patcher/zefie_3k_iso_patcher.c
// Function: getFileDir
void getFileDir(char *filename, char *ret) {
	print_debug("attempting to find directory for %s\n",filename);
	char tmp[PATH_MAX];
	realpath(filename, tmp);
	if (!tmp) {
		printf("Error finding directory for %s (Err %i).\n", filename, errno);
		return;
	}
	print_debug("realpath for %s returned %s\n",filename,tmp);
	char *pos = strrchr(tmp, 47);
	int strpos = (pos - tmp);
	strncpy(ret, tmp, strpos);
	print_debug("found directory %s\n",ret);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsi, %rbx
movq %rsp, %r14
movq %r14, %rsi
callq 0x40be00
movq %r14, %rdi
movl $0x2f, %esi
callq 0x401050
subl %r14d, %eax
movslq %eax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x401088
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: count
void count(struct counter *c) {
	char	msg[] = "statistics counter overflow";
	c->n++;
	if (c->n >= 1000) {
		c->n -= 1000;
		c->n1k++;
		if (c->n1k >= 1000) {
			c->n1k -= 1000;
			c->n1m++;
			if (c->n1m >= 1000) {
				c->n1m -= 1000;
				c->n1g++;
				if (c->n1g >= 1000) {
					c->n1t -= 1000;
					c->n1t++;
					if (c->n1t >= 1000) {
						error(msg, NOEXPR);
					}
				}
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movups 0x1458e(%rip), %xmm0    # 0x178ec
movups %xmm0, -0x14(%rbp)
movaps 0x14577(%rip), %xmm0    # 0x178e0
movaps %xmm0, -0x20(%rbp)
movl (%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rdi)
cmpl $0x3e7, %eax            # imm = 0x3E7
jl 0x33e5
addl $0xfffffc19, %eax       # imm = 0xFFFFFC19
movl %eax, (%rdi)
movl 0x4(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rdi)
cmpl $0x3e7, %eax            # imm = 0x3E7
jl 0x33e5
addl $0xfffffc19, %eax       # imm = 0xFFFFFC19
movl %eax, 0x4(%rdi)
movl 0x8(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%rdi)
cmpl $0x3e7, %eax            # imm = 0x3E7
jl 0x33e5
addl $0xfffffc19, %eax       # imm = 0xFFFFFC19
movl %eax, 0x8(%rdi)
movl 0xc(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
cmpl $0x3e7, %eax            # imm = 0x3E7
jl 0x33e5
movl 0x10(%rdi), %eax
leal -0x3e7(%rax), %ecx
movl %ecx, 0x10(%rdi)
cmpl $0x7cf, %eax            # imm = 0x7CF
jl 0x33e5
leaq -0x20(%rbp), %rdi
movq $-0x8, %rsi
callq 0x33eb
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: error
cell error(char *msg, cell expr) {
	int	os;
	char	buf[100];

	if (Error_flag)
		return UNDEFINED;
	os = Outstream;
	Outstream = Quiet_mode? 2: 1;
	Error_flag = 1;
	pr("error: ");
	if (box_value(S_loading) == TRUE) {
		if (File_list != NIL) {
			print_form(car(File_list));
			pr(": ");
		}
		sprintf(buf, "%d: ", Line_no);
		pr(buf);
	}
	pr(msg);
	if (expr != NOEXPR) {
		pr(": ");
		Error_flag = 0;
		print_error_form(expr);
		Error_flag = 1;
	}
	nl();
	print_calltrace();
	Outstream = os;
	if (Quiet_mode)
		bye(1);
	return UNDEFINED;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
cmpl $0x0, 0x1b1b3(%rip)     # 0x1e5b4
jne 0x3516
movq %rsi, %rbx
movq %rdi, %r14
movl 0x1ae6c(%rip), %r12d    # 0x1e280
cmpl $0x1, 0x1b19d(%rip)     # 0x1e5b8
movl $0x2, %eax
sbbl $0x0, %eax
movl %eax, 0x1ae57(%rip)     # 0x1e280
movl $0x1, 0x1b181(%rip)     # 0x1e5b4
leaq 0x12dac(%rip), %rdi     # 0x161e6
callq 0x3964
movq 0x1b17a(%rip), %rax     # 0x1e5c0
movq 0x1b17b(%rip), %rcx     # 0x1e5c8
cmpq $-0x2, (%rax,%rcx,8)
jne 0x34a5
movq 0x1aced(%rip), %rax     # 0x1e148
cmpq $-0x1, %rax
je 0x347f
movq 0x1ad08(%rip), %rcx     # 0x1e170
movq (%rcx,%rax,8), %rdi
xorl %esi, %esi
callq 0x9124
leaq 0x131c0(%rip), %rdi     # 0x1663a
callq 0x3964
movl 0x1b14b(%rip), %edx     # 0x1e5d0
leaq 0x12d62(%rip), %rsi     # 0x161ee
leaq -0x90(%rbp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x31f0
movq %r15, %rdi
callq 0x3964
movq %r14, %rdi
callq 0x3964
cmpq $-0x8, %rbx
je 0x34f5
leaq 0x13180(%rip), %rdi     # 0x1663a
callq 0x3964
xorl %r14d, %r14d
movl %r14d, 0x1b0eb(%rip)    # 0x1e5b4
movl $0x32, 0x1adb1(%rip)    # 0x1e284
movl %r14d, 0x1adae(%rip)    # 0x1e288
movq %rbx, %rdi
xorl %esi, %esi
callq 0x9124
movl %r14d, 0x1ad99(%rip)    # 0x1e284
movl $0x1, 0x1b0bf(%rip)     # 0x1e5b4
leaq 0x143db(%rip), %rdi     # 0x178d7
callq 0x3964
callq 0x39eb
movl %r12d, 0x1ad73(%rip)    # 0x1e280
cmpl $0x0, 0x1b0a4(%rip)     # 0x1e5b8
jne 0x352a
movq $-0x5, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: node3
cell node3(cell pcar, cell pcdr, int ptag) {
	cell	n;
	int	k;
	char	buf[100];

	if (Run_stats) {
		count(&Nodes);
		if (Cons_stats)
			count(&Conses);
	}
	if (Free_list == NIL) {
		if (ptag == 0)
			Tmp_car = pcar;
		if (ptag != VECTOR_TAG && ptag != STREAM_TAG)
			Tmp_cdr = pcdr;
		k = gc();
		/*
		 * Performance increases dramatically if we
		 * do not wait for the pool to run dry.
		 * In fact, don't even let it come close to that.
		 */
		if (k < Cons_pool_size / 2) {
			if (	Memory_limit_kn &&
				Cons_pool_size + Cons_segment_size
					> Memory_limit_kn
			) {
				error("hit memory limit", NOEXPR);
			}
			else {
				new_cons_segment();
				if (Verbose_GC) {
					sprintf(buf,
						"GC: new segment,"
						 " nodes = %d,"
						 " next segment = %d",
						Cons_pool_size,
						Cons_segment_size);
					pr(buf); nl();
				}
				gc();
			}
		}
		Tmp_car = Tmp_cdr = NIL;
	}
	if (Free_list == NIL)
		fatal("cons3: failed to recover from low memory condition");
	n = Free_list;
	Free_list = cdr(Free_list);
	car(n) = pcar;
	cdr(n) = pcdr;
	Tag[n] = ptag;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, 0x1af1a(%rip)     # 0x1e620
je 0x3729
leaq 0x1af31(%rip), %rdi     # 0x1e640
callq 0x334f
cmpl $0x0, 0x1af39(%rip)     # 0x1e654
je 0x3729
leaq 0x1af34(%rip), %rdi     # 0x1e658
callq 0x334f
movq 0x1af08(%rip), %rax     # 0x1e638
cmpq $-0x1, %rax
jne 0x380b
cmpl $0x20, %ebx
je 0x3756
cmpl $0x10, %ebx
je 0x3756
testl %ebx, %ebx
jne 0x374f
movq %r15, 0x1a9c9(%rip)     # 0x1e118
movq %r14, 0x1a9ca(%rip)     # 0x1e120
callq 0x3ed9
movslq 0x1ae72(%rip), %rcx     # 0x1e5d4
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
cmpl %edx, %eax
jge 0x37ea
movq 0x1aefa(%rip), %rax     # 0x1e670
testq %rax, %rax
je 0x379f
movslq 0x1ae56(%rip), %rdx     # 0x1e5d8
addq %rcx, %rdx
cmpq %rdx, %rax
jge 0x379f
leaq 0x12aa9(%rip), %rdi     # 0x1623a
movq $-0x8, %rsi
callq 0x33eb
jmp 0x37ea
callq 0x3b01
cmpl $0x0, 0x1a945(%rip)     # 0x1e0f0
je 0x37e5
movl 0x1ae21(%rip), %edx     # 0x1e5d4
movl 0x1ae1f(%rip), %ecx     # 0x1e5d8
leaq 0x12a8b(%rip), %rsi     # 0x1624b
leaq -0x90(%rbp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x31f0
movq %r12, %rdi
callq 0x3964
leaq 0x140f7(%rip), %rdi     # 0x178d7
callq 0x3964
callq 0x3ed9
movq $-0x1, %rcx
movq %rcx, 0x1a928(%rip)     # 0x1e120
movq %rcx, 0x1a919(%rip)     # 0x1e118
movq 0x1ae32(%rip), %rax     # 0x1e638
cmpq %rcx, %rax
je 0x3843
movq 0x1adae(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rax,8), %rdx
movq %rdx, 0x1ae1b(%rip)     # 0x1e638
movq 0x1a94c(%rip), %rdx     # 0x1e170
movq %r15, (%rdx,%rax,8)
movq %r14, (%rcx,%rax,8)
movq 0x1adad(%rip), %rcx     # 0x1e5e0
movb %bl, (%rcx,%rax)
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12a30(%rip), %rdi     # 0x1627a
callq 0x3ab4
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: unsave
cell unsave(int k) {
	cell	n = NIL; /*LINT*/

	while (k) {
		if (Stack == NIL)
			fatal("unsave: stack underflow");
		n = car(Stack);
		Stack = cdr(Stack);
		k--;
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %edi, %edi
je 0x3887
movq 0x1a8ca(%rip), %rcx     # 0x1e128
movq 0x1a90b(%rip), %rdx     # 0x1e170
movq 0x1ad54(%rip), %rsi     # 0x1e5c0
cmpq $-0x1, %rcx
je 0x3890
movq (%rdx,%rcx,8), %rax
movq (%rsi,%rcx,8), %rcx
movq %rcx, 0x1a8a7(%rip)     # 0x1e128
decl %edi
jne 0x386c
jmp 0x388e
movq $-0x1, %rax
popq %rbp
retq
leaq 0x12a8c(%rip), %rdi     # 0x16323
callq 0x3ab4
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: pr_raw
void pr_raw(char *s, int k) {
	if (Printer_limit && Printer_count > Printer_limit) {
		if (Printer_limit > 0)
			fwrite("...", 1, 3, Streams[Outstream]);
		Printer_limit = -1;
		return;
	}
	fwrite(s, 1, k, Streams[Outstream]);
	if (Outstream == 1 && s[k-1] == '\n')
		flush();
	Printer_count += k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x1a9b7(%rip), %eax     # 0x1e284
testl %eax, %eax
je 0x3911
cmpl %eax, 0x1a9b1(%rip)     # 0x1e288
jle 0x3911
testl %eax, %eax
jle 0x3905
movslq 0x1a99c(%rip), %rax     # 0x1e280
leaq 0x1a895(%rip), %rcx     # 0x1e180
movq (%rcx,%rax,8), %rcx
leaq 0x128ca(%rip), %rdi     # 0x161c0
movl $0x1, %esi
movl $0x3, %edx
callq 0x3210
movl $0xffffffff, 0x1a975(%rip) # imm = 0xFFFFFFFF
jmp 0x3959
movslq %ebx, %r15
movslq 0x1a965(%rip), %rax     # 0x1e280
leaq 0x1a85e(%rip), %rcx     # 0x1e180
movq (%rcx,%rax,8), %rcx
movl $0x1, %esi
movq %r14, %rdi
movq %r15, %rdx
callq 0x3210
cmpl $0x1, 0x1a943(%rip)     # 0x1e280
jne 0x3953
cmpb $0xa, -0x1(%r14,%r15)
jne 0x3953
movq 0x1a83a(%rip), %rdi     # 0x1e188
callq 0x3160
addl %ebx, 0x1a92f(%rip)     # 0x1e288
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: print_error_form
void print_error_form(cell n) {
	Printer_limit = 50;
	Printer_count = 0;
	print_form(n);
	Printer_limit = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl $0x32, 0x1a8c1(%rip)    # 0x1e284
xorl %ebx, %ebx
movl %ebx, 0x1a8bd(%rip)     # 0x1e288
xorl %esi, %esi
callq 0x9124
movl %ebx, 0x1a8ac(%rip)     # 0x1e284
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: print_calltrace
void print_calltrace(void) {
	int	i, j;

	for (i=0; i<Proc_max; i++)
		if (Called_procedures[i] != NIL)
			break;
	if (i == Proc_max)
		return;
	pr("call trace:");
	i = Proc_ptr;
	for (j=0; j<Proc_max; j++) {
		if (i >= Proc_max)
			i = 0;
		if (Called_procedures[i] != NIL) {
			pr(" ");
			print_form(Called_procedures[i]);
		}
		i++;
	}
	nl();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x1a88c(%rip), %rax     # 0x1e28c
testq %rax, %rax
jle 0x3a22
leaq 0x1a884(%rip), %rdx     # 0x1e290
xorl %ecx, %ecx
cmpq $-0x1, (%rdx)
jne 0x3a24
incq %rcx
addq $0x8, %rdx
cmpq %rcx, %rax
jne 0x3a0e
jmp 0x3a28
xorl %ecx, %ecx
cmpl %eax, %ecx
jne 0x3a37
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1279c(%rip), %rdi     # 0x161da
callq 0x3964
movl 0x1a843(%rip), %eax     # 0x1e28c
testl %eax, %eax
jle 0x3a9a
xorl %r14d, %r14d
movl 0x1ab59(%rip), %r15d    # 0x1e5b0
leaq 0x1a832(%rip), %r12     # 0x1e290
xorl %r13d, %r13d
cmpl %eax, %r15d
cmovgel %r14d, %r15d
movslq %r15d, %rbx
cmpq $-0x1, (%r12,%rbx,8)
je 0x3a8f
leaq 0x13d9f(%rip), %rdi     # 0x17818
callq 0x3964
movq (%r12,%rbx,8), %rdi
xorl %esi, %esi
callq 0x9124
movl 0x1a7fd(%rip), %eax     # 0x1e28c
incl %r15d
incl %r13d
cmpl %eax, %r13d
jl 0x3a61
leaq 0x13e36(%rip), %rdi     # 0x178d7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3964
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: fatal
void fatal(char *msg) {
	Outstream = Quiet_mode? 2: 1;
	pr("fatal ");
	Error_flag = 0;
	error(msg, NOEXPR);
	bye(2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, 0x1aaf4(%rip)     # 0x1e5b8
movl $0x2, %eax
sbbl $0x0, %eax
movl %eax, 0x1a7ae(%rip)     # 0x1e280
leaq 0x1271a(%rip), %rdi     # 0x161f3
callq 0x3964
movl $0x0, 0x1aacc(%rip)     # 0x1e5b4
movq %rbx, %rdi
movq $-0x8, %rsi
callq 0x33eb
movl $0x2, %edi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: new_cons_segment
void new_cons_segment(void) {
	Car = realloc(Car, sizeof(cell) * (Cons_pool_size+Cons_segment_size));
	Cdr = realloc(Cdr, sizeof(cell) * (Cons_pool_size+Cons_segment_size));
	Tag = realloc(Tag, Cons_pool_size + Cons_segment_size);
	if (Car == NULL || Cdr == NULL || Tag == NULL)
		fatal("new_cons_segment: out of physical memory");
	memset(&car(Cons_pool_size), 0, Cons_segment_size * sizeof(cell));
	memset(&cdr(Cons_pool_size), 0, Cons_segment_size * sizeof(cell));
	memset(&Tag[Cons_pool_size], 0, Cons_segment_size);
	Cons_pool_size += Cons_segment_size;
	Cons_segment_size = Cons_segment_size * 3 / 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x1a664(%rip), %rdi     # 0x1e170
movslq 0x1aac1(%rip), %rax     # 0x1e5d4
movslq 0x1aabe(%rip), %rsi     # 0x1e5d8
addq %rax, %rsi
shlq $0x3, %rsi
callq 0x3190
movq %rax, 0x1a643(%rip)     # 0x1e170
movq 0x1aa8c(%rip), %rdi     # 0x1e5c0
movslq 0x1aa99(%rip), %rax     # 0x1e5d4
movslq 0x1aa96(%rip), %rsi     # 0x1e5d8
addq %rax, %rsi
shlq $0x3, %rsi
callq 0x3190
movq %rax, 0x1aa6b(%rip)     # 0x1e5c0
movq 0x1aa84(%rip), %rdi     # 0x1e5e0
movslq 0x1aa71(%rip), %rax     # 0x1e5d4
movslq 0x1aa6e(%rip), %rsi     # 0x1e5d8
addq %rax, %rsi
callq 0x3190
movq %rax, 0x1aa67(%rip)     # 0x1e5e0
testq %rax, %rax
je 0x3c19
movq 0x1a5e7(%rip), %rax     # 0x1e170
testq %rax, %rax
je 0x3c19
cmpq $0x0, 0x1aa26(%rip)     # 0x1e5c0
je 0x3c19
movslq 0x1aa31(%rip), %rcx     # 0x1e5d4
leaq (%rax,%rcx,8), %rdi
movslq 0x1aa2a(%rip), %rdx     # 0x1e5d8
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x30d0
movslq 0x1aa14(%rip), %rdi     # 0x1e5d4
shlq $0x3, %rdi
addq 0x1a9f5(%rip), %rdi     # 0x1e5c0
movslq 0x1aa06(%rip), %rdx     # 0x1e5d8
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x30d0
movslq 0x1a9f0(%rip), %rdi     # 0x1e5d4
addq 0x1a9f5(%rip), %rdi     # 0x1e5e0
movslq 0x1a9e6(%rip), %rdx     # 0x1e5d8
xorl %esi, %esi
callq 0x30d0
movl 0x1a9d9(%rip), %eax     # 0x1e5d8
addl %eax, 0x1a9cf(%rip)     # 0x1e5d4
leal (%rax,%rax,2), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movl %ecx, 0x1a9c1(%rip)     # 0x1e5d8
popq %rbp
retq
leaq 0x125da(%rip), %rdi     # 0x161fa
callq 0x3ab4
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: new_vec_segment
void new_vec_segment(void) {
	Vectors = realloc(Vectors, sizeof(cell) *
			(Vec_pool_size + Vec_segment_size));
	if (Vectors == NULL)
		fatal("out of physical memory");
	memset(&Vectors[Vec_pool_size], 0, Vec_segment_size * sizeof(cell));
	Vec_pool_size += Vec_segment_size;
	Vec_segment_size = Vec_segment_size * 3 / 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x1a9b5(%rip), %rdi     # 0x1e5e8
movslq 0x1a9b6(%rip), %rax     # 0x1e5f0
movslq 0x1a9b3(%rip), %rsi     # 0x1e5f4
addq %rax, %rsi
shlq $0x3, %rsi
callq 0x3190
movq %rax, 0x1a994(%rip)     # 0x1e5e8
testq %rax, %rax
je 0x3c9b
movslq 0x1a990(%rip), %rbx     # 0x1e5f0
leaq (%rax,%rbx,8), %rdi
movslq 0x1a989(%rip), %r14     # 0x1e5f4
movq %r14, %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x30d0
leal (%rbx,%r14), %eax
movl %eax, 0x1a96d(%rip)     # 0x1e5f0
leal (%r14,%r14,2), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movl %ecx, 0x1a95e(%rip)     # 0x1e5f4
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x13787(%rip), %rdi     # 0x17429
callq 0x3ab4
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: gc
int gc(void) {
	int	i, k;
	char	buf[100];

	if (Run_stats)
		count(&Collections);
	for (i=0; i<MAX_STREAMS; i++)
		if (Stream_flags[i] & LOCK_TAG)
			Stream_flags[i] |= USED_TAG;
		else
			Stream_flags[i] &= ~USED_TAG;
	for (i=0; GC_root[i] != NULL; i++)
		mark(GC_root[i][0]);
	k = 0;
	Free_list = NIL;
	for (i=0; i<Cons_pool_size; i++) {
		if (!(Tag[i] & MARK_TAG)) {
			cdr(i) = Free_list;
			Free_list = i;
			k++;
		}
		else {
			Tag[i] &= ~MARK_TAG;
		}
	}
	for (i=0; i<MAX_STREAMS; i++) {
		if (!(Stream_flags[i] & USED_TAG) && Streams[i] != NULL) {
			fclose(Streams[i]);
			Streams[i] = NULL;
		}
	}
	if (Verbose_GC > 1) {
		sprintf(buf, "GC: %d nodes reclaimed", k);
		pr(buf); nl();
	}
	return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
cmpl $0x0, 0x1a731(%rip)     # 0x1e620
je 0x3efd
leaq 0x1a72c(%rip), %rdi     # 0x1e624
callq 0x334f
xorl %eax, %eax
leaq 0x1a6fa(%rip), %r14     # 0x1e600
movb (%rax,%r14), %cl
movl %ecx, %edx
andb $0x3f, %dl
movl %ecx, %esi
orb $0x40, %sil
testb %cl, %cl
movzbl %sil, %ecx
movzbl %dl, %edx
cmovsl %ecx, %edx
movb %dl, (%rax,%r14)
incq %rax
cmpq $0x20, %rax
jne 0x3f06
movq 0x1935b(%rip), %rax     # 0x1d290
testq %rax, %rax
je 0x3f55
leaq 0x19357(%rip), %rbx     # 0x1d298
movq (%rax), %rdi
callq 0x3ca7
movq (%rbx), %rax
addq $0x8, %rbx
testq %rax, %rax
jne 0x3f41
movq $-0x1, 0x1a6d8(%rip) # 0x1e638
movl 0x1a66e(%rip), %ecx     # 0x1e5d4
testl %ecx, %ecx
jle 0x3fbe
xorl %eax, %eax
movq 0x1a66d(%rip), %rdx     # 0x1e5e0
xorl %ebx, %ebx
movb (%rdx,%rax), %sil
testb $0x2, %sil
jne 0x3f9c
movq 0x1a6b2(%rip), %rsi     # 0x1e638
movq 0x1a633(%rip), %rdi     # 0x1e5c0
movq %rsi, (%rdi,%rax,8)
movq %rax, 0x1a6a0(%rip)     # 0x1e638
incl %ebx
jmp 0x3fb1
andb $-0x3, %sil
movb %sil, (%rdx,%rax)
movq 0x1a635(%rip), %rdx     # 0x1e5e0
movl 0x1a623(%rip), %ecx     # 0x1e5d4
incq %rax
movslq %ecx, %rsi
cmpq %rsi, %rax
jl 0x3f75
jmp 0x3fc0
xorl %ebx, %ebx
leaq 0x1a1b9(%rip), %r15     # 0x1e180
xorl %r12d, %r12d
testb $0x40, (%r12,%r14)
jne 0x3fe5
movq (%r15), %rdi
testq %rdi, %rdi
je 0x3fe5
callq 0x3090
movq $0x0, (%r15)
incq %r12
addq $0x8, %r15
cmpq $0x20, %r12
jne 0x3fca
cmpl $0x2, 0x1a0f7(%rip)     # 0x1e0f0
jl 0x4029
leaq 0x12221(%rip), %rsi     # 0x16223
leaq -0x90(%rbp), %r14
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
callq 0x3964
leaq 0x138b3(%rip), %rdi     # 0x178d7
callq 0x3964
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: unmark_vectors
void unmark_vectors(void) {
	int	p, k, link;

	p = 0;
	while (p < Free_vecs) {
		link = p;
		k = Vectors[p + RAW_VECTOR_SIZE];
		p += vector_size(k);
		Vectors[link] = NIL;
	}
}

// Assembly:
cmpq $0x0, 0x1a638(%rip)     # 0x1e678
jle 0x4078
pushq %rbp
movq %rsp, %rbp
xorl %ecx, %ecx
movq 0x1a599(%rip), %rax     # 0x1e5e8
xorl %edx, %edx
movslq 0x10(%rax,%rcx,8), %rsi
addq $0x7, %rsi
shrq $0x3, %rsi
addl %esi, %edx
addl $0x3, %edx
movq $-0x1, (%rax,%rcx,8)
movslq %edx, %rcx
cmpq %rcx, 0x1a603(%rip)     # 0x1e678
jg 0x4051
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: gcv
int gcv(void) {
	int	v, k, to, from;
	char	buf[100];

	unmark_vectors();
	gc();		/* re-mark live vectors */
	to = from = 0;
	while (from < Free_vecs) {
		v = Vectors[from + RAW_VECTOR_SIZE];
		k = vector_size(v);
		if (Vectors[from + RAW_VECTOR_LINK] != NIL) {
			if (to != from) {
				memmove(&Vectors[to], &Vectors[from],
					k * sizeof(cell));
				cdr(Vectors[to + RAW_VECTOR_LINK]) =
					to + RAW_VECTOR_DATA;
			}
			to += k;
		}
		from += k;
	}
	k = Free_vecs - to;
	if (Verbose_GC > 1) {
		sprintf(buf, "GC: gcv: %d cells reclaimed", k);
		pr(buf); nl();
	}
	Free_vecs = to;
	return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
callq 0x4038
callq 0x3ed9
movq 0x1a5df(%rip), %rbx     # 0x1e678
testq %rbx, %rbx
jle 0x4118
xorl %ecx, %ecx
movq 0x1a541(%rip), %rax     # 0x1e5e8
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq 0x10(%rax,%rcx,8), %r12
addq $0x7, %r12
shrq $0x3, %r12
addl $0x3, %r12d
cmpq $-0x1, (%rax,%rcx,8)
je 0x4108
cmpl %r14d, %r15d
je 0x4105
leaq (%rax,%rcx,8), %rsi
movslq %r15d, %rbx
leaq (%rax,%rbx,8), %rdi
movslq %r12d, %rdx
shlq $0x3, %rdx
callq 0x31a0
leal 0x3(%r15), %eax
movslq %eax, %rcx
movq 0x1a4d1(%rip), %rdx     # 0x1e5c0
movq 0x1a4f2(%rip), %rax     # 0x1e5e8
movq (%rax,%rbx,8), %rsi
movq %rcx, (%rdx,%rsi,8)
movq 0x1a573(%rip), %rbx     # 0x1e678
addl %r12d, %r15d
addl %r14d, %r12d
movslq %r12d, %rcx
movl %r12d, %r14d
cmpq %rcx, %rbx
jg 0x40ad
jmp 0x411b
xorl %r15d, %r15d
subl %r15d, %ebx
cmpl $0x2, 0x19fcb(%rip)     # 0x1e0f0
jl 0x4155
leaq 0x1217f(%rip), %rsi     # 0x162ad
leaq -0x90(%rbp), %r14
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
callq 0x3964
leaq 0x13787(%rip), %rdi     # 0x178d7
callq 0x3964
movslq %r15d, %rax
movq %rax, 0x1a519(%rip)     # 0x1e678
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: integer_value
cell integer_value(char *src, cell x) {
	char	msg[100];

	if (cddr(x) != NIL) {
		sprintf(msg, "%s: integer argument too big", src);
		error(msg, x);
		return 0;
	}
	return cadr(x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq 0x1a27d(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rsi,8), %rax
cmpq $-0x1, (%rcx,%rax,8)
je 0x4379
movq %rsi, %rbx
movq %rdi, %rdx
leaq 0x11fe0(%rip), %rsi     # 0x1633b
xorl %r14d, %r14d
leaq -0x80(%rbp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x31f0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x33eb
jmp 0x4384
movq 0x19df0(%rip), %rcx     # 0x1e170
movq (%rcx,%rax,8), %r14
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: reverse_segments
cell reverse_segments(cell n) {
	cell	m;

	m = NIL;
	while (n != NIL) {
		m = new_atom(car(n), m);
		n = cdr(n);
	}
	return m;
}

// Assembly:
cmpq $-0x1, %rdi
je 0x445e
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $-0x1, %rax
movq 0x19d3b(%rip), %rcx     # 0x1e170
movq (%rcx,%rbx,8), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq 0x1a173(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rbx,8), %rbx
cmpq $-0x1, %rbx
jne 0x442e
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq $-0x1, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: bignum_add
cell bignum_add(cell a, cell b) {
	Tmp = b;
	save(a);
	save(b);
	Tmp = NIL;
	a = x_bignum_add(a, b);
	unsave(2);
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x199ce(%rip)     # 0x1e110
movq 0x199df(%rip), %rsi     # 0x1e128
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x199d1(%rip)     # 0x1e128
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x199bd(%rip)     # 0x1e128
movq $-0x1, 0x1999a(%rip) # 0x1e110
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4466
movq %rax, %rbx
movl $0x2, %edi
callq 0x384f
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq