LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: assqv
int assqv(char *who, int v, cell x, cell a) {
	cell	p;
	char	buf[64];

	for (p = a; p != NIL; p = cdr(p)) {
		if (!list_p(car(p))) {
			sprintf(buf, "%s: bad element in alist", who);
			return error(buf, p);
		}
		if (!v && x == caar(p))
			return car(p);
		if (v && eqv_p(x, caar(p)))
			return car(p);
	}
	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %r15
pushq $-0x3
popq %r14
cmpq $-0x1, %rbx
je 0xf353
movq 0xcea2(%rip), %rcx      # 0x1c170
movq (%rcx,%rbx,8), %rax
testq %rax, %rax
js 0xf2eb
movq 0xd302(%rip), %rdx      # 0x1c5e0
movb (%rdx,%rax), %dl
andb $0x19, %dl
cmpb $0x8, %dl
je 0xf2f1
jmp 0xf31a
cmpq $-0x1, %rax
jne 0xf31a
movq (%rcx,%rax,8), %rsi
testl %r13d, %r13d
je 0xf308
movq %r12, %rdi
callq 0xf1b2
testl %eax, %eax
je 0xf30d
jmp 0xf343
cmpq %r12, %rsi
je 0xf350
movq 0xd2ac(%rip), %rax      # 0x1c5c0
movq (%rax,%rbx,8), %rbx
jmp 0xf2bd
leaq 0x5ad1(%rip), %rsi      # 0x14df2
leaq -0x70(%rbp), %r14
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33e4
pushq $-0x5
popq %r14
jmp 0xf353
movq 0xce26(%rip), %rax      # 0x1c170
movl (%rax,%rbx,8), %r14d
jmp 0xf353
movl %eax, %r14d
movl %r14d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rax
movq 0xcd8a(%rip), %rcx      # 0x1c170
movq (%rcx,%rdx,8), %rdi
movq 0xd1cf(%rip), %rdx      # 0x1c5c0
movq (%rdx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rsi
callq *%rax
movq 0xcd6e(%rip), %rcx      # 0x1c170
movq %rbx, %rdx
testl %eax, %eax
jne 0xf414
movq 0xd1b0(%rip), %rax      # 0x1c5c0
movq (%rax,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rax
movq (%rcx,%rbx,8), %rsi
testq %rsi, %rsi
js 0xf435
movq 0xd1b8(%rip), %rdx      # 0x1c5e0
testb $0x1, (%rdx,%rsi)
je 0xf435
cmpq $-0x1f, (%rcx,%rsi,8)
je 0xf45d
movq 0xd184(%rip), %rdx      # 0x1c5c0
movq (%rdx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rsi
testq %rsi, %rsi
js 0xf47d
movq 0xd190(%rip), %rdx      # 0x1c5e0
testb $0x1, (%rdx,%rsi)
je 0xf47d
cmpq $-0x1f, (%rcx,%rsi,8)
jne 0xf47d
testq %rax, %rax
js 0xf47d
testb $0x1, (%rdx,%rax)
je 0xf47d
cmpq $-0x18, (%rcx,%rax,8)
jne 0xf47d
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5580
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: pp_floor
cell pp_floor(cell x) {
	cell	n, m, e;

	x = car(x);
	if (integer_p(x))
		return x;
	e = x_real_exponent(x);
	if (e >= 0)
		return real_to_bignum(x);
	m = new_atom(T_INTEGER, x_real_mantissa(x));
	save(m);
	while (e < 0) {
		m = bignum_shift_right(m);
		m = car(m);
		car(Stack) = m;
		e++;
	}
	if (x_real_negative_p(x)) {
		/* sign not in mantissa! */
		m = bignum_add(m, make_integer(1));
	}
	unsave(1);
	n = make_real(x_real_flags(x), e, cdr(m));
	return real_to_bignum(n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xccdb(%rip), %rax      # 0x1c170
movq (%rax,%rdi,8), %rbx
testq %rbx, %rbx
js 0xf4c0
movq 0xd13b(%rip), %rcx      # 0x1c5e0
testb $0x1, (%rcx,%rbx)
je 0xf4c0
cmpq $-0x18, (%rax,%rbx,8)
jne 0xf4c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xd0f9(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rdx
movq (%rax,%rdx,8), %r15
testq %r15, %r15
jns 0xf59d
movq (%rcx,%rdx,8), %rsi
pushq $-0x18
popq %rdi
pushq $0x1
popq %rdx
callq 0x3613
movq %rax, %r14
movq 0xcc33(%rip), %rsi      # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0xcc22(%rip)      # 0x1c128
testq %r15, %r15
je 0xf52e
movq %r14, %rdi
callq 0x4a81
movq 0xcc56(%rip), %rcx      # 0x1c170
movq (%rcx,%rax,8), %r14
movq 0xcc03(%rip), %rax      # 0x1c128
movq %r14, (%rcx,%rax,8)
incq %r15
jmp 0xf506
movq 0xcc3b(%rip), %rcx      # 0x1c170
movq 0xd084(%rip), %rax      # 0x1c5c0
movq (%rax,%rbx,8), %rdx
testb $0x1, (%rcx,%rdx,8)
je 0xf572
movq (%rax,%rdx,8), %rdx
movq (%rax,%rdx,8), %rdx
cmpq $0x0, (%rcx,%rdx,8)
jne 0xf55c
cmpq $-0x1, (%rax,%rdx,8)
je 0xf572
pushq $0x1
popq %rdi
callq 0x35ed
movq %r14, %rdi
movq %rax, %rsi
callq 0x44fe
movq %rax, %r14
pushq $0x1
popq %rdi
callq 0x3775
movq 0xcbef(%rip), %rax      # 0x1c170
movq 0xd038(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rbx,8), %rdx
movl (%rax,%rdx,8), %edi
movq (%rcx,%r14,8), %rdx
xorl %esi, %esi
callq 0x529a
movq %rax, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x687a
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xca4f(%rip), %rcx      # 0x1c170
movq (%rcx,%rdi,8), %rax
testq %rax, %rax
js 0xf73e
movq 0xceaf(%rip), %rdx      # 0x1c5e0
testb $0x1, (%rdx,%rax)
je 0xf73e
cmpq $-0x18, (%rcx,%rax,8)
je 0xf778
movq 0xce7b(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rax,8), %rax
movq (%rcx,%rax,8), %rax
movq (%rcx,%rax,8), %rsi
pushq $-0x18
popq %rdi
pushq $0x1
popq %rdx
callq 0x3613
movq 0xca0d(%rip), %rdx      # 0x1c170
movq 0xce56(%rip), %rcx      # 0x1c5c0
movq (%rdx,%rbx,8), %rsi
movq (%rcx,%rsi,8), %rsi
testb $0x1, (%rdx,%rsi,8)
jne 0xf77f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rcx,%rsi,8), %rsi
movq (%rcx,%rsi,8), %rsi
cmpq $0x0, (%rdx,%rsi,8)
jne 0xf795
cmpq $-0x1, (%rcx,%rsi,8)
je 0xf778
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x426f
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc8f2(%rip), %rax      # 0x1c170
movq (%rax,%rdi,8), %rsi
leaq 0x5582(%rip), %rdi      # 0x14e0b
callq 0x41c5
cmpq $0x100, %rax            # imm = 0x100
jb 0xf8b7
movq 0xc8d3(%rip), %rax      # 0x1c170
movq (%rax,%rbx,8), %rsi
leaq 0x5567(%rip), %rdi      # 0x14e0f
callq 0x33e4
pushq $-0x5
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %eax, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7314
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x46c4
leaq 0x5fd1(%rip), %rdi      # 0x158d8
movl %eax, %esi
callq 0x729e
movq 0xccab(%rip), %rdx      # 0x1c5c0
movq (%rdx,%rax,8), %rcx
shlq $0x3, %rcx
addq 0xccc4(%rip), %rcx      # 0x1c5e8
cmpq $-0x1, %rbx
je 0xf998
movq 0xc83f(%rip), %rsi      # 0x1c170
movq (%rsi,%rbx,8), %rdi
testq %rdi, %rdi
js 0xf968
movq 0xcc9f(%rip), %r8       # 0x1c5e0
testb $0x1, (%r8,%rdi)
je 0xf968
cmpq $-0x16, (%rsi,%rdi,8)
jne 0xf968
movq (%rdx,%rdi,8), %rdx
movb (%rsi,%rdx,8), %dl
movb %dl, (%rcx)
incq %rcx
movq 0xcc5e(%rip), %rdx      # 0x1c5c0
movq (%rdx,%rbx,8), %rbx
jmp 0xf924
leaq 0x54c1(%rip), %rsi      # 0x14e30
leaq -0x80(%rbp), %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x31f0
movq 0xc7e9(%rip), %rax      # 0x1c170
movq (%rax,%rbx,8), %rsi
movq %r15, %rdi
callq 0x33e4
pushq $-0x5
popq %rax
jmp 0xf99b
movb $0x0, (%rcx)
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xcc11(%rip), %rax      # 0x1c5e8
movq 0xcbe2(%rip), %rcx      # 0x1c5c0
movq 0xc78b(%rip), %rdx      # 0x1c170
movq %rdi, -0x30(%rbp)
movq (%rdx,%rdi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movl -0x8(%rax,%rcx,8), %eax
cmpl $0x2, %eax
pushq $0x1
popq %r15
cmovgel %eax, %r15d
decl %r15d
pushq $-0x1
popq %r12
xorl %r14d, %r14d
movq %r12, %rbx
cmpq %r14, %r15
je 0xfa88
movq 0xcba7(%rip), %rax      # 0x1c5c0
movq 0xc750(%rip), %rcx      # 0x1c170
movq -0x30(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq 0xcbb1(%rip), %rax      # 0x1c5e8
movsbl (%r14,%rax), %edi
callq 0x7314
movq %rax, %rdi
pushq $-0x1
popq %rsi
pushq $0x8
popq %rdx
callq 0x3613
movq %rax, %r13
cmpq $-0x1, %r12
je 0xfa65
movq 0xcb61(%rip), %rax      # 0x1c5c0
movq %r13, (%rax,%rbx,8)
jmp 0xfa80
movq 0xc6bc(%rip), %rsi      # 0x1c128
movq %r13, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0xc6ab(%rip)      # 0x1c128
movq %r13, %r12
incq %r14
movq %r13, %rbx
jmp 0xfa0d
cmpq $-0x1, %r12
je 0xfa96
pushq $0x1
popq %rdi
callq 0x3775
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0xc498(%rip), %rax      # 0x1c170
movq (%rax,%rdi,8), %rsi
leaq 0x47b9(%rip), %rdi      # 0x1449c
callq 0x41c5
movq %rax, %rbx
testl %ebx, %ebx
js 0xfd44
leaq 0x5be2(%rip), %rdi      # 0x158d8
movl %ebx, %esi
callq 0x729e
movq %rax, %r15
movq 0xc8b9(%rip), %rax      # 0x1c5c0
movq (%rax,%r15,8), %r12
shlq $0x3, %r12
addq 0xc8d2(%rip), %r12      # 0x1c5e8
movq 0xc453(%rip), %rcx      # 0x1c170
movq (%rax,%r14,8), %rdx
movq (%rcx,%rdx,8), %rdx
movq (%rax,%rdx,8), %rax
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
movl (%rcx,%rax,8), %esi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x30d0
movb $0x0, (%rbx,%r12)
jmp 0xfd57
leaq 0x511c(%rip), %rdi      # 0x14e67
movq %r14, %rsi
callq 0x33e4
pushq $-0x5
popq %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0xc3fc(%rip), %rax      # 0x1c170
movq (%rax,%rdi,8), %rsi
leaq 0x5104(%rip), %rdi      # 0x14e83
callq 0x41c5
movq %rax, %rbx
testl %ebx, %ebx
js 0xfdd5
leal (,%rbx,8), %esi
pushq $-0x24
popq %rdi
callq 0x4037
movq 0xc81f(%rip), %rdx      # 0x1c5c0
movq (%rdx,%rax,8), %rcx
shlq $0x3, %rcx
addq 0xc838(%rip), %rcx      # 0x1c5e8
movq 0xc3b9(%rip), %rsi      # 0x1c170
movq (%rdx,%r14,8), %rdx
movq (%rsi,%rdx,8), %rdx
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
xorl %esi, %esi
cmpq %rsi, %rbx
je 0xfdef
movq %rdx, (%rcx,%rsi,8)
incq %rsi
jmp 0xfdc7
movq 0xc394(%rip), %rax      # 0x1c170
movq (%rax,%r14,8), %rsi
leaq 0x50a3(%rip), %rdi      # 0x14e8a
callq 0x33e4
pushq $-0x5
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: pp_setvec
cell pp_setvec(cell x) {
	cell	fill = cadddr(x);
	int	i, k = vector_len(car(x));
	int	p0 = integer_value("setvec", cadr(x));
	int	pn = integer_value("setvec", caddr(x));
	cell	*v = vector(car(x));
	cell	n;

	if (p0 < 0 || p0 > k || pn < p0 || pn > k) {
		n = node(caddr(x), NIL);
		n = node(cadr(x), n);
		return error("setvec: bad range", n);
	}
	for (i=p0; i<pn; i++)
		v[i] = fill;
	return car(x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc364(%rip), %rax      # 0x1c170
movq 0xc7ad(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rdi,8), %rdx
movq (%rcx,%rdx,8), %rsi
movq (%rcx,%rsi,8), %rsi
movq (%rax,%rsi,8), %r12
movq 0xc7be(%rip), %rsi      # 0x1c5e8
movq (%rax,%rdi,8), %rdi
movq (%rcx,%rdi,8), %rcx
movq -0x8(%rsi,%rcx,8), %r13
movq (%rax,%rdx,8), %rsi
leaq 0x5064(%rip), %r15      # 0x14ea6
movq %r15, %rdi
callq 0x41c5
movq %rax, %r14
movq 0xc31c(%rip), %rax      # 0x1c170
movq 0xc765(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rsi
movq %r15, %rdi
callq 0x41c5
movq 0xc74a(%rip), %rdx      # 0x1c5c0
movq 0xc2f3(%rip), %rcx      # 0x1c170
testl %r14d, %r14d
js 0xfec1
addq $0x7, %r13
shrq $0x3, %r13
cmpl %r13d, %r14d
jg 0xfec1
cmpl %r14d, %eax
jl 0xfec1
cmpl %r13d, %eax
jg 0xfec1
movq (%rcx,%rbx,8), %rsi
movq (%rdx,%rsi,8), %rdx
shlq $0x3, %rdx
addq 0xc73c(%rip), %rdx      # 0x1c5e8
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
cmpl %eax, %r14d
jge 0xff0b
movq %r12, (%rdx,%r14,8)
incq %r14
jmp 0xfeb3
movq (%rdx,%rbx,8), %rax
movq (%rdx,%rax,8), %rax
movq (%rcx,%rax,8), %rdi
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x3613
movq 0xc292(%rip), %rcx      # 0x1c170
movq 0xc6db(%rip), %rdx      # 0x1c5c0
movq (%rdx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
leaq 0x4faf(%rip), %rdi      # 0x14ead
movq %rax, %rsi
callq 0x33e4
pushq $-0x5
popq %rax
jmp 0xff0f
movq (%rcx,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x1f, %edi
ja 0xff55
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0xc24d(%rip), %r14      # 0x1c180
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0xff46
callq 0x3090
andq $0x0, (%r14,%rbx,8)
leaq 0xc6b3(%rip), %rax      # 0x1c600
movb $0x0, (%rbx,%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movslq %edi, %r14
leaq 0xc66b(%rip), %r15      # 0x1c600
movb (%r14,%r15), %r12b
movl %r12d, %eax
orb $-0x80, %al
movb %al, (%r14,%r15)
pushq $-0x1
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x3613
pushq $0x21
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3613
movb %r12b, (%r14,%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl $0x1, 0xc6e7(%rip)      # 0x1c6c0
movq 0xc190(%rip), %rax      # 0x1c170
movq (%rax,%rdi,8), %rdi
callq 0x38e1
andl $0x0, 0xc6d0(%rip)      # 0x1c6c0
pushq $-0x6
popq %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %r14d, %r14d
pushq $-0x1
popq %rbx
leaq 0xc13f(%rip), %r15      # 0x1c180
cmpl $0x2, %r14d
je 0x10072
movq %r15, %rcx
xorl %eax, %eax
cmpq $0x20, %rax
je 0x10061
cmpq $0x0, (%rcx)
je 0x10070
incq %rax
addq $0x8, %rcx
jmp 0x1004c
testl %r14d, %r14d
jne 0x1006b
callq 0x3dd2
incl %r14d
jmp 0x10041
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x1002a
testl %eax, %eax
js 0x100c1
movl %eax, %ebx
movq %r15, %rdi
movq %r14, %rsi
callq 0x31c0
movq %rax, %rcx
movl %ebx, %eax
leaq 0xc0cf(%rip), %rdx      # 0x1c180
movq %rcx, (%rdx,%rax,8)
xorl %eax, %eax
cmpq $0x1, %rcx
sbbl %eax, %eax
orl %ebx, %eax
jmp 0x100c4
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x124f7
movq 0xbe9b(%rip), %rsi      # 0x1c128
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0xbe8a(%rip)      # 0x1c128
movq %rbx, %rdi
callq 0x11e5e
movq %rax, %rbx
pushq $0x1
popq %rdi
callq 0x3775
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x11305
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq 0xc310(%rip), %rax      # 0x1c5e8
movq 0xc2e1(%rip), %rcx      # 0x1c5c0
movq 0xbe8a(%rip), %rdx      # 0x1c170
movq (%rdx,%rdi,8), %rsi
movq (%rcx,%rsi,8), %rcx
cmpq $0x3fe, -0x8(%rax,%rcx,8) # imm = 0x3FE
jl 0x1030b
leaq 0x4bbf(%rip), %rdi      # 0x14ebf
callq 0x33e4
pushq $-0x5
popq %r14
jmp 0x1035e
movq %rdi, %rbx
leaq (%rax,%rcx,8), %rsi
leaq -0x420(%rbp), %r14
movq %r14, %rdi
callq 0x3060
movq %r14, %rdi
callq 0x100cf
pushq $-0x6
popq %r14
testl %eax, %eax
jns 0x1035e
leaq -0x420(%rbp), %r15
movq %r15, %rdi
callq 0x30a0
movw $0x6d2e, -0x420(%rbp,%rax) # imm = 0x6D2E
movb $0x0, -0x41e(%rbp,%rax)
movq %r15, %rdi
callq 0x100cf
testl %eax, %eax
js 0x1036f
movq %r14, %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xbdfa(%rip), %rax      # 0x1c170
movq (%rax,%rbx,8), %rsi
leaq 0x4b52(%rip), %rdi      # 0x14ed3
jmp 0x10300
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc22a(%rip), %rax      # 0x1c5c0
movq 0xbdd3(%rip), %rcx      # 0x1c170
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rdi
shlq $0x3, %rdi
addq 0xc238(%rip), %rdi      # 0x1c5e8
leaq 0x4c72(%rip), %rsi      # 0x15029
callq 0x1007f
testl %eax, %eax
js 0x103d0
pushq $-0x17
popq %rsi
movl %eax, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xff7d
movq 0xbd99(%rip), %rax      # 0x1c170
movq (%rax,%rbx,8), %rsi
leaq 0x4b08(%rip), %rdi      # 0x14eea
callq 0x33e4
pushq $-0x5
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc1bf(%rip), %rax      # 0x1c5c0
movq 0xbd68(%rip), %rcx      # 0x1c170
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rdi
shlq $0x3, %rdi
addq 0xc1cd(%rip), %rdi      # 0x1c5e8
leaq 0x4d0a(%rip), %rsi      # 0x1512c
callq 0x1007f
testl %eax, %eax
js 0x1043b
pushq $-0x19
popq %rsi
movl %eax, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xff7d
movq 0xbd2e(%rip), %rax      # 0x1c170
movq (%rax,%rbx,8), %rsi
leaq 0x4abb(%rip), %rdi      # 0x14f08
callq 0x33e4
pushq $-0x5
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc154(%rip), %rax      # 0x1c5c0
movq 0xbcfd(%rip), %rcx      # 0x1c170
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rdi
shlq $0x3, %rdi
addq 0xc162(%rip), %rdi      # 0x1c5e8
leaq 0x53a9(%rip), %rsi      # 0x15836
callq 0x1007f
testl %eax, %eax
js 0x104a6
pushq $-0x19
popq %rsi
movl %eax, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xff7d
movq 0xbcc3(%rip), %rax      # 0x1c170
movq (%rax,%rbx,8), %rsi
leaq 0x4a6f(%rip), %rdi      # 0x14f27
callq 0x33e4
pushq $-0x5
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movslq 0xc1c3(%rip), %rax      # 0x1c698
leaq 0xbca4(%rip), %r14      # 0x1c180
movq (%r14,%rax,8), %rdi
callq 0x3220
cmpl $-0x1, %eax
je 0x10509
movl %eax, %ebx
movslq 0xc1a5(%rip), %rax      # 0x1c698
movq (%r14,%rax,8), %rsi
movl %ebx, %edi
callq 0x3170
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x7314
pushq $-0x4
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movslq 0xc17c(%rip), %rax      # 0x1c698
leaq 0xbc5d(%rip), %rcx      # 0x1c180
movq (%rcx,%rax,8), %rdi
callq 0x3220
cmpl $-0x1, %eax
je 0x10539
movl %eax, %edi
popq %rbp
jmp 0x7314
pushq $-0x4
popq %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movslq 0xc14d(%rip), %rax      # 0x1c698
leaq 0xbc2e(%rip), %rcx      # 0x1c180
movq (%rcx,%rax,8), %rdx
leaq 0xc253(%rip), %rbx      # 0x1c7b0
movq %rbx, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x3100
testq %rax, %rax
je 0x105a1
movq %rbx, %rdi
callq 0x30a0
leal -0x1(%rax), %ecx
movslq %ecx, %rcx
cmpb $0xa, (%rcx,%rbx)
jne 0x1058d
cltq
movb $0x0, -0x1(%rax,%rbx)
decq %rax
leaq 0xc21c(%rip), %rdi      # 0x1c7b0
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x729e
pushq $-0x4
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x30a0
leaq 0x1(%rax), %rdi
callq 0x3150
testq %rbx, %rbx
je 0x105d8
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3060
leaq 0x496b(%rip), %rdi      # 0x14f4a
callq 0x39b6
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xbfcb(%rip), %rax      # 0x1c5c0
movq 0xbb74(%rip), %rcx      # 0x1c170
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rdi
shlq $0x3, %rdi
addq 0xbfd9(%rip), %rdi      # 0x1c5e8
callq 0x105ab
movq %rax, %r14
movq 0xbfa2(%rip), %rax      # 0x1c5c0
movq 0xbb4b(%rip), %rcx      # 0x1c170
movq (%rcx,%rbx,8), %rcx
movq (%rax,%rcx,8), %rdi
shlq $0x3, %rdi
addq 0xbfb0(%rip), %rdi      # 0x1c5e8
leaq 0x49ea(%rip), %rsi      # 0x15029
callq 0x31c0
testq %rax, %rax
je 0x1066c
movq %rax, %rdi
callq 0x3090
movq 0xbb18(%rip), %rax      # 0x1c170
movq (%rax,%rbx,8), %rsi
leaq 0x4904(%rip), %rdi      # 0x14f67
callq 0x33e4
pushq $-0x5
jmp 0x1067e
movq %r14, %rdi
callq 0x10684
movq %r14, %rdi
callq 0x3040
pushq $-0x6
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: pp_gensym
cell pp_gensym(cell x) {
	char	pre[101];
	int	k;

	if (x == NIL) {
		strcpy(pre, "g");
		k = 1;
	}
	else if (string_p(car(x))) {
		memcpy(pre, string(car(x)), 100);
		k = string_len(car(x));
	}
	else if (symbol_p(car(x))) {
		memcpy(pre, symbol_name(car(x)), 100);
		k = symbol_len(car(x));
	}
	else
		return error("gensym: expected str/id, got",
				car(x));
	if (k > 100)
		return error("gensym: prefix too long", car(x));
	pre[100] = 0;
	return gensym(pre);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
cmpq $-0x1, %rdi
je 0x10928
movq 0xb872(%rip), %rax      # 0x1c170
movq (%rax,%rdi,8), %rbx
testq %rbx, %rbx
js 0x10914
movq 0xbcd2(%rip), %rcx      # 0x1c5e0
testb $0x10, (%rcx,%rbx)
jne 0x10944
leaq 0x466a(%rip), %rdi      # 0x14f85
movq %rbx, %rsi
callq 0x33e4
pushq $-0x5
popq %rax
jmp 0x1093b
movw $0x67, -0x80(%rbp)
leaq -0x80(%rbp), %rdi
movb $0x0, 0x64(%rdi)
callq 0xb223
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpq $-0x21, (%rax,%rbx,8)
je 0x10952
cmpq $-0x22, (%rax,%rbx,8)
jne 0x10914
movq 0xbc8f(%rip), %rax      # 0x1c5e8
movq 0xbc60(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rbx,8), %rcx
leaq (%rax,%rcx,8), %r14
leaq -0x80(%rbp), %rdi
pushq $0x64
popq %rdx
movq %r14, %rsi
callq 0x3130
cmpl $0x65, -0x8(%r14)
jl 0x1092e
leaq 0x461d(%rip), %rdi      # 0x14fa2
jmp 0x1091b
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
callq 0x3f4c
xorps %xmm0, %xmm0
andl $0x0, 0xc229(%rip)      # 0x1cbd0
movups %xmm0, 0xc212(%rip)     # 0x1cbc0
andl $0x0, 0xbcb3(%rip)      # 0x1c668
movups %xmm0, 0xbc9c(%rip)     # 0x1c658
leaq 0xbc95(%rip), %r14      # 0x1c658
movups %xmm0, 0xbc76(%rip)     # 0x1c640
andl $0x0, 0xbc7f(%rip)      # 0x1c650
leaq 0xbc68(%rip), %r15      # 0x1c640
movups %xmm0, 0xbc45(%rip)     # 0x1c624
andl $0x0, 0xbc4e(%rip)      # 0x1c634
leaq 0xbc37(%rip), %r13      # 0x1c624
andl $0x0, 0xbc60(%rip)      # 0x1c654
movl 0xbc26(%rip), %ebx      # 0x1c620
movl $0x1, 0xbc1c(%rip)      # 0x1c620
movq 0xb765(%rip), %rax      # 0x1c170
movq (%rax,%r12,8), %rdi
callq 0x10278
movq 0xb70d(%rip), %rsi      # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0xb6fc(%rip)      # 0x1c128
movl %ebx, 0xbbee(%rip)      # 0x1c620
movq %r13, %rdi
callq 0x3509
pushq $-0x1
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, %r12
movq 0xb6d7(%rip), %rsi      # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0xb6c6(%rip)      # 0x1c128
movq 0xb707(%rip), %rcx      # 0x1c170
movq %r12, (%rcx,%rax,8)
movq %r15, %rdi
callq 0x3509
movq %rax, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %r15
movq 0xb6e4(%rip), %rax      # 0x1c170
movq 0xb695(%rip), %rcx      # 0x1c128
movq %r15, (%rax,%rcx,8)
movq %r14, %rdi
callq 0x3509
movq %rax, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %r14
movq 0xb6ba(%rip), %rax      # 0x1c170
movq 0xb66b(%rip), %rcx      # 0x1c128
movq %r14, (%rax,%rcx,8)
leaq 0xc0f8(%rip), %rdi      # 0x1cbc0
callq 0x3509
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %rbx
pushq $0x2
popq %rdi
callq 0x3775
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3613
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq 0xc0cb(%rip), %rax      # 0x1cbd8
testq %rax, %rax
je 0x10b6b
cmpq $0x0, (%rax)
je 0x10b6b
movq 0xb651(%rip), %rax      # 0x1c170
movq (%rax,%rdi,8), %rsi
leaq 0x4490(%rip), %rdi      # 0x14fba
callq 0x41c5
xorl %edx, %edx
movq 0xc0a0(%rip), %rcx      # 0x1cbd8
cmpq %rdx, %rax
je 0x10b4a
cmpq $0x0, (%rcx,%rdx,8)
leaq 0x1(%rdx), %rdx
jne 0x10b38
jmp 0x10b6b
movq (%rcx,%rax,8), %rbx
testq %rbx, %rbx
je 0x10b6b
movq %rbx, %rdi
callq 0x30a0
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x729e
pushq $-0x3
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq 0xba3e(%rip), %rax      # 0x1c5c0
movq 0xb5e7(%rip), %rcx      # 0x1c170
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rdi
shlq $0x3, %rdi
addq 0xba4c(%rip), %rdi      # 0x1c5e8
callq 0x3030
testq %rax, %rax
je 0x10bc1
movq %rax, %rbx
movq %rax, %rdi
callq 0x30a0
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x729e
pushq $-0x3
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdx, %rbx
movq %rsi, %rcx
movq 0xbaaf(%rip), %rax      # 0x1c6c8
movq 0xb550(%rip), %rdx      # 0x1c170
movq 0xb999(%rip), %rsi      # 0x1c5c0
movq (%rsi,%rdi,8), %rsi
imulq $0x28, (%rdx,%rsi,8), %rdx
movq (%rax,%rdx), %rdx
leaq 0x417b(%rip), %rsi      # 0x14db6
leaq -0x80(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33e4
pushq $-0x5
popq %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: uses_transformer_p
int uses_transformer_p(cell x) {
	cell	y;

	if (atom_p(x) || car(x) == S_quote)
		return 0;
	if (tuple_p(x) && symbol_p(car(x))) {
		y = lookup(car(x), Environment, 0);
		if (y != NIL && syntax_p(binding_value(y)))
			return 1;
	}
	while (tuple_p(x)) {
		if (uses_transformer_p(car(x)))
			return 1;
		x = cdr(x);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
js 0x110bc
movq %rdi, %r14
movq 0xb5a6(%rip), %rax      # 0x1c5e0
movzbl (%rax,%rdi), %edx
testb $0x11, %dl
jne 0x110bc
movq 0xb126(%rip), %rcx      # 0x1c170
movq (%rcx,%r14,8), %rdi
cmpq 0xb653(%rip), %rdi      # 0x1c6a8
je 0x110bc
andl $0x8, %edx
shrl $0x3, %edx
testq %rdi, %rdi
sets %sil
orb %dl, %sil
pushq $0x1
popq %r15
jne 0x110c9
testb $0x10, (%rax,%rdi)
je 0x110c9
cmpq $-0x22, (%rcx,%rdi,8)
jne 0x110c9
movq 0xb087(%rip), %rsi      # 0x1c108
xorl %edx, %edx
callq 0xca03
cmpq $-0x1, %rax
je 0x110c9
movq 0xb52b(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rax,8), %rax
testq %rax, %rax
js 0x110c9
movq 0xb53b(%rip), %rcx      # 0x1c5e0
testb $0x1, (%rcx,%rax)
je 0x110c9
movq 0xb0be(%rip), %rcx      # 0x1c170
cmpq $-0x23, (%rcx,%rax,8)
jne 0x110c9
movl %r15d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testq %r14, %r14
js 0x110bc
movq 0xb50b(%rip), %rax      # 0x1c5e0
testb $0x19, (%rax,%r14)
jne 0x110bc
movq 0xb08d(%rip), %rax      # 0x1c170
movq (%rax,%r14,8), %rdi
callq 0x1101b
testl %eax, %eax
jne 0x110b9
movq 0xb4c9(%rip), %rax      # 0x1c5c0
movq (%rax,%r14,8), %r14
jmp 0x110c9
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xa747(%rip), %eax      # 0x1c5b4
testq %rdi, %rdi
js 0x11eeb
testl %eax, %eax
jne 0x11eeb
movq 0xa763(%rip), %rax      # 0x1c5e0
testb $0x11, (%rax,%rbx)
jne 0x11eeb
movq 0xa2e6(%rip), %rax      # 0x1c170
movq (%rax,%rbx,8), %rax
cmpq 0xa813(%rip), %rax      # 0x1c6a8
je 0x11eeb
movq 0xa28a(%rip), %rsi      # 0x1c128
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0xa279(%rip)      # 0x1c128
cmpl $0x0, 0xa6fe(%rip)      # 0x1c5b4
jne 0x11ee3
movq %rbx, %rdi
callq 0x1101b
testl %eax, %eax
je 0x11ee3
movq %rbx, %rdi
callq 0x110fd
movq %rax, %rbx
movq 0xa29a(%rip), %rax      # 0x1c170
movq 0xa24b(%rip), %rcx      # 0x1c128
movq %rbx, (%rax,%rcx,8)
jmp 0x11eaf
pushq $0x1
popq %rdi
callq 0x3775
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0xa23c(%rip), %rcx      # 0x1c138
cmpq $-0x1, %rcx
je 0x11f20
movq 0xa267(%rip), %rax      # 0x1c170
movq (%rax,%rcx,8), %rax
movq 0xa6ac(%rip), %rdx      # 0x1c5c0
movq (%rdx,%rcx,8), %rcx
movq %rcx, 0xa219(%rip)      # 0x1c138
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x31e4(%rip), %rdi      # 0x1510f
callq 0x39b6
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x9fd9(%rip), %rax      # 0x1c170
movq (%rax,%rdi,8), %r14
movq 0xa41e(%rip), %rcx      # 0x1c5c0
movq (%rcx,%r14,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rdi
xorl %edx, %edx
callq 0x3613
movq 0x9fb4(%rip), %rcx      # 0x1c170
movq 0xa3fd(%rip), %rdx      # 0x1c5c0
movq (%rdx,%r14,8), %rdx
movq (%rcx,%rdx,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
pushq $-0x1e
popq %rdi
pushq $0x1
popq %rdx
movq %rax, %rsi
callq 0x3613
movq 0xa3d6(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rbx,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x3613
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: fnmatch
cell fnmatch(cell n, int *ps) {
	cell	c, cas, p, a, v, rib, g;
	cell	new;

	save(Environment);
	p = car(n);
	Environment = cadr(p);
	if (cdr(n) != NIL && cddr(n) == NIL)
		a = cadr(n);
	else
		a = cdr(n);
	c = rib = UNDEFINED;
	for (cas = cdddr(p); cas != NIL; cas = cdr(cas)) {
		c = car(cas);
		v = car(c);
		g = 0;
		if (tuple_p(v) && car(v) == GUARD) {
			v = cadr(v);
			g =  1;
		}
		if ((rib = destructuring_bind(v, a)) == UNDEFINED)
			continue;
		if (!g)
			break;
		Environment = make_env(rib, Environment);
		save(n);
		set(car(Stack), next_case(n, cas));
		*ps = EV_GUARD;
		return cddar(c);
	}
	*ps = EV_BETA;
	if (rib == UNDEFINED)
		return error("no match", n);
	Environment = make_env(rib, Environment);
	return cadr(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, -0x30(%rbp)
movq %rdi, %r14
movq 0x9ef0(%rip), %rdi      # 0x1c108
movq 0x9f09(%rip), %rsi      # 0x1c128
xorl %edx, %edx
callq 0x3613
movq %rax, 0x9efb(%rip)      # 0x1c128
movq 0x9f3c(%rip), %rdx      # 0x1c170
movq (%rdx,%r14,8), %rcx
movq 0xa381(%rip), %rax      # 0x1c5c0
movq (%rax,%rcx,8), %rsi
movq (%rdx,%rsi,8), %rsi
movq %rsi, 0x9eba(%rip)      # 0x1c108
movq (%rax,%r14,8), %rsi
cmpq $-0x1, %rsi
je 0x1226e
leaq (%rax,%r14,8), %rdi
cmpq $-0x1, (%rax,%rsi,8)
leaq (%rdx,%rsi,8), %rdx
cmovneq %rdi, %rdx
movq (%rdx), %r12
jmp 0x12272
pushq $-0x1
popq %r12
movq (%rax,%rcx,8), %rcx
movq (%rax,%rcx,8), %rcx
leaq (%rax,%rcx,8), %rcx
movq (%rcx), %r15
cmpq $-0x1, %r15
je 0x122d6
movq 0x9ee2(%rip), %rcx      # 0x1c170
movq (%rcx,%r15,8), %r13
movq (%rcx,%r13,8), %rdi
movb $0x1, %bl
testq %rdi, %rdi
js 0x122bb
movq 0xa33c(%rip), %rdx      # 0x1c5e0
testb $0x19, (%rdx,%rdi)
jne 0x122bb
cmpq $-0x9, (%rcx,%rdi,8)
jne 0x122bb
movq (%rax,%rdi,8), %rax
movq (%rcx,%rax,8), %rdi
xorl %ebx, %ebx
movq %r12, %rsi
callq 0x11f30
cmpq $-0x5, %rax
jne 0x122f7
movq 0xa2f0(%rip), %rax      # 0x1c5c0
leaq (%rax,%r15,8), %rcx
jmp 0x1227e
movq -0x30(%rbp), %rax
movl $0x2, (%rax)
leaq 0x2e47(%rip), %rdi      # 0x1512e
movq %r14, %rsi
callq 0x33e4
pushq $-0x5
popq %rax
jmp 0x12397
testb %bl, %bl
je 0x1232f
movq -0x30(%rbp), %rcx
movl $0x2, (%rcx)
movq 0x9dfc(%rip), %rsi      # 0x1c108
movq %rax, %rdi
callq 0xc8fd
movq %rax, 0x9ded(%rip)      # 0x1c108
movq 0x9e4e(%rip), %rax      # 0x1c170
movq 0xa297(%rip), %rcx      # 0x1c5c0
movq (%rcx,%r13,8), %rcx
jmp 0x12393
movq 0x9dd2(%rip), %rsi      # 0x1c108
movq %rax, %rdi
callq 0xc8fd
movq %rax, 0x9dc3(%rip)      # 0x1c108
movq 0x9ddc(%rip), %rsi      # 0x1c128
movq %r14, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x9dcb(%rip)      # 0x1c128
movq %r14, %rdi
movq %r15, %rsi
callq 0x12186
movq 0x9e01(%rip), %rcx      # 0x1c170
movq 0x9db2(%rip), %rdx      # 0x1c128
movq %rax, (%rcx,%rdx,8)
movq -0x30(%rbp), %rax
movl $0x3, (%rax)
movq 0xa235(%rip), %rax      # 0x1c5c0
movq (%rcx,%r13,8), %rcx
movq (%rax,%rcx,8), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq 0x9d85(%rip), %rax      # 0x1c138
xorl %ebx, %ebx
cmpq $-0x1, %rax
je 0x12424
movq 0x9dae(%rip), %rcx      # 0x1c170
cmpq $0x2, (%rcx,%rax,8)
jne 0x12424
pushq $0x1
popq %rbx
movl %ebx, %edi
callq 0x3775
movq %rax, 0x9d36(%rip)      # 0x1c110
movq 0x9d8f(%rip), %rax      # 0x1c170
movq 0x9d40(%rip), %rcx      # 0x1c128
movq (%rax,%rcx,8), %rax
movq %rax, 0x9d15(%rip)      # 0x1c108
pushq $0x2
popq %rdi
callq 0x3775
callq 0x11ef5
movq 0x9d09(%rip), %rdi      # 0x1c110
movq 0x9d1a(%rip), %rsi      # 0x1c128
xorl %edx, %edx
callq 0x3613
movq %rax, 0x9d0c(%rip)      # 0x1c128
orq $-0x1, 0x9cec(%rip)     # 0x1c110
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rsi
movq 0xa17f(%rip), %rax      # 0x1c5c0
leaq 0x9d20(%rip), %rdx      # 0x1c168
movq 0x9d21(%rip), %rcx      # 0x1c170
movq (%rdx), %r15
cmpq $-0x1, %r15
je 0x124dd
movq (%rcx,%r15,8), %rdx
movq (%rax,%rdx,8), %rbx
movq (%rax,%rbx,8), %rdx
movq (%rax,%rdx,8), %rdx
cmpq $-0x1, %rdx
je 0x1247e
movq (%rcx,%rdx,8), %rdi
cmpq %rsi, (%rcx,%rdi,8)
jne 0x12468
jmp 0x12484
leaq (%rax,%r15,8), %rdx
jmp 0x1244f
movq (%rax,%r15,8), %rax
movq %rax, 0x9cd9(%rip)      # 0x1c168
pushq $-0x1
popq %r14
movq %rsi, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3613
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x9caf(%rip), %rcx      # 0x1c170
movq (%rcx,%r15,8), %rdx
movq (%rcx,%rdx,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3613
leaq 0x2c53(%rip), %rdi      # 0x15137
callq 0x33e4
pushq $-0x5
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0xa14d(%rip)      # 0x1c698
movl $0x1, 0x9d2b(%rip)      # 0x1c280
leaq 0x2c0c(%rip), %rdi      # 0x15168
pushq $-0x8
popq %rsi
callq 0x33e4
leaq -0x2b(%rip), %rsi       # 0x12540
pushq $0x2
popq %rdi
popq %rbp
jmp 0x3120
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $-0x1
popq %rbx
xorl %r13d, %r13d
movq %rbx, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %r14
movq 0x9b67(%rip), %rsi      # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x9b56(%rip)      # 0x1c128
cmpl $0x0, 0x9fdf(%rip)      # 0x1c5b8
jne 0x125ea
leaq -0xa2(%rip), %rsi       # 0x12540
pushq $0x2
popq %rdi
callq 0x3120
movl $0xffffff9b, 0xa0dc(%rip) # imm = 0xFFFFFF9B
pushq $-0x65
popq %rax
leaq 0x2b94(%rip), %r15      # 0x15192
leaq 0x32d2(%rip), %r12      # 0x158d7
cmpl $-0x4, %eax
je 0x12722
movl %r13d, 0x9f9f(%rip)     # 0x1c5b4
andl $0x0, 0xa07c(%rip)      # 0x1c698
movl $0x1, 0x9c5a(%rip)      # 0x1c280
callq 0x12519
callq 0x124f7
movq 0x9ad1(%rip), %rax      # 0x1c108
movq 0x9b32(%rip), %rcx      # 0x1c170
movq %rax, (%rcx,%r14,8)
orq $-0x1, 0x9b1e(%rip)     # 0x1c168
cmpl %r13d, 0x9f67(%rip)     # 0x1c5b8
jne 0x12660
movq %r15, %rdi
callq 0x3873
callq 0x37bb
movl 0xa06a(%rip), %eax      # 0x1c6d0
cmpl $-0x5, %eax
je 0x12670
cmpl $-0x65, %eax
jne 0x1267b
callq 0x8d74
movl %eax, 0xa055(%rip)      # 0x1c6d0
callq 0xa9c2
movq %rax, 0x9a71(%rip)      # 0x1c0f8
movl 0xa043(%rip), %eax      # 0x1c6d0
cmpl $-0x65, %eax
je 0x126aa
cmpl $-0x4, %eax
je 0x126aa
movq 0x9aba(%rip), %rsi      # 0x1c158
leaq 0x20ed(%rip), %rdi      # 0x14792
callq 0x33e4
cmpl $0x0, 0x9f03(%rip)      # 0x1c5b4
jne 0x126c2
movq 0x9a3e(%rip), %rdi      # 0x1c0f8
callq 0x10278
movq %rax, %rbx
cmpl $0x0, 0x9eeb(%rip)      # 0x1c5b4
sete %al
cmpq $-0x5, %rbx
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x126fc
movq %rbx, %rdi
callq 0x38e1
movq %r12, %rdi
callq 0x3873
movq 0x9ecf(%rip), %rax      # 0x1c5c0
movq 0xa4f8(%rip), %rcx      # 0x1cbf0
movq %rbx, (%rax,%rcx,8)
cmpl $0x0, 0x9eb1(%rip)      # 0x1c5b4
je 0x12717
movq 0x9a64(%rip), %rax      # 0x1c170
movq (%rax,%r14,8), %rax
movq %rax, 0x99f1(%rip)      # 0x1c108
movl 0x9fb3(%rip), %eax      # 0x1c6d0
jmp 0x12605
pushq $0x1
popq %rdi
callq 0x3775
leaq 0x31a6(%rip), %rdi      # 0x158d7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3873
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
leaq 0x28df(%rip), %rdi      # 0x15376
callq 0x3030
testq %rax, %rax
leaq 0x28e3(%rip), %rbx      # 0x15389
cmovneq %rax, %rbx
movq %rbx, %rdi
callq 0x30a0
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x729e
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x12ad5
movq %rdi, %rbx
cmpb $0x0, (%rdi)
jne 0x12adc
leaq 0x28d8(%rip), %rbx      # 0x153b4
pushq $0x2f
popq %rsi
movq %rbx, %rdi
callq 0x30c0
leaq 0x1(%rax), %rcx
testq %rax, %rax
cmoveq %rbx, %rcx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: grow_primitives
void grow_primitives(void) {
	Max_prims += PRIM_SEG_SIZE;
	Primitives = (PRIM *) realloc(Primitives, sizeof(PRIM) * Max_prims);
	if (Primitives == NULL)
		fatal("grow_primitives: out of physical memory");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x9edb(%rip), %rax      # 0x1cc14
addq $0x100, %rax            # imm = 0x100
movl %eax, 0x9ecf(%rip)      # 0x1cc14
movq 0x997c(%rip), %rdi      # 0x1c6c8
imulq $0x28, %rax, %rsi
callq 0x3190
movq %rax, 0x996c(%rip)      # 0x1c6c8
testq %rax, %rax
je 0x12d63
popq %rbp
retq
leaq 0x26ae(%rip), %rdi      # 0x15418
callq 0x39b6