LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: limit
cell limit(char *msg, int(*pred)(cell,cell), cell x) {
	cell	k;

	if (pred(car(x), cadr(x)))
		k = car(x);
	else
		k = cadr(x);
	if (!real_p(car(x)) && !real_p(cadr(x)))
		return k;
	if (integer_p(k))
		return bignum_to_real(k);
	return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0xfdc1(%rip), %rcx      # 0x28180
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq 0xfdb2(%rip), %rcx      # 0x28180
movq 0x101fb(%rip), %rdx     # 0x285d0
movq -0x20(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rsi
callq *%rax
cmpl $0x0, %eax
je 0x183fd
movq 0xfd91(%rip), %rax      # 0x28180
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x1841b
movq 0xfd7c(%rip), %rax      # 0x28180
movq 0x101c5(%rip), %rcx     # 0x285d0
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq 0xfd5e(%rip), %rax      # 0x28180
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jl 0x1846c
movq 0x101bc(%rip), %rax     # 0x285f0
movq 0xfd45(%rip), %rcx      # 0x28180
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1846c
movq 0xfd2a(%rip), %rax      # 0x28180
movq 0xfd23(%rip), %rcx      # 0x28180
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $-0x1f, (%rax,%rcx,8)
je 0x184e8
movq 0xfd0d(%rip), %rax      # 0x28180
movq 0x10156(%rip), %rcx     # 0x285d0
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $0x0, (%rax,%rcx,8)
jl 0x184de
movq 0x10160(%rip), %rax     # 0x285f0
movq 0xfce9(%rip), %rcx      # 0x28180
movq 0x10132(%rip), %rdx     # 0x285d0
movq -0x20(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x184de
movq 0xfcc3(%rip), %rax      # 0x28180
movq 0xfcbc(%rip), %rcx      # 0x28180
movq 0x10105(%rip), %rdx     # 0x285d0
movq -0x20(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $-0x1f, (%rax,%rcx,8)
je 0x184e8
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1852f
cmpq $0x0, -0x28(%rbp)
jl 0x18527
movq 0x100fa(%rip), %rax     # 0x285f0
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x18527
movq 0xfc73(%rip), %rax      # 0x28180
movq -0x28(%rbp), %rcx
cmpq $-0x18, (%rax,%rcx,8)
jne 0x18527
movq -0x28(%rbp), %rdi
callq 0x6870
movq %rax, -0x8(%rbp)
jmp 0x1852f
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_real_mant
cell pp_real_mant(cell x) {
	cell	m;

	if (integer_p(car(x)))
		return car(x);
	m = new_atom(T_INTEGER, x_real_mantissa(car(x)));
	if (x_real_negative_p(car(x)))
		m = bignum_negate(m);
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0xf71d(%rip), %rax      # 0x28180
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jl 0x18ac5
movq 0xfb7b(%rip), %rax      # 0x285f0
movq 0xf704(%rip), %rcx      # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x18ac5
movq 0xf6e9(%rip), %rax      # 0x28180
movq 0xf6e2(%rip), %rcx      # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $-0x18, (%rax,%rcx,8)
jne 0x18ac5
movq 0xf6cc(%rip), %rax      # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x18bce
movq 0xfb04(%rip), %rax      # 0x285d0
movq 0xfafd(%rip), %rcx      # 0x285d0
movq 0xfaf6(%rip), %rdx      # 0x285d0
movq 0xf69f(%rip), %rsi      # 0x28180
movq -0x10(%rbp), %rdi
movq (%rsi,%rdi,8), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rsi
movq $-0x18, %rdi
movl $0x1, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movq 0xf66f(%rip), %rax      # 0x28180
movq 0xfab8(%rip), %rcx      # 0x285d0
movq 0xf661(%rip), %rdx      # 0x28180
movq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x18bc6
movq 0xf63c(%rip), %rax      # 0x28180
movq 0xfa85(%rip), %rcx      # 0x285d0
movq 0xfa7e(%rip), %rdx      # 0x285d0
movq 0xfa77(%rip), %rsi      # 0x285d0
movq 0xf620(%rip), %rdi      # 0x28180
movq -0x10(%rbp), %r8
movq (%rdi,%r8,8), %rdi
movq (%rsi,%rdi,8), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x18bb9
movq 0xfa4e(%rip), %rax      # 0x285d0
movq 0xfa47(%rip), %rcx      # 0x285d0
movq 0xfa40(%rip), %rdx      # 0x285d0
movq 0xfa39(%rip), %rsi      # 0x285d0
movq 0xf5e2(%rip), %rdi      # 0x28180
movq -0x10(%rbp), %r8
movq (%rdi,%r8,8), %rdi
movq (%rsi,%rdi,8), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $-0x1, (%rax,%rcx,8)
je 0x18bc6
movq -0x18(%rbp), %rdi
callq 0x4a70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_chr
cell pp_chr(cell x) {
	cell	n;

	n = integer_value("chr", car(x));
	if (n < 0 || n > 255)
		return error("chr: argument value out of range", car(x));
	return make_char(n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0xf3ad(%rip), %rax      # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x8122(%rip), %rdi      # 0x20f04
callq 0x4960
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x18dfc
cmpq $0xff, -0x18(%rbp)
jle 0x18e1d
movq 0xf37d(%rip), %rax      # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x80f6(%rip), %rdi      # 0x20f08
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0x18e2c
movq -0x18(%rbp), %rax
movl %eax, %edi
callq 0xa240
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: implode
cell implode(char *who, cell x) {
	cell	n;
	int	k = length(x);
	char	*s;
	char	buf[100];

	n = make_string("", k);
	s = string(n);
	while (x != NIL) {
		if (!char_p(car(x))) {
			sprintf(buf, "%s: expected list of char,"
					" got list containing",
				who);
			return error(buf, car(x));
		}
		*s++ = cadar(x);
		x = cdr(x);
	}
	*s = 0;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5160
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
leaq 0x8b2b(%rip), %rdi      # 0x219d4
callq 0xa160
movq %rax, -0x20(%rbp)
movq 0xf73f(%rip), %rax      # 0x285f8
movq 0xf710(%rip), %rcx      # 0x285d0
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0x18fb9
movq 0xf29b(%rip), %rax      # 0x28180
movq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jl 0x18f2f
movq 0xf6f9(%rip), %rax      # 0x285f0
movq 0xf282(%rip), %rcx      # 0x28180
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x18f2f
movq 0xf267(%rip), %rax      # 0x28180
movq 0xf260(%rip), %rcx      # 0x28180
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $-0x16, (%rax,%rcx,8)
je 0x18f69
leaq -0xa0(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x7fe8(%rip), %rsi      # 0x20f29
movb $0x0, %al
callq 0x3200
leaq -0xa0(%rbp), %rdi
movq 0xf22a(%rip), %rax      # 0x28180
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0x18fc8
movq 0xf210(%rip), %rax      # 0x28180
movq 0xf659(%rip), %rcx      # 0x285d0
movq 0xf202(%rip), %rdx      # 0x28180
movq -0x18(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movq 0xf628(%rip), %rax      # 0x285d0
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0x18ed3
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_explode
cell pp_explode(cell x) {
	char	*s;
	cell	n, a, new;
	int	k, i;

	k = string_len(car(x));
	n = NIL;
	a = NIL;
	for (i=0; i<k-1; i++) {
		s = string(car(x));
		if (n == NIL) {
			n = a = cons(make_char(s[i]), NIL);
			save(n);
		}
		else {
			set(cdr(a), cons(make_char(s[i]), NIL));
			a = cdr(a);
		}
	}
	if (n != NIL)
		unsave(1);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0xf5d5(%rip), %rax      # 0x285f8
movq 0xf5a6(%rip), %rcx      # 0x285d0
movq 0xf14f(%rip), %rdx      # 0x28180
movq -0x8(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x2c(%rbp)
movq $-0x1, -0x18(%rbp)
movq $-0x1, -0x20(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl -0x2c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1914a
movq 0xf581(%rip), %rax      # 0x285f8
movq 0xf552(%rip), %rcx      # 0x285d0
movq 0xf0fb(%rip), %rdx      # 0x28180
movq -0x8(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x190eb
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0xa240
movq %rax, %rdi
movq $-0x1, %rsi
movl $0x8, %edx
callq 0x3780
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq 0xf05d(%rip), %rsi      # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0xf04f(%rip)      # 0x28138
jmp 0x1913a
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0xa240
movq %rax, %rdi
movq $-0x1, %rsi
movl $0x8, %edx
callq 0x3780
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq 0xf4b1(%rip), %rax      # 0x285d0
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0xf4a2(%rip), %rax      # 0x285d0
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0x1913c
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1905f
cmpq $-0x1, -0x18(%rbp)
je 0x1915b
movl $0x1, %edi
callq 0x3950
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_newstr
cell pp_newstr(cell x) {
	cell	n;
	int	k;
	char	*s;

	k = integer_value("string", car(x));
	if (k < 0)
		return error("string: got negative length", x);
	n = make_string("", k);
	s = string(n);
	memset(s, char_value(cadr(x)), k);
	s[k] = 0;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq 0xec5d(%rip), %rax      # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x7032(%rip), %rdi      # 0x20564
callq 0x4960
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x19559
movq -0x10(%rbp), %rsi
leaq 0x7a15(%rip), %rdi      # 0x20f60
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0x195e1
movl -0x1c(%rbp), %esi
leaq 0x8471(%rip), %rdi      # 0x219d4
callq 0xa160
movq %rax, -0x18(%rbp)
movq 0xf085(%rip), %rax      # 0x285f8
movq 0xf056(%rip), %rcx      # 0x285d0
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq 0xebe8(%rip), %rax      # 0x28180
movq 0xf031(%rip), %rcx      # 0x285d0
movq 0xebda(%rip), %rdx      # 0x28180
movq 0xf023(%rip), %rsi      # 0x285d0
movq -0x10(%rbp), %r8
movq (%rsi,%r8,8), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rdx
movzbl %al, %esi
callq 0x30e0
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_newvec
cell pp_newvec(cell x) {
	int	i, k;
	cell	n, *v, m;

	k = integer_value("newvec", car(x));
	if (k < 0)
		return error("newvec: got negative length", car(x));
	n = new_vec(T_VECTOR, k * sizeof(cell));
	v = vector(n);
	m = cadr(x);
	for (i=0; i<k; i++)
		v[i] = m;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq 0xeb7d(%rip), %rax      # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x796a(%rip), %rdi      # 0x20f7c
callq 0x4960
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x19644
movq 0xeb59(%rip), %rax      # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x794d(%rip), %rdi      # 0x20f83
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0x196cf
movslq -0x18(%rbp), %rax
shlq $0x3, %rax
movl %eax, %esi
movq $-0x24, %rdi
callq 0x4790
movq %rax, -0x20(%rbp)
movq 0xef93(%rip), %rax      # 0x285f8
movq 0xef64(%rip), %rcx      # 0x285d0
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq 0xeafa(%rip), %rax      # 0x28180
movq 0xef43(%rip), %rcx      # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x196c7
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x196a4
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: close_stream
void close_stream(int stream) {
	if (stream < 0 || stream >= MAX_STREAMS)
		return;
	if (Streams[stream] == NULL) {
		Stream_flags[stream] = 0;
		return;
	}
	fclose(Streams[stream]); /* already closed? don't care */
	Streams[stream] = NULL;
	Stream_flags[stream] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x198e7
cmpl $0x20, -0x4(%rbp)
jl 0x198e9
jmp 0x19942
movslq -0x4(%rbp), %rcx
leaq 0xe89c(%rip), %rax      # 0x28190
cmpq $0x0, (%rax,%rcx,8)
jne 0x1990c
movslq -0x4(%rbp), %rcx
leaq 0xed0a(%rip), %rax      # 0x28610
movb $0x0, (%rax,%rcx)
jmp 0x19942
movslq -0x4(%rbp), %rcx
leaq 0xe879(%rip), %rax      # 0x28190
movq (%rax,%rcx,8), %rdi
callq 0x3090
movslq -0x4(%rbp), %rcx
leaq 0xe865(%rip), %rax      # 0x28190
movq $0x0, (%rax,%rcx,8)
movslq -0x4(%rbp), %rcx
leaq 0xecd2(%rip), %rax      # 0x28610
movb $0x0, (%rax,%rcx)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: make_stream
cell make_stream(int sid, cell type) {
	cell	n;
	int	pf;

	pf = Stream_flags[sid];
	Stream_flags[sid] |= LOCK_TAG;
	n = new_atom(sid, NIL);
	n = node3(type, n, ATOM_TAG|STREAM_TAG);
	Stream_flags[sid] = pf;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xec56(%rip), %rax      # 0x28610
movzbl (%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xec44(%rip), %rax      # 0x28610
movzbl (%rax,%rcx), %eax
orl $0x80, %eax
movb %al, %dl
leaq 0xec32(%rip), %rax      # 0x28610
movb %dl, (%rax,%rcx)
movslq -0x4(%rbp), %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x21, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movb %al, %dl
movslq -0x4(%rbp), %rcx
leaq 0xebf0(%rip), %rax      # 0x28610
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_print
cell pp_print(cell x) {
	Displaying = 1;
	print_form(car(x));
	Displaying = 0;
	return UNIT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, 0xec8a(%rip)      # 0x286d0
movq 0xe733(%rip), %rax      # 0x28180
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3b70
movl $0x0, 0xec6c(%rip)      # 0x286d0
movq $-0x6, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: new_stream
int new_stream(void) {
	int	i, tries;

	for (tries=0; tries<2; tries++) {
		for (i=0; i<MAX_STREAMS; i++) {
			if (Streams[i] == NULL) {
				return i;
			}
		}
		if (tries == 0)
			gc();
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jge 0x19b41
movl $0x0, -0x8(%rbp)
cmpl $0x20, -0x8(%rbp)
jge 0x19b29
movslq -0x8(%rbp), %rcx
leaq 0xe683(%rip), %rax      # 0x28190
cmpq $0x0, (%rax,%rcx,8)
jne 0x19b1c
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x19b48
jmp 0x19b1e
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x19afc
cmpl $0x0, -0xc(%rbp)
jne 0x19b34
callq 0x43d0
jmp 0x19b36
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x19aef
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: open_stream
int open_stream(char *path, char *mode) {
	int	i = new_stream();

	if (i < 0)
		return -1;
	Streams[i] = fopen(path, mode);
	if (Streams[i] == NULL)
		return -1;
	else
		return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x19ae0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x19b87
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x19bc7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x31c0
movq %rax, %rdx
movslq -0x1c(%rbp), %rcx
leaq 0xe5ee(%rip), %rax      # 0x28190
movq %rdx, (%rax,%rcx,8)
movslq -0x1c(%rbp), %rcx
leaq 0xe5df(%rip), %rax      # 0x28190
cmpq $0x0, (%rax,%rcx,8)
jne 0x19bc1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x19bc7
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: isfirst
int isfirst(int t) {
	return	Token != TOK_VAL ||
		Token != TOK_FUN ||
		Token != TOK_TYPE ||
		Token != TOK_LOCAL ||
		Token != TOK_INFIX ||
		Token != TOK_INFIXR ||
		Token != TOK_NONFIX ||
	 	Token != END_OF_FILE ||
		Token != TOK_EXCEPTION;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movb $0x1, %al
cmpl $0xffffff1e, 0xe8ad(%rip) # imm = 0xFFFFFF1E
movb %al, -0x5(%rbp)
jne 0x19ec0
movb $0x1, %al
cmpl $0xffffff2e, 0xe898(%rip) # imm = 0xFFFFFF2E
movb %al, -0x5(%rbp)
jne 0x19ec0
movb $0x1, %al
cmpl $0xffffff1f, 0xe887(%rip) # imm = 0xFFFFFF1F
movb %al, -0x5(%rbp)
jne 0x19ec0
movb $0x1, %al
cmpl $0xffffff27, 0xe876(%rip) # imm = 0xFFFFFF27
movb %al, -0x5(%rbp)
jne 0x19ec0
movb $0x1, %al
cmpl $0xffffff2a, 0xe865(%rip) # imm = 0xFFFFFF2A
movb %al, -0x5(%rbp)
jne 0x19ec0
movb $0x1, %al
cmpl $0xffffff29, 0xe854(%rip) # imm = 0xFFFFFF29
movb %al, -0x5(%rbp)
jne 0x19ec0
movb $0x1, %al
cmpl $0xffffff26, 0xe843(%rip) # imm = 0xFFFFFF26
movb %al, -0x5(%rbp)
jne 0x19ec0
movb $0x1, %al
cmpl $-0x4, 0xe835(%rip)     # 0x286e0
movb %al, -0x5(%rbp)
jne 0x19ec0
cmpl $0xffffff30, 0xe826(%rip) # imm = 0xFFFFFF30
setne %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: eval
cell eval(cell x) {
	reset_calltrace();
	save(x);
	x = expand_syntax(x);
	unsave(1);
	x = xeval(x, 0);
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1dfc0
movq -0x8(%rbp), %rdi
movq 0xe24c(%rip), %rsi      # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0xe23e(%rip)      # 0x28138
movq -0x8(%rbp), %rdi
callq 0x1d440
movq %rax, -0x8(%rbp)
movl $0x1, %edi
callq 0x3950
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x1bff0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_load
cell pp_load(cell x) {
	char	file[TOKEN_LENGTH+1];

	if (string_len(car(x)) > TOKEN_LENGTH-3)
		return error("load: path too long", car(x));
	strcpy(file, string(car(x)));
	if (load(file) < 0) {
		strcat(file, ".m");
		if (load(file) < 0)
			return error("load: cannot open file", car(x));
	}
	return UNIT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x10(%rbp)
movq 0xe6b2(%rip), %rax      # 0x285f8
movq 0xe683(%rip), %rcx      # 0x285d0
movq 0xe22c(%rip), %rdx      # 0x28180
movq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
subq $0x1, %rcx
cmpq $0x3fd, (%rax,%rcx,8)   # imm = 0x3FD
jle 0x19f92
movq 0xe20b(%rip), %rax      # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x7034(%rip), %rdi      # 0x20fb8
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0x1a026
leaq -0x420(%rbp), %rdi
movq 0xe658(%rip), %rsi      # 0x285f8
movq 0xe629(%rip), %rax      # 0x285d0
movq 0xe1d2(%rip), %rcx      # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x3060
leaq -0x420(%rbp), %rdi
callq 0x19bd0
cmpl $0x0, %eax
jge 0x1a01e
leaq -0x420(%rbp), %rdi
leaq 0x7505(%rip), %rsi      # 0x214ea
callq 0x31f0
leaq -0x420(%rbp), %rdi
callq 0x19bd0
cmpl $0x0, %eax
jge 0x1a01c
movq 0xe17e(%rip), %rax      # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x6fbb(%rip), %rdi      # 0x20fcc
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0x1a026
jmp 0x1a01e
movq $-0x6, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_instream
cell pp_instream(cell x) {
	int	p;

	p = open_stream(string(car(x)), "r");
	if (p < 0)
		return error("instream: could not open file", car(x));
	return make_stream(p, T_INSTREAM);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0xe5a5(%rip), %rdi      # 0x285f8
movq 0xe576(%rip), %rax      # 0x285d0
movq 0xe11f(%rip), %rcx      # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq %rax, %rdi
leaq 0x70a7(%rip), %rsi      # 0x21122
callq 0x19b60
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x1a0aa
movq 0xe0f0(%rip), %rax      # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x6f44(%rip), %rdi      # 0x20fe3
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0x1a0bd
movl -0x14(%rbp), %edi
movq $-0x17, %rsi
callq 0x199a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_outstream
cell pp_outstream(cell x) {
	int	p;

	p = open_stream(string(car(x)), "w");
	if (p < 0)
		return error("outstream: could not open file", car(x));
	return make_stream(p, T_OUTSTREAM);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0xe515(%rip), %rdi      # 0x285f8
movq 0xe4e6(%rip), %rax      # 0x285d0
movq 0xe08f(%rip), %rcx      # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq %rax, %rdi
leaq 0x711a(%rip), %rsi      # 0x21225
callq 0x19b60
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x1a13a
movq 0xe060(%rip), %rax      # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x6ed2(%rip), %rdi      # 0x21001
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0x1a14d
movl -0x14(%rbp), %edi
movq $-0x19, %rsi
callq 0x199a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_appendstream
cell pp_appendstream(cell x) {
	int	p;

	p = open_stream(string(car(x)), "a");
	if (p < 0)
		return error("append_stream: could not open file", car(x));
	return make_stream(p, T_OUTSTREAM);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0xe485(%rip), %rdi      # 0x285f8
movq 0xe456(%rip), %rax      # 0x285d0
movq 0xdfff(%rip), %rcx      # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq %rax, %rdi
leaq 0x7794(%rip), %rsi      # 0x2192f
callq 0x19b60
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x1a1ca
movq 0xdfd0(%rip), %rax      # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x6e61(%rip), %rdi      # 0x21020
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0x1a1dd
movl -0x14(%rbp), %edi
movq $-0x19, %rsi
callq 0x199a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_peekc
cell pp_peekc(cell x) {
	int	c;

	c = read_c();
	if (c == EOF)
		return END_OF_FILE;
	ungetc(c, Streams[Instream]);
	return make_char(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movslq 0xe4a5(%rip), %rcx      # 0x286a8
leaq 0xdf86(%rip), %rax      # 0x28190
movq (%rax,%rcx,8), %rdi
callq 0x3230
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x1a226
movq $-0x4, -0x8(%rbp)
jmp 0x1a24c
movl -0x14(%rbp), %edi
movslq 0xe478(%rip), %rcx      # 0x286a8
leaq 0xdf59(%rip), %rax      # 0x28190
movq (%rax,%rcx,8), %rsi
callq 0x3180
movl -0x14(%rbp), %edi
callq 0xa240
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_readc
cell pp_readc(cell x) {
	int	c;

	c = read_c();
	if (c == EOF)
		return END_OF_FILE;
	return make_char(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movslq 0xe435(%rip), %rcx      # 0x286a8
leaq 0xdf16(%rip), %rax      # 0x28190
movq (%rax,%rcx,8), %rdi
callq 0x3230
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x1a296
movq $-0x4, -0x8(%rbp)
jmp 0x1a2a2
movl -0x14(%rbp), %edi
callq 0xa240
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_readln
cell pp_readln(cell x) {
	static char	buf[TOKEN_LENGTH+1];
	int		k;

	if (fgets(buf, TOKEN_LENGTH, Streams[Instream]) == NULL)
		return END_OF_FILE;
	k = strlen(buf);
	if (buf[k-1] == '\n')
		buf[--k] = 0;
	return make_string(buf, k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movslq 0xe3e5(%rip), %rcx      # 0x286a8
leaq 0xdec6(%rip), %rax      # 0x28190
movq (%rax,%rcx,8), %rdx
leaq 0xe4eb(%rip), %rdi      # 0x287c0
movl $0x400, %esi            # imm = 0x400
callq 0x3110
cmpq $0x0, %rax
jne 0x1a2ef
movq $-0x4, -0x8(%rbp)
jmp 0x1a341
leaq 0xe4ca(%rip), %rdi      # 0x287c0
callq 0x30a0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0xe4b2(%rip), %rax      # 0x287c0
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x1a32e
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movslq %eax, %rcx
leaq 0xe496(%rip), %rax      # 0x287c0
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %esi
leaq 0xe488(%rip), %rdi      # 0x287c0
callq 0xa160
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: copy_string
char *copy_string(char *s) {
	char	*new;

	new = malloc(strlen(s)+1);
	if (s == NULL)
		fatal("copy_string(): out of memory");
	strcpy(new, s);
	return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30a0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x3160
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1a388
leaq 0x6cc0(%rip), %rdi      # 0x21043
callq 0x3c70
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3060
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_dump_image
cell pp_dump_image(cell x) {
	char	*path = copy_string(string(car(x)));
	FILE	*f;

	f = fopen(string(car(x)), "r");
	if (f != NULL) {
		fclose(f);
		return error("dump_image: file exists", car(x));
	}
	dump_image(path);
	free(path);
	return UNIT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0xe245(%rip), %rdi      # 0x285f8
movq 0xe216(%rip), %rax      # 0x285d0
movq 0xddbf(%rip), %rcx      # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x1a350
movq %rax, -0x18(%rbp)
movq 0xe214(%rip), %rdi      # 0x285f8
movq 0xe1e5(%rip), %rax      # 0x285d0
movq 0xdd8e(%rip), %rcx      # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq %rax, %rdi
leaq 0x6d16(%rip), %rsi      # 0x21122
callq 0x31c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1a446
movq -0x20(%rbp), %rdi
callq 0x3090
movq 0xdd54(%rip), %rax      # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x6c25(%rip), %rdi      # 0x21060
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0x1a460
movq -0x18(%rbp), %rdi
callq 0x1a470
movq -0x18(%rbp), %rdi
callq 0x3040
movq $-0x6, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_stats
cell pp_stats(cell x) {
	cell	n, m;
	int	o_run_stats;

	gcv(); /* start from a known state */
	reset_counter(&Reductions);
	reset_counter(&Conses);
	reset_counter(&Nodes);
	reset_counter(&Collections);
	o_run_stats = Run_stats;
	Run_stats = 1;
	Cons_stats = 0;
	n = eval(car(x));
	save(n);
	Run_stats = o_run_stats;
	n = counter_to_list(&Collections);
	n = node(n, NIL);
	save(n);
	car(Stack) = n;
	m = counter_to_list(&Nodes);
	n = node(m, n);
	car(Stack) = n;
	m = counter_to_list(&Conses);
	n = node(m, n);
	car(Stack) = n;
	m = counter_to_list(&Reductions);
	n = node(m, n);
	n = node(unsave(2), n);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x4640
leaq 0xe208(%rip), %rdi      # 0x28bd0
callq 0x3350
leaq 0xdc94(%rip), %rdi      # 0x28668
callq 0x3350
leaq 0xdc70(%rip), %rdi      # 0x28650
callq 0x3350
leaq 0xdc48(%rip), %rdi      # 0x28634
callq 0x3350
movl 0xdc39(%rip), %eax      # 0x28630
movl %eax, -0x1c(%rbp)
movl $0x1, 0xdc2c(%rip)      # 0x28630
movl $0x0, 0xdc56(%rip)      # 0x28664
movq 0xd76b(%rip), %rax      # 0x28180
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x19ed0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0xd707(%rip), %rsi      # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0xd6f9(%rip)      # 0x28138
movl -0x1c(%rbp), %eax
movl %eax, 0xdbe8(%rip)      # 0x28630
leaq 0xdbe5(%rip), %rdi      # 0x28634
callq 0x3600
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0xd6bf(%rip), %rsi      # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0xd6b1(%rip)      # 0x28138
movq -0x10(%rbp), %rdx
movq 0xd6ee(%rip), %rax      # 0x28180
movq 0xd69f(%rip), %rcx      # 0x28138
movq %rdx, (%rax,%rcx,8)
leaq 0xdbac(%rip), %rdi      # 0x28650
callq 0x3600
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq 0xd6b5(%rip), %rax      # 0x28180
movq 0xd666(%rip), %rcx      # 0x28138
movq %rdx, (%rax,%rcx,8)
leaq 0xdb8b(%rip), %rdi      # 0x28668
callq 0x3600
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq 0xd67c(%rip), %rax      # 0x28180
movq 0xd62d(%rip), %rcx      # 0x28138
movq %rdx, (%rax,%rcx,8)
leaq 0xe0ba(%rip), %rdi      # 0x28bd0
callq 0x3600
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movl $0x2, %edi
callq 0x3950
movq %rax, %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_argv
cell pp_argv(cell x) {
	cell	n;
	char	**cl;

	if (Command_line == NULL || *Command_line == NULL)
		return FALSE;
	n = integer_value("argv", car(x));
	cl = Command_line;
	for (; n--; cl++)
		if (*cl == NULL)
			return FALSE;
	return *cl == NULL? FALSE: make_string(*cl, strlen(*cl));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, 0xe074(%rip)      # 0x28be8
je 0x1ab83
movq 0xe06b(%rip), %rax      # 0x28be8
cmpq $0x0, (%rax)
jne 0x1ab90
movq $-0x3, -0x8(%rbp)
jmp 0x1ac38
movq 0xd5e9(%rip), %rax      # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x650d(%rip), %rdi      # 0x210b3
callq 0x4960
movq %rax, -0x18(%rbp)
movq 0xe032(%rip), %rax      # 0x28be8
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1abf3
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1abe3
movq $-0x3, -0x8(%rbp)
jmp 0x1ac38
jmp 0x1abe5
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x1abba
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1ac0a
movq $-0x3, %rax
movq %rax, -0x28(%rbp)
jmp 0x1ac30
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x30a0
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0xa160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_environ
cell pp_environ(cell x) {
	char	*s;

	s = getenv(string(car(x)));
	if (s == NULL)
		return FALSE;
	return make_string(s, strlen(s));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0xd995(%rip), %rdi      # 0x285f8
movq 0xd966(%rip), %rax      # 0x285d0
movq 0xd50f(%rip), %rcx      # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x3030
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1ac9e
movq $-0x3, -0x8(%rbp)
jmp 0x1acbe
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30a0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0xa160
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: expected
cell expected(cell who, char *what, cell got) {
	char	msg[100];
	PRIM	*p;

	p = &Primitives[cadr(who)];
	sprintf(msg, "%s: expected %s, got", p->name, what);
	return error(msg, got);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0xd99a(%rip), %rax      # 0x286d8
movq 0xd43b(%rip), %rcx      # 0x28180
movq 0xd884(%rip), %rdx      # 0x285d0
movq -0x8(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
imulq $0x28, (%rcx,%rdx,8), %rcx
addq %rcx, %rax
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rcx
leaq 0x6105(%rip), %rsi      # 0x20e81
movb $0x0, %al
callq 0x3200
leaq -0x80(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x34b0
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: expand_syntax
cell expand_syntax(cell x) {
	if (Error_flag || atom_p(x) || car(x) == S_quote)
		return x;
	save(x);
	while (!Error_flag) {
		if (!uses_transformer_p(x))
			break;
		x = expand_syntax_1(x);
		car(Stack) = x;
	}
	unsave(1);
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movl 0xb172(%rip), %eax      # 0x285c4
cmpl $0x0, %eax
jne 0x1d4a4
cmpq $0x0, -0x10(%rbp)
jl 0x1d4a4
movq 0xb18b(%rip), %rax      # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x1d4a4
movq 0xb174(%rip), %rax      # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x1d4a4
movq 0xaced(%rip), %rax      # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq 0xb216(%rip), %rax      # 0x286b8
jne 0x1d4ae
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1d522
movq -0x10(%rbp), %rdi
movq 0xac7f(%rip), %rsi      # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0xac71(%rip)      # 0x28138
movl 0xb0f7(%rip), %eax      # 0x285c4
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1d4db
jmp 0x1d510
movq -0x10(%rbp), %rdi
callq 0x1b930
cmpl $0x0, %eax
jne 0x1d4eb
jmp 0x1d510
movq -0x10(%rbp), %rdi
callq 0x1bb90
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq 0xac7d(%rip), %rax      # 0x28180
movq 0xac2e(%rip), %rcx      # 0x28138
movq %rdx, (%rax,%rcx,8)
jmp 0x1d4c7
movl $0x1, %edi
callq 0x3950
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: restore_state
cell restore_state(void) {
	cell	v;

	if (State_stack == NIL)
		fatal("restore_state: stack underflow");
	v = car(State_stack);
	State_stack = cdr(State_stack);
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $-0x1, 0xac08(%rip)     # 0x28148
jne 0x1d54e
leaq 0x3cbf(%rip), %rdi      # 0x21208
callq 0x3c70
movq 0xac2b(%rip), %rax      # 0x28180
movq 0xabec(%rip), %rcx      # 0x28148
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq 0xb065(%rip), %rax      # 0x285d0
movq 0xabd6(%rip), %rcx      # 0x28148
movq (%rax,%rcx,8), %rax
movq %rax, 0xabcb(%rip)      # 0x28148
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: next_case
cell next_case(cell app, cell cas) {
	cell	n, f;

	f = car(app);
	n = node(caddr(f), cas);
	n = node(cadr(f), n);
	n = node3(T_FUNCTION, n, ATOM_TAG);
	return node(n, cdr(app));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xa769(%rip), %rax      # 0x28180
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq 0xa756(%rip), %rax      # 0x28180
movq 0xab9f(%rip), %rcx      # 0x285d0
movq 0xab98(%rip), %rdx      # 0x285d0
movq -0x20(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movq 0xa722(%rip), %rax      # 0x28180
movq 0xab6b(%rip), %rcx      # 0x285d0
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq $-0x1e, %rdi
movl $0x1, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq 0xab2c(%rip), %rax      # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
xorl %edx, %edx
callq 0x3780
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: tail_call
int tail_call(void) {
	if (State_stack == NIL || car(State_stack) != EV_BETA)
		return 0;
	Tmp = unsave(1);
	Environment = car(Stack);
	unsave(2);
	restore_state();
	save(Tmp);
	Tmp = NIL;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $-0x1, 0xa388(%rip)     # 0x28148
je 0x1ddd7
movq 0xa3b7(%rip), %rax      # 0x28180
movq 0xa378(%rip), %rcx      # 0x28148
cmpq $0x2, (%rax,%rcx,8)
je 0x1dde0
movl $0x0, -0x4(%rbp)
jmp 0x1de47
movl $0x1, %edi
callq 0x3950
movq %rax, 0xa32f(%rip)      # 0x28120
movq 0xa388(%rip), %rax      # 0x28180
movq 0xa339(%rip), %rcx      # 0x28138
movq (%rax,%rcx,8), %rax
movq %rax, 0xa30e(%rip)      # 0x28118
movl $0x2, %edi
callq 0x3950
callq 0x1d530
movq 0xa300(%rip), %rdi      # 0x28120
movq 0xa311(%rip), %rsi      # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0xa303(%rip)      # 0x28138
movq $-0x1, 0xa2e0(%rip) # 0x28120
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: raise_exception
cell raise_exception(cell e) {
	cell	cs, n, p, fn;

	for (p = Exnstack; p != NIL; p = cdr(p)) {
		fn = cdar(p);
		for (cs = cddr(fn); cs != NIL; cs = cdr(cs)) {
			if (caar(cs) == e) {
				Exnstack = cdr(p);
				n = node(e, NIL);
				n = node(fn, n);
				n = node(n, NIL);
				n = node(caar(p), n);
				return n;
			}
		}
	}
	return error("unhandled exception", e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq 0xa315(%rip), %rax      # 0x28178
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
je 0x1df99
movq 0xa757(%rip), %rax      # 0x285d0
movq 0xa300(%rip), %rcx      # 0x28180
movq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq 0xa739(%rip), %rax      # 0x285d0
movq 0xa732(%rip), %rcx      # 0x285d0
movq -0x30(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0x1df7f
movq 0xa2c0(%rip), %rax      # 0x28180
movq 0xa2b9(%rip), %rcx      # 0x28180
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x10(%rbp), %rax
jne 0x1df65
movq 0xa6ec(%rip), %rax      # 0x285d0
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0xa285(%rip)      # 0x28178
movq -0x10(%rbp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x20(%rbp)
movq 0xa247(%rip), %rax      # 0x28180
movq 0xa240(%rip), %rcx      # 0x28180
movq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1dfad
jmp 0x1df67
movq 0xa662(%rip), %rax      # 0x285d0
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0x1deae
jmp 0x1df81
movq 0xa648(%rip), %rax      # 0x285d0
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x1de67
movq -0x10(%rbp), %rsi
leaq 0x328c(%rip), %rdi      # 0x21230
callq 0x34b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: keyboard_interrupt
void keyboard_interrupt(int sig) {
	Instream = 0;
	Outstream = 1;
	error("interrupted", NOEXPR);
	signal(SIGINT, keyboard_interrupt);
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, 0xa653(%rip)      # 0x286a8
movl $0x1, 0xa231(%rip)      # 0x28290
leaq 0x31fb(%rip), %rdi      # 0x21261
movq $-0x8, %rsi
callq 0x34b0
movl $0x2, %edi
leaq -0x3e(%rip), %rsi       # 0x1e040
callq 0x3130
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: repl
void repl(void) {
	cell	n = NIL; /*LINT*/
	cell	sane_env;

	sane_env = node(NIL, NIL);
	save(sane_env);
	if (!Quiet_mode) {
		signal(SIGINT, keyboard_interrupt);
	}
	Token = TOK_SEMI;
	while (Token != END_OF_FILE) {
		Error_flag = 0;
		Instream = 0;
		Outstream = 1;
		clear_leftover_envs();
		reset_calltrace();
		car(sane_env) = Environment;
		Exnstack = NIL;
		if (!Quiet_mode) {
			pr("> ");
			flush();
		}
		if (Token == TOK_SEMI || Token == UNDEFINED)
			Token = scan();
		Program = prog();
		if (Token != END_OF_FILE && Token != TOK_SEMI) {
			error("syntax error at", Attr);
		}
		if (!Error_flag)
			n = eval(Program);
		if (!Error_flag && n != UNDEFINED) {
			print_form(n);
			pr("\n");
			box_value(S_it) = n;
		}
		if (Error_flag) {
			Environment = car(sane_env);
			recover();
		}
	}
	unsave(1);
	pr("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $-0x1, -0x8(%rbp)
movq $-0x1, %rsi
xorl %edx, %edx
movq %rsi, %rdi
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x9fd8(%rip), %rsi      # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x9fca(%rip)      # 0x28138
cmpl $0x0, 0xa453(%rip)      # 0x285c8
jne 0x1e188
movl $0x2, %edi
leaq -0x143(%rip), %rsi      # 0x1e040
callq 0x3130
movl $0xffffff9b, 0xa54e(%rip) # imm = 0xFFFFFF9B
cmpl $-0x4, 0xa547(%rip)     # 0x286e0
je 0x1e2d3
movl $0x0, 0xa41b(%rip)      # 0x285c4
movl $0x0, 0xa4f5(%rip)      # 0x286a8
movl $0x1, 0xa0d3(%rip)      # 0x28290
callq 0x1e000
callq 0x1dfc0
movq 0x9f4a(%rip), %rdx      # 0x28118
movq 0x9fab(%rip), %rax      # 0x28180
movq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq $-0x1, 0x9f90(%rip) # 0x28178
cmpl $0x0, 0xa3d9(%rip)      # 0x285c8
jne 0x1e202
leaq 0x3093(%rip), %rdi      # 0x2128b
callq 0x3ab0
callq 0x39d0
cmpl $-0x65, 0xa4d7(%rip)    # 0x286e0
je 0x1e214
cmpl $-0x5, 0xa4ce(%rip)     # 0x286e0
jne 0x1e21f
callq 0xcc90
movl %eax, 0xa4c1(%rip)      # 0x286e0
callq 0xf860
movq %rax, 0x9edd(%rip)      # 0x28108
cmpl $-0x4, 0xa4ae(%rip)     # 0x286e0
je 0x1e250
cmpl $-0x65, 0xa4a5(%rip)    # 0x286e0
je 0x1e250
movq 0x9f24(%rip), %rsi      # 0x28168
leaq 0x2612(%rip), %rdi      # 0x2085d
callq 0x34b0
movl 0xa36e(%rip), %eax      # 0x285c4
cmpl $0x0, %eax
jne 0x1e26b
movq 0x9ea6(%rip), %rdi      # 0x28108
callq 0x19ed0
movq %rax, -0x8(%rbp)
movl 0xa353(%rip), %eax      # 0x285c4
cmpl $0x0, %eax
jne 0x1e2a8
cmpq $-0x5, -0x8(%rbp)
je 0x1e2a8
movq -0x8(%rbp), %rdi
callq 0x3b70
leaq 0x3746(%rip), %rdi      # 0x219d3
callq 0x3ab0
movq -0x8(%rbp), %rdx
movq 0xa333(%rip), %rax      # 0x285d0
movq 0xa95c(%rip), %rcx      # 0x28c00
movq %rdx, (%rax,%rcx,8)
movl 0xa316(%rip), %eax      # 0x285c4
cmpl $0x0, %eax
je 0x1e2ce
movq 0x9ec6(%rip), %rax      # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x9e4f(%rip)      # 0x28118
callq 0x1e0d0
jmp 0x1e192
movl $0x1, %edi
callq 0x3950
leaq 0x36ef(%rip), %rdi      # 0x219d3
callq 0x3ab0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: xfread
int xfread(cell name, void *buf, int siz, int n, FILE *f) {
	if (fread(buf, siz, n, f) != n) {
		error("image file read error", name);
		return -1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
movslq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x3080
movslq -0x20(%rbp), %rcx
cmpq %rcx, %rax
je 0x1e341
movq -0x10(%rbp), %rsi
leaq 0x2fbc(%rip), %rdi      # 0x212ef
callq 0x34b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1e348
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: get_library_path
cell get_library_path(void) {
	char	*s;

	s = getenv("MLITE_LIBRARY_PATH");
	if (s == NULL)
		s = DEFAULT_LIBRARY_PATH;
	return make_string(s, (int) strlen(s));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x2d00(%rip), %rdi      # 0x2146f
callq 0x3030
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1e78a
leaq 0x2cfc(%rip), %rax      # 0x21482
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30a0
movq -0x10(%rbp), %rdi
movl %eax, %esi
callq 0xa160
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: libname
char *libname(char *argv0) {
	char	*name;

	if (argv0 == NULL || argv0[0] == 0)
		argv0 = "mlite";
	name = strrchr(argv0, '/');
	name = name? &name[1]: argv0;
	return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1e7cf
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1e7da
leaq 0x2cd7(%rip), %rax      # 0x214ad
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x30d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1e801
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1e809
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)