LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: apply_special
cell apply_special(cell x, int *pc, int *ps) {
	cell	sf;

	sf = car(x);
	if (sf == S_quote) return sf_quote(x);
	else if (sf == S_if) return sf_if(x, pc, ps);
	else if (sf == S_also) return sf_also(x, pc, ps);
	else if (sf == S_or) return sf_or(x, pc, ps);
	else if (sf == S_begin) return sf_begin(x, pc, ps);
	else if (sf == S_fn) return sf_fn(x);
	else if (sf == S_setb) return sf_setb(x, pc, ps);
	else if (sf == S_letrec) return sf_letrec(x, pc);
	else if (sf == S_define) return sf_define(0, x, pc, ps);
	else if (sf == S_raise) return sf_raise(x, pc, ps);
	else if (sf == S_from) return sf_redirect(0, x, pc, ps);
	else if (sf == S_to) return sf_redirect(1, x, pc, ps);
	else if (sf == S_define_type) return sf_define_type(x, pc);
	else if (sf == S_define_syntax) return sf_define(1, x, pc, ps);
	else fatal("internal: unknown special form");
	return UNDEFINED;
}

// Assembly:
movq %rdx, %r8
movq %rsi, %rcx
movq %rdi, %rdx
movq 0xf295(%rip), %rsi      # 0x1e170
movq (%rsi,%rdi,8), %rax
cmpq 0xf7c2(%rip), %rax      # 0x1e6a8
jne 0xeef0
movq %rdx, %rdi
jmp 0xe352
cmpq 0xf849(%rip), %rax      # 0x1e740
jne 0xef07
movq %rdx, %rdi
movq %rcx, %rsi
movq %r8, %rdx
jmp 0xdd9a
cmpq 0xf7da(%rip), %rax      # 0x1e6e8
jne 0xef21
movl $0x8, %edi
movq $-0x2, %rsi
jmp 0xdd2e
cmpq 0xf7d8(%rip), %rax      # 0x1e700
jne 0xef3b
movl $0x9, %edi
movq $-0x3, %rsi
jmp 0xdd2e
cmpq 0xf816(%rip), %rax      # 0x1e758
jne 0xef55
movl $0x7, %edi
movq $-0x6, %rsi
jmp 0xdd2e
cmpq 0xf7ac(%rip), %rax      # 0x1e708
jne 0xef66
movq %rdx, %rdi
jmp 0xe1b0
cmpq 0xf81b(%rip), %rax      # 0x1e788
jne 0xef7d
movq %rdx, %rdi
movq %rcx, %rsi
movq %r8, %rdx
jmp 0xe3c4
cmpq 0xf7e4(%rip), %rax      # 0x1e768
jne 0xef91
movq %rdx, %rdi
movq %rcx, %rsi
jmp 0xe0aa
cmpq 0xf7c8(%rip), %rax      # 0x1e760
jne 0xefaa
xorl %edi, %edi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
jmp 0xe549
cmpq 0xf787(%rip), %rax      # 0x1e738
jne 0xefd0
movl $0x2, (%rcx)
movl $0xc, (%r8)
movq 0xf5f9(%rip), %rax      # 0x1e5c0
movq (%rax,%rdx,8), %rax
movq (%rsi,%rax,8), %rax
retq
cmpq 0xf771(%rip), %rax      # 0x1e748
jne 0xefdd
xorl %edi, %edi
jmp 0xefeb
cmpq 0xf76c(%rip), %rax      # 0x1e750
jne 0xeff9
movl $0x1, %edi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
jmp 0xee10
cmpq 0xf770(%rip), %rax      # 0x1e770
jne 0xf00d
movq %rdx, %rdi
movq %rcx, %rsi
jmp 0xeb89
cmpq 0xf77c(%rip), %rax      # 0x1e790
jne 0xf020
movl $0x1, %edi
jmp 0xef9c
pushq %rbp
movq %rsp, %rbp
leaq 0x7bd6(%rip), %rdi      # 0x16c01
callq 0x3ab4
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: append_str
cell append_str(cell x) {
	cell	p, n;
	int	k, m;
	char	*s;

	k = 0;
	for (p = x; p != NIL; p = cdr(p))
		k += string_len(car(p))-1;
	n = make_string("", k);
	s = string(n);
	k = 0;
	for (p = x; p != NIL; p = cdr(p)) {
		m = string_len(car(p));
		memcpy(&s[k], string(car(p)), m);
		k += string_len(car(p))-1;
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpq $-0x1, %rdi
je 0xf084
movq 0xf59d(%rip), %rax      # 0x1e5e8
movq 0xf56e(%rip), %rcx      # 0x1e5c0
xorl %r8d, %r8d
movq 0xf114(%rip), %rdx      # 0x1e170
movq %rbx, %rsi
movl %r8d, %r15d
movq (%rdx,%rsi,8), %rdi
movq (%rcx,%rdi,8), %rdi
movl -0x8(%rax,%rdi,8), %edi
leal (%r15,%rdi), %r8d
decl %r8d
movq (%rcx,%rsi,8), %rsi
cmpq $-0x1, %rsi
jne 0xf05f
addl %edi, %r15d
jmp 0xf08a
movl $0x1, %r15d
movq $-0x21, %rdi
movl %r15d, %esi
callq 0x416e
movq %rax, %r14
movq 0xf51d(%rip), %rax      # 0x1e5c0
movq (%rax,%r14,8), %rdi
shlq $0x3, %rdi
addq 0xf536(%rip), %rdi      # 0x1e5e8
movslq %r15d, %rdx
xorl %esi, %esi
callq 0x30d0
cmpq $-0x1, %rbx
je 0xf130
movq 0xf51f(%rip), %rax      # 0x1e5e8
movq 0xf4f0(%rip), %rcx      # 0x1e5c0
movq (%rcx,%r14,8), %rdx
leaq (%rax,%rdx,8), %r15
movq 0xf091(%rip), %rdx      # 0x1e170
xorl %edi, %edi
movq (%rdx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rcx
leaq (%rax,%rcx,8), %rsi
movslq -0x8(%rsi), %rdx
movslq %edi, %r12
leaq (%r15,%r12), %rdi
callq 0x3130
movq 0xf4e4(%rip), %rax      # 0x1e5e8
movq 0xf4b5(%rip), %rcx      # 0x1e5c0
movq 0xf05e(%rip), %rdx      # 0x1e170
movq (%rdx,%rbx,8), %rsi
movq (%rcx,%rsi,8), %rsi
movq -0x8(%rax,%rsi,8), %rsi
leaq (%r12,%rsi), %rdi
decq %rdi
movq (%rcx,%rbx,8), %rbx
cmpq $-0x1, %rbx
jne 0xf0e1
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: append_list
cell append_list(cell x) {
	cell	new, n, p, a, *pa;

	if (car(x) == NIL)
		return cadr(x);
	if (cadr(x) == NIL)
		return car(x);
	a = n = cons(NIL, NIL);
	pa = &a;
	save(n);
	for (p = car(x); p != NIL; p = cdr(p)) {
		car(a) = car(p);
		set(cdr(a), cons(NIL, NIL));
		pa = &cdr(a);
		a = cdr(a);
	}
	unsave(1);
	*pa = cadr(x);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0xf01e(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %r14
movq 0xf463(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rax
cmpq $-0x1, %r14
je 0xf208
cmpq $-0x1, %rax
je 0xf234
movq %rdi, %rbx
movq $-0x1, %rdi
movq $-0x1, %rsi
movl $0x8, %edx
callq 0x36e8
movq %rax, %r14
movq 0xef8a(%rip), %rsi      # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xef79(%rip)      # 0x1e128
movq 0xefba(%rip), %rax      # 0x1e170
movq (%rax,%rbx,8), %r15
cmpq $-0x1, %r15
je 0xf20d
movq %r14, %rax
movq %rax, %r12
movq 0xefa3(%rip), %rax      # 0x1e170
movq (%rax,%r15,8), %rcx
movq %rcx, (%rax,%r12,8)
movq $-0x1, %rdi
movq $-0x1, %rsi
movl $0x8, %edx
callq 0x36e8
movq 0xf3cc(%rip), %rcx      # 0x1e5c0
movq %rax, (%rcx,%r12,8)
movq (%rcx,%r15,8), %r15
cmpq $-0x1, %r15
jne 0xf1c3
leaq (%rcx,%r12,8), %r15
jmp 0xf211
movq %rax, %r14
jmp 0xf234
leaq -0x28(%rbp), %r15
movl $0x1, %edi
callq 0x384f
movq 0xef4e(%rip), %rax      # 0x1e170
movq 0xf397(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rbx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%r15)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: pp_append
cell pp_append(cell x) {
	cell	n1, n2;

	n1 = car(x);
	n2 = cadr(x);
	if (list_p(n1) && list_p(n2))
		return append_list(x);
	if (string_p(n1) && string_p(n2))
		return append_str(x);
	return error("@: expected tuple of str/list, got", x);
}

// Assembly:
movq %rdi, %rsi
movq 0xef22(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rdx
movq 0xf367(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rcx
testq %rdx, %rdx
js 0xf280
movq 0xf373(%rip), %rdi      # 0x1e5e0
movb (%rdi,%rdx), %r8b
movl %r8d, %r9d
andb $0x19, %r9b
cmpb $0x8, %r9b
je 0xf286
jmp 0xf2be
cmpq $-0x1, %rdx
jne 0xf2c4
testq %rcx, %rcx
js 0xf2a8
movq 0xf34e(%rip), %rdi      # 0x1e5e0
movb (%rdi,%rcx), %dil
andb $0x19, %dil
cmpb $0x8, %dil
jne 0xf2ae
movq %rsi, %rdi
jmp 0xf13c
cmpq $-0x1, %rcx
je 0xf2a0
testq %rdx, %rdx
js 0xf2c4
movq 0xf326(%rip), %rdi      # 0x1e5e0
movb (%rdi,%rdx), %r8b
testb $0x10, %r8b
jne 0xf2dd
pushq %rbp
movq %rsp, %rbp
leaq 0x7951(%rip), %rdi      # 0x16c20
callq 0x33eb
movq $-0x5, %rax
popq %rbp
retq
cmpq $-0x21, (%rax,%rdx,8)
jne 0xf2c4
testq %rcx, %rcx
js 0xf2c4
testb $0x10, (%rdi,%rcx)
je 0xf2c4
cmpq $-0x21, (%rax,%rcx,8)
jne 0xf2c4
movq %rsi, %rdi
jmp 0xf030
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: pp_clone
cell pp_clone(cell x) {
	cell	v;
	int	k;

	if (vector_p(car(x))) {
		k = vector_len(car(x));
		v = new_vec(T_VECTOR, k * sizeof(cell));
		memcpy(vector(v), vector(car(x)), k * sizeof(cell));
		return v;
	}
	else {
		return car(x);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xee61(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rbx
testq %rbx, %rbx
js 0xf3a2
movq 0xf2bd(%rip), %rcx      # 0x1e5e0
testb $0x10, (%rcx,%rbx)
je 0xf3a2
cmpq $-0x24, (%rax,%rbx,8)
jne 0xf3a2
movq %rdi, %r14
movq 0xf2ae(%rip), %rax      # 0x1e5e8
movq 0xf27f(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rbx,8), %rcx
movq -0x8(%rax,%rcx,8), %rax
shlq $0x1d, %rax
movl $0xe0000000, %r15d      # imm = 0xE0000000
addq %rax, %r15
sarq $0x1d, %r15
andq $-0x8, %r15
movq $-0x24, %rdi
movl %r15d, %esi
callq 0x416e
movq %rax, %rbx
movq 0xf270(%rip), %rax      # 0x1e5e8
movq 0xf241(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rbx,8), %rdx
leaq (%rax,%rdx,8), %rdi
movq 0xede2(%rip), %rdx      # 0x1e170
movq (%rdx,%r14,8), %rdx
movq (%rcx,%rdx,8), %rcx
leaq (%rax,%rcx,8), %rsi
movq %r15, %rdx
callq 0x3130
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: pp_len
cell pp_len(cell x) {
	int	k = 0;

	if (string_p(car(x)))
		return make_integer(string_len(car(x))-1);
	if (vector_p(car(x)))
		return make_integer(vector_len(car(x)));
	if (!list_p(car(x)) && !tuple_p(car(x)))
		error("len: expected str/list/tuple/vec, got", car(x));
	for (x = car(x); x != NIL; x = cdr(x))
		k++;
	return make_integer(k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xedb0(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rsi
testq %rsi, %rsi
js 0xf3e0
movq 0xf210(%rip), %rcx      # 0x1e5e0
movzbl (%rcx,%rsi), %ecx
testb $0x10, %cl
jne 0xf41b
testb $0x11, %cl
je 0xf403
jmp 0xf3e6
cmpq $-0x1, %rsi
je 0xf43e
leaq 0x7856(%rip), %rdi      # 0x16c43
callq 0x33eb
movq 0xed77(%rip), %rax      # 0x1e170
movq (%rax,%rbx,8), %rsi
cmpq $-0x1, %rsi
je 0xf43e
movq 0xf1b6(%rip), %rax      # 0x1e5c0
xorl %edi, %edi
movq (%rax,%rsi,8), %rsi
incq %rdi
cmpq $-0x1, %rsi
jne 0xf40c
jmp 0xf468
cmpq $-0x21, (%rax,%rsi,8)
jne 0xf442
movq 0xf1bf(%rip), %rax      # 0x1e5e8
movq 0xf190(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rsi,8), %rcx
movq -0x8(%rax,%rcx,8), %rdi
decq %rdi
jmp 0xf468
xorl %edi, %edi
jmp 0xf468
cmpq $-0x24, (%rax,%rsi,8)
jne 0xf3d9
movq 0xf198(%rip), %rax      # 0x1e5e8
movq 0xf169(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rsi,8), %rcx
movq -0x8(%rax,%rcx,8), %rdi
addq $0x7, %rdi
shrq $0x3, %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x18, %rdi
movq %rax, %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x36e8
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: pp_order
cell pp_order(cell x) {
	if (car(x) == UNIT)
		return make_integer(0);
	if (tuple_p(car(x)))
		return pp_len(x);
	return make_integer(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xecd2(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rax
cmpq $-0x6, %rax
jne 0xf4ac
xorl %edi, %edi
jmp 0xf4c3
testq %rax, %rax
js 0xf4be
movq 0xf128(%rip), %rcx      # 0x1e5e0
testb $0x19, (%rcx,%rax)
je 0xf4e9
movl $0x1, %edi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x18, %rdi
movq %rax, %rsi
movl $0x1, %edx
popq %rbp
jmp 0x36e8
popq %rbp
jmp 0xf3b0
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: pp_rev
cell pp_rev(cell x) {
	cell	n, m;
	int	k, i;
	char	*s, *d;

	if (list_p(car(x))) {
		m = NIL;
		for (n = car(x); n != NIL; n = cdr(n))
			m = cons(car(n), m);
		return m;
	}
	if (string_p(car(x))) {
		s = string(car(x));
		k = string_len(car(x))-1;
		m = make_string("", k);
		d = string(m);
		for (i=0; i<k; i++)
			d[i] = s[k-i-1];
		d[i] = 0;
		return m;
	}
	return error("rev: expected list/str, got", car(x));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xec6c(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %r14
testq %r14, %r14
js 0xf55a
movq 0xf0cc(%rip), %rcx      # 0x1e5e0
movb (%rcx,%r14), %cl
movl %ecx, %edx
andb $0x19, %dl
cmpb $0x8, %dl
jne 0xf570
movq $-0x1, %rbx
movq 0xec40(%rip), %rax      # 0x1e170
movq (%rax,%r14,8), %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x36e8
movq %rax, %rbx
movq 0xf075(%rip), %rax      # 0x1e5c0
movq (%rax,%r14,8), %r14
cmpq $-0x1, %r14
jne 0xf529
jmp 0xf62b
cmpq $-0x1, %r14
jne 0xf615
movq $-0x1, %rbx
jmp 0xf62b
testb $0x10, %cl
je 0xf615
cmpq $-0x21, (%rax,%r14,8)
jne 0xf615
movq 0xf05d(%rip), %r15      # 0x1e5e8
movq 0xf02e(%rip), %rax      # 0x1e5c0
movq (%rax,%r14,8), %r12
movq -0x8(%r15,%r12,8), %r14
leal -0x1(%r14), %r13d
movq $-0x21, %rdi
movl %r14d, %esi
callq 0x416e
movq %rax, %rbx
movq 0xf008(%rip), %rax      # 0x1e5c0
movq (%rax,%rbx,8), %rdi
shlq $0x3, %rdi
addq 0xf021(%rip), %rdi      # 0x1e5e8
movslq %r14d, %rdx
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x30d0
movq 0xefe5(%rip), %rax      # 0x1e5c0
movq (%rax,%rbx,8), %rax
shlq $0x3, %rax
addq 0xeffe(%rip), %rax      # 0x1e5e8
testl %r13d, %r13d
jle 0xf60e
movl %r13d, %r14d
leaq (%r15,%r12,8), %rcx
decq %rcx
movq %rax, %rdx
movq %r14, %rsi
movb (%rcx,%rsi), %dil
movb %dil, (%rdx)
incq %rdx
decq %rsi
jne 0xf5ff
movb $0x0, (%rax,%r14)
jmp 0xf62b
leaq 0x764d(%rip), %rdi      # 0x16c69
movq %r14, %rsi
callq 0x33eb
movq $-0x5, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: sublis
cell sublis(cell x, int p0, int pn, int tag) {
	cell	p, a, new;

	pn -= p0;
	if (pn == 0)
		return NIL;
	a = node3(NIL, NIL, tag);
	save(a);
	for (p = car(x); p0; p = cdr(p), p0--)
		;
	for (; pn; p = cdr(p), pn--) {
		car(a) = car(p);
		if (pn > 1) {
			set(cdr(a), node3(NIL, NIL, tag));
			a = cdr(a);
		}
	}
	return unsave(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
subl %esi, %r14d
je 0xfd6d
movl %ecx, %ebx
movl %esi, %r12d
movq %rdi, %r13
movq $-0x1, %rdi
movq $-0x1, %rsi
movl %ecx, %edx
callq 0x36e8
movq %rax, %r15
movq 0xe44e(%rip), %rsi      # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xe43d(%rip)      # 0x1e128
movq 0xe47e(%rip), %rcx      # 0x1e170
movq (%rcx,%r13,8), %r13
testl %r12d, %r12d
je 0xfd0b
movq 0xe8be(%rip), %rax      # 0x1e5c0
movq (%rax,%r13,8), %r13
decl %r12d
jne 0xfd02
movq (%rcx,%r13,8), %rax
movq %rax, (%rcx,%r15,8)
cmpl $0x1, %r14d
jle 0xfd45
movq $-0x1, %rdi
movq $-0x1, %rsi
movl %ebx, %edx
callq 0x36e8
movq 0xe88b(%rip), %rdx      # 0x1e5c0
movq %rax, (%rdx,%r15,8)
movq 0xe430(%rip), %rcx      # 0x1e170
movq %rax, %r15
jmp 0xfd4c
movq 0xe874(%rip), %rdx      # 0x1e5c0
movq (%rdx,%r13,8), %r13
decl %r14d
jne 0xfd0b
movl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x384f
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: pp_ref
cell pp_ref(cell x) {
	int	p, k, n;

	p = integer_value("ref", cadr(x));
	if (cons_p(car(x))) {
		for (n = car(x); n != NIL && p; n = cdr(n), p--)
			;
		if (n == NIL)
			return error("ref: index out of range", cadr(x));
		return car(n);
	}
	if (vector_p(car(x))) {
		k = vector_len(car(x))-1;
		if (p < 0 || p > k)
			return error("ref: index out of range", cadr(x));
		return vector(car(x))[p];
	}
	if (!string_p(car(x)))
		return error("ref: expected str/tuple/list/vec, got", car(x));
	k = string_len(car(x))-1;
	if (p < 0 || p >= k)
		return error("ref: index out of range", cadr(x));
	return make_char(string(car(x))[p]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xe1a7(%rip), %rax      # 0x1e170
movq 0xe5f0(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x6d23(%rip), %rdi      # 0x16d02
callq 0x432f
movq 0xe185(%rip), %rcx      # 0x1e170
movq (%rcx,%rbx,8), %rsi
testq %rsi, %rsi
js 0x10008
movq 0xe5e5(%rip), %rdx      # 0x1e5e0
movb (%rdx,%rsi), %dl
testb $0x11, %dl
je 0x10014
testb $0x10, %dl
jne 0x10053
leaq 0x6d0f(%rip), %rdi      # 0x16d1e
jmp 0x10116
cmpl $-0x1, %esi
je 0x1003e
testl %eax, %eax
je 0x1003e
movq 0xe59c(%rip), %rdx      # 0x1e5c0
decl %eax
movslq %esi, %rsi
movq (%rdx,%rsi,8), %rsi
addl $-0x1, %eax
setb %dil
cmpl $-0x1, %esi
je 0x1003e
testb %dil, %dil
jne 0x10026
cmpl $-0x1, %esi
je 0x10100
movslq %esi, %rax
movq (%rcx,%rax,8), %rax
jmp 0x10122
cmpq $-0x24, (%rcx,%rsi,8)
jne 0x10094
movq 0xe55f(%rip), %rdx      # 0x1e5c0
testl %eax, %eax
js 0x100fa
movq (%rdx,%rsi,8), %rsi
movq 0xe574(%rip), %rdi      # 0x1e5e8
movq -0x8(%rdi,%rsi,8), %r8
addq $0x7, %r8
shrq $0x3, %r8
decl %r8d
cmpl %eax, %r8d
jl 0x100fa
leaq (%rdi,%rsi,8), %rcx
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
jmp 0x1004a
cmpq $-0x21, (%rcx,%rsi,8)
jne 0x10008
movq 0xe51a(%rip), %rdx      # 0x1e5c0
testl %eax, %eax
js 0x100fa
movq (%rdx,%rsi,8), %rsi
movq 0xe533(%rip), %rdi      # 0x1e5e8
movl -0x8(%rdi,%rsi,8), %r8d
decl %r8d
cmpl %eax, %r8d
jle 0x100fa
leaq (%rdi,%rsi,8), %rcx
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movzbl (%rcx,%rax), %edi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x16, %rdi
movq %rax, %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x36e8
movq (%rdx,%rbx,8), %rax
jmp 0x1010b
movq 0xe4b9(%rip), %rax      # 0x1e5c0
movq (%rax,%rbx,8), %rax
movq (%rcx,%rax,8), %rsi
leaq 0x6bf0(%rip), %rdi      # 0x16d06
callq 0x33eb
movq $-0x5, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: pp_typecheck
cell pp_typecheck(cell x) {
	cell	cname, datum, type, ps, p;
	char	msg[TOKEN_LENGTH*2];

	cname = car(x);
	datum = cadr(x);
	ps = caddr(x);
	if (!tuple_p(ps) || !symbol_p(car(ps)))
		return error("type-check: bad type pattern", ps);
	type = car(ps);
	for (ps = cdr(ps); tuple_p(ps); ps = cdr(ps)) {
		p = car(ps);
		if (symbol_p(p) && p == datum)
			return datum;
		else if (p == S_cons && list_p(datum))
			return datum;
		else if (tuple_p(p) && tuple_p(datum) && car(p) == car(datum))
			return datum;
	}
	sprintf(msg, "%s: expected %s, got",
			string(cname), string(type));
	return error(msg, datum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq 0xdd6d(%rip), %rcx      # 0x1e170
movq 0xe1b6(%rip), %rax      # 0x1e5c0
movq (%rax,%rdi,8), %r9
movq (%rax,%r9,8), %rdx
movq (%rcx,%rdx,8), %rsi
testq %rsi, %rsi
js 0x10428
movq 0xe1be(%rip), %rdx      # 0x1e5e0
testb $0x19, (%rdx,%rsi)
je 0x1044a
leaq 0x696a(%rip), %rdi      # 0x16d99
callq 0x33eb
movq $-0x5, %rbx
movq %rbx, %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %rbp
retq
movq (%rcx,%rsi,8), %r8
testq %r8, %r8
js 0x10428
testb $0x10, (%rdx,%r8)
je 0x10428
cmpq $-0x22, (%rcx,%r8,8)
jne 0x10428
movq (%rcx,%rdi,8), %rdi
movq (%rcx,%r9,8), %rbx
movq (%rax,%rsi,8), %rsi
testq %rsi, %rsi
js 0x104fa
movq 0xe213(%rip), %r9       # 0x1e690
testb $0x19, (%rdx,%rsi)
jne 0x104fa
movq (%rcx,%rsi,8), %r10
testq %r10, %r10
js 0x1049f
testb $0x10, (%rdx,%r10)
je 0x1049f
cmpq $-0x22, (%rcx,%r10,8)
jne 0x1049f
cmpq %rbx, %r10
je 0x1043b
cmpq %r9, %r10
jne 0x104bf
testq %rbx, %rbx
js 0x104b9
movb (%rdx,%rbx), %r11b
andb $0x19, %r11b
cmpb $0x8, %r11b
jne 0x104bf
jmp 0x1043b
cmpq $-0x1, %rbx
je 0x10534
testq %r10, %r10
js 0x104cf
movzbl (%rdx,%r10), %r11d
testb $0x11, %r11b
je 0x104da
movq (%rax,%rsi,8), %rsi
testq %rsi, %rsi
jns 0x1047d
jmp 0x104fa
testb $0x8, %r11b
jne 0x104cf
testq %rbx, %rbx
js 0x104cf
testb $0x19, (%rdx,%rbx)
jne 0x104cf
movq (%rcx,%r10,8), %r10
cmpq (%rcx,%rbx,8), %r10
jne 0x104cf
jmp 0x1043b
movq 0xe0e7(%rip), %rcx      # 0x1e5e8
movq (%rax,%rdi,8), %rdx
leaq (%rcx,%rdx,8), %rdx
movq (%rax,%r8,8), %rax
leaq (%rcx,%rax,8), %rcx
leaq 0x689e(%rip), %rsi      # 0x16db6
leaq -0x810(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x1042f
movq $-0x1, %rbx
jmp 0x1043b
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: pp_call_cc
cell pp_call_cc(cell x) {
	cell	cc, n;

	cc = node(Stack, NIL);
	cc = node(Stack_bottom, cc);
	cc = node(State_stack, cc);
	cc = node(Environment, cc);
	cc = new_atom(T_CONTINUATION, cc);
	n = node(cc, NIL);
	n = node(car(x), n);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xdbd8(%rip), %rdi      # 0x1e128
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0xdbcb(%rip), %rdi      # 0x1e130
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0xdbc2(%rip), %rdi      # 0x1e138
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0xdb81(%rip), %rdi      # 0x1e108
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq $-0x25, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0xdbb3(%rip), %rcx      # 0x1e170
movq (%rcx,%rbx,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x36e8
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: resume
cell resume(cell x) {
	cell	cc;

	if (cdr(x) == NIL)
		return too_few_args(x);
	if (cddr(x) != NIL)
		return too_many_args(x);
	cc = cdar(x);
	Environment = car(cc);
	State_stack = cadr(cc);
	Stack_bottom = caddr(cc);
	Stack = cadddr(cc);
	return cadr(x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rsi
movq 0xdfe1(%rip), %rax      # 0x1e5c0
movq (%rax,%rdi,8), %rcx
cmpq $-0x1, %rcx
je 0x105f9
cmpq $-0x1, (%rax,%rcx,8)
je 0x1060e
leaq 0x647a(%rip), %rdi      # 0x16a71
jmp 0x10600
leaq 0x645f(%rip), %rdi      # 0x16a5f
callq 0x33eb
movq $-0x5, %rax
jmp 0x10669
movq 0xdb5b(%rip), %rcx      # 0x1e170
movq (%rcx,%rsi,8), %rdx
movq (%rax,%rdx,8), %rdx
movq (%rcx,%rdx,8), %rdi
movq %rdi, 0xdae0(%rip)      # 0x1e108
movq (%rax,%rdx,8), %rdi
movq (%rcx,%rdi,8), %rdi
movq %rdi, 0xdb01(%rip)      # 0x1e138
movq (%rax,%rdx,8), %rdi
movq (%rax,%rdi,8), %rdi
movq (%rcx,%rdi,8), %rdi
movq %rdi, 0xdae6(%rip)      # 0x1e130
movq (%rax,%rdx,8), %rdx
movq (%rax,%rdx,8), %rdx
movq (%rax,%rdx,8), %rdx
movq (%rcx,%rdx,8), %rdx
movq %rdx, 0xdac7(%rip)      # 0x1e128
movq (%rax,%rsi,8), %rax
movq (%rcx,%rax,8), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: pp_registerb
cell pp_registerb(cell x) {
	cell	n;

	n = node(car(x), cadr(x));
	Exnstack = node(n, Exnstack);
	return UNIT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xdafa(%rip), %rcx      # 0x1e170
movq (%rcx,%rdi,8), %rax
movq 0xdf3f(%rip), %rdx      # 0x1e5c0
movq (%rdx,%rdi,8), %rdx
movq (%rcx,%rdx,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq 0xdace(%rip), %rsi      # 0x1e168
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xdabd(%rip)      # 0x1e168
movq $-0x6, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: pp_unregisterb
cell pp_unregisterb(cell x) {
	if (Exnstack == NIL)
		return error("internal error: no handlers registered",
			NOEXPR);
	Exnstack = cdr(Exnstack);
	return car(x);
}

// Assembly:
movq 0xdaad(%rip), %rax      # 0x1e168
cmpq $-0x1, %rax
je 0x106df
movq 0xdef8(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rax,8), %rax
movq %rax, 0xda95(%rip)      # 0x1e168
movq 0xda96(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x66e1(%rip), %rdi      # 0x16dcb
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: eqv_p
int eqv_p(cell a, cell b) {
	if (a == b)
		return 1;
	if (char_p(a) && char_p(b) && char_value(a) == char_value(b))
		return 1;
	if (number_p(a) && number_p(b)) {
		if (real_p(a) != real_p(b))
			return 0;
		return real_equal_p(a, b);
	}
	return a == b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
cmpq %rsi, %rdi
je 0x107cf
xorl %eax, %eax
testq %rdi, %rdi
js 0x107cf
movq 0xdebd(%rip), %r8       # 0x1e5e0
testb $0x1, (%r8,%rdi)
je 0x107cf
movq 0xda3b(%rip), %rcx      # 0x1e170
movq (%rcx,%rdi,8), %rdx
cmpq $-0x16, %rdx
setne %r9b
testq %rsi, %rsi
sets %r10b
orb %r9b, %r10b
je 0x1075a
cmpq $-0x1f, %rdx
jne 0x1078a
testq %rsi, %rsi
jns 0x1079e
jmp 0x107cf
testb $0x1, (%r8,%rsi)
je 0x10786
cmpq $-0x16, (%rcx,%rsi,8)
jne 0x10786
movq 0xde51(%rip), %rax      # 0x1e5c0
movq (%rax,%rdi,8), %rdx
movq (%rcx,%rdx,8), %rdx
movq (%rax,%rsi,8), %rsi
movl $0x1, %eax
cmpq (%rcx,%rsi,8), %rdx
je 0x107cf
xorl %eax, %eax
jmp 0x107cf
testq %rsi, %rsi
sets %r9b
cmpq $-0x18, %rdx
setne %r10b
orb %r9b, %r10b
jne 0x107cf
testb $0x1, (%r8,%rsi)
je 0x107cf
movq (%rcx,%rsi,8), %rcx
cmpq $-0x18, %rcx
je 0x107b5
cmpq $-0x1f, %rcx
jne 0x107cf
cmpq $-0x1f, %rdx
sete %dl
cmpq $-0x1f, %rcx
setne %cl
cmpb %cl, %dl
je 0x107cf
xorl %edx, %edx
popq %rbp
jmp 0x60ad
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0xfffffffd, %r14d      # imm = 0xFFFFFFFD
cmpq $-0x1, %rcx
je 0x108ad
movq %rcx, %rbx
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %r15
movq 0xd950(%rip), %rcx      # 0x1e170
movq (%rcx,%rbx,8), %rax
testq %rax, %rax
js 0x1083d
movq 0xddb0(%rip), %rdx      # 0x1e5e0
movb (%rdx,%rax), %dl
andb $0x19, %dl
cmpb $0x8, %dl
je 0x10843
jmp 0x10879
cmpq $-0x1, %rax
jne 0x10879
movq (%rcx,%rax,8), %rsi
testl %r13d, %r13d
je 0x10861
movq %r12, %rdi
callq 0x106ff
movq 0xd915(%rip), %rcx      # 0x1e170
testl %eax, %eax
je 0x10866
jmp 0x108a4
cmpq %r12, %rsi
je 0x108aa
movq 0xdd53(%rip), %rax      # 0x1e5c0
movq (%rax,%rbx,8), %rbx
cmpq $-0x1, %rbx
jne 0x10820
jmp 0x108ad
leaq 0x6572(%rip), %rsi      # 0x16df2
leaq -0x70(%rbp), %r14
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33eb
movl $0xfffffffb, %r14d      # imm = 0xFFFFFFFB
jmp 0x108ad
movl (%rcx,%rbx,8), %r14d
jmp 0x108ad
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_O3/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 0xd830(%rip), %rcx      # 0x1e170
movq (%rcx,%rdx,8), %rdi
movq 0xdc75(%rip), %rdx      # 0x1e5c0
movq (%rdx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rsi
callq *%rax
movq 0xd814(%rip), %rcx      # 0x1e170
movq %rbx, %rdx
testl %eax, %eax
jne 0x1096e
movq 0xdc56(%rip), %rax      # 0x1e5c0
movq (%rax,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rax
movq (%rcx,%rbx,8), %rsi
testq %rsi, %rsi
js 0x1098f
movq 0xdc5e(%rip), %rdx      # 0x1e5e0
testb $0x1, (%rdx,%rsi)
je 0x1098f
cmpq $-0x1f, (%rcx,%rsi,8)
je 0x109b7
movq 0xdc2a(%rip), %rdx      # 0x1e5c0
movq (%rdx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rsi
testq %rsi, %rsi
js 0x109d7
movq 0xdc36(%rip), %rdx      # 0x1e5e0
testb $0x1, (%rdx,%rsi)
je 0x109d7
cmpq $-0x1f, (%rcx,%rsi,8)
jne 0x109d7
testq %rax, %rax
js 0x109d7
testb $0x1, (%rdx,%rax)
je 0x109d7
cmpq $-0x18, (%rcx,%rax,8)
jne 0x109d7
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5b40
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd781(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rbx
testq %rbx, %rbx
js 0x10a1a
movq 0xdbe1(%rip), %rcx      # 0x1e5e0
testb $0x1, (%rcx,%rbx)
je 0x10a1a
cmpq $-0x18, (%rax,%rbx,8)
jne 0x10a1a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xdb9f(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rdx
movq (%rax,%rdx,8), %r15
testq %r15, %r15
jns 0x10b15
movq (%rcx,%rdx,8), %rsi
movq $-0x18, %rdi
movl $0x1, %edx
callq 0x36e8
movq %rax, %r14
movq 0xd6d3(%rip), %rsi      # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xd6c2(%rip)      # 0x1e128
movq %r14, %rdi
callq 0x4dca
movq 0xd6fb(%rip), %rcx      # 0x1e170
movq (%rcx,%rax,8), %r14
movq 0xd6a8(%rip), %rax      # 0x1e128
movq %r14, (%rcx,%rax,8)
incq %r15
jne 0x10a66
movq 0xdb30(%rip), %rax      # 0x1e5c0
movq (%rax,%rbx,8), %rdx
testb $0x1, (%rcx,%rdx,8)
je 0x10ae8
movq (%rax,%rdx,8), %rdx
movq (%rax,%rdx,8), %rdx
cmpq $0x0, (%rcx,%rdx,8)
jne 0x10ab0
cmpq $-0x1, (%rax,%rdx,8)
je 0x10ae8
movl $0x1, %edi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x18, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %r14, %rdi
movq %rax, %rsi
callq 0x472e
movq %rax, %r14
movl $0x1, %edi
callq 0x384f
movq 0xd677(%rip), %rax      # 0x1e170
movq 0xdac0(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rbx,8), %rdx
movl (%rax,%rdx,8), %edi
movq (%rcx,%r14,8), %rdx
xorl %esi, %esi
callq 0x5768
movq %rax, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7074
// File: /workspace/github_c_makefile_star2_O3/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 0xd4df(%rip), %rcx      # 0x1e170
movq (%rcx,%rdi,8), %rax
testq %rax, %rax
js 0x10cae
movq 0xd93f(%rip), %rdx      # 0x1e5e0
testb $0x1, (%rdx,%rax)
je 0x10cae
cmpq $-0x18, (%rcx,%rax,8)
je 0x10cee
movq 0xd90b(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rax,8), %rax
movq (%rcx,%rax,8), %rax
movq (%rcx,%rax,8), %rsi
movq $-0x18, %rdi
movl $0x1, %edx
callq 0x36e8
movq 0xd497(%rip), %rdx      # 0x1e170
movq 0xd8e0(%rip), %rcx      # 0x1e5c0
movq (%rdx,%rbx,8), %rsi
movq (%rcx,%rsi,8), %rsi
testb $0x1, (%rdx,%rsi,8)
jne 0x10cf5
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rcx,%rsi,8), %rsi
movq (%rcx,%rsi,8), %rsi
cmpq $0x0, (%rdx,%rsi,8)
jne 0x10d0b
cmpq $-0x1, (%rcx,%rsi,8)
je 0x10cee
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x43d9
// File: /workspace/github_c_makefile_star2_O3/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 0xd33f(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rsi
leaq 0x5fcf(%rip), %rdi      # 0x16e0b
callq 0x432f
cmpq $0x100, %rax            # imm = 0x100
jb 0x10e6e
movq 0xd320(%rip), %rax      # 0x1e170
movq (%rax,%rbx,8), %rsi
leaq 0x5fb4(%rip), %rdi      # 0x16e0f
callq 0x33eb
movq $-0x5, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x16, %rdi
movq %rax, %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x36e8
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %r12d
cmpq $-0x1, %rsi
je 0x10ef9
movq 0xd6d7(%rip), %rax      # 0x1e5c0
movq %rbx, %rcx
movq (%rax,%rcx,8), %rcx
incl %r12d
cmpq $-0x1, %rcx
jne 0x10eec
movq $-0x21, %rdi
movl %r12d, %esi
callq 0x416e
movq %rax, %r15
movq 0xd6ae(%rip), %rax      # 0x1e5c0
movq (%rax,%r15,8), %rdi
shlq $0x3, %rdi
addq 0xd6c7(%rip), %rdi      # 0x1e5e8
movslq %r12d, %rdx
xorl %esi, %esi
callq 0x30d0
movq 0xd68e(%rip), %rcx      # 0x1e5c0
movq (%rcx,%r15,8), %rax
shlq $0x3, %rax
addq 0xd6a7(%rip), %rax      # 0x1e5e8
cmpq $-0x1, %rbx
je 0x10f84
movq 0xd222(%rip), %rdx      # 0x1e170
movq (%rdx,%rbx,8), %rsi
testq %rsi, %rsi
js 0x10f89
movq 0xd682(%rip), %rdi      # 0x1e5e0
testb $0x1, (%rdi,%rsi)
je 0x10f89
cmpq $-0x16, (%rdx,%rsi,8)
jne 0x10f89
movq (%rcx,%rsi,8), %rcx
movb (%rdx,%rcx,8), %cl
movb %cl, (%rax)
incq %rax
movq 0xd642(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rbx,8), %rbx
jmp 0x10f41
movb $0x0, (%rax)
jmp 0x10fbe
leaq 0x5ea0(%rip), %rsi      # 0x16e30
leaq -0x90(%rbp), %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x31f0
movq 0xd1c5(%rip), %rax      # 0x1e170
movq (%rax,%rbx,8), %rsi
movq %r15, %rdi
callq 0x33eb
movq $-0x5, %r15
movq %r15, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: 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 0xd5e9(%rip), %rcx      # 0x1e5e8
movq 0xd5ba(%rip), %rax      # 0x1e5c0
movq 0xd163(%rip), %rdx      # 0x1e170
movq %rdi, -0x30(%rbp)
movq (%rdx,%rdi,8), %rdx
movq (%rax,%rdx,8), %rdx
movq -0x8(%rcx,%rdx,8), %r12
movq $-0x1, %r14
cmpl $0x2, %r12d
jl 0x110f9
decl %r12d
xorl %r13d, %r13d
movq $-0x1, %rbx
movq 0xd12d(%rip), %rcx      # 0x1e170
movq -0x30(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq 0xd58e(%rip), %rax      # 0x1e5e8
movzbl (%r13,%rax), %edi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x16, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %rdi
movq $-0x1, %rsi
movl $0x8, %edx
callq 0x36e8
movq %rax, %r15
cmpq $-0x1, %r14
je 0x110af
movq 0xd517(%rip), %rax      # 0x1e5c0
movq %r15, (%rax,%rbx,8)
jmp 0x110d1
movq 0xd072(%rip), %rsi      # 0x1e128
movq %r15, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xd061(%rip)      # 0x1e128
movq 0xd4f2(%rip), %rax      # 0x1e5c0
movq %r15, %r14
incq %r13
movq %r15, %rbx
cmpq %r13, %r12
jne 0x1103c
cmpq $-0x1, %r14
je 0x110f2
movl $0x1, %edi
callq 0x384f
jmp 0x110f9
movq $-0x1, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xcdec(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rsi
leaq 0x510d(%rip), %rdi      # 0x1649c
callq 0x432f
movq %rax, %rbx
testl %ebx, %ebx
js 0x11415
leal 0x1(%rbx), %r12d
movq $-0x21, %rdi
movl %r12d, %esi
callq 0x416e
movq %rax, %r15
movq 0xd208(%rip), %rax      # 0x1e5c0
movq (%rax,%r15,8), %rdi
shlq $0x3, %rdi
addq 0xd221(%rip), %rdi      # 0x1e5e8
xorl %esi, %esi
movq %r12, %rdx
callq 0x30d0
movq 0xd1e8(%rip), %rax      # 0x1e5c0
movq (%rax,%r15,8), %r12
shlq $0x3, %r12
addq 0xd201(%rip), %r12      # 0x1e5e8
movq 0xcd82(%rip), %rcx      # 0x1e170
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 0x1142b
leaq 0x5a4b(%rip), %rdi      # 0x16e67
movq %r14, %rsi
callq 0x33eb
movq $-0x5, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xcd28(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rsi
leaq 0x5a30(%rip), %rdi      # 0x16e83
callq 0x432f
movq %rax, %rbx
testl %ebx, %ebx
js 0x114b1
leal (,%rbx,8), %esi
movq $-0x24, %rdi
callq 0x416e
testl %ebx, %ebx
je 0x114cf
movq 0xd143(%rip), %rdx      # 0x1e5c0
movq (%rdx,%rax,8), %rcx
shlq $0x3, %rcx
addq 0xd15c(%rip), %rcx      # 0x1e5e8
movq 0xccdd(%rip), %rsi      # 0x1e170
movq (%rdx,%r14,8), %rdx
movq (%rsi,%rdx,8), %rdx
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
xorl %esi, %esi
movq %rdx, (%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %rbx
jne 0x114a3
jmp 0x114cf
movq 0xccb8(%rip), %rax      # 0x1e170
movq (%rax,%r14,8), %rsi
leaq 0x59c7(%rip), %rdi      # 0x16e8a
callq 0x33eb
movq $-0x5, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xcc84(%rip), %rax      # 0x1e170
movq 0xd0cd(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rdi,8), %rdx
movq (%rcx,%rdx,8), %rsi
movq (%rcx,%rsi,8), %rsi
movq (%rax,%rsi,8), %r12
movq 0xd0de(%rip), %rsi      # 0x1e5e8
movq (%rax,%rdi,8), %rdi
movq (%rcx,%rdi,8), %rcx
movq -0x8(%rsi,%rcx,8), %r13
movq (%rax,%rdx,8), %rsi
leaq 0x5984(%rip), %r15      # 0x16ea6
movq %r15, %rdi
callq 0x432f
movq %rax, %r14
movq 0xcc3c(%rip), %rax      # 0x1e170
movq 0xd085(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rsi
movq %r15, %rdi
callq 0x432f
movq 0xd06a(%rip), %rsi      # 0x1e5c0
movq 0xcc13(%rip), %rdx      # 0x1e170
testl %r14d, %r14d
js 0x115b9
addq $0x7, %r13
shrq $0x3, %r13
cmpl %r13d, %r14d
jg 0x115b9
cmpl %r14d, %eax
jl 0x115b9
cmpl %r13d, %eax
jg 0x115b9
movq (%rdx,%rbx,8), %rcx
cmpl %eax, %r14d
jge 0x11609
movq (%rsi,%rcx,8), %rcx
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
leaq (,%r14,8), %rsi
leaq (%rsi,%rcx,8), %rcx
addq 0xd044(%rip), %rcx      # 0x1e5e8
movq %r12, (%rcx)
addq $0x8, %rcx
incl %r14d
cmpl %eax, %r14d
jl 0x115a4
movq (%rdx,%rbx,8), %rcx
jmp 0x11609
movq (%rsi,%rbx,8), %rax
movq (%rsi,%rax,8), %rax
movq (%rdx,%rax,8), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0xcb96(%rip), %rcx      # 0x1e170
movq 0xcfdf(%rip), %rdx      # 0x1e5c0
movq (%rdx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
leaq 0x58b3(%rip), %rdi      # 0x16ead
movq %rax, %rsi
callq 0x33eb
movq $-0x5, %rcx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x11655
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0xcb50(%rip), %r14      # 0x1e180
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0x11646
callq 0x3090
movq $0x0, (%r14,%rbx,8)
leaq 0xcfb3(%rip), %rax      # 0x1e600
movb $0x0, (%rbx,%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0xcfa4(%rip)      # 0x1e6c0
movq 0xca4d(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rdi
xorl %esi, %esi
callq 0x9124
movl $0x0, 0xcf88(%rip)      # 0x1e6c0
movq $-0x6, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movb $0x1, %cl
leaq 0xc9d6(%rip), %rbx      # 0x1e180
movq %rbx, %rdx
xorl %eax, %eax
cmpq $0x0, (%rdx)
je 0x117d5
incq %rax
addq $0x8, %rdx
cmpq $0x20, %rax
jne 0x117af
testb $0x1, %cl
je 0x117d0
callq 0x3ed9
xorl %ecx, %ecx
jmp 0x117aa
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, %al
leaq 0xc987(%rip), %r15      # 0x1e180
movq %r15, %r13
xorl %r12d, %r12d
cmpq $0x0, (%r13)
je 0x11820
incq %r12
addq $0x8, %r13
cmpq $0x20, %r12
jne 0x117ff
testb $0x1, %al
je 0x1184c
callq 0x3ed9
xorl %eax, %eax
jmp 0x117f9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31c0
movq %rax, %rcx
movq %rax, (%r13)
xorl %eax, %eax
cmpq $0x1, %rcx
sbbl %eax, %eax
orl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1183d
// File: /workspace/github_c_makefile_star2_O3/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
leaq 0xc816(%rip), %rdi      # 0x1e290
movl $0x320, %edx            # imm = 0x320
movl $0xff, %esi
callq 0x30d0
movq 0xc698(%rip), %rsi      # 0x1e128
movq %rbx, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xc687(%rip)      # 0x1e128
movq %rbx, %rdi
callq 0x139d8
movq %rax, %rbx
movl $0x1, %edi
callq 0x384f
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x12cd5
// File: /workspace/github_c_makefile_star2_O3/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 0xcb0b(%rip), %rax      # 0x1e5e8
movq 0xcadc(%rip), %rcx      # 0x1e5c0
movq 0xc685(%rip), %rdx      # 0x1e170
movq (%rdx,%rdi,8), %rsi
movq (%rcx,%rsi,8), %rcx
cmpq $0x3fe, -0x8(%rax,%rcx,8) # imm = 0x3FE
jl 0x11b13
leaq 0x53ba(%rip), %rdi      # 0x16ebf
callq 0x33eb
movq $-0x5, %r14
jmp 0x11b69
movq %rdi, %rbx
leaq (%rax,%rcx,8), %rsi
leaq -0x420(%rbp), %r14
movq %r14, %rdi
callq 0x3060
movq %r14, %rdi
callq 0x11853
movq $-0x6, %r14
testl %eax, %eax
jns 0x11b69
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 0x11853
testl %eax, %eax
js 0x11b7a
movq %r14, %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xc5ef(%rip), %rax      # 0x1e170
movq (%rax,%rbx,8), %rsi
leaq 0x5347(%rip), %rdi      # 0x16ed3
jmp 0x11b05
// File: /workspace/github_c_makefile_star2_O3/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 0xca1f(%rip), %rax      # 0x1e5c0
movq 0xc5c8(%rip), %rcx      # 0x1e170
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rdi
shlq $0x3, %rdi
addq 0xca2d(%rip), %rdi      # 0x1e5e8
leaq 0x5467(%rip), %rsi      # 0x17029
callq 0x117dc
testl %eax, %eax
js 0x11bdf
movl %eax, %edi
movq $-0x17, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x116b8
movq 0xc58a(%rip), %rax      # 0x1e170
movq (%rax,%rbx,8), %rsi
leaq 0x52f9(%rip), %rdi      # 0x16eea
callq 0x33eb
movq $-0x5, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc9ac(%rip), %rax      # 0x1e5c0
movq 0xc555(%rip), %rcx      # 0x1e170
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rdi
shlq $0x3, %rdi
addq 0xc9ba(%rip), %rdi      # 0x1e5e8
leaq 0x54f7(%rip), %rsi      # 0x1712c
callq 0x117dc
testl %eax, %eax
js 0x11c52
movl %eax, %edi
movq $-0x19, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x116b8
movq 0xc517(%rip), %rax      # 0x1e170
movq (%rax,%rbx,8), %rsi
leaq 0x52a4(%rip), %rdi      # 0x16f08
callq 0x33eb
movq $-0x5, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc939(%rip), %rax      # 0x1e5c0
movq 0xc4e2(%rip), %rcx      # 0x1e170
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rdi
shlq $0x3, %rdi
addq 0xc947(%rip), %rdi      # 0x1e5e8
leaq 0x5b8e(%rip), %rsi      # 0x17836
callq 0x117dc
testl %eax, %eax
js 0x11cc5
movl %eax, %edi
movq $-0x19, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x116b8
movq 0xc4a4(%rip), %rax      # 0x1e170
movq (%rax,%rbx,8), %rsi
leaq 0x5250(%rip), %rdi      # 0x16f27
callq 0x33eb
movq $-0x5, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc9a0(%rip), %rax      # 0x1e698
leaq 0xc481(%rip), %r14      # 0x1e180
movq (%r14,%rax,8), %rdi
callq 0x3220
cmpl $-0x1, %eax
je 0x11d4d
movl %eax, %ebx
movslq 0xc982(%rip), %rax      # 0x1e698
movq (%r14,%rax,8), %rsi
movl %ebx, %edi
callq 0x3170
movzbl %bl, %edi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x16, %rdi
movq %rax, %rsi
movl $0x1, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x36e8
movq $-0x4, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc934(%rip), %rax      # 0x1e698
leaq 0xc415(%rip), %rcx      # 0x1e180
movq (%rcx,%rax,8), %rdi
callq 0x3220
cmpl $-0x1, %eax
je 0x11da2
movzbl %al, %edi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x16, %rdi
movq %rax, %rsi
movl $0x1, %edx
popq %rbp
jmp 0x36e8
movq $-0x4, %rax
popq %rbp
retq