LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: real_to_bignum
cell real_to_bignum(cell r) {
	cell	n;
	int	neg;

	if (x_real_exponent(r) >= 0) {
		neg = x_real_negative_p(r);
		n = scale_mantissa(r, 0, 0);
		if (n == NIL)
			return NIL;
		n = new_atom(T_INTEGER, x_real_mantissa(n));
		if (neg)
			n = bignum_negate(n);
		return n;
	}
	return NIL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x1f05d(%rip), %rax     # 0x28180
movq 0x1f4a6(%rip), %rcx     # 0x285d0
movq 0x1f49f(%rip), %rdx     # 0x285d0
movq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $0x0, (%rax,%rcx,8)
jl 0x926e
movq 0x1f031(%rip), %rax     # 0x28180
movq 0x1f47a(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rcx
andq $0x1, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x1d(%rbp)
je 0x91e8
movq 0x1f008(%rip), %rcx     # 0x28180
movq 0x1f451(%rip), %rax     # 0x285d0
movq 0x1f44a(%rip), %rdx     # 0x285d0
movq 0x1f443(%rip), %rsi     # 0x285d0
movq -0x10(%rbp), %rdi
movq (%rsi,%rdi,8), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rax,%rdx,8), %rdx
xorl %eax, %eax
cmpq $0x0, (%rcx,%rdx,8)
movb %al, -0x1e(%rbp)
jne 0x91e0
movq 0x1f420(%rip), %rax     # 0x285d0
movq 0x1f419(%rip), %rcx     # 0x285d0
movq 0x1f412(%rip), %rdx     # 0x285d0
movq 0x1f40b(%rip), %rsi     # 0x285d0
movq -0x10(%rbp), %rdi
movq (%rsi,%rdi,8), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $-0x1, (%rax,%rcx,8)
sete %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
xorb $-0x1, %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x70b0
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x9217
movq $-0x1, -0x8(%rbp)
jmp 0x9276
movq 0x1f3b2(%rip), %rax     # 0x285d0
movq 0x1f3ab(%rip), %rcx     # 0x285d0
movq 0x1f3a4(%rip), %rdx     # 0x285d0
movq -0x18(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rsi
movq $-0x18, %rdi
movl $0x1, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x9264
movq -0x18(%rbp), %rdi
callq 0x4a70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9276
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: real_integer_p
cell real_integer_p(cell x) {
	if (integer_p(x))
		return 1;
	if (real_p(x) && real_to_bignum(x) != NIL)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0x92c6
movq 0x1f356(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x92c6
movq 0x1eecf(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x18, (%rax,%rcx,8)
jne 0x92c6
movq $0x1, -0x8(%rbp)
jmp 0x9317
cmpq $0x0, -0x10(%rbp)
jl 0x930f
movq 0x1f31c(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x930f
movq 0x1ee95(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x1f, (%rax,%rcx,8)
jne 0x930f
movq -0x10(%rbp), %rdi
callq 0x9110
cmpq $-0x1, %rax
je 0x930f
movq $0x1, -0x8(%rbp)
jmp 0x9317
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: find_symbol
cell find_symbol(char *s) {
	cell	y;

	y = Symbols;
	while (y != NIL) {
		if (!strcmp(symbol_name(car(y)), s))
			return car(y);
		y = cdr(y);
	}
	return NIL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x1edcd(%rip), %rax     # 0x28110
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0x93ae
movq 0x1f2a3(%rip), %rdi     # 0x285f8
movq 0x1f274(%rip), %rax     # 0x285d0
movq 0x1ee1d(%rip), %rcx     # 0x28180
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3120
cmpl $0x0, %eax
jne 0x9399
movq 0x1edf5(%rip), %rax     # 0x28180
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x93b6
movq 0x1f230(%rip), %rax     # 0x285d0
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0x9347
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: make_ident
cell make_ident(char *s, int k) {
	cell	n;

	n = new_vec(T_SYMBOL, k+1);
	strcpy(symbol_name(n), s);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %esi
addl $0x1, %esi
movq $-0x22, %rdi
callq 0x4790
movq %rax, -0x18(%rbp)
movq 0x1f20c(%rip), %rdi     # 0x285f8
movq 0x1f1dd(%rip), %rax     # 0x285d0
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x3060
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: symbol_ref
cell symbol_ref(char *s) {
	cell	y, new;

	y = find_symbol(s);
	if (y != NIL)
		return y;
	new = make_ident(s, (int) strlen(s));
	Symbols = node(new, Symbols);
	return car(Symbols);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9330
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0x944a
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9499
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30a0
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x93c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq 0x1ec9b(%rip), %rsi     # 0x28110
xorl %edx, %edx
callq 0x3780
movq %rax, 0x1ec8d(%rip)     # 0x28110
movq 0x1ecf6(%rip), %rax     # 0x28180
movq 0x1ec7f(%rip), %rcx     # 0x28110
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: string_to_bignum
cell string_to_bignum(char *s) {
	cell	n, v;
	int	k, j, sign;

	sign = 1;
	if (s[0] == '-') {
		s++;
		sign = -1;
	}
	else if (s[0] == '+') {
		s++;
	}
	/* plan9's atol() interprets leading 0 as octal! */
	while (s[0] == '0' && s[1])
		s++;
	k = (int) strlen(s);
	n = NIL;
	while (k) {
		j = k <= DIGITS_PER_WORD? k: DIGITS_PER_WORD;
		v = atol(&s[k-j]);
		s[k-j] = 0;
		k -= j;
		if (k == 0)
			v *= sign;
		n = new_atom(v, n);
	}
	return new_atom(T_INTEGER, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x9d14
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
jmp 0x9d2e
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x9d2c
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x9d2e
jmp 0x9d30
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x25(%rbp)
jne 0x9d52
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x9d5b
jmp 0x9d69
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x9d30
movq -0x8(%rbp), %rdi
callq 0x30a0
movl %eax, -0x1c(%rbp)
movq $-0x1, -0x10(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x9e07
cmpl $0x9, -0x1c(%rbp)
jg 0x9d95
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x9d9f
movl $0x9, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9d9f
movl -0x2c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %eax
subl -0x20(%rbp), %eax
cltq
addq %rax, %rdi
callq 0x31b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl -0x20(%rbp), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x9dec
movslq -0x24(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
jmp 0x9d7d
movq -0x10(%rbp), %rsi
movq $-0x18, %rdi
movl $0x1, %edx
callq 0x3780
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: make_string
cell make_string(char *s, int k) {
	cell	n;

	n = new_vec(T_STRING, k+1);
	strncpy(string(n), s, k+1);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %esi
addl $0x1, %esi
movq $-0x21, %rdi
callq 0x4790
movq %rax, -0x18(%rbp)
movq 0x1e46c(%rip), %rdi     # 0x285f8
movq 0x1e43d(%rip), %rax     # 0x285d0
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x3050
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: string_to_number
cell string_to_number(char *s) {
	int	i;

	for (i=0; s[i]; i++) {
		if (s[i] == '.' || is_exp_char(s[i]))
			return string_to_real(s);
	}
	return string_to_bignum(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xa21f
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
je 0xa203
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x65, %eax
jne 0xa212
movq -0x10(%rbp), %rdi
callq 0x9e30
movq %rax, -0x8(%rbp)
jmp 0xa22c
jmp 0xa214
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa1d3
movq -0x10(%rbp), %rdi
callq 0x9ce0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: strcmp_ci
int strcmp_ci(char *s1, char *s2) {
	int	c1, c2;

	while (1) {
		c1 = tolower((int) *s1++);
		c2 = tolower((int) *s2++);
		if (!c1 || !c2 || c1 != c2)
			break;
	}
	return c1<c2? -1: c1>c2? 1: 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %edi
callq 0x3150
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %edi
callq 0x3150
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xa2e8
cmpl $0x0, -0x18(%rbp)
je 0xa2e8
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
je 0xa2ea
jmp 0xa2ec
jmp 0xa2a0
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xa2fe
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x1c(%rbp)
jmp 0xa313
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovgl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: memcmp_ci
int memcmp_ci(char *s1, char *s2, int k) {
	int	c1 = 0, c2 = 0;

	while (k--) {
		c1 = tolower((int) *s1++);
		c2 = tolower((int) *s2++);
		if (c1 != c2)
			break;
	}
	return c1<c2? -1: c1>c2? 1: 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0xa391
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %edi
callq 0x3150
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %edi
callq 0x3150
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0xa38f
jmp 0xa391
jmp 0xa341
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xa3a3
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x20(%rbp)
jmp 0xa3b8
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovgl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: read_string
cell read_string(void) {
	char	s[TOKEN_LENGTH+1];
	cell	n;
	int	c, i, q;
	int	inv;

	i = 0;
	q = 0;
	c = read_c();
	inv = 0;
	while (q || c != '"') {
		if (c == EOF)
			return error("missing '\"' in string literal", NOEXPR);
		if (Error_flag)
			break;
		if (i >= TOKEN_LENGTH-2) {
			return error("string literal too long", NOEXPR);
			i--;
		}
		if (q && c != '"' && c != '\\') {
			s[i++] = '\\';
			inv = 1;
		}
		s[i] = c;
		q = !q && c == '\\';
		if (!q)
			i++;
		c = read_c();
	}
	s[i] = 0;
	n = make_string(s, i);
	if (inv)
		error("invalid escape sequence in string", n);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movl $0x0, -0x420(%rbp)
movl $0x0, -0x424(%rbp)
movslq 0x1e2b2(%rip), %rcx     # 0x286a8
leaq 0x1dd93(%rip), %rax     # 0x28190
movq (%rax,%rcx,8), %rdi
callq 0x3230
movl %eax, -0x41c(%rbp)
movl $0x0, -0x428(%rbp)
movb $0x1, %al
cmpl $0x0, -0x424(%rbp)
movb %al, -0x429(%rbp)
jne 0xa437
cmpl $0x22, -0x41c(%rbp)
setne %al
movb %al, -0x429(%rbp)
movb -0x429(%rbp), %al
testb $0x1, %al
jne 0xa446
jmp 0xa565
cmpl $-0x1, -0x41c(%rbp)
jne 0xa46b
leaq 0x160bd(%rip), %rdi     # 0x20513
movq $-0x8, %rsi
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0xa5b4
movl 0x1e153(%rip), %eax     # 0x285c4
cmpl $0x0, %eax
je 0xa47b
jmp 0xa565
cmpl $0x3fe, -0x420(%rbp)    # imm = 0x3FE
jl 0xa4a3
leaq 0x160a3(%rip), %rdi     # 0x20531
movq $-0x8, %rsi
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0xa5b4
cmpl $0x0, -0x424(%rbp)
je 0xa4e3
cmpl $0x22, -0x41c(%rbp)
je 0xa4e3
cmpl $0x5c, -0x41c(%rbp)
je 0xa4e3
movl -0x420(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x420(%rbp)
cltq
movb $0x5c, -0x410(%rbp,%rax)
movl $0x1, -0x428(%rbp)
movl -0x41c(%rbp), %eax
movb %al, %cl
movslq -0x420(%rbp), %rax
movb %cl, -0x410(%rbp,%rax)
xorl %eax, %eax
cmpl $0x0, -0x424(%rbp)
movb %al, -0x42a(%rbp)
jne 0xa51a
cmpl $0x5c, -0x41c(%rbp)
sete %al
movb %al, -0x42a(%rbp)
movb -0x42a(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x424(%rbp)
cmpl $0x0, -0x424(%rbp)
jne 0xa543
movl -0x420(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x420(%rbp)
movslq 0x1e15e(%rip), %rcx     # 0x286a8
leaq 0x1dc3f(%rip), %rax     # 0x28190
movq (%rax,%rcx,8), %rdi
callq 0x3230
movl %eax, -0x41c(%rbp)
jmp 0xa416
movslq -0x420(%rbp), %rax
movb $0x0, -0x410(%rbp,%rax)
leaq -0x410(%rbp), %rdi
movl -0x420(%rbp), %esi
callq 0xa160
movq %rax, -0x418(%rbp)
cmpl $0x0, -0x428(%rbp)
je 0xa5a9
movq -0x418(%rbp), %rsi
leaq 0x15fa5(%rip), %rdi     # 0x20549
callq 0x34b0
movq -0x418(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: read_char
cell read_char(void) {
	cell	n;
	char	*s;
	int	c;

	if (read_c() != '"')
		return error("missing `\"' in char literal", NOEXPR);
	n = read_string();
	s = string(n);
	if (!strcmp(s, "backslash"))
		c = '\\';
	else if (!strcmp(s, "newline"))
		c = '\n';
	else if (!strcmp(s, "quote"))
		c = '"';
	else if (!strcmp(s, "space"))
		c = ' ';
	else if (!strcmp(s, "tab"))
		c = '\t';
	else if (strlen(s) != 1)
		return error("malformed string literal", n);
	else
		c = *s;
	return make_char(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movslq 0x1e0c9(%rip), %rcx     # 0x286a8
leaq 0x1dbaa(%rip), %rax     # 0x28190
movq (%rax,%rcx,8), %rdi
callq 0x3230
cmpl $0x22, %eax
je 0xa610
leaq 0x15f70(%rip), %rdi     # 0x2056b
movq $-0x8, %rsi
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0xa71b
callq 0xa3d0
movq %rax, -0x10(%rbp)
movq 0x1dfd8(%rip), %rax     # 0x285f8
movq 0x1dfa9(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x15f42(%rip), %rsi     # 0x20587
callq 0x3120
cmpl $0x0, %eax
jne 0xa65b
movl $0x5c, -0x1c(%rbp)
jmp 0xa70f
movq -0x18(%rbp), %rdi
leaq 0x15f2b(%rip), %rsi     # 0x20591
callq 0x3120
cmpl $0x0, %eax
jne 0xa67c
movl $0xa, -0x1c(%rbp)
jmp 0xa70d
movq -0x18(%rbp), %rdi
leaq 0x16f0d(%rip), %rsi     # 0x21594
callq 0x3120
cmpl $0x0, %eax
jne 0xa69a
movl $0x22, -0x1c(%rbp)
jmp 0xa70b
movq -0x18(%rbp), %rdi
leaq 0x16a74(%rip), %rsi     # 0x21119
callq 0x3120
cmpl $0x0, %eax
jne 0xa6b8
movl $0x20, -0x1c(%rbp)
jmp 0xa709
movq -0x18(%rbp), %rdi
leaq 0x15ed6(%rip), %rsi     # 0x20599
callq 0x3120
cmpl $0x0, %eax
jne 0xa6d6
movl $0x9, -0x1c(%rbp)
jmp 0xa707
movq -0x18(%rbp), %rdi
callq 0x30a0
cmpq $0x1, %rax
je 0xa6fb
movq -0x10(%rbp), %rsi
leaq 0x15ead(%rip), %rdi     # 0x2059d
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0xa71b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0xa707
jmp 0xa709
jmp 0xa70b
jmp 0xa70d
jmp 0xa70f
movl -0x1c(%rbp), %edi
callq 0xa240
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: funny_char
cell funny_char(char *msg, int c) {
	char	buf[128];

	if (isprint(c))
		return error(msg, make_char(c));
	sprintf(buf, "%s, code", msg);
	return error(buf, make_integer(c));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
callq 0x3240
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0xa784
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl -0x14(%rbp), %edi
callq 0xa240
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0xa7c7
leaq -0xa0(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x15e20(%rip), %rsi     # 0x205b6
movb $0x0, %al
callq 0x3200
leaq -0xa0(%rbp), %rax
movq %rax, -0xb0(%rbp)
movslq -0x14(%rbp), %rdi
callq 0x3740
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
callq 0x34b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: read_number
cell read_number(int c) {
	char	s[TOKEN_LENGTH];
	int	i;

	i = 0;
	while (isdigit(c) || c == '.' || is_exp_char(c) || c == '~') {
		if (i >= TOKEN_LENGTH-2) {
			return error("numeric literal too long", NOEXPR);
			i--;
		}
		s[i] = c;
		i++;
		c = read_c();
	}
	s[i] = 0;
	reject(c);
	return string_to_number(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movl %edi, -0xc(%rbp)
movl $0x0, -0x414(%rbp)
callq 0x3240
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x800, %ecx            # imm = 0x800
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x415(%rbp)
jne 0xa844
movb $0x1, %al
cmpl $0x2e, -0xc(%rbp)
movb %al, -0x415(%rbp)
je 0xa844
movb $0x1, %al
cmpl $0x65, -0xc(%rbp)
movb %al, -0x415(%rbp)
je 0xa844
cmpl $0x7e, -0xc(%rbp)
sete %al
movb %al, -0x415(%rbp)
movb -0x415(%rbp), %al
testb $0x1, %al
jne 0xa850
jmp 0xa8b6
cmpl $0x3fe, -0x414(%rbp)    # imm = 0x3FE
jl 0xa875
leaq 0x15d5c(%rip), %rdi     # 0x205bf
movq $-0x8, %rsi
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0xa8ef
movl -0xc(%rbp), %eax
movb %al, %cl
movslq -0x414(%rbp), %rax
movb %cl, -0x410(%rbp,%rax)
movl -0x414(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x414(%rbp)
movslq 0x1de0a(%rip), %rcx     # 0x286a8
leaq 0x1d8eb(%rip), %rax     # 0x28190
movq (%rax,%rcx,8), %rdi
callq 0x3230
movl %eax, -0xc(%rbp)
jmp 0xa7f8
movslq -0x414(%rbp), %rax
movb $0x0, -0x410(%rbp,%rax)
movl -0xc(%rbp), %edi
movslq 0x1ddd9(%rip), %rcx     # 0x286a8
leaq 0x1d8ba(%rip), %rax     # 0x28190
movq (%rax,%rcx,8), %rsi
callq 0x3180
leaq -0x410(%rbp), %rdi
callq 0xa1c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: read_ident
cell read_ident(int c, int scm) {
	char	s[TOKEN_LENGTH];
	int	i;

	i = 0;
	while (is_ident(c) || isdigit(c) || (scm && c == '!')) {
		if (i >= TOKEN_LENGTH-2) {
			return error("identifier too long", NOEXPR);
			i--;
		}
		s[i] = c;
		i++;
		c = read_c();
	}
	s[i] = 0;
	reject(c);
	if (!strcmp(s, "true"))
		return TRUE;
	else if (!strcmp(s, "false"))
		return FALSE;
	return symbol_ref(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl $0x0, -0x414(%rbp)
callq 0x3240
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x400, %ecx            # imm = 0x400
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x415(%rbp)
jne 0xa9b2
movb $0x1, %al
cmpl $0x5f, -0xc(%rbp)
movb %al, -0x415(%rbp)
je 0xa9b2
movb $0x1, %al
cmpl $0x3a, -0xc(%rbp)
movb %al, -0x415(%rbp)
je 0xa9b2
movb $0x1, %al
cmpl $0x27, -0xc(%rbp)
movb %al, -0x415(%rbp)
je 0xa9b2
callq 0x3240
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x800, %ecx            # imm = 0x800
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x415(%rbp)
jne 0xa9b2
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x416(%rbp)
je 0xa9a6
cmpl $0x21, -0xc(%rbp)
sete %al
movb %al, -0x416(%rbp)
movb -0x416(%rbp), %al
movb %al, -0x415(%rbp)
movb -0x415(%rbp), %al
testb $0x1, %al
jne 0xa9be
jmp 0xaa27
cmpl $0x3fe, -0x414(%rbp)    # imm = 0x3FE
jl 0xa9e6
leaq 0x15c07(%rip), %rdi     # 0x205d8
movq $-0x8, %rsi
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0xaaa6
movl -0xc(%rbp), %eax
movb %al, %cl
movslq -0x414(%rbp), %rax
movb %cl, -0x410(%rbp,%rax)
movl -0x414(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x414(%rbp)
movslq 0x1dc99(%rip), %rcx     # 0x286a8
leaq 0x1d77a(%rip), %rax     # 0x28190
movq (%rax,%rcx,8), %rdi
callq 0x3230
movl %eax, -0xc(%rbp)
jmp 0xa91b
movslq -0x414(%rbp), %rax
movb $0x0, -0x410(%rbp,%rax)
movl -0xc(%rbp), %edi
movslq 0x1dc68(%rip), %rcx     # 0x286a8
leaq 0x1d749(%rip), %rax     # 0x28190
movq (%rax,%rcx,8), %rsi
callq 0x3180
leaq -0x410(%rbp), %rdi
leaq 0x15b8e(%rip), %rsi     # 0x205ec
callq 0x3120
cmpl $0x0, %eax
jne 0xaa72
movq $-0x2, -0x8(%rbp)
jmp 0xaaa6
leaq -0x410(%rbp), %rdi
leaq 0x15b71(%rip), %rsi     # 0x205f1
callq 0x3120
cmpl $0x0, %eax
jne 0xaa94
movq $-0x3, -0x8(%rbp)
jmp 0xaaa6
jmp 0xaa96
leaq -0x410(%rbp), %rdi
callq 0x9420
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: read_opsym
cell read_opsym(int c) {
	char	s[TOKEN_LENGTH];
	int	i;

	i = 0;
	while (is_opsym(c)) {
		if (i >= TOKEN_LENGTH-2) {
			return error("operator symbol too long", NOEXPR);
			i--;
		}
		s[i] = c;
		i++;
		c = read_c();
	}
	s[i] = 0;
	reject(c);
	return symbol_ref(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movl %edi, -0xc(%rbp)
movl $0x0, -0x414(%rbp)
movl -0xc(%rbp), %esi
leaq 0x15b15(%rip), %rdi     # 0x205f7
callq 0x30c0
cmpq $0x0, %rax
je 0xab50
cmpl $0x3fe, -0x414(%rbp)    # imm = 0x3FE
jl 0xab12
leaq 0x15b07(%rip), %rdi     # 0x20607
movq $-0x8, %rsi
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0xab89
movl -0xc(%rbp), %eax
movb %al, %cl
movslq -0x414(%rbp), %rax
movb %cl, -0x410(%rbp,%rax)
movl -0x414(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x414(%rbp)
movslq 0x1db6d(%rip), %rcx     # 0x286a8
leaq 0x1d64e(%rip), %rax     # 0x28190
movq (%rax,%rcx,8), %rdi
callq 0x3230
movl %eax, -0xc(%rbp)
jmp 0xaad8
movslq -0x414(%rbp), %rax
movb $0x0, -0x410(%rbp,%rax)
movl -0xc(%rbp), %edi
movslq 0x1db3f(%rip), %rcx     # 0x286a8
leaq 0x1d620(%rip), %rax     # 0x28190
movq (%rax,%rcx,8), %rsi
callq 0x3180
leaq -0x410(%rbp), %rdi
callq 0x9420
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: xread
cell xread(void) {
	if (Streams[Instream] == NULL)
		return error("instream is not open", NOEXPR);
	Level = 0;
	return read_form();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movslq 0x1daa9(%rip), %rcx     # 0x286a8
leaq 0x1d58a(%rip), %rax     # 0x28190
cmpq $0x0, (%rax,%rcx,8)
jne 0xac26
leaq 0x15a75(%rip), %rdi     # 0x20689
movq $-0x8, %rsi
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0xac39
movl $0x0, 0x1da60(%rip)     # 0x28690
callq 0x9830
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: ntoa
char *ntoa(char *b, cell x, int w) {
	char	buf[40];
	int	i = 0, neg = 0;
	char	*p = &buf[sizeof(buf)-1];

	if (x < 0) {
		x = -x;
		neg = 1;
	}
	*p = 0;
	while (x || i == 0) {
		i++;
		if (i >= sizeof(buf)-1)
			fatal("ntoa: number too big");
		p--;
		*p = x % 10 + '0';
		x = x / 10;
	}
	while (i < (w-neg) && i < sizeof(buf)-1) {
		i++;
		p--;
		*p = '0';
	}
	if (neg) {
		if (i >= sizeof(buf)-1)
			fatal("ntoa: number too big");
		p--;
		*p = '-';
	}
	strcpy(b, p);
	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
leaq -0x40(%rbp), %rax
addq $0x27, %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0xac95
xorl %eax, %eax
subq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x1, -0x48(%rbp)
movq -0x50(%rbp), %rax
movb $0x0, (%rax)
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x51(%rbp)
jne 0xacb2
cmpl $0x0, -0x44(%rbp)
sete %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0xacbb
jmp 0xad14
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
movslq -0x44(%rbp), %rax
cmpq $0x27, %rax
jb 0xacda
leaq 0x159c9(%rip), %rdi     # 0x2069e
callq 0x3c70
movq -0x50(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
addq $0x30, %rdx
movb %dl, %cl
movq -0x50(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x10(%rbp)
jmp 0xac9c
jmp 0xad16
movl -0x44(%rbp), %ecx
movl -0x14(%rbp), %edx
subl -0x48(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x52(%rbp)
jge 0xad36
movslq -0x44(%rbp), %rax
cmpq $0x27, %rax
setb %al
movb %al, -0x52(%rbp)
movb -0x52(%rbp), %al
testb $0x1, %al
jne 0xad3f
jmp 0xad5d
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
movq -0x50(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movb $0x30, (%rax)
jmp 0xad16
cmpl $0x0, -0x48(%rbp)
je 0xad8c
movslq -0x44(%rbp), %rax
cmpq $0x27, %rax
jb 0xad79
leaq 0x1592a(%rip), %rdi     # 0x2069e
callq 0x3c70
movq -0x50(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movb $0x2d, (%rax)
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x3060
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: print_expanded_real
void print_expanded_real(cell m, cell e, int n_digits, int neg) {
	char	buf[DIGITS_PER_WORD+3];
	int	k, first;
	int	dp_offset, old_offset;

	dp_offset = e+n_digits;
	if (neg)
		pr("-");
	if (dp_offset <= 0)
		pr("0");
	if (dp_offset < 0)
		pr(".");
	while (dp_offset < 0) {
		pr("0");
		dp_offset++;
	}
	dp_offset = e+n_digits;
	first = 1;
	while (m != NIL) {
		ntoa(buf, labs(car(m)), first? 0: DIGITS_PER_WORD);
		k = strlen(buf);
		old_offset = dp_offset;
		dp_offset -= k;
		if (dp_offset < 0 && old_offset >= 0) {
			memmove(&buf[k+dp_offset+1], &buf[k+dp_offset],
				-dp_offset+1);
			buf[k+dp_offset] = '.';
		}
		pr(buf);
		m = cdr(m);
		first = 0;
	}
	if (dp_offset >= 0) {
		while (dp_offset > 0) {
			pr("0");
			dp_offset--;
		}
		pr(".0");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xade6
leaq 0x1549b(%rip), %rdi     # 0x2027c
callq 0x3ab0
cmpl $0x0, -0x30(%rbp)
jg 0xadf8
leaq 0x158c1(%rip), %rdi     # 0x206b4
callq 0x3ab0
cmpl $0x0, -0x30(%rbp)
jge 0xae0a
leaq 0x15485(%rip), %rdi     # 0x2028a
callq 0x3ab0
jmp 0xae0c
cmpl $0x0, -0x30(%rbp)
jge 0xae29
leaq 0x1589b(%rip), %rdi     # 0x206b4
callq 0x3ab0
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xae0c
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movl %eax, -0x30(%rbp)
movl $0x1, -0x2c(%rbp)
cmpq $-0x1, -0x8(%rbp)
je 0xaf0a
leaq -0x24(%rbp), %rdi
movq 0x1d32c(%rip), %rax     # 0x28180
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq %rsi, %rax
negq %rax
cmovnsq %rax, %rsi
movl -0x2c(%rbp), %ecx
movl $0x9, %edx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edx
callq 0xac50
leaq -0x24(%rbp), %rdi
callq 0x30a0
movl %eax, -0x28(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x28(%rbp), %ecx
movl -0x30(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jge 0xaee2
cmpl $0x0, -0x34(%rbp)
jl 0xaee2
movl -0x28(%rbp), %eax
addl -0x30(%rbp), %eax
addl $0x1, %eax
cltq
leaq -0x24(%rbp), %rdi
addq %rax, %rdi
movl -0x28(%rbp), %eax
addl -0x30(%rbp), %eax
cltq
leaq -0x24(%rbp), %rsi
addq %rax, %rsi
xorl %eax, %eax
subl -0x30(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x31a0
movl -0x28(%rbp), %eax
addl -0x30(%rbp), %eax
cltq
movb $0x2e, -0x24(%rbp,%rax)
leaq -0x24(%rbp), %rdi
callq 0x3ab0
movq 0x1d6de(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x2c(%rbp)
jmp 0xae3e
cmpl $0x0, -0x30(%rbp)
jl 0xaf3b
jmp 0xaf12
cmpl $0x0, -0x30(%rbp)
jle 0xaf2f
leaq 0x15795(%rip), %rdi     # 0x206b4
callq 0x3ab0
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xaf12
leaq 0x1577d(%rip), %rdi     # 0x206b3
callq 0x3ab0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: round_last
cell round_last(cell m, cell e, int n_digits, int flags) {
	cell	one;
	int	r;

	m = bignum_shift_right(new_atom(T_INTEGER, m));
	r = integer_value("print", cdr(m));
	m = car(m);
	if (r >= 5) {
		save(m);
		one = make_integer(1);
		m = bignum_add(m, one);
		unsave(1);
	}
	m = cdr(m);
	n_digits--;
	e++;
	m = make_real(flags, e, m);
	return real_normalize(m, "print");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq $-0x18, %rdi
movl $0x1, %edx
callq 0x3780
movq %rax, %rdi
callq 0x5760
movq %rax, -0x8(%rbp)
movq 0x1d642(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x15719(%rip), %rdi     # 0x206b6
callq 0x4960
movl %eax, -0x24(%rbp)
movq 0x1d1d4(%rip), %rax     # 0x28180
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
cmpl $0x5, -0x24(%rbp)
jl 0xb000
movq -0x8(%rbp), %rdi
movq 0x1d16f(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x1d161(%rip)     # 0x28138
movl $0x1, %edi
callq 0x3740
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4e50
movq %rax, -0x8(%rbp)
movl $0x1, %edi
callq 0x3950
movq 0x1d5c9(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x6350
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1566f(%rip), %rsi     # 0x206b6
callq 0x6460
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: print_integer
int print_integer(cell n) {
	int	first;
	char	buf[DIGITS_PER_WORD+2];

	if (!integer_p(n))
		return 0;
	n = cdr(n);
	first = 1;
	while (n != NIL) {
		pr(ntoa(buf, car(n), first? 0: DIGITS_PER_WORD));
		n = cdr(n);
		first = 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0xb34c
movq 0x1d2c6(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xb34c
movq 0x1ce3f(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x18, (%rax,%rcx,8)
je 0xb355
movl $0x0, -0x4(%rbp)
jmp 0xb3c9
movq 0x1d274(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
cmpq $-0x1, -0x10(%rbp)
je 0xb3c2
leaq -0x1f(%rbp), %rdi
movq 0x1cdff(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl -0x14(%rbp), %ecx
movl $0x9, %edx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edx
callq 0xac50
movq %rax, %rdi
callq 0x3ab0
movq 0x1d223(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
jmp 0xb36f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: print_quoted
int print_quoted(cell n) {
	if (	car(n) == S_quote &&
		cdr(n) != NIL &&
		cddr(n) == NIL
	) {
		pr("'");
		print_form(cadr(n));
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq 0x1cd8d(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq 0x1d2b6(%rip), %rax     # 0x286b8
jne 0xb467
movq 0x1d1c5(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
cmpq $-0x1, (%rax,%rcx,8)
je 0xb467
movq 0x1d1b3(%rip), %rax     # 0x285d0
movq 0x1d1ac(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $-0x1, (%rax,%rcx,8)
jne 0xb467
leaq 0x15228(%rip), %rdi     # 0x20662
callq 0x3ab0
movq 0x1cd3a(%rip), %rax     # 0x28180
movq 0x1d183(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3b70
movl $0x1, -0x4(%rbp)
jmp 0xb46e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: print_fun
int print_fun(cell n) {
	cell	p, c;

	if (procedure_p(n)) {
		pr("fn");
		n = caddr(n);
		for (p = n; p != NIL; p = cdr(p)) {
			pr(p==n? " ": " | ");
			c = caar(p);
			if (tuple_p(c) && car(c) == GUARD) {
				c = cadr(c);
				pr("!");
			}
			print_form(c);
		}
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0xb606
movq 0x1d152(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xb606
movq 0x1ccc7(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x1e, (%rax,%rcx,8)
jne 0xb606
leaq 0x151ed(%rip), %rdi     # 0x206bc
callq 0x3ab0
movq 0x1cca5(%rip), %rax     # 0x28180
movq 0x1d0ee(%rip), %rcx     # 0x285d0
movq 0x1d0e7(%rip), %rdx     # 0x285d0
movq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0xb5fd
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdx
leaq 0x151a0(%rip), %rdi     # 0x206bf
leaq 0x163eb(%rip), %rax     # 0x21911
cmpq %rdx, %rcx
cmoveq %rax, %rdi
callq 0x3ab0
movq 0x1cc47(%rip), %rax     # 0x28180
movq 0x1cc40(%rip), %rcx     # 0x28180
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jl 0xb5dc
movq 0x1d08e(%rip), %rax     # 0x285f0
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xb5dc
movq 0x1d077(%rip), %rax     # 0x285f0
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0xb5dc
movq 0x1d060(%rip), %rax     # 0x285f0
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0xb5dc
movq 0x1cbd9(%rip), %rax     # 0x28180
movq -0x20(%rbp), %rcx
cmpq $-0x9, (%rax,%rcx,8)
jne 0xb5dc
movq 0x1cbc7(%rip), %rax     # 0x28180
movq 0x1d010(%rip), %rcx     # 0x285d0
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
leaq 0x155e7(%rip), %rdi     # 0x20bbe
callq 0x3ab0
movq -0x20(%rbp), %rdi
callq 0x3b70
movq 0x1cfe4(%rip), %rax     # 0x285d0
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0xb505
movl $0x1, -0x4(%rbp)
jmp 0xb60d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: print_continuation
int print_continuation(cell n) {
	if (continuation_p(n)) {
		pr("<continuation>");
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0xb671
movq 0x1cfb6(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xb671
movq 0x1cb2f(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x25, (%rax,%rcx,8)
jne 0xb671
leaq 0x15060(%rip), %rdi     # 0x206c3
callq 0x3ab0
movl $0x1, -0x4(%rbp)
jmp 0xb678
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: print_char
int print_char(cell n) {
	char	b[1];
	int	c;

	if (!char_p(n))
		return 0;
	if (!Displaying)
		pr("#\"");
	c = cadr(n);
	if (!Displaying && c == ' ')
		pr("space");
	else if (!Displaying && c == '\n')
		pr("newline");
	else {
		b[0] = c;
		pr_raw(b, 1);
	}
	if (!Displaying)
		pr("\"");
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0xb6cc
movq 0x1cf46(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xb6cc
movq 0x1cabf(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x16, (%rax,%rcx,8)
je 0xb6d8
movl $0x0, -0x4(%rbp)
jmp 0xb776
cmpl $0x0, 0x1cff1(%rip)     # 0x286d0
jne 0xb6ed
leaq 0x14fea(%rip), %rdi     # 0x206d2
callq 0x3ab0
movq 0x1ca8c(%rip), %rax     # 0x28180
movq 0x1ced5(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x18(%rbp)
cmpl $0x0, 0x1cfbf(%rip)     # 0x286d0
jne 0xb727
cmpl $0x20, -0x18(%rbp)
jne 0xb727
leaq 0x159f9(%rip), %rdi     # 0x21119
callq 0x3ab0
jmp 0xb75a
cmpl $0x0, 0x1cfa2(%rip)     # 0x286d0
jne 0xb744
cmpl $0xa, -0x18(%rbp)
jne 0xb744
leaq 0x14e54(%rip), %rdi     # 0x20591
callq 0x3ab0
jmp 0xb758
movl -0x18(%rbp), %eax
movb %al, -0x11(%rbp)
leaq -0x11(%rbp), %rdi
movl $0x1, %esi
callq 0x39f0
jmp 0xb75a
cmpl $0x0, 0x1cf6f(%rip)     # 0x286d0
jne 0xb76f
leaq 0x14f69(%rip), %rdi     # 0x206d3
callq 0x3ab0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: print_string
int print_string(cell n) {
	char	b[1];
	int	k;
	char	*s;

	if (!string_p(n))
		return 0;
	if (!Displaying)
		pr("\"");
	s = string(n);
	k = string_len(n)-1;
	while (k) {
		b[0] = *s++;
		if (!Displaying && (b[0] == '"' || b[0] == '\\'))
			pr("\\");
		pr_raw(b, 1);
		k--;
	}
	if (!Displaying)
		pr("\"");
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0xb7bc
movq 0x1ce56(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xb7bc
movq 0x1c9cf(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x21, (%rax,%rcx,8)
je 0xb7c8
movl $0x0, -0x4(%rbp)
jmp 0xb899
cmpl $0x0, 0x1cf01(%rip)     # 0x286d0
jne 0xb7dd
leaq 0x14efb(%rip), %rdi     # 0x206d3
callq 0x3ab0
movq 0x1ce14(%rip), %rax     # 0x285f8
movq 0x1cde5(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq 0x1cdf3(%rip), %rax     # 0x285f8
movq 0x1cdc4(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
subq $0x1, %rax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xb87d
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %al
movb %al, -0x11(%rbp)
cmpl $0x0, 0x1ce8c(%rip)     # 0x286d0
jne 0xb864
movsbl -0x11(%rbp), %eax
cmpl $0x22, %eax
je 0xb858
movsbl -0x11(%rbp), %eax
cmpl $0x5c, %eax
jne 0xb864
leaq 0x14e76(%rip), %rdi     # 0x206d5
callq 0x3ab0
leaq -0x11(%rbp), %rdi
movl $0x1, %esi
callq 0x39f0
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb823
cmpl $0x0, 0x1ce4c(%rip)     # 0x286d0
jne 0xb892
leaq 0x14e46(%rip), %rdi     # 0x206d3
callq 0x3ab0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: print_symbol
int print_symbol(cell n) {
	char	b[2];
	int	k;
	char	*s;

	if (!symbol_p(n))
		return 0;
	s = symbol_name(n);
	k = symbol_len(n)-1;
	b[1] = 0;
	while (k) {
		b[0] = *s++;
		pr(b);
		k--;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0xb8ec
movq 0x1cd26(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xb8ec
movq 0x1c89f(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x22, (%rax,%rcx,8)
je 0xb8f5
movl $0x0, -0x4(%rbp)
jmp 0xb974
movq 0x1ccfc(%rip), %rax     # 0x285f8
movq 0x1cccd(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq 0x1ccdb(%rip), %rax     # 0x285f8
movq 0x1ccac(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
subq $0x1, %rax
movl %eax, -0x18(%rbp)
movb $0x0, -0x11(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xb96d
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %al
movb %al, -0x12(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x3ab0
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb93f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: print_primitive
int print_primitive(cell n) {
	PRIM	*p;

	if (!primitive_p(n))
		return 0;
	pr("<primitive ");
	p = &Primitives[cadr(n)];
	pr(p->name);
	pr(">");
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0xb9bc
movq 0x1cc56(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xb9bc
movq 0x1c7cf(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x1d, (%rax,%rcx,8)
je 0xb9c5
movl $0x0, -0x4(%rbp)
jmp 0xba19
leaq 0x14d0b(%rip), %rdi     # 0x206d7
callq 0x3ab0
movq 0x1cd00(%rip), %rax     # 0x286d8
movq 0x1c7a1(%rip), %rcx     # 0x28180
movq 0x1cbea(%rip), %rdx     # 0x285d0
movq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
imulq $0x28, (%rcx,%rdx,8), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3ab0
leaq 0x1485c(%rip), %rdi     # 0x20269
callq 0x3ab0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: print_syntax
int print_syntax(cell n) {
	if (!syntax_p(n))
		return 0;
	pr("<macro>");
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0xba6c
movq 0x1cba6(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xba6c
movq 0x1c71f(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x23, (%rax,%rcx,8)
je 0xba75
movl $0x0, -0x4(%rbp)
jmp 0xba88
leaq 0x14c67(%rip), %rdi     # 0x206e3
callq 0x3ab0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: print_vector
int print_vector(cell n) {
	cell	*p;
	int	k;

	if (!vector_p(n))
		return 0;
	p = vector(n);
	k = vector_len(n);
	while (k--) {
		print_form(*p++);
		if (k)
			pr(", ");
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0xbadc
movq 0x1cb36(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xbadc
movq 0x1c6af(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x24, (%rax,%rcx,8)
je 0xbae8
movl $0x0, -0x4(%rbp)
jmp 0xbb80
movq 0x1cb09(%rip), %rax     # 0x285f8
movq 0x1cada(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq 0x1cae8(%rip), %rax     # 0x285f8
movq 0x1cab9(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
subq $0x1, %rax
shrq $0x3, %rax
addq $0x3, %rax
subq $0x3, %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
je 0xbb79
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rdi
callq 0x3b70
cmpl $0x0, -0x1c(%rbp)
je 0xbb77
leaq 0x14b79(%rip), %rdi     # 0x206eb
callq 0x3ab0
jmp 0xbb3e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: print_stream
int print_stream(cell n) {
	char	buf[100];

	if (!instream_p(n) && !outstream_p(n))
		return 0;
	sprintf(buf, "<%sstream %d>",
		instream_p(n)? "in": "out",
		(int) stream_id(n));
	pr(buf);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0xbbe6
movq 0x1ca43(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xbbe6
movq 0x1ca2c(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0xbbe6
movq 0x1c5a5(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x17, (%rax,%rcx,8)
je 0xbc39
cmpq $0x0, -0x10(%rbp)
jl 0xbc2d
movq 0x1c9fc(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xbc2d
movq 0x1c9e5(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0xbc2d
movq 0x1c55e(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x19, (%rax,%rcx,8)
je 0xbc39
movl $0x0, -0x4(%rbp)
jmp 0xbd06
leaq -0x80(%rbp), %rax
movq %rax, -0x90(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x81(%rbp)
jl 0xbcaa
movq 0x1c996(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
andl $0x1, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x81(%rbp)
je 0xbcaa
movq 0x1c977(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
andl $0x20, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x81(%rbp)
je 0xbcaa
movq 0x1c4e8(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x17, (%rax,%rcx,8)
sete %al
movb %al, -0x81(%rbp)
movq -0x90(%rbp), %rdi
movb -0x81(%rbp), %cl
leaq 0x14a3e(%rip), %rdx     # 0x206fc
leaq 0x1589d(%rip), %rax     # 0x21562
testb $0x1, %cl
cmovneq %rax, %rdx
movq 0x1c4ad(%rip), %rax     # 0x28180
movq 0x1c8f6(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rsi
movq (%rcx,%rsi,8), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %ecx
leaq 0x149ff(%rip), %rsi     # 0x206ee
movb $0x0, %al
callq 0x3200
leaq -0x80(%rbp), %rdi
callq 0x3ab0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)